ignotum 0.0.2 → 0.0.4

package/src/cli/dev.ts

@@ -1,44 +1,20 @@
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-
 import prefresh from "@prefresh/vite";
 import tailwindcss from "@tailwindcss/vite";
 import { Effect, FileSystem, Path, Schema } from "effect";
-import { createServer, defaultClientConditions, normalizePath } from "vite";
-import type { Alias, ViteDevServer } from "vite";
+import { createServer } from "vite";
+import type { ViteDevServer } from "vite";
 
 import { generate } from "./codegen.js";
+import {
+  resolveClientBuildConfig,
+  validateClientFiles,
+  type ClientFiles,
+} from "./client-config.js";
+import { loadClientEntryTitle } from "./client-entry.js";
 import { ignotumClientPlugin } from "./client-plugin.js";
 import { acquireDevDatabaseLock, devDatabasePath } from "../dev-runtime/dev-database.js";
 import { ignotumSyncPlugin } from "../dev-runtime/sync.js";
 
-const requiredClientFiles = ["App.tsx", "styles.css"] as const;
-const preactSpecifiers = [
-  "preact/jsx-dev-runtime",
-  "preact/jsx-runtime",
-  "preact/devtools",
-  "preact/debug",
-  "preact/hooks",
-  "preact",
-] as const;
-const prefreshSpecifiers = ["@prefresh/core", "@prefresh/utils"] as const;
-
-export class ClientFileNotFound extends Schema.TaggedError<ClientFileNotFound>()(
-  "ClientFileNotFound",
-  {
-    message: Schema.String,
-    path: Schema.String,
-  },
-) {}
-
-export class ClientRuntimeResolutionFailed extends Schema.TaggedError<ClientRuntimeResolutionFailed>()(
-  "ClientRuntimeResolutionFailed",
-  {
-    cause: Schema.Defect(),
-    message: Schema.String,
-  },
-) {}
-
 export class ViteStartupFailed extends Schema.TaggedError<ViteStartupFailed>()(
   "ViteStartupFailed",
   {
@@ -51,76 +27,20 @@ export interface DevOptions {
   readonly host: string;
   readonly open: boolean;
   readonly port: number;
-  readonly projectDirectory: string;
+  readonly appDirectory: string;
 }
 
-const validateClientFiles = Effect.fn("Dev.validateClientFiles")(function* (
-  projectDirectory: string,
+const acquireViteServer = Effect.fn("Dev.acquireViteServer")(function* (
+  options: DevOptions,
+  clientFiles: ClientFiles,
 ) {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  const clientDirectory = path.join(projectDirectory, "client");
-
-  yield* Effect.forEach(
-    requiredClientFiles,
-    Effect.fn("Dev.validateClientFile")(function* (fileName) {
-      const filePath = path.join(clientDirectory, fileName);
-      const exists = yield* fileSystem.exists(filePath);
-
-      if (!exists) {
-        return yield* ClientFileNotFound.make({
-          message: `Required client file not found: ${filePath}`,
-          path: filePath,
-        });
-      }
-    }),
-    { discard: true },
-  );
-});
-
-const resolveClientAliases = Effect.fn("Dev.resolveClientAliases")(function* () {
-  return yield* Effect.try({
-    try: (): Array<Alias> => {
-      const prefreshRequire = createRequire(import.meta.resolve("@prefresh/vite"));
-
-      return [
-        {
-          find: /^tailwindcss$/,
-          replacement: normalizePath(fileURLToPath(import.meta.resolve("tailwindcss/index.css"))),
-        },
-        ...preactSpecifiers.map((specifier) => ({
-          find: specifier,
-          replacement: normalizePath(fileURLToPath(import.meta.resolve(specifier))),
-        })),
-        ...prefreshSpecifiers.map((specifier) => ({
-          find: specifier,
-          replacement: normalizePath(prefreshRequire.resolve(specifier)),
-        })),
-      ];
-    },
-    catch: (cause) =>
-      ClientRuntimeResolutionFailed.make({
-        cause,
-        message: "Ignotum could not resolve its client runtime.",
-      }),
-  });
-});
-
-const acquireViteServer = Effect.fn("Dev.acquireViteServer")(function* (options: DevOptions) {
-  const fileSystem = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const aliases = yield* resolveClientAliases();
-  const clientDirectory = path.join(options.projectDirectory, "client");
-  const databasePath = yield* devDatabasePath(options.projectDirectory);
+  const runPromise = Effect.runPromiseWith(yield* Effect.context<never>());
+  const clientConfig = yield* resolveClientBuildConfig(true);
+  const clientDirectory = clientFiles.clientDirectory;
+  const databasePath = yield* devDatabasePath(options.appDirectory);
   const stateDirectory = path.dirname(databasePath);
-  const sourceClientEntry = fileURLToPath(new URL("../../src/client/index.ts", import.meta.url));
-  const sourceContractsEntry = fileURLToPath(
-    new URL("../../../contracts/src/schema/index.ts", import.meta.url),
-  );
-  const hasSourceClient = yield* fileSystem.exists(sourceClientEntry);
-  const hasSourceContracts = yield* fileSystem.exists(sourceContractsEntry);
-  const hasWorkspaceSourceExports = hasSourceClient && hasSourceContracts;
-
   yield* fileSystem.makeDirectory(stateDirectory, { recursive: true });
 
   return yield* Effect.acquireRelease(
@@ -133,8 +53,17 @@ const acquireViteServer = Effect.fn("Dev.acquireViteServer")(function* (options:
             mode: "development",
             root: clientDirectory,
             plugins: [
-              ignotumSyncPlugin(options.projectDirectory, databasePath),
-              ignotumClientPlugin(),
+              ignotumSyncPlugin(options.appDirectory, databasePath),
+              ignotumClientPlugin({
+                development: true,
+                icon: clientFiles.iconPath === undefined ? undefined : "/icon.svg",
+                loadTitle: () =>
+                  runPromise(
+                    loadClientEntryTitle(clientFiles.entryPath).pipe(
+                      Effect.provideService(FileSystem.FileSystem, fileSystem),
+                    ),
+                  ),
+              }),
               prefreshPlugin,
               tailwindcss(),
             ],
@@ -144,13 +73,19 @@ const acquireViteServer = Effect.fn("Dev.acquireViteServer")(function* (options:
                 runtime: "automatic",
               },
             },
-            resolve: {
-              alias: aliases,
-              conditions: [
-                ...(hasWorkspaceSourceExports ? ["@ignotum/source"] : []),
-                ...defaultClientConditions,
+            optimizeDeps: {
+              include: [
+                "preact",
+                "preact/hooks",
+                "preact/jsx-runtime",
+                "ignotum/client",
+                "ignotum/client/jsx-dev-runtime",
               ],
-              dedupe: ["preact"],
+            },
+            resolve: {
+              alias: clientConfig.aliases,
+              conditions: [...clientConfig.conditions],
+              dedupe: ["preact", "preact/hooks"],
               tsconfigPaths: true,
             },
             server: {
@@ -187,13 +122,13 @@ const listen = Effect.fn("Dev.listen")(function* (server: ViteDevServer) {
 });
 
 export const dev = Effect.fn("Dev.run")(function* (options: DevOptions) {
-  yield* validateClientFiles(options.projectDirectory);
-  yield* generate(options.projectDirectory);
+  const clientFiles = yield* validateClientFiles(options.appDirectory);
+  yield* generate(options.appDirectory);
 
   return yield* Effect.scoped(
     Effect.gen(function* () {
-      yield* acquireDevDatabaseLock(options.projectDirectory);
-      const server = yield* acquireViteServer(options);
+      yield* acquireDevDatabaseLock(options.appDirectory);
+      const server = yield* acquireViteServer(options, clientFiles);
 
       yield* listen(server);
       yield* Effect.sync(() => {

package/src/cli/module-boundaries.ts

@@ -0,0 +1,183 @@
+import { isBuiltin } from "node:module";
+
+import * as Config from "effect/Config";
+import { Effect, FileSystem, Predicate, Schema, String } from "effect";
+import { normalizePath } from "vite";
+import type { Plugin } from "vite";
+
+const BuildGraph = Schema.Literals(["Client", "Server"]);
+type BuildGraph = typeof BuildGraph.Type;
+type PackageGraph = BuildGraph | "Shared";
+
+interface PackageEntry {
+  readonly graph: PackageGraph;
+  readonly specifier: string;
+}
+
+const packageEntries: ReadonlyArray<PackageEntry> = [
+  { graph: "Client", specifier: "ignotum/client" },
+  { graph: "Client", specifier: "ignotum/internal/api" },
+  { graph: "Server", specifier: "ignotum/server" },
+  { graph: "Server", specifier: "ignotum/internal/host" },
+  { graph: "Server", specifier: "ignotum/internal/server" },
+  { graph: "Shared", specifier: "ignotum/internal/types" },
+];
+
+export class BuildBoundaryViolation extends Schema.TaggedError<BuildBoundaryViolation>()(
+  "BuildBoundaryViolation",
+  {
+    graph: BuildGraph,
+    importer: Schema.String,
+    message: Schema.String,
+    specifier: Schema.String,
+  },
+) {}
+
+const cleanModuleId = (id: string): string => normalizePath(id.split("?", 1)[0] ?? id);
+
+const caseVariant = (path: string): string | undefined => {
+  for (let index = 0; index < path.length; index += 1) {
+    const character = path[index];
+    if (character === undefined) continue;
+    const lower: string = String.toLowerCase(character);
+    const upper: string = String.toUpperCase(character);
+    if (lower === upper) continue;
+    return `${path.slice(0, index)}${character === lower ? upper : lower}${path.slice(index + 1)}`;
+  }
+};
+
+const isWithin = (id: string, directory: string): boolean =>
+  id === directory || id.startsWith(`${directory}/`);
+
+const packageGraph = (specifier: string): PackageGraph | undefined => {
+  for (const entry of packageEntries) {
+    if (specifier === entry.specifier || specifier.startsWith(`${entry.specifier}/`)) {
+      return entry.graph;
+    }
+  }
+};
+
+const isForbiddenPackage = (graph: BuildGraph, specifier: string): boolean => {
+  const owner = packageGraph(specifier);
+  return owner !== undefined && owner !== "Shared" && owner !== graph;
+};
+
+export const moduleBoundariesPlugin = Effect.fn("Deploy.moduleBoundariesPlugin")(function* (
+  graph: BuildGraph,
+  appDirectory: string,
+) {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const runPromise = Effect.runPromiseWith(yield* Effect.context<never>());
+  const isolatedDiscovery =
+    (yield* Config.string("IGNOTUM_ISOLATED_DISCOVERY").pipe(Config.withDefault("0"))) === "1";
+  const realAppDirectory = isolatedDiscovery
+    ? normalizePath(cleanModuleId(appDirectory))
+    : normalizePath(yield* fileSystem.realPath(cleanModuleId(appDirectory)));
+  const appCaseVariant = caseVariant(realAppDirectory);
+  const caseInsensitive =
+    !isolatedDiscovery &&
+    appCaseVariant !== undefined &&
+    (yield* fileSystem.exists(appCaseVariant));
+
+  const canonicalModuleId = Effect.fn("Deploy.canonicalModuleId")(function* (id: string) {
+    const cleaned = cleanModuleId(id);
+    const exists = yield* fileSystem.exists(cleaned);
+    const canonical =
+      exists && !isolatedDiscovery
+        ? normalizePath(yield* fileSystem.realPath(cleaned))
+        : normalizePath(cleaned);
+    return caseInsensitive ? String.toLowerCase(canonical) : canonical;
+  });
+
+  const normalizedApp = yield* canonicalModuleId(appDirectory);
+  const clientDirectory = yield* canonicalModuleId(`${normalizedApp}/client`);
+  const serverDirectory = yield* canonicalModuleId(`${normalizedApp}/server`);
+  const generatedApi = yield* canonicalModuleId(`${normalizedApp}/_generated/api.ts`);
+  const generatedServer = yield* canonicalModuleId(`${normalizedApp}/_generated/server.ts`);
+
+  const reject = (specifier: string, importer: string, reason: string): never => {
+    throw BuildBoundaryViolation.make({
+      graph,
+      importer,
+      message: `${graph.toLowerCase()} build cannot import ${specifier} from ${importer}: ${reason}.`,
+      specifier,
+    });
+  };
+
+  const validateSpecifier = (specifier: string, importer: string): void => {
+    const cleaned = cleanModuleId(specifier);
+    if (isBuiltin(cleaned)) reject(specifier, importer, "Node built-ins are unavailable");
+    if (cleaned.endsWith(".node")) reject(specifier, importer, "native add-ons are unavailable");
+    if (isForbiddenPackage(graph, cleaned)) {
+      reject(
+        specifier,
+        importer,
+        `the package entry belongs to the ${graph === "Client" ? "server" : "client"}`,
+      );
+    }
+  };
+
+  const validateCanonicalId = (cleaned: string, importer: string, specifier: string): void => {
+    if (cleaned.endsWith(".node")) {
+      reject(specifier, importer, "native add-ons are unavailable");
+    }
+
+    if (graph === "Client" && (isWithin(cleaned, serverDirectory) || cleaned === generatedServer)) {
+      reject(specifier, importer, "the resolved module belongs to the server");
+    }
+
+    if (graph === "Server" && (isWithin(cleaned, clientDirectory) || cleaned === generatedApi)) {
+      reject(specifier, importer, "the resolved module belongs to the client");
+    }
+  };
+
+  const validateResolvedId = (id: string, importer: string, specifier: string): Promise<void> =>
+    id.startsWith("\0")
+      ? Promise.resolve()
+      : runPromise(canonicalModuleId(id)).then((cleaned) =>
+          validateCanonicalId(cleaned, importer, specifier),
+        );
+
+  return {
+    name: `ignotum:${graph.toLowerCase()}-boundaries`,
+    enforce: "pre",
+
+    moduleParsed: (moduleInfo) =>
+      moduleInfo.id.startsWith("\0")
+        ? undefined
+        : runPromise(canonicalModuleId(moduleInfo.id)).then((cleaned) => {
+            validateCanonicalId(cleaned, moduleInfo.id, moduleInfo.id);
+            if (
+              graph === "Server" &&
+              isWithin(cleaned, normalizedApp) &&
+              moduleInfo.dynamicallyImportedIds.length > 0
+            ) {
+              reject(
+                moduleInfo.dynamicallyImportedIds[0] ?? "dynamic import",
+                moduleInfo.id,
+                "dynamic imports are unavailable in server functions",
+              );
+            }
+          }),
+
+    resolveId: function (specifier, importer, options) {
+      const importingModule = importer ?? "<entry>";
+      validateSpecifier(specifier, importingModule);
+      return this.resolve(specifier, importer, { ...options, skipSelf: true }).then((resolved) => {
+        if (resolved === null) return resolved;
+        return validateResolvedId(resolved.id, importingModule, specifier).then(() => resolved);
+      });
+    },
+
+    resolveDynamicImport: (specifier, importer) => {
+      if (graph === "Server") {
+        reject(
+          Predicate.isString(specifier) ? specifier : "dynamic import",
+          importer ?? "<entry>",
+          "dynamic imports are unavailable in server functions",
+        );
+      }
+      return null;
+    },
+  } satisfies Plugin;
+});