@cratis/chronicle 6.18.0 → 6.20.0

package/testing/projections/for_ProjectionCapabilities/when_validating_numeric_schemas.spec.ts

@@ -12,22 +12,31 @@ chai.should();
 
 describe('when validating the numeric capability matrix', () => {
     for (const format of ['int32', 'uint32']) {
-        it(`should accept ${format} arithmetic with a matching event operand and literal`, () => {
+        it(`should accept a finite ${format} literal without admitting arithmetic`, () => {
             const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from
-                .add(model => model.total).with(event => event.quantity)
                 .set(model => model.quantity).toValue(12)));
-            const modelSchema = JSON.parse(compiled.readModels[0].Schema) as { properties: { total: { type: string; format?: string }; quantity: { type: string; format?: string } } };
-            modelSchema.properties.total = { type: 'integer', format };
+            const modelSchema = JSON.parse(compiled.readModels[0].Schema) as { properties: { quantity: { type: string; format?: string } } };
             modelSchema.properties.quantity = { type: 'integer', format };
             compiled.readModels[0].Schema = JSON.stringify(modelSchema);
-            const eventSchema = compiled.eventSchemas.get(definition)!.get('capability-changed:1:0')!.schema;
-            eventSchema.properties!.quantity = { type: 'integer', format };
             (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
         });
     }
 
-    it('should accept GUID identifiers and finite double arithmetic', () => {
-        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from.add(model => model.total).with(event => event.quantity)));
+    it('should admit mappings into unformatted Number fields generated by TypeScript', () => {
+        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from
+            .set(model => model.total).to(event => event.name)
+            .set(model => model.quantity).to(event => event.quantity)));
+        const schema = JSON.parse(compiled.readModels[0].Schema) as { properties: { total: { type: string; format?: string }; quantity: { type: string; format?: string } } };
+        ('format' in schema.properties.total).should.be.false;
+        ('format' in schema.properties.quantity).should.be.false;
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
+        // The oracle's compatible-mappings fixture also tests formatted int32/uint32 sources into unformatted Number targets.
+        compiled.eventSchemas.get(definition)!.get('capability-changed:1:0')!.schema.properties!.quantity = { type: 'integer', format: 'int32' };
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
+    });
+
+    it('should accept GUID identifiers and a finite double literal', () => {
+        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from.set(model => model.total).toValue(2.5)));
         const schema = JSON.parse(compiled.readModels[0].Schema) as { properties: { id: { type: string; format?: string }; total: { format?: string } } };
         schema.properties.id.format = 'guid';
         schema.properties.total.format = 'double';
@@ -35,10 +44,10 @@ describe('when validating the numeric capability matrix', () => {
         (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
     });
 
-    it('should accept numeric identifiers with a declared number schema', () => {
+    it('should accept numeric identifiers with the fixture-backed double schema', () => {
         const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));
-        const schema = JSON.parse(compiled.readModels[0].Schema) as { properties: { id: { type: string } } };
-        schema.properties.id.type = 'number';
+        const schema = JSON.parse(compiled.readModels[0].Schema) as { properties: { id: { type: string; format?: string } } };
+        schema.properties.id = { type: 'number', format: 'double' };
         compiled.readModels[0].Schema = JSON.stringify(schema);
         (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
     });
@@ -54,6 +63,25 @@ describe('when validating the numeric capability matrix', () => {
         });
     }
 
+    it('should reject a double event operand into an integer accumulator before replay', () => {
+        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from.add(model => model.total).with(event => event.quantity)));
+        const schema = JSON.parse(compiled.readModels[0].Schema) as { properties: { total: { type: string; format?: string } } };
+        schema.properties.total = { type: 'integer', format: 'int32' };
+        compiled.readModels[0].Schema = JSON.stringify(schema);
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+            .with.property('message').that.includes('arithmetic requires a kernel-backed test');
+    });
+
+    it('should reject an int32 $value literal with a fractional spelling even if its value is integral', () => {
+        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from.set(model => model.total).toValue(1)));
+        const schema = JSON.parse(compiled.readModels[0].Schema) as { properties: { total: { type: string; format?: string } } };
+        schema.properties.total = { type: 'integer', format: 'int32' };
+        compiled.readModels[0].Schema = JSON.stringify(schema);
+        definition.From[0].Value.Properties.total = '$value(1.0)';
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+            .with.property('message').that.includes('$value numeric literal is outside');
+    });
+
     it('should reject an overflowing initial integer value', () => {
         const { compiled, definition } = compileDeclarative(builder => builder.from(Changed)
             .withInitialValues(() => ({ id: '', name: '', quantity: 0, total: 2147483648, state: '', labels: [], details: {} })));
@@ -68,6 +96,6 @@ describe('when validating the numeric capability matrix', () => {
         const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from.add(model => model.total).with(event => event.quantity)));
         compiled.eventSchemas.get(definition)!.get('capability-changed:1:0')!.schema.properties!.quantity.format = 'int64';
         (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
-            .with.property('message').that.includes('arithmetic operand requires a supported numeric event schema');
+            .with.property('message').that.includes('arithmetic requires a kernel-backed test');
     });
 });

package/testing/projections/for_ProjectionCapabilities/when_validating_schema_boundaries.spec.ts

@@ -29,22 +29,16 @@ function setModelSchema(compiled: ReturnType<typeof compileDeclarative>['compile
 }
 
 describe('when validating schema-bound projection operations', () => {
-    it('should accept generated date, date concept, and nested date formats for pass-through and initial values', () => {
+    it('should accept generated scalar date and date-concept formats for pass-through', () => {
         const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from
             .set(model => model.name).to(event => event.name)
-            .set(model => model.state).to(event => event.name)
-            .set(model => model.details).to(event => event.details))
-            .withInitialValues(() => ({ id: '', name: '', quantity: 0, total: 0, state: new Date('2026-01-01') as unknown as string,
-                labels: [], details: { created: new Date('2026-01-01') } })));
+            .set(model => model.state).to(event => event.name)));
         const dates = JsonSchemaGenerator.generate(Dated).properties!;
         setModelSchema(compiled, properties => {
             properties.name = dates.created;
             properties.state = dates.timestamp;
-            properties.details = dates.details;
         });
-        const event = compiled.eventSchemas.get(definition)!.get('capability-changed:1:0')!.schema;
-        event.properties!.name = dates.created;
-        event.properties!.details = dates.details;
+        compiled.eventSchemas.get(definition)!.get('capability-changed:1:0')!.schema.properties!.name = dates.created;
         (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
     });
 
@@ -56,6 +50,70 @@ describe('when validating schema-bound projection operations', () => {
         (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
     });
 
+    const mismatches: Array<{ name: string; source: JsonSchema; target: JsonSchema }> = [
+        { name: 'date-time to string', source: { type: 'string', format: 'date-time' }, target: { type: 'string' } },
+        { name: 'boolean to string', source: { type: 'boolean' }, target: { type: 'string' } },
+        { name: 'number to integer', source: { type: 'number', format: 'double' }, target: { type: 'integer', format: 'int32' } },
+        { name: 'object to scalar', source: { type: 'object', properties: { other: { type: 'string' } } }, target: { type: 'string' } },
+        { name: 'concept-shaped object to object', source: { type: 'object', properties: { value: { type: 'integer', format: 'int32' } } },
+            target: { type: 'object', properties: { value: { type: 'integer', format: 'int32' } } } }
+    ];
+    for (const mapping of mismatches) {
+        for (const autoMap of [false, true]) {
+            it(`should reject ${mapping.name} for ${autoMap ? 'AutoMap' : 'setFrom'} with the declaration and path`, () => {
+                const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => {
+                    if (!autoMap) from.set(model => model.name).to(event => event.name);
+                }));
+                setModelSchema(compiled, properties => { properties.name = mapping.target; });
+                compiled.eventSchemas.get(definition)!.get('capability-changed:1:0')!.schema.properties!.name = mapping.source;
+                (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+                    .with.property('message').that.includes(`From[capability-changed:1].${autoMap ? 'AutoMap' : 'Properties'}.name`)
+                    .and.includes(autoMap ? '.from (AutoMap)' : '.from().set')
+                    .and.includes('kernel-backed test');
+            });
+        }
+    }
+
+    for (const [property, target, value, reason] of [
+        ['state', { type: 'boolean' }, 'yes', 'initial boolean value must be a JSON boolean'],
+        ['total', { type: 'integer', format: 'int32' }, '5', 'initial numeric value must be a JSON number'],
+        ['state', { type: 'string', format: 'guid' }, 'not-a-guid', 'initial GUID value must be canonical lowercase text']
+    ] as const) {
+        it(`should reject incompatible initial value for ${property}`, () => {
+            const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));
+            setModelSchema(compiled, properties => { properties[property] = target; });
+            definition.InitialModelState = JSON.stringify({ [property]: value });
+            (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+                .with.property('message').that.includes(`InitialModelState.${property} (.withInitialValues)`)
+                .and.includes(reason);
+        });
+    }
+
+    it('should reject unproven initial date-time, object and array values', () => {
+        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));
+        for (const [property, value] of [['state', '2026-01-01T00:00:00.000Z'], ['details', {}], ['labels', []]] as const) {
+            if (property === 'state') setModelSchema(compiled, properties => { properties.state = { type: 'string', format: 'date-time' }; });
+            definition.InitialModelState = JSON.stringify({ [property]: value });
+            (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+                .with.property('message').that.includes(`InitialModelState.${property}`);
+        }
+    });
+
+    for (const [name, schema] of [
+        ['unmapped', { type: 'string', security: [{ metadataType: 'Secret', details: '' }] }],
+        ['nested', { type: 'object', properties: { secret: { type: 'string', compliance: [{ metadataType: 'PII', details: '' }] } } }],
+        ['array item', { type: 'array', items: { type: 'string', compliance: [{ metadataType: 'PII', details: '' }] } }],
+        ['additional property', { type: 'object', additionalProperties: { type: 'string', security: [{ metadataType: 'Encrypted', details: '' }] } }]
+    ] as const) {
+        it(`should reject protected ${name} schema members even when unmapped`, () => {
+            const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));
+            setModelSchema(compiled, properties => { properties.unmapped = schema as JsonSchema; });
+            (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation)
+                .with.property('message').that.includes('ReadModel.Schema.unmapped')
+                .and.includes('protected fields require a kernel-backed test');
+        });
+    }
+
     it('should accept $null for a date destination', () => {
         const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from.set(model => model.state).toValue(null)));
         setModelSchema(compiled, properties => { properties.state = { type: 'string', format: 'date-time' }; });
@@ -72,37 +130,26 @@ describe('when validating schema-bound projection operations', () => {
         });
     }
 
-    it('should use a string key when neither id nor Id exists', () => {
+    it('should reject missing or differently cased id schemas until their key behavior is fixture-backed', () => {
         const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));
         setModelSchema(compiled, properties => { delete properties.id; });
-        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
-    });
-
-    it('should use Id when id is absent, but prefer id when both exist', () => {
-        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));
-        setModelSchema(compiled, properties => { properties.Id = { type: 'string' }; delete properties.id; });
-        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
-        setModelSchema(compiled, properties => { properties.id = { type: 'boolean' }; });
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation, 'ReadModel.Schema.id');
+        setModelSchema(compiled, properties => { properties.Id = { type: 'string' }; });
         (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation, 'ReadModel.Schema.id');
     });
 
-    it('should not treat ID as the kernel identifier', () => {
+    it('should reject schemas whose properties collide with the lowercase id', () => {
         const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));
-        setModelSchema(compiled, properties => { delete properties.id; properties.ID = { type: 'boolean' }; });
-        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
-    });
-
-    it('should skip AutoMap validation for arithmetic-only events', () => {
-        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from.add(model => model.total).with(event => event.quantity)));
-        setModelSchema(compiled, properties => { properties.name.format = 'float'; });
-        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
+        setModelSchema(compiled, properties => { properties.Id = { type: 'string' }; });
+        (() => ProjectionCapabilities.validate(compiled, definition)).should.throw(UnsupportedProjectionOperation,
+            'case-insensitively colliding read-model properties require a kernel-backed test');
     });
 
     for (const [expression, destination, reason] of [
         ['$value(maybe)', 'state', '$value boolean literal'],
         ['$value(not-a-guid)', 'state', '$value GUID literal'],
-        ['$value(text)', 'details', '$value object/array literals'],
-        ['$value(text)', 'labels', '$value object/array literals']
+        ['$value(text)', 'details', 'object/array target mappings require a kernel-backed test'],
+        ['$value(text)', 'labels', 'object/array target mappings require a kernel-backed test']
     ]) {
         it(`should reject invalid ${expression} for ${destination} (${reason})`, () => {
             const { compiled, definition } = compileDeclarative(builder => builder.from(Changed));

package/testing/projections/for_ProjectionCapabilities/when_validating_supported_operations.spec.ts

@@ -3,17 +3,12 @@
 
 import 'reflect-metadata';
 import { chai, describe, it } from 'vitest';
-import { addFrom } from '../../../projections/modelBound/addFrom.js';
 import { clearWith } from '../../../projections/modelBound/clearWith.js';
-import { count } from '../../../projections/modelBound/count.js';
-import { decrement } from '../../../projections/modelBound/decrement.js';
-import { increment } from '../../../projections/modelBound/increment.js';
 import { noAutoMap } from '../../../projections/modelBound/noAutoMap.js';
 import { removedWith } from '../../../projections/modelBound/removedWith.js';
 import { setFrom } from '../../../projections/modelBound/setFrom.js';
 import { setFromContext } from '../../../projections/modelBound/setFromContext.js';
 import { setValue } from '../../../projections/modelBound/setValue.js';
-import { subtractFrom } from '../../../projections/modelBound/subtractFrom.js';
 import { ProjectionCapabilities } from '../ProjectionCapabilities.js';
 import { Changed } from './given/Changed.js';
 import { Removed } from './given/Removed.js';
@@ -25,16 +20,11 @@ describe('when validating the phase-one projection subset', () => {
     const modelBound = [
         { name: 'root From and schema-inferred AutoMap', configure: () => {} },
         { name: 'setFrom and event source identity', configure: (model: Function) => setFrom(Changed, 'name')(model.prototype, 'name') },
-        { name: 'setFromContext maps eventType without needing it in the event schema', configure: (model: Function) => setFromContext(Changed, 'eventType')(model.prototype, 'state') },
+        { name: 'setFromContext maps eventSourceId without needing it in the event schema', configure: (model: Function) => setFromContext(Changed, 'eventSourceId')(model.prototype, 'state') },
         { name: 'setFromContext maps the event source identity', configure: (model: Function) => setFromContext(Changed, 'eventSourceId')(model.prototype, 'state') },
         { name: 'setFromContext maps a nested identity member', configure: (model: Function) => setFromContext(Changed, 'causedBy.subject')(model.prototype, 'state') },
         { name: 'constant text', configure: (model: Function) => setValue(Changed, 'ready')(model.prototype, 'state') },
         { name: 'scalar clearing', configure: (model: Function) => clearWith(Removed)(model.prototype, 'state') },
-        { name: 'addition', configure: (model: Function) => addFrom(Changed, 'quantity')(model.prototype, 'total') },
-        { name: 'subtraction', configure: (model: Function) => subtractFrom(Changed, 'quantity')(model.prototype, 'total') },
-        { name: 'count', configure: (model: Function) => count(Changed)(model.prototype, 'total') },
-        { name: 'increment', configure: (model: Function) => increment(Changed)(model.prototype, 'total') },
-        { name: 'decrement', configure: (model: Function) => decrement(Changed)(model.prototype, 'total') },
         { name: 'root removal', configure: (model: Function) => removedWith(Removed)(model) },
         { name: 'AutoMap exclusions', configure: (model: Function) => noAutoMap(model.prototype, 'quantity') }
     ];
@@ -45,15 +35,11 @@ describe('when validating the phase-one projection subset', () => {
         });
     }
 
-    it('should accept declarative multiple root sources, explicit mappings, constants, arithmetic, and removal', () => {
+    it('should accept declarative explicit mappings, constants, and a separate removal event', () => {
         const { compiled, definition } = compileDeclarative(builder => builder
             .from(Changed, from => from.set(model => model.name).to(event => event.name)
-                .set(model => model.id).toEventSourceId()
-                .set(model => model.state).toValue('ready')
-                .add(model => model.total).with(event => event.quantity)
-                .subtract(model => model.total).with(event => event.quantity)
-                .increment(model => model.total).decrement(model => model.total).count(model => model.total))
-            .from(Removed).removedWith(Removed).withInitialValues(() => ({ id: '', name: '', quantity: 0, total: 0, state: 'new', labels: [], details: {} })));
+                .set(model => model.state).toValue('ready'))
+            .removedWith(Removed).withInitialValues(() => ({ id: '', name: '', quantity: 0, total: 0, state: 'new' })));
         (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
     });
 
@@ -67,17 +53,10 @@ describe('when validating the phase-one projection subset', () => {
         ['eventStreamId', '$eventContext(EventStreamId)'],
         ['subject', '$eventContext(Subject)'],
         ['hash', '$eventContext(Hash)'],
-        ['causedBy', '$eventContext(CausedBy)'],
-        ['observationState', '$eventContext(ObservationState)'],
-        ['eventType', '$eventContext(EventType)'],
-        ['occurred', '$eventContext(Occurred)'],
         ['correlationId', '$eventContext(CorrelationId)'],
-        ['causation', '$eventContext(Causation)'],
-        ['tags', '$eventContext(Tags)'],
         ['causedBy.subject', '$eventContext(CausedBy.Subject)'],
         ['causedBy.name', '$eventContext(CausedBy.Name)'],
-        ['causedBy.userName', '$eventContext(CausedBy.UserName)'],
-        ['causedBy.onBehalfOf', '$eventContext(CausedBy.OnBehalfOf)']
+        ['causedBy.userName', '$eventContext(CausedBy.UserName)']
     ]) {
         it(`should accept the client's emitted context expression ${expression}`, () => {
             const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from =>
@@ -87,17 +66,11 @@ describe('when validating the phase-one projection subset', () => {
         });
     }
 
-    it('should accept declarative null clearing and an explicit null initial accumulator', () => {
+    it('should accept declarative null clearing with numeric initial state', () => {
         const { compiled, definition } = compileDeclarative(builder => builder
-            .from(Changed, from => from.set(model => model.state).toValue(null).count(model => model.total))
-            .withInitialValues(() => ({ id: '', name: '', quantity: 0, total: null as unknown as number, state: '', labels: [], details: {} })));
+            .from(Changed, from => from.set(model => model.state).toValue(null))
+            .withInitialValues(() => ({ id: '', name: '', quantity: 0, total: 0, state: '' })));
         (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
     });
 
-    it('should accept an ordinary object or array value without mistaking it for a child projection', () => {
-        const { compiled, definition } = compileDeclarative(builder => builder.from(Changed, from => from
-            .set(model => model.labels).to(event => event.labels)
-            .set(model => model.details).to(event => event.details)));
-        (() => ProjectionCapabilities.validate(compiled, definition)).should.not.throw();
-    });
 });