@facilis.dev/analyze 0.0.0-stage → 0.1.1

package/src/passes/schema-tables.ts

@@ -0,0 +1,216 @@
+import {
+  callArguments,
+  identifierName,
+  memberName,
+  objectEntries,
+  propertyName,
+  propertyValue,
+  unwrapExpression,
+  type AstNode,
+} from "../ast/node.ts";
+import { diagnostic } from "../diagnostics.ts";
+import type { ModuleGraph, ProjectFile } from "../module-graph.ts";
+import { staticString } from "../static-eval.ts";
+import type { ConfigFacts, Diagnostic, TableFact, UnknownFact } from "../types.ts";
+import { buildColumnFact, type ColumnReference } from "./schema-columns.ts";
+import { scopeOf, type ScopedColumn } from "./schema-scope.ts";
+import {
+  createDslResolver,
+  nodeRef,
+  schemaDiagnostics,
+  schemaUnknown,
+  topLevelDeclarators,
+  type DslResolver,
+} from "./schema-dsl.ts";
+import { buildPolicyFacts } from "./schema-policies.ts";
+
+export interface TableDraft {
+  readonly fact: TableFact;
+  readonly binding: string | null;
+  readonly references: readonly ColumnReference[];
+}
+
+export interface TableScan {
+  readonly drafts: readonly TableDraft[];
+  readonly diagnostics: readonly Diagnostic[];
+}
+
+interface TableCall {
+  readonly call: AstNode;
+  readonly methods: readonly string[];
+}
+
+/** Local `pgEnum("name", values)` consts; a column built from one is a known enum builder. */
+function collectEnumBindings(
+  file: ProjectFile,
+  resolver: DslResolver,
+  graph: ModuleGraph,
+): Map<string, string> {
+  const enums = new Map<string, string>();
+  for (const declarator of topLevelDeclarators(file.program)) {
+    const binding = identifierName(declarator.id);
+    const init = unwrapExpression(declarator.init);
+    if (binding === undefined || init?.type !== "CallExpression") continue;
+    const symbol = resolver(init.callee);
+    if (symbol?.pkg !== "pg-core" || symbol.name !== "pgEnum") continue;
+    const name = staticString(callArguments(init)[0], { graph, file: file.path });
+    enums.set(binding, name.ok ? name.value : binding);
+  }
+  return enums;
+}
+
+/** The `pgTable` call inside `pgTable(...).enableRLS()`, plus the chain methods after it. */
+function findTableCall(init: unknown, resolver: DslResolver): TableCall | null {
+  let current = unwrapExpression(init);
+  const methods: string[] = [];
+  let guard = 0;
+  while (current?.type === "CallExpression" && guard < 32) {
+    guard += 1;
+    const callee = unwrapExpression(current.callee);
+    if (callee === undefined) return null;
+    if (callee.type === "MemberExpression") {
+      const name = memberName(callee);
+      if (name === undefined) return null;
+      methods.unshift(name);
+      current = unwrapExpression(callee.object);
+      continue;
+    }
+    const symbol = resolver(callee);
+    if (symbol?.pkg !== "pg-core" || symbol.name !== "pgTable") return null;
+    return { call: current, methods };
+  }
+  return null;
+}
+
+function buildTableDraft(input: {
+  readonly graph: ModuleGraph;
+  readonly file: ProjectFile;
+  readonly resolver: DslResolver;
+  readonly enums: ReadonlyMap<string, string>;
+  readonly config: ConfigFacts;
+  readonly binding: string | null;
+  readonly tableCall: TableCall;
+}): { draft: TableDraft; diagnostics: readonly Diagnostic[] } {
+  const { graph, file, resolver, enums, config, binding, tableCall } = input;
+  const source = nodeRef(file, tableCall.call);
+  const args = callArguments(tableCall.call);
+  const unknowns: UnknownFact[] = [];
+  const diagnostics: Diagnostic[] = [];
+  const nameResult = staticString(args[0], { graph, file: file.path });
+  let name: string;
+  if (nameResult.ok && nameResult.value.length > 0) {
+    name = nameResult.value;
+  } else {
+    name = binding ?? "unknown";
+    unknowns.push(schemaUnknown('table name of "' + name + '" is not a static string', source));
+  }
+
+  const columns: ScopedColumn[] = [];
+  const references: ColumnReference[] = [];
+  const columnsArgument = unwrapExpression(args[1]);
+  if (columnsArgument?.type !== "ObjectExpression") {
+    unknowns.push(
+      schemaUnknown('columns of table "' + name + '" are not an object literal', source),
+    );
+  } else {
+    for (const entry of objectEntries(columnsArgument)) {
+      if (entry.type === "SpreadElement") {
+        unknowns.push(
+          schemaUnknown(
+            'spread columns in table "' + name + '" are outside the DSL',
+            nodeRef(file, entry),
+          ),
+        );
+        continue;
+      }
+      const property = propertyName(entry);
+      if (property === undefined) {
+        unknowns.push(
+          schemaUnknown(
+            'computed column key in table "' + name + '" is outside the DSL',
+            nodeRef(file, entry),
+          ),
+        );
+        continue;
+      }
+      const result = buildColumnFact({
+        property,
+        expression: propertyValue(entry),
+        propertyNode: entry,
+        file,
+        graph,
+        resolver,
+        enums,
+      });
+      diagnostics.push(...result.diagnostics);
+      if (result.reference !== null) {
+        references.push({ column: property, target: result.reference });
+      }
+      columns.push({ column: result.column, tenant: result.tenant });
+    }
+  }
+
+  const policyScan = buildPolicyFacts({
+    extras: args[2],
+    file,
+    graph,
+    resolver,
+  });
+  diagnostics.push(...policyScan.diagnostics);
+  const rlsEnabled = tableCall.methods.includes("enableRLS");
+  const scope = scopeOf(columns, config);
+  const fact: TableFact = {
+    name,
+    binding,
+    columns: columns.map((entry) => entry.column),
+    primaryKey: columns
+      .filter((entry) => entry.column.primaryKey)
+      .map((entry) => entry.column.property),
+    foreignKeys: [],
+    policies: policyScan.policies,
+    rlsEnabled,
+    scope,
+    source,
+    unknown: unknowns,
+  };
+  diagnostics.push(...schemaDiagnostics(unknowns));
+  if (scope !== null && (!rlsEnabled || policyScan.policies.length === 0)) {
+    diagnostics.push(
+      diagnostic(
+        "rls-on-scoped-table",
+        "error",
+        'scoped table "' + name + '" must call .enableRLS() and declare a policy',
+        source,
+      ),
+    );
+  }
+  return { draft: { fact, binding, references }, diagnostics };
+}
+
+export function collectTableDrafts(
+  graph: ModuleGraph,
+  file: ProjectFile,
+  config: ConfigFacts,
+): TableScan {
+  const resolver = createDslResolver(graph, file);
+  const enums = collectEnumBindings(file, resolver, graph);
+  const drafts: TableDraft[] = [];
+  const diagnostics: Diagnostic[] = [];
+  for (const declarator of topLevelDeclarators(file.program)) {
+    const binding = identifierName(declarator.id) ?? null;
+    const tableCall = findTableCall(declarator.init, resolver);
+    if (tableCall === null) continue;
+    const result = buildTableDraft({
+      graph,
+      file,
+      resolver,
+      enums,
+      config,
+      binding,
+      tableCall,
+    });
+    drafts.push(result.draft);
+    diagnostics.push(...result.diagnostics);
+  }
+  return { drafts, diagnostics };
+}

package/src/passes/schema.ts

@@ -0,0 +1,67 @@
+import type { ModuleGraph, ProjectFile } from "../module-graph.ts";
+import type { ConfigFacts, Diagnostic, RelationFact, TableFact } from "../types.ts";
+import { isSchemaFile } from "./schema-dsl.ts";
+import { collectFileLinkDrafts } from "./schema-file-links.ts";
+import { buildTableLookup, finalizeTables, withFrameworkTables } from "./schema-foreign-keys.ts";
+import { collectTableDrafts, type TableDraft } from "./schema-tables.ts";
+import { collectReExportedDrafts } from "./schema-re-exports.ts";
+import { buildRelationFacts } from "./schema-relations.ts";
+
+export interface SchemaResult {
+  readonly tables: readonly TableFact[];
+  readonly relations: readonly RelationFact[];
+  readonly diagnostics: readonly Diagnostic[];
+}
+
+function schemaFiles(graph: ModuleGraph): ProjectFile[] {
+  return [...graph.files.values()]
+    .filter((file) => isSchemaFile(graph, file.path))
+    .toSorted((left, right) => left.path.localeCompare(right.path));
+}
+
+/** Tables declared twice (invalid TS, but analyzable) keep the first declaration. */
+function dedupeDrafts(drafts: readonly TableDraft[]): TableDraft[] {
+  const seen = new Set<string>();
+  const out: TableDraft[] = [];
+  for (const draft of drafts) {
+    if (seen.has(draft.fact.name)) continue;
+    seen.add(draft.fact.name);
+    out.push(draft);
+  }
+  return out;
+}
+
+/** Interpret the Drizzle DSL under `db/**`, including framework tables reached by re-export. */
+export function buildSchemaFacts(graph: ModuleGraph, config: ConfigFacts): SchemaResult {
+  const files = schemaFiles(graph);
+  const collected: TableDraft[] = [];
+  const externalTables: TableDraft[] = [];
+  const diagnostics: Diagnostic[] = [];
+  for (const file of files) {
+    const scan = collectTableDrafts(graph, file, config);
+    collected.push(...scan.drafts);
+    diagnostics.push(...scan.diagnostics);
+    // Generated link tables follow the file's own declarations, which is their source order:
+    // `const todoFiles = fileLinks(todos, ...)` comes after the `todos` it references.
+    const links = collectFileLinkDrafts(graph, file, scan.drafts);
+    collected.push(...links.drafts);
+    externalTables.push(...links.externalTables);
+    diagnostics.push(...links.diagnostics);
+  }
+
+  const seenNames = new Set(collected.map((draft) => draft.fact.name));
+  const visitedFiles = new Set(files.map((file) => file.path));
+  for (const file of files) {
+    const scan = collectReExportedDrafts(graph, file, config, seenNames, visitedFiles);
+    collected.push(...scan.drafts);
+    diagnostics.push(...scan.diagnostics);
+  }
+
+  const drafts = dedupeDrafts(collected);
+  const lookup = withFrameworkTables(buildTableLookup(drafts), externalTables);
+  const finalized = finalizeTables(graph, drafts, lookup);
+  diagnostics.push(...finalized.diagnostics);
+  const relations = buildRelationFacts(graph, files, lookup);
+  diagnostics.push(...relations.diagnostics);
+  return { tables: finalized.tables, relations: relations.relations, diagnostics };
+}

package/src/passes/screen-components.ts

@@ -0,0 +1,162 @@
+/**
+ * JSX component resolution for the static page preview: find a component's returned
+ * expression and resolve a JSX name to a project file through the module graph.
+ *
+ * The resolver is deliberately one level deep per call; the preview builder owns the depth,
+ * cycle and node budgets.
+ */
+
+import { asNode, nodeArray, type AstNode } from "../ast/node.ts";
+import type { ModuleGraph } from "../module-graph.ts";
+import { defaultExportDeclaration } from "../module-info.ts";
+import { sourceRef } from "../source.ts";
+
+export interface ComponentRef {
+  readonly file: string;
+  readonly name: string;
+}
+
+export function lineRef(
+  graph: ModuleGraph,
+  file: string,
+  node: AstNode,
+): { file: string; line: number } {
+  const source = graph.file(file)?.source;
+  return source === undefined
+    ? { file, line: 1 }
+    : sourceRef(file, source, typeof node.start === "number" ? node.start : 0);
+}
+
+function componentDeclaration(program: AstNode, name: string): AstNode | undefined {
+  const wanted = name === "default" ? null : name;
+  for (const statement of nodeArray(program, "body")) {
+    const declaration =
+      statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration"
+        ? asNode(statement.declaration)
+        : statement;
+    if (declaration === undefined) continue;
+    if (declaration.type === "FunctionDeclaration") {
+      const id = asNode(declaration.id);
+      if (
+        id !== undefined &&
+        typeof id.name === "string" &&
+        (wanted === null || id.name === wanted)
+      ) {
+        return declaration;
+      }
+    }
+    if (declaration.type !== "VariableDeclaration") continue;
+    for (const item of nodeArray(declaration, "declarations")) {
+      const id = asNode(item.id);
+      const init = asNode(item.init);
+      if (id === undefined || init === undefined) continue;
+      if (typeof id.name !== "string" || (wanted !== null && id.name !== wanted)) continue;
+      if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")
+        return init;
+    }
+  }
+  if (name === "default") return defaultExportDeclaration(program);
+  return undefined;
+}
+
+export function returnedExpression(body: AstNode): AstNode | undefined {
+  if (body.type === "BlockStatement") {
+    for (const statement of nodeArray(body, "body")) {
+      const found = returnedExpression(statement);
+      if (found !== undefined) return found;
+    }
+    return undefined;
+  }
+  if (body.type === "ReturnStatement") return asNode(body.argument);
+  if (body.type === "IfStatement") {
+    const consequent = asNode(body.consequent);
+    const alternate = asNode(body.alternate);
+    return (
+      (consequent === undefined ? undefined : returnedExpression(consequent)) ??
+      (alternate === undefined ? undefined : returnedExpression(alternate))
+    );
+  }
+  if (body.type === "TryStatement") {
+    const block = asNode(body.block);
+    const handler = asNode(body.handler);
+    const finalizer = asNode(body.finalizer);
+    const handlerBody = handler === undefined ? undefined : asNode(handler.body);
+    return (
+      (block === undefined ? undefined : returnedExpression(block)) ??
+      (handlerBody === undefined ? undefined : returnedExpression(handlerBody)) ??
+      (finalizer === undefined ? undefined : returnedExpression(finalizer))
+    );
+  }
+  return undefined;
+}
+
+export function componentExpression(
+  graph: ModuleGraph,
+  filePath: string,
+  name: string,
+): AstNode | undefined {
+  const file = graph.file(filePath);
+  if (file === undefined) return undefined;
+  const declaration = componentDeclaration(file.program, name);
+  if (declaration === undefined) return undefined;
+  if (declaration.type === "ArrowFunctionExpression") {
+    const body = asNode(declaration.body);
+    return body === undefined
+      ? undefined
+      : body.type === "BlockStatement"
+        ? returnedExpression(body)
+        : body;
+  }
+  if (declaration.type === "FunctionDeclaration" || declaration.type === "FunctionExpression") {
+    const body = asNode(declaration.body);
+    return body === undefined ? undefined : returnedExpression(body);
+  }
+  return declaration;
+}
+
+export function resolveComponent(
+  graph: ModuleGraph,
+  originFile: string,
+  name: string,
+): ComponentRef | null {
+  const local = name.includes(".") ? name.slice(0, name.indexOf(".")) : name;
+  const binding = graph.resolveBinding(originFile, local);
+  if (binding === null) return null;
+  const file = graph.file(binding.file);
+  if (file === undefined) return null;
+  return { file: file.path, name: binding.name };
+}
+
+export function firstComponentName(graph: ModuleGraph, filePath: string): string | null {
+  const file = graph.file(filePath);
+  if (file === undefined) return null;
+  for (const statement of nodeArray(file.program, "body")) {
+    const declaration =
+      statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration"
+        ? asNode(statement.declaration)
+        : statement;
+    if (declaration === undefined) continue;
+    if (declaration.type === "FunctionDeclaration") {
+      const id = asNode(declaration.id);
+      if (id !== undefined && typeof id.name === "string") return id.name;
+    }
+    if (declaration.type !== "VariableDeclaration") continue;
+    for (const item of nodeArray(declaration, "declarations")) {
+      const id = asNode(item.id);
+      const init = asNode(item.init);
+      if (id === undefined || init === undefined || typeof id.name !== "string") continue;
+      if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")
+        return id.name;
+    }
+  }
+  return null;
+}
+
+export function canExpand(file: string): boolean {
+  if (file.startsWith("src/components/ui/")) return false;
+  return (
+    file.startsWith("src/pages/") ||
+    file.startsWith("src/layouts/") ||
+    file.startsWith("src/components/")
+  );
+}

package/src/passes/screen-intrinsics.ts

@@ -0,0 +1,29 @@
+/**
+ * Which intrinsic JSX elements the page preview draws, and which copy they carry.
+ *
+ * Sections are the page's layout skeleton and are always drawn; content intrinsics are the
+ * copy-bearing blocks and controls that make the schematic page readable (D-170). Layout-only
+ * wrappers such as `<div>` are flattened, and a copy-bearing text element with no readable copy
+ * is flattened too, so the preview never draws empty boxes for spacing wrappers.
+ */
+
+import type { AstNode } from "../ast/node.ts";
+import { isContentIntrinsic, isRoleIntrinsic, isSectionIntrinsic } from "./jsx.ts";
+import { jsxContentFields, jsxTextFields, type JsxTextFields } from "./jsx-text.ts";
+
+/** What a drawable intrinsic contributes: its copy and whether it spends the content budget. */
+export interface IntrinsicPlan {
+  /** Content intrinsics have their own node budget and only draw when they carry something. */
+  readonly content: boolean;
+  readonly fields: JsxTextFields | undefined;
+}
+
+/** Classify one intrinsic element, or null when it is flattened into its parent. */
+export function planIntrinsic(node: AstNode, name: string): IntrinsicPlan | null {
+  const section = isSectionIntrinsic(name);
+  if (!section && !isContentIntrinsic(name)) return null;
+  const fields = section ? jsxTextFields(node) : jsxContentFields(node, name);
+  // A control or media element is a visible block even without copy; a bare span is not.
+  if (!section && fields === undefined && !isRoleIntrinsic(name)) return null;
+  return { content: !section, fields };
+}