leoric 2.15.0-alpha.3 → 2.15.0-beta.1

package/Readme.md

@@ -13,19 +13,19 @@ Leoric is an object-relational mapping library for Node.js, which is heavily inf
 Assume the tables of posts, users, and comments were setup already. We may declare the models as classes by extending from the base class `Bone` of Leoric. After the models are connected to the database, the columns of the tables are mapped as attributes, the associations are setup, feel free to start querying.
 
 ```js
-import { Bone, connect } from 'leoric'
+import Realm, { Bone } from 'leoric'
 
-// define model
-class Post extends Bone {
+const realm = new Realm({ host: 'example.com' })
+const Post = realm.define(class Post extends Bone {
   static initialize() {
     this.belongsTo('author', { Model: 'User' })
     this.hasMany('comments')
   }
-}
+})
 
 async function main() {
   // connect models to database
-  await connect({ host: 'example.com', models: [ Post ], /* among other options */ })
+  await realm.connect()
 
   // CRUD
   await Post.create({ title: 'New Post' })
@@ -47,15 +47,15 @@ If table structures were intended to be maintained in the models, Leoric can be
 ```js
 import Realm, { Bone, DataTypes } from 'leoric';
 const { BIGINT, STRING } = DataTypes;
-class Post extends Bone {
+const realm = new Realm();
+const Post = realm.define(class Post extends Bone {
   static attributes = {
     id: { type: BIGINT, primaryKey: true },
     email: { type: STRING, allowNull: false },
     nickname: { type: STRING, allowNull: false },
   }
-}
+});
 
-const realm = new Realm({ models: [ Post ] });
 await realm.sync();
 ```
 
@@ -83,19 +83,19 @@ import User from './user';
 
 export default class Post extends Bone {
   @Column({ autoIncrement: true })
-  id: bigint;
+  declare id: bigint;
 
   @Column(TEXT)
-  content: string;
+  declare content: string;
 
   @Column()
-  description: string;
+  declare description: string;
 
   @Column()
-  userId: bigint;
+  declare userId: bigint;
 
   @BelongsTo()
-  user: User;
+  declare user: User;
 }
 ```
 

package/dist/abstract_bone.d.ts

@@ -24,16 +24,26 @@ export interface InitOptions {
 export declare const columnAttributesKey: unique symbol;
 export declare const synchronizedKey: unique symbol;
 export declare const tableKey: unique symbol;
+export declare const hasLoadedAttributesKey: unique symbol;
+export declare class LeoricModelDefinitionError extends Error {
+    constructor(modelName: string);
+}
+export declare class LeoricClassFieldError extends Error {
+    modelName: string;
+    attributeName: string;
+    constructor(modelName: string, attributeName: string);
+}
 export declare class AbstractBone {
-    #private;
     static DataTypes: typeof DataTypes;
     [key: string]: any;
+    [key: symbol]: any;
     isNewRecord: boolean;
     static [columnAttributesKey]: {
         [key: string]: Attribute;
     } | null;
     static [synchronizedKey]: boolean;
     static [tableKey]: string;
+    static [hasLoadedAttributesKey]: boolean;
     static get synchronized(): boolean;
     static set synchronized(value: boolean);
     /**
@@ -199,6 +209,7 @@ export declare class AbstractBone {
     static select<T extends typeof AbstractBone>(this: T, ...names: Array<BoneColumns<T>> | string[]): Spell<T>;
     static select<T extends typeof AbstractBone>(this: T, ...names: string[]): Spell<T>;
     static select<T extends typeof AbstractBone>(this: T, ...names: Raw[]): Spell<T>;
+    static select<T extends typeof AbstractBone>(this: T, ...names: Array<string | Raw>): Spell<T>;
     static select<T extends typeof AbstractBone>(this: T, filter: (name: string) => boolean): Spell<T>;
     /**
      * JOIN arbitrary models with given ON conditions
@@ -317,6 +328,8 @@ export declare class AbstractBone {
     attribute<T, Key extends keyof T, U extends T[Key]>(this: T, name: Key): U extends Literal ? U : Literal;
     attribute<T, Key extends keyof Values<T>>(this: T, name: Key, value: Literal): this;
     attribute<T, Key extends keyof T>(this: T, name: Key, value: Literal): this;
+    attribute(name: string): Literal;
+    attribute(name: string, value: Literal): this;
     /**
      * instance.hasAttribute(name)
      * @param name
@@ -437,7 +450,9 @@ export declare class AbstractBone {
      */
     reload(): Promise<this>;
     /**
-     * Protected clone
+     * Protected clone — replaces internal state with merged data from target.
+     * Note: `this` here is the proxy (all method calls go through proxy). The proxy
+     * has no `set` trap, so Symbol-key assignments delegate to the underlying target.
      */
     _clone(target: any): void;
     /**
@@ -479,3 +494,8 @@ export declare class AbstractBone {
      */
     toObject(): any;
 }
+export declare function markModelClassReady<T extends typeof AbstractBone>(Model: T): T;
+export declare function isModelClassReady(Model: typeof AbstractBone): boolean;
+export declare function markModelClassFieldsChecked<T extends typeof AbstractBone>(Model: T): T;
+export declare function hasCheckedModelClassFields(Model: typeof AbstractBone): boolean;
+export declare function assertModelClassFields(instance: AbstractBone): void;

package/dist/abstract_bone.js

@@ -1,5 +1,4 @@
-var _AbstractBone_raw, _AbstractBone_rawSaved, _AbstractBone_rawUnset, _AbstractBone_rawPrevious;
-import { __awaiter, __classPrivateFieldGet, __classPrivateFieldSet, __rest } from "tslib";
+import { __awaiter, __rest } from "tslib";
 import util, { isDeepStrictEqual } from 'util';
 import Debug from 'debug';
 import pluralize from 'pluralize';
@@ -17,6 +16,36 @@ export const columnAttributesKey = Symbol('leoric#columnAttributes');
 export const synchronizedKey = Symbol('leoric#synchronized');
 export const tableKey = Symbol('leoric#table');
 const debug = Debug('leoric');
+// Module-private Symbol keys for internal instance state. The properties are initialized
+// with enumerable: false so they are invisible to assert.deepStrictEqual (which only compares
+// own enumerable Symbol keys), matching the behavior of the original private fields.
+const RAW = Symbol('leoric#raw');
+const RAW_SAVED = Symbol('leoric#rawSaved');
+const RAW_UNSET = Symbol('leoric#rawUnset');
+const RAW_PREVIOUS = Symbol('leoric#rawPrevious');
+const MODEL_READY = Symbol('leoric#modelReady');
+const MODEL_CLASS_FIELDS_CHECKED = Symbol('leoric#modelClassFieldsChecked');
+// Short accessors for internal state
+function $raw(self) { return self[RAW]; }
+function $rawSaved(self) { return self[RAW_SAVED]; }
+function $rawUnset(self) { return self[RAW_UNSET]; }
+function $rawPrevious(self) { return self[RAW_PREVIOUS]; }
+// Kept as a compatibility export for adapters and consumers that reference the symbol.
+export const hasLoadedAttributesKey = Symbol('leoric#hasLoadedAttributes');
+export class LeoricModelDefinitionError extends Error {
+    constructor(modelName) {
+        super(`${modelName} is not a registered Leoric model. Add it to the realm models, decorate it with @Model(), or define it through realm.define().`);
+        this.name = 'LeoricModelDefinitionError';
+    }
+}
+export class LeoricClassFieldError extends Error {
+    constructor(modelName, attributeName) {
+        super(`${modelName}.${attributeName} is emitted as an ES class field and shadows Leoric's attribute accessor. Add \`declare\`, decorate ${modelName} with @Model(), or define it through realm.define(${modelName}, attributes).`);
+        this.name = 'LeoricClassFieldError';
+        this.modelName = modelName;
+        this.attributeName = attributeName;
+    }
+}
 export class AbstractBone {
     static get synchronized() {
         return this[synchronizedKey];
@@ -44,12 +73,17 @@ export class AbstractBone {
         return this[tableKey];
     }
     constructor(values, opts = {}) {
-        // private state
-        _AbstractBone_raw.set(this, {});
-        _AbstractBone_rawSaved.set(this, {});
-        _AbstractBone_rawUnset.set(this, new Set());
-        _AbstractBone_rawPrevious.set(this, {});
         this.isNewRecord = true;
+        const Model = new.target;
+        if (Model !== AbstractBone && !isModelClassReady(Model)) {
+            throw new LeoricModelDefinitionError(Model.name);
+        }
+        // Initialize internal Symbol-keyed properties as non-enumerable so they are
+        // invisible to assert.deepStrictEqual (which only compares own enumerable Symbol keys).
+        Object.defineProperty(this, RAW, { value: {}, writable: true, configurable: true, enumerable: false });
+        Object.defineProperty(this, RAW_SAVED, { value: {}, writable: true, configurable: true, enumerable: false });
+        Object.defineProperty(this, RAW_UNSET, { value: new Set(), writable: true, configurable: true, enumerable: false });
+        Object.defineProperty(this, RAW_PREVIOUS, { value: {}, writable: true, configurable: true, enumerable: false });
         Object.defineProperty(this, 'isNewRecord', {
             value: opts.isNewRecord !== undefined ? opts.isNewRecord : true,
             configurable: true,
@@ -190,6 +224,7 @@ export class AbstractBone {
             set(value) {
                 return this.attribute(name, value);
             } }, customDescriptor), { enumerable: true, configurable: true }));
+        this[hasLoadedAttributesKey] = true;
     }
     static hasOne(name, options) {
         options = (Object.assign(Object.assign({ className: capitalize(name), foreignKey: camelCase(`${this.name}Id`) }, options), { hasMany: false }));
@@ -236,6 +271,7 @@ export class AbstractBone {
         opts = opts !== null && opts !== void 0 ? opts : {};
         const data = Object.assign({}, values);
         const instance = new this(data);
+        assertModelClassFields(instance);
         return instance.create(Object.assign({}, opts));
     }
     /**
@@ -296,7 +332,11 @@ export class AbstractBone {
             const autoIncrement = attribute.autoIncrement || (attribute.jsType == Number && attribute.primaryKey);
             if (options.validate !== false)
                 records.map(entry => this._validateAttributes(entry));
-            const instances = records.map(entry => new this(entry));
+            const instances = records.map(entry => {
+                const instance = new this(entry);
+                assertModelClassFields(instance);
+                return instance;
+            });
             if (options.individualHooks) {
                 yield Promise.all(instances.map(instance => instance.save(options)));
                 return instances;
@@ -474,6 +514,7 @@ export class AbstractBone {
         if (!options || options.validate !== false) {
             const validateData = copyValues(values);
             const instance = new this(validateData);
+            assertModelClassFields(instance);
             instance._validateAttributes(validateData);
         }
         let spell = new Spell(this, options).$where(conditions).$update(data);
@@ -674,6 +715,7 @@ export class AbstractBone {
         var _a;
         const { attributes, attributeMap } = this;
         const instance = new this();
+        assertModelClassFields(instance);
         const skipCloneValue = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.skipCloneValue) === true;
         for (const columnName in row) {
             const value = row[columnName];
@@ -778,9 +820,10 @@ export class AbstractBone {
             }
         }
         this[columnAttributesKey] = null;
+        markModelClassReady(this);
     }
     static from(table) {
-        return new Spell(this).$from(table);
+        return new Spell(this).$from(table).later(Collection.init);
     }
     /**
      * Restore soft-deleted rows by clearing deletedAt.
@@ -799,33 +842,33 @@ export class AbstractBone {
     // raw accessors
     getRaw(key) {
         if (key)
-            return __classPrivateFieldGet(this, _AbstractBone_raw, "f")[key];
-        return __classPrivateFieldGet(this, _AbstractBone_raw, "f");
+            return $raw(this)[key];
+        return $raw(this);
     }
     getRawSaved(key) {
         if (key)
-            return __classPrivateFieldGet(this, _AbstractBone_rawSaved, "f")[key];
-        return __classPrivateFieldGet(this, _AbstractBone_rawSaved, "f");
+            return $rawSaved(this)[key];
+        return $rawSaved(this);
     }
     getRawPrevious(key) {
         if (key)
-            return __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[key];
-        return __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f");
+            return $rawPrevious(this)[key];
+        return $rawPrevious(this);
     }
     _setRaw(...args) {
         const [name, value] = args;
         if (args.length > 1) {
-            __classPrivateFieldGet(this, _AbstractBone_raw, "f")[name] = value;
+            $raw(this)[name] = value;
         }
         else if (args.length === 1 && name !== undefined && typeof name === 'object') {
-            __classPrivateFieldSet(this, _AbstractBone_raw, name, "f");
+            this[RAW] = name;
         }
     }
     _getRawUnset() {
-        return __classPrivateFieldGet(this, _AbstractBone_rawUnset, "f");
+        return $rawUnset(this);
     }
     _setRawSaved(key, value) {
-        __classPrivateFieldGet(this, _AbstractBone_rawSaved, "f")[key] = value;
+        $rawSaved(this)[key] = value;
     }
     /**
      * @example
@@ -838,13 +881,13 @@ export class AbstractBone {
         if (!attribute)
             throw new Error(`${this.constructor.name} has no attribute "${name}"`);
         if (arguments.length > 1) {
-            __classPrivateFieldGet(this, _AbstractBone_raw, "f")[name] = value instanceof Raw ? value : attribute.cast(value);
-            __classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").delete(name);
+            $raw(this)[name] = value instanceof Raw ? value : attribute.cast(value);
+            $rawUnset(this).delete(name);
             return this;
         }
-        if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(name))
+        if ($rawUnset(this).has(name))
             return;
-        const rawValue = __classPrivateFieldGet(this, _AbstractBone_raw, "f")[name];
+        const rawValue = $raw(this)[name];
         return rawValue == null ? null : rawValue;
     }
     /**
@@ -863,7 +906,7 @@ export class AbstractBone {
      * bone.attributeWas('foo')  // => 1
      */
     attributeWas(name) {
-        const value = __classPrivateFieldGet(this, _AbstractBone_rawSaved, "f")[name];
+        const value = $rawSaved(this)[name];
         return value == null ? null : value;
     }
     /**
@@ -873,7 +916,7 @@ export class AbstractBone {
      * bone.attributeChanged('foo')
      */
     attributeChanged(name) {
-        if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(name) || !this.hasAttribute(name))
+        if ($rawUnset(this).has(name) || !this.hasAttribute(name))
             return false;
         const value = this.attribute(name);
         const valueWas = this.attributeWas(name);
@@ -890,7 +933,7 @@ export class AbstractBone {
      */
     changes(name) {
         if (name != null) {
-            if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(name) || !this.hasAttribute(name))
+            if ($rawUnset(this).has(name) || !this.hasAttribute(name))
                 return {};
             const value = this.attribute(name);
             const valueWas = this.attributeWas(name);
@@ -900,7 +943,7 @@ export class AbstractBone {
         }
         const result = {};
         for (const attrKey of Object.keys(this.constructor.attributes)) {
-            if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(attrKey))
+            if ($rawUnset(this).has(attrKey))
                 continue;
             const value = this.attribute(attrKey);
             const valueWas = this.attributeWas(attrKey);
@@ -920,21 +963,21 @@ export class AbstractBone {
     }
     previousChanges(name) {
         if (name != null) {
-            if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(name) || __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[name] === undefined || !this.hasAttribute(name)) {
+            if ($rawUnset(this).has(name) || $rawPrevious(this)[name] === undefined || !this.hasAttribute(name)) {
                 return {};
             }
             const value = this.attribute(name);
-            const valueWas = __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[name] == null ? null : __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[name];
+            const valueWas = $rawPrevious(this)[name] == null ? null : $rawPrevious(this)[name];
             if (isDeepStrictEqual(value, valueWas))
                 return {};
             return { [name]: [valueWas, value] };
         }
         const result = {};
         for (const attrKey of Object.keys(this.constructor.attributes)) {
-            if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(attrKey) || __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[attrKey] === undefined)
+            if ($rawUnset(this).has(attrKey) || $rawPrevious(this)[attrKey] === undefined)
                 continue;
             const value = this.attribute(attrKey);
-            const valueWas = __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[attrKey] == null ? null : __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[attrKey];
+            const valueWas = $rawPrevious(this)[attrKey] == null ? null : $rawPrevious(this)[attrKey];
             if (!isDeepStrictEqual(value, valueWas))
                 result[attrKey] = [valueWas, value];
         }
@@ -958,8 +1001,9 @@ export class AbstractBone {
      */
     _save() {
         return __awaiter(this, arguments, void 0, function* (opts = {}) {
+            assertModelClassFields(this);
             const { primaryKey } = this.constructor;
-            if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(primaryKey))
+            if ($rawUnset(this).has(primaryKey))
                 throw new Error(`unset primary key ${primaryKey}`);
             if (this[primaryKey] == null) {
                 yield this.create(opts);
@@ -989,17 +1033,17 @@ export class AbstractBone {
             const attribute = attributes[name];
             let value;
             try {
-                value = attribute.uncast(__classPrivateFieldGet(this, _AbstractBone_raw, "f")[name]);
+                value = attribute.uncast($raw(this)[name]);
             }
             catch (error) {
                 console.error(error);
-                value = __classPrivateFieldGet(this, _AbstractBone_raw, "f")[name];
+                value = $raw(this)[name];
             }
-            if (__classPrivateFieldGet(this, _AbstractBone_rawSaved, "f")[name] !== undefined)
-                __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[name] = __classPrivateFieldGet(this, _AbstractBone_rawSaved, "f")[name];
-            else if (__classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[name] === undefined && __classPrivateFieldGet(this, _AbstractBone_raw, "f")[name] != null)
-                __classPrivateFieldGet(this, _AbstractBone_rawPrevious, "f")[name] = null;
-            __classPrivateFieldGet(this, _AbstractBone_rawSaved, "f")[name] = attribute.cast(value);
+            if ($rawSaved(this)[name] !== undefined)
+                $rawPrevious(this)[name] = $rawSaved(this)[name];
+            else if ($rawPrevious(this)[name] === undefined && $raw(this)[name] != null)
+                $rawPrevious(this)[name] = null;
+            $rawSaved(this)[name] = attribute.cast(value);
         }
     }
     /**
@@ -1057,6 +1101,7 @@ export class AbstractBone {
      * Internal upsert implementation
      */
     _upsert(opts) {
+        assertModelClassFields(this);
         const data = {};
         const Model = this.constructor;
         const { attributes, primaryKey } = Model;
@@ -1091,6 +1136,7 @@ export class AbstractBone {
      */
     _update(values, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            assertModelClassFields(this);
             const Model = this.constructor;
             const { attributes, primaryKey, shardingKey } = Model;
             const changes = {};
@@ -1195,6 +1241,7 @@ export class AbstractBone {
      * Internal create implementation
      */
     _create(opts = {}) {
+        assertModelClassFields(this);
         const Model = this.constructor;
         const { primaryKey, attributes } = Model;
         const data = {};
@@ -1250,13 +1297,15 @@ export class AbstractBone {
         });
     }
     /**
-     * Protected clone
+     * Protected clone — replaces internal state with merged data from target.
+     * Note: `this` here is the proxy (all method calls go through proxy). The proxy
+     * has no `set` trap, so Symbol-key assignments delegate to the underlying target.
      */
     _clone(target) {
-        __classPrivateFieldSet(this, _AbstractBone_raw, Object.assign({}, this.getRaw(), target.getRaw()), "f");
-        __classPrivateFieldSet(this, _AbstractBone_rawSaved, Object.assign({}, this.getRawSaved(), target.getRawSaved()), "f");
-        __classPrivateFieldSet(this, _AbstractBone_rawPrevious, Object.assign({}, this.getRawPrevious(), target.getRawPrevious()), "f");
-        __classPrivateFieldSet(this, _AbstractBone_rawUnset, target._getRawUnset(), "f");
+        this[RAW] = Object.assign({}, this.getRaw(), target.getRaw());
+        this[RAW_SAVED] = Object.assign({}, this.getRawSaved(), target.getRawSaved());
+        this[RAW_PREVIOUS] = Object.assign({}, this.getRawPrevious(), target.getRawPrevious());
+        this[RAW_UNSET] = target._getRawUnset();
     }
     /**
      * Validate current changes
@@ -1314,13 +1363,13 @@ export class AbstractBone {
      * post.toJSON()  // => { id: 1, ... }
      * @return {Object}
      */
-    [(_AbstractBone_raw = new WeakMap(), _AbstractBone_rawSaved = new WeakMap(), _AbstractBone_rawUnset = new WeakMap(), _AbstractBone_rawPrevious = new WeakMap(), util.inspect.custom)]() {
+    [util.inspect.custom]() {
         return this.constructor.name + ' ' + util.inspect(this.toJSON());
     }
     toJSON() {
         const obj = {};
         for (const key in this) {
-            if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(key))
+            if ($rawUnset(this).has(key))
                 continue;
             if (typeof this[key] !== 'function') {
                 const value = this[key];
@@ -1342,7 +1391,7 @@ export class AbstractBone {
     toObject() {
         const obj = {};
         for (const key in this) {
-            if (__classPrivateFieldGet(this, _AbstractBone_rawUnset, "f").has(key))
+            if ($rawUnset(this).has(key))
                 continue;
             if (typeof this[key] !== 'function') {
                 const value = this[key];
@@ -1357,6 +1406,48 @@ AbstractBone.DataTypes = DataTypes.invokable;
  * The primary key of the model, defaults to `id`.
  */
 AbstractBone.primaryKey = 'id';
+export function markModelClassReady(Model) {
+    if (isModelClassReady(Model))
+        return Model;
+    Object.defineProperty(Model, MODEL_READY, {
+        value: true,
+        configurable: false,
+        enumerable: false,
+        writable: false,
+    });
+    return Model;
+}
+export function isModelClassReady(Model) {
+    return Object.prototype.hasOwnProperty.call(Model, MODEL_READY);
+}
+export function markModelClassFieldsChecked(Model) {
+    if (hasCheckedModelClassFields(Model))
+        return Model;
+    Object.defineProperty(Model, MODEL_CLASS_FIELDS_CHECKED, {
+        value: true,
+        configurable: false,
+        enumerable: false,
+        writable: false,
+    });
+    return Model;
+}
+export function hasCheckedModelClassFields(Model) {
+    return Object.prototype.hasOwnProperty.call(Model, MODEL_CLASS_FIELDS_CHECKED);
+}
+export function assertModelClassFields(instance) {
+    const Model = instance.constructor;
+    if (hasCheckedModelClassFields(Model))
+        return;
+    const { attributes } = Model;
+    if (!attributes)
+        return;
+    for (const name of Object.keys(attributes)) {
+        if (Object.prototype.hasOwnProperty.call(instance, name)) {
+            throw new LeoricClassFieldError(Model.name, name);
+        }
+    }
+    markModelClassFieldsChecked(Model);
+}
 function looseReadonly(props) {
     return Object.keys(props).reduce((result, name) => {
         result[name] = { value: props[name], writable: false, enumerable: false, configurable: true };
@@ -1429,6 +1520,11 @@ function valuesValidate(values, attributes, ctx) {
 function cloneValue(value) {
     if (value instanceof Date && isNaN(value))
         return value;
+    // structuredClone converts Buffer to Uint8Array, breaking isDeepStrictEqual comparisons.
+    // Preserve Buffer type by copying manually.
+    if (Buffer.isBuffer(value))
+        return Buffer.from(value);
+    // eslint-disable-next-line no-undef
     return typeof structuredClone === 'function' ? structuredClone(value) : JSON.parse(JSON.stringify(value));
 }
 Reflect.defineMetadata(IS_LEORIC_BONE, true, AbstractBone);