kea-typegen 3.7.1 → 3.8.0

package/src/__tests__/inline.ts

@@ -0,0 +1,266 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import * as ts from 'typescript'
+import { AppOptions } from '../types'
+import { programFromSource } from '../utils'
+import { visitProgram } from '../visit/visit'
+import { printToFiles } from '../print/print'
+
+describe('manually typed logics', () => {
+    test('skips logics typed with MakeLogicType', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            interface Values { name: string }
+            interface Actions { updateName: (name: string) => { name: string } }
+
+            const logic = kea<MakeLogicType<Values, Actions>>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        expect(visitProgram(programFromSource(logicSource)).length).toBe(0)
+    })
+
+    test('skips logics typed with a custom local type, even when named like a generated one', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            export type logicType = MakeLogicType<{ name: string }, { updateName: (name: string) => { name: string } }>
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        expect(visitProgram(programFromSource(logicSource)).length).toBe(0)
+    })
+
+    test('does not skip local logic types carrying the kea-typegen marker', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            // Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.
+            export type logicType = MakeLogicType<{ name: string }, { updateName: (name: string) => { name: string } }>
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        const parsedLogics = visitProgram(programFromSource(logicSource))
+        expect(parsedLogics.length).toBe(1)
+        expect(parsedLogics[0].actions.map((a) => a.name)).toEqual(['updateName'])
+    })
+
+    test('does not skip generated blocks where the marker sits on the values interface', () => {
+        const logicSource = `
+            import { kea, MakeLogicType } from 'kea'
+
+            // Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.
+            export interface logicValues { name: string }
+
+            export interface logicActions { updateName: (name: string) => { name: string } }
+
+            export type logicType = MakeLogicType<logicValues, logicActions>
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        const parsedLogics = visitProgram(programFromSource(logicSource))
+        expect(parsedLogics.length).toBe(1)
+    })
+
+    test('does not skip logics with a generated type that does not resolve yet', () => {
+        const logicSource = `
+            import { kea } from 'kea'
+
+            const logic = kea<logicType>({
+                actions: () => ({
+                    updateName: (name: string) => ({ name }),
+                }),
+            })
+        `
+        expect(visitProgram(programFromSource(logicSource)).length).toBe(1)
+    })
+})
+
+describe('inline mode', () => {
+    const createProgram = (fileNames: string[]) =>
+        ts.createProgram(fileNames, {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+    test('writes and updates MakeLogicType blocks above the logic', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.ts')
+            const logicTypePath = path.join(logicDir, 'logicType.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(logicDir, { recursive: true })
+
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    'export const logic = kea({',
+                    '    props: {} as { id: number },',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '    }),',
+                    '    reducers: () => ({',
+                    "        value: ['' as string, { setValue: (_, { value }) => value }],",
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: logicDir,
+                typesPath: logicDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inline: true,
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            const parsedLogics = visitProgram(program, appOptions)
+            expect(parsedLogics.length).toBe(1)
+
+            const response = await printToFiles(program, appOptions, parsedLogics)
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+
+            expect(writtenLogic).toContain("import { MakeLogicType, kea } from 'kea'")
+            expect(writtenLogic).toContain('// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.')
+            expect(writtenLogic).toContain('export interface logicValues {')
+            expect(writtenLogic).toContain('export interface logicActions {')
+            expect(writtenLogic).toContain('export interface logicProps {')
+            expect(writtenLogic).toContain('export type logicType = MakeLogicType<logicValues, logicActions, logicProps>')
+            expect(writtenLogic).toContain('export const logic = kea<logicType>({')
+            expect(writtenLogic).toContain('value: string')
+            expect(writtenLogic).toContain('setValue: (value: string) =>')
+            expect(fs.existsSync(logicTypePath)).toBe(false)
+
+            // a second pass over the written file changes nothing
+            const secondProgram = createProgram([logicPath])
+            const secondParsedLogics = visitProgram(secondProgram, appOptions)
+            expect(secondParsedLogics.length).toBe(1)
+
+            const secondResponse = await printToFiles(secondProgram, appOptions, secondParsedLogics)
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+            expect(fs.readFileSync(logicPath, 'utf8')).toBe(writtenLogic)
+
+            // adding an action updates the existing block in place
+            fs.writeFileSync(
+                logicPath,
+                fs
+                    .readFileSync(logicPath, 'utf8')
+                    .replace('setValue: (value: string) => ({ value }),', 'setValue: (value: string) => ({ value }),\n        reset: true,'),
+            )
+
+            const thirdProgram = createProgram([logicPath])
+            const thirdResponse = await printToFiles(thirdProgram, appOptions, visitProgram(thirdProgram, appOptions))
+            expect(thirdResponse.writtenFiles).toBe(1)
+
+            const updatedLogic = fs.readFileSync(logicPath, 'utf8')
+            expect(updatedLogic).toContain('reset: ')
+            expect(updatedLogic.match(/export type logicType = MakeLogicType</g)?.length).toBe(1)
+            expect(updatedLogic.match(/export interface logicValues \{/g)?.length).toBe(1)
+            expect(updatedLogic.match(/export interface logicActions \{/g)?.length).toBe(1)
+            expect(updatedLogic.match(/DO NOT EDIT THIS BLOCK MANUALLY/g)?.length).toBe(1)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('replaces the old logicType.ts import when switching to inline mode', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-migrate-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.ts')
+            const logicTypePath = path.join(logicDir, 'logicType.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(logicDir, { recursive: true })
+
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(logicTypePath, 'export interface logicType {}\n')
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { kea } from 'kea'",
+                    "import type { logicType } from './logicType'",
+                    '',
+                    'export const logic = kea<logicType>({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: logicDir,
+                typesPath: logicDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inline: true,
+                write: true,
+                delete: true,
+                log: () => {},
+            }
+
+            const program = createProgram([logicPath])
+            const response = await printToFiles(program, appOptions, visitProgram(program, appOptions))
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+
+            expect(writtenLogic).not.toContain("from './logicType'")
+            expect(writtenLogic).toContain("import { MakeLogicType, kea } from 'kea'")
+            expect(writtenLogic).toContain('export interface logicActions {')
+            // no values or props on this logic, so no interfaces are generated for them
+            expect(writtenLogic).toContain('export type logicType = MakeLogicType<{}, logicActions>')
+            expect(writtenLogic).toContain('export const logic = kea<logicType>({')
+            expect(fs.existsSync(logicTypePath)).toBe(false)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+})

package/src/cli/typegen.ts

@@ -39,6 +39,10 @@ yargs
     .option('delete', { describe: 'Delete logicType.ts files without a corresponding logic.ts', type: 'boolean' })
     .option('add-ts-nocheck', { describe: 'Add @ts-nocheck to top of logicType.ts files', type: 'boolean' })
     .option('convert-to-builders', { describe: 'Convert Kea 2.0 inputs to Kea 3.0 logic builders', type: 'boolean' })
+    .option('inline', {
+        describe: 'Write logic types as MakeLogicType blocks above each kea() call, instead of logicType.ts files',
+        type: 'boolean',
+    })
     .option('import-global-types', {
         describe: 'Add import statements in logicType.ts files for global types (e.g. @types/node)',
         type: 'boolean',

package/src/print/print.ts

@@ -36,6 +36,7 @@ import { printSharedListeners } from './printSharedListeners'
 import { printListeners } from './printListeners'
 import { writePaths } from '../write/writePaths'
 import { writeTypeImports } from '../write/writeTypeImports'
+import { writeInlineLogicTypes } from '../write/writeInlineLogicTypes'
 import { printInternalExtraInput } from './printInternalExtraInput'
 import { convertToBuilders } from '../write/convertToBuilders'
 import { cacheWrittenFile } from '../cache'
@@ -78,8 +79,10 @@ export async function printToFiles(
         }
         groupedByFile[parsedLogic.fileName].push(parsedLogic)
 
-        // create the Nodes and gather referenced types
-        printLogicType(parsedLogic, appOptions)
+        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
@@ -105,6 +108,11 @@ export async function printToFiles(
     const shouldIgnore = (absolutePath: string) =>
         !!doNotImportFromPaths.find((badPath) => absolutePath.startsWith(badPath))
 
+    const nodeModulesPath = path.join(
+        appOptions.packageJsonPath ? path.dirname(appOptions.packageJsonPath) : appOptions.rootPath,
+        'node_modules',
+    )
+
     let writtenFiles = 0
     let filesToWrite = 0
     let filesToModify = 0
@@ -112,6 +120,27 @@ export async function printToFiles(
     for (const [fileName, parsedLogics] of Object.entries(groupedByFile)) {
         const typeFileName = parsedLogics[0].typeFileName
 
+        if (appOptions.inline) {
+            // write/update MakeLogicType blocks above the logics instead of writing a logicType.ts file
+            const inlineResponse = await writeInlineLogicTypes(
+                program,
+                appOptions,
+                fileName,
+                parsedLogics,
+                nodeModulesPath,
+                shouldIgnore,
+            )
+            filesToWrite += inlineResponse.filesToWrite
+            writtenFiles += inlineResponse.writtenFiles
+
+            // the logicType.ts file is superseded by the inline block
+            if (appOptions.delete && fs.existsSync(typeFileName)) {
+                log(`🗑️ Deleting: ${path.relative(process.cwd(), typeFileName)}`)
+                fs.unlinkSync(typeFileName)
+            }
+            continue
+        }
+
         const logicStrings = []
         const requiredKeys = new Set(['Logic'])
         for (const parsedLogic of parsedLogics) {
@@ -131,62 +160,12 @@ export async function printToFiles(
 
         const output = logicStrings.join('\n\n')
 
-        const nodeModulesPath = path.join(
-            appOptions.packageJsonPath ? path.dirname(appOptions.packageJsonPath) : appOptions.rootPath,
-            'node_modules',
+        const otherimports = buildTypeImportEntries(
+            parsedLogics[0].typeReferencesToImportFromFiles,
+            parsedLogics[0].typeFileName,
+            nodeModulesPath,
+            shouldIgnore,
         )
-
-        const otherimports = Object.entries(parsedLogics[0].typeReferencesToImportFromFiles)
-            .filter(([_, list]) => list.size > 0)
-            .map(([file, list]) => {
-                let finalPath = file
-
-                // Relative path? Get the absolute.
-                if (finalPath.startsWith('.')) {
-                    finalPath = path.resolve(path.dirname(parsedLogics[0].typeFileName), finalPath)
-                }
-                if (finalPath.startsWith('node_modules/')) {
-                    finalPath = path.resolve(path.dirname(nodeModulesPath), finalPath)
-                }
-                // clean up '../../node_modules/...'
-                if (finalPath.startsWith(nodeModulesPath)) {
-                    finalPath = finalPath.substring(nodeModulesPath.length + 1)
-                    if (finalPath.startsWith('.pnpm/')) {
-                        // node_modules/.pnpm/pkg@version/node_modules/* --> *
-                        const regex = /\.pnpm\/[^/]+@[^\/]+\/node_modules\/(.*)/
-                        const result = finalPath.match(regex)
-                        if (result && result.length > 1) {
-                            finalPath = result[1]
-                        }
-                    }
-                    if (finalPath.startsWith('@types/')) {
-                        finalPath = finalPath.substring(7)
-                    }
-                }
-
-                // Resolve absolute urls
-                if (finalPath.startsWith('/')) {
-                    finalPath = path.relative(path.dirname(parsedLogics[0].typeFileName), finalPath)
-                    if (!finalPath.startsWith('.')) {
-                        finalPath = `./${finalPath}`
-                    }
-                }
-
-                // Remove extension
-                finalPath = finalPath.replace(/(\.d|)\.tsx?$/, '')
-
-                // Remove "/index"
-                if (finalPath.split('/').length === 2 && finalPath.endsWith('/index')) {
-                    finalPath = finalPath.substring(0, finalPath.length - 6)
-                }
-
-                return {
-                    list: [...list].sort(),
-                    fullPath: file,
-                    finalPath,
-                }
-            })
-            .filter((entry) => !shouldIgnore(entry.fullPath))
             .map(({ list, finalPath }) => `import type { ${list.join(', ')} } from '${finalPath}'`)
             .join('\n')
 
@@ -306,6 +285,72 @@ export async function printToFiles(
     return { filesToWrite, writtenFiles, filesToModify }
 }
 
+export interface TypeImportEntry {
+    list: string[]
+    fullPath: string
+    finalPath: string
+}
+
+/** Resolve gathered type references into import specifiers, relative to the file they'll be imported into */
+export function buildTypeImportEntries(
+    typeReferencesToImportFromFiles: Record<string, Set<string>>,
+    importIntoFile: string,
+    nodeModulesPath: string,
+    shouldIgnore: (absolutePath: string) => boolean,
+): TypeImportEntry[] {
+    return Object.entries(typeReferencesToImportFromFiles)
+        .filter(([_, list]) => list.size > 0)
+        .map(([file, list]) => {
+            let finalPath = file
+
+            // Relative path? Get the absolute.
+            if (finalPath.startsWith('.')) {
+                finalPath = path.resolve(path.dirname(importIntoFile), finalPath)
+            }
+            if (finalPath.startsWith('node_modules/')) {
+                finalPath = path.resolve(path.dirname(nodeModulesPath), finalPath)
+            }
+            // clean up '../../node_modules/...'
+            if (finalPath.startsWith(nodeModulesPath)) {
+                finalPath = finalPath.substring(nodeModulesPath.length + 1)
+                if (finalPath.startsWith('.pnpm/')) {
+                    // node_modules/.pnpm/pkg@version/node_modules/* --> *
+                    const regex = /\.pnpm\/[^/]+@[^\/]+\/node_modules\/(.*)/
+                    const result = finalPath.match(regex)
+                    if (result && result.length > 1) {
+                        finalPath = result[1]
+                    }
+                }
+                if (finalPath.startsWith('@types/')) {
+                    finalPath = finalPath.substring(7)
+                }
+            }
+
+            // Resolve absolute urls
+            if (finalPath.startsWith('/')) {
+                finalPath = path.relative(path.dirname(importIntoFile), finalPath)
+                if (!finalPath.startsWith('.')) {
+                    finalPath = `./${finalPath}`
+                }
+            }
+
+            // Remove extension
+            finalPath = finalPath.replace(/(\.d|)\.tsx?$/, '')
+
+            // Remove "/index"
+            if (finalPath.split('/').length === 2 && finalPath.endsWith('/index')) {
+                finalPath = finalPath.substring(0, finalPath.length - 6)
+            }
+
+            return {
+                list: [...list].sort(),
+                fullPath: file,
+                finalPath,
+            }
+        })
+        .filter((entry) => !shouldIgnore(entry.fullPath))
+}
+
 export function nodeToString(node: Node): string {
     const printer = createPrinter({ newLine: NewLineKind.LineFeed })
     const sourceFile = createSourceFile('logic.ts', '', ScriptTarget.Latest, false, ScriptKind.TS)

package/src/types.ts

@@ -78,6 +78,8 @@ export interface AppOptions {
     addTsNocheck?: boolean
     /** Convert kea 2.0 logic input to kea 3.0 builders */
     convertToBuilders?: boolean
+    /** Write logic types as MakeLogicType blocks above each kea() call, instead of into logicType.ts files */
+    inline?: boolean
     /** 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

@@ -53,6 +53,87 @@ export function isKeaCall(node: ts.Node, checker: ts.TypeChecker) {
     return ts.isObjectLiteralExpression(input) || ts.isArrayLiteralExpression(input)
 }
 
+/** True if the node has a leading "kea-typegen" comment, marking it as generated by us */
+export function hasKeaTypegenMarker(node: ts.Node): boolean {
+    const sourceFile = node.getSourceFile()
+    const ranges = ts.getLeadingCommentRanges(sourceFile.text, node.pos) ?? []
+    return ranges.some(({ pos, end }) => sourceFile.text.slice(pos, end).includes('kea-typegen'))
+}
+
+const INLINE_BLOCK_SUFFIXES = ['Values', 'Actions', 'Props']
+
+/**
+ * The statements making up an inline logic type block: the `logicType` alias itself, plus any
+ * `logicValues` / `logicActions` / `logicProps` interfaces directly above it.
+ */
+export function getInlineBlockStatements(
+    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration,
+    logicName: string,
+): ts.Statement[] {
+    const statements = declaration.getSourceFile().statements
+    const index = statements.indexOf(declaration)
+    if (index === -1) {
+        return [declaration]
+    }
+    const generatedNames = new Set(INLINE_BLOCK_SUFFIXES.map((suffix) => `${logicName}${suffix}`))
+    const block: ts.Statement[] = [declaration]
+    for (let i = index - 1; i >= 0; i--) {
+        const statement = statements[i]
+        if (
+            (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) &&
+            generatedNames.has(statement.name.text)
+        ) {
+            block.unshift(statement)
+        } else {
+            break
+        }
+    }
+    return block
+}
+
+/** True if this local `logicType` declaration is part of a kea-typegen generated inline block */
+export function isGeneratedInlineBlock(
+    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration,
+    logicName: string,
+): boolean {
+    return getInlineBlockStatements(declaration, logicName).some(hasKeaTypegenMarker)
+}
+
+/**
+ * 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.
+ * Manually typed logics are skipped entirely.
+ */
+export function isManuallyTypedLogic(
+    typeArgument: ts.TypeNode,
+    logicTypeName: string,
+    checker: ts.TypeChecker,
+): boolean {
+    if (!ts.isTypeReferenceNode(typeArgument)) {
+        // e.g. kea<{ actions: ... }>(...)
+        return true
+    }
+    if (!ts.isIdentifier(typeArgument.typeName) || typeArgument.typeName.escapedText !== logicTypeName) {
+        // e.g. kea<MakeLogicType<Values, Actions>>(...) or kea<MyCustomLogicType>(...)
+        return true
+    }
+    const symbol = checker.getSymbolAtLocation(typeArgument.typeName)
+    const declaration = symbol?.getDeclarations()?.[0]
+    if (!declaration) {
+        // "logicType" that doesn't resolve --> a generated type that doesn't exist yet
+        return false
+    }
+    if (ts.isImportSpecifier(declaration)) {
+        // imported logic types are managed by kea-typegen
+        return false
+    }
+    if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) {
+        // local declarations are ours only if their block carries the kea-typegen marker (written by --inline mode)
+        return !isGeneratedInlineBlock(declaration, logicTypeName.replace(/Type$/, ''))
+    }
+    return true
+}
+
 export function getTypeNodeForNode(node: ts.Node, checker: ts.TypeChecker): ts.TypeNode {
     let typeNode
     if (node) {

package/src/visit/visit.ts

@@ -10,6 +10,7 @@ import {
     getLogicPathString,
     getTypeNodeForNode,
     isKeaCall,
+    isManuallyTypedLogic,
 } from '../utils'
 import { visitActions } from './visitActions'
 import { visitReducers } from './visitReducers'
@@ -216,6 +217,19 @@ export function visitKeaCalls(
         const keaTypeArguments = ts.isCallExpression(node.parent) ? node.parent.typeArguments : []
         const keaTypeArgument = keaTypeArguments?.[0]
 
+        // if the logic is already manually typed (e.g. kea<MakeLogicType<...>>(...)), leave it alone
+        if (keaTypeArgument && isManuallyTypedLogic(keaTypeArgument, logicTypeName, checker)) {
+            if (appOptions?.verbose) {
+                appOptions.log(
+                    `🩶 Skipping manually typed logic "${logicName}" in ${path.relative(
+                        process.cwd(),
+                        sourceFile.fileName,
+                    )}`,
+                )
+            }
+            return
+        }
+
         const pathString = getLogicPathString(appOptions, sourceFile.fileName)
         let typeFileName = sourceFile.fileName.replace(/\.[tj]sx?$/, 'Type.ts')