kea-typegen 3.6.8 → 3.7.1

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/__tests__/write.ts

@@ -153,3 +153,59 @@ test('writeTypeImports replaces existing kea generic without leaving a trailing
         fs.rmSync(tempDir, { recursive: true, force: true })
     }
 })
+
+test('visitProgram limits project-aware single-file generation to the requested source file', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-single-file-'))
+
+    try {
+        const logicDir = path.join(tempDir, 'src')
+        const firstLogicPath = path.join(logicDir, 'firstLogic.ts')
+        const secondLogicPath = path.join(logicDir, 'secondLogic.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\n')
+        fs.writeFileSync(
+            firstLogicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const firstLogic = kea({',
+                '    actions: () => ({ first: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+        fs.writeFileSync(
+            secondLogicPath,
+            [
+                "import { kea } from 'kea'",
+                '',
+                'export const secondLogic = kea({',
+                '    actions: () => ({ second: true }),',
+                '})',
+                '',
+            ].join('\n'),
+        )
+
+        const program = ts.createProgram([firstLogicPath, secondLogicPath], {
+            module: ts.ModuleKind.CommonJS,
+            moduleResolution: ts.ModuleResolutionKind.NodeJs,
+            target: ts.ScriptTarget.ES2020,
+            skipLibCheck: true,
+        })
+
+        const parsedLogics = visitProgram(program, {
+            rootPath: logicDir,
+            typesPath: logicDir,
+            sourceFilePath: secondLogicPath,
+            log: () => {},
+        })
+
+        expect(parsedLogics.map((logic) => logic.logicName)).toEqual(['secondLogic'])
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+})

package/src/cli/typegen.ts

@@ -18,7 +18,11 @@ yargs
         await runTypeGen({ ...includeKeaConfig(parsedToAppOptions(argv)), write: true, watch: true })
     })
     .option('config', { alias: 'c', describe: 'Path to tsconfig.json (otherwise auto-detected)', type: 'string' })
-    .option('file', { alias: 'f', describe: "Single file to evaluate (can't be used with --config)", type: 'string' })
+    .option('file', {
+        alias: 'f',
+        describe: 'Single file to evaluate. Uses --config/.kearc compiler options when available.',
+        type: 'string',
+    })
     .option('root', {
         alias: 'r',
         describe: 'Root for logic paths. E.g: ./frontend/src',
@@ -51,6 +55,11 @@ yargs
         describe: 'Cache generated logic files into .typegen, use them if generating a logic type for the first time',
         type: 'boolean',
     })
+    .option('prettier', {
+        describe: 'Format generated logic type declarations with Prettier (use --no-prettier to skip)',
+        type: 'boolean',
+        default: true,
+    })
     .option('verbose', { describe: 'Slightly more verbose output log', type: 'boolean' })
     .demandCommand()
     .help()

package/src/print/print.ts

@@ -40,8 +40,16 @@ import { printInternalExtraInput } from './printInternalExtraInput'
 import { convertToBuilders } from '../write/convertToBuilders'
 import { cacheWrittenFile } from '../cache'
 
+const prettierConfigCache = new Map<string, Promise<prettier.Options | null>>()
+
 export async function runThroughPrettier(sourceText: string, filePath: string): Promise<string> {
-    const options = await prettier.resolveConfig(filePath)
+    let configPromise = prettierConfigCache.get(filePath)
+    if (!configPromise) {
+        configPromise = prettier.resolveConfig(filePath, { useCache: true })
+        prettierConfigCache.set(filePath, configPromise)
+    }
+
+    const options = await configPromise
     if (options) {
         try {
             return await prettier.format(sourceText, { ...options, filepath: filePath })
@@ -107,11 +115,12 @@ export async function printToFiles(
         const logicStrings = []
         const requiredKeys = new Set(['Logic'])
         for (const parsedLogic of parsedLogics) {
-            const logicTypeStirng = await runThroughPrettier(
-                nodeToString(parsedLogic.interfaceDeclaration),
-                typeFileName,
+            const logicTypeString = nodeToString(parsedLogic.interfaceDeclaration)
+            logicStrings.push(
+                appOptions.prettier === false
+                    ? logicTypeString
+                    : await runThroughPrettier(logicTypeString, typeFileName),
             )
-            logicStrings.push(logicTypeStirng)
             for (const string of parsedLogic.importFromKeaInLogicType.values()) {
                 requiredKeys.add(string)
             }

package/src/test-support/watch-mode-smoke.js

@@ -1,12 +1,15 @@
 const fs = require('fs')
+const os = require('os')
 const path = require('path')
 
 require('ts-node/register/transpile-only')
 
 const repoRoot = path.resolve(__dirname, '..', '..')
-const projectDir = fs.mkdtempSync(path.join(repoRoot, 'tmp-watch-smoke-'))
+const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-watch-smoke-'))
 const tsconfigPath = path.join(projectDir, 'tsconfig.json')
+const keaDtsPath = path.join(projectDir, 'node_modules', 'kea', 'index.d.ts')
 const fileCount = 200
+const logicPaths = []
 
 const noop = () => {}
 console.info = noop
@@ -18,6 +21,10 @@ let completed = 0
 let settleTimer
 let timeoutTimer
 let finished = false
+let editTriggered = false
+let incrementalAfterEdit = false
+const parsedLogicCountsAfterEdit = []
+const sourceFilePathsAfterEdit = []
 
 function cleanup() {
     try {
@@ -41,16 +48,31 @@ function finish(code) {
             completed,
             active,
             maxActive,
+            incrementalAfterEdit,
+            parsedLogicCountsAfterEdit,
+            sourceFilePathsAfterEdit,
         }) + '\n',
     )
     process.exit(code)
 }
 
 function scheduleFinishIfSettled() {
-    if (started > 1 && active === 0) {
-        clearTimeout(settleTimer)
-        settleTimer = setTimeout(() => finish(0), 300)
+    if (active !== 0) {
+        return
     }
+
+    clearTimeout(settleTimer)
+    settleTimer = setTimeout(() => {
+        if (!editTriggered && started > 1) {
+            editTriggered = true
+            fs.appendFileSync(logicPaths[0], '\n// trigger incremental watch pass\n')
+            return
+        }
+
+        if (editTriggered && incrementalAfterEdit) {
+            finish(0)
+        }
+    }, 300)
 }
 
 process.on('uncaughtException', (error) => {
@@ -82,9 +104,13 @@ fs.writeFileSync(
     ),
 )
 
+fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
+fs.writeFileSync(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+
 for (let i = 0; i < fileCount; i++) {
     const dir = path.join(projectDir, 'src', `group${String(i % 10).padStart(2, '0')}`)
     const filePath = path.join(dir, `logic${i}.ts`)
+    logicPaths.push(filePath)
 
     fs.mkdirSync(dir, { recursive: true })
     fs.writeFileSync(
@@ -109,11 +135,20 @@ const printModule = require(path.join(repoRoot, 'src/print/print'))
 const originalPrintToFiles = printModule.printToFiles
 
 printModule.printToFiles = async function (...args) {
+    const appOptions = args[1]
+    const parsedLogics = args[2]
+
     active += 1
     started += 1
     maxActive = Math.max(maxActive, active)
     clearTimeout(settleTimer)
 
+    if (editTriggered) {
+        parsedLogicCountsAfterEdit.push(parsedLogics.length)
+        sourceFilePathsAfterEdit.push(appOptions.sourceFilePath || null)
+        incrementalAfterEdit = incrementalAfterEdit || (parsedLogics.length === 1 && !!appOptions.sourceFilePath)
+    }
+
     await new Promise((resolve) => setTimeout(resolve, 25))
 
     try {

package/src/test-support/write-mode-smoke.js

@@ -1,13 +1,15 @@
 const fs = require('fs')
 const Module = require('module')
+const os = require('os')
 const path = require('path')
 
 require('ts-node/register/transpile-only')
 
 const repoRoot = path.resolve(__dirname, '..', '..')
-const projectDir = fs.mkdtempSync(path.join(repoRoot, 'tmp-write-smoke-'))
+const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kea-typegen-write-smoke-'))
 const tsconfigPath = path.join(projectDir, 'tsconfig.json')
 const logicFilePath = path.join(projectDir, 'src', 'logic.ts')
+const keaDtsPath = path.join(projectDir, 'node_modules', 'kea', 'index.d.ts')
 
 const noop = () => {}
 
@@ -83,6 +85,7 @@ process.on('unhandledRejection', (error) => {
 })
 
 fs.mkdirSync(path.dirname(logicFilePath), { recursive: true })
+fs.mkdirSync(path.dirname(keaDtsPath), { recursive: true })
 fs.writeFileSync(
     tsconfigPath,
     JSON.stringify(
@@ -102,6 +105,8 @@ fs.writeFileSync(
     ),
 )
 
+fs.writeFileSync(keaDtsPath, 'export function kea<T = any>(input: any): T\n')
+
 fs.writeFileSync(
     logicFilePath,
     [