npm - declapract-typescript-ehmpathy - Versions diffs - 0.49.9 → 0.49.11 - Mend

@@ -0,0 +1,23 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+export const check: FileCheckFunction = (contents) => {
+  const packageJSONObject = JSON.parse(contents!);
+  if (
+    Object.keys(packageJSONObject.dependencies).includes('simple-type-guards')
+  )
+    return; // matches
+  throw new Error('does not match bad practice');
+};
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {}; // should not occur
+  const packageJSONObject = JSON.parse(contents);
+  const fixedPackageJSONObject = {
+    ...packageJSONObject,
+    dependencies: {
+      ...packageJSONObject.dependencies,
+      'simple-type-guards': undefined,
+    },
+  };
+  return { contents: JSON.stringify(fixedPackageJSONObject, null, 2) };
+};

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "domain-objects": "@declapract{check.minVersion('0.31.13')}",
+    "type-fns": "@declapract{check.minVersion('1.21.3')}"
+  }
+}

@@ -0,0 +1,4 @@
+import { FileCheckType } from 'declapract';
+// project should have domain objects... otherwise, what is the purpose of this thing? (how can we have a service that does not operate on a domain?)
+export const check = FileCheckType.EXISTS;

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "@ehmpathy/error-fns": "@declapract{check.minVersion('0.0.0')}"
+  }
+}

@@ -0,0 +1,23 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { FileCheckType, type FileFixFunction } from 'declapract';
+export const check = FileCheckType.CONTAINS;
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents }; // do nothing if no contents
+  const packageJSON = JSON.parse(contents);
+  const updatedPackageJSON = {
+    ...packageJSON,
+    dependencies: {
+      ...packageJSON.dependencies,
+      '@ehmpathy/error-fns': undefined,
+    },
+    devDependencies: {
+      ...packageJSON.devDependencies,
+      '@ehmpathy/error-fns': undefined,
+    },
+  };
+  return {
+    contents: JSON.stringify(updatedPackageJSON, null, 2),
+  };
+};

	@@ -0,0 +1 @@
1	+ `simple-type-guards` has been deprecated in favor of `type-fns`

@@ -0,0 +1,17 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+export const check: FileCheckFunction = (contents) => {
+  if (contents?.includes("from '@ehmpathy/error-fns'")) return; // matches if it includes this
+  throw new Error('does not match bad practice'); // does not otherwise
+};
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return {}; // do nothing if no contents
+  return {
+    contents: contents.replace(
+      /from '@ehmpathy\/error-fns'/g,
+      "from 'helpful-errors'",
+    ),
+  };
+};

@@ -0,0 +1,85 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import { UnexpectedCodePathError } from 'helpful-errors';
+/**
+ * known error classes exported by helpful-errors
+ *
+ * only these classes should be rewritten — custom error classes
+ * (e.g., UserInputError, HumanGuidanceError) must be left alone
+ */
+const KNOWN_CLASSES = [
+  'UnexpectedCodePathError',
+  'BadRequestError',
+  'HelpfulError',
+  'MalfunctionError',
+  'ConstraintError',
+];
+/**
+ * pattern source for local imports that end with a known error class name
+ *
+ * anchored to line start via ^ with multiline flag (m)
+ * supports both `import { X }` and `import type { X }`
+ *
+ * examples that match:
+ *   import { UnexpectedCodePathError } from '../../utils/errors/UnexpectedCodePathError'
+ *   import type { BadRequestError } from '@src/domain.operations/BadRequestError'
+ *
+ * examples that do NOT match:
+ *   from 'helpful-errors' (already correct)
+ *   from '../../utils/errors/UserInputError' (custom class)
+ *   const msg = "import { X } from 'local/UnexpectedCodePathError'" (mid-line)
+ *   // import { X } from '../../errors/UnexpectedCodePathError' (comment)
+ */
+const IMPORT_PREFIX = `(^\\s*import\\s+(?:type\\s+)?\\{[^}]+\\}\\s+)`;
+const FROM_LOCAL_ERROR = `from ['"][^'"]*\\/(${KNOWN_CLASSES.join('|')})['"]`;
+const LOCAL_ERROR_IMPORT_PATTERN_SOURCE = `${IMPORT_PREFIX}${FROM_LOCAL_ERROR}`;
+/**
+ * regex for test: match once, multiline mode
+ */
+const LOCAL_ERROR_IMPORT_PATTERN = new RegExp(
+  LOCAL_ERROR_IMPORT_PATTERN_SOURCE,
+  'm',
+);
+/**
+ * regex for replace: match all occurrences, multiline mode
+ */
+const LOCAL_ERROR_IMPORT_PATTERN_GLOBAL = new RegExp(
+  LOCAL_ERROR_IMPORT_PATTERN_SOURCE,
+  'gm',
+);
+/**
+ * .what = detect local error imports that should use helpful-errors
+ * .why = flag files for fix by declapract
+ */
+export const check: FileCheckFunction = (contents) => {
+  // matches bad practice if local error import found
+  if (contents && LOCAL_ERROR_IMPORT_PATTERN.test(contents)) return;
+  // no local error imports found — file does not need migration
+  UnexpectedCodePathError.throw(
+    'no local error imports found; file uses helpful-errors or custom errors',
+    { hint: 'this file does not need migration to helpful-errors' },
+  );
+};
+/**
+ * .what = replace local error imports with helpful-errors
+ * .why = consolidate error class sources for easier maintenance
+ */
+export const fix: FileFixFunction = (contents) => {
+  // skip if empty
+  if (!contents) return {};
+  // replace all local error imports, preserve import prefix via $1
+  return {
+    contents: contents.replace(
+      LOCAL_ERROR_IMPORT_PATTERN_GLOBAL,
+      "$1from 'helpful-errors'",
+    ),
+  };
+};

@@ -0,0 +1,26 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+export const check: FileCheckFunction = (contents) => {
+  if (!contents) throw new Error('fine, does not match bad practice'); // if not defined, doesn't have the script
+  const parsedContents = JSON.parse(contents);
+  if (typeof parsedContents.scripts.format === 'string') return; // matches bad practice file
+  throw new Error('fine, does not have format script');
+};
+export const fix: FileFixFunction = (contents) => {
+  // parse the contents
+  if (!contents) return {}; // do nothing if no contents, shouldn't have reached here to begin with
+  const parsedContents = JSON.parse(contents);
+  // remove "format"
+  const fixedContents = {
+    ...parsedContents,
+    scripts: {
+      ...parsedContents.scripts,
+      format: undefined, // remove format
+    },
+  };
+  // and return the fixed json
+  return { contents: JSON.stringify(fixedContents, null, 2) };
+};

@@ -0,0 +1,6 @@
+Prettier is no longer used - biome or other tools are preferred. This bad practice removes:
+- prettier.config.js
+- .prettierignore
+- prettier and @trivago/prettier-plugin-sort-imports devDependencies
+- fix:format:prettier and test:format:prettier scripts

@@ -0,0 +1,3 @@
+*.md
+.yalc/
+dist/

@@ -0,0 +1,8 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+export const check = FileCheckType.EXISTS;
+export const fix: FileFixFunction = () => {
+  // Remove the file by returning null contents
+  return { contents: null };
+};

@@ -0,0 +1,10 @@
+{
+  "devDependencies": {
+    "prettier": "@declapract{check.minVersion('2.8.1')}",
+    "@trivago/prettier-plugin-sort-imports": "@declapract{check.minVersion('4.3.0')}"
+  },
+  "scripts": {
+    "fix:format:prettier": "prettier --write '**/*.ts' --config ./prettier.config.js",
+    "test:format:prettier": "prettier --parser typescript --check 'src/**/*.ts' --config ./prettier.config.js"
+  }
+}

@@ -0,0 +1,35 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+export const check = FileCheckType.CONTAINS;
+const depsToRemove = ['prettier', '@trivago/prettier-plugin-sort-imports'];
+const scriptsToRemove = ['fix:format:prettier', 'test:format:prettier'];
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+  const packageJSON = JSON.parse(contents);
+  // Remove prettier devDependencies
+  const updatedDevDeps = { ...packageJSON.devDependencies };
+  for (const dep of depsToRemove) {
+    delete updatedDevDeps[dep];
+  }
+  // Remove prettier scripts
+  const updatedScripts = { ...packageJSON.scripts };
+  for (const script of scriptsToRemove) {
+    delete updatedScripts[script];
+  }
+  const fixedPackageJSON = {
+    ...packageJSON,
+    devDependencies:
+      Object.keys(updatedDevDeps).length > 0 ? updatedDevDeps : undefined,
+    scripts:
+      Object.keys(updatedScripts).length > 0 ? updatedScripts : undefined,
+  };
+  return { contents: JSON.stringify(fixedPackageJSON, null, 2) };
+};

@@ -0,0 +1,10 @@
+// ref: http://json.schemastore.org/prettierrc
+module.exports = {
+  trailingComma: 'all',
+  tabWidth: 2,
+  singleQuote: true,
+  plugins: ['@trivago/prettier-plugin-sort-imports'],
+  importOrder: ['^[./]'],
+  importOrderSeparation: true,
+};

@@ -0,0 +1,32 @@
+import { FileCheckType, type FileContentsFunction } from 'declapract';
+import { isPresent } from 'type-fns';
+/**
+ * declare the expected contents
+ */
+export const contents: FileContentsFunction = (context) => {
+  const formatters = [
+    'biome',
+    context.projectPractices.includes('terraform') ? 'terraform' : null, // only include the terraform formatter if terraform practice is used
+  ].filter(isPresent);
+  return JSON.stringify(
+    {
+      scripts: {
+        'fix:format': formatters
+          .map((formatter) => `npm run fix:format:${formatter}`)
+          .join(' && '),
+        'test:format': formatters
+          .map((formatter) => `npm run test:format:${formatter}`)
+          .join(' && '),
+      },
+    },
+    null,
+    2,
+  );
+};
+/**
+ * check that they're contained in the file
+ */
+export const check: FileCheckType = FileCheckType.CONTAINS;

declapract-typescript-ehmpathy 0.49.9 → 0.49.11