kea-typegen 1.2.1 → 1.4.1

package/src/print/printListeners.ts

@@ -1,47 +1,46 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printListeners(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.listeners.map(({ name, payload, action }) =>
-            ts.createPropertySignature(
+            factory.createPropertySignature(
                 undefined,
-                ts.createStringLiteral(name),
+                factory.createStringLiteral(name),
                 undefined,
-                ts.createArrayTypeNode(
-                    ts.createParenthesizedType(
-                        ts.createFunctionTypeNode(
+                factory.createArrayTypeNode(
+                    factory.createParenthesizedType(
+                        factory.createFunctionTypeNode(
                             undefined,
                             [
-                                ts.createParameter(
+                                factory.createParameterDeclaration(
                                     undefined,
                                     undefined,
                                     undefined,
-                                    ts.createIdentifier('action'),
+                                    factory.createIdentifier('action'),
                                     undefined,
                                     action,
                                     undefined,
                                 ),
-                                ts.createParameter(
+                                factory.createParameterDeclaration(
                                     undefined,
                                     undefined,
                                     undefined,
-                                    ts.createIdentifier('previousState'),
+                                    factory.createIdentifier('previousState'),
                                     undefined,
-                                    ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                                    factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                                     undefined,
                                 ),
                             ],
-                            ts.createUnionTypeNode([
-                                { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true },
-                                ts.createTypeReferenceNode(ts.createIdentifier('Promise'), [
-                                    { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true },
+                            factory.createUnionTypeNode([
+                                { ...factory.createToken(SyntaxKind.VoidKeyword), _typeNodeBrand: true },
+                                factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [
+                                    { ...factory.createToken(SyntaxKind.VoidKeyword), _typeNodeBrand: true },
                                 ]),
                             ]),
                         ),
                     ),
                 ),
-                undefined,
             ),
         ),
     )

package/src/print/printProps.ts

@@ -1,12 +1,12 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printProps(parsedLogic: ParsedLogic) {
-    return parsedLogic.propsType || ts.createTypeReferenceNode(
-        ts.createIdentifier("Record"),
-        [
-            ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
-            ts.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)
-        ]
+    return (
+        parsedLogic.propsType ||
+        factory.createTypeReferenceNode(factory.createIdentifier('Record'), [
+            factory.createKeywordTypeNode(SyntaxKind.StringKeyword),
+            factory.createKeywordTypeNode(SyntaxKind.UnknownKeyword),
+        ])
     )
 }

package/src/print/printReducer.ts

@@ -1,47 +1,46 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printReducer(parsedLogic: ParsedLogic) {
-    return ts.createFunctionTypeNode(
+    return factory.createFunctionTypeNode(
         undefined,
         [
-            ts.createParameter(
+            factory.createParameterDeclaration(
                 undefined,
                 undefined,
                 undefined,
-                ts.createIdentifier('state'),
+                factory.createIdentifier('state'),
                 undefined,
-                ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                 undefined,
             ),
-            ts.createParameter(
+            factory.createParameterDeclaration(
                 undefined,
                 undefined,
                 undefined,
-                ts.createIdentifier('action'),
+                factory.createIdentifier('action'),
                 undefined,
-                ts.createFunctionTypeNode(undefined, [], ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)),
+                factory.createFunctionTypeNode(undefined, [], factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
                 undefined,
             ),
-            ts.createParameter(
+            factory.createParameterDeclaration(
                 undefined,
                 undefined,
                 undefined,
-                ts.createIdentifier('fullState'),
+                factory.createIdentifier('fullState'),
                 undefined,
-                ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                 undefined,
             ),
         ],
-        ts.createTypeLiteralNode(
+        factory.createTypeLiteralNode(
             cleanDuplicateAnyNodes(parsedLogic.reducers).map((reducer) =>
-                ts.createPropertySignature(
+                factory.createPropertySignature(
                     undefined,
-                    ts.createIdentifier(reducer.name),
+                    factory.createIdentifier(reducer.name),
                     undefined,
                     reducer.typeNode,
-                    undefined,
                 ),
             ),
         ),

package/src/print/printReducerOptions.ts

@@ -1,19 +1,18 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { ParsedLogic, ReducerTransform } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printReducerOptions(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers)
             .filter((r: ReducerTransform) => r.reducerOptions)
             .map((reducer: ReducerTransform) => {
                 if (reducer.reducerOptions) {
-                    return ts.createPropertySignature(
+                    return factory.createPropertySignature(
                         undefined,
-                        ts.createIdentifier(reducer.name),
+                        factory.createIdentifier(reducer.name),
                         undefined,
                         reducer.reducerOptions,
-                        undefined,
                     )
                 }
             })

package/src/print/printReducers.ts

@@ -1,48 +1,47 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printReducers(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers).map((reducer) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(reducer.name),
+                factory.createIdentifier(reducer.name),
                 undefined,
-                ts.createFunctionTypeNode(
+                factory.createFunctionTypeNode(
                     undefined,
                     [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('state'),
+                            factory.createIdentifier('state'),
                             undefined,
                             reducer.typeNode,
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('action'),
+                            factory.createIdentifier('action'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('fullState'),
+                            factory.createIdentifier('fullState'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
                     ],
                     reducer.typeNode,
                 ),
-                undefined,
             )
         }),
     )

package/src/print/printSelector.ts

@@ -1,29 +1,28 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printSelector(parsedLogic: ParsedLogic) {
-    return ts.createFunctionTypeNode(
+    return factory.createFunctionTypeNode(
         undefined,
         [
-            ts.createParameter(
+            factory.createParameterDeclaration(
                 undefined,
                 undefined,
                 undefined,
-                ts.createIdentifier('state'),
+                factory.createIdentifier('state'),
                 undefined,
-                ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                 undefined,
             ),
         ],
-        ts.createTypeLiteralNode(
+        factory.createTypeLiteralNode(
             cleanDuplicateAnyNodes(parsedLogic.reducers).map((reducer) =>
-                ts.createPropertySignature(
+                factory.createPropertySignature(
                     undefined,
-                    ts.createIdentifier(reducer.name),
+                    factory.createIdentifier(reducer.name),
                     undefined,
                     reducer.typeNode,
-                    undefined,
                 ),
             ),
         ),

package/src/print/printSelectors.ts

@@ -1,39 +1,38 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printSelectors(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers.concat(parsedLogic.selectors)).map((reducer) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(reducer.name),
+                factory.createIdentifier(reducer.name),
                 undefined,
-                ts.createFunctionTypeNode(
+                factory.createFunctionTypeNode(
                     undefined,
                     [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('state'),
+                            factory.createIdentifier('state'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('props'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createIdentifier('props'),
+                            factory.createToken(SyntaxKind.QuestionToken),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
                     ],
                     reducer.typeNode,
                 ),
-                undefined,
             )
         }),
     )

package/src/print/printSharedListeners.ts

@@ -1,61 +1,60 @@
-import * as ts from 'typescript'
+import { factory, SyntaxKind } from 'typescript'
 import { ParsedLogic } from '../types'
 
 export function printSharedListeners(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         parsedLogic.sharedListeners.map(({ name, payload, action }) =>
-            ts.createPropertySignature(
+            factory.createPropertySignature(
                 undefined,
-                ts.createStringLiteral(name),
+                factory.createStringLiteral(name),
                 undefined,
-                ts.createFunctionTypeNode(
+                factory.createFunctionTypeNode(
                     undefined,
                     [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('payload'),
+                            factory.createIdentifier('payload'),
                             undefined,
-                            payload || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            payload || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('breakpoint'),
+                            factory.createIdentifier('breakpoint'),
                             undefined,
-                            ts.createTypeReferenceNode(ts.createIdentifier('BreakPointFunction'), undefined),
+                            factory.createTypeReferenceNode(factory.createIdentifier('BreakPointFunction'), undefined),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('action'),
+                            factory.createIdentifier('action'),
                             undefined,
                             action,
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('previousState'),
+                            factory.createIdentifier('previousState'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
                     ],
-                    ts.createUnionTypeNode([
-                        { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true },
-                        ts.createTypeReferenceNode(ts.createIdentifier('Promise'), [
-                            { ...ts.createToken(ts.SyntaxKind.VoidKeyword), _typeNodeBrand: true },
+                    factory.createUnionTypeNode([
+                        { ...factory.createToken(SyntaxKind.VoidKeyword), _typeNodeBrand: true },
+                        factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [
+                            { ...factory.createToken(SyntaxKind.VoidKeyword), _typeNodeBrand: true },
                         ]),
                     ]),
                 ),
-                undefined,
             ),
         ),
     )

package/src/print/printValues.ts

@@ -1,16 +1,15 @@
-import * as ts from 'typescript'
+import { factory } from 'typescript'
 import { ParsedLogic } from '../types'
-import {cleanDuplicateAnyNodes} from "../utils";
+import { cleanDuplicateAnyNodes } from '../utils'
 
 export function printValues(parsedLogic: ParsedLogic) {
-    return ts.createTypeLiteralNode(
+    return factory.createTypeLiteralNode(
         cleanDuplicateAnyNodes(parsedLogic.reducers.concat(parsedLogic.selectors)).map((reducer) => {
-            return ts.createPropertySignature(
+            return factory.createPropertySignature(
                 undefined,
-                ts.createIdentifier(reducer.name),
+                factory.createIdentifier(reducer.name),
                 undefined,
                 reducer.typeNode,
-                undefined,
             )
         }),
     )

package/src/typegen.ts

@@ -105,7 +105,7 @@ export function runTypeGen(appOptions: AppOptions) {
     function goThroughAllTheFiles(
         program,
         appOptions,
-    ): { filesToWrite: number; writtenFiles: number; importsToModify: number } {
+    ): { filesToWrite: number; writtenFiles: number; filesToModify: number } {
         const parsedLogics = visitProgram(program, appOptions)
         if (appOptions.verbose) {
             log(`🗒️ ${parsedLogics.length} logic${parsedLogics.length === 1 ? '' : 's'} found!`)
@@ -115,7 +115,7 @@ export function runTypeGen(appOptions: AppOptions) {
 
         // running "kea-typegen check" and would write files?
         // exit with 1
-        if (!appOptions.write && !appOptions.watch && (response.filesToWrite > 0 || response.importsToModify > 0)) {
+        if (!appOptions.write && !appOptions.watch && (response.filesToWrite > 0 || response.filesToModify > 0)) {
             process.exit(1)
         }
 
@@ -126,9 +126,9 @@ export function runTypeGen(appOptions: AppOptions) {
         if (appOptions.write) {
             let round = 0
             while ((round += 1)) {
-                const { writtenFiles, importsToModify } = goThroughAllTheFiles(program, appOptions)
+                const { writtenFiles, filesToModify } = goThroughAllTheFiles(program, appOptions)
 
-                if (writtenFiles === 0 && importsToModify === 0) {
+                if (writtenFiles === 0 && filesToModify === 0) {
                     log(`👋 Finished writing files! Exiting.`)
                     process.exit(0)
                 }

package/src/types.ts

@@ -35,6 +35,8 @@ export interface ParsedLogic {
     logicTypeImported: boolean
     path: string[]
     pathString: string
+    hasPathInLogic: boolean
+    hasKeyInLogic: boolean
     logicTypeArguments: string[]
     constants: string[]
     events: Record<string, boolean>
@@ -50,11 +52,12 @@ export interface ParsedLogic {
     typeReferencesToImportFromFiles: Record<string, Set<string>>
     typeReferencesInLogicInput: Set<string>
     interfaceDeclaration?: ts.InterfaceDeclaration
-    extraInput: Record<string, { typeNode: ts.TypeNode, withLogicFunction: boolean }>
+    extraInput: Record<string, { typeNode: ts.TypeNode; withLogicFunction: boolean }>
 }
 
 export interface AppOptions {
     tsConfigPath?: string
+    packageJsonPath?: string
     sourceFilePath?: string
     rootPath?: string
     typesPath?: string
@@ -62,7 +65,14 @@ export interface AppOptions {
     watch?: boolean
     quiet?: boolean
     verbose?: boolean
+    /** Do not write imports inside logic.ts files */
     noImport?: boolean
+    /** Add import statements in logicType.ts files for global types (e.g. @types/node) */
+    importGlobalTypes?: boolean
+    /** List of paths we will never import from inside logicType.ts files */
+    ignoreImportPaths?: string[]
+    /** Write paths inside logic.ts files */
+    writePaths?: boolean
 
     log: (message: string) => void
 }

package/src/utils.ts

@@ -4,7 +4,7 @@ import { cloneNode } from '@wessberg/ts-clone-node'
 import { visitProgram } from './visit/visit'
 import { parsedLogicToTypeString } from './print/print'
 import { AppOptions, NameType, ParsedLogic } from './types'
-import { NodeBuilderFlags } from 'typescript'
+import { factory, NodeBuilderFlags, SyntaxKind } from 'typescript'
 
 export function logicSourceToLogicType(logicSource: string, appOptions?: AppOptions) {
     const program = programFromSource(logicSource)
@@ -54,19 +54,19 @@ export function getTypeNodeForNode(node: ts.Node, checker: ts.TypeChecker): ts.T
             if (ts.isParenthesizedTypeNode(typeNode)) {
                 typeNode = typeNode.type
             }
-        } else if (node?.kind === ts.SyntaxKind.TrueKeyword || node?.kind === ts.SyntaxKind.FalseKeyword) {
-            typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)
+        } else if (node?.kind === SyntaxKind.TrueKeyword || node?.kind === SyntaxKind.FalseKeyword) {
+            typeNode = factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword)
         } else if (ts.isStringLiteralLike(node)) {
-            typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+            typeNode = factory.createKeywordTypeNode(SyntaxKind.StringKeyword)
         } else if (ts.isNumericLiteral(node)) {
-            typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+            typeNode = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword)
         } else if (ts.isArrayLiteralExpression(node) && node.elements.length === 0) {
-            typeNode = ts.createArrayTypeNode(ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword))
+            typeNode = factory.createArrayTypeNode(factory.createKeywordTypeNode(SyntaxKind.AnyKeyword))
         } else {
             typeNode = checker.typeToTypeNode(checker.getTypeAtLocation(node), undefined, undefined)
         }
     } else {
-        typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+        typeNode = factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)
     }
     return typeNode
 }
@@ -82,13 +82,13 @@ export function getAndGatherTypeNodeForDefaultValue(
 }
 
 export function getParameterDeclaration(param: ts.ParameterDeclaration) {
-    return ts.createParameter(
+    return factory.createParameterDeclaration(
         undefined,
         undefined,
         undefined,
-        ts.createIdentifier(param.name.getText()),
-        param.initializer || param.questionToken ? ts.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-        cloneNode(param.type || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)),
+        factory.createIdentifier(param.name.getText()),
+        param.initializer || param.questionToken ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
+        cloneNode(param.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)),
         undefined,
     )
 }
@@ -216,7 +216,7 @@ export function getLogicPathString(appOptions: AppOptions, fileName: string) {
 }
 
 export function getFilenamesForSymbol(symbol: ts.Symbol): string[] | undefined {
-    return symbol?.declarations
+    return (symbol?.declarations || [])
         .map((d) => d.getSourceFile().fileName)
         .filter((str) => !str.includes('/node_modules/typescript/lib/lib'))
 }
@@ -230,7 +230,7 @@ export function gatherImports(input: ts.Node, checker: ts.TypeChecker, parsedLog
         let node = requestedNode
         if (ts.isTypeReferenceNode(node)) {
             let typeRootName: string | undefined
-            if (node.typeName?.kind === ts.SyntaxKind.FirstNode) {
+            if (node.typeName?.kind === SyntaxKind.FirstNode) {
                 try {
                     typeRootName = node.typeName.getFirstToken().getText()
                 } catch (e) {
@@ -254,9 +254,9 @@ export function storeExtractedSymbol(
     parsedLogic: ParsedLogic,
     typeRootName?: string,
 ) {
-    const declaration = symbol.getDeclarations()[0]
+    const declaration = symbol.getDeclarations()?.[0]
 
-    if (ts.isImportSpecifier(declaration)) {
+    if (declaration && ts.isImportSpecifier(declaration)) {
         const importFilename = getFilenameForImportSpecifier(declaration, checker)
         if (importFilename) {
             addTypeImport(parsedLogic, importFilename, typeRootName || declaration.getText())
@@ -334,8 +334,8 @@ export function isAnyUnknown(node?: ts.Node): boolean {
     const unPromised = unPromisify(node)
     return (
         !unPromised ||
-        unPromised.kind === ts.SyntaxKind.AnyKeyword ||
-        unPromised.kind === ts.SyntaxKind.UnknownKeyword ||
+        unPromised.kind === SyntaxKind.AnyKeyword ||
+        unPromised.kind === SyntaxKind.UnknownKeyword ||
         (ts.isTypeLiteralNode(unPromised) && unPromised.members.length === 0)
     )
 }

package/src/visit/visit.ts

@@ -179,9 +179,9 @@ export function visitKeaCalls(
             // only if symbol resolves we mark the logic type as imported
             const symbol = checker.getSymbolAtLocation(keaTypeArgument.typeName)
             if (symbol) {
-                const declaration = symbol.getDeclarations()[0]
+                const declaration = symbol.getDeclarations()?.[0]
 
-                if (ts.isImportSpecifier(declaration)) {
+                if (declaration && ts.isImportSpecifier(declaration)) {
                     const filename = getFilenameForImportSpecifier(declaration, checker)
                     logicTypeImported = filename === typeFileName
                 }
@@ -214,9 +214,11 @@ export function visitKeaCalls(
             propsType: undefined,
             path: pathString.split('.'),
             pathString: pathString,
+            hasKeyInLogic: false,
+            hasPathInLogic: false,
             typeReferencesToImportFromFiles: {},
             typeReferencesInLogicInput: new Set(),
-            extraInput: {}
+            extraInput: {},
         }
 
         const input = (node.parent as ts.CallExpression).arguments[0] as ts.ObjectLiteralExpression
@@ -232,6 +234,12 @@ export function visitKeaCalls(
             }
 
             const name = symbol.getName()
+            if (name === 'path') {
+                parsedLogic.hasPathInLogic = true
+            }
+            if (name === 'key') {
+                parsedLogic.hasKeyInLogic = true
+            }
 
             let type = checker.getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration)
             let typeNode = type ? checker.typeToTypeNode(type, undefined, undefined) : null