@lunora/codegen 1.0.0-alpha.12 → 1.0.0-alpha.120

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/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 };