ts-prorm-orm 1.1.0

package/dist/models/methods.js

@@ -0,0 +1,382 @@
+"use strict";
+/**
+ * Custom Methods Helpers for Models
+ *
+ * This module provides utilities for adding custom class and instance methods
+ * to Prorm-like models.
+ */
+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.commonClassMethods = exports.commonInstanceMethods = void 0;
+exports.addClassMethods = addClassMethods;
+exports.addInstanceMethods = addInstanceMethods;
+exports.extendModel = extendModel;
+/**
+ * Add custom class methods to a model
+ * Use this to add static methods to a model (e.g., User.findByEmail)
+ *
+ * @example
+ * ```typescript
+ * addClassMethods(User, {
+ *   findByEmail: async function(email) {
+ *     return this.findOne({ where: { email } });
+ *   },
+ *   findByRole: function(role) {
+ *     return this.findAll({ where: { role } });
+ *   }
+ * });
+ * ```
+ *
+ * @param model - The model static to add methods to
+ * @param methods - Object containing method names and their implementations
+ */
+function addClassMethods(model, methods) {
+    for (const [methodName, methodFn] of Object.entries(methods)) {
+        model[methodName] = methodFn;
+    }
+}
+/**
+ * Add custom instance methods to a model
+ * Use this to add methods that will be available on model instances (e.g., user.getFullName())
+ *
+ * @example
+ * ```typescript
+ * addInstanceMethods(User, {
+ *   getFullName: function() {
+ *     return `${this.firstName} ${this.lastName}`;
+ *   },
+ *   isActive: function() {
+ *     return this.status === 'active';
+ *   }
+ * });
+ * ```
+ *
+ * @param model - The model static to add methods to
+ * @param methods - Object containing method names and their implementations
+ */
+function addInstanceMethods(model, methods) {
+    // Store instance methods on the model for use by ModelInstance constructor
+    const existingMethods = model.instanceMethods || {};
+    model.instanceMethods = { ...existingMethods, ...methods };
+}
+/**
+ * Helper to extend a model with additional methods after definition
+ * Useful for adding methods to models defined elsewhere
+ *
+ * @example
+ * ```typescript
+ * // Extend User model with custom methods
+ * extendModel(User, {
+ *   classMethods: {
+ *     findActive: function() {
+ *       return this.findAll({ where: { status: 'active' } });
+ *     }
+ *   },
+ *   instanceMethods: {
+ *     getDisplayName: function() {
+ *       return this.name || this.email;
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @param model - The model to extend
+ * @param options - Object containing classMethods and/or instanceMethods
+ */
+function extendModel(model, options) {
+    if (options.classMethods) {
+        addClassMethods(model, options.classMethods);
+    }
+    if (options.instanceMethods) {
+        addInstanceMethods(model, options.instanceMethods);
+    }
+}
+/**
+ * Common instance methods that can be added to any model
+ */
+exports.commonInstanceMethods = {
+    /**
+     * Get a single attribute value
+     * @example
+     * ```typescript
+     * const name = user.get('firstName');
+     * ```
+     */
+    get(key) {
+        return this.getDataValue(key);
+    },
+    /**
+     * Set a single attribute value
+     * @example
+     * ```typescript
+     * user.set('firstName', 'John');
+     * ```
+     */
+    set(key, value) {
+        this.setDataValue(key, value);
+    },
+    /**
+     * Get raw data value (bypasses getters)
+     * @example
+     * ```typescript
+     * const value = user.getDataValue('firstName');
+     * ```
+     */
+    getDataValue(key) {
+        return this.dataValues[key];
+    },
+    /**
+     * Set raw data value (bypasses setters)
+     * @example
+     * ```typescript
+     * user.setDataValue('firstName', 'John');
+     * ```
+     */
+    setDataValue(key, value) {
+        this.dataValues[key] = value;
+        this.isDirty = true;
+        this._changed.add(key);
+    },
+    /**
+     * Check if record is new (not saved to database)
+     * @example
+     * ```typescript
+     * if (user.isNewRecord) {
+     *   console.log('New user!');
+     * }
+     * ```
+     */
+    isNewRecord() {
+        return this.isNewRecord;
+    },
+    /**
+     * Convert instance to JSON
+     * @example
+     * ```typescript
+     * const json = user.toJSON();
+     * ```
+     */
+    toJSON() {
+        return { ...this.dataValues };
+    },
+    /**
+     * Check if a specific field has changed
+     * @example
+     * ```typescript
+     * if (user.changed('email')) {
+     *   console.log('Email was changed');
+     * }
+     * ```
+     */
+    changed(key) {
+        if (key) {
+            return this._changed.has(key);
+        }
+        return Array.from(this._changed);
+    },
+    /**
+     * Get previous value of a field
+     * @example
+     * ```typescript
+     * const oldEmail = user.previous('email');
+     * ```
+     */
+    previous(key) {
+        if (key) {
+            return this._previousDataValues[key];
+        }
+        return { ...this._previousDataValues };
+    },
+};
+/**
+ * Common class methods that can be added to any model
+ */
+exports.commonClassMethods = {
+    /**
+     * Find a record or create it if not found
+     * @example
+     * ```typescript
+     * const [user, created] = await User.findOrCreate({
+     *   where: { email: 'john@example.com' },
+     *   defaults: { name: 'John' }
+     * });
+     * ```
+     */
+    async findOrCreate(options) {
+        const existing = await this.findOne({ where: options.where });
+        if (existing) {
+            return [existing, false];
+        }
+        const createValues = { ...options.defaults, ...options.where };
+        const created = await this.create(createValues);
+        return [created, true];
+    },
+    /**
+     * Find a record or build (but not save) it if not found
+     * @example
+     * ```typescript
+     * const [user, built] = await User.findOrBuild({
+     *   where: { email: 'john@example.com' },
+     *   defaults: { name: 'John' }
+     * });
+     * if (built) {
+     *   await user.save();
+     * }
+     * ```
+     */
+    async findOrBuild(options) {
+        const existing = await this.findOne({ where: options.where });
+        if (existing) {
+            return [existing, false];
+        }
+        const buildValues = { ...options.defaults, ...options.where };
+        // Create instance without saving - we'll need to import ModelInstance
+        const instance = new (await Promise.resolve().then(() => __importStar(require('./model')))).ModelInstance(this, this.prorm, buildValues, { isNewRecord: true });
+        return [instance, true];
+    },
+    /**
+     * Insert or update a record
+     * @example
+     * ```typescript
+     * const [user, isNew] = await User.upsert({
+     *   id: 1,
+     *   name: 'John',
+     *   email: 'john@example.com'
+     * });
+     * ```
+     */
+    async upsert(values, _options) {
+        // Find primary key
+        const attributes = this.rawAttributes;
+        let pkAttr = 'id';
+        for (const [attrName, attr] of Object.entries(attributes)) {
+            if (attr.primaryKey) {
+                pkAttr = attrName;
+                break;
+            }
+        }
+        const pkValue = values[pkAttr];
+        if (pkValue !== undefined && pkValue !== null) {
+            const existing = await this.findOne({
+                where: { [pkAttr]: pkValue },
+            });
+            if (existing) {
+                await existing.set(values);
+                await existing.save();
+                return [existing, false];
+            }
+        }
+        const created = await this.create(values);
+        return [created, true];
+    },
+    /**
+     * Find a record by where conditions, or create it with upsert semantics
+     * Similar to findOrCreate but uses upsert for the create path
+     * @example
+     * ```typescript
+     * const [user, created] = await User.upsertOrCreate({
+     *   where: { email: 'john@example.com' },
+     *   defaults: { name: 'John' },
+     *   updateValues: { name: 'John Updated' }
+     * });
+     * ```
+     */
+    async upsertOrCreate(options) {
+        const existing = await this.findOne({ where: options.where });
+        if (existing) {
+            // Update with provided updateValues or defaults
+            const updateData = options.updateValues || options.defaults || {};
+            await existing.set(updateData);
+            await existing.save();
+            return [existing, false];
+        }
+        // Create with defaults merged with where conditions
+        const createValues = { ...options.defaults, ...options.where };
+        const created = await this.create(createValues);
+        return [created, true];
+    },
+    /**
+     * Bulk upsert - upsert multiple records at once
+     * @example
+     * ```typescript
+     * const results = await User.bulkUpsert([
+     *   { id: 1, name: 'John' },
+     *   { id: 2, name: 'Jane' },
+     *   { name: 'New User' }
+     * ], { conflictKeys: ['email'], updateKeys: ['name'] });
+     * ```
+     */
+    async bulkUpsert(records, options = {}) {
+        if (records.length === 0)
+            return 0;
+        const { conflictKeys = ['id'], updateKeys = [] } = options;
+        // Get the primary key or first conflict key
+        const pkAttr = conflictKeys[0];
+        let updatedCount = 0;
+        // Process each record individually (for proper upsert semantics)
+        // In a production implementation, this would use dialect-specific
+        // INSERT ... ON CONFLICT (PostgreSQL) or INSERT ... ON DUPLICATE KEY UPDATE (MySQL)
+        for (const record of records) {
+            const where = {};
+            where[pkAttr] = record[pkAttr];
+            const existing = await this.findOne({ where });
+            if (existing) {
+                // Update with provided values
+                const updateData = {};
+                for (const key of updateKeys) {
+                    if (record[key] !== undefined) {
+                        updateData[key] = record[key];
+                    }
+                }
+                if (Object.keys(updateData).length > 0) {
+                    await existing.set(updateData);
+                    await existing.save();
+                    updatedCount++;
+                }
+            }
+            else {
+                await this.create(record);
+            }
+        }
+        return updatedCount;
+    },
+};
+exports.default = {
+    addClassMethods,
+    addInstanceMethods,
+    extendModel,
+    commonInstanceMethods: exports.commonInstanceMethods,
+    commonClassMethods: exports.commonClassMethods,
+};

package/dist/models/model-manager.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Model Manager Module
+ * Manages model registry and tracking all defined models
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelManager = void 0;
+/**
+ * ModelManager class to track all models
+ */
+class ModelManager {
+    constructor() {
+        this.models = new Map();
+        this.modelDefinitions = new Map();
+    }
+    /**
+     * Get a model by name
+     * @param name - Model name
+     */
+    getModel(name) {
+        return this.models.get(name);
+    }
+    /**
+     * Set a model
+     * @param name - Model name
+     * @param model - Model static
+     */
+    setModel(name, model) {
+        // Check if model with same name already exists
+        if (this.models.has(name)) {
+            throw new Error(`Model '${name}' already exists. Use removeModel() first to replace.`);
+        }
+        this.models.set(name, model);
+    }
+    /**
+     * Check if a model exists
+     * @param name - Model name
+     */
+    hasModel(name) {
+        return this.models.has(name);
+    }
+    /**
+     * Remove a model by name
+     * @param name - Model name
+     */
+    removeModel(name) {
+        const existed = this.models.has(name);
+        this.models.delete(name);
+        this.modelDefinitions.delete(name);
+        return existed;
+    }
+    /**
+     * Get all registered models
+     * @returns Map of model name to ModelStatic
+     */
+    getModels() {
+        return new Map(this.models);
+    }
+    /**
+     * Get all model names
+     * @returns Array of model names
+     */
+    getModelNames() {
+        return Array.from(this.models.keys());
+    }
+    /**
+     * Store a model definition
+     * @param name - Model name
+     * @param attributes - Model attributes
+     * @param options - Model options
+     */
+    addModelDefinition(name, attributes, options) {
+        this.modelDefinitions.set(name, { name, attributes, options });
+    }
+    /**
+     * Get a model definition
+     * @param name - Model name
+     */
+    getModelDefinition(name) {
+        return this.modelDefinitions.get(name);
+    }
+    /**
+     * Get all model definitions
+     */
+    getAllModelDefinitions() {
+        return new Map(this.modelDefinitions);
+    }
+    /**
+     * Clear all models
+     */
+    clear() {
+        this.models.clear();
+        this.modelDefinitions.clear();
+    }
+    /**
+     * Get the count of registered models
+     */
+    getModelCount() {
+        return this.models.size;
+    }
+}
+exports.ModelManager = ModelManager;
+exports.default = ModelManager;