@cratis/chronicle 6.14.0 → 6.14.2

package/readModels/registration.standard.spec.ts

@@ -0,0 +1,108 @@
+// 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/ChronicleConnection.js';
+import { eventType } from '../events/eventTypeDecorator.js';
+import { Projections } from '../projections/Projections.js';
+import { setFrom } from '../projections/modelBound/setFrom.js';
+import { DecoratorType } from '../types/DecoratorType.js';
+import { TypeDiscoverer } from '../types/TypeDiscoverer.js';
+import { ReadModels } from './ReadModels.js';
+
+@eventType('cold-registration-event')
+class Changed { @field(String) value!: string; }
+
+let constructions = 0;
+class PropertyOnly {
+    @setFrom(Changed, 'value')
+    @field(String)
+    value = '';
+
+    constructor() { constructions++; }
+}
+
+describe('when discovering a standard-decorated property-only read model', () => {
+    it('should register and query the model before any instance has been constructed', async () => {
+        expect(constructions).toBe(0);
+        const discoverer = new TypeDiscoverer(async () => ['models.ts'], async () => ({ PropertyOnly }));
+        await discoverer.discover('models.ts');
+        expect(constructions).toBe(0);
+
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const getInstanceByKey = vi.fn().mockResolvedValue({ ReadModel: '{"value":"stored"}' });
+        const connection = { readModels: { registerMany, getInstanceByKey }, projections: { register } } as unknown as ChronicleConnection;
+        const projections = new Projections('store', 'Default', connection, provider, 'sink');
+        await projections.register();
+        const readModels = new ReadModels('store', 'Default', connection, provider, 'sink', type => projections.hasForModel(type));
+        const result = await readModels.findInstanceById(PropertyOnly, 'id');
+
+        expect(registerMany.mock.calls[0][0].ReadModels.some((model: { Type: { Identifier: string } }) => model.Type.Identifier === 'PropertyOnly')).toBe(true);
+        expect(register.mock.calls.some(call => call[0].Projections[0].ReadModel === 'PropertyOnly')).toBe(true);
+        expect(getInstanceByKey).toHaveBeenCalledWith(expect.objectContaining({ ReadModelIdentifier: 'PropertyOnly', ReadModelKey: 'id' }));
+        expect(result?.value).toBe('stored');
+    });
+
+    it('should register an explicitly supplied model without glob discovery or construction', async () => {
+        class ExplicitModel {
+            @setFrom(Changed)
+            @field(String)
+            value = '';
+        }
+        const discoverer = new TypeDiscoverer();
+        discoverer.register(DecoratorType.ReadModel, ExplicitModel);
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+
+        await new Projections('store', 'Default', connection, provider, 'sink').register();
+
+        expect(registerMany.mock.calls[0][0].ReadModels.some((model: { Type: { Identifier: string } }) => model.Type.Identifier === 'ExplicitModel')).toBe(true);
+        expect(register.mock.calls.some(call => call[0].Projections[0].ReadModel === 'ExplicitModel')).toBe(true);
+    });
+
+    it('should not register the same model twice when constructed before discovery', async () => {
+        class ConstructedFirst {
+            @setFrom(Changed)
+            @field(String)
+            value = '';
+        }
+        new ConstructedFirst();
+        const discoverer = new TypeDiscoverer(async () => ['models.ts'], async () => ({ ConstructedFirst }));
+        await discoverer.discover('models.ts');
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        expect(provider.readModels.filter(type => type === ConstructedFirst)).toHaveLength(1);
+
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+        await new Projections('store', 'Default', connection, provider, 'sink').register();
+
+        expect(registerMany.mock.calls[0][0].ReadModels.filter((model: { Type: { Identifier: string } }) => model.Type.Identifier === 'ConstructedFirst')).toHaveLength(1);
+        expect(register.mock.calls.filter(call => call[0].Projections[0].ReadModel === 'ConstructedFirst')).toHaveLength(1);
+    });
+
+    it('should not register the same model again after its first construction', async () => {
+        const discoverer = new TypeDiscoverer(async () => ['models.ts'], async () => ({ PropertyOnly }));
+        await discoverer.discover('models.ts');
+        const provider = new DefaultClientArtifactsProvider(discoverer);
+        const registerMany = vi.fn().mockResolvedValue({});
+        const register = vi.fn().mockResolvedValue({});
+        const connection = { readModels: { registerMany }, projections: { register } } as unknown as ChronicleConnection;
+        await new Projections('store', 'Default', connection, provider, 'sink').register();
+        const registered = registerMany.mock.calls.length;
+        const registeredProjections = register.mock.calls.length;
+
+        new PropertyOnly();
+        new PropertyOnly();
+
+        expect(provider.readModels.filter(type => type === PropertyOnly)).toHaveLength(1);
+        expect(registerMany).toHaveBeenCalledTimes(registered);
+        expect(register).toHaveBeenCalledTimes(registeredProjections);
+    });
+});

package/readModels/rootReadModelTypes.ts

@@ -13,8 +13,7 @@ import { isNested } from '../projections/modelBound/nested.js';
 import { getReducerMetadata } from '../reducers/reducer.js';
 import { TypeIntrospector } from '../types/TypeIntrospector.js';
 
-/** Excludes models used as children or nested objects from root projection registration. */
-export function rootReadModelTypes(artifacts: IClientArtifactsProvider): Constructor[] {
+function inspectReadModelTypes(artifacts: IClientArtifactsProvider): { models: Constructor[]; usedAsChildren: Set<Function>; visited: Set<Function> } {
     const models = artifacts.readModels;
     const usedAsChildren = new Set<Function>();
     const visited = new Set<Function>();
@@ -61,5 +60,16 @@ export function rootReadModelTypes(artifacts: IClientArtifactsProvider): Constru
         const model = getReducerMetadata(type)?.readModel;
         if (model) inspect(model);
     }
+    return { models, usedAsChildren, visited };
+}
+
+/** Excludes models used as children or nested objects from root projection registration. */
+export function rootReadModelTypes(artifacts: IClientArtifactsProvider): Constructor[] {
+    const { models, usedAsChildren } = inspectReadModelTypes(artifacts);
     return models.filter(type => !usedAsChildren.has(type));
 }
+
+/** Includes all read-model types reached from registered roots, including children and nested models. */
+export function reachableReadModelTypes(artifacts: IClientArtifactsProvider): Function[] {
+    return [...inspectReadModelTypes(artifacts).visited];
+}

package/types/TypeDiscoverer.ts

@@ -6,17 +6,18 @@ import { DecoratorType } from './DecoratorType.js';
 import { Constructor } from '@cratis/fundamentals';
 import { TypeIntrospector } from './TypeIntrospector.js';
 import { hasPropertyMetadata } from './propertyDecoratorMetadata.js';
+import { hasModelBoundMetadata, modelBoundPropertyKeys } from './modelBoundPropertyMetadata.js';
+import { getStandardMetadata, hasOwnStandardMetadata } from './standardDecoratorMetadata.js';
 
 type GlobFunction = (pattern: string | string[], options?: { ignore: string[] }) => Promise<string[]>;
 type FileImporter = (filePath: string) => Promise<unknown>;
 
-const modelBoundPropertyKeys = [
-    'setFrom', 'setFromContext', 'setValue', 'addFrom', 'subtractFrom',
-    'increment', 'decrement', 'count', 'childrenFrom', 'join', 'fromEvery', 'fromAll'
-].map(name => `chronicle:projection:${name}`);
-
 /** Identifies models whose event mappings live on their properties rather than on @fromEvent. */
 export function hasModelBoundProperties(type: Function): boolean {
+    // A standard field decorator can mark its metadata before any instances exist. Once the
+    // class is evaluated, Symbol.metadata links that object back to the exported constructor.
+    const metadata = hasOwnStandardMetadata(type) ? getStandardMetadata(type) : undefined;
+    if (metadata && hasModelBoundMetadata(metadata)) return true;
     return TypeIntrospector.getTrackedProperties(type).some(property =>
         modelBoundPropertyKeys.some(key => hasPropertyMetadata(key, type.prototype, property)));
 }

package/types/modelBoundProperty.ts

@@ -5,6 +5,7 @@ import type { Constructor } from '@cratis/fundamentals';
 import { TypeDiscoverer } from './TypeDiscoverer.js';
 import { ChronicleClassOrPropertyDecorator, ChroniclePropertyDecorator, decorateClassOrProperty, decorateProperty } from './propertyDecoratorMetadata.js';
 import { getStandardMetadata, hasOwnStandardMetadata } from './standardDecoratorMetadata.js';
+import { trackModelBoundMetadata } from './modelBoundPropertyMetadata.js';
 
 const registered = new WeakSet<Function>();
 
@@ -28,9 +29,10 @@ export function decorateModelBoundProperty(legacy: PropertyDecorator): Chronicle
     return (target: object | undefined, keyOrContext: string | symbol | ClassFieldDecoratorContext) => {
         decorate(target as object, keyOrContext as string);
         if (typeof keyOrContext === 'object') {
-            // Standard field decorators do not receive the class constructor. Their initializer
-            // runs when the first instance is created; direct queries can also register the type.
+            // Standard field decorators do not receive the class constructor. Discovery resolves
+            // the metadata against exported classes; the initializer remains a fallback.
             const metadata = keyOrContext.metadata;
+            if (metadata) trackModelBoundMetadata(metadata, keyOrContext.name as string);
             keyOrContext.addInitializer(function () { if (metadata) registerDeclaringClass(this as object, metadata); });
         } else {
             register((target as { constructor: Function }).constructor);
@@ -45,6 +47,7 @@ export function decorateModelBoundClassOrProperty(legacy: (target: object, prope
         decorate(target as object, keyOrContext as string);
         if (typeof keyOrContext === 'object' && keyOrContext?.kind === 'field') {
             const metadata = keyOrContext.metadata;
+            if (metadata) trackModelBoundMetadata(metadata, keyOrContext.name as string);
             keyOrContext.addInitializer(function () { if (metadata) registerDeclaringClass(this as object, metadata); });
         } else if (typeof keyOrContext === 'string' || typeof keyOrContext === 'symbol') {
             register((target as { constructor: Function }).constructor);

package/types/modelBoundPropertyMetadata.ts

@@ -0,0 +1,67 @@
+// 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 { getStandardMetadata } from './standardDecoratorMetadata.js';
+
+// The standard field decorator has no constructor, but its metadata object is attached to
+// the declaring class after evaluation. Discovery can match that object to a module export.
+const mappedMetadata = new WeakMap<object, Set<string>>();
+const pendingMetadata = new Set<WeakRef<object>>();
+const finalizedMetadata = new FinalizationRegistry<WeakRef<object>>(reference => pendingMetadata.delete(reference));
+
+export const modelBoundPropertyKeys = [
+    'setFrom', 'setFromContext', 'setValue', 'addFrom', 'subtractFrom',
+    'increment', 'decrement', 'count', 'childrenFrom', 'join', 'fromEvery', 'fromAll'
+].map(name => `chronicle:projection:${name}`);
+
+/** Records a standard-decorated class with an event mapping on one of its fields. */
+export function trackModelBoundMetadata(metadata: object, property: string): void {
+    if (!modelBoundPropertyKeys.some(key => Reflect.hasOwnMetadata(key, metadata, property))) return;
+    let properties = mappedMetadata.get(metadata);
+    if (!properties) {
+        properties = new Set<string>();
+        mappedMetadata.set(metadata, properties);
+        const reference = new WeakRef(metadata);
+        pendingMetadata.add(reference);
+        finalizedMetadata.register(metadata, reference, reference);
+    }
+    properties.add(property);
+}
+
+/** Whether a class's standard decorator metadata contains a mapped property. */
+export function hasModelBoundMetadata(metadata: object): boolean {
+    return mappedMetadata.has(metadata);
+}
+
+/** Returns unresolved mappings grouped by class metadata, dropping resolved and collected entries. */
+export function takeUnregisteredModelBoundMappings(registeredTypes: Function[]): string[] {
+    const registeredMetadata = new Set<object>();
+    for (const type of registeredTypes) {
+        for (let metadata: object | null | undefined = getStandardMetadata(type); metadata; metadata = Object.getPrototypeOf(metadata) as object | null) {
+            registeredMetadata.add(metadata);
+        }
+    }
+    const unmapped: string[] = [];
+    for (const reference of pendingMetadata) {
+        const metadata = reference.deref();
+        pendingMetadata.delete(reference);
+        finalizedMetadata.unregister(reference);
+        if (!metadata || registeredMetadata.has(metadata)) continue;
+        const mappingsForClass = new Set<string>();
+        for (const property of mappedMetadata.get(metadata) ?? []) {
+            for (const key of modelBoundPropertyKeys) {
+                const value = Reflect.getOwnMetadata(key, metadata, property) as unknown;
+                if (value === undefined) continue;
+                const mappings: unknown[] = Array.isArray(value) ? value : [value];
+                for (const mapping of mappings) {
+                    const eventType = mapping && typeof mapping === 'object' && 'eventType' in mapping ? mapping.eventType : undefined;
+                    const eventName = typeof eventType === 'function' ? eventType.name : 'all events';
+                    mappingsForClass.add(`${property} <- ${eventName}`);
+                }
+            }
+        }
+        if (mappingsForClass.size > 0) unmapped.push(`{${[...mappingsForClass].join(', ')}}`);
+    }
+    return unmapped;
+}