ignotum 0.0.2 → 0.0.4

package/src/cli/build/client.ts

@@ -0,0 +1,103 @@
+import { Array, Effect, FileSystem, Path, String } from "effect";
+import tailwindcss from "@tailwindcss/vite";
+import { sha256 } from "@ignotum/deployment";
+
+import { resolveClientBuildConfig, validateClientFiles } from "../client-config.js";
+import { loadClientEntryTitle } from "../client-entry.js";
+import { clientEntryId, ignotumClientPlugin, renderClientDocument } from "../client-plugin.js";
+import { moduleBoundariesPlugin } from "../module-boundaries.js";
+import { InvalidBuildOutput, runViteBuild } from "./artifact.js";
+
+export interface ClientBuildResult {
+  readonly assets: number;
+  readonly shellPath: string;
+}
+
+export const buildClient = Effect.fn("Deploy.buildClient")(function* (
+  appDirectory: string,
+  outputDirectory: string,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const clientFiles = yield* validateClientFiles(appDirectory);
+  const clientDirectory = clientFiles.clientDirectory;
+  const title = yield* loadClientEntryTitle(clientFiles.entryPath);
+  const clientConfig = yield* resolveClientBuildConfig(false);
+  const boundaries = yield* moduleBoundariesPlugin("Client", appDirectory);
+
+  yield* fileSystem.makeDirectory(outputDirectory, { recursive: true });
+
+  const output = yield* runViteBuild("client", {
+    appType: "spa",
+    build: {
+      assetsDir: "assets",
+      emptyOutDir: true,
+      outDir: outputDirectory,
+      rolldownOptions: {
+        input: clientEntryId,
+        output: {
+          assetFileNames: "assets/[name]-[hash][extname]",
+          chunkFileNames: "assets/[name]-[hash].js",
+          entryFileNames: "assets/[name]-[hash].js",
+        },
+      },
+      sourcemap: false,
+    },
+    configFile: false,
+    logLevel: "warn",
+    mode: "production",
+    oxc: {
+      jsx: {
+        importSource: "ignotum/client",
+        runtime: "automatic",
+      },
+    },
+    plugins: [
+      boundaries,
+      ignotumClientPlugin({ development: false, icon: undefined, loadTitle: undefined }),
+      tailwindcss(),
+    ],
+    publicDir: false,
+    resolve: {
+      alias: clientConfig.aliases,
+      conditions: [...clientConfig.conditions],
+      dedupe: ["preact"],
+      tsconfigPaths: true,
+    },
+    root: clientDirectory,
+  });
+  const entry = Array.findFirst(output, (item) => item.type === "chunk" && item.isEntry);
+  const entryFile = yield* Effect.fromOption(entry, () =>
+    InvalidBuildOutput.make({ message: "The client build did not emit an entry chunk." }),
+  ).pipe(Effect.map((item) => item.fileName));
+  const styles = Array.sort(String.Order)(
+    Array.map(
+      Array.filter(output, (item) => item.type === "asset" && item.fileName.endsWith(".css")),
+      (item) => item.fileName,
+    ),
+  );
+  let icon: string | undefined;
+  if (clientFiles.iconPath !== undefined) {
+    const bytes = yield* fileSystem.readFile(clientFiles.iconPath);
+    const digest = yield* sha256(bytes);
+    const fileName = `icon-${digest}.svg`;
+    const assetsDirectory = path.join(outputDirectory, "assets");
+    yield* fileSystem.makeDirectory(assetsDirectory, { recursive: true });
+    yield* fileSystem.writeFile(path.join(assetsDirectory, fileName), bytes);
+    icon = `/assets/${fileName}`;
+  }
+  const shellPath = path.join(outputDirectory, "_shell.html");
+  const document = renderClientDocument({
+    icon,
+    scripts: [{ source: entryFile, type: "External" }],
+    styles,
+    title,
+  });
+
+  yield* fileSystem.writeFileString(shellPath, document);
+
+  return {
+    assets: output.length + (icon === undefined ? 0 : 1),
+    shellPath,
+  } satisfies ClientBuildResult;
+});

package/src/cli/build/server.ts

@@ -0,0 +1,526 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import * as Config from "effect/Config";
+import { Array, Effect, FileSystem, Path, Predicate, Schema, String } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { createServer, defaultServerConditions, normalizePath } from "vite";
+import type { Plugin, ViteDevServer } from "vite";
+
+import {
+  ServerBuildManifest,
+  SchemaSnapshot,
+  schemaSnapshotPath,
+  type ServerFunctionArtifact,
+} from "@ignotum/contracts/deployment";
+import { FunctionAddress } from "@ignotum/contracts/runtime/sync";
+import type { FunctionKind } from "@ignotum/contracts/runtime/functions";
+import { isDefinedSchema, type DefinedSchema, type Tables } from "@ignotum/contracts/schema";
+import {
+  artifactReference,
+  encodeCanonical,
+  encodeSchemaSnapshot,
+  makeSchemaSnapshot,
+  utf8Bytes,
+} from "@ignotum/deployment";
+
+import { inspectRuntimeFunctionDefinition } from "../../internal/function-definition.js";
+import { moduleBoundariesPlugin, BuildBoundaryViolation } from "../module-boundaries.js";
+import {
+  causeMessage,
+  InvalidBuildOutput,
+  runViteBuild,
+  sourceMapPathTransform,
+  ViteBuildFailed,
+  type GeneratedChunk,
+} from "./artifact.js";
+
+const hostModuleId = "ignotum:host";
+const encodeJavaScriptString = Schema.encodeSync(Schema.fromJsonString(Schema.String));
+
+const DiscoveredServerFunction = Schema.Struct({
+  address: FunctionAddress,
+  exportName: Schema.String,
+  kind: Schema.Literals(["Mutation", "Query"]),
+  moduleName: Schema.String,
+  modulePath: Schema.String,
+});
+interface DiscoveredServerFunction {
+  readonly address: FunctionAddress;
+  readonly exportName: string;
+  readonly kind: FunctionKind;
+  readonly moduleName: string;
+  readonly modulePath: string;
+}
+
+const ServerDiscoveryManifest = Schema.Struct({
+  functions: Schema.Array(DiscoveredServerFunction),
+  schema: SchemaSnapshot,
+});
+type ServerDiscoveryManifest = typeof ServerDiscoveryManifest.Type;
+const ServerDiscoveryManifestJson = Schema.fromJsonString(ServerDiscoveryManifest);
+const ServerModuleNamesJson = Schema.fromJsonString(Schema.Array(Schema.String));
+
+export interface ServerBuildResult {
+  readonly functions: number;
+  readonly manifestPath: string;
+}
+
+export class ServerFunctionDiscoveryFailed extends Schema.TaggedError<ServerFunctionDiscoveryFailed>()(
+  "ServerFunctionDiscoveryFailed",
+  {
+    cause: Schema.Defect(),
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+export class InvalidServerFunctionExport extends Schema.TaggedError<InvalidServerFunctionExport>()(
+  "InvalidServerFunctionExport",
+  {
+    exportName: Schema.String,
+    message: Schema.String,
+    path: Schema.String,
+  },
+) {}
+
+const serverConditions = Effect.fn("Deploy.serverConditions")(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const sourceServerEntry = fileURLToPath(new URL("../../internal/server.ts", import.meta.url));
+  const hasWorkspaceSourceExports = yield* fileSystem.exists(sourceServerEntry);
+
+  return [...(hasWorkspaceSourceExports ? ["@ignotum/source"] : []), ...defaultServerConditions];
+});
+
+const acquireModuleRunner = Effect.fn("Deploy.acquireServerModuleRunner")(function* (
+  appDirectory: string,
+  conditions: ReadonlyArray<string>,
+) {
+  const boundaries = yield* moduleBoundariesPlugin("Server", appDirectory);
+  const discoveryCacheDirectory = yield* Config.string("IGNOTUM_DISCOVERY_CACHE_DIR").pipe(
+    Config.withDefault(""),
+  );
+  return yield* Effect.acquireRelease(
+    Effect.tryPromise({
+      try: () =>
+        createServer({
+          appType: "custom",
+          configFile: false,
+          cacheDir: discoveryCacheDirectory.length > 0 ? discoveryCacheDirectory : undefined,
+          css: { postcss: {} },
+          logLevel: "warn",
+          mode: "production",
+          optimizeDeps: { noDiscovery: true },
+          plugins: [boundaries],
+          resolve: {
+            conditions: [...conditions],
+            noExternal: true,
+            tsconfigPaths: true,
+          },
+          root: appDirectory,
+          server: {
+            forwardConsole: false,
+            middlewareMode: true,
+            fs: { strict: true, allow: [appDirectory] },
+            watch: null,
+          },
+          ssr: {
+            noExternal: true,
+            resolve: { conditions: [...conditions] },
+          },
+        }),
+      catch: (cause) =>
+        Schema.is(BuildBoundaryViolation)(cause)
+          ? cause
+          : ViteBuildFailed.make({
+              cause,
+              message: `Vite could not create the server function module runner: ${causeMessage(cause)}`,
+            }),
+    }),
+    (server) => Effect.promise(() => server.close()),
+  );
+});
+
+const discoverModuleFunctions = Effect.fn("Deploy.discoverServerModule")(function* (
+  server: ViteDevServer,
+  appDirectory: string,
+  moduleName: string,
+) {
+  const path = yield* Path.Path;
+  const modulePath = path.join(appDirectory, "server", `${moduleName}.ts`);
+  const loadedModule = yield* Effect.tryPromise({
+    try: () => server.ssrLoadModule(normalizePath(modulePath)),
+    catch: (cause) =>
+      Schema.is(BuildBoundaryViolation)(cause)
+        ? cause
+        : ServerFunctionDiscoveryFailed.make({
+            cause,
+            message: `Could not load server function module ${moduleName}: ${causeMessage(cause)}`,
+            path: modulePath,
+          }),
+  });
+  const functions: globalThis.Array<DiscoveredServerFunction> = [];
+
+  for (const [exportName, candidate] of Object.entries(loadedModule)) {
+    if (!Predicate.isObject(candidate)) continue;
+    const inspected = inspectRuntimeFunctionDefinition(candidate);
+    if (inspected === undefined) {
+      if (
+        Predicate.hasProperty(candidate, "_tag") &&
+        (candidate._tag === "Mutation" || candidate._tag === "Query")
+      ) {
+        return yield* InvalidServerFunctionExport.make({
+          exportName,
+          message: `${moduleName}.${exportName} looks like a server function but is not a valid schema-bound definition.`,
+          path: modulePath,
+        });
+      }
+      continue;
+    }
+
+    functions.push({
+      address: FunctionAddress.make(`api.${moduleName}.${exportName}`),
+      exportName,
+      kind: inspected.definition._tag,
+      moduleName,
+      modulePath,
+    });
+  }
+
+  return Array.sortWith(functions, (definition) => definition.address, String.Order);
+});
+
+const discoverServerFunctionsInProcess = Effect.fn("Deploy.discoverServerFunctions")(function* (
+  appDirectory: string,
+  moduleNames: ReadonlyArray<string>,
+  conditions: ReadonlyArray<string>,
+) {
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      const server = yield* acquireModuleRunner(appDirectory, conditions);
+      const path = yield* Path.Path;
+      const schemaPath = path.join(appDirectory, "server", "schema.ts");
+      const loadedSchemaModule = yield* Effect.tryPromise({
+        try: () => server.ssrLoadModule(normalizePath(schemaPath)),
+        catch: (cause) =>
+          Schema.is(BuildBoundaryViolation)(cause)
+            ? cause
+            : ServerFunctionDiscoveryFailed.make({
+                cause,
+                message: `Could not load the application schema: ${causeMessage(cause)}`,
+                path: schemaPath,
+              }),
+      });
+      const schemaCandidate = yield* Schema.decodeUnknownEffect(Schema.ObjectKeyword)(
+        loadedSchemaModule.default,
+      ).pipe(
+        Effect.mapError(() =>
+          InvalidBuildOutput.make({
+            message: "The default export from server/schema.ts is not an Ignotum schema.",
+          }),
+        ),
+      );
+      if (!isDefinedSchema(schemaCandidate)) {
+        return yield* InvalidBuildOutput.make({
+          message: "The default export from server/schema.ts is not an Ignotum schema.",
+        });
+      }
+      const modules = yield* Effect.forEach(moduleNames, (moduleName) =>
+        discoverModuleFunctions(server, appDirectory, moduleName),
+      );
+      return {
+        functions: Array.flatten(modules),
+        schema: schemaCandidate,
+      } satisfies {
+        readonly functions: ReadonlyArray<DiscoveredServerFunction>;
+        readonly schema: DefinedSchema<Tables>;
+      };
+    }),
+  );
+});
+
+export const runServerDiscoveryWorker = Effect.fn("Deploy.runServerDiscoveryWorker")(function* (
+  appDirectory: string,
+  moduleNamesJson: string,
+  outputPath: string,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const moduleNames = yield* Schema.decodeEffect(ServerModuleNamesJson)(moduleNamesJson).pipe(
+    Effect.orDie,
+  );
+  const conditions = yield* serverConditions();
+  const discovered = yield* discoverServerFunctionsInProcess(appDirectory, moduleNames, conditions);
+  const schema = yield* Effect.try({
+    try: () => makeSchemaSnapshot(discovered.schema),
+    catch: () =>
+      InvalidBuildOutput.make({
+        message: "The application schema does not have canonical Ignotum descriptors.",
+      }),
+  });
+  const encoded = yield* Schema.encodeEffect(ServerDiscoveryManifestJson)({
+    functions: discovered.functions,
+    schema,
+  });
+  yield* fileSystem.writeFileString(outputPath, encoded);
+});
+
+const discoveryWorkerEntry = Effect.fn("Deploy.discoveryWorkerEntry")(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const sourceEntry = fileURLToPath(new URL("../../../dist/cli/bin.mjs", import.meta.url));
+  const bundledEntry = fileURLToPath(import.meta.url);
+  return (yield* fileSystem.exists(sourceEntry)) ? sourceEntry : bundledEntry;
+});
+
+const nodeModulesDirectory = (): string => {
+  const resolved = createRequire(import.meta.url).resolve("vite/package.json");
+  const marker = `${globalThis.process.platform === "win32" ? "\\" : "/"}node_modules${
+    globalThis.process.platform === "win32" ? "\\" : "/"
+  }`;
+  const index = resolved.indexOf(marker);
+  return index < 0 ? resolved : resolved.slice(0, index + marker.length - 1);
+};
+
+const discoverServerFunctions = Effect.fn("Deploy.discoverServerFunctionsIsolated")(function* (
+  appDirectory: string,
+  moduleNames: ReadonlyArray<string>,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const workerEntry = yield* discoveryWorkerEntry();
+  return yield* Effect.scoped(
+    Effect.gen(function* () {
+      const directory = yield* Effect.acquireRelease(
+        fileSystem.makeTempDirectory({ prefix: "ignotum-discovery-" }),
+        (temporary) =>
+          fileSystem.remove(temporary, { force: true, recursive: true }).pipe(Effect.orDie),
+      );
+      const outputPath = path.join(directory, "discovery.json");
+      const encodedModuleNames = yield* Schema.encodeEffect(ServerModuleNamesJson)(moduleNames);
+      const packageRoot = path.resolve(path.dirname(workerEntry), "../..");
+      const workspaceProbes: Array<string> = [];
+      let ancestor = path.resolve(appDirectory);
+      while (true) {
+        for (const name of [
+          "package.json",
+          "pnpm-workspace.yaml",
+          "lerna.json",
+          "deno.json",
+          "deno.jsonc",
+        ]) {
+          workspaceProbes.push(path.join(ancestor, name));
+        }
+        const parent = path.dirname(ancestor);
+        if (parent === ancestor) break;
+        ancestor = parent;
+      }
+      const readPermissions = [
+        appDirectory,
+        nodeModulesDirectory(),
+        packageRoot,
+        ...workspaceProbes,
+      ].map((allowedPath) => `--allow-fs-read=${allowedPath}`);
+      const exitCode = yield* spawner.exitCode(
+        ChildProcess.make(
+          process.execPath,
+          [
+            "--permission",
+            "--allow-addons",
+            ...readPermissions,
+            `--allow-fs-write=${directory}`,
+            workerEntry,
+            "__ignotum_discover_server",
+            appDirectory,
+            encodedModuleNames,
+            outputPath,
+          ],
+          {
+            cwd: appDirectory,
+            env: {
+              IGNOTUM_DISCOVERY_CACHE_DIR: path.join(directory, "vite-cache"),
+              IGNOTUM_ISOLATED_DISCOVERY: "1",
+              NODE_ENV: "production",
+            },
+            stderr: "inherit",
+            stdout: "ignore",
+          },
+        ),
+      );
+      if (exitCode !== ChildProcessSpawner.ExitCode(0)) {
+        return yield* ServerFunctionDiscoveryFailed.make({
+          cause: new Error(`Discovery worker exited with code ${exitCode}.`),
+          message: "Application metadata discovery failed in the isolated build process.",
+          path: appDirectory,
+        });
+      }
+      const encoded = yield* fileSystem.readFileString(outputPath);
+      return yield* Schema.decodeEffect(ServerDiscoveryManifestJson)(encoded).pipe(
+        Effect.mapError((cause) =>
+          ServerFunctionDiscoveryFailed.make({
+            cause,
+            message: "The isolated build process returned invalid application metadata.",
+            path: outputPath,
+          }),
+        ),
+      );
+    }),
+  );
+});
+
+const serverFunctionEntryPlugin = (definition: DiscoveredServerFunction): Plugin => {
+  const entryId = `virtual:ignotum/server-function/${definition.address}`;
+  const resolvedEntryId = `\0${entryId}`;
+  const source = `import { call } from ${encodeJavaScriptString(hostModuleId)}
+import { invoke } from "ignotum/internal/host"
+import { ${definition.exportName} as definition } from ${encodeJavaScriptString(normalizePath(definition.modulePath))}
+
+export default async function handler(encodedRequest) {
+  return invoke(definition, JSON.parse(encodedRequest), call)
+}
+`;
+
+  return {
+    name: "ignotum:server-function-entry",
+    load: (id) => (id === resolvedEntryId ? source : undefined),
+    resolveId: (id) => (id === entryId ? resolvedEntryId : undefined),
+  };
+};
+
+const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
+  appDirectory: string,
+  serverOutputDirectory: string,
+  conditions: ReadonlyArray<string>,
+  definition: DiscoveredServerFunction,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const functionDirectory = path.join(serverOutputDirectory, "functions", definition.moduleName);
+  const transformSourceMapPath = yield* sourceMapPathTransform(appDirectory);
+  const boundaries = yield* moduleBoundariesPlugin("Server", appDirectory);
+  const entryId = `virtual:ignotum/server-function/${definition.address}`;
+  yield* fileSystem.makeDirectory(functionDirectory, { recursive: true });
+
+  const output = yield* runViteBuild(definition.address, {
+    build: {
+      cssCodeSplit: false,
+      emptyOutDir: false,
+      minify: "oxc",
+      modulePreload: false,
+      outDir: functionDirectory,
+      rolldownOptions: {
+        external: [hostModuleId],
+        input: entryId,
+        preserveEntrySignatures: "strict",
+        treeshake: {
+          manualPureFunctions: ["mutation", "query"],
+        },
+        output: {
+          codeSplitting: false,
+          entryFileNames: `${definition.exportName}-[hash].mjs`,
+          format: "es",
+          sourcemapPathTransform: transformSourceMapPath,
+        },
+      },
+      sourcemap: true,
+      target: "es2020",
+    },
+    configFile: false,
+    logLevel: "warn",
+    mode: "production",
+    plugins: [boundaries, serverFunctionEntryPlugin(definition)],
+    resolve: {
+      conditions: [...conditions],
+      noExternal: true,
+      tsconfigPaths: true,
+    },
+    root: appDirectory,
+  });
+  const entries = Array.filter(
+    output,
+    (item): item is GeneratedChunk => item.type === "chunk" && item.isEntry,
+  );
+  if (entries.length !== 1) {
+    return yield* InvalidBuildOutput.make({
+      message: `${definition.address} did not emit exactly one entry chunk.`,
+    });
+  }
+  const entry = entries[0];
+  if (entry === undefined) {
+    return yield* InvalidBuildOutput.make({
+      message: `${definition.address} did not emit an entry chunk.`,
+    });
+  }
+  if (
+    entry.dynamicImports.length > 0 ||
+    entry.imports.length !== 1 ||
+    entry.imports[0] !== hostModuleId ||
+    !entry.exports.includes("default")
+  ) {
+    return yield* InvalidBuildOutput.make({
+      message: `${definition.address} is not a self-contained default-exported handler. Imports: ${entry.imports.join(", ") || "none"}; dynamic imports: ${entry.dynamicImports.join(", ") || "none"}; exports: ${entry.exports.join(", ") || "none"}.`,
+    });
+  }
+
+  const relativeFile = normalizePath(path.join("functions", definition.moduleName, entry.fileName));
+  const relativeSourceMap = `${relativeFile}.map`;
+  const absoluteFile = path.join(serverOutputDirectory, relativeFile);
+  const absoluteSourceMap = path.join(serverOutputDirectory, relativeSourceMap);
+  const sourceMapExists = yield* fileSystem.exists(absoluteSourceMap);
+  if (!sourceMapExists) {
+    return yield* InvalidBuildOutput.make({
+      message: `${definition.address} did not emit a source map.`,
+    });
+  }
+  const bundlePath = normalizePath(path.join("server", relativeFile));
+  const sourceMapPath = normalizePath(path.join("server", relativeSourceMap));
+
+  return {
+    address: definition.address,
+    kind: definition.kind,
+    bundle: yield* artifactReference(bundlePath, yield* fileSystem.readFile(absoluteFile)),
+    sourceMap: yield* artifactReference(
+      sourceMapPath,
+      yield* fileSystem.readFile(absoluteSourceMap),
+    ),
+  } satisfies ServerFunctionArtifact;
+});
+
+export const buildServer = Effect.fn("Deploy.buildServer")(function* (
+  appDirectory: string,
+  outputDirectory: string,
+  functionModules: ReadonlyArray<string>,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const conditions = yield* serverConditions();
+  const discovered = yield* discoverServerFunctions(appDirectory, functionModules);
+
+  yield* fileSystem.makeDirectory(outputDirectory, { recursive: true });
+  const encodedSnapshot = encodeSchemaSnapshot(discovered.schema);
+  const snapshotBytes = utf8Bytes(encodedSnapshot);
+  yield* fileSystem.writeFile(path.join(outputDirectory, "schema.json"), snapshotBytes);
+  const functions = yield* Effect.forEach(
+    discovered.functions,
+    (definition) => buildServerFunction(appDirectory, outputDirectory, conditions, definition),
+    { concurrency: 4 },
+  );
+  const manifest = {
+    formatVersion: 1,
+    schema: yield* artifactReference(schemaSnapshotPath, snapshotBytes),
+    functions,
+  } satisfies ServerBuildManifest;
+  const encodedManifest = `${encodeCanonical(ServerBuildManifest, manifest)}\n`;
+  const manifestPath = path.join(outputDirectory, "manifest.json");
+  yield* fileSystem.writeFileString(manifestPath, encodedManifest);
+  yield* Schema.decodeEffect(Schema.fromJsonString(ServerBuildManifest))(encodedManifest).pipe(
+    Effect.mapError(() =>
+      InvalidBuildOutput.make({ message: "Ignotum emitted an invalid server manifest." }),
+    ),
+  );
+
+  return {
+    functions: functions.length,
+    manifestPath,
+  } satisfies ServerBuildResult;
+});