@cratis/fundamentals 7.19.3 → 7.19.5

package/for_JsonSerializer/when_deserializing_generic_array_without_a_value.ts

@@ -0,0 +1,10 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { JsonSerializer } from '../JsonSerializer';
+import { Document } from './given/a_model_with_field_metadata';
+
+describe('when deserializing a generic array without a value', () => {
+    it('should use an empty array for an absent collection', () => JsonSerializer.deserialize(Document, '{}').names.should.deep.equal([]));
+    it('should preserve an explicit null collection', () => (JsonSerializer.deserialize(Document, '{"names":null}').names === null).should.be.true);
+});

package/for_JsonSerializer/when_round_tripping_fields_with_legacy_decorators.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { given } from './given/given';
+import { JsonSerializer } from '../JsonSerializer';
+import { Document, a_model_with_field_metadata } from './given/a_model_with_field_metadata';
+
+describe('when round tripping fields with legacy decorators', given(a_model_with_field_metadata, context => {
+    let written: {
+        identifier: string;
+        label: string;
+        quantity: number;
+        enabled: boolean;
+        identifiers: string[];
+        children: { identifier: string }[];
+    };
+    let read: Document;
+
+    beforeEach(() => {
+        const document = JsonSerializer.deserialize(Document, JSON.stringify(context.payload));
+        const json = JsonSerializer.serialize(document);
+        written = JSON.parse(json);
+        read = JsonSerializer.deserialize(Document, json);
+    });
+
+    it('should write a concept wrapping a Guid as a string', () => written.identifier.should.equal(context.identifier));
+    it('should write falsy concept payloads without object wrappers', () => [written.label, written.quantity, written.enabled].should.deep.equal(['', 0, false]));
+    it('should write generic arrays of concepts as underlying values', () => written.identifiers.should.deep.equal([context.identifier]));
+    it('should write generic arrays of nested models as objects', () => written.children.should.deep.equal([{ identifier: context.identifier }]));
+    it('should read back the nested array model and typed concept', () => read.children[0].identifier.value.toString().should.equal(context.identifier));
+}));

package/for_fieldDecorator/fixtures/standard_decorated_types.ts

@@ -3,7 +3,20 @@
 
 declare const fundamentals: typeof import('../../index');
 
-const { derivedType, field, JsonSerializer, ValueMap } = fundamentals;
+const { ConceptAs, derivedType, field, Guid, JsonSerializer, ValueMap } = fundamentals;
+
+class Identifier extends ConceptAs<InstanceType<typeof Guid>> {
+    static readonly valueType = Guid;
+}
+
+class Label extends ConceptAs<string> {}
+class Quantity extends ConceptAs<number> {}
+class Enabled extends ConceptAs<boolean> {}
+
+class Child {
+    @field(Identifier)
+    identifier!: Identifier;
+}
 
 function replaceClass<Target extends import('../../Constructor').Constructor>(target: Target): Target {
     return class extends target { } as Target;
@@ -39,6 +52,33 @@ class Drawing {
     @field(String)
     title!: string;
 
+    @field(Array, { genericArguments: [String] })
+    names!: string[];
+
+    @field(Identifier)
+    identifier!: Identifier;
+
+    @field(Label)
+    label!: Label;
+
+    @field(Quantity)
+    quantity!: Quantity;
+
+    @field(Enabled)
+    enabled!: Enabled;
+
+    @field(Child)
+    child!: Child;
+
+    @field(Array, { genericArguments: [Identifier] })
+    identifiers!: Identifier[];
+
+    @field(Array, { genericArguments: [Child] })
+    children!: Child[];
+
+    @field(Label, true)
+    legacyLabels!: Label[];
+
     @field(Date)
     createdAt!: Date;
 
@@ -54,8 +94,18 @@ class Drawing {
 }
 
 const instanceCountBeforeDeserialize = Drawing.instanceCount;
+const identifier = 'f0fa7c5e-9f7b-4688-8851-e0b6eeebe28b';
 const drawing = JsonSerializer.deserialize(Drawing, JSON.stringify({
+    child: { identifier },
+    children: [{ identifier }],
     createdAt: '2026-08-16T09:30:00.000Z',
+    enabled: false,
+    identifier,
+    identifiers: [identifier],
+    label: '',
+    legacyLabels: ['older'],
+    names: ['one', 'two'],
+    quantity: 0,
     scores: {
         first: 42
     },
@@ -72,5 +122,6 @@ const drawing = JsonSerializer.deserialize(Drawing, JSON.stringify({
     title: 'Standard decorators'
 }));
 const instanceCountAfterDeserialize = Drawing.instanceCount;
+const serializedDrawing = JsonSerializer.serialize(drawing);
 
-void [Circle, Rectangle, ReplacedShape, instanceCountBeforeDeserialize, drawing, instanceCountAfterDeserialize];
+void [Child, Circle, Rectangle, ReplacedShape, instanceCountBeforeDeserialize, drawing, instanceCountAfterDeserialize, serializedDrawing];

package/for_fieldDecorator/when_executing_standard_typescript_decorator_emit.ts

@@ -19,19 +19,34 @@ describe('when executing standard TypeScript decorator emit', () => {
     let symbolMetadataWasAbsent: boolean;
     let symbolMetadataWasPolyfilled: boolean;
     let executionResult: {
+        Child: fundamentals.Constructor;
         Circle: fundamentals.Constructor;
         Drawing: fundamentals.Constructor;
+        Enabled: fundamentals.Constructor;
+        Identifier: fundamentals.Constructor;
+        Label: fundamentals.Constructor;
+        Quantity: fundamentals.Constructor;
         Rectangle: fundamentals.Constructor;
         ReplacedShape: fundamentals.Constructor;
         Shape: fundamentals.Constructor;
         drawing: {
+            child: { identifier: { value: fundamentals.Guid } };
+            children: object[];
             createdAt: Date;
+            enabled: { value: boolean };
+            identifier: { value: fundamentals.Guid };
+            identifiers: { value: fundamentals.Guid }[];
+            label: { value: string };
+            legacyLabels: { value: string }[];
+            names: string[];
+            quantity: { value: number };
             scores: fundamentals.ValueMap<string, number>;
             shapes: object[];
             title: string;
         };
         instanceCountAfterDeserialize: number;
         instanceCountBeforeDeserialize: number;
+        serializedDrawing: string;
     };
     let registeredDerivedTypes: fundamentals.Constructor[];
     let legacySemanticDiagnosticCount: number;
@@ -86,7 +101,7 @@ describe('when executing standard TypeScript decorator emit', () => {
             reportDiagnostics: true
         }).outputText;
 
-        const script = new Script(`${emittedJavaScript}\n({ Circle, Drawing, Rectangle, ReplacedShape, Shape, drawing, instanceCountAfterDeserialize, instanceCountBeforeDeserialize })`);
+        const script = new Script(`${emittedJavaScript}\n({ Child, Circle, Drawing, Enabled, Identifier, Label, Quantity, Rectangle, ReplacedShape, Shape, drawing, instanceCountAfterDeserialize, instanceCountBeforeDeserialize, serializedDrawing })`);
         executionResult = script.runInNewContext({ Array, Boolean, Date, fundamentals, JSON, Number, Object, String, Symbol }) as typeof executionResult;
         registeredDerivedTypes = fundamentals.DerivedType.getDerivedTypesFor(executionResult.Shape);
     });
@@ -104,6 +119,36 @@ describe('when executing standard TypeScript decorator emit', () => {
     it('should expose field metadata before constructing an instance', () => executionResult.instanceCountBeforeDeserialize.should.equal(0));
     it('should construct the target only during first-call deserialization', () => executionResult.instanceCountAfterDeserialize.should.equal(1));
     it('should deserialize primitive fields', () => executionResult.drawing.title.should.equal('Standard decorators'));
+    it('should read array elements declared through generic arguments', () => executionResult.drawing.names.should.deep.equal(['one', 'two']));
+    it('should read a concept underlying Guid as a Guid', () => executionResult.drawing.identifier.value.should.be.instanceOf(fundamentals.Guid));
+    it('should wrap an empty string in its concept', () => {
+        (executionResult.drawing.label instanceof executionResult.Label).should.be.true;
+        executionResult.drawing.label.value.should.equal('');
+    });
+    it('should wrap zero in its concept', () => {
+        (executionResult.drawing.quantity instanceof executionResult.Quantity).should.be.true;
+        executionResult.drawing.quantity.value.should.equal(0);
+    });
+    it('should wrap false in its concept', () => {
+        (executionResult.drawing.enabled instanceof executionResult.Enabled).should.be.true;
+        executionResult.drawing.enabled.value.should.equal(false);
+    });
+    it('should read a nested model and its concept', () => {
+        (executionResult.drawing.child instanceof executionResult.Child).should.be.true;
+        executionResult.drawing.child.identifier.value.should.be.instanceOf(fundamentals.Guid);
+    });
+    it('should read an array of concepts', () => {
+        (executionResult.drawing.identifiers[0] instanceof executionResult.Identifier).should.be.true;
+        executionResult.drawing.identifiers[0].value.should.be.instanceOf(fundamentals.Guid);
+    });
+    it('should read an array of nested models', () => (executionResult.drawing.children[0] instanceof executionResult.Child).should.be.true);
+    it('should keep reading legacy enumerable fields', () => executionResult.drawing.legacyLabels[0].value.should.equal('older'));
+    it('should serialize generic arrays of concepts as values', () => JSON.parse(executionResult.serializedDrawing).identifiers.should.deep.equal(['f0fa7c5e-9f7b-4688-8851-e0b6eeebe28b']));
+    it('should serialize generic arrays of nested models', () => JSON.parse(executionResult.serializedDrawing).children.should.deep.equal([{ identifier: 'f0fa7c5e-9f7b-4688-8851-e0b6eeebe28b' }]));
+    it('should serialize falsy concept values', () => {
+        const written = JSON.parse(executionResult.serializedDrawing);
+        [written.label, written.quantity, written.enabled].should.deep.equal(['', 0, false]);
+    });
     it('should deserialize date fields', () => executionResult.drawing.createdAt.should.be.instanceOf(Date));
     it('should deserialize polymorphic array entries', () => (executionResult.drawing.shapes[0] instanceof executionResult.Circle).should.be.true);
     it('should deserialize every registered derivative', () => (executionResult.drawing.shapes[1] instanceof executionResult.Rectangle).should.be.true);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/fundamentals",
-    "version": "7.19.3",
+    "version": "7.19.5",
     "description": "The shared building blocks beneath the Cratis stack — GUIDs, concepts, derived-type serialization, property-path proxies, and decorators for TypeScript",
     "keywords": [
         "cratis",
@@ -56,7 +56,7 @@
     },
     "devDependencies": {
         "@typescript/native": "npm:typescript@^7.0.2",
-        "rollup": "4.63.3",
+        "rollup": "4.63.4",
         "rollup-plugin-typescript2": "0.37.0",
         "typescript": "npm:@typescript/typescript6@^6.0.2",
         "typescript-programmatic-api": "npm:@typescript/typescript6@^6.0.2"