@lunora/codegen 1.0.0-alpha.3 → 1.0.0-alpha.31

package/dist/packem_shared/MUTATORS_FILENAME-BZOfUhlY.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-DyQ5FwkM.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/{OPENRPC_VERSION-BGUrsrt_.mjs → OPENRPC_VERSION-u5SqDDGk.mjs}

@@ -1,4 +1,4 @@
-import { GENERATED_HEADER } from './GENERATED_HEADER-CuLyj0WQ.mjs';
+import { GENERATED_HEADER } from './GENERATED_HEADER-f6nMvllu.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-BF0iUmx7.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-DyQ5FwkM.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 };