kea-typegen 1.2.1 → 1.4.1

package/src/visit/visitActions.ts

@@ -1,10 +1,10 @@
 import { ParsedLogic } from '../types'
-import * as ts from 'typescript'
+import { factory, isFunctionLike, isPropertyAssignment, PropertyAssignment, SyntaxKind, Type } from 'typescript'
 import { NodeBuilderFlags } from 'typescript'
 import { cloneNode } from '@wessberg/ts-clone-node'
 import { gatherImports } from '../utils'
 
-export function visitActions(type: ts.Type, inputProperty: ts.PropertyAssignment, parsedLogic: ParsedLogic) {
+export function visitActions(type: Type, inputProperty: PropertyAssignment, parsedLogic: ParsedLogic) {
     const { checker } = parsedLogic
     const properties = checker.getPropertiesOfType(type)
 
@@ -15,24 +15,26 @@ export function visitActions(type: ts.Type, inputProperty: ts.PropertyAssignment
         let returnTypeNode
         let parameters
 
-        if (!ts.isPropertyAssignment(property.valueDeclaration)) {
+        if (!isPropertyAssignment(property.valueDeclaration)) {
             continue
         }
         const { initializer } = property.valueDeclaration
 
-        if (ts.isFunctionLike(initializer)) {
+        if (isFunctionLike(initializer)) {
             // action is a function action: () => ({ ... })
             parameters = initializer.parameters.map((param) => {
                 if (param.type) {
                     gatherImports(param.type, checker, parsedLogic)
                 }
-                return ts.createParameter(
+                return factory.createParameterDeclaration(
                     undefined,
                     undefined,
                     undefined,
-                    ts.createIdentifier(param.name.getText()),
-                    param.initializer || param.questionToken ? ts.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-                    param.type ? cloneNode(param.type) : ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                    factory.createIdentifier(param.name.getText()),
+                    param.initializer || param.questionToken
+                        ? factory.createToken(SyntaxKind.QuestionToken)
+                        : undefined,
+                    param.type ? cloneNode(param.type) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                     undefined,
                 )
             })
@@ -58,8 +60,8 @@ export function visitActions(type: ts.Type, inputProperty: ts.PropertyAssignment
             // action is a value (action: true)
             const typeNode = checker.typeToTypeNode(type, undefined, undefined)
             gatherImports(typeNode, checker, parsedLogic)
-            returnTypeNode = ts.createTypeLiteralNode([
-                ts.createPropertySignature(undefined, ts.createIdentifier('value'), undefined, typeNode, undefined),
+            returnTypeNode = factory.createTypeLiteralNode([
+                factory.createPropertySignature(undefined, factory.createIdentifier('value'), undefined, typeNode),
             ])
         }
         parsedLogic.actions.push({ name, parameters, returnTypeNode })

package/src/visit/visitListeners.ts

@@ -47,20 +47,20 @@ export function visitListeners(type: ts.Type, inputProperty: ts.PropertyAssignme
                 parsedLogic.listeners.push({
                     name: action.name,
                     payload: action.returnTypeNode,
-                    action: ts.createTypeLiteralNode([
-                        ts.createPropertySignature(
+                    action: ts.factory.createTypeLiteralNode([
+                        ts.factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier('type'),
-                            undefined,
-                            ts.createLiteralTypeNode(ts.createStringLiteral(getActionType(action.name))),
+                            ts.factory.createIdentifier('type'),
                             undefined,
+                            ts.factory.createLiteralTypeNode(
+                                ts.factory.createStringLiteral(getActionType(action.name)),
+                            ),
                         ),
-                        ts.createPropertySignature(
+                        ts.factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier('payload'),
+                            ts.factory.createIdentifier('payload'),
                             undefined,
                             action.returnTypeNode,
-                            undefined,
                         ),
                     ]),
                 })

package/src/visit/visitLoaders.ts

@@ -1,5 +1,15 @@
 import { ParsedLogic } from '../types'
-import * as ts from 'typescript'
+import {
+    factory,
+    isArrayLiteralExpression,
+    isFunctionLike,
+    isObjectLiteralExpression,
+    isTypeReferenceNode,
+    PropertyAssignment,
+    SyntaxKind,
+    Type,
+    TypeNode,
+} from 'typescript'
 import {
     gatherImports,
     getParameterDeclaration,
@@ -9,22 +19,22 @@ import {
 } from '../utils'
 import { NodeBuilderFlags } from 'typescript'
 
-export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment, parsedLogic: ParsedLogic) {
+export function visitLoaders(type: Type, inputProperty: PropertyAssignment, parsedLogic: ParsedLogic) {
     const { checker } = parsedLogic
 
     for (const property of type.getProperties()) {
         const loaderName = property.getName()
-        const value = (property.valueDeclaration as ts.PropertyAssignment).initializer
+        const value = (property.valueDeclaration as PropertyAssignment).initializer
 
         let defaultValue
         let objectLiteral
-        if (ts.isArrayLiteralExpression(value)) {
+        if (isArrayLiteralExpression(value)) {
             defaultValue = value.elements[0]
             objectLiteral = value.elements[1]
-        } else if (ts.isObjectLiteralExpression(value)) {
+        } else if (isObjectLiteralExpression(value)) {
             defaultValue = (value.properties.find(
                 (property) => checker.getSymbolAtLocation(property.name)?.getName() === '__default',
-            ) as ts.PropertyAssignment)?.initializer
+            ) as PropertyAssignment)?.initializer
             objectLiteral = value
         }
 
@@ -35,18 +45,18 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
         parsedLogic.reducers.push({ name: loaderName, typeNode: defaultValueTypeNode })
         parsedLogic.reducers.push({
             name: `${loaderName}Loading`,
-            typeNode: ts.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),
+            typeNode: factory.createKeywordTypeNode(SyntaxKind.BooleanKeyword),
         })
 
         if (objectLiteral) {
-            ;(objectLiteral.properties || []).forEach((property: ts.PropertyAssignment) => {
+            ;(objectLiteral.properties || []).forEach((property: PropertyAssignment) => {
                 const loaderActionName = checker.getSymbolAtLocation(property.name)?.getName()
                 if (loaderActionName === '__default') {
                     return
                 }
 
                 const func = property.initializer
-                if (!ts.isFunctionLike(func)) {
+                if (!isFunctionLike(func)) {
                     return
                 }
 
@@ -54,14 +64,14 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
                 const parameters = param ? [getParameterDeclaration(param)] : []
 
                 if (!parsedLogic.actions.find(({ name }) => name === `${loaderActionName}`)) {
-                    const returnTypeNode = param?.type || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                    const returnTypeNode = param?.type || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)
                     gatherImports(param, checker, parsedLogic)
 
                     parsedLogic.actions.push({ name: `${loaderActionName}`, parameters, returnTypeNode })
                 }
 
                 if (!parsedLogic.actions.find(({ name }) => name === `${loaderActionName}Success`)) {
-                    let returnTypeNode: ts.TypeNode
+                    let returnTypeNode: TypeNode
                     if (func) {
                         const funcType = checker.getTypeAtLocation(func)
                         const signature = funcType?.getCallSignatures()[0]
@@ -82,11 +92,11 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
                     }
 
                     if (!returnTypeNode) {
-                        returnTypeNode = defaultValueTypeNode || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                        returnTypeNode = defaultValueTypeNode || factory.createKeywordTypeNode(SyntaxKind.AnyKeyword)
                     }
 
                     if (
-                        ts.isTypeReferenceNode(returnTypeNode) &&
+                        isTypeReferenceNode(returnTypeNode) &&
                         (returnTypeNode.typeName as any)?.escapedText === 'Promise'
                     ) {
                         returnTypeNode = returnTypeNode.typeArguments?.[0]
@@ -95,41 +105,37 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
                     gatherImports(returnTypeNode, checker, parsedLogic)
 
                     const successParameters = [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier(loaderName),
+                            factory.createIdentifier(loaderName),
                             undefined,
                             returnTypeNode,
                             undefined,
                         ),
-                        ts.createParameter(
-                            undefined,
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
-                            ts.createIdentifier('payload'),
                             undefined,
+                            factory.createIdentifier('payload'),
+                            factory.createToken(SyntaxKind.QuestionToken),
                             parsedLogic.actions.find((a) => a.name === loaderActionName)?.returnTypeNode,
                             undefined,
                         ),
                     ]
-                    const successReturnTypeNode = ts.createTypeLiteralNode([
-                        ts.createPropertySignature(
+                    const successReturnTypeNode = factory.createTypeLiteralNode([
+                        factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier(loaderName),
+                            factory.createIdentifier(loaderName),
                             undefined,
                             returnTypeNode,
-                            undefined,
                         ),
-                        ts.createPropertySignature(
+                        factory.createPropertySignature(
                             undefined,
-                            ts.createIdentifier('payload'),
-                            parameters.length === 0 || isAnyUnknown(parameters[0])
-                                ? ts.createToken(ts.SyntaxKind.QuestionToken)
-                                : undefined,
+                            factory.createIdentifier('payload'),
+                            factory.createToken(SyntaxKind.QuestionToken),
                             parsedLogic.actions.find((a) => a.name === loaderActionName)?.returnTypeNode,
-                            undefined,
                         ),
                     ])
                     parsedLogic.actions.push({
@@ -141,39 +147,37 @@ export function visitLoaders(type: ts.Type, inputProperty: ts.PropertyAssignment
 
                 if (!parsedLogic.actions.find(({ name }) => name === `${loaderActionName}Failure`)) {
                     const failureParameters = [
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('error'),
+                            factory.createIdentifier('error'),
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                            factory.createKeywordTypeNode(SyntaxKind.StringKeyword),
                             undefined,
                         ),
-                        ts.createParameter(
+                        factory.createParameterDeclaration(
                             undefined,
                             undefined,
                             undefined,
-                            ts.createIdentifier('errorObject'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                            factory.createIdentifier('errorObject'),
+                            factory.createToken(SyntaxKind.QuestionToken),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                             undefined,
                         ),
                     ]
-                    const failureReturnTypeNode = ts.createTypeLiteralNode([
-                        ts.createPropertySignature(
-                            undefined,
-                            ts.createIdentifier('error'),
+                    const failureReturnTypeNode = factory.createTypeLiteralNode([
+                        factory.createPropertySignature(
                             undefined,
-                            ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                            factory.createIdentifier('error'),
                             undefined,
+                            factory.createKeywordTypeNode(SyntaxKind.StringKeyword),
                         ),
-                        ts.createPropertySignature(
-                            undefined,
-                            ts.createIdentifier('errorObject'),
-                            ts.createToken(ts.SyntaxKind.QuestionToken),
-                            ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                        factory.createPropertySignature(
                             undefined,
+                            factory.createIdentifier('errorObject'),
+                            factory.createToken(SyntaxKind.QuestionToken),
+                            factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                         ),
                     ])
 

package/src/visit/visitReducers.ts

@@ -34,7 +34,7 @@ export function visitReducers(type: ts.Type, inputProperty: ts.PropertyAssignmen
                     }
                 }
             } else if (ts.isObjectLiteralExpression(value)) {
-                typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                typeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
             }
 
             parsedLogic.reducers.push({ name, typeNode, reducerOptions })

package/src/visit/visitSelectors.ts

@@ -34,7 +34,7 @@ export function visitSelectors(type: ts.Type, inputProperty: ts.PropertyAssignme
 
             if (selectorInputTypeNode && ts.isTupleTypeNode(selectorInputTypeNode)) {
                 let takenNames: Record<string, number> = {}
-                functionTypes = (selectorInputTypeNode.elements || ts.createNodeArray([]))
+                functionTypes = (selectorInputTypeNode.elements || ts.factory.createNodeArray([]))
                     .filter((e) => ts.isTypeNode(e))
                     .map((selectorTypeNode, index) => {
                         let name = functionNames[index] || 'arg'
@@ -49,7 +49,7 @@ export function visitSelectors(type: ts.Type, inputProperty: ts.PropertyAssignme
                             name,
                             type: ts.isFunctionTypeNode(selectorTypeNode)
                                 ? cloneNode(selectorTypeNode.type)
-                                : ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                                : ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
                         }
                     })
             }
@@ -67,7 +67,7 @@ export function visitSelectors(type: ts.Type, inputProperty: ts.PropertyAssignme
                     typeNode = checker.typeToTypeNode(type, undefined, NodeBuilderFlags.NoTruncation)
                     gatherImports(typeNode, checker, parsedLogic)
                 } else {
-                    typeNode = ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                    typeNode = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
                 }
 
                 parsedLogic.selectors.push({

package/src/visit/visitSharedListeners.ts

@@ -23,21 +23,19 @@ export function visitSharedListeners(type: ts.Type, inputProperty: ts.PropertyAs
             parsedLogic.sharedListeners.push({
                 name,
                 payload: typeNode,
-                action: ts.createTypeLiteralNode([
-                    ts.createPropertySignature(
+                action: ts.factory.createTypeLiteralNode([
+                    ts.factory.createPropertySignature(
                         undefined,
-                        ts.createIdentifier('type'),
-                        undefined,
-                        ts.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                        ts.factory.createIdentifier('type'),
                         undefined,
+                        ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
                     ),
-                    ts.createPropertySignature(
-                        undefined,
-                        ts.createIdentifier('payload'),
+                    ts.factory.createPropertySignature(
                         undefined,
-                        typeNode || ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-                        // ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                        ts.factory.createIdentifier('payload'),
                         undefined,
+                        typeNode || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+                        // ts.factory.createKeywordTypeNode(SyntaxKind.AnyKeyword),
                     ),
                 ]),
             })

package/src/{import/writeLogicTypeImports.ts → write/write.ts}

@@ -5,10 +5,14 @@ import * as fs from 'fs'
 import { runThroughPrettier } from '../print/print'
 import * as diff from 'diff'
 import * as path from 'path'
+import { factory, SyntaxKind } from 'typescript'
 
+// NOTE:
 // This is an unfortunate workaround. The TS compiler strips all
-// whitespace. This uses "jsdiff" to add them back.
-// If it turns out to be flaky, it might be worth rewriting to babel.
+// whitespace AND COMMENTS. This uses "jsdiff" to add back the whitespace,
+// but not the comments.
+//
+// This should be rewritten to babel!
 // https://github.com/microsoft/TypeScript/issues/843#issuecomment-555932858
 function addBackNewlines(oldText: string, newText: string) {
     const patch = diff.parsePatch(diff.createPatch('file', oldText, newText, '', ''))
@@ -31,7 +35,7 @@ function addBackNewlines(oldText: string, newText: string) {
     return diff.applyPatch(oldText, patch)
 }
 
-export function writeLogicTypeImports(
+export function writeTypeImports(
     appOptions: AppOptions,
     program: ts.Program,
     filename: string,
@@ -52,18 +56,19 @@ export function writeLogicTypeImports(
         importLocation = `./${importLocation}`
     }
     const createImportDeclaration = () =>
-        ts.createImportDeclaration(
+        factory.createImportDeclaration(
             undefined,
             undefined,
-            ts.createImportClause(
+            factory.createImportClause(
+                true,
                 undefined,
-                ts.createNamedImports(
+                factory.createNamedImports(
                     allParsedLogics.map((l) =>
-                        ts.createImportSpecifier(undefined, ts.createIdentifier(l.logicTypeName)),
+                        factory.createImportSpecifier(undefined, undefined, factory.createIdentifier(l.logicTypeName)),
                     ),
                 ),
             ),
-            ts.createLiteral(importLocation),
+            factory.createStringLiteral(importLocation),
         )
 
     const transformer = <T extends ts.Node>(context: ts.TransformationContext) => {
@@ -77,15 +82,20 @@ export function writeLogicTypeImports(
                     parsedLogicMapByNode.has(node.expression)
                 ) {
                     const { logicTypeName, typeReferencesInLogicInput } = parsedLogicMapByNode.get(node.expression)
-                    return ts.createCall(
+                    return factory.createCallExpression(
                         node.expression,
                         [
-                            ts.createTypeReferenceNode(
-                                ts.createIdentifier(logicTypeName),
+                            factory.createTypeReferenceNode(
+                                factory.createIdentifier(logicTypeName),
                                 typeReferencesInLogicInput.size > 0
-                                    ? [...typeReferencesInLogicInput.values()].sort().map((type) =>
-                                          ts.createTypeReferenceNode(ts.createIdentifier(type), undefined),
-                                      )
+                                    ? [...typeReferencesInLogicInput.values()]
+                                          .sort()
+                                          .map((type) =>
+                                              factory.createTypeReferenceNode(
+                                                  factory.createIdentifier(type),
+                                                  undefined,
+                                              ),
+                                          )
                                     : undefined,
                             ),
                         ],
@@ -149,6 +159,97 @@ export function writeLogicTypeImports(
         }
     }
 
+    writeFile(sourceFile, transformer, filename)
+
+    log(`🔥 Import added: ${path.relative(process.cwd(), filename)}`)
+}
+
+export function writePaths(appOptions: AppOptions, program: ts.Program, filename: string, parsedLogics: ParsedLogic[]) {
+    const { log } = appOptions
+    const sourceFile = program.getSourceFile(filename)
+    const checker = program.getTypeChecker()
+
+    const parsedLogicMapByNode = new Map<ts.Node, ParsedLogic>()
+    for (const parsedLogic of parsedLogics) {
+        parsedLogicMapByNode.set(parsedLogic.node, parsedLogic)
+    }
+
+    const transformer = <T extends ts.Node>(context: ts.TransformationContext) => {
+        return (rootNode: T) => {
+            function visit(node: ts.Node): ts.Node {
+                node = ts.visitEachChild(node, visit, context)
+                if (
+                    ts.isCallExpression(node) &&
+                    isKeaCall(node.expression, checker) &&
+                    parsedLogicMapByNode.has(node.expression)
+                ) {
+                    const { path, hasKeyInLogic } = parsedLogicMapByNode.get(node.expression)
+                    return factory.createCallExpression(
+                        node.expression,
+                        node.typeArguments,
+                        node.arguments.map((argument, i) =>
+                            i === 0 && ts.isObjectLiteralExpression(argument)
+                                ? factory.createObjectLiteralExpression(
+                                      [
+                                          hasKeyInLogic
+                                              ? factory.createPropertyAssignment(
+                                                    factory.createIdentifier('path'),
+                                                    factory.createArrowFunction(
+                                                        undefined,
+                                                        undefined,
+                                                        [
+                                                            factory.createParameterDeclaration(
+                                                                undefined,
+                                                                undefined,
+                                                                undefined,
+                                                                factory.createIdentifier('key'),
+                                                                undefined,
+                                                                undefined,
+                                                                undefined,
+                                                            ),
+                                                        ],
+                                                        undefined,
+                                                        factory.createToken(SyntaxKind.EqualsGreaterThanToken),
+                                                        factory.createArrayLiteralExpression(
+                                                            [
+                                                                ...path.map((str) => factory.createStringLiteral(str)),
+                                                                factory.createIdentifier('key'),
+                                                            ],
+                                                            false,
+                                                        ),
+                                                    ),
+                                                )
+                                              : factory.createPropertyAssignment(
+                                                    factory.createIdentifier('path'),
+                                                    factory.createArrayLiteralExpression(
+                                                        path.map((str) => factory.createStringLiteral(str)),
+                                                        false,
+                                                    ),
+                                                ),
+                                          ...argument.properties,
+                                      ],
+                                      true,
+                                  )
+                                : argument,
+                        ),
+                    )
+                }
+                return node
+            }
+            return ts.visitNode(rootNode, visit)
+        }
+    }
+
+    writeFile(sourceFile, transformer, filename)
+
+    log(`🔥 Path added: ${path.relative(process.cwd(), filename)}`)
+}
+
+function writeFile<T>(
+    sourceFile: ts.SourceFile,
+    transformer: <T extends ts.Node>(context: ts.TransformationContext) => (rootNode: T) => T,
+    filename: string,
+) {
     const printer: ts.Printer = ts.createPrinter()
     const result: ts.TransformationResult<ts.SourceFile> = ts.transform<ts.SourceFile>(sourceFile, [transformer])
 
@@ -161,6 +262,4 @@ export function writeLogicTypeImports(
     const newestText = addBackNewlines(oldText, newText)
 
     fs.writeFileSync(filename, newestText)
-
-    log(`🔥 Import added: ${path.relative(process.cwd(), filename)}`)
 }

package/dist/src/import/writeLogicTypeImports.d.ts

@@ -1,3 +0,0 @@
-import { AppOptions, ParsedLogic } from '../types';
-import * as ts from 'typescript';
-export declare function writeLogicTypeImports(appOptions: AppOptions, program: ts.Program, filename: string, parsedLogics: ParsedLogic[], allParsedLogics: ParsedLogic[]): void;

package/dist/src/import/writeLogicTypeImports.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"writeLogicTypeImports.js","sourceRoot":"","sources":["../../../src/import/writeLogicTypeImports.ts"],"names":[],"mappings":"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"}