kea-typegen 3.6.8 → 3.7.1

package/src/typegen.ts

@@ -6,6 +6,7 @@ import { AppOptions } from './types'
 import { Program } from 'typescript'
 import { version } from '../package.json'
 import { restoreCachedTypes } from './cache'
+import { createWatchChangeTracker, planWatchTypegenPass, WatchFileChange, WatchTypegenPlan } from './watch'
 
 // The undocumented defaultMaximumTruncationLength setting determines at what point printed types are truncated in versions less than 5.
 // In kea-typegen output, we NEVER want the types truncated, as that results in a syntax error –
@@ -25,14 +26,18 @@ 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 = replaceProgram(() =>
-                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
                 },
@@ -40,22 +45,19 @@ export async function runTypeGen(appOptions: AppOptions) {
         }
         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
             // builder is enough and avoids extra emit-related work on every rebuild.
             const createProgram = ts.createSemanticDiagnosticsBuilderProgram
+            const watchChangeTracker = createWatchChangeTracker(ts.sys)
 
             const host = ts.createWatchCompilerHost(
                 appOptions.tsConfigPath,
                 compilerOptions.options,
                 {
-                    ...ts.sys,
+                    ...watchChangeTracker.system,
                     writeFile(_path: string, _data: string, _writeByteOrderMark?: boolean) {
                         // skip emit
                         // https://github.com/microsoft/TypeScript/issues/32385
@@ -92,6 +94,7 @@ export async function runTypeGen(appOptions: AppOptions) {
 
             const origPostProgramCreate = host.afterProgramCreate
             let scheduledProgram: Program | undefined
+            let scheduledChanges: WatchFileChange[] = []
             let runningTypegen = false
 
             const runScheduledTypegen = async () => {
@@ -104,10 +107,16 @@ export async function runTypeGen(appOptions: AppOptions) {
                 try {
                     while (scheduledProgram) {
                         const nextProgram = scheduledProgram
+                        const nextChanges = scheduledChanges
                         scheduledProgram = undefined
+                        scheduledChanges = []
 
                         try {
-                            await goThroughAllTheFiles(nextProgram, appOptions)
+                            await goThroughWatchTypegenPlan(
+                                nextProgram,
+                                appOptions,
+                                planWatchTypegenPass(nextProgram, nextChanges),
+                            )
                         } catch (error) {
                             console.error('⛔ Error running kea-typegen in watch mode')
                             console.error(error)
@@ -124,8 +133,10 @@ export async function runTypeGen(appOptions: AppOptions) {
 
             host.afterProgramCreate = (prog) => {
                 program = prog.getProgram()
+                const changes = watchChangeTracker.consume()
                 origPostProgramCreate?.(prog)
                 scheduledProgram = program
+                scheduledChanges.push(...changes)
                 void runScheduledTypegen()
             }
 
@@ -173,7 +184,52 @@ export async function runTypeGen(appOptions: AppOptions) {
         return response
     }
 
-    if (program && !appOptions.watch && !appOptions.sourceFilePath) {
+    async function goThroughWatchTypegenPlan(
+        program,
+        appOptions,
+        plan: WatchTypegenPlan,
+    ): Promise<{ filesToWrite: number; writtenFiles: number; filesToModify: number }> {
+        if (plan.kind === 'skip') {
+            if (appOptions.verbose) {
+                appOptions.log(`⏭️ Skipping typegen watch pass: ${plan.reason}`)
+            }
+            return { filesToWrite: 0, writtenFiles: 0, filesToModify: 0 }
+        }
+
+        if (plan.kind === 'full') {
+            if (appOptions.verbose) {
+                appOptions.log(`🔎 Running full typegen watch pass: ${plan.reason}`)
+            }
+            return await goThroughAllTheFiles(program, appOptions)
+        }
+
+        if (appOptions.verbose) {
+            appOptions.log(`🎯 Running incremental typegen watch pass: ${plan.reason}`)
+        }
+
+        const response = { filesToWrite: 0, writtenFiles: 0, filesToModify: 0 }
+
+        for (const sourceFilePath of plan.sourceFilePaths) {
+            const fileResponse = await goThroughAllTheFiles(program, {
+                ...appOptions,
+                delete: false,
+                sourceFilePath,
+            })
+
+            response.filesToWrite += fileResponse.filesToWrite
+            response.writtenFiles += fileResponse.writtenFiles
+            response.filesToModify += fileResponse.filesToModify
+        }
+
+        return response
+    }
+
+    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()
@@ -202,6 +258,13 @@ 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()

package/src/types.ts

@@ -82,6 +82,8 @@ export interface AppOptions {
     showTsErrors?: boolean
     /** Cache generated logic files into .typegen, use them if generating a logic type for the first time */
     useCache?: boolean
+    /** Skip Prettier formatting while generating logic type files */
+    prettier?: boolean
 
     log: (message: string) => void
 }

package/src/visit/visit.ts

@@ -25,7 +25,7 @@ import { visitEvents } from './visitEvents'
 import { visitDefaults } from './visitDefaults'
 import { visitSharedListeners } from './visitSharedListeners'
 import { cloneNode } from 'ts-clone-node'
-import {NodeBuilderFlags} from "typescript";
+import { NodeBuilderFlags } from 'typescript'
 
 const visitFunctions = {
     actions: visitActions,
@@ -44,20 +44,52 @@ const visitFunctions = {
     windowValues: visitWindowValues,
 }
 
+// Cheap text prefilters so we only do expensive AST + type-checker work on files
+// that can actually contain the thing we're looking for. On large projects most
+// source files contain no Kea logic at all, and walking every node (and resolving
+// a symbol for every identifier via the checker) for them dominates runtime.
+//
+// `kea` is never aliased on import in practice, so a `kea(` / `kea<` text match is a
+// safe-enough gate for the Kea-call pass. If a project does alias `kea`, set
+// KEA_TYPEGEN_NO_PREFILTER=1 to fall back to scanning every file.
+const KEA_CALL_REGEX = /\bkea\s*[<(]/
+const prefilterDisabled = process.env.KEA_TYPEGEN_NO_PREFILTER === '1'
+
+function fileMightContainKeaCall(sourceFile: ts.SourceFile): boolean {
+    return prefilterDisabled || KEA_CALL_REGEX.test(sourceFile.text)
+}
+
+function fileMightContainResetContext(sourceFile: ts.SourceFile): boolean {
+    return prefilterDisabled || sourceFile.text.includes('resetContext')
+}
+
 export function visitProgram(program: ts.Program, appOptions?: AppOptions): ParsedLogic[] {
     const checker = program.getTypeChecker()
     const parsedLogics: ParsedLogic[] = []
     const pluginModules: PluginModule[] = []
     const typeBuilderModules: TypeBuilderModule[] = []
+    const sourceFilePath = appOptions?.sourceFilePath ? path.resolve(appOptions.sourceFilePath) : undefined
 
     for (const sourceFile of program.getSourceFiles()) {
-        if (!sourceFile.isDeclarationFile && !sourceFile.fileName.endsWith('Type.ts')) {
+        if (
+            !sourceFile.isDeclarationFile &&
+            !sourceFile.fileName.endsWith('Type.ts') &&
+            fileMightContainResetContext(sourceFile)
+        ) {
             ts.forEachChild(sourceFile, visitResetContext(checker, pluginModules))
         }
     }
 
     for (const sourceFile of program.getSourceFiles()) {
-        if (!sourceFile.isDeclarationFile && !sourceFile.fileName.endsWith('Type.ts')) {
+        if (sourceFilePath && path.resolve(sourceFile.fileName) !== sourceFilePath) {
+            continue
+        }
+
+        if (
+            !sourceFile.isDeclarationFile &&
+            !sourceFile.fileName.endsWith('Type.ts') &&
+            fileMightContainKeaCall(sourceFile)
+        ) {
             if (appOptions?.verbose) {
                 appOptions.log(`👀 Visiting: ${path.relative(process.cwd(), sourceFile.fileName)}`)
             }
@@ -245,7 +277,6 @@ export function visitKeaCalls(
         const calls: {
             name: string
             type: ts.Type
-            typeNode: ts.TypeNode | null
             expression: ts.Expression
             typeBuilders: PluginModule[]
         }[] = []
@@ -261,8 +292,7 @@ export function visitKeaCalls(
                 }
                 const name = symbol.getName()
                 const type = checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration)
-                const typeNode = type ? checker.typeToTypeNode(type, undefined, NodeBuilderFlags.NoTruncation) : null
-                calls.push({ name, type, typeNode, expression: inputProperty.initializer, typeBuilders: [] })
+                calls.push({ name, type, expression: inputProperty.initializer, typeBuilders: [] })
             }
         } else if (ts.isArrayLiteralExpression(input)) {
             for (const callExpression of input.elements) {
@@ -273,7 +303,6 @@ export function visitKeaCalls(
                 const builderName = callExpression.expression.getText()
                 const argument = callExpression.arguments[0]
                 const type = checker.getTypeAtLocation(argument)
-                const typeNode = type ? checker.typeToTypeNode(type, undefined, NodeBuilderFlags.NoTruncation) : null
 
                 const identifier = callExpression.expression
                 const symbol = checker.getSymbolAtLocation(identifier)
@@ -348,14 +377,13 @@ export function visitKeaCalls(
                 calls.push({
                     name: builderName,
                     type,
-                    typeNode,
                     expression: callExpression.arguments[0],
                     typeBuilders: typeBuilders,
                 })
             }
         }
 
-        for (let { name, type, typeNode, expression, typeBuilders } of calls) {
+        for (let { name, type, expression, typeBuilders } of calls) {
             if (name === 'path' || name === 'logicPath') {
                 parsedLogic.hasPathInLogic = true
             }
@@ -363,18 +391,31 @@ export function visitKeaCalls(
                 parsedLogic.hasKeyInLogic = true
             }
 
-            if (typeNode && ts.isFunctionTypeNode(typeNode)) {
-                type = type.getCallSignatures()[0].getReturnType()
-                typeNode = type ? checker.typeToTypeNode(type, undefined, NodeBuilderFlags.NoTruncation) : null
+            // Equivalent to the previous `ts.isFunctionTypeNode(typeNode)` check, but without
+            // eagerly building a typeNode: a pure function type has call signatures and no
+            // members, so we unwrap it to its return type before visiting/printing.
+            const callSignatures = type.getCallSignatures()
+            if (callSignatures.length > 0 && type.getProperties().length === 0) {
+                type = callSignatures[0].getReturnType()
             }
 
             visitFunctions[name]?.(parsedLogic, type, expression)
 
+            let typeNode: ts.TypeNode | null | undefined = undefined
+            const getTypeNode = (): ts.TypeNode | null => {
+                if (typeNode === undefined) {
+                    typeNode = type ? checker.typeToTypeNode(type, undefined, NodeBuilderFlags.NoTruncation) : null
+                }
+                return typeNode
+            }
+
             const visitKeaPropertyArguments: VisitKeaPropertyArguments = {
                 name,
                 appOptions,
                 type,
-                typeNode,
+                get typeNode() {
+                    return getTypeNode()
+                },
                 parsedLogic,
                 node: expression,
                 checker,

package/src/watch.ts

@@ -0,0 +1,261 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import * as ts from 'typescript'
+import { getFilenameForImportDeclaration } from './utils'
+
+const KEA_CALL_REGEX = /\bkea\s*[<(]/
+const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.mjsx']
+const TYPEGEN_FILE_REGEX = /(^|\.|\/)typegen\.[tj]s$/
+const MAX_INCREMENTAL_CHANGED_FILES = 50
+
+export interface WatchFileChange {
+    fileName: string
+    eventKind: ts.FileWatcherEventKind
+}
+
+export type WatchTypegenPlan =
+    | { kind: 'full'; reason: string }
+    | { kind: 'files'; sourceFilePaths: string[]; reason: string }
+    | { kind: 'skip'; reason: string }
+
+export interface WatchChangeTracker {
+    system: ts.System
+    consume(): WatchFileChange[]
+}
+
+export function createWatchChangeTracker(baseSystem: ts.System): WatchChangeTracker {
+    const changes = new Map<string, WatchFileChange>()
+
+    const track = (fileName: string, eventKind: ts.FileWatcherEventKind): void => {
+        changes.set(path.resolve(fileName), { fileName: path.resolve(fileName), eventKind })
+    }
+
+    const system: ts.System = {
+        ...baseSystem,
+        watchFile(fileName, callback, pollingInterval, options) {
+            return baseSystem.watchFile!(
+                fileName,
+                (changedFileName, eventKind, modifiedTime) => {
+                    track(changedFileName, eventKind)
+                    callback(changedFileName, eventKind, modifiedTime)
+                },
+                pollingInterval,
+                options,
+            )
+        },
+        watchDirectory(fileName, callback, recursive, options) {
+            return baseSystem.watchDirectory!(
+                fileName,
+                (changedFileName) => {
+                    track(changedFileName, ts.FileWatcherEventKind.Created)
+                    callback(changedFileName)
+                },
+                recursive,
+                options,
+            )
+        },
+    }
+
+    return {
+        system,
+        consume() {
+            const currentChanges = [...changes.values()]
+            changes.clear()
+            return currentChanges
+        },
+    }
+}
+
+export function planWatchTypegenPass(program: ts.Program, changes: WatchFileChange[]): WatchTypegenPlan {
+    if (changes.length === 0) {
+        return { kind: 'full', reason: 'initial watch pass' }
+    }
+
+    const normalizedChanges = dedupeChanges(changes)
+
+    if (normalizedChanges.length > MAX_INCREMENTAL_CHANGED_FILES) {
+        return { kind: 'full', reason: `${normalizedChanges.length} files changed` }
+    }
+
+    if (normalizedChanges.some((change) => change.eventKind === ts.FileWatcherEventKind.Deleted)) {
+        return { kind: 'full', reason: 'deleted file detected' }
+    }
+
+    const sourceFilesByPath = getSourceFilesByPath(program)
+    const reverseDependencies = buildReverseDependencyMap(program)
+    const queue: string[] = []
+
+    for (const change of normalizedChanges) {
+        const changedPath = path.resolve(change.fileName)
+
+        if (isTypegenModuleFile(changedPath)) {
+            return { kind: 'full', reason: `typegen module changed: ${path.relative(process.cwd(), changedPath)}` }
+        }
+
+        const sourceFile = sourceFilesByPath.get(changedPath)
+
+        if (sourceFile?.text.includes('resetContext')) {
+            return { kind: 'full', reason: `resetContext changed: ${path.relative(process.cwd(), changedPath)}` }
+        }
+
+        if (isGeneratedTypeFile(changedPath)) {
+            queue.push(...sourcePathsForTypeFile(changedPath, sourceFilesByPath))
+            queue.push(changedPath)
+            continue
+        }
+
+        if (sourceFile) {
+            if (sourceFile.isDeclarationFile) {
+                return {
+                    kind: 'full',
+                    reason: `declaration file changed: ${path.relative(process.cwd(), changedPath)}`,
+                }
+            }
+
+            queue.push(changedPath)
+            continue
+        }
+
+        if (isSourceLikeFile(changedPath) && fs.existsSync(changedPath)) {
+            return {
+                kind: 'full',
+                reason: `new source file outside program: ${path.relative(process.cwd(), changedPath)}`,
+            }
+        }
+    }
+
+    const affectedLogicFiles = collectAffectedLogicFiles(queue, sourceFilesByPath, reverseDependencies)
+
+    if (affectedLogicFiles.length === 0) {
+        return { kind: 'skip', reason: 'no affected Kea logic files' }
+    }
+
+    return {
+        kind: 'files',
+        sourceFilePaths: affectedLogicFiles,
+        reason: `${affectedLogicFiles.length} affected Kea logic file${affectedLogicFiles.length === 1 ? '' : 's'}`,
+    }
+}
+
+function dedupeChanges(changes: WatchFileChange[]): WatchFileChange[] {
+    const deduped = new Map<string, WatchFileChange>()
+
+    for (const change of changes) {
+        deduped.set(path.resolve(change.fileName), { ...change, fileName: path.resolve(change.fileName) })
+    }
+
+    return [...deduped.values()]
+}
+
+function getSourceFilesByPath(program: ts.Program): Map<string, ts.SourceFile> {
+    const sourceFilesByPath = new Map<string, ts.SourceFile>()
+
+    for (const sourceFile of program.getSourceFiles()) {
+        sourceFilesByPath.set(path.resolve(sourceFile.fileName), sourceFile)
+    }
+
+    return sourceFilesByPath
+}
+
+function buildReverseDependencyMap(program: ts.Program): Map<string, Set<string>> {
+    const checker = program.getTypeChecker()
+    const reverseDependencies = new Map<string, Set<string>>()
+
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile) {
+            continue
+        }
+
+        const importerPath = path.resolve(sourceFile.fileName)
+
+        ts.forEachChild(sourceFile, function visit(node) {
+            if (ts.isImportDeclaration(node)) {
+                const importedFileName = getFilenameForImportDeclaration(checker, node)
+
+                if (importedFileName) {
+                    const importedPath = path.resolve(importedFileName)
+                    let importers = reverseDependencies.get(importedPath)
+
+                    if (!importers) {
+                        importers = new Set()
+                        reverseDependencies.set(importedPath, importers)
+                    }
+
+                    importers.add(importerPath)
+                }
+            }
+
+            ts.forEachChild(node, visit)
+        })
+    }
+
+    return reverseDependencies
+}
+
+function collectAffectedLogicFiles(
+    startPaths: string[],
+    sourceFilesByPath: Map<string, ts.SourceFile>,
+    reverseDependencies: Map<string, Set<string>>,
+): string[] {
+    const visited = new Set<string>()
+    const queue = startPaths.map((filePath) => path.resolve(filePath))
+    const affectedLogicFiles = new Set<string>()
+
+    while (queue.length > 0) {
+        const currentPath = queue.shift()!
+
+        if (visited.has(currentPath)) {
+            continue
+        }
+
+        visited.add(currentPath)
+
+        const sourceFile = sourceFilesByPath.get(currentPath)
+        if (
+            sourceFile &&
+            !sourceFile.isDeclarationFile &&
+            !isGeneratedTypeFile(currentPath) &&
+            sourceFileMightContainKeaCall(sourceFile)
+        ) {
+            affectedLogicFiles.add(currentPath)
+        }
+
+        if (isGeneratedTypeFile(currentPath)) {
+            queue.push(...sourcePathsForTypeFile(currentPath, sourceFilesByPath))
+        }
+
+        for (const importerPath of reverseDependencies.get(currentPath) ?? []) {
+            queue.push(importerPath)
+        }
+    }
+
+    return [...affectedLogicFiles].sort()
+}
+
+function sourcePathsForTypeFile(typeFilePath: string, sourceFilesByPath: Map<string, ts.SourceFile>): string[] {
+    if (!isGeneratedTypeFile(typeFilePath)) {
+        return []
+    }
+
+    const sourceBasePath = typeFilePath.slice(0, -'Type.ts'.length)
+
+    return SOURCE_EXTENSIONS.map((extension) => `${sourceBasePath}${extension}`).filter((sourcePath) =>
+        sourceFilesByPath.has(path.resolve(sourcePath)),
+    )
+}
+
+function isGeneratedTypeFile(filePath: string): boolean {
+    return filePath.endsWith('Type.ts')
+}
+
+function isSourceLikeFile(filePath: string): boolean {
+    return SOURCE_EXTENSIONS.some((extension) => filePath.endsWith(extension))
+}
+
+function isTypegenModuleFile(filePath: string): boolean {
+    return TYPEGEN_FILE_REGEX.test(filePath.split(path.sep).join('/'))
+}
+
+function sourceFileMightContainKeaCall(sourceFile: ts.SourceFile): boolean {
+    return KEA_CALL_REGEX.test(sourceFile.text)
+}