@lunora/codegen 1.0.0-alpha.13 → 1.0.0-alpha.130

package/dist/packem_shared/LUNORA_ERROR_CODES-CySpQPD3.mjs

@@ -1,61 +0,0 @@
-import { jsonSchemaFromNode, objectSchemaFromNodes } from '@lunora/values';
-
-const literalConst = (literalValue) => {
-  if (literalValue === void 0) {
-    return {};
-  }
-  const trimmed = literalValue.trim();
-  if (trimmed === "true") {
-    return { const: true };
-  }
-  if (trimmed === "false") {
-    return { const: false };
-  }
-  if (trimmed === "null") {
-    return { const: null, type: "null" };
-  }
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return { const: trimmed.slice(1, -1), type: "string" };
-  }
-  const asNumber = Number(trimmed);
-  if (!Number.isNaN(asNumber)) {
-    return { const: asNumber };
-  }
-  return { const: trimmed };
-};
-const irReader = {
-  constraints: () => void 0,
-  inner: (validator) => validator.inner,
-  isNullable: (validator) => validator.column?.notNull === false,
-  // `ValidatorIR.kind` is a loose `string` (build-time AST); narrow it to the
-  // shared reader's `ValidatorKind`. Unknown kinds fall through the mapper's
-  // `default` branch to an empty schema, exactly as before.
-  kind: (validator) => validator.kind,
-  literalSchema: (validator) => literalConst(validator.literalValue),
-  members: (validator) => validator.members ?? [],
-  shape: (validator) => validator.shape ?? {},
-  tableName: (validator) => validator.tableName,
-  valueChild: (validator) => validator.valueType
-};
-const validatorIrToJsonSchema = (validator) => jsonSchemaFromNode(validator, irReader);
-const objectSchema = (shape) => objectSchemaFromNodes(shape, irReader);
-const argsObjectSchema = (args) => objectSchema(args);
-const LUNORA_ERROR_CODES = [
-  "BAD_REQUEST",
-  "CONFLICT",
-  "COUNT_RLS_UNSUPPORTED",
-  "FORBIDDEN",
-  "FUNCTION_NOT_FOUND",
-  "INTERNAL",
-  "INTERNAL_SERVER_ERROR",
-  "METHOD_NOT_ALLOWED",
-  "NOT_FOUND",
-  "NOT_IMPLEMENTED",
-  "PAYLOAD_TOO_LARGE",
-  "TOO_MANY_REQUESTS",
-  "UNAUTHORIZED",
-  "UNPROCESSABLE",
-  "VALIDATION_ERROR"
-];
-
-export { LUNORA_ERROR_CODES, argsObjectSchema, literalConst, objectSchema, validatorIrToJsonSchema };

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

@@ -1,131 +0,0 @@
-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/OPENRPC_VERSION-CQ3f8YQ-.mjs

@@ -1,60 +0,0 @@
-import { GENERATED_HEADER } from './GENERATED_HEADER-BEA7oWGC.mjs';
-import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
-import { argsObjectSchema, LUNORA_ERROR_CODES } from './LUNORA_ERROR_CODES-CySpQPD3.mjs';
-
-const OPENRPC_VERSION = "1.3.2";
-const inferredResultSchema = () => {
-  return { description: "Result is TS-inferred from the function's return type (no `.output()` declared); best-effort — any JSON." };
-};
-const rpcMethod = (definition) => {
-  const namespace = sanitizeNamespace(definition.filePath);
-  const functionPath = `${namespace}:${definition.exportName}`;
-  return {
-    description: `Invoke the \`${definition.kind}\` \`${functionPath}\` over the Lunora RPC envelope (POST /_lunora/rpc, body \`{ "functionPath": "${functionPath}", "args": { … } }\`).`,
-    errors: LUNORA_ERROR_CODES.map((code, index) => {
-      return { code: -32e3 - index, data: { code }, message: code };
-    }),
-    name: functionPath,
-    params: [
-      {
-        description: "The function's argument object (the RPC envelope's `args`).",
-        name: "args",
-        // A function with no declared args still takes an (empty) args
-        // object; `required` reflects whether the function declares any
-        // arguments at all.
-        required: Object.keys(definition.args).length > 0,
-        schema: argsObjectSchema(definition.args)
-      }
-    ],
-    result: {
-      name: "result",
-      schema: inferredResultSchema()
-    },
-    summary: `${definition.kind}: ${functionPath}`,
-    "x-lunora-function-kind": definition.kind,
-    // OpenRPC has no first-class tag grouping; surface the file namespace as
-    // an `x-tags` extension so tooling can group methods by source file.
-    "x-tags": [{ name: namespace }]
-  };
-};
-const buildOpenRpcDocument = (input) => {
-  const version = input.version ?? "0.0.0";
-  const rpcFunctions = input.functions.filter((definition) => definition.visibility !== "internal" && definition.kind !== "stream");
-  const methods = rpcFunctions.map((definition) => rpcMethod(definition)).toSorted((a, b) => a.name.localeCompare(b.name));
-  const document = {
-    info: {
-      description: "Auto-generated from @lunora/values-typed functions by @lunora/codegen. Do not edit — run `lunora codegen` to regenerate.",
-      title: "Lunora RPC",
-      version
-    },
-    methods,
-    openrpc: OPENRPC_VERSION
-  };
-  return document;
-};
-const emitOpenRpc = (input) => `${JSON.stringify(buildOpenRpcDocument(input), void 0, 2)}
-`;
-const emitOpenRpcModule = (document_) => `${GENERATED_HEADER}export const openRpcSpec: Record<string, unknown> = ${JSON.stringify(document_, void 0, 4)};
-`;
-
-export { OPENRPC_VERSION, buildOpenRpcDocument, emitOpenRpc, emitOpenRpcModule };

package/dist/packem_shared/QUEUES_FILENAME-B5_eWCRe.mjs

@@ -1,119 +0,0 @@
-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 };