@lunora/codegen 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/discoverSchema-BBulgGbH.mjs

@@ -0,0 +1,542 @@
+import { SyntaxKind, Node } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-54jWDxA9.mjs';
+import { a as parseObjectShape } from './parse-validator-tuQtHrsr.mjs';
+
+const VECTOR_METRICS = /* @__PURE__ */ new Set(["cosine", "dot-product", "euclidean"]);
+const ON_DELETE_ACTIONS = /* @__PURE__ */ new Set(["cascade", "restrict", "set null"]);
+const RESERVED_TABLE_NAMES = /* @__PURE__ */ new Set(["delete", "get", "insert", "normalizeId", "patch", "query", "replace", "system"]);
+const assertTableNameAllowed = (name, node) => {
+  if (RESERVED_TABLE_NAMES.has(name)) {
+    throw diagnosticAt(
+      node,
+      `table name "${name}" is reserved — it collides with a \`ctx.db\` member (one of ${[...RESERVED_TABLE_NAMES].map((reserved) => `"${reserved}"`).join(", ")}). Rename the table.`
+    );
+  }
+};
+const getStringProperty = (object, key) => {
+  const property = object.getProperty(key);
+  if (property && Node.isPropertyAssignment(property)) {
+    const initializer = property.getInitializer();
+    if (initializer && Node.isStringLiteral(initializer)) {
+      return initializer.getLiteralText();
+    }
+  }
+  return void 0;
+};
+const getNumberProperty = (object, key) => {
+  const property = object.getProperty(key);
+  if (property && Node.isPropertyAssignment(property)) {
+    const initializer = property.getInitializer();
+    if (initializer && Node.isNumericLiteral(initializer)) {
+      return Number(initializer.getLiteralText());
+    }
+  }
+  return void 0;
+};
+const getStringArrayProperty = (object, key) => {
+  const property = object.getProperty(key);
+  if (property && Node.isPropertyAssignment(property)) {
+    const initializer = property.getInitializer();
+    if (initializer && Node.isArrayLiteralExpression(initializer)) {
+      return initializer.getElements().filter((element) => Node.isStringLiteral(element)).map((element) => element.getLiteralText());
+    }
+  }
+  return void 0;
+};
+const asMetric = (value) => value && VECTOR_METRICS.has(value) ? value : void 0;
+const asOnDelete = (value) => value && ON_DELETE_ACTIONS.has(value) ? value : void 0;
+const relationsObjectBody = (argument) => {
+  if (!Node.isArrowFunction(argument)) {
+    return void 0;
+  }
+  let body = argument.getBody();
+  if (Node.isParenthesizedExpression(body)) {
+    body = body.getExpression();
+  } else if (Node.isBlock(body)) {
+    const returnStatement = body.getStatements().find((statement) => Node.isReturnStatement(statement));
+    body = returnStatement && Node.isReturnStatement(returnStatement) ? returnStatement.getExpression() ?? body : body;
+  }
+  return Node.isObjectLiteralExpression(body) ? body : void 0;
+};
+const relationFromProperty = (property) => {
+  if (!Node.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node.isCallExpression(initializer)) {
+    return void 0;
+  }
+  const callee = initializer.getExpression();
+  if (!Node.isPropertyAccessExpression(callee)) {
+    return void 0;
+  }
+  const method = callee.getName();
+  if (method !== "one" && method !== "many") {
+    return void 0;
+  }
+  const [tableArgument, optionsExpression] = initializer.getArguments();
+  const table = tableArgument && Node.isStringLiteral(tableArgument) ? tableArgument.getLiteralText() : "_unknown_";
+  let field = "_unknown_";
+  let references = "_id";
+  let onDelete;
+  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
+    field = getStringProperty(optionsExpression, "field") ?? field;
+    references = getStringProperty(optionsExpression, "references") ?? references;
+    onDelete = method === "one" ? asOnDelete(getStringProperty(optionsExpression, "onDelete")) : void 0;
+  }
+  return { field, kind: method, name: property.getName(), onDelete, references, table };
+};
+const parseRelations = (argument) => {
+  const body = relationsObjectBody(argument);
+  if (!body) {
+    return [];
+  }
+  const relations = [];
+  for (const property of body.getProperties()) {
+    const relation = relationFromProperty(property);
+    if (relation) {
+      relations.push(relation);
+    }
+  }
+  return relations;
+};
+const indexNameOf = (nameArgument) => nameArgument && Node.isStringLiteral(nameArgument) ? nameArgument.getLiteralText() : "_unnamed_";
+const parseIndexCall = (args) => {
+  const [indexName, fieldsExpression, optionsExpression] = args;
+  let unique = false;
+  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
+    const property = optionsExpression.getProperty("unique");
+    if (property && Node.isPropertyAssignment(property)) {
+      const initializer = property.getInitializer();
+      if (initializer && !Node.isTrueLiteral(initializer) && !Node.isFalseLiteral(initializer)) {
+        throw diagnosticAt(initializer, `\`unique\` must be a literal \`true\` or \`false\`, got ${JSON.stringify(initializer.getText())}`);
+      }
+      unique = initializer ? Node.isTrueLiteral(initializer) : false;
+    }
+  }
+  const fields = fieldsExpression && Node.isArrayLiteralExpression(fieldsExpression) ? fieldsExpression.getElements().filter((element) => Node.isStringLiteral(element)).map((element) => element.getLiteralText()) : [];
+  return { fields, name: indexNameOf(indexName), unique };
+};
+const parseSearchIndexCall = (args) => {
+  const [indexName, optionsExpression] = args;
+  let field = "_unknown_";
+  let filterFields;
+  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
+    field = getStringProperty(optionsExpression, "field") ?? field;
+    filterFields = getStringArrayProperty(optionsExpression, "filterFields");
+  }
+  return { field, filterFields, name: indexNameOf(indexName) };
+};
+const rankSortKeyFromElement = (element) => {
+  if (!Node.isObjectLiteralExpression(element)) {
+    return void 0;
+  }
+  const field = getStringProperty(element, "field");
+  if (field === void 0) {
+    return void 0;
+  }
+  const direction = getStringProperty(element, "direction");
+  return { direction: direction === "desc" ? "desc" : "asc", field };
+};
+const parseRankIndexCall = (args) => {
+  const [indexName, optionsExpression] = args;
+  let sortBy = [];
+  let partitionBy;
+  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
+    const sortByProperty = optionsExpression.getProperty("sortBy");
+    if (sortByProperty && Node.isPropertyAssignment(sortByProperty)) {
+      const initializer = sortByProperty.getInitializer();
+      if (initializer && Node.isArrayLiteralExpression(initializer)) {
+        sortBy = initializer.getElements().map((element) => rankSortKeyFromElement(element)).filter((key) => key !== void 0);
+      }
+    }
+    partitionBy = getStringArrayProperty(optionsExpression, "partitionBy");
+  }
+  return { name: indexNameOf(indexName), partitionBy, sortBy };
+};
+const parseVectorizeCall = (args, table) => {
+  const [fieldArgument, optionsExpression] = args;
+  const field = fieldArgument && Node.isStringLiteral(fieldArgument) ? fieldArgument.getLiteralText() : "_unknown_";
+  if (!optionsExpression || !Node.isObjectLiteralExpression(optionsExpression)) {
+    return void 0;
+  }
+  return {
+    dimensions: getNumberProperty(optionsExpression, "dimensions"),
+    field,
+    metadata: getStringArrayProperty(optionsExpression, "metadata"),
+    metric: asMetric(getStringProperty(optionsExpression, "metric")),
+    name: getStringProperty(optionsExpression, "index") ?? "_unnamed_",
+    table
+  };
+};
+const parseGlobalBackend = (args) => {
+  const optionsExpression = args[0];
+  if (optionsExpression && Node.isObjectLiteralExpression(optionsExpression)) {
+    const backend = getStringProperty(optionsExpression, "backend");
+    if (backend === "hyperdrive") {
+      return "hyperdrive";
+    }
+  }
+  return "d1";
+};
+const applyTableMethod = (accumulator, method, args, name) => {
+  switch (method) {
+    case "externallyManaged": {
+      accumulator.externallyManaged = true;
+      break;
+    }
+    case "global": {
+      accumulator.shardMode = "global";
+      accumulator.globalBackend = parseGlobalBackend(args);
+      break;
+    }
+    case "index": {
+      accumulator.indexes.push(parseIndexCall(args));
+      break;
+    }
+    case "rankIndex": {
+      accumulator.rankIndexes.push(parseRankIndexCall(args));
+      break;
+    }
+    case "relations": {
+      const builder = args[0];
+      if (builder) {
+        accumulator.relations.push(...parseRelations(builder));
+      }
+      break;
+    }
+    case "searchIndex": {
+      accumulator.searchIndexes.push(parseSearchIndexCall(args));
+      break;
+    }
+    case "shardBy": {
+      const field = args[0];
+      accumulator.shardMode = { field: field && Node.isStringLiteral(field) ? field.getLiteralText() : "_unknown_", kind: "shardBy" };
+      break;
+    }
+    case "vectorize": {
+      const vectorIndex = parseVectorizeCall(args, name);
+      if (vectorIndex) {
+        accumulator.vectorIndexes.push(vectorIndex);
+      }
+      break;
+    }
+  }
+};
+const parseTableBuilder = (expression, name) => {
+  const accumulator = {
+    externallyManaged: false,
+    indexes: [],
+    rankIndexes: [],
+    relations: [],
+    searchIndexes: [],
+    shardMode: "root",
+    vectorIndexes: []
+  };
+  let shape = {};
+  let current = expression;
+  while (Node.isCallExpression(current)) {
+    const callee = current.getExpression();
+    const args = current.getArguments();
+    if (Node.isPropertyAccessExpression(callee)) {
+      applyTableMethod(accumulator, callee.getName(), args, name);
+      current = callee.getExpression();
+    } else if (Node.isIdentifier(callee) && callee.getText() === "defineTable") {
+      const first = args[0];
+      if (first && Node.isObjectLiteralExpression(first)) {
+        shape = parseObjectShape(first);
+      }
+      break;
+    } else {
+      break;
+    }
+  }
+  return {
+    externallyManaged: accumulator.externallyManaged,
+    globalBackend: accumulator.shardMode === "global" ? accumulator.globalBackend ?? "d1" : void 0,
+    indexes: accumulator.indexes,
+    name,
+    rankIndexes: accumulator.rankIndexes,
+    relations: accumulator.relations,
+    searchIndexes: accumulator.searchIndexes,
+    shape,
+    shardMode: accumulator.shardMode,
+    vectorIndexes: accumulator.vectorIndexes
+  };
+};
+const sourceTableOf = (optionsExpression) => {
+  const sourceProperty = optionsExpression.getProperty("source");
+  if (sourceProperty && Node.isPropertyAssignment(sourceProperty)) {
+    const sourceInitializer = sourceProperty.getInitializer();
+    if (sourceInitializer && Node.isObjectLiteralExpression(sourceInitializer)) {
+      return getStringProperty(sourceInitializer, "table") ?? "_unknown_";
+    }
+  }
+  return "_unknown_";
+};
+const standaloneVectorIndexFromProperty = (property) => {
+  if (!Node.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node.isCallExpression(initializer)) {
+    return void 0;
+  }
+  const callee = initializer.getExpression();
+  if (!Node.isIdentifier(callee) || callee.getText() !== "defineVectorIndex") {
+    return void 0;
+  }
+  const optionsExpression = initializer.getArguments()[0];
+  if (!optionsExpression || !Node.isObjectLiteralExpression(optionsExpression)) {
+    return void 0;
+  }
+  const nameNode = property.getNameNode();
+  const indexName = Node.isStringLiteral(nameNode) ? nameNode.getLiteralText() : nameNode.getText();
+  return {
+    dimensions: getNumberProperty(optionsExpression, "dimensions"),
+    metric: asMetric(getStringProperty(optionsExpression, "metric")),
+    name: indexName,
+    table: sourceTableOf(optionsExpression)
+  };
+};
+const parseStandaloneVectorIndexes = (object) => {
+  const result = [];
+  for (const property of object.getProperties()) {
+    const index = standaloneVectorIndexFromProperty(property);
+    if (index) {
+      result.push(index);
+    }
+  }
+  return result;
+};
+const prefixTableName = (key, bareName) => `${key}_${bareName}`;
+const rewriteReference = (target, key, bareNames) => bareNames.has(target) ? prefixTableName(key, target) : target;
+const namespaceExtensionTable = (table, key, bareNames) => {
+  const ownPrefixed = prefixTableName(key, table.name);
+  return {
+    ...table,
+    name: ownPrefixed,
+    relations: table.relations.map((relation) => {
+      return { ...relation, table: rewriteReference(relation.table, key, bareNames) };
+    }),
+    // Inline `.vectorize()` stamps `table` with the bare owner name, so it
+    // is always one of `bareNames` and resolves to `ownPrefixed`.
+    vectorIndexes: table.vectorIndexes.map((index) => {
+      return { ...index, table: rewriteReference(index.table, key, bareNames) };
+    })
+  };
+};
+const declarationInitializer = (declaration) => {
+  if (Node.isVariableDeclaration(declaration) || Node.isPropertyAssignment(declaration)) {
+    return declaration.getInitializer();
+  }
+  if (Node.isShorthandPropertyAssignment(declaration)) {
+    return declaration.getNameNode();
+  }
+  return void 0;
+};
+const objectPropertyInitializer = (objectLiteral, name) => {
+  const property = objectLiteral.getProperty(name);
+  if (property && Node.isPropertyAssignment(property)) {
+    return property.getInitializer();
+  }
+  return void 0;
+};
+const isInlineExtensionCall = (argument) => {
+  if (!Node.isCallExpression(argument)) {
+    return false;
+  }
+  const callee = argument.getExpression();
+  return Node.isIdentifier(callee) && callee.getText() === "defineSchemaExtension";
+};
+const extensionTargetIdentifier = (argument) => {
+  if (Node.isIdentifier(argument)) {
+    return argument;
+  }
+  if (Node.isPropertyAccessExpression(argument)) {
+    return argument.getNameNode();
+  }
+  return void 0;
+};
+const nextExpressionFromDeclaration = (declaration, argument) => {
+  const initializer = declarationInitializer(declaration);
+  if (!initializer) {
+    return void 0;
+  }
+  if (Node.isPropertyAccessExpression(argument) && Node.isObjectLiteralExpression(initializer)) {
+    return objectPropertyInitializer(initializer, argument.getName());
+  }
+  return initializer;
+};
+const resolveSchemaExtensionCall = (argument) => {
+  let current = argument;
+  let hops = 0;
+  while (current && hops < 32) {
+    hops += 1;
+    if (isInlineExtensionCall(current)) {
+      return current;
+    }
+    const target = extensionTargetIdentifier(current);
+    const symbol = target && Node.isIdentifier(target) ? target.getSymbol() : void 0;
+    const declarations = symbol?.getAliasedSymbol()?.getDeclarations() ?? symbol?.getDeclarations() ?? [];
+    const first = declarations[0];
+    if (!first) {
+      return void 0;
+    }
+    const declarationFile = first.getSourceFile();
+    if (declarationFile.isInNodeModules() || declarationFile.isDeclarationFile()) {
+      return void 0;
+    }
+    current = nextExpressionFromDeclaration(first, current);
+  }
+  return void 0;
+};
+const extensionPartsOf = (call) => {
+  const [keyArgument, optionsArgument] = call.getArguments();
+  if (!keyArgument || !Node.isStringLiteral(keyArgument)) {
+    return void 0;
+  }
+  if (!optionsArgument || !Node.isObjectLiteralExpression(optionsArgument)) {
+    return void 0;
+  }
+  return { key: keyArgument.getLiteralText(), options: optionsArgument };
+};
+const parseExtensionTables = (options) => {
+  const tablesProperty = options.getProperty("tables");
+  if (!tablesProperty || !Node.isPropertyAssignment(tablesProperty)) {
+    return [];
+  }
+  const tablesObject = tablesProperty.getInitializer();
+  if (!tablesObject || !Node.isObjectLiteralExpression(tablesObject)) {
+    return [];
+  }
+  const tables = [];
+  for (const property of tablesObject.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const initializer = property.getInitializer();
+    if (!initializer) {
+      continue;
+    }
+    tables.push(parseTableBuilder(initializer, property.getName()));
+  }
+  return tables;
+};
+const parseExtensionVectorIndexes = (options) => {
+  const property = options.getProperty("vectorIndexes");
+  if (!property || !Node.isPropertyAssignment(property)) {
+    return [];
+  }
+  const object = property.getInitializer();
+  if (!object || !Node.isObjectLiteralExpression(object)) {
+    return [];
+  }
+  return parseStandaloneVectorIndexes(object);
+};
+const mergeExtension = (key, options) => {
+  const bareTables = parseExtensionTables(options);
+  const bareNames = new Set(bareTables.map((table) => table.name));
+  const tables = bareTables.map((table) => namespaceExtensionTable(table, key, bareNames));
+  const vectorIndexes = parseExtensionVectorIndexes(options).map((index) => {
+    return { ...index, name: prefixTableName(key, index.name), table: rewriteReference(index.table, key, bareNames) };
+  });
+  return { tables, vectorIndexes };
+};
+const mergeExtendCall = (extendCall) => {
+  const extendArgument = extendCall.getArguments()[0];
+  if (!extendArgument) {
+    return void 0;
+  }
+  const resolved = resolveSchemaExtensionCall(extendArgument);
+  if (!resolved) {
+    console.warn(
+      `@lunora/codegen: skipping \`.extend(${extendArgument.getText()})\` — its \`defineSchemaExtension(...)\` definition could not be resolved from local sources (cross-package node_modules/.d.ts resolution is a deferred phase). Extension tables will be absent from the generated types.`
+    );
+    return void 0;
+  }
+  const parts = extensionPartsOf(resolved);
+  if (!parts) {
+    console.warn(`@lunora/codegen: skipping \`.extend(...)\` — \`defineSchemaExtension\` requires a string \`key\` and an options object literal.`);
+    return void 0;
+  }
+  return mergeExtension(parts.key, parts.options);
+};
+const extendCallsOf = (defineSchemaCall) => {
+  const calls = [];
+  let current = defineSchemaCall;
+  for (; ; ) {
+    const parent = current.getParent();
+    if (!parent || !Node.isPropertyAccessExpression(parent)) {
+      break;
+    }
+    const callParent = parent.getParent();
+    if (!callParent || !Node.isCallExpression(callParent)) {
+      break;
+    }
+    if (parent.getName() === "extend") {
+      calls.push(callParent);
+    }
+    current = callParent;
+  }
+  return calls;
+};
+const parseBaseTables = (object) => {
+  const tables = [];
+  for (const property of object.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const initializer = property.getInitializer();
+    if (initializer) {
+      const name = property.getName();
+      assertTableNameAllowed(name, property.getNameNode());
+      tables.push(parseTableBuilder(initializer, name));
+    }
+  }
+  return tables;
+};
+const applyExtensions = (defineSchemaCall, tables) => {
+  const existingTableNames = new Set(tables.map((table) => table.name));
+  const vectorIndexes = [];
+  for (const extendCall of extendCallsOf(defineSchemaCall)) {
+    const merged = mergeExtendCall(extendCall);
+    if (!merged) {
+      continue;
+    }
+    for (const table of merged.tables) {
+      if (existingTableNames.has(table.name)) {
+        throw diagnosticAt(
+          extendCall,
+          `defineSchema(...).extend(...): table "${table.name}" already exists — another extension with the same key already contributed it.`
+        );
+      }
+      existingTableNames.add(table.name);
+      tables.push(table);
+    }
+    vectorIndexes.push(...merged.vectorIndexes);
+  }
+  return vectorIndexes;
+};
+const discoverSchema = (project, schemaPath) => {
+  const file = project.addSourceFileAtPath(schemaPath);
+  const defineSchemaCall = file.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => {
+    const callee = call.getExpression();
+    return Node.isIdentifier(callee) && callee.getText() === "defineSchema";
+  });
+  if (!defineSchemaCall) {
+    throw new Error(`defineSchema() not found in ${schemaPath}`);
+  }
+  const argument = defineSchemaCall.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    throw diagnosticAt(defineSchemaCall, "defineSchema() expects an object literal");
+  }
+  const tables = parseBaseTables(argument);
+  const standaloneArgument = defineSchemaCall.getArguments()[1];
+  const standaloneVectorIndexes = standaloneArgument && Node.isObjectLiteralExpression(standaloneArgument) ? parseStandaloneVectorIndexes(standaloneArgument) : [];
+  const extensionStandaloneVectorIndexes = applyExtensions(defineSchemaCall, tables);
+  const vectorIndexes = [...tables.flatMap((table) => table.vectorIndexes), ...standaloneVectorIndexes, ...extensionStandaloneVectorIndexes];
+  return { tables, vectorIndexes };
+};
+
+export { discoverSchema as default };

package/dist/packem_shared/discoverStorageRulesMetadata-DAqJUxUv.mjs

@@ -0,0 +1,97 @@
+import { Node } from 'ts-morph';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+
+const STORAGE_OPERATIONS = /* @__PURE__ */ new Set(["delete", "list", "read", "write"]);
+const isStorageRulesCall = (node) => {
+  if (!Node.isCallExpression(node)) {
+    return false;
+  }
+  const callee = node.getExpression();
+  if (Node.isIdentifier(callee)) {
+    return callee.getText() === "storageRules";
+  }
+  return Node.isPropertyAccessExpression(callee) && callee.getName() === "storageRules";
+};
+const storageRulesCallsInChain = (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 && isStorageRulesCall(argument)) {
+        calls.push(argument);
+      }
+    }
+    node = chainCallee.getExpression();
+  }
+  return calls;
+};
+const stringPropertyOf = (object, name) => {
+  if (!Node.isObjectLiteralExpression(object)) {
+    return void 0;
+  }
+  const property = object.getProperty(name);
+  if (!property || !Node.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const initializer = property.getInitializer();
+  return initializer && Node.isStringLiteral(initializer) ? initializer.getLiteralText() : void 0;
+};
+const extractRules = (call, file, procedure) => {
+  const argument = call.getArguments()[0];
+  if (!argument || !Node.isArrayLiteralExpression(argument)) {
+    return [];
+  }
+  const rules = [];
+  for (const element of argument.getElements()) {
+    if (!Node.isObjectLiteralExpression(element)) {
+      continue;
+    }
+    const on = stringPropertyOf(element, "on");
+    if (on === void 0 || !STORAGE_OPERATIONS.has(on)) {
+      continue;
+    }
+    const prefix = stringPropertyOf(element, "prefix");
+    const rule = { bucket: stringPropertyOf(element, "bucket") ?? "", file, on, procedure };
+    if (prefix !== void 0) {
+      rule.prefix = prefix;
+    }
+    rules.push(rule);
+  }
+  return rules;
+};
+const exportedProcedureChains = (sourceFile) => {
+  const chains = [];
+  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) {
+        chains.push({ name: declaration.getName(), receiver: classified.receiver });
+      }
+    }
+  }
+  return chains;
+};
+const discoverStorageRulesMetadata = (project, lunoraDirectory) => {
+  const rules = [];
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const relativePath = lunoraRelativePath(lunoraDirectory, filePath);
+    for (const { name, receiver } of exportedProcedureChains(sourceFile)) {
+      for (const call of storageRulesCallsInChain(receiver)) {
+        rules.push(...extractRules(call, relativePath, name));
+      }
+    }
+  }
+  return { rules };
+};
+
+export { discoverStorageRulesMetadata as default };