@pikku/cli 0.12.70 → 0.12.71

package/dist/src/functions/commands/tests-coverage.js

@@ -1,273 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, relative, dirname } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import ts from 'typescript';
-import { pikkuSessionlessFunc } from '#pikku';
-function innerBody(init) {
-    if (!ts.isCallExpression(init))
-        return null;
-    for (const arg of init.arguments) {
-        if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg))
-            return arg.body;
-        if (ts.isObjectLiteralExpression(arg)) {
-            for (const p of arg.properties) {
-                if (ts.isPropertyAssignment(p) &&
-                    ts.isIdentifier(p.name) &&
-                    p.name.text === 'func' &&
-                    (ts.isArrowFunction(p.initializer) ||
-                        ts.isFunctionExpression(p.initializer)))
-                    return p.initializer.body;
-            }
-        }
-    }
-    return null;
-}
-function bodySpan(file, exportedName, astCache) {
-    let sf = astCache.get(file);
-    if (!sf) {
-        sf = ts.createSourceFile(file, readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, true);
-        astCache.set(file, sf);
-    }
-    const lineOf = (pos) => sf.getLineAndCharacterOfPosition(pos).line + 1;
-    const isExported = (node) => ts.canHaveModifiers(node) &&
-        ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-    const spanOfBody = (body) => {
-        if (ts.isBlock(body) && body.statements.length) {
-            return {
-                start: lineOf(body.statements[0].getStart(sf)),
-                end: lineOf(body.statements[body.statements.length - 1].getEnd()),
-            };
-        }
-        return { start: lineOf(body.getStart(sf)), end: lineOf(body.getEnd()) };
-    };
-    let span = null;
-    sf.forEachChild((node) => {
-        if (span)
-            return;
-        if (ts.isVariableStatement(node) && isExported(node)) {
-            for (const decl of node.declarationList.declarations) {
-                if (ts.isIdentifier(decl.name) &&
-                    decl.name.text === exportedName &&
-                    decl.initializer) {
-                    const body = innerBody(decl.initializer);
-                    span = body
-                        ? spanOfBody(body)
-                        : {
-                            start: lineOf(decl.initializer.getStart(sf)),
-                            end: lineOf(decl.initializer.getEnd()),
-                        };
-                }
-            }
-        }
-        else if (ts.isFunctionDeclaration(node) &&
-            node.name?.text === exportedName &&
-            isExported(node) &&
-            node.body) {
-            span = spanOfBody(node.body);
-        }
-    });
-    return span;
-}
-function lineCoverage(fileCov, span) {
-    const covered = new Set();
-    const missed = new Set();
-    if (fileCov) {
-        for (const id of Object.keys(fileCov.statementMap)) {
-            const ln = fileCov.statementMap[id].start.line;
-            if (ln >= span.start && ln <= span.end) {
-                if (fileCov.s[id] > 0)
-                    covered.add(ln);
-                else
-                    missed.add(ln);
-            }
-        }
-    }
-    for (const ln of covered)
-        missed.delete(ln);
-    return {
-        covered: [...covered].sort((a, b) => a - b),
-        missed: [...missed].sort((a, b) => a - b),
-    };
-}
-export const pikkuTestsCoverage = pikkuSessionlessFunc({
-    func: async ({ logger, config }, input) => {
-        const noRun = input?.noRun ?? false;
-        const aiOut = input?.aiOut ?? null;
-        const packageMappings = config.packageMappings ?? {};
-        const srcDirs = config.srcDirectories ?? [];
-        const functionsRelDir = Object.keys(packageMappings).find((key) => srcDirs.some((src) => src === key || src.startsWith(key + '/'))) ?? Object.keys(packageMappings)[0];
-        if (!functionsRelDir) {
-            logger.error('packageMappings must have at least one entry pointing to your functions package');
-            process.exit(1);
-        }
-        const functionsDir = join(config.rootDir, functionsRelDir);
-        const ftestDir = join(functionsDir, 'tests');
-        if (!existsSync(ftestDir)) {
-            logger.error(`tests directory not found at ${ftestDir}. Run 'pikku tests init' first.`);
-            process.exit(1);
-        }
-        const verboseMetaPath = join(config.outDir, 'function', 'pikku-functions-meta-verbose.gen.json');
-        if (!existsSync(verboseMetaPath)) {
-            logger.error(`Verbose metadata not found at ${verboseMetaPath}. Run 'pikku all' first.`);
-            process.exit(1);
-        }
-        const coverageFinal = join(functionsDir, '.coverage', 'coverage-final.json');
-        const outDir = join(ftestDir, '.coverage');
-        const outFile = join(outDir, 'function-coverage.json');
-        if (!noRun) {
-            const findBin = (name, searchFrom) => {
-                let dir = searchFrom;
-                for (let i = 0; i < 6; i++) {
-                    const candidate = join(dir, 'node_modules', '.bin', name);
-                    if (existsSync(candidate))
-                        return candidate;
-                    const parent = dirname(dir);
-                    if (parent === dir)
-                        break;
-                    dir = parent;
-                }
-                return name; // fallback: assume on PATH
-            };
-            const c8 = findBin('c8', ftestDir);
-            const cucumber = findBin('cucumber-js', ftestDir);
-            const envFile = join(ftestDir, '.env.test');
-            const spawnEnv = { ...process.env };
-            if (existsSync(envFile)) {
-                for (const line of readFileSync(envFile, 'utf8').split('\n')) {
-                    const trimmed = line.trim();
-                    if (!trimmed || trimmed.startsWith('#'))
-                        continue;
-                    const eq = trimmed.indexOf('=');
-                    if (eq < 0)
-                        continue;
-                    spawnEnv[trimmed.slice(0, eq).trim()] = trimmed
-                        .slice(eq + 1)
-                        .trim()
-                        .replace(/^['"]|['"]$/g, '');
-                }
-            }
-            logger.info('Running function tests under c8...');
-            const res = spawnSync(process.execPath, [
-                c8,
-                '--src',
-                'src',
-                '--include',
-                'src/**',
-                '--report-dir',
-                '.coverage',
-                '--reporter',
-                'json',
-                '--reporter',
-                'text-summary',
-                cucumber,
-                '--require-module',
-                'tsx',
-                '--require',
-                'tests/tests/support/**/*.ts',
-                'tests/tests/features/**/*.feature',
-                '--format',
-                'progress',
-                // Persist the HTML report so the console can parse scenarios back out
-                // of it (readAllMeta attaches them per function).
-                '--format',
-                'html:tests/tests/reports/cucumber-report.html',
-            ], { cwd: functionsDir, stdio: 'inherit', env: spawnEnv });
-            if (res.status !== 0) {
-                logger.error(`Test run failed (exit ${res.status})`);
-                process.exit(res.status ?? 1);
-            }
-        }
-        if (!existsSync(coverageFinal)) {
-            logger.error(`coverage-final.json not found at ${coverageFinal}. Run without --no-run.`);
-            process.exit(1);
-        }
-        const coverage = JSON.parse(readFileSync(coverageFinal, 'utf8'));
-        const meta = JSON.parse(readFileSync(verboseMetaPath, 'utf8'));
-        const astCache = new Map();
-        const functions = Object.values(meta)
-            .filter((m) => m.sourceFile && !m.sourceFile.endsWith('.gen.ts'))
-            .map((m) => {
-            const span = bodySpan(m.sourceFile, m.exportedName, astCache);
-            const { covered, missed } = span
-                ? lineCoverage(coverage[m.sourceFile], span)
-                : { covered: [], missed: [] };
-            const total = covered.length + missed.length;
-            const ratio = total ? covered.length / total : 0;
-            const status = total === 0
-                ? 'unknown'
-                : covered.length === 0
-                    ? 'uncovered'
-                    : missed.length === 0
-                        ? 'covered'
-                        : 'partial';
-            return {
-                name: m.name,
-                sourceFile: relative(functionsDir, m.sourceFile),
-                exposed: m.expose !== false,
-                description: m.description ?? null,
-                coveredLines: covered.length,
-                totalLines: total,
-                missedLines: missed,
-                ratio: Number(ratio.toFixed(3)),
-                status,
-            };
-        })
-            .sort((a, b) => a.ratio - b.ratio || a.name.localeCompare(b.name));
-        const summary = {
-            total: functions.length,
-            covered: 0,
-            partial: 0,
-            uncovered: 0,
-            unknown: 0,
-        };
-        for (const f of functions)
-            summary[f.status]++;
-        const overallRatio = functions.length
-            ? Number((functions.reduce((a, f) => a + f.ratio, 0) / functions.length).toFixed(3))
-            : 0;
-        mkdirSync(outDir, { recursive: true });
-        writeFileSync(outFile, JSON.stringify({
-            generatedAt: new Date().toISOString(),
-            summary: { ...summary, overallRatio },
-            functions,
-        }, null, 2) + '\n');
-        const uncovered = functions.filter((f) => f.status === 'uncovered');
-        console.log(`\nFunction coverage → ${relative(config.rootDir, outFile)}`);
-        console.log(`  ${summary.covered} covered · ${summary.partial} partial · ${summary.uncovered} uncovered · ${summary.unknown} unknown (overall ${(overallRatio * 100).toFixed(1)}%)`);
-        if (uncovered.length)
-            console.log(`  uncovered: ${uncovered.map((f) => f.name).join(', ')}`);
-        if (aiOut !== null) {
-            const generatedAt = new Date().toISOString();
-            const pct = Math.round(overallRatio * 100);
-            const needWork = functions.filter((f) => f.status !== 'covered');
-            const lines = [
-                `Coverage report — generated ${generatedAt}.`,
-                `Overall: ${pct}% (${summary.covered}/${summary.total} functions fully covered)`,
-                '',
-                needWork.length === 0
-                    ? 'All functions are fully covered — nothing to do!'
-                    : `Functions needing coverage (${needWork.length}):`,
-                ...needWork.flatMap((fn) => {
-                    const ratio = Math.round(fn.ratio * 100);
-                    const missed = fn.missedLines.length > 0 ? fn.missedLines.join(', ') : 'none';
-                    return [
-                        `- ${fn.name} [${fn.status}, ${ratio}% covered, ${fn.coveredLines}/${fn.totalLines} lines]`,
-                        `  file: ${fn.sourceFile}`,
-                        `  missed lines: ${missed}`,
-                    ];
-                }),
-            ];
-            if (needWork.length > 0) {
-                lines.push('', 'Write @pikku/cucumber Gherkin scenarios (no custom steps) in tests/tests/features/ to cover the missed lines above.', 'Use pikku meta to get versioned RPC names and function schemas before writing.', 'Run pikku tests coverage after writing to verify coverage improved.');
-            }
-            const prompt = lines.join('\n') + '\n';
-            if (aiOut === '-') {
-                process.stdout.write(prompt);
-            }
-            else {
-                writeFileSync(aiOut, prompt, 'utf-8');
-                console.log(`AI prompt → ${relative(config.rootDir, aiOut)}`);
-            }
-        }
-    },
-});

package/dist/src/functions/commands/tests-init.d.ts

@@ -1,7 +0,0 @@
-export declare const pikkuTestsInit: import("#pikku").PikkuFunctionConfig<{
-    force?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
-    force?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
-    force?: boolean;
-}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/tests-init.js

@@ -1,274 +0,0 @@
-import { existsSync } from 'fs';
-import { mkdir, writeFile } from 'fs/promises';
-import { dirname, join, relative } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
-const toJs = (p) => p.replace(/\.(?:d\.)?ts$/, '.js');
-// ---------------------------------------------------------------------------
-// Template generators
-// ---------------------------------------------------------------------------
-function packageJson() {
-    return JSON.stringify({
-        name: 'tests',
-        version: '0.0.1',
-        private: true,
-        type: 'module',
-        description: 'Function test harness — Cucumber over in-process Pikku RPC with stubbed services.',
-        scripts: {
-            test: "node --env-file=.env.test node_modules/.bin/cucumber-js --config tests/cucumber.mjs --tags 'not @skip'",
-            'test:tag': 'node --env-file=.env.test node_modules/.bin/cucumber-js --config tests/cucumber.mjs --tags',
-            coverage: 'pikku tests coverage',
-            tsc: 'tsc --noEmit',
-        },
-        dependencies: {
-            '@pikku/cucumber': '^0.12.0',
-            '@pikku/kysely-node-sqlite': '^0.12.0',
-        },
-        devDependencies: {
-            '@cucumber/cucumber': '^11.0.0',
-            '@types/node': '^22',
-            c8: '^10.0.0',
-            tsx: '^4.21.0',
-            typescript: '~5.8.0',
-        },
-    }, null, 2);
-}
-function tsconfig() {
-    return JSON.stringify({
-        compilerOptions: {
-            target: 'ES2022',
-            module: 'NodeNext',
-            moduleResolution: 'NodeNext',
-            types: ['node'],
-            noEmit: true,
-            skipLibCheck: true,
-            esModuleInterop: true,
-            resolveJsonModule: true,
-            strict: true,
-        },
-        include: ['tests/**/*.ts'],
-    }, null, 2);
-}
-function envTest() {
-    return `# Environment variables required by createConfig() during tests.
-# Add any env vars your config.ts reads at module load time.
-# This file is loaded via --env-file and is NOT committed to version control.
-NODE_ENV=test
-`;
-}
-function cucumberMjs() {
-    return `export default {
-  requireModule: ['tsx'],
-  require: ['tests/support/**/*.ts', 'tests/steps/**/*.ts'],
-  paths: ['tests/features/**/*.feature'],
-  format: ['progress', 'html:tests/reports/cucumber-report.html'],
-  forceExit: true,
-}
-`;
-}
-function hooksTs(bootstrapImport) {
-    return `import '${bootstrapImport}'
-import { Before, After, BeforeAll, AfterAll, setDefaultTimeout, Given, When, Then } from '@cucumber/cucumber'
-import { registerHooks, registerCommonSteps } from '@pikku/cucumber'
-import { db } from './services.js'
-
-registerHooks({ Before, After, BeforeAll, AfterAll, setDefaultTimeout }, db)
-registerCommonSteps({ Given, When, Then })
-`;
-}
-function starterFeature() {
-    return `Feature: Example function test
-
-  Starter scenario created by \`pikku tests init\`. It uses only the built-in
-  pikku/cucumber steps (no custom step code) and passes out of the box, so the
-  Run-tests button and coverage report work immediately. Replace it with real
-  scenarios that call your RPCs — see the commented example at the bottom.
-
-  Scenario: the function-test harness is wired up
-    Given the data "example" is:
-      | hello | world |
-    Then the data "example" is not empty
-
-  # Real example — call one of your RPCs and assert the outcome. Uncomment and
-  # adapt (run \`pikku meta\` to list versioned RPC names and input schemas):
-  #
-  # Scenario: an anonymous user cannot reach a protected RPC
-  #   When an anonymous user calls "yourProtectedRpc"
-  #   Then the call fails with "Unauthorized"
-  #
-  # Scenario: a public RPC returns data
-  #   When an anonymous user calls "yourPublicRpc" with:
-  #     | someField | someValue |
-  #   Then the call succeeds
-  #   And the result has "id"
-`;
-}
-function worldTs() {
-    return `import { World, setWorldConstructor } from '@cucumber/cucumber'
-import { createFunctionWorld } from '@pikku/cucumber'
-import { createStubServices } from './services.js'
-
-createFunctionWorld(World, setWorldConstructor, createStubServices)
-`;
-}
-function servicesTs(configImport, servicesImport, schemaImport, coercionImport, configVar, servicesVar, repoRootRel, hasDb, migrationsRel, seedRel) {
-    if (!hasDb) {
-        return `import { createDbUtils, type StubTracker } from '@pikku/cucumber'
-import { ${configVar} } from '${configImport}'
-import { ${servicesVar} } from '${servicesImport}'
-
-export const db = createDbUtils({ migrationsDir: '', seedFile: '' })
-
-export async function createStubServices(_dbFile: string, tracker: StubTracker) {
-  const injected = new Proxy({} as Record<string, unknown>, {
-    get(_, prop: string) { return tracker.stub(prop) },
-  })
-  const config = await ${configVar}()
-  const services = await ${servicesVar}(config as never, injected as never)
-  return { services }
-}
-`;
-    }
-    return `import { createNodeSqliteKysely, createCoercionPlugin } from '@pikku/kysely-node-sqlite'
-import { createDbUtils, type StubTracker } from '@pikku/cucumber'
-import { ${configVar} } from '${configImport}'
-import { ${servicesVar} } from '${servicesImport}'
-import { coercionMap } from '${coercionImport}'
-import type { DB } from '${schemaImport}'
-import { dirname, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const repoRoot = (p: string) => resolve(__dirname, '${repoRootRel}', p)
-
-export const db = createDbUtils({
-  migrationsDir: repoRoot('${migrationsRel}'),
-  seedFile: repoRoot('${seedRel}'),
-})
-
-type StubKysely = ReturnType<typeof createNodeSqliteKysely<DB>>
-
-const REAL_SERVICES = (kysely: StubKysely) => ({ kysely })
-
-export async function createStubServices(dbFile: string, tracker: StubTracker) {
-  const kysely = createNodeSqliteKysely<DB>({
-    filename: dbFile,
-    camelCase: true,
-    plugins: [createCoercionPlugin({ map: coercionMap })],
-  })
-
-  const real = REAL_SERVICES(kysely)
-  const injected = new Proxy(real as Record<string, unknown>, {
-    get(target, prop: string) {
-      if (prop in target) return target[prop]
-      return tracker.stub(prop)
-    },
-  })
-
-  const config = await ${configVar}()
-  const services = await ${servicesVar}(
-    { ...config, dev: { db: { file: dbFile } } } as never,
-    injected as never,
-  )
-
-  return { services, kysely }
-}
-`;
-}
-// ---------------------------------------------------------------------------
-// Command
-// ---------------------------------------------------------------------------
-export const pikkuTestsInit = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState }, input) => {
-        const force = input?.force;
-        const state = await getInspectorState(true);
-        const { pikkuConfigFactory, singletonServicesFactory } = state.filesAndMethods;
-        if (!pikkuConfigFactory) {
-            logger.error('createConfig not found — ensure it is exported from your project');
-            process.exit(1);
-        }
-        if (!singletonServicesFactory) {
-            logger.error('createSingletonServices not found — ensure it is exported from your project');
-            process.exit(1);
-        }
-        const packageMappings = config.packageMappings ?? {};
-        const srcDirs = config.srcDirectories ?? [];
-        const functionsRelDir = Object.keys(packageMappings).find((key) => srcDirs.some((src) => src === key || src.startsWith(key + '/'))) ?? Object.keys(packageMappings)[0];
-        if (!functionsRelDir) {
-            logger.error('packageMappings must have at least one entry pointing to your functions package');
-            process.exit(1);
-        }
-        const functionsDir = join(config.rootDir, functionsRelDir);
-        const ftestDir = join(functionsDir, 'tests');
-        if (existsSync(ftestDir) && !force) {
-            logger.error(`tests directory already exists at ${ftestDir}. Use --force to overwrite.`);
-            process.exit(1);
-        }
-        const supportDir = join(ftestDir, 'tests', 'support');
-        const rel = (abs) => {
-            const r = relative(supportDir, abs);
-            return r.startsWith('.') ? r : './' + r;
-        };
-        const bootstrapImport = toJs(rel(join(config.outDir, 'pikku-bootstrap.gen.ts')));
-        const configImport = toJs(rel(pikkuConfigFactory.file));
-        const servicesImport = toJs(rel(singletonServicesFactory.file));
-        // coercion/schema may live under outDir/db (new default) or rootDir/db (legacy)
-        const schemaInOutDir = join(config.outDir, 'db', 'schema.gen.ts');
-        const schemaInRootDir = join(config.rootDir, 'db', 'schema.gen.ts');
-        const schemaFile = existsSync(schemaInOutDir)
-            ? schemaInOutDir
-            : schemaInRootDir;
-        const coercionInOutDir = join(config.outDir, 'db', 'coercion.gen.ts');
-        const coercionInRootDir = join(config.rootDir, 'db', 'coercion.gen.ts');
-        const coercionFile = existsSync(coercionInOutDir)
-            ? coercionInOutDir
-            : coercionInRootDir;
-        const schemaImport = toJs(rel(schemaFile));
-        const coercionImport = toJs(rel(coercionFile));
-        const repoRootRel = relative(supportDir, config.rootDir);
-        // Engine-aware db layout: stages live under db/sqlite or db/postgres with a
-        // matching db/<engine>-seed.sql (see the deploy convention). Pick whichever
-        // engine the project actually ships migrations for.
-        const engine = existsSync(join(config.rootDir, 'db', 'sqlite'))
-            ? 'sqlite'
-            : existsSync(join(config.rootDir, 'db', 'postgres'))
-                ? 'postgres'
-                : null;
-        // Only sqlite runs in the harness today (node:sqlite); postgres falls back
-        // to stubbed services until a pglite-backed harness lands.
-        const hasDb = engine === 'sqlite';
-        const migrationsRel = engine ? `db/${engine}` : '';
-        const seedRel = engine ? `db/${engine}-seed.sql` : '';
-        if (engine === 'postgres') {
-            logger.info('Note: Postgres function-test harness support is not wired yet (the harness runs on node:sqlite). Tracking in pikkujs/pikku#758 — the scaffold falls back to stubbed services.');
-        }
-        const files = [
-            [join(ftestDir, '.env.test'), envTest()],
-            // Empty lockfile so Yarn Berry treats tests/ as a standalone project
-            // rather than expecting it in the parent repo's workspaces (the harness
-            // is intentionally outside the workspace graph).
-            [join(ftestDir, 'yarn.lock'), ''],
-            [join(ftestDir, 'package.json'), packageJson()],
-            [join(ftestDir, 'tsconfig.json'), tsconfig()],
-            [join(ftestDir, 'tests', 'cucumber.mjs'), cucumberMjs()],
-            [join(supportDir, 'hooks.ts'), hooksTs(bootstrapImport)],
-            [join(supportDir, 'world.ts'), worldTs()],
-            [
-                join(supportDir, 'services.ts'),
-                servicesTs(configImport, servicesImport, schemaImport, coercionImport, pikkuConfigFactory.variable, singletonServicesFactory.variable, repoRootRel, hasDb, migrationsRel, seedRel),
-            ],
-            [
-                join(ftestDir, 'tests', 'features', 'example.feature'),
-                starterFeature(),
-            ],
-        ];
-        for (const [filePath, content] of files) {
-            await mkdir(dirname(filePath), { recursive: true });
-            await writeFile(filePath, content, 'utf-8');
-            logger.info(`  created ${relative(config.rootDir, filePath)}`);
-        }
-        logger.info('\nFunction test harness initialized.');
-        logger.info('Next steps:');
-        logger.info('  1. Install deps in tests/ and run: yarn test');
-        logger.info('  2. Edit tests/tests/features/example.feature — add scenarios that call your RPCs');
-    },
-});