kea-typegen 3.7.0 → 3.8.0

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)
+}

package/src/write/writeInlineLogicTypes.ts

@@ -0,0 +1,305 @@
+import * as ts from 'typescript'
+import * as fs from 'fs'
+import * as osPath from 'path'
+import { factory, SyntaxKind } from 'typescript'
+import { AppOptions, ParsedLogic } from '../types'
+import { buildTypeImportEntries, nodeToString, runThroughPrettier } from '../print/print'
+import { printValues } from '../print/printValues'
+import { getInlineBlockStatements, isGeneratedInlineBlock } from '../utils'
+import { applyTextEdits, getImportInsertPosition, getTypeArgumentInsertEnd, TextEdit } from './writeTypeImports'
+
+export const INLINE_TYPE_MARKER = ' Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.'
+
+/**
+ * Print a block of interfaces (Values, Actions, and Props when it's a literal), plus an
+ * `export type logicType = MakeLogicType<logicValues, logicActions, logicProps>` alias tying them together.
+ */
+export function printInlineLogicType(parsedLogic: ParsedLogic): string {
+    const statements: ts.Statement[] = []
+    const typeArguments: ts.TypeNode[] = []
+
+    const createExportedInterface = (name: string, members: readonly ts.TypeElement[]) =>
+        factory.createInterfaceDeclaration(
+            [factory.createModifier(SyntaxKind.ExportKeyword)],
+            factory.createIdentifier(name),
+            undefined,
+            undefined,
+            members,
+        )
+    const addSection = (suffix: string, members: readonly ts.TypeElement[]) => {
+        if (members.length > 0) {
+            const name = `${parsedLogic.logicName}${suffix}`
+            statements.push(createExportedInterface(name, members))
+            typeArguments.push(factory.createTypeReferenceNode(factory.createIdentifier(name), undefined))
+        } else {
+            typeArguments.push(factory.createTypeLiteralNode([]))
+        }
+    }
+
+    addSection('Values', printValues(parsedLogic).members)
+    addSection(
+        'Actions',
+        parsedLogic.actions.map(({ name, parameters, returnTypeNode }) =>
+            factory.createPropertySignature(
+                undefined,
+                factory.createIdentifier(name),
+                undefined,
+                factory.createFunctionTypeNode(undefined, parameters, returnTypeNode),
+            ),
+        ),
+    )
+    if (parsedLogic.propsType) {
+        if (ts.isTypeLiteralNode(parsedLogic.propsType)) {
+            addSection('Props', parsedLogic.propsType.members)
+        } else {
+            // props are already a named type (e.g. `props: {} as MyProps`) - reference it directly
+            typeArguments.push(parsedLogic.propsType)
+        }
+    }
+
+    statements.push(
+        factory.createTypeAliasDeclaration(
+            [factory.createModifier(SyntaxKind.ExportKeyword)],
+            factory.createIdentifier(parsedLogic.logicTypeName),
+            undefined,
+            factory.createTypeReferenceNode(factory.createIdentifier('MakeLogicType'), typeArguments),
+        ),
+    )
+    ts.addSyntheticLeadingComment(statements[0], SyntaxKind.SingleLineCommentTrivia, INLINE_TYPE_MARKER, true)
+    return statements.map(nodeToString).join('\n\n')
+}
+
+/**
+ * Write/update generated MakeLogicType blocks above every logic in the file,
+ * instead of writing a separate logicType.ts file.
+ */
+export async function writeInlineLogicTypes(
+    program: ts.Program,
+    appOptions: AppOptions,
+    filename: string,
+    parsedLogics: ParsedLogic[],
+    nodeModulesPath: string,
+    shouldIgnore: (absolutePath: string) => boolean,
+): Promise<{ filesToWrite: number; writtenFiles: number }> {
+    const { log } = appOptions
+    const unchanged = { filesToWrite: 0, writtenFiles: 0 }
+
+    if (!filename.match(/\.tsx?$/)) {
+        return unchanged
+    }
+    const sourceFile = program.getSourceFile(filename)
+    if (!sourceFile) {
+        throw new Error(`Could not find source file: ${filename}`)
+    }
+    const rawCode = sourceFile.text
+    const edits: TextEdit[] = []
+    const managedLogics: ParsedLogic[] = []
+
+    for (const parsedLogic of parsedLogics) {
+        const existingDeclaration = sourceFile.statements.find(
+            (statement): statement is ts.TypeAliasDeclaration | ts.InterfaceDeclaration =>
+                (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) &&
+                statement.name.text === parsedLogic.logicTypeName,
+        )
+        if (existingDeclaration && !isGeneratedInlineBlock(existingDeclaration, parsedLogic.logicName)) {
+            // a manually written type with the same name - leave the logic alone
+            continue
+        }
+        managedLogics.push(parsedLogic)
+
+        const printedBlock = printInlineLogicType(parsedLogic)
+        const block = (
+            appOptions.prettier === false ? printedBlock : await runThroughPrettier(printedBlock, filename)
+        ).trimEnd()
+
+        if (existingDeclaration) {
+            const blockStatements = getInlineBlockStatements(existingDeclaration, parsedLogic.logicName)
+            const start = getBlockStart(blockStatements[0], sourceFile)
+            const end = existingDeclaration.getEnd()
+            if (rawCode.slice(start, end) !== block) {
+                edits.push({ start, end, text: block })
+            }
+        } else {
+            const statement = getTopLevelStatement(parsedLogic.node)
+            const insertPos = statement.getStart(sourceFile)
+            edits.push({ start: insertPos, end: insertPos, text: `${block}\n\n` })
+        }
+
+        // make sure the kea call is typed with the local logic type: kea<logicType>(...)
+        const callExpression = parsedLogic.node.parent
+        if (ts.isCallExpression(callExpression)) {
+            const start = callExpression.expression.getEnd()
+            const end = callExpression.typeArguments ? getTypeArgumentInsertEnd(callExpression, sourceFile) : start
+            const text = `<${parsedLogic.logicTypeName}>`
+            if (rawCode.slice(start, end) !== text) {
+                edits.push({ start, end, text })
+            }
+        }
+    }
+
+    if (managedLogics.length > 0) {
+        const importDeclarations = sourceFile.statements.filter(ts.isImportDeclaration)
+        const newImportLines: string[] = []
+
+        // make sure MakeLogicType is imported from kea
+        if (!importsMakeLogicType(importDeclarations)) {
+            const keaNamedImport = importDeclarations.find(
+                (declaration) =>
+                    ts.isStringLiteralLike(declaration.moduleSpecifier) &&
+                    declaration.moduleSpecifier.text === 'kea' &&
+                    declaration.importClause?.namedBindings &&
+                    ts.isNamedImports(declaration.importClause.namedBindings) &&
+                    declaration.importClause.namedBindings.elements.length > 0,
+            )
+            if (keaNamedImport) {
+                const firstElement = (keaNamedImport.importClause.namedBindings as ts.NamedImports).elements[0]
+                const pos = firstElement.getStart(sourceFile)
+                edits.push({ start: pos, end: pos, text: 'MakeLogicType, ' })
+            } else {
+                newImportLines.push(`import type { MakeLogicType } from 'kea'`)
+            }
+        }
+
+        // remove the now obsolete `import type { logicType } from './logicType'`, if any
+        const typeFileNameBase = parsedLogics[0].typeFileName.replace(/\.[tj]sx?$/, '')
+        for (const declaration of importDeclarations) {
+            if (!ts.isStringLiteralLike(declaration.moduleSpecifier)) {
+                continue
+            }
+            const specifier = declaration.moduleSpecifier.text
+            if (!specifier.startsWith('.')) {
+                continue
+            }
+            if (osPath.resolve(osPath.dirname(filename), specifier) === typeFileNameBase) {
+                const start = declaration.getStart(sourceFile)
+                let end = declaration.getEnd()
+                if (rawCode[end] === '\n') {
+                    end += 1
+                }
+                edits.push({ start, end, text: '' })
+            }
+        }
+
+        // import referenced types that are not yet available in this file
+        const knownNames = collectKnownTypeNames(sourceFile)
+        for (const parsedLogic of parsedLogics) {
+            knownNames.add(parsedLogic.logicTypeName)
+        }
+
+        const mergedTypeReferences: Record<string, Set<string>> = {}
+        for (const parsedLogic of managedLogics) {
+            for (const [file, names] of Object.entries(parsedLogic.typeReferencesToImportFromFiles)) {
+                mergedTypeReferences[file] = mergedTypeReferences[file] ?? new Set()
+                for (const name of names) {
+                    mergedTypeReferences[file].add(name)
+                }
+            }
+        }
+
+        for (const entry of buildTypeImportEntries(mergedTypeReferences, filename, nodeModulesPath, shouldIgnore)) {
+            const absolutePath = entry.fullPath.startsWith('.')
+                ? osPath.resolve(osPath.dirname(filename), entry.fullPath)
+                : entry.fullPath
+            if (absolutePath === filename || absolutePath === parsedLogics[0].typeFileName) {
+                // types declared in this very file, or in the logicType.ts file we're replacing
+                continue
+            }
+            const missing = entry.list.filter((name) => !knownNames.has(name))
+            missing.forEach((name) => knownNames.add(name))
+            if (missing.length > 0) {
+                newImportLines.push(`import type { ${missing.join(', ')} } from '${entry.finalPath}'`)
+            }
+        }
+
+        if (newImportLines.length > 0) {
+            const insertPos = getImportInsertPosition(sourceFile, rawCode)
+            const text =
+                importDeclarations.length > 0
+                    ? `\n${newImportLines.join('\n')}${rawCode.slice(insertPos, insertPos + 1) === '\n' ? '' : '\n'}`
+                    : `${newImportLines.join('\n')}\n`
+            edits.push({ start: insertPos, end: insertPos, text })
+        }
+    }
+
+    if (edits.length === 0) {
+        if (appOptions.verbose) {
+            log(`🤷 Unchanged: ${osPath.relative(process.cwd(), filename)}`)
+        }
+        return unchanged
+    }
+
+    if (!appOptions.write) {
+        log(`❌ Will not write inline logic types: ${osPath.relative(process.cwd(), filename)}`)
+        return { filesToWrite: 1, writtenFiles: 0 }
+    }
+
+    const editedCode = applyTextEdits(rawCode, edits)
+    const newText = appOptions.prettier === false ? editedCode : await runThroughPrettier(editedCode, filename)
+    fs.writeFileSync(filename, newText)
+    log(`🔥 Writing inline logic types: ${osPath.relative(process.cwd(), filename)}`)
+    return { filesToWrite: 1, writtenFiles: 1 }
+}
+
+/** Start of the generated block: the kea-typegen marker comment if present, otherwise the declaration itself */
+function getBlockStart(declaration: ts.Statement, sourceFile: ts.SourceFile): number {
+    const ranges = ts.getLeadingCommentRanges(sourceFile.text, declaration.pos) ?? []
+    const marker = ranges.find(({ pos, end }) => sourceFile.text.slice(pos, end).includes('kea-typegen'))
+    return marker ? marker.pos : declaration.getStart(sourceFile)
+}
+
+function getTopLevelStatement(node: ts.Node): ts.Node {
+    let statement = node
+    while (statement.parent && !ts.isSourceFile(statement.parent)) {
+        statement = statement.parent
+    }
+    return statement
+}
+
+function importsMakeLogicType(importDeclarations: ts.ImportDeclaration[]): boolean {
+    return importDeclarations.some(
+        (declaration) =>
+            ts.isStringLiteralLike(declaration.moduleSpecifier) &&
+            declaration.moduleSpecifier.text === 'kea' &&
+            declaration.importClause?.namedBindings &&
+            ts.isNamedImports(declaration.importClause.namedBindings) &&
+            declaration.importClause.namedBindings.elements.some(
+                (element) => element.name.text === 'MakeLogicType' && !element.propertyName,
+            ),
+    )
+}
+
+/** All type-ish names already bound at the top level of the file */
+function collectKnownTypeNames(sourceFile: ts.SourceFile): Set<string> {
+    const names = new Set<string>()
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement) && statement.importClause) {
+            if (statement.importClause.name) {
+                names.add(statement.importClause.name.text)
+            }
+            const namedBindings = statement.importClause.namedBindings
+            if (namedBindings) {
+                if (ts.isNamedImports(namedBindings)) {
+                    namedBindings.elements.forEach((element) => names.add(element.name.text))
+                } else {
+                    names.add(namedBindings.name.text)
+                }
+            }
+        } else if (
+            (ts.isTypeAliasDeclaration(statement) ||
+                ts.isInterfaceDeclaration(statement) ||
+                ts.isClassDeclaration(statement) ||
+                ts.isEnumDeclaration(statement) ||
+                ts.isFunctionDeclaration(statement)) &&
+            statement.name
+        ) {
+            names.add(statement.name.text)
+        } else if (ts.isVariableStatement(statement)) {
+            for (const declaration of statement.declarationList.declarations) {
+                if (ts.isIdentifier(declaration.name)) {
+                    names.add(declaration.name.text)
+                }
+            }
+        }
+    }
+    return names
+}

package/src/write/writeTypeImports.ts

@@ -3,13 +3,13 @@ import * as ts from 'typescript'
 import * as osPath from 'path'
 import { runThroughPrettier } from '../print/print'
 import * as fs from 'fs'
-interface TextEdit {
+export interface TextEdit {
     start: number
     end: number
     text: string
 }
 
-function applyTextEdits(source: string, edits: TextEdit[]): string {
+export 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)
@@ -19,7 +19,7 @@ function getImportPath(importDeclaration: ts.ImportDeclaration): string | null {
     return ts.isStringLiteralLike(importDeclaration.moduleSpecifier) ? importDeclaration.moduleSpecifier.text : null
 }
 
-function getImportInsertPosition(sourceFile: ts.SourceFile, rawCode: string): number {
+export 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()
@@ -29,7 +29,7 @@ function getImportInsertPosition(sourceFile: ts.SourceFile, rawCode: string): nu
     return shebangMatch ? shebangMatch[0].length : 0
 }
 
-function getTypeArgumentInsertEnd(callExpression: ts.CallExpression, sourceFile: ts.SourceFile): number {
+export function getTypeArgumentInsertEnd(callExpression: ts.CallExpression, sourceFile: ts.SourceFile): number {
     const openParenToken = callExpression
         .getChildren(sourceFile)
         .find((child) => child.kind === ts.SyntaxKind.OpenParenToken)

package/tsconfig.json

@@ -17,6 +17,7 @@
         "node_modules",
         "dist",
         "samples",
+        "samples-inline",
         "form-plugin"
     ]
 }