kea-typegen 3.7.1 → 3.8.0

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"
     ]
 }