@carno.js/orm 0.2.3

package/dist/cache/query-cache-manager.d.ts

@@ -0,0 +1,14 @@
+import { CacheService } from '@carno.js/core';
+import { Statement } from '../driver/driver.interface';
+export declare class QueryCacheManager {
+    private cacheService;
+    private keyGenerator;
+    private namespaceKeys;
+    constructor(cacheService: CacheService);
+    get<T>(statement: Statement<T>): Promise<any>;
+    set<T>(statement: Statement<T>, value: any, ttl?: number): Promise<void>;
+    invalidate<T>(statement: Statement<T>): Promise<void>;
+    private registerKeyInNamespace;
+    private getNamespace;
+    private generateKey;
+}

package/dist/cache/query-cache-manager.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryCacheManager = void 0;
+const cache_key_generator_1 = require("./cache-key-generator");
+class QueryCacheManager {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+        this.namespaceKeys = new Map();
+        this.keyGenerator = new cache_key_generator_1.CacheKeyGenerator();
+    }
+    async get(statement) {
+        const key = this.generateKey(statement);
+        return this.cacheService.get(key);
+    }
+    async set(statement, value, ttl) {
+        const key = this.generateKey(statement);
+        const namespace = this.getNamespace(statement);
+        this.registerKeyInNamespace(namespace, key);
+        await this.cacheService.set(key, value, ttl);
+    }
+    async invalidate(statement) {
+        const namespace = this.getNamespace(statement);
+        const keys = this.namespaceKeys.get(namespace);
+        if (!keys || keys.size === 0) {
+            return;
+        }
+        const deletePromises = Array.from(keys).map(key => this.cacheService.del(key));
+        await Promise.all(deletePromises);
+        this.namespaceKeys.delete(namespace);
+    }
+    registerKeyInNamespace(namespace, key) {
+        if (!this.namespaceKeys.has(namespace)) {
+            this.namespaceKeys.set(namespace, new Set());
+        }
+        this.namespaceKeys.get(namespace).add(key);
+    }
+    getNamespace(statement) {
+        return statement.table || 'unknown';
+    }
+    generateKey(statement) {
+        return `orm:${this.keyGenerator.generate(statement)}`;
+    }
+}
+exports.QueryCacheManager = QueryCacheManager;

package/dist/common/email.vo.d.ts

@@ -0,0 +1,4 @@
+import { ValueObject } from "./value-object";
+export declare class Email extends ValueObject<string, Email> {
+    protected validate(value: string): boolean;
+}

package/dist/common/email.vo.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Email = void 0;
+const value_object_1 = require("./value-object");
+const REGEX = /^[a-z0-9.]+@[a-z0-9]+\.[a-z]+(\.[a-z]+)?$/i;
+class Email extends value_object_1.ValueObject {
+    validate(value) {
+        return REGEX.test(value);
+    }
+}
+exports.Email = Email;

package/dist/common/uuid.d.ts

@@ -0,0 +1,4 @@
+import { ValueObject } from './value-object';
+export declare class Uuid extends ValueObject<string, Uuid> {
+    protected validate(value: string): boolean;
+}

package/dist/common/uuid.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uuid = void 0;
+const value_object_1 = require("./value-object");
+class Uuid extends value_object_1.ValueObject {
+    validate(value) {
+        return /^[a-f\d]{8}(-[a-f\d]{4}){4}[a-f\d]{8}$/i.test(value);
+    }
+}
+exports.Uuid = Uuid;

package/dist/common/value-object.d.ts

@@ -0,0 +1,95 @@
+type VoExtended<T, Vo> = Vo extends ValueObject<T, Vo> ? Vo : ValueObject<T, Vo>;
+type DatabaseValues = {
+    max?: number;
+    min?: number;
+    precision?: number;
+    scale?: number;
+};
+export declare abstract class ValueObject<T, Vo> {
+    /**
+     * Validates the value of the Value Object.
+     * It is abstract so that each Value Object can implement its own validation.
+     * It is protected from being called directly.
+     *
+     * @param value
+     * @protected
+     */
+    protected abstract validate(value: T): boolean;
+    /**
+     * The maximum length of the Value Object.
+     * It value is optional and will be used in database if this Value Object is used as a column.
+     * If the value is string, it will be the maximum number of characters.
+     * If the value is number, it will be the maximum number.
+     */
+    protected max?: number;
+    /**
+     * The minimum length of the Value Object.
+     * It value is optional.
+     * If the value is string, it will be the minimum number of characters.
+     * If the value is number, it will be the minimum number.
+     */
+    protected min?: number;
+    /**
+     * The precision of the Value Object.
+     * It value is optional and will be used in database if this Value Object is used as a column.
+     * It is the number of digits in a number.
+     */
+    protected precision?: number;
+    /**
+     * The scale of the Value Object.
+     * It value is optional and will be used in database if this Value Object is used as a column.
+     * It is the number of digits to the right of the decimal point in a number.
+     */
+    protected scale?: number;
+    /**
+     * Valor do Value Object.
+     * É privado para não ser alterado diretamente.
+     * O valor também é imutável.
+     *
+     * @private
+     */
+    private value;
+    constructor(value: T, skipValidation?: boolean);
+    /**
+     * Creates a Value Object instance from a value.
+     *
+     * @example
+     * Email.from('test@test.com');
+     *
+     * @param value
+     */
+    static from<T, Vo>(this: new (value: T) => VoExtended<T, Vo>, value: T): VoExtended<T, Vo>;
+    /**
+     * Returns the scalar value of the Value Object.
+     *
+     */
+    getValue(): T;
+    /**
+     * Compares the value of the Value Object with another Value Object.
+     *
+     * @param vo
+     */
+    equals(vo: ValueObject<T, Vo>): boolean;
+    /**
+     * Returns the database settings of the Value Object.
+     *
+     * @returns
+     */
+    getDatabaseValues(): DatabaseValues;
+    /**
+     * Sets the value of the Value Object.
+     *
+     * @param value
+     * @private
+     */
+    private setValue;
+    /**
+     * Validates the value of the Value Object.
+     * It is private so that it can only be called by the constructor.
+     *
+     * @param value
+     * @returns
+     */
+    private validateDatabase;
+}
+export {};

package/dist/common/value-object.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueObject = void 0;
+const core_1 = require("@carno.js/core");
+class ValueObject {
+    constructor(value, skipValidation = false) {
+        if (!skipValidation && (!this.validate(value) || !this.validateDatabase(value))) {
+            throw new core_1.HttpException(`Invalid value for ${this.constructor.name}`, 400);
+        }
+        this.setValue(value);
+    }
+    /**
+     * Creates a Value Object instance from a value.
+     *
+     * @example
+     * Email.from('test@test.com');
+     *
+     * @param value
+     */
+    static from(value) {
+        return new this(value);
+    }
+    /**
+     * Returns the scalar value of the Value Object.
+     *
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Compares the value of the Value Object with another Value Object.
+     *
+     * @param vo
+     */
+    equals(vo) {
+        return this.getValue() === vo.getValue();
+    }
+    /**
+     * Returns the database settings of the Value Object.
+     *
+     * @returns
+     */
+    getDatabaseValues() {
+        return {
+            max: this.max,
+            min: this.min,
+            precision: this.precision,
+            scale: this.scale,
+        };
+    }
+    /**
+     * Sets the value of the Value Object.
+     *
+     * @param value
+     * @private
+     */
+    setValue(value) {
+        this.value = value;
+    }
+    /**
+     * Validates the value of the Value Object.
+     * It is private so that it can only be called by the constructor.
+     *
+     * @param value
+     * @returns
+     */
+    validateDatabase(value) {
+        if (typeof value === "string") {
+            if (this.max !== undefined && value.length > this.max) {
+                throw new core_1.HttpException(`Value exceeds maximum length of ${this.max}`, 400);
+            }
+            if (this.min !== undefined && value.length < this.min) {
+                throw new core_1.HttpException(`Value is less than minimum length of ${this.min}`, 400);
+            }
+        }
+        else if (typeof value === "number") {
+            if (this.max !== undefined && value > this.max) {
+                throw new core_1.HttpException(`Value exceeds maximum value of ${this.max}`, 400);
+            }
+            if (this.min !== undefined && value < this.min) {
+                throw new core_1.HttpException(`Value is less than minimum value of ${this.min}`, 400);
+            }
+            if (this.precision !== undefined) {
+                const totalDigits = value.toString().replace(".", "").length;
+                if (totalDigits > this.precision) {
+                    throw new core_1.HttpException(`Value exceeds precision of ${this.precision}`, 400);
+                }
+            }
+            if (this.scale !== undefined) {
+                const decimalDigits = (value.toString().split(".")[1] || "").length;
+                if (decimalDigits > this.scale) {
+                    throw new core_1.HttpException(`Value exceeds scale of ${this.scale}`, 400);
+                }
+            }
+        }
+        return true;
+    }
+}
+exports.ValueObject = ValueObject;

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const ENTITIES = "carno:entities";
+export declare const PROPERTIES = "carno:properties";
+export declare const PROPERTIES_METADATA = "carno:properties:metadata";
+export declare const PROPERTIES_RELATIONS = "carno:properties:relations";
+export declare const EVENTS_METADATA = "carno:events:metadata";
+export declare const COMPUTED_PROPERTIES = "carno:computed:properties";

package/dist/constants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPUTED_PROPERTIES = exports.EVENTS_METADATA = exports.PROPERTIES_RELATIONS = exports.PROPERTIES_METADATA = exports.PROPERTIES = exports.ENTITIES = void 0;
+exports.ENTITIES = 'carno:entities';
+exports.PROPERTIES = 'carno:properties';
+exports.PROPERTIES_METADATA = 'carno:properties:metadata';
+exports.PROPERTIES_RELATIONS = 'carno:properties:relations';
+exports.EVENTS_METADATA = 'carno:events:metadata';
+exports.COMPUTED_PROPERTIES = 'carno:computed:properties';

package/dist/decorators/computed.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Computed(): PropertyDecorator;

package/dist/decorators/computed.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Computed = Computed;
+const core_1 = require("@carno.js/core");
+const constants_1 = require("../constants");
+function Computed() {
+    return (target, propertyKey) => {
+        const computedProperties = core_1.Metadata.get(constants_1.COMPUTED_PROPERTIES, target.constructor) || [];
+        computedProperties.push(propertyKey);
+        core_1.Metadata.set(constants_1.COMPUTED_PROPERTIES, computedProperties, target.constructor);
+    };
+}

package/dist/decorators/entity.decorator.d.ts

@@ -0,0 +1,3 @@
+export declare function Entity(options?: {
+    tableName?: string;
+}): ClassDecorator;

package/dist/decorators/entity.decorator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = Entity;
+const constants_1 = require("../constants");
+const core_1 = require("@carno.js/core");
+function Entity(options) {
+    return (target) => {
+        const entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect) || [];
+        entities.push({ target, options });
+        core_1.Metadata.set(constants_1.ENTITIES, entities, Reflect);
+    };
+}

package/dist/decorators/enum.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ClassType, EnumOptions } from '../driver/driver.interface';
+export declare function Enum(options?: EnumOptions<any> | (() => ClassType)): PropertyDecorator;

package/dist/decorators/enum.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enum = Enum;
+const property_decorator_1 = require("./property.decorator");
+function Enum(options) {
+    const isEnum = true;
+    if (!options) {
+        return (0, property_decorator_1.Property)({ isEnum, enumItems: '__AUTO_DETECT__', dbType: 'enum' });
+    }
+    //@ts-ignore
+    let enumItems = typeof options === 'function' ? options() : (typeof options.items === 'function' ? options.items() : options.items);
+    if (typeof enumItems === 'object') {
+        enumItems = Object.keys(enumItems).map(key => enumItems[key]);
+    }
+    return (0, property_decorator_1.Property)({ ...options, isEnum, enumItems, dbType: 'enum' });
+}

package/dist/decorators/event-hook.decorator.d.ts

@@ -0,0 +1,4 @@
+export declare function BeforeCreate(): (target: any, propertyName: any) => void;
+export declare function AfterCreate(): (target: any, propertyName: any) => void;
+export declare function BeforeUpdate(): (target: any, propertyName: any) => void;
+export declare function AfterUpdate(): (target: any, propertyName: any) => void;

package/dist/decorators/event-hook.decorator.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeforeCreate = BeforeCreate;
+exports.AfterCreate = AfterCreate;
+exports.BeforeUpdate = BeforeUpdate;
+exports.AfterUpdate = AfterUpdate;
+const constants_1 = require("../constants");
+function BeforeCreate() {
+    return function (target, propertyName) {
+        const metadata = Reflect.getMetadata(constants_1.EVENTS_METADATA, target.constructor) || [];
+        Reflect.defineMetadata(constants_1.EVENTS_METADATA, [...metadata, { type: 'beforeCreate', propertyName }], target.constructor);
+    };
+}
+function AfterCreate() {
+    return function (target, propertyName) {
+        const metadata = Reflect.getMetadata(constants_1.EVENTS_METADATA, target.constructor) || [];
+        Reflect.defineMetadata(constants_1.EVENTS_METADATA, [...metadata, { type: 'afterCreate', propertyName }], target.constructor);
+    };
+}
+function BeforeUpdate() {
+    return function (target, propertyName) {
+        const metadata = Reflect.getMetadata(constants_1.EVENTS_METADATA, target.constructor) || [];
+        Reflect.defineMetadata(constants_1.EVENTS_METADATA, [...metadata, { type: 'beforeUpdate', propertyName }], target.constructor);
+    };
+}
+function AfterUpdate() {
+    return function (target, propertyName) {
+        const metadata = Reflect.getMetadata(constants_1.EVENTS_METADATA, target.constructor) || [];
+        Reflect.defineMetadata(constants_1.EVENTS_METADATA, [...metadata, { type: 'afterUpdate', propertyName }], target.constructor);
+    };
+}

package/dist/decorators/index.decorator.d.ts

@@ -0,0 +1,17 @@
+import { FilterQuery } from "../driver/driver.interface";
+export type IndexColumnMap<T> = {
+    [K in keyof T as K extends symbol ? never : K]: string;
+};
+export type IndexPredicate<T> = string | ((columns: IndexColumnMap<T>) => string);
+export type IndexWhere<T> = IndexPredicate<T> | FilterQuery<T>;
+export type IndexDefinition = {
+    name: string;
+    properties: string[];
+    where?: IndexWhere<any>;
+};
+type IndexOptions<T> = {
+    properties: (keyof T)[];
+    where?: IndexWhere<T>;
+} | (keyof T)[] | undefined;
+export declare function Index<T>(options?: IndexOptions<T>): ClassDecorator & PropertyDecorator;
+export {};

package/dist/decorators/index.decorator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Index = Index;
+const core_1 = require("@carno.js/core");
+function getCtor(target) {
+    return typeof target === "function" ? target : target.constructor;
+}
+function buildFromOptions(options) {
+    const props = Array.isArray(options) ? options : options?.properties;
+    if (!props || props.length === 0)
+        return null;
+    const keys = props;
+    const where = Array.isArray(options) ? undefined : options?.where;
+    return { name: `${keys.join('_')}_index`, properties: keys, where };
+}
+function buildFromProperty(propertyKey) {
+    const name = String(propertyKey);
+    return { name: `${name}_index`, properties: [name] };
+}
+function resolveIndex(options, propertyKey) {
+    const fromOptions = buildFromOptions(options);
+    if (fromOptions)
+        return fromOptions;
+    if (!propertyKey)
+        throw new Error("@Index on class requires properties option");
+    return buildFromProperty(propertyKey);
+}
+function Index(options) {
+    return (target, propertyKey) => {
+        const ctor = getCtor(target);
+        const indexes = [...(core_1.Metadata.get("indexes", ctor) || [])];
+        const index = resolveIndex(options, propertyKey);
+        indexes.push(index);
+        core_1.Metadata.set("indexes", indexes, ctor);
+    };
+}

package/dist/decorators/one-many.decorator.d.ts

@@ -0,0 +1,6 @@
+import { EntityName } from '../driver/driver.interface';
+import { PropertyOptions } from './property.decorator';
+export declare function OneToMany<T>(entity: () => EntityName<T>, fkKey: (string & keyof T) | ((e: T) => any)): PropertyDecorator;
+type ManyToOneOptions = Partial<PropertyOptions>;
+export declare function ManyToOne<T>(entityOrOptions?: (() => EntityName<T>) | ManyToOneOptions, maybeOptions?: ManyToOneOptions): PropertyDecorator;
+export {};

package/dist/decorators/one-many.decorator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneToMany = OneToMany;
+exports.ManyToOne = ManyToOne;
+const constants_1 = require("../constants");
+const core_1 = require("@carno.js/core");
+const utils_1 = require("../utils");
+const index_decorator_1 = require("./index.decorator");
+function OneToMany(entity, fkKey) {
+    return (target, propertyKey) => {
+        const existing = core_1.Metadata.get(constants_1.PROPERTIES_RELATIONS, target.constructor) || [];
+        const options = { relation: 'one-to-many', propertyKey, isRelation: true, entity, fkKey, type: core_1.Metadata.getType(target, propertyKey), originalEntity: target.constructor };
+        options['columnName'] = `${(0, utils_1.toSnakeCase)(propertyKey)}_id`;
+        // @ts-ignore
+        existing.push(options);
+        core_1.Metadata.set(constants_1.PROPERTIES_RELATIONS, existing, target.constructor);
+    };
+}
+function ManyToOne(entityOrOptions, maybeOptions) {
+    return (target, propertyKey) => {
+        const existing = core_1.Metadata.get(constants_1.PROPERTIES_RELATIONS, target.constructor) || [];
+        const hasEntity = typeof entityOrOptions === 'function';
+        const entity = hasEntity ? entityOrOptions : undefined;
+        const options = (!hasEntity ? entityOrOptions : maybeOptions) || {};
+        const columnName = options.columnName || `${(0, utils_1.toSnakeCase)(propertyKey)}_id`;
+        const relationOptions = {
+            relation: 'many-to-one',
+            propertyKey,
+            isRelation: true,
+            entity: entity || '__AUTO_DETECT__',
+            type: core_1.Metadata.getType(target, propertyKey),
+            originalEntity: target.constructor,
+            columnName,
+            ...options,
+        };
+        if (options.index) {
+            (0, index_decorator_1.Index)({ properties: [propertyKey] })(target, propertyKey);
+        }
+        existing.push(relationOptions);
+        core_1.Metadata.set(constants_1.PROPERTIES_RELATIONS, existing, target.constructor);
+    };
+}

package/dist/decorators/primary-key.decorator.d.ts

@@ -0,0 +1,2 @@
+import { PropertyOptions } from './property.decorator';
+export declare function PrimaryKey(options?: Omit<PropertyOptions, 'isPrimary'>): PropertyDecorator;

package/dist/decorators/primary-key.decorator.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryKey = PrimaryKey;
+const property_decorator_1 = require("./property.decorator");
+function PrimaryKey(options) {
+    const isPrimary = true;
+    return (0, property_decorator_1.Property)({ ...options, isPrimary });
+}

package/dist/decorators/property.decorator.d.ts

@@ -0,0 +1,24 @@
+export type PropertyOptions = {
+    isPrimary?: boolean;
+    nullable?: boolean;
+    default?: any;
+    length?: number;
+    hidden?: boolean;
+    unique?: boolean;
+    index?: boolean;
+    precision?: number;
+    scale?: number;
+    dbType?: "varchar" | "text" | "int" | "bigint" | "float" | "double" | "decimal" | "date" | "datetime" | "time" | "timestamp" | "boolean" | "json" | "jsonb" | "enum" | "array" | "uuid";
+    autoIncrement?: boolean;
+    columnName?: string;
+    isEnum?: boolean;
+    enumItems?: string[] | number[] | '__AUTO_DETECT__';
+    array?: boolean;
+    onUpdate?: () => any;
+    onInsert?: () => any;
+};
+export type Prop = {
+    propertyKey: any;
+    options: PropertyOptions | undefined;
+};
+export declare function Property(options?: PropertyOptions): PropertyDecorator;

package/dist/decorators/property.decorator.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Property = Property;
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const core_1 = require("@carno.js/core");
+const index_decorator_1 = require("./index.decorator");
+const __1 = require("..");
+function Property(options) {
+    return (target, propertyKey) => {
+        const properties = core_1.Metadata.get(constants_1.PROPERTIES, target.constructor) || [];
+        // 1) Resolva o tipo logo no início
+        const propType = core_1.Metadata.getType(target, propertyKey);
+        const length = (options && options.length) || (0, utils_1.getDefaultLength)(propType?.name);
+        if ((0, core_1.isObject)(propType) && options.dbType !== "enum") {
+            throw new Error(`Property ${String(propertyKey)} has unknown type`);
+        }
+        options = { length, ...options };
+        options["columnName"] = options?.columnName || (0, utils_1.toSnakeCase)(propertyKey);
+        if (propType && (0, utils_1.extendsFrom)(__1.ValueObject, propType.prototype)) {
+            let instance = new propType(null, true).getDatabaseValues();
+            options["length"] = instance.max;
+            options["precision"] = instance.precision;
+            options["scale"] = instance.scale;
+            instance = null; // Garbage collector
+        }
+        properties.push({ propertyKey, options });
+        core_1.Metadata.set(constants_1.PROPERTIES, properties, target.constructor);
+        if (options.isPrimary) {
+            const indexes = core_1.Metadata.get("indexes", target.constructor) || [];
+            indexes.push({ name: `[TABLE]_pkey`, properties: [propertyKey] });
+            core_1.Metadata.set("indexes", indexes, target.constructor);
+        }
+        if (options.index) {
+            (0, index_decorator_1.Index)({ properties: [propertyKey] })(target, propertyKey);
+        }
+        // 2) Atualize PROPERTIES_METADATA apenas para esta propriedade
+        const existingTypes = core_1.Metadata.get(constants_1.PROPERTIES_METADATA, target.constructor) || {};
+        // Cria uma cópia para evitar mutação compartilhada entre entidades
+        const types = { ...existingTypes };
+        types[propertyKey] = { type: propType, options };
+        core_1.Metadata.set(constants_1.PROPERTIES_METADATA, types, target.constructor);
+    };
+}

package/dist/decorators/unique.decorator.d.ts

@@ -0,0 +1,9 @@
+export type UniqueDefinition = {
+    name: string;
+    properties: string[];
+};
+type UniqueOptions<T> = {
+    properties: (keyof T)[];
+} | (keyof T)[] | undefined;
+export declare function Unique<T>(options?: UniqueOptions<T>): ClassDecorator & PropertyDecorator;
+export {};

package/dist/decorators/unique.decorator.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unique = Unique;
+const core_1 = require("@carno.js/core");
+function getCtor(target) {
+    return typeof target === "function" ? target : target.constructor;
+}
+function buildFromOptions(options) {
+    const props = Array.isArray(options) ? options : options?.properties;
+    if (!props || props.length === 0) {
+        return null;
+    }
+    const keys = props;
+    return {
+        name: `${keys.join('_')}_unique`,
+        properties: keys,
+    };
+}
+function buildFromProperty(propertyKey) {
+    const name = String(propertyKey);
+    return {
+        name: `${name}_unique`,
+        properties: [name],
+    };
+}
+function resolveUnique(options, propertyKey) {
+    const fromOptions = buildFromOptions(options);
+    if (fromOptions) {
+        return fromOptions;
+    }
+    if (!propertyKey) {
+        throw new Error("@Unique on class requires properties option");
+    }
+    return buildFromProperty(propertyKey);
+}
+function Unique(options) {
+    return (target, propertyKey) => {
+        const ctor = getCtor(target);
+        const uniques = [...(core_1.Metadata.get("uniques", ctor) || [])];
+        const unique = resolveUnique(options, propertyKey);
+        uniques.push(unique);
+        core_1.Metadata.set("uniques", uniques, ctor);
+    };
+}