@agjs/tsforge 0.1.0

package/src/rule-packs/drizzle/rules/relations-must-cover-fks.ts

@@ -0,0 +1,209 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+import type { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+
+import { createRule } from "../../create-rule";
+import {
+  findCallExpressionsDeep,
+  isForeignKeyCall,
+  isPgTableCall,
+  isRelationsCall,
+} from "../utils";
+
+export const RULE_NAME = "relations-must-cover-fks";
+
+export interface RelationsMustCoverFksOptions {
+  readonly allowExternalFile?: boolean;
+  readonly relationsFilePatterns?: readonly string[];
+}
+
+type RuleOptions = [RelationsMustCoverFksOptions];
+type MessageIds = "missingRelations";
+
+const DEFAULT_RELATIONS_FILES: readonly string[] = [
+  "relations.ts",
+  "relations.tsx",
+  "relations.js",
+];
+
+const optionSchema: JSONSchema4 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allowExternalFile: {
+      type: "boolean",
+    },
+    relationsFilePatterns: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true,
+      minItems: 1,
+    },
+  },
+};
+
+interface IRelationsFileCache {
+  readonly mtimeMs: number;
+  readonly tables: ReadonlySet<string>;
+}
+
+const relationsFileCache = new Map<string, IRelationsFileCache>();
+const RELATIONS_CALL_PATTERN = /\brelations\s*\(\s*([A-Za-z_$][\w$]*)/g;
+
+function readTablesFromRelationsFile(filePath: string): ReadonlySet<string> {
+  let stat: fs.Stats;
+
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return new Set();
+  }
+
+  const cached = relationsFileCache.get(filePath);
+
+  if (cached?.mtimeMs === stat.mtimeMs) {
+    return cached.tables;
+  }
+
+  let source: string;
+
+  try {
+    source = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return new Set();
+  }
+
+  const tables = new Set<string>();
+  let match: RegExpExecArray | null;
+
+  while ((match = RELATIONS_CALL_PATTERN.exec(source)) !== null) {
+    if (match[1]) {
+      tables.add(match[1]);
+    }
+  }
+
+  RELATIONS_CALL_PATTERN.lastIndex = 0;
+
+  relationsFileCache.set(filePath, { mtimeMs: stat.mtimeMs, tables });
+
+  return tables;
+}
+
+function collectExternalRelations(
+  startDir: string,
+  patterns: readonly string[]
+): Set<string> {
+  const out = new Set<string>();
+  const cwd = process.cwd();
+  let cursor = path.resolve(startDir);
+
+  while (true) {
+    for (const basename of patterns) {
+      const candidate = path.join(cursor, basename);
+
+      if (fs.existsSync(candidate)) {
+        for (const t of readTablesFromRelationsFile(candidate)) {
+          out.add(t);
+        }
+      }
+    }
+
+    if (cursor === cwd || path.dirname(cursor) === cursor) {
+      break;
+    }
+
+    cursor = path.dirname(cursor);
+  }
+
+  return out;
+}
+
+export const relationsMustCoverFksRule = createRule<RuleOptions, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Every Drizzle table that declares a foreignKey(...) must be covered by a relations(...) call. Searches sibling `relations.ts` files by default.",
+    },
+    schema: [optionSchema],
+    messages: {
+      missingRelations:
+        "Table '{{name}}' declares foreignKey(...) but no relations(...) call covers it. Drizzle's `db.query.{{name}}.findMany({ with: ... })` will not work.",
+    },
+  },
+  defaultOptions: [{ allowExternalFile: true }],
+  create(context, [options]) {
+    const allowExternalFile = options.allowExternalFile ?? true;
+    const relationsFiles =
+      options.relationsFilePatterns ?? DEFAULT_RELATIONS_FILES;
+
+    const tablesWithFks = new Map<string, TSESTree.VariableDeclarator>();
+    const tablesWithRelations = new Set<string>();
+
+    return {
+      VariableDeclarator(node) {
+        if (node.init?.type !== AST_NODE_TYPES.CallExpression) {
+          return;
+        }
+
+        if (!isPgTableCall(node.init)) {
+          return;
+        }
+
+        if (node.id.type !== AST_NODE_TYPES.Identifier) {
+          return;
+        }
+
+        const fkCalls = findCallExpressionsDeep(node.init, isForeignKeyCall);
+
+        if (fkCalls.length === 0) {
+          return;
+        }
+
+        tablesWithFks.set(node.id.name, node);
+      },
+      CallExpression(node) {
+        if (!isRelationsCall(node)) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+
+        if (firstArg?.type === AST_NODE_TYPES.Identifier) {
+          tablesWithRelations.add(firstArg.name);
+        }
+      },
+      "Program:exit"() {
+        if (allowExternalFile) {
+          const filename = context.filename;
+
+          if (filename && filename !== "<input>") {
+            const dir = path.dirname(filename);
+
+            for (const t of collectExternalRelations(dir, relationsFiles)) {
+              tablesWithRelations.add(t);
+            }
+          }
+        }
+
+        for (const [name, declarator] of tablesWithFks) {
+          if (tablesWithRelations.has(name)) {
+            continue;
+          }
+
+          context.report({
+            node: declarator,
+            messageId: "missingRelations",
+            data: { name },
+          });
+        }
+      },
+    };
+  },
+});
+
+export function __clearRelationsFileCacheForTests(): void {
+  relationsFileCache.clear();
+}

package/src/rule-packs/drizzle/rules/schema-files-must-not-import-driver.ts

@@ -0,0 +1,127 @@
+import type { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+
+import { createRule } from "../../create-rule";
+import { matchesAnyGlobPattern } from "../../utils";
+
+export const RULE_NAME = "schema-files-must-not-import-driver";
+
+export interface SchemaFilesMustNotImportDriverOptions {
+  readonly filePattern?: string;
+  readonly forbiddenSources?: readonly string[];
+  readonly forbiddenSourcePatterns?: readonly string[];
+}
+
+type RuleOptions = [SchemaFilesMustNotImportDriverOptions];
+type MessageIds = "forbiddenDriverImport";
+
+const DEFAULT_FILE_PATTERN = "**/schema/**/*.schema.ts";
+
+const DEFAULT_FORBIDDEN_SOURCES: readonly string[] = [
+  "pg",
+  "postgres",
+  "node-postgres",
+  "mysql2",
+  "better-sqlite3",
+  "@libsql/client",
+  "@neondatabase/serverless",
+  "@vercel/postgres",
+  "@planetscale/database",
+];
+
+const DEFAULT_FORBIDDEN_SOURCE_PATTERNS: readonly string[] = [
+  "drizzle-orm/node-postgres",
+  "drizzle-orm/postgres-js",
+  "drizzle-orm/neon-http",
+  "drizzle-orm/neon-serverless",
+  "drizzle-orm/vercel-postgres",
+  "drizzle-orm/aws-data-api/**",
+  "drizzle-orm/mysql2",
+  "drizzle-orm/planetscale-serverless",
+  "drizzle-orm/tidb-serverless",
+  "drizzle-orm/better-sqlite3",
+  "drizzle-orm/bun-sqlite",
+  "drizzle-orm/d1",
+  "drizzle-orm/expo-sqlite",
+  "drizzle-orm/libsql",
+  "drizzle-orm/op-sqlite",
+];
+
+const optionSchema: JSONSchema4 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    filePattern: {
+      type: "string",
+    },
+    forbiddenSources: {
+      type: "array",
+      uniqueItems: true,
+      items: { type: "string" },
+    },
+    forbiddenSourcePatterns: {
+      type: "array",
+      uniqueItems: true,
+      items: { type: "string" },
+    },
+  },
+};
+
+export const schemaFilesMustNotImportDriverRule = createRule<
+  RuleOptions,
+  MessageIds
+>({
+  name: RULE_NAME,
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow imports from database driver packages inside schema files. Schema files must remain driver-agnostic.",
+    },
+    schema: [optionSchema],
+    messages: {
+      forbiddenDriverImport:
+        "Schema files must not import from driver package '{{source}}' — schema definitions must remain driver-agnostic. Move the connection setup to the consuming application.",
+    },
+  },
+  defaultOptions: [
+    {
+      filePattern: DEFAULT_FILE_PATTERN,
+      forbiddenSources: [...DEFAULT_FORBIDDEN_SOURCES],
+      forbiddenSourcePatterns: [...DEFAULT_FORBIDDEN_SOURCE_PATTERNS],
+    },
+  ],
+  create(context, [options]) {
+    const filePattern = options.filePattern ?? DEFAULT_FILE_PATTERN;
+
+    if (!matchesAnyGlobPattern(context.filename, [filePattern])) {
+      return {};
+    }
+
+    const forbiddenSources = new Set(
+      options.forbiddenSources ?? DEFAULT_FORBIDDEN_SOURCES
+    );
+    const forbiddenPatterns =
+      options.forbiddenSourcePatterns ?? DEFAULT_FORBIDDEN_SOURCE_PATTERNS;
+
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+
+        if (typeof source !== "string") {
+          return;
+        }
+
+        if (
+          forbiddenSources.has(source) ||
+          matchesAnyGlobPattern(source, forbiddenPatterns)
+        ) {
+          context.report({
+            node: node.source,
+            messageId: "forbiddenDriverImport",
+            data: { source },
+          });
+        }
+      },
+    };
+  },
+});

package/src/rule-packs/drizzle/rules/schema-files-must-only-export-schema.ts

@@ -0,0 +1,149 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+import type { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+
+import { createRule } from "../../create-rule";
+import { isSchemaBuilderCall } from "../utils";
+import { matchesAnyGlobPattern } from "../../utils";
+
+export const RULE_NAME = "schema-files-must-only-export-schema";
+
+export interface SchemaFilesMustOnlyExportSchemaOptions {
+  readonly filePattern?: string;
+}
+
+type RuleOptions = [SchemaFilesMustOnlyExportSchemaOptions];
+type MessageIds = "nonSchemaExport";
+
+const DEFAULT_FILE_PATTERN = "**/schema/**/*.schema.ts";
+
+const optionSchema: JSONSchema4 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    filePattern: {
+      type: "string",
+    },
+  },
+};
+
+export const schemaFilesMustOnlyExportSchemaRule = createRule<
+  RuleOptions,
+  MessageIds
+>({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Restrict schema files to exporting only Drizzle schema artifacts (tables, schemas, relations, indices) and types.",
+    },
+    schema: [optionSchema],
+    messages: {
+      nonSchemaExport:
+        "Schema files may only export tables, schemas, relations, and types — move '{{name}}' elsewhere.",
+    },
+  },
+  defaultOptions: [{ filePattern: DEFAULT_FILE_PATTERN }],
+  create(context, [options]) {
+    const filePattern = options.filePattern ?? DEFAULT_FILE_PATTERN;
+
+    if (!matchesAnyGlobPattern(context.filename, [filePattern])) {
+      return {};
+    }
+
+    return {
+      ExportNamedDeclaration(node) {
+        if (node.source) {
+          return;
+        }
+
+        const declaration = node.declaration;
+
+        if (!declaration) {
+          return;
+        }
+
+        if (
+          declaration.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+          declaration.type === AST_NODE_TYPES.TSInterfaceDeclaration
+        ) {
+          return;
+        }
+
+        if (declaration.type === AST_NODE_TYPES.VariableDeclaration) {
+          for (const declarator of declaration.declarations) {
+            if (
+              declarator.init?.type === AST_NODE_TYPES.CallExpression &&
+              isSchemaBuilderCall(declarator.init)
+            ) {
+              continue;
+            }
+
+            context.report({
+              node: declarator,
+              messageId: "nonSchemaExport",
+              data: { name: getDeclaratorName(declarator) ?? "<anonymous>" },
+            });
+          }
+
+          return;
+        }
+
+        context.report({
+          node: declaration,
+          messageId: "nonSchemaExport",
+          data: { name: getNamedDeclarationName(declaration) ?? "<anonymous>" },
+        });
+      },
+      ExportDefaultDeclaration(node) {
+        context.report({
+          node,
+          messageId: "nonSchemaExport",
+          data: { name: getDefaultExportName(node) ?? "default" },
+        });
+      },
+    };
+  },
+});
+
+function getDeclaratorName(
+  declarator: TSESTree.VariableDeclarator
+): string | null {
+  if (declarator.id.type === AST_NODE_TYPES.Identifier) {
+    return declarator.id.name;
+  }
+
+  return null;
+}
+
+function getNamedDeclarationName(
+  declaration: NonNullable<TSESTree.ExportNamedDeclaration["declaration"]>
+): string | null {
+  if (
+    "id" in declaration &&
+    declaration.id?.type === AST_NODE_TYPES.Identifier
+  ) {
+    return declaration.id.name;
+  }
+
+  return null;
+}
+
+function getDefaultExportName(
+  node: TSESTree.ExportDefaultDeclaration
+): string | null {
+  const declaration = node.declaration;
+
+  if (
+    "id" in declaration &&
+    declaration.id?.type === AST_NODE_TYPES.Identifier
+  ) {
+    return declaration.id.name;
+  }
+
+  if (declaration.type === AST_NODE_TYPES.Identifier) {
+    return declaration.name;
+  }
+
+  return null;
+}