Add liquid-spec adapter service

.gitignore

@@ -25,4 +25,6 @@ tmp/
 benchmark/*.log
 benchmark/*.txt
 
-.DS_Store
+.DS_Store
+
+bin/*

eslint.config.js

@@ -26,6 +26,12 @@ export default defineConfig([
           accessibility: "no-public",
         },
       ],
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          varsIgnorePattern: "^_",
+        },
+      ],
     },
   },
   tseslint.configs.recommended,

liquid-spec/README.md

@@ -0,0 +1,9 @@
+A JSON-RPC service and build script for running LiquidScript against liquid-spec.
+
+## Usage
+
+To build a standalone executable, `bin/liquidscript_service`, from the root of the repository:
+
+```
+bun spec:build
+```

liquid-spec/build.ts

@@ -0,0 +1,12 @@
+await Bun.build({
+  entrypoints: ["./liquid-spec/cli.ts"],
+  compile: {
+    outfile: "bin/liquidscript_service",
+  },
+  minify: true,
+  sourcemap: "linked",
+  bytecode: true,
+  define: {
+    NODE_ENV: "production",
+  },
+});

liquid-spec/cli.ts

@@ -0,0 +1,8 @@
+import { LiquidscriptSession } from "./liquidscript";
+
+const session = new LiquidscriptSession();
+
+session.listen().catch((err) => {
+  console.error("[FATAL]", err);
+  process.exit(1);
+});

liquid-spec/liquidscript.ts

@@ -0,0 +1,132 @@
+import type { TemplateSource } from "../dist/liquidscript";
+import path from "path";
+import {
+  Environment,
+  LiquidError,
+  ObjectLoader,
+  TemplateNotFoundError,
+  type Template,
+} from "../dist/liquidscript.esm";
+import { LiquidSpecSession } from "./session";
+import type {
+  CompileParams,
+  CompileSuccessResult,
+  CompileFailResult,
+  RenderParams,
+  RenderResult,
+} from "./types";
+
+class CustomObjectLoader extends ObjectLoader {
+  override getSourceSync(env: Environment, name: string): TemplateSource {
+    const source = this.obj[this.withFileExtension(name)];
+    if (source) return { source, name };
+    throw new TemplateNotFoundError(name);
+  }
+
+  withFileExtension(name: string): string {
+    return path.extname(name) ? name : name + ".liquid";
+  }
+}
+
+export class LiquidscriptSession extends LiquidSpecSession {
+  private templates: Map<string, Template>;
+  private nextTemplateId: number = 1;
+
+  constructor() {
+    super({
+      packageName: "liquidscript",
+      packageVersion: "dev",
+      debug: false,
+    });
+
+    this.templates = new Map();
+  }
+
+  override async compile(
+    params: CompileParams,
+  ): Promise<CompileSuccessResult | CompileFailResult> {
+    const id = `${this.nextTemplateId}`;
+    this.nextTemplateId += 1;
+
+    try {
+      this.templates.set(
+        id,
+        new Environment({
+          loader: new CustomObjectLoader(params.filesystem || {}),
+        }).parse(params.template),
+      );
+
+      return {
+        template_id: id,
+      };
+    } catch (err) {
+      if (err instanceof LiquidError) {
+        return {
+          template_id: id,
+          error: {
+            type: err.constructor.name,
+            message: err.message,
+            line: -1,
+          },
+        };
+      } else {
+        return {
+          template_id: id,
+          error: {
+            type: "unexpected",
+            message: `${err}`,
+            line: -1,
+          },
+        };
+      }
+    }
+  }
+
+  override async render(params: RenderParams): Promise<RenderResult> {
+    const template = this.templates.get(params.template_id);
+
+    if (!template) {
+      return {
+        output: "",
+        errors: [
+          {
+            type: "render_error",
+            message: `unknown template id ${params.template_id}`,
+            line: -1,
+          },
+        ],
+      };
+    }
+
+    try {
+      return {
+        output: template?.renderSync(params.environment || {}),
+        errors: [],
+      };
+    } catch (err) {
+      if (err instanceof LiquidError) {
+        return {
+          output: "",
+          errors: [
+            {
+              type: err.constructor.name,
+              message: err.message,
+              line: -1,
+            },
+          ],
+        };
+      } else {
+        return {
+          output: "",
+          errors: [
+            {
+              type: "unexpected",
+              message: `${err}`,
+              line: -1,
+            },
+          ],
+        };
+      }
+    }
+  }
+}