@geonosis/oxlint-plugin-biological-architecture 2.13.0 → 3.0.0

package/dist/rules/cell-no-tissues.js

@@ -0,0 +1,23 @@
+// src/rules/cell-no-tissues.ts
+import { directionRule } from "./lib/direction-rule.js";
+var HIGHER_LEVEL_PATTERNS = [
+  /(?:^|\/)(?:features\/[^/]+\/)?tissues\//,
+  /(?:^|\/)(?:features\/[^/]+\/)?organs\//,
+  /(?:^|\/)layouts\//,
+  /(?:^|\/)app\//
+];
+var cellNoTissues = directionRule({
+  description: "Cells cannot import tissues, organs, or app route files. Direction is wrong: tissues compose cells (not the reverse), and organs compose tissues and cells.",
+  fixShape: `A cell cannot import a tissue, an organ, a layout or an app route — that is the direction
+inverted. If a cell needs a layout around it, take the layout as \`children\` and let a tissue arrange
+both. Type-only imports are exempt; \`export … from\` is not.`,
+  forbidden: (target) => HIGHER_LEVEL_PATTERNS.some((pattern) => pattern.test(target.path)),
+  messages: {
+    forbidden: 'Cell "{{file}}" cannot import higher-level component "{{source}}". Direction is wrong: tissues/organs compose cells, not the reverse. If this cell needs to render a layout-like wrapper, the wrapper should be a compound, or this cell should be promoted.'
+  },
+  scope: "cells"
+});
+var cell_no_tissues_default = cellNoTissues;
+export {
+  cell_no_tissues_default as default
+};

package/dist/rules/cells-folder-index-is-barrel.d.ts

@@ -0,0 +1,35 @@
+import { type RuleContext } from './lib/context.js';
+interface ProgramNode {
+    body: Statement[];
+    loc?: unknown;
+    type: 'Program';
+}
+interface Statement {
+    declaration?: unknown;
+    importKind?: string;
+    loc?: unknown;
+    source?: {
+        value: string;
+    } | null;
+    specifiers?: unknown[];
+    type: string;
+}
+declare const cellsFolderIndexIsBarrel: {
+    create(context: RuleContext): {
+        Program?: undefined;
+    } | {
+        Program(node: ProgramNode): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            notBarrel: string;
+        };
+        schema: never[];
+        type: 'problem';
+    };
+};
+export default cellsFolderIndexIsBarrel;

package/dist/rules/cells-folder-index-is-barrel.js

@@ -0,0 +1,66 @@
+// src/rules/cells-folder-index-is-barrel.ts
+import { isCellsBarrel } from "./lib/cells-barrel.js";
+import { normalise } from "./lib/paths.js";
+function describeStatement(stmt) {
+  switch (stmt.type) {
+    case "ClassDeclaration":
+      return "a class declaration";
+    case "ExportDefaultDeclaration":
+      return "a default export declaration";
+    case "ExportNamedDeclaration":
+      return "a named export declaration (not a re-export)";
+    case "ExpressionStatement":
+      return "a top-level expression statement";
+    case "FunctionDeclaration":
+      return "a function declaration";
+    case "ImportDeclaration":
+      return "a side-effect import";
+    case "VariableDeclaration":
+      return "a variable declaration";
+    default:
+      return `a ${stmt.type} statement`;
+  }
+}
+var cellsFolderIndexIsBarrel = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = normalise(filename);
+    if (!isCellsBarrel(normalized))
+      return {};
+    const shortName = normalized.split("/").pop() || normalized;
+    return {
+      Program(node) {
+        for (const stmt of node.body) {
+          if (stmt.type === "ExportAllDeclaration")
+            continue;
+          if (stmt.type === "ExportNamedDeclaration" && stmt.source)
+            continue;
+          if (stmt.type === "ImportDeclaration" && stmt.importKind === "type")
+            continue;
+          context.report({
+            data: { file: shortName, kind: describeStatement(stmt) },
+            messageId: "notBarrel",
+            node: stmt
+          });
+        }
+      }
+    };
+  },
+  fixShape: `\`cells/index.ts\` and \`cells/dynamic.ts\` are barrels: \`export … from\` lines and nothing else. No
+function, class or variable declaration, no side-effect import. Logic that wants to live in the
+barrel belongs in a cell file the barrel re-exports.`,
+  meta: {
+    docs: {
+      description: "Barrel files under cells/ (index.ts, dynamic.ts, dynamic.tsx) must contain ONLY re-export statements. Component definitions belong in their own file."
+    },
+    messages: {
+      notBarrel: 'Barrel file "{{file}}" contains {{kind}}. Barrel files under cells/ must be pure re-export manifests (only `export * from` or `export { X } from`). Component definitions belong in their own file.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var cells_folder_index_is_barrel_default = cellsFolderIndexIsBarrel;
+export {
+  cells_folder_index_is_barrel_default as default
+};

package/dist/rules/compound-must-be-stateless.d.ts

@@ -0,0 +1,39 @@
+import { type RuleContext } from './lib/context.js';
+import type { AnyNode } from './lib/nodes.js';
+interface ImportNode {
+    importKind?: string;
+    source: {
+        value: string;
+    };
+    specifiers?: ImportSpecifier[];
+}
+interface ImportSpecifier {
+    imported?: {
+        name: string;
+        type: string;
+    };
+    type: string;
+}
+declare const compoundMustBeStateless: {
+    create(context: RuleContext): {
+        CallExpression?: undefined;
+        ImportDeclaration?: undefined;
+    } | {
+        CallExpression(node: AnyNode): void;
+        ImportDeclaration(node: ImportNode): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            forbiddenContextImport: string;
+            forbiddenHookCall: string;
+            forbiddenReactHook: string;
+        };
+        schema: never[];
+        type: 'problem';
+    };
+};
+export default compoundMustBeStateless;

package/dist/rules/compound-must-be-stateless.js

@@ -0,0 +1,86 @@
+// src/rules/compound-must-be-stateless.ts
+import { hookCalledBy } from "./lib/hooks.js";
+import { normalise } from "./lib/paths.js";
+var reactForbiddenHooks = new Set([
+  "useCallback",
+  "useEffect",
+  "useImperativeHandle",
+  "useLayoutEffect",
+  "useMemo",
+  "useReducer",
+  "useRef",
+  "useState"
+]);
+var CONTEXT_MODULE = /(?:^|\/)(?:providers|contexts)\//;
+var COMPOUND_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?compounds\//;
+var compoundMustBeStateless = {
+  create(context) {
+    const filename = context.filename;
+    const normalized = normalise(filename);
+    const isCompound = COMPOUND_FILE_PATTERN.test(normalized);
+    if (!isCompound)
+      return {};
+    const shortName = normalized.split("/").pop() || normalized;
+    return {
+      CallExpression(node) {
+        const name = hookCalledBy(node);
+        if (name === null)
+          return;
+        context.report({
+          data: { file: shortName, hook: name },
+          messageId: "forbiddenHookCall",
+          node
+        });
+      },
+      ImportDeclaration(node) {
+        if (node.importKind === "type")
+          return;
+        const source = node.source.value;
+        if (source === "react") {
+          const specifiers = node.specifiers ?? [];
+          for (const spec of specifiers) {
+            if (spec.type !== "ImportSpecifier")
+              continue;
+            const importedName = spec.imported?.name;
+            if (!importedName)
+              continue;
+            if (reactForbiddenHooks.has(importedName)) {
+              context.report({
+                data: { file: shortName, hook: importedName },
+                messageId: "forbiddenReactHook",
+                node
+              });
+            }
+          }
+          return;
+        }
+        if (CONTEXT_MODULE.test(source)) {
+          context.report({
+            data: { file: shortName, source },
+            messageId: "forbiddenContextImport",
+            node
+          });
+        }
+      }
+    };
+  },
+  fixShape: `A compound is inert: no \`useState\`, no \`useEffect\`, no \`useMemo\`, no store read, no provider import —
+no hook call at all. It takes what it renders as props. If it needs state, the caller is a cell or an
+organelle and holds it; if the file itself needs state, it is not a compound.`,
+  meta: {
+    docs: {
+      description: "Compounds are pure stateless props-in/JSX-out components. They cannot: (1) import React hooks from react, (2) call ANY hook (use* functions), (3) import from providers/ or contexts/. If you need state, this is a cell or organelle."
+    },
+    messages: {
+      forbiddenContextImport: 'Compound "{{file}}" imports from "{{source}}". Compounds must not use context/providers — receive data via props instead.',
+      forbiddenHookCall: 'Compound "{{file}}" calls hook "{{hook}}". Compounds are stateless — no hooks allowed. Move to cells/ or organelles/.',
+      forbiddenReactHook: 'Compound "{{file}}" imports "{{hook}}" from react. Compounds are stateless — move to cells/ or organelles/.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var compound_must_be_stateless_default = compoundMustBeStateless;
+export {
+  compound_must_be_stateless_default as default
+};

package/dist/rules/compound-no-stores.d.ts

@@ -0,0 +1,21 @@
+declare const compoundNoStores: {
+    create(context: {
+        filename: string;
+        options?: readonly unknown[];
+        report: (descriptor: {
+            data: Record<string, string>;
+            messageId: string;
+            node: unknown;
+        }) => void;
+    }): import('./lib/visitors.js').Visitor;
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: Record<string, string>;
+        schema: unknown[];
+        type: 'problem';
+    };
+};
+export default compoundNoStores;

package/dist/rules/compound-no-stores.js

@@ -0,0 +1,25 @@
+// src/rules/compound-no-stores.ts
+import { directionRule } from "./lib/direction-rule.js";
+var FORBIDDEN_PATTERNS = [
+  /(?:^|\/)stores\//,
+  /(?:^|\/)organelles\//,
+  /(?:^|\/)cells\//,
+  /(?:^|\/)tissues\//,
+  /(?:^|\/)layouts\//,
+  /\/app\//
+];
+var compoundNoStores = directionRule({
+  description: "Compounds may only import atoms, molecules, and other compounds. They cannot import organelles, cells, tissues, stores, or app routes — direction rule: a parent may only compose children at levels <= its own.",
+  fixShape: `A compound may import atoms, molecules and other compounds. Stores, organelles, cells, tissues,
+layouts and app routes are all above it. Take the data as a prop from the cell that reads the store.
+Type-only imports are exempt; \`export … from\` is not.`,
+  forbidden: (target) => FORBIDDEN_PATTERNS.some((pattern) => pattern.test(target.path)),
+  messages: {
+    forbidden: "Compounds cannot import from {{source}}. Direction violation — compounds are level 3 and can only depend on atoms, molecules, other compounds, and shared libs/domains/types."
+  },
+  scope: (importer) => importer.tier === "compounds" && !/__tests__\//.test(importer.path)
+});
+var compound_no_stores_default = compoundNoStores;
+export {
+  compound_no_stores_default as default
+};

package/dist/rules/constants-in-constants-file.d.ts

@@ -0,0 +1,41 @@
+type Declarator = {
+    type: string;
+    id: {
+        type: string;
+        name?: string;
+    };
+};
+type ExportNamedDeclaration = {
+    type: 'ExportNamedDeclaration';
+    declaration?: {
+        type: string;
+        kind?: string;
+        declarations?: Declarator[];
+    } | null;
+};
+declare const constantsInConstantsFile: {
+    create(context: {
+        filename: string;
+        report: (d: {
+            messageId: string;
+            node: unknown;
+            data: Record<string, string>;
+        }) => void;
+    }): {
+        ExportNamedDeclaration?: undefined;
+    } | {
+        ExportNamedDeclaration(node: ExportNamedDeclaration): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            outsideConstantsFile: string;
+        };
+        schema: never[];
+        type: 'problem';
+    };
+};
+export default constantsInConstantsFile;

package/dist/rules/constants-in-constants-file.js

@@ -0,0 +1,41 @@
+// src/rules/constants-in-constants-file.ts
+import { normalise } from "./lib/paths.js";
+var exemptFiles = [/\/constants\.ts$/, /\/__tests__\//, /\/scripts\//, /\/testing\//, /\.d\.ts$/];
+var screamingSnake = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/;
+var constantsInConstantsFile = {
+  create(context) {
+    const normalized = normalise(context.filename);
+    if (exemptFiles.some((file) => file.test(normalized)))
+      return {};
+    return {
+      ExportNamedDeclaration(node) {
+        const declaration = node.declaration;
+        if (!declaration || declaration.type !== "VariableDeclaration")
+          return;
+        for (const declarator of declaration.declarations ?? []) {
+          const name = declarator.id.type === "Identifier" ? declarator.id.name : undefined;
+          if (name !== undefined && name.length >= 3 && screamingSnake.test(name)) {
+            context.report({ messageId: "outsideConstantsFile", node, data: { name } });
+          }
+        }
+      }
+    };
+  },
+  fixShape: `A \`SCREAMING_SNAKE\` export is a fact, and a fact lives in a \`constants.ts\` beside its owner — not
+scattered across the module that happens to use it first. Move the declaration, import it back.
+Non-exported module locals are unaffected.`,
+  meta: {
+    docs: {
+      description: "A SCREAMING_SNAKE export is a constant, and constants live in the constants.ts beside their owner."
+    },
+    messages: {
+      outsideConstantsFile: "{{name}} is a constant declared outside constants.ts. Move it to the constants.ts of its domain, feature lib or package."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var constants_in_constants_file_default = constantsInConstantsFile;
+export {
+  constants_in_constants_file_default as default
+};

package/dist/rules/dialect-through-the-seam.d.ts

@@ -0,0 +1,63 @@
+import { type RuleContextWithOptions } from './lib/context.js';
+import { type Probe } from './lib/probe.js';
+interface Options {
+    /**
+     * Regex sources over the normalised filename: the files the Postgres-word check leaves alone —
+     * test helpers, fixtures. Naming any REPLACES the test-path default.
+     */
+    exempt?: string | string[];
+    /**
+     * Regex sources over the normalised filename: the only files that may name a dialect or driver
+     * module — the schema, the dialect module, the client, the drivers, drizzle-kit's configs.
+     */
+    seam?: string | string[];
+}
+declare const dialectThroughTheSeam: {
+    create(context: RuleContextWithOptions<Options>): import('./lib/visitors.js').Visitor;
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            dialectOutsideSeam: string;
+            postgresOutsideDialect: string;
+        };
+        schema: {
+            additionalProperties: boolean;
+            properties: {
+                exempt: {
+                    anyOf: ({
+                        type: 'string';
+                        items?: undefined;
+                    } | {
+                        items: {
+                            type: 'string';
+                        };
+                        type: 'array';
+                    })[];
+                };
+                seam: {
+                    anyOf: ({
+                        type: 'string';
+                        items?: undefined;
+                    } | {
+                        items: {
+                            type: 'string';
+                        };
+                        type: 'array';
+                    })[];
+                };
+            };
+            type: 'object';
+        }[];
+        type: 'problem';
+    };
+    /**
+     * A file OUTSIDE the seam importing the dialect — the inverse of a probe placed where its option
+     * points. Tried against the repo's own `seam`: a seam broad enough to swallow every candidate has
+     * configured a rule that can never fire, and the probe says so rather than calling it green.
+     */
+    probe(options: readonly unknown[]): Probe;
+};
+export default dialectThroughTheSeam;

package/dist/rules/dialect-through-the-seam.js

@@ -0,0 +1,102 @@
+// src/rules/dialect-through-the-seam.ts
+import { DEFAULT_TEST_EXEMPT, PATTERNS, patternsOf, requireOption } from "./lib/options.js";
+import { anyOf, normalise } from "./lib/paths.js";
+import { bagOf } from "./lib/probe.js";
+import { optionsBag } from "./lib/schema.js";
+import { mergeVisitors, onImportSource } from "./lib/visitors.js";
+var RULE = "dialect-through-the-seam";
+var ACCEPTS = "{ seam: string | string[] (regex sources over the filename: the files that may name the dialect), exempt: string | string[] (regex sources: files the Postgres-word check leaves alone, default the test paths: __tests__/, .test., .spec.) }";
+var dialectModules = [
+  "drizzle-orm/pg-core",
+  "drizzle-orm/sqlite-core",
+  "drizzle-orm/d1",
+  "drizzle-orm/postgres-js",
+  "drizzle-orm/node-postgres",
+  "drizzle-orm/pglite",
+  "drizzle-orm/neon-http",
+  "drizzle-orm/neon-serverless",
+  "postgres",
+  "pg"
+];
+var postgresWords = /\b(to_tsquery|ts_rank|set_config|current_setting|to_char|to_timestamp|regexp_replace|explain|information_schema|set local)\b/i;
+var isDialectModule = (source) => typeof source === "string" && dialectModules.some((module) => source === module || source.startsWith(`${module}/`));
+var dialectThroughTheSeam = {
+  create(context) {
+    const bag = context.options?.[0] ?? {};
+    const seam = requireOption(RULE, patternsOf(bag.seam), "seam", ACCEPTS);
+    const exempt = bag.exempt === undefined ? DEFAULT_TEST_EXEMPT : patternsOf(bag.exempt);
+    const normalized = normalise(context.filename);
+    const atTheSeam = anyOf(seam, normalized);
+    const inTests = anyOf(exempt, normalized);
+    const checkImport = (source, node) => {
+      if (atTheSeam || !isDialectModule(source))
+        return;
+      context.report({ data: { source }, messageId: "dialectOutsideSeam", node });
+    };
+    const checkText = (text, node) => {
+      if (atTheSeam || inTests)
+        return;
+      const word = postgresWords.exec(text)?.[1];
+      if (word === undefined)
+        return;
+      context.report({ data: { word }, messageId: "postgresOutsideDialect", node });
+    };
+    return mergeVisitors(onImportSource(checkImport, { typeOnly: "visit" }), {
+      TaggedTemplateExpression(node) {
+        if (node.tag?.type !== "Identifier" || node.tag.name !== "sql")
+          return;
+        checkText((node.quasi?.quasis ?? []).map((part) => part.value?.raw ?? "").join(" "), node);
+      },
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee?.type !== "MemberExpression")
+          return;
+        if (callee.object?.name !== "sql" || callee.property?.name !== "raw")
+          return;
+        const [first] = node.arguments ?? [];
+        if (first?.type !== "Literal" || typeof first.value !== "string")
+          return;
+        checkText(first.value, node);
+      }
+    });
+  },
+  fixShape: `Dialect-typed names (\`drizzle-orm/pg-core\`, \`drizzle-orm/sqlite-core\`, \`drizzle-orm/d1\`, …) are
+imported only at the seam the \`seam\` option names (regex sources over the filename): the schema, the
+dialect module, the client, the drivers, and drizzle-kit's configs. Everywhere else, use the
+dialect-free aliases the seam exports (\`Database\`, \`AnyColumn\`, \`rowsOf\`) so the same query compiles
+against either engine. A Postgres function spelled outside the seam is named in the dialect module and
+called from there; \`exempt\` (default: the test paths) is where that check stays quiet. Enabled without
+\`seam\` the rule reports that once a run and judges nothing.`,
+  meta: {
+    docs: {
+      description: "The dialect and the driver are named at one seam — the files the `seam` option names (the schema, dialect.ts, client.ts, the drivers, the drizzle-kit configs); nothing else imports a dialect or driver module, and nothing outside the seam spells a Postgres function. Enabled without `seam` the rule reports that once a run."
+    },
+    messages: {
+      dialectOutsideSeam: 'This file imports "{{source}}". A dialect or driver module is named only at the seam (the schema, dialect.ts, client.ts, the drivers) — use the neutral types and the cell port the seam exports instead.',
+      postgresOutsideDialect: '"{{word}}" is Postgres, not SQL. Name the fragment in the dialect module and call it from here, so the query reads as the question it asks.'
+    },
+    schema: optionsBag({
+      exempt: PATTERNS,
+      seam: PATTERNS
+    }),
+    type: "problem"
+  },
+  probe(options) {
+    const seam = patternsOf(bagOf(options).seam);
+    const outside = ["geonosis-probe-dialect.ts", "src/geonosis-probe-dialect.ts"].find((path) => !anyOf(seam, path));
+    if (outside === undefined) {
+      throw new Error(`biological-architecture/${RULE}: every path a probe could be written at is inside \`seam\` (${seam.join(", ")}), so there is nowhere left for this rule to speak.`);
+    }
+    return {
+      path: outside,
+      source: `import { pgTable } from 'drizzle-orm/pg-core'
+
+export const geonosisProbe = pgTable
+`
+    };
+  }
+};
+var dialect_through_the_seam_default = dialectThroughTheSeam;
+export {
+  dialect_through_the_seam_default as default
+};

package/dist/rules/durable-body-reads-through-steps.d.ts

@@ -0,0 +1,78 @@
+import { type RuleContextWithOptions } from './lib/context.js';
+import { type AnyNode } from './lib/nodes.js';
+import { type Probe } from './lib/probe.js';
+interface Options {
+    /** The config key that marks a workflow durable. Default: the engine's `execution`. */
+    durableKey?: string;
+    /** What that key must say. Default: the engine's `'durable'`. */
+    durableValue?: boolean | string;
+    /** The identifiers a body reaches the outside world through — this repo's ports. */
+    ports?: string[];
+    /**
+     * The receivers whose calls the ENGINE has already made steps of — `stepsOf`' proxy over a module
+     * of bound queries. A call through one is journalled under its own name and answered from the
+     * record on a replay, so it is exactly what this rule asks for rather than what it forbids.
+     */
+    stepProxies?: string[];
+    /** The call names that define a step. Default: `createStep`. */
+    stepFactories?: string[];
+    /** The call names that define a workflow. Default: `createWorkflow`. */
+    workflowFactories?: string[];
+}
+declare const durableBodyReadsThroughSteps: {
+    create(context: RuleContextWithOptions<Options>): {
+        CallExpression(node: AnyNode): void;
+    };
+    fixShape: string;
+    meta: {
+        docs: {
+            description: string;
+        };
+        messages: {
+            freeRead: string;
+        };
+        schema: {
+            additionalProperties: boolean;
+            properties: {
+                durableKey: {
+                    type: 'string';
+                };
+                durableValue: {
+                    type: readonly ["boolean", "string"];
+                };
+                ports: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                stepFactories: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                stepProxies: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+                workflowFactories: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
+            };
+            type: 'object';
+        }[];
+        type: 'problem';
+    };
+    /**
+     * A durable body with one free read and no step at all: a step would be the remedy, and a probe
+     * that carried one would be claiming a finding from the shape the rule accepts.
+     */
+    probe(options: readonly unknown[]): Probe;
+};
+export default durableBodyReadsThroughSteps;