kea-typegen 3.8.0 → 3.8.1

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

@@ -29,22 +29,44 @@ 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
+
+    const valueSources = new Map<string, string | undefined>()
+    for (const value of [...parsedLogic.reducers, ...parsedLogic.selectors]) {
+        valueSources.set(value.name, value.sourceLogic)
+    }
+
+    addSection(
+        'Values',
+        printValues(parsedLogic).members.map((member) =>
+            withSourceLogicComment(
+                member,
+                member.name && ts.isIdentifier(member.name) ? valueSources.get(member.name.text) : undefined,
+            ),
+        ),
+    )
     addSection(
         'Actions',
-        parsedLogic.actions.map(({ name, parameters, returnTypeNode }) =>
-            factory.createPropertySignature(
-                undefined,
-                factory.createIdentifier(name),
-                undefined,
-                factory.createFunctionTypeNode(undefined, parameters, returnTypeNode),
+        parsedLogic.actions.map(({ name, parameters, returnTypeNode, sourceLogic }) =>
+            withSourceLogicComment(
+                factory.createPropertySignature(
+                    undefined,
+                    factory.createIdentifier(name),
+                    undefined,
+                    factory.createFunctionTypeNode(undefined, parameters, returnTypeNode),
+                ),
+                sourceLogic,
             ),
         ),
     )
@@ -57,15 +79,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 +140,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 +161,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 +274,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) ?? []