chore: add common package (#59)

Author: valerybugakov

.eslintrc.js

@@ -11,8 +11,7 @@ module.exports = {
       jsx: true,
     },
     EXPERIMENTAL_useSourceOfProjectReferenceRedirect: true,
-    project: ['./tsconfig.eslint.json', './tsconfig.json', './packages/*/tsconfig.json'],
-    allowAutomaticSingleRunInference: true,
+    project: ['./tsconfig.eslint.json', './packages/*/tsconfig.json'],
     tsconfigRootDir: __dirname,
     warnOnUnsupportedTypeScriptVersion: false,
   },

packages/codemod/src/transforms/globalCssToCssModule/ts/splitClassName.ts

@@ -1,9 +1,13 @@
 interface SplitClassNameOptions {
+    // ClassName value string which might contain replaceable parts.
     className: string
+    // Mapping between classes and exportNames.
     exportNameMap: Record<string, string>
+    // Object to collect replaced classes usage in React component.
     usageStats: Record<string, boolean>
 }
 
+// Object that contains array of exportNames found in the className and the left over value.
 interface SplitClassNameResult {
     exportNames: string[]
     leftOverClassnames: string[]
@@ -12,11 +16,6 @@ interface SplitClassNameResult {
 /**
  * Example: splitClassName({ className: 'kek--wow d-flex mr-1', exportNameMap: { 'kek--wow': 'kekWow' }, usageStats: {})
  * returns: { exportNames: ['kekWow'], leftOverClassnames: ['d-flex', 'mr-1'] }
- *
- * @param className ClassName value string which might contain replaceable parts.
- * @param exportNameMap Mapping between classes and exportNames.
- * @param usageStats Object to collect replaced classes usage in React component.
- * @returns Object that contains array of exportNames found in the className and the left over value.
  */
 export function splitClassName(options: SplitClassNameOptions): SplitClassNameResult {
     const { className, exportNameMap, usageStats } = options

packages/common/README.md

@@ -0,0 +1,3 @@
+# Common
+
+Contains generic utilities reused between multiple packages of the codemod monorepo.

packages/common/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-common',
+    rootDir: __dirname,
+}
+
+// eslint-disable-next-line import/no-default-export
+export default config

packages/common/package.json

@@ -0,0 +1,18 @@
+{
+  "private": true,
+  "name": "@sourcegraph/codemod-common",
+  "version": "1.0.0",
+  "description": "@sourcegraph/codemod-common",
+  "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)'"
+  }
+}

packages/common/src/ManualChangeList.ts

@@ -0,0 +1,59 @@
+import signale from 'signale'
+import { Node } from 'ts-morph'
+
+import { ManualChangeError } from './errors'
+
+export interface ManualChangeLog {
+    node: Node
+    message: string
+}
+
+export type ManualChangesReported = Record<string, ManualChangeLog>
+
+export interface ManualChangeList {
+    manualChangesReported: ManualChangesReported
+    throwManualChangeError(manualChangeLog: ManualChangeLog): void
+    addManualChangeLog(manualChangeLog: ManualChangeLog): void
+}
+
+// Used to avoid the duplicate reports on the same AST node.
+function getManualLogId(manualChangeLog: ManualChangeLog): string {
+    const { node, message } = manualChangeLog
+
+    return [
+        node.getSourceFile().getFilePath(),
+        node.getPos(),
+        node.getStartLinePos(),
+        node.getEndLineNumber(),
+        message,
+    ].join(',')
+}
+
+export function throwManualChangeError({ node, message }: ManualChangeLog): void {
+    throw new ManualChangeError(node, message)
+}
+
+export function logRequiredManualChanges(manualChangesReported: ManualChangesReported): void {
+    for (const { message } of Object.values(manualChangesReported)) {
+        signale.log(message)
+    }
+}
+
+export function createManualChangeList(this: void): ManualChangeList {
+    const manualChangesReported: ManualChangesReported = {}
+
+    function addManualChangeLog(manualChangeLog: ManualChangeLog): void {
+        const { node, message } = manualChangeLog
+        const { line, column } = node.getSourceFile().getLineAndColumnAtPos(node.getPos())
+        const filePath = node.getSourceFile().getFilePath()
+
+        manualChangesReported[getManualLogId(manualChangeLog)] = {
+            node,
+            message: ['', `${filePath}:${line}:${column} - warning: ${message}`, `>>>    ${node.getFullText()}`].join(
+                '\n'
+            ),
+        }
+    }
+
+    return { manualChangesReported, throwManualChangeError, addManualChangeLog }
+}

packages/common/src/__tests__/ManualChangeLog.test.ts

@@ -0,0 +1,28 @@
+import { createManualChangeList } from '../ManualChangeList'
+import { createSourceFile } from '../testing'
+
+describe('createManualChangeList', () => {
+    it('collects manual change logs', () => {
+        const manualChangeList = createManualChangeList()
+
+        const { sourceFile } = createSourceFile('const x = 1')
+        const manualChangeLog = {
+            node: sourceFile.getFirstChildOrThrow(),
+            message: 'Hello there!',
+        }
+
+        expect(manualChangeList.manualChangesReported).toEqual({})
+
+        manualChangeList.addManualChangeLog(manualChangeLog)
+        manualChangeList.addManualChangeLog(manualChangeLog)
+
+        const changelogEntries = Object.entries(manualChangeList.manualChangesReported)
+        expect(changelogEntries.length).toBe(1)
+
+        const [id, { node, message }] = changelogEntries[0]
+
+        expect(node).toBe(manualChangeLog.node)
+        expect(message).toBe(['', '/test.tsx:1:1 - warning: Hello there!', '>>>    const x = 1'].join('\n'))
+        expect(id).toBe('/test.tsx,0,0,1,Hello there!')
+    })
+})

packages/common/src/__tests__/errors.test.ts

@@ -0,0 +1,29 @@
+import { throwFromMethodsIfUndefinedReturn } from '../errors'
+
+describe('throwFromMethodsIfUndefinedReturn', () => {
+    it('throws from object method if undefined is returned', () => {
+        const object = {
+            void() {
+                // nothing here
+            },
+        }
+
+        expect(() => {
+            throwFromMethodsIfUndefinedReturn(object).void()
+        }).toThrow()
+    })
+
+    it('preserves type signature of methods', () => {
+        const object = {
+            void(count: number, name: string) {
+                if (count && name) {
+                    // nothing here
+                }
+            },
+        }
+
+        expect(() => {
+            throwFromMethodsIfUndefinedReturn(object).void(0, 'name')
+        }).toThrow()
+    })
+})

packages/common/src/errors.ts

@@ -0,0 +1,35 @@
+import { errors } from '@ts-morph/common'
+import { Node } from 'ts-morph'
+
+import { AnyFunction, NonVoidFunction } from './types'
+
+export { errors }
+
+export class ManualChangeError extends Error {
+    constructor(public node: Node, public message: string) {
+        super(message)
+    }
+}
+
+type NonVoidRecordMethods<T extends Record<string, AnyFunction>> = {
+    [key in keyof T]: NonVoidFunction<T[key]>
+}
+
+/**
+ * Wraps each object's method into `errors.throwIfNullOrUndefined()` and updates type signature accordingly.
+ */
+export function throwFromMethodsIfUndefinedReturn<T extends Record<string, AnyFunction>>(
+    record: T
+): NonVoidRecordMethods<T> {
+    const entriesWithWrappedValueCall = Object.entries(record).map(([key, value]) => {
+        return [
+            key,
+            (...args: unknown[]) => {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return errors.throwIfNullOrUndefined(value(...args), 'unexpected void return')
+            },
+        ]
+    })
+
+    return Object.fromEntries(entriesWithWrappedValueCall) as NonVoidRecordMethods<T>
+}

packages/common/src/index.ts

@@ -0,0 +1,5 @@
+export * from './utils'
+export * from './errors'
+export * from './types'
+export * from './ManualChangeList'
+export * from './testing'