@lunora/codegen 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/LUNORA_SOLUTION_RULES-BTejmZp-.mjs

@@ -0,0 +1,131 @@
+const LUNORA_SOLUTION_RULES = [
+  {
+    body: [
+      "Lunora codegen couldn't find a schema to generate from.",
+      "",
+      "Create `lunora/schema.ts` exporting a `defineSchema(...)` call:",
+      "",
+      "```ts",
+      'import { defineSchema, defineTable, v } from "@lunora/server";',
+      "",
+      "export default defineSchema({",
+      "  messages: defineTable({ body: v.string() }),",
+      "});",
+      "```",
+      "",
+      "Or run `lunora init` to scaffold Lunora (a sample `lunora/schema.ts` included) into your app."
+    ].join("\n"),
+    header: "No Lunora schema found",
+    id: "lunora-schema-missing",
+    test: (message) => message.includes("defineSchema() not found") || message.includes("schema.ts not found at")
+  },
+  {
+    body: [
+      "`defineSchema(...)` must be called with an **inline object literal** mapping table names to `defineTable(...)`:",
+      "",
+      "```ts",
+      "export default defineSchema({",
+      "  todos: defineTable({ title: v.string(), done: v.boolean() }),",
+      "});",
+      "```",
+      "",
+      "Codegen reads the schema statically, so it can't follow a variable or a spread — pass the object literal directly."
+    ].join("\n"),
+    header: "`defineSchema()` needs an inline object literal",
+    id: "lunora-schema-not-object-literal",
+    test: (message) => message.includes("defineSchema() expects an object literal")
+  },
+  {
+    body: [
+      "This table name collides with a built-in `ctx.db` member, so the generated client can't expose it.",
+      "",
+      "Rename the table to anything that isn't a reserved name (the error lists them) — e.g. `userAccounts` instead of `insert`."
+    ].join("\n"),
+    header: "Table name is reserved",
+    id: "lunora-table-reserved",
+    test: (message) => message.includes("is reserved") && message.includes("ctx.db")
+  },
+  {
+    body: [
+      "Two tables resolve to the same name — usually a base table and a schema **extension** both defining it.",
+      "",
+      "Rename one of them, or drop the duplicate from the extension. Each table name must be unique across `defineSchema(...)` and every `.extend(...)`."
+    ].join("\n"),
+    header: "Duplicate table name",
+    id: "lunora-table-duplicate",
+    // Anchor on `.extend(` — the only Lunora throw for this is
+    // `defineSchema(...).extend(...): table "x" already exists …`. Matching a
+    // bare "already exists"/"extension" pair would false-positive on
+    // unrelated forwarded errors (e.g. a "file already exists" + "extension").
+    test: (message) => message.includes("already exists") && message.includes(".extend(")
+  },
+  {
+    body: [
+      '`.jurisdiction(...)` accepts only a **string literal** of `"eu"`, `"us"`, or `"fedramp"`:',
+      "",
+      "```ts",
+      'defineSchema({ /* … */ }).jurisdiction("eu");',
+      "```"
+    ].join("\n"),
+    header: "Invalid `.jurisdiction(...)` value",
+    id: "lunora-jurisdiction",
+    test: (message) => message.includes("unknown jurisdiction") || message.includes("jurisdiction") && message.includes('"eu", "us", or "fedramp"')
+  },
+  {
+    body: [
+      "The `unique` flag on an index must be a **literal** `true` or `false`, not a computed value — codegen needs to read it statically:",
+      "",
+      "```ts",
+      'defineTable({ email: v.string() }).index("by_email", ["email"], { unique: true });',
+      "```"
+    ].join("\n"),
+    header: "`unique` must be a literal",
+    id: "lunora-unique-literal",
+    test: (message) => message.includes("must be a literal") && message.includes("unique")
+  },
+  {
+    body: [
+      "A declared container/workflow class isn't re-exported by your worker entry, so `wrangler deploy` would reject it.",
+      "",
+      "Add the generated re-export shown in the error to your worker entry (e.g. `src/index.ts`):",
+      "",
+      "```ts",
+      'export * from "./lunora/_generated/containers";',
+      "```"
+    ].join("\n"),
+    header: "Binding not exported by your worker entry",
+    id: "lunora-worker-entry-export-gap",
+    test: (message) => message.includes("not exported by your worker entry")
+  },
+  {
+    body: [
+      "A row with the same value already exists in a `unique` index.",
+      "",
+      "- If you meant to upsert, use `ctx.db.<table>().upsert(...)` (or `.patch(...)` an existing row) instead of `.insert(...)`.",
+      `- Otherwise pick a value that isn't already taken, and consider surfacing a friendly "already exists" message to the user.`
+    ].join("\n"),
+    header: "Unique constraint violation",
+    id: "lunora-runtime-unique",
+    test: (message) => message.includes("unique constraint violation on")
+  },
+  {
+    body: [
+      "Another write changed this row while your mutation was running (optimistic concurrency conflict).",
+      "",
+      "Re-read the row and retry the mutation with the fresh value. Lunora serializes a DO's mutations, so a persistent conflict usually means the handler conflicts **with itself** (e.g. a trigger or cascade touching the same row) — split that work rather than adding a retry loop."
+    ].join("\n"),
+    header: "Optimistic concurrency conflict",
+    id: "lunora-runtime-occ",
+    test: (message) => message.includes("optimistic concurrency conflict")
+  }
+];
+const findLunoraSolution = (message) => {
+  for (const rule of LUNORA_SOLUTION_RULES) {
+    if (rule.test(message)) {
+      return { body: rule.body, header: rule.header, id: rule.id };
+    }
+  }
+  return void 0;
+};
+
+export { LUNORA_SOLUTION_RULES, findLunoraSolution };

package/dist/packem_shared/MUTATORS_FILENAME-BhqdPtKp.mjs

@@ -0,0 +1,81 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { Node, SyntaxKind } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DeblMkzO.mjs';
+
+const MUTATORS_FILENAME = "mutators.ts";
+const MUTATOR_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["@lunora/server", "lunorash/server"]);
+const isDefineMutator = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineMutator";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (!MUTATOR_MODULE_SPECIFIERS.has(declaration.getImportDeclaration().getModuleSpecifierValue())) {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineMutator";
+  }
+  return false;
+};
+const isMutatorNamespaceImport = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return false;
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isNamespaceImport(declaration)) {
+      continue;
+    }
+    const importDeclaration = declaration.getFirstAncestorByKind(SyntaxKind.ImportDeclaration);
+    return importDeclaration !== void 0 && MUTATOR_MODULE_SPECIFIERS.has(importDeclaration.getModuleSpecifierValue());
+  }
+  return false;
+};
+const isDefineMutatorCallee = (callee) => {
+  if (Node.isIdentifier(callee)) {
+    return isDefineMutator(callee);
+  }
+  if (Node.isPropertyAccessExpression(callee)) {
+    const object = callee.getExpression();
+    return callee.getName() === "defineMutator" && Node.isIdentifier(object) && isMutatorNamespaceImport(object);
+  }
+  return false;
+};
+const mutatorsFromSource = (source) => {
+  const mutators = [];
+  for (const declaration of source.getVariableDeclarations()) {
+    if (!declaration.isExported()) {
+      continue;
+    }
+    const initializer = declaration.getInitializer();
+    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const callee = initializer.getExpression();
+    if (!isDefineMutatorCallee(callee)) {
+      continue;
+    }
+    const nameNode = declaration.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      throw diagnosticAt(nameNode, "defineMutator exports must be plain named exports (no destructuring)");
+    }
+    mutators.push({ exportName: nameNode.getText(), filePath: "mutators" });
+  }
+  return mutators;
+};
+const discoverMutators = (project, lunoraDirectory) => {
+  const mutatorsPath = join(lunoraDirectory, MUTATORS_FILENAME);
+  if (!existsSync(mutatorsPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(mutatorsPath) ?? project.addSourceFileAtPath(mutatorsPath);
+  const mutators = mutatorsFromSource(source);
+  mutators.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  return mutators;
+};
+
+export { MUTATORS_FILENAME, discoverMutators, isDefineMutatorCallee };

package/dist/packem_shared/{buildOpenRpcDocument-BZGY1-jT.mjs → OPENRPC_VERSION-t5pV2NIN.mjs}

@@ -1,4 +1,4 @@
-import { GENERATED_HEADER } from './emitApi-hRVC-kE7.mjs';
+import { GENERATED_HEADER } from './GENERATED_HEADER-CI272wRm.mjs';
 import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
 import { argsObjectSchema, LUNORA_ERROR_CODES } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
 

package/dist/packem_shared/QUEUES_FILENAME-B5_eWCRe.mjs

@@ -0,0 +1,119 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { queueDefaultName, queueBindingName } from '@lunora/queue';
+import { SyntaxKind, Node } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DeblMkzO.mjs';
+
+const QUEUES_FILENAME = "queues.ts";
+const isDefineQueue = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineQueue";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (declaration.getImportDeclaration().getModuleSpecifierValue() !== "@lunora/queue") {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineQueue";
+  }
+  return false;
+};
+const stringProperty = (expression, exportName, property) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `queue "${exportName}": \`${property}\` must be a static string literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const numberProperty = (expression, exportName, property) => {
+  if (Node.isNumericLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `queue "${exportName}": \`${property}\` must be a static numeric literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const queueNameOverride = (argument, exportName) => {
+  const nameProperty = argument.getProperty("name");
+  if (!nameProperty || !Node.isPropertyAssignment(nameProperty)) {
+    return void 0;
+  }
+  const name = stringProperty(nameProperty.getInitializerOrThrow(), exportName, "name");
+  if (name.length === 0) {
+    throw diagnosticAt(nameProperty, `queue "${exportName}": \`name\` must be a non-empty string when provided`);
+  }
+  return name;
+};
+const queueFromCall = (call, exportName) => {
+  const argument = call.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    throw diagnosticAt(call, `queue "${exportName}": defineQueue must be passed an inline object literal`);
+  }
+  const ir = {
+    bindingName: queueBindingName(exportName),
+    exportName,
+    mode: "push",
+    name: queueNameOverride(argument, exportName) ?? queueDefaultName(exportName),
+    tuning: {}
+  };
+  const modeProperty = argument.getProperty("mode");
+  if (modeProperty && Node.isPropertyAssignment(modeProperty)) {
+    const mode = stringProperty(modeProperty.getInitializerOrThrow(), exportName, "mode");
+    if (mode !== "push" && mode !== "pull") {
+      throw diagnosticAt(modeProperty, `queue "${exportName}": \`mode\` must be "push" or "pull" (got ${JSON.stringify(mode)})`);
+    }
+    ir.mode = mode;
+  }
+  const dlqProperty = argument.getProperty("deadLetterQueue");
+  if (dlqProperty && Node.isPropertyAssignment(dlqProperty)) {
+    ir.tuning.deadLetterQueue = stringProperty(dlqProperty.getInitializerOrThrow(), exportName, "deadLetterQueue");
+  }
+  for (const property of ["maxBatchSize", "maxBatchTimeout", "maxRetries", "retryDelay"]) {
+    const node = argument.getProperty(property);
+    if (node && Node.isPropertyAssignment(node)) {
+      ir.tuning[property] = numberProperty(node.getInitializerOrThrow(), exportName, property);
+    }
+  }
+  return ir;
+};
+const queuesFromSource = (source) => {
+  const queues = [];
+  for (const declaration of source.getVariableDeclarations()) {
+    if (!declaration.isExported()) {
+      continue;
+    }
+    const initializer = declaration.getInitializer();
+    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const call = initializer;
+    const callee = call.getExpression();
+    if (!Node.isIdentifier(callee) || !isDefineQueue(callee)) {
+      continue;
+    }
+    const nameNode = declaration.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      throw diagnosticAt(nameNode, "defineQueue exports must be plain named exports (no destructuring)");
+    }
+    queues.push(queueFromCall(call, nameNode.getText()));
+  }
+  return queues;
+};
+const discoverQueues = (project, lunoraDirectory) => {
+  const queuesPath = join(lunoraDirectory, QUEUES_FILENAME);
+  if (!existsSync(queuesPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(queuesPath) ?? project.addSourceFileAtPath(queuesPath);
+  const queues = queuesFromSource(source);
+  queues.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  return queues;
+};
+
+export { QUEUES_FILENAME, discoverQueues };