@cratis/chronicle 6.6.0 → 6.7.1

package/readModels/ReadModels.ts

@@ -17,11 +17,13 @@ import { ensureQuerySuccess } from '../connection/callResults.js';
 import { EventSequenceId } from '../eventSequences/EventSequenceId.js';
 import { getProjectionMetadata } from '../projections/declarative/projection.js';
 import { hasFromEventMetadata } from '../projections/modelBound/fromEvent.js';
+import { hasModelBoundProperties } from '../types/TypeDiscoverer.js';
 import { isPassive } from '../projections/modelBound/passive.js';
 import { getReducerMetadata } from '../reducers/reducer.js';
 import { JsonSchemaGenerator } from '../schemas/index.js';
 import { WellKnownSinks } from '../sinks/index.js';
-import { getReadModelMetadata } from './readModel.js';
+import { getReadModelMetadata, getReadModelId } from './readModel.js';
+import { assertUniqueReadModelIds } from './assertUniqueReadModelIds.js';
 import type { IMaterializedReadModels } from './IMaterializedReadModels.js';
 import { MaterializedReadModels } from './MaterializedReadModels.js';
 import { ReadModelSubjectResolver } from './ReadModelSubjectResolver.js';
@@ -239,6 +241,7 @@ export class ReadModels implements IReadModels {
     }
 
     private resolveReadModels<TReadModel>(readModelType?: Constructor<TReadModel>): ResolvedReadModel[] {
+        assertUniqueReadModelIds(this._clientArtifacts.readModels);
         const resolved = new Map<string, ResolvedReadModel>();
 
         for (const projectionType of this._clientArtifacts.projections) {
@@ -251,9 +254,8 @@ export class ReadModels implements IReadModels {
                 continue;
             }
 
-            const readModelMetadata = getReadModelMetadata(metadata.readModelType);
-            const identifier = readModelMetadata?.id.value ?? metadata.readModelType.name;
-            resolved.set(identifier, {
+            const identifier = getReadModelId(metadata.readModelType);
+            this.addResolved(resolved, {
                 type: metadata.readModelType,
                 identifier,
                 eventSequenceId: metadata.eventSequenceId ?? EventSequenceId.eventLog.value,
@@ -265,7 +267,7 @@ export class ReadModels implements IReadModels {
         }
 
         for (const modelBoundType of this._clientArtifacts.readModels) {
-            if (!hasFromEventMetadata(modelBoundType)) {
+            if (!hasFromEventMetadata(modelBoundType) && !hasModelBoundProperties(modelBoundType)) {
                 continue;
             }
 
@@ -273,18 +275,14 @@ export class ReadModels implements IReadModels {
                 continue;
             }
 
-            const metadata = getReadModelMetadata(modelBoundType);
-            if (!metadata) {
-                continue;
-            }
-
-            resolved.set(metadata.id.value, {
+            const identifier = getReadModelId(modelBoundType);
+            this.addResolved(resolved, {
                 type: modelBoundType,
-                identifier: metadata.id.value,
+                identifier,
                 eventSequenceId: EventSequenceId.eventLog.value,
                 observerType: ContractReadModelObserverType.Projection,
-                observerIdentifier: metadata.id.value,
-                schema: JSON.stringify(metadata.schema),
+                observerIdentifier: identifier,
+                schema: this.getReadModelSchema(modelBoundType, identifier),
                 isActive: !isPassive(modelBoundType)
             });
         }
@@ -299,9 +297,8 @@ export class ReadModels implements IReadModels {
                 continue;
             }
 
-            const readModelMetadata = getReadModelMetadata(metadata.readModel);
-            const identifier = readModelMetadata?.id.value ?? metadata.readModel.name;
-            resolved.set(identifier, {
+            const identifier = getReadModelId(metadata.readModel);
+            this.addResolved(resolved, {
                 type: metadata.readModel,
                 identifier,
                 eventSequenceId: metadata.eventSequenceId ?? EventSequenceId.eventLog.value,
@@ -315,10 +312,19 @@ export class ReadModels implements IReadModels {
         return Array.from(resolved.values());
     }
 
+    private addResolved(models: Map<string, ResolvedReadModel>, model: ResolvedReadModel): void {
+        const existing = models.get(model.identifier);
+        if (existing && (existing.type !== model.type || existing.observerType !== model.observerType ||
+            existing.observerIdentifier !== model.observerIdentifier)) {
+            throw new Error(`Read model id '${model.identifier}' has multiple observers or model types.`);
+        }
+        models.set(model.identifier, model);
+    }
+
     private resolveReadModel<TReadModel>(readModelType: Constructor<TReadModel>): ResolvedReadModel {
         const [resolved] = this.resolveReadModels(readModelType);
         if (!resolved) {
-            throw new Error(`Unknown read model '${readModelType.name}'. Make sure it is decorated and discoverable.`);
+            throw new Error(`Unknown read model '${readModelType.name}'. Make sure it is discoverable through a projection, reducer, or model-bound mapping.`);
         }
 
         return resolved;

package/readModels/assertUniqueReadModelIds.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { Constructor } from '@cratis/fundamentals';
+import { getReadModelId } from './readModel.js';
+
+/** Refuses to register two different model types under the same storage identity. */
+export function assertUniqueReadModelIds(types: Iterable<Constructor>): void {
+    const byId = new Map<string, Constructor>();
+    for (const type of types) {
+        const id = getReadModelId(type);
+        const previous = byId.get(id);
+        if (previous && previous !== type) {
+            throw new Error(`Read model id '${id}' is shared by '${previous.name}' and '${type.name}'.`);
+        }
+        byId.set(id, type);
+    }
+}

package/readModels/discovery.spec.ts

@@ -0,0 +1,113 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { field } from '@cratis/fundamentals';
+import { describe, expect, it, vi } from 'vitest';
+import { DefaultClientArtifactsProvider } from '../artifacts/DefaultClientArtifactsProvider.js';
+import type { ChronicleConnection } from '../connection/index.js';
+import { projection } from '../projections/declarative/projection.js';
+import { fromEvent } from '../projections/modelBound/fromEvent.js';
+import { setFrom } from '../projections/modelBound/setFrom.js';
+import { Projections } from '../projections/Projections.js';
+import { eventType } from '../events/eventTypeDecorator.js';
+import { TypeDiscoverer } from '../types/TypeDiscoverer.js';
+import { reducer } from '../reducers/reducer.js';
+import { ReadModels } from './ReadModels.js';
+import { readModel } from './readModel.js';
+
+@eventType('discovery-event')
+class Event { @field(String) value!: string; }
+@fromEvent(Event)
+class ModelBound {
+    @field(String) value!: string;
+}
+class Projected {
+    static readonly readModelId = 'projected-custom';
+    @field(String) value!: string;
+}
+@projection('projected-observer', Projected)
+class ProjectedObserver {
+    define() {}
+}
+class Reduced {
+    @field(Number) count!: number;
+}
+@reducer('reduced-observer', undefined, Reduced)
+class ReducedObserver {}
+@readModel('legacy-id')
+@fromEvent(Event)
+class Legacy {
+    @field(String) value!: string;
+}
+class MappedOnly {
+    @field(String)
+    @setFrom(Event)
+    value!: string;
+}
+
+function createConnection() {
+    const registerMany = vi.fn().mockResolvedValue({});
+    const register = vi.fn().mockResolvedValue({});
+    const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+    return { connection, registerMany, register };
+}
+
+describe('when discovering read models from observers', () => {
+    it('should discover and register an exported property-bound model without a class decorator', async () => {
+        const discoverer = new TypeDiscoverer(async () => ['virtual.ts'], async () => ({ MappedOnly }));
+        await discoverer.discover('virtual');
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        expect(provider.readModels).toContain(MappedOnly);
+        const { connection, registerMany, register } = createConnection();
+        const projections = new Projections('store', 'Default', connection, provider, 'sink');
+        await projections.register();
+        const definition = registerMany.mock.calls[0][0].ReadModels.find(
+            (model: { Type: { Identifier: string } }) => model.Type.Identifier === 'MappedOnly');
+        expect(definition).toBeDefined();
+        expect(JSON.parse(definition.Schema).properties.value.type).toBe('string');
+        expect(register.mock.calls.some(call => call[0].Projections[0].ReadModel === 'MappedOnly')).toBe(true);
+    });
+    it('should deduplicate inferred types and retain custom identifiers', async () => {
+        const provider = DefaultClientArtifactsProvider.default;
+        for (const type of [ModelBound, Projected, Reduced]) {
+            expect(provider.readModels.filter(model => model === type)).toHaveLength(1);
+        }
+        const { connection, registerMany } = createConnection();
+        await new ReadModels('store', 'Default', connection, provider, 'sink').register();
+        const definitions = registerMany.mock.calls[0][0].ReadModels;
+        const byId = new Map(definitions.map((definition: { Type: { Identifier: string } }) => [definition.Type.Identifier, definition]));
+        for (const id of ['ModelBound', 'projected-custom', 'Reduced']) {
+            expect(byId.has(id)).toBe(true);
+        }
+        expect(JSON.parse(byId.get('projected-custom').Schema).properties.value.type).toBe('string');
+        expect(JSON.parse(byId.get('Reduced').Schema).properties.count.type).toBe('number');
+    });
+
+    it('should preserve the deprecated decorator identifier, schema, and discovery', async () => {
+        const provider = DefaultClientArtifactsProvider.default;
+        expect(provider.readModels).toContain(Legacy);
+        const { connection, registerMany } = createConnection();
+        await new ReadModels('store', 'Default', connection, provider, 'sink').register();
+        const definition = registerMany.mock.calls[0][0].ReadModels.find(
+            (model: { Type: { Identifier: string } }) => model.Type.Identifier === 'legacy-id');
+        expect(definition).toBeDefined();
+        expect(JSON.parse(definition.Schema).properties.value.type).toBe('string');
+    });
+
+    it('should explain how to discover an unknown model', async () => {
+        class Unknown {}
+        const provider = { ...DefaultClientArtifactsProvider.default, readModels: [], projections: [], reducers: [] };
+        const { connection } = createConnection();
+        await expect(new ReadModels('store', 'Default', connection, provider, 'sink').findInstanceById(Unknown, 'key'))
+            .rejects.toThrow('Make sure it is discoverable through a projection, reducer, or model-bound mapping.');
+    });
+
+    it('should reject two distinct models with the same identifier before registration', async () => {
+        class First { static readonly readModelId = 'collision'; }
+        class Second { static readonly readModelId = 'collision'; }
+        const provider = { ...DefaultClientArtifactsProvider.default, readModels: [First, Second], projections: [], reducers: [] };
+        const { connection, registerMany } = createConnection();
+        await expect(new ReadModels('store', 'Default', connection, provider, 'sink').register()).rejects.toThrow(/collision/);
+        expect(registerMany).not.toHaveBeenCalled();
+    });
+});

package/readModels/readModel.ts

@@ -30,6 +30,9 @@ export interface ReadModelMetadata {
  * TypeScript decorator that marks a class as a read model and captures reflection metadata.
  * @param id - The unique identifier for the read model. Defaults to the class name if omitted.
  * @returns A class decorator.
+ * @deprecated Read models are discovered from @projection(..., ReadModelType),
+ * @reducer(..., ReadModelType), or @fromEvent on the model. For a custom identifier,
+ * declare `static readonly readModelId = 'custom-id'` on the model instead.
  */
 export function readModel(id: string = ''): ChronicleClassDecorator {
     return (target: object, context?: ClassDecoratorContext) => {
@@ -83,3 +86,14 @@ export function getReadModelMetadata(target: Function): ReadModelMetadata | unde
 export function isReadModel(target: Function): boolean {
     return Reflect.hasMetadata(READ_MODEL_METADATA_KEY, target);
 }
+
+/** Resolves the compatible identifier of a decorated or inferred read model. */
+export function getReadModelId(target: Function): string {
+    const decorated = getReadModelMetadata(target);
+    if (decorated) return decorated.id.value;
+    const explicit = (target as unknown as { readModelId?: unknown }).readModelId;
+    if (explicit !== undefined && (typeof explicit !== 'string' || !explicit.trim())) {
+        throw new TypeError(`Read model '${target.name}' must have a non-empty string readModelId.`);
+    }
+    return explicit as string | undefined ?? target.name;
+}

package/readModels/standardFallbacks.standard.spec.ts

@@ -21,7 +21,7 @@ const artifacts = {
     constraints: [], projections: [], webhooks: [], eventTypeMigrations: [], globalForHandlers: []
 } as IClientArtifactsProvider;
 
-describe('standard read models without @readModel', () => {
+describe('inferred read models with standard decorators', () => {
     it('rejects an untyped array before registering a reducer read model', async () => {
         const registerMany = vi.fn();
         const connection = { readModels: { registerMany } } as unknown as ChronicleConnection;

package/reducers/Reducers.spec.ts

@@ -89,6 +89,24 @@ function createConnection() {
 }
 
 describe('Reducers', () => {
+    describe('when a reducer produces an inferred model', () => {
+        class NamedState {
+            static readonly readModelId = 'existing-state-id';
+            count = 0;
+        }
+        class NamedReducer {}
+        reducer('named-reducer', undefined, NamedState)(NamedReducer);
+
+        it('should register the model under its explicit identifier with a schema from its type', async () => {
+            const { connection } = createConnection();
+            const registerMany = vi.spyOn(connection.readModels, 'registerMany');
+            const reducers = new Reducers(createArtifacts([NamedReducer]), connection, 'store', 'Default', new ConnectionLifecycle(), 'sink');
+            await reducers.register();
+            const definition = registerMany.mock.calls[0][0].ReadModels[0];
+            expect(definition.Type.Identifier).toBe('existing-state-id');
+            expect(JSON.parse(definition.Schema).properties.count.type).toBe('number');
+        });
+    });
     describe('when registering an active reducer (the default)', () => {
         class SomeReducer {}
         reducer('some-active-reducer')(SomeReducer);

package/reducers/Reducers.ts

@@ -18,6 +18,8 @@ import { notifyReplayLifecycle } from '../observation/notifyReplayLifecycle.js';
 import { IReducers } from './IReducers.js';
 import { getReducerMetadata } from './reducer.js';
 import { getReadModelMetadata } from '../readModels/index.js';
+import { getReadModelId } from '../readModels/readModel.js';
+import { assertUniqueReadModelIds } from '../readModels/assertUniqueReadModelIds.js';
 import { JsonSchemaGenerator } from '../schemas/index.js';
 
 /** Expression used to partition reducer observations by event source ID. */
@@ -151,6 +153,7 @@ export class Reducers implements IReducers {
             await this.discover();
         }
 
+        assertUniqueReadModelIds(this._clientArtifacts.readModels);
         await this.registerReadModels();
 
         this._logger.info('Registering reducers', { count: this._reducers.size });
@@ -188,6 +191,12 @@ export class Reducers implements IReducers {
             };
         });
 
+        const identifiers = new Set<string>();
+        for (const definition of readModels) {
+            const identifier = definition.Type.Identifier;
+            if (identifiers.has(identifier)) throw new Error(`Read model id '${identifier}' has multiple reducers.`);
+            identifiers.add(identifier);
+        }
         this._logger.info('Registering read models for reducers', { count: readModels.length });
         await this._connection.readModels.registerMany({
             EventStore: this._eventStoreName,
@@ -204,7 +213,7 @@ export class Reducers implements IReducers {
             if (readModelMeta?.schema) {
                 return JSON.stringify(readModelMeta.schema);
             }
-            // No @readModel() decorator — generate from instance
+            // Generate the schema directly from the inferred model type.
             return JSON.stringify(JsonSchemaGenerator.generate(metadata.readModel));
         }
 
@@ -281,7 +290,7 @@ export class Reducers implements IReducers {
     private getReducerReadModelIdentifier(reducerType: Constructor): string {
         const metadata = getReducerMetadata(reducerType);
         if (metadata?.readModel) {
-            return getReadModelMetadata(metadata.readModel)?.id.value ?? metadata.readModel.name;
+            return getReadModelId(metadata.readModel);
         }
 
         return (reducerType as Function).name;

package/schemas/JsonSchemaGenerator.confidentiality.spec.ts

@@ -8,14 +8,13 @@ import { pii } from '../compliance/pii.js';
 import { encrypted } from '../confidentiality/encrypted.js';
 import { EncryptionScope } from '../confidentiality/EncryptionScope.js';
 import { PIIAndEncryptedCombinedNotSupported } from '../confidentiality/PIIAndEncryptedCombinedNotSupported.js';
-import { getReadModelMetadata, readModel } from '../readModels/readModel.js';
+import { JsonSchemaGenerator } from './JsonSchemaGenerator.js';
 import { JsonSchema } from './JsonSchema.js';
 
-// See JsonSchemaGenerator.spec.ts for why decorators are applied as plain function calls here
-// rather than `@decorator` syntax, and why order matters.
+// See JsonSchemaGenerator.spec.ts for why decorators are applied as plain function calls here.
 
 function schemaFor(target: Function): JsonSchema {
-    return getReadModelMetadata(target)!.schema;
+    return JsonSchemaGenerator.generate(target);
 }
 
 describe('JsonSchemaGenerator - security metadata', () => {
@@ -26,7 +25,6 @@ describe('JsonSchemaGenerator - security metadata', () => {
         }
         encrypted()(PartnerCredentials);
 
-        readModel()(PartnerCredentials);
         const schema = schemaFor(PartnerCredentials);
 
         it('should mark every one of its own properties as EncryptedSubject', () => {
@@ -46,7 +44,6 @@ describe('JsonSchemaGenerator - security metadata', () => {
             name = '';
         }
         encrypted(EncryptionScope.Subject, 'Partner API key')(Integration.prototype, 'apiKey');
-        readModel()(Integration);
         const schema = schemaFor(Integration);
 
         it('should mark the decorated property as EncryptedSubject', () => {
@@ -67,7 +64,6 @@ describe('JsonSchemaGenerator - security metadata', () => {
             value = '';
         }
         encrypted(scope)(Secret.prototype, 'value');
-        readModel()(Secret);
         const schema = schemaFor(Secret);
 
         it(`should resolve to metadataType ${expectedMetadataType}`, () => {
@@ -88,7 +84,6 @@ describe('JsonSchemaGenerator - security metadata', () => {
         class Configuration {
             key: ApiKey = new ApiKey('');
         }
-        readModel()(Configuration);
         const schema = schemaFor(Configuration);
 
         it('should mark the concept-typed property as EncryptedNamespace', () => {
@@ -105,7 +100,6 @@ describe('JsonSchemaGenerator - security metadata', () => {
             contact: ContactDetails = new ContactDetails();
         }
         encrypted(EncryptionScope.Subject, 'Vendor contact information')(Vendor.prototype, 'contact');
-        readModel()(Vendor);
         const schema = schemaFor(Vendor);
 
         it('should push the security metadata down onto every leaf property', () => {
@@ -130,7 +124,6 @@ describe('JsonSchemaGenerator - security metadata', () => {
             tokens: Token[] = [];
         }
         field(Array, { enumerable: true, genericArguments: [Token] })(Session.prototype, 'tokens');
-        readModel()(Session);
         const schema = schemaFor(Session);
 
         it('should carry the element concept security metadata onto the item schema', () => {
@@ -150,7 +143,7 @@ describe('JsonSchemaGenerator - security metadata', () => {
         encrypted()(ConflictedValue.prototype, 'value');
 
         it('should throw PIIAndEncryptedCombinedNotSupported when generating the schema', () => {
-            expect(() => { readModel()(ConflictedValue); }).toThrow(PIIAndEncryptedCombinedNotSupported);
+            expect(() => schemaFor(ConflictedValue)).toThrow(PIIAndEncryptedCombinedNotSupported);
         });
     });
 
@@ -162,7 +155,7 @@ describe('JsonSchemaGenerator - security metadata', () => {
         encrypted()(MixedClass.prototype, 'value');
 
         it('should throw PIIAndEncryptedCombinedNotSupported when generating the schema', () => {
-            expect(() => { readModel()(MixedClass); }).toThrow(PIIAndEncryptedCombinedNotSupported);
+            expect(() => schemaFor(MixedClass)).toThrow(PIIAndEncryptedCombinedNotSupported);
         });
     });
 
@@ -171,13 +164,11 @@ describe('JsonSchemaGenerator - security metadata', () => {
             ssn = '';
         }
         pii()(OnlyPii.prototype, 'ssn');
-        readModel()(OnlyPii);
 
         class OnlyEncrypted {
             apiKey = '';
         }
         encrypted()(OnlyEncrypted.prototype, 'apiKey');
-        readModel()(OnlyEncrypted);
 
         it('should not throw for either type', () => {
             expect(() => schemaFor(OnlyPii)).not.toThrow();

package/schemas/JsonSchemaGenerator.spec.ts

@@ -6,19 +6,17 @@ import { ConceptAs, field, Guid } from '@cratis/fundamentals';
 import { describe, expect, it } from 'vitest';
 import { pii } from '../compliance/pii.js';
 import { eventType, getEventTypeJsonSchemaFor } from '../events/eventTypeDecorator.js';
-import { getReadModelMetadata, readModel } from '../readModels/readModel.js';
+import { JsonSchemaGenerator } from './JsonSchemaGenerator.js';
 import { JsonSchema } from './JsonSchema.js';
 
 // Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
 // fixtures don't depend on the test runner's decorator-syntax support - they exercise exactly
 // the same decorator functions and metadata storage that `@decorator` syntax would invoke.
 //
-// Order matters here in a way it would not for a real `@decorator` stack: class decorators
-// apply bottom-to-top, so `pii()` must run - and therefore be called - before `readModel()`/
-// `eventType()` so the compliance metadata already exists when the schema is generated.
+// Apply `pii()` before generating the schema so compliance metadata is available.
 
 function schemaFor(target: Function): JsonSchema {
-    return getReadModelMetadata(target)!.schema;
+    return JsonSchemaGenerator.generate(target);
 }
 
 describe('JsonSchemaGenerator', () => {
@@ -27,7 +25,6 @@ describe('JsonSchemaGenerator', () => {
         class LegacyModel {
             code = new LegacyCode('A');
         }
-        readModel()(LegacyModel);
         expect(schemaFor(LegacyModel).properties?.code.type).toBe('string');
     });
 
@@ -53,7 +50,6 @@ describe('JsonSchemaGenerator', () => {
             email = '';
         }
         pii()(PersonProfile);
-        readModel()(PersonProfile);
 
         const schema = schemaFor(PersonProfile);
 
@@ -69,7 +65,6 @@ describe('JsonSchemaGenerator', () => {
             ssn = '';
         }
         pii('Social security number')(Contact.prototype, 'ssn');
-        readModel()(Contact);
 
         const schema = schemaFor(Contact);
 
@@ -96,7 +91,6 @@ describe('JsonSchemaGenerator', () => {
             class Customer {
                 email: EmailAddress = new EmailAddress('');
             }
-            readModel()(Customer);
 
             const schema = schemaFor(Customer);
 
@@ -130,7 +124,6 @@ describe('JsonSchemaGenerator', () => {
         }
         pii()(Employee.prototype, 'name');
         pii('Every field on this record is personal')(Employee);
-        readModel()(Employee);
 
         const schema = schemaFor(Employee);
 
@@ -156,7 +149,6 @@ describe('JsonSchemaGenerator', () => {
             contact: ContactDetails = new ContactDetails();
         }
         pii('Vendor contact information')(Vendor.prototype, 'contact');
-        readModel()(Vendor);
 
         const schema = schemaFor(Vendor);
 
@@ -182,7 +174,6 @@ describe('JsonSchemaGenerator', () => {
             codes: RequirementCode[] = [];
         }
         field(Array, { enumerable: true, genericArguments: [RequirementCode] })(Contract.prototype, 'codes');
-        readModel()(Contract);
 
         const schema = schemaFor(Contract);
 
@@ -211,7 +202,6 @@ describe('JsonSchemaGenerator', () => {
             items: PlainItem[] = [];
         }
         field(Array, { enumerable: true, genericArguments: [PlainItem] })(Basket.prototype, 'items');
-        readModel()(Basket);
 
         const schema = schemaFor(Basket);
 

package/schemas/decorators.legacy.spec.ts

@@ -4,7 +4,7 @@
 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 { JsonSchemaGenerator } from './JsonSchemaGenerator.js';
 import { expectedProperties } from './decorators.expected.fixture.js';
 import { getProjectionMetadata, projection } from '../projections/declarative/projection.js';
 import { getReducerMetadata, reducer } from '../reducers/reducer.js';
@@ -35,7 +35,6 @@ class LegacyEvent {
     @field(Quantity) quantity!: Quantity;
 }
 
-@readModel('legacy-model')
 class LegacyModel {
     @field(Number) count!: number;
 }
@@ -52,7 +51,7 @@ 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(JsonSchemaGenerator.generate(LegacyModel).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');

package/schemas/decorators.standard.spec.ts

@@ -4,7 +4,7 @@
 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 { getReadModelId } 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';
@@ -39,8 +39,8 @@ class ReplacedEvent {
 }
 
 @replaceClass
-@readModel('replaced-model')
 class ReplacedModel {
+    static readonly readModelId = 'replaced-model';
     @field(Number) amount!: number;
 }
 
@@ -57,7 +57,6 @@ class StandardEvent {
     @field(Quantity) quantity!: Quantity;
 }
 
-@readModel('standard-model')
 class StandardModel {
     @field(Number)
     @setFrom(StandardEvent)
@@ -87,7 +86,6 @@ class ChildMapping extends ParentMapping {
 @eventType('empty-schema')
 class MissingMembers {}
 
-@readModel('empty-model')
 class EmptyModel {}
 
 @eventType('missing-field')
@@ -145,6 +143,9 @@ class UntypedArray {
 @projection('standard-projection', StandardModel)
 class StandardProjection {}
 
+@projection('replaced-model-projection', ReplacedModel)
+class ReplacedModelProjection {}
+
 @reducer('standard-reducer', undefined, StandardModel)
 class StandardReducer {}
 
@@ -157,20 +158,21 @@ const standardSchema = getEventTypeMetadata(StandardEvent)!.schema;
 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(JsonSchemaGenerator.generate(StandardModel).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(JsonSchemaGenerator.generate(StandardModel).properties?.contact.compliance).toEqual([{ metadataType: 'PII', details: 'personal' }]);
+        expect(JsonSchemaGenerator.generate(StandardModel).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(JsonSchemaGenerator.generate(ReplacedModel).properties?.amount.type).toBe('number');
+        expect(getReadModelId(ReplacedModel)).toBe('replaced-model');
         expect(TypeDiscoverer.default.getTypeByDecoratorTypeAndName(DecoratorType.EventType, 'replaced-event')).toBe(ReplacedEvent);
-        expect(TypeDiscoverer.default.getTypeByDecoratorTypeAndName(DecoratorType.ReadModel, 'replaced-model')).toBe(ReplacedModel);
+        expect(getProjectionMetadata(ReplacedModelProjection)?.readModelType).toBe(ReplacedModel);
     });
 
     it('keeps inherited property metadata copy-on-write', () => {
@@ -205,7 +207,7 @@ describe('standard decorator syntax', () => {
 
     it('rejects missing member metadata instead of registering an empty schema', () => {
         expect(getEventTypeMetadata(MissingMembers)!.schema.properties).toEqual({});
-        expect(getReadModelMetadata(EmptyModel)!.schema.properties).toEqual({});
+        expect(JsonSchemaGenerator.generate(EmptyModel).properties).toEqual({});
         expect(() => getEventTypeMetadata(MissingField)!.schema).toThrow(/Cannot determine the type of MissingField.value/);
     });