@vertesia/common 1.6.0-dev.20260923.085325Z → 1.6.0-dev.20261004.085740Z

package/src/schema-for-extraction.test.ts

@@ -1,191 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-    isExtractableSchemaNode,
-    mergePreservingNonExtractable,
-    schemaForExtraction,
-} from './schema-for-extraction.js';
-
-describe('schemaForExtraction', () => {
-    it('drops top-level properties marked x-extract: false and cleans required', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                po_number: { type: 'string' },
-                match: { type: 'string', 'x-extract': false },
-                match_reason: { type: 'string', 'x-extract': false },
-            },
-            required: ['po_number', 'match'],
-        };
-        const filtered = schemaForExtraction(schema);
-        expect(Object.keys(filtered.properties as object).sort()).toEqual(['po_number']);
-        expect(filtered.required).toEqual(['po_number']);
-        expect((filtered.properties as Record<string, unknown>).po_number).toEqual({ type: 'string' });
-    });
-
-    it('drops nested and array-item properties with x-extract: false', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                line_items: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            part_number: { type: 'string' },
-                            match: { type: 'string', 'x-extract': false },
-                            quantity: { type: 'string' },
-                        },
-                        required: ['part_number', 'match'],
-                    },
-                },
-            },
-        };
-        const filtered = schemaForExtraction(schema);
-        const items = (filtered.properties as Record<string, Record<string, unknown>>).line_items.items as Record<
-            string,
-            unknown
-        >;
-        expect(Object.keys(items.properties as object).sort()).toEqual(['part_number', 'quantity']);
-        expect(items.required).toEqual(['part_number']);
-    });
-
-    it('treats missing x-extract as extractable', () => {
-        expect(isExtractableSchemaNode({ type: 'string' })).toBe(true);
-        expect(isExtractableSchemaNode({ type: 'string', 'x-extract': true })).toBe(true);
-        expect(isExtractableSchemaNode({ type: 'string', 'x-extract': false })).toBe(false);
-    });
-
-    it('filters $defs and drops properties that reference non-extractable definitions', () => {
-        const schema = {
-            type: 'object',
-            $defs: {
-                hidden: { type: 'string', 'x-extract': false },
-                visible: {
-                    type: 'object',
-                    properties: {
-                        value: { type: 'string' },
-                        match: { type: 'string', 'x-extract': false },
-                    },
-                    required: ['value', 'match'],
-                },
-            },
-            properties: {
-                hidden: { $ref: '#/$defs/hidden' },
-                visible: { $ref: '#/$defs/visible' },
-            },
-            required: ['hidden', 'visible'],
-        };
-
-        const filtered = schemaForExtraction(schema);
-
-        expect(filtered.$defs.hidden).toBeUndefined();
-        expect(filtered.$defs.visible).toEqual({
-            type: 'object',
-            properties: { value: { type: 'string' } },
-            required: ['value'],
-        });
-        expect(filtered.properties).toEqual({ visible: { $ref: '#/$defs/visible' } });
-        expect(filtered.required).toEqual(['visible']);
-    });
-
-    it('drops non-extractable anyOf branches', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                value: {
-                    anyOf: [{ type: 'string', 'x-extract': false }, { type: 'number' }],
-                },
-            },
-        };
-
-        const filtered = schemaForExtraction(schema);
-
-        expect((filtered.properties.value as { anyOf: unknown[] }).anyOf).toEqual([{ type: 'number' }]);
-    });
-});
-
-describe('mergePreservingNonExtractable', () => {
-    it('preserves non-extractable top-level values over model output', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                po_number: { type: 'string' },
-                match: { type: 'string', 'x-extract': false },
-            },
-        };
-        const existing = { po_number: 'OLD', match: 'erp-hit' };
-        const extracted = { po_number: 'NEW', match: 'model-invented' };
-        expect(mergePreservingNonExtractable(existing, extracted, schema)).toEqual({
-            po_number: 'NEW',
-            match: 'erp-hit',
-        });
-    });
-
-    it('clears extractable fields omitted by the latest extraction', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                po_number: { type: 'string' },
-                total: { type: 'number' },
-                match: { type: 'string', 'x-extract': false },
-            },
-        };
-        const existing = { po_number: 'STALE', total: 42, match: 'erp-hit' };
-        const extracted = { total: 50 };
-
-        expect(mergePreservingNonExtractable(existing, extracted, schema)).toEqual({
-            total: 50,
-            match: 'erp-hit',
-        });
-    });
-
-    it('does not preserve non-extractable array item fields by index', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                line_items: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            part: { type: 'string' },
-                            match: { type: 'string', 'x-extract': false },
-                        },
-                    },
-                },
-            },
-        };
-        const existing = {
-            line_items: [
-                { part: 'A', match: 'hit-a' },
-                { part: 'B', match: 'hit-b' },
-            ],
-        };
-        const extracted = {
-            line_items: [{ part: 'B2' }],
-        };
-        expect(mergePreservingNonExtractable(existing, extracted, schema)).toEqual({
-            line_items: [{ part: 'B2' }],
-        });
-    });
-
-    it('preserves top-level values referenced through non-extractable $defs', () => {
-        const schema = {
-            type: 'object',
-            $defs: {
-                match: { type: 'string', 'x-extract': false },
-            },
-            properties: {
-                po_number: { type: 'string' },
-                match: { $ref: '#/$defs/match' },
-            },
-        };
-        const existing = { po_number: 'OLD', match: 'erp-hit' };
-        const extracted = { po_number: 'NEW', match: 'model-invented' };
-
-        expect(mergePreservingNonExtractable(existing, extracted, schema)).toEqual({
-            po_number: 'NEW',
-            match: 'erp-hit',
-        });
-    });
-});

package/src/store/agent-approval.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { normalizeAgentToolApprovalMode } from './agent-approval.js';
-
-describe('normalizeAgentToolApprovalMode', () => {
-    it('defaults interactive runs to full_control when no mode is supplied', () => {
-        expect(normalizeAgentToolApprovalMode(undefined, true)).toBe('full_control');
-    });
-
-    it('keeps supplied modes for interactive runs', () => {
-        expect(normalizeAgentToolApprovalMode('ask', true)).toBe('ask');
-        expect(normalizeAgentToolApprovalMode('auto_review', true)).toBe('auto_review');
-    });
-
-    it('forces non-interactive runs to full_control', () => {
-        expect(normalizeAgentToolApprovalMode('ask', false)).toBe('full_control');
-        expect(normalizeAgentToolApprovalMode('auto_review', undefined)).toBe('full_control');
-    });
-});

package/src/store/content-type-editing.test.ts

@@ -1,17 +0,0 @@
-import Ajv from 'ajv';
-import { describe, expect, it } from 'vitest';
-import { ContentTypeEditingPolicySchema } from './editing-policy-schema.generated.js';
-
-const validate = new Ajv.default({ allErrors: true, strict: false }).compile(ContentTypeEditingPolicySchema);
-
-describe('ContentTypeEditingPolicySchema', () => {
-    it('accepts an omitted or configured interaction', () => {
-        expect(validate({})).toBe(true);
-        expect(validate({ interaction: 'sys:GeneralAgent' })).toBe(true);
-    });
-
-    it('rejects unknown fields and non-string interactions', () => {
-        expect(validate({ interaction: 42 })).toBe(false);
-        expect(validate({ interaction: 'sys:GeneralAgent', tools: [] })).toBe(false);
-    });
-});

package/src/store/ms.d.ts

@@ -1,42 +0,0 @@
-/**
- * Types for the `ms` package (version 3.0.0-canary.1)
- */
-declare module 'ms' {
-    declare type Unit =
-        | 'Years'
-        | 'Year'
-        | 'Yrs'
-        | 'Yr'
-        | 'Y'
-        | 'Weeks'
-        | 'Week'
-        | 'W'
-        | 'Days'
-        | 'Day'
-        | 'D'
-        | 'Hours'
-        | 'Hour'
-        | 'Hrs'
-        | 'Hr'
-        | 'H'
-        | 'Minutes'
-        | 'Minute'
-        | 'Mins'
-        | 'Min'
-        | 'M'
-        | 'Seconds'
-        | 'Second'
-        | 'Secs'
-        | 'Sec'
-        | 's'
-        | 'Milliseconds'
-        | 'Millisecond'
-        | 'Msecs'
-        | 'Msec'
-        | 'Ms';
-    declare type UnitAnyCase = Unit | Uppercase<Unit> | Lowercase<Unit>;
-    export declare type StringValue = `${number}` | `${number}${UnitAnyCase}` | `${number} ${UnitAnyCase}`;
-    declare function ms(value: StringValue, options?: Options): number;
-    declare function ms(value: number, options?: Options): string;
-    export default ms;
-}

package/src/store/schedule.test.ts

@@ -1,59 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import type { AgentSchedule, CreateSchedulePayload, ScheduleListItem, UpdateSchedulePayload } from './schedule.js';
-
-describe('CreateSchedulePayload', () => {
-    it('accepts agent schedules without an explicit target', () => {
-        expectTypeOf({
-            run_as: { mode: 'creator' as const },
-            name: 'Weekly report',
-            interaction: 'WeeklyReportAgent',
-            cron_expression: '0 9 * * MON',
-        }).toMatchTypeOf<CreateSchedulePayload>();
-    });
-
-    it('accepts process schedules with context', () => {
-        expectTypeOf({
-            run_as: { mode: 'creator' as const },
-            name: 'Nightly refresh',
-            target: 'process' as const,
-            process: '68c01a23456789abcdef0123',
-            cron_expression: '0 2 * * *',
-            context: { collection: 'reports' },
-        }).toMatchTypeOf<CreateSchedulePayload>();
-    });
-
-    it('rejects a process schedule without a process definition', () => {
-        expectTypeOf({
-            run_as: { mode: 'creator' as const },
-            name: 'Nightly refresh',
-            target: 'process' as const,
-            cron_expression: '0 2 * * *',
-        }).not.toMatchTypeOf<CreateSchedulePayload>();
-    });
-});
-
-describe('schedule read models', () => {
-    it('report the configuration a process schedule fires with', () => {
-        // The gap this closes: execution worked, but nothing read back said what a process schedule
-        // ran with, so it could not be inspected or recreated from the API.
-        expectTypeOf<AgentSchedule['context']>().toEqualTypeOf<Record<string, unknown> | undefined>();
-        expectTypeOf<AgentSchedule['run_type']>().toEqualTypeOf<'programmatic' | 'supervised' | undefined>();
-    });
-
-    it('summarize run_type in a listing but not context', () => {
-        // `run_type` is a scalar, like `target`. `context` is caller-sized payload, so it stays out
-        // of the summary for the same reason `vars` does.
-        expectTypeOf<ScheduleListItem['run_type']>().toEqualTypeOf<'programmatic' | 'supervised' | undefined>();
-        expectTypeOf<ScheduleListItem>().not.toHaveProperty('context');
-        expectTypeOf<ScheduleListItem>().not.toHaveProperty('vars');
-    });
-
-    it('do not accept execution inputs on update', () => {
-        // These are fixed in the scheduler at creation and update does not re-publish the job
-        // specification, so accepting them would record a change that never takes effect.
-        expectTypeOf<UpdateSchedulePayload>().not.toHaveProperty('context');
-        expectTypeOf<UpdateSchedulePayload>().not.toHaveProperty('run_type');
-        expectTypeOf<UpdateSchedulePayload>().not.toHaveProperty('process');
-        expectTypeOf<UpdateSchedulePayload>().not.toHaveProperty('interaction');
-    });
-});