chore: add toolkit-ts package (#60)

Author: valerybugakov

packages/toolkit-ts/README.md

@@ -0,0 +1,3 @@
+# Toolkit-ts
+
+Contains wrappers and utilities for `ts-morph` to manipulate Typescript AST on a higher level.

packages/toolkit-ts/jest.config.ts

@@ -0,0 +1,12 @@
+import type { InitialOptionsTsJest } from 'ts-jest'
+
+import baseConfig from '../../jest.config.base'
+
+const config: InitialOptionsTsJest = {
+    ...baseConfig,
+    displayName: 'codemod-toolkit-ts',
+    rootDir: __dirname,
+}
+
+// eslint-disable-next-line import/no-default-export
+export default config

packages/toolkit-ts/package.json

@@ -0,0 +1,21 @@
+{
+  "private": true,
+  "name": "@sourcegraph/codemod-toolkit-ts",
+  "version": "1.0.0",
+  "description": "@sourcegraph/codemod-toolkit-ts",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --build ./tsconfig.build.json",
+    "build:watch": "tsc  --build ./tsconfig.build.json --watch",
+    "build:clean": "tsc  --build --clean ./tsconfig.build.json && rimraf dist ./*.tsbuildinfo",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "format": "prettier --write \"./**/*.{ts,js,json,md}\" --ignore-path ../../.prettierignore",
+    "lint": "eslint './src/**/*.ts?(x)'"
+  },
+  "dependencies": {
+    "@sourcegraph/codemod-common": "1.0.0"
+  }
+}

packages/toolkit-ts/src/index.ts

@@ -0,0 +1 @@
+export * from './manipulation'

packages/toolkit-ts/src/manipulation/ImportDeclaration.ts

@@ -0,0 +1,61 @@
+import { ImportDeclaration, ImportDeclarationStructure, OptionalKind, SourceFile } from 'ts-morph'
+
+import { checkIfFileHasIdentifier } from './SourceFile'
+
+export function getImportDeclarationByModuleSpecifier(
+    sourceFile: SourceFile,
+    moduleSpecifier: string
+): ImportDeclaration | undefined {
+    return sourceFile.getImportDeclarations().find(importDeclaration => {
+        return importDeclaration.getModuleSpecifierValue() === moduleSpecifier
+    })
+}
+
+export interface AddImportIfIdentifierIsUsedOptions {
+    sourceFile: SourceFile
+    importStructure: Omit<OptionalKind<ImportDeclarationStructure>, 'namedImports'> & {
+        namedImports?: string[]
+    }
+}
+
+/**
+ * Adds missing declarations to the source file if literals from the provided import structure are used in the code.
+ * TODO: use type information instead of literal names to understand what needs to be changed.
+ */
+export function addOrUpdateImportIfIdentifierIsUsed(options: AddImportIfIdentifierIsUsedOptions): void {
+    const { sourceFile, importStructure } = options
+    const { namedImports, defaultImport, moduleSpecifier } = importStructure
+
+    const usedNamedImports = namedImports?.filter(namedImport => {
+        return checkIfFileHasIdentifier(sourceFile, namedImport)
+    })
+
+    const usedDefaultImport =
+        defaultImport && checkIfFileHasIdentifier(sourceFile, defaultImport) ? defaultImport : undefined
+
+    const importDeclaration = getImportDeclarationByModuleSpecifier(sourceFile, moduleSpecifier)
+
+    if (importDeclaration) {
+        if (usedNamedImports) {
+            for (const namedImport of usedNamedImports) {
+                const isAddedAlready = importDeclaration.getNamedImports().some(existingImport => {
+                    return existingImport.getName() === namedImport
+                })
+
+                if (!isAddedAlready) {
+                    importDeclaration.addNamedImport(namedImport)
+                }
+            }
+        }
+
+        if (usedDefaultImport && importDeclaration.getDefaultImport()?.getText() !== usedDefaultImport) {
+            importDeclaration.setDefaultImport(usedDefaultImport)
+        }
+    } else if ((usedNamedImports && usedNamedImports.length > 0) || usedDefaultImport) {
+        sourceFile.addImportDeclaration({
+            namedImports: usedNamedImports,
+            defaultImport: usedDefaultImport,
+            moduleSpecifier,
+        })
+    }
+}

packages/toolkit-ts/src/manipulation/Node.ts

@@ -0,0 +1,28 @@
+import { Node } from 'ts-morph'
+
+import { errors } from '@sourcegraph/codemod-common'
+
+export function getParentUntil<T extends Node>(
+    start: Node,
+    condition: (parent: Node, child: Node) => parent is T
+): T | undefined {
+    let node = start
+    let parent = start.getParent()
+
+    while (parent && !condition(parent, node)) {
+        node = parent
+        parent = node.getParent()
+    }
+
+    return parent
+}
+
+export function getParentUntilOrThrow<T extends Node>(
+    start: Node,
+    condition: (parent: Node, child: Node) => parent is T
+): T {
+    return errors.throwIfNullOrUndefined(
+        getParentUntil(start, condition),
+        'Expected to find a parent matching condition provided.'
+    )
+}

packages/toolkit-ts/src/manipulation/SourceFile.ts

@@ -0,0 +1,7 @@
+import { SourceFile, SyntaxKind } from 'ts-morph'
+
+export function checkIfFileHasIdentifier(sourceFile: SourceFile, identifierString: string): boolean {
+    return sourceFile.getDescendantsOfKind(SyntaxKind.Identifier).some(identifier => {
+        return identifier.getText() === identifierString
+    })
+}

packages/toolkit-ts/src/manipulation/__tests__/ImportDeclaration.test.ts

@@ -0,0 +1,80 @@
+import { SyntaxKind } from 'ts-morph'
+
+import { createSourceFile } from '@sourcegraph/codemod-common'
+
+import { addOrUpdateImportIfIdentifierIsUsed } from '../ImportDeclaration'
+
+const classNamesImportStructure = {
+    defaultImport: 'classNames',
+    moduleSpecifier: 'classnames',
+}
+
+describe('addOrUpdateImportIfIdentifierIsUsed', () => {
+    it('adds default import if needed', () => {
+        const { sourceFile } = createSourceFile('const className = classNames("d-flex", )')
+
+        addOrUpdateImportIfIdentifierIsUsed({ sourceFile, importStructure: classNamesImportStructure })
+        const importDeclaration = sourceFile.getFirstDescendantByKindOrThrow(SyntaxKind.ImportDeclaration)
+
+        expect(importDeclaration.getModuleSpecifier().getLiteralValue()).toBe(classNamesImportStructure.moduleSpecifier)
+        expect(importDeclaration.getDefaultImport()?.getText()).toBe(classNamesImportStructure.defaultImport)
+    })
+
+    it('adds named imports if needed', () => {
+        const { sourceFile } = createSourceFile('const markup = <Container><Button /><Container>')
+        const importStructure = {
+            namedImports: ['Button', 'Container', 'Input'],
+            moduleSpecifier: '@sourcegraph/wildcard',
+        }
+
+        addOrUpdateImportIfIdentifierIsUsed({ sourceFile, importStructure })
+        const importDeclaration = sourceFile.getFirstDescendantByKindOrThrow(SyntaxKind.ImportDeclaration)
+        const namedImports = importDeclaration.getNamedImports()
+
+        expect(importDeclaration.getModuleSpecifier().getLiteralValue()).toBe(importStructure.moduleSpecifier)
+        expect(namedImports.length).toBe(2)
+        expect(
+            namedImports.map(namedImport => {
+                return namedImport.getText()
+            })
+        ).toEqual(['Button', 'Container'])
+    })
+
+    it('updates existing import declaration if needed', () => {
+        const { sourceFile } = createSourceFile(`
+            import { Container } from '@sourcegraph/wildcard'
+
+            const markup = <Container><Button /><Container>
+        `)
+
+        const importStructure = {
+            namedImports: ['Button', 'Container', 'Input'],
+            moduleSpecifier: '@sourcegraph/wildcard',
+        }
+
+        addOrUpdateImportIfIdentifierIsUsed({ sourceFile, importStructure })
+        const importDeclaration = sourceFile.getFirstDescendantByKindOrThrow(SyntaxKind.ImportDeclaration)
+        const namedImports = importDeclaration.getNamedImports()
+
+        expect(importDeclaration.getModuleSpecifier().getLiteralValue()).toBe(importStructure.moduleSpecifier)
+        expect(namedImports.length).toBe(2)
+        expect(
+            namedImports.map(namedImport => {
+                return namedImport.getText()
+            })
+        ).toEqual(['Container', 'Button'])
+    })
+
+    it('does not add import if it already exists', () => {
+        const { sourceFile } = createSourceFile(`
+            import classNames from 'classnames'
+
+            const className = classNames("d-flex", )
+        `)
+
+        addOrUpdateImportIfIdentifierIsUsed({ sourceFile, importStructure: classNamesImportStructure })
+        const importDeclarations = sourceFile.getDescendantsOfKind(SyntaxKind.ImportDeclaration)
+
+        expect(importDeclarations.length).toBe(1)
+    })
+})

packages/toolkit-ts/src/manipulation/__tests__/Node.test.ts

@@ -0,0 +1,29 @@
+import { Node, SyntaxKind } from 'ts-morph'
+
+import { errors, createStringLiteral } from '@sourcegraph/codemod-common'
+
+import { getParentUntilOrThrow } from '../Node'
+
+describe('getParentUntilOrThrow', () => {
+    const node = createStringLiteral(`
+        export const Button = () => {
+            return (
+                <div>
+                    <button className="btn" />
+                </div>
+            )
+        }
+    `)
+
+    it('returns parent of kind if it exits', () => {
+        expect(getParentUntilOrThrow(node, Node.isArrowFunction).getKind()).toBe(SyntaxKind.ArrowFunction)
+        expect(getParentUntilOrThrow(node, Node.isJsxElement).getKind()).toBe(SyntaxKind.JsxElement)
+        expect(getParentUntilOrThrow(node, Node.isVariableDeclaration).getName()).toBe('Button')
+    })
+
+    it('throws if parent of kind does not exit', () => {
+        expect(() => {
+            return getParentUntilOrThrow(node, Node.isClassDeclaration)
+        }).toThrowError(errors.InvalidOperationError)
+    })
+})

packages/toolkit-ts/src/manipulation/__tests__/SourceFile.test.ts

@@ -0,0 +1,17 @@
+import { createSourceFile } from '@sourcegraph/codemod-common'
+
+import { checkIfFileHasIdentifier } from '../SourceFile'
+
+describe('checkIfFileHasIdentifier', () => {
+    it('returns `true` if source files has identifier', () => {
+        const { sourceFile } = createSourceFile('const x = 1')
+
+        expect(checkIfFileHasIdentifier(sourceFile, 'x')).toBe(true)
+    })
+
+    it('returns `false` if source files does not have identifier', () => {
+        const { sourceFile } = createSourceFile('const x = 1')
+
+        expect(checkIfFileHasIdentifier(sourceFile, 'y')).toBe(false)
+    })
+})