@confect/cli 9.0.0-next.4 → 9.0.0-next.6

package/src/confect/dev.ts

@@ -22,9 +22,13 @@ import {
   Stream,
   String,
 } from "effect";
+import {
+  externalPlugin,
+  loadTsConfig,
+  tsconfigPathsToRegExp,
+} from "bundle-require";
 import * as esbuild from "esbuild";
 import { logCoalescedBuildErrors } from "../BuildError";
-import { absoluteExternalsPlugin } from "../Bundler";
 import * as CodegenError from "../CodegenError";
 import { ConfectDirectory } from "../ConfectDirectory";
 import { ConvexDirectory } from "../ConvexDirectory";
@@ -45,8 +49,14 @@ import { ProjectRoot } from "../ProjectRoot";
 import { generateAuthConfig, generateCrons, generateHttp } from "../utils";
 import { codegenHandler, loadPreviousFunctionPaths } from "./codegen";
 
-const GENERATED_SPEC_PATH = "_generated/spec.ts";
-const GENERATED_NODE_SPEC_PATH = "_generated/nodeSpec.ts";
+const GENERATED_DIRNAME = "_generated";
+
+const GENERATED_SPEC_PATH = Effect.andThen(Path.Path, (path) =>
+  path.join(GENERATED_DIRNAME, "spec.ts"),
+);
+const GENERATED_NODE_SPEC_PATH = Effect.andThen(Path.Path, (path) =>
+  path.join(GENERATED_DIRNAME, "nodeSpec.ts"),
+);
 
 // Quiescence window: the sync loop waits this long for further signals
 // after each batch. One user edit fires `onEnd` on every esbuild
@@ -95,7 +105,7 @@ const changeChar = (change: "Added" | "Removed" | "Modified") =>
   Match.value(change).pipe(
     Match.when("Added", () => ({ char: "+", color: Ansi.green })),
     Match.when("Removed", () => ({ char: "-", color: Ansi.red })),
-    Match.when("Modified", () => ({ char: "~", color: Ansi.yellow })),
+    Match.when("Modified", () => ({ char: "~", color: Ansi.magenta })),
     Match.exhaustive,
   );
 
@@ -410,10 +420,18 @@ const discoverEntryPoints = Effect.gen(function* () {
       });
     });
 
+  const generatedSpecPath = yield* GENERATED_SPEC_PATH;
+  const generatedNodeSpecPath = yield* GENERATED_NODE_SPEC_PATH;
+
   const fixedEntryOptions = yield* Effect.all([
-    tryEntry(GENERATED_SPEC_PATH, "specDirty"),
-    tryEntry(GENERATED_NODE_SPEC_PATH, "specDirty"),
-    tryEntry("schema.ts", "specDirty"),
+    tryEntry(generatedSpecPath, "specDirty"),
+    tryEntry(generatedNodeSpecPath, "specDirty"),
+    // `confect/schema.ts` is no longer user-authored; the runtime
+    // `DatabaseSchema` lives at `_generated/schema.ts` (codegen-written,
+    // so not an entry point — wiring it through esbuild would form a
+    // codegen→write→onEnd→codegen loop). Updates to `confect/tables/*.ts`
+    // still reach this dev loop via the impl entry points' import graphs;
+    // brand-new tables are caught by the Create-event safety net below.
     tryEntry("http.ts", "httpDirty"),
     tryEntry("crons.ts", "cronsDirty"),
     tryEntry("auth.ts", "authDirty"),
@@ -430,6 +448,7 @@ const discoverEntryPoints = Effect.gen(function* () {
 
 const esbuildOptions = (
   entry: EntryPoint,
+  notExternal: ReadonlyArray<RegExp>,
   signal: Queue.Queue<void>,
   pendingRef: Ref.Ref<Pending>,
   watcherErrorsRef: Ref.Ref<WatcherErrors>,
@@ -451,7 +470,7 @@ const esbuildOptions = (
     format: "esm" as const,
     logLevel: "silent" as const,
     plugins: [
-      absoluteExternalsPlugin,
+      externalPlugin({ notExternal: [...notExternal] }),
       {
         name: "notify-rebuild",
         setup(build: esbuild.PluginBuild) {
@@ -489,6 +508,7 @@ const esbuildOptions = (
 
 const createEntryPointWatcher = (
   entry: EntryPoint,
+  notExternal: ReadonlyArray<RegExp>,
   signal: Queue.Queue<void>,
   pendingRef: Ref.Ref<Pending>,
   watcherErrorsRef: Ref.Ref<WatcherErrors>,
@@ -496,7 +516,13 @@ const createEntryPointWatcher = (
   Effect.acquireRelease(
     Effect.promise(async () => {
       const ctx = await esbuild.context(
-        esbuildOptions(entry, signal, pendingRef, watcherErrorsRef),
+        esbuildOptions(
+          entry,
+          notExternal,
+          signal,
+          pendingRef,
+          watcherErrorsRef,
+        ),
       );
       await ctx.watch();
       return ctx;
@@ -534,6 +560,17 @@ const entryPointsWatcher = (
   Effect.gen(function* () {
     const parentScope = yield* Effect.scope;
     const scopesRef = yield* Ref.make(new Map<string, Scope.CloseableScope>());
+    const projectRoot = yield* ProjectRoot.get;
+    // Discover the user's `tsconfig.json#paths` once at watcher startup so
+    // `~/...`-style aliases pointing into the user's source tree get bundled
+    // by esbuild instead of externalized via `bundle-require`'s `node_modules`
+    // heuristic. `loadTsConfig` walks up from `projectRoot` to find a
+    // `tsconfig.json`; if none exists, `paths` is empty and `notExternal` is
+    // `[]`, leaving the externalization rule unchanged.
+    const tsconfig = loadTsConfig(projectRoot);
+    const notExternal = tsconfigPathsToRegExp(
+      tsconfig?.data.compilerOptions?.paths ?? {},
+    );
 
     const sync = Effect.gen(function* () {
       const desired = yield* discoverEntryPoints;
@@ -569,6 +606,7 @@ const entryPointsWatcher = (
           );
           yield* createEntryPointWatcher(
             entry,
+            notExternal,
             signal,
             pendingRef,
             watcherErrorsRef,
@@ -679,6 +717,10 @@ const handleConfectChange = ({
     );
   }
 
+  // A stray `confect/schema.ts` (now codegen-owned at
+  // `_generated/schema.ts`) shouldn't exist; flagging it here ensures the
+  // next codegen pass surfaces the migration error
+  // (`LegacySchemaFileError`) instead of silently ignoring the file.
   if (relativePath === "schema.ts") {
     return flipDirtyAndSignal(
       pendingRef,
@@ -699,7 +741,7 @@ const handleConfectChange = ({
     );
   }
 
-  // Any other `.ts` under `confect/` (helpers like `tables/Notes.ts`).
+  // Any other `.ts` under `confect/` (helpers like `tables/notes.ts`).
   // Updates to such files are handled by the esbuild watcher for whichever
   // entry point imports them — its onEnd flips the right dirty flag.
   // Creates are our safety net: when a previously-missing import is added,

package/src/log.ts

@@ -57,7 +57,7 @@ export const logFileAdded = logFile("+", Ansi.green);
 
 export const logFileRemoved = logFile("-", Ansi.red);
 
-export const logFileModified = logFile("~", Ansi.yellow);
+export const logFileModified = logFile("~", Ansi.magenta);
 
 // --- Function subline logs ---
 
@@ -101,4 +101,6 @@ export const logSuccess = logStatus("✔︎", Ansi.green);
 
 export const logFailure = logStatus("✘", Ansi.red);
 
-export const logPending = logStatus("⭘", Ansi.yellow);
+export const logPending = logStatus("⭘", Ansi.cyan);
+
+export const logWarn = logStatus("⚠", Ansi.yellow);

package/src/templates.ts

@@ -2,7 +2,6 @@ import { Array, Effect, Option } from "effect";
 import { CodeBlockWriter } from "./CodeBlockWriter";
 import {
   collectImportBindings,
-  collectLeafPaths,
   type SpecAssemblyNode,
 } from "./SpecAssemblyNode";
 
@@ -36,15 +35,197 @@ export const functions = ({
     return yield* cbw.toString();
   });
 
-export const schema = ({ schemaImportPath }: { schemaImportPath: string }) =>
+/**
+ * Emit `convex/schema.ts` as a one-line re-export of the codegen-emitted
+ * deploy schema in `confect/_generated/convexSchema.ts`. Deploy-time
+ * consumers (the Convex CLI, `convex-test`) keep reading
+ * `convex/schema.ts`; the runtime `DatabaseSchema` in
+ * `confect/_generated/schema.ts` is untouched by this file.
+ */
+export const schema = ({
+  convexSchemaImportPath,
+}: {
+  convexSchemaImportPath: string;
+}) =>
   Effect.gen(function* () {
     const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
 
-    yield* cbw.writeLine(`import schemaDefinition from "${schemaImportPath}";`);
-    yield* cbw.newLine();
     yield* cbw.writeLine(
-      `export default schemaDefinition.convexSchemaDefinition;`,
+      `export { default } from "${convexSchemaImportPath}";`,
+    );
+
+    return yield* cbw.toString();
+  });
+
+interface TableModuleBinding {
+  readonly importPath: string;
+  readonly tableName: string;
+}
+
+/**
+ * Emit `confect/_generated/schema.ts` — the runtime `DatabaseSchema` used
+ * by impls and the per-group registries (and downstream by per-function
+ * bundles for codec lookup). Every table wrapper at
+ * `confect/_generated/tables/<name>.ts` is imported statically and
+ * registered as a value entry on the `DatabaseSchema.make({...})` call.
+ * Per-table laziness lives inside each `Table`: its `Fields`, `Doc`, and
+ * `tableDefinition` are lazy memoised getters that only evaluate the
+ * user-supplied field-schema callback on first access, so unused tables in
+ * a function bundle never pay schema-construction cost despite the
+ * static import.
+ *
+ * The `DatabaseSchema` import is aliased to `$DatabaseSchema` because each
+ * table is imported under its own (filename-derived) name; a table named
+ * `DatabaseSchema` would otherwise collide with the library import and emit
+ * a duplicate-binding file. The leading `$` makes the alias collision-proof:
+ * `validateConfectTableIdentifier` requires names to match
+ * `/^[a-zA-Z][a-zA-Z0-9_]*$/`, which forbids `$`, so no valid table import
+ * can ever shadow it.
+ */
+export const runtimeSchema = ({
+  tableModules,
+}: {
+  tableModules: ReadonlyArray<TableModuleBinding>;
+}) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(
+      `import { DatabaseSchema as $DatabaseSchema } from "@confect/server";`,
+    );
+
+    if (tableModules.length > 0) {
+      yield* cbw.blankLine();
+      yield* Effect.forEach(tableModules, ({ tableName, importPath }) =>
+        cbw.writeLine(`import ${tableName} from "${importPath}";`),
+      );
+    }
+
+    yield* cbw.blankLine();
+
+    if (tableModules.length === 0) {
+      yield* cbw.writeLine(`export default $DatabaseSchema.make({});`);
+    } else {
+      yield* cbw.writeLine(`export default $DatabaseSchema.make({`);
+      yield* cbw.indent(
+        Effect.gen(function* () {
+          for (const { tableName } of tableModules) {
+            yield* cbw.writeLine(`${tableName},`);
+          }
+        }),
+      );
+      yield* cbw.writeLine(`});`);
+    }
+
+    return yield* cbw.toString();
+  });
+
+/**
+ * Emit `confect/_generated/convexSchema.ts` — the Convex deploy-time
+ * `SchemaDefinition`. Imports every table from its generated wrapper at
+ * `_generated/tables/<name>` and calls `defineSchema({...})` exactly once.
+ * The file deliberately avoids any `@confect/server` import so that the
+ * deploy artifact's import graph stays decoupled from the runtime
+ * `DatabaseSchema` machinery.
+ *
+ * The `defineSchema` import is aliased to `$defineSchema` because each table
+ * is imported under its own (filename-derived) name; a table named
+ * `defineSchema` would otherwise collide with the library import and emit a
+ * duplicate-binding file. The leading `$` makes the alias collision-proof:
+ * `validateConfectTableIdentifier` requires names to match
+ * `/^[a-zA-Z][a-zA-Z0-9_]*$/`, which forbids `$`, so no valid table import
+ * can ever shadow it.
+ */
+export const convexSchema = ({
+  tableModules,
+}: {
+  tableModules: ReadonlyArray<TableModuleBinding>;
+}) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(
+      `import { defineSchema as $defineSchema } from "convex/server";`,
+    );
+
+    if (tableModules.length > 0) {
+      yield* cbw.blankLine();
+      yield* Effect.forEach(tableModules, ({ tableName, importPath }) =>
+        cbw.writeLine(`import ${tableName} from "${importPath}";`),
+      );
+    }
+
+    yield* cbw.blankLine();
+
+    if (tableModules.length === 0) {
+      yield* cbw.writeLine(`export default $defineSchema({});`);
+    } else {
+      yield* cbw.writeLine(`export default $defineSchema({`);
+      yield* cbw.indent(
+        Effect.gen(function* () {
+          for (const { tableName } of tableModules) {
+            yield* cbw.writeLine(`${tableName}: ${tableName}.tableDefinition,`);
+          }
+        }),
+      );
+      yield* cbw.writeLine(`});`);
+    }
+
+    return yield* cbw.toString();
+  });
+
+/**
+ * Emit `confect/_generated/id.ts` — a type-constrained `Id` constructor and
+ * a `TableNames` union derived from the user's `confect/tables/*.ts`
+ * filenames. User-authored table modules import `Id` from this file to
+ * declare cross-table id references without typing the destination name as
+ * a free string (and without ever importing each other transitively).
+ *
+ * When the table directory is empty the `TableNames` union resolves to
+ * `never`, which still lets the file typecheck against an empty workspace.
+ */
+export const id = ({ tableNames }: { tableNames: ReadonlyArray<string> }) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import { GenericId } from "@confect/core";`);
+    yield* cbw.blankLine();
+
+    const union =
+      tableNames.length === 0
+        ? "never"
+        : tableNames.map((n) => `"${n}"`).join(" | ");
+    yield* cbw.writeLine(`export type TableNames = ${union};`);
+    yield* cbw.blankLine();
+
+    yield* cbw.writeLine(
+      `export const Id = <const TableName extends TableNames>(`,
     );
+    yield* cbw.indent(cbw.writeLine(`tableName: TableName,`));
+    yield* cbw.writeLine(`) => GenericId.GenericId(tableName);`);
+
+    return yield* cbw.toString();
+  });
+
+/**
+ * Emit `confect/_generated/tables/<tableName>.ts` — a two-line wrapper that
+ * imports the user-authored `UnnamedTable` and binds the file basename to
+ * it, producing the fully-named `Table` value that downstream consumers
+ * (schema, specs, impls) read.
+ */
+export const tableWrapper = ({
+  tableName,
+  unnamedImportPath,
+}: {
+  tableName: string;
+  unnamedImportPath: string;
+}) =>
+  Effect.gen(function* () {
+    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
+
+    yield* cbw.writeLine(`import unnamed from "${unnamedImportPath}";`);
+    yield* cbw.blankLine();
+    yield* cbw.writeLine(`export default unnamed("${tableName}");`);
 
     return yield* cbw.toString();
   });
@@ -110,54 +291,15 @@ export const refs = ({
     return yield* cbw.toString();
   });
 
-export const api = ({
+export const registeredFunctionsForGroup = ({
   schemaImportPath,
   specImportPath,
-}: {
-  schemaImportPath: string;
-  specImportPath: string;
-}) =>
-  Effect.gen(function* () {
-    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
-
-    yield* cbw.writeLine(`import { Api } from "@confect/server";`);
-    yield* cbw.writeLine(`import schema from "${schemaImportPath}";`);
-    yield* cbw.writeLine(`import spec from "${specImportPath}";`);
-    yield* cbw.blankLine();
-    yield* cbw.writeLine(`export default Api.make(schema, spec);`);
-
-    return yield* cbw.toString();
-  });
-
-export const nodeApi = ({
-  schemaImportPath,
-  nodeSpecImportPath,
-}: {
-  schemaImportPath: string;
-  nodeSpecImportPath: string;
-}) =>
-  Effect.gen(function* () {
-    const cbw = new CodeBlockWriter({ indentNumberOfSpaces: 2 });
-
-    yield* cbw.writeLine(`import { Api } from "@confect/server";`);
-    yield* cbw.blankLine();
-    yield* cbw.writeLine(`import schema from "${schemaImportPath}";`);
-    yield* cbw.writeLine(`import nodeSpec from "${nodeSpecImportPath}";`);
-    yield* cbw.blankLine();
-    yield* cbw.writeLine(`export default Api.make(schema, nodeSpec);`);
-
-    return yield* cbw.toString();
-  });
-
-export const registeredFunctionsForGroup = ({
-  apiImportPath,
-  groupPathDot,
   implImportPath,
   layerExportName,
   useNode = false,
 }: {
-  apiImportPath: string;
-  groupPathDot: string;
+  schemaImportPath: string;
+  specImportPath: string;
   implImportPath: string;
   layerExportName: string;
   useNode?: boolean;
@@ -178,14 +320,20 @@ export const registeredFunctionsForGroup = ({
       );
     }
 
-    yield* cbw.writeLine(`import api from "${apiImportPath}";`);
+    yield* cbw.writeLine(`import databaseSchema from "${schemaImportPath}";`);
     yield* cbw.writeLine(`import ${layerExportName} from "${implImportPath}";`);
     yield* cbw.blankLine();
-    const quotedGroupPath = `"${groupPathDot.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    // The group's own leaf spec is referenced type-only (`typeof import(...)`),
+    // so the spec module is erased at transpile time and never enters the
+    // per-function bundle; only `databaseSchema` and the impl are runtime
+    // imports. Typing from the leaf spec (not the project-wide assembled spec)
+    // keeps the registry's type dependent solely on its own group.
+    const specType = `typeof import("${specImportPath}")["default"]`;
+    const makeFn = useNode
+      ? "RegisteredNodeFunction.make"
+      : "RegisteredConvexFunction.make";
     yield* cbw.writeLine(
-      useNode
-        ? `export default RegisteredFunctions.buildForGroup(api, ${quotedGroupPath}, ${layerExportName}, RegisteredNodeFunction.make);`
-        : `export default RegisteredFunctions.buildForGroup(api, ${quotedGroupPath}, ${layerExportName}, RegisteredConvexFunction.make);`,
+      `export default RegisteredFunctions.buildForGroup<${specType}>(databaseSchema, ${layerExportName}, ${makeFn});`,
     );
 
     return yield* cbw.toString();
@@ -473,13 +621,6 @@ export const assembledSpec = ({
       runtime === "Convex" ? "GroupSpec.makeAt" : "GroupSpec.makeNodeAt";
 
     yield* cbw.write(`export default ${specFactory}`);
-    yield* Effect.forEach(collectLeafPaths(nodes), (leaf) =>
-      Effect.gen(function* () {
-        yield* cbw.write(`.addPath(${leaf.binding.localName}, `);
-        yield* cbw.quote(leaf.dotPath);
-        yield* cbw.write(")");
-      }),
-    );
     yield* Effect.forEach(nodes, (node) =>
       writeRootAddAt(cbw, node, groupFactory),
     );