@lunora/codegen 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/index.d.mts

@@ -855,7 +855,7 @@ declare const discoverRlsMetadata: (project: Project, lunoraDirectory: string) =
 * Load `<projectRoot>/lunora/schema.ts`, find `defineSchema({...})`, and
 * return a structural IR. Throws if the file or call cannot be found.
 */
-declare const discoverSchema: (project: Project, schemaPath: string) => SchemaIR;
+declare const discoverSchema: (project: Project, schemaPath: string, projectRoot?: string) => SchemaIR;
 /**
 * Aggregate the schema-wide storage-rule metadata the studio's inspector reads:
 * every statically-discovered `(bucket, on, prefix, procedure)` entry across all

package/dist/index.d.ts

@@ -855,7 +855,7 @@ declare const discoverRlsMetadata: (project: Project, lunoraDirectory: string) =
 * Load `<projectRoot>/lunora/schema.ts`, find `defineSchema({...})`, and
 * return a structural IR. Throws if the file or call cannot be found.
 */
-declare const discoverSchema: (project: Project, schemaPath: string) => SchemaIR;
+declare const discoverSchema: (project: Project, schemaPath: string, projectRoot?: string) => SchemaIR;
 /**
 * Aggregate the schema-wide storage-rule metadata the studio's inspector reads:
 * every statically-discovered `(bucket, on, prefix, procedure)` entry across all

package/dist/index.mjs

@@ -5,21 +5,21 @@ export { CONTAINERS_FILENAME, discoverContainers } from './packem_shared/CONTAIN
 export { default as discoverCrons } from './packem_shared/discoverCrons-BL6iGuJ3.mjs';
 export { discoverFunctions } from './packem_shared/discoverFunctions-DEgAcRuD.mjs';
 export { default as discoverHttpRoutes } from './packem_shared/discoverHttpRoutes-C978pBiG.mjs';
-export { default as discoverInserts } from './packem_shared/discoverInserts-CRQdXvHO.mjs';
+export { default as discoverInserts } from './packem_shared/discoverInserts-pLBFsSAV.mjs';
 export { default as discoverMaskProcedures } from './packem_shared/discoverMaskProcedures-B64zA740.mjs';
 export { default as discoverMigrations } from './packem_shared/discoverMigrations-Doj_-BAA.mjs';
 export { default as discoverNondeterministicCalls } from './packem_shared/discoverNondeterministicCalls-4KiPQxQU.mjs';
 export { default as discoverQueries } from './packem_shared/discoverQueries-BkIi0dBD.mjs';
 export { default as discoverR2sqlCalls } from './packem_shared/discoverR2sqlCalls-BpDqvcUn.mjs';
 export { discoverRlsMetadata, default as discoverRlsProcedures } from './packem_shared/discoverRlsMetadata-DpRB1HMe.mjs';
-export { default as discoverSchema } from './packem_shared/discoverSchema-DB_QrIQe.mjs';
+export { default as discoverSchema } from './packem_shared/discoverSchema-DYl0QfDH.mjs';
 export { default as discoverStorageRulesMetadata } from './packem_shared/discoverStorageRulesMetadata-DAqJUxUv.mjs';
 export { WORKFLOWS_FILENAME, discoverWorkflows } from './packem_shared/WORKFLOWS_FILENAME-DRDQdhfq.mjs';
 export { GENERATED_HEADER, emitApi, emitContainers, emitCrons, emitDataModel, emitDrizzleSchema, emitFunctions, emitServer, emitShard, emitVectors, emitWorkflows, emitWranglerCronTriggers } from './packem_shared/GENERATED_HEADER-DF1hQcix.mjs';
 export { emitApp } from './packem_shared/emitApp-Ci_hcJNO.mjs';
 export { buildOpenApiDocument, emitOpenApi, emitOpenApiModule } from './packem_shared/buildOpenApiDocument-Cns1EkCQ.mjs';
 export { OPENRPC_VERSION, buildOpenRpcDocument, emitOpenRpc, emitOpenRpcModule } from './packem_shared/OPENRPC_VERSION-C7zKVeKi.mjs';
-export { SCHEMA_SNAPSHOT_FILENAME, createCodegenProject, refreshCodegenProject, runCodegen } from './packem_shared/SCHEMA_SNAPSHOT_FILENAME-BqOtU2lC.mjs';
+export { SCHEMA_SNAPSHOT_FILENAME, createCodegenProject, refreshCodegenProject, runCodegen } from './packem_shared/SCHEMA_SNAPSHOT_FILENAME-g7kpX8hu.mjs';
 export { SCHEMA_SNAPSHOT_VERSION, SchemaSnapshotParseError, buildSchemaSnapshot, diffSchemaSnapshots, evaluateSchemaDrift, parseSchemaSnapshot, serializeSchemaSnapshot } from './packem_shared/SCHEMA_SNAPSHOT_VERSION-DzLDbWk3.mjs';
 export { schemaFromIr } from './packem_shared/schemaFromIr-DTYsLBaA.mjs';
 export { LUNORA_ERROR_CODES, validatorIrToJsonSchema } from './packem_shared/LUNORA_ERROR_CODES-CySpQPD3.mjs';

package/dist/packem_shared/{SCHEMA_SNAPSHOT_FILENAME-BqOtU2lC.mjs → SCHEMA_SNAPSHOT_FILENAME-g7kpX8hu.mjs}

@@ -7,14 +7,14 @@ import discoverAuthApiCalls from './discoverAuthApiCalls-C35R6z0T.mjs';
 import { discoverContainers } from './CONTAINERS_FILENAME-0K-pjNb8.mjs';
 import discoverCrons from './discoverCrons-BL6iGuJ3.mjs';
 import discoverHttpRoutes from './discoverHttpRoutes-C978pBiG.mjs';
-import discoverInserts from './discoverInserts-CRQdXvHO.mjs';
+import discoverInserts from './discoverInserts-pLBFsSAV.mjs';
 import discoverMaskProcedures, { discoverMaskMetadata } from './discoverMaskProcedures-B64zA740.mjs';
 import discoverMigrations from './discoverMigrations-Doj_-BAA.mjs';
 import discoverNondeterministicCalls from './discoverNondeterministicCalls-4KiPQxQU.mjs';
 import discoverQueries from './discoverQueries-BkIi0dBD.mjs';
 import discoverR2sqlCalls from './discoverR2sqlCalls-BpDqvcUn.mjs';
 import discoverRlsProcedures, { discoverRlsMetadata } from './discoverRlsMetadata-DpRB1HMe.mjs';
-import discoverSchema from './discoverSchema-DB_QrIQe.mjs';
+import discoverSchema from './discoverSchema-DYl0QfDH.mjs';
 import discoverStorageRulesMetadata from './discoverStorageRulesMetadata-DAqJUxUv.mjs';
 import { e as enclosingExportName$1 } from './discover-ast-CT6BgBr4.mjs';
 import { discoverWorkflows } from './WORKFLOWS_FILENAME-DRDQdhfq.mjs';
@@ -723,7 +723,7 @@ const runCodegen = (options) => {
     throw new Error(`schema.ts not found at ${schemaPath}`);
   }
   const project = options.project ?? createCodegenProject(lunoraDirectory);
-  const schema = discoverSchema(project, schemaPath);
+  const schema = discoverSchema(project, schemaPath, options.projectRoot);
   const functions = discoverFunctions(project, lunoraDirectory);
   const httpRoutes = discoverHttpRoutes(project, lunoraDirectory);
   const migrations = discoverMigrations(project, lunoraDirectory);

package/dist/packem_shared/{discoverInserts-CRQdXvHO.mjs → discoverInserts-pLBFsSAV.mjs}

@@ -13,9 +13,31 @@ const isDatabaseInsertCall = (call) => {
   }
   return Node.isIdentifier(receiver) && receiver.getText() === "db";
 };
+const resolveStringConst = (identifier) => {
+  if (!Node.isIdentifier(identifier)) {
+    return void 0;
+  }
+  const symbol = identifier.getSymbol();
+  const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
+  for (const declaration of declarations) {
+    if (Node.isVariableDeclaration(declaration)) {
+      const initializer = declaration.getInitializer();
+      if (initializer && Node.isStringLiteral(initializer)) {
+        return initializer.getLiteralText();
+      }
+    }
+  }
+  return void 0;
+};
 const tableOf = (call) => {
   const argument = call.getArguments()[0];
-  return argument && Node.isStringLiteral(argument) ? argument.getLiteralText() : "";
+  if (!argument) {
+    return "";
+  }
+  if (Node.isStringLiteral(argument)) {
+    return argument.getLiteralText();
+  }
+  return resolveStringConst(argument) ?? "";
 };
 const discoverInserts = (project, lunoraDirectory) => {
   const writes = [];

package/dist/packem_shared/{discoverSchema-DB_QrIQe.mjs → discoverSchema-DYl0QfDH.mjs}

@@ -1,6 +1,212 @@
-import { SyntaxKind, Node } from 'ts-morph';
+import { Node, SyntaxKind } from 'ts-morph';
 import { diagnosticAt } from './CodegenDiagnosticError-54jWDxA9.mjs';
 import { a as parseObjectShape } from './parse-validator-tuQtHrsr.mjs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+
+const renderLiteralValue = (value) => {
+  switch (typeof value) {
+    case "bigint": {
+      return value.toString();
+    }
+    case "boolean":
+    case "number": {
+      return String(value);
+    }
+    case "string": {
+      return JSON.stringify(value);
+    }
+    default: {
+      return value === null ? "null" : void 0;
+    }
+  }
+};
+const columnMetaToIR = (column) => {
+  const hasDefault = column?.["defaultValue"] !== void 0 || column?.["defaultFn"] !== void 0 || column?.["serverDefault"] !== void 0;
+  return {
+    ...hasDefault ? { hasDefault: true } : {},
+    ...column?.["onUpdateFn"] === void 0 ? {} : { hasOnUpdate: true },
+    notNull: column?.["notNull"] ?? true,
+    ...column?.["unique"] === true ? { unique: true } : {}
+  };
+};
+const runtimeValidatorToIR = (validator) => {
+  const meta = validator?._meta ?? {};
+  const kind = validator?.kind ?? "unknown";
+  const ir = { column: columnMetaToIR(meta["column"]), kind };
+  switch (kind) {
+    case "array":
+    case "optional": {
+      ir.inner = runtimeValidatorToIR(meta["inner"]);
+      break;
+    }
+    case "id": {
+      ir.tableName = meta["tableName"];
+      break;
+    }
+    case "literal": {
+      ir.literalValue = renderLiteralValue(meta["value"]);
+      break;
+    }
+    case "object": {
+      const shape = meta["shape"] ?? {};
+      ir.shape = Object.fromEntries(Object.entries(shape).map(([name, child]) => [name, runtimeValidatorToIR(child)]));
+      break;
+    }
+    case "record": {
+      ir.valueType = runtimeValidatorToIR(meta["valueValidator"]);
+      if (meta["keyValidator"] !== void 0) {
+        ir.keyType = runtimeValidatorToIR(meta["keyValidator"]);
+      }
+      break;
+    }
+    case "storage": {
+      if (typeof meta["bucket"] === "string") {
+        ir.bucket = meta["bucket"];
+      }
+      break;
+    }
+    case "union": {
+      const members = meta["members"] ?? [];
+      ir.members = members.map((member) => runtimeValidatorToIR(member));
+      break;
+    }
+  }
+  return ir;
+};
+const shardModeToIR = (shardMode) => {
+  if (shardMode?.kind === "global") {
+    return "global";
+  }
+  if (shardMode?.kind === "shardBy" && typeof shardMode.field === "string") {
+    return { field: shardMode.field, kind: "shardBy" };
+  }
+  return "root";
+};
+const warnDroppedTableFeatures = (builder, bareName) => {
+  const dropped = [];
+  if (builder.relationMap && Object.keys(builder.relationMap).length > 0) {
+    dropped.push("relations");
+  }
+  if (builder.rankIndexes && builder.rankIndexes.length > 0) {
+    dropped.push("rank indexes");
+  }
+  if (builder.vectorIndexes && builder.vectorIndexes.length > 0) {
+    dropped.push("vector indexes");
+  }
+  if (dropped.length > 0) {
+    console.warn(
+      `@lunora/codegen: package schema-extension table "${bareName}" declares ${dropped.join(" + ")}, which are not yet introspected from a node_modules extension — they will be absent from the generated types.`
+    );
+  }
+};
+const runtimeTableToIR = (builder, bareName) => {
+  const shape = builder.shape ?? {};
+  const indexes = (builder.indexes ?? []).map((index) => {
+    return { fields: index.fields, name: index.name, ...index.unique ? { unique: true } : {} };
+  });
+  warnDroppedTableFeatures(builder, bareName);
+  return {
+    ...builder.isExternallyManaged ? { externallyManaged: true } : {},
+    indexes,
+    name: bareName,
+    rankIndexes: [],
+    relations: [],
+    searchIndexes: (builder.searchIndexes ?? []).map((index) => {
+      return {
+        field: index.field,
+        ...index.filterFields ? { filterFields: index.filterFields } : {},
+        name: index.name
+      };
+    }),
+    shape: Object.fromEntries(Object.entries(shape).map(([name, validator]) => [name, runtimeValidatorToIR(validator)])),
+    shardMode: shardModeToIR(builder.shardMode),
+    // Inline vector/rank indexes and relations are not yet introspected from a
+    // package extension; their presence is surfaced via `warnDroppedTableFeatures`.
+    vectorIndexes: []
+  };
+};
+const resolvedExtensionToIR = (value) => {
+  const { key, tables } = value;
+  if (typeof key !== "string" || typeof tables !== "object" || tables === null) {
+    return void 0;
+  }
+  const bareTables = Object.entries(tables).map(([bareName, builder]) => runtimeTableToIR(builder, bareName));
+  const vectorIndexes = value["vectorIndexes"] ?? {};
+  const bareVectorIndexes = Object.entries(vectorIndexes ?? {}).map(([name, index]) => {
+    return {
+      ...index.dimensions === void 0 ? {} : { dimensions: index.dimensions },
+      ...index.field === void 0 ? {} : { field: index.field },
+      ...index.metadata === void 0 ? {} : { metadata: index.metadata },
+      ...index.metric === void 0 ? {} : { metric: index.metric },
+      name,
+      table: index.table ?? ""
+    };
+  });
+  return { bareTables, bareVectorIndexes, key };
+};
+const receiverIdentifierText = (argument) => {
+  if (Node.isIdentifier(argument)) {
+    return argument.getText();
+  }
+  if (Node.isPropertyAccessExpression(argument)) {
+    const receiver = argument.getExpression();
+    return Node.isIdentifier(receiver) ? receiver.getText() : void 0;
+  }
+  return void 0;
+};
+const accessPathOf = (argument) => {
+  const receiverName = receiverIdentifierText(argument);
+  if (receiverName === void 0) {
+    return void 0;
+  }
+  const property = Node.isPropertyAccessExpression(argument) ? argument.getName() : void 0;
+  const propertyPath = property === void 0 ? [] : [property];
+  for (const declaration of argument.getSourceFile().getImportDeclarations()) {
+    const moduleSpecifier = declaration.getModuleSpecifierValue();
+    for (const named of declaration.getNamedImports()) {
+      const localName = named.getAliasNode()?.getText() ?? named.getName();
+      if (localName === receiverName) {
+        return { importedName: named.getName(), moduleSpecifier, propertyPath };
+      }
+    }
+    if (declaration.getDefaultImport()?.getText() === receiverName) {
+      return { importedName: "default", moduleSpecifier, propertyPath };
+    }
+    if (declaration.getNamespaceImport()?.getText() === receiverName && property !== void 0) {
+      return { importedName: property, moduleSpecifier, propertyPath: [] };
+    }
+  }
+  return void 0;
+};
+const readExtensionValue = (module_, access) => {
+  let current = module_[access.importedName];
+  for (const segment of access.propertyPath) {
+    if (typeof current !== "object" || current === null) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+};
+const resolvePackageExtension = (argument, projectRoot) => {
+  const access = accessPathOf(argument);
+  if (!access) {
+    return void 0;
+  }
+  try {
+    const projectRequire = createRequire(join(projectRoot, "noop.cjs"));
+    const resolved = projectRequire.resolve(access.moduleSpecifier);
+    const loadedModule = projectRequire(resolved);
+    const value = readExtensionValue(loadedModule, access);
+    if (typeof value !== "object" || value === null) {
+      return void 0;
+    }
+    return resolvedExtensionToIR(value);
+  } catch {
+    return void 0;
+  }
+};
 
 const VECTOR_METRICS = /* @__PURE__ */ new Set(["cosine", "dot-product", "euclidean"]);
 const ON_DELETE_ACTIONS = /* @__PURE__ */ new Set(["cascade", "restrict", "set null"]);
@@ -455,24 +661,30 @@ const parseExtensionVectorIndexes = (options) => {
   }
   return parseStandaloneVectorIndexes(object);
 };
-const mergeExtension = (key, options) => {
-  const bareTables = parseExtensionTables(options);
+const namespaceExtension = (key, bareTables, bareVectorIndexes) => {
   const bareNames = new Set(bareTables.map((table) => table.name));
   const tables = bareTables.map((table) => namespaceExtensionTable(table, key, bareNames));
-  const vectorIndexes = parseExtensionVectorIndexes(options).map((index) => {
+  const vectorIndexes = bareVectorIndexes.map((index) => {
     return { ...index, name: prefixTableName(key, index.name), table: rewriteReference(index.table, key, bareNames) };
   });
   return { tables, vectorIndexes };
 };
-const mergeExtendCall = (extendCall) => {
+const mergeExtension = (key, options) => namespaceExtension(key, parseExtensionTables(options), parseExtensionVectorIndexes(options));
+const mergeExtendCall = (extendCall, projectRoot) => {
   const extendArgument = extendCall.getArguments()[0];
   if (!extendArgument) {
     return void 0;
   }
   const resolved = resolveSchemaExtensionCall(extendArgument);
   if (!resolved) {
+    if (projectRoot !== void 0) {
+      const fromPackage = resolvePackageExtension(extendArgument, projectRoot);
+      if (fromPackage) {
+        return namespaceExtension(fromPackage.key, fromPackage.bareTables, fromPackage.bareVectorIndexes);
+      }
+    }
     console.warn(
-      `@lunora/codegen: skipping \`.extend(${extendArgument.getText()})\` — its \`defineSchemaExtension(...)\` definition could not be resolved from local sources (cross-package node_modules/.d.ts resolution is a deferred phase). Extension tables will be absent from the generated types.`
+      `@lunora/codegen: skipping \`.extend(${extendArgument.getText()})\` — its \`defineSchemaExtension(...)\` could not be resolved from local sources, and ${projectRoot === void 0 ? "no project root was available to resolve the package" : "the package could not be imported/introspected"}. Extension tables will be absent from the generated types.`
     );
     return void 0;
   }
@@ -517,11 +729,11 @@ const parseBaseTables = (object) => {
   }
   return tables;
 };
-const applyExtensions = (defineSchemaCall, tables) => {
+const applyExtensions = (defineSchemaCall, tables, projectRoot) => {
   const existingTableNames = new Set(tables.map((table) => table.name));
   const vectorIndexes = [];
   for (const extendCall of extendCallsOf(defineSchemaCall)) {
-    const merged = mergeExtendCall(extendCall);
+    const merged = mergeExtendCall(extendCall, projectRoot);
     if (!merged) {
       continue;
     }
@@ -539,7 +751,7 @@ const applyExtensions = (defineSchemaCall, tables) => {
   }
   return vectorIndexes;
 };
-const discoverSchema = (project, schemaPath) => {
+const discoverSchema = (project, schemaPath, projectRoot) => {
   const file = project.addSourceFileAtPath(schemaPath);
   const defineSchemaCall = file.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => {
     const callee = call.getExpression();
@@ -555,7 +767,7 @@ const discoverSchema = (project, schemaPath) => {
   const tables = parseBaseTables(argument);
   const standaloneArgument = defineSchemaCall.getArguments()[1];
   const standaloneVectorIndexes = standaloneArgument && Node.isObjectLiteralExpression(standaloneArgument) ? parseStandaloneVectorIndexes(standaloneArgument) : [];
-  const extensionStandaloneVectorIndexes = applyExtensions(defineSchemaCall, tables);
+  const extensionStandaloneVectorIndexes = applyExtensions(defineSchemaCall, tables, projectRoot);
   const vectorIndexes = [...tables.flatMap((table) => table.vectorIndexes), ...standaloneVectorIndexes, ...extensionStandaloneVectorIndexes];
   return { tables, vectorIndexes };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/codegen",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.7",
   "description": "Code generator for Lunora: emits _generated/{api,server,dataModel}.ts from your schema",
   "keywords": [
     "cloudflare",