@geonosis/oxlint-plugin-biological-architecture 3.2.0 → 3.3.0

package/dist/rules/lib/token-layer.js

@@ -0,0 +1,170 @@
+// src/rules/lib/token-layer.ts
+import { isTypeOnly, sourceOf } from "./imports.js";
+import { propertyNameOf } from "./nodes.js";
+import { withoutTypes } from "./objects.js";
+var THEMEKIT = "@geonosis/themekit";
+var PALETTE_TAKERS = [
+  "compile",
+  "defineTheme",
+  "emitVariables",
+  "toDtcg",
+  "valueAt"
+];
+var PALETTE_TYPES = [
+  "StatusPair",
+  "Theme",
+  "ThemeColors",
+  "ThemeFonts",
+  "ThemeMode",
+  "ThemeModes",
+  "ThemeRadii",
+  "ThemeShadows",
+  "ThemeStatusColors",
+  "TokenValue"
+];
+var isNode = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var childOf = (node, key) => {
+  const child = node?.[key];
+  return isNode(child) ? child : undefined;
+};
+var childrenOf = (node, key) => {
+  const children = node[key];
+  return Array.isArray(children) ? children.filter(isNode) : [];
+};
+var nameOf = (node) => typeof node?.name === "string" ? node.name : undefined;
+var tokenLayerOf = () => {
+  const takers = new Set;
+  const namespaces = new Set;
+  const typeLocals = new Set;
+  const typeNamespaces = new Set;
+  const typed = [];
+  const objects = new Set;
+  const passed = new Set;
+  const bindings = new Map;
+  const open = [];
+  const single = (name) => {
+    const binding = bindings.get(name);
+    return binding?.declarations === 1 ? binding.object : undefined;
+  };
+  const isPaletteType = (reference) => {
+    if (reference?.type !== "TSTypeReference")
+      return false;
+    const name = childOf(reference, "typeName");
+    if (name?.type === "Identifier")
+      return typeLocals.has(nameOf(name) ?? "");
+    if (name?.type !== "TSQualifiedName")
+      return false;
+    const namespace = nameOf(childOf(name, "left"));
+    const member = nameOf(childOf(name, "right"));
+    return namespace !== undefined && member !== undefined && typeNamespaces.has(namespace) && PALETTE_TYPES.includes(member);
+  };
+  const typedObject = (expression, reference) => {
+    const object = withoutTypes(expression);
+    if (object?.type === "ObjectExpression")
+      typed.push({ object, reference });
+  };
+  const takesPalette = (callee) => {
+    if (callee?.type === "Identifier")
+      return takers.has(nameOf(callee) ?? "");
+    if (callee?.type !== "MemberExpression")
+      return false;
+    const owner = nameOf(childOf(callee, "object"));
+    const name = propertyNameOf(callee);
+    return owner !== undefined && namespaces.has(owner) && name !== null && PALETTE_TAKERS.includes(name);
+  };
+  return {
+    covers: (chain) => chain.some((one) => objects.has(one)),
+    enclosing: () => [...open],
+    resolve: () => {
+      for (const one of typed) {
+        if (isPaletteType(one.reference))
+          objects.add(one.object);
+      }
+      const queue = [...objects];
+      for (const name of passed) {
+        const held = single(name);
+        if (held !== undefined && !objects.has(held)) {
+          objects.add(held);
+          queue.push(held);
+        }
+      }
+      for (const object of queue) {
+        for (const member of childrenOf(object, "properties")) {
+          const value = withoutTypes(member.type === "SpreadElement" ? member.argument : member.value);
+          const held = value?.type === "Identifier" ? single(nameOf(value) ?? "") : undefined;
+          if (held !== undefined && !objects.has(held)) {
+            objects.add(held);
+            queue.push(held);
+          }
+        }
+      }
+    },
+    visitor: {
+      CallExpression(node) {
+        if (!takesPalette(childOf(node, "callee")))
+          return;
+        const argument = withoutTypes(childrenOf(node, "arguments")[0]);
+        if (argument?.type === "ObjectExpression")
+          objects.add(argument);
+        else if (argument?.type === "Identifier")
+          passed.add(nameOf(argument) ?? "");
+      },
+      ImportDeclaration(node) {
+        if (sourceOf(node) !== THEMEKIT)
+          return;
+        for (const specifier of node.specifiers ?? []) {
+          const local = specifier.local?.name;
+          if (local === undefined)
+            continue;
+          const typeOnly = isTypeOnly(node) || specifier.importKind === "type";
+          if (specifier.type === "ImportNamespaceSpecifier") {
+            typeNamespaces.add(local);
+            if (!typeOnly)
+              namespaces.add(local);
+            continue;
+          }
+          const imported = specifier.imported?.name;
+          if (imported === undefined)
+            continue;
+          if (PALETTE_TYPES.includes(imported))
+            typeLocals.add(local);
+          if (!typeOnly && PALETTE_TAKERS.includes(imported))
+            takers.add(local);
+        }
+      },
+      TSAsExpression(node) {
+        typedObject(node.expression, childOf(node, "typeAnnotation"));
+      },
+      TSSatisfiesExpression(node) {
+        typedObject(node.expression, childOf(node, "typeAnnotation"));
+      },
+      ObjectExpression(node) {
+        open.push(node);
+      },
+      "ObjectExpression:exit"() {
+        open.pop();
+      },
+      VariableDeclaration(node) {
+        for (const declarator of childrenOf(node, "declarations")) {
+          const id = childOf(declarator, "id");
+          const name = nameOf(id);
+          if (id?.type !== "Identifier" || name === undefined)
+            continue;
+          typedObject(declarator.init, childOf(childOf(id, "typeAnnotation"), "typeAnnotation"));
+          const init = withoutTypes(declarator.init);
+          const held = node.kind === "const" && init?.type === "ObjectExpression" ? init : undefined;
+          bindings.set(name, {
+            declarations: (bindings.get(name)?.declarations ?? 0) + 1,
+            ...held === undefined ? {} : { object: held }
+          });
+        }
+      }
+    }
+  };
+};
+export {
+  PALETTE_TAKERS,
+  PALETTE_TYPES,
+  THEMEKIT,
+  tokenLayerOf
+};

package/dist/rules/lib/workspace-members.js

@@ -1,6 +1,7 @@
 // src/rules/lib/workspace-members.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { remembered } from "./fresh.js";
 import { readManifest } from "./module-text.js";
 var MARKERS = ["pnpm-workspace.yaml", "package.json"];
 var SKIPPED = new Set(["node_modules", ".git"]);
@@ -62,8 +63,9 @@ var nameOf = (manifest) => {
   const name = readManifest(manifest)?.name;
   return typeof name === "string" ? name : undefined;
 };
-var cache = new Map;
-var rootAbove = (from) => {
+var rooted = new Map;
+var members = new Map;
+var rootAbove = (from) => remembered(rooted, dirname(from), () => {
   let dir = dirname(from);
   for (;; ) {
     for (const marker of MARKERS) {
@@ -85,27 +87,23 @@ var rootAbove = (from) => {
       return;
     dir = parent;
   }
-};
+});
 var membersFrom = (from) => {
   const found = rootAbove(from);
   if (found === undefined)
     return;
   const marker = join(found.root, found.marker);
-  const stamp = statSync(marker).mtimeMs;
-  const held = cache.get(marker);
-  if (held?.stamp === stamp)
-    return held.members;
-  const globs = globsOf(found.marker, readFileSync(marker, "utf8")) ?? [];
-  const names = new Map;
-  for (const dir of memberDirs(found.root, globs)) {
-    const manifest = join(dir, "package.json");
-    const name = existsSync(manifest) ? nameOf(manifest) : undefined;
-    if (name !== undefined && !names.has(name))
-      names.set(name, manifest);
-  }
-  const members = { names, root: found.root };
-  cache.set(marker, { members, stamp });
-  return members;
+  return remembered(members, marker, () => {
+    const globs = globsOf(found.marker, readFileSync(marker, "utf8")) ?? [];
+    const names = new Map;
+    for (const dir of memberDirs(found.root, globs)) {
+      const manifest = join(dir, "package.json");
+      const name = existsSync(manifest) ? nameOf(manifest) : undefined;
+      if (name !== undefined && !names.has(name))
+        names.set(name, manifest);
+    }
+    return { names, root: found.root };
+  });
 };
 var workspaceMemberNamed = (from, name) => membersFrom(from)?.names.get(name);
 var hasWorkspaceAbove = (from) => rootAbove(from) !== undefined;

package/dist/rules/list-take-without-order.d.ts

@@ -2,6 +2,8 @@ import { type RuleContextWithRawOptions } from './lib/context.js';
 import { type AnyNode } from './lib/nodes.js';
 declare const listTakeWithoutOrder: {
     create(context: RuleContextWithRawOptions): {
+        CallExpression?: undefined;
+    } | {
         CallExpression(node: AnyNode): void;
     };
     fixShape: string;
@@ -10,7 +12,12 @@ declare const listTakeWithoutOrder: {
             description: string;
         };
         messages: {
+            truncated: string;
             unordered: string;
+            unorderedFind: string;
+            unorderedFirst: string;
+            unorderedLimit: string;
+            unorderedSql: string;
         };
         schema: {
             additionalProperties: boolean;
@@ -21,12 +28,29 @@ declare const listTakeWithoutOrder: {
                     };
                     type: 'array';
                 };
+                exempt: {
+                    anyOf: ({
+                        type: 'string';
+                        items?: undefined;
+                    } | {
+                        items: {
+                            type: 'string';
+                        };
+                        type: 'array';
+                    })[];
+                };
                 orderKeys: {
                     items: {
                         type: 'string';
                     };
                     type: 'array';
                 };
+                uniqueColumns: {
+                    items: {
+                        type: 'string';
+                    };
+                    type: 'array';
+                };
             };
             type: 'object';
         }[];

package/dist/rules/list-take-without-order.js

@@ -1,10 +1,130 @@
 // src/rules/list-take-without-order.ts
-import { propertyNameOf, walkNode } from "./lib/nodes.js";
+import { FUNCTION_BOUNDARY_TYPES, propertyNameOf, walkNode } from "./lib/nodes.js";
 import { keyNameOf } from "./lib/objects.js";
+import { DEFAULT_TEST_EXEMPT, PATTERNS, patternsOf } from "./lib/options.js";
+import { anyOf, normalise } from "./lib/paths.js";
 import { bagOf } from "./lib/probe.js";
 import { optionsBag, STRINGS } from "./lib/schema.js";
+var UNIQUE_COLUMNS = ["id"];
+var RELATIONAL = new Set(["findFirst", "findMany"]);
+var AGGREGATE = /^\s*(?:count|sum|min|max|avg|total|group_concat)\s*\(/i;
 var CALLEES = [String.raw`^(?:\w+\.)?list[A-Z]`, String.raw`^(?:\w+\.)?graph$`];
 var ORDER_KEYS = ["order", "orderBy"];
+var TEST_PATHS = [...DEFAULT_TEST_EXEMPT, "integration-tests/"];
+var PAGING_KEYS = ["take", "skip", "offset"];
+var WHOLE_MEMBERS = new Set([
+  "entries",
+  "every",
+  "filter",
+  "flat",
+  "flatMap",
+  "forEach",
+  "join",
+  "keys",
+  "length",
+  "map",
+  "reduce",
+  "reduceRight",
+  "some",
+  "values"
+]);
+var ROW_MEMBERS = new Set([
+  "at",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "pop",
+  "shift",
+  "slice",
+  "sort",
+  "toSorted"
+]);
+var WRAPPERS = new Set([
+  "AwaitExpression",
+  "ParenthesizedExpression",
+  "TSAsExpression",
+  "TSNonNullExpression",
+  "TSSatisfiesExpression"
+]);
+var isNode = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parentOf = (node) => isNode(node.parent) ? node.parent : undefined;
+var valueOf = (call) => {
+  let at = call;
+  for (let up = parentOf(at);up !== undefined && WRAPPERS.has(up.type ?? ""); up = parentOf(at)) {
+    at = up;
+  }
+  return at;
+};
+var useOf = (value) => {
+  const up = parentOf(value);
+  if (up === undefined)
+    return "other";
+  if (up.type === "MemberExpression" && up.object === value) {
+    if (up.computed === true)
+      return "row";
+    const member = propertyNameOf(up);
+    if (member !== null && ROW_MEMBERS.has(member))
+      return "row";
+    return member !== null && WHOLE_MEMBERS.has(member) ? "whole" : "other";
+  }
+  if (up.type === "ForOfStatement" && up.right === value)
+    return "whole";
+  if (up.type === "SpreadElement")
+    return "whole";
+  if (up.type === "CallExpression" || up.type === "NewExpression") {
+    return Array.isArray(up.arguments) && up.arguments.includes(value) ? "whole" : "other";
+  }
+  return "other";
+};
+var nameOf = (node) => isNode(node) && node.type === "Identifier" && typeof node.name === "string" ? [node.name] : [];
+var boundNames = (id) => {
+  if (!isNode(id))
+    return [];
+  if (id.type === "Identifier")
+    return nameOf(id);
+  if (id.type === "ArrayPattern")
+    return "row";
+  if (id.type !== "ObjectPattern" || !Array.isArray(id.properties))
+    return [];
+  return id.properties.flatMap((one) => {
+    if (!isNode(one) || one.type !== "Property")
+      return [];
+    return isNode(one.value) && one.value.type === "AssignmentPattern" ? nameOf(one.value.left) : nameOf(one.value);
+  });
+};
+var scopeOf = (node) => {
+  let at = node;
+  for (let up = parentOf(at);up !== undefined; up = parentOf(at)) {
+    at = up;
+    if (up.type === "Program" || FUNCTION_BOUNDARY_TYPES.has(up.type ?? ""))
+      break;
+  }
+  return at;
+};
+var usesOf = (call) => {
+  const value = valueOf(call);
+  const up = parentOf(value);
+  if (up?.type !== "VariableDeclarator" || up.init !== value)
+    return [useOf(value)];
+  const names = boundNames(up.id);
+  if (names === "row")
+    return ["row"];
+  const uses = [];
+  walkNode(scopeOf(up), (inner) => {
+    if (inner.type === "Identifier" && names.includes(String(inner.name)))
+      uses.push(useOf(inner));
+  });
+  return uses;
+};
+var capOf = (take, skip) => {
+  if (!isNode(take) || take.type !== "Literal")
+    return null;
+  if (typeof take.value !== "number" || take.value <= 1)
+    return null;
+  const fromTheStart = skip === undefined || isNode(skip) && skip.type === "Literal" && skip.value === 0;
+  return fromTheStart ? take.value : null;
+};
 var spellingOf = (callee) => {
   if (callee === undefined)
     return null;
@@ -16,17 +136,139 @@ var spellingOf = (callee) => {
   const object = callee.object;
   return object?.type === "Identifier" ? `${String(object.name)}.${property}` : property;
 };
+var linksOf = (top) => {
+  const links = [];
+  let at = top;
+  while (at.type === "CallExpression" && isNode(at.callee)) {
+    const callee = at.callee;
+    const name = callee.type === "MemberExpression" ? propertyNameOf(callee) : null;
+    if (name === null || callee.computed === true || !isNode(callee.object))
+      break;
+    links.unshift({ args: at.arguments ?? [], call: at, name });
+    at = callee.object;
+  }
+  return { links, root: at };
+};
+var isChainTop = (node) => {
+  const up = parentOf(node);
+  return !(up?.type === "MemberExpression" && up.object === node);
+};
+var pins = (node, unique) => {
+  if (!isNode(node))
+    return false;
+  if (node.type === "ArrowFunctionExpression")
+    return pins(node.body, unique);
+  if (node.type !== "CallExpression" || !isNode(node.callee))
+    return false;
+  const name = node.callee.type === "Identifier" ? node.callee.name : propertyNameOf(node.callee);
+  const [left] = node.arguments ?? [];
+  const column = isNode(left) && left.type === "MemberExpression" ? propertyNameOf(left) : null;
+  return name === "eq" && column !== null && unique.includes(column);
+};
+var sqlOf = (node) => {
+  if (!isNode(node))
+    return null;
+  if (node.type === "Literal")
+    return typeof node.value === "string" ? node.value : null;
+  if (node.type !== "TemplateLiteral" || !Array.isArray(node.quasis))
+    return null;
+  return node.quasis.map((quasi) => isNode(quasi) && isNode(quasi.value) && typeof quasi.value.cooked === "string" ? quasi.value.cooked : "").join(" ? ");
+};
+var preparedSql = (links) => {
+  const prepare = links.find((one) => one.name === "prepare");
+  const sql = prepare === undefined ? null : sqlOf(prepare.args[0]);
+  return prepare === undefined || sql === null ? null : { at: prepare.call, sql };
+};
+var valueInside = (node) => WRAPPERS.has(node.type ?? "") && isNode(node.expression) ? valueInside(node.expression) : node;
+var declaredSql = (root) => {
+  if (root.type !== "Identifier")
+    return null;
+  let found = null;
+  walkNode(scopeOf(root), (inner) => {
+    if (found !== null || inner.type !== "VariableDeclarator")
+      return;
+    const id = inner.id;
+    if (id?.type !== "Identifier" || id.name !== root.name || !isNode(inner.init))
+      return;
+    found = preparedSql(linksOf(valueInside(inner.init)).links)?.sql ?? null;
+  });
+  return found;
+};
+var readSql = (sql, unique) => {
+  const list = /^\s*select\s+([\s\S]*?)\s+from\b/i.exec(sql)?.[1];
+  const where = /\bwhere\b([\s\S]*)/i.exec(sql)?.[1] ?? "";
+  const columns = unique.map((one) => one.replace(/[^\w]/g, "")).join("|");
+  return {
+    limits: /\blimit\b/i.test(sql),
+    orders: /\border\s+by\b/i.test(sql),
+    pinned: columns !== "" && !/\bor\b/i.test(where) && new RegExp(String.raw`\b(?:\w+\.)?(?:${columns})\s*=\s*(?:\?\d*|[:@$]\w+|\d+|'[^']*')`, "i").test(where),
+    selects: /^\s*(?:with|select)\b/i.test(sql),
+    single: list !== undefined && !/\bgroup\s+by\b/i.test(sql) && list.split(",").every((part) => AGGREGATE.test(part))
+  };
+};
 var listTakeWithoutOrder = {
   create(context) {
     const options = bagOf(context.options);
     const callees = (options.callees ?? CALLEES).map((pattern) => new RegExp(pattern));
     const orderKeys = options.orderKeys ?? ORDER_KEYS;
+    const exempt = options.exempt === undefined ? TEST_PATHS : patternsOf(options.exempt);
+    const unique = options.uniqueColumns ?? UNIQUE_COLUMNS;
+    if (anyOf(exempt, normalise(context.filename)))
+      return {};
+    const judgeChain = (node) => {
+      if (!isChainTop(node))
+        return;
+      const { links, root } = linksOf(node);
+      const names = links.map((one) => one.name);
+      const last = links.at(-1);
+      if (names.includes("from") && names.includes("limit") && !names.includes("orderBy")) {
+        const where = links.find((one) => one.name === "where");
+        const limit = links.find((one) => one.name === "limit");
+        if (limit !== undefined && !pins(where?.args[0], unique)) {
+          context.report({ data: {}, messageId: "unorderedLimit", node: limit.call });
+        }
+      }
+      if (last !== undefined && RELATIONAL.has(last.name) && root.type === "MemberExpression" && isNode(root.object) && root.object.type === "MemberExpression" && propertyNameOf(root.object) === "query") {
+        const config = new Map;
+        const [first] = last.args;
+        if (isNode(first) && first.type === "ObjectExpression" && Array.isArray(first.properties)) {
+          for (const one of first.properties) {
+            const key = one.type === "Property" ? keyNameOf(one) : null;
+            if (key !== null)
+              config.set(key, one.value);
+          }
+        }
+        const paged = last.name === "findFirst" || config.has("limit");
+        if (paged && !config.has("orderBy") && !(last.name === "findFirst" && pins(config.get("where"), unique))) {
+          context.report({
+            data: { callee: last.name },
+            messageId: "unorderedFind",
+            node: last.call
+          });
+        }
+      }
+      const inline = preparedSql(links);
+      if (inline !== null) {
+        const read = readSql(inline.sql, unique);
+        if (read.selects && read.limits && !read.orders && !read.pinned) {
+          context.report({ data: {}, messageId: "unorderedSql", node: inline.at });
+        }
+      }
+      if (last?.name === "first") {
+        const sql = inline?.sql ?? declaredSql(root);
+        const read = sql === null ? null : readSql(sql, unique);
+        if (read !== null && read.selects && !read.orders && !read.limits && !read.pinned && !read.single) {
+          context.report({ data: {}, messageId: "unorderedFirst", node: last.call });
+        }
+      }
+    };
     return {
       CallExpression(node) {
+        judgeChain(node);
         const callee = spellingOf(node.callee);
         if (callee === null || !callees.some((pattern) => pattern.test(callee)))
           return;
-        let takes = false;
+        const paging = new Map;
         let orders = false;
         let unreadable = false;
         for (const argument of node.arguments ?? []) {
@@ -36,13 +278,24 @@ var listTakeWithoutOrder = {
             if (inner.type !== "Property")
               return;
             const key = keyNameOf(inner);
-            if (key === "take")
-              takes = true;
+            if (key !== null && PAGING_KEYS.includes(key) && !paging.has(key)) {
+              paging.set(key, inner.value);
+            }
             if (key !== null && orderKeys.includes(key))
               orders = true;
           });
         }
-        if (!takes || orders || unreadable)
+        if (!paging.has("take") || unreadable)
+          return;
+        const cap = capOf(paging.get("take"), paging.get("skip") ?? paging.get("offset"));
+        if (cap !== null) {
+          const uses = usesOf(node);
+          if (uses.includes("whole") && !uses.includes("row")) {
+            context.report({ data: { callee, take: String(cap) }, messageId: "truncated", node });
+            return;
+          }
+        }
+        if (orders)
           return;
         context.report({
           data: { callee, order: orderKeys[0] ?? "" },
@@ -56,18 +309,48 @@ var listTakeWithoutOrder = {
 or \`query.graph\` call carrying \`take\` names an \`order\` beside it — the column the page is a page OF —
 so the first row is the first row every time, and the row a previous stage just wrote is where the
 reader expects it. Without one the database returns whatever is cheapest, which is stable in
-development and different under load. A spread the rule cannot read is left alone. Which calls are
-list calls is the \`callees\` option and which key declares the ordering is \`orderKeys\`.`,
+development and different under load. A spread the rule cannot read is left alone.
+
+A \`take\` that is a cap, not a page, is the other finding, and naming an \`order\` does not clear it:
+a literal above 1, from the first row (no \`skip\` or \`offset\`, or a literal 0), whose result is bound
+to a name and then iterated, counted, mapped, filtered or handed whole to another call, with no
+first-row read (\`[n]\`, \`.at()\`, \`.find()\`, \`.slice()\`, \`.sort()\`) beside it. Ordering makes the cut
+deterministic: the row after the cap is still never read. Remove the cap, or read pages with \`skip\`
+until one comes back short, or count first. A \`take\` the caller supplies, a \`skip\` the caller
+supplies, a \`take\` of 1 and a result nothing here consumes stay the first finding, which an
+\`order\` clears.
+
+On D1 the same question is asked three more ways, and each is answered by an order or by a unique
+column. A Drizzle select chain with \`.limit(n)\` and no \`.orderBy(…)\` anywhere in it; a relational
+\`findMany({ limit })\` with no \`orderBy\`, or a \`findFirst\`, which is \`LIMIT 1\`, with no \`orderBy\`; and
+on the raw binding a \`prepare()\` SELECT with LIMIT and no ORDER BY, or a \`.first()\` over a SELECT with
+no ORDER BY — D1's \`.first()\` does not alter the statement, it returns the first row it produced. A
+\`where\` that is \`eq(t.<unique>, …)\`, or a SQL WHERE \`<unique> = ?\` with no OR, pins the row and is not
+the bug; the unique columns are \`uniqueColumns\` (default \`id\`). A \`.first()\` over an aggregate
+SELECT with no GROUP BY is one row and is not judged, and only SQL written as a string or a template
+literal is read.
+
+Which calls are list calls is the \`callees\` option and which key declares the ordering is
+\`orderKeys\`. Test files are not judged (\`__tests__/\`, \`.test.\`, \`.spec.\`, \`integration-tests/\`):
+the row a fixture takes does not matter. \`exempt\` replaces that list; \`exempt: []\` judges test
+files too.`,
   meta: {
     docs: {
-      description: "A list or graph call that takes a page without declaring an order. The rows come back in whatever order is cheapest, so `[0]`, `.find()` and `.sort()` over the result answer a question about the page rather than about the table."
+      description: "A list or graph call that takes a page without declaring an order. The rows come back in whatever order is cheapest, so `[0]`, `.find()` and `.sort()` over the result answer a question about the page rather than about the table. A literal `take` whose result is consumed whole is a cap that drops rows silently, ordered or not, and has its own message. Test files are not judged unless `exempt` is emptied."
     },
     messages: {
-      unordered: "`{{callee}}` takes a page with no `{{order}}`: the rows come back in whatever order the database finds cheapest, so the first row is a different row under load. Name the column the page is a page of."
+      truncated: "`{{callee}}` reads at most {{take}} rows and the code below treats them as all of them: the rows past the {{take}}th are never seen, in any order. Remove the cap, page through with `skip` until a page comes back short, or count first.",
+      unordered: "`{{callee}}` takes a page with no `{{order}}`: the rows come back in whatever order the database finds cheapest, so the first row is a different row under load. Name the column the page is a page of.",
+      unorderedFind: "`{{callee}}` reads a page with no `orderBy` (`findFirst` is `LIMIT 1`): SQLite returns the rows in whatever order is cheapest, so the row it answers with changes under load. Add `orderBy`, or pin the row with `eq` on a unique column.",
+      unorderedFirst: "`.first()` returns the first row the statement produced, and this SELECT has no ORDER BY — D1 adds neither a LIMIT nor an order — so when more than one row matches, which one comes back is SQLite's choice. Add ORDER BY, or pin the row by a unique column in the WHERE.",
+      unorderedLimit: "`.limit()` in a select with no `.orderBy()`: SQLite returns the rows in whatever order is cheapest, so the page is a different page under load. Add `.orderBy(…)` naming the column the page is a page of.",
+      unorderedSql: "This SELECT has LIMIT and no ORDER BY: SQLite returns the rows in whatever order is cheapest, so the page is a different page under load. Add ORDER BY naming the column the page is a page of."
     },
     schema: optionsBag({
       callees: STRINGS,
-      orderKeys: STRINGS
+      exempt: PATTERNS,
+      orderKeys: STRINGS,
+      uniqueColumns: STRINGS
     }),
     type: "problem"
   }

package/dist/rules/no-orm-outside-db.js

@@ -14,6 +14,7 @@ Everywhere else, reach the data through a query the data layer exports. The ORM
 below the seam, and a caller that names it has crossed it. Which paths are the data layer is the
 \`dataLayer\` option (default \`/packages/db/\`).`,
   forbidden: (target, importer, options) => isOrmModule(target.source) && !anyOf(options.dataLayer, importer.path),
+  mayForbid: isOrmModule,
   messageId: "ormOutsideDb",
   messages: {
     ormOutsideDb: 'This file imports "{{source}}". drizzle-orm lives only in the data-layer package — reach the data through a query that package exports, or add the query there.'

package/dist/rules/subpath-over-barrel.d.ts

@@ -12,6 +12,7 @@ declare const subpathOverBarrel: {
     create(context: RuleContextWithOptions<Options>): {
         ExportNamedDeclaration: (node: AnyNode) => void;
         ImportDeclaration: (node: AnyNode) => void;
+        Program(node: AnyNode): void;
     };
     fixShape: string;
     meta: {