ts-prorm-orm 1.1.0

package/dist/foreign-data.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * Foreign Data Wrapper (FDW) support for PostgreSQL
+ *
+ * Provides management of:
+ *  - Foreign servers  (CREATE/ALTER/DROP FOREIGN SERVER)
+ *  - User mappings    (CREATE/ALTER/DROP USER MAPPING)
+ *  - Foreign tables   (CREATE/DROP FOREIGN TABLE, IMPORT FOREIGN SCHEMA)
+ *
+ * FDW is a PostgreSQL-only feature; attempting to use these APIs with SQLite
+ * or MySQL will throw a DatabaseError.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForeignDataManager = exports.KNOWN_FDWS = void 0;
+exports.buildOptionsClause = buildOptionsClause;
+// ---------------------------------------------------------------------------
+// Well-known FDW extension names
+// ---------------------------------------------------------------------------
+/**
+ * Catalog of well-known Foreign Data Wrapper extension names.
+ */
+exports.KNOWN_FDWS = {
+    POSTGRES: 'postgres_fdw', // PostgreSQL -> PostgreSQL
+    MYSQL: 'mysql_fdw', // PostgreSQL -> MySQL/MariaDB
+    REDIS: 'redis_fdw', // PostgreSQL -> Redis
+    MONGO: 'mongo_fdw', // PostgreSQL -> MongoDB
+    FILE: 'file_fdw', // PostgreSQL -> CSV/files (built-in)
+    S3: 'parquet_s3_fdw', // PostgreSQL -> S3/Parquet
+    SQLITE: 'sqlite_fdw', // PostgreSQL -> SQLite
+    ORACLE: 'oracle_fdw', // PostgreSQL -> Oracle
+    ODBC: 'odbc_fdw', // PostgreSQL -> any ODBC source
+    TDS: 'tds_fdw', // PostgreSQL -> SQL Server/Sybase
+    CSTORE: 'cstore_fdw', // Columnar storage
+    MULTICORN: 'multicorn', // Python-based FDW framework
+};
+// ---------------------------------------------------------------------------
+// ForeignDataManager
+// ---------------------------------------------------------------------------
+/**
+ * Manages Foreign Data Wrapper objects (servers, user mappings, foreign tables)
+ * for a Prorm instance.
+ *
+ * All operations delegate SQL generation to the underlying dialect so that
+ * non-PostgreSQL dialects can throw meaningful errors at a single point.
+ */
+class ForeignDataManager {
+    constructor(prorm) {
+        this.prorm = prorm;
+    }
+    // -------------------------------------------------------------------------
+    // Foreign Servers
+    // -------------------------------------------------------------------------
+    /**
+     * CREATE FOREIGN SERVER
+     */
+    async createServer(name, opts) {
+        const sql = this.prorm.dialect.buildCreateServerQuery(name, opts);
+        await this.prorm.dialect.query(sql);
+    }
+    /**
+     * ALTER FOREIGN SERVER
+     */
+    async alterServer(name, opts) {
+        const sql = this.prorm.dialect.buildAlterServerQuery(name, opts);
+        await this.prorm.dialect.query(sql);
+    }
+    /**
+     * DROP FOREIGN SERVER
+     */
+    async dropServer(name, opts) {
+        const sql = this.prorm.dialect.buildDropServerQuery(name, opts);
+        await this.prorm.dialect.query(sql);
+    }
+    /**
+     * List all foreign servers visible in the current database.
+     */
+    async getServers() {
+        const sql = this.prorm.dialect.getServersQuery();
+        const result = await this.prorm.dialect.query(sql, { raw: true });
+        return (result.rows ?? []).map((row) => ({
+            name: row.srvname,
+            fdw: row.fdwname,
+            options: parsePgOptions(row.srvoptions),
+        }));
+    }
+    /**
+     * Return true if a foreign server with the given name exists.
+     */
+    async serverExists(name) {
+        const servers = await this.getServers();
+        return servers.some((s) => s.name === name);
+    }
+    // -------------------------------------------------------------------------
+    // User Mappings
+    // -------------------------------------------------------------------------
+    /**
+     * CREATE USER MAPPING
+     */
+    async createUserMapping(opts) {
+        const sql = this.prorm.dialect.buildCreateUserMappingQuery(opts);
+        await this.prorm.dialect.query(sql);
+    }
+    /**
+     * ALTER USER MAPPING (re-uses the same SQL builder as CREATE with altered keywords)
+     */
+    async alterUserMapping(opts) {
+        const sql = this.prorm.dialect.buildAlterUserMappingQuery(opts);
+        await this.prorm.dialect.query(sql);
+    }
+    /**
+     * DROP USER MAPPING
+     */
+    async dropUserMapping(serverName, user = 'CURRENT_USER', opts) {
+        const sql = this.prorm.dialect.buildDropUserMappingQuery(serverName, user, opts);
+        await this.prorm.dialect.query(sql);
+    }
+    // -------------------------------------------------------------------------
+    // Foreign Tables
+    // -------------------------------------------------------------------------
+    /**
+     * CREATE FOREIGN TABLE
+     */
+    async createForeignTable(tableName, opts) {
+        const sql = this.prorm.dialect.buildCreateForeignTableQuery(tableName, opts);
+        await this.prorm.dialect.query(sql);
+    }
+    /**
+     * DROP FOREIGN TABLE
+     */
+    async dropForeignTable(tableName, opts) {
+        const sql = this.prorm.dialect.buildDropForeignTableQuery(tableName, opts);
+        await this.prorm.dialect.query(sql);
+    }
+    /**
+     * IMPORT FOREIGN SCHEMA
+     */
+    async importForeignSchema(remoteSchema, serverName, opts) {
+        const sql = this.prorm.dialect.buildImportForeignSchemaQuery(remoteSchema, serverName, opts);
+        await this.prorm.dialect.query(sql);
+    }
+}
+exports.ForeignDataManager = ForeignDataManager;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse a PostgreSQL options array (e.g. ['"host=localhost"', '"port=5432"'])
+ * into a plain Record<string, string>.
+ */
+function parsePgOptions(raw) {
+    if (!raw || !Array.isArray(raw))
+        return {};
+    const out = {};
+    for (const item of raw) {
+        // Items come back as 'key=value' or '"key=value"'
+        const cleaned = item.replace(/^"(.*)"$/, '$1');
+        const eqIdx = cleaned.indexOf('=');
+        if (eqIdx === -1)
+            continue;
+        const key = cleaned.slice(0, eqIdx);
+        const val = cleaned.slice(eqIdx + 1);
+        out[key] = val;
+    }
+    return out;
+}
+/**
+ * Build a PostgreSQL OPTIONS (...) clause from a plain object.
+ * Each value is single-quoted and existing single quotes are escaped.
+ */
+function buildOptionsClause(opts) {
+    const pairs = Object.entries(opts).map(([k, v]) => `${k} '${v.replace(/'/g, "''")}'`);
+    return `OPTIONS (${pairs.join(', ')})`;
+}

package/dist/hooks/hooks-manager.js

@@ -0,0 +1,350 @@
+"use strict";
+/**
+ * Hooks Manager for the TypeScript ORM
+ * Provides a centralized system for managing Prorm-style model hooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HooksManager = void 0;
+exports.createHooksObject = createHooksObject;
+exports.addHookMethods = addHookMethods;
+exports.beforeValidate = beforeValidate;
+exports.afterValidate = afterValidate;
+exports.beforeCreate = beforeCreate;
+exports.afterCreate = afterCreate;
+exports.beforeUpdate = beforeUpdate;
+exports.afterUpdate = afterUpdate;
+exports.beforeDestroy = beforeDestroy;
+exports.afterDestroy = afterDestroy;
+exports.beforeSave = beforeSave;
+exports.afterSave = afterSave;
+exports.beforeBulkCreate = beforeBulkCreate;
+exports.afterBulkCreate = afterBulkCreate;
+exports.beforeBulkUpdate = beforeBulkUpdate;
+exports.afterBulkUpdate = afterBulkUpdate;
+exports.beforeBulkDestroy = beforeBulkDestroy;
+exports.afterBulkDestroy = afterBulkDestroy;
+exports.beforeFind = beforeFind;
+exports.afterFind = afterFind;
+// ==================== Hooks Manager Class ====================
+/**
+ * HooksManager - Manages all lifecycle hooks for a model
+ */
+class HooksManager {
+    constructor(modelName = 'AnonymousModel') {
+        this.hooks = new Map();
+        this.modelName = modelName;
+        this.initializeHooks();
+    }
+    /**
+     * Initialize all hook types as empty Sets
+     */
+    initializeHooks() {
+        const hookNames = [
+            'beforeValidate',
+            'afterValidate',
+            'beforeCreate',
+            'afterCreate',
+            'beforeUpdate',
+            'afterUpdate',
+            'beforeDestroy',
+            'afterDestroy',
+            'beforeSave',
+            'afterSave',
+            'beforeBulkCreate',
+            'afterBulkCreate',
+            'beforeBulkUpdate',
+            'afterBulkUpdate',
+            'beforeBulkDestroy',
+            'afterBulkDestroy',
+            'beforeFind',
+            'afterFind',
+        ];
+        for (const hookName of hookNames) {
+            this.hooks.set(hookName, new Set());
+        }
+    }
+    /**
+     * Get all hooks
+     */
+    getHooks() {
+        return this.hooks;
+    }
+    /**
+     * Get hooks for a specific hook name
+     */
+    getHook(hookName) {
+        return this.hooks.get(hookName) || new Set();
+    }
+    /**
+     * Add a hook callback
+     */
+    addHook(hookName, callback) {
+        const normalizedName = this.normalizeHookName(hookName);
+        if (!this.hooks.has(normalizedName)) {
+            this.hooks.set(normalizedName, new Set());
+        }
+        const hookSet = this.hooks.get(normalizedName);
+        hookSet.add(callback);
+        return this;
+    }
+    /**
+     * Remove a hook callback
+     */
+    removeHook(hookName, callback) {
+        const normalizedName = this.normalizeHookName(hookName);
+        const hookSet = this.hooks.get(normalizedName);
+        if (hookSet) {
+            hookSet.delete(callback);
+        }
+        return this;
+    }
+    /**
+     * Run all callbacks for a specific hook
+     */
+    async runHook(hookName, ...args) {
+        const normalizedName = this.normalizeHookName(hookName);
+        const hookSet = this.hooks.get(normalizedName);
+        if (!hookSet || hookSet.size === 0) {
+            return;
+        }
+        const isBulkHook = normalizedName.startsWith('beforeBulk') || normalizedName.startsWith('afterBulk');
+        const isFindHook = normalizedName === 'beforeFind' || normalizedName === 'afterFind';
+        for (const callback of hookSet) {
+            try {
+                if (isBulkHook) {
+                    // Bulk hooks receive (instances, options)
+                    await callback(args[0], args[1]);
+                }
+                else if (isFindHook) {
+                    // Find hooks receive (options)
+                    await callback(args[0]);
+                }
+                else {
+                    // Instance hooks receive (instance, options)
+                    await callback(args[0], args[1]);
+                }
+            }
+            catch (error) {
+                throw new Error(`Error in ${this.modelName}.${normalizedName} hook: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    /**
+     * Check if a hook has registered callbacks
+     */
+    hasHook(hookName) {
+        const normalizedName = this.normalizeHookName(hookName);
+        const hookSet = this.hooks.get(normalizedName);
+        return hookSet ? hookSet.size > 0 : false;
+    }
+    /**
+     * Get the count of hooks for a specific hook name
+     */
+    getHookCount(hookName) {
+        const normalizedName = this.normalizeHookName(hookName);
+        const hookSet = this.hooks.get(normalizedName);
+        return hookSet ? hookSet.size : 0;
+    }
+    /**
+     * Clear all hooks
+     */
+    clearHooks() {
+        for (const hookSet of this.hooks.values()) {
+            hookSet.clear();
+        }
+        return this;
+    }
+    /**
+     * Clear hooks for a specific hook name
+     */
+    clearHook(hookName) {
+        const normalizedName = this.normalizeHookName(hookName);
+        const hookSet = this.hooks.get(normalizedName);
+        if (hookSet) {
+            hookSet.clear();
+        }
+        return this;
+    }
+    /**
+     * Normalize hook name to camelCase
+     */
+    normalizeHookName(hookName) {
+        return hookName
+            .replace(/^(before|after)_/i, (_, prefix) => prefix + hookName.charAt(prefix.length).toUpperCase())
+            .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    }
+}
+exports.HooksManager = HooksManager;
+// ==================== Hook Wrapper Functions ====================
+/**
+ * Create a hooks object compatible with Model options
+ */
+function createHooksObject(hooksManager) {
+    const hooksObj = {};
+    const hookNames = [
+        'beforeValidate',
+        'afterValidate',
+        'beforeCreate',
+        'afterCreate',
+        'beforeUpdate',
+        'afterUpdate',
+        'beforeDestroy',
+        'afterDestroy',
+        'beforeSave',
+        'afterSave',
+        'beforeBulkCreate',
+        'afterBulkCreate',
+        'beforeBulkUpdate',
+        'afterBulkUpdate',
+        'beforeBulkDestroy',
+        'afterBulkDestroy',
+        'beforeFind',
+        'afterFind',
+    ];
+    for (const hookName of hookNames) {
+        hooksObj[hookName] = async (instance, options) => {
+            await hooksManager.runHook(hookName, instance, options);
+        };
+    }
+    return hooksObj;
+}
+/**
+ * Mixin function to add hook methods to a Model class
+ */
+function addHookMethods(target, hooksManager) {
+    /**
+     * Add a hook
+     */
+    target.addHook = function (hookName, callback) {
+        return hooksManager.addHook(hookName, callback);
+    };
+    /**
+     * Remove a hook
+     */
+    target.removeHook = function (hookName, callback) {
+        return hooksManager.removeHook(hookName, callback);
+    };
+    /**
+     * Run a hook
+     */
+    target.runHook = async function (hookName, ...args) {
+        return hooksManager.runHook(hookName, ...args);
+    };
+    /**
+     * Check if a hook exists
+     */
+    target.hasHook = function (hookName) {
+        return hooksManager.hasHook(hookName);
+    };
+}
+// ==================== Convenience Hook Creators ====================
+/**
+ * Create a beforeValidate hook wrapper
+ */
+function beforeValidate(callback) {
+    return { beforeValidate: callback };
+}
+/**
+ * Create an afterValidate hook wrapper
+ */
+function afterValidate(callback) {
+    return { afterValidate: callback };
+}
+/**
+ * Create a beforeCreate hook wrapper
+ */
+function beforeCreate(callback) {
+    return { beforeCreate: callback };
+}
+/**
+ * Create an afterCreate hook wrapper
+ */
+function afterCreate(callback) {
+    return { afterCreate: callback };
+}
+/**
+ * Create a beforeUpdate hook wrapper
+ */
+function beforeUpdate(callback) {
+    return { beforeUpdate: callback };
+}
+/**
+ * Create an afterUpdate hook wrapper
+ */
+function afterUpdate(callback) {
+    return { afterUpdate: callback };
+}
+/**
+ * Create a beforeDestroy hook wrapper
+ */
+function beforeDestroy(callback) {
+    return { beforeDestroy: callback };
+}
+/**
+ * Create an afterDestroy hook wrapper
+ */
+function afterDestroy(callback) {
+    return { afterDestroy: callback };
+}
+/**
+ * Create a beforeSave hook wrapper
+ */
+function beforeSave(callback) {
+    return { beforeSave: callback };
+}
+/**
+ * Create an afterSave hook wrapper
+ */
+function afterSave(callback) {
+    return { afterSave: callback };
+}
+/**
+ * Create a beforeBulkCreate hook wrapper
+ */
+function beforeBulkCreate(callback) {
+    return { beforeBulkCreate: callback };
+}
+/**
+ * Create an afterBulkCreate hook wrapper
+ */
+function afterBulkCreate(callback) {
+    return { afterBulkCreate: callback };
+}
+/**
+ * Create a beforeBulkUpdate hook wrapper
+ */
+function beforeBulkUpdate(callback) {
+    return { beforeBulkUpdate: callback };
+}
+/**
+ * Create an afterBulkUpdate hook wrapper
+ */
+function afterBulkUpdate(callback) {
+    return { afterBulkUpdate: callback };
+}
+/**
+ * Create a beforeBulkDestroy hook wrapper
+ */
+function beforeBulkDestroy(callback) {
+    return { beforeBulkDestroy: callback };
+}
+/**
+ * Create an afterBulkDestroy hook wrapper
+ */
+function afterBulkDestroy(callback) {
+    return { afterBulkDestroy: callback };
+}
+/**
+ * Create a beforeFind hook wrapper
+ */
+function beforeFind(callback) {
+    return { beforeFind: callback };
+}
+/**
+ * Create an afterFind hook wrapper
+ */
+function afterFind(callback) {
+    return { afterFind: callback };
+}
+// ==================== Default Export ====================
+exports.default = HooksManager;

package/dist/hooks/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Hooks module exports for the TypeScript ORM
+ * Provides a comprehensive hooks system for model lifecycle events
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterFind = exports.beforeFind = exports.afterBulkDestroy = exports.beforeBulkDestroy = exports.afterBulkUpdate = exports.beforeBulkUpdate = exports.afterBulkCreate = exports.beforeBulkCreate = exports.afterSave = exports.beforeSave = exports.afterDestroy = exports.beforeDestroy = exports.afterUpdate = exports.beforeUpdate = exports.afterCreate = exports.beforeCreate = exports.afterValidate = exports.beforeValidate = exports.addHookMethods = exports.createHooksObject = exports.default = exports.HooksManager = void 0;
+// Main HooksManager class
+var hooks_manager_1 = require("./hooks-manager");
+Object.defineProperty(exports, "HooksManager", { enumerable: true, get: function () { return hooks_manager_1.HooksManager; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(hooks_manager_1).default; } });
+// Hook wrapper functions
+var hooks_manager_2 = require("./hooks-manager");
+Object.defineProperty(exports, "createHooksObject", { enumerable: true, get: function () { return hooks_manager_2.createHooksObject; } });
+Object.defineProperty(exports, "addHookMethods", { enumerable: true, get: function () { return hooks_manager_2.addHookMethods; } });
+// Individual hook creators
+Object.defineProperty(exports, "beforeValidate", { enumerable: true, get: function () { return hooks_manager_2.beforeValidate; } });
+Object.defineProperty(exports, "afterValidate", { enumerable: true, get: function () { return hooks_manager_2.afterValidate; } });
+Object.defineProperty(exports, "beforeCreate", { enumerable: true, get: function () { return hooks_manager_2.beforeCreate; } });
+Object.defineProperty(exports, "afterCreate", { enumerable: true, get: function () { return hooks_manager_2.afterCreate; } });
+Object.defineProperty(exports, "beforeUpdate", { enumerable: true, get: function () { return hooks_manager_2.beforeUpdate; } });
+Object.defineProperty(exports, "afterUpdate", { enumerable: true, get: function () { return hooks_manager_2.afterUpdate; } });
+Object.defineProperty(exports, "beforeDestroy", { enumerable: true, get: function () { return hooks_manager_2.beforeDestroy; } });
+Object.defineProperty(exports, "afterDestroy", { enumerable: true, get: function () { return hooks_manager_2.afterDestroy; } });
+Object.defineProperty(exports, "beforeSave", { enumerable: true, get: function () { return hooks_manager_2.beforeSave; } });
+Object.defineProperty(exports, "afterSave", { enumerable: true, get: function () { return hooks_manager_2.afterSave; } });
+Object.defineProperty(exports, "beforeBulkCreate", { enumerable: true, get: function () { return hooks_manager_2.beforeBulkCreate; } });
+Object.defineProperty(exports, "afterBulkCreate", { enumerable: true, get: function () { return hooks_manager_2.afterBulkCreate; } });
+Object.defineProperty(exports, "beforeBulkUpdate", { enumerable: true, get: function () { return hooks_manager_2.beforeBulkUpdate; } });
+Object.defineProperty(exports, "afterBulkUpdate", { enumerable: true, get: function () { return hooks_manager_2.afterBulkUpdate; } });
+Object.defineProperty(exports, "beforeBulkDestroy", { enumerable: true, get: function () { return hooks_manager_2.beforeBulkDestroy; } });
+Object.defineProperty(exports, "afterBulkDestroy", { enumerable: true, get: function () { return hooks_manager_2.afterBulkDestroy; } });
+Object.defineProperty(exports, "beforeFind", { enumerable: true, get: function () { return hooks_manager_2.beforeFind; } });
+Object.defineProperty(exports, "afterFind", { enumerable: true, get: function () { return hooks_manager_2.afterFind; } });