@cheetah.js/orm 0.1.146 → 0.1.147

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("@cheetah.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);
+    };
+}

package/dist/domain/entities.d.ts

@@ -1,5 +1,5 @@
 import { PropertyOptions } from "../decorators/property.decorator";
-import { Relationship, SnapshotIndexInfo, SnapshotTable } from "../driver/driver.interface";
+import { Relationship, SnapshotIndexInfo, SnapshotTable, SnapshotUniqueInfo } from "../driver/driver.interface";
 export type Property = {
     options: PropertyOptions;
     type: Function;
@@ -10,6 +10,7 @@ export type Options = {
     };
     hideProperties: string[];
     indexes?: SnapshotIndexInfo[];
+    uniques?: SnapshotUniqueInfo[];
     relations: Relationship<any>[];
     tableName: string;
     hooks?: {

package/dist/domain/entities.js

@@ -77,6 +77,31 @@ function buildIndexWhere(where, columnMap) {
     const builder = new index_condition_builder_1.IndexConditionBuilder(columnMap);
     return builder.build(where);
 }
+function mapUniqueDefinitions(uniques, entityName, columnMap) {
+    return uniques.map((unique) => toSnapshotUnique(unique, entityName, columnMap));
+}
+function toSnapshotUnique(unique, entityName, columnMap) {
+    const columns = resolveUniqueColumns(unique, columnMap);
+    const uniqueName = resolveUniqueName(unique.name, entityName, columns);
+    return {
+        table: entityName,
+        uniqueName,
+        columnName: columns.join(","),
+    };
+}
+function resolveUniqueColumns(unique, columnMap) {
+    return unique.properties.map((propName) => resolveUniqueColumn(propName, columnMap));
+}
+function resolveUniqueColumn(propName, columnMap) {
+    const mapped = columnMap[propName];
+    if (mapped) {
+        return mapped;
+    }
+    return (0, utils_1.toSnakeCase)(propName);
+}
+function resolveUniqueName(name, entityName, columns) {
+    return `${columns.join("_")}_unique`;
+}
 let EntityStorage = EntityStorage_1 = class EntityStorage {
     constructor() {
         this.entities = new Map();
@@ -85,6 +110,7 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
     add(entity, properties, relations, hooks) {
         const entityName = entity.options?.tableName || (0, utils_1.toSnakeCase)(entity.target.name);
         const indexes = core_1.Metadata.get("indexes", entity.target) || [];
+        const uniques = core_1.Metadata.get("uniques", entity.target) || [];
         const columnMap = buildIndexColumnMap(properties, relations);
         this.entities.set(entity.target, {
             properties: properties,
@@ -93,6 +119,7 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
                 .map(([key]) => key),
             relations,
             indexes: mapIndexDefinitions(indexes, entityName, columnMap),
+            uniques: mapUniqueDefinitions(uniques, entityName, columnMap),
             hooks,
             tableName: entityName,
             ...entity.options,
@@ -116,6 +143,7 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
             tableName: values.tableName,
             schema: values.schema || "public",
             indexes: values.indexes || [],
+            uniques: values.uniques || [],
             columns: this.snapshotColumns(values),
         };
     }

package/dist/driver/bun-mysql.driver.d.ts

@@ -26,6 +26,13 @@ export declare class BunMysqlDriver extends BunDriverBase implements DriverInter
         name: string;
         properties?: string[];
     }, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
     getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;

package/dist/driver/bun-mysql.driver.js

@@ -141,6 +141,17 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
     getDropIndex(index, schema, tableName) {
         return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${index.name}\`;`;
     }
+    getCreateUniqueConstraint(unique, schema, tableName) {
+        const properties = unique.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Unique properties are required.");
+        }
+        const columns = properties.map((prop) => `\`${prop}\``).join(', ');
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${unique.name}\` UNIQUE (${columns});`;
+    }
+    getDropUniqueConstraint(unique, schema, tableName) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${unique.name}\`;`;
+    }
     getAlterTableType(schema, tableName, colName, colDiff) {
         return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
     }

package/dist/driver/bun-pg.driver.d.ts

@@ -25,6 +25,13 @@ export declare class BunPgDriver extends BunDriverBase implements DriverInterfac
         name: string;
         properties?: string[];
     }, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
     getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;

package/dist/driver/bun-pg.driver.js

@@ -114,6 +114,17 @@ class BunPgDriver extends bun_driver_base_1.BunDriverBase {
     getDropIndex(index, schema, tableName) {
         return this.getDropConstraint(index, schema, tableName);
     }
+    getCreateUniqueConstraint(unique, schema, tableName) {
+        const properties = unique.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Unique properties are required.");
+        }
+        const columns = properties.map((prop) => `"${prop}"`).join(', ');
+        return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${unique.name}" UNIQUE (${columns});`;
+    }
+    getDropUniqueConstraint(unique, schema, tableName) {
+        return this.getDropConstraint(unique, schema, tableName);
+    }
     getAlterTableType(schema, tableName, colName, colDiff) {
         return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" TYPE ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
     }

package/dist/driver/driver.interface.d.ts

@@ -20,6 +20,8 @@ export interface DriverInterface {
     getAddColumn(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff, colDiffInstructions: string[]): void;
     getDropColumn(colDiffInstructions: string[], schema: string | undefined, tableName: string, colName: string): void;
     getDropIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: UniqueStatement, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: UniqueStatement, schema: string | undefined, tableName: string): string;
     getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
@@ -136,6 +138,7 @@ export type SnapshotTable = {
     schema?: string;
     columns: ColumnsInfo[];
     indexes: SnapshotIndexInfo[];
+    uniques?: SnapshotUniqueInfo[];
     foreignKeys?: ForeignKeyInfo[];
 };
 export type SnapshotIndexInfo = {
@@ -144,11 +147,20 @@ export type SnapshotIndexInfo = {
     columnName: string;
     where?: string;
 };
+export type SnapshotUniqueInfo = {
+    table: string;
+    uniqueName: string;
+    columnName: string;
+};
 export type IndexStatement = {
     name: string;
     properties?: string[];
     where?: string;
 };
+export type UniqueStatement = {
+    name: string;
+    properties?: string[];
+};
 export type ForeignKeyInfo = {
     referencedTableName: string;
     referencedColumnName: string;

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './decorators/property.decorator';
 export * from './decorators/primary-key.decorator';
 export * from './decorators/one-many.decorator';
 export * from './decorators/index.decorator';
+export * from './decorators/unique.decorator';
 export * from './decorators/event-hook.decorator';
 export * from './decorators/enum.decorator';
 export * from './decorators/computed.decorator';

package/dist/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./decorators/property.decorator"), exports);
 __exportStar(require("./decorators/primary-key.decorator"), exports);
 __exportStar(require("./decorators/one-many.decorator"), exports);
 __exportStar(require("./decorators/index.decorator"), exports);
+__exportStar(require("./decorators/unique.decorator"), exports);
 __exportStar(require("./decorators/event-hook.decorator"), exports);
 __exportStar(require("./decorators/enum.decorator"), exports);
 __exportStar(require("./decorators/computed.decorator"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.146",
+  "version": "0.1.147",
   "description": "A simple ORM for Cheetah.js.",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "01d694ffaf36a91a0367d2d79c3f87f43402f62a"
+  "gitHead": "9efbea28c5bb4bdc91e8aa6ba03a634f0a4ab00f"
 }