kea-typegen 3.4.7 → 3.6.0

package/src/__tests__/utils.ts

@@ -1,4 +1,9 @@
-import { sourceToSourceFile, programFromSource, logicSourceToLogicType } from '../utils'
+import { sourceToSourceFile, programFromSource, logicSourceToLogicType, gatherImports } from '../utils'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import * as ts from 'typescript'
+import { ParsedLogic } from '../types'
 import { SyntaxKind } from 'typescript'
 
 test('sourceToSourceFile', () => {
@@ -35,3 +40,75 @@ test('logicSourceToLogicType', () => {
 
     expect(string).toContain('export interface myRandomLogicType extends Logic {')
 })
+
+test('gatherImports prefers source package path for re-exported npm types', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-imports-'))
+    try {
+        const logicPath = path.join(tempDir, 'logic.ts')
+        const keaPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+        const reactGridLayoutIndexPath = path.join(tempDir, 'node_modules', 'react-grid-layout', 'index.d.ts')
+        const reactGridLayoutTypesPath = path.join(
+            tempDir,
+            'node_modules',
+            'react-grid-layout',
+            'dist',
+            'types-BiXsdXr7.d.ts',
+        )
+
+        fs.mkdirSync(path.dirname(keaPath), { recursive: true })
+        fs.mkdirSync(path.dirname(reactGridLayoutTypesPath), { recursive: true })
+
+        fs.writeFileSync(
+            logicPath,
+            [
+                "import { kea } from 'kea'",
+                "import type { Layout, LayoutItem } from 'react-grid-layout'",
+                '',
+                'export const dashboardLogic = kea({',
+                '    reducers: () => ({',
+                '        currentLayout: [null as Layout | null, {}],',
+                '        responsiveLayouts: [null as Record<string, LayoutItem[]> | null, {}],',
+                '    }),',
+                '})',
+            ].join('\n'),
+        )
+        fs.writeFileSync(keaPath, 'export function kea(input: any): any')
+        fs.writeFileSync(
+            reactGridLayoutIndexPath,
+            "export { L as Layout, a as LayoutItem } from './dist/types-BiXsdXr7'\n",
+        )
+        fs.writeFileSync(
+            reactGridLayoutTypesPath,
+            ['export type L = { i: string }', 'export type a = { x: number }'].join('\n'),
+        )
+
+        const program = ts.createProgram([logicPath], {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+        const sourceFile = program.getSourceFile(logicPath)
+        if (!sourceFile) {
+            throw new Error('Expected test source file to exist')
+        }
+
+        const parsedLogic = {
+            node: sourceFile,
+            typeReferencesToImportFromFiles: {},
+        } as unknown as ParsedLogic
+
+        gatherImports(sourceFile, program.getTypeChecker(), parsedLogic)
+
+        expect(parsedLogic.typeReferencesToImportFromFiles['react-grid-layout']).toEqual(
+            new Set(['Layout', 'LayoutItem']),
+        )
+        expect(
+            Object.keys(parsedLogic.typeReferencesToImportFromFiles).some((importPath) =>
+                importPath.includes('react-grid-layout/dist/types-BiXsdXr7'),
+            ),
+        ).toBe(false)
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})

package/src/cli/typegen.ts

@@ -8,30 +8,15 @@ import { AppOptions } from '../types'
 import { runTypeGen } from '../typegen'
 
 yargs
-    .command(
-        'check',
-        '- check what should be done',
-        (yargs) => {},
-        (argv) => {
-            runTypeGen({ ...includeKeaConfig(parsedToAppOptions(argv)), write: false, watch: false })
-        },
-    )
-    .command(
-        'write',
-        '- write logicType.ts files',
-        (yargs) => {},
-        (argv) => {
-            runTypeGen({ ...includeKeaConfig(parsedToAppOptions(argv)), write: true, watch: false })
-        },
-    )
-    .command(
-        'watch',
-        '- watch for changes and write logicType.ts files',
-        (yargs) => {},
-        (argv) => {
-            runTypeGen({ ...includeKeaConfig(parsedToAppOptions(argv)), write: true, watch: true })
-        },
-    )
+    .command('check', '- check what should be done', {}, async (argv) => {
+        await runTypeGen({ ...includeKeaConfig(parsedToAppOptions(argv)), write: false, watch: false })
+    })
+    .command('write', '- write logicType.ts files', {}, async (argv) => {
+        await runTypeGen({ ...includeKeaConfig(parsedToAppOptions(argv)), write: true, watch: false })
+    })
+    .command('watch', '- watch for changes and write logicType.ts files', {}, async (argv) => {
+        await runTypeGen({ ...includeKeaConfig(parsedToAppOptions(argv)), write: true, watch: true })
+    })
     .option('config', { alias: 'c', describe: 'Path to tsconfig.json (otherwise auto-detected)', type: 'string' })
     .option('file', { alias: 'f', describe: "Single file to evaluate (can't be used with --config)", type: 'string' })
     .option('root', {
@@ -69,7 +54,8 @@ yargs
     .option('verbose', { describe: 'Slightly more verbose output log', type: 'boolean' })
     .demandCommand()
     .help()
-    .wrap(80).argv
+    .wrap(80)
+    .parse()
 
 function parsedToAppOptions(parsedOptions) {
     const { root, types, config, file, ...rest } = parsedOptions
@@ -110,13 +96,13 @@ function includeKeaConfig(appOptions: AppOptions): AppOptions {
         const configDirPath = path.dirname(configFilePath)
         try {
             rawData = fs.readFileSync(configFilePath)
-        } catch (e) {
+        } catch {
             console.error(`Error reading Kea config file: ${configFilePath}`)
             process.exit(1)
         }
         try {
             keaConfig = JSON.parse(rawData)
-        } catch (e) {
+        } catch {
             console.error(`Error parsing Kea config JSON: ${configFilePath}`)
             process.exit(1)
         }

package/src/print/print.ts

@@ -40,11 +40,11 @@ import { printInternalExtraInput } from './printInternalExtraInput'
 import { convertToBuilders } from '../write/convertToBuilders'
 import { cacheWrittenFile } from '../cache'
 
-export function runThroughPrettier(sourceText: string, filePath: string): string {
-    const options = prettier.resolveConfig.sync(filePath)
+export async function runThroughPrettier(sourceText: string, filePath: string): Promise<string> {
+    const options = await prettier.resolveConfig(filePath)
     if (options) {
         try {
-            return prettier.format(sourceText, { ...options, filepath: filePath })
+            return await prettier.format(sourceText, { ...options, filepath: filePath })
         } catch (e) {
             console.error(`!! Prettier: Error formatting "${filePath}"`)
             console.error(e.message)
@@ -56,11 +56,11 @@ export function runThroughPrettier(sourceText: string, filePath: string): string
 }
 
 // returns files to write
-export function printToFiles(
+export async function printToFiles(
     program: Program,
     appOptions: AppOptions,
     parsedLogics: ParsedLogic[],
-): { filesToWrite: number; writtenFiles: number; filesToModify: number } {
+): Promise<{ filesToWrite: number; writtenFiles: number; filesToModify: number }> {
     const { log } = appOptions
 
     const groupedByFile: Record<string, ParsedLogic[]> = {}
@@ -101,13 +101,16 @@ export function printToFiles(
     let filesToWrite = 0
     let filesToModify = 0
 
-    Object.entries(groupedByFile).forEach(([fileName, parsedLogics]) => {
+    for (const [fileName, parsedLogics] of Object.entries(groupedByFile)) {
         const typeFileName = parsedLogics[0].typeFileName
 
         const logicStrings = []
         const requiredKeys = new Set(['Logic'])
         for (const parsedLogic of parsedLogics) {
-            const logicTypeStirng = runThroughPrettier(nodeToString(parsedLogic.interfaceDeclaration), typeFileName)
+            const logicTypeStirng = await runThroughPrettier(
+                nodeToString(parsedLogic.interfaceDeclaration),
+                typeFileName,
+            )
             logicStrings.push(logicTypeStirng)
             for (const string of parsedLogic.importFromKeaInLogicType.values()) {
                 requiredKeys.add(string)
@@ -232,7 +235,7 @@ export function printToFiles(
         const logicsNeedingImports = parsedLogics.filter(parsedLogicNeedsTypeImport)
         if (logicsNeedingImports.length > 0) {
             if (appOptions.write && !appOptions.noImport) {
-                writeTypeImports(appOptions, program, fileName, logicsNeedingImports, parsedLogics)
+                await writeTypeImports(appOptions, program, fileName, logicsNeedingImports, parsedLogics)
                 filesToModify += logicsNeedingImports.length
             } else {
                 log(
@@ -276,7 +279,7 @@ export function printToFiles(
                 )
             }
         }
-    })
+    }
 
     if (writtenFiles === 0 && filesToModify === 0) {
         if (appOptions.write) {

package/src/typegen.ts

@@ -16,7 +16,7 @@ if (parseInt(ts.versionMajorMinor.split('.')[0]) < 5) {
     ;(ts as any).defaultMaximumTruncationLength = Infinity
 }
 
-export function runTypeGen(appOptions: AppOptions) {
+export async function runTypeGen(appOptions: AppOptions) {
     let program: Program
     let resetProgram: () => void
 
@@ -49,7 +49,7 @@ export function runTypeGen(appOptions: AppOptions) {
                 compilerOptions.options,
                 {
                     ...ts.sys,
-                    writeFile(path: string, data: string, writeByteOrderMark?: boolean) {
+                    writeFile(_path: string, _data: string, _writeByteOrderMark?: boolean) {
                         // skip emit
                         // https://github.com/microsoft/TypeScript/issues/32385
                         // https://github.com/microsoft/TypeScript/issues/36917
@@ -89,11 +89,11 @@ export function runTypeGen(appOptions: AppOptions) {
             }
             const origPostProgramCreate = host.afterProgramCreate
 
-            host.afterProgramCreate = (prog) => {
+            host.afterProgramCreate = async (prog) => {
                 program = prog.getProgram()
                 origPostProgramCreate!(prog)
 
-                goThroughAllTheFiles(program, appOptions)
+                await goThroughAllTheFiles(program, appOptions)
             }
 
             ts.createWatchProgram(host)
@@ -108,16 +108,16 @@ export function runTypeGen(appOptions: AppOptions) {
         log(`⛔ No tsconfig.json found! No source file specified.`)
     }
 
-    function goThroughAllTheFiles(
+    async function goThroughAllTheFiles(
         program,
         appOptions,
-    ): { filesToWrite: number; writtenFiles: number; filesToModify: number } {
+    ): Promise<{ filesToWrite: number; writtenFiles: number; filesToModify: number }> {
         const parsedLogics = visitProgram(program, appOptions)
         if (appOptions.verbose) {
             log(`🗒️ ${parsedLogics.length} logic${parsedLogics.length === 1 ? '' : 's'} found!`)
         }
 
-        const response = printToFiles(program, appOptions, parsedLogics)
+        const response = await printToFiles(program, appOptions, parsedLogics)
 
         // running "kea-typegen check" and would write files?
         // exit with 1
@@ -136,7 +136,7 @@ export function runTypeGen(appOptions: AppOptions) {
 
             let round = 0
             while ((round += 1)) {
-                const { writtenFiles, filesToModify } = goThroughAllTheFiles(program, appOptions)
+                const { writtenFiles, filesToModify } = await goThroughAllTheFiles(program, appOptions)
 
                 if (writtenFiles === 0 && filesToModify === 0) {
                     log(`👋 Finished writing files! Exiting.`)

package/src/utils.ts

@@ -24,7 +24,7 @@ export function programFromSource(sourceCode: string) {
 }
 
 function rejectImportPath(path: string): boolean {
-    if (path.includes('/node_modules/typescript/')) {
+    if (path.includes('/node_modules/typescript/') || path === 'typescript' || path.startsWith('typescript/')) {
         return true
     }
     return false
@@ -274,13 +274,116 @@ export function storeExtractedSymbol(
     // Also checking isTypeNameAlreadyImported to prevent multiple imports of the same type,
     // which we were seeing when importing from `export * from ...` files
     if (typeName && !isTypeNameAlreadyImported(parsedLogic, typeName)) {
-        const importFilename = getFilenameForNode(declaration, checker)
+        const importFilenameFromNode = getFilenameForNode(declaration, checker)
+        const sourceFileImportedPackagePath =
+            importFilenameFromNode &&
+            findImportPathForPackageInSourceFile(
+                parsedLogic.node.getSourceFile(),
+                importFilenameFromNode,
+                typeName.split('.')[0],
+                checker,
+            )
+        const importFilename = sourceFileImportedPackagePath || importFilenameFromNode
         if (importFilename && !rejectImportPath(importFilename)) {
             addTypeImport(parsedLogic, importFilename, typeName)
         }
     }
 }
 
+function findImportPathForPackageInSourceFile(
+    sourceFile: ts.SourceFile,
+    importFilename: string,
+    typeName: string,
+    checker: ts.TypeChecker,
+): string | undefined {
+    const packageName = extractNpmPackageName(importFilename)
+    if (!packageName) {
+        return
+    }
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteralLike(statement.moduleSpecifier)) {
+            continue
+        }
+        const importPath = statement.moduleSpecifier.text
+        if (
+            extractNpmPackageName(importPath) === packageName &&
+            moduleSpecifierExportsTypeName(statement.moduleSpecifier, typeName, checker)
+        ) {
+            return importPath
+        }
+    }
+}
+
+function moduleSpecifierExportsTypeName(
+    moduleSpecifier: ts.Expression,
+    typeName: string,
+    checker: ts.TypeChecker,
+): boolean {
+    const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier)
+    if (!moduleSymbol) {
+        return false
+    }
+
+    return checker.getExportsOfModule(moduleSymbol).some((moduleExport) => moduleExport.getName() === typeName)
+}
+
+function extractNpmPackageName(input: string): string | undefined {
+    const packagePath = extractNodeModulesPackagePath(input)
+    if (packagePath) {
+        const normalizedPackagePath = packagePath.replace(/\\/g, '/')
+        if (normalizedPackagePath === 'typescript' || normalizedPackagePath.startsWith('typescript/')) {
+            return
+        }
+        if (normalizedPackagePath.startsWith('@types/')) {
+            return
+        }
+        if (normalizedPackagePath.startsWith('@')) {
+            const [scope, name] = normalizedPackagePath.split('/')
+            return scope && name ? `${scope}/${name}` : undefined
+        }
+        return normalizedPackagePath.split('/')[0]
+    }
+
+    if (input.startsWith('@types/')) {
+        return
+    }
+    if (input.startsWith('@')) {
+        const [scope, name] = input.split('/')
+        if (!scope || scope.length <= 1 || !name) {
+            return
+        }
+        return `${scope}/${name}`
+    }
+    if (!input.startsWith('.') && !input.startsWith('/') && !input.startsWith('~')) {
+        return input.split('/')[0]
+    }
+}
+
+function extractNodeModulesPackagePath(input: string): string | undefined {
+    const normalizedInput = input.replace(/\\/g, '/')
+    const nodeModulesMarker = '/node_modules/'
+    if (!normalizedInput.includes(nodeModulesMarker)) {
+        return
+    }
+
+    let packagePath = normalizedInput.split(nodeModulesMarker).pop()
+    if (!packagePath) {
+        return
+    }
+    if (packagePath.startsWith('.pnpm/')) {
+        const pnpmNodeModulesMarker = '/node_modules/'
+        if (!packagePath.includes(pnpmNodeModulesMarker)) {
+            return
+        }
+        packagePath = packagePath.split(pnpmNodeModulesMarker).pop()
+        if (!packagePath) {
+            return
+        }
+    }
+    return packagePath
+}
+
 export function getFilenameForImportDeclaration(checker: ts.TypeChecker, importNode: ts.ImportDeclaration): string {
     const moduleSymbol = checker.getSymbolAtLocation(importNode.moduleSpecifier)
     const otherSourceFile = moduleSymbol?.getDeclarations()[0].getSourceFile()

package/src/write/convertToBuilders.ts

@@ -4,7 +4,7 @@ import { print, visit } from 'recast'
 import { runThroughPrettier } from '../print/print'
 import * as fs from 'fs'
 import * as osPath from 'path'
-import { t, b, visitAllKeaCalls, assureImport, getAst } from "./utils";
+import { t, b, visitAllKeaCalls, assureImport, getAst } from './utils'
 
 const supportedProperties = {
     props: 'kea',
@@ -33,7 +33,7 @@ const supportedProperties = {
     events: 'kea',
 }
 
-export function convertToBuilders(
+export async function convertToBuilders(
     appOptions: AppOptions,
     program: ts.Program,
     filename: string,
@@ -120,7 +120,7 @@ export function convertToBuilders(
         }
     }
 
-    const newText = runThroughPrettier(print(ast).code, filename)
+    const newText = await runThroughPrettier(print(ast).code, filename)
     fs.writeFileSync(filename, newText)
 
     log(`🔥 Converted to builders: ${osPath.relative(process.cwd(), filename)}`)

package/src/write/writePaths.ts

@@ -4,9 +4,14 @@ import { print, visit } from 'recast'
 import { runThroughPrettier } from '../print/print'
 import * as fs from 'fs'
 import * as osPath from 'path'
-import { t, b, visitAllKeaCalls, assureImport, getAst } from "./utils";
+import { t, b, visitAllKeaCalls, assureImport, getAst } from './utils'
 
-export function writePaths(appOptions: AppOptions, program: ts.Program, filename: string, parsedLogics: ParsedLogic[]) {
+export async function writePaths(
+    appOptions: AppOptions,
+    program: ts.Program,
+    filename: string,
+    parsedLogics: ParsedLogic[],
+) {
     const { log } = appOptions
     const sourceFile = program.getSourceFile(filename)
     const rawCode = sourceFile.getText()
@@ -52,7 +57,7 @@ export function writePaths(appOptions: AppOptions, program: ts.Program, filename
     visitAllKeaCalls(ast, parsedLogics, filename, ({ path, parsedLogic }) => {
         const stmt = path.node
         const arg = stmt.arguments[0]
-        const logicPath = parsedLogic.path.filter(p => p !== '..')
+        const logicPath = parsedLogic.path.filter((p) => p !== '..')
 
         if (t.ObjectExpression.check(arg)) {
             const pathProperty = arg.properties.find(
@@ -80,7 +85,7 @@ export function writePaths(appOptions: AppOptions, program: ts.Program, filename
         }
     })
 
-    const newText = runThroughPrettier(print(ast).code, filename)
+    const newText = await runThroughPrettier(print(ast).code, filename)
     fs.writeFileSync(filename, newText)
 
     log(`🔥 Path added: ${osPath.relative(process.cwd(), filename)}`)

package/src/write/writeTypeImports.ts

@@ -6,7 +6,7 @@ import { runThroughPrettier } from '../print/print'
 import * as fs from 'fs'
 import { t, b, visitAllKeaCalls, getAst } from './utils'
 
-export function writeTypeImports(
+export async function writeTypeImports(
     appOptions: AppOptions,
     program: ts.Program,
     filename: string,
@@ -75,7 +75,7 @@ export function writeTypeImports(
         ])
     })
 
-    const newText = runThroughPrettier(print(ast).code, filename)
+    const newText = await runThroughPrettier(print(ast).code, filename)
     fs.writeFileSync(filename, newText)
 
     log(`🔥 Import added: ${osPath.relative(process.cwd(), filename)}`)