oxlint-plugin-arch 0.12.0 → 0.12.2

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.12.2
+
+### Added
+
+- Preset: folder key `services` names an app's or package's service folder inside `source` (default `services`). An app or backend without `services/` uses `lib/` as its service folder, so a flat `lib/` gets the same layout, naming, import-boundary and registry checks; next to `services/`, `lib/` stays portable helpers. `arch/boundaries-imports` gets the matching `services` option.
+
+### Fixed
+
+- `arch/schemas-local` no longer reports `z.config(...)` and zod's error formatters (`prettifyError`, `treeifyError`, `flattenError`, `formatError`), or an import used only for them; they build no schema. The new `calls` option sets that list.
+
+## 0.12.1
+
+### Changed
+
+- Preset: tests live in a `tests/` (or `test/`) folder. A `*.test.*` or `*.spec.*` file inside a unit's source is reported by `arch/files-restricted`.
+
+### Fixed
+
+- Preset detection reads `pnpm-workspace.yaml` (block or flow lists), workspace globs with `*` anywhere, `**`, `{a,b}` and `!exclude`, and peer dependencies (a UI package with React as a peer is `ui`). Packages and service domains named like output folders (`build`, `public`) are no longer skipped.
+- Preset detection keeps a root app's or backend's recipe next to its workspace packages (when the root has its own source folder), gives a single root package its recipe (`library` included), and keeps the root unit next to a detected `scripts/` CLI. A folder with its own `package.json` is a unit with its own kind, also when nested in another workspace or listed through a `*` key, instead of inheriting the root app's kind.
+- Preset: a unit without `src/` uses its own folder as source (a workspace Next app with `app/` at the package root).
+- Preset detection honors a configured `source`, `backend.registry` file or `false`, expands `*` keys (with exact keys beside them, which also inherit the wildcard's `source`) before adding conventions, and understands import maps such as `"#/*": "./src/*.ts"`, `"#/*.ts": "./src/*.ts"`, exact and conditional entries.
+- Preset detection: a service may import its own domain's operations; other domains stay banned through one `!(domain)` pattern per domain, and a ban you configure yourself is never lifted. A web app's or package's own aliases that overlap the backend's (`#/*`, `#/lib/*`) are no longer banned.
+- Preset detection skips broken symlinks, follows symlinked folders, and drops conventions inside a `false` folder or for a group a parent sets to `false` (an exact key beats a `*` key at the same depth, and an exact key that revives a unit under a `false` wildcard keeps its conventions), instead of throwing.
+- Preset: folder keys accept dots (`packages/my.lib`, `.agents`), and `apps/web/` or `./apps` match the detected `apps/web` and `apps`.
+- Preset: nested group options merge with the inherited ones (`tests.mocking: { allow: [] }` keeps the parent's `preset` and `deny`, also when the parent used the `'strict'` shorthand).
+- Preset: the registry file is exempt from the domain layout and its file and folder name checks; test files skip the domain, operation and frontend runtime file name checks (the `tests/` check below reports them once); operation files in `actions/` and `queries/` keep the single-export check; `layout.strict` accepts `.rsc.tsx`.
+- Preset: Tailwind stylesheet detection ignores comments, strings and plugins such as `tailwindcss-animate`, accepts `@import url("tailwindcss")` with or without quotes, and follows symlinked folders.
+- Preset: `dist`, `build`, `coverage` and `.output` are ignored at the project root and at each unit's root, not at any depth, so a `services/build/` domain is linted.
+- `arch/boundaries-deny` import globs accept `!(a|b)`: one path segment that is none of the names.
+- Preset: `layout.strict` checks domain file names at any depth under `services/<domain>/`, so a nested or misnamed file (`order/queries/order-query-list.ts`) is reported for its name, not only its folder. `layout.operations: 'folders'` keeps its own `actions/` and `queries/` names.
+- Preset detection: a `next` or `vinext` dependency wins over a leftover `@tanstack/react-start` one.
+- Preset detection: a package with `services/<domain>/<domain>.service.ts` gets the `backend` recipe without a backend framework dependency.
+- Preset: `services/**/*.rsc.{ts,tsx}` files and frontend operation files (`*-action.*.client.ts` and the other runtime suffixes) keep the export prefix check next to their name pattern or template. Since 0.12.0 the later override replaced it; 0.11 ran both.
+- `dillon-anti-slop/no-shape-in-symbol-names` reports only names you declare: not another API's property (`schema.shape`, `record.shape = 1`), a renamed destructured property or import, a qualified type read, a JSX member or attribute, or a renamed re-export from another module. A shorthand property reports once.
+
 ## 0.12.0
 
 ### Breaking: rebuilt package

package/dist/index.js

@@ -32,8 +32,12 @@ function optionsPatternsTest(patterns, value) {
   });
 }
 function optionsGlob(pattern) {
-  const source = pattern.replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
-  return new RegExp(`^${source}$`);
+  const negated = [];
+  const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    return `\x02${negated.length - 1}\x03`;
+  }).replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
+  return new RegExp(`^${negated.reduce((text, names, index) => text.replace(`\x02${index}\x03`, `(?!(?:${names})(?:/|$))[^/]*`), source)}$`);
 }
 function optionsPatternLabel(pattern) {
   return pattern === undefined ? "" : [pattern].flat().filter((source) => source !== "").join(" | ");
@@ -1107,15 +1111,19 @@ function boundariesContains(directory, candidate) {
 function boundariesStripExtension(path) {
   return path.replace(/\.[cm]?[jt]sx?$/, "");
 }
-function boundariesDomain(path, appRoot) {
+function boundariesServiceFolder(options, root) {
+  const nested = [...options.web, ...options.backend].filter((other) => other.length > root.length && boundariesContains(root, other));
+  return options.services?.find((folder) => folder.startsWith(`${root}/`) && !nested.some((other) => boundariesContains(other, folder))) ?? `${root}/services`;
+}
+function boundariesDomain(path, appRoot, services) {
   const relative = path.slice(appRoot.length + 1);
   if (relative.startsWith("types/") && relative.endsWith(".types.ts")) {
     return relative.slice("types/".length).split(".")[0];
   }
-  if (!relative.startsWith("services/")) {
+  if (!boundariesContains(services, path) || path === services) {
     return;
   }
-  const parts = relative.slice("services/".length).split("/");
+  const parts = path.slice(services.length + 1).split("/");
   return parts.length > 1 ? parts[0] : parts[0].split(".")[0].replace(/-(?:action|query|driver)$/, "");
 }
 function boundariesPrivateDomain({ options, file, target, reExport, roots, owner }) {
@@ -1124,8 +1132,8 @@ function boundariesPrivateDomain({ options, file, target, reExport, roots, owner
     return;
   }
   const targetOwner = roots.find((path) => boundariesContains(path, target));
-  const fileDomain = owner ? boundariesDomain(file, owner) : undefined;
-  const targetDomain = targetOwner ? boundariesDomain(target, targetOwner) : undefined;
+  const fileDomain = owner ? boundariesDomain(file, owner, boundariesServiceFolder(options, owner)) : undefined;
+  const targetDomain = targetOwner ? boundariesDomain(target, targetOwner, boundariesServiceFolder(options, targetOwner)) : undefined;
   const sameDomain = owner && owner === targetOwner && fileDomain && fileDomain === targetDomain;
   const targetStem = boundariesStripExtension(target);
   const publicSurface = boundariesPublicSurface.test(targetStem) && !boundariesActionOrQuery.test(targetStem);
@@ -1140,11 +1148,11 @@ function boundariesPrivateDomain({ options, file, target, reExport, roots, owner
 }
 function boundariesPortableLib(check) {
   const { options, file, source, target, typeOnly, reExport, roots, web, backendImport } = check;
-  if (!options.portable || !web || !boundariesContains(`${web}/lib`, file)) {
+  if (!options.portable || !web || !boundariesContains(`${web}/lib`, file) || boundariesServiceFolder(options, web) === `${web}/lib`) {
     return;
   }
   const portableTarget = target.startsWith("/") ? resolve2(target).replaceAll("\\", "/") : target;
-  const appService = roots.some((path) => boundariesContains(`${path}/services`, portableTarget));
+  const appService = roots.some((path) => boundariesContains(boundariesServiceFolder(options, path), portableTarget));
   const backendTarget = options.backend.some((path) => boundariesContains(path, portableTarget));
   const appPackage = boundariesMatchesImport(options.appPackages, source);
   if (backendImport || backendTarget || appService || appPackage) {
@@ -1171,6 +1179,7 @@ var boundariesImports = defineRule7({
           backend: { type: "array", items: { type: "string" } },
           packages: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
           roles: { type: "array", items: { type: "string" } },
+          services: { type: "array", items: { type: "string" } },
           portable: { type: "boolean" },
           backendPackages: { type: "array", items: { type: "string" } },
           entrypoints: { type: "array", items: { type: "string" } },
@@ -1196,11 +1205,14 @@ var boundariesImports = defineRule7({
       const imported = { options, file, source, target, typeOnly, reExport, roots, owner, web, backendImport };
       const inPackage = [options.packages].flat().some((path) => path && boundariesContains(path, file));
       const appTarget = backendImport || options.web.some((path) => boundariesContains(path, target)) || boundariesMatchesImport(options.appPackages, source);
-      const domainContract = /\.(?:types|constants)\.ts$/.test(file) && !typeOnly && /\/(?:core\/|services\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/))/.test(target);
+      const serviceFolders = roots.map((path) => boundariesServiceFolder(options, path));
+      const serviceTarget = serviceFolders.find((folder) => boundariesContains(folder, target));
+      const serviceFile = serviceFolders.find((folder) => boundariesContains(folder, file));
+      const domainContract = /\.(?:types|constants)\.ts$/.test(file) && !typeOnly && (/\/(?:core\/|services\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/))/.test(target) || serviceTarget !== undefined && /\/.*(?:\.(?:service|utils)|-(?:action|query)\.|\/(?:actions|queries)\/)/.test(target.slice(serviceTarget.length)));
       const reason = [
         web && backendImport && !options.entrypoints.includes(source) ? "frontend code uses only public backend entry points" : undefined,
         inPackage && appTarget ? "shared packages do not import app internals" : undefined,
-        file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
+        (file.includes("/services/") && /\/services\/service(?:\.ts)?$/.test(target) || serviceFile !== undefined && /^\/service(?:\.ts)?$/.test(target.slice(serviceFile.length))) && !typeOnly ? "service dependencies are injected rather than read from the registry" : undefined,
         domainContract ? "domain types/constants use type-only imports from implementations" : undefined,
         file.endsWith(".client.ts") && !typeOnly && boundariesMatchesImport(options.uiPackages ?? ["react", "react-dom"], source) ? "client services are React-free; use hooks for React behavior" : undefined,
         boundariesPrivateDomain(imported),
@@ -1241,9 +1253,9 @@ var boundariesImports = defineRule7({
         }
       },
       TSImportType(node) {
-        const { portable: portableLib, web } = { ...boundariesImportsDefaults, ...optionsFirst(context) };
+        const options = { ...boundariesImportsDefaults, ...optionsFirst(context) };
         const file = context.filename.replaceAll("\\", "/");
-        if (portableLib && web.some((path) => file.startsWith(`${path}/lib/`))) {
+        if (options.portable && options.web.some((path) => file.startsWith(`${path}/lib/`) && boundariesServiceFolder(options, path) !== `${path}/lib`)) {
           check(node, node.source.value, true);
         }
       }
@@ -5390,6 +5402,7 @@ var schemasInline = defineRule46({
 import { defineRule as defineRule47 } from "@oxlint/plugins";
 var schemasLocalImportMessage = "Do not import runtime schema constructors from {{source}}; import a named schema instead.";
 var schemasLocalConstructionMessage = "Do not construct schemas locally; import a named schema instead.";
+var schemasLocalCalls = ["config", "prettifyError", "treeifyError", "flattenError", "formatError"];
 var schemasLocal = defineRule47({
   meta: {
     type: "problem",
@@ -5400,6 +5413,7 @@ var schemasLocal = defineRule47({
         properties: {
           packages: { type: "array", items: { type: "string" } },
           namespaces: { type: "array", items: { type: "string" } },
+          calls: { type: "array", items: { type: "string" } },
           allow: { type: "array", items: { type: "string" } },
           patterns: { type: "array", items: { type: "string" } },
           message: { type: "string" },
@@ -5417,8 +5431,15 @@ var schemasLocal = defineRule47({
   createOnce(context) {
     let constructors = new Set;
     let packages = new Set;
+    let calls = new Set;
+    let pending = [];
+    let schemaUses = new Set;
+    let callUses = new Set;
     let importMessage = schemasLocalImportMessage;
     let constructionMessage = schemasLocalConstructionMessage;
+    function isAllowedCall(node, member) {
+      return member?.type === "MemberExpression" && member.object === node && !member.computed && member.property.type === "Identifier" && calls.has(member.property.name) && member.parent.type === "CallExpression" && member.parent.callee === member;
+    }
     function isPackage(source) {
       return packages.has(source) || [...packages].some((name) => source.startsWith(`${name}/`));
     }
@@ -5443,6 +5464,10 @@ var schemasLocal = defineRule47({
         const filename = context.filename.replaceAll("\\", "/");
         constructors = new Set(options.namespaces);
         packages = new Set(options.packages);
+        calls = new Set(options.calls ?? schemasLocalCalls);
+        pending = [];
+        schemaUses = new Set;
+        callUses = new Set;
         importMessage = options.importMessage ?? options.message ?? schemasLocalImportMessage;
         constructionMessage = options.constructionMessage ?? options.message ?? schemasLocalConstructionMessage;
         if ((options.allow ?? []).some((suffix) => filename.endsWith(suffix)) || (options.patterns ?? []).some((pattern) => new RegExp(pattern).test(filename))) {
@@ -5460,7 +5485,27 @@ var schemasLocal = defineRule47({
         for (const name of locals) {
           constructors.add(name);
         }
-        reportRuntimeImport(node, node.source.value);
+        if (locals.length === 0) {
+          reportRuntimeImport(node, node.source.value);
+          return;
+        }
+        pending.push({ node, locals });
+      },
+      Identifier(node) {
+        if (!constructors.has(node.name) || node.parent.type.startsWith("Import")) {
+          return;
+        }
+        if (isAllowedCall(node, node.parent)) {
+          callUses.add(node.name);
+          return;
+        }
+        schemaUses.add(node.name);
+      },
+      "Program:exit"() {
+        const runtime = pending.filter(({ locals }) => locals.some((name) => schemaUses.has(name) || !callUses.has(name)));
+        for (const { node } of runtime) {
+          reportRuntimeImport(node, node.source.value);
+        }
       },
       ExportNamedDeclaration: checkReexport,
       ExportAllDeclaration: checkReexport,
@@ -5469,7 +5514,7 @@ var schemasLocal = defineRule47({
         while (root.type === "MemberExpression") {
           root = root.object;
         }
-        if (root.type !== "Identifier" || !constructors.has(root.name)) {
+        if (root.type !== "Identifier" || !constructors.has(root.name) || node.callee.type === "MemberExpression" && node.callee.object === root && isAllowedCall(root, root.parent)) {
           return;
         }
         context.report({

package/dist/preset/preset-detect.d.ts

@@ -1,4 +1,3 @@
 import type * as PresetTypes from '../types/preset.types.ts';
-export declare function presetManifest(root: string, directory: string): PresetTypes.PresetManifest;
+export declare function presetRegistryFile(root: string, source: string, configured: PresetTypes.PresetBackendOptions['registry'], services: string): string | undefined;
 export declare function presetDetect(root: string, folders: PresetTypes.PresetFolders): PresetTypes.PresetFolders;
-export declare function presetStylesheet(root: string, directory: string): string | undefined;

package/dist/preset/preset-stylesheet.d.ts

@@ -0,0 +1 @@
+export declare function presetStylesheet(root: string, directory: string): string | undefined;

package/dist/preset/preset-units.d.ts

@@ -0,0 +1,2 @@
+import type * as PresetTypes from '../types/preset.types.ts';
+export declare function presetUnits(root: string, scopes: PresetTypes.PresetScope[], ignored: Set<string>): PresetTypes.PresetUnit[];

package/dist/preset/preset.constants.d.ts

@@ -41,6 +41,8 @@ export declare const presetExportPrefix: {
 };
 export declare const presetGeneratedFiles: string[];
 export declare const presetBuiltinFileRoles: string[];
+export declare const presetShorthandOptions: readonly [readonly ['tests', 'mocking', 'preset'], readonly ['backend', 'registry', 'file']];
+export declare const presetOutputFolders: string[];
 export declare const presetLiteralSegment: RegExp;
 export declare const presetIllustrationPalette: string[];
 export declare const presetGroupOrder: PresetTypes.PresetGroupName[];