@rtpaulino/entity 0.10.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 rtpaulino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @rtpaulino/entity

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+export * from './lib/entity.js';
+export * from './lib/entity-utils.js';
+export * from './lib/types.js';
+export * from './lib/property.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAE1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+import 'reflect-metadata';
+export * from './lib/entity.js';
+export * from './lib/entity-utils.js';
+export * from './lib/types.js';
+export * from './lib/property.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import 'reflect-metadata';\n\nexport * from './lib/entity.js';\nexport * from './lib/entity-utils.js';\nexport * from './lib/types.js';\nexport * from './lib/property.js';\n"],"names":[],"mappings":"AAAA,OAAO,mBAAmB;AAE1B,cAAc,kBAAkB;AAChC,cAAc,wBAAwB;AACtC,cAAc,iBAAiB;AAC/B,cAAc,oBAAoB"}

package/dist/lib/entity-utils.d.ts

@@ -0,0 +1,35 @@
+import { PropertyOptions } from './types.js';
+export declare class EntityUtils {
+    /**
+     * Checks if a given object is an instance of a class decorated with @Entity()
+     * or if the provided value is an entity class itself
+     *
+     * @param obj - The object or class to check
+     * @returns true if the object is an entity instance or entity class, false otherwise
+     *
+     * @example
+     * ```typescript
+     * @Entity()
+     * class User {
+     *   name: string;
+     * }
+     *
+     * const user = new User();
+     * console.log(EntityUtils.isEntity(user)); // true
+     * console.log(EntityUtils.isEntity(User)); // true
+     * console.log(EntityUtils.isEntity({})); // false
+     * ```
+     */
+    static isEntity(obj: unknown): obj is object;
+    static sameEntity(a: object, b: object): boolean;
+    static getPropertyKeys(target: object): string[];
+    static getPropertyOptions(target: object, propertyKey: string): PropertyOptions | undefined;
+    static equals(a: unknown, b: unknown): boolean;
+    static diff<T extends object>(oldEntity: T, newEntity: T): {
+        property: string;
+        oldValue: unknown;
+        newValue: unknown;
+    }[];
+    static changes<T extends object>(oldEntity: T, newEntity: T): Partial<T>;
+}
+//# sourceMappingURL=entity-utils.d.ts.map

package/dist/lib/entity-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-utils.d.ts","sourceRoot":"","sources":["../../src/lib/entity-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,eAAe,EAChB,MAAM,YAAY,CAAC;AAGpB,qBAAa,WAAW;IACtB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM;IAmB5C,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAQhD,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAoChD,MAAM,CAAC,kBAAkB,CACvB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,eAAe,GAAG,SAAS;IA8B9B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO;IAe9C,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,EAC1B,SAAS,EAAE,CAAC,EACZ,SAAS,EAAE,CAAC,GACX;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,EAAE;IA4B/D,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAYzE"}

package/dist/lib/entity-utils.js

@@ -0,0 +1,140 @@
+import { ENTITY_METADATA_KEY, PROPERTY_METADATA_KEY, PROPERTY_OPTIONS_METADATA_KEY } from './types.js';
+import { isEqualWith } from 'lodash-es';
+export class EntityUtils {
+    /**
+   * Checks if a given object is an instance of a class decorated with @Entity()
+   * or if the provided value is an entity class itself
+   *
+   * @param obj - The object or class to check
+   * @returns true if the object is an entity instance or entity class, false otherwise
+   *
+   * @example
+   * ```typescript
+   * @Entity()
+   * class User {
+   *   name: string;
+   * }
+   *
+   * const user = new User();
+   * console.log(EntityUtils.isEntity(user)); // true
+   * console.log(EntityUtils.isEntity(User)); // true
+   * console.log(EntityUtils.isEntity({})); // false
+   * ```
+   */ static isEntity(obj) {
+        if (obj == null) {
+            return false;
+        }
+        // Check if obj is a constructor function (class)
+        if (typeof obj === 'function') {
+            return Reflect.hasMetadata(ENTITY_METADATA_KEY, obj);
+        }
+        // Check if obj is an object instance
+        if (typeof obj !== 'object' || Array.isArray(obj)) {
+            return false;
+        }
+        const constructor = Object.getPrototypeOf(obj).constructor;
+        return Reflect.hasMetadata(ENTITY_METADATA_KEY, constructor);
+    }
+    static sameEntity(a, b) {
+        if (!this.isEntity(a) || !this.isEntity(b)) {
+            return false;
+        }
+        return Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
+    }
+    static getPropertyKeys(target) {
+        // Determine if we're dealing with a prototype or an instance
+        let currentProto;
+        // Check if target is a prototype by checking if it has a constructor property
+        // and if target === target.constructor.prototype
+        if (target.constructor && target === target.constructor.prototype) {
+            // target is already a prototype
+            currentProto = target;
+        } else {
+            // target is an instance, get its prototype
+            currentProto = Object.getPrototypeOf(target);
+        }
+        const keys = [];
+        const seen = new Set();
+        // Walk the prototype chain to collect all inherited properties
+        while(currentProto && currentProto !== Object.prototype){
+            // Use getOwnMetadata to only get metadata directly on this prototype
+            const protoKeys = Reflect.getOwnMetadata(PROPERTY_METADATA_KEY, currentProto) || [];
+            for (const key of protoKeys){
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    keys.push(key);
+                }
+            }
+            currentProto = Object.getPrototypeOf(currentProto);
+        }
+        return keys;
+    }
+    static getPropertyOptions(target, propertyKey) {
+        // Determine if we're dealing with a prototype or an instance
+        let currentProto;
+        // Check if target is a prototype by checking if it has a constructor property
+        // and if target === target.constructor.prototype
+        if (target.constructor && target === target.constructor.prototype) {
+            // target is already a prototype
+            currentProto = target;
+        } else {
+            // target is an instance, get its prototype
+            currentProto = Object.getPrototypeOf(target);
+        }
+        // Walk the prototype chain to find the property options
+        while(currentProto && currentProto !== Object.prototype){
+            const protoOptions = Reflect.getOwnMetadata(PROPERTY_OPTIONS_METADATA_KEY, currentProto) || {};
+            if (protoOptions[propertyKey]) {
+                return protoOptions[propertyKey];
+            }
+            currentProto = Object.getPrototypeOf(currentProto);
+        }
+        return undefined;
+    }
+    static equals(a, b) {
+        return isEqualWith(a, b, (val1, val2)=>{
+            if (this.isEntity(val1)) {
+                if (!this.sameEntity(val1, val2)) {
+                    return false;
+                }
+                const diff = this.diff(val1, val2);
+                return diff.length === 0;
+            }
+            return undefined;
+        });
+    }
+    static diff(oldEntity, newEntity) {
+        if (!this.sameEntity(oldEntity, newEntity)) {
+            throw new Error('Entities must be of the same type to compute diff');
+        }
+        const diffs = [];
+        const keys = this.getPropertyKeys(oldEntity);
+        for (const key of keys){
+            const oldValue = oldEntity[key];
+            const newValue = newEntity[key];
+            // Check if there's a custom equals function for this property
+            const propertyOptions = this.getPropertyOptions(oldEntity, key);
+            const areEqual = propertyOptions?.equals ? propertyOptions.equals(oldValue, newValue) : this.equals(oldValue, newValue);
+            if (!areEqual) {
+                diffs.push({
+                    property: key,
+                    oldValue,
+                    newValue
+                });
+            }
+        }
+        return diffs;
+    }
+    static changes(oldEntity, newEntity) {
+        if (!this.sameEntity(oldEntity, newEntity)) {
+            throw new Error('Entities must be of the same type to compute changes');
+        }
+        const diff = this.diff(oldEntity, newEntity);
+        return diff.reduce((acc, { property, newValue })=>{
+            acc[property] = newValue;
+            return acc;
+        }, {});
+    }
+}
+
+//# sourceMappingURL=entity-utils.js.map

package/dist/lib/entity-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/entity-utils.ts"],"sourcesContent":["import {\n  ENTITY_METADATA_KEY,\n  PROPERTY_METADATA_KEY,\n  PROPERTY_OPTIONS_METADATA_KEY,\n  PropertyOptions,\n} from './types.js';\nimport { isEqualWith } from 'lodash-es';\n\nexport class EntityUtils {\n  /**\n   * Checks if a given object is an instance of a class decorated with @Entity()\n   * or if the provided value is an entity class itself\n   *\n   * @param obj - The object or class to check\n   * @returns true if the object is an entity instance or entity class, false otherwise\n   *\n   * @example\n   * ```typescript\n   * @Entity()\n   * class User {\n   *   name: string;\n   * }\n   *\n   * const user = new User();\n   * console.log(EntityUtils.isEntity(user)); // true\n   * console.log(EntityUtils.isEntity(User)); // true\n   * console.log(EntityUtils.isEntity({})); // false\n   * ```\n   */\n  static isEntity(obj: unknown): obj is object {\n    if (obj == null) {\n      return false;\n    }\n\n    // Check if obj is a constructor function (class)\n    if (typeof obj === 'function') {\n      return Reflect.hasMetadata(ENTITY_METADATA_KEY, obj);\n    }\n\n    // Check if obj is an object instance\n    if (typeof obj !== 'object' || Array.isArray(obj)) {\n      return false;\n    }\n\n    const constructor = Object.getPrototypeOf(obj).constructor;\n    return Reflect.hasMetadata(ENTITY_METADATA_KEY, constructor);\n  }\n\n  static sameEntity(a: object, b: object): boolean {\n    if (!this.isEntity(a) || !this.isEntity(b)) {\n      return false;\n    }\n\n    return Object.getPrototypeOf(a) === Object.getPrototypeOf(b);\n  }\n\n  static getPropertyKeys(target: object): string[] {\n    // Determine if we're dealing with a prototype or an instance\n    let currentProto: any;\n\n    // Check if target is a prototype by checking if it has a constructor property\n    // and if target === target.constructor.prototype\n    if (target.constructor && target === target.constructor.prototype) {\n      // target is already a prototype\n      currentProto = target;\n    } else {\n      // target is an instance, get its prototype\n      currentProto = Object.getPrototypeOf(target);\n    }\n\n    const keys: string[] = [];\n    const seen = new Set<string>();\n\n    // Walk the prototype chain to collect all inherited properties\n    while (currentProto && currentProto !== Object.prototype) {\n      // Use getOwnMetadata to only get metadata directly on this prototype\n      const protoKeys: string[] =\n        Reflect.getOwnMetadata(PROPERTY_METADATA_KEY, currentProto) || [];\n\n      for (const key of protoKeys) {\n        if (!seen.has(key)) {\n          seen.add(key);\n          keys.push(key);\n        }\n      }\n\n      currentProto = Object.getPrototypeOf(currentProto);\n    }\n\n    return keys;\n  }\n\n  static getPropertyOptions(\n    target: object,\n    propertyKey: string,\n  ): PropertyOptions | undefined {\n    // Determine if we're dealing with a prototype or an instance\n    let currentProto: any;\n\n    // Check if target is a prototype by checking if it has a constructor property\n    // and if target === target.constructor.prototype\n    if (target.constructor && target === target.constructor.prototype) {\n      // target is already a prototype\n      currentProto = target;\n    } else {\n      // target is an instance, get its prototype\n      currentProto = Object.getPrototypeOf(target);\n    }\n\n    // Walk the prototype chain to find the property options\n    while (currentProto && currentProto !== Object.prototype) {\n      const protoOptions: Record<string, PropertyOptions> =\n        Reflect.getOwnMetadata(PROPERTY_OPTIONS_METADATA_KEY, currentProto) ||\n        {};\n\n      if (protoOptions[propertyKey]) {\n        return protoOptions[propertyKey];\n      }\n\n      currentProto = Object.getPrototypeOf(currentProto);\n    }\n\n    return undefined;\n  }\n\n  static equals(a: unknown, b: unknown): boolean {\n    return isEqualWith(a, b, (val1, val2) => {\n      if (this.isEntity(val1)) {\n        if (!this.sameEntity(val1, val2)) {\n          return false;\n        }\n\n        const diff = this.diff(val1, val2);\n\n        return diff.length === 0;\n      }\n      return undefined;\n    });\n  }\n\n  static diff<T extends object>(\n    oldEntity: T,\n    newEntity: T,\n  ): { property: string; oldValue: unknown; newValue: unknown }[] {\n    if (!this.sameEntity(oldEntity, newEntity)) {\n      throw new Error('Entities must be of the same type to compute diff');\n    }\n\n    const diffs: { property: string; oldValue: unknown; newValue: unknown }[] =\n      [];\n\n    const keys = this.getPropertyKeys(oldEntity);\n\n    for (const key of keys) {\n      const oldValue = (oldEntity as any)[key];\n      const newValue = (newEntity as any)[key];\n\n      // Check if there's a custom equals function for this property\n      const propertyOptions = this.getPropertyOptions(oldEntity, key);\n      const areEqual = propertyOptions?.equals\n        ? propertyOptions.equals(oldValue, newValue)\n        : this.equals(oldValue, newValue);\n\n      if (!areEqual) {\n        diffs.push({ property: key, oldValue, newValue });\n      }\n    }\n\n    return diffs;\n  }\n\n  static changes<T extends object>(oldEntity: T, newEntity: T): Partial<T> {\n    if (!this.sameEntity(oldEntity, newEntity)) {\n      throw new Error('Entities must be of the same type to compute changes');\n    }\n\n    const diff = this.diff(oldEntity, newEntity);\n\n    return diff.reduce((acc, { property, newValue }) => {\n      (acc as any)[property] = newValue;\n      return acc;\n    }, {} as Partial<T>);\n  }\n}\n"],"names":["ENTITY_METADATA_KEY","PROPERTY_METADATA_KEY","PROPERTY_OPTIONS_METADATA_KEY","isEqualWith","EntityUtils","isEntity","obj","Reflect","hasMetadata","Array","isArray","constructor","Object","getPrototypeOf","sameEntity","a","b","getPropertyKeys","target","currentProto","prototype","keys","seen","Set","protoKeys","getOwnMetadata","key","has","add","push","getPropertyOptions","propertyKey","protoOptions","undefined","equals","val1","val2","diff","length","oldEntity","newEntity","Error","diffs","oldValue","newValue","propertyOptions","areEqual","property","changes","reduce","acc"],"mappings":"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"}

package/dist/lib/entity.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Decorator that marks a class as an Entity.
+ * This allows us to identify entity instances later.
+ *
+ * @example
+ * ```typescript
+ * @Entity()
+ * class User {
+ *   name: string;
+ * }
+ * ```
+ */
+export declare function Entity(): ClassDecorator;
+//# sourceMappingURL=entity.d.ts.map

package/dist/lib/entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../src/lib/entity.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,IAAI,cAAc,CAMvC"}

package/dist/lib/entity.js

@@ -0,0 +1,21 @@
+import { ENTITY_METADATA_KEY } from './types.js';
+/**
+ * Decorator that marks a class as an Entity.
+ * This allows us to identify entity instances later.
+ *
+ * @example
+ * ```typescript
+ * @Entity()
+ * class User {
+ *   name: string;
+ * }
+ * ```
+ */ export function Entity() {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return function(target) {
+        // Store metadata on the class constructor
+        Reflect.defineMetadata(ENTITY_METADATA_KEY, true, target);
+    };
+}
+
+//# sourceMappingURL=entity.js.map

package/dist/lib/entity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/entity.ts"],"sourcesContent":["import { ENTITY_METADATA_KEY } from './types.js';\n\n/**\n * Decorator that marks a class as an Entity.\n * This allows us to identify entity instances later.\n *\n * @example\n * ```typescript\n * @Entity()\n * class User {\n *   name: string;\n * }\n * ```\n */\nexport function Entity(): ClassDecorator {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  return function (target: Function) {\n    // Store metadata on the class constructor\n    Reflect.defineMetadata(ENTITY_METADATA_KEY, true, target);\n  };\n}\n"],"names":["ENTITY_METADATA_KEY","Entity","target","Reflect","defineMetadata"],"mappings":"AAAA,SAASA,mBAAmB,QAAQ,aAAa;AAEjD;;;;;;;;;;;CAWC,GACD,OAAO,SAASC;IACd,sEAAsE;IACtE,OAAO,SAAUC,MAAgB;QAC/B,0CAA0C;QAC1CC,QAAQC,cAAc,CAACJ,qBAAqB,MAAME;IACpD;AACF"}

package/dist/lib/property.d.ts

@@ -0,0 +1,21 @@
+import { PropertyOptions } from './types.js';
+/**
+ * Property decorator that marks class properties with metadata.
+ * This decorator can be used to identify and track properties within classes.
+ *
+ * @param options - Optional configuration for the property
+ *
+ * @example
+ * class User {
+ *   @Property()
+ *   name: string;
+ *
+ *   @Property({ equals: (a, b) => a.toLowerCase() === b.toLowerCase() })
+ *   email: string;
+ *
+ *   @Property()
+ *   age: number;
+ * }
+ */
+export declare function Property<T = any>(options?: PropertyOptions<T>): PropertyDecorator;
+//# sourceMappingURL=property.d.ts.map

package/dist/lib/property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.d.ts","sourceRoot":"","sources":["../../src/lib/property.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAChB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,GAAG,EAC9B,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,GAC3B,iBAAiB,CAiCnB"}

package/dist/lib/property.js

@@ -0,0 +1,42 @@
+import { PROPERTY_METADATA_KEY, PROPERTY_OPTIONS_METADATA_KEY } from './types.js';
+/**
+ * Property decorator that marks class properties with metadata.
+ * This decorator can be used to identify and track properties within classes.
+ *
+ * @param options - Optional configuration for the property
+ *
+ * @example
+ * class User {
+ *   @Property()
+ *   name: string;
+ *
+ *   @Property({ equals: (a, b) => a.toLowerCase() === b.toLowerCase() })
+ *   email: string;
+ *
+ *   @Property()
+ *   age: number;
+ * }
+ */ export function Property(options) {
+    return (target, propertyKey)=>{
+        // Only support string property keys
+        if (typeof propertyKey !== 'string') {
+            return;
+        }
+        // Get existing metadata from own property only (not from prototype chain)
+        const existingProperties = Reflect.getOwnMetadata(PROPERTY_METADATA_KEY, target) || [];
+        // Add this property if not already tracked
+        if (!existingProperties.includes(propertyKey)) {
+            existingProperties.push(propertyKey);
+        }
+        // Store updated metadata on the target itself
+        Reflect.defineMetadata(PROPERTY_METADATA_KEY, existingProperties, target);
+        // Store property options if provided
+        if (options) {
+            const existingOptions = Reflect.getOwnMetadata(PROPERTY_OPTIONS_METADATA_KEY, target) || {};
+            existingOptions[propertyKey] = options;
+            Reflect.defineMetadata(PROPERTY_OPTIONS_METADATA_KEY, existingOptions, target);
+        }
+    };
+}
+
+//# sourceMappingURL=property.js.map

package/dist/lib/property.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/property.ts"],"sourcesContent":["import {\n  PROPERTY_METADATA_KEY,\n  PROPERTY_OPTIONS_METADATA_KEY,\n  PropertyOptions,\n} from './types.js';\n\n/**\n * Property decorator that marks class properties with metadata.\n * This decorator can be used to identify and track properties within classes.\n *\n * @param options - Optional configuration for the property\n *\n * @example\n * class User {\n *   @Property()\n *   name: string;\n *\n *   @Property({ equals: (a, b) => a.toLowerCase() === b.toLowerCase() })\n *   email: string;\n *\n *   @Property()\n *   age: number;\n * }\n */\nexport function Property<T = any>(\n  options?: PropertyOptions<T>,\n): PropertyDecorator {\n  return (target: object, propertyKey: string | symbol): void => {\n    // Only support string property keys\n    if (typeof propertyKey !== 'string') {\n      return;\n    }\n\n    // Get existing metadata from own property only (not from prototype chain)\n    const existingProperties: string[] =\n      Reflect.getOwnMetadata(PROPERTY_METADATA_KEY, target) || [];\n\n    // Add this property if not already tracked\n    if (!existingProperties.includes(propertyKey)) {\n      existingProperties.push(propertyKey);\n    }\n\n    // Store updated metadata on the target itself\n    Reflect.defineMetadata(PROPERTY_METADATA_KEY, existingProperties, target);\n\n    // Store property options if provided\n    if (options) {\n      const existingOptions: Record<string, PropertyOptions> =\n        Reflect.getOwnMetadata(PROPERTY_OPTIONS_METADATA_KEY, target) || {};\n\n      existingOptions[propertyKey] = options;\n\n      Reflect.defineMetadata(\n        PROPERTY_OPTIONS_METADATA_KEY,\n        existingOptions,\n        target,\n      );\n    }\n  };\n}\n"],"names":["PROPERTY_METADATA_KEY","PROPERTY_OPTIONS_METADATA_KEY","Property","options","target","propertyKey","existingProperties","Reflect","getOwnMetadata","includes","push","defineMetadata","existingOptions"],"mappings":"AAAA,SACEA,qBAAqB,EACrBC,6BAA6B,QAExB,aAAa;AAEpB;;;;;;;;;;;;;;;;;CAiBC,GACD,OAAO,SAASC,SACdC,OAA4B;IAE5B,OAAO,CAACC,QAAgBC;QACtB,oCAAoC;QACpC,IAAI,OAAOA,gBAAgB,UAAU;YACnC;QACF;QAEA,0EAA0E;QAC1E,MAAMC,qBACJC,QAAQC,cAAc,CAACR,uBAAuBI,WAAW,EAAE;QAE7D,2CAA2C;QAC3C,IAAI,CAACE,mBAAmBG,QAAQ,CAACJ,cAAc;YAC7CC,mBAAmBI,IAAI,CAACL;QAC1B;QAEA,8CAA8C;QAC9CE,QAAQI,cAAc,CAACX,uBAAuBM,oBAAoBF;QAElE,qCAAqC;QACrC,IAAID,SAAS;YACX,MAAMS,kBACJL,QAAQC,cAAc,CAACP,+BAA+BG,WAAW,CAAC;YAEpEQ,eAAe,CAACP,YAAY,GAAGF;YAE/BI,QAAQI,cAAc,CACpBV,+BACAW,iBACAR;QAEJ;IACF;AACF"}

package/dist/lib/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Metadata key used to store property information
+ */
+export declare const PROPERTY_METADATA_KEY: unique symbol;
+/**
+ * Metadata key used to store property options
+ */
+export declare const PROPERTY_OPTIONS_METADATA_KEY: unique symbol;
+/**
+ * Metadata key used to store entity information
+ */
+export declare const ENTITY_METADATA_KEY: unique symbol;
+/**
+ * Options for the Property decorator
+ */
+export interface PropertyOptions<T = any> {
+    /**
+     * Custom equality comparison function for this property
+     * @param a - First value to compare
+     * @param b - Second value to compare
+     * @returns true if values are equal, false otherwise
+     */
+    equals?: (a: T, b: T) => boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,qBAAqB,eAA8B,CAAC;AAEjE;;GAEG;AACH,eAAO,MAAM,6BAA6B,eAEzC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,eAA4B,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,GAAG;IACtC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CAClC"}

package/dist/lib/types.js

@@ -0,0 +1,11 @@
+/**
+ * Metadata key used to store property information
+ */ export const PROPERTY_METADATA_KEY = Symbol('property:metadata');
+/**
+ * Metadata key used to store property options
+ */ export const PROPERTY_OPTIONS_METADATA_KEY = Symbol('property:options:metadata');
+/**
+ * Metadata key used to store entity information
+ */ export const ENTITY_METADATA_KEY = Symbol('entity:metadata');
+
+//# sourceMappingURL=types.js.map

package/dist/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/types.ts"],"sourcesContent":["/**\n * Metadata key used to store property information\n */\nexport const PROPERTY_METADATA_KEY = Symbol('property:metadata');\n\n/**\n * Metadata key used to store property options\n */\nexport const PROPERTY_OPTIONS_METADATA_KEY = Symbol(\n  'property:options:metadata',\n);\n\n/**\n * Metadata key used to store entity information\n */\nexport const ENTITY_METADATA_KEY = Symbol('entity:metadata');\n\n/**\n * Options for the Property decorator\n */\nexport interface PropertyOptions<T = any> {\n  /**\n   * Custom equality comparison function for this property\n   * @param a - First value to compare\n   * @param b - Second value to compare\n   * @returns true if values are equal, false otherwise\n   */\n  equals?: (a: T, b: T) => boolean;\n}\n"],"names":["PROPERTY_METADATA_KEY","Symbol","PROPERTY_OPTIONS_METADATA_KEY","ENTITY_METADATA_KEY"],"mappings":"AAAA;;CAEC,GACD,OAAO,MAAMA,wBAAwBC,OAAO,qBAAqB;AAEjE;;CAEC,GACD,OAAO,MAAMC,gCAAgCD,OAC3C,6BACA;AAEF;;CAEC,GACD,OAAO,MAAME,sBAAsBF,OAAO,mBAAmB"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@rtpaulino/entity",
+  "version": "0.10.13",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@rtpaulino/libs": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "tags": [
+      "scope:entity"
+    ],
+    "sourceRoot": "packages/entity/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "dependsOn": [
+          "typecheck"
+        ],
+        "options": {
+          "outputPath": "packages/entity/dist",
+          "main": "packages/entity/src/index.ts",
+          "tsConfig": "packages/entity/tsconfig.lib.json",
+          "skipTypeCheck": true,
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@rtpaulino/core": "^0.10.4",
+    "@swc/helpers": "~0.5.18",
+    "lodash-es": "^4.17.22"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12"
+  },
+  "peerDependencies": {
+    "reflect-metadata": "^0.2.2"
+  }
+}