ts-prorm-orm 1.1.0

package/dist/migrations/seeder.js

@@ -0,0 +1,353 @@
+"use strict";
+/**
+ * Seeder System - Manages database seed data
+ * Provides a way to populate a database with initial or test data
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeederRunner = void 0;
+exports.createSeeder = createSeeder;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const events_1 = require("events");
+/**
+ * Helper to create a seeder with full type safety
+ */
+function createSeeder(definition) {
+    return definition;
+}
+/**
+ * SeederRunner manages the lifecycle of database seeders
+ */
+class SeederRunner extends events_1.EventEmitter {
+    constructor(prorm, options = {}) {
+        super();
+        this.prorm = prorm;
+        this.options = options;
+        this.tableName = options.seedsTableName || 'PrormData';
+        this.seedersPath = options.seedersPath || './seeders';
+        this.pattern = options.pattern || /\.(js|ts)$/;
+    }
+    /**
+     * Get the dialect instance from the prorm object.
+     * Supports both the custom ORM (getDialectInstance) and a plain query wrapper.
+     */
+    getDialect() {
+        if (this.prorm && typeof this.prorm.getDialectInstance === 'function') {
+            return this.prorm.getDialectInstance();
+        }
+        return null;
+    }
+    /**
+     * Execute a raw SQL query via the prorm/dialect instance
+     */
+    async rawQuery(sql, options) {
+        const dialect = this.getDialect();
+        if (dialect) {
+            return dialect.query(sql, options);
+        }
+        // Fallback: prorm may have a .query() method directly
+        if (typeof this.prorm.query === 'function') {
+            return this.prorm.query(sql, options);
+        }
+        throw new Error('Unable to execute query: no query interface available');
+    }
+    /**
+     * Escape an identifier using the dialect, or fall back to simple quoting
+     */
+    escapeId(name) {
+        const dialect = this.getDialect();
+        if (dialect && typeof dialect.escapeId === 'function') {
+            return dialect.escapeId(name);
+        }
+        return `"${name}"`;
+    }
+    /**
+     * Escape a literal value using the dialect so it can be inlined directly into
+     * SQL. Inlining avoids relying on a specific bind-placeholder style (`?`,
+     * `$1`, `:name`), which differs between dialects — Postgres-family dialects,
+     * for example, do not understand `?` — and keeps the tracking/seeder SQL
+     * portable across every dialect.
+     */
+    escapeVal(value) {
+        const dialect = this.getDialect();
+        if (dialect && typeof dialect.escape === 'function') {
+            return dialect.escape(value);
+        }
+        // Fallback escaping when no dialect is available (rare)
+        if (value === null || value === undefined)
+            return 'NULL';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'boolean')
+            return value ? 'TRUE' : 'FALSE';
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    /**
+     * Resolve the current environment used for env-scoped seeders.
+     * Prefers the explicit option, then NODE_ENV; otherwise undefined.
+     */
+    resolveEnv() {
+        return this.options.env || process.env.NODE_ENV || undefined;
+    }
+    /**
+     * Ensure the PrormData tracking table exists
+     */
+    async ensureSeedsTable() {
+        const dialect = this.getDialect();
+        if (!dialect) {
+            throw new Error('Prorm is not connected');
+        }
+        const tableExists = await this.tableExists();
+        if (!tableExists) {
+            const sql = `CREATE TABLE IF NOT EXISTS ${this.escapeId(this.tableName)} (
+        "name" VARCHAR(255) NOT NULL UNIQUE,
+        "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )`;
+            await this.rawQuery(sql);
+        }
+    }
+    /**
+     * Check whether the tracking table exists
+     */
+    async tableExists() {
+        const dialect = this.getDialect();
+        if (dialect && typeof dialect.showTables === 'function') {
+            const tables = await dialect.showTables();
+            return tables.includes(this.tableName);
+        }
+        // Fallback for SQLite: query sqlite_master
+        try {
+            const result = await this.rawQuery(`SELECT name FROM sqlite_master WHERE type='table' AND name=${this.escapeVal(this.tableName)}`);
+            return result.rows && result.rows.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Return names of all seeders that have already been executed
+     */
+    async getExecutedSeeds() {
+        await this.ensureSeedsTable();
+        const result = await this.rawQuery(`SELECT "name" FROM ${this.escapeId(this.tableName)} ORDER BY "createdAt" ASC`);
+        return (result.rows || []).map((r) => r.name);
+    }
+    /**
+     * Discover all seeder files in the seeders path, sorted by name
+     */
+    discoverSeederFiles(seedersPath) {
+        if (!fs.existsSync(seedersPath)) {
+            return [];
+        }
+        return fs
+            .readdirSync(seedersPath)
+            .filter((f) => this.pattern.test(f))
+            .sort()
+            .map((f) => path.join(seedersPath, f));
+    }
+    /**
+     * Load a seeder module from disk
+     */
+    loadSeeder(filePath) {
+        const ext = path.extname(filePath);
+        if (ext === '.ts') {
+            // For TypeScript files, require ts-node registration or pre-compiled output
+            // In test environments ts-jest handles this automatically
+            delete require.cache[require.resolve(filePath)];
+            return require(filePath);
+        }
+        const fullPath = path.resolve(filePath);
+        delete require.cache[require.resolve(fullPath)];
+        return require(fullPath);
+    }
+    /**
+     * Build the query interface object passed to seeder functions.
+     * This mirrors the shape that seeder authors expect.
+     */
+    buildQueryInterface() {
+        const dialect = this.getDialect();
+        const self = this;
+        return {
+            bulkInsert: async (tableName, records) => {
+                if (!records || records.length === 0)
+                    return;
+                const cols = Object.keys(records[0]);
+                const colList = cols.map((c) => self.escapeId(c)).join(', ');
+                for (const record of records) {
+                    const vals = cols.map((c) => self.escapeVal(record[c])).join(', ');
+                    await self.rawQuery(`INSERT INTO ${self.escapeId(tableName)} (${colList}) VALUES (${vals})`);
+                }
+            },
+            bulkDelete: async (tableName, where) => {
+                let sql = `DELETE FROM ${self.escapeId(tableName)}`;
+                if (where && Object.keys(where).length > 0) {
+                    const conditions = Object.entries(where)
+                        .map(([k, v]) => `${self.escapeId(k)} = ${self.escapeVal(v)}`)
+                        .join(' AND ');
+                    sql += ` WHERE ${conditions}`;
+                    await self.rawQuery(sql);
+                }
+                else {
+                    await self.rawQuery(sql);
+                }
+            },
+            prormQuery: async (sql, opts) => {
+                return self.rawQuery(sql, opts);
+            },
+        };
+    }
+    /**
+     * Run all pending seeders (or a single one, via `options.only`). Returns
+     * the names of seeders that were executed.
+     *
+     * Seeders are discovered in sorted filename order (see
+     * discoverSeederFiles) and run strictly one after another. If a seeder's
+     * up() throws, the error propagates immediately: seeders already recorded
+     * in this call remain recorded (their tracking rows were only inserted
+     * after up() resolved successfully), the failing seeder is NOT recorded
+     * as executed, and no further seeders in the batch are attempted. Re-running
+     * runSeeders() afterwards will retry the failed seeder and any that never
+     * got a chance to run.
+     */
+    async runSeeders(seedersPath, options = {}) {
+        const targetPath = seedersPath || this.seedersPath;
+        await this.ensureSeedsTable();
+        const executed = new Set(await this.getExecutedSeeds());
+        let files = this.discoverSeederFiles(targetPath);
+        if (options.only) {
+            files = files.filter((f) => path.basename(f, path.extname(f)) === options.only);
+            if (files.length === 0) {
+                throw new Error(`Seeder file not found for: ${options.only}`);
+            }
+        }
+        const queryInterface = this.buildQueryInterface();
+        const currentEnv = this.resolveEnv();
+        const ran = [];
+        for (const filePath of files) {
+            const name = path.basename(filePath, path.extname(filePath));
+            const alreadyExecuted = executed.has(name);
+            if (alreadyExecuted && !(options.only && options.force)) {
+                continue;
+            }
+            const seeder = this.loadSeeder(filePath);
+            // Environment scoping: seeders with no `env` field always run. A seeder
+            // that DOES declare `env` only runs when it matches the supplied env;
+            // when no env can be resolved we skip it rather than running it
+            // unconditionally (which previously leaked dev fixtures into every env).
+            if (seeder.env) {
+                const allowed = Array.isArray(seeder.env) ? seeder.env : [seeder.env];
+                if (!options.env || !allowed.includes(options.env)) {
+                    continue;
+                }
+            }
+            this.emit('beforeSeed', { name });
+            const start = Date.now();
+            await seeder.up(queryInterface, this.prorm);
+            // Record as executed (replace any prior record when force-re-running)
+            if (alreadyExecuted) {
+                await this.rawQuery(`DELETE FROM ${this.escapeId(this.tableName)} WHERE "name" = ?`, {
+                    replacements: [name],
+                });
+            }
+            await this.rawQuery(`INSERT INTO ${this.escapeId(this.tableName)} ("name", "createdAt") VALUES (${this.escapeVal(name)}, ${this.escapeVal(new Date().toISOString())})`);
+            const duration = Date.now() - start;
+            this.emit('afterSeed', { name, duration });
+            ran.push(name);
+        }
+        return ran;
+    }
+    /**
+     * Undo a specific seeder, or the most recently executed one if no name given
+     */
+    async undoSeeder(seederName) {
+        await this.ensureSeedsTable();
+        const executed = await this.getExecutedSeeds();
+        if (executed.length === 0) {
+            return;
+        }
+        const targetName = seederName || executed[executed.length - 1];
+        // Find the file for this seeder
+        const files = this.discoverSeederFiles(this.seedersPath);
+        const file = files.find((f) => path.basename(f, path.extname(f)) === targetName);
+        if (!file) {
+            throw new Error(`Seeder file not found for: ${targetName}`);
+        }
+        const queryInterface = this.buildQueryInterface();
+        const seeder = this.loadSeeder(file);
+        await seeder.down(queryInterface, this.prorm);
+        await this.rawQuery(`DELETE FROM ${this.escapeId(this.tableName)} WHERE "name" = ${this.escapeVal(targetName)}`);
+    }
+    /**
+     * Undo all executed seeders in reverse order
+     */
+    async undoAllSeeders() {
+        await this.ensureSeedsTable();
+        const executed = await this.getExecutedSeeds();
+        // Reverse order
+        const reversed = [...executed].reverse();
+        for (const name of reversed) {
+            await this.undoSeeder(name);
+        }
+    }
+    /**
+     * Return the status of all seed files (both pending and executed)
+     */
+    async getSeedStatus() {
+        await this.ensureSeedsTable();
+        // Fetch executed records with timestamps
+        const result = await this.rawQuery(`SELECT "name", "createdAt" FROM ${this.escapeId(this.tableName)} ORDER BY "createdAt" ASC`);
+        const executedMap = new Map((result.rows || []).map((r) => [r.name, new Date(r.createdAt)]));
+        const files = this.discoverSeederFiles(this.seedersPath);
+        const statuses = [];
+        for (const filePath of files) {
+            const name = path.basename(filePath, path.extname(filePath));
+            if (executedMap.has(name)) {
+                statuses.push({ name, status: 'executed', executedAt: executedMap.get(name) });
+            }
+            else {
+                statuses.push({ name, status: 'pending' });
+            }
+        }
+        // Also include any executed seeds whose files no longer exist
+        for (const [name, executedAt] of executedMap) {
+            if (!statuses.find((s) => s.name === name)) {
+                statuses.push({ name, status: 'executed', executedAt });
+            }
+        }
+        return statuses;
+    }
+}
+exports.SeederRunner = SeederRunner;