@lunora/codegen 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/packem_shared/{discoverSchema-BBulgGbH.mjs → discoverSchema-BnWHHJ4T.mjs}

@@ -1,6 +1,212 @@
-import { SyntaxKind, Node } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-54jWDxA9.mjs';
-import { a as parseObjectShape } from './parse-validator-tuQtHrsr.mjs';
+import { Node, SyntaxKind } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DeblMkzO.mjs';
+import { a as parseObjectShape } from './parse-validator-Cabb60UV.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"]);
@@ -179,6 +385,18 @@ const parseGlobalBackend = (args) => {
   }
   return "d1";
 };
+const softDeleteFieldOf = (optionsArgument) => {
+  if (optionsArgument && Node.isObjectLiteralExpression(optionsArgument)) {
+    const fieldProperty = optionsArgument.getProperty("field");
+    if (fieldProperty && Node.isPropertyAssignment(fieldProperty)) {
+      const initializer = fieldProperty.getInitializer();
+      if (initializer && Node.isStringLiteral(initializer)) {
+        return initializer.getLiteralText();
+      }
+    }
+  }
+  return "deletedAt";
+};
 const applyTableMethod = (accumulator, method, args, name) => {
   switch (method) {
     case "externallyManaged": {
@@ -214,6 +432,10 @@ const applyTableMethod = (accumulator, method, args, name) => {
       accumulator.shardMode = { field: field && Node.isStringLiteral(field) ? field.getLiteralText() : "_unknown_", kind: "shardBy" };
       break;
     }
+    case "softDelete": {
+      accumulator.softDelete = { field: softDeleteFieldOf(args[0]) };
+      break;
+    }
     case "vectorize": {
       const vectorIndex = parseVectorizeCall(args, name);
       if (vectorIndex) {
@@ -251,6 +473,9 @@ const parseTableBuilder = (expression, name) => {
       break;
     }
   }
+  if (accumulator.softDelete && !(accumulator.softDelete.field in shape)) {
+    shape = { ...shape, [accumulator.softDelete.field]: { inner: { kind: "number" }, kind: "optional" } };
+  }
   return {
     externallyManaged: accumulator.externallyManaged,
     globalBackend: accumulator.shardMode === "global" ? accumulator.globalBackend ?? "d1" : void 0,
@@ -261,6 +486,7 @@ const parseTableBuilder = (expression, name) => {
     searchIndexes: accumulator.searchIndexes,
     shape,
     shardMode: accumulator.shardMode,
+    softDelete: accumulator.softDelete,
     vectorIndexes: accumulator.vectorIndexes
   };
 };
@@ -354,7 +580,27 @@ const extensionTargetIdentifier = (argument) => {
     return argument;
   }
   if (Node.isPropertyAccessExpression(argument)) {
-    return argument.getNameNode();
+    const receiver = argument.getExpression();
+    return Node.isIdentifier(receiver) ? receiver : void 0;
+  }
+  return void 0;
+};
+const pluginConfigObject = (expression) => {
+  if (Node.isObjectLiteralExpression(expression)) {
+    return expression;
+  }
+  if (Node.isCallExpression(expression)) {
+    const callee = expression.getExpression();
+    let name;
+    if (Node.isIdentifier(callee)) {
+      name = callee.getText();
+    } else if (Node.isPropertyAccessExpression(callee)) {
+      name = callee.getName();
+    }
+    if (name === "definePlugin") {
+      const configArgument = expression.getArguments()[1];
+      return configArgument && Node.isObjectLiteralExpression(configArgument) ? configArgument : void 0;
+    }
   }
   return void 0;
 };
@@ -363,8 +609,9 @@ const nextExpressionFromDeclaration = (declaration, argument) => {
   if (!initializer) {
     return void 0;
   }
-  if (Node.isPropertyAccessExpression(argument) && Node.isObjectLiteralExpression(initializer)) {
-    return objectPropertyInitializer(initializer, argument.getName());
+  if (Node.isPropertyAccessExpression(argument)) {
+    const configObject = pluginConfigObject(initializer);
+    return configObject ? objectPropertyInitializer(configObject, argument.getName()) : void 0;
   }
   return initializer;
 };
@@ -434,24 +681,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;
   }
@@ -481,6 +734,33 @@ const extendCallsOf = (defineSchemaCall) => {
   }
   return calls;
 };
+const JURISDICTIONS = /* @__PURE__ */ new Set(["eu", "fedramp", "us"]);
+const jurisdictionOf = (defineSchemaCall) => {
+  let current = defineSchemaCall;
+  for (; ; ) {
+    const parent = current.getParent();
+    if (!parent || !Node.isPropertyAccessExpression(parent)) {
+      break;
+    }
+    const callParent = parent.getParent();
+    if (!callParent || !Node.isCallExpression(callParent)) {
+      break;
+    }
+    if (parent.getName() === "jurisdiction") {
+      const argument = callParent.getArguments()[0];
+      if (!argument || !Node.isStringLiteral(argument)) {
+        throw diagnosticAt(callParent, '`.jurisdiction(...)` expects a string literal ("eu", "us", or "fedramp")');
+      }
+      const value = argument.getLiteralText();
+      if (!JURISDICTIONS.has(value)) {
+        throw diagnosticAt(argument, `unknown jurisdiction ${JSON.stringify(value)} — expected "eu", "us", or "fedramp"`);
+      }
+      return value;
+    }
+    current = callParent;
+  }
+  return void 0;
+};
 const parseBaseTables = (object) => {
   const tables = [];
   for (const property of object.getProperties()) {
@@ -496,11 +776,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;
     }
@@ -518,7 +798,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();
@@ -534,9 +814,9 @@ 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 };
+  return { jurisdiction: jurisdictionOf(defineSchemaCall), tables, vectorIndexes };
 };
 
 export { discoverSchema as default };

package/dist/packem_shared/{discoverStorageRulesMetadata-DAqJUxUv.mjs → discoverStorageRulesMetadata-Da8BKXcI.mjs}

@@ -1,5 +1,5 @@
 import { Node } from 'ts-morph';
-import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-BWMczzBx.mjs';
 
 const STORAGE_OPERATIONS = /* @__PURE__ */ new Set(["delete", "list", "read", "write"]);
 const isStorageRulesCall = (node) => {

package/dist/packem_shared/{emitApp-CzZ6GbrD.mjs → emitApp-KfMaKXWe.mjs}

@@ -1,4 +1,4 @@
-import { GENERATED_HEADER } from './emitApi-hRVC-kE7.mjs';
+import { GENERATED_HEADER } from './GENERATED_HEADER-BiFXNUvo.mjs';
 
 const LONG_TAIL = [
   ["hasAi", "ai", "ai", "Override the Workers AI binding backing `ctx.ai` (defaults to `env.AI`)."],
@@ -13,6 +13,12 @@ const LONG_TAIL = [
   ["hasImages", "images", "images", "Override the Images binding backing `ctx.images` (defaults to `env.IMAGES`)."],
   ["hasKv", "kv", "kv", "Override the Workers KV binding backing `ctx.kv` (defaults to `env.KV`)."],
   ["hasPayments", "payment", "payment", "Wire the payment options backing `ctx.payments`."],
+  [
+    "hasR2sql",
+    "r2sql",
+    "r2sql",
+    "Wire the R2 SQL client backing `ctx.r2sql` — build it with `createR2Sql({ accountId, apiToken, bucket })` (defaults to env `R2_SQL_TOKEN` / `R2_SQL_ACCOUNT_ID` / `R2_SQL_BUCKET`)."
+  ],
   ["hasVectors", "vectors", "vectors", "Wire the Vectorize index map backing `ctx.vectors`."]
 ];
 const hasAnyLongTail = (options) => LONG_TAIL.some(([flag]) => options[flag]);
@@ -268,7 +274,7 @@ const buildShardFactoryBody = (options) => {
                           const namespace = this.schedulerDeclaration?.namespace(env);
                           const origin = this.schedulerDeclaration?.origin?.(env);
 
-                          return namespace && origin ? createScheduler({ namespace, originUrl: origin }) : undefined;
+                          return namespace && origin ? createScheduler({${options.jurisdiction ? ` jurisdiction: ${JSON.stringify(options.jurisdiction)},` : ""} namespace, originUrl: origin }) : undefined;
                       },
                   }
                 : {}),`
@@ -342,6 +348,10 @@ const buildWorkerOptionLines = (options) => [
 const buildBaseWorkerOptions = (options) => [
   `            cronJobs: LUNORA_CRONS,`,
   `            functions: LUNORA_FUNCTIONS,`,
+  // Schema `.jurisdiction("…")` pins every DO the worker reaches to the
+  // Cloudflare data-residency region. Emitted only when declared, so apps
+  // without it keep the un-pinned global namespace (and unchanged output).
+  ...options.jurisdiction ? [`            jurisdiction: ${JSON.stringify(options.jurisdiction)},`] : [],
   ...options.wantsOpenApi ? [`            openApiSpec,`] : [],
   ...options.wantsOpenRpc ? [`            openRpcSpec,`] : [],
   `            routes: this.routeMap,`,

package/dist/packem_shared/{lintSchema-DicbOHvH.mjs → formatAdvisories-8NIv1k0I.mjs}

@@ -36,7 +36,7 @@ const toAdvisorSchema = (schema) => {
     })
   };
 };
-const lintSchema = (schema, queries = [], inserts, authApiCalls, rlsProcedures, containers, workflows, workflowCalls, maskProcedures, nondeterministicCalls, procedureProtections, argumentValidators, secretLiterals, sqlInterpolations, adminRoutes) => runAdvisor(
+const lintSchema = (schema, queries = [], inserts, authApiCalls, rlsProcedures, containers, workflows, workflowCalls, maskProcedures, nondeterministicCalls, procedureProtections, argumentValidators, secretLiterals, sqlInterpolations, adminRoutes, r2sqlCalls) => runAdvisor(
   {
     adminRoutes,
     argValidators: argumentValidators,
@@ -47,6 +47,7 @@ const lintSchema = (schema, queries = [], inserts, authApiCalls, rlsProcedures,
     nondeterministicCalls,
     procedureProtections,
     queries,
+    r2sqlCalls,
     rlsProcedures,
     schema: toAdvisorSchema(schema),
     secretLiterals,

package/dist/packem_shared/{parse-validator-tuQtHrsr.mjs → parse-validator-Cabb60UV.mjs}

@@ -124,7 +124,8 @@ const parseValidatorCall = (call) => {
   }
   if (TRANSPARENT_MODIFIERS.has(member)) {
     const receiver = callee.getExpression();
-    return Node.isExpression(receiver) ? parseValidator(receiver) : { kind: "any" };
+    const base = Node.isExpression(receiver) ? parseValidator(receiver) : { kind: "any" };
+    return member === "check" ? { ...base, hasRefinement: true } : base;
   }
   return parseBuilderMember(member, args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/codegen",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.10",
   "description": "Code generator for Lunora: emits _generated/{api,server,dataModel}.ts from your schema",
   "keywords": [
     "cloudflare",
@@ -46,11 +46,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/advisor": "1.0.0-alpha.1",
-    "@lunora/container": "1.0.0-alpha.1",
-    "@lunora/scheduler": "1.0.0-alpha.1",
-    "@lunora/values": "1.0.0-alpha.1",
-    "@lunora/workflow": "1.0.0-alpha.1",
+    "@lunora/advisor": "1.0.0-alpha.5",
+    "@lunora/container": "1.0.0-alpha.2",
+    "@lunora/scheduler": "1.0.0-alpha.2",
+    "@lunora/values": "1.0.0-alpha.2",
+    "@lunora/workflow": "1.0.0-alpha.2",
     "ts-morph": "^28.0.0"
   },
   "engines": {