declapract-typescript-ehmpathy 0.49.13 → 0.49.14

package/dist/practices/conventional-commits/commitlint-body-max-line.declapract.integration.test.ts

@@ -46,4 +46,23 @@ describe('conventional-commits commitlint body-max-line-length', () => {
       });
     });
   });
+
+  /**
+   * .what = clamps #516: the footer gets the same warn-level 140 as the body
+   * .why  = config-conventional's footer-max-line-length is error-level 100, so a long
+   *         `Co-Authored-By:` or `Refs:` trailer failed test:commits though the body rule allowed it
+   */
+  given('the shipped commitlint.config.js, loaded as commitlint loads it (#516)', () => {
+    // the template is a commonjs config, so require it as commitlint does
+    const config = require(join(__dirname, 'best-practice/commitlint.config.js')) as {
+      rules: Record<string, unknown>;
+    };
+
+    when('the footer-max-line-length rule is read', () => {
+      then('it is warn-level 140, beside the body rule', () => {
+        expect(config.rules['footer-max-line-length']).toEqual([1, 'always', 140]);
+        expect(config.rules['body-max-line-length']).toEqual([1, 'always', 140]);
+      });
+    });
+  });
 });

package/dist/practices/dates-and-times/.declapract.integration.test.ts

@@ -0,0 +1,95 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+// executeApply is slow (full practice evaluation), so grant a generous limit
+jest.setTimeout(180_000);
+
+/**
+ * .what = end-to-end proof of the uni-time → iso-time migration, run through the REAL declapract
+ *   apply pipeline against a genTempDir clone of a consumer repo.
+ * .why  = the package.json fix and the src fix are two declarations that must agree: the src fix
+ *   rewrites each import to `iso-time` and each `Uni*` name to its `Iso*` twin (#662), so the
+ *   package.json fix must install `iso-time` where `@ehmpathy/uni-time` sat (#642). only the pipeline
+ *   proves both land on one repo.
+ * .note = each touched file is snapshotted before AND after.
+ */
+describe('dates-and-times uni-time migration', () => {
+  given('[case1] a repo with @ehmpathy/uni-time in dependencies and a src import of it', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-dates-uni-time',
+      clone:
+        './src/practices/dates-and-times/bad-practices/uni-time/.test/assets/demo-repo-with-uni-time',
+      symlink: [
+        {
+          at: 'declarations',
+          to: './src/.test/assets/dates-and-times/declarations',
+        },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const pkgPath = 'package.json';
+    const srcPath = 'src/domain.objects/SurfLesson.ts';
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const applyFix = async () => {
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'dates-and-times',
+        file: pkgPath,
+      });
+      await executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'dates-and-times',
+        file: srcPath,
+      });
+    };
+
+    when('[t0] the input (before any fix)', () => {
+      then('package.json and the src file match snapshot', async () => {
+        expect(await read(pkgPath)).toMatchSnapshot('package.json — before');
+        expect(await read(srcPath)).toMatchSnapshot('SurfLesson.ts — before');
+      });
+    });
+
+    when('[t1] the uni-time fixes are applied', () => {
+      useThen('apply both fixes', async () => applyFix());
+
+      then('package.json holds iso-time where @ehmpathy/uni-time sat (#642)', async () => {
+        const after = await read(pkgPath);
+        const pkg = JSON.parse(after);
+        expect(pkg.dependencies['iso-time']).toEqual('1.11.7');
+        expect(pkg.dependencies['@ehmpathy/uni-time']).toBeUndefined();
+        expect(pkg.devDependencies['iso-time']).toBeUndefined();
+        expect(after).toMatchSnapshot('package.json — after');
+      });
+
+      then('the src file reads iso-time and each Uni* name reads as its Iso* twin (#662)', async () => {
+        const after = await read(srcPath);
+        expect(after).toContain(
+          "import { asIsoTimeStamp, type IsoDateStamp, type IsoTimeStamp } from 'iso-time';",
+        );
+        expect(after).toContain('bookedAt: IsoTimeStamp;');
+        expect(after).toContain('lessonDay: IsoDateStamp;');
+        expect(after).not.toMatch(/Uni[A-Z]/);
+        expect(after).toMatchSnapshot('SurfLesson.ts — after');
+      });
+    });
+
+    when('[t2] the fixes are applied a second time (idempotency)', () => {
+      const passes = useThen('a second apply over its own output', async () => {
+        const before = { pkg: await read(pkgPath), src: await read(srcPath) };
+        await applyFix();
+        const after = { pkg: await read(pkgPath), src: await read(srcPath) };
+        return { before, after };
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});

package/dist/practices/dates-and-times/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,59 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`dates-and-times uni-time migration given: [case1] a repo with @ehmpathy/uni-time in dependencies and a src import of it when: [t0] the input (before any fix) then: package.json and the src file match snapshot: SurfLesson.ts — before 1`] = `
+"import { asUniDateTime, type UniDate, type UniDateTime } from '@ehmpathy/uni-time';
+
+export interface SurfLesson {
+  bookedAt: UniDateTime;
+  lessonDay: UniDate;
+}
+
+export const asLessonBookedAt = (input: { at: Date }): UniDateTime =>
+  asUniDateTime(input.at);
+"
+`;
+
+exports[`dates-and-times uni-time migration given: [case1] a repo with @ehmpathy/uni-time in dependencies and a src import of it when: [t0] the input (before any fix) then: package.json and the src file match snapshot: package.json — before 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "@ehmpathy/uni-time": "1.10.0",
+    "date-fns": "2.30.0",
+    "domain-objects": "0.34.0"
+  },
+  "devDependencies": {
+    "jest": "29.3.1"
+  }
+}
+"
+`;
+
+exports[`dates-and-times uni-time migration given: [case1] a repo with @ehmpathy/uni-time in dependencies and a src import of it when: [t1] the uni-time fixes are applied then: package.json holds iso-time where @ehmpathy/uni-time sat (#642): package.json — after 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "date-fns": "2.30.0",
+    "domain-objects": "0.34.0",
+    "iso-time": "1.11.7"
+  },
+  "devDependencies": {
+    "jest": "29.3.1"
+  }
+}
+"
+`;
+
+exports[`dates-and-times uni-time migration given: [case1] a repo with @ehmpathy/uni-time in dependencies and a src import of it when: [t1] the uni-time fixes are applied then: the src file reads iso-time and each Uni* name reads as its Iso* twin (#662): SurfLesson.ts — after 1`] = `
+"import { asIsoTimeStamp, type IsoDateStamp, type IsoTimeStamp } from 'iso-time';
+
+export interface SurfLesson {
+  bookedAt: IsoTimeStamp;
+  lessonDay: IsoDateStamp;
+}
+
+export const asLessonBookedAt = (input: { at: Date }): IsoTimeStamp =>
+  asIsoTimeStamp(input.at);
+"
+`;

package/dist/practices/dates-and-times/bad-practices/moment/src/<star><star>/<star>.ts.declapract.ts

@@ -0,0 +1,21 @@
+import type { FileCheckFunction } from 'declapract';
+
+/**
+ * .what = whether a source file imports `moment`, via esm import, side-effect import, or require
+ */
+const isMomentImported = (contents: string): boolean =>
+  /(?:from\s+|import\s+|require\(\s*)['"]moment['"]/.test(contents);
+
+/**
+ * .what = detects a source file that imports `moment`
+ * .why  = the detection lives on the importer, not on package.json. a moment migration has no
+ *         safe automatic fix (a dropped dependency breaks every import), and declapract marks a
+ *         file manual when one of its failed checks has no fix — so a package.json detection would
+ *         block every other package.json fix in the repo. on the importer, the manual flag lands
+ *         exactly on the file the adopter must migrate to iso-time.
+ * .note = bad-practice semantics: return = detected, throw = not detected
+ */
+export const check: FileCheckFunction = (contents) => {
+  if (contents !== null && isMomentImported(contents)) return;
+  throw new Error('does not match bad practice: no moment import');
+};

package/dist/practices/dates-and-times/bad-practices/uni-time/.test/assets/demo-repo-with-uni-time/declapract.use.yml

@@ -0,0 +1,5 @@
+# .note = the declarations dir is symlinked by the test (holds declapract.declare.yml + a
+#         practices/dates-and-times symlink to the real practice), so the consumer's own src/ tree
+#         stays free to hold the target .ts file the src/**/*.ts glob matches.
+declarations: 'declarations/declapract.declare.yml'
+useCase: lambda-service

package/dist/practices/dates-and-times/bad-practices/uni-time/.test/assets/demo-repo-with-uni-time/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "@ehmpathy/uni-time": "1.10.0",
+    "date-fns": "2.30.0",
+    "domain-objects": "0.34.0"
+  },
+  "devDependencies": {
+    "jest": "29.3.1"
+  }
+}

package/dist/practices/dates-and-times/bad-practices/uni-time/.test/assets/demo-repo-with-uni-time/src/domain.objects/SurfLesson.ts

@@ -0,0 +1,9 @@
+import { asUniDateTime, type UniDate, type UniDateTime } from '@ehmpathy/uni-time';
+
+export interface SurfLesson {
+  bookedAt: UniDateTime;
+  lessonDay: UniDate;
+}
+
+export const asLessonBookedAt = (input: { at: Date }): UniDateTime =>
+  asUniDateTime(input.at);

package/dist/practices/dates-and-times/bad-practices/uni-time/package.json.declapract.ts

@@ -3,19 +3,49 @@ import { FileCheckType, type FileFixFunction } from 'declapract';
 
 export const check = FileCheckType.CONTAINS;
 
+/**
+ * .what = the iso-time version the uni-time fix installs; the release the src fix's identifier
+ *         map was read against (iso-time's own uni-time migration table).
+ */
+const ISO_TIME_VERSION = '1.11.7';
+
+/**
+ * .what = one dependency section, with `@ehmpathy/uni-time` swapped for `iso-time` where it sat.
+ * .note = an extant `iso-time` version is kept; a section with no uni-time is returned as is.
+ */
+const asSectionWithUniTimeSwapped = (input: {
+  section: Record<string, string> | undefined;
+}): Record<string, string | undefined> | undefined => {
+  if (!input.section?.['@ehmpathy/uni-time']) return input.section;
+  return {
+    ...input.section,
+    '@ehmpathy/uni-time': undefined, // undefined drops the key from the written json
+    'iso-time': input.section['iso-time'] ?? ISO_TIME_VERSION,
+  };
+};
+
+/**
+ * .what = swap `@ehmpathy/uni-time` for `iso-time` in each dep section that held it.
+ * .why  = the src fix rewrites every `@ehmpathy/uni-time` import to `iso-time`; a package.json fix
+ *         that only removes the old dep leaves each rewritten file on a package that is not
+ *         installed, and tsc fails with `Cannot find module 'iso-time'` (#642). so `iso-time` lands
+ *         in the same section `@ehmpathy/uni-time` sat in.
+ * .note = an extant `iso-time` version is the adopter's choice and is kept. a section the repo
+ *         never declared is not added.
+ */
 export const fix: FileFixFunction = (contents) => {
   if (!contents) return { contents }; // pass through if contents absent
   const packageJSON = JSON.parse(contents);
+
+  // swap the dep within each section, only where uni-time sat
   const updatedPackageJSON = {
     ...packageJSON,
-    dependencies: {
-      ...packageJSON.dependencies,
-      '@ehmpathy/uni-time': undefined,
-    },
-    devDependencies: {
-      ...packageJSON.devDependencies,
-      '@ehmpathy/uni-time': undefined,
-    },
+    dependencies: asSectionWithUniTimeSwapped({
+      section: packageJSON.dependencies,
+    }),
+    devDependencies: asSectionWithUniTimeSwapped({
+      section: packageJSON.devDependencies,
+    }),
   };
   return {
     contents: JSON.stringify(updatedPackageJSON, null, 2),

package/dist/practices/dates-and-times/bad-practices/uni-time/src/<star><star>/<star>.ts.declapract.ts

@@ -6,12 +6,44 @@ export const check: FileCheckFunction = (contents) => {
   throw new Error('does not match bad practice'); // does not otherwise
 };
 
+/**
+ * .what = each uni-time identifier and its iso-time twin, per iso-time's own migration table.
+ * .why  = iso-time renamed every exported name (the `Iso{Unit}{Nature}` pattern), so a module swap
+ *         alone leaves each imported name unresolved (#662).
+ */
+const UNI_TO_ISO_IDENTIFIERS: Record<string, string> = {
+  UniDateTime: 'IsoTimeStamp',
+  UniDate: 'IsoDateStamp',
+  UniMonth: 'IsoMonthStamp',
+  UniTime: 'IsoTimeFloat',
+  UniDateRange: 'IsoDateStampRange',
+  UniDateTimeRange: 'IsoTimeStampRange',
+  UniDuration: 'IsoDuration',
+  isUniDateTime: 'isIsoTimeStamp',
+  isUniDate: 'isIsoDateStamp',
+  isUniMonth: 'isIsoMonthStamp',
+  asUniDateTime: 'asIsoTimeStamp',
+  asUniDate: 'asIsoDateStamp',
+};
+
+/**
+ * .what = rename each whole-word uni-time identifier to its iso-time twin.
+ * .why  = a word boundary on both sides keeps an identifier that merely holds a uni-time name
+ *         inside it (`CommunityUniDate`) untouched, and makes the map order-free.
+ */
+const withIsoIdentifiers = (input: { contents: string }): string =>
+  input.contents.replace(
+    new RegExp(`\\b(${Object.keys(UNI_TO_ISO_IDENTIFIERS).join('|')})\\b`, 'g'),
+    (name) => UNI_TO_ISO_IDENTIFIERS[name] ?? name,
+  );
+
 export const fix: FileFixFunction = (contents) => {
   if (!contents) return {}; // pass through if contents absent
-  return {
-    contents: contents.replace(
-      /from '@ehmpathy\/uni-time'/g,
-      "from 'iso-time'",
-    ),
-  };
+
+  // swap the module, then the names it exports
+  const withIsoModule = contents.replace(
+    /from '@ehmpathy\/uni-time'/g,
+    "from 'iso-time'",
+  );
+  return { contents: withIsoIdentifiers({ contents: withIsoModule }) };
 };

package/dist/practices/declastruct/bad-practices/old-module-name/package.json.declapract.ts

@@ -1,12 +1,74 @@
-import type { FileCheckFunction } from 'declapract';
-import expect from 'expect';
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
 
+import { asPackageJSON } from '../../../../utils/asPackageJSON';
+
+const PRACTICE = 'declastruct/old-module-name';
+
+/**
+ * .what = the retired name of this practice package
+ */
+const OLD_MODULE_NAME = 'best-practices-typescript';
+
+/**
+ * .what = whether a package.json declares the retired module name, in either dependency map
+ * .note = parses the contents. a match against `JSON.stringify(contents)` (a string) never
+ *         matched an object shape, so the detection was dead.
+ */
+const isOldModuleDeclared = (contents: string | null): boolean => {
+  if (contents === null) return false;
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+  return [packageJSON.dependencies, packageJSON.devDependencies].some(
+    (deps) => !!deps && OLD_MODULE_NAME in deps,
+  );
+};
+
+/**
+ * .what = one dependency section, with the retired module name dropped
+ */
+const asSectionWithoutOldModule = (input: {
+  section: Record<string, string> | undefined;
+}): Record<string, string> | undefined =>
+  input.section
+    ? Object.fromEntries(
+        Object.entries(input.section).filter(
+          ([name]) => name !== OLD_MODULE_NAME,
+        ),
+      )
+    : input.section;
+
+/**
+ * .what = detects a package.json that still depends on the retired `best-practices-typescript`
+ * .note = bad-practice semantics: return = detected, throw = not detected
+ */
 export const check: FileCheckFunction = (contents) => {
-  expect(JSON.stringify(contents ?? 'null')).toMatchObject(
-    expect.objectContaining({
-      dependencies: expect.objectContaining({
-        'best-practices-typescript': expect.any(String),
-      }),
-    }),
+  if (isOldModuleDeclared(contents)) return;
+  throw new Error(
+    'does not match bad practice: no best-practices-typescript dependency',
   );
 };
+
+/**
+ * .what = drops the retired dependency from both dependency maps
+ * .why  = a detection with no fix marks the whole package.json manual, which blocks every other
+ *         package.json fix. the declapract practice declares the current package itself, so a
+ *         drop is all this repair owes.
+ */
+export const fix: FileFixFunction = (contents) => {
+  if (contents === null) return { contents };
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+  return {
+    contents: JSON.stringify(
+      {
+        ...packageJSON,
+        dependencies: asSectionWithoutOldModule({
+          section: packageJSON.dependencies,
+        }),
+        devDependencies: asSectionWithoutOldModule({
+          section: packageJSON.devDependencies,
+        }),
+      },
+      null,
+      2,
+    ),
+  };
+};

package/dist/practices/directory-structure-src/.declapract.integration.test.ts

@@ -0,0 +1,98 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+// executeApply is slow (full practice evaluation), so grant a generous limit
+jest.setTimeout(180_000);
+
+/**
+ * .what = end-to-end proof of the domain barrel move and the bare barrel import repoint (#655, #671).
+ * .why  = two barrels (`domain/index.ts` → `./objects`, and `domain/objects/index.ts`) both move onto
+ *   `domain.objects/index.ts`; the outer one, stripped, held no export and could win the path. and
+ *   a bare `'@src/domain'` / `'../domain'` import matched neither the check nor the fix. only the real
+ *   pipeline proves which file lands on the shared path.
+ * .note = the outer barrel is applied AFTER the inner one — the order in which it used to win.
+ */
+describe('directory-structure-src domain barrels and bare barrel imports', () => {
+  given('[case1] a repo with two domain barrels and bare barrel imports', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-dirs-two-barrels',
+      clone: './src/.test/assets/directory-structure-src/demo-repo-with-two-domain-barrels',
+      symlink: [
+        {
+          at: 'declarations',
+          to: './src/.test/assets/directory-structure-src/declarations',
+        },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const read = (relativePath: string) =>
+      fs.readFile(path.join(tempDir, relativePath), 'utf-8');
+    const isPresent = (relativePath: string) =>
+      fs
+        .access(path.join(tempDir, relativePath))
+        .then(() => true)
+        .catch(() => false);
+    const applyOne = (input: { file: string }) =>
+      executeApply({
+        config: path.join(tempDir, 'declapract.use.yml'),
+        practice: 'directory-structure-src',
+        file: input.file,
+      });
+
+    when('[t0] the input (before any fix)', () => {
+      then('the barrels and the importer match snapshot', async () => {
+        expect(await read('src/domain/index.ts')).toMatchSnapshot('outer barrel — before');
+        expect(await read('src/domain/objects/index.ts')).toMatchSnapshot('inner barrel — before');
+        expect(await read('src/domain.operations/getQuote.ts')).toMatchSnapshot('importer — before');
+      });
+    });
+
+    when('[t1] the moves and the import repoint are applied', () => {
+      const after = useThen('apply, outer barrel last', async () => {
+        await applyOne({ file: 'src/domain/objects/index.ts' });
+        await applyOne({ file: 'src/domain/objects/Quote.ts' });
+        await applyOne({ file: 'src/domain/index.ts' });
+        await applyOne({ file: 'src/domain.operations/getQuote.ts' });
+        return {
+          barrel: await read('src/domain.objects/index.ts'),
+          importer: await read('src/domain.operations/getQuote.ts'),
+          outerPresent: await isPresent('src/domain/index.ts'),
+          quotePresent: await isPresent('src/domain.objects/Quote.ts'),
+        };
+      });
+
+      then('domain.objects/index.ts holds the inner barrel list, never the stripped outer one (#655)', () => {
+        expect(after.barrel).toContain("export * from './Quote';");
+        expect(after.outerPresent).toBe(false);
+        expect(after.quotePresent).toBe(true);
+        expect(after.barrel).toMatchSnapshot('domain.objects/index.ts — after');
+      });
+
+      then('each bare barrel import is repointed, and a package subpath is left alone (#655, #671)', () => {
+        expect(after.importer).toContain("from '@src/domain.objects';");
+        expect(after.importer).toContain("from '../domain.objects';");
+        expect(after.importer).toContain("from 'some-pkg/domain';");
+        expect(after.importer).toMatchSnapshot('importer — after');
+      });
+    });
+
+    when('[t2] the importer and the barrel are applied a second time (idempotency)', () => {
+      const passes = useThen('a second apply over its own output', async () => {
+        const files = ['src/domain.objects/index.ts', 'src/domain.operations/getQuote.ts'];
+        const before = await Promise.all(files.map((file) => read(file)));
+        await applyOne({ file: files[0]! });
+        await applyOne({ file: files[1]! });
+        const after = await Promise.all(files.map((file) => read(file)));
+        return { before, after };
+      });
+
+      then('the second apply is a no-op', () => {
+        expect(passes.after).toEqual(passes.before);
+      });
+    });
+  });
+});

package/dist/practices/directory-structure-src/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,37 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t0] the input (before any fix) then: the barrels and the importer match snapshot: importer — before 1`] = `
+"import type { Quote } from '@src/domain';
+import type { Quote as QuoteRelative } from '../domain';
+import type { Widget } from 'some-pkg/domain';
+
+export const getQuote = (input: { quote: Quote; peer: QuoteRelative; widget: Widget }) =>
+  input.quote;
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t0] the input (before any fix) then: the barrels and the importer match snapshot: inner barrel — before 1`] = `
+"export * from './Quote';
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t0] the input (before any fix) then: the barrels and the importer match snapshot: outer barrel — before 1`] = `
+"// export * from './constants';
+export * from './objects';
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t1] the moves and the import repoint are applied then: domain.objects/index.ts holds the inner barrel list, never the stripped outer one (#655): domain.objects/index.ts — after 1`] = `
+"export * from './Quote';
+"
+`;
+
+exports[`directory-structure-src domain barrels and bare barrel imports given: [case1] a repo with two domain barrels and bare barrel imports when: [t1] the moves and the import repoint are applied then: each bare barrel import is repointed, and a package subpath is left alone (#655, #671): importer — after 1`] = `
+"import type { Quote } from '@src/domain.objects';
+import type { Quote as QuoteRelative } from '../domain.objects';
+import type { Widget } from 'some-pkg/domain';
+
+export const getQuote = (input: { quote: Quote; peer: QuoteRelative; widget: Widget }) =>
+  input.quote;
+"
+`;

package/dist/practices/directory-structure-src/bad-practices/domain-dir/src/<star><star>/domain/<star><star>/<star>.declapract.ts

@@ -1,14 +1,62 @@
 import { FileCheckType, type FileFixFunction } from 'declapract';
 
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
 // if files exist in any /domain/, this is a bad practice
 export const check = FileCheckType.EXISTS;
 
+/**
+ * .what = whether a file is an outer `domain/index.ts` barrel that only forwards `./objects`,
+ *         beside an inner `domain/objects/index.ts` barrel.
+ * .why  = both barrels move onto one path, `domain.objects/index.ts`. the outer one, once its
+ *         `./objects` forward is stripped, holds no export — and if it wins the path, every domain
+ *         export vanishes from the barrel with no error (#655). the inner barrel holds the real
+ *         list, so the outer one must yield the path to it.
+ */
+const isOuterBarrelBesideInner = (input: {
+  contents: string | null;
+  relativeFilePath: string;
+  projectRoot: string | null;
+}): boolean => {
+  if (!input.contents || !input.projectRoot) return false;
+  if (!/(?:^|\/)domain\/index\.ts$/.test(input.relativeFilePath)) return false;
+  const codeOnly = input.contents
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/^\s*\/\/.*$/gm, '')
+    .trim();
+  if (!/^export\s+\*\s+from\s+['"]\.\/objects['"];?$/.test(codeOnly))
+    return false;
+  // the inner barrel, before its move or after it (apply order is not guaranteed)
+  const domainDir = path.join(
+    input.projectRoot,
+    path.dirname(input.relativeFilePath),
+  );
+  return (
+    existsSync(path.join(domainDir, 'objects', 'index.ts')) ||
+    existsSync(path.join(path.dirname(domainDir), 'domain.objects', 'index.ts'))
+  );
+};
+
 export const fix: FileFixFunction = (contents, context) => {
+  // an outer barrel that only forwards ./objects yields the path to the inner barrel (#655)
+  if (
+    isOuterBarrelBesideInner({
+      contents,
+      relativeFilePath: context.relativeFilePath,
+      projectRoot: context.getProjectRootDirectory?.() ?? null,
+    })
+  )
+    return { contents: null };
+
   // move any /domain/objects/* to /domain.objects/*
   // move any /domain/* to /domain.objects/*
+  // .note = the lookahead leaves the slash after each segment unconsumed, so adjacent segments
+  //         (`/domain/domain/`) each move. a consumed slash left the second `domain` segment in
+  //         place, which the `src/**/domain/**/*` glob then matched again on the next apply.
   const newPath = context.relativeFilePath
-    .replace(/\/domain\/objects\//g, '/domain.objects/')
-    .replace(/\/domain\//g, '/domain.objects/');
+    .replace(/\/domain\/objects(?=\/)/g, '/domain.objects')
+    .replace(/\/domain(?=\/)/g, '/domain.objects');
 
   let fixedContents = contents;