ts-codemod-lib 1.0.1 → 1.1.0

package/README.md

@@ -1,19 +1,434 @@
 # ts-codemod-lib
 
-<!--
 [![npm version](https://img.shields.io/npm/v/ts-codemod-lib.svg)](https://www.npmjs.com/package/ts-codemod-lib)
 [![npm downloads](https://img.shields.io/npm/dm/ts-codemod-lib.svg)](https://www.npmjs.com/package/ts-codemod-lib)
 [![License](https://img.shields.io/npm/l/ts-codemod-lib.svg)](./LICENSE)
-[![codecov](https://codecov.io/gh/noshiro-pf/ts-codemod-lib/branch/main/graph/badge.svg?token=********)](https://codecov.io/gh/noshiro-pf/ts-codemod-lib)
- -->
+[![codecov](https://codecov.io/gh/noshiro-pf/ts-codemod-lib/graph/badge.svg?token=BVx5UgsiVr)](https://codecov.io/gh/noshiro-pf/ts-codemod-lib)
 
-A TypeScript library for building codemods and AST transformations
+A TypeScript library for code transformations using AST (Abstract Syntax Tree) transformers, powered by the TypeScript Compiler API.
+
+## Overview
+
+`ts-codemod-lib` provides utilities and ready-to-use transformers for automated TypeScript code transformations. It enables you to programmatically modify TypeScript source code through AST manipulation, making it ideal for large-scale refactoring tasks, enforcing type safety, and promoting immutability.
+
+## Features
+
+- **AST-based Transformations**: Leverage TypeScript Compiler API for reliable type-aware code transformations
+- **Ready-to-use Transformers**: Append `as const`, convert to readonly types, replace `any` with `unknown`, and more
+- **Ready-to-use CLI Tools**: Convert interfaces to types, add readonly modifiers, and more
+- **Extensible API**: Build custom transformers using the provided utilities
+- **Type-safe**: Written in TypeScript with strict type checking
+- **Selective Transformation**: Support for ignoring specific lines or entire files via comments
+
+## Installation
+
+```bash
+# Using npm
+npm install -D ts-codemod-lib
+
+# Using pnpm
+pnpm add -D ts-codemod-lib
+
+# Using yarn
+yarn add -D ts-codemod-lib
+```
+
+## Available Transformers
+
+This library provides TypeScript AST transformers that can be used to automatically modify your TypeScript code. The transformers can be used individually or combined for more complex transformations.
+
+### 1. `appendAsConstTransformer`
+
+Appends `as const` to array literals and object literals to make them readonly constants. This transformer helps in creating immutable data structures by automatically adding the TypeScript `as const` assertion.
+
+Example:
+
+```ts
+// Before
+const arr = [1, 2, 3];
+
+const obj = { a: 1, b: 2 };
+
+// After
+const arr2 = [1, 2, 3] as const;
+
+const obj2 = { a: 1, b: 2 } as const;
+```
+
+### 2. `convertToReadonlyTypeTransformer`
+
+Converts TypeScript type definitions to readonly types. This transformer helps in creating more type-safe code by making types readonly where appropriate. It also normalizes nested readonly types (e.g., `Readonly<Readonly<T>>` becomes `Readonly<T>`).
+
+Options:
+
+- `ignorePrefixes`: Array of string prefixes for identifiers that should not be made readonly
+- `DeepReadonlyTypeName`: Custom name for the DeepReadonly type utility (defaults to "DeepReadonly")
+
+Example:
+
+```ts
+// Before
+type User = {
+    id: number;
+    description: string;
+    preferences: Map<string, string>;
+    friendIds: number[];
+    mut_items: string[]; // With ignorePrefixes: ['mut_']
+};
+
+// After
+type User2 = Readonly<{
+    id: number;
+    description: string;
+    preferences: ReadonlyMap<string, string>;
+    friendIds: readonly number[];
+    mut_items: string[]; // Not made readonly due to 'mut_' prefix
+}>;
+```
+
+For more detailed transformation examples, see the [test file](./src/functions/ast-transformers/convert-to-readonly-type.test.mts) which covers various scenarios including complex types, nested structures, and DeepReadonly transformations.
+
+### 3. `convertInterfaceToTypeTransformer`
+
+Converts TypeScript interface declarations to type aliases. This transformer helps in maintaining consistency by using type aliases throughout the codebase.
+
+Example:
+
+```ts
+// Before
+interface User {
+    id: number;
+    name: string;
+}
+
+// After
+type User2 = {
+    id: number;
+    name: string;
+};
+```
+
+### 4. `replaceAnyWithUnknownTransformer`
+
+Replaces `any` type annotations with `unknown` for improved type safety. The `unknown` type requires type checking before operations, making your code more robust. For function parameters with rest arguments, `(...args: any) => R` is converted to `(...args: readonly unknown[]) => R`.
+
+Example:
+
+```ts
+// Before
+const getValue = (data: any): any => data.value;
+
+const sortValues = (...args: any): any =>
+    args.toSorted((a: any, b: any) => a - b);
+
+// After
+const getValue2 = (data: unknown): unknown => (data as any).value;
+
+const sortValues2 = (...args: readonly unknown[]): unknown =>
+    (args as any).toSorted((a: any, b: any) => a - b);
+```
+
+For more detailed transformation examples, see the [test file](./src/functions/ast-transformers/replace-any-with-unknown.test.mts) which covers various scenarios including function parameters, return types, and variable declarations.
+
+### 5. `replaceRecordWithUnknownRecordTransformer`
+
+Replaces `Record<string, unknown>` and `Readonly<Record<string, unknown>>` with `UnknownRecord` for better type safety and consistency. This transformer also handles index signatures `[k: string]: unknown` in interfaces and type literals.
+
+Example:
+
+```ts
+// Before
+type Config = Record<string, unknown>;
+
+type ReadonlyConfig = Readonly<Record<string, unknown>>;
+
+type Data = Record<string, unknown>;
+
+// After
+type Config2 = UnknownRecord;
+
+type ReadonlyConfig2 = UnknownRecord;
+
+type Data2 = UnknownRecord;
+```
+
+### Disabling Transformers
+
+- Nodes on the line immediately following a `// transformer-ignore-next-line` comment will be skipped.
+- Files containing a `/* transformer-ignore */` comment will be skipped entirely.
+
+Examples:
+
+**Example using `// transformer-ignore-next-line`:**
+
+```ts
+// Before
+type Config = {
+    apiKey: string;
+    // transformer-ignore-next-line
+    mutableOptions: string[]; // This line will not be made Readonly
+    settings: { timeout: number };
+};
+
+// After applying convertToReadonlyTypeTransformer
+type Config2 = Readonly<{
+    apiKey: string;
+    mutableOptions: string[]; // Not made Readonly because it was skipped
+    settings: Readonly<{ timeout: number }>;
+}>;
+```
+
+**Example using `/* transformer-ignore */`:**
+
+```ts
+// Before
+type Data = { value: any };
+
+const items = [1, 2, 3];
+
+// After applying any transformer (e.g., replaceAnyWithUnknownTransformer, appendAsConstTransformer)
+// No changes will be made to this file.
+type Data2 = { value: any };
+
+const items2 = [1, 2, 3];
+```
+
+## CLI Tools
+
+This package provides command-line tools for common TypeScript transformations:
+
+### append-as-const
+
+Appends `as const` to array literals and object literals to make them readonly constants.
+
+```bash
+npx append-as-const <baseDir> [--exclude <pattern>] [--silent]
+```
+
+### convert-interface-to-type
+
+Converts TypeScript interface declarations to type aliases.
+
+```bash
+npx convert-interface-to-type <baseDir> [--exclude <pattern>] [--silent]
+```
+
+### convert-to-readonly
+
+Adds `readonly` modifiers to type definitions throughout your codebase.
+
+```bash
+npx convert-to-readonly <baseDir> [--exclude <pattern>] [--silent]
+```
+
+### replace-any-with-unknown
+
+Replaces `any` type annotations with `unknown` for improved type safety.
+
+```bash
+npx replace-any-with-unknown <baseDir> [--exclude <pattern>] [--silent]
+```
+
+### replace-record-with-unknown-record
+
+Replaces `Record<string, unknown>` with `UnknownRecord` for better type safety.
+
+```bash
+npx replace-record-with-unknown-record <baseDir> [--exclude <pattern>] [--silent]
+```
+
+**Common Options:**
+
+- `baseDir`: Base directory to scan for TypeScript files
+- `--exclude`: Glob patterns to exclude (e.g., `"src/generated/**/*.mts"`)
+- `--silent`: Suppress output messages
+
+## Programmatic Usage
+
+### Using Transformers with String Input/Output
+
+You can use the `astTransformerToStringTransformer` utility to apply these transformers to source code strings:
+
+```tsx
+import dedent from 'dedent';
+import {
+    appendAsConstTransformer,
+    convertInterfaceToTypeTransformer,
+    convertToReadonlyTypeTransformer,
+    replaceAnyWithUnknownTransformer,
+    replaceRecordWithUnknownRecordTransformer,
+    transformSourceCode,
+} from 'ts-codemod-lib';
+
+const originalCode = dedent`
+  export interface A {
+    name?: string;
+    point: [x: number, y: number, z?: number];
+    meta: {
+      description?: string;
+      tags: string[];
+      attributes: Record<string, unknown>;
+      data?: any;
+    };
+  }
+
+  export const obj = {
+    point: [1, 2],
+    meta: {
+      tags: ['example', 'test'],
+      attributes: {
+        key1: 'value1',
+        key2: 42,
+      },
+    },
+  } satisfies A;
+
+  export const arr = ['a', {}, 0];
+`;
+
+const isTsx = false;
+
+// Apply transformations to source code
+const transformedCode = transformSourceCode(originalCode, isTsx, [
+    convertInterfaceToTypeTransformer(),
+    replaceRecordWithUnknownRecordTransformer(),
+    convertToReadonlyTypeTransformer(),
+    appendAsConstTransformer(),
+    replaceAnyWithUnknownTransformer(),
+]);
+
+const expected = dedent`
+  export type A = Readonly< {
+    name?: string;
+    point: (readonly  [x: number, y: number, z?: number]);
+    meta: Readonly< {
+        description?: string;
+        tags: (readonly  string[]);
+        attributes: UnknownRecord;
+        data?: unknown;
+      }>;
+  }>;
+
+  export const obj = {
+    point: [1, 2],
+    meta: {
+      tags: ['example', 'test'],
+      attributes: {
+        key1: 'value1',
+        key2: 42,
+      },
+    },
+  } as const satisfies A;
+
+  export const arr = ['a', {}, 0] as const;
+`;
+
+if (import.meta.vitest !== undefined) {
+    test('transformSourceCode', () => {
+        assert.isTrue(transformedCode === expected);
+    });
+}
+```
+
+Note: It is recommended to apply all transformers at once using `transformSourceCode` rather than applying each transformer individually.
+This is more efficient as it avoids the overhead of parsing and printing before and after applying each AST transformation.
+
+### Apply Transformers to `src` Directory
+
+```sh
+npm install -D glob prettier
+```
+
+```tsx
+import * as fs from 'node:fs/promises';
+import {
+    appendAsConstTransformer,
+    convertInterfaceToTypeTransformer,
+    convertToReadonlyTypeTransformer,
+    replaceAnyWithUnknownTransformer,
+    replaceRecordWithUnknownRecordTransformer,
+    transformSourceCode,
+} from 'ts-codemod-lib';
+
+for await (const filePath of fs.glob('path/to/src/**/*.{mts,tsx}')) {
+    if (filePath.endsWith('.d.mts')) {
+        console.log(`Skipping declaration file: ${filePath}`);
+
+        continue;
+    }
+
+    console.log(`Processing file: ${filePath}`);
+
+    const originalCode = await fs.readFile(filePath, 'utf8');
+
+    const isTsx = filePath.endsWith('.tsx') || filePath.endsWith('.jsx');
+
+    // Apply transformations to source code
+    const transformedCode = transformSourceCode(originalCode, isTsx, [
+        convertInterfaceToTypeTransformer(),
+        replaceRecordWithUnknownRecordTransformer(),
+        convertToReadonlyTypeTransformer(),
+        appendAsConstTransformer(),
+        replaceAnyWithUnknownTransformer(),
+    ]);
+
+    await fs.writeFile(filePath, transformedCode, 'utf8');
+}
+```
+
+Run:
+
+```sh
+node codemod.mjs
+```
+
+## Notes
+
+- Types within JSDoc comments are not transformed.
+
+    ```ts
+    // Before
+    /**
+     * Processes user data.
+     * @param {object} user - The user object.
+     * @param {string[]} user.roles - User roles.
+     * @returns {object} Processed data.
+     */
+    function processUser(user: { name: string; roles: string[] }): {
+        success: boolean;
+    } {
+        // ... implementation ...
+        return { success: true };
+    }
+
+    // After applying convertToReadonlyTypeTransformer
+    /**
+     * Processes user data.
+     * @param {object} user - The user object. // JSDoc type is not changed
+     * @param {string[]} user.roles - User roles. // JSDoc type is not changed
+     * @returns {object} Processed data. // JSDoc type is not changed
+     */
+    function processUser(
+        user: Readonly<{ name: string; roles: readonly string[] }>,
+    ): Readonly<{ success: boolean }> {
+        // ... implementation ...
+        return { success: true };
+    }
+    ```
+
+- Comment positions might change due to the heuristics used for restoring comments in the code.
+    - When parsing source code into an AST using the TypeScript Compiler API, comments are often attached to the preceding or succeeding node. However, sometimes comments become detached (orphaned). These detached comments might be omitted when the source code string is generated by TypeScript's printer (though some might be restored). `ts-codemod-lib` includes preprocessing to identify all detached comments that the printer cannot restore and reattaches them to the immediately preceding or succeeding node, making them printable. However, the determination of whether to attach the comment before or after the node is heuristic, so the comment might move to a different position than in the original code.
+    - Possible workarounds include experimenting to find comment positions less likely to become orphaned (comments clearly preceding a node are less likely to be orphaned) or excluding the relevant section from transformation using the `// transformer-ignore-next-line` comment.
+    - I intend to resolve practical issues as much as possible, so please submit an issue if you find any problems.
+    - Related link: <https://github.com/microsoft/TypeScript/issues/20506#issuecomment-349740820>
 
 ## Documentation
 
 - API reference: <https://noshiro-pf.github.io/ts-codemod-lib/>
 
-## Local Setup
+## For Developers
+
+### Local Setup
 
 ```sh
 git clone https://github.com/noshiro-pf/ts-codemod-lib.git
@@ -21,7 +436,7 @@ git submodule update --init --recursive
 pnpm i
 ```
 
-## Syncing AGENTS.md Updates
+### Syncing AGENTS.md Updates
 
 1. Update `AGENTS.md` in the common repository (`common-agent-config`)
 2. Update the submodule in each project
@@ -31,3 +446,10 @@ git submodule update --remote --merge
 git add agents/common
 git commit -m "Update AGENTS.md"
 ```
+
+### Resources
+
+- <https://ts-ast-viewer.com/#>
+- <https://github.com/itsdouges/typescript-transformer-handbook>
+- <https://github.com/microsoft/TypeScript/wiki/Using-the-Compiler-API>
+- <https://blog.nnn.dev/entry/2022/03/10/110000>

package/dist/cmd/append-as-const.d.mts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import 'ts-repo-utils';
+//# sourceMappingURL=append-as-const.d.mts.map

package/dist/cmd/append-as-const.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-as-const.d.mts","sourceRoot":"","sources":["../../src/cmd/append-as-const.mts"],"names":[],"mappings":";AAMA,OAAO,eAAe,CAAC"}

package/dist/cmd/append-as-const.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import * as cmd from 'cmd-ts';
+import dedent from 'dedent';
+import { castMutable, Result, unknownToString } from 'ts-data-forge';
+import 'ts-repo-utils';
+import { appendAsConstTransformer } from '../functions/ast-transformers/append-as-const.mjs';
+import 'ts-morph';
+import '../functions/functions/is-primitive-type-node.mjs';
+import '../functions/ast-transformers/readonly-transformer-helpers/constants.mjs';
+import { transformSourceCode } from '../functions/ast-transformers/transform-source-code.mjs';
+
+/* eslint-disable no-await-in-loop */
+const cmdDef = cmd.command({
+    name: 'append-as-const-cli',
+    version: '1.0.0',
+    args: {
+        baseDir: cmd.positional({
+            type: cmd.string,
+            displayName: 'baseDir',
+            description: 'The base directory in which to perform the conversion',
+        }),
+        exclude: cmd.multioption({
+            long: 'exclude',
+            type: cmd.optional(cmd.array(cmd.string)),
+            description: 'Glob patterns of files to exclude from the base directory (e.g., "src/generated/**/*.mts")',
+        }),
+        silent: cmd.flag({
+            long: 'silent',
+            type: cmd.optional(cmd.boolean),
+            description: 'If true, suppresses output messages (default: false)',
+        }),
+    },
+    handler: (args) => {
+        appendAsConstCLI({
+            baseDir: args.baseDir,
+            exclude: args.exclude ?? [],
+            silent: args.silent ?? false,
+        }).catch((error) => {
+            console.error('An error occurred:', error);
+            process.exit(1);
+        });
+    },
+});
+const appendAsConstCLI = async (args) => {
+    const echoIfNotSilent = args.silent ? () => { } : echo;
+    const errorIfNotSilent = args.silent ? () => { } : console.error;
+    // Find all files matching the glob
+    const globResult = await glob(args.baseDir, {
+        ignore: castMutable(args.exclude),
+    });
+    if (Result.isErr(globResult)) {
+        errorIfNotSilent('Error finding files matching pattern:', globResult.value);
+        return Result.err(undefined);
+    }
+    const files = globResult.value;
+    if (files.length === 0) {
+        echoIfNotSilent('No files found matching pattern:', args.baseDir);
+        return Result.ok(undefined);
+    }
+    const { errorFiles, transformedCount, unchangedCount } = await transformFiles(files, args.silent);
+    const hr = '='.repeat(50);
+    echoIfNotSilent(dedent `
+    ${hr}
+    Summary:
+      ✅ Transformed: ${transformedCount}
+      ⏭️ Unchanged:   ${unchangedCount}
+      ❌ Errors:      ${errorFiles.length}
+      📊 Total:       ${files.length}
+  `);
+    if (errorFiles.length > 0) {
+        echoIfNotSilent('\nFiles with errors:');
+        for (const fileName of errorFiles) {
+            echoIfNotSilent(`  - ${fileName}`);
+        }
+    }
+    echoIfNotSilent(hr);
+    if (errorFiles.length > 0) {
+        return Result.err(undefined);
+    }
+    return Result.ok(undefined);
+};
+const transformFiles = async (filePaths, silent) => {
+    let mut_transformedCount = 0;
+    let mut_unchangedCount = 0;
+    const mut_errorFiles = [];
+    for (const filePath of filePaths) {
+        const result = await transformOneFile(filePath, silent);
+        if (Result.isOk(result)) {
+            switch (result.value) {
+                case 'transformed':
+                    mut_transformedCount += 1;
+                    break;
+                case 'unchanged':
+                    mut_unchangedCount += 1;
+                    break;
+            }
+        }
+        else {
+            mut_errorFiles.push(path.basename(filePath));
+        }
+    }
+    return {
+        transformedCount: mut_transformedCount,
+        unchangedCount: mut_unchangedCount,
+        errorFiles: mut_errorFiles,
+    };
+};
+const transformOneFile = async (filePath, silent) => {
+    const echoIfNotSilent = silent ? () => { } : echo;
+    const errorIfNotSilent = silent ? () => { } : console.error;
+    const fileName = path.basename(filePath);
+    const isTsx = fileName.endsWith('.tsx') || fileName.endsWith('.jsx');
+    try {
+        const originalCode = await fs.readFile(filePath, 'utf8');
+        // Transform the code with all transformers
+        const transformedCode = transformSourceCode(originalCode, isTsx, [
+            appendAsConstTransformer(),
+        ]);
+        // Check if the code was actually changed
+        if (transformedCode === originalCode) {
+            echoIfNotSilent(`⏭️ ${fileName} - no changes needed`);
+            return Result.ok('unchanged');
+        }
+        else {
+            // Write back the transformed code
+            await fs.writeFile(filePath, transformedCode, 'utf8');
+            echoIfNotSilent(`✅ ${fileName} - transformed`);
+            return Result.ok('transformed');
+        }
+    }
+    catch (error) {
+        const errStr = unknownToString(error);
+        errorIfNotSilent(`❌ ${fileName} - error: ${errStr}`);
+        return Result.err(errStr);
+    }
+};
+await cmd.run(cmdDef, process.argv.slice(2));
+//# sourceMappingURL=append-as-const.mjs.map

package/dist/cmd/append-as-const.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"append-as-const.mjs","sources":["../../src/cmd/append-as-const.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/cmd/convert-interface-to-type.d.mts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import 'ts-repo-utils';
+//# sourceMappingURL=convert-interface-to-type.d.mts.map

package/dist/cmd/convert-interface-to-type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-interface-to-type.d.mts","sourceRoot":"","sources":["../../src/cmd/convert-interface-to-type.mts"],"names":[],"mappings":";AAMA,OAAO,eAAe,CAAC"}