@cratis/chronicle 6.3.1 → 6.4.0

package/schemas/createDeferredSchema.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { JsonSchema } from './JsonSchema.js';
+import { JsonSchemaGenerator } from './JsonSchemaGenerator.js';
+import { TypeIntrospector } from '../types/TypeIntrospector.js';
+import { requireCompletedStandardMetadata } from '../types/standardDecoratorMetadata.js';
+
+/** Resolves a standard-decorated class's members and schema together, after class evaluation. */
+export function createDeferredSchema(getType: () => Function): () => { members: ReadonlyMap<string, Function | undefined>; schema: JsonSchema } {
+    let resolved: { members: ReadonlyMap<string, Function | undefined>; schema: JsonSchema } | undefined;
+    return () => {
+        const type = getType();
+        requireCompletedStandardMetadata(type);
+        if (!resolved) {
+            const members = TypeIntrospector.getMembers(type);
+            resolved = { members, schema: JsonSchemaGenerator.generate(type, members, { requireResolvedTypes: true }) };
+        }
+        return resolved;
+    };
+}

package/schemas/decorators.expected.fixture.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { JsonSchema } from './JsonSchema.js';
+
+/** Expected schema contract for both decorator transforms. */
+export const expectedProperties: Record<string, JsonSchema> = {
+    name: { type: 'string' },
+    age: { type: 'number' },
+    active: { type: 'boolean' },
+    id: { type: 'string', format: 'guid' },
+    occurred: { type: 'string', format: 'date-time' },
+    codes: { type: 'array', items: { type: 'string' } },
+    address: {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        title: 'Address',
+        type: 'object',
+        properties: { city: { type: 'string' } },
+        required: ['city'],
+        additionalProperties: false
+    },
+    code: { type: 'string' },
+    quantity: { type: 'number' }
+};

package/schemas/decorators.legacy.spec.ts

@@ -0,0 +1,62 @@
+// 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, expect, it } from 'vitest';
+import { eventType, getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { getReadModelMetadata, readModel } from '../readModels/readModel.js';
+import { expectedProperties } from './decorators.expected.fixture.js';
+import { getProjectionMetadata, projection } from '../projections/declarative/projection.js';
+import { getReducerMetadata, reducer } from '../reducers/reducer.js';
+import { getReactorMetadata, reactor } from '../reactors/reactor.js';
+
+class Code extends ConceptAs<string> {
+    static readonly valueType = String;
+}
+
+class Quantity extends ConceptAs<number> {
+    static readonly valueType = Number;
+}
+
+class Address {
+    @field(String) city!: string;
+}
+
+@eventType('legacy-fixture')
+class LegacyEvent {
+    @field(String) name!: string;
+    @field(Number) age!: number;
+    @field(Boolean) active!: boolean;
+    @field(Guid) id!: Guid;
+    @field(Date) occurred!: Date;
+    @field(Array, { genericArguments: [Code] }) codes!: Code[];
+    @field(Address) address!: Address;
+    @field(Code) code!: Code;
+    @field(Quantity) quantity!: Quantity;
+}
+
+@readModel('legacy-model')
+class LegacyModel {
+    @field(Number) count!: number;
+}
+
+@projection('legacy-projection', LegacyModel)
+class LegacyProjection {}
+
+@reducer('legacy-reducer', undefined, LegacyModel)
+class LegacyReducer {}
+
+@reactor('legacy-reactor')
+class LegacyReactor {}
+
+describe('legacy decorator syntax', () => {
+    it('registers the same schemas as standard decorators', () => {
+        expect(getEventTypeMetadata(LegacyEvent)?.eventType.id.value).toBe('legacy-fixture');
+        expect(getReadModelMetadata(LegacyModel)?.schema.properties?.count.type).toBe('number');
+        expect(getEventTypeMetadata(LegacyEvent)?.schema.properties).toEqual(expectedProperties);
+        expect(getEventTypeMetadata(LegacyEvent)?.schema.required).toEqual(Object.keys(expectedProperties));
+        expect(getProjectionMetadata(LegacyProjection)?.id.value).toBe('legacy-projection');
+        expect(getReducerMetadata(LegacyReducer)?.id.value).toBe('legacy-reducer');
+        expect(getReactorMetadata(LegacyReactor)?.id.value).toBe('legacy-reactor');
+    });
+});

package/schemas/decorators.standard.spec.ts

@@ -0,0 +1,235 @@
+// 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, typeKey } from '@cratis/fundamentals';
+import { describe, expect, it } from 'vitest';
+import { eventType, getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { getReadModelMetadata, readModel } from '../readModels/readModel.js';
+import { getSetFromMetadata, setFrom } from '../projections/modelBound/setFrom.js';
+import { getProjectionMetadata, projection } from '../projections/declarative/projection.js';
+import { getReducerMetadata, reducer } from '../reducers/reducer.js';
+import { getReactorMetadata, reactor } from '../reactors/reactor.js';
+import { DecoratorType, TypeDiscoverer } from '../types/index.js';
+import { pii } from '../compliance/pii.js';
+import { subject, getSubjectPropertyName } from '../compliance/subject.js';
+import { encrypted } from '../confidentiality/encrypted.js';
+import { JsonSchemaGenerator } from './JsonSchemaGenerator.js';
+import { expectedProperties } from './decorators.expected.fixture.js';
+
+class Code extends ConceptAs<string> {
+    static readonly valueType = String;
+}
+
+class Quantity extends ConceptAs<number> {
+    static readonly valueType = Number;
+}
+
+class Address {
+    @field(String) city!: string;
+}
+
+function replaceClass<T extends new (...args: never[]) => object>(value: T, _context: ClassDecoratorContext<T>): T {
+    return class extends (value as new () => object) {} as T;
+}
+
+@replaceClass
+@eventType('replaced-event')
+class ReplacedEvent {
+    @field(String) value!: string;
+}
+
+@replaceClass
+@readModel('replaced-model')
+class ReplacedModel {
+    @field(Number) amount!: number;
+}
+
+@eventType('standard-fixture')
+class StandardEvent {
+    @field(String) name!: string;
+    @field(Number) age!: number;
+    @field(Boolean) active!: boolean;
+    @field(Guid) id!: Guid;
+    @field(Date) occurred!: Date;
+    @field(Array, { genericArguments: [Code] }) codes!: Code[];
+    @field(Address) address!: Address;
+    @field(Code) code!: Code;
+    @field(Quantity) quantity!: Quantity;
+}
+
+@readModel('standard-model')
+class StandardModel {
+    @field(Number)
+    @setFrom(StandardEvent)
+    count!: number;
+
+    @field(String)
+    @subject()
+    ownerId!: string;
+
+    @field(String)
+    @pii('personal')
+    contact!: string;
+
+    @field(String)
+    @encrypted()
+    secret!: string;
+}
+
+class ParentMapping {
+    @setFrom(StandardEvent) value!: string;
+}
+
+class ChildMapping extends ParentMapping {
+    @setFrom(StandardEvent, 'name') value = '';
+}
+
+@eventType('empty-schema')
+class MissingMembers {}
+
+@readModel('empty-model')
+class EmptyModel {}
+
+@eventType('missing-field')
+class MissingField {
+    constructor(readonly value: string) {}
+}
+
+class UnspecifiedQuantity extends ConceptAs<number> {}
+
+class ConceptGuid extends ConceptAs<Guid> {
+    static readonly valueType = Guid;
+}
+
+class ConceptDate extends ConceptAs<Date> {
+    static readonly valueType = Date;
+}
+
+@eventType('untyped-concept')
+class UntypedConceptEvent {
+    @field(UnspecifiedQuantity) quantity!: UnspecifiedQuantity;
+}
+
+class ForeignConcept {
+    static readonly [typeKey] = 'ConceptAs';
+    static readonly valueType = Number;
+}
+
+class ForeignGuid {
+    static readonly [typeKey] = 'Guid';
+}
+
+@eventType('foreign-types')
+class ForeignTypes {
+    @field(ForeignConcept) amount!: ForeignConcept;
+    @field(ForeignGuid) id!: ForeignGuid;
+    @field(Object) data!: object;
+    @field(ConceptGuid) conceptId!: ConceptGuid;
+    @field(ConceptDate) conceptDate!: ConceptDate;
+    @field(Array, { genericArguments: [String] }) names!: string[];
+    @field(Array, { genericArguments: [Number] }) numbers!: number[];
+    @field(Array, { genericArguments: [Boolean] }) flags!: boolean[];
+    @field(Array, { genericArguments: [Guid] }) guids!: Guid[];
+    @field(Array, { genericArguments: [Address] }) addresses!: Address[];
+}
+
+class UndecoratedModel {
+    @field(Array) items!: string[];
+}
+
+@eventType('untyped-array')
+class UntypedArray {
+    @field(Array) items!: string[];
+}
+
+@projection('standard-projection', StandardModel)
+class StandardProjection {}
+
+@reducer('standard-reducer', undefined, StandardModel)
+class StandardReducer {}
+
+@reactor('standard-reactor')
+class StandardReactor {}
+
+const standardSchema = getEventTypeMetadata(StandardEvent)!.schema;
+
+// No instance is constructed: @field's standard metadata must be available after class evaluation.
+describe('standard decorator syntax', () => {
+    it('registers the event and read model with their declared member types', () => {
+        expect(getEventTypeMetadata(StandardEvent)?.eventType.id.value).toBe('standard-fixture');
+        expect(getReadModelMetadata(StandardModel)?.schema.properties?.count.type).toBe('number');
+        expect(getSetFromMetadata(StandardModel.prototype, 'count')).toEqual([{ eventType: StandardEvent, eventPropertyName: undefined }]);
+        expect(getSubjectPropertyName(StandardModel)).toBe('ownerId');
+        expect(getReadModelMetadata(StandardModel)?.schema.properties?.contact.compliance).toEqual([{ metadataType: 'PII', details: 'personal' }]);
+        expect(getReadModelMetadata(StandardModel)?.schema.properties?.secret.security).toEqual([{ metadataType: 'EncryptedSubject', details: '' }]);
+        expect(standardSchema.properties).toEqual(expectedProperties);
+        expect(standardSchema.required).toEqual(Object.keys(expectedProperties));
+    });
+
+    it('resolves schemas on an outer decorator replacement class', () => {
+        expect(getEventTypeMetadata(ReplacedEvent)!.schema.properties?.value.type).toBe('string');
+        expect(getReadModelMetadata(ReplacedModel)!.schema.properties?.amount.type).toBe('number');
+        expect(TypeDiscoverer.default.getTypeByDecoratorTypeAndName(DecoratorType.EventType, 'replaced-event')).toBe(ReplacedEvent);
+        expect(TypeDiscoverer.default.getTypeByDecoratorTypeAndName(DecoratorType.ReadModel, 'replaced-model')).toBe(ReplacedModel);
+    });
+
+    it('keeps inherited property metadata copy-on-write', () => {
+        expect(getSetFromMetadata(ParentMapping.prototype, 'value')).toHaveLength(1);
+        expect(getSetFromMetadata(ChildMapping.prototype, 'value')).toHaveLength(2);
+        expect(getSetFromMetadata(ParentMapping.prototype, 'value')).toHaveLength(1);
+    });
+
+    it('registers projections, reducers, and reactors', () => {
+        expect(getProjectionMetadata(StandardProjection)?.id.value).toBe('standard-projection');
+        expect(getReducerMetadata(StandardReducer)?.id.value).toBe('standard-reducer');
+        expect(getReactorMetadata(StandardReactor)?.id.value).toBe('standard-reactor');
+        expect(TypeDiscoverer.default.getTypeByDecoratorTypeAndName(DecoratorType.Projection, 'standard-projection')).toBe(StandardProjection);
+        expect(TypeDiscoverer.default.getTypeByDecoratorTypeAndName(DecoratorType.Reducer, 'standard-reducer')).toBe(StandardReducer);
+        expect(TypeDiscoverer.default.getTypeByDecoratorTypeAndName(DecoratorType.Reactor, 'standard-reactor')).toBe(StandardReactor);
+    });
+
+    it('rejects protected event source identifiers in standard mode', () => {
+        expect(() => {
+            class BadPII {
+                @pii() eventSourceId!: string;
+            }
+            void BadPII;
+        }).toThrow(/cannot be applied to 'eventSourceId'/);
+        expect(() => {
+            class BadEncrypted {
+                @encrypted() eventSourceId!: string;
+            }
+            void BadEncrypted;
+        }).toThrow(/cannot be applied to 'eventSourceId'/);
+    });
+
+    it('rejects missing member metadata instead of registering an empty schema', () => {
+        expect(getEventTypeMetadata(MissingMembers)!.schema.properties).toEqual({});
+        expect(getReadModelMetadata(EmptyModel)!.schema.properties).toEqual({});
+        expect(() => getEventTypeMetadata(MissingField)!.schema).toThrow(/Cannot determine the type of MissingField.value/);
+    });
+
+    it('rejects a concept without a declared primitive in standard mode', () => {
+        expect(() => getEventTypeMetadata(UntypedConceptEvent)!.schema).toThrow(/Cannot determine the value type of concept UnspecifiedQuantity/);
+    });
+
+    it('recognizes Fundamentals types from another package copy by their type key', () => {
+        expect(getEventTypeMetadata(ForeignTypes)!.schema.properties).toMatchObject({
+            amount: { type: 'number' },
+            id: { type: 'string', format: 'guid' },
+            data: { type: 'object' },
+            conceptId: { type: 'string', format: 'guid' },
+            conceptDate: { type: 'string', format: 'date-time' },
+            names: { type: 'array', items: { type: 'string' } },
+            numbers: { type: 'array', items: { type: 'number' } },
+            flags: { type: 'array', items: { type: 'boolean' } },
+            guids: { type: 'array', items: { type: 'string', format: 'guid' } },
+            addresses: { type: 'array', items: { type: 'object', properties: { city: { type: 'string' } } } }
+        });
+    });
+
+    it('rejects untyped arrays in standard mode', () => {
+        expect(() => getEventTypeMetadata(UntypedArray)!.schema).toThrow(/Cannot determine the element type of UntypedArray.items/);
+        expect(() => JsonSchemaGenerator.generate(UndecoratedModel)).toThrow(/Cannot determine the element type of UndecoratedModel.items/);
+    });
+});

package/schemas/index.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export { JsonSchemaGenerator } from './JsonSchemaGenerator';
-export { jsonSchemaProperty, getTrackedJsonSchemaProperties } from './jsonSchemaProperty';
-export type { ComplianceSchemaMetadata, JsonSchema } from './JsonSchema';
+export { JsonSchemaGenerator } from './JsonSchemaGenerator.js';
+export type { JsonSchemaGenerationOptions } from './JsonSchemaGenerator.js';
+export { jsonSchemaProperty, getTrackedJsonSchemaProperties } from './jsonSchemaProperty.js';
+export type { ComplianceSchemaMetadata, JsonSchema } from './JsonSchema.js';

package/schemas/jsonSchemaProperty.ts

@@ -2,16 +2,17 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import 'reflect-metadata';
-import { TypeIntrospector } from '../types';
+import { TypeIntrospector } from '../types/index.js';
+import { ChroniclePropertyDecorator, decorateProperty } from '../types/propertyDecoratorMetadata.js';
 
 /**
  * Decorates a class property so its runtime type metadata can be used for JSON schema generation.
  * @returns A property decorator.
  */
-export function jsonSchemaProperty(): PropertyDecorator {
-    return (target: object, propertyKey: string | symbol) => {
+export function jsonSchemaProperty(): ChroniclePropertyDecorator {
+    return decorateProperty((target: object, propertyKey: string | symbol) => {
         TypeIntrospector.trackProperty(target.constructor as Function, propertyKey.toString());
-    };
+    });
 }
 
 /**

package/schemas/legacyDesignMetadata.spec.ts

@@ -0,0 +1,39 @@
+// 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 { runInNewContext } from 'node:vm';
+import { ConceptAs, field, Guid } from '@cratis/fundamentals';
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+import { JsonSchemaGenerator } from './JsonSchemaGenerator.js';
+
+const source = `
+function mark() { return () => {}; }
+class LegacyId extends ConceptAs {
+    @mark() value!: Guid;
+}
+class LegacyHolder {
+    @field(LegacyId) id!: LegacyId;
+}
+exports.types = { LegacyId, LegacyHolder };
+`;
+
+const compiled = ts.transpileModule(source, {
+    compilerOptions: {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.CommonJS,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true
+    }
+}).outputText;
+
+describe('legacy emitDecoratorMetadata compatibility', () => {
+    it('resolves a Guid-backed concept through emitted design:type', () => {
+        const sandbox = { exports: {} as { types?: { LegacyId: Function; LegacyHolder: Function } }, ConceptAs, field, Guid, Reflect };
+        runInNewContext(compiled, sandbox);
+        const { LegacyId, LegacyHolder } = sandbox.exports.types!;
+        expect(Reflect.getMetadata('design:type', LegacyId.prototype, 'value')).toBe(Guid);
+        expect(JsonSchemaGenerator.generate(LegacyHolder).properties?.id).toEqual({ type: 'string', format: 'guid' });
+    });
+});

package/seeding/EventSeeding.ts

@@ -2,16 +2,16 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { diag } from '@opentelemetry/api';
-import { IClientArtifactsProvider } from '../artifacts';
-import { ChronicleConnection } from '../connection';
-import { ensureCommandSuccess } from '../connection/callResults';
-import { EventStoreNamespaceName } from '../EventStoreNamespaceName';
-import { getEventTypeFor } from '../events/eventTypeDecorator';
-import { getTagsFor } from '../events/tagDecorator';
-import { ICanSeedEvents } from './ICanSeedEvents';
-import { IEventSeeding } from './IEventSeeding';
-import { IEventSeedingBuilder } from './IEventSeedingBuilder';
-import { IEventSeedingScopeBuilder } from './IEventSeedingScopeBuilder';
+import { IClientArtifactsProvider } from '../artifacts/index.js';
+import { ChronicleConnection } from '../connection/index.js';
+import { ensureCommandSuccess } from '../connection/callResults.js';
+import { EventStoreNamespaceName } from '../EventStoreNamespaceName.js';
+import { getEventTypeFor } from '../events/eventTypeDecorator.js';
+import { getTagsFor } from '../events/tagDecorator.js';
+import { ICanSeedEvents } from './ICanSeedEvents.js';
+import { IEventSeeding } from './IEventSeeding.js';
+import { IEventSeedingBuilder } from './IEventSeedingBuilder.js';
+import { IEventSeedingScopeBuilder } from './IEventSeedingScopeBuilder.js';
 
 interface SeedingEntry {
     readonly eventSourceId: string;

package/seeding/ICanSeedEvents.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { IEventSeedingBuilder } from './IEventSeedingBuilder';
+import { IEventSeedingBuilder } from './IEventSeedingBuilder.js';
 
 /**
  * Defines a system that can seed events into the event store.

package/seeding/IEventSeeding.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { IEventSeedingBuilder } from './IEventSeedingBuilder';
+import { IEventSeedingBuilder } from './IEventSeedingBuilder.js';
 
 /**
  * Defines the event seeding API surface.

package/seeding/IEventSeedingBuilder.ts

@@ -1,8 +1,8 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { EventStoreNamespaceName } from '../EventStoreNamespaceName';
-import { IEventSeedingScopeBuilder } from './IEventSeedingScopeBuilder';
+import { EventStoreNamespaceName } from '../EventStoreNamespaceName.js';
+import { IEventSeedingScopeBuilder } from './IEventSeedingScopeBuilder.js';
 
 /**
  * Defines a builder for seeding events in the event store.

package/seeding/index.ts

@@ -1,10 +1,10 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export type { ICanSeedEvents } from './ICanSeedEvents';
-export type { IEventSeedingScopeBuilder } from './IEventSeedingScopeBuilder';
-export type { IEventSeedingBuilder } from './IEventSeedingBuilder';
-export type { IEventSeeding } from './IEventSeeding';
-export { seeder, getSeederMetadata, isSeeder } from './seeder';
-export type { SeederMetadata } from './seeder';
-export { EventSeeding } from './EventSeeding';
+export type { ICanSeedEvents } from './ICanSeedEvents.js';
+export type { IEventSeedingScopeBuilder } from './IEventSeedingScopeBuilder.js';
+export type { IEventSeedingBuilder } from './IEventSeedingBuilder.js';
+export type { IEventSeeding } from './IEventSeeding.js';
+export { seeder, getSeederMetadata, isSeeder } from './seeder.js';
+export type { SeederMetadata } from './seeder.js';
+export { EventSeeding } from './EventSeeding.js';

package/seeding/seeder.ts

@@ -3,7 +3,7 @@
 
 import 'reflect-metadata';
 import { Constructor } from '@cratis/fundamentals';
-import { DecoratorType, TypeDiscoverer } from '../types';
+import { DecoratorType, TypeDiscoverer } from '../types/index.js';
 
 /** Metadata key used to store seeder information on a class. */
 const SEEDER_METADATA_KEY = 'chronicle:seeder';

package/sinks/index.ts

@@ -1,4 +1,4 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export { WellKnownSinks } from './WellKnownSinks';
+export { WellKnownSinks } from './WellKnownSinks.js';

package/transactions/IUnitOfWork.ts

@@ -2,11 +2,11 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Guid } from '@cratis/fundamentals';
-import { AppendError } from '../eventSequences/AppendError';
-import { ConcurrencyViolation } from '../eventSequences/ConcurrencyViolation';
-import { ConstraintViolation } from '../eventSequences/ConstraintViolation';
-import { EventSequenceId } from '../eventSequences/EventSequenceId';
-import { AppendResult } from '../eventSequences/AppendResult';
+import { AppendError } from '../eventSequences/AppendError.js';
+import { ConcurrencyViolation } from '../eventSequences/ConcurrencyViolation.js';
+import { ConstraintViolation } from '../eventSequences/ConstraintViolation.js';
+import { EventSequenceId } from '../eventSequences/EventSequenceId.js';
+import { AppendResult } from '../eventSequences/AppendResult.js';
 
 /**
  * Represents a unit of work for buffering event appends and committing them as transactions.

package/transactions/IUnitOfWorkManager.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Guid } from '@cratis/fundamentals';
-import { IUnitOfWork } from './IUnitOfWork';
+import { IUnitOfWork } from './IUnitOfWork.js';
 
 /**
  * Defines an API for managing units of work in the active async context.

package/transactions/UnitOfWork.spec.ts

@@ -3,12 +3,12 @@
 
 import { describe, expect, it, vi } from 'vitest';
 import { Guid } from '@cratis/fundamentals';
-import type { AppendResult } from '../eventSequences/AppendResult';
-import { EventSequenceId } from '../eventSequences/EventSequenceId';
-import { EventSequenceNumber } from '../eventSequences/EventSequenceNumber';
-import type { IEventSequence } from '../eventSequences/IEventSequence';
-import type { IEventStore } from '../IEventStore';
-import { UnitOfWork } from './UnitOfWork';
+import type { AppendResult } from '../eventSequences/AppendResult.js';
+import { EventSequenceId } from '../eventSequences/EventSequenceId.js';
+import { EventSequenceNumber } from '../eventSequences/EventSequenceNumber.js';
+import type { IEventSequence } from '../eventSequences/IEventSequence.js';
+import type { IEventStore } from '../IEventStore.js';
+import { UnitOfWork } from './UnitOfWork.js';
 
 function createAppendResult(overrides: Partial<AppendResult> = {}): AppendResult {
     return {

package/transactions/UnitOfWork.ts

@@ -2,14 +2,14 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Guid } from '@cratis/fundamentals';
-import { AppendError } from '../eventSequences/AppendError';
-import { AppendResult } from '../eventSequences/AppendResult';
-import { ConcurrencyViolation } from '../eventSequences/ConcurrencyViolation';
-import { ConstraintViolation } from '../eventSequences/ConstraintViolation';
-import { EventForEventSourceId } from '../eventSequences/EventForEventSourceId';
-import { EventSequenceId } from '../eventSequences/EventSequenceId';
-import { IEventStore } from '../IEventStore';
-import { IUnitOfWork } from './IUnitOfWork';
+import { AppendError } from '../eventSequences/AppendError.js';
+import { AppendResult } from '../eventSequences/AppendResult.js';
+import { ConcurrencyViolation } from '../eventSequences/ConcurrencyViolation.js';
+import { ConstraintViolation } from '../eventSequences/ConstraintViolation.js';
+import { EventForEventSourceId } from '../eventSequences/EventForEventSourceId.js';
+import { EventSequenceId } from '../eventSequences/EventSequenceId.js';
+import { IEventStore } from '../IEventStore.js';
+import { IUnitOfWork } from './IUnitOfWork.js';
 
 interface EventForEventSourceIdWithSequenceNumber {
     readonly sequenceNumber: number;

package/transactions/UnitOfWorkManager.ts

@@ -3,11 +3,11 @@
 
 import { AsyncLocalStorage } from 'async_hooks';
 import { Guid } from '@cratis/fundamentals';
-import { IEventStore } from '../IEventStore';
-import { IUnitOfWork } from './IUnitOfWork';
-import { IUnitOfWorkManager } from './IUnitOfWorkManager';
-import { NoUnitOfWorkHasBeenStarted } from './NoUnitOfWorkHasBeenStarted';
-import { UnitOfWork } from './UnitOfWork';
+import { IEventStore } from '../IEventStore.js';
+import { IUnitOfWork } from './IUnitOfWork.js';
+import { IUnitOfWorkManager } from './IUnitOfWorkManager.js';
+import { NoUnitOfWorkHasBeenStarted } from './NoUnitOfWorkHasBeenStarted.js';
+import { UnitOfWork } from './UnitOfWork.js';
 
 /**
  * Implements {@link IUnitOfWorkManager} using {@link AsyncLocalStorage} for async-context scoping.

package/transactions/index.ts

@@ -1,8 +1,8 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export type { IUnitOfWork } from './IUnitOfWork';
-export type { IUnitOfWorkManager } from './IUnitOfWorkManager';
-export { NoUnitOfWorkHasBeenStarted } from './NoUnitOfWorkHasBeenStarted';
-export { UnitOfWork } from './UnitOfWork';
-export { UnitOfWorkManager } from './UnitOfWorkManager';
+export type { IUnitOfWork } from './IUnitOfWork.js';
+export type { IUnitOfWorkManager } from './IUnitOfWorkManager.js';
+export { NoUnitOfWorkHasBeenStarted } from './NoUnitOfWorkHasBeenStarted.js';
+export { UnitOfWork } from './UnitOfWork.js';
+export { UnitOfWorkManager } from './UnitOfWorkManager.js';

package/types/TypeDiscoverer.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import path from 'path';
-import { DecoratorType } from './DecoratorType';
+import { DecoratorType } from './DecoratorType.js';
 import { Constructor } from '@cratis/fundamentals';
 
 type GlobFunction = (pattern: string | string[]) => Promise<string[]>;