@cratis/chronicle 6.3.1 → 6.4.0

package/readModels/MaterializedReadModels.spec.ts

@@ -4,11 +4,11 @@
 import 'reflect-metadata';
 import { field } from '@cratis/fundamentals';
 import { describe, expect, it, vi } from 'vitest';
-import type { ChronicleConnection } from '../connection';
-import { pii } from '../compliance/pii';
-import { subject } from '../compliance/subject';
-import { readModel } from './readModel';
-import { MaterializedReadModels } from './MaterializedReadModels';
+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
 // fixtures don't depend on the test runner's decorator-syntax support.

package/readModels/MaterializedReadModels.ts

@@ -3,11 +3,11 @@
 
 import type { Constructor } from '@cratis/fundamentals';
 import { JsonSerializer } from '@cratis/fundamentals';
-import { ChronicleConnection } from '../connection';
-import { JsonSchemaGenerator } from '../schemas';
-import { getReadModelMetadata } from './readModel';
-import { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
-import type { IMaterializedReadModels } from './IMaterializedReadModels';
+import { ChronicleConnection } from '../connection/index.js';
+import { JsonSchemaGenerator } from '../schemas/index.js';
+import { getReadModelMetadata } from './readModel.js';
+import { ReadModelSubjectResolver } from './ReadModelSubjectResolver.js';
+import type { IMaterializedReadModels } from './IMaterializedReadModels.js';
 
 const defaultTake = 50;
 

package/readModels/ReadModelSubjectResolver.spec.ts

@@ -3,8 +3,8 @@
 
 import 'reflect-metadata';
 import { describe, expect, it } from 'vitest';
-import { subject } from '../compliance/subject';
-import { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
+import { subject } from '../compliance/subject.js';
+import { ReadModelSubjectResolver } from './ReadModelSubjectResolver.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.

package/readModels/ReadModelSubjectResolver.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import type { Constructor } from '@cratis/fundamentals';
-import { getSubjectPropertyName } from '../compliance/subject';
+import { getSubjectPropertyName } from '../compliance/subject.js';
 
 /**
  * Resolves the compliance subject - the natural person a read model's Personal Identifiable

package/readModels/ReadModels.spec.ts

@@ -4,12 +4,12 @@
 import 'reflect-metadata';
 import type { Constructor } from '@cratis/fundamentals';
 import { describe, expect, it, vi } from 'vitest';
-import type { IClientArtifactsProvider } from '../artifacts';
-import type { ChronicleConnection } from '../connection';
-import { subject } from '../compliance/subject';
-import { fromEvent } from '../projections/modelBound/fromEvent';
-import { readModel } from './readModel';
-import { ReadModels } from './ReadModels';
+import type { IClientArtifactsProvider } from '../artifacts/index.js';
+import type { ChronicleConnection } from '../connection/index.js';
+import { subject } from '../compliance/subject.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
 // fixtures don't depend on the test runner's decorator-syntax support.

package/readModels/ReadModels.ts

@@ -10,24 +10,24 @@ import {
 } from '@cratis/chronicle.contracts';
 import type { Constructor } from '@cratis/fundamentals';
 import { Guid, JsonSerializer } from '@cratis/fundamentals';
-import { IClientArtifactsProvider } from '../artifacts';
-import { toContractsGuid } from '../connection/Guid';
-import { ChronicleConnection } from '../connection';
-import { ensureQuerySuccess } from '../connection/callResults';
-import { EventSequenceId } from '../eventSequences/EventSequenceId';
-import { getProjectionMetadata } from '../projections/declarative/projection';
-import { hasFromEventMetadata } from '../projections/modelBound/fromEvent';
-import { isPassive } from '../projections/modelBound/passive';
-import { getReducerMetadata } from '../reducers/reducer';
-import { JsonSchemaGenerator } from '../schemas';
-import { WellKnownSinks } from '../sinks';
-import { getReadModelMetadata } from './readModel';
-import type { IMaterializedReadModels } from './IMaterializedReadModels';
-import { MaterializedReadModels } from './MaterializedReadModels';
-import { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
-import type { IReadModels } from './IReadModels';
-import type { ReadModelChangeset } from './ReadModelChangeset';
-import type { ReadModelSnapshot } from './ReadModelSnapshot';
+import { IClientArtifactsProvider } from '../artifacts/index.js';
+import { toContractsGuid } from '../connection/Guid.js';
+import { ChronicleConnection } from '../connection/index.js';
+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 { 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 type { IMaterializedReadModels } from './IMaterializedReadModels.js';
+import { MaterializedReadModels } from './MaterializedReadModels.js';
+import { ReadModelSubjectResolver } from './ReadModelSubjectResolver.js';
+import type { IReadModels } from './IReadModels.js';
+import type { ReadModelChangeset } from './ReadModelChangeset.js';
+import type { ReadModelSnapshot } from './ReadModelSnapshot.js';
 
 const unlimitedEventCount = BigInt('18446744073709551615');
 

package/readModels/index.ts

@@ -1,13 +1,13 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export { ReadModelId } from './ReadModelId';
-export type { IReadModels } from './IReadModels';
-export type { IMaterializedReadModels } from './IMaterializedReadModels';
-export { ReadModels } from './ReadModels';
-export { MaterializedReadModels } from './MaterializedReadModels';
-export { ReadModelSubjectResolver } from './ReadModelSubjectResolver';
-export type { ReadModelChangeset } from './ReadModelChangeset';
-export type { ReadModelSnapshot } from './ReadModelSnapshot';
-export { readModel, getReadModelMetadata, isReadModel } from './readModel';
-export type { ReadModelMetadata } from './readModel';
+export { ReadModelId } from './ReadModelId.js';
+export type { IReadModels } from './IReadModels.js';
+export type { IMaterializedReadModels } from './IMaterializedReadModels.js';
+export { ReadModels } from './ReadModels.js';
+export { MaterializedReadModels } from './MaterializedReadModels.js';
+export { ReadModelSubjectResolver } from './ReadModelSubjectResolver.js';
+export type { ReadModelChangeset } from './ReadModelChangeset.js';
+export type { ReadModelSnapshot } from './ReadModelSnapshot.js';
+export { readModel, getReadModelMetadata, isReadModel } from './readModel.js';
+export type { ReadModelMetadata } from './readModel.js';

package/readModels/readModel.ts

@@ -3,9 +3,11 @@
 
 import 'reflect-metadata';
 import { Constructor } from '@cratis/fundamentals';
-import { ReadModelId } from './ReadModelId';
-import { DecoratorType, TypeDiscoverer, TypeIntrospector } from '../types';
-import { JsonSchema, JsonSchemaGenerator } from '../schemas';
+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/reducers/Reducers.spec.ts

@@ -3,15 +3,15 @@
 
 import { describe, expect, it, vi } from 'vitest';
 import type { Constructor } from '@cratis/fundamentals';
-import type { IClientArtifactsProvider } from '../artifacts';
-import type { ChronicleConnection } from '../connection';
-import { ConnectionLifecycle } from '../connection/ConnectionLifecycle';
-import { eventType, getEventTypeFor } from '../events/eventTypeDecorator';
-import type { EventContext } from '../events/EventContext';
-import { filterEventsByTag } from '../events/filterEventsByTagDecorator';
-import { tag } from '../events/tagDecorator';
-import { reducer } from './reducer';
-import { Reducers } from './Reducers';
+import type { IClientArtifactsProvider } from '../artifacts/index.js';
+import type { ChronicleConnection } from '../connection/index.js';
+import { ConnectionLifecycle } from '../connection/ConnectionLifecycle.js';
+import { eventType, getEventTypeFor } from '../events/eventTypeDecorator.js';
+import type { EventContext } from '../events/EventContext.js';
+import { filterEventsByTag } from '../events/filterEventsByTagDecorator.js';
+import { tag } from '../events/tagDecorator.js';
+import { reducer } from './reducer.js';
+import { Reducers } from './Reducers.js';
 
 const flush = () => new Promise(resolve => setTimeout(resolve, 0));
 

package/reducers/Reducers.ts

@@ -5,20 +5,20 @@ import 'reflect-metadata';
 import { diag } from '@opentelemetry/api';
 import { Constructor, Guid } from '@cratis/fundamentals';
 import { ObservationState, ReadModelObserverType, ReducerMessage } from '@cratis/chronicle.contracts';
-import { IClientArtifactsProvider } from '../artifacts';
-import { ChronicleConnection } from '../connection';
-import { toContractsGuid } from '../connection/Guid';
-import { ConnectionLifecycle } from '../connection/ConnectionLifecycle';
-import { getEventTypeMetadata } from '../events/eventTypeDecorator';
-import { toClientEventContext } from '../events/toClientEventContext';
-import { getTagsFor } from '../events/tagDecorator';
-import { getFilterTagsFor } from '../events/filterEventsByTagDecorator';
-import { EventSequenceId } from '../eventSequences/EventSequenceId';
-import { notifyReplayLifecycle } from '../observation/notifyReplayLifecycle';
-import { IReducers } from './IReducers';
-import { getReducerMetadata } from './reducer';
-import { getReadModelMetadata } from '../readModels';
-import { JsonSchemaGenerator } from '../schemas';
+import { IClientArtifactsProvider } from '../artifacts/index.js';
+import { ChronicleConnection } from '../connection/index.js';
+import { toContractsGuid } from '../connection/Guid.js';
+import { ConnectionLifecycle } from '../connection/ConnectionLifecycle.js';
+import { getEventTypeMetadata } from '../events/eventTypeDecorator.js';
+import { toClientEventContext } from '../events/toClientEventContext.js';
+import { getTagsFor } from '../events/tagDecorator.js';
+import { getFilterTagsFor } from '../events/filterEventsByTagDecorator.js';
+import { EventSequenceId } from '../eventSequences/EventSequenceId.js';
+import { notifyReplayLifecycle } from '../observation/notifyReplayLifecycle.js';
+import { IReducers } from './IReducers.js';
+import { getReducerMetadata } from './reducer.js';
+import { getReadModelMetadata } from '../readModels/index.js';
+import { JsonSchemaGenerator } from '../schemas/index.js';
 
 /** Expression used to partition reducer observations by event source ID. */
 const EVENT_SOURCE_ID_KEY = '$eventSourceId';

package/reducers/index.ts

@@ -1,8 +1,8 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-export { ReducerId } from './ReducerId';
-export { reducer, getReducerMetadata, isReducer } from './reducer';
-export type { ReducerMetadata } from './reducer';
-export type { IReducers } from './IReducers';
-export { Reducers } from './Reducers';
+export { ReducerId } from './ReducerId.js';
+export { reducer, getReducerMetadata, isReducer } from './reducer.js';
+export type { ReducerMetadata } from './reducer.js';
+export type { IReducers } from './IReducers.js';
+export { Reducers } from './Reducers.js';

package/reducers/reducer.spec.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { describe, expect, it } from 'vitest';
-import { getReducerMetadata, reducer } from './reducer';
+import { getReducerMetadata, reducer } from './reducer.js';
 
 describe('reducer', () => {
     describe('when decorating a class without specifying isActive', () => {

package/reducers/reducer.ts

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

package/schemas/JsonSchemaGenerator.confidentiality.spec.ts

@@ -4,12 +4,12 @@
 import 'reflect-metadata';
 import { ConceptAs, field } from '@cratis/fundamentals';
 import { describe, expect, it } from 'vitest';
-import { pii } from '../compliance/pii';
-import { encrypted } from '../confidentiality/encrypted';
-import { EncryptionScope } from '../confidentiality/EncryptionScope';
-import { PIIAndEncryptedCombinedNotSupported } from '../confidentiality/PIIAndEncryptedCombinedNotSupported';
-import { getReadModelMetadata, readModel } from '../readModels/readModel';
-import { JsonSchema } from './JsonSchema';
+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 { 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.
@@ -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,12 +2,12 @@
 // 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';
-import { eventType, getEventTypeJsonSchemaFor } from '../events/eventTypeDecorator';
-import { getReadModelMetadata, readModel } from '../readModels/readModel';
-import { JsonSchema } from './JsonSchema';
+import { pii } from '../compliance/pii.js';
+import { eventType, getEventTypeJsonSchemaFor } from '../events/eventTypeDecorator.js';
+import { getReadModelMetadata, readModel } from '../readModels/readModel.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
@@ -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,18 +2,24 @@
 // 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 { ComplianceSchemaMetadata, JsonSchema, SecuritySchemaMetadata } from './JsonSchema';
-import { TypeIntrospector } from '../types';
-import { ComplianceMetadata } from '../compliance/ComplianceMetadata';
-import { ComplianceMetadataResolver } from '../compliance/ComplianceMetadataResolver';
-import { SecurityMetadata } from '../confidentiality/SecurityMetadata';
-import { SecurityMetadataResolver } from '../confidentiality/SecurityMetadataResolver';
-import { PIIAndEncryptedCombinedNotSupported } from '../confidentiality/PIIAndEncryptedCombinedNotSupported';
+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';
+import { SecurityMetadataResolver } from '../confidentiality/SecurityMetadataResolver.js';
+import { PIIAndEncryptedCombinedNotSupported } from '../confidentiality/PIIAndEncryptedCombinedNotSupported.js';
 
 /**
  * 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;
         }