@cheetah.js/orm 0.1.141 → 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

@@ -12,7 +12,63 @@ var EntityStorage_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 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();
@@ -21,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,
@@ -69,6 +97,10 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
         return this.entities.entries();
     }
     static getInstance() {
+        const scoped = orm_session_context_1.ormSessionContext.getStorage();
+        if (scoped) {
+            return scoped;
+        }
         return EntityStorage_1.instance;
     }
     async snapshot(values) {

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/orm-session-context.d.ts

@@ -0,0 +1,16 @@
+import type { Orm } from './orm';
+import type { EntityStorage } from './domain/entities';
+type OrmSession = {
+    orm: Orm<any>;
+    storage: EntityStorage;
+};
+declare class OrmSessionContext {
+    private storage;
+    constructor();
+    run<T>(session: OrmSession, routine: () => Promise<T>): Promise<T>;
+    getOrm(): Orm<any> | undefined;
+    getStorage(): EntityStorage | undefined;
+    hasContext(): boolean;
+}
+export declare const ormSessionContext: OrmSessionContext;
+export type { OrmSession };

package/dist/orm-session-context.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ormSessionContext = void 0;
+const async_hooks_1 = require("async_hooks");
+class OrmSessionContext {
+    constructor() {
+        this.storage = new async_hooks_1.AsyncLocalStorage();
+    }
+    run(session, routine) {
+        return this.storage.run(session, routine);
+    }
+    getOrm() {
+        return this.storage.getStore()?.orm;
+    }
+    getStorage() {
+        return this.storage.getStore()?.storage;
+    }
+    hasContext() {
+        return this.storage.getStore() !== undefined;
+    }
+}
+exports.ormSessionContext = new OrmSessionContext();

package/dist/orm.js

@@ -15,6 +15,7 @@ const core_1 = require("@cheetah.js/core");
 const SqlBuilder_1 = require("./SqlBuilder");
 const query_cache_manager_1 = require("./cache/query-cache-manager");
 const transaction_context_1 = require("./transaction/transaction-context");
+const orm_session_context_1 = require("./orm-session-context");
 let Orm = Orm_1 = class Orm {
     constructor(logger, cacheService) {
         this.logger = logger;
@@ -28,6 +29,10 @@ let Orm = Orm_1 = class Orm {
         }
     }
     static getInstance() {
+        const scoped = orm_session_context_1.ormSessionContext.getOrm();
+        if (scoped) {
+            return scoped;
+        }
         return Orm_1.instance;
     }
     setConnection(connection) {

package/dist/testing/with-database.js

@@ -45,6 +45,8 @@ const entities_1 = require("../domain/entities");
 const orm_1 = require("../orm");
 const orm_service_1 = require("../orm.service");
 const bun_pg_driver_1 = require("../driver/bun-pg.driver");
+const orm_session_context_1 = require("../orm-session-context");
+const constants_1 = require("../constants");
 const DEFAULT_SCHEMA = 'public';
 const DEFAULT_CONNECTION = {
     host: 'localhost',
@@ -57,6 +59,7 @@ const DEFAULT_CONNECTION = {
 const sessionCache = new Map();
 function getCacheKey(options) {
     const connection = resolveConnection(options.connection);
+    const entitySignature = resolveEntitySignature();
     return JSON.stringify({
         host: connection.host,
         port: connection.port,
@@ -64,8 +67,20 @@ function getCacheKey(options) {
         schema: options.schema ?? DEFAULT_SCHEMA,
         entityFile: options.entityFile,
         migrationPath: connection.migrationPath,
+        entitySignature,
     });
 }
+function resolveEntitySignature() {
+    const entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect) || [];
+    return buildEntitySignature(entities);
+}
+function buildEntitySignature(entities) {
+    if (entities.length < 1) {
+        return 'none';
+    }
+    const names = entities.map((entity) => entity.target?.name ?? 'unknown');
+    return names.sort().join('|');
+}
 async function withDatabase(arg1, arg2, arg3) {
     const { routine: targetRoutine, options: targetOptions, statements } = await normalizeArgs(arg1, arg2, arg3);
     const cacheKey = getCacheKey(targetOptions);
@@ -80,12 +95,13 @@ async function withDatabase(arg1, arg2, arg3) {
         };
         sessionCache.set(cacheKey, cachedSession);
     }
-    activateSession(cachedSession);
-    const context = buildContext(cachedSession.orm);
-    await dropAndRecreateSchema(context, cachedSession.schema);
-    await prepareSchema(context, cachedSession.schema);
-    await createTables(context, schemaStatements);
-    await targetRoutine(context);
+    await runWithSession(cachedSession, async () => {
+        const context = buildContext(cachedSession.orm);
+        await dropAndRecreateSchema(context, cachedSession.schema);
+        await prepareSchema(context, cachedSession.schema);
+        await createTables(context, schemaStatements);
+        await targetRoutine(context);
+    });
 }
 async function createSession(options) {
     const logger = selectLogger(options);
@@ -112,9 +128,8 @@ async function initializeOrm(orm, storage, options) {
     const connection = resolveConnection(options.connection);
     await service.onInit(connection);
 }
-function activateSession(session) {
-    orm_1.Orm.instance = session.orm;
-    entities_1.EntityStorage.instance = session.storage;
+async function runWithSession(session, routine) {
+    await orm_session_context_1.ormSessionContext.run({ orm: session.orm, storage: session.storage }, routine);
 }
 function resolveConnection(overrides) {
     if (!overrides) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.141",
+  "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": "f3f3004bde2d552db43db3ac56b4d286bbfbc7f6"
+  "gitHead": "698043086053a80b0e1fe53adb89ac494ef92f9f"
 }