ts-prorm-orm 1.1.0

package/dist/logging.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * Logging system for the ORM
+ * Provides configurable logging with different levels and custom logger support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevelStrings = exports.LogLevel = void 0;
+exports.createLogger = createLogger;
+exports.createSilentLogger = createSilentLogger;
+exports.getDefaultLogger = getDefaultLogger;
+exports.setDefaultLogger = setDefaultLogger;
+exports.resetDefaultLogger = resetDefaultLogger;
+const events_1 = require("events");
+/**
+ * Log levels
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["QUIET"] = 4] = "QUIET";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Log level string mapping
+ */
+exports.LogLevelStrings = {
+    debug: LogLevel.DEBUG,
+    info: LogLevel.INFO,
+    warn: LogLevel.WARN,
+    error: LogLevel.ERROR,
+    quiet: LogLevel.QUIET,
+};
+/**
+ * Logger class for the ORM
+ * Supports multiple log levels, custom loggers, and SQL query logging
+ */
+class Logger extends events_1.EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.level = LogLevel.INFO;
+        this.logSQL = false;
+        this.slowQueryThreshold = 1000; // 1 second default
+        this.logSlowQueries = true;
+        this.useColors = true;
+        if (options.level !== undefined) {
+            this.setLevel(options.level);
+        }
+        if (options.logSQL !== undefined) {
+            this.logSQL = options.logSQL;
+        }
+        if (options.slowQueryThreshold !== undefined) {
+            this.slowQueryThreshold = options.slowQueryThreshold;
+        }
+        if (options.logSlowQueries !== undefined) {
+            this.logSlowQueries = options.logSlowQueries;
+        }
+        if (options.logging !== undefined) {
+            this.customLogger = options.logging;
+        }
+        if (options.prormLogging !== undefined) {
+            this.prormLogger = options.prormLogging;
+        }
+        if (options.colors !== undefined) {
+            this.useColors = options.colors;
+        }
+    }
+    /**
+     * Set the minimum log level
+     */
+    setLevel(level) {
+        if (typeof level === 'string') {
+            this.level = exports.LogLevelStrings[level] ?? LogLevel.INFO;
+        }
+        else {
+            this.level = level;
+        }
+    }
+    /**
+     * Get the current log level
+     */
+    getLevel() {
+        return this.level;
+    }
+    /**
+     * Get the current log level name
+     */
+    getLevelName() {
+        return LogLevel[this.level];
+    }
+    /**
+     * Log a debug message
+     */
+    debug(message, meta) {
+        this.log(LogLevel.DEBUG, message, meta);
+    }
+    /**
+     * Log an info message
+     */
+    info(message, meta) {
+        this.log(LogLevel.INFO, message, meta);
+    }
+    /**
+     * Log a warning message
+     */
+    warn(message, meta) {
+        this.log(LogLevel.WARN, message, meta);
+    }
+    /**
+     * Log an error message
+     */
+    error(message, meta) {
+        this.log(LogLevel.ERROR, message, meta);
+    }
+    /**
+     * Core log method
+     */
+    log(level, message, meta) {
+        if (level < this.level)
+            return;
+        const entry = {
+            level,
+            levelName: LogLevel[level],
+            message,
+            timestamp: new Date(),
+            meta,
+        };
+        // Emit log event
+        this.emit('log', entry);
+        // Output to logger
+        this.output(level, message, meta);
+    }
+    /**
+     * Output log message
+     */
+    output(level, message, meta) {
+        const prefix = this.formatPrefix(level);
+        const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+        const fullMessage = `${prefix}${message}${metaStr}`;
+        if (this.customLogger) {
+            // Use custom logger
+            const isDebug = level === LogLevel.DEBUG;
+            this.customLogger(fullMessage, isDebug);
+        }
+        else {
+            // Use default console logging
+            this.defaultOutput(level, fullMessage);
+        }
+    }
+    /**
+     * Default console output
+     */
+    defaultOutput(level, message) {
+        const color = this.getLevelColor(level);
+        const coloredMessage = this.useColors ? `${color}${message}${Logger.colors.reset}` : message;
+        switch (level) {
+            case LogLevel.DEBUG:
+                console.log(coloredMessage);
+                break;
+            case LogLevel.INFO:
+                console.log(coloredMessage);
+                break;
+            case LogLevel.WARN:
+                console.warn(coloredMessage);
+                break;
+            case LogLevel.ERROR:
+                console.error(coloredMessage);
+                break;
+        }
+    }
+    /**
+     * Get color for log level
+     */
+    getLevelColor(level) {
+        if (!this.useColors)
+            return '';
+        switch (level) {
+            case LogLevel.DEBUG:
+                return Logger.colors.gray;
+            case LogLevel.INFO:
+                return Logger.colors.blue;
+            case LogLevel.WARN:
+                return Logger.colors.yellow;
+            case LogLevel.ERROR:
+                return Logger.colors.red;
+            default:
+                return Logger.colors.reset;
+        }
+    }
+    /**
+     * Format log prefix
+     */
+    formatPrefix(level) {
+        const timestamp = new Date().toISOString();
+        const levelName = LogLevel[level].padEnd(5);
+        const color = this.getLevelColor(level);
+        const reset = this.useColors ? Logger.colors.reset : '';
+        return `[${timestamp}] ${color}${levelName}${reset}: `;
+    }
+    /**
+     * Log a SQL query with timing
+     */
+    logQuery(sql, duration) {
+        // Emit query event
+        this.emit('query', sql, duration || 0);
+        // Use Prorm-style logger if provided
+        if (this.prormLogger) {
+            this.prormLogger(sql, duration);
+            return;
+        }
+        // Log the SQL if enabled
+        if (this.logSQL && this.level <= LogLevel.DEBUG) {
+            this.debug(`Executing SQL: ${sql}`);
+        }
+        // Log slow queries
+        if (duration !== undefined && duration > this.slowQueryThreshold) {
+            const message = `Slow query (${duration}ms): ${sql}`;
+            if (this.logSlowQueries) {
+                this.warn(message);
+            }
+            this.emit('slowQuery', sql, duration);
+        }
+    }
+    /**
+     * Set whether to log SQL queries
+     */
+    setLogSQL(logSQL) {
+        this.logSQL = logSQL;
+    }
+    /**
+     * Set slow query threshold
+     */
+    setSlowQueryThreshold(threshold) {
+        this.slowQueryThreshold = threshold;
+    }
+    /**
+     * Check if logging is enabled for a level
+     */
+    isLevelEnabled(level) {
+        return level >= this.level;
+    }
+    /**
+     * Create a child logger with additional context
+     */
+    child(meta) {
+        const childLogger = new Logger({
+            level: this.level,
+            logSQL: this.logSQL,
+            slowQueryThreshold: this.slowQueryThreshold,
+            logSlowQueries: this.logSlowQueries,
+            logging: this.customLogger,
+            colors: this.useColors,
+        });
+        // Wrap the log method to include child metadata
+        const originalDebug = childLogger.debug.bind(childLogger);
+        const originalInfo = childLogger.info.bind(childLogger);
+        const originalWarn = childLogger.warn.bind(childLogger);
+        const originalError = childLogger.error.bind(childLogger);
+        childLogger.debug = (message, childMeta) => {
+            originalDebug(message, { ...meta, ...childMeta });
+        };
+        childLogger.info = (message, childMeta) => {
+            originalInfo(message, { ...meta, ...childMeta });
+        };
+        childLogger.warn = (message, childMeta) => {
+            originalWarn(message, { ...meta, ...childMeta });
+        };
+        childLogger.error = (message, childMeta) => {
+            originalError(message, { ...meta, ...childMeta });
+        };
+        return childLogger;
+    }
+}
+exports.Logger = Logger;
+// ANSI color codes
+Logger.colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    magenta: '\x1b[35m',
+    gray: '\x1b[90m',
+};
+/**
+ * Create a default logger instance
+ */
+function createLogger(options = {}) {
+    return new Logger(options);
+}
+/**
+ * Create a no-op logger (for testing)
+ */
+function createSilentLogger() {
+    return new Logger({ level: LogLevel.QUIET });
+}
+/**
+ * Default logger for Prorm
+ */
+let defaultLogger = null;
+/**
+ * Get or create the default logger
+ */
+function getDefaultLogger(options = {}) {
+    if (!defaultLogger) {
+        defaultLogger = new Logger(options);
+    }
+    return defaultLogger;
+}
+/**
+ * Set the default logger
+ */
+function setDefaultLogger(logger) {
+    defaultLogger = logger;
+}
+/**
+ * Reset the default logger
+ */
+function resetDefaultLogger() {
+    defaultLogger = null;
+}
+exports.default = {
+    Logger,
+    LogLevel,
+    LogLevelStrings: exports.LogLevelStrings,
+    createLogger,
+    createSilentLogger,
+    getDefaultLogger,
+    setDefaultLogger,
+    resetDefaultLogger,
+};

package/dist/migrations/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Migration System - Main entry point for all migration-related exports
+ * Provides migration management capabilities for the TypeScript ORM
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrormMigration = exports.createQueryInterface = exports.QueryInterface = exports.createMigration = exports.createMigrator = exports.Migrator = exports.buildMigrationTemplate = exports.createMigrationTemplate = exports.Migration = void 0;
+// Re-export Migration class and helpers
+var migration_1 = require("./migration");
+Object.defineProperty(exports, "Migration", { enumerable: true, get: function () { return migration_1.Migration; } });
+Object.defineProperty(exports, "createMigrationTemplate", { enumerable: true, get: function () { return migration_1.createMigrationTemplate; } });
+Object.defineProperty(exports, "buildMigrationTemplate", { enumerable: true, get: function () { return migration_1.buildMigrationTemplate; } });
+// Re-export Migrator class
+var migrator_1 = require("./migrator");
+Object.defineProperty(exports, "Migrator", { enumerable: true, get: function () { return migrator_1.Migrator; } });
+Object.defineProperty(exports, "createMigrator", { enumerable: true, get: function () { return migrator_1.createMigrator; } });
+Object.defineProperty(exports, "createMigration", { enumerable: true, get: function () { return migrator_1.createMigration; } });
+// Re-export QueryInterface for migrations
+var query_interface_1 = require("./query-interface");
+Object.defineProperty(exports, "QueryInterface", { enumerable: true, get: function () { return query_interface_1.QueryInterface; } });
+Object.defineProperty(exports, "createQueryInterface", { enumerable: true, get: function () { return query_interface_1.createQueryInterface; } });
+// Re-export PrormMigration integration
+var prormmigration_1 = require("./prormmigration");
+Object.defineProperty(exports, "PrormMigration", { enumerable: true, get: function () { return prormmigration_1.PrormMigration; } });
+// Re-export Schema diffing and migration generation
+__exportStar(require("../schema"), exports);

package/dist/migrations/migration.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Migration class - Base class for all migrations
+ * Stores migration metadata including name, batch number, and timestamp
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration = void 0;
+exports.buildMigrationTemplate = buildMigrationTemplate;
+exports.createMigrationTemplate = createMigrationTemplate;
+/**
+ * Migration class representing a single database migration
+ */
+class Migration {
+    /**
+     * Create a new Migration instance
+     * @param options - Migration options
+     */
+    constructor(options) {
+        this.name = options.name;
+        this.timestamp = Date.now();
+        this.batch = 0;
+        this.migrationUp = options.up;
+        this.migrationDown = options.down;
+    }
+    /**
+     * Get the up migration function
+     */
+    get up() {
+        return this.migrationUp;
+    }
+    /**
+     * Get the down migration function
+     */
+    get down() {
+        return this.migrationDown;
+    }
+    /**
+     * Set the up migration function
+     */
+    setUp(up) {
+        this.migrationUp = up;
+    }
+    /**
+     * Set the down migration function
+     */
+    setDown(down) {
+        this.migrationDown = down;
+    }
+    /**
+     * Execute the migration (run up)
+     * @param queryInterface - The query interface to use
+     * @param prorm - The prorm instance
+     */
+    async runUp(queryInterface, prorm) {
+        if (this.migrationUp) {
+            await this.migrationUp(queryInterface, prorm);
+        }
+    }
+    /**
+     * Revert the migration (run down)
+     * @param queryInterface - The query interface to use
+     * @param prorm - The prorm instance
+     */
+    async runDown(queryInterface, prorm) {
+        if (this.migrationDown) {
+            await this.migrationDown(queryInterface, prorm);
+        }
+    }
+    /**
+     * Get migration metadata
+     */
+    getMeta() {
+        return {
+            id: this.id,
+            name: this.name,
+            timestamp: this.timestamp,
+            batch: this.batch,
+        };
+    }
+    /**
+     * Set migration metadata from database record
+     */
+    setMeta(meta) {
+        this.id = meta.id;
+        // Note: name and timestamp are intentionally not modified here
+        // as they represent the original migration definition
+        this.batch = meta.batch;
+    }
+    /**
+     * Check if migration has been executed
+     */
+    isExecuted() {
+        return this.id !== undefined;
+    }
+    /**
+     * Get a timestamp string for the migration name
+     */
+    static getTimestamp() {
+        const now = new Date();
+        const year = now.getFullYear();
+        const month = String(now.getMonth() + 1).padStart(2, '0');
+        const day = String(now.getDate()).padStart(2, '0');
+        const hours = String(now.getHours()).padStart(2, '0');
+        const minutes = String(now.getMinutes()).padStart(2, '0');
+        const seconds = String(now.getSeconds()).padStart(2, '0');
+        return `${year}${month}${day}${hours}${minutes}${seconds}`;
+    }
+    /**
+     * Generate a migration file name with timestamp
+     */
+    static generateFileName(name) {
+        return `${this.getTimestamp()}-${name}`;
+    }
+    /**
+     * Parse migration file name to extract timestamp and name
+     */
+    static parseFileName(filename) {
+        const match = filename.match(/^(\d{14})-(.+)$/);
+        if (match) {
+            return {
+                timestamp: match[1],
+                name: match[2],
+            };
+        }
+        return null;
+    }
+}
+exports.Migration = Migration;
+/**
+ * The single canonical migration file template used by every migration
+ * generator in this codebase (Migrator.createMigration, MigrationCli.create,
+ * cli.ts migration:create). Produces a CommonJS `module.exports = { up, down }`
+ * file, which is the format `Migrator.loadMigrationFile()` requires via
+ * `require()` (for `.ts` files this is transpiled on the fly via ts-node).
+ *
+ * Keeping exactly one template in one place means the loader and the
+ * generator can never drift out of sync again.
+ */
+function buildMigrationTemplate(name) {
+    return `/**
+ * Migration: ${name}
+ * Created at: ${new Date().toISOString()}
+ */
+
+module.exports = {
+  up: async (queryInterface, prorm) => {
+    /**
+     * Add migration commands here
+     *
+     * Example:
+     * await queryInterface.createTable('users', {
+     *   id: {
+     *     type: Prorm.INTEGER,
+     *     primaryKey: true,
+     *     autoIncrement: true
+     *   },
+     *   name: {
+     *     type: Prorm.STRING,
+     *     allowNull: false
+     *   },
+     *   createdAt: {
+     *     type: Prorm.DATE,
+     *     allowNull: false,
+     *     defaultValue: prorm.literal('CURRENT_TIMESTAMP')
+     *   },
+     *   updatedAt: {
+     *     type: Prorm.DATE,
+     *     allowNull: false,
+     *     defaultValue: prorm.literal('CURRENT_TIMESTAMP')
+     *   }
+     * });
+     */
+  },
+
+  down: async (queryInterface, prorm) => {
+    /**
+     * Add commands to revert migration here
+     *
+     * Example:
+     * await queryInterface.dropTable('users');
+     */
+  }
+};
+`;
+}
+/**
+ * @deprecated Use `buildMigrationTemplate` instead. This used to emit an
+ * ESM-style (`export const up = ...`) template that was incompatible with
+ * `Migrator.loadMigrationFile()`, which only ever loaded migrations via
+ * CommonJS `require()`. It now delegates to the canonical CommonJS template
+ * so any existing callers keep working, but new code should call
+ * `buildMigrationTemplate` directly.
+ */
+function createMigrationTemplate(name) {
+    return buildMigrationTemplate(name);
+}