@confect/cli 9.0.0-next.0 → 9.0.0-next.10

package/dist/confect/codegen.mjs

@@ -1,35 +1,47 @@
-import { logFileAdded, logFileModified, logFileRemoved, logPending, logSuccess } from "../log.mjs";
-import { fromBundlerError } from "../BuildError.mjs";
-import { MissingImplFileError, MissingSchemaFileError, MissingSpecFileError, SchemaInvalidDefaultExportError, tapAndLog } from "../CodegenError.mjs";
+import { logFileAdded, logFileModified, logFileRemoved, logPending, logSuccess, logWarn } from "../log.mjs";
+import { bundle } from "../Bundler.mjs";
+import { LegacySchemaFileError, MissingImplFileError, MissingSpecFileError, ParentChildNameCollisionError, tapAndLog } from "../CodegenError.mjs";
 import { ConvexDirectory } from "../ConvexDirectory.mjs";
 import { ConfectDirectory } from "../ConfectDirectory.mjs";
 import { FunctionPaths, make } from "../FunctionPaths.mjs";
-import { bundle } from "../Bundler.mjs";
-import { assemblyNodesFromLeaves, partitionByRuntime } from "../SpecAssemblyNode.mjs";
-import { api, assembledSpec, nodeApi, refs, registeredFunctionsForGroup, schema, services } from "../templates.mjs";
-import { WriteTracker, generateAuthConfig, generateCrons, generateFunctions, generateHttp, removePathExtension, removePathIfExists, toModuleImportPath, touchConvexSchema, writeFileStringAndLog } from "../utils.mjs";
-import { discoverLeafImplFiles, discoverLeafSpecFiles, implPathForSpec, registeredFunctionsRelativePath, specPathForImpl, toLeafModule, toNodeRegistryLeaf, validateImpl, validateSpec } from "../LeafModule.mjs";
-import { Array, Effect, Either, HashSet, Match, Option, Ref } from "effect";
-import { Command } from "@effect/cli";
+import { assemblyNodesFromLeaves } from "../SpecAssemblyNode.mjs";
+import { assembledSpec, convexSchema, id, refs, registeredFunctionsForGroup, runtimeSchema, schema, services, tableWrapper } from "../templates.mjs";
+import { WriteTracker, generateAuthConfig, generateCrons, generateFunctions, generateHttp, removePathIfExists, toModuleImportPath, touchConvexSchema, writeFileStringAndLog } from "../utils.mjs";
+import { discoverLeafImplFiles, discoverLeafSpecFiles, implPathForSpec, registeredFunctionsRelativePath, specPathForImpl, toLeafModule, validateImpl, validateSpec } from "../LeafModule.mjs";
+import { TABLES_DIRNAME, discover, validate } from "../TableModule.mjs";
+import * as Effect from "effect/Effect";
+import * as Command from "@effect/cli/Command";
 import { Spec } from "@confect/core";
-import * as DatabaseSchema from "@confect/server/DatabaseSchema";
-import { FileSystem, Path } from "@effect/platform";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Array from "effect/Array";
+import * as Either from "effect/Either";
+import * as HashSet from "effect/HashSet";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
 
 //#region src/confect/codegen.ts
-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_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"),
+		path.join(GENERATED_DIRNAME, "nodeSpec.ts")
+	];
+});
 const codegen = Command.make("codegen", {}, () => Effect.gen(function* () {
 	yield* logPending("Performing initial sync…");
 	yield* codegenHandler.pipe(Effect.asVoid, Effect.tap(() => logSuccess("Generated files are up-to-date")), tapAndLog);
@@ -43,22 +55,31 @@ const codegenHandler = Effect.gen(function* () {
 });
 const runCodegen = Effect.gen(function* () {
 	yield* generateConfectGeneratedDirectory;
-	yield* validateSchema;
-	const leaves = yield* loadAndValidateLeafModules;
+	yield* rejectLegacySchemaFile;
+	const tableModules = yield* discover;
+	yield* warnIfNoTables(tableModules);
+	yield* generateIdConstructor(tableModules);
+	yield* 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);
 	yield* Effect.all([
-		generateApi,
+		removeGeneratedApi,
 		generateRefs,
-		generateNodeApi,
-		generateServices
+		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)
@@ -80,20 +101,90 @@ const loadAndValidateLeafModules = Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
 	const specFiles = yield* discoverLeafSpecFiles;
-	const leaves = yield* Effect.forEach(specFiles, (specRelativePath) => Effect.gen(function* () {
-		const leaf = yield* toLeafModule(specRelativePath);
-		yield* validateSpec(leaf);
+	const results = yield* Effect.forEach(specFiles, (specRelativePath) => Effect.gen(function* () {
+		const discovered = yield* toLeafModule(specRelativePath);
+		const groupSpec = yield* validateSpec(discovered);
+		const leaf = {
+			...discovered,
+			runtime: Option.some(groupSpec.runtime)
+		};
 		const implRelativePath = yield* implPathForSpec(specRelativePath);
 		const implAbsolutePath = path.join(confectDirectory, implRelativePath);
 		if (!(yield* fs.exists(implAbsolutePath))) return yield* new MissingImplFileError({
 			specPath: specRelativePath,
 			expectedImplPath: implRelativePath
 		});
-		return leaf;
+		return {
+			leaf,
+			groupSpec
+		};
 	}));
 	yield* validateOrphanImpls(specFiles);
-	return leaves;
+	return {
+		leaves: Array.map(results, ({ leaf }) => leaf),
+		groupSpecsByRelativePath: new Map(Array.map(results, ({ leaf, groupSpec }) => [leaf.relativePath, groupSpec]))
+	};
+});
+/**
+* Walk the assembly tree and fail with a {@link ParentChildNameCollisionError}
+* when a parent leaf declares a function or subgroup whose name matches a
+* sibling subdirectory spec's segment. Without this check the colliding
+* descendant would overwrite the parent's entry in the assembled
+* `GroupSpec.groups` map at runtime, surfacing as a confusing
+* `Refs.make` error rather than a codegen-time diagnostic.
+*/
+const validateNoParentChildNameCollisions = (leaves, groupSpecsByRelativePath) => Effect.gen(function* () {
+	const nodes = assemblyNodesFromLeaves(leaves);
+	yield* Effect.forEach(nodes, (n) => checkAssemblyNodeForCollisions(n, groupSpecsByRelativePath));
+});
+const checkAssemblyNodeForCollisions = (node, groupSpecsByRelativePath) => Effect.gen(function* () {
+	yield* Option.match(node.importBinding, {
+		onNone: () => Effect.void,
+		onSome: (binding) => Effect.gen(function* () {
+			if (node.children.length === 0) return;
+			const parentRelativePath = bindingToRelativeSpecPath(binding.importPath);
+			const parentGroupSpec = groupSpecsByRelativePath.get(parentRelativePath);
+			if (parentGroupSpec === void 0) return;
+			yield* Effect.forEach(node.children, (child) => {
+				if (Object.prototype.hasOwnProperty.call(parentGroupSpec.functions, child.segment)) return Effect.fail(new ParentChildNameCollisionError({
+					parentSpecPath: parentRelativePath,
+					childSpecPath: childRepresentativeSpecPath(child),
+					collisionName: child.segment,
+					collisionKind: "function"
+				}));
+				if (Object.prototype.hasOwnProperty.call(parentGroupSpec.groups, child.segment)) return Effect.fail(new ParentChildNameCollisionError({
+					parentSpecPath: parentRelativePath,
+					childSpecPath: childRepresentativeSpecPath(child),
+					collisionName: child.segment,
+					collisionKind: "group"
+				}));
+				return Effect.void;
+			});
+		})
+	});
+	yield* Effect.forEach(node.children, (child) => checkAssemblyNodeForCollisions(child, groupSpecsByRelativePath));
 });
+/**
+* `LeafModule.specImportPath` is the import path used from inside the
+* generated `_generated/spec.ts` (e.g. `"../notes.spec"`). Strip the
+* `../` prefix and re-add the `.ts` extension to recover the leaf's
+* confect-relative spec path used as the key in
+* `groupSpecsByRelativePath`.
+*/
+const bindingToRelativeSpecPath = (importPath) => {
+	return `${importPath.startsWith("../") ? importPath.slice(3) : importPath}.ts`;
+};
+/**
+* A child assembly node may itself be a parent without a leaf (when the
+* actual leaves live only in deeper subdirectories). In that case we
+* surface the first descendant leaf as a representative path so the
+* error message points at something the user actually wrote.
+*/
+const childRepresentativeSpecPath = (node) => {
+	if (Option.isSome(node.importBinding)) return bindingToRelativeSpecPath(node.importBinding.value.importPath);
+	for (const child of node.children) return childRepresentativeSpecPath(child);
+	return node.segment;
+};
 const validateOrphanImpls = (specFiles) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
@@ -114,7 +205,8 @@ const removeLegacyFiles = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
-	yield* Effect.forEach(LEGACY_PATHS, (relativePath) => Effect.gen(function* () {
+	const legacyPaths = yield* LEGACY_PATHS;
+	yield* Effect.forEach(legacyPaths, (relativePath) => Effect.gen(function* () {
 		const absolutePath = path.join(confectDirectory, relativePath);
 		if (yield* fs.exists(absolutePath)) {
 			yield* removePathIfExists(absolutePath);
@@ -125,23 +217,10 @@ const removeLegacyFiles = Effect.gen(function* () {
 const generateAssembledSpecs = (leaves) => Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
-	const { convex, node } = partitionByRuntime(leaves);
-	if (convex.length > 0) {
-		const nodes = assemblyNodesFromLeaves(convex);
-		const specContents = yield* assembledSpec({
-			nodes,
-			runtime: "Convex"
-		});
-		yield* writeFileStringAndLog(path.join(confectDirectory, GENERATED_SPEC_PATH), specContents);
-	}
-	if (node.length > 0) {
-		const nodes = assemblyNodesFromLeaves(Array.map(node, toNodeRegistryLeaf));
-		const nodeSpecContents = yield* assembledSpec({
-			nodes,
-			runtime: "Node"
-		});
-		yield* writeFileStringAndLog(path.join(confectDirectory, GENERATED_NODE_SPEC_PATH), nodeSpecContents);
-	}
+	const generatedSpecPath = yield* GENERATED_SPEC_PATH;
+	const nodes = assemblyNodesFromLeaves(leaves);
+	const specContents = yield* assembledSpec({ nodes });
+	yield* writeFileStringAndLog(path.join(confectDirectory, generatedSpecPath), specContents);
 });
 const validateImplModules = (leaves) => Effect.forEach(leaves, validateImpl);
 const generateGroupRegisteredFunctions = (leaves) => Effect.gen(function* () {
@@ -154,15 +233,19 @@ const generateGroupRegisteredFunctions = (leaves) => Effect.gen(function* () {
 		const fs = yield* FileSystem.FileSystem;
 		if (!(yield* fs.exists(registryDir))) yield* fs.makeDirectory(registryDir, { recursive: true });
 		const implRelativePath = yield* implPathForSpec(leaf.relativePath);
-		const apiFileName = leaf.runtime === "Node" ? "nodeApi.ts" : "api.ts";
-		const apiImportPath = yield* toModuleImportPath(path.relative(path.dirname(registryPath), path.join(confectDirectory, "_generated", apiFileName)));
+		const schemaImportPath = yield* toModuleImportPath(path.relative(path.dirname(registryPath), path.join(confectDirectory, "_generated", "schema.ts")));
+		const specImportPath = yield* toModuleImportPath(path.relative(path.dirname(registryPath), path.join(confectDirectory, leaf.relativePath)));
 		const implImportPath = yield* toModuleImportPath(path.relative(path.dirname(registryPath), path.join(confectDirectory, implRelativePath)));
+		const runtime = yield* Option.match(leaf.runtime, {
+			onNone: () => Effect.dieMessage(`Runtime for '${leaf.relativePath}' was not resolved before registry generation.`),
+			onSome: Effect.succeed
+		});
 		yield* writeFileStringAndLog(registryPath, yield* registeredFunctionsForGroup({
-			apiImportPath,
-			groupPathDot: leaf.registryGroupPathDot,
+			schemaImportPath,
+			specImportPath,
 			implImportPath,
 			layerExportName: leaf.exportName,
-			useNode: leaf.runtime === "Node"
+			useNode: runtime === "Node"
 		}));
 	}));
 });
@@ -190,130 +273,178 @@ const removeObsoleteRegisteredFunctions = (leaves) => Effect.gen(function* () {
 const getGeneratedSpecPath = Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
-	return path.join(confectDirectory, GENERATED_SPEC_PATH);
-});
-const getGeneratedNodeSpecPath = Effect.gen(function* () {
-	const path = yield* Path.Path;
-	const confectDirectory = yield* ConfectDirectory.get;
-	return path.join(confectDirectory, GENERATED_NODE_SPEC_PATH);
+	const generatedSpecPath = yield* GENERATED_SPEC_PATH;
+	return path.join(confectDirectory, generatedSpecPath);
 });
 const loadGeneratedSpec = Effect.gen(function* () {
 	const specPath = yield* getGeneratedSpecPath;
 	const { module: specModule } = yield* bundle(specPath);
 	const spec = specModule.default;
-	if (!Spec.isConvexSpec(spec)) return yield* Effect.dieMessage("_generated/spec.ts does not export a valid Convex Spec");
+	if (!Spec.isSpec(spec)) return yield* Effect.dieMessage("_generated/spec.ts does not export a valid Spec");
 	return spec;
 });
-const loadGeneratedNodeSpec = Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	const nodeSpecPath = yield* getGeneratedNodeSpecPath;
-	if (!(yield* fs.exists(nodeSpecPath))) return Option.none();
-	const { module: nodeSpecModule } = yield* bundle(nodeSpecPath);
-	const nodeSpec = nodeSpecModule.default;
-	if (!Spec.isNodeSpec(nodeSpec)) return yield* Effect.dieMessage("_generated/nodeSpec.ts does not export a valid Node Spec");
-	return Option.some(nodeSpec);
-});
 const emptyFunctionPaths = FunctionPaths.make(HashSet.empty());
 const loadPreviousFunctionPaths = Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const specPath = yield* getGeneratedSpecPath;
 	if (!(yield* fs.exists(specPath))) return emptyFunctionPaths;
 	const specEither = yield* loadGeneratedSpec.pipe(Effect.either);
-	return yield* Either.match(specEither, {
-		onLeft: () => Effect.succeed(emptyFunctionPaths),
-		onRight: (spec) => Effect.gen(function* () {
-			const nodeSpecOption = yield* loadGeneratedNodeSpec;
-			const mergedSpec = Option.match(nodeSpecOption, {
-				onNone: () => spec,
-				onSome: (nodeSpec) => Spec.merge(spec, nodeSpec)
-			});
-			return make(mergedSpec);
-		})
+	return Either.match(specEither, {
+		onLeft: () => emptyFunctionPaths,
+		onRight: (spec) => make(spec)
 	});
 });
-const generateApi = Effect.gen(function* () {
+/**
+* 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) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
-	const apiPath = path.join(confectDirectory, "_generated", "api.ts");
-	const apiDir = path.dirname(apiPath);
-	const schemaImportPath = yield* toModuleImportPath(path.relative(apiDir, path.join(confectDirectory, "schema.ts")));
-	const specImportPath = yield* toModuleImportPath(path.relative(apiDir, path.join(confectDirectory, GENERATED_SPEC_PATH)));
-	yield* writeFileStringAndLog(apiPath, yield* api({
-		schemaImportPath,
-		specImportPath
-	}));
+	const filePath = path.join(confectDirectory, "_generated", fileName);
+	if (yield* fs.exists(filePath)) {
+		yield* removePathIfExists(filePath);
+		yield* logFileRemoved(filePath);
+	}
 });
-const generateNodeApi = Effect.gen(function* () {
+const removeGeneratedApi = removeObsoleteGeneratedFile("api.ts");
+const removeGeneratedNodeApi = removeObsoleteGeneratedFile("nodeApi.ts");
+const generateFunctionModules = Effect.gen(function* () {
+	return yield* generateFunctions(yield* loadGeneratedSpec);
+});
+/**
+* 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 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;
-	}
-	const nodeApiDir = path.dirname(nodeApiPath);
-	const schemaImportPath = yield* toModuleImportPath(path.relative(nodeApiDir, path.join(confectDirectory, "schema.ts")));
-	const nodeSpecImportPath = yield* toModuleImportPath(path.relative(nodeApiDir, nodeSpecPath));
-	yield* writeFileStringAndLog(nodeApiPath, yield* nodeApi({
-		schemaImportPath,
-		nodeSpecImportPath
-	}));
+	const legacyPath = path.join(confectDirectory, "schema.ts");
+	if (yield* fs.exists(legacyPath)) return yield* new LegacySchemaFileError({ schemaPath: "schema.ts" });
 });
-const generateFunctionModules = Effect.gen(function* () {
-	const spec = yield* loadGeneratedSpec;
-	const nodeSpecOption = yield* loadGeneratedNodeSpec;
-	return yield* generateFunctions(Option.match(nodeSpecOption, {
-		onNone: () => spec,
-		onSome: (nodeSpec) => Spec.merge(spec, nodeSpec)
+/**
+* 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) => tableModules.length === 0 ? logWarn(`No tables discovered in \`confect/${TABLES_DIRNAME}/\`. Generating an empty schema; add a \`Table.make(...)\` module under that directory unless this backend is intentionally tables-free.`) : Effect.void;
+const tableModuleBindings = (tableModules, generatedFilePath) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const confectDirectory = yield* ConfectDirectory.get;
+	const generatedDir = path.dirname(generatedFilePath);
+	const generatedTablesDirname = yield* GENERATED_TABLES_DIRNAME;
+	return yield* Effect.forEach(tableModules, (tm) => Effect.gen(function* () {
+		const wrapperAbsolutePath = path.join(confectDirectory, generatedTablesDirname, `${tm.tableName}.ts`);
+		return {
+			importPath: yield* toModuleImportPath(path.relative(generatedDir, wrapperAbsolutePath)),
+			tableName: tm.tableName
+		};
 	}));
 });
-const validateSchema = Effect.gen(function* () {
+const generateIdConstructor = (tableModules) => 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 tableNames = tableModules.map((tm) => tm.tableName);
+	yield* writeFileStringAndLog(idPath, yield* id({ tableNames }));
+});
+const generateTableWrappers = (tableModules) => 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");
-	if (!(yield* fs.exists(confectSchemaPath))) return yield* new MissingSchemaFileError({ schemaPath: "schema.ts" });
-	yield* 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" }));
-	}));
+	const generatedTablesDirname = yield* GENERATED_TABLES_DIRNAME;
+	const wrappersDir = path.join(confectDirectory, generatedTablesDirname);
+	if (!(yield* fs.exists(wrappersDir))) yield* fs.makeDirectory(wrappersDir, { recursive: true });
+	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));
+		yield* writeFileStringAndLog(wrapperPath, yield* tableWrapper({
+			tableName: tm.tableName,
+			unnamedImportPath
+		}));
+	}), { concurrency: "unbounded" });
+});
+/**
+* Remove any stale `_generated/tables/*.ts` wrapper whose source table
+* has been deleted or renamed. Mirrors `removeObsoleteRegisteredFunctions`
+* for the wrapper directory.
+*/
+const removeObsoleteTableWrappers = (tableModules) => 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 generateSchema = Effect.gen(function* () {
+const generateRuntimeSchema = (tableModules) => 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);
+	yield* writeFileStringAndLog(schemaPath, yield* runtimeSchema({ tableModules: bindings }));
+});
+const generateConvexSchema = (tableModules) => 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);
+	yield* writeFileStringAndLog(convexSchemaPath, yield* convexSchema({ tableModules: bindings }));
+});
+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");
+	const generatedConvexSchemaRelativePath = yield* GENERATED_CONVEX_SCHEMA_PATH;
 	const convexSchemaPath = path.join(convexDirectory, "schema.ts");
-	const importPathWithoutExt = yield* removePathExtension(path.relative(path.dirname(convexSchemaPath), confectSchemaPath));
-	yield* writeFileStringAndLog(convexSchemaPath, yield* schema({ schemaImportPath: importPathWithoutExt }));
+	const generatedConvexSchemaPath = path.join(confectDirectory, generatedConvexSchemaRelativePath);
+	const convexSchemaImportPath = yield* toModuleImportPath(path.relative(path.dirname(convexSchemaPath), generatedConvexSchemaPath));
+	yield* writeFileStringAndLog(convexSchemaPath, yield* schema({ convexSchemaImportPath }));
 });
 const generateServices = Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
 	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)));
 	yield* writeFileStringAndLog(servicesPath, yield* services({ schemaImportPath }));
 });
 const generateRefs = Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const confectDirectory = yield* ConfectDirectory.get;
 	const confectGeneratedDirectory = path.join(confectDirectory, "_generated");
 	const refsPath = path.join(confectGeneratedDirectory, "refs.ts");
 	const refsDir = path.dirname(refsPath);
-	const specImportPath = yield* toModuleImportPath(path.relative(refsDir, path.join(confectDirectory, GENERATED_SPEC_PATH)));
-	const nodeSpecPath = yield* getGeneratedNodeSpecPath;
-	const nodeSpecImportPath = (yield* fs.exists(nodeSpecPath)) ? Option.some(yield* toModuleImportPath(path.relative(refsDir, nodeSpecPath))) : Option.none();
-	yield* writeFileStringAndLog(refsPath, yield* refs({
-		specImportPath,
-		nodeSpecImportPath
-	}));
+	const generatedSpecPath = yield* GENERATED_SPEC_PATH;
+	const specImportPath = yield* toModuleImportPath(path.relative(refsDir, path.join(confectDirectory, generatedSpecPath)));
+	yield* writeFileStringAndLog(refsPath, yield* refs({ specImportPath }));
 });
 const logGenerated = (effect) => effect.pipe(Effect.tap(Option.match({
 	onNone: () => Effect.void,