@cratis/chronicle 6.32.0 → 6.33.0

package/readModels/for_ReadModels/when_releasing_a_document/with_an_unknown_subject_property.spec.ts

@@ -0,0 +1,42 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each(['unknown', 'contact.phone', '__subject', '__subjects', 'toString'])('when releasing a document with unknown subject property %s', property => {
+    let context: a_stored_read_model;
+    let error: Error;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        await context.readModels.releaseDocument(AccountDocument, {
+            name: 'encrypted name', contact: { phone: 'encrypted phone' }, unknown: 'not declared',
+            'contact.phone': 'not declared', toString: 'not declared',
+            __subject: 'owner', __subjects: { [property]: 'other-owner' }
+        }).catch(caught => { error = caught as Error; });
+    });
+
+    it('should reject undeclared, nested, reserved and inherited property names', () => error.message.should.equal('Stored read model document has an unknown subject property.'));
+    it('should validate the entire subject map before attempting any releases', () => context.release.mock.calls.should.have.lengthOf(0));
+});
+
+describe.each(['email', 'removedProperty', 'contact.phone', 'toString'])('when releasing a document with a stale subject property %s', property => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            name: 'encrypted name', __subject: 'owner', __subjects: { [property]: 'other-owner' }
+        });
+    });
+
+    it('should ignore mappings without a corresponding document property', () => result.should.deep.equal({ name: 'encrypted name' }));
+    it('should release only the existing properties under their subject', () => {
+        context.release.mock.calls.should.have.lengthOf(1);
+        JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ name: 'encrypted name' });
+    });
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_bookkeeping_fields.spec.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([undefined, 'owner'])('when releasing a document with bookkeeping and default subject %s', defaultSubject => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'stored name', _id: 'storage-id', __generation: 1,
+            __subject: defaultSubject, __subjects: {}
+        });
+    });
+
+    it('should strip storage-only and subject metadata', () => result.should.deep.equal({ id: 'account', name: 'stored name' }));
+    it('should never send bookkeeping for release', () => {
+        context.release.mock.calls.forEach(([request]) => {
+            JSON.parse(request.Payload).should.deep.equal({ id: 'account', name: 'stored name' });
+        });
+    });
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_conflicting_or_missing_properties.spec.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+const should = chai.should();
+
+describe.each([
+    '{}',
+    '{"name":"wrong group"}',
+    '{"email":"released email","name":"overwrite released group"}',
+    '{"email":"released email","id":"overwrite unreleased property"}',
+    '{"email":"released email","__proto__":{"polluted":true}}'
+])('when releasing a document with missing or conflicting response properties %s', payload => {
+    let result: Record<string, unknown> | undefined;
+    let error: Error;
+
+    beforeEach(async () => {
+        const context = new a_stored_read_model();
+        result = undefined;
+        context.release.mockResolvedValueOnce({ HasError: false, Error: '', Payload: '{"name":"released name"}' });
+        context.release.mockResolvedValueOnce({ HasError: false, Error: '', Payload: payload });
+        await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', email: 'encrypted email',
+            __subjects: { name: 'owner', email: 'other-owner' }
+        }).then(released => { result = released; }, caught => { error = caught as Error; });
+    });
+
+    it('should reject the whole operation', () => error.message.should.equal('Failed to release stored read model document: missing or conflicting properties.'));
+    it('should not expose a partial result', () => should.not.exist(result));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_empty_subject_metadata.spec.ts

@@ -0,0 +1,56 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([
+    { __subject: null }, { __subject: '' },
+    { __subjects: { name: null } }, { __subjects: { name: '' } },
+    { __subjects: null }, { __subjects: [] }, { __subjects: 'owner' }, { __subjects: 42 }
+])('when releasing a document without usable subject metadata %j', metadata => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        result = await context.readModels.releaseDocument(AccountDocument, { name: 'stored name', ...metadata });
+    });
+
+    it('should copy properties without a subject unchanged', () => result.should.deep.equal({ name: 'stored name' }));
+    it('should not attempt release', () => context.release.mock.calls.should.have.lengthOf(0));
+});
+
+describe.each([null, ''])('when releasing a document with an empty property subject %j and a default subject', subject => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: JSON.stringify({ name: 'released name' }) });
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            name: 'encrypted name', __subject: 'owner', __subjects: { name: subject }
+        });
+    });
+
+    it('should fall back to the default subject', () => context.requestFor('owner').Subject.should.equal('owner'));
+    it('should release the property', () => result.should.deep.equal({ name: 'released name' }));
+});
+
+describe.each([null, ''])('when releasing a document with an empty default subject %j and a property subject', subject => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: JSON.stringify({ name: 'released name' }) });
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', __subject: subject, __subjects: { name: 'owner' }
+        });
+    });
+
+    it('should release only the property with a subject', () => JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ name: 'encrypted name' }));
+    it('should retain properties without a subject', () => result.should.deep.equal({ id: 'account', name: 'released name' }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_invalid_subject_metadata.spec.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([
+    { __subject: 42 }, { __subject: false }, { __subject: [] }, { __subject: {} },
+    { __subjects: { name: 42 } }, { __subjects: { name: false } },
+    { __subjects: { name: [] } }, { __subjects: { name: { subject: 'private@example.test' } } },
+    { __subjects: { email: 42 } }, { __subjects: { removedProperty: 42 } }
+])('when releasing a document with invalid subject metadata %j', metadata => {
+    let context: a_stored_read_model;
+    let error: Error;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        await context.readModels.releaseDocument(AccountDocument, { name: 'encrypted name', ...metadata })
+            .catch(caught => { error = caught as Error; });
+    });
+
+    it('should reject the document', () => error.should.be.instanceOf(Error));
+    it('should not expose metadata values in the error', () => error.message.should.not.contain('private@example.test'));
+    it('should not attempt release with invalid metadata', () => context.release.mock.calls.should.have.lengthOf(0));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_mixed_subjects.spec.ts

@@ -0,0 +1,38 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document with mixed default and property subjects', () => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockImplementation(async request => ({
+            HasError: false, Error: '', Payload: JSON.stringify(request.Subject === 'owner'
+                ? { id: 'account', name: 'released name' } : { email: 'released email' })
+        }));
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', email: 'encrypted email',
+            __subject: 'owner', __subjects: { name: 'owner', email: 'joined-owner' }
+        });
+    });
+
+    it('should reuse the default subject group for matching property subjects', () => context.release.mock.calls.should.have.lengthOf(2));
+    it('should apply the default to unmapped properties', () => {
+        JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ id: 'account', name: 'encrypted name' });
+    });
+    it('should override the default for mapped properties', () => {
+        JSON.parse(context.requestFor('joined-owner').Payload).should.deep.equal({ email: 'encrypted email' });
+    });
+    it('should send a schema limited to the overridden property', () => {
+        Object.keys(JSON.parse(context.requestFor('joined-owner').Schema).properties).should.deep.equal(['email']);
+    });
+    it('should merge the released properties without bookkeeping', () => result.should.deep.equal({
+        id: 'account', name: 'released name', email: 'released email'
+    }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_property_subjects.spec.ts

@@ -0,0 +1,52 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { beforeEach, chai, describe, it } from 'vitest';
+import { JsonSchemaGenerator } from '../../../schemas/index.js';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document with property subjects', () => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockImplementation(async request => ({
+            HasError: false, Error: '', Payload: JSON.stringify(request.Subject === 'owner'
+                ? { name: 'released name', email: 'released email' }
+                : { contact: { phone: 'released phone' }, contacts: [{ phone: 'released list phone' }] })
+        }));
+        result = await context.readModels.releaseDocument(AccountDocument, {
+            id: 'account', name: 'encrypted name', email: 'encrypted email',
+            contact: { phone: 'encrypted phone' }, contacts: [{ phone: 'encrypted list phone' }],
+            __subjects: { name: 'owner', email: 'owner', contact: 'contact-owner', contacts: 'contact-owner' }
+        });
+    });
+
+    it('should batch properties by distinct subject', () => context.release.mock.calls.should.have.lengthOf(2));
+    it('should send only the owner properties to that subject', () => {
+        JSON.parse(context.requestFor('owner').Payload).should.deep.equal({ name: 'encrypted name', email: 'encrypted email' });
+    });
+    it('should release each nested subtree and array under its top-level subject', () => {
+        JSON.parse(context.requestFor('contact-owner').Payload).should.deep.equal({
+            contact: { phone: 'encrypted phone' }, contacts: [{ phone: 'encrypted list phone' }]
+        });
+    });
+    it('should retain nested compliance schemas', () => {
+        const properties = JsonSchemaGenerator.generate(AccountDocument).properties!;
+        JSON.parse(context.requestFor('contact-owner').Schema).properties.should.deep.equal({
+            contact: properties.contact, contacts: properties.contacts
+        });
+    });
+    it('should include the array item phone PII metadata in the subject-specific schema', () => {
+        JSON.parse(context.requestFor('contact-owner').Schema).properties.contacts.items.properties.phone.should.deep.equal({
+            type: 'string', compliance: [{ metadataType: 'PII', details: '' }]
+        });
+    });
+    it('should combine the released groups and retain properties without a subject', () => result.should.deep.equal({
+        id: 'account', name: 'released name', email: 'released email',
+        contact: { phone: 'released phone' }, contacts: [{ phone: 'released list phone' }]
+    }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/with_whitespace_subjects.spec.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 { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe.each([
+    { __subject: '  \t' },
+    { __subject: 'owner', __subjects: { name: '  \t' } }
+])('when releasing a document with a whitespace-only subject %j', metadata => {
+    let context: a_stored_read_model;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        context.release.mockResolvedValue({ HasError: false, Error: '', Payload: JSON.stringify({ name: 'released name' }) });
+        result = await context.readModels.releaseDocument(AccountDocument, { name: 'encrypted name', ...metadata });
+    });
+
+    it('should preserve the exact subject in the release request', () => context.requestFor('  \t').Subject.should.equal('  \t'));
+    it('should release the property', () => result.should.deep.equal({ name: 'released name' }));
+});

package/readModels/for_ReadModels/when_releasing_a_document/without_subjects.spec.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 { beforeEach, chai, describe, it } from 'vitest';
+import { AccountDocument, a_stored_read_model } from '../given/a_stored_read_model.js';
+
+chai.should();
+
+describe('when releasing a document without subjects', () => {
+    let context: a_stored_read_model;
+    let document: Record<string, unknown>;
+    let result: Record<string, unknown>;
+
+    beforeEach(async () => {
+        context = new a_stored_read_model();
+        document = { id: 'account', name: 'unchanged', contact: { phone: 'unchanged phone' } };
+        result = await context.readModels.releaseDocument(AccountDocument, document);
+    });
+
+    it('should leave data values unchanged', () => result.should.deep.equal(document));
+    it('should not infer a subject from id or subject decorators', () => context.release.mock.calls.should.have.lengthOf(0));
+    it('should return a copy', () => result.should.not.equal(document));
+    it('should not share unreleased subtrees with the input', () => result.contact!.should.not.equal(document.contact));
+});

package/schemas/JsonSchemaGenerator.ts

@@ -61,7 +61,9 @@ export class JsonSchemaGenerator {
         const schemaProperties: Record<string, JsonSchema> = {};
         const prototype = target.prototype;
 
-        for (const [memberName, memberType] of membersToUse.entries()) {
+        for (const [memberName, reflectedMemberType] of membersToUse.entries()) {
+            // A children collection is an array even when neither design:type nor an initializer is available.
+            const memberType = reflectedMemberType ?? (getChildrenFromMetadata(prototype, memberName).length > 0 ? Array : undefined);
             if (!memberType && requireResolvedTypes) {
                 throw new TypeError(`Cannot determine the type of ${target.name}.${memberName}; declare @field with its runtime type.`);
             }
@@ -144,7 +146,7 @@ export class JsonSchemaGenerator {
 
     /**
      * Maps an array-typed member to a schema, resolving the element type from a
-     * `@field(Array, { genericArguments: [ItemType] })` declaration when present.
+     * `@childrenFrom` child type or `@field(Array, { genericArguments: [ItemType] })` declaration when present.
      * @param declaringType - The class constructor that declares the array property.
      * @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.
@@ -173,14 +175,27 @@ export class JsonSchemaGenerator {
             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) };
+        const childrenMetadata = declaringType && propertyName ? getChildrenFromMetadata(declaringType.prototype, propertyName) : [];
+        if (!requireResolvedTypes && !childrenMetadata.length) return { type: 'array', items: { type: 'object' } }; // Legacy schema compatibility outside children.
+        const items = this.mapRuntimeTypeToSchema(elementType, undefined, undefined, requireResolvedTypes);
+        if (!requireResolvedTypes && childrenMetadata.length) {
+            // Match buildChildrenEntry's identifier discovery, including members whose types are unresolved.
+            const members = [...TypeIntrospector.getMembers(elementType).keys()];
+            const eventKey = childrenMetadata[0]?.key;
+            const identifiedBy = childrenMetadata.find(metadata => metadata.identifiedBy)?.identifiedBy ??
+                members.find(name => name.toLowerCase() === 'id') ??
+                (eventKey !== undefined ? members.find(name => name.toLowerCase() === eventKey.toLowerCase()) : undefined) ?? '$eventSourceId';
+            if (!items.properties || !Object.hasOwn(items.properties, identifiedBy)) {
+                return { type: 'array', items: { type: 'object' } };
+            }
+        }
+        return { type: 'array', items };
     }
 
     /**
-     * Resolves the element type of an array property from its `@field(Array, { genericArguments: [...] })`
-     * declaration. TypeScript erases generic type arguments at runtime, so without an explicit
-     * `@field` declaration the element type cannot be recovered.
+     * Resolves the element type from an explicit `@childrenFrom` child type, then from
+     * `@field(Array, { genericArguments: [...] })`. TypeScript erases generic type arguments
+     * at runtime, so an explicit declaration is needed to recover the element type.
      * @param declaringType - The class constructor that declares the array property.
      * @param propertyName - The array property name.
      * @returns The element type constructor, or undefined when it cannot be resolved.

package/schemas/for_JsonSchemaGenerator/when_generating_children/with_legacy_decorators.legacy.spec.ts

@@ -0,0 +1,143 @@
+// 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 { field } from '@cratis/fundamentals';
+import { chai, describe, it } from 'vitest';
+import { childrenFrom } from '../../../projections/modelBound/childrenFrom.js';
+import { JsonSchemaGenerator } from '../../JsonSchemaGenerator.js';
+
+chai.should();
+
+class ItemAdded {
+    itemId = '';
+    name = '';
+}
+
+class Item {
+    id = '';
+    name = '';
+    quantity = 0;
+}
+
+class Order {
+    @childrenFrom(ItemAdded, { childType: Item, key: 'itemId' })
+    options: Item[] = [];
+
+    @childrenFrom(ItemAdded, Item)
+    positional: Item[] = [];
+
+    @childrenFrom(ItemAdded, { childType: Item, key: 'itemId' })
+    withoutInitializer!: Item[];
+
+    @field(Array, { genericArguments: [Item] })
+    @childrenFrom(ItemAdded, 'itemId')
+    fieldMetadata: Item[] = [];
+
+    @childrenFrom(ItemAdded, { key: 'itemId', identifiedBy: 'id' })
+    unknown: Item[] = [];
+
+    @field(Array, { genericArguments: [Item] })
+    unrelated: Item[] = [];
+}
+
+class DeclaredItem {
+    @field(String) id!: string;
+    @field(String) name!: string;
+}
+
+class DeclaredOrder {
+    @childrenFrom(ItemAdded, { childType: DeclaredItem, key: 'itemId' })
+    items!: DeclaredItem[];
+}
+
+class UnresolvedItem {
+    id!: string;
+    name!: string;
+}
+
+class PartiallyResolvedItem {
+    id = '';
+    name!: string;
+}
+
+class MissingIdentifierItem {
+    id!: string;
+    name = '';
+}
+
+class CustomIdentifierItem {
+    itemId = '';
+    name!: string;
+}
+
+class CapitalizedIdentifierItem {
+    Id = '';
+    name!: string;
+}
+
+class FallbackOrder {
+    @childrenFrom(ItemAdded, { childType: UnresolvedItem, key: 'itemId', identifiedBy: 'id' })
+    unresolved!: UnresolvedItem[];
+
+    @childrenFrom(ItemAdded, { childType: MissingIdentifierItem, key: 'itemId', identifiedBy: 'id' })
+    missingIdentifier!: MissingIdentifierItem[];
+
+    @childrenFrom(ItemAdded, { childType: PartiallyResolvedItem, key: 'itemId' })
+    partial!: PartiallyResolvedItem[];
+
+    @childrenFrom(ItemAdded, { childType: CustomIdentifierItem, key: 'itemId' })
+    custom!: CustomIdentifierItem[];
+
+    @childrenFrom(ItemAdded, { childType: CapitalizedIdentifierItem, key: 'itemId' })
+    capitalized!: CapitalizedIdentifierItem[];
+
+    @childrenFrom(ItemAdded, { childType: MissingIdentifierItem, key: 'itemId' })
+    undiscoverableIdentifier!: MissingIdentifierItem[];
+}
+
+const schema = JsonSchemaGenerator.generate(Order);
+
+describe('for JsonSchemaGenerator', () => {
+    describe('when generating children with legacy decorators without design metadata', () => {
+        for (const property of ['options', 'positional', 'withoutInitializer', 'fieldMetadata']) {
+            it(`should register typed items for ${property}`, () => {
+                chai.should().not.exist(Reflect.getMetadata('design:type', Order.prototype, property));
+                schema.properties![property].should.deep.equal({ type: 'array', items: JsonSchemaGenerator.generate(Item) });
+                schema.properties![property].items!.properties!.should.deep.equal({
+                    id: { type: 'string' }, name: { type: 'string' }, quantity: { type: 'number' }
+                });
+            });
+        }
+
+        it('should resolve child properties from explicit field metadata without initializers', () => {
+            JsonSchemaGenerator.generate(DeclaredOrder).properties!.items.items!.properties!.should.deep.equal({
+                id: { type: 'string' }, name: { type: 'string' }
+            });
+        });
+
+        it('should retain untyped items when the child type is unknown', () => {
+            schema.properties!.unknown.should.deep.equal({ type: 'array', items: { type: 'object' } });
+        });
+
+        it('should retain untyped items for child members declared only with definite assignment', () => {
+            JsonSchemaGenerator.generate(FallbackOrder).properties!.unresolved.should.deep.equal({ type: 'array', items: { type: 'object' } });
+        });
+
+        for (const property of ['missingIdentifier', 'undiscoverableIdentifier']) {
+            it(`should retain untyped items for ${property} despite a resolved non-identifier property`, () => {
+                JsonSchemaGenerator.generate(FallbackOrder).properties![property].should.deep.equal({ type: 'array', items: { type: 'object' } });
+            });
+        }
+
+        for (const [property, childType] of [['partial', PartiallyResolvedItem], ['custom', CustomIdentifierItem], ['capitalized', CapitalizedIdentifierItem]] as const) {
+            it(`should retain typed items for ${property} with a resolved identifier`, () => {
+                JsonSchemaGenerator.generate(FallbackOrder).properties![property].should.deep.equal({ type: 'array', items: JsonSchemaGenerator.generate(childType) });
+            });
+        }
+
+        it('should preserve legacy array schemas outside children collections', () => {
+            schema.properties!.unrelated.should.deep.equal({ type: 'array', items: { type: 'object' } });
+        });
+    });
+});

package/schemas/for_JsonSchemaGenerator/when_generating_children/with_standard_decorators.standard.spec.ts

@@ -0,0 +1,66 @@
+// 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 { chai, describe, it } from 'vitest';
+import { childrenFrom } from '../../../projections/modelBound/childrenFrom.js';
+import { JsonSchemaGenerator } from '../../JsonSchemaGenerator.js';
+
+chai.should();
+
+function should(value: unknown): ReturnType<typeof chai.expect> {
+    return (value as { should: ReturnType<typeof chai.expect> }).should;
+}
+
+class ItemAdded {
+    @field(String) itemId!: string;
+    @field(String) name!: string;
+}
+
+class Item {
+    @field(String) id!: string;
+    @field(String) name!: string;
+    @field(Number) quantity!: number;
+}
+
+class Order {
+    @field(Array)
+    @childrenFrom(ItemAdded, { childType: Item, key: 'itemId' })
+    options!: Item[];
+
+    @field(Array)
+    @childrenFrom(ItemAdded, Item)
+    positional!: Item[];
+
+    @childrenFrom(ItemAdded, { childType: Item, key: 'itemId' })
+    withoutField!: Item[];
+
+    @field(Array, { genericArguments: [Item] })
+    @childrenFrom(ItemAdded, 'itemId')
+    fieldMetadata!: Item[];
+}
+
+class UnknownOrder {
+    @field(Array)
+    @childrenFrom(ItemAdded, { key: 'itemId', identifiedBy: 'id' })
+    items!: Item[];
+}
+
+const schema = JsonSchemaGenerator.generate(Order);
+
+describe('for JsonSchemaGenerator', () => {
+    describe('when generating children with standard decorators', () => {
+        for (const property of ['options', 'positional', 'withoutField', 'fieldMetadata']) {
+            it(`should register typed items for ${property}`, () => {
+                should(schema.properties![property]).deep.equal({ type: 'array', items: JsonSchemaGenerator.generate(Item) });
+                should(schema.properties![property].items!.properties!).deep.equal({
+                    id: { type: 'string' }, name: { type: 'string' }, quantity: { type: 'number' }
+                });
+            });
+        }
+
+        it('should still reject an unresolved child type', () => {
+            should(() => JsonSchemaGenerator.generate(UnknownOrder)).throw(TypeError, 'Cannot determine the element type of UnknownOrder.items');
+        });
+    });
+});