@cratis/chronicle 6.38.0 → 6.40.0

package/testing/for_EventScenario/when_appending_field_types/with_legacy_decorators.legacy.spec.ts

@@ -0,0 +1,124 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { ConceptAs, field, Guid } from '@cratis/fundamentals';
+import { describe } from 'vitest';
+import { eventType, getEventTypeMetadata } from '../../../events/eventTypeDecorator.js';
+import { unique } from '../../../events/constraints/unique.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import { fromEvent } from '../../../projections/modelBound/fromEvent.js';
+import { setFrom } from '../../../projections/modelBound/setFrom.js';
+import { reactor } from '../../../reactors/reactor.js';
+import { reducer } from '../../../reducers/reducer.js';
+import { fieldScenarioBehaviors } from './field_scenario_behaviors.fixture.js';
+
+class Identifier extends ConceptAs<Guid> { static readonly valueType = Guid; }
+class Amount extends ConceptAs<number> { static readonly valueType = Number; }
+class Occurred extends ConceptAs<Date> { static readonly valueType = Date; }
+
+const identifier = () => Guid.parse('abcdef01-abcd-abcd-abcd-abcdef012345');
+const occurred = () => new Date('2025-01-02T03:04:05.123Z');
+
+class Payload {
+    @field(Number) amount = 1.5;
+    @field(Guid) identifier = identifier();
+    @field(Date) occurred = occurred();
+}
+
+@eventType('FieldTypesRecorded')
+class FieldsRecorded {
+    @field(Number) amount = 1.5;
+    @field(Guid) identifier = identifier();
+    @field(Date) occurred = occurred();
+    @field(Amount) amountConcept = new Amount(1e-7);
+    @field(Identifier) identifierConcept = new Identifier(identifier());
+    @field(Occurred) occurredConcept = new Occurred(occurred());
+    @field(Payload) payload = new Payload();
+    @field(Object) arbitrary = { nested: { number: 9007199254740992 }, values: [true, 1.5] };
+}
+
+@reactor('FieldTypesReactor')
+class Echo {
+    fieldsRecorded(event: FieldsRecorded) { return Object.assign(new FieldsRecorded(), event); }
+}
+
+class StoredFields {}
+class StoreFields {
+    fieldsRecorded(event: FieldsRecorded) { return event; }
+}
+reducer('FieldTypesReducer', undefined, StoredFields)(StoreFields);
+
+@fromEvent(FieldsRecorded)
+class ScalarProjection {
+    @field(String) id = '';
+    @field(Number) amount = 0;
+    @field(Guid) identifier = Guid.empty;
+    @field(Date) occurred = new Date(0);
+}
+
+@fromEvent(FieldsRecorded)
+class ObjectProjection {
+    @field(String) id = '';
+    @field(Object) payload = {};
+}
+
+@fromEvent(FieldsRecorded)
+class HashProjection {
+    @field(String) id = '';
+    @field(String) @setFrom(FieldsRecorded, '$eventContext(Hash)') hash = '';
+}
+
+@eventType('OracleFieldGuid')
+class GuidClaimed {
+    @field(Guid) key = identifier();
+}
+@eventType('OracleFieldNumber')
+class NumberClaimed {
+    @field(Number) key = 1;
+}
+@eventType('OracleFieldDouble')
+class DoubleClaimed {
+    @field(Number) key = 1;
+}
+getEventTypeMetadata(DoubleClaimed)!.schema.properties!.key.format = 'double';
+@constraint('OracleFieldKey')
+class DoubleKey {
+    define(builder: IConstraintBuilder) { builder.unique(key => key.on(DoubleClaimed, event => event.key)); }
+}
+@constraint('OracleFieldKey')
+class GuidKey {
+    define(builder: IConstraintBuilder) { builder.unique(key => key.on(GuidClaimed, event => event.key)); }
+}
+@constraint('OracleFieldKey')
+class NumberKey {
+    define(builder: IConstraintBuilder) { builder.unique(key => key.on(NumberClaimed, event => event.key)); }
+}
+@eventType('ConceptGuidClaimed')
+class ConceptGuidClaimed {
+    @field(Identifier) @unique('ConceptGuidKey') key = new Identifier(identifier());
+}
+@eventType('ConceptNumberClaimed')
+class ConceptNumberClaimed {
+    @field(Amount) @unique('ConceptNumberKey') key = new Amount(42);
+}
+@eventType('DateClaimed')
+class DateClaimed {
+    @field(Date) @unique('DateKey') key = occurred();
+}
+@eventType('ConceptDateClaimed')
+class ConceptDateClaimed {
+    @field(Occurred) @unique('ConceptDateKey') key = new Occurred(occurred());
+}
+@eventType('ObjectClaimed')
+class ObjectClaimed {
+    @field(Object) @unique('ObjectKey') key = { amount: 1.5 };
+}
+
+describe('when appending field types with legacy decorators', () => {
+    fieldScenarioBehaviors({ recorded: FieldsRecorded, reactor: Echo, model: StoredFields, reducer: StoreFields,
+        projection: ScalarProjection, objectProjection: ObjectProjection, hashProjection: HashProjection,
+        guid: GuidClaimed, number: NumberClaimed, guidConstraint: GuidKey, numberConstraint: NumberKey, guidConcept: ConceptGuidClaimed, numberConcept: ConceptNumberClaimed,
+        double: DoubleClaimed, doubleConstraint: DoubleKey, rejected: [DateClaimed, ConceptDateClaimed, ObjectClaimed] });
+});

package/testing/for_EventScenario/when_appending_field_types/with_standard_decorators.standard.spec.ts

@@ -0,0 +1,123 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ConceptAs, field, Guid } from '@cratis/fundamentals';
+import { describe } from 'vitest';
+import { eventType, getEventTypeMetadata } from '../../../events/eventTypeDecorator.js';
+import { unique } from '../../../events/constraints/unique.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import { fromEvent } from '../../../projections/modelBound/fromEvent.js';
+import { setFrom } from '../../../projections/modelBound/setFrom.js';
+import { reactor } from '../../../reactors/reactor.js';
+import { reducer } from '../../../reducers/reducer.js';
+import { fieldScenarioBehaviors } from './field_scenario_behaviors.fixture.js';
+
+class Identifier extends ConceptAs<Guid> { static readonly valueType = Guid; }
+class Amount extends ConceptAs<number> { static readonly valueType = Number; }
+class Occurred extends ConceptAs<Date> { static readonly valueType = Date; }
+
+const identifier = () => Guid.parse('abcdef01-abcd-abcd-abcd-abcdef012345');
+const occurred = () => new Date('2025-01-02T03:04:05.123Z');
+
+class Payload {
+    @field(Number) amount = 1.5;
+    @field(Guid) identifier = identifier();
+    @field(Date) occurred = occurred();
+}
+
+@eventType('FieldTypesRecorded')
+class FieldsRecorded {
+    @field(Number) amount = 1.5;
+    @field(Guid) identifier = identifier();
+    @field(Date) occurred = occurred();
+    @field(Amount) amountConcept = new Amount(1e-7);
+    @field(Identifier) identifierConcept = new Identifier(identifier());
+    @field(Occurred) occurredConcept = new Occurred(occurred());
+    @field(Payload) payload = new Payload();
+    @field(Object) arbitrary = { nested: { number: 9007199254740992 }, values: [true, 1.5] };
+}
+
+@reactor('FieldTypesReactor')
+class Echo {
+    fieldsRecorded(event: FieldsRecorded) { return Object.assign(new FieldsRecorded(), event); }
+}
+
+class StoredFields {}
+class StoreFields {
+    fieldsRecorded(event: FieldsRecorded) { return event; }
+}
+reducer('FieldTypesReducer', undefined, StoredFields)(StoreFields);
+
+@fromEvent(FieldsRecorded)
+class ScalarProjection {
+    @field(String) id = '';
+    @field(Number) amount = 0;
+    @field(Guid) identifier = Guid.empty;
+    @field(Date) occurred = new Date(0);
+}
+
+@fromEvent(FieldsRecorded)
+class ObjectProjection {
+    @field(String) id = '';
+    @field(Object) payload = {};
+}
+
+@fromEvent(FieldsRecorded)
+class HashProjection {
+    @field(String) id = '';
+    @field(String) @setFrom(FieldsRecorded, '$eventContext(Hash)') hash = '';
+}
+
+@eventType('OracleFieldGuid')
+class GuidClaimed {
+    @field(Guid) key = identifier();
+}
+@eventType('OracleFieldNumber')
+class NumberClaimed {
+    @field(Number) key = 1;
+}
+@eventType('OracleFieldDouble')
+class DoubleClaimed {
+    @field(Number) key = 1;
+}
+getEventTypeMetadata(DoubleClaimed)!.schema.properties!.key.format = 'double';
+@constraint('OracleFieldKey')
+class DoubleKey {
+    define(builder: IConstraintBuilder) { builder.unique(key => key.on(DoubleClaimed, event => event.key)); }
+}
+@constraint('OracleFieldKey')
+class GuidKey {
+    define(builder: IConstraintBuilder) { builder.unique(key => key.on(GuidClaimed, event => event.key)); }
+}
+@constraint('OracleFieldKey')
+class NumberKey {
+    define(builder: IConstraintBuilder) { builder.unique(key => key.on(NumberClaimed, event => event.key)); }
+}
+@eventType('ConceptGuidClaimed')
+class ConceptGuidClaimed {
+    @field(Identifier) @unique('ConceptGuidKey') key = new Identifier(identifier());
+}
+@eventType('ConceptNumberClaimed')
+class ConceptNumberClaimed {
+    @field(Amount) @unique('ConceptNumberKey') key = new Amount(42);
+}
+@eventType('DateClaimed')
+class DateClaimed {
+    @field(Date) @unique('DateKey') key = occurred();
+}
+@eventType('ConceptDateClaimed')
+class ConceptDateClaimed {
+    @field(Occurred) @unique('ConceptDateKey') key = new Occurred(occurred());
+}
+@eventType('ObjectClaimed')
+class ObjectClaimed {
+    @field(Object) @unique('ObjectKey') key = { amount: 1.5 };
+}
+
+describe('when appending field types with standard decorators', () => {
+    fieldScenarioBehaviors({ recorded: FieldsRecorded, reactor: Echo, model: StoredFields, reducer: StoreFields,
+        projection: ScalarProjection, objectProjection: ObjectProjection, hashProjection: HashProjection,
+        guid: GuidClaimed, number: NumberClaimed, guidConstraint: GuidKey, numberConstraint: NumberKey, guidConcept: ConceptGuidClaimed, numberConcept: ConceptNumberClaimed,
+        double: DoubleClaimed, doubleConstraint: DoubleKey, rejected: [DateClaimed, ConceptDateClaimed, ObjectClaimed] });
+});

package/testing/for_EventScenario/when_appending_field_types/with_unproven_schemas.legacy.spec.ts

@@ -0,0 +1,82 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { field, Guid } from '@cratis/fundamentals';
+import { chai, describe, it } from 'vitest';
+import { eventType, getEventTypeMetadata } from '../../../events/eventTypeDecorator.js';
+import { unique } from '../../../events/constraints/unique.js';
+import { constraint } from '../../../events/constraints/constraint.js';
+import type { IConstraintBuilder } from '../../../events/constraints/IConstraintBuilder.js';
+import type { JsonSchema } from '../../../schemas/JsonSchema.js';
+import { EventScenario, UnsupportedEventSequenceOperation } from '../../index.js';
+
+chai.should();
+
+for (const schema of [
+    { type: 'string', format: 'date' }, { type: 'string', format: 'date-time' },
+    { type: 'object' }, { type: 'integer', format: 'int64' }, { type: 'number', format: 'decimal' }
+] satisfies JsonSchema[]) {
+    describe(`when registering a ${schema.type}/${schema.format ?? 'unformatted'} constrained schema`, () => {
+        it('should reject the constraint without rejecting an unconstrained field', async () => {
+            class Recorded { @field(Object) @unique(`Unsupported${schema.type}${schema.format ?? ''}`) key: unknown = {}; }
+            eventType(`Unsupported${schema.type}${schema.format ?? ''}`)(Recorded);
+            getEventTypeMetadata(Recorded)!.schema.properties!.key = schema;
+            (() => new EventScenario({ artifacts: { eventTypes: [Recorded] } })).should.throw(UnsupportedEventSequenceOperation, 'artifacts.constraints');
+            const scenario = new EventScenario({ artifacts: { eventTypes: [Recorded] }, constraints: 'disabled' });
+            const event = new Recorded();
+            event.key = schema.type === 'string' ? '2025-01-02' : schema.type === 'object' ? { value: 42 } : 1.5;
+            if (schema.format === 'date-time') event.key = '2025-01-02T03:04:05.000Z';
+            if (schema.type === 'integer') event.key = 42;
+            (await scenario.append('A', event)).isSuccess.should.equal(true);
+        });
+    });
+}
+
+for (const mode of ['composite', 'scoped', 'ignoreCasing']) {
+    describe(`when registering a ${mode} Guid key without fixture evidence`, () => {
+        it('should reject instead of inheriting plain-string constraint support', () => {
+            class Recorded { @field(Guid) key = Guid.empty; @field(String) label = ''; }
+            eventType(`UnprovenGuid${mode}`)(Recorded);
+            class Definition {
+                define(builder: IConstraintBuilder) {
+                    if (mode === 'scoped') builder.perEventSourceType();
+                    builder.unique(key => {
+                        if (mode === 'composite') key.on(Recorded, event => event.key, event => event.label);
+                        else key.on(Recorded, event => event.key);
+                        if (mode === 'ignoreCasing') key.ignoreCasing();
+                    });
+                }
+            }
+            constraint(`UnprovenGuid${mode}`)(Definition);
+            (() => new EventScenario({ artifacts: { eventTypes: [Recorded], constraints: [Definition] } }))
+                .should.throw(UnsupportedEventSequenceOperation, 'artifacts.constraints');
+        });
+    });
+}
+
+for (const protection of ['compliance', 'security'] as const) {
+    describe(`when registering nested ${protection} metadata`, () => {
+        it('should reject before serializing an object payload', () => {
+            class Recorded { @field(Object) payload = {}; }
+            eventType(`Nested${protection}`)(Recorded);
+            getEventTypeMetadata(Recorded)!.schema.properties!.payload = {
+                type: 'object', properties: { nested: { type: 'string', [protection]: [{ metadataType: 'protected', details: '' }] } }
+            };
+            (() => new EventScenario({ artifacts: { eventTypes: [Recorded] }, constraints: 'disabled' }))
+                .should.throw(UnsupportedEventSequenceOperation, 'artifacts.eventTypes.schema');
+        });
+    });
+}
+
+describe('when registering a uuid constraint schema alias', () => {
+    it('should reject unproven constraint semantics but accept a valid unconstrained payload', async () => {
+        class Recorded { @field(Guid) @unique('UuidAlias') key: Guid | string = Guid.empty; }
+        eventType('UuidAlias')(Recorded);
+        getEventTypeMetadata(Recorded)!.schema.properties!.key.format = 'uuid';
+        (() => new EventScenario({ artifacts: { eventTypes: [Recorded] } }))
+            .should.throw(UnsupportedEventSequenceOperation, 'artifacts.constraints');
+        const scenario = new EventScenario({ artifacts: { eventTypes: [Recorded] }, constraints: 'disabled' });
+        (await scenario.append('A', new Recorded())).isSuccess.should.equal(true);
+    });
+});

package/testing/projections/ProjectionReadModelProcessor.ts

@@ -123,6 +123,16 @@ export class ProjectionReadModelProcessor<TReadModel extends object> implements
                 continue;
             }
             const schema = this._eventSchemas.get(typeId)!;
+            // EventScenario preserves client JSON, not kernel-normalized GUID/date/number/object JSON.
+            // Its deterministic hash is not kernel evidence for those payloads. Ordinary mappings
+            // still use the independently validated projection converters below.
+            if (event.scenarioLocalHash && from && Object.values(from.Value.Properties ?? {}).some(expression =>
+                /^\$eventContext\(Hash(?:\.Value)?\)$/.test(expression)) &&
+                Object.values(schema.properties ?? {}).some(property =>
+                    !['string', 'boolean'].includes(property.type ?? '') || property.format !== undefined)) {
+                throw new UnsupportedProjectionOperation(String(this._definition.ReadModel), binding.path, binding.declaration,
+                    'observed Hash mappings for numeric, Guid, date or object event fields are not fixture-backed; use a kernel-backed test');
+            }
             const content = ProjectionValueConverter.eventContent(event.content, schema);
             let state = engine[key];
             if (!state) {