@cratis/chronicle 6.23.0 → 6.25.0

package/testing/InProcessConstraints.ts

@@ -12,11 +12,28 @@ import { UnsupportedEventSequenceOperation } from './UnsupportedEventSequenceOpe
 export type WireConstraintViolation = ContractsConstraintViolation;
 
 const unavailable = '18446744073709551615';
+// Only the key characters captured by the packaged oracle, not every valid event-content character.
+const provenString = /^[A-Za-z0-9 .@_:\-|{}$\u00e9]*$/;
+
+function kernelKeyString(value: unknown, name: string): string {
+    if (typeof value === 'string' && provenString.test(value)) return value;
+    if (typeof value === 'boolean') return value ? 'True' : 'False';
+    throw new UnsupportedEventSequenceOperation('artifacts.constraints', name,
+        'Only fixture-backed scalar string and boolean keys are supported.');
+}
+
+function keyHash(value: string): string {
+    return createHash('sha256').update(value).digest('hex');
+}
 
 /** Narrow, fixture-backed unscoped constraint validation over serialized event snapshots. */
 export class InProcessConstraints {
+    private readonly _constrainedProperties = new Map<string, Set<string>>();
+    private readonly _removalTypes = new Set<string>();
+
     constructor(private readonly _definitions: ReadonlyMap<string, ConstraintCapture>) {
-        const coveredTypes = new Set<string>();
+        const coveredTypes = new Map<string, string>();
+        const removalOwners = new Map<string, string>();
         for (const [name, capture] of _definitions) {
             if (capture.uniqueConstraint && capture.uniqueEventType) {
                 throw this.unsupported(name, 'A definition with both constraint kinds is not fixture-backed.');
@@ -26,10 +43,24 @@ export class InProcessConstraints {
             }
             if (capture.uniqueConstraint) {
                 const unique = capture.uniqueConstraint;
-                if (unique.ignoreCasing || unique.removedWithEventTypeId || unique.removedWithEventTypeIds?.length ||
-                    unique.eventDefinitions.length === 0 || unique.eventDefinitions.some(entry => entry.properties.length !== 1 ||
+                if (unique.ignoreCasing || unique.eventDefinitions.length === 0 ||
+                    unique.eventDefinitions.some(entry => entry.properties.length !== 1 ||
                         !/^[a-z][a-zA-Z0-9]*$/.test(entry.properties[0]))) {
-                    throw this.unsupported(name, 'Case folding, removal and composite or nested keys are not fixture-backed.');
+                    throw this.unsupported(name, 'Case folding and composite or nested keys are not fixture-backed.');
+                }
+                for (const id of [unique.removedWithEventTypeId, ...(unique.removedWithEventTypeIds ?? [])]) {
+                    if (id === undefined) continue;
+                    const owner = removalOwners.get(id);
+                    if (owner !== undefined && owner !== name) {
+                        throw this.unsupported(name, 'Removal type shared by several definitions is not fixture-backed.');
+                    }
+                    removalOwners.set(id, name);
+                    this._removalTypes.add(id);
+                }
+                for (const entry of unique.eventDefinitions) {
+                    const properties = this._constrainedProperties.get(entry.eventTypeId) ?? new Set<string>();
+                    properties.add(entry.properties[0]);
+                    this._constrainedProperties.set(entry.eventTypeId, properties);
                 }
             } else if (capture.uniqueEventType) {
                 const unique = capture.uniqueEventType;
@@ -43,15 +74,58 @@ export class InProcessConstraints {
                 capture.uniqueEventType?.eventTypeIds ?? [capture.uniqueEventType!.eventTypeId];
             for (const id of ids) {
                 if (coveredTypes.has(id)) throw this.unsupported(name, 'Overlapping constraints are not fixture-backed.');
-                coveredTypes.add(id);
+                coveredTypes.set(id, name);
+            }
+        }
+        for (const [name, definition] of _definitions) {
+            const unique = definition.uniqueConstraint;
+            if (!unique) continue;
+            for (const id of [unique.removedWithEventTypeId, ...(unique.removedWithEventTypeIds ?? [])]) {
+                if (id !== undefined && coveredTypes.has(id) && coveredTypes.get(id) !== name) {
+                    throw this.unsupported(name, 'Removal overlapping another validating definition is not fixture-backed.');
+                }
             }
         }
     }
 
+    isRemovalOnlyType(eventTypeId: string): boolean {
+        return this._removalTypes.has(eventTypeId) && !this._constrainedProperties.has(eventTypeId);
+    }
+
+    hasRemovalType(eventTypeId: string): boolean { return this._removalTypes.has(eventTypeId); }
+
+    isConstrainedProperty(eventTypeId: string, property: string): boolean {
+        return this._constrainedProperties.get(eventTypeId)?.has(property) ?? false;
+    }
+
     /** Validate against committed history and all earlier entries of this append, without changing state. */
     validate(history: readonly AppendedEvent[], incoming: readonly AppendedEvent[]): WireConstraintViolation[] {
         const violations: WireConstraintViolation[] = [];
-        const stagedKeys = new Map<string, string>();
+        // Durable ownership is one claim per source, not one entry per historical value.
+        // Rebuild it from committed history; batch claims below remain independent and are never released.
+        const owners = new Map<string, Map<string, { key: string; sequence: string }>>();
+        for (const [name, definition] of this._definitions) {
+            if (!definition.uniqueConstraint) continue;
+            const claims = new Map<string, { key: string; sequence: string }>();
+            const unique = definition.uniqueConstraint;
+            const removals = new Set([unique.removedWithEventTypeId, ...(unique.removedWithEventTypeIds ?? [])]);
+            for (const prior of history) {
+                const type = prior.eventType.id.value;
+                const source = prior.context.eventSourceId;
+                if (removals.has(type)) {
+                    claims.delete(source);
+                    continue;
+                }
+                const property = unique.eventDefinitions.find(entry => entry.eventTypeId === type)?.properties[0];
+                if (property === undefined) continue;
+                const value = prior.content[property];
+                if (typeof value !== 'string' && typeof value !== 'boolean') throw this.unsupported(name, 'History has an unproven key.');
+                claims.set(source, { key: keyHash(kernelKeyString(value, name)),
+                    sequence: prior.context.sequenceNumber.toString() });
+            }
+            owners.set(name, claims);
+        }
+        const stagedKeys = new Map<string, Map<string, string>>();
         const stagedTypes = new Set<string>();
         for (const event of incoming) {
             const type = event.eventType.id.value;
@@ -59,45 +133,20 @@ export class InProcessConstraints {
             for (const [name, definition] of this._definitions) {
                 const property = definition.uniqueConstraint?.eventDefinitions.find(entry => entry.eventTypeId === type)?.properties[0];
                 if (property !== undefined) {
-                    const raw = event.content[property];
-                    // The oracle proves ordinal ASCII casing and significant spaces; no .NET Unicode folding or conversion is inferred.
-                    if (typeof raw !== 'string' || !/^[A-Za-z ]+$/.test(raw)) {
-                        throw this.unsupported(name, 'Only nonempty ASCII letter and space string keys are fixture-backed.');
-                    }
-                    const key = createHash('sha256').update(raw).digest('hex');
-                    const claims = new Map<string, { source: string; sequence: string }>();
-                    const owners = new Map<string, string>();
-                    for (const prior of history) {
-                        const priorProperty = definition.uniqueConstraint!.eventDefinitions.find(entry =>
-                            entry.eventTypeId === prior.eventType.id.value)?.properties[0];
-                        if (priorProperty !== undefined) {
-                            const priorValue = prior.content[priorProperty];
-                            if (typeof priorValue !== 'string') throw this.unsupported(name, 'History has an unproven key.');
-                            owners.set(prior.context.eventSourceId, createHash('sha256').update(priorValue).digest('hex'));
-                            claims.set(createHash('sha256').update(priorValue).digest('hex'), {
-                                source: prior.context.eventSourceId, sequence: prior.context.sequenceNumber.toString()
-                            });
-                        }
-                    }
-                    const ownerKey = owners.get(source);
-                    if (ownerKey !== undefined && ownerKey !== key) {
-                        throw this.unsupported(name, 'Replacing a unique key is not fixture-backed.');
-                    }
-                    const stagedOwner = stagedKeys.get(`${name}\u0000${source}`);
-                    if (stagedOwner !== undefined && stagedOwner !== key) {
-                        throw this.unsupported(name, 'Replacing a key within one batch is not fixture-backed.');
-                    }
-                    const existing = claims.get(key);
-                    const batchOwner = stagedKeys.get(`${name}\u0001${key}`);
-                    if (existing && existing.source !== source || batchOwner && batchOwner !== source) {
+                    const raw = kernelKeyString(event.content[property], name);
+                    const key = keyHash(raw);
+                    const existing = [...owners.get(name)!.entries()].find(([, claim]) => claim.key === key);
+                    const batchClaims = stagedKeys.get(name) ?? new Map<string, string>();
+                    const batchOwner = batchClaims.get(key);
+                    if (existing && existing[0] !== source || batchOwner !== undefined && batchOwner !== source) {
                         const details = { PropertyName: property, PropertyValue: raw };
-                        violations.push({ EventTypeId: type, SequenceNumber: BigInt(existing?.sequence ?? unavailable), ConstraintType: 1,
+                        violations.push({ EventTypeId: type, SequenceNumber: BigInt(existing?.[1].sequence ?? unavailable), ConstraintType: 1,
                             ConstraintName: name,
-                            Message: `Event '${type}' on member '${property}' violated a unique constraint on sequence number ${existing?.sequence ?? unavailable}`,
+                            Message: `Event '${type}' on member '${property}' violated a unique constraint on sequence number ${existing?.[1].sequence ?? unavailable}`,
                             Details: details });
                     } else {
-                        stagedKeys.set(`${name}\u0000${source}`, key);
-                        stagedKeys.set(`${name}\u0001${key}`, source);
+                        batchClaims.set(key, source);
+                        stagedKeys.set(name, batchClaims);
                     }
                 }
                 const uniqueType = definition.uniqueEventType;

package/testing/InProcessEventSequence.ts

@@ -94,7 +94,8 @@ export class InProcessEventSequence implements IEventSequence {
             if (eventType.generation.value !== 1 || eventType.tombstone) {
                 throw this.unsupported('artifacts.eventTypes', type.name, 'Only generation 1, non-tombstone events are proven.');
             }
-            if (options.constraints !== 'disabled' && getRemovedConstraintNames(type).length) {
+            if (options.constraints !== 'disabled' && getRemovedConstraintNames(type).length &&
+                !this._constraints?.hasRemovalType(eventType.id.value)) {
                 throw this.unsupported('artifacts.eventTypes.constraints', type.name, 'Constraint removal is not fixture-backed.');
             }
             if (getTagsFor(type).length) throw this.unsupported('artifacts.eventTypes.tags', type.name, 'Tagged events are not fixture-backed.');
@@ -104,7 +105,8 @@ export class InProcessEventSequence implements IEventSequence {
                 schema.enum !== undefined || schema.items !== undefined || schema.format !== undefined ||
                 schema.additionalProperties !== false ||
                 schema.required?.length !== Object.keys(schema.properties ?? {}).length ||
-                !schema.properties || Object.keys(schema.properties).length === 0 ||
+                !schema.properties || (Object.keys(schema.properties).length === 0 &&
+                    !this._constraints?.isRemovalOnlyType(eventType.id.value)) ||
                 Object.entries(schema.properties).some(([key, property]) =>
                     !/^[a-z][a-zA-Z0-9]*$/.test(key) || !['string', 'boolean'].includes(property.type ?? '') ||
                     property.format !== undefined || property.compliance?.length || property.security?.length ||
@@ -170,8 +172,10 @@ export class InProcessEventSequence implements IEventSequence {
             let content: Record<string, unknown>;
             try {
                 prepared = prepareSingleAppend(event, this._correlationId ? { correlationId: this._correlationId() } : undefined);
-                content = JSON.parse(prepared.content) as Record<string, unknown>;
+                content = this.checkedContent(event, prepared.content, 'append.content',
+                    'Content differs from the flat scalar schema; null, missing and extra values are not proven.');
             } catch (error) {
+                if (error instanceof UnsupportedEventSequenceOperation) throw error;
                 throw this.unsupported('append.serialization', event.constructor.name, `Payload or metadata could not be serialized: ${String(error)}.`);
             }
             try {
@@ -184,13 +188,6 @@ export class InProcessEventSequence implements IEventSequence {
                 Object.keys(prepared.causationChain[0].properties).length !== 0) {
                 throw this.unsupported('append.context', event.constructor.name, 'Ambient identity or causation metadata is not fixture-backed.');
             }
-            const properties = metadata.schema.properties!;
-            if (!content || typeof content !== 'object' || Array.isArray(content) ||
-                Object.keys(content).length !== Object.keys(properties).length ||
-                Object.entries(properties).some(([key, property]) => typeof content[key] !== property.type ||
-                    (property.type === 'string' && !/^[\x20-\x21\x23-\x5b\x5d-\x7e\u00e9]*$/.test(content[key] as string)))) {
-                throw this.unsupported('append.content', event.constructor.name, 'Content differs from the flat scalar schema; null, missing and extra values are not proven.');
-            }
             const occurred = this._clock();
             // Date has millisecond precision; only the UTC year range representable by DateTimeOffset is supported.
             if (!(occurred instanceof Date) || Number.isNaN(occurred.getTime()) ||
@@ -432,16 +429,20 @@ export class InProcessEventSequence implements IEventSequence {
         }
     }
 
-    private checkedContent(event: object, serialized: string, operation: string): Record<string, unknown> {
+    private checkedContent(event: object, serialized: string, operation: string,
+        mismatchReason = 'Content differs from the fixture-backed scalar schema.'): Record<string, unknown> {
         let content: Record<string, unknown>;
         try { content = JSON.parse(serialized) as Record<string, unknown>; }
         catch { throw this.unsupported(operation, event.constructor.name, 'Content must be valid JSON.'); }
-        const properties = this._catalog.get(event.constructor)!.schema.properties!;
+        const metadata = this._catalog.get(event.constructor)!;
+        const properties = metadata.schema.properties!;
         if (!content || typeof content !== 'object' || Array.isArray(content) ||
             Object.keys(content).length !== Object.keys(properties).length ||
             Object.entries(properties).some(([key, property]) => typeof content[key] !== property.type ||
+                (this._constraints?.isConstrainedProperty(metadata.eventType.id.value, key) &&
+                    (typeof Reflect.get(event, key) !== property.type || Reflect.get(event, key) !== content[key])) ||
                 (property.type === 'string' && !/^[\x20-\x21\x23-\x5b\x5d-\x7e\u00e9]*$/.test(content[key] as string)))) {
-            throw this.unsupported(operation, event.constructor.name, 'Content differs from the fixture-backed scalar schema.');
+            throw this.unsupported(operation, event.constructor.name, mismatchReason);
         }
         return content;
     }