proteum 2.5.1 → 2.5.2

package/tests/eslint-rules.test.cjs

@@ -146,6 +146,28 @@ test('proteum lint allows client catches routed to context app error handling',
     assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
 });
 
+test('proteum lint rejects optional client error handler calls', () => {
+    for (const statement of [
+        'app?.handleError(error);',
+        'context.app?.handleError(error);',
+        'window.app?.handleError(error);',
+    ]) {
+        const messages = lint(`
+            export const run = async () => {
+                const app = useContext();
+                const context = useContext();
+                try {
+                    await Investor.api.ensureApiKey();
+                } catch (error) {
+                    ${statement}
+                }
+            };
+        `);
+
+        assert.equal(messages.some((message) => message.ruleId === swallowedErrorRuleId), true);
+    }
+});
+
 test('proteum lint allows client catches using app error messages for UI feedback', () => {
     const messages = lint(`
         export const run = async () => {
@@ -221,6 +243,67 @@ test('proteum lint allows server catches routed to app error reporting', () => {
     assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
 });
 
+test('proteum lint allows server catches routed to instance app error reporting', () => {
+    const messages = lint(
+        `
+            export class WorkerController {
+                async run(context) {
+                    try {
+                        await context.services.Worker.run();
+                    } catch (error) {
+                        await this.app.reportError(error, context.request);
+                    }
+                }
+            }
+        `,
+        'server/example.ts',
+    );
+
+    assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
+});
+
+test('proteum lint rejects optional server error reporter calls', () => {
+    for (const statement of [
+        'app.reportError?.(error);',
+        'app?.reportError(error);',
+        'context.app?.reportError(error);',
+    ]) {
+        const messages = lint(
+            `
+                export const run = async (context) => {
+                    const app = context.app;
+                    try {
+                        await context.services.Worker.run();
+                    } catch (error) {
+                        ${statement}
+                    }
+                };
+            `,
+            'server/example.ts',
+        );
+
+        assert.equal(messages.some((message) => message.ruleId === swallowedErrorRuleId), true);
+    }
+});
+
+test('proteum lint rejects conditional server error reporter calls', () => {
+    const messages = lint(
+        `
+            export const run = async (context) => {
+                const app = context.app;
+                try {
+                    await context.services.Worker.run();
+                } catch (error) {
+                    if (app) app.reportError(error, context.request);
+                }
+            };
+        `,
+        'server/example.ts',
+    );
+
+    assert.equal(messages.some((message) => message.ruleId === swallowedErrorRuleId), true);
+});
+
 test('proteum lint rejects server catches routed to client app error handling', () => {
     const messages = lint(
         `
@@ -271,6 +354,23 @@ test('proteum lint allows manual promise rejection', () => {
     assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
 });
 
+test('proteum lint allows returning manual promise rejection', () => {
+    const messages = lint(
+        `
+            export const run = async (input) => {
+                try {
+                    await input.load();
+                } catch (error) {
+                    return Promise.reject(error);
+                }
+            };
+        `,
+        'common/example.ts',
+    );
+
+    assert.equal(messages.filter((message) => message.ruleId === swallowedErrorRuleId).length, 0);
+});
+
 test('proteum lint allows direct reject promise catch handlers', () => {
     const messages = lint(
         `

package/tests/scaffold-templates.test.cjs

@@ -6,13 +6,38 @@ process.env.TS_NODE_PROJECT = path.join(coreRoot, 'cli', 'tsconfig.json');
 process.env.TS_NODE_TRANSPILE_ONLY = '1';
 require('ts-node/register/transpile-only');
 
-const { createServerIndexTemplate } = require('../cli/scaffold/templates.ts');
+const { createCommandTemplate, createControllerTemplate, createServerIndexTemplate } = require('../cli/scaffold/templates.ts');
 
 test('server index scaffold uses explicit defineApplication router property', () => {
     const content = createServerIndexTemplate({ appIdentifier: 'ExampleApp' });
 
-    assert.match(content, /export default defineApplication\(\{/);
+    assert.match(content, /const ExampleAppApplication = defineApplication\(\{/);
+    assert.match(content, /export type ExampleApp = InstanceType<typeof ExampleAppApplication>/);
+    assert.match(content, /export default ExampleAppApplication/);
+    assert.match(content, /export type TControllerRequestServices = \{\}/);
     assert.match(content, /services: \(\) => \(\{\}\),/);
     assert.match(content, /router: \(app\) =>\s+new Router\(/);
     assert.doesNotMatch(content, /services: \(app\) => \(\{\s+Router: new Router\(/);
 });
+
+test('controller scaffold imports app-typed generated controller helpers', () => {
+    const content = createControllerTemplate({
+        appIdentifier: 'ExampleApp',
+        className: 'BillingController',
+        methodName: 'read',
+    });
+
+    assert.match(content, /from '@generated\/server\/controller'/);
+    assert.doesNotMatch(content, /from '@server\/app\/controller'/);
+});
+
+test('command scaffold infers app type from defineApplication default export', () => {
+    const content = createCommandTemplate({
+        className: 'BillingCommands',
+        methodName: 'sync',
+    });
+
+    assert.match(content, /import type AppApplication from '@\/server\/index'/);
+    assert.match(content, /type App = InstanceType<typeof AppApplication>/);
+    assert.doesNotMatch(content, /import type App from '@\/server\/index'/);
+});

package/tests/verify-changed.test.cjs

@@ -0,0 +1,200 @@
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const coreRoot = path.resolve(__dirname, '..');
+const cliBin = path.join(coreRoot, 'cli', 'bin.js');
+
+process.env.TS_NODE_PROJECT = path.join(coreRoot, 'cli', 'tsconfig.json');
+process.env.TS_NODE_TRANSPILE_ONLY = '1';
+require('ts-node/register/transpile-only');
+
+const { buildChangedVerificationPlan, runChangedVerification } = require('../cli/verification/changed.ts');
+
+const createRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-verify-changed-'));
+
+const writeFile = (root, filepath, content = '') => {
+    const fullPath = path.join(root, filepath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+};
+
+const planCommands = (plan) => plan.selectedChecks.map((check) => check.command);
+const planIds = (plan) => plan.selectedChecks.map((check) => check.id);
+
+test('changed verification planner runs changed test files directly', () => {
+    const root = createRoot();
+    writeFile(root, 'tests/unit/session.test.ts', 'test("session", () => {});\n');
+
+    const plan = buildChangedVerificationPlan({
+        cwd: root,
+        changedFiles: ['tests/unit/session.test.ts'],
+    });
+
+    assert.deepEqual(planCommands(plan), ["npx vitest run 'tests/unit/session.test.ts'"]);
+    assert.deepEqual(plan.selectedChecks[0].matchedFiles, ['tests/unit/session.test.ts']);
+});
+
+test('changed verification planner runs related tests for source files', () => {
+    const root = createRoot();
+    writeFile(root, 'packages/auth/src/session.ts', 'export const session = true;\n');
+
+    const plan = buildChangedVerificationPlan({
+        cwd: root,
+        changedFiles: ['packages/auth/src/session.ts'],
+    });
+
+    assert.deepEqual(planCommands(plan), ["npx vitest related 'packages/auth/src/session.ts'"]);
+    assert.deepEqual(plan.selectedChecks[0].matchedFiles, ['packages/auth/src/session.ts']);
+});
+
+test('changed verification planner loads project config and applies Klair-style MCP rules', () => {
+    const root = createRoot();
+    writeFile(
+        root,
+        'proteum.verify.config.ts',
+        `import { defineVerificationConfig } from 'proteum/config';
+
+export default defineVerificationConfig({
+    suites: {
+        mcpFast: 'npm run test:mcp:fast',
+        mcpBranches: 'npm run test:mcp:branches',
+    },
+    rules: [
+        {
+            id: 'mcp-fast',
+            match: ['packages/mcp/src/**', 'packages/2_usecases/src/mcp-v7/**'],
+            run: ['mcpFast'],
+            reason: 'MCP behavior changed.',
+        },
+        {
+            id: 'mcp-branches',
+            match: [
+                'packages/mcp/src/**/catalog*.ts',
+                'packages/mcp/src/**/dispatcher*.ts',
+                'packages/mcp/src/**/fallback*.ts',
+                'packages/mcp/src/**/validation*.ts',
+                'packages/2_usecases/src/mcp-v7/**/catalog*.ts',
+                'packages/2_usecases/src/mcp-v7/**/dispatcher*.ts',
+                'packages/2_usecases/src/mcp-v7/**/fallback*.ts',
+                'packages/2_usecases/src/mcp-v7/**/validation*.ts',
+            ],
+            run: ['mcpBranches'],
+            reason: 'MCP branch-risk behavior changed.',
+        },
+    ],
+});
+`,
+    );
+    writeFile(root, 'packages/mcp/src/server.ts', 'export const server = true;\n');
+    writeFile(root, 'packages/mcp/src/dispatcher.ts', 'export const dispatcher = true;\n');
+
+    const normalPlan = buildChangedVerificationPlan({
+        cwd: root,
+        changedFiles: ['packages/mcp/src/server.ts'],
+    });
+    assert.ok(planCommands(normalPlan).includes('npm run test:mcp:fast'));
+    assert.equal(planCommands(normalPlan).includes('npm run test:mcp:branches'), false);
+
+    const branchRiskPlan = buildChangedVerificationPlan({
+        cwd: root,
+        changedFiles: ['packages/mcp/src/dispatcher.ts'],
+    });
+    assert.ok(planCommands(branchRiskPlan).includes('npm run test:mcp:fast'));
+    assert.ok(planCommands(branchRiskPlan).includes('npm run test:mcp:branches'));
+});
+
+test('changed verification planner skips tests for docs-only changes', () => {
+    const root = createRoot();
+    writeFile(root, 'docs/testing.md', '# Testing\n');
+
+    const plan = buildChangedVerificationPlan({
+        cwd: root,
+        changedFiles: ['docs/testing.md'],
+    });
+
+    assert.deepEqual(plan.selectedChecks, []);
+    assert.equal(plan.docsOnly, true);
+    assert.deepEqual(plan.skippedChecks.map((check) => check.id), ['builtin:docs-only']);
+});
+
+test('changed verification dry-run reports the plan without executing checks', async () => {
+    const root = createRoot();
+    writeFile(
+        root,
+        'proteum.verify.config.ts',
+        `import { defineVerificationConfig } from 'proteum/config';
+
+export default defineVerificationConfig({
+    suites: {
+        fail: 'node -e "process.exit(7)"',
+    },
+    always: ['fail'],
+});
+`,
+    );
+    writeFile(root, 'README.md', '# Docs\n');
+
+    const result = await runChangedVerification({
+        cwd: root,
+        changedFiles: ['README.md'],
+        dryRun: true,
+    });
+
+    assert.equal(result.dryRun, true);
+    assert.equal(result.executions.length, 0);
+    assert.equal(result.result.ok, true);
+    assert.ok(planIds(result).includes('always:fail'));
+});
+
+test('changed verification captures command failures and returns a failed result', async () => {
+    const root = createRoot();
+    writeFile(
+        root,
+        'proteum.verify.config.ts',
+        `import { defineVerificationConfig } from 'proteum/config';
+
+export default defineVerificationConfig({
+    suites: {
+        fail: 'node -e "process.exit(7)"',
+    },
+    always: ['fail'],
+});
+`,
+    );
+    writeFile(root, 'README.md', '# Docs\n');
+
+    const result = await runChangedVerification({
+        cwd: root,
+        changedFiles: ['README.md'],
+    });
+
+    assert.equal(result.result.ok, false);
+    assert.equal(result.result.failedChecks, 1);
+    assert.deepEqual(result.executions.map((execution) => execution.status), ['failed']);
+    assert.equal(result.executions[0].exitCode, 7);
+});
+
+test('verify changed CLI JSON output keeps the planner and execution shape stable', () => {
+    const root = createRoot();
+    spawnSync('git', ['init'], { cwd: root, encoding: 'utf8' });
+    writeFile(root, 'docs/testing.md', '# Testing\n');
+
+    const result = spawnSync(process.execPath, [cliBin, 'verify', 'changed', '--dry-run', '--json'], {
+        cwd: root,
+        encoding: 'utf8',
+    });
+
+    assert.equal(result.status, 0, result.stderr);
+    const output = JSON.parse(result.stdout);
+
+    assert.deepEqual(output.changedFiles, ['docs/testing.md']);
+    assert.ok(Array.isArray(output.selectedChecks));
+    assert.ok(Array.isArray(output.skippedChecks));
+    assert.ok(Array.isArray(output.executions));
+    assert.equal(typeof output.result.ok, 'boolean');
+    assert.equal(output.result.selectedChecks, 0);
+    assert.equal(output.result.failedChecks, 0);
+});