@cratis/chronicle 6.7.0 → 6.8.0

package/projections/Projections.modelBoundCompleteness.spec.ts

@@ -7,7 +7,6 @@ import { describe, expect, it, vi } from 'vitest';
 import { IClientArtifactsProvider } from '../artifacts/index.js';
 import { ChronicleConnection } from '../connection/index.js';
 import { eventType } from '../events/eventTypeDecorator.js';
-import { readModel } from '../readModels/readModel.js';
 import { clearWith } from './modelBound/clearWith.js';
 import { eventLog, eventSequence } from './modelBound/eventSequence.js';
 import { fromAll } from './modelBound/fromAll.js';
@@ -40,7 +39,6 @@ setFrom(MbWorkArrangementSet, 'location')(MbAssignmentSummary.prototype, 'locati
 noAutoMap(MbAssignmentSummary.prototype, 'location');
 setFrom(MbCandidateSubmitted, 'name')(MbAssignmentSummary.prototype, 'candidateName');
 fromEvent(MbWorkArrangementSet)(MbAssignmentSummary);
-readModel()(MbAssignmentSummary);
 
 class MbFullyExcluded {
     id!: string;
@@ -49,7 +47,6 @@ class MbFullyExcluded {
 setFrom(MbWorkArrangementSet, 'location')(MbFullyExcluded.prototype, 'location');
 fromEvent(MbWorkArrangementSet)(MbFullyExcluded);
 noAutoMap(MbFullyExcluded);
-readModel()(MbFullyExcluded);
 
 class MbProductRenamed {
     name!: string;
@@ -72,7 +69,6 @@ class MbProductVersion {
 fromAll('version')(MbProductVersion.prototype, 'version');
 fromEvent(MbProductRenamed)(MbProductVersion);
 fromEvent(MbProductPriceChanged)(MbProductVersion);
-readModel()(MbProductVersion);
 
 class MbOrderPlaced {
     amount!: number;
@@ -86,7 +82,6 @@ class MbOrderSummaryWithCustomSequence {
 setFrom(MbOrderPlaced, 'amount')(MbOrderSummaryWithCustomSequence.prototype, 'totalAmount');
 fromEvent(MbOrderPlaced)(MbOrderSummaryWithCustomSequence);
 eventSequence('custom-sequence')(MbOrderSummaryWithCustomSequence);
-readModel()(MbOrderSummaryWithCustomSequence);
 
 class MbLocalEvent {
     data!: string;
@@ -100,7 +95,6 @@ class MbLocalSnapshot {
 setFrom(MbLocalEvent, 'data')(MbLocalSnapshot.prototype, 'data');
 fromEvent(MbLocalEvent)(MbLocalSnapshot);
 eventLog(MbLocalSnapshot);
-readModel()(MbLocalSnapshot);
 
 class MbProjectNoted {
     note!: string;
@@ -117,7 +111,6 @@ class MbProjectNotes {
 setFrom(MbProjectNoted, 'note')(MbProjectNotes.prototype, 'note');
 clearWith(MbProjectNoteCleared)(MbProjectNotes.prototype, 'note');
 fromEvent(MbProjectNoted)(MbProjectNotes);
-readModel()(MbProjectNotes);
 
 interface BuiltFromEntry {
     Key: { Id: string };

package/projections/Projections.operationalSurface.spec.ts

@@ -7,7 +7,6 @@ import { IClientArtifactsProvider } from '../artifacts/index.js';
 import { ChronicleConnection } from '../connection/index.js';
 import { ObserverRunningState } from '../observation/ObserverRunningState.js';
 import { eventType } from '../events/eventTypeDecorator.js';
-import { readModel } from '../readModels/readModel.js';
 import { eventSequence } from './modelBound/eventSequence.js';
 import { fromEvent } from './modelBound/fromEvent.js';
 import { projection } from './declarative/projection.js';
@@ -30,17 +29,14 @@ class OpSummary {
 }
 fromEvent(OpStateChanged)(OpSummary);
 eventSequence('custom-op-sequence')(OpSummary);
-readModel()(OpSummary);
 
 class UndiscoveredSummary {
     id!: string;
 }
-readModel()(UndiscoveredSummary);
 
 class DeclarativeReadModel {
     id!: string;
 }
-readModel()(DeclarativeReadModel);
 
 class DeclarativeSummaryProjection implements IProjectionFor<DeclarativeReadModel> {
     // discover() never calls define() - only register() does - so a no-op body is sufficient here.

package/projections/Projections.spec.ts

@@ -6,7 +6,6 @@ import { describe, expect, it, vi } from 'vitest';
 import { IClientArtifactsProvider } from '../artifacts/index.js';
 import { ChronicleConnection } from '../connection/index.js';
 import { eventType } from '../events/eventTypeDecorator.js';
-import { readModel } from '../readModels/readModel.js';
 import { addFrom } from './modelBound/addFrom.js';
 import { count } from './modelBound/count.js';
 import { decrement } from './modelBound/decrement.js';
@@ -59,7 +58,6 @@ decrement(CounterDecremented)(Inventory.prototype, 'decrementedCount');
 count(ThingHappened)(Inventory.prototype, 'thingsHappenedCount');
 count(KeyedThingHappened, 'all-things')(Inventory.prototype, 'constantKeyedCount');
 fromEvent(ItemAdded)(Inventory);
-readModel()(Inventory);
 
 /**
  * Builds a {@link Projections} instance wired to capture the registration payload sent

package/projections/Projections.ts

@@ -601,7 +601,7 @@ export class Projections implements IProjections {
                 }
             }
 
-            const memberNames = new Set(getReadModelMetadata(type)?.members.keys() ?? properties);
+            const memberNames = new Set(getReadModelMetadata(type)?.members.keys() ?? TypeIntrospector.getMembers(type).keys());
             const merged = mergeGlobalHandlers(type.name, memberNames, from, globalHandlers);
             const reclassified = reclassify(type.name, merged, join, enteringEventTypes, variantMetadata.key);
             from = reclassified.from;

package/projections/Projections.variants.spec.ts

@@ -6,7 +6,6 @@ import { describe, expect, it, vi } from 'vitest';
 import { IClientArtifactsProvider } from '../artifacts/index.js';
 import { ChronicleConnection } from '../connection/index.js';
 import { eventType } from '../events/eventTypeDecorator.js';
-import { readModel } from '../readModels/readModel.js';
 import { entersOn } from './modelBound/entersOn.js';
 import { fromEvent } from './modelBound/fromEvent.js';
 import { globalFor } from './modelBound/globalFor.js';
@@ -50,7 +49,6 @@ setFrom(IssueCreated, 'title')(BacklogItem.prototype, 'title');
 variantOf(WorkItem, 'id')(BacklogItem);
 entersOn(IssueCreated)(BacklogItem);
 fromEvent(IssueCreated)(BacklogItem);
-readModel()(BacklogItem);
 
 class PullRequestItem {
     id!: string;
@@ -64,7 +62,6 @@ variantOf(WorkItem, 'id')(PullRequestItem);
 entersOn(PullRequestCreated)(PullRequestItem);
 fromEvent(PullRequestCreated)(PullRequestItem);
 fromEvent(BuildCompleted)(PullRequestItem);
-readModel()(PullRequestItem);
 
 /** A shared handler with no entering event of its own - never registered as its own projection. */
 class TitleHandler {
@@ -81,7 +78,6 @@ class UndeclaredVariant {
 setFrom(IssueCreated, 'title')(UndeclaredVariant.prototype, 'title');
 variantOf(WorkItem, 'id')(UndeclaredVariant);
 fromEvent(IssueCreated)(UndeclaredVariant);
-readModel()(UndeclaredVariant);
 
 /** A separate identity, used to prove sibling cross-wiring stays scoped to one identity. */
 class OtherIdentity {}
@@ -92,7 +88,6 @@ class OtherVariant {
 variantOf(OtherIdentity, 'id')(OtherVariant);
 entersOn(IssueCreated)(OtherVariant);
 fromEvent(IssueCreated)(OtherVariant);
-readModel()(OtherVariant);
 
 interface CapturedDefinition {
     Identifier: string;

package/readModels/MaterializedReadModels.spec.ts

@@ -7,7 +7,6 @@ import { describe, expect, it, vi } from 'vitest';
 import type { ChronicleConnection } from '../connection/index.js';
 import { pii } from '../compliance/pii.js';
 import { subject } from '../compliance/subject.js';
-import { readModel } from './readModel.js';
 import { MaterializedReadModels } from './MaterializedReadModels.js';
 
 // Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
@@ -37,7 +36,6 @@ describe('MaterializedReadModels', () => {
         field(String)(Employee.prototype, 'ssn');
         pii()(Employee.prototype, 'ssn');
         subject()(Employee.prototype, 'personId');
-        readModel('EmployeeWithSubjectMaterialized')(Employee);
 
         it('should release using the decorated property as the subject', async () => {
             const json = JSON.stringify({ id: 'employee-1', personId: 'person-42', ssn: '123-45-6789' });
@@ -57,7 +55,6 @@ describe('MaterializedReadModels', () => {
         field(String)(Customer.prototype, 'id');
         field(String)(Customer.prototype, 'ssn');
         pii()(Customer.prototype, 'ssn');
-        readModel('CustomerWithIdOnlyMaterialized')(Customer);
 
         it('should fall back to the id property as the subject, unchanged from today', async () => {
             const json = JSON.stringify({ id: 'customer-7', ssn: '987-65-4321' });
@@ -75,7 +72,6 @@ describe('MaterializedReadModels', () => {
         }
         field(String)(Anonymous.prototype, 'ssn');
         pii()(Anonymous.prototype, 'ssn');
-        readModel('AnonymousMaterialized')(Anonymous);
 
         it('should fail closed without a subject', async () => {
             const json = JSON.stringify({ ssn: '000-00-0000' });
@@ -98,7 +94,6 @@ describe('MaterializedReadModels', () => {
         field(String)(PrivateCustomer.prototype, 'id');
         field(String)(PrivateCustomer.prototype, 'ssn');
         pii()(PrivateCustomer.prototype, 'ssn');
-        readModel('PrivateCustomer')(PrivateCustomer);
 
         it('should reject instead of returning encrypted content', async () => {
             const { readModels } = createMaterializedReadModels(

package/readModels/ReadModels.spec.ts

@@ -10,7 +10,6 @@ import { subject } from '../compliance/subject.js';
 import { pii } from '../compliance/pii.js';
 import { reducer } from '../reducers/reducer.js';
 import { fromEvent } from '../projections/modelBound/fromEvent.js';
-import { readModel } from './readModel.js';
 import { ReadModels } from './ReadModels.js';
 
 // Decorators are applied as plain function calls (rather than `@decorator` syntax) so these
@@ -49,7 +48,6 @@ describe('ReadModels', () => {
     describe('when no read model instance exists for a key', () => {
         class MissingModel { id = ''; }
         fromEvent(SomeEvent)(MissingModel);
-        readModel('MissingModel')(MissingModel);
 
         it('should retain the legacy prototype-only instance for getInstanceById', async () => {
             const { readModels, release } = createReadModels(MissingModel);
@@ -80,7 +78,6 @@ describe('ReadModels', () => {
         class ExistingModel { id = ''; }
         field(String)(ExistingModel.prototype, 'id');
         fromEvent(SomeEvent)(ExistingModel);
-        readModel('ExistingModel')(ExistingModel);
 
         it('should deserialize the model', async () => {
             const { readModels, getInstanceByKey } = createReadModels(ExistingModel);
@@ -99,7 +96,6 @@ describe('ReadModels', () => {
         field(String)(PrivateModel.prototype, 'id');
         field(String)(PrivateModel.prototype, 'ssn');
         pii()(PrivateModel.prototype, 'ssn');
-        readModel('PrivateInstanceModel')(PrivateModel);
         class PrivateReducer {}
         reducer('PrivateInstanceReducer', undefined, PrivateModel)(PrivateReducer);
 
@@ -124,7 +120,6 @@ describe('ReadModels', () => {
         field(String)(PrivateModel.prototype, 'id');
         field(String)(PrivateModel.prototype, 'ssn');
         pii()(PrivateModel.prototype, 'ssn');
-        readModel('PrivateReducerModel')(PrivateModel);
         class PrivateReducer {}
         reducer('PrivateReducer', undefined, PrivateModel)(PrivateReducer);
 
@@ -150,7 +145,6 @@ describe('ReadModels', () => {
         }
         subject()(Employee.prototype, 'personId');
         fromEvent(SomeEvent)(Employee);
-        readModel('EmployeeWithSubject')(Employee);
 
         it('should release using the decorated property as the subject', async () => {
             const { readModels, release } = createReadModels(Employee);
@@ -169,7 +163,6 @@ describe('ReadModels', () => {
             id = '';
         }
         fromEvent(SomeEvent)(Customer);
-        readModel('CustomerWithIdOnly')(Customer);
 
         it('should fall back to the id property as the subject, unchanged from today', async () => {
             const { readModels, release } = createReadModels(Customer);
@@ -187,7 +180,6 @@ describe('ReadModels', () => {
             name = '';
         }
         fromEvent(SomeEvent)(Anonymous);
-        readModel('AnonymousReadModel')(Anonymous);
 
         it('should throw, same as today', async () => {
             const { readModels } = createReadModels(Anonymous);
@@ -202,7 +194,6 @@ describe('ReadModels', () => {
             id = '';
         }
         fromEvent(SomeEvent)(Customer);
-        readModel('CustomerForReleaseMany')(Customer);
 
         it('should release each instance using its own resolved subject', async () => {
             const { readModels, release } = createReadModels(Customer);

package/readModels/ReadModels.ts

@@ -324,7 +324,7 @@ export class ReadModels implements IReadModels {
     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/discovery.spec.ts

@@ -67,22 +67,41 @@ describe('when discovering read models from observers', () => {
         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 decorated and custom identifiers', async () => {
+    it('should deduplicate inferred types and retain custom identifiers', async () => {
         const provider = DefaultClientArtifactsProvider.default;
-        for (const type of [ModelBound, Projected, Reduced, Legacy]) {
+        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', 'legacy-id']) {
+        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'; }

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,7 +89,7 @@ function createConnection() {
 }
 
 describe('Reducers', () => {
-    describe('when a reducer produces a model without @readModel', () => {
+    describe('when a reducer produces an inferred model', () => {
         class NamedState {
             static readonly readModelId = 'existing-state-id';
             count = 0;

package/reducers/Reducers.ts

@@ -213,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));
         }
 

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/);
     });
 

package/types/TypeDiscoverer.ts

@@ -75,7 +75,7 @@ export class TypeDiscoverer {
         if (decoratorType === DecoratorType.ReadModel) {
             const previous = Array.from(typesForDecorator).find(([, registered]) => registered === type);
             if (previous && previous[0] !== discoveredName) {
-                // A named @readModel overrides the type-name alias registered by an observer.
+                // An explicit legacy registration overrides the type-name alias registered by an observer.
                 if (previous[0] !== type.name) return;
                 typesForDecorator.delete(previous[0]);
             }