@cratis/chronicle 6.3.2 → 6.5.0

package/readModels/MaterializedReadModels.spec.ts

@@ -77,22 +77,33 @@ describe('MaterializedReadModels', () => {
         pii()(Anonymous.prototype, 'ssn');
         readModel('AnonymousMaterialized')(Anonymous);
 
-        it('should not call release, unchanged from today', async () => {
+        it('should fail closed without a subject', async () => {
             const json = JSON.stringify({ ssn: '000-00-0000' });
             const { readModels, release } = createMaterializedReadModels([json]);
 
-            await readModels.getInstances(Anonymous);
-
+            await expect(readModels.getInstances(Anonymous)).rejects.toThrow(/subject/);
             expect(release).not.toHaveBeenCalled();
         });
 
-        it('should return the instance unreleased', async () => {
+        it('should not return the unreleased instance', async () => {
             const json = JSON.stringify({ ssn: '000-00-0000' });
             const { readModels } = createMaterializedReadModels([json]);
 
-            const [instance] = await readModels.getInstances(Anonymous);
+            await expect(readModels.getInstances(Anonymous)).rejects.toThrow(/subject/);
+        });
+    });
 
-            expect(instance.ssn).toBe('000-00-0000');
+    describe('when the compliance service rejects release', () => {
+        class PrivateCustomer { id = ''; ssn = ''; }
+        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(
+                ['{"id":"a","ssn":"ciphertext"}'], { HasError: true, Error: 'denied' });
+            await expect(readModels.getInstances(PrivateCustomer)).rejects.toThrow('Failed to release PII: denied');
         });
     });
 });

package/readModels/MaterializedReadModels.ts

@@ -100,7 +100,7 @@ export class MaterializedReadModels implements IMaterializedReadModels {
     private async releaseInstance<TReadModel>(readModelType: Constructor<TReadModel>, instance: TReadModel, schema: string): Promise<TReadModel> {
         const subject = ReadModelSubjectResolver.resolveFrom(readModelType, instance);
         if (!subject) {
-            return instance;
+            throw new Error('Read model instance must have a property decorated with @subject() or an "id" property to serve as the subject for PII release');
         }
 
         const payload = JsonSerializer.serialize(instance);
@@ -113,7 +113,7 @@ export class MaterializedReadModels implements IMaterializedReadModels {
         });
 
         if (response.HasError) {
-            return instance;
+            throw new Error(`Failed to release PII: ${response.Error}`);
         }
 
         return this.deserialize(readModelType, response.Payload);

package/readModels/ReadModels.spec.ts

@@ -2,11 +2,13 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import 'reflect-metadata';
-import type { Constructor } from '@cratis/fundamentals';
+import { field, type Constructor } from '@cratis/fundamentals';
 import { describe, expect, it, vi } from 'vitest';
 import type { IClientArtifactsProvider } from '../artifacts/index.js';
 import type { ChronicleConnection } from '../connection/index.js';
 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';
@@ -20,8 +22,10 @@ class SomeEvent {
 
 function createReadModels(readModelType: Constructor, releaseResponse: Record<string, unknown> = { HasError: false, Payload: '{}' }) {
     const release = vi.fn().mockResolvedValue(releaseResponse);
+    const getInstanceByKey = vi.fn().mockResolvedValue({ ReadModel: '' });
     const connection = {
-        compliance: { release }
+        compliance: { release },
+        readModels: { getInstanceByKey }
     } as unknown as ChronicleConnection;
 
     const clientArtifacts = {
@@ -38,10 +42,99 @@ function createReadModels(readModelType: Constructor, releaseResponse: Record<st
     } as IClientArtifactsProvider;
 
     const readModels = new ReadModels('test-store', 'test-namespace', connection, clientArtifacts, 'default-sink');
-    return { readModels, release };
+    return { readModels, release, getInstanceByKey };
 }
 
 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);
+            const instance = await readModels.getInstanceById(MissingModel, 'missing');
+            expect(instance).toBeInstanceOf(MissingModel);
+            expect(Object.keys(instance)).toEqual([]);
+            expect(release).not.toHaveBeenCalled();
+        });
+
+        it('should return null from findInstanceById without releasing PII', async () => {
+            const { readModels, release, getInstanceByKey } = createReadModels(MissingModel);
+            const instance = await readModels.findInstanceById(MissingModel, 'missing', 'session-1');
+            expect(instance).toBeNull();
+            expect(getInstanceByKey).toHaveBeenCalledWith(expect.objectContaining({ ReadModelKey: 'missing', SessionId: 'session-1' }));
+            expect(release).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when a read model instance exists for a key', () => {
+        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);
+            getInstanceByKey.mockResolvedValue({ ReadModel: '{"id":"found"}' });
+            const instance = await readModels.findInstanceById(ExistingModel, 'found');
+            expect(instance).toBeInstanceOf(ExistingModel);
+            expect(instance?.id).toBe('found');
+            const legacyInstance = await readModels.getInstanceById(ExistingModel, 'found');
+            expect(legacyInstance).toBeInstanceOf(ExistingModel);
+            expect(legacyInstance.id).toBe('found');
+        });
+    });
+
+    describe('when reading a compliance-bearing reducer', () => {
+        class PrivateModel { id = ''; ssn = ''; }
+        field(String)(PrivateModel.prototype, 'id');
+        field(String)(PrivateModel.prototype, 'ssn');
+        pii()(PrivateModel.prototype, 'ssn');
+        readModel('PrivateInstanceModel')(PrivateModel);
+        class PrivateReducer {}
+        reducer('PrivateInstanceReducer', undefined, PrivateModel)(PrivateReducer);
+
+        it('should reject both read methods when compliance release fails', async () => {
+            const release = vi.fn().mockResolvedValue({ HasError: true, Error: 'denied' });
+            const getInstanceByKey = vi.fn().mockResolvedValue({ ReadModel: '{"id":"a","ssn":"ciphertext"}' });
+            const connection = {
+                readModels: { getInstanceByKey },
+                compliance: { release }
+            } as unknown as ChronicleConnection;
+            const provider = { reducers: [PrivateReducer], projections: [], readModels: [] } as unknown as IClientArtifactsProvider;
+            const readModels = new ReadModels('store', 'tenant', connection, provider, 'sink');
+
+            await expect(readModels.getInstanceById(PrivateModel, 'a')).rejects.toThrow('Failed to release PII: denied');
+            await expect(readModels.findInstanceById(PrivateModel, 'a')).rejects.toThrow('Failed to release PII: denied');
+            expect(release).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('when watching a compliance-bearing reducer', () => {
+        class PrivateModel { id = ''; ssn = ''; }
+        field(String)(PrivateModel.prototype, 'id');
+        field(String)(PrivateModel.prototype, 'ssn');
+        pii()(PrivateModel.prototype, 'ssn');
+        readModel('PrivateReducerModel')(PrivateModel);
+        class PrivateReducer {}
+        reducer('PrivateReducer', undefined, PrivateModel)(PrivateReducer);
+
+        it('should reject rather than expose an unreleased changeset', async () => {
+            const release = vi.fn().mockResolvedValue({ HasError: true, Error: 'denied' });
+            const connection = {
+                readModels: { watch: async function* () {
+                    yield { Namespace: 'tenant', ModelKey: 'a', ReadModel: '{"id":"a","ssn":"ciphertext"}', Removed: false };
+                } },
+                compliance: { release }
+            } as unknown as ChronicleConnection;
+            const provider = { reducers: [PrivateReducer], projections: [], readModels: [] } as unknown as IClientArtifactsProvider;
+            const readModels = new ReadModels('store', 'tenant', connection, provider, 'sink');
+            const iterator = readModels.watch(PrivateModel)[Symbol.asyncIterator]();
+            await expect(iterator.next()).rejects.toThrow('Failed to release PII: denied');
+        });
+    });
+
     describe('when releasing a read model with a property decorated with @subject()', () => {
         class Employee {
             id = '';

package/readModels/ReadModels.ts

@@ -72,7 +72,10 @@ export class ReadModels implements IReadModels {
         });
     }
 
-    /** @inheritdoc */
+    /**
+     * @inheritdoc
+     * @deprecated Use {@link findInstanceById} to distinguish an absent instance from a stored one.
+     */
     async getInstanceById<TReadModel>(readModelType: Constructor<TReadModel>, key: string, sessionId?: string): Promise<TReadModel> {
         const readModel = this.resolveReadModel(readModelType);
         const response = await this._connection.readModels.getInstanceByKey({
@@ -93,6 +96,30 @@ export class ReadModels implements IReadModels {
         return instance;
     }
 
+    /** @inheritdoc */
+    async findInstanceById<TReadModel>(readModelType: Constructor<TReadModel>, key: string, sessionId?: string): Promise<TReadModel | null> {
+        const readModel = this.resolveReadModel(readModelType);
+        const response = await this._connection.readModels.getInstanceByKey({
+            EventStore: this._eventStore,
+            Namespace: this._namespace,
+            ReadModelIdentifier: readModel.identifier,
+            EventSequenceId: readModel.eventSequenceId,
+            ReadModelKey: key,
+            SessionId: sessionId ?? ''
+        });
+
+        if (!response.ReadModel) {
+            return null;
+        }
+        const instance = this.deserializeReadModel(readModelType, response.ReadModel);
+
+        if (readModel.observerType === ContractReadModelObserverType.Reducer && this.schemaHasComplianceMetadata(readModel.schema)) {
+            return this.release(readModelType, instance);
+        }
+
+        return instance;
+    }
+
     /** @inheritdoc */
     async getInstances<TReadModel>(readModelType: Constructor<TReadModel>, eventCount: bigint = unlimitedEventCount): Promise<TReadModel[]> {
         const readModel = this.resolveReadModel(readModelType);
@@ -149,10 +176,13 @@ export class ReadModels implements IReadModels {
             ReadModelIdentifier: readModel.identifier,
             EventSequenceId: readModel.eventSequenceId
         })) {
+            const instance = this.deserializeReadModel(readModelType, changeset.ReadModel);
+            const requiresRelease = !changeset.Removed && readModel.observerType === ContractReadModelObserverType.Reducer &&
+                this.schemaHasComplianceMetadata(readModel.schema);
             yield {
                 namespace: changeset.Namespace,
                 key: changeset.ModelKey,
-                readModel: this.deserializeReadModel(readModelType, changeset.ReadModel),
+                readModel: requiresRelease ? await this.release(readModelType, instance) : instance,
                 removed: changeset.Removed
             };
         }

package/readModels/readModel.ts

@@ -6,6 +6,8 @@ import { Constructor } from '@cratis/fundamentals';
 import { ReadModelId } from './ReadModelId.js';
 import { DecoratorType, TypeDiscoverer, TypeIntrospector } from '../types/index.js';
 import { JsonSchema, JsonSchemaGenerator } from '../schemas/index.js';
+import { ChronicleClassDecorator } from '../types/standardDecoratorMetadata.js';
+import { createDeferredSchema } from '../schemas/createDeferredSchema.js';
 
 /** Metadata key used to store read model information on a class. */
 const READ_MODEL_METADATA_KEY = 'chronicle:readModel';
@@ -29,14 +31,23 @@ export interface ReadModelMetadata {
  * @param id - The unique identifier for the read model. Defaults to the class name if omitted.
  * @returns A class decorator.
  */
-export function readModel(id: string = ''): ClassDecorator {
-    return (target: object) => {
-        const constructor = target as Function;
+export function readModel(id: string = ''): ChronicleClassDecorator {
+    return (target: object, context?: ClassDecoratorContext) => {
+        let constructor = target as Function;
         const readModelId = new ReadModelId(id || constructor.name);
-        const members = TypeIntrospector.getMembers(constructor);
-        const metadata: ReadModelMetadata = {
+        const members = context?.kind === 'class' ? undefined : TypeIntrospector.getMembers(constructor);
+        const resolve = createDeferredSchema(() => constructor);
+        const metadata: ReadModelMetadata = context?.kind === 'class' ? {
             id: readModelId,
-            members,
+            get members() {
+                return resolve().members;
+            },
+            get schema() {
+                return resolve().schema;
+            }
+        } : {
+            id: readModelId,
+            members: members!,
             schema: JsonSchemaGenerator.generate(constructor, members)
         };
         Reflect.defineMetadata(READ_MODEL_METADATA_KEY, metadata, target);
@@ -45,6 +56,13 @@ export function readModel(id: string = ''): ClassDecorator {
             constructor as Constructor,
             readModelId.value
         );
+        context?.addInitializer(function () {
+            if (this !== constructor) {
+                constructor = this;
+                Reflect.defineMetadata(READ_MODEL_METADATA_KEY, metadata, constructor);
+                TypeDiscoverer.default.register(DecoratorType.ReadModel, constructor as Constructor, readModelId.value);
+            }
+        });
     };
 }
 

package/readModels/standardFallbacks.standard.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 { field } from '@cratis/fundamentals';
+import { describe, expect, it, vi } from 'vitest';
+import { IClientArtifactsProvider } from '../artifacts/IClientArtifactsProvider.js';
+import { ChronicleConnection } from '../connection/ChronicleConnection.js';
+import { reducer } from '../reducers/reducer.js';
+import { MaterializedReadModels } from './MaterializedReadModels.js';
+import { ReadModels } from './ReadModels.js';
+
+class UndecoratedModel {
+    @field(Array) items!: string[];
+}
+
+@reducer('undecorated-model', undefined, UndecoratedModel)
+class ModelReducer {}
+
+const artifacts = {
+    eventTypes: [], readModels: [], reactors: [], reducers: [ModelReducer], seeders: [],
+    constraints: [], projections: [], webhooks: [], eventTypeMigrations: [], globalForHandlers: []
+} as IClientArtifactsProvider;
+
+describe('standard read models without @readModel', () => {
+    it('rejects an untyped array before registering a reducer read model', async () => {
+        const registerMany = vi.fn();
+        const connection = { readModels: { registerMany } } as unknown as ChronicleConnection;
+        const readModels = new ReadModels('test', 'Default', connection, artifacts, 'sink');
+        await expect(readModels.register(UndecoratedModel)).rejects.toThrow(/Cannot determine the element type of UndecoratedModel.items/);
+        expect(registerMany).not.toHaveBeenCalled();
+    });
+
+    it('rejects an untyped array instead of releasing an incomplete materialized schema', async () => {
+        const getInstances = vi.fn().mockResolvedValue({ Instances: [] });
+        const connection = { materializedReadModels: { getInstances } } as unknown as ChronicleConnection;
+        const materialized = new MaterializedReadModels('test', 'Default', connection);
+        await expect(materialized.getInstances(UndecoratedModel)).rejects.toThrow(/Cannot determine the element type of UndecoratedModel.items/);
+    });
+});

package/schemas/JsonSchemaGenerator.confidentiality.spec.ts

@@ -77,6 +77,8 @@ describe('JsonSchemaGenerator - security metadata', () => {
 
     describe('when a property is typed as a ConceptAs<T> marked @encrypted()', () => {
         class ApiKey extends ConceptAs<string> {
+            static readonly valueType = String;
+
             constructor(value: string) {
                 super(value);
             }

package/schemas/JsonSchemaGenerator.spec.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import 'reflect-metadata';
-import { ConceptAs, field } from '@cratis/fundamentals';
+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';
@@ -22,6 +22,31 @@ function schemaFor(target: Function): JsonSchema {
 }
 
 describe('JsonSchemaGenerator', () => {
+    it('retains the legacy string-concept fallback without emitted type metadata', () => {
+        class LegacyCode extends ConceptAs<string> {}
+        class LegacyModel {
+            code = new LegacyCode('A');
+        }
+        readModel()(LegacyModel);
+        expect(schemaFor(LegacyModel).properties?.code.type).toBe('string');
+    });
+
+    it('preserves Guid and Date-backed legacy concepts with design:type', () => {
+        class LegacyId extends ConceptAs<Guid> {}
+        class LegacyTime extends ConceptAs<Date> {}
+        Reflect.defineMetadata('design:type', Guid, LegacyId.prototype, 'value');
+        Reflect.defineMetadata('design:type', Date, LegacyTime.prototype, 'value');
+        class LegacyEvent {
+            id = new LegacyId(Guid.empty);
+            occurred = new LegacyTime(new Date());
+        }
+        eventType()(LegacyEvent);
+        expect(getEventTypeJsonSchemaFor(LegacyEvent).properties).toMatchObject({
+            id: { type: 'string', format: 'guid' },
+            occurred: { type: 'string', format: 'date-time' }
+        });
+    });
+
     describe('when a class is marked @pii() at the class level', () => {
         class PersonProfile {
             name = '';
@@ -59,6 +84,8 @@ describe('JsonSchemaGenerator', () => {
 
     describe('when a property is typed as a ConceptAs<T> marked @pii()', () => {
         class EmailAddress extends ConceptAs<string> {
+            static readonly valueType = String;
+
             constructor(value: string) {
                 super(value);
             }

package/schemas/JsonSchemaGenerator.ts

@@ -2,9 +2,10 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import 'reflect-metadata';
-import { ConceptAs, Constructor, Fields, Guid } from '@cratis/fundamentals';
+import { conceptAsTypeKey, Constructor, Fields, Guid, typeKeyOf } from '@cratis/fundamentals';
 import { ComplianceSchemaMetadata, JsonSchema, SecuritySchemaMetadata } from './JsonSchema.js';
 import { TypeIntrospector } from '../types/index.js';
+import { hasOwnStandardMetadata } from '../types/standardDecoratorMetadata.js';
 import { ComplianceMetadata } from '../compliance/ComplianceMetadata.js';
 import { ComplianceMetadataResolver } from '../compliance/ComplianceMetadataResolver.js';
 import { SecurityMetadata } from '../confidentiality/SecurityMetadata.js';
@@ -14,6 +15,11 @@ import { PIIAndEncryptedCombinedNotSupported } from '../confidentiality/PIIAndEn
 /**
  * Generates JSON schemas for class constructors using reflection metadata.
  */
+export interface JsonSchemaGenerationOptions {
+    /** Reject members and array elements without runtime types. Defaults to true for standard-decorated classes. */
+    readonly requireResolvedTypes?: boolean;
+}
+
 export class JsonSchemaGenerator {
     private static readonly _knownTypeFormats = new Map<Function, { type: JsonSchema['type']; format: string }>([
         [Guid, { type: 'string', format: 'guid' }],
@@ -44,15 +50,20 @@ export class JsonSchemaGenerator {
      * Generates a JSON schema for a class constructor.
      * @param target - The class constructor to generate schema for.
      * @param members - Optional pre-introspected members for reuse.
+     * @param options - Schema resolution options. A boolean remains supported for existing callers.
      * @returns The generated JSON schema.
      */
-    static generate(target: Function, members?: ReadonlyMap<string, Function | undefined>): JsonSchema {
+    static generate(target: Function, members?: ReadonlyMap<string, Function | undefined>, options?: JsonSchemaGenerationOptions | boolean): JsonSchema {
+        const requireResolvedTypes = typeof options === 'boolean' ? options : options?.requireResolvedTypes ?? hasOwnStandardMetadata(target);
         const membersToUse = members ?? TypeIntrospector.getMembers(target);
         const schemaProperties: Record<string, JsonSchema> = {};
         const prototype = target.prototype;
 
         for (const [memberName, memberType] of membersToUse.entries()) {
-            const propertySchema = this.mapRuntimeTypeToSchema(memberType, target, memberName);
+            if (!memberType && requireResolvedTypes) {
+                throw new TypeError(`Cannot determine the type of ${target.name}.${memberName}; declare @field with its runtime type.`);
+            }
+            const propertySchema = this.mapRuntimeTypeToSchema(memberType, target, memberName, requireResolvedTypes);
             // Only include properties whose type was resolved. An empty schema ({}) means
             // the runtime type was unavailable (e.g. esbuild/tsx omits design:paramtypes).
             if (Object.keys(propertySchema).length > 0) {
@@ -71,9 +82,8 @@ export class JsonSchemaGenerator {
             }
         }
 
-        // When no property types could be resolved, return a minimal schema with empty
-        // properties so the server uses its fallback path that preserves all event
-        // content as-is via ConvertUnknownSchemaTypeToClrType.
+        // Legacy decorators retain the minimal schema fallback for members with no
+        // runtime type metadata. Standard decorators reject unresolved types above.
         if (Object.keys(schemaProperties).length === 0) {
             return this.createEmptySchema(target.name);
         }
@@ -85,7 +95,7 @@ export class JsonSchemaGenerator {
         };
     }
 
-    private static mapRuntimeTypeToSchema(runtimeType: Function | undefined, declaringType?: Function, propertyName?: string): JsonSchema {
+    private static mapRuntimeTypeToSchema(runtimeType: Function | undefined, declaringType?: Function, propertyName?: string, requireResolvedTypes = false): JsonSchema {
         const knownTypeFormat = this.getKnownTypeFormat(runtimeType);
         if (knownTypeFormat) {
             return knownTypeFormat;
@@ -104,25 +114,29 @@ export class JsonSchemaGenerator {
         }
 
         if (runtimeType === Array) {
-            return this.mapArrayTypeToSchema(declaringType, propertyName);
+            return this.mapArrayTypeToSchema(declaringType, propertyName, requireResolvedTypes);
         }
 
         if (!runtimeType) {
             return {};
         }
 
-        // A ConceptAs<T> serializes as its underlying primitive value, so the schema must
-        // describe that primitive rather than the wrapper object. The generic argument T is
-        // not available at runtime, so resolve it from the 'value' property's design:type
-        // when present (ts-node/webpack with emitDecoratorMetadata) and fall back to string
-        // when it is not (esbuild/tsx) — string-backed concepts are by far the common case.
+        // TypeScript erases ConceptAs<T>'s primitive type. Prefer an explicit field or
+        // static hint; legacy emitDecoratorMetadata is the last available source.
         if (this.isConceptAs(runtimeType)) {
-            const valueType = Reflect.getMetadata('design:type', runtimeType.prototype, 'value') as Function | undefined;
-            return this.mapRuntimeTypeToSchema(valueType ?? String);
+            const concept = runtimeType as Function & { valueType?: Function };
+            const fieldType = Fields.getFieldsForType(concept as Constructor).find(field => field.name === 'value')?.type;
+            const valueType = fieldType ?? concept.valueType ?? Reflect.getMetadata('design:type', runtimeType.prototype, 'value') as Function | undefined;
+            if (!valueType && !requireResolvedTypes) return { type: 'string' }; // Legacy schema compatibility.
+            const valueSchema = this.mapRuntimeTypeToSchema(valueType, undefined, undefined, requireResolvedTypes);
+            if (!valueType || !valueSchema.type || (requireResolvedTypes && valueSchema.type === 'object')) {
+                throw new TypeError(`Cannot determine the value type of concept ${runtimeType.name}; declare static readonly valueType = String, Number, Boolean, Guid, or Date.`);
+            }
+            return valueSchema;
         }
 
         if (runtimeType !== Object) {
-            return this.generate(runtimeType);
+            return this.generate(runtimeType, undefined, requireResolvedTypes);
         }
 
         return { type: 'object' };
@@ -135,7 +149,7 @@ export class JsonSchemaGenerator {
      * @param propertyName - The array property name.
      * @returns The array schema, with the element's own compliance metadata carried onto `items` when the element is a PII concept.
      */
-    private static mapArrayTypeToSchema(declaringType: Function | undefined, propertyName: string | undefined): JsonSchema {
+    private static mapArrayTypeToSchema(declaringType: Function | undefined, propertyName: string | undefined, requireResolvedTypes: boolean): JsonSchema {
         const elementType = this.getArrayElementType(declaringType, propertyName);
 
         // An array whose element is a ConceptAs<T> loses its classification the moment it is put in
@@ -143,7 +157,7 @@ export class JsonSchemaGenerator {
         // item schema - a value that would be encrypted as a scalar would otherwise be persisted in
         // the clear as a list element. Mirrors the C# generator's explicit enumerable-of-concept branch.
         if (elementType && this.isConceptAs(elementType)) {
-            const itemSchema = this.mapRuntimeTypeToSchema(elementType);
+            const itemSchema = this.mapRuntimeTypeToSchema(elementType, undefined, undefined, requireResolvedTypes);
             const complianceMetadata = ComplianceMetadataResolver.getMetadataForType(elementType);
             const securityMetadata = SecurityMetadataResolver.getMetadataForType(elementType);
             this.throwIfBothCompliantAndSecure(elementType.name, complianceMetadata, securityMetadata);
@@ -152,7 +166,15 @@ export class JsonSchemaGenerator {
             return { type: 'array', items: itemSchema };
         }
 
-        return { type: 'array', items: { type: 'object' } };
+        if (!elementType) {
+            if (requireResolvedTypes) {
+                throw new TypeError(`Cannot determine the element type of ${declaringType?.name}.${propertyName}; declare @field(Array, { genericArguments: [ItemType] }).`);
+            }
+            return { type: 'array', items: { type: 'object' } };
+        }
+
+        if (!requireResolvedTypes) return { type: 'array', items: { type: 'object' } }; // Legacy schema compatibility.
+        return { type: 'array', items: this.mapRuntimeTypeToSchema(elementType, undefined, undefined, true) };
     }
 
     /**
@@ -189,16 +211,7 @@ export class JsonSchemaGenerator {
     }
 
     private static isConceptAs(runtimeType: Function): boolean {
-        let current: Function | null = runtimeType;
-        while (current && current !== Function.prototype) {
-            if (current === ConceptAs) {
-                return true;
-            }
-
-            current = Object.getPrototypeOf(current) as Function | null;
-        }
-
-        return false;
+        return typeKeyOf(runtimeType as Constructor) === conceptAsTypeKey;
     }
 
     private static getKnownTypeFormat(runtimeType: Function | undefined): JsonSchema | undefined {
@@ -206,7 +219,9 @@ export class JsonSchemaGenerator {
             return undefined;
         }
 
-        const known = this._knownTypeFormats.get(runtimeType);
+        const known = typeKeyOf(runtimeType as Constructor) === 'Guid'
+            ? this._knownTypeFormats.get(Guid)
+            : this._knownTypeFormats.get(runtimeType);
         if (!known) {
             return undefined;
         }

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' }
+};