kea-typegen 3.8.0 → 3.8.2

package/src/print/print.ts

@@ -39,7 +39,8 @@ import { writeTypeImports } from '../write/writeTypeImports'
 import { writeInlineLogicTypes } from '../write/writeInlineLogicTypes'
 import { printInternalExtraInput } from './printInternalExtraInput'
 import { convertToBuilders } from '../write/convertToBuilders'
-import { cacheWrittenFile } from '../cache'
+import { cacheWrittenFile, deleteCachedFile } from '../cache'
+import { isInlineFile } from '../utils'
 
 const prettierConfigCache = new Map<string, Promise<prettier.Options | null>>()
 
@@ -78,11 +79,6 @@ export async function printToFiles(
             groupedByFile[parsedLogic.fileName] = []
         }
         groupedByFile[parsedLogic.fileName].push(parsedLogic)
-
-        if (!appOptions.inline) {
-            // create the Nodes and gather referenced types
-            printLogicType(parsedLogic, appOptions)
-        }
     }
 
     // Automatically ignore imports from "node_modules/@types/node", if {types: ["node"]} in tsconfig.json
@@ -120,7 +116,7 @@ export async function printToFiles(
     for (const [fileName, parsedLogics] of Object.entries(groupedByFile)) {
         const typeFileName = parsedLogics[0].typeFileName
 
-        if (appOptions.inline) {
+        if (isInlineFile(appOptions, program.getSourceFile(fileName), parsedLogics)) {
             // write/update MakeLogicType blocks above the logics instead of writing a logicType.ts file
             const inlineResponse = await writeInlineLogicTypes(
                 program,
@@ -137,10 +133,16 @@ export async function printToFiles(
             if (appOptions.delete && fs.existsSync(typeFileName)) {
                 log(`🗑️ Deleting: ${path.relative(process.cwd(), typeFileName)}`)
                 fs.unlinkSync(typeFileName)
+                deleteCachedFile(typeFileName, appOptions)
             }
             continue
         }
 
+        // create the Nodes and gather referenced types
+        for (const parsedLogic of parsedLogics) {
+            printLogicType(parsedLogic, appOptions)
+        }
+
         const logicStrings = []
         const requiredKeys = new Set(['Logic'])
         for (const parsedLogic of parsedLogics) {

package/src/types.ts

@@ -5,11 +5,15 @@ export interface ActionTransform {
     name: string
     parameters: ts.ParameterDeclaration[]
     returnTypeNode: ts.TypeNode
+    /** Name of the logic this action was connected from, e.g. "userLogic" */
+    sourceLogic?: string
 }
 
 export interface NameType {
     name: string
     typeNode: ts.TypeNode | ts.KeywordTypeNode | ts.ParenthesizedTypeNode
+    /** Name of the logic this value was connected from, e.g. "userLogic" */
+    sourceLogic?: string
 }
 
 export interface ReducerTransform extends NameType {}
@@ -18,6 +22,12 @@ export interface SelectorTransform extends NameType {
     functionTypes?: { name: string; type: ts.TypeNode }[]
 }
 
+/** A selector combiner parameter without a type annotation, plus the inferred type to write into the source */
+export interface SelectorParamAnnotation {
+    parameter: ts.ParameterDeclaration
+    typeNode: ts.TypeNode
+}
+
 export interface ListenerTransform {
     name: string
     action: ts.TypeNode | ts.KeywordTypeNode | ts.ParenthesizedTypeNode
@@ -46,6 +56,7 @@ export interface ParsedLogic {
     propsType?: ts.TypeNode
     keyType?: ts.TypeNode
     typeReferencesToImportFromFiles: Record<string, Set<string>>
+    selectorParamAnnotations: SelectorParamAnnotation[]
     interfaceDeclaration?: ts.InterfaceDeclaration
     extraActions: Record<string, ts.TypeNode>
     extraInput: Record<string, { typeNode: ts.TypeNode; withLogicFunction: boolean }>
@@ -80,6 +91,8 @@ export interface AppOptions {
     convertToBuilders?: boolean
     /** Write logic types as MakeLogicType blocks above each kea() call, instead of into logicType.ts files */
     inline?: boolean
+    /** Like `inline`, but only for logic files under these paths. Everything else keeps its logicType.ts file. */
+    inlinePaths?: string[]
     /** Show TypeScript errors */
     showTsErrors?: boolean
     /** Cache generated logic files into .typegen, use them if generating a logic type for the first time */

package/src/utils.ts

@@ -99,6 +99,47 @@ export function isGeneratedInlineBlock(
     return getInlineBlockStatements(declaration, logicName).some(hasKeaTypegenMarker)
 }
 
+/** Find a top-level `type logicType = ...` or `interface logicType {...}` declaration in the file */
+export function findLogicTypeDeclaration(
+    sourceFile: ts.SourceFile,
+    logicTypeName: string,
+): ts.TypeAliasDeclaration | ts.InterfaceDeclaration | undefined {
+    return sourceFile.statements.find(
+        (statement): statement is ts.TypeAliasDeclaration | ts.InterfaceDeclaration =>
+            (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement)) &&
+            statement.name.text === logicTypeName,
+    )
+}
+
+/**
+ * Should this logic file get inline MakeLogicType blocks instead of a logicType.ts file?
+ * True when running with --inline, when the file sits under one of `inlinePaths`, or when the
+ * file already carries a generated inline block (so converted files stay inline, whatever the config).
+ */
+export function isInlineFile(
+    appOptions: AppOptions | undefined,
+    sourceFile: ts.SourceFile | undefined,
+    parsedLogics: ParsedLogic[],
+): boolean {
+    if (appOptions?.inline) {
+        return true
+    }
+    if (!sourceFile) {
+        return false
+    }
+    for (const inlinePath of appOptions?.inlinePaths ?? []) {
+        const resolvedPath = path.resolve(appOptions?.rootPath ?? '.', inlinePath)
+        const resolvedFileName = path.resolve(sourceFile.fileName)
+        if (resolvedFileName === resolvedPath || resolvedFileName.startsWith(resolvedPath + path.sep)) {
+            return true
+        }
+    }
+    return parsedLogics.some((parsedLogic) => {
+        const declaration = findLogicTypeDeclaration(sourceFile, parsedLogic.logicTypeName)
+        return declaration ? isGeneratedInlineBlock(declaration, parsedLogic.logicName) : false
+    })
+}
+
 /**
  * True if the type argument in `kea<...>()` is a manually written type (e.g. `MakeLogicType<...>`
  * or a custom interface), as opposed to a type that kea-typegen generates and keeps updated.
@@ -173,7 +214,8 @@ export function getParameterDeclaration(param: ts.ParameterDeclaration) {
     return factory.createParameterDeclaration(
         undefined,
         undefined,
-        factory.createIdentifier(param.name.getText()),
+        // .getText() throws on synthetic nodes (e.g. from signatureToSignatureDeclaration)
+        factory.createIdentifier(ts.isIdentifier(param.name) ? param.name.text : param.name.getText()),
         param.initializer || param.questionToken ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
         cloneNodeSorted(param.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
         undefined,

package/src/visit/visit.ts

@@ -281,6 +281,7 @@ export function visitKeaCalls(
             hasKeyInLogic: false,
             hasPathInLogic: false,
             typeReferencesToImportFromFiles: {},
+            selectorParamAnnotations: [],
             extraActions: {},
             extraInput: {},
             extraLogicFields: {},

package/src/visit/visitConnect.ts

@@ -1,5 +1,6 @@
 import { ParsedLogic } from '../types'
 import * as ts from 'typescript'
+import { NodeBuilderFlags } from 'typescript'
 import { cloneNodeSorted, gatherImports, getParameterDeclaration } from '../utils'
 import { Expression, Type } from 'typescript'
 
@@ -47,6 +48,7 @@ export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: E
 
                 const symbol = checker.getSymbolAtLocation(logicReference)
                 const otherLogicType = checker.getTypeOfSymbolAtLocation(symbol, logicReference)
+                const sourceLogic = ts.isIdentifier(logicReference) ? logicReference.text : logicReference.getText()
 
                 if (loaderName === 'actions') {
                     const actionsForLogic = otherLogicType
@@ -85,12 +87,59 @@ export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: E
                                                 name: lookup[name],
                                                 returnTypeNode,
                                                 parameters,
+                                                sourceLogic,
                                             })
                                         }
                                     }
                                 }
                             }
                         }
+                    } else if (actionsForLogic) {
+                        // `actionCreators` is not a literal type node we can walk syntactically - e.g. the other
+                        // logic is typed with MakeLogicType, where actionCreators is a mapped type. Resolve the
+                        // connected action types semantically instead.
+                        const actionCreatorsType = checker.getTypeOfSymbolAtLocation(actionsForLogic, logicReference)
+                        for (const actionProperty of actionCreatorsType.getProperties()) {
+                            const name = actionProperty.getName()
+                            if (!lookup[name]) {
+                                continue
+                            }
+                            const actionCreatorType = checker.getTypeOfSymbolAtLocation(actionProperty, logicReference)
+                            const signature = actionCreatorType.getCallSignatures()[0]
+                            if (!signature) {
+                                continue
+                            }
+                            const signatureNode = checker.signatureToSignatureDeclaration(
+                                signature,
+                                ts.SyntaxKind.FunctionType,
+                                logicReference,
+                                NodeBuilderFlags.NoTruncation | NodeBuilderFlags.IgnoreErrors,
+                            ) as ts.FunctionTypeNode | undefined
+                            if (!signatureNode) {
+                                continue
+                            }
+                            const parameters = signatureNode.parameters.map((param) => getParameterDeclaration(param))
+                            let returnType: ts.TypeNode = signatureNode.type
+                            if (ts.isParenthesizedTypeNode(returnType)) {
+                                returnType = returnType.type
+                            }
+                            if (ts.isTypeLiteralNode(returnType)) {
+                                const payload = returnType.members.find(
+                                    (m) => m.name && ts.isIdentifier(m.name) && m.name.text === 'payload',
+                                )
+                                if (payload && ts.isPropertySignature(payload) && payload.type) {
+                                    const returnTypeNode = cloneNodeSorted(payload.type)
+                                    gatherImports(signatureNode, checker, parsedLogic)
+
+                                    parsedLogic.actions.push({
+                                        name: lookup[name],
+                                        returnTypeNode,
+                                        parameters,
+                                        sourceLogic,
+                                    })
+                                }
+                            }
+                        }
                     }
                 }
 
@@ -109,6 +158,7 @@ export function visitConnect(parsedLogic: ParsedLogic, type: Type, expression: E
                                         name: lookup[name],
                                         typeNode,
                                         functionTypes: [],
+                                        sourceLogic,
                                     })
                                 }
                             }

package/src/visit/visitSelectors.ts

@@ -14,8 +14,14 @@ export function visitSelectors(parsedLogic: ParsedLogic, type: Type, expression:
             const inputFunctionTypeNode = checker.getTypeAtLocation(inputFunction)
 
             const selectorInputFunctionType = inputFunctionTypeNode.getCallSignatures()[0]?.getReturnType() as ts.Type
+            // IgnoreErrors: the tuple may mention types not referenceable from the logic file
+            // (e.g. kea's internal Props); we only consume the elements' return types anyway
             const selectorInputTypeNode = selectorInputFunctionType
-                ? checker.typeToTypeNode(selectorInputFunctionType, inputFunction, NodeBuilderFlags.NoTruncation)
+                ? checker.typeToTypeNode(
+                      selectorInputFunctionType,
+                      inputFunction,
+                      NodeBuilderFlags.NoTruncation | NodeBuilderFlags.IgnoreErrors,
+                  )
                 : null
 
             let functionNames = []
@@ -75,6 +81,25 @@ export function visitSelectors(parsedLogic: ParsedLogic, type: Type, expression:
                     typeNode,
                     functionTypes,
                 })
+
+                // combiner parameters without a type annotation, e.g. `(counter) => counter * 2`.
+                // In inline mode these get their inferred types written into the source, since
+                // MakeLogicType's loose selector typing can no longer infer them contextually.
+                computedFunction.parameters.forEach((parameter, index) => {
+                    const functionType = functionTypes[index]
+                    if (
+                        !parameter.type &&
+                        !parameter.dotDotDotToken &&
+                        ts.isIdentifier(parameter.name) &&
+                        functionType &&
+                        functionType.type.kind !== ts.SyntaxKind.AnyKeyword
+                    ) {
+                        parsedLogic.selectorParamAnnotations.push({
+                            parameter,
+                            typeNode: functionType.type,
+                        })
+                    }
+                })
             }
         }
     }

package/src/write/writeInlineLogicTypes.ts

@@ -4,11 +4,10 @@ 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 { cleanDuplicateAnyNodes, 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.'
+export const INLINE_TYPE_MARKER = " Generated by kea-typegen. Update if you're an agent, ignore if you're human."
 
 /**
  * Print a block of interfaces (Values, Actions, and Props when it's a literal), plus an
@@ -29,24 +28,60 @@ export function printInlineLogicType(parsedLogic: ParsedLogic): string {
     const addSection = (suffix: string, members: readonly ts.TypeElement[]) => {
         if (members.length > 0) {
             const name = `${parsedLogic.logicName}${suffix}`
-            statements.push(createExportedInterface(name, members))
+            const declaration = createExportedInterface(name, members)
+            ts.addSyntheticLeadingComment(declaration, SyntaxKind.SingleLineCommentTrivia, INLINE_TYPE_MARKER, true)
+            statements.push(declaration)
             typeArguments.push(factory.createTypeReferenceNode(factory.createIdentifier(name), undefined))
         } else {
             typeArguments.push(factory.createTypeLiteralNode([]))
         }
     }
 
-    addSection('Values', printValues(parsedLogic).members)
+    // mark connected values/actions with the logic they come from, e.g. `user: UserType | null // userLogic`
+    const withSourceLogicComment = <T extends ts.TypeElement>(member: T, sourceLogic: string | undefined): T =>
+        sourceLogic ? ts.addSyntheticTrailingComment(member, SyntaxKind.SingleLineCommentTrivia, ` ${sourceLogic}`, false) : member
+
+    // connected entries first, grouped by source logic (groups alphabetical, entries alphabetical
+    // within each group), then the logic's own entries alphabetically
+    const bySourceLogicThenName = (
+        a: { name: string; sourceLogic?: string },
+        b: { name: string; sourceLogic?: string },
+    ): number => {
+        if (!!a.sourceLogic !== !!b.sourceLogic) {
+            return a.sourceLogic ? -1 : 1
+        }
+        if (a.sourceLogic && b.sourceLogic && a.sourceLogic !== b.sourceLogic) {
+            return a.sourceLogic < b.sourceLogic ? -1 : 1
+        }
+        return a.name === b.name ? 0 : a.name < b.name ? -1 : 1
+    }
+
+    addSection(
+        'Values',
+        [...cleanDuplicateAnyNodes(parsedLogic.reducers.concat(parsedLogic.selectors))]
+            .sort(bySourceLogicThenName)
+            .map(({ name, typeNode, sourceLogic }) =>
+                withSourceLogicComment(
+                    factory.createPropertySignature(undefined, factory.createIdentifier(name), undefined, typeNode),
+                    sourceLogic,
+                ),
+            ),
+    )
     addSection(
         'Actions',
-        parsedLogic.actions.map(({ name, parameters, returnTypeNode }) =>
-            factory.createPropertySignature(
-                undefined,
-                factory.createIdentifier(name),
-                undefined,
-                factory.createFunctionTypeNode(undefined, parameters, returnTypeNode),
+        [...parsedLogic.actions]
+            .sort(bySourceLogicThenName)
+            .map(({ name, parameters, returnTypeNode, sourceLogic }) =>
+                withSourceLogicComment(
+                    factory.createPropertySignature(
+                        undefined,
+                        factory.createIdentifier(name),
+                        undefined,
+                        factory.createFunctionTypeNode(undefined, parameters, returnTypeNode),
+                    ),
+                    sourceLogic,
+                ),
             ),
-        ),
     )
     if (parsedLogic.propsType) {
         if (ts.isTypeLiteralNode(parsedLogic.propsType)) {
@@ -57,15 +92,17 @@ export function printInlineLogicType(parsedLogic: ParsedLogic): string {
         }
     }
 
-    statements.push(
-        factory.createTypeAliasDeclaration(
-            [factory.createModifier(SyntaxKind.ExportKeyword)],
-            factory.createIdentifier(parsedLogic.logicTypeName),
-            undefined,
-            factory.createTypeReferenceNode(factory.createIdentifier('MakeLogicType'), typeArguments),
-        ),
+    const typeAlias = 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)
+    if (statements.length === 0) {
+        // no interfaces at all - the alias itself carries the marker
+        ts.addSyntheticLeadingComment(typeAlias, SyntaxKind.SingleLineCommentTrivia, INLINE_TYPE_MARKER, true)
+    }
+    statements.push(typeAlias)
     return statements.map(nodeToString).join('\n\n')
 }
 
@@ -116,12 +153,14 @@ export async function writeInlineLogicTypes(
             const blockStatements = getInlineBlockStatements(existingDeclaration, parsedLogic.logicName)
             const start = getBlockStart(blockStatements[0], sourceFile)
             const end = existingDeclaration.getEnd()
-            if (rawCode.slice(start, end) !== block) {
+            if (!sameGeneratedCode(rawCode.slice(start, end), block)) {
                 edits.push({ start, end, text: block })
             }
         } else {
             const statement = getTopLevelStatement(parsedLogic.node)
-            const insertPos = statement.getStart(sourceFile)
+            // insert above the statement's leading comments, so they stay attached to the logic
+            const leadingComments = ts.getLeadingCommentRanges(rawCode, statement.pos) ?? []
+            const insertPos = leadingComments.length > 0 ? leadingComments[0].pos : statement.getStart(sourceFile)
             edits.push({ start: insertPos, end: insertPos, text: `${block}\n\n` })
         }
 
@@ -135,6 +174,14 @@ export async function writeInlineLogicTypes(
                 edits.push({ start, end, text })
             }
         }
+
+        // annotate untyped selector combiner parameters, e.g. `(counter) => ...` -> `(counter: number) => ...`.
+        // MakeLogicType types these as `any`, so without an explicit annotation the inferred
+        // value types would degrade to `any` on the next typegen run.
+        for (const { parameter, typeNode } of parsedLogic.selectorParamAnnotations) {
+            const insertPos = (parameter.questionToken ?? parameter.name).getEnd()
+            edits.push({ start: insertPos, end: insertPos, text: `: ${nodeToString(typeNode)}` })
+        }
     }
 
     if (managedLogics.length > 0) {
@@ -240,6 +287,21 @@ export async function writeInlineLogicTypes(
     return { filesToWrite: 1, writtenFiles: 1 }
 }
 
+/**
+ * Compare generated code ignoring formatting, so a formatter (prettier, oxfmt, ...) reflowing the
+ * block - semicolons, trailing commas, quotes, line breaks - does not make us rewrite it forever.
+ */
+function sameGeneratedCode(existingCode: string, generatedCode: string): boolean {
+    const normalize = (code: string): string =>
+        code
+            .replace(/"/g, "'")
+            .replace(/[;,]/g, '')
+            .replace(/\s+/g, '')
+            // leading pipe of a formatter-reflowed union type, e.g. `selection: | number | EditorRange`
+            .replace(/([:(<=[])\|/g, '$1')
+    return normalize(existingCode) === normalize(generatedCode)
+}
+
 /** 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) ?? []