@cheetah.js/orm 0.1.89 → 0.1.91

package/README.md

@@ -123,7 +123,7 @@ export class User {
 }
 ```
 
-For define a index for a multiple properties, add the @Index decorator:
+For define a index for a multiple properties, add the @Index decorator. You can use it on a property or on the class. It accepts either an array of property names (legacy) or an object with a properties field (recommended):
 
 ```javascript
 @Entity()
@@ -134,10 +134,29 @@ export class User {
     @Property()
     name: string;
 
-    @Index(['name', 'email'])
-    @Property()
-    email: string;
-}
+    // Property-level (compound index)
+    @Index({ properties: ['name', 'email'] })
+    @Property()
+    email: string;
+}
+
+// Or, at the class level
+
+@Entity()
+@Index<{ User }>({ properties: ['name', 'email'] })
+export class User {
+  @PrimaryKey()
+  id: number;
+
+  @Property()
+  name: string;
+
+  @Property()
+  email: string;
+}
+
+// Backward compatible usage (array):
+// @Index(['name', 'email'])
 ```
 
 #### Property options

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

@@ -1,3 +1,5 @@
-export declare function Index<T>(options?: {
+type IndexOptions<T> = {
     properties: (keyof T)[];
-}): PropertyDecorator;
+} | (keyof T)[] | undefined;
+export declare function Index<T>(options?: IndexOptions<T>): ClassDecorator & PropertyDecorator;
+export {};

package/dist/decorators/index.decorator.js

@@ -2,18 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Index = Index;
 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('_')}_index`, properties: keys };
+}
+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 indexes = core_1.Metadata.get('indexes', target.constructor) || [];
-        let index;
-        if (options && options.properties) {
-            const properties = options.properties;
-            index = { name: `${properties.join('_')}_index`, properties: options.properties };
-        }
-        else {
-            index = { name: `${propertyKey}_index`, properties: [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, target.constructor);
+        core_1.Metadata.set("indexes", indexes, ctor);
     };
 }

package/dist/domain/entities.js

@@ -28,10 +28,33 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
                 .map(([key]) => key),
             relations,
             indexes: indexes.map((index) => {
+                // Convert property names to database column names
+                const columnNames = index.properties.map(propName => {
+                    // Check if it's a regular property
+                    if (properties[propName]) {
+                        return properties[propName].options.columnName;
+                    }
+                    // Check if it's a relation
+                    const relation = relations.find(rel => String(rel.propertyKey) === propName);
+                    if (relation) {
+                        return relation.columnName;
+                    }
+                    // Fallback to snake_case conversion if not found
+                    return (0, utils_1.toSnakeCase)(propName);
+                });
+                // Preserve the original index name if it's a primary key index (contains _pkey or [TABLE])
+                // Otherwise, generate index name using column names
+                let indexName;
+                if (index.name.includes('_pkey') || index.name.includes('[TABLE]')) {
+                    indexName = index.name.replace("[TABLE]", entityName);
+                }
+                else {
+                    indexName = `${columnNames.join("_")}_index`;
+                }
                 return {
                     table: entityName,
-                    indexName: index.name.replace("[TABLE]", entityName),
-                    columnName: index.properties.join(","),
+                    indexName,
+                    columnName: columnNames.join(","),
                 };
             }),
             hooks,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.89",
+  "version": "0.1.91",
   "description": "A simple ORM for Cheetah.js",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -37,7 +37,7 @@
     "uuid": "^9.0.1"
   },
   "peerDependencies": {
-    "@cheetah.js/core": "^0.1.35"
+    "@cheetah.js/core": "^0.1.90"
   },
   "author": "",
   "license": "MIT",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "466942b8f3150372473238d0860408d0651ddd39"
+  "gitHead": "f173c0f552aac5f22debe446c8192abd5a80d9a3"
 }