kea-typegen 3.6.5 → 3.6.8

package/src/test-support/write-mode-smoke.js

@@ -0,0 +1,147 @@
+const fs = require('fs')
+const Module = require('module')
+const path = require('path')
+
+require('ts-node/register/transpile-only')
+
+const repoRoot = path.resolve(__dirname, '..', '..')
+const projectDir = fs.mkdtempSync(path.join(repoRoot, 'tmp-write-smoke-'))
+const tsconfigPath = path.join(projectDir, 'tsconfig.json')
+const logicFilePath = path.join(projectDir, 'src', 'logic.ts')
+
+const noop = () => {}
+
+let createProgramCalls = 0
+let reusedOldProgram = false
+let finished = false
+const exitSignalKey = '__writeModeSmokeExit'
+
+const originalTs = require('typescript')
+const instrumentedTs = new Proxy(originalTs, {
+    get(target, property, receiver) {
+        if (property === 'createProgram') {
+            return function (...args) {
+                createProgramCalls += 1
+                reusedOldProgram = reusedOldProgram || !!args[3]
+                return Reflect.get(target, property, receiver).apply(this, args)
+            }
+        }
+
+        return Reflect.get(target, property, receiver)
+    },
+})
+
+const originalModuleLoad = Module._load
+Module._load = function (request, parent, isMain) {
+    if (request === 'typescript') {
+        return instrumentedTs
+    }
+
+    return originalModuleLoad.apply(this, arguments)
+}
+
+function cleanup() {
+    try {
+        fs.rmSync(projectDir, { recursive: true, force: true })
+    } catch {}
+}
+
+function finish(code, error) {
+    if (finished) {
+        return
+    }
+    finished = true
+
+    cleanup()
+
+    if (error) {
+        console.error(error)
+    }
+
+    fs.writeFileSync(
+        process.stdout.fd,
+        JSON.stringify({
+            createProgramCalls,
+            reusedOldProgram,
+        }) + '\n',
+    )
+
+    process.exitCode = code
+}
+
+const originalProcessExit = process.exit
+process.exit = (code) => {
+    throw { [exitSignalKey]: true, code: code ?? 0 }
+}
+
+process.on('uncaughtException', (error) => {
+    finish(1, error)
+})
+
+process.on('unhandledRejection', (error) => {
+    finish(1, error)
+})
+
+fs.mkdirSync(path.dirname(logicFilePath), { recursive: true })
+fs.writeFileSync(
+    tsconfigPath,
+    JSON.stringify(
+        {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'commonjs',
+                moduleResolution: 'node',
+                esModuleInterop: true,
+                skipLibCheck: true,
+                strict: false,
+            },
+            include: ['src/**/*'],
+        },
+        null,
+        2,
+    ),
+)
+
+fs.writeFileSync(
+    logicFilePath,
+    [
+        "import { kea } from 'kea'",
+        '',
+        'export const logic = kea({',
+        '    actions: () => ({',
+        '        setValue: (value: string) => ({ value }),',
+        '    }),',
+        '    reducers: () => ({',
+        "        value: ['', { setValue: (_, payload) => payload.value }],",
+        '    }),',
+        '})',
+        '',
+    ].join('\n'),
+)
+
+const { runTypeGen } = require(path.join(repoRoot, 'src/typegen'))
+
+Promise.resolve(
+    runTypeGen({
+        tsConfigPath: tsconfigPath,
+        rootPath: projectDir,
+        typesPath: projectDir,
+        write: true,
+        watch: false,
+        log: noop,
+    }),
+)
+    .then(() => {
+        finish(0)
+    })
+    .catch((error) => {
+        if (error && error[exitSignalKey]) {
+            finish(error.code)
+        } else {
+            finish(1, error)
+        }
+    })
+    .finally(() => {
+        Module._load = originalModuleLoad
+        process.exit = originalProcessExit
+    })

package/src/typegen.ts

@@ -26,12 +26,17 @@ export async function runTypeGen(appOptions: AppOptions) {
     if (appOptions.sourceFilePath) {
         log(`❇️ Loading file: ${appOptions.sourceFilePath}`)
         resetProgram = () => {
-            program = ts.createProgram([appOptions.sourceFilePath], {
-                target: ts.ScriptTarget.ES5,
-                module: ts.ModuleKind.CommonJS,
-                noEmit: true,
-                noErrorTruncation: true,
-            })
+            program = replaceProgram(() =>
+                ts.createProgram([appOptions.sourceFilePath], {
+                    target: ts.ScriptTarget.ES5,
+                    module: ts.ModuleKind.CommonJS,
+                    noEmit: true,
+                    noErrorTruncation: true,
+                }),
+                (nextProgram) => {
+                    program = nextProgram
+                },
+            )
         }
         resetProgram()
     } else if (appOptions.tsConfigPath) {
@@ -85,24 +90,62 @@ export async function runTypeGen(appOptions: AppOptions) {
                 console.info(codes[diagnostic.code] || `🥚 ${ts.formatDiagnostic(diagnostic, formatHost).trim()}`)
             }
 
-            const origCreateProgram = host.createProgram
-            host.createProgram = (rootNames: ReadonlyArray<string>, options, host, oldProgram) => {
-                return origCreateProgram(rootNames, options, host, oldProgram)
-            }
             const origPostProgramCreate = host.afterProgramCreate
+            let scheduledProgram: Program | undefined
+            let runningTypegen = false
 
-            host.afterProgramCreate = async (prog) => {
-                program = prog.getProgram()
-                origPostProgramCreate!(prog)
+            const runScheduledTypegen = async () => {
+                if (runningTypegen) {
+                    return
+                }
 
-                await goThroughAllTheFiles(program, appOptions)
+                runningTypegen = true
+
+                try {
+                    while (scheduledProgram) {
+                        const nextProgram = scheduledProgram
+                        scheduledProgram = undefined
+
+                        try {
+                            await goThroughAllTheFiles(nextProgram, appOptions)
+                        } catch (error) {
+                            console.error('⛔ Error running kea-typegen in watch mode')
+                            console.error(error)
+                        }
+                    }
+                } finally {
+                    runningTypegen = false
+
+                    if (scheduledProgram) {
+                        void runScheduledTypegen()
+                    }
+                }
+            }
+
+            host.afterProgramCreate = (prog) => {
+                program = prog.getProgram()
+                origPostProgramCreate?.(prog)
+                scheduledProgram = program
+                void runScheduledTypegen()
             }
 
             ts.createWatchProgram(host)
         } else {
-            const host = ts.createCompilerHost(compilerOptions.options)
             resetProgram = () => {
-                program = ts.createProgram(compilerOptions.fileNames, compilerOptions.options, host, program)
+                // Write mode can require multiple passes as generated imports and type files
+                // land on disk. Reusing the previous Program retains too much compiler state
+                // for large projects, so rebuild from a fresh host each round instead.
+                // Clear the previous Program reference before allocating the next one to
+                // avoid holding both huge compiler graphs live at the same time.
+                program = replaceProgram(
+                    () => {
+                        const host = ts.createCompilerHost(compilerOptions.options)
+                        return ts.createProgram(compilerOptions.fileNames, compilerOptions.options, host)
+                    },
+                    (nextProgram) => {
+                        program = nextProgram
+                    },
+                )
             }
             resetProgram()
         }
@@ -158,3 +201,10 @@ export async function runTypeGen(appOptions: AppOptions) {
         }
     }
 }
+
+export function replaceProgram(createProgram: () => Program, setProgram: (program?: Program) => void): Program {
+    setProgram(undefined)
+    const nextProgram = createProgram()
+    setProgram(nextProgram)
+    return nextProgram
+}

package/src/write/writeTypeImports.ts

@@ -1,10 +1,41 @@
 import { AppOptions, ParsedLogic } from '../types'
 import * as ts from 'typescript'
-import { print, visit } from 'recast'
 import * as osPath from 'path'
 import { runThroughPrettier } from '../print/print'
 import * as fs from 'fs'
-import { t, b, visitAllKeaCalls, getAst } from './utils'
+interface TextEdit {
+    start: number
+    end: number
+    text: string
+}
+
+function applyTextEdits(source: string, edits: TextEdit[]): string {
+    return edits
+        .sort((a, b) => b.start - a.start || b.end - a.end)
+        .reduce((output, { start, end, text }) => output.slice(0, start) + text + output.slice(end), source)
+}
+
+function getImportPath(importDeclaration: ts.ImportDeclaration): string | null {
+    return ts.isStringLiteralLike(importDeclaration.moduleSpecifier) ? importDeclaration.moduleSpecifier.text : null
+}
+
+function getImportInsertPosition(sourceFile: ts.SourceFile, rawCode: string): number {
+    const importDeclarations = sourceFile.statements.filter(ts.isImportDeclaration)
+    if (importDeclarations.length > 0) {
+        return importDeclarations[importDeclarations.length - 1].getEnd()
+    }
+
+    const shebangMatch = rawCode.match(/^#!.*(?:\r?\n|$)/)
+    return shebangMatch ? shebangMatch[0].length : 0
+}
+
+function getTypeArgumentInsertEnd(callExpression: ts.CallExpression, sourceFile: ts.SourceFile): number {
+    const openParenToken = callExpression
+        .getChildren(sourceFile)
+        .find((child) => child.kind === ts.SyntaxKind.OpenParenToken)
+
+    return openParenToken ? openParenToken.getStart(sourceFile) : callExpression.expression.getEnd()
+}
 
 export async function writeTypeImports(
     appOptions: AppOptions,
@@ -15,9 +46,10 @@ export async function writeTypeImports(
 ) {
     const { log } = appOptions
     const sourceFile = program.getSourceFile(filename)
-    const rawCode = sourceFile.getText()
-
-    const ast = getAst(filename, rawCode)
+    if (!sourceFile) {
+        throw new Error(`Could not find source file: ${filename}`)
+    }
+    const rawCode = fs.readFileSync(filename, 'utf8')
 
     let importLocation = osPath
         .relative(osPath.dirname(filename), logicsNeedingImports[0].typeFileName)
@@ -26,56 +58,57 @@ export async function writeTypeImports(
         importLocation = `./${importLocation}`
     }
 
-    // add import if missing
-    let foundImport = false
-    visit(ast, {
-        visitImportDeclaration(path) {
-            const importPath =
-                path.value.source && t.StringLiteral.check(path.value.source) ? path.value.source.value : null
-
-            if (
-                t.ImportDeclaration.check(path.value) &&
-                importPath &&
-                osPath.resolve(osPath.dirname(filename), importPath) ===
-                    osPath.resolve(osPath.dirname(filename), importLocation)
-            ) {
-                foundImport = true
-                path.value.importKind = 'type'
-                path.value.specifiers = parsedLogics.map((l) =>
-                    b.importSpecifier(b.identifier(l.logicTypeName), b.identifier(l.logicTypeName)),
-                )
-            }
-            return false
-        },
+    const desiredImport = `import type { ${parsedLogics.map((l) => l.logicTypeName).join(', ')} } from '${importLocation}'`
+    const importDeclarations = sourceFile.statements.filter(ts.isImportDeclaration)
+    const matchingImport = importDeclarations.find((importDeclaration) => {
+        const importPath = getImportPath(importDeclaration)
+        return (
+            importPath !== null &&
+            osPath.resolve(osPath.dirname(filename), importPath) ===
+                osPath.resolve(osPath.dirname(filename), importLocation)
+        )
     })
 
-    if (!foundImport) {
-        visit(ast, {
-            visitProgram(path) {
-                path.value.body = [
-                    ...path.value.body.filter((n) => t.ImportDeclaration.check(n)),
-                    b.importDeclaration(
-                        parsedLogics.map((l) =>
-                            b.importSpecifier(b.identifier(l.logicTypeName), b.identifier(l.logicTypeName)),
-                        ),
-                        b.stringLiteral(importLocation),
-                        'type',
-                    ),
-                    ...path.value.body.filter((n) => !t.ImportDeclaration.check(n)),
-                ]
-                return false
-            },
+    const edits: TextEdit[] = []
+    if (matchingImport) {
+        edits.push({
+            start: matchingImport.getStart(sourceFile),
+            end: matchingImport.getEnd(),
+            text: desiredImport,
+        })
+    } else {
+        const insertPos = getImportInsertPosition(sourceFile, rawCode)
+        const hasExistingImports = importDeclarations.length > 0
+        const importText = hasExistingImports
+            ? `\n${desiredImport}${rawCode.slice(insertPos, insertPos + 1) === '\n' ? '' : '\n'}`
+            : `${desiredImport}\n`
+
+        edits.push({
+            start: insertPos,
+            end: insertPos,
+            text: importText,
         })
     }
 
-    // find all kea calls, add `<logicType>` type parameters if needed
-    visitAllKeaCalls(ast, logicsNeedingImports, filename, ({ path, parsedLogic }) => {
-        path.node.typeParameters = b.tsTypeParameterInstantiation([
-            b.tsTypeReference(b.identifier(parsedLogic.logicTypeName)),
-        ])
-    })
+    for (const parsedLogic of logicsNeedingImports) {
+        const callExpression = parsedLogic.node.parent
+        if (!ts.isCallExpression(callExpression)) {
+            continue
+        }
+
+        const typeArgumentStart = callExpression.expression.getEnd()
+        const typeArgumentEnd = callExpression.typeArguments
+            ? getTypeArgumentInsertEnd(callExpression, sourceFile)
+            : typeArgumentStart
+
+        edits.push({
+            start: typeArgumentStart,
+            end: typeArgumentEnd,
+            text: `<${parsedLogic.logicTypeName}>`,
+        })
+    }
 
-    const newText = await runThroughPrettier(print(ast).code, filename)
+    const newText = await runThroughPrettier(applyTextEdits(rawCode, edits), filename)
     fs.writeFileSync(filename, newText)
 
     log(`🔥 Import added: ${osPath.relative(process.cwd(), filename)}`)