@cheetah.js/orm 0.1.142 → 0.1.143

package/README.md

@@ -124,7 +124,7 @@ export class User {
 }
 ```
 
-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):
+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()
@@ -156,12 +156,34 @@ export class User {
   email: string;
 }
 
-// Backward compatible usage (array):
-// @Index(['name', 'email'])
-```
-
-#### Property options
-| Option | Type | Description                                                                                |
+// Backward compatible usage (array):
+// @Index(['name', 'email'])
+```
+
+Partial indexes (Postgres only) can be declared with `where`. You can provide a raw SQL string or a typed callback that receives the column map (with autocomplete based on your entity):
+
+```javascript
+@Entity()
+@Index<{ User }>({
+  properties: ['email'],
+  where: (columns) => `${columns.isActive} = true`,
+})
+export class User {
+  @PrimaryKey()
+  id: number;
+
+  @Property()
+  email: string;
+
+  @Property()
+  isActive: boolean;
+}
+```
+
+Note: MySQL does not support partial indexes; using `where` with the MySQL driver will throw.
+
+#### Property options
+| Option | Type | Description                                                                                |
 | ------ | ---- |--------------------------------------------------------------------------------------------|
 | nullable | boolean | Defines if the property is nullable.                                                       |
 | unique | boolean | Defines if the property is unique.                                                         |

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

@@ -1,5 +1,15 @@
+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 IndexDefinition = {
+    name: string;
+    properties: string[];
+    where?: IndexPredicate<any>;
+};
 type IndexOptions<T> = {
     properties: (keyof T)[];
+    where?: IndexPredicate<T>;
 } | (keyof T)[] | undefined;
 export declare function Index<T>(options?: IndexOptions<T>): ClassDecorator & PropertyDecorator;
 export {};

package/dist/decorators/index.decorator.js

@@ -10,7 +10,8 @@ function buildFromOptions(options) {
     if (!props || props.length === 0)
         return null;
     const keys = props;
-    return { name: `${keys.join('_')}_index`, properties: keys };
+    const where = Array.isArray(options) ? undefined : options?.where;
+    return { name: `${keys.join('_')}_index`, properties: keys, where };
 }
 function buildFromProperty(propertyKey) {
     const name = String(propertyKey);

package/dist/domain/entities.js

@@ -14,6 +14,61 @@ exports.EntityStorage = void 0;
 const core_1 = require("@cheetah.js/core");
 const orm_session_context_1 = require("../orm-session-context");
 const utils_1 = require("../utils");
+function buildIndexColumnMap(properties, relations) {
+    const map = mapPropertyColumns(properties);
+    addRelationColumns(map, relations);
+    return map;
+}
+function mapPropertyColumns(properties) {
+    const map = {};
+    Object.entries(properties).forEach(([key, value]) => {
+        map[key] = value.options.columnName;
+    });
+    return map;
+}
+function addRelationColumns(map, relations) {
+    relations.forEach((relation) => {
+        map[String(relation.propertyKey)] = relation.columnName;
+    });
+}
+function mapIndexDefinitions(indexes, entityName, columnMap) {
+    return indexes.map((index) => toSnapshotIndex(index, entityName, columnMap));
+}
+function toSnapshotIndex(index, entityName, columnMap) {
+    const columns = resolveIndexColumns(index, columnMap);
+    const indexName = resolveIndexName(index.name, entityName, columns);
+    return {
+        table: entityName,
+        indexName,
+        columnName: columns.join(","),
+        where: resolveIndexWhere(index.where, columnMap),
+    };
+}
+function resolveIndexColumns(index, columnMap) {
+    return index.properties.map((propName) => resolveIndexColumn(propName, columnMap));
+}
+function resolveIndexColumn(propName, columnMap) {
+    const mapped = columnMap[propName];
+    if (mapped) {
+        return mapped;
+    }
+    return (0, utils_1.toSnakeCase)(propName);
+}
+function resolveIndexName(name, entityName, columns) {
+    if (name.includes('_pkey') || name.includes('[TABLE]')) {
+        return name.replace("[TABLE]", entityName);
+    }
+    return `${columns.join("_")}_index`;
+}
+function resolveIndexWhere(where, columnMap) {
+    if (!where) {
+        return undefined;
+    }
+    if (typeof where === "string") {
+        return where;
+    }
+    return where(columnMap);
+}
 let EntityStorage = EntityStorage_1 = class EntityStorage {
     constructor() {
         this.entities = new Map();
@@ -22,42 +77,14 @@ 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 columnMap = buildIndexColumnMap(properties, relations);
         this.entities.set(entity.target, {
             properties: properties,
             hideProperties: Object.entries(properties)
                 .filter(([_key, value]) => value.options.hidden)
                 .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,
-                    columnName: columnNames.join(","),
-                };
-            }),
+            indexes: mapIndexDefinitions(indexes, entityName, columnMap),
             hooks,
             tableName: entityName,
             ...entity.options,

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

@@ -1,4 +1,4 @@
-import { ColDiff, ConnectionSettings, DriverInterface, ForeignKeyInfo, SnapshotConstraintInfo, SnapshotIndexInfo, SnapshotTable, Statement } from './driver.interface';
+import { ColDiff, ConnectionSettings, DriverInterface, ForeignKeyInfo, IndexStatement, SnapshotConstraintInfo, SnapshotIndexInfo, SnapshotTable, Statement } from './driver.interface';
 import { BunDriverBase } from './bun-driver.base';
 export declare class BunMysqlDriver extends BunDriverBase implements DriverInterface {
     readonly dbType: "mysql";
@@ -19,10 +19,7 @@ export declare class BunMysqlDriver extends BunDriverBase implements DriverInter
     protected buildLimitAndOffsetClause(statement: Statement<any>): string;
     getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
     getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo): string;
-    getCreateIndex(index: {
-        name: string;
-        properties: string[];
-    }, schema: string | undefined, tableName: string): string;
+    getCreateIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
     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: {

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

@@ -95,7 +95,15 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
         return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${tableName}_${colDiff.colName}_fk\` FOREIGN KEY (\`${colDiff.colName}\`) REFERENCES \`${fk.referencedTableName}\` (\`${fk.referencedColumnName}\`);`;
     }
     getCreateIndex(index, schema, tableName) {
-        return `CREATE INDEX \`${index.name}\` ON \`${schema}\`.\`${tableName}\` (${index.properties.map((prop) => `\`${prop}\``).join(', ')});`;
+        const properties = index.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Index properties are required.");
+        }
+        if (index.where) {
+            throw new Error("Partial indexes are only supported on postgres.");
+        }
+        const columns = properties.map((prop) => `\`${prop}\``).join(', ');
+        return `CREATE INDEX \`${index.name}\` ON \`${schema}\`.\`${tableName}\` (${columns});`;
     }
     getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions) {
         let sql = ``;

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

@@ -1,4 +1,4 @@
-import { ColDiff, ConnectionSettings, DriverInterface, ForeignKeyInfo, SnapshotConstraintInfo, SnapshotIndexInfo, SnapshotTable, Statement } from './driver.interface';
+import { ColDiff, ConnectionSettings, DriverInterface, ForeignKeyInfo, IndexStatement, SnapshotConstraintInfo, SnapshotIndexInfo, SnapshotTable, Statement } from './driver.interface';
 import { BunDriverBase } from './bun-driver.base';
 export declare class BunPgDriver extends BunDriverBase implements DriverInterface {
     readonly dbType: "postgres";
@@ -18,10 +18,7 @@ export declare class BunPgDriver extends BunDriverBase implements DriverInterfac
     }>;
     getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
     getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo): string;
-    getCreateIndex(index: {
-        name: string;
-        properties: string[];
-    }, schema: string | undefined, tableName: string): string;
+    getCreateIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
     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: {

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

@@ -70,7 +70,13 @@ class BunPgDriver extends bun_driver_base_1.BunDriverBase {
         return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${tableName}_${colDiff.colName}_fk" FOREIGN KEY ("${colDiff.colName}") REFERENCES "${fk.referencedTableName}" ("${fk.referencedColumnName}");`;
     }
     getCreateIndex(index, schema, tableName) {
-        return `CREATE INDEX "${index.name}" ON "${schema}"."${tableName}" (${index.properties.map((prop) => `"${prop}"`).join(', ')});`;
+        const properties = index.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Index properties are required.");
+        }
+        const columns = properties.map((prop) => `"${prop}"`).join(', ');
+        const where = this.buildWhereClause(index.where);
+        return `CREATE INDEX "${index.name}" ON "${schema}"."${tableName}" (${columns})${where};`;
     }
     getAddColumn(schema, tableName, colName, colDiff, colDiffInstructions) {
         let beforeSql = ``;

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

@@ -16,16 +16,10 @@ export interface DriverInterface {
     snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined>;
     getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
     getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo): string;
-    getCreateIndex(index: {
-        name: string;
-        properties?: string[];
-    }, schema: string | undefined, tableName: string): string;
+    getCreateIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
     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: {
-        name: string;
-        properties?: string[];
-    }, schema: string | undefined, tableName: string): string;
+    getDropIndex(index: IndexStatement, 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;
@@ -148,6 +142,12 @@ export type SnapshotIndexInfo = {
     table: string;
     indexName: string;
     columnName: string;
+    where?: string;
+};
+export type IndexStatement = {
+    name: string;
+    properties?: string[];
+    where?: string;
 };
 export type ForeignKeyInfo = {
     referencedTableName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.142",
+  "version": "0.1.143",
   "description": "A simple ORM for Cheetah.js.",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "eb70114c61e3b2467bf063bade66ba6cba9ed4cf"
+  "gitHead": "698043086053a80b0e1fe53adb89ac494ef92f9f"
 }