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

package/src/confect/codegen.ts

@@ -1,27 +1,18 @@
-import { type GroupSpec, Spec } from "@confect/core";
-import * as DatabaseSchema from "@confect/server/DatabaseSchema";
+import { Spec, type GroupSpec } from "@confect/core";
 import { Command } from "@effect/cli";
 import { FileSystem, Path } from "@effect/platform";
 import { Array, Effect, Either, HashSet, Match, Option, Ref } from "effect";
-import { fromBundlerError } from "../BuildError";
+import * as Bundler from "../Bundler";
 import * as CodegenError from "../CodegenError";
 import {
+  LegacySchemaFileError,
   MissingImplFileError,
-  MissingSchemaFileError,
   MissingSpecFileError,
   ParentChildNameCollisionError,
-  SchemaInvalidDefaultExportError,
 } from "../CodegenError";
 import { ConfectDirectory } from "../ConfectDirectory";
 import { ConvexDirectory } from "../ConvexDirectory";
 import * as FunctionPaths from "../FunctionPaths";
-import {
-  logFileAdded,
-  logFileModified,
-  logFileRemoved,
-  logPending,
-  logSuccess,
-} from "../log";
 import {
   discoverLeafImplFiles,
   discoverLeafSpecFiles,
@@ -34,19 +25,26 @@ import {
   validateSpec,
   type LeafModule,
 } from "../LeafModule";
+import {
+  logFileAdded,
+  logFileModified,
+  logFileRemoved,
+  logPending,
+  logSuccess,
+  logWarn,
+} from "../log";
 import {
   assemblyNodesFromLeaves,
   partitionByRuntime,
   type SpecAssemblyNode,
 } from "../SpecAssemblyNode";
+import * as TableModule from "../TableModule";
 import * as templates from "../templates";
-import * as Bundler from "../Bundler";
 import {
   generateAuthConfig,
   generateCrons,
   generateFunctions,
   generateHttp,
-  removePathExtension,
   removePathIfExists,
   toModuleImportPath,
   touchConvexSchema,
@@ -54,21 +52,41 @@ import {
   WriteTracker,
 } from "../utils";
 
-const GENERATED_SPEC_PATH = "_generated/spec.ts";
-const GENERATED_NODE_SPEC_PATH = "_generated/nodeSpec.ts";
-
-const LEGACY_PATHS = [
-  "spec.ts",
-  "nodeSpec.ts",
-  "impl.ts",
-  "nodeImpl.ts",
-  "notesAndRandom.impl.ts",
-  "groups.impl.ts",
-  "_generated/registeredFunctions.ts",
-  "_generated/nodeRegisteredFunctions.ts",
-  "_generated/impl.ts",
-  "_generated/nodeImpl.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"),
+);
+const GENERATED_SCHEMA_PATH = Effect.andThen(Path.Path, (path) =>
+  path.join(GENERATED_DIRNAME, "schema.ts"),
+);
+const GENERATED_CONVEX_SCHEMA_PATH = Effect.andThen(Path.Path, (path) =>
+  path.join(GENERATED_DIRNAME, "convexSchema.ts"),
+);
+const GENERATED_ID_PATH = Effect.andThen(Path.Path, (path) =>
+  path.join(GENERATED_DIRNAME, "id.ts"),
+);
+const GENERATED_TABLES_DIRNAME = Effect.andThen(Path.Path, (path) =>
+  path.join(GENERATED_DIRNAME, "tables"),
+);
+
+const LEGACY_PATHS = Effect.gen(function* () {
+  const path = yield* Path.Path;
+
+  return [
+    "spec.ts",
+    "nodeSpec.ts",
+    "impl.ts",
+    "nodeImpl.ts",
+    path.join(GENERATED_DIRNAME, "registeredFunctions.ts"),
+    path.join(GENERATED_DIRNAME, "nodeRegisteredFunctions.ts"),
+    path.join(GENERATED_DIRNAME, "impl.ts"),
+    path.join(GENERATED_DIRNAME, "nodeImpl.ts"),
+  ];
+});
 
 export const codegen = Command.make("codegen", {}, () =>
   Effect.gen(function* () {
@@ -98,27 +116,50 @@ export const codegenHandler = Effect.gen(function* () {
 
 const runCodegen = Effect.gen(function* () {
   yield* generateConfectGeneratedDirectory;
-  // Validate schema first so its missing-file / invalid-default-export
-  // diagnostics surface ahead of impl bundling, which transitively depends
-  // on schema via `_generated/api.ts` and would otherwise blow up with a
-  // less actionable bundler error.
-  yield* validateSchema;
+  // Reject a legacy `confect/schema.ts` up front so the user-facing
+  // migration message surfaces before any bundler error from impl
+  // validation (each impl imports `_generated/schema.ts`).
+  yield* rejectLegacySchemaFile;
+  // List `confect/tables/*.ts` (filename-only — no bundling yet) so the
+  // `_generated/id.ts` constructor can be emitted *before* we bundle any
+  // user-authored table module. Tables import from `_generated/id.ts` for
+  // cross-table id refs, so it must exist on disk first.
+  const tableModules = yield* TableModule.discover;
+  yield* warnIfNoTables(tableModules);
+  yield* generateIdConstructor(tableModules);
+  // Now that `_generated/id.ts` is on disk, bundle each table module and
+  // check its default export is an `UnnamedTable`. Surface diagnostics
+  // here (rather than later) so they appear before impl-validation noise.
+  yield* TableModule.validate(tableModules);
+  yield* generateTableWrappers(tableModules);
+  yield* removeObsoleteTableWrappers(tableModules);
+  yield* generateRuntimeSchema(tableModules);
   const { leaves, groupSpecsByRelativePath } =
     yield* loadAndValidateLeafModules;
   yield* removeLegacyFiles;
   yield* validateNoParentChildNameCollisions(leaves, groupSpecsByRelativePath);
   yield* generateAssembledSpecs(leaves);
-  yield* validateImplModules(leaves);
-  yield* generateGroupRegisteredFunctions(leaves);
-  yield* removeObsoleteRegisteredFunctions(leaves);
+  // `_generated/api.ts` / `nodeApi.ts` are no longer imported by generated or
+  // impl code (impls take the database schema from `_generated/schema`
+  // directly), so remove any copies left over from earlier versions before
+  // impl validation runs.
   yield* Effect.all(
-    [generateApi, generateRefs, generateNodeApi, generateServices],
+    [
+      removeGeneratedApi,
+      generateRefs,
+      removeGeneratedNodeApi,
+      generateServices,
+      generateConvexSchema(tableModules),
+    ],
     { concurrency: "unbounded" },
   );
+  yield* validateImplModules(leaves);
+  yield* generateGroupRegisteredFunctions(leaves);
+  yield* removeObsoleteRegisteredFunctions(leaves);
   const [functionPaths] = yield* Effect.all(
     [
       generateFunctionModules,
-      generateSchema,
+      generateConvexSchemaReexport,
       logGenerated(generateHttp),
       logGenerated(generateCrons),
       logGenerated(generateAuthConfig),
@@ -318,8 +359,9 @@ const removeLegacyFiles = Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const confectDirectory = yield* ConfectDirectory.get;
+  const legacyPaths = yield* LEGACY_PATHS;
 
-  yield* Effect.forEach(LEGACY_PATHS, (relativePath) =>
+  yield* Effect.forEach(legacyPaths, (relativePath) =>
     Effect.gen(function* () {
       const absolutePath = path.join(confectDirectory, relativePath);
       if (yield* fs.exists(absolutePath)) {
@@ -334,6 +376,8 @@ const generateAssembledSpecs = (leaves: ReadonlyArray<LeafModule>) =>
   Effect.gen(function* () {
     const path = yield* Path.Path;
     const confectDirectory = yield* ConfectDirectory.get;
+    const generatedSpecPath = yield* GENERATED_SPEC_PATH;
+    const generatedNodeSpecPath = yield* GENERATED_NODE_SPEC_PATH;
     const { convex, node } = partitionByRuntime(leaves);
 
     if (convex.length > 0) {
@@ -343,7 +387,7 @@ const generateAssembledSpecs = (leaves: ReadonlyArray<LeafModule>) =>
         runtime: "Convex",
       });
       yield* writeFileStringAndLog(
-        path.join(confectDirectory, GENERATED_SPEC_PATH),
+        path.join(confectDirectory, generatedSpecPath),
         specContents,
       );
     }
@@ -357,7 +401,7 @@ const generateAssembledSpecs = (leaves: ReadonlyArray<LeafModule>) =>
         runtime: "Node",
       });
       yield* writeFileStringAndLog(
-        path.join(confectDirectory, GENERATED_NODE_SPEC_PATH),
+        path.join(confectDirectory, generatedNodeSpecPath),
         nodeSpecContents,
       );
     }
@@ -387,11 +431,18 @@ const generateGroupRegisteredFunctions = (leaves: ReadonlyArray<LeafModule>) =>
         }
 
         const implRelativePath = yield* implPathForSpec(leaf.relativePath);
-        const apiFileName = leaf.runtime === "Node" ? "nodeApi.ts" : "api.ts";
-        const apiImportPath = yield* toModuleImportPath(
+        const schemaImportPath = yield* toModuleImportPath(
+          path.relative(
+            path.dirname(registryPath),
+            path.join(confectDirectory, "_generated", "schema.ts"),
+          ),
+        );
+        // The group's own leaf spec (sibling of its impl), referenced
+        // type-only by the registry to shape its returned record.
+        const specImportPath = yield* toModuleImportPath(
           path.relative(
             path.dirname(registryPath),
-            path.join(confectDirectory, "_generated", apiFileName),
+            path.join(confectDirectory, leaf.relativePath),
           ),
         );
         const implImportPath = yield* toModuleImportPath(
@@ -402,8 +453,8 @@ const generateGroupRegisteredFunctions = (leaves: ReadonlyArray<LeafModule>) =>
         );
 
         const contents = yield* templates.registeredFunctionsForGroup({
-          apiImportPath,
-          groupPathDot: leaf.registryGroupPathDot,
+          schemaImportPath,
+          specImportPath,
           implImportPath,
           layerExportName: leaf.exportName,
           useNode: leaf.runtime === "Node",
@@ -457,13 +508,15 @@ const removeObsoleteRegisteredFunctions = (leaves: ReadonlyArray<LeafModule>) =>
 const getGeneratedSpecPath = Effect.gen(function* () {
   const path = yield* Path.Path;
   const confectDirectory = yield* ConfectDirectory.get;
-  return path.join(confectDirectory, GENERATED_SPEC_PATH);
+  const generatedSpecPath = yield* GENERATED_SPEC_PATH;
+  return path.join(confectDirectory, generatedSpecPath);
 });
 
 const getGeneratedNodeSpecPath = Effect.gen(function* () {
   const path = yield* Path.Path;
   const confectDirectory = yield* ConfectDirectory.get;
-  return path.join(confectDirectory, GENERATED_NODE_SPEC_PATH);
+  const generatedNodeSpecPath = yield* GENERATED_NODE_SPEC_PATH;
+  return path.join(confectDirectory, generatedNodeSpecPath);
 });
 
 const loadGeneratedSpec = Effect.gen(function* () {
@@ -526,120 +579,254 @@ export const loadPreviousFunctionPaths = Effect.gen(function* () {
   });
 });
 
-const generateApi = Effect.gen(function* () {
-  const path = yield* Path.Path;
-  const confectDirectory = yield* ConfectDirectory.get;
+/**
+ * Remove a now-obsolete `_generated/<name>.ts` if present (and log it), for
+ * projects upgrading from a version that still emitted it.
+ */
+const removeObsoleteGeneratedFile = (fileName: string) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const confectDirectory = yield* ConfectDirectory.get;
+    const filePath = path.join(confectDirectory, "_generated", fileName);
 
-  const apiPath = path.join(confectDirectory, "_generated", "api.ts");
-  const apiDir = path.dirname(apiPath);
+    if (yield* fs.exists(filePath)) {
+      yield* removePathIfExists(filePath);
+      yield* logFileRemoved(filePath);
+    }
+  });
 
-  const schemaImportPath = yield* toModuleImportPath(
-    path.relative(apiDir, path.join(confectDirectory, "schema.ts")),
-  );
+// `_generated/api.ts` is no longer imported by generated or impl code: impls
+// take the database schema (`_generated/schema`) directly, and per-group
+// registries reference the spec type-only. Remove any stale copy.
+const removeGeneratedApi = removeObsoleteGeneratedFile("api.ts");
 
-  const specImportPath = yield* toModuleImportPath(
-    path.relative(apiDir, path.join(confectDirectory, GENERATED_SPEC_PATH)),
-  );
+// `_generated/nodeApi.ts` is obsolete for the same reason.
+const removeGeneratedNodeApi = removeObsoleteGeneratedFile("nodeApi.ts");
 
-  const apiContents = yield* templates.api({
-    schemaImportPath,
-    specImportPath,
+const generateFunctionModules = Effect.gen(function* () {
+  const spec = yield* loadGeneratedSpec;
+  const nodeSpecOption = yield* loadGeneratedNodeSpec;
+
+  const mergedSpec = Option.match(nodeSpecOption, {
+    onNone: () => spec,
+    onSome: (nodeSpec) => Spec.merge(spec, nodeSpec),
   });
 
-  yield* writeFileStringAndLog(apiPath, apiContents);
+  return yield* generateFunctions(mergedSpec);
 });
 
-export const generateNodeApi = Effect.gen(function* () {
+/**
+ * The user-authored `confect/schema.ts` is no longer supported: codegen now
+ * owns both `_generated/schema.ts` (runtime) and `_generated/convexSchema.ts`
+ * (deploy), derived from a single scan of `confect/tables/*.ts`. Detect a
+ * stray file and fail with a clear migration message — leaving it in place
+ * would silently shadow the codegen-owned `_generated/schema.ts` /
+ * `_generated/convexSchema.ts`.
+ */
+const rejectLegacySchemaFile = Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const confectDirectory = yield* ConfectDirectory.get;
+  const legacyPath = path.join(confectDirectory, "schema.ts");
 
-  const nodeSpecPath = yield* getGeneratedNodeSpecPath;
-  const nodeApiPath = path.join(confectDirectory, "_generated", "nodeApi.ts");
-
-  if (!(yield* fs.exists(nodeSpecPath))) {
-    if (yield* fs.exists(nodeApiPath)) {
-      yield* removePathIfExists(nodeApiPath);
-      yield* logFileRemoved(nodeApiPath);
-    }
-    return;
+  if (yield* fs.exists(legacyPath)) {
+    return yield* new LegacySchemaFileError({ schemaPath: "schema.ts" });
   }
+});
 
-  const nodeApiDir = path.dirname(nodeApiPath);
+/**
+ * Surface a yellow `⚠` warning when codegen sees no tables — either the
+ * `confect/tables/` directory is missing or it contains no `.ts` files.
+ * Generation still succeeds (emitting an empty `DatabaseSchema` and
+ * `defineSchema({})`), since action-only / table-free Confect backends
+ * are legal — but the warning catches the much more common case of a
+ * typoed directory or files placed under the wrong root.
+ */
+const warnIfNoTables = (
+  tableModules: ReadonlyArray<TableModule.TableModule>,
+) =>
+  tableModules.length === 0
+    ? logWarn(
+        `No tables discovered in \`confect/${TableModule.TABLES_DIRNAME}/\`. ` +
+          `Generating an empty schema; add a \`Table.make(...)\` module under that ` +
+          `directory unless this backend is intentionally tables-free.`,
+      )
+    : Effect.void;
 
-  const schemaImportPath = yield* toModuleImportPath(
-    path.relative(nodeApiDir, path.join(confectDirectory, "schema.ts")),
-  );
+const tableModuleBindings = (
+  tableModules: ReadonlyArray<TableModule.TableModule>,
+  generatedFilePath: string,
+) =>
+  Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const confectDirectory = yield* ConfectDirectory.get;
+    const generatedDir = path.dirname(generatedFilePath);
 
-  const nodeSpecImportPath = yield* toModuleImportPath(
-    path.relative(nodeApiDir, nodeSpecPath),
-  );
+    const generatedTablesDirname = yield* GENERATED_TABLES_DIRNAME;
 
-  const nodeApiContents = yield* templates.nodeApi({
-    schemaImportPath,
-    nodeSpecImportPath,
+    return yield* Effect.forEach(tableModules, (tm) =>
+      Effect.gen(function* () {
+        const wrapperAbsolutePath = path.join(
+          confectDirectory,
+          generatedTablesDirname,
+          `${tm.tableName}.ts`,
+        );
+        const importPath = yield* toModuleImportPath(
+          path.relative(generatedDir, wrapperAbsolutePath),
+        );
+        return {
+          importPath,
+          tableName: tm.tableName,
+        };
+      }),
+    );
   });
 
-  yield* writeFileStringAndLog(nodeApiPath, nodeApiContents);
-});
+const generateIdConstructor = (
+  tableModules: ReadonlyArray<TableModule.TableModule>,
+) =>
+  Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const confectDirectory = yield* ConfectDirectory.get;
+    const generatedIdPath = yield* GENERATED_ID_PATH;
+    const idPath = path.join(confectDirectory, generatedIdPath);
 
-const generateFunctionModules = Effect.gen(function* () {
-  const spec = yield* loadGeneratedSpec;
-  const nodeSpecOption = yield* loadGeneratedNodeSpec;
+    const tableNames = tableModules.map((tm) => tm.tableName);
+    const contents = yield* templates.id({ tableNames });
 
-  const mergedSpec = Option.match(nodeSpecOption, {
-    onNone: () => spec,
-    onSome: (nodeSpec) => Spec.merge(spec, nodeSpec),
+    yield* writeFileStringAndLog(idPath, contents);
   });
 
-  return yield* generateFunctions(mergedSpec);
-});
-
-export const validateSchema = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const confectDirectory = yield* ConfectDirectory.get;
-  const confectSchemaPath = path.join(confectDirectory, "schema.ts");
+const generateTableWrappers = (
+  tableModules: ReadonlyArray<TableModule.TableModule>,
+) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const confectDirectory = yield* ConfectDirectory.get;
+    const generatedTablesDirname = yield* GENERATED_TABLES_DIRNAME;
+    const wrappersDir = path.join(confectDirectory, generatedTablesDirname);
 
-  if (!(yield* fs.exists(confectSchemaPath))) {
-    return yield* new MissingSchemaFileError({ schemaPath: "schema.ts" });
-  }
+    if (!(yield* fs.exists(wrappersDir))) {
+      yield* fs.makeDirectory(wrappersDir, { recursive: true });
+    }
 
-  yield* Bundler.bundle(confectSchemaPath).pipe(
-    Effect.mapError((error) => fromBundlerError("schema.ts", error)),
-    Effect.andThen(({ module: schemaModule }) => {
-      const defaultExport = schemaModule.default;
-
-      return DatabaseSchema.isDatabaseSchema(defaultExport)
-        ? Effect.succeed(defaultExport)
-        : Effect.fail(
-            new SchemaInvalidDefaultExportError({
-              schemaPath: "schema.ts",
-            }),
+    yield* Effect.forEach(
+      tableModules,
+      (tm) =>
+        Effect.gen(function* () {
+          const wrapperPath = path.join(
+            confectDirectory,
+            generatedTablesDirname,
+            `${tm.tableName}.ts`,
           );
-    }),
-  );
-});
+          const unnamedAbsolutePath = path.join(
+            confectDirectory,
+            tm.relativePath,
+          );
+          const unnamedImportPath = yield* toModuleImportPath(
+            path.relative(path.dirname(wrapperPath), unnamedAbsolutePath),
+          );
+          const contents = yield* templates.tableWrapper({
+            tableName: tm.tableName,
+            unnamedImportPath,
+          });
+          yield* writeFileStringAndLog(wrapperPath, contents);
+        }),
+      { concurrency: "unbounded" },
+    );
+  });
 
-const generateSchema = Effect.gen(function* () {
+/**
+ * Remove any stale `_generated/tables/*.ts` wrapper whose source table
+ * has been deleted or renamed. Mirrors `removeObsoleteRegisteredFunctions`
+ * for the wrapper directory.
+ */
+const removeObsoleteTableWrappers = (
+  tableModules: ReadonlyArray<TableModule.TableModule>,
+) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const confectDirectory = yield* ConfectDirectory.get;
+    const generatedTablesDirname = yield* GENERATED_TABLES_DIRNAME;
+    const wrappersDir = path.join(confectDirectory, generatedTablesDirname);
+
+    if (!(yield* fs.exists(wrappersDir))) {
+      return;
+    }
+
+    const expected = new Set(tableModules.map((tm) => `${tm.tableName}.ts`));
+    const existing = yield* fs.readDirectory(wrappersDir, { recursive: true });
+    yield* Effect.forEach(existing, (entry) => {
+      if (path.extname(entry) !== ".ts") {
+        return Effect.void;
+      }
+      if (!expected.has(entry)) {
+        return Effect.gen(function* () {
+          const absolutePath = path.join(wrappersDir, entry);
+          if (yield* fs.exists(absolutePath)) {
+            yield* removePathIfExists(absolutePath);
+            yield* logFileRemoved(absolutePath);
+          }
+        });
+      }
+      return Effect.void;
+    });
+  });
+
+const generateRuntimeSchema = (
+  tableModules: ReadonlyArray<TableModule.TableModule>,
+) =>
+  Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const confectDirectory = yield* ConfectDirectory.get;
+    const generatedSchemaPath = yield* GENERATED_SCHEMA_PATH;
+    const schemaPath = path.join(confectDirectory, generatedSchemaPath);
+
+    const bindings = yield* tableModuleBindings(tableModules, schemaPath);
+    const contents = yield* templates.runtimeSchema({ tableModules: bindings });
+
+    yield* writeFileStringAndLog(schemaPath, contents);
+  });
+
+const generateConvexSchema = (
+  tableModules: ReadonlyArray<TableModule.TableModule>,
+) =>
+  Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const confectDirectory = yield* ConfectDirectory.get;
+    const generatedConvexSchemaPath = yield* GENERATED_CONVEX_SCHEMA_PATH;
+    const convexSchemaPath = path.join(
+      confectDirectory,
+      generatedConvexSchemaPath,
+    );
+
+    const bindings = yield* tableModuleBindings(tableModules, convexSchemaPath);
+    const contents = yield* templates.convexSchema({ tableModules: bindings });
+
+    yield* writeFileStringAndLog(convexSchemaPath, contents);
+  });
+
+const generateConvexSchemaReexport = Effect.gen(function* () {
   const path = yield* Path.Path;
   const confectDirectory = yield* ConfectDirectory.get;
   const convexDirectory = yield* ConvexDirectory.get;
-
-  const confectSchemaPath = path.join(confectDirectory, "schema.ts");
-
-  // `validateSchema` runs once at the top of `runCodegen`; no need to
-  // bundle the schema again here.
+  const generatedConvexSchemaRelativePath = yield* GENERATED_CONVEX_SCHEMA_PATH;
 
   const convexSchemaPath = path.join(convexDirectory, "schema.ts");
+  const generatedConvexSchemaPath = path.join(
+    confectDirectory,
+    generatedConvexSchemaRelativePath,
+  );
 
-  const relativeImportPath = path.relative(
-    path.dirname(convexSchemaPath),
-    confectSchemaPath,
+  const convexSchemaImportPath = yield* toModuleImportPath(
+    path.relative(path.dirname(convexSchemaPath), generatedConvexSchemaPath),
   );
-  const importPathWithoutExt = yield* removePathExtension(relativeImportPath);
+
   const schemaContents = yield* templates.schema({
-    schemaImportPath: importPathWithoutExt,
+    convexSchemaImportPath,
   });
 
   yield* writeFileStringAndLog(convexSchemaPath, schemaContents);
@@ -652,9 +839,12 @@ const generateServices = Effect.gen(function* () {
   const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
 
   const servicesPath = path.join(confectGeneratedDirectory, "services.ts");
-  const schemaImportPath = path.relative(
-    path.dirname(servicesPath),
-    path.join(confectDirectory, "schema"),
+  const generatedSchemaPath = yield* GENERATED_SCHEMA_PATH;
+  const schemaImportPath = yield* toModuleImportPath(
+    path.relative(
+      path.dirname(servicesPath),
+      path.join(confectDirectory, generatedSchemaPath),
+    ),
   );
 
   const servicesContentsString = yield* templates.services({
@@ -672,9 +862,10 @@ const generateRefs = Effect.gen(function* () {
   const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
   const refsPath = path.join(confectGeneratedDirectory, "refs.ts");
   const refsDir = path.dirname(refsPath);
+  const generatedSpecPath = yield* GENERATED_SPEC_PATH;
 
   const specImportPath = yield* toModuleImportPath(
-    path.relative(refsDir, path.join(confectDirectory, GENERATED_SPEC_PATH)),
+    path.relative(refsDir, path.join(confectDirectory, generatedSpecPath)),
   );
 
   const nodeSpecPath = yield* getGeneratedNodeSpecPath;