Implement RFC-2 infra compiler

Author: djgrant

packages/esbuild-plugins/package.json

@@ -9,7 +9,8 @@
     "dev": "npm run build -- --watch"
   },
   "dependencies": {
-    "esbuild": "^0.19.3"
+    "esbuild": "^0.19.3",
+    "typescript": "^5.2.2"
   },
   "devDependencies": {
     "@types/common-tags": "^1.8.2",

packages/esbuild-plugins/src/function-plugin.ts renamed to packages/esbuild-plugins/src/function-infra-plugin.ts

@@ -1,21 +1,18 @@
 import esbuild, { Plugin } from "esbuild";
+import { readConfigExport } from "./read-config-export";
 
 /**
  * compiles cloud function modules
  * runs separate esbuild process to get exports metadata
  */
-export function functionPlugin(opts: {
-  fileIsFunction: (filePath: string) => boolean;
+export function functionInfraPlugin(opts: {
   getFile: (filePath: string) => string | Promise<string>;
   esbuildInstance?: typeof esbuild;
 }): Plugin {
   return {
     name: "function",
     setup(build) {
-      build.onLoad({ filter: /.*$/ }, async (args) => {
-        const isFunction = await opts.fileIsFunction(args.path);
-        if (!isFunction) return;
-
+      build.onLoad({ filter: /.\.fn*/ }, async (args) => {
         const esbuild = opts.esbuildInstance || (await import("esbuild"));
         const fileContent = await opts.getFile(args.path);
 
@@ -35,11 +32,18 @@ export function functionPlugin(opts: {
         const reservedExports = ["preload", "config"];
         const userExports = exports.filter((e) => !reservedExports.includes(e));
 
-        let infraCode = `import { createWorkflowNode } from "@notation/sdk"`;
+        let infraCode = `import { fn } from "@notation/sdk"`;
+
+        if (exports.includes("config")) {
+          const config = readConfigExport(fileContent);
+          infraCode = infraCode.concat(`\nconst config = ${config};`);
+        } else {
+          infraCode = infraCode.concat(`\nconst config = {};`);
+        }
 
         for (const handlerName of userExports) {
           infraCode = infraCode.concat(
-            `\nexport const ${handlerName} = createWorkflowNode("${handlerName}");`,
+            `\nexport const ${handlerName} = fn({ handler: "${handlerName}", ...config });`,
           );
         }
 

packages/esbuild-plugins/src/index.ts

@@ -1 +1 @@
-export * from "./function-plugin";
+export * from "./function-infra-plugin";

packages/esbuild-plugins/src/read-config-export.ts

@@ -0,0 +1,65 @@
+import * as ts from "typescript";
+
+export function readConfigExport(input: string) {
+  const sourceFile = ts.createSourceFile(
+    "file.ts",
+    input,
+    ts.ScriptTarget.ESNext,
+    true,
+  );
+
+  const configExport = sourceFile.statements.find(
+    (stmt) =>
+      ts.isVariableStatement(stmt) &&
+      stmt.declarationList.declarations.some(
+        (decl) => decl.name.getText() === "config",
+      ),
+  ) as ts.VariableStatement | undefined;
+
+  if (!configExport) {
+    throw new Error("No named export 'config' found.");
+  }
+
+  const configDeclaration = configExport.declarationList.declarations.find(
+    (decl) => decl.name.getText() === "config",
+  ) as ts.VariableDeclaration;
+
+  if (
+    !configDeclaration ||
+    !ts.isObjectLiteralExpression(configDeclaration.initializer!)
+  ) {
+    throw new Error("'config' is not an object literal.");
+  }
+
+  let configObjectStr = "{ ";
+
+  configDeclaration.initializer.properties.forEach((prop, index, array) => {
+    if (ts.isPropertyAssignment(prop)) {
+      const key = prop.name.getText();
+      const valueNode = prop.initializer;
+      if (
+        ts.isStringLiteral(valueNode) ||
+        ts.isNumericLiteral(valueNode) ||
+        valueNode.kind === ts.SyntaxKind.TrueKeyword ||
+        valueNode.kind === ts.SyntaxKind.FalseKeyword
+      ) {
+        const value = valueNode.getText();
+        configObjectStr += `${key}: ${value}${
+          index < array.length - 1 ? ", " : " "
+        }`;
+      } else {
+        throw new Error(
+          `Invalid value type for key '${key}': only numbers, strings, and booleans are allowed.`,
+        );
+      }
+    } else {
+      throw new Error(
+        `Invalid property assignment in 'config': ${prop.getText()}`,
+      );
+    }
+  });
+
+  configObjectStr += "}";
+
+  return configObjectStr;
+}

packages/esbuild-plugins/test/esbuild-test-utils.ts

@@ -3,11 +3,15 @@ import esbuild, { BuildOptions, Plugin } from "esbuild";
 const virtualFilePlugin = (input: any): Plugin => ({
   name: "virtual-file",
   setup(build) {
-    build.onResolve({ filter: /.*/ }, (args) => {
+    build.onResolve({ filter: /\..*/ }, (args) => {
       return { path: args.path, namespace: "stdin" };
     });
-    build.onLoad({ filter: /.*/, namespace: "stdin" }, (args) => {
-      return { contents: input, loader: "ts", resolveDir: args.path };
+    build.onLoad({ filter: /\..*/, namespace: "stdin" }, (args) => {
+      return {
+        contents: input,
+        loader: "ts",
+        resolveDir: args.path,
+      };
     });
   },
 });
@@ -19,7 +23,7 @@ export function createBuilder(
     const buildOptions = getBuildOptions(input);
 
     const result = await esbuild.build({
-      entryPoints: ["entry.ts"],
+      entryPoints: [".entry.fn.ts"],
       write: false,
       ...buildOptions,
       plugins: [...(buildOptions.plugins || []), virtualFilePlugin(input)],

packages/esbuild-plugins/test/function-infra-plugin.test.ts

@@ -0,0 +1,66 @@
+import { expect, it } from "bun:test";
+import { stripIndent } from "common-tags";
+import { functionInfraPlugin } from "../src/function-infra-plugin";
+import { createBuilder } from "./esbuild-test-utils";
+
+const buildInfra = createBuilder((input) => ({
+  plugins: [functionInfraPlugin({ getFile: () => input })],
+}));
+
+it("remaps exports", async () => {
+  const input = `
+    import { handler, FnConfig } from "@notation/sdk";
+    export const getNum = handler(() => 1);
+  `;
+
+  const expected = stripIndent`
+    import { fn } from "@notation/sdk";
+    const config = {};
+    export const getNum = fn({ handler: "getNum", ...config });
+  `;
+
+  const output = await buildInfra(input);
+
+  expect(output).toContain(expected);
+});
+
+it("merges config", async () => {
+  const input = `
+    import { handler, FnConfig } from "@notation/sdk";
+    export const getNum = handler(() => 1);
+    export const config: FnConfig = { memory: 64 };
+  `;
+
+  const expected = stripIndent`
+    import { fn } from "@notation/sdk";
+    const config = { memory: 64 };
+    export const getNum = fn({ handler: "getNum", ...config });
+  `;
+
+  const output = await buildInfra(input);
+
+  expect(output).toContain(expected);
+});
+
+it("should strip runtime code", async () => {
+  const input = `
+    import { handler } from "@notation/sdk";
+    import lib from "lib";
+
+    let num = lib.getNum();
+
+    export const getNum = () => num;
+    export const getDoubleNum = () => num * 2;
+  `;
+
+  const expected = stripIndent`
+    import { fn } from "@notation/sdk";
+    const config = {};
+    export const getDoubleNum = fn({ handler: "getDoubleNum", ...config });
+    export const getNum = fn({ handler: "getNum", ...config });
+  `;
+
+  const output = await buildInfra(input);
+
+  expect(output).toContain(expected);
+});

packages/esbuild-plugins/test/function-plugin.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import { readConfigExport } from "../src/read-config-export";
+
+test("Valid config object", () => {
+  const input = `
+    export const config = { 
+      key1: "value1", 
+      key2: 123, 
+      key3: true, 
+      key4: false 
+    };
+  `;
+  expect(readConfigExport(input)).toBe(
+    '{ key1: "value1", key2: 123, key3: true, key4: false }',
+  );
+});
+
+test("Config object with invalid value type", () => {
+  const input = `
+    export const config = { 
+      key1: [123],  
+    };
+  `;
+  expect(() => readConfigExport(input)).toThrow(
+    /Invalid value type for key 'key1'/,
+  );
+});
+
+test("No config object", () => {
+  const input = `export const somethingElse = { key1: "value1" };`;
+  expect(() => readConfigExport(input)).toThrow(
+    /No named export 'config' found./,
+  );
+});
+
+describe("invalid inputs", () => {
+  const invalidInputs = {
+    identifier: "export const config = identifier;",
+    callExpression: "export const config = identifier;",
+    string: "export const config = 123;",
+    number: "export const config = '123';",
+    array: "export const config = [];",
+  };
+  for (const [invalidType, invalidStatement] of Object.entries(invalidInputs)) {
+    test(invalidType, () => {
+      expect(() => readConfigExport(invalidStatement)).toThrow(
+        /'config' is not an object literal./,
+      );
+    });
+  }
+});