kea-typegen 3.7.0 → 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/__tests__/watch.ts

@@ -1,44 +1,271 @@
 import { spawn } from 'child_process'
+import * as fs from 'fs'
+import * as os from 'os'
 import * as path from 'path'
+import * as ts from 'typescript'
+import { planWatchTypegenPass } from '../watch'
 
-test(
-    'watch mode does not overlap successive typegen passes',
-    async () => {
-        const repoRoot = path.resolve(__dirname, '..', '..')
-        const scriptPath = path.join(repoRoot, 'src/test-support/watch-mode-smoke.js')
+function writeFile(filePath: string, source: string): void {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true })
+    fs.writeFileSync(filePath, source)
+}
 
-        const result = await new Promise<{ code: number | null; signal: NodeJS.Signals | null; stdout: string; stderr: string }>(
-            (resolve, reject) => {
-                const child = spawn(process.execPath, [scriptPath], {
-                    cwd: repoRoot,
-                    env: { ...process.env, FORCE_COLOR: '0' },
-                })
+function createProgram(fileNames: string[]): ts.Program {
+    return ts.createProgram(fileNames, {
+        module: ts.ModuleKind.CommonJS,
+        moduleResolution: ts.ModuleResolutionKind.NodeJs,
+        target: ts.ScriptTarget.ES2020,
+        skipLibCheck: true,
+    })
+}
 
-                let stdout = ''
-                let stderr = ''
+test('watch mode does not overlap successive typegen passes', async () => {
+    const repoRoot = path.resolve(__dirname, '..', '..')
+    const scriptPath = path.join(repoRoot, 'src/test-support/watch-mode-smoke.js')
 
-                child.stdout.on('data', (chunk) => {
-                    stdout += chunk.toString()
-                })
+    const result = await new Promise<{
+        code: number | null
+        signal: NodeJS.Signals | null
+        stdout: string
+        stderr: string
+    }>((resolve, reject) => {
+        const child = spawn(process.execPath, [scriptPath], {
+            cwd: repoRoot,
+            env: { ...process.env, FORCE_COLOR: '0' },
+        })
 
-                child.stderr.on('data', (chunk) => {
-                    stderr += chunk.toString()
-                })
+        let stdout = ''
+        let stderr = ''
 
-                child.on('error', reject)
-                child.on('close', (code, signal) => resolve({ code, signal, stdout, stderr }))
-            },
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString()
+        })
+
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString()
+        })
+
+        child.on('error', reject)
+        child.on('close', (code, signal) => resolve({ code, signal, stdout, stderr }))
+    })
+
+    expect(result.signal).toBeNull()
+    expect(result.code).toBe(0)
+
+    const payload = JSON.parse(result.stdout.trim())
+
+    expect(payload.started).toBeGreaterThan(1)
+    expect(payload.completed).toBeGreaterThan(0)
+    expect(payload.maxActive).toBe(1)
+    expect(payload.incrementalAfterEdit).toBe(true)
+    expect(payload.parsedLogicCountsAfterEdit).toContain(1)
+    expect(payload.sourceFilePathsAfterEdit.some(Boolean)).toBe(true)
+    expect(result.stderr).toBe('')
+}, 30000)
+
+test('watch planner limits a direct logic edit to the changed logic and dependent logics', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-watch-direct-logic-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const firstLogicPath = path.join(logicDir, 'firstLogic.ts')
+        const secondLogicPath = path.join(logicDir, 'secondLogic.ts')
+        const unrelatedLogicPath = path.join(logicDir, 'unrelatedLogic.ts')
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+        writeFile(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+        writeFile(
+            firstLogicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const firstLogic = kea({',
+                '    actions: () => ({ first: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+        writeFile(
+            secondLogicPath,
+            [
+                "import { kea } from 'kea'",
+                "import { firstLogic } from './firstLogic'",
+                '',
+                'export const secondLogic = kea({',
+                '    connect: { values: [firstLogic, ["first"]] },',
+                '})',
+                '',
+            ].join('\n'),
+        )
+        writeFile(
+            unrelatedLogicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const unrelatedLogic = kea({',
+                '    actions: () => ({ unrelated: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+
+        const program = createProgram([firstLogicPath, secondLogicPath, unrelatedLogicPath])
+        const plan = planWatchTypegenPass(program, [
+            { fileName: firstLogicPath, eventKind: ts.FileWatcherEventKind.Changed },
+        ])
+
+        expect(plan).toEqual({
+            kind: 'files',
+            sourceFilePaths: [firstLogicPath, secondLogicPath].sort(),
+            reason: '2 affected Kea logic files',
+        })
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})
+
+test('watch planner regenerates logics affected by a helper type edit', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-watch-helper-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const helperPath = path.join(logicDir, 'helper.ts')
+        const logicPath = path.join(logicDir, 'logic.ts')
+        const unrelatedLogicPath = path.join(logicDir, 'unrelatedLogic.ts')
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+        writeFile(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+        writeFile(helperPath, 'export interface HelperType { value: string }\n')
+        writeFile(
+            logicPath,
+            [
+                "import { kea } from 'kea'",
+                "import type { HelperType } from './helper'",
+                '',
+                'export const logic = kea({',
+                '    actions: () => ({ setValue: (value: HelperType) => ({ value }) }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+        writeFile(
+            unrelatedLogicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const unrelatedLogic = kea({',
+                '    actions: () => ({ unrelated: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+
+        const program = createProgram([helperPath, logicPath, unrelatedLogicPath])
+        const plan = planWatchTypegenPass(program, [
+            { fileName: helperPath, eventKind: ts.FileWatcherEventKind.Changed },
+        ])
+
+        expect(plan).toEqual({
+            kind: 'files',
+            sourceFilePaths: [logicPath],
+            reason: '1 affected Kea logic file',
+        })
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})
+
+test('watch planner maps generated type changes back to source logics and dependents', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-watch-type-file-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const firstLogicPath = path.join(logicDir, 'firstLogic.ts')
+        const firstLogicTypePath = path.join(logicDir, 'firstLogicType.ts')
+        const secondLogicPath = path.join(logicDir, 'secondLogic.ts')
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+        writeFile(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+        writeFile(firstLogicTypePath, 'export interface firstLogicType {}\n')
+        writeFile(
+            firstLogicPath,
+            [
+                "import { kea } from 'kea'",
+                "import type { firstLogicType } from './firstLogicType'",
+                '',
+                'export const firstLogic = kea<firstLogicType>({',
+                '    actions: () => ({ first: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+        writeFile(
+            secondLogicPath,
+            [
+                "import { kea } from 'kea'",
+                "import { firstLogic } from './firstLogic'",
+                '',
+                'export const secondLogic = kea({',
+                '    connect: { actions: [firstLogic, ["first"]] },',
+                '})',
+                '',
+            ].join('\n'),
+        )
+
+        const program = createProgram([firstLogicPath, firstLogicTypePath, secondLogicPath])
+        const plan = planWatchTypegenPass(program, [
+            { fileName: firstLogicTypePath, eventKind: ts.FileWatcherEventKind.Changed },
+        ])
+
+        expect(plan).toEqual({
+            kind: 'files',
+            sourceFilePaths: [firstLogicPath, secondLogicPath].sort(),
+            reason: '2 affected Kea logic files',
+        })
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})
+
+test('watch planner falls back to a full pass for deleted files and resetContext changes', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-watch-full-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const logicPath = path.join(logicDir, 'logic.ts')
+        const contextPath = path.join(logicDir, 'context.ts')
+        const keaDtsPath = path.join(tempDir, 'node_modules', 'kea', 'index.d.ts')
+
+        writeFile(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+        writeFile(
+            logicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const logic = kea({',
+                '    actions: () => ({ value: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+        writeFile(
+            contextPath,
+            ["import { resetContext } from 'kea'", '', 'resetContext({ plugins: [] })', ''].join('\n'),
         )
 
-        expect(result.signal).toBeNull()
-        expect(result.code).toBe(0)
+        const program = createProgram([logicPath, contextPath])
 
-        const payload = JSON.parse(result.stdout.trim())
+        expect(
+            planWatchTypegenPass(program, [{ fileName: logicPath, eventKind: ts.FileWatcherEventKind.Deleted }]),
+        ).toEqual({ kind: 'full', reason: 'deleted file detected' })
 
-        expect(payload.started).toBeGreaterThan(1)
-        expect(payload.completed).toBeGreaterThan(0)
-        expect(payload.maxActive).toBe(1)
-        expect(result.stderr).toBe('')
-    },
-    30000,
-)
+        expect(
+            planWatchTypegenPass(program, [{ fileName: contextPath, eventKind: ts.FileWatcherEventKind.Changed }]),
+        ).toEqual({
+            kind: 'full',
+            reason: `resetContext changed: ${path.relative(process.cwd(), contextPath)}`,
+        })
+    } 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',