@cratis/fundamentals 7.17.1 → 7.18.1

package/for_fieldDecorator/when_standard_metadata_is_inherited_and_overridden.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Fields } from '../Fields';
+import { field } from '../fieldDecorator';
+import { StandardFieldDecoratorContext } from '../StandardFieldDecoratorContext';
+
+class BaseType { }
+class DerivedType extends BaseType { }
+
+describe('when standard metadata is inherited and overridden', () => {
+    const baseMetadata: Record<PropertyKey, unknown> = Object.create(null) as Record<PropertyKey, unknown>;
+    const derivedMetadata: Record<PropertyKey, unknown> = Object.create(baseMetadata) as Record<PropertyKey, unknown>;
+    const contextFor = (name: string, metadata: Record<PropertyKey, unknown>): StandardFieldDecoratorContext => ({
+        kind: 'field',
+        metadata,
+        name,
+        private: false,
+        static: false
+    });
+
+    field(String)(undefined, contextFor('baseValue', baseMetadata));
+    field(String)(undefined, contextFor('value', baseMetadata));
+    field(Number)(undefined, contextFor('value', derivedMetadata));
+    field(Boolean)(undefined, contextFor('derivedValue', derivedMetadata));
+    Object.defineProperty(BaseType, Symbol.metadata, { value: baseMetadata });
+    Object.defineProperty(DerivedType, Symbol.metadata, { value: derivedMetadata });
+
+    const baseFields = Fields.getFieldsForType(BaseType);
+    const derivedFields = Fields.getFieldsForType(DerivedType);
+
+    it('should preserve fields declared by the base type', () => derivedFields.find(_ => _.name === 'baseValue')!.type.should.equal(String));
+    it('should preserve fields declared by the derived type', () => derivedFields.find(_ => _.name === 'derivedValue')!.type.should.equal(Boolean));
+    it('should keep a single overridden field', () => derivedFields.filter(_ => _.name === 'value').should.have.lengthOf(1));
+    it('should use the derived field definition', () => derivedFields.find(_ => _.name === 'value')!.type.should.equal(Number));
+    it('should not mutate the base field definition', () => baseFields.find(_ => _.name === 'value')!.type.should.equal(String));
+});

package/for_reflection/when_loading_with_existing_symbol_metadata.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+describe('when loading with existing Symbol metadata', () => {
+    const originalMetadataDescriptor = Object.getOwnPropertyDescriptor(Symbol, 'metadata');
+    const existingMetadata = Symbol('existing metadata');
+    let actualMetadata: symbol;
+
+    beforeAll(async () => {
+        Object.defineProperty(Symbol, 'metadata', {
+            configurable: true,
+            value: existingMetadata
+        });
+
+        await import(/* @vite-ignore */ '../reflection?existingSymbolMetadata');
+        actualMetadata = Symbol.metadata;
+    });
+
+    afterAll(() => {
+        Reflect.deleteProperty(Symbol, 'metadata');
+        if (originalMetadataDescriptor) Object.defineProperty(Symbol, 'metadata', originalMetadataDescriptor);
+    });
+
+    it('should preserve the existing identity', () => actualMetadata.should.equal(existingMetadata));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/fundamentals",
-    "version": "7.17.1",
+    "version": "7.18.1",
     "description": "",
     "author": "Cratis",
     "license": "MIT",
@@ -41,6 +41,13 @@
             "require": "./dist/cjs/reflection.js"
         }
     },
+    "installConfig": {
+        "hoistingLimits": "workspaces"
+    },
+    "devDependencies": {
+        "rollup-plugin-typescript2": "0.37.0",
+        "typescript-programmatic-api": "npm:typescript@6.0.3"
+    },
     "scripts": {
         "prepare": "yarn g:build",
         "clean": "yarn g:clean",

package/reflection.ts

@@ -29,6 +29,19 @@ declare global {
     }
 }
 
+// Standard decorators expose their class metadata through Symbol.metadata. Define it before any
+// decorated class is evaluated on runtimes that do not provide it yet. Symbol.for keeps the value
+// stable if more than one copy of this package is loaded in the same realm.
+const symbolConstructor = Symbol as unknown as { metadata?: unknown };
+if (symbolConstructor.metadata === undefined || symbolConstructor.metadata === null) {
+    Object.defineProperty(Symbol, 'metadata', {
+        configurable: true,
+        enumerable: false,
+        value: Symbol.for('Symbol.metadata'),
+        writable: false
+    });
+}
+
 // Check if native metadata API is available by testing for multiple methods
 if (typeof Reflect.defineMetadata !== 'function' || typeof Reflect.getOwnMetadata !== 'function') {
     const metadataMap = new WeakMap<any, Map<string | symbol, any>>();