kea-typegen 3.8.0 → 3.8.1

package/src/__tests__/inline.ts

@@ -194,7 +194,8 @@ describe('inline mode', () => {
             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)
+            // one marker per generated interface (values, actions, props)
+            expect(updatedLogic.match(/DO NOT EDIT THIS BLOCK MANUALLY/g)?.length).toBe(3)
         } finally {
             fs.rmSync(tempDir, { recursive: true, force: true })
         }
@@ -263,4 +264,484 @@ describe('inline mode', () => {
             fs.rmSync(tempDir, { recursive: true, force: true })
         }
     })
+
+    test('leaves a reformatted but semantically identical block alone', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-reformat-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.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 { MakeLogicType, kea } from 'kea'",
+                    '',
+                    'export const logic = kea({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string | number) => ({ 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])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            // simulate a formatter pass: strip semicolons and reflow unions with a leading pipe
+            const formatted = fs
+                .readFileSync(logicPath, 'utf8')
+                .replace(/;$/gm, '')
+                .replace(/value: string \| number\) =>/g, 'value:\n        | string\n        | number\n    ) =>')
+            fs.writeFileSync(logicPath, formatted)
+
+            const secondProgram = createProgram([logicPath])
+            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+            expect(fs.readFileSync(logicPath, 'utf8')).toBe(formatted)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('keeps leading comments attached to the logic when inserting the block', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-comments-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.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'",
+                    '',
+                    '// this comment describes the logic and must stay attached to it',
+                    'export const logic = kea({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ 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 response = await printToFiles(program, appOptions, visitProgram(program, appOptions))
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+            expect(writtenLogic).toContain(
+                [
+                    '// this comment describes the logic and must stay attached to it',
+                    'export const logic = kea<logicType>({',
+                ].join('\n'),
+            )
+            // the generated block sits above the comment
+            expect(writtenLogic.indexOf('DO NOT EDIT THIS BLOCK MANUALLY')).toBeLessThan(
+                writtenLogic.indexOf('// this comment describes the logic'),
+            )
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('annotates untyped selector combiner parameters', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-selectors-'))
+
+        try {
+            const logicDir = path.join(tempDir, 'src')
+            const logicPath = path.join(logicDir, 'logic.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({',
+                    '    actions: () => ({',
+                    '        setCounter: (counter: number) => ({ counter }),',
+                    '    }),',
+                    '    reducers: () => ({',
+                    '        counter: [0 as number, { setCounter: (_, { counter }) => counter }],',
+                    '    }),',
+                    '    selectors: () => ({',
+                    '        doubleCounter: [(s): [() => number] => [s.counter], (counter) => counter * 2],',
+                    '        typedCounter: [(s): [() => number] => [s.counter], (counter: number) => counter * 3],',
+                    '    }),',
+                    '})',
+                    '',
+                ].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 response = await printToFiles(program, appOptions, visitProgram(program, appOptions))
+            expect(response.writtenFiles).toBe(1)
+
+            const writtenLogic = fs.readFileSync(logicPath, 'utf8')
+            expect(writtenLogic).toContain('(counter: number) => counter * 2')
+            // already annotated params stay untouched
+            expect(writtenLogic).toContain('(counter: number) => counter * 3')
+
+            // a second pass changes nothing
+            const secondProgram = createProgram([logicPath])
+            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+})
+
+describe('mixed mode with inlinePaths', () => {
+    const createProgram = (fileNames: string[]) =>
+        ts.createProgram(fileNames, {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+    const writeKeaDts = (tempDir: string) => {
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+        fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+        fs.writeFileSync(
+            keaDtsPath,
+            [
+                'export function kea<T = any>(input: any): T',
+                'export interface MakeLogicType<V = any, A = any, P = any> {}',
+                '',
+            ].join('\n'),
+        )
+    }
+
+    const simpleLogicSource = [
+        "import { kea } from 'kea'",
+        '',
+        'export const logic = kea({',
+        '    actions: () => ({',
+        '        setValue: (value: string) => ({ value }),',
+        '    }),',
+        '})',
+        '',
+    ].join('\n')
+
+    test('files under inlinePaths go inline, everything else keeps logicType.ts', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-paths-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const inlineDir = path.join(rootDir, 'scenes', 'inlined')
+            const classicDir = path.join(rootDir, 'scenes', 'classic')
+            const inlineLogicPath = path.join(inlineDir, 'inlinedLogic.ts')
+            const classicLogicPath = path.join(classicDir, 'classicLogic.ts')
+
+            writeKeaDts(tempDir)
+            fs.mkdirSync(inlineDir, { recursive: true })
+            fs.mkdirSync(classicDir, { recursive: true })
+            fs.writeFileSync(inlineLogicPath, simpleLogicSource.replace('export const logic', 'export const inlinedLogic'))
+            fs.writeFileSync(classicLogicPath, simpleLogicSource.replace('export const logic', 'export const classicLogic'))
+
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inlinePaths: [path.join(rootDir, 'scenes', 'inlined')],
+                write: true,
+                delete: true,
+                log: () => {},
+            }
+
+            const program = createProgram([inlineLogicPath, classicLogicPath])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            const writtenInlineLogic = fs.readFileSync(inlineLogicPath, 'utf8')
+            expect(writtenInlineLogic).toContain('// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.')
+            expect(writtenInlineLogic).toContain('export type inlinedLogicType = MakeLogicType<{}, inlinedLogicActions>')
+            expect(fs.existsSync(path.join(inlineDir, 'inlinedLogicType.ts'))).toBe(false)
+
+            const writtenClassicLogic = fs.readFileSync(classicLogicPath, 'utf8')
+            expect(writtenClassicLogic).not.toContain('MakeLogicType')
+            expect(fs.existsSync(path.join(classicDir, 'classicLogicType.ts'))).toBe(true)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('relative inlinePaths resolve against rootPath', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-paths-relative-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const inlineDir = path.join(rootDir, 'scenes', 'inlined')
+            const inlineLogicPath = path.join(inlineDir, 'inlinedLogic.ts')
+
+            writeKeaDts(tempDir)
+            fs.mkdirSync(inlineDir, { recursive: true })
+            fs.writeFileSync(inlineLogicPath, simpleLogicSource.replace('export const logic', 'export const inlinedLogic'))
+
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inlinePaths: ['./scenes/inlined'],
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([inlineLogicPath])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            expect(fs.readFileSync(inlineLogicPath, 'utf8')).toContain(
+                '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+            )
+            expect(fs.existsSync(path.join(inlineDir, 'inlinedLogicType.ts'))).toBe(false)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('connected actions from an inline (MakeLogicType) logic land in the consuming logic type', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-connect-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const inlineLogicPath = path.join(rootDir, 'inlinedLogic.ts')
+            const consumerLogicPath = path.join(rootDir, 'consumerLogic.ts')
+            const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+            fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+            fs.mkdirSync(rootDir, { recursive: true })
+
+            // minimal kea with a mapped-type MakeLogicType, mirroring the real shape
+            fs.writeFileSync(
+                keaDtsPath,
+                [
+                    'export function kea<T = any>(input: any): T',
+                    'export type AnyFunction = (...args: any) => any',
+                    'export interface MakeLogicType<V = any, A = any, P = any> {',
+                    '    actionCreators: {',
+                    '        [K in keyof A]: A[K] extends AnyFunction',
+                    '            ? (...args: Parameters<A[K]>) => { type: string; payload: ReturnType<A[K]> }',
+                    '            : never',
+                    '    }',
+                    '    values: V',
+                    '}',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                inlineLogicPath,
+                [
+                    "import { MakeLogicType, kea } from 'kea'",
+                    '',
+                    '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+                    'export interface inlinedLogicValues {',
+                    '    value: string',
+                    '}',
+                    '',
+                    'export interface inlinedLogicActions {',
+                    '    setValue: (value: string) => {',
+                    '        value: string',
+                    '    }',
+                    '}',
+                    '',
+                    'export type inlinedLogicType = MakeLogicType<inlinedLogicValues, inlinedLogicActions>',
+                    '',
+                    'export const inlinedLogic = kea<inlinedLogicType>({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '    }),',
+                    '    reducers: () => ({',
+                    "        value: ['' as string, { setValue: (_, { value }) => value }],",
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+            fs.writeFileSync(
+                consumerLogicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    "import { inlinedLogic } from './inlinedLogic'",
+                    '',
+                    'export const consumerLogic = kea({',
+                    '    connect: {',
+                    "        actions: [inlinedLogic, ['setValue']],",
+                    "        values: [inlinedLogic, ['value']],",
+                    '    },',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+            const inlineConsumerDir = path.join(rootDir, 'inlineConsumer')
+            const inlineConsumerLogicPath = path.join(inlineConsumerDir, 'inlineConsumerLogic.ts')
+            fs.mkdirSync(inlineConsumerDir, { recursive: true })
+            fs.writeFileSync(
+                inlineConsumerLogicPath,
+                [
+                    "import { kea } from 'kea'",
+                    '',
+                    "import { inlinedLogic } from '../inlinedLogic'",
+                    '',
+                    'export const inlineConsumerLogic = kea({',
+                    '    connect: {',
+                    "        actions: [inlinedLogic, ['setValue']],",
+                    "        values: [inlinedLogic, ['value']],",
+                    '    },',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                inlinePaths: [inlineConsumerDir],
+                write: true,
+                log: () => {},
+            }
+
+            const program = createProgram([inlineLogicPath, consumerLogicPath, inlineConsumerLogicPath])
+            await printToFiles(program, appOptions, visitProgram(program, appOptions))
+
+            // consumerLogic is classic-mode, so it gets a logicType.ts that must include the connected action
+            const consumerType = fs.readFileSync(path.join(rootDir, 'consumerLogicType.ts'), 'utf8')
+            expect(consumerType).toContain('setValue: (value: string) => void')
+            expect(consumerType).toContain('value: string')
+
+            // the inline consumer's block marks connected values/actions with their source logic
+            const inlineConsumer = fs.readFileSync(inlineConsumerLogicPath, 'utf8')
+            expect(inlineConsumer).toMatch(/value: string.* \/\/ inlinedLogic/)
+            expect(inlineConsumer).toMatch(/\};? \/\/ inlinedLogic/)
+
+            // a second pass over the annotated block changes nothing
+            const secondProgram = createProgram([inlineLogicPath, consumerLogicPath, inlineConsumerLogicPath])
+            const secondResponse = await printToFiles(secondProgram, appOptions, visitProgram(secondProgram, appOptions))
+            expect(secondResponse).toEqual({ filesToWrite: 0, writtenFiles: 0, filesToModify: 0 })
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
+
+    test('files that already carry an inline block stay inline without any inline options', async () => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-inline-sticky-'))
+
+        try {
+            const rootDir = path.join(tempDir, 'src')
+            const logicPath = path.join(rootDir, 'stickyLogic.ts')
+
+            writeKeaDts(tempDir)
+            fs.mkdirSync(rootDir, { recursive: true })
+            fs.writeFileSync(
+                logicPath,
+                [
+                    "import { MakeLogicType, kea } from 'kea'",
+                    '',
+                    '// Generated by kea-typegen. DO NOT EDIT THIS BLOCK MANUALLY.',
+                    'export interface stickyLogicActions {',
+                    '    setValue: (value: string) => {',
+                    '        value: string',
+                    '    }',
+                    '}',
+                    '',
+                    'export type stickyLogicType = MakeLogicType<{}, stickyLogicActions>',
+                    '',
+                    'export const stickyLogic = kea<stickyLogicType>({',
+                    '    actions: () => ({',
+                    '        setValue: (value: string) => ({ value }),',
+                    '        setOther: (other: number) => ({ other }),',
+                    '    }),',
+                    '})',
+                    '',
+                ].join('\n'),
+            )
+
+            // no `inline`, no `inlinePaths` - the existing block alone keeps the file inline
+            const appOptions: AppOptions = {
+                rootPath: rootDir,
+                typesPath: rootDir,
+                packageJsonPath: path.join(tempDir, 'package.json'),
+                write: 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).toContain('setOther: (other: number) =>')
+            expect(writtenLogic.match(/DO NOT EDIT THIS BLOCK MANUALLY/g)?.length).toBe(1)
+            expect(fs.existsSync(path.join(rootDir, 'stickyLogicType.ts'))).toBe(false)
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true })
+        }
+    })
 })

package/src/cache.ts

@@ -3,6 +3,7 @@ import * as path from 'path'
 import { AppOptions, ParsedLogic } from './types'
 import { Program } from 'typescript'
 import { visitProgram } from './visit/visit'
+import { isInlineFile } from './utils'
 
 export function cachePath(appOptions: AppOptions, fileName: string): string {
     return path.join(process.cwd(), '.typegen', path.relative(process.cwd(), fileName))
@@ -13,8 +14,16 @@ export function restoreCachedTypes(program: Program, appOptions: AppOptions, log
         return false
     }
     const parsedLogics = visitProgram(program, appOptions)
+    const parsedLogicsByFile: Record<string, ParsedLogic[]> = {}
+    for (const pl of parsedLogics) {
+        parsedLogicsByFile[pl.fileName] = [...(parsedLogicsByFile[pl.fileName] ?? []), pl]
+    }
     let restored = false
     for (const pl of parsedLogics) {
+        if (isInlineFile(appOptions, program.getSourceFile(pl.fileName), parsedLogicsByFile[pl.fileName])) {
+            // inline files have their types in the logic file itself, there is no logicType.ts to restore
+            continue
+        }
         if (!fs.existsSync(pl.typeFileName)) {
             const from = cachePath(appOptions, pl.typeFileName)
             if (fs.existsSync(from)) {
@@ -36,3 +45,13 @@ export function cacheWrittenFile(fileName: string, appOptions: AppOptions) {
     fs.mkdirSync(path.dirname(dest), { recursive: true })
     fs.copyFileSync(fileName, dest)
 }
+
+export function deleteCachedFile(fileName: string, appOptions: AppOptions) {
+    if (!appOptions.useCache) {
+        return
+    }
+    const dest = cachePath(appOptions, fileName)
+    if (fs.existsSync(dest)) {
+        fs.unlinkSync(dest)
+    }
+}

package/src/cli/typegen.ts

@@ -43,6 +43,12 @@ yargs
         describe: 'Write logic types as MakeLogicType blocks above each kea() call, instead of logicType.ts files',
         type: 'boolean',
     })
+    .option('inline-paths', {
+        describe:
+            'Like --inline, but only for logic files under these paths (relative to --root). ' +
+            'Everything else keeps its logicType.ts file.',
+        type: 'array',
+    })
     .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

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

package/src/types.ts

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