@lunora/codegen 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/discoverMaskProcedures-B64zA740.mjs

@@ -0,0 +1,217 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+
+const isMaskCall = (node) => {
+  if (!Node.isCallExpression(node)) {
+    return false;
+  }
+  const callee = node.getExpression();
+  if (Node.isIdentifier(callee)) {
+    return callee.getText() === "mask";
+  }
+  if (Node.isPropertyAccessExpression(callee)) {
+    return callee.getName() === "mask";
+  }
+  return false;
+};
+const memberName = (member) => {
+  if (Node.isPropertyAssignment(member) || Node.isShorthandPropertyAssignment(member) || Node.isMethodDeclaration(member) || Node.isGetAccessorDeclaration(member)) {
+    return member.getName();
+  }
+  return void 0;
+};
+const extractMaskColumns = (maskCall) => {
+  const argument = maskCall.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    return [];
+  }
+  const pairs = [];
+  for (const tableProperty of argument.getProperties()) {
+    const table = memberName(tableProperty);
+    if (table === void 0 || !Node.isPropertyAssignment(tableProperty)) {
+      continue;
+    }
+    const initializer = tableProperty.getInitializer();
+    if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+      continue;
+    }
+    for (const columnProperty of initializer.getProperties()) {
+      const column = memberName(columnProperty);
+      if (column !== void 0) {
+        pairs.push({ column, table });
+      }
+    }
+  }
+  return pairs;
+};
+const maskCallsInChain = (receiver) => {
+  const calls = [];
+  let node = receiver;
+  while (Node.isCallExpression(node)) {
+    const chainCallee = node.getExpression();
+    if (!Node.isPropertyAccessExpression(chainCallee)) {
+      break;
+    }
+    if (chainCallee.getName() === "use") {
+      const argument = node.getArguments()[0];
+      if (argument && isMaskCall(argument)) {
+        calls.push(argument);
+      }
+    }
+    node = chainCallee.getExpression();
+  }
+  return calls;
+};
+const maskFromBuilderChain = (receiver) => {
+  const calls = maskCallsInChain(receiver);
+  return { maskColumns: calls.flatMap((call) => extractMaskColumns(call)), usesMask: calls.length > 0 };
+};
+const READ_METHODS = /* @__PURE__ */ new Set(["findFirst", "findFirstOrThrow", "findMany", "get", "query"]);
+const WRITE_METHODS = /* @__PURE__ */ new Set(["delete", "insert", "patch", "replace"]);
+const isDatabaseCall = (call, methodSet) => {
+  const callee = call.getExpression();
+  if (!Node.isPropertyAccessExpression(callee) || !methodSet.has(callee.getName())) {
+    return false;
+  }
+  const receiver = callee.getExpression();
+  if (Node.isPropertyAccessExpression(receiver)) {
+    return receiver.getName() === "db";
+  }
+  return Node.isIdentifier(receiver) && receiver.getText() === "db";
+};
+const tableArgumentOf = (call) => {
+  const argument = call.getArguments()[0];
+  return argument && Node.isStringLiteral(argument) ? argument.getLiteralText() : "";
+};
+const tablesAccessedIn = (declaration) => {
+  const tablesRead = /* @__PURE__ */ new Set();
+  const tablesWritten = /* @__PURE__ */ new Set();
+  for (const call of declaration.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    if (isDatabaseCall(call, READ_METHODS)) {
+      const table = tableArgumentOf(call);
+      if (table !== "") {
+        tablesRead.add(table);
+      }
+    } else if (isDatabaseCall(call, WRITE_METHODS)) {
+      const table = tableArgumentOf(call);
+      if (table !== "") {
+        tablesWritten.add(table);
+      }
+    }
+  }
+  return { tablesRead: [...tablesRead], tablesWritten: [...tablesWritten] };
+};
+const procedureIrFromDeclaration = (declaration, relativePath) => {
+  if (!Node.isVariableDeclaration(declaration)) {
+    return void 0;
+  }
+  const initializer = declaration.getInitializer();
+  if (!initializer || !Node.isCallExpression(initializer)) {
+    return void 0;
+  }
+  const classified = classifyProcedureCall(initializer);
+  if (!classified) {
+    return void 0;
+  }
+  const chain = classified.receiver ? maskFromBuilderChain(classified.receiver) : { maskColumns: [], usesMask: false };
+  const { tablesRead, tablesWritten } = tablesAccessedIn(declaration);
+  return {
+    exportName: declaration.getName(),
+    file: relativePath,
+    maskColumns: chain.maskColumns,
+    tablesRead,
+    tablesWritten,
+    usesMask: chain.usesMask,
+    visibility: classified.visibility
+  };
+};
+const discoverMaskProcedures = (project, lunoraDirectory) => {
+  const procedures = [];
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const relativePath = lunoraRelativePath(lunoraDirectory, filePath);
+    for (const statement of sourceFile.getVariableStatements()) {
+      if (!statement.isExported()) {
+        continue;
+      }
+      for (const declaration of statement.getDeclarations()) {
+        const ir = procedureIrFromDeclaration(declaration, relativePath);
+        if (ir) {
+          procedures.push(ir);
+        }
+      }
+    }
+  }
+  return procedures;
+};
+const strategyOf = (columnProperty) => {
+  if (Node.isPropertyAssignment(columnProperty)) {
+    const initializer = columnProperty.getInitializer();
+    if (initializer && Node.isStringLiteral(initializer)) {
+      const literal = initializer.getLiteralText();
+      if (literal === "redact" || literal === "hash") {
+        return literal;
+      }
+    }
+  }
+  return "custom";
+};
+const extractMaskColumnMetadata = (maskCall) => {
+  const argument = maskCall.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    return [];
+  }
+  const columns = [];
+  for (const tableProperty of argument.getProperties()) {
+    const table = memberName(tableProperty);
+    if (table === void 0 || !Node.isPropertyAssignment(tableProperty)) {
+      continue;
+    }
+    const initializer = tableProperty.getInitializer();
+    if (!initializer || !Node.isObjectLiteralExpression(initializer)) {
+      continue;
+    }
+    for (const columnProperty of initializer.getProperties()) {
+      const column = memberName(columnProperty);
+      if (column !== void 0) {
+        columns.push({ column, strategy: strategyOf(columnProperty), table });
+      }
+    }
+  }
+  return columns;
+};
+const exportedProcedureChains = (sourceFile) => {
+  const receivers = [];
+  for (const statement of sourceFile.getVariableStatements()) {
+    if (!statement.isExported()) {
+      continue;
+    }
+    for (const declaration of statement.getDeclarations()) {
+      const initializer = declaration.getInitializer();
+      const classified = initializer && Node.isCallExpression(initializer) ? classifyProcedureCall(initializer) : void 0;
+      if (classified?.receiver) {
+        receivers.push(classified.receiver);
+      }
+    }
+  }
+  return receivers;
+};
+const discoverMaskMetadata = (project, lunoraDirectory) => {
+  const columnsByKey = /* @__PURE__ */ new Map();
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    for (const receiver of exportedProcedureChains(sourceFile)) {
+      for (const maskCall of maskCallsInChain(receiver)) {
+        for (const column of extractMaskColumnMetadata(maskCall)) {
+          const key = `${column.table}\0${column.column}`;
+          if (!columnsByKey.has(key)) {
+            columnsByKey.set(key, column);
+          }
+        }
+      }
+    }
+  }
+  return { columns: [...columnsByKey.values()] };
+};
+
+export { discoverMaskProcedures as default, discoverMaskMetadata };

package/dist/packem_shared/discoverMigrations-Doj_-BAA.mjs

@@ -0,0 +1,91 @@
+import { relative, sep } from 'node:path';
+import { SyntaxKind, Node } from 'ts-morph';
+import { listLunoraSourceFiles } from './discoverFunctions-DEgAcRuD.mjs';
+
+const TS_EXTENSION_RE = /\.ts$/u;
+const isDefineMigration = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineMigration";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (declaration.getImportDeclaration().getModuleSpecifierValue() !== "@lunora/server") {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineMigration";
+  }
+  return false;
+};
+const stringProperty = (object, name) => {
+  const property = object.getProperty(name);
+  if (!property || !Node.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  return initializer && Node.isStringLiteral(initializer) ? initializer.getLiteralValue() : void 0;
+};
+const migrationFromDeclaration = (declaration, relativePath) => {
+  const initializer = declaration.getInitializer();
+  if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+    return void 0;
+  }
+  const callee = initializer.getExpression();
+  if (!Node.isIdentifier(callee) || !isDefineMigration(callee)) {
+    return void 0;
+  }
+  const argument = initializer.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    return void 0;
+  }
+  const id = stringProperty(argument, "id");
+  const exportName = declaration.getName();
+  if (id === void 0 || id.trim() === "") {
+    throw Object.assign(
+      new Error(`Migration "${exportName}" in "${relativePath}" must declare \`id\` as a non-empty string literal so codegen can key the registry.`),
+      { code: "MIGRATION_ID_NOT_STATIC", name: "LunoraError", status: 500 }
+    );
+  }
+  return { exportName, filePath: relativePath, id, table: stringProperty(argument, "table") ?? "" };
+};
+const assertUniqueIds = (migrations) => {
+  const seenIds = /* @__PURE__ */ new Map();
+  for (const migration of migrations) {
+    const prior = seenIds.get(migration.id);
+    if (prior !== void 0) {
+      throw Object.assign(
+        new Error(
+          `Duplicate migration id "${migration.id}": declared in both "${prior}" and "${migration.filePath}". Migration ids must be unique across the project.`
+        ),
+        { code: "DUPLICATE_MIGRATION_ID", id: migration.id, name: "LunoraError", paths: [prior, migration.filePath], status: 500 }
+      );
+    }
+    seenIds.set(migration.id, migration.filePath);
+  }
+};
+const discoverMigrations = (project, lunoraDirectory) => {
+  const filePaths = listLunoraSourceFiles(lunoraDirectory);
+  const migrations = [];
+  for (const filePath of filePaths) {
+    const source = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const relativePath = relative(lunoraDirectory, filePath).split(sep).join("/").replace(TS_EXTENSION_RE, "");
+    for (const statement of source.getVariableStatements()) {
+      if (!statement.isExported()) {
+        continue;
+      }
+      for (const declaration of statement.getDeclarations()) {
+        const migration = migrationFromDeclaration(declaration, relativePath);
+        if (migration) {
+          migrations.push(migration);
+        }
+      }
+    }
+  }
+  migrations.sort((a, b) => a.id.localeCompare(b.id));
+  assertUniqueIds(migrations);
+  return migrations;
+};
+
+export { discoverMigrations as default };

package/dist/packem_shared/discoverNondeterministicCalls-4KiPQxQU.mjs

@@ -0,0 +1,122 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+
+const PROPERTY_CALLS = {
+  "crypto.getRandomValues": "crypto.getRandomValues",
+  "crypto.randomUUID": "crypto.randomUUID",
+  "Date.now": "Date.now",
+  "Math.random": "Math.random"
+};
+const FETCH_GLOBAL_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "self"]);
+const GLOBAL_THIS_RECEIVERS = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
+const receiverNameOf = (receiver) => {
+  if (Node.isIdentifier(receiver)) {
+    return receiver.getText();
+  }
+  if (Node.isPropertyAccessExpression(receiver)) {
+    const inner = receiver.getExpression();
+    if (Node.isIdentifier(inner) && GLOBAL_THIS_RECEIVERS.has(inner.getText())) {
+      return receiver.getName();
+    }
+  }
+  return void 0;
+};
+const nondeterministicCalleeOf = (call) => {
+  const callee = call.getExpression();
+  if (Node.isIdentifier(callee)) {
+    const name = callee.getText();
+    return name === "fetch" || name === "Date" ? name : void 0;
+  }
+  if (!Node.isPropertyAccessExpression(callee)) {
+    return void 0;
+  }
+  const method = callee.getName();
+  const receiverName = receiverNameOf(callee.getExpression());
+  if (receiverName === void 0) {
+    return void 0;
+  }
+  if (method === "fetch" && FETCH_GLOBAL_RECEIVERS.has(receiverName)) {
+    return "fetch";
+  }
+  return PROPERTY_CALLS[`${receiverName}.${method}`];
+};
+const nondeterministicNewOf = (expression) => {
+  const callee = expression.getExpression();
+  if (!Node.isIdentifier(callee) || callee.getText() !== "Date") {
+    return void 0;
+  }
+  const argumentNodes = expression.getArguments();
+  const allLiteral = argumentNodes.every(
+    (argument) => Node.isNumericLiteral(argument) || Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument)
+  );
+  return argumentNodes.length > 0 && allLiteral ? void 0 : "new Date";
+};
+const handlerOf = (call, receiver) => {
+  if (receiver) {
+    const handler = call.getArguments()[0];
+    return handler && (Node.isArrowFunction(handler) || Node.isFunctionExpression(handler)) ? handler : void 0;
+  }
+  const first = call.getArguments()[0];
+  if (!first || !Node.isObjectLiteralExpression(first)) {
+    return void 0;
+  }
+  const handlerProperty = first.getProperty("handler");
+  if (!handlerProperty || !Node.isPropertyAssignment(handlerProperty)) {
+    return void 0;
+  }
+  const initializer = handlerProperty.getInitializer();
+  return initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) ? initializer : void 0;
+};
+const exportedProcedureHandler = (declaration) => {
+  const initializer = declaration.getInitializer();
+  if (!initializer || !Node.isCallExpression(initializer)) {
+    return void 0;
+  }
+  const classified = classifyProcedureCall(initializer);
+  if (!classified || classified.kind !== "query" && classified.kind !== "mutation") {
+    return void 0;
+  }
+  const handler = handlerOf(initializer, classified.receiver);
+  return handler ? { exportName: declaration.getName(), handler, kind: classified.kind } : void 0;
+};
+const callsInHandler = (procedure, file) => {
+  const found = [];
+  for (const callNode of procedure.handler.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    const callee = nondeterministicCalleeOf(callNode);
+    if (callee !== void 0) {
+      found.push({ callee, exportName: procedure.exportName, file, kind: procedure.kind, line: callNode.getStartLineNumber() });
+    }
+  }
+  for (const newNode of procedure.handler.getDescendantsOfKind(SyntaxKind.NewExpression)) {
+    const callee = nondeterministicNewOf(newNode);
+    if (callee !== void 0) {
+      found.push({ callee, exportName: procedure.exportName, file, kind: procedure.kind, line: newNode.getStartLineNumber() });
+    }
+  }
+  return found;
+};
+const callsInSourceFile = (sourceFile, relativePath) => {
+  const found = [];
+  for (const statement of sourceFile.getVariableStatements()) {
+    if (!statement.isExported()) {
+      continue;
+    }
+    for (const declaration of statement.getDeclarations()) {
+      const procedure = exportedProcedureHandler(declaration);
+      if (procedure) {
+        found.push(...callsInHandler(procedure, relativePath));
+      }
+    }
+  }
+  return found;
+};
+const discoverNondeterministicCalls = (project, lunoraDirectory) => {
+  const calls = [];
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    calls.push(...callsInSourceFile(sourceFile, lunoraRelativePath(lunoraDirectory, filePath)));
+  }
+  return calls;
+};
+
+export { discoverNondeterministicCalls as default };

package/dist/packem_shared/discoverQueries-BkIi0dBD.mjs

@@ -0,0 +1,62 @@
+import { SyntaxKind, Node } from 'ts-morph';
+import { listLunoraSourceFiles, lunoraRelativePath } from './discoverFunctions-DEgAcRuD.mjs';
+
+const INDEX_METHODS = /* @__PURE__ */ new Set(["withIndex", "withSearchIndex"]);
+const isDatabaseQueryCall = (call) => {
+  const callee = call.getExpression();
+  if (!Node.isPropertyAccessExpression(callee) || callee.getName() !== "query") {
+    return false;
+  }
+  const receiver = callee.getExpression();
+  if (Node.isPropertyAccessExpression(receiver)) {
+    return receiver.getName() === "db";
+  }
+  return Node.isIdentifier(receiver) && receiver.getText() === "db";
+};
+const chainMethods = (queryCall) => {
+  const methods = [];
+  let node = queryCall;
+  for (; ; ) {
+    const parent = node.getParent();
+    if (!parent || !Node.isPropertyAccessExpression(parent)) {
+      break;
+    }
+    const callParent = parent.getParent();
+    if (!callParent || !Node.isCallExpression(callParent)) {
+      break;
+    }
+    methods.push(parent.getName());
+    node = callParent;
+  }
+  return methods;
+};
+const tableOf = (queryCall) => {
+  const argument = queryCall.getArguments()[0];
+  return argument && Node.isStringLiteral(argument) ? argument.getLiteralText() : "";
+};
+const discoverQueries = (project, lunoraDirectory) => {
+  const reads = [];
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const relativePath = lunoraRelativePath(lunoraDirectory, filePath);
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      if (!isDatabaseQueryCall(call)) {
+        continue;
+      }
+      const methods = chainMethods(call);
+      if (!methods.includes("filter")) {
+        continue;
+      }
+      reads.push({
+        file: relativePath,
+        hasFilter: true,
+        hasIndex: methods.some((method) => INDEX_METHODS.has(method)),
+        line: call.getStartLineNumber(),
+        table: tableOf(call)
+      });
+    }
+  }
+  return reads;
+};
+
+export { discoverQueries as default };