@rtpaulino/entity 0.23.1 → 0.24.1

package/dist/index.d.ts

@@ -12,4 +12,5 @@ export * from './lib/primitive-deserializers.js';
 export * from './lib/validators.js';
 export * from './lib/zod-property.js';
 export * from './lib/injected-property.js';
+export * from './lib/entity-definition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +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,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC"}
+{"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,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC;AACjD,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC"}

package/dist/index.js

@@ -12,5 +12,6 @@ export * from './lib/primitive-deserializers.js';
 export * from './lib/validators.js';
 export * from './lib/zod-property.js';
 export * from './lib/injected-property.js';
+export * from './lib/entity-definition.js';
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +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/entity-di.js';\nexport * from './lib/entity-registry.js';\nexport * from './lib/types.js';\nexport * from './lib/property.js';\nexport * from './lib/validation-error.js';\nexport * from './lib/problem.js';\nexport * from './lib/validation-utils.js';\nexport * from './lib/primitive-deserializers.js';\nexport * from './lib/validators.js';\nexport * from './lib/zod-property.js';\nexport * from './lib/injected-property.js';\n"],"names":[],"mappings":"AAAA,OAAO,mBAAmB;AAE1B,cAAc,kBAAkB;AAChC,cAAc,wBAAwB;AACtC,cAAc,qBAAqB;AACnC,cAAc,2BAA2B;AACzC,cAAc,iBAAiB;AAC/B,cAAc,oBAAoB;AAClC,cAAc,4BAA4B;AAC1C,cAAc,mBAAmB;AACjC,cAAc,4BAA4B;AAC1C,cAAc,mCAAmC;AACjD,cAAc,sBAAsB;AACpC,cAAc,wBAAwB;AACtC,cAAc,6BAA6B"}
+{"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/entity-di.js';\nexport * from './lib/entity-registry.js';\nexport * from './lib/types.js';\nexport * from './lib/property.js';\nexport * from './lib/validation-error.js';\nexport * from './lib/problem.js';\nexport * from './lib/validation-utils.js';\nexport * from './lib/primitive-deserializers.js';\nexport * from './lib/validators.js';\nexport * from './lib/zod-property.js';\nexport * from './lib/injected-property.js';\nexport * from './lib/entity-definition.js';\n"],"names":[],"mappings":"AAAA,OAAO,mBAAmB;AAE1B,cAAc,kBAAkB;AAChC,cAAc,wBAAwB;AACtC,cAAc,qBAAqB;AACnC,cAAc,2BAA2B;AACzC,cAAc,iBAAiB;AAC/B,cAAc,oBAAoB;AAClC,cAAc,4BAA4B;AAC1C,cAAc,mBAAmB;AACjC,cAAc,4BAA4B;AAC1C,cAAc,mCAAmC;AACjD,cAAc,sBAAsB;AACpC,cAAc,wBAAwB;AACtC,cAAc,6BAA6B;AAC3C,cAAc,6BAA6B"}

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

@@ -0,0 +1,294 @@
+import { PropertyOptions, type AnyCtor } from './types.js';
+import { EntityOptions } from './entity.js';
+import { Problem } from './problem.js';
+import { stringPropertyOptions, enumPropertyOptions, numberPropertyOptions, intPropertyOptions, booleanPropertyOptions, datePropertyOptions, bigIntPropertyOptions, entityPropertyOptions, arrayPropertyOptions, passthroughPropertyOptions, discriminatedEntityPropertyOptions } from './property.js';
+import { zodPropertyOptions } from './zod-property.js';
+/**
+ * Configuration for defining an entity schema
+ */
+export interface EntitySchemaConfig<T = any> {
+    /**
+     * Name for the entity (required for schema-based entities)
+     */
+    name: string;
+    /**
+     * Entity options (collection, stringifiable, etc.)
+     */
+    options?: Omit<EntityOptions, 'name'>;
+    /**
+     * Property definitions - key is property name, value is property options
+     */
+    properties: Record<string, PropertyOptions>;
+    /**
+     * Validator functions that will be attached to the entity class
+     * Each function receives the entity instance and returns problems
+     */
+    validators?: Array<(instance: T) => Problem[] | Promise<Problem[]>>;
+    /**
+     * Whether to register this entity in the EntityRegistry.
+     * For dynamic schemas, defaults to false to prevent memory leaks.
+     * Set to true if you need discriminated entity deserialization.
+     */
+    register?: boolean;
+}
+/**
+ * Wrapper object returned by EntitySchema.define() with EntityUtils methods
+ */
+export interface EntitySchemaWrapper<T> {
+    /**
+     * The generated entity class
+     */
+    readonly entityClass: AnyCtor<T>;
+    /**
+     * Parse data into an entity instance
+     */
+    parse(data: unknown): Promise<T>;
+    /**
+     * Parse data into an entity instance without throwing
+     */
+    safeParse(data: unknown): Promise<{
+        success: true;
+        data: T;
+        problems: Problem[];
+    } | {
+        success: false;
+        data: undefined;
+        problems: Problem[];
+    }>;
+    /**
+     * Parse only present properties without throwing
+     */
+    parsePartial(data: unknown): Promise<Partial<T>>;
+    /**
+     * Parse only present properties without throwing
+     */
+    safeParsePartial(data: unknown): Promise<{
+        success: true;
+        data: Partial<T>;
+        problems: Problem[];
+    } | {
+        success: false;
+        data: undefined;
+        problems: Problem[];
+    }>;
+    /**
+     * Serialize entity instance to plain object
+     */
+    serialize(instance: T): unknown;
+    /**
+     * Update entity instance with new data
+     */
+    update(instance: T, data: unknown): Promise<T>;
+    /**
+     * Update entity instance with new data without throwing
+     */
+    safeUpdate(instance: T, data: unknown): Promise<{
+        success: true;
+        data: T;
+        problems: Problem[];
+    } | {
+        success: false;
+        data: T;
+        problems: Problem[];
+    }>;
+    /**
+     * Validate entity instance
+     */
+    validate(instance: T): Promise<Problem[]>;
+    /**
+     * Check if two instances are equal
+     */
+    equals(a: T, b: T): boolean;
+    /**
+     * Get differences between two instances
+     */
+    diff(a: T, b: T): Record<string, {
+        from: unknown;
+        to: unknown;
+    }>;
+    /**
+     * Get changed values as partial object
+     */
+    getChanges(a: T, b: T): Partial<T>;
+}
+/**
+ * Factory for creating schema-based entities without pre-defining a class
+ */
+export declare class EntitySchema {
+    /**
+     * Define a new entity schema and return a wrapper with EntityUtils methods
+     *
+     * @param config - Schema configuration with name, properties, options, and validators
+     * @returns Wrapper object with parse, serialize, validate, etc. methods
+     *
+     * @example
+     * ```typescript
+     * const UserSchema = EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     name: { type: () => String },
+     *     age: { type: () => Number, optional: true },
+     *     tags: { type: () => String, array: true },
+     *   },
+     *   validators: [
+     *     (user) => user.name.length < 2 ? [{ path: 'name', message: 'Too short' }] : []
+     *   ]
+     * });
+     *
+     * const user = await UserSchema.parse({ name: 'John', age: 30, tags: ['admin'] });
+     * const serialized = UserSchema.serialize(user);
+     * const isValid = (await UserSchema.validate(user)).length === 0;
+     * ```
+     */
+    static define<T extends object = any>(config: EntitySchemaConfig<T>): EntitySchemaWrapper<T>;
+}
+/**
+ * Property definition helpers for EntitySchema
+ * These mirror the decorator-based property helpers but return PropertyOptions objects
+ */
+export declare const EntityProps: {
+    /**
+     * String property with optional validation
+     * @example
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     name: EntityProps.String({ minLength: 2, maxLength: 50 }),
+     *     email: EntityProps.String({ pattern: /^.+@.+\..+$/ }),
+     *   }
+     * })
+     */
+    String: typeof stringPropertyOptions;
+    /**
+     * Enum property (validates string against enum values)
+     * @example
+     * enum Status { Active = 'active', Inactive = 'inactive' }
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     status: EntityProps.Enum(Status),
+     *   }
+     * })
+     */
+    Enum: typeof enumPropertyOptions;
+    /**
+     * Number property with optional min/max validation
+     * @example
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     age: EntityProps.Number({ min: 0, max: 150 }),
+     *     score: EntityProps.Number({ optional: true }),
+     *   }
+     * })
+     */
+    Number: typeof numberPropertyOptions;
+    /**
+     * Integer property (number that must be an integer)
+     * @example
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     age: EntityProps.Int({ min: 0 }),
+     *   }
+     * })
+     */
+    Int: typeof intPropertyOptions;
+    /**
+     * Boolean property
+     * @example
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     isActive: EntityProps.Boolean(),
+     *     emailVerified: EntityProps.Boolean({ optional: true }),
+     *   }
+     * })
+     */
+    Boolean: typeof booleanPropertyOptions;
+    /**
+     * Date property
+     * @example
+     * EntitySchema.define({
+     *   name: 'Event',
+     *   properties: {
+     *     createdAt: EntityProps.Date(),
+     *     scheduledFor: EntityProps.Date({ optional: true }),
+     *   }
+     * })
+     */
+    Date: typeof datePropertyOptions;
+    /**
+     * BigInt property
+     * @example
+     * EntitySchema.define({
+     *   name: 'Transaction',
+     *   properties: {
+     *     amount: EntityProps.BigInt(),
+     *   }
+     * })
+     */
+    BigInt: typeof bigIntPropertyOptions;
+    /**
+     * Entity property (nested entity)
+     * @example
+     * const AddressSchema = EntitySchema.define({ ... });
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     address: EntityProps.Entity(() => AddressSchema.entityClass),
+     *   }
+     * })
+     */
+    Entity: typeof entityPropertyOptions;
+    /**
+     * Array property
+     * @example
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     tags: EntityProps.Array(() => String),
+     *     addresses: EntityProps.Array(() => AddressSchema.entityClass),
+     *   }
+     * })
+     */
+    Array: typeof arrayPropertyOptions;
+    /**
+     * Passthrough property (no deserialization/validation)
+     * @example
+     * EntitySchema.define({
+     *   name: 'Config',
+     *   properties: {
+     *     metadata: EntityProps.Passthrough(),
+     *   }
+     * })
+     */
+    Passthrough: typeof passthroughPropertyOptions;
+    /**
+     * Zod schema property (validates using Zod schema)
+     * @example
+     * import { z } from 'zod';
+     * EntitySchema.define({
+     *   name: 'User',
+     *   properties: {
+     *     data: EntityProps.Zod(z.object({
+     *       name: z.string().min(3),
+     *       age: z.number().int().min(0)
+     *     })),
+     *   }
+     * })
+     */
+    Zod: typeof zodPropertyOptions;
+    /**
+     * Discriminated entity property (for polymorphic entities with discriminator)
+     * @example
+     * EntitySchema.define({
+     *   name: 'Shape',
+     *   properties: {
+     *     shape: EntityProps.DiscriminatedEntity({ discriminatorProperty: 'type' }),
+     *   }
+     * })
+     */
+    DiscriminatedEntity: typeof discriminatedEntityPropertyOptions;
+};
+//# sourceMappingURL=entity-definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity-definition.d.ts","sourceRoot":"","sources":["../../src/lib/entity-definition.ts"],"names":[],"mappings":"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"}

package/dist/lib/entity-definition.js

@@ -0,0 +1,273 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ import { ENTITY_METADATA_KEY, ENTITY_OPTIONS_METADATA_KEY, ENTITY_VALIDATOR_METADATA_KEY, PROPERTY_METADATA_KEY, PROPERTY_OPTIONS_METADATA_KEY } from './types.js';
+import { EntityRegistry } from './entity-registry.js';
+import { EntityUtils } from './entity-utils.js';
+import { stringPropertyOptions, enumPropertyOptions, numberPropertyOptions, intPropertyOptions, booleanPropertyOptions, datePropertyOptions, bigIntPropertyOptions, entityPropertyOptions, arrayPropertyOptions, passthroughPropertyOptions, discriminatedEntityPropertyOptions } from './property.js';
+import { zodPropertyOptions } from './zod-property.js';
+/**
+ * Define entity metadata on an existing class programmatically
+ * This sets the same metadata that @Entity() and @Property() decorators would set
+ *
+ * @param entityClass - The class to define as an entity
+ * @param config - Configuration with properties, options, and validators
+ * @internal
+ */ function defineEntity(entityClass, config) {
+    const entityName = config.name;
+    // 1. Mark as entity
+    Reflect.defineMetadata(ENTITY_METADATA_KEY, true, entityClass);
+    // 2. Set entity options with resolved name
+    const entityOptions = {
+        ...config.options,
+        name: entityName
+    };
+    Reflect.defineMetadata(ENTITY_OPTIONS_METADATA_KEY, entityOptions, entityClass);
+    // 3. Register in EntityRegistry if enabled
+    if (config.register) {
+        EntityRegistry.register(entityName, entityClass);
+    }
+    // 4. Set property keys
+    const propertyKeys = Object.keys(config.properties);
+    Reflect.defineMetadata(PROPERTY_METADATA_KEY, propertyKeys, entityClass.prototype);
+    // 5. Set property options
+    Reflect.defineMetadata(PROPERTY_OPTIONS_METADATA_KEY, config.properties, entityClass.prototype);
+    // 6. Set up validators if provided
+    if (config.validators && config.validators.length > 0) {
+        const validatorMethodNames = [];
+        config.validators.forEach((validatorFn, index)=>{
+            const methodName = `__dynamicValidator${index}`;
+            validatorMethodNames.push(methodName);
+            // Attach validator as instance method that uses 'this'
+            entityClass.prototype[methodName] = function() {
+                return validatorFn(this);
+            };
+        });
+        Reflect.defineMetadata(ENTITY_VALIDATOR_METADATA_KEY, validatorMethodNames, entityClass.prototype);
+    }
+}
+/**
+ * Factory for creating schema-based entities without pre-defining a class
+ */ export class EntitySchema {
+    /**
+   * Define a new entity schema and return a wrapper with EntityUtils methods
+   *
+   * @param config - Schema configuration with name, properties, options, and validators
+   * @returns Wrapper object with parse, serialize, validate, etc. methods
+   *
+   * @example
+   * ```typescript
+   * const UserSchema = EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     name: { type: () => String },
+   *     age: { type: () => Number, optional: true },
+   *     tags: { type: () => String, array: true },
+   *   },
+   *   validators: [
+   *     (user) => user.name.length < 2 ? [{ path: 'name', message: 'Too short' }] : []
+   *   ]
+   * });
+   *
+   * const user = await UserSchema.parse({ name: 'John', age: 30, tags: ['admin'] });
+   * const serialized = UserSchema.serialize(user);
+   * const isValid = (await UserSchema.validate(user)).length === 0;
+   * ```
+   */ static define(config) {
+        // Generate anonymous entity class
+        const entityClass = class {
+            constructor(data){
+                Object.assign(this, data);
+            }
+        };
+        // Define entity metadata
+        defineEntity(entityClass, {
+            name: config.name,
+            options: config.options,
+            properties: config.properties,
+            validators: config.validators,
+            register: config.register ?? false
+        });
+        // Create wrapper with EntityUtils methods
+        const wrapper = {
+            entityClass,
+            async parse (data) {
+                return EntityUtils.parse(entityClass, data);
+            },
+            async safeParse (data) {
+                return EntityUtils.safeParse(entityClass, data);
+            },
+            async parsePartial (data) {
+                return EntityUtils.partialParse(entityClass, data);
+            },
+            async safeParsePartial (data) {
+                return EntityUtils.safePartialParse(entityClass, data);
+            },
+            serialize (instance) {
+                return EntityUtils.toJSON(instance);
+            },
+            async update (instance, data) {
+                return EntityUtils.update(instance, data);
+            },
+            async safeUpdate (instance, data) {
+                return EntityUtils.safeUpdate(instance, data);
+            },
+            async validate (instance) {
+                return EntityUtils.validate(instance);
+            },
+            equals (a, b) {
+                return EntityUtils.equals(a, b);
+            },
+            diff (a, b) {
+                const diffs = EntityUtils.diff(a, b);
+                const result = {};
+                for (const diff of diffs){
+                    result[diff.property] = {
+                        from: diff.oldValue,
+                        to: diff.newValue
+                    };
+                }
+                return result;
+            },
+            getChanges (a, b) {
+                return EntityUtils.changes(a, b);
+            }
+        };
+        return wrapper;
+    }
+}
+/**
+ * Property definition helpers for EntitySchema
+ * These mirror the decorator-based property helpers but return PropertyOptions objects
+ */ export const EntityProps = {
+    /**
+   * String property with optional validation
+   * @example
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     name: EntityProps.String({ minLength: 2, maxLength: 50 }),
+   *     email: EntityProps.String({ pattern: /^.+@.+\..+$/ }),
+   *   }
+   * })
+   */ String: stringPropertyOptions,
+    /**
+   * Enum property (validates string against enum values)
+   * @example
+   * enum Status { Active = 'active', Inactive = 'inactive' }
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     status: EntityProps.Enum(Status),
+   *   }
+   * })
+   */ Enum: enumPropertyOptions,
+    /**
+   * Number property with optional min/max validation
+   * @example
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     age: EntityProps.Number({ min: 0, max: 150 }),
+   *     score: EntityProps.Number({ optional: true }),
+   *   }
+   * })
+   */ Number: numberPropertyOptions,
+    /**
+   * Integer property (number that must be an integer)
+   * @example
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     age: EntityProps.Int({ min: 0 }),
+   *   }
+   * })
+   */ Int: intPropertyOptions,
+    /**
+   * Boolean property
+   * @example
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     isActive: EntityProps.Boolean(),
+   *     emailVerified: EntityProps.Boolean({ optional: true }),
+   *   }
+   * })
+   */ Boolean: booleanPropertyOptions,
+    /**
+   * Date property
+   * @example
+   * EntitySchema.define({
+   *   name: 'Event',
+   *   properties: {
+   *     createdAt: EntityProps.Date(),
+   *     scheduledFor: EntityProps.Date({ optional: true }),
+   *   }
+   * })
+   */ Date: datePropertyOptions,
+    /**
+   * BigInt property
+   * @example
+   * EntitySchema.define({
+   *   name: 'Transaction',
+   *   properties: {
+   *     amount: EntityProps.BigInt(),
+   *   }
+   * })
+   */ BigInt: bigIntPropertyOptions,
+    /**
+   * Entity property (nested entity)
+   * @example
+   * const AddressSchema = EntitySchema.define({ ... });
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     address: EntityProps.Entity(() => AddressSchema.entityClass),
+   *   }
+   * })
+   */ Entity: entityPropertyOptions,
+    /**
+   * Array property
+   * @example
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     tags: EntityProps.Array(() => String),
+   *     addresses: EntityProps.Array(() => AddressSchema.entityClass),
+   *   }
+   * })
+   */ Array: arrayPropertyOptions,
+    /**
+   * Passthrough property (no deserialization/validation)
+   * @example
+   * EntitySchema.define({
+   *   name: 'Config',
+   *   properties: {
+   *     metadata: EntityProps.Passthrough(),
+   *   }
+   * })
+   */ Passthrough: passthroughPropertyOptions,
+    /**
+   * Zod schema property (validates using Zod schema)
+   * @example
+   * import { z } from 'zod';
+   * EntitySchema.define({
+   *   name: 'User',
+   *   properties: {
+   *     data: EntityProps.Zod(z.object({
+   *       name: z.string().min(3),
+   *       age: z.number().int().min(0)
+   *     })),
+   *   }
+   * })
+   */ Zod: zodPropertyOptions,
+    /**
+   * Discriminated entity property (for polymorphic entities with discriminator)
+   * @example
+   * EntitySchema.define({
+   *   name: 'Shape',
+   *   properties: {
+   *     shape: EntityProps.DiscriminatedEntity({ discriminatorProperty: 'type' }),
+   *   }
+   * })
+   */ DiscriminatedEntity: discriminatedEntityPropertyOptions
+};
+
+//# sourceMappingURL=entity-definition.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/entity-definition.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport {\n  ENTITY_METADATA_KEY,\n  ENTITY_OPTIONS_METADATA_KEY,\n  ENTITY_VALIDATOR_METADATA_KEY,\n  PROPERTY_METADATA_KEY,\n  PROPERTY_OPTIONS_METADATA_KEY,\n  PropertyOptions,\n  type AnyCtor,\n} from './types.js';\nimport { EntityOptions } from './entity.js';\nimport { EntityRegistry } from './entity-registry.js';\nimport { EntityUtils } from './entity-utils.js';\nimport { Problem } from './problem.js';\nimport {\n  stringPropertyOptions,\n  enumPropertyOptions,\n  numberPropertyOptions,\n  intPropertyOptions,\n  booleanPropertyOptions,\n  datePropertyOptions,\n  bigIntPropertyOptions,\n  entityPropertyOptions,\n  arrayPropertyOptions,\n  passthroughPropertyOptions,\n  discriminatedEntityPropertyOptions,\n} from './property.js';\nimport { zodPropertyOptions } from './zod-property.js';\n\n/**\n * Configuration for defining an entity schema\n */\nexport interface EntitySchemaConfig<T = any> {\n  /**\n   * Name for the entity (required for schema-based entities)\n   */\n  name: string;\n  /**\n   * Entity options (collection, stringifiable, etc.)\n   */\n  options?: Omit<EntityOptions, 'name'>;\n  /**\n   * Property definitions - key is property name, value is property options\n   */\n  properties: Record<string, PropertyOptions>;\n  /**\n   * Validator functions that will be attached to the entity class\n   * Each function receives the entity instance and returns problems\n   */\n  validators?: Array<(instance: T) => Problem[] | Promise<Problem[]>>;\n  /**\n   * Whether to register this entity in the EntityRegistry.\n   * For dynamic schemas, defaults to false to prevent memory leaks.\n   * Set to true if you need discriminated entity deserialization.\n   */\n  register?: boolean;\n}\n\n/**\n * Wrapper object returned by EntitySchema.define() with EntityUtils methods\n */\nexport interface EntitySchemaWrapper<T> {\n  /**\n   * The generated entity class\n   */\n  readonly entityClass: AnyCtor<T>;\n\n  /**\n   * Parse data into an entity instance\n   */\n  parse(data: unknown): Promise<T>;\n\n  /**\n   * Parse data into an entity instance without throwing\n   */\n  safeParse(\n    data: unknown,\n  ): Promise<\n    | { success: true; data: T; problems: Problem[] }\n    | { success: false; data: undefined; problems: Problem[] }\n  >;\n\n  /**\n   * Parse only present properties without throwing\n   */\n  parsePartial(data: unknown): Promise<Partial<T>>;\n\n  /**\n   * Parse only present properties without throwing\n   */\n  safeParsePartial(\n    data: unknown,\n  ): Promise<\n    | { success: true; data: Partial<T>; problems: Problem[] }\n    | { success: false; data: undefined; problems: Problem[] }\n  >;\n\n  /**\n   * Serialize entity instance to plain object\n   */\n  serialize(instance: T): unknown;\n\n  /**\n   * Update entity instance with new data\n   */\n  update(instance: T, data: unknown): Promise<T>;\n\n  /**\n   * Update entity instance with new data without throwing\n   */\n  safeUpdate(\n    instance: T,\n    data: unknown,\n  ): Promise<\n    | { success: true; data: T; problems: Problem[] }\n    | { success: false; data: T; problems: Problem[] }\n  >;\n\n  /**\n   * Validate entity instance\n   */\n  validate(instance: T): Promise<Problem[]>;\n\n  /**\n   * Check if two instances are equal\n   */\n  equals(a: T, b: T): boolean;\n\n  /**\n   * Get differences between two instances\n   */\n  diff(a: T, b: T): Record<string, { from: unknown; to: unknown }>;\n\n  /**\n   * Get changed values as partial object\n   */\n  getChanges(a: T, b: T): Partial<T>;\n}\n\n/**\n * Define entity metadata on an existing class programmatically\n * This sets the same metadata that @Entity() and @Property() decorators would set\n *\n * @param entityClass - The class to define as an entity\n * @param config - Configuration with properties, options, and validators\n * @internal\n */\nfunction defineEntity<T>(\n  entityClass: AnyCtor<T>,\n  config: EntitySchemaConfig<T>,\n): void {\n  const entityName = config.name;\n\n  // 1. Mark as entity\n  Reflect.defineMetadata(ENTITY_METADATA_KEY, true, entityClass);\n\n  // 2. Set entity options with resolved name\n  const entityOptions: EntityOptions = {\n    ...config.options,\n    name: entityName,\n  };\n  Reflect.defineMetadata(\n    ENTITY_OPTIONS_METADATA_KEY,\n    entityOptions,\n    entityClass,\n  );\n\n  // 3. Register in EntityRegistry if enabled\n  if (config.register) {\n    EntityRegistry.register(entityName, entityClass);\n  }\n\n  // 4. Set property keys\n  const propertyKeys = Object.keys(config.properties);\n  Reflect.defineMetadata(\n    PROPERTY_METADATA_KEY,\n    propertyKeys,\n    entityClass.prototype,\n  );\n\n  // 5. Set property options\n  Reflect.defineMetadata(\n    PROPERTY_OPTIONS_METADATA_KEY,\n    config.properties,\n    entityClass.prototype,\n  );\n\n  // 6. Set up validators if provided\n  if (config.validators && config.validators.length > 0) {\n    const validatorMethodNames: string[] = [];\n\n    config.validators.forEach((validatorFn, index) => {\n      const methodName = `__dynamicValidator${index}`;\n      validatorMethodNames.push(methodName);\n\n      // Attach validator as instance method that uses 'this'\n      (entityClass.prototype as any)[methodName] = function ():\n        | Problem[]\n        | Promise<Problem[]> {\n        return validatorFn(this);\n      };\n    });\n\n    Reflect.defineMetadata(\n      ENTITY_VALIDATOR_METADATA_KEY,\n      validatorMethodNames,\n      entityClass.prototype,\n    );\n  }\n}\n\n/**\n * Factory for creating schema-based entities without pre-defining a class\n */\nexport class EntitySchema {\n  /**\n   * Define a new entity schema and return a wrapper with EntityUtils methods\n   *\n   * @param config - Schema configuration with name, properties, options, and validators\n   * @returns Wrapper object with parse, serialize, validate, etc. methods\n   *\n   * @example\n   * ```typescript\n   * const UserSchema = EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     name: { type: () => String },\n   *     age: { type: () => Number, optional: true },\n   *     tags: { type: () => String, array: true },\n   *   },\n   *   validators: [\n   *     (user) => user.name.length < 2 ? [{ path: 'name', message: 'Too short' }] : []\n   *   ]\n   * });\n   *\n   * const user = await UserSchema.parse({ name: 'John', age: 30, tags: ['admin'] });\n   * const serialized = UserSchema.serialize(user);\n   * const isValid = (await UserSchema.validate(user)).length === 0;\n   * ```\n   */\n  static define<T extends object = any>(\n    config: EntitySchemaConfig<T>,\n  ): EntitySchemaWrapper<T> {\n    // Generate anonymous entity class\n    const entityClass = class {\n      constructor(data: any) {\n        Object.assign(this, data);\n      }\n    } as unknown as AnyCtor<T>;\n\n    // Define entity metadata\n    defineEntity(entityClass, {\n      name: config.name,\n      options: config.options,\n      properties: config.properties,\n      validators: config.validators,\n      register: config.register ?? false, // Default to false for dynamic schemas to prevent memory leaks\n    });\n\n    // Create wrapper with EntityUtils methods\n    const wrapper: EntitySchemaWrapper<T> = {\n      entityClass,\n\n      async parse(data: unknown): Promise<T> {\n        return EntityUtils.parse(entityClass as any, data) as Promise<T>;\n      },\n\n      async safeParse(data: unknown) {\n        return EntityUtils.safeParse(entityClass as any, data) as Promise<\n          | { success: true; data: T; problems: Problem[] }\n          | { success: false; data: undefined; problems: Problem[] }\n        >;\n      },\n\n      async parsePartial(data: unknown): Promise<Partial<T>> {\n        return EntityUtils.partialParse(entityClass as any, data) as Promise<\n          Partial<T>\n        >;\n      },\n\n      async safeParsePartial(data: unknown) {\n        return EntityUtils.safePartialParse(\n          entityClass as any,\n          data,\n        ) as unknown as Promise<\n          | { success: true; data: Partial<T>; problems: Problem[] }\n          | { success: false; data: undefined; problems: Problem[] }\n        >;\n      },\n\n      serialize(instance: T): unknown {\n        return EntityUtils.toJSON(instance as any);\n      },\n\n      async update(instance: T, data: unknown): Promise<T> {\n        return EntityUtils.update(instance as any, data as any) as Promise<T>;\n      },\n\n      async safeUpdate(instance: T, data: unknown) {\n        return EntityUtils.safeUpdate(instance as any, data as any) as Promise<\n          | { success: true; data: T; problems: Problem[] }\n          | { success: false; data: T; problems: Problem[] }\n        >;\n      },\n\n      async validate(instance: T): Promise<Problem[]> {\n        return EntityUtils.validate(instance as any);\n      },\n\n      equals(a: T, b: T): boolean {\n        return EntityUtils.equals(a as any, b as any);\n      },\n\n      diff(a: T, b: T): Record<string, { from: unknown; to: unknown }> {\n        const diffs = EntityUtils.diff(a as any, b as any);\n        const result: Record<string, { from: unknown; to: unknown }> = {};\n        for (const diff of diffs) {\n          result[diff.property] = { from: diff.oldValue, to: diff.newValue };\n        }\n        return result;\n      },\n\n      getChanges(a: T, b: T): Partial<T> {\n        return EntityUtils.changes(a as any, b as any) as Partial<T>;\n      },\n    };\n\n    return wrapper;\n  }\n}\n\n/**\n * Property definition helpers for EntitySchema\n * These mirror the decorator-based property helpers but return PropertyOptions objects\n */\nexport const EntityProps = {\n  /**\n   * String property with optional validation\n   * @example\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     name: EntityProps.String({ minLength: 2, maxLength: 50 }),\n   *     email: EntityProps.String({ pattern: /^.+@.+\\..+$/ }),\n   *   }\n   * })\n   */\n  String: stringPropertyOptions,\n\n  /**\n   * Enum property (validates string against enum values)\n   * @example\n   * enum Status { Active = 'active', Inactive = 'inactive' }\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     status: EntityProps.Enum(Status),\n   *   }\n   * })\n   */\n  Enum: enumPropertyOptions,\n\n  /**\n   * Number property with optional min/max validation\n   * @example\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     age: EntityProps.Number({ min: 0, max: 150 }),\n   *     score: EntityProps.Number({ optional: true }),\n   *   }\n   * })\n   */\n  Number: numberPropertyOptions,\n\n  /**\n   * Integer property (number that must be an integer)\n   * @example\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     age: EntityProps.Int({ min: 0 }),\n   *   }\n   * })\n   */\n  Int: intPropertyOptions,\n\n  /**\n   * Boolean property\n   * @example\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     isActive: EntityProps.Boolean(),\n   *     emailVerified: EntityProps.Boolean({ optional: true }),\n   *   }\n   * })\n   */\n  Boolean: booleanPropertyOptions,\n\n  /**\n   * Date property\n   * @example\n   * EntitySchema.define({\n   *   name: 'Event',\n   *   properties: {\n   *     createdAt: EntityProps.Date(),\n   *     scheduledFor: EntityProps.Date({ optional: true }),\n   *   }\n   * })\n   */\n  Date: datePropertyOptions,\n\n  /**\n   * BigInt property\n   * @example\n   * EntitySchema.define({\n   *   name: 'Transaction',\n   *   properties: {\n   *     amount: EntityProps.BigInt(),\n   *   }\n   * })\n   */\n  BigInt: bigIntPropertyOptions,\n\n  /**\n   * Entity property (nested entity)\n   * @example\n   * const AddressSchema = EntitySchema.define({ ... });\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     address: EntityProps.Entity(() => AddressSchema.entityClass),\n   *   }\n   * })\n   */\n  Entity: entityPropertyOptions,\n\n  /**\n   * Array property\n   * @example\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     tags: EntityProps.Array(() => String),\n   *     addresses: EntityProps.Array(() => AddressSchema.entityClass),\n   *   }\n   * })\n   */\n  Array: arrayPropertyOptions,\n\n  /**\n   * Passthrough property (no deserialization/validation)\n   * @example\n   * EntitySchema.define({\n   *   name: 'Config',\n   *   properties: {\n   *     metadata: EntityProps.Passthrough(),\n   *   }\n   * })\n   */\n  Passthrough: passthroughPropertyOptions,\n\n  /**\n   * Zod schema property (validates using Zod schema)\n   * @example\n   * import { z } from 'zod';\n   * EntitySchema.define({\n   *   name: 'User',\n   *   properties: {\n   *     data: EntityProps.Zod(z.object({\n   *       name: z.string().min(3),\n   *       age: z.number().int().min(0)\n   *     })),\n   *   }\n   * })\n   */\n  Zod: zodPropertyOptions,\n\n  /**\n   * Discriminated entity property (for polymorphic entities with discriminator)\n   * @example\n   * EntitySchema.define({\n   *   name: 'Shape',\n   *   properties: {\n   *     shape: EntityProps.DiscriminatedEntity({ discriminatorProperty: 'type' }),\n   *   }\n   * })\n   */\n  DiscriminatedEntity: discriminatedEntityPropertyOptions,\n};\n"],"names":["ENTITY_METADATA_KEY","ENTITY_OPTIONS_METADATA_KEY","ENTITY_VALIDATOR_METADATA_KEY","PROPERTY_METADATA_KEY","PROPERTY_OPTIONS_METADATA_KEY","EntityRegistry","EntityUtils","stringPropertyOptions","enumPropertyOptions","numberPropertyOptions","intPropertyOptions","booleanPropertyOptions","datePropertyOptions","bigIntPropertyOptions","entityPropertyOptions","arrayPropertyOptions","passthroughPropertyOptions","discriminatedEntityPropertyOptions","zodPropertyOptions","defineEntity","entityClass","config","entityName","name","Reflect","defineMetadata","entityOptions","options","register","propertyKeys","Object","keys","properties","prototype","validators","length","validatorMethodNames","forEach","validatorFn","index","methodName","push","EntitySchema","define","data","assign","wrapper","parse","safeParse","parsePartial","partialParse","safeParsePartial","safePartialParse","serialize","instance","toJSON","update","safeUpdate","validate","equals","a","b","diff","diffs","result","property","from","oldValue","to","newValue","getChanges","changes","EntityProps","String","Enum","Number","Int","Boolean","Date","BigInt","Entity","Array","Passthrough","Zod","DiscriminatedEntity"],"mappings":"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"}

package/dist/lib/entity.d.ts

@@ -28,6 +28,12 @@ export interface EntityOptions {
      * Used by @CollectionEntity ('collection') and @Stringifiable ('value').
      */
     wrapperProperty?: string;
+    /**
+     * Whether to register this entity in the EntityRegistry.
+     * Set to false for dynamic entities to prevent memory leaks.
+     * Defaults to true.
+     */
+    register?: boolean;
 }
 /**
  * Decorator that marks a class as an Entity.

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

@@ -1 +1 @@
-{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../src/lib/entity.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,cAAc,CAqBlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAM,GACxC,cAAc,CAMhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,aAAa,CAC3B,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAM,GACxC,cAAc,CAEhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,IAAI,eAAe,CAmBjD"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../src/lib/entity.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,cAAc,CAwBlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAM,GACxC,cAAc,CAMhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,aAAa,CAC3B,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAM,GACxC,cAAc,CAEhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,IAAI,eAAe,CAmBjD"}