@lunora/codegen 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/discoverRlsMetadata-DpRB1HMe.mjs

@@ -0,0 +1,280 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { listLunoraSourceFiles, lunoraRelativePath, classifyProcedureCall } from './discoverFunctions-DEgAcRuD.mjs';
+
+const isRlsCall = (node) => {
+  if (!Node.isCallExpression(node)) {
+    return false;
+  }
+  const callee = node.getExpression();
+  if (Node.isIdentifier(callee)) {
+    return callee.getText() === "rls";
+  }
+  if (Node.isPropertyAccessExpression(callee)) {
+    return callee.getName() === "rls";
+  }
+  return false;
+};
+const extractPolicyTables = (rlsCall) => {
+  const argument = rlsCall.getArguments()[0];
+  if (!argument || !Node.isArrayLiteralExpression(argument)) {
+    return [];
+  }
+  const tables = [];
+  for (const element of argument.getElements()) {
+    if (!Node.isObjectLiteralExpression(element)) {
+      continue;
+    }
+    const tableProperty = element.getProperty("table");
+    if (!tableProperty || !Node.isPropertyAssignment(tableProperty)) {
+      continue;
+    }
+    const initializer = tableProperty.getInitializer();
+    if (initializer && Node.isStringLiteral(initializer)) {
+      tables.push(initializer.getLiteralText());
+    }
+  }
+  return tables;
+};
+const rlsCallsInChain = (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 && isRlsCall(argument)) {
+        calls.push(argument);
+      }
+    }
+    node = chainCallee.getExpression();
+  }
+  return calls;
+};
+const rlsFromBuilderChain = (receiver) => {
+  const calls = rlsCallsInChain(receiver);
+  return { rlsTables: calls.flatMap((call) => extractPolicyTables(call)), usesRls: calls.length > 0 };
+};
+const READ_METHODS = /* @__PURE__ */ new Set(["findFirst", "findFirstOrThrow", "findMany", "get", "query"]);
+const WRITE_METHODS = /* @__PURE__ */ new Set(["delete", "deleteMany", "insert", "insertMany", "patch", "patchMany", "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 ? rlsFromBuilderChain(classified.receiver) : { rlsTables: [], usesRls: false };
+  const { tablesRead, tablesWritten } = tablesAccessedIn(declaration);
+  return {
+    exportName: declaration.getName(),
+    file: relativePath,
+    rlsTables: chain.rlsTables,
+    tablesRead,
+    tablesWritten,
+    usesRls: chain.usesRls,
+    visibility: classified.visibility
+  };
+};
+const discoverRlsProcedures = (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 POLICY_OPERATIONS = /* @__PURE__ */ new Set(["delete", "insert", "read", "update"]);
+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 extractPolicies = (rlsCall, file, procedure) => {
+  const argument = rlsCall.getArguments()[0];
+  if (!argument || !Node.isArrayLiteralExpression(argument)) {
+    return [];
+  }
+  const policies = [];
+  for (const element of argument.getElements()) {
+    if (!Node.isObjectLiteralExpression(element)) {
+      continue;
+    }
+    const on = stringPropertyOf(element, "on");
+    if (on === void 0 || !POLICY_OPERATIONS.has(on)) {
+      continue;
+    }
+    policies.push({ file, on, procedure, table: stringPropertyOf(element, "table") ?? "" });
+  }
+  return policies;
+};
+const extractRolePermissions = (roleObject) => {
+  if (!Node.isObjectLiteralExpression(roleObject)) {
+    return [];
+  }
+  const property = roleObject.getProperty("permissions");
+  if (!property || !Node.isPropertyAssignment(property)) {
+    return [];
+  }
+  const initializer = property.getInitializer();
+  if (!initializer || !Node.isArrayLiteralExpression(initializer)) {
+    return [];
+  }
+  const permissions = [];
+  for (const element of initializer.getElements()) {
+    if (Node.isStringLiteral(element)) {
+      permissions.push(element.getLiteralText());
+      continue;
+    }
+    if (Node.isCallExpression(element)) {
+      const firstArgument = element.getArguments()[0];
+      if (firstArgument && Node.isStringLiteral(firstArgument)) {
+        permissions.push(firstArgument.getLiteralText());
+      }
+    }
+  }
+  return permissions;
+};
+const withDescription = (role, description) => description === void 0 ? role : { ...role, description };
+const roleFromElement = (element) => {
+  if (Node.isCallExpression(element)) {
+    const nameArgument = element.getArguments()[0];
+    if (!nameArgument || !Node.isStringLiteral(nameArgument)) {
+      return void 0;
+    }
+    const optionsObject = element.getArguments()[1];
+    const description = optionsObject ? stringPropertyOf(optionsObject, "description") : void 0;
+    const permissions = optionsObject ? extractRolePermissions(optionsObject) : [];
+    return withDescription({ name: nameArgument.getLiteralText(), permissions }, description);
+  }
+  if (Node.isObjectLiteralExpression(element)) {
+    const name = stringPropertyOf(element, "name");
+    if (name === void 0) {
+      return void 0;
+    }
+    return withDescription({ name, permissions: extractRolePermissions(element) }, stringPropertyOf(element, "description"));
+  }
+  return void 0;
+};
+const extractRoles = (rlsCall) => {
+  const optionsArgument = rlsCall.getArguments()[1];
+  if (!optionsArgument || !Node.isObjectLiteralExpression(optionsArgument)) {
+    return [];
+  }
+  const rolesProperty = optionsArgument.getProperty("roles");
+  if (!rolesProperty || !Node.isPropertyAssignment(rolesProperty)) {
+    return [];
+  }
+  const initializer = rolesProperty.getInitializer();
+  if (!initializer || !Node.isArrayLiteralExpression(initializer)) {
+    return [];
+  }
+  const roles = [];
+  for (const element of initializer.getElements()) {
+    const role = roleFromElement(element);
+    if (role) {
+      roles.push(role);
+    }
+  }
+  return roles;
+};
+const rlsMetadataFromChain = (receiver, file, procedure) => {
+  const calls = rlsCallsInChain(receiver);
+  return {
+    policies: calls.flatMap((call) => extractPolicies(call, file, procedure)),
+    roles: calls.flatMap((call) => extractRoles(call))
+  };
+};
+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 discoverRlsMetadata = (project, lunoraDirectory) => {
+  const policies = [];
+  const rolesByName = /* @__PURE__ */ new Map();
+  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)) {
+      const metadata = rlsMetadataFromChain(receiver, relativePath, name);
+      policies.push(...metadata.policies);
+      for (const role of metadata.roles) {
+        if (!rolesByName.has(role.name)) {
+          rolesByName.set(role.name, role);
+        }
+      }
+    }
+  }
+  return { policies, roles: [...rolesByName.values()] };
+};
+
+export { discoverRlsProcedures as default, discoverRlsMetadata };