kea-typegen 3.6.6 → 3.7.0

package/src/__tests__/write.ts

@@ -0,0 +1,211 @@
+import { spawn } from 'child_process'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import * as ts from 'typescript'
+import { AppOptions } from '../types'
+import { visitProgram } from '../visit/visit'
+import { writeTypeImports } from '../write/writeTypeImports'
+
+test(
+    'write mode recreates the TypeScript program from scratch between passes',
+    async () => {
+        const repoRoot = path.resolve(__dirname, '..', '..')
+        const scriptPath = path.join(repoRoot, 'src/test-support/write-mode-smoke.js')
+
+        const result = await new Promise<{ code: number | null; signal: NodeJS.Signals | null; stdout: string; stderr: string }>(
+            (resolve, reject) => {
+                const child = spawn(process.execPath, [scriptPath], {
+                    cwd: repoRoot,
+                    env: { ...process.env, FORCE_COLOR: '0' },
+                })
+
+                let stdout = ''
+                let stderr = ''
+
+                child.stdout.on('data', (chunk) => {
+                    stdout += chunk.toString()
+                })
+
+                child.stderr.on('data', (chunk) => {
+                    stderr += chunk.toString()
+                })
+
+                child.on('error', reject)
+                child.on('close', (code, signal) => resolve({ code, signal, stdout, stderr }))
+            },
+        )
+
+        expect(result.signal).toBeNull()
+        expect(result.code).toBe(0)
+
+        const payload = JSON.parse(result.stdout.trim())
+
+        expect(payload.createProgramCalls).toBeGreaterThan(1)
+        expect(payload.reusedOldProgram).toBe(false)
+        expect(result.stderr).toBe('')
+    },
+    30000,
+)
+
+test('writeTypeImports adds missing type import and kea generic', async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-write-imports-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const logicPath = path.join(logicDir, 'logic.ts')
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+        fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+        fs.mkdirSync(logicDir, { recursive: true })
+
+        fs.writeFileSync(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+        fs.writeFileSync(
+            logicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const logic = kea({',
+                '    actions: () => ({',
+                '        setValue: (value: string) => ({ value }),',
+                '    }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+
+        const program = ts.createProgram([logicPath], {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+        const appOptions: AppOptions = {
+            rootPath: logicDir,
+            typesPath: logicDir,
+            log: () => {},
+        }
+
+        const [parsedLogic] = visitProgram(program, appOptions)
+        await writeTypeImports(appOptions, program, logicPath, [parsedLogic], [parsedLogic])
+
+        const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+
+        expect(writtenLogic).toMatch(/import type \{ logicType \} from ['"]\.\/logicType['"]/)
+        expect(writtenLogic).toContain('export const logic = kea<logicType>({')
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})
+
+test('writeTypeImports replaces existing kea generic without leaving a trailing >', async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-write-existing-generic-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const logicPath = path.join(logicDir, 'logic.ts')
+        const logicTypePath = path.join(logicDir, 'logicType.ts')
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+        fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+        fs.mkdirSync(logicDir, { recursive: true })
+
+        fs.writeFileSync(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+        fs.writeFileSync(logicTypePath, 'export interface logicType {}\n')
+        fs.writeFileSync(
+            logicPath,
+            [
+                "import type { logicType } from './logicType'",
+                "import { kea, actions } from 'kea'",
+                '',
+                'export const logic = kea<logicType<string>>([',
+                '    actions({',
+                '        setValue: (value: string) => ({ value }),',
+                '    }),',
+                '])',
+                '',
+            ].join('\n'),
+        )
+
+        const program = ts.createProgram([logicPath], {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+        const appOptions: AppOptions = {
+            rootPath: logicDir,
+            typesPath: logicDir,
+            log: () => {},
+        }
+
+        const [parsedLogic] = visitProgram(program, appOptions)
+        await writeTypeImports(appOptions, program, logicPath, [parsedLogic], [parsedLogic])
+
+        const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+
+        expect(writtenLogic).toMatch(/import type \{ logicType \} from ['"]\.\/logicType['"]/)
+        expect(writtenLogic).toContain('export const logic = kea<logicType>([')
+        expect(writtenLogic).not.toContain('kea<logicType>>([')
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})
+
+test('visitProgram limits project-aware single-file generation to the requested source file', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-single-file-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const firstLogicPath = path.join(logicDir, 'firstLogic.ts')
+        const secondLogicPath = path.join(logicDir, 'secondLogic.ts')
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+        fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+        fs.mkdirSync(logicDir, { recursive: true })
+
+        fs.writeFileSync(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+        fs.writeFileSync(
+            firstLogicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const firstLogic = kea({',
+                '    actions: () => ({ first: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+        fs.writeFileSync(
+            secondLogicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const secondLogic = kea({',
+                '    actions: () => ({ second: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+
+        const program = ts.createProgram([firstLogicPath, secondLogicPath], {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+        const parsedLogics = visitProgram(program, {
+            rootPath: logicDir,
+            typesPath: logicDir,
+            sourceFilePath: secondLogicPath,
+            log: () => {},
+        })
+
+        expect(parsedLogics.map((logic) => logic.logicName)).toEqual(['secondLogic'])
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})

package/src/cli/typegen.ts

@@ -18,7 +18,11 @@ yargs
         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('file', {
+        alias: 'f',
+        describe: 'Single file to evaluate. Uses --config/.kearc compiler options when available.',
+        type: 'string',
+    })
     .option('root', {
         alias: 'r',
         describe: 'Root for logic paths. E.g: ./frontend/src',
@@ -51,6 +55,11 @@ yargs
         describe: 'Cache generated logic files into .typegen, use them if generating a logic type for the first time',
         type: 'boolean',
     })
+    .option('prettier', {
+        describe: 'Format generated logic type declarations with Prettier (use --no-prettier to skip)',
+        type: 'boolean',
+        default: true,
+    })
     .option('verbose', { describe: 'Slightly more verbose output log', type: 'boolean' })
     .demandCommand()
     .help()

package/src/print/print.ts

@@ -40,8 +40,16 @@ import { printInternalExtraInput } from './printInternalExtraInput'
 import { convertToBuilders } from '../write/convertToBuilders'
 import { cacheWrittenFile } from '../cache'
 
+const prettierConfigCache = new Map<string, Promise<prettier.Options | null>>()
+
 export async function runThroughPrettier(sourceText: string, filePath: string): Promise<string> {
-    const options = await prettier.resolveConfig(filePath)
+    let configPromise = prettierConfigCache.get(filePath)
+    if (!configPromise) {
+        configPromise = prettier.resolveConfig(filePath, { useCache: true })
+        prettierConfigCache.set(filePath, configPromise)
+    }
+
+    const options = await configPromise
     if (options) {
         try {
             return await prettier.format(sourceText, { ...options, filepath: filePath })
@@ -107,11 +115,12 @@ export async function printToFiles(
         const logicStrings = []
         const requiredKeys = new Set(['Logic'])
         for (const parsedLogic of parsedLogics) {
-            const logicTypeStirng = await runThroughPrettier(
-                nodeToString(parsedLogic.interfaceDeclaration),
-                typeFileName,
+            const logicTypeString = nodeToString(parsedLogic.interfaceDeclaration)
+            logicStrings.push(
+                appOptions.prettier === false
+                    ? logicTypeString
+                    : await runThroughPrettier(logicTypeString, typeFileName),
             )
-            logicStrings.push(logicTypeStirng)
             for (const string of parsedLogic.importFromKeaInLogicType.values()) {
                 requiredKeys.add(string)
             }

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

@@ -0,0 +1,140 @@
+const fs = require('fs')
+const path = require('path')
+
+require('ts-node/register/transpile-only')
+
+const repoRoot = path.resolve(__dirname, '..', '..')
+const projectDir = fs.mkdtempSync(path.join(repoRoot, 'tmp-watch-smoke-'))
+const tsconfigPath = path.join(projectDir, 'tsconfig.json')
+const fileCount = 200
+
+const noop = () => {}
+console.info = noop
+
+let active = 0
+let maxActive = 0
+let started = 0
+let completed = 0
+let settleTimer
+let timeoutTimer
+let finished = false
+
+function cleanup() {
+    try {
+        fs.rmSync(projectDir, { recursive: true, force: true })
+    } catch {}
+}
+
+function finish(code) {
+    if (finished) {
+        return
+    }
+    finished = true
+    clearTimeout(settleTimer)
+    clearTimeout(timeoutTimer)
+    cleanup()
+
+    fs.writeFileSync(
+        process.stdout.fd,
+        JSON.stringify({
+            started,
+            completed,
+            active,
+            maxActive,
+        }) + '\n',
+    )
+    process.exit(code)
+}
+
+function scheduleFinishIfSettled() {
+    if (started > 1 && active === 0) {
+        clearTimeout(settleTimer)
+        settleTimer = setTimeout(() => finish(0), 300)
+    }
+}
+
+process.on('uncaughtException', (error) => {
+    console.error(error)
+    finish(1)
+})
+
+process.on('unhandledRejection', (error) => {
+    console.error(error)
+    finish(1)
+})
+
+fs.writeFileSync(
+    tsconfigPath,
+    JSON.stringify(
+        {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'commonjs',
+                moduleResolution: 'node',
+                esModuleInterop: true,
+                skipLibCheck: true,
+                strict: false,
+            },
+            include: ['src/**/*'],
+        },
+        null,
+        2,
+    ),
+)
+
+for (let i = 0; i < fileCount; i++) {
+    const dir = path.join(projectDir, 'src', `group${String(i % 10).padStart(2, '0')}`)
+    const filePath = path.join(dir, `logic${i}.ts`)
+
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(
+        filePath,
+        [
+            "import { kea } from 'kea'",
+            '',
+            `export const logic${i} = kea({`,
+            '    actions: () => ({',
+            '        setValue: (value: string) => ({ value }),',
+            '    }),',
+            '    reducers: () => ({',
+            "        value: ['' as string, { setValue: (_, payload) => payload.value }],",
+            '    }),',
+            '})',
+            '',
+        ].join('\n'),
+    )
+}
+
+const printModule = require(path.join(repoRoot, 'src/print/print'))
+const originalPrintToFiles = printModule.printToFiles
+
+printModule.printToFiles = async function (...args) {
+    active += 1
+    started += 1
+    maxActive = Math.max(maxActive, active)
+    clearTimeout(settleTimer)
+
+    await new Promise((resolve) => setTimeout(resolve, 25))
+
+    try {
+        return await originalPrintToFiles.apply(this, args)
+    } finally {
+        await new Promise((resolve) => setTimeout(resolve, 25))
+        active -= 1
+        completed += 1
+        scheduleFinishIfSettled()
+    }
+}
+
+const { runTypeGen } = require(path.join(repoRoot, 'src/typegen'))
+
+timeoutTimer = setTimeout(() => finish(1), 20000)
+
+runTypeGen({
+    tsConfigPath: tsconfigPath,
+    rootPath: projectDir,
+    typesPath: projectDir,
+    write: true,
+    watch: true,
+    log: noop,
+})

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

@@ -25,21 +25,26 @@ export async function runTypeGen(appOptions: AppOptions) {
 
     if (appOptions.sourceFilePath) {
         log(`❇️ Loading file: ${appOptions.sourceFilePath}`)
+        const compilerOptions = appOptions.tsConfigPath
+            ? loadTsConfig(appOptions.tsConfigPath, log).options
+            : {
+                  target: ts.ScriptTarget.ES5,
+                  module: ts.ModuleKind.CommonJS,
+                  noEmit: true,
+                  noErrorTruncation: true,
+              }
+
         resetProgram = () => {
-            program = ts.createProgram([appOptions.sourceFilePath], {
-                target: ts.ScriptTarget.ES5,
-                module: ts.ModuleKind.CommonJS,
-                noEmit: true,
-                noErrorTruncation: true,
-            })
+            program = replaceProgram(
+                () => ts.createProgram([appOptions.sourceFilePath], compilerOptions),
+                (nextProgram) => {
+                    program = nextProgram
+                },
+            )
         }
         resetProgram()
     } else if (appOptions.tsConfigPath) {
-        log(`🥚 TypeScript Config: ${appOptions.tsConfigPath}`)
-
-        const configFile = ts.readJsonConfigFile(appOptions.tsConfigPath, ts.sys.readFile)
-        const rootFolder = path.dirname(appOptions.tsConfigPath)
-        const compilerOptions = ts.parseJsonSourceFileConfigFileContent(configFile, ts.sys, rootFolder)
+        const compilerOptions = loadTsConfig(appOptions.tsConfigPath, log)
 
         if (appOptions.watch) {
             // We don't emit JavaScript files in typegen watch mode, so the semantic-only
@@ -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()
         }
@@ -130,7 +173,12 @@ export async function runTypeGen(appOptions: AppOptions) {
         return response
     }
 
-    if (program && !appOptions.watch && !appOptions.sourceFilePath) {
+    if (program && !appOptions.watch && appOptions.sourceFilePath) {
+        await goThroughAllTheFiles(program, appOptions)
+        if (appOptions.write) {
+            log(`👋 Finished writing files! Exiting.`)
+        }
+    } else if (program && !appOptions.watch) {
         if (appOptions.write) {
             if (restoreCachedTypes(program, appOptions, log)) {
                 resetProgram()
@@ -158,3 +206,17 @@ export async function runTypeGen(appOptions: AppOptions) {
         }
     }
 }
+
+function loadTsConfig(tsConfigPath: string, log: AppOptions['log']): ts.ParsedCommandLine {
+    log(`🥚 TypeScript Config: ${tsConfigPath}`)
+    const configFile = ts.readJsonConfigFile(tsConfigPath, ts.sys.readFile)
+    const rootFolder = path.dirname(tsConfigPath)
+    return ts.parseJsonSourceFileConfigFileContent(configFile, ts.sys, rootFolder)
+}
+
+export function replaceProgram(createProgram: () => Program, setProgram: (program?: Program) => void): Program {
+    setProgram(undefined)
+    const nextProgram = createProgram()
+    setProgram(nextProgram)
+    return nextProgram
+}