@cheetah.js/orm 0.1.142 → 0.1.144

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,60 @@ 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;
+}
+```
+
+You can also use the ORM filter syntax in `where` (with `$in`, `$or`, `$nor`, etc.):
+
+```javascript
+@Entity()
+@Index<{ User }>({
+  properties: ['email'],
+  where: {
+    isActive: true,
+    status: { $in: ['active', 'pending'] },
+  },
+})
+export class User {
+  @PrimaryKey()
+  id: number;
+
+  @Property()
+  email: string;
+
+  @Property()
+  isActive: boolean;
+
+  @Property()
+  status: string;
+}
+```
+
+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,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

@@ -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,69 @@ 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");
+const index_condition_builder_1 = require("../query/index-condition-builder");
+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;
+    }
+    if (typeof where === "function") {
+        return where(columnMap);
+    }
+    return buildIndexWhere(where, columnMap);
+}
+function buildIndexWhere(where, columnMap) {
+    const builder = new index_condition_builder_1.IndexConditionBuilder(columnMap);
+    return builder.build(where);
+}
 let EntityStorage = EntityStorage_1 = class EntityStorage {
     constructor() {
         this.entities = new Map();
@@ -22,42 +85,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/dist/query/index-condition-builder.d.ts

@@ -0,0 +1,41 @@
+import { FilterQuery } from '../driver/driver.interface';
+export declare class IndexConditionBuilder<T> {
+    private columnMap;
+    private readonly OPERATORS;
+    private lastKeyNotOperator;
+    constructor(columnMap: Record<string, string>);
+    build(condition: FilterQuery<T>): string;
+    private processConditions;
+    private getEntries;
+    private processEntries;
+    private processEntry;
+    private handleScalarValue;
+    private handleObjectValue;
+    private buildLogicalOperatorCondition;
+    private buildOperatorConditions;
+    private buildOperatorCondition;
+    private buildSimpleCondition;
+    private buildInCondition;
+    private buildNotInCondition;
+    private buildLikeCondition;
+    private buildComparisonCondition;
+    private buildNestedLogicalCondition;
+    private buildNorCondition;
+    private wrapWithLogicalOperator;
+    private extractValueFromValueObject;
+    private formatValue;
+    private formatDate;
+    private isNullish;
+    private isPrimitive;
+    private formatPrimitive;
+    private formatJson;
+    private escapeString;
+    private isScalarValue;
+    private isArrayValue;
+    private isLogicalOperator;
+    private isNorOperator;
+    private extractLogicalOperator;
+    private trackLastNonOperatorKey;
+    private resolveColumnName;
+    private buildNullCondition;
+}

package/dist/query/index-condition-builder.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexConditionBuilder = void 0;
+const value_object_1 = require("../common/value-object");
+const utils_1 = require("../utils");
+class IndexConditionBuilder {
+    constructor(columnMap) {
+        this.columnMap = columnMap;
+        this.OPERATORS = [
+            '$eq',
+            '$ne',
+            '$in',
+            '$nin',
+            '$like',
+            '$gt',
+            '$gte',
+            '$lt',
+            '$lte',
+            '$and',
+            '$or',
+            '$nor',
+        ];
+        this.lastKeyNotOperator = '';
+    }
+    build(condition) {
+        const sqlParts = this.processConditions(condition);
+        if (sqlParts.length === 0) {
+            return '';
+        }
+        return this.wrapWithLogicalOperator(sqlParts, 'AND');
+    }
+    processConditions(condition) {
+        const entries = this.getEntries(condition);
+        return this.processEntries(entries);
+    }
+    getEntries(condition) {
+        if (!condition || typeof condition !== 'object') {
+            return [];
+        }
+        return Object.entries(condition);
+    }
+    processEntries(entries) {
+        const sqlParts = [];
+        for (const [key, value] of entries) {
+            const extractedValue = this.extractValueFromValueObject(value);
+            const conditionSql = this.processEntry(key, extractedValue);
+            if (conditionSql) {
+                sqlParts.push(conditionSql);
+            }
+        }
+        return sqlParts;
+    }
+    processEntry(key, value) {
+        this.trackLastNonOperatorKey(key);
+        if (this.isScalarValue(value)) {
+            return this.handleScalarValue(key, value);
+        }
+        if (this.isArrayValue(key, value)) {
+            return this.buildInCondition(key, value);
+        }
+        return this.handleObjectValue(key, value);
+    }
+    handleScalarValue(key, value) {
+        if (key === '$eq') {
+            return this.buildSimpleCondition(this.lastKeyNotOperator, value, '=');
+        }
+        return this.buildSimpleCondition(key, value, '=');
+    }
+    handleObjectValue(key, value) {
+        if (this.isLogicalOperator(key)) {
+            return this.buildLogicalOperatorCondition(key, value);
+        }
+        if (this.isNorOperator(key)) {
+            return this.buildNorCondition(value);
+        }
+        return this.buildOperatorConditions(key, value);
+    }
+    buildLogicalOperatorCondition(key, value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const operator = this.extractLogicalOperator(key);
+        return this.wrapWithLogicalOperator(conditions, operator);
+    }
+    buildOperatorConditions(key, value) {
+        const parts = [];
+        for (const operator of this.OPERATORS) {
+            if (operator in value) {
+                const condition = this.buildOperatorCondition(key, operator, value[operator]);
+                parts.push(condition);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    buildOperatorCondition(key, operator, value) {
+        switch (operator) {
+            case '$eq':
+                return this.buildSimpleCondition(key, value, '=');
+            case '$ne':
+                return this.buildSimpleCondition(key, value, '!=');
+            case '$in':
+                return this.buildInCondition(key, value);
+            case '$nin':
+                return this.buildNotInCondition(key, value);
+            case '$like':
+                return this.buildLikeCondition(key, value);
+            case '$gt':
+                return this.buildComparisonCondition(key, value, '>');
+            case '$gte':
+                return this.buildComparisonCondition(key, value, '>=');
+            case '$lt':
+                return this.buildComparisonCondition(key, value, '<');
+            case '$lte':
+                return this.buildComparisonCondition(key, value, '<=');
+            case '$and':
+            case '$or':
+                return this.buildNestedLogicalCondition(operator, value);
+            case '$nor':
+                return this.buildNorCondition(value);
+            default:
+                return '';
+        }
+    }
+    buildSimpleCondition(key, value, operator) {
+        const column = this.resolveColumnName(key);
+        if (this.isNullish(value))
+            return this.buildNullCondition(column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${column} ${operator} ${formattedValue}`;
+    }
+    buildInCondition(key, values) {
+        const column = this.resolveColumnName(key);
+        const formattedValues = values.map((val) => this.formatValue(val)).join(', ');
+        return `${column} IN (${formattedValues})`;
+    }
+    buildNotInCondition(key, values) {
+        const column = this.resolveColumnName(key);
+        const formattedValues = values.map((val) => this.formatValue(val)).join(', ');
+        return `${column} NOT IN (${formattedValues})`;
+    }
+    buildLikeCondition(key, value) {
+        const column = this.resolveColumnName(key);
+        return `${column} LIKE '${value}'`;
+    }
+    buildComparisonCondition(key, value, operator) {
+        const column = this.resolveColumnName(key);
+        if (this.isNullish(value))
+            return this.buildNullCondition(column, operator);
+        const formattedValue = this.formatValue(value);
+        return `${column} ${operator} ${formattedValue}`;
+    }
+    buildNestedLogicalCondition(operator, value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const logicalOp = this.extractLogicalOperator(operator);
+        return this.wrapWithLogicalOperator(conditions, logicalOp);
+    }
+    buildNorCondition(value) {
+        const conditions = value.map((cond) => this.build(cond));
+        const wrapped = this.wrapWithLogicalOperator(conditions, 'OR');
+        return `NOT ${wrapped}`;
+    }
+    wrapWithLogicalOperator(conditions, operator) {
+        return `(${conditions.join(` ${operator} `)})`;
+    }
+    extractValueFromValueObject(value) {
+        if ((0, utils_1.extendsFrom)(value_object_1.ValueObject, value?.constructor?.prototype)) {
+            return value.getValue();
+        }
+        return value;
+    }
+    formatValue(value) {
+        if (value instanceof Date)
+            return this.formatDate(value);
+        if (this.isNullish(value))
+            return 'NULL';
+        if (this.isPrimitive(value))
+            return this.formatPrimitive(value);
+        return this.formatJson(value);
+    }
+    formatDate(value) {
+        return `'${value.toISOString()}'`;
+    }
+    isNullish(value) {
+        return value === null || value === undefined;
+    }
+    isPrimitive(value) {
+        return ['string', 'number', 'boolean', 'bigint'].includes(typeof value);
+    }
+    formatPrimitive(value) {
+        if (typeof value === 'string')
+            return `'${this.escapeString(value)}'`;
+        return `${value}`;
+    }
+    formatJson(value) {
+        return `'${this.escapeString(JSON.stringify(value))}'`;
+    }
+    escapeString(value) {
+        return value.replace(/'/g, "''");
+    }
+    isScalarValue(value) {
+        const isDate = value instanceof Date;
+        return typeof value !== 'object' || value === null || isDate;
+    }
+    isArrayValue(key, value) {
+        return !this.OPERATORS.includes(key) && Array.isArray(value);
+    }
+    isLogicalOperator(key) {
+        return ['$or', '$and'].includes(key);
+    }
+    isNorOperator(key) {
+        return key === '$nor';
+    }
+    extractLogicalOperator(key) {
+        return key.toUpperCase().replace('$', '');
+    }
+    trackLastNonOperatorKey(key) {
+        if (!this.OPERATORS.includes(key)) {
+            this.lastKeyNotOperator = key;
+        }
+    }
+    resolveColumnName(property) {
+        if (property.startsWith('$')) {
+            return property;
+        }
+        const column = this.columnMap[property];
+        if (column) {
+            return column;
+        }
+        return (0, utils_1.toSnakeCase)(property);
+    }
+    buildNullCondition(column, operator) {
+        if (operator === '!=' || operator === '<>')
+            return `${column} IS NOT NULL`;
+        return `${column} IS NULL`;
+    }
+}
+exports.IndexConditionBuilder = IndexConditionBuilder;

package/package.json

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