proteum 2.5.1 → 2.5.3

package/tests/definition-contracts.test.cjs

@@ -18,6 +18,7 @@ const {
     indexRouteDefinitions,
     writeGeneratedRouteModule,
 } = require('../cli/compiler/common/generatedRouteModules.ts');
+const { createTypedControllerHelperContent } = require('../cli/compiler/artifacts/controllerHelper.ts');
 const { findClientRouteFiles } = require('../cli/compiler/artifacts/discovery.ts');
 const { indexControllers } = require('../cli/compiler/common/controllers.ts');
 const {
@@ -107,6 +108,51 @@ export default definePageRoute({
     assert.deepEqual(definition.normalizedOptionKeys, ['auth']);
 });
 
+test('route indexer accepts imported const-only option metadata', () => {
+    const root = createTempDir();
+    const filepath = path.join(root, 'client/pages/feed.tsx');
+    const catalogFilepath = path.join(root, 'client/catalogs/routes.ts');
+
+    writeFile(
+        catalogFilepath,
+        `export const PAGE_AUTH = {
+    feed: {
+        auth: {
+            hasFeature: 'opportunitiesFreq',
+        },
+        authTracking: {
+            source: 'investor_feed',
+            feature: 'opportunitiesFreq',
+            action: 'open-feed',
+            triggerKind: 'open',
+        },
+    },
+} as const;
+`,
+    );
+    writeFile(
+        filepath,
+        `import { definePageRoute } from '@common/router/definitions';
+import { PAGE_AUTH } from '@/client/catalogs/routes';
+
+export default definePageRoute({
+    path: '/feed',
+    options: {
+        auth: PAGE_AUTH.feed.auth,
+        authTracking: PAGE_AUTH.feed.authTracking,
+    },
+    data: null,
+    render: () => null,
+});
+`,
+    );
+
+    const [definition] = indexRouteDefinitions({ side: 'client', sourceFilepath: filepath });
+
+    assert.equal(definition.path, '/feed');
+    assert.deepEqual(definition.normalizedOptionKeys, ['auth', 'authTracking']);
+});
+
 test('router port override updates absolute runtime URLs', () => {
     const root = createTempDir();
 
@@ -262,6 +308,37 @@ export default defineServerRoutes(({ Users }) => [
     assert.equal(definition.targetResolution, 'static-expression');
 });
 
+test('server route factories can push explicit route definitions from a block body', () => {
+    const root = createTempDir();
+    const filepath = path.join(root, 'server/routes/api.ts');
+
+    writeFile(
+        filepath,
+        `import { defineServerRoute, defineServerRoutes } from '@common/router/definitions';
+
+export default defineServerRoutes((app) => {
+    const { Users } = app;
+    const routeOptions = {};
+    const routes = [];
+
+    routes.push(defineServerRoute({
+        method: 'GET',
+        path: '/api/users',
+        options: routeOptions,
+        handler: async () => Users.list(),
+    }));
+
+    return routes;
+});
+`,
+    );
+
+    const [definition] = indexRouteDefinitions({ side: 'server', sourceFilepath: filepath });
+
+    assert.equal(definition.methodName, 'get');
+    assert.equal(definition.path, '/api/users');
+});
+
 test('route definitions register through explicit router registrar', () => {
     const calls = [];
 
@@ -386,6 +463,17 @@ export default class Legacy extends Controller {
     );
 });
 
+test('generated typed controller helper binds action context to app root', () => {
+    const content = createTypedControllerHelperContent('TestApp');
+
+    assert.match(content, /@server\/app\/controller/);
+    assert.match(content, /@\/server\/index/);
+    assert.match(content, /export type TApplication = import\('@\/server\/index'\)\.TestApp/);
+    assert.match(content, /export type TControllerRequestServices = import\('@\/server\/index'\)\.TControllerRequestServices/);
+    assert.match(content, /TControllerActionContext<\n    TInput,\n    TApplication,\n    TControllerRequestServices\n>/);
+    assert.match(content, /handler: \(context: TTypedControllerActionContext<z\.output<TSchema>>\) => TResult/);
+});
+
 test('service artifact parser reads defineApplication router factories', () => {
     const root = createTempDir();
     const filepath = path.join(root, 'server/index.ts');
@@ -451,3 +539,44 @@ export default App;
     assert.deepEqual(bootstrap.rootServices.map((service) => service.registeredName), ['Router']);
     assert.deepEqual(bootstrap.routerPlugins.map((service) => service.registeredName), ['schema']);
 });
+
+test('service artifact parser reads named defineApplication service factories', () => {
+    const root = createTempDir();
+    const filepath = path.join(root, 'server/index.ts');
+    const serviceFilepath = path.join(root, 'server/services/Billing.ts');
+    const { parseAppBootstrapSource } = loadServiceArtifactsForAppRoot(root);
+
+    writeFile(serviceFilepath, 'export default class Billing {}');
+    writeFile(
+        filepath,
+        `import { defineApplication } from '@server/app';
+import Router from '@server/services/router';
+import SchemaRouter from '@server/services/schema/router';
+import Billing from '@/server/services/Billing';
+
+const createServices = (app) => ({
+    Billing: new Billing(app, {}, app),
+});
+
+const createRouter = (app) => new Router(
+    app,
+    {
+        plugins: {
+            schema: new SchemaRouter({}, app),
+        },
+    },
+    app,
+);
+
+export default defineApplication({
+    services: createServices,
+    router: createRouter,
+});
+`,
+    );
+
+    const bootstrap = parseAppBootstrapSource(filepath);
+
+    assert.deepEqual(bootstrap.rootServices.map((service) => service.registeredName), ['Billing', 'Router']);
+    assert.deepEqual(bootstrap.routerPlugins.map((service) => service.registeredName), ['schema']);
+});

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);
+});