ts-prorm-orm 1.2.3 → 2.1.0

package/dist/core/expressions.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Raw SQL expression wrappers used by the Prorm instance API.
+ *
+ * `Literal` embeds SQL verbatim; `Col` references a column without quoting it
+ * as a value. Note that `src/operators.ts` also exposes `literal()`/`col()`
+ * factories producing a different shape - the dialects consume the operators
+ * form, so prefer those in new code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Col = exports.Literal = void 0;
+/**
+ * Represents a raw SQL literal value
+ * Used for inserting raw SQL expressions into queries
+ *
+ * @example
+ * // Use in default values
+ * createdAt: { type: DATE, defaultValue: prorm.literal('NOW()') }
+ *
+ * @example
+ * // Use in updates
+ * User.update({ count: prorm.literal('count + 1') }, {...})
+ *
+ * @example
+ * // Use in select with calculations
+ * User.findAll({ attributes: [[prorm.literal('1 + 1'), 'two']] })
+ */
+class Literal {
+    constructor(sql) {
+        this.val = sql;
+    }
+    /**
+     * Get the raw SQL string
+     */
+    toString() {
+        return this.val;
+    }
+}
+exports.Literal = Literal;
+/**
+ * Class representing a column reference for use with Prorm functions
+ * Used to create properly quoted column identifiers
+ *
+ * @example
+ * // Single column: col('name') -> "name"
+ * // Table and column: col('User', 'name') -> "User"."name"
+ * // Dot notation: col('table.column') -> "table"."column"
+ */
+class Col {
+    /**
+     * Create a column reference
+     * @param tableOrColumn - Table name (if second param provided) or column name
+     * @param column - Column name (if first param is table name)
+     */
+    constructor(tableOrColumn, column) {
+        if (column !== undefined) {
+            // col('User', 'name') -> "User"."name"
+            this.col = `"${tableOrColumn}"."${column}"`;
+        }
+        else if (tableOrColumn.includes('.')) {
+            // col('table.column') -> "table"."column"
+            const [table, col] = tableOrColumn.split('.');
+            this.col = `"${table}"."${col}"`;
+        }
+        else {
+            // col('name') -> "name"
+            this.col = `"${tableOrColumn}"`;
+        }
+    }
+    /**
+     * Get the SQL representation of the column
+     */
+    toSql() {
+        return this.col;
+    }
+    /**
+     * Get the column as a string
+     */
+    toString() {
+        return this.col;
+    }
+}
+exports.Col = Col;

package/dist/core/hooks-manager.d.ts

@@ -0,0 +1,179 @@
+/**
+ * Lifecycle hook registries for a Prorm instance.
+ *
+ * `HooksManager` holds instance-wide hooks (define/sync/connect/destroy/...);
+ * `ModelHooks` holds the per-model set. Both were declared inline in prorm.ts,
+ * above the Prorm class.
+ *
+ * Not to be confused with `src/hooks/hooks-manager.ts` - a separate,
+ * currently unreferenced model-level hook system that shares the class name.
+ */
+import type { HookCallback, Connection, SyncOptions } from './types';
+import type { AttributeOptions, ModelStatic, DestroyOptions, ReloadOptions } from '../types';
+import type { ModelOptions as ModelOptionsType } from '../types';
+/** Loose model type, matching the alias prorm.ts uses. */
+type AnyModel = any;
+/**
+ * Hook manager for Prorm instance
+ */
+export declare class HooksManager {
+    private beforeDefineHooks;
+    private afterDefineHooks;
+    private beforeSyncHooks;
+    private afterSyncHooks;
+    private beforeConnectHooks;
+    private afterConnectHooks;
+    private beforeDisconnectHooks;
+    private afterDisconnectHooks;
+    private beforeDestroyHooks;
+    private afterDestroyHooks;
+    private beforeUpsertHooks;
+    private afterUpsertHooks;
+    private beforeReloadHooks;
+    /**
+     * Register a beforeDefine hook
+     */
+    beforeDefine(callback: HookCallback): void;
+    /**
+     * Register an afterDefine hook
+     */
+    afterDefine(callback: HookCallback): void;
+    /**
+     * Register a beforeSync hook
+     */
+    beforeSync(callback: HookCallback): void;
+    /**
+     * Register an afterSync hook
+     */
+    afterSync(callback: HookCallback): void;
+    /**
+     * Register a beforeConnect hook
+     */
+    beforeConnect(callback: HookCallback): void;
+    /**
+     * Register an afterConnect hook
+     */
+    afterConnect(callback: HookCallback): void;
+    /**
+     * Register a beforeDisconnect hook
+     */
+    beforeDisconnect(callback: HookCallback): void;
+    /**
+     * Register an afterDisconnect hook
+     */
+    afterDisconnect(callback: HookCallback): void;
+    /**
+     * Register a beforeDestroy hook
+     */
+    beforeDestroy(callback: HookCallback): void;
+    /**
+     * Register an afterDestroy hook
+     */
+    afterDestroy(callback: HookCallback): void;
+    /**
+     * Register a beforeUpsert hook
+     */
+    beforeUpsert(callback: HookCallback): void;
+    /**
+     * Register an afterUpsert hook
+     */
+    afterUpsert(callback: HookCallback): void;
+    /**
+     * Register a beforeReload hook
+     */
+    beforeReload(callback: HookCallback): void;
+    /**
+     * Execute all beforeDefine hooks
+     */
+    runBeforeDefine(modelName: string, attributes: Record<string, AttributeOptions>, options: ModelOptionsType): Promise<void>;
+    /**
+     * Execute all afterDefine hooks
+     */
+    runAfterDefine(model: ModelStatic<AnyModel>): Promise<void>;
+    /**
+     * Execute all beforeSync hooks
+     */
+    runBeforeSync(options: SyncOptions): Promise<void>;
+    /**
+     * Execute all afterSync hooks
+     */
+    runAfterSync(options: SyncOptions): Promise<void>;
+    /**
+     * Execute all beforeConnect hooks
+     */
+    runBeforeConnect(): Promise<void>;
+    /**
+     * Execute all afterConnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    runAfterConnect(connection: Connection): Promise<void>;
+    /**
+     * Execute all beforeDisconnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    runBeforeDisconnect(connection: Connection): Promise<void>;
+    /**
+     * Execute all afterDisconnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    runAfterDisconnect(connection: Connection): Promise<void>;
+    /**
+     * Execute all beforeDestroy hooks
+     * @param options - The destroy options
+     */
+    runBeforeDestroy(options: DestroyOptions): Promise<void>;
+    /**
+     * Execute all afterDestroy hooks
+     * @param options - The destroy options
+     */
+    runAfterDestroy(options: DestroyOptions): Promise<void>;
+    /**
+     * Execute all beforeUpsert hooks
+     * @param options - The upsert options
+     */
+    runBeforeUpsert(options: any): Promise<void>;
+    /**
+     * Execute all afterUpsert hooks
+     * @param options - The upsert options
+     */
+    runAfterUpsert(options: any): Promise<void>;
+    /**
+     * Execute all beforeReload hooks
+     * @param options - The reload options
+     */
+    runBeforeReload(options: ReloadOptions): Promise<void>;
+    /**
+     * Add a hook by name
+     * @param hookName - The name of the hook (e.g., 'beforeDefine', 'afterSync')
+     * @param callback - The hook callback function
+     */
+    addHook(hookName: string, callback: HookCallback): void;
+    /**
+     * Clear all hooks
+     */
+    clearHooks(): void;
+}
+/**
+ * Model-level hooks manager
+ */
+export declare class ModelHooks {
+    private beforeSyncHooks;
+    private afterSyncHooks;
+    /**
+     * Register a beforeSync hook on the model
+     */
+    beforeSync(callback: HookCallback): void;
+    /**
+     * Register an afterSync hook on the model
+     */
+    afterSync(callback: HookCallback): void;
+    /**
+     * Run beforeSync hooks
+     */
+    runBeforeSync(options: SyncOptions): Promise<void>;
+    /**
+     * Run afterSync hooks
+     */
+    runAfterSync(options: SyncOptions): Promise<void>;
+}
+export {};

package/dist/core/hooks-manager.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * Lifecycle hook registries for a Prorm instance.
+ *
+ * `HooksManager` holds instance-wide hooks (define/sync/connect/destroy/...);
+ * `ModelHooks` holds the per-model set. Both were declared inline in prorm.ts,
+ * above the Prorm class.
+ *
+ * Not to be confused with `src/hooks/hooks-manager.ts` - a separate,
+ * currently unreferenced model-level hook system that shares the class name.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelHooks = exports.HooksManager = void 0;
+/**
+ * Hook manager for Prorm instance
+ */
+class HooksManager {
+    constructor() {
+        this.beforeDefineHooks = [];
+        this.afterDefineHooks = [];
+        this.beforeSyncHooks = [];
+        this.afterSyncHooks = [];
+        this.beforeConnectHooks = [];
+        this.afterConnectHooks = [];
+        this.beforeDisconnectHooks = [];
+        this.afterDisconnectHooks = [];
+        this.beforeDestroyHooks = [];
+        this.afterDestroyHooks = [];
+        this.beforeUpsertHooks = [];
+        this.afterUpsertHooks = [];
+        this.beforeReloadHooks = [];
+    }
+    /**
+     * Register a beforeDefine hook
+     */
+    beforeDefine(callback) {
+        this.beforeDefineHooks.push(callback);
+    }
+    /**
+     * Register an afterDefine hook
+     */
+    afterDefine(callback) {
+        this.afterDefineHooks.push(callback);
+    }
+    /**
+     * Register a beforeSync hook
+     */
+    beforeSync(callback) {
+        this.beforeSyncHooks.push(callback);
+    }
+    /**
+     * Register an afterSync hook
+     */
+    afterSync(callback) {
+        this.afterSyncHooks.push(callback);
+    }
+    /**
+     * Register a beforeConnect hook
+     */
+    beforeConnect(callback) {
+        this.beforeConnectHooks.push(callback);
+    }
+    /**
+     * Register an afterConnect hook
+     */
+    afterConnect(callback) {
+        this.afterConnectHooks.push(callback);
+    }
+    /**
+     * Register a beforeDisconnect hook
+     */
+    beforeDisconnect(callback) {
+        this.beforeDisconnectHooks.push(callback);
+    }
+    /**
+     * Register an afterDisconnect hook
+     */
+    afterDisconnect(callback) {
+        this.afterDisconnectHooks.push(callback);
+    }
+    /**
+     * Register a beforeDestroy hook
+     */
+    beforeDestroy(callback) {
+        this.beforeDestroyHooks.push(callback);
+    }
+    /**
+     * Register an afterDestroy hook
+     */
+    afterDestroy(callback) {
+        this.afterDestroyHooks.push(callback);
+    }
+    /**
+     * Register a beforeUpsert hook
+     */
+    beforeUpsert(callback) {
+        this.beforeUpsertHooks.push(callback);
+    }
+    /**
+     * Register an afterUpsert hook
+     */
+    afterUpsert(callback) {
+        this.afterUpsertHooks.push(callback);
+    }
+    /**
+     * Register a beforeReload hook
+     */
+    beforeReload(callback) {
+        this.beforeReloadHooks.push(callback);
+    }
+    /**
+     * Execute all beforeDefine hooks
+     */
+    async runBeforeDefine(modelName, attributes, options) {
+        for (const hook of this.beforeDefineHooks) {
+            await hook({ modelName, attributes, options });
+        }
+    }
+    /**
+     * Execute all afterDefine hooks
+     */
+    async runAfterDefine(model) {
+        for (const hook of this.afterDefineHooks) {
+            await hook({ model });
+        }
+    }
+    /**
+     * Execute all beforeSync hooks
+     */
+    async runBeforeSync(options) {
+        for (const hook of this.beforeSyncHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Execute all afterSync hooks
+     */
+    async runAfterSync(options) {
+        for (const hook of this.afterSyncHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Execute all beforeConnect hooks
+     */
+    async runBeforeConnect() {
+        for (const hook of this.beforeConnectHooks) {
+            await hook();
+        }
+    }
+    /**
+     * Execute all afterConnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    async runAfterConnect(connection) {
+        for (const hook of this.afterConnectHooks) {
+            await hook(connection);
+        }
+    }
+    /**
+     * Execute all beforeDisconnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    async runBeforeDisconnect(connection) {
+        for (const hook of this.beforeDisconnectHooks) {
+            await hook(connection);
+        }
+    }
+    /**
+     * Execute all afterDisconnect hooks
+     * @param connection - The connection object to pass to hooks
+     */
+    async runAfterDisconnect(connection) {
+        for (const hook of this.afterDisconnectHooks) {
+            await hook(connection);
+        }
+    }
+    /**
+     * Execute all beforeDestroy hooks
+     * @param options - The destroy options
+     */
+    async runBeforeDestroy(options) {
+        for (const hook of this.beforeDestroyHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Execute all afterDestroy hooks
+     * @param options - The destroy options
+     */
+    async runAfterDestroy(options) {
+        for (const hook of this.afterDestroyHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Execute all beforeUpsert hooks
+     * @param options - The upsert options
+     */
+    async runBeforeUpsert(options) {
+        for (const hook of this.beforeUpsertHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Execute all afterUpsert hooks
+     * @param options - The upsert options
+     */
+    async runAfterUpsert(options) {
+        for (const hook of this.afterUpsertHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Execute all beforeReload hooks
+     * @param options - The reload options
+     */
+    async runBeforeReload(options) {
+        for (const hook of this.beforeReloadHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Add a hook by name
+     * @param hookName - The name of the hook (e.g., 'beforeDefine', 'afterSync')
+     * @param callback - The hook callback function
+     */
+    addHook(hookName, callback) {
+        const methodName = hookName;
+        if (typeof this[methodName] === 'function') {
+            this[methodName](callback);
+        }
+    }
+    /**
+     * Clear all hooks
+     */
+    clearHooks() {
+        this.beforeDefineHooks = [];
+        this.afterDefineHooks = [];
+        this.beforeSyncHooks = [];
+        this.afterSyncHooks = [];
+        this.beforeConnectHooks = [];
+        this.afterConnectHooks = [];
+        this.beforeDisconnectHooks = [];
+        this.afterDisconnectHooks = [];
+        this.beforeDestroyHooks = [];
+        this.afterDestroyHooks = [];
+        this.beforeUpsertHooks = [];
+        this.afterUpsertHooks = [];
+        this.beforeReloadHooks = [];
+    }
+}
+exports.HooksManager = HooksManager;
+/**
+ * Model-level hooks manager
+ */
+class ModelHooks {
+    constructor() {
+        this.beforeSyncHooks = [];
+        this.afterSyncHooks = [];
+    }
+    /**
+     * Register a beforeSync hook on the model
+     */
+    beforeSync(callback) {
+        this.beforeSyncHooks.push(callback);
+    }
+    /**
+     * Register an afterSync hook on the model
+     */
+    afterSync(callback) {
+        this.afterSyncHooks.push(callback);
+    }
+    /**
+     * Run beforeSync hooks
+     */
+    async runBeforeSync(options) {
+        for (const hook of this.beforeSyncHooks) {
+            await hook({ options });
+        }
+    }
+    /**
+     * Run afterSync hooks
+     */
+    async runAfterSync(options) {
+        for (const hook of this.afterSyncHooks) {
+            await hook({ options });
+        }
+    }
+}
+exports.ModelHooks = ModelHooks;