ts-prorm-orm 1.1.0

package/dist/decorators/audit.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * @Audit class decorator — automatically record model lifecycle events to an
+ * in-memory audit log.
+ *
+ * When applied to a model class the decorator registers beforeCreate,
+ * beforeUpdate, and beforeDestroy hooks (via ModelClass.addHook) that append
+ * structured entries to a per-class log.
+ *
+ * Example:
+ *
+ *   @Audit({ tableName: 'audit_log', trackFields: ['name', 'email'] })
+ *   class User extends Model { ... }
+ *
+ *   // After create/update/destroy hooks fire:
+ *   const log = getAuditLog(User);
+ *   clearAuditLog(User);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuditLog = getAuditLog;
+exports.clearAuditLog = clearAuditLog;
+exports.Audit = Audit;
+exports.getAuditOptions = getAuditOptions;
+// ==================== In-memory storage ====================
+const auditLogs = new Map();
+function getLog(target) {
+    if (!auditLogs.has(target)) {
+        auditLogs.set(target, []);
+    }
+    return auditLogs.get(target);
+}
+/** Return all audit log entries accumulated for a model class. */
+function getAuditLog(target) {
+    return getLog(target);
+}
+/** Clear all audit log entries for a model class. */
+function clearAuditLog(target) {
+    auditLogs.set(target, []);
+}
+// ==================== Internal helpers ====================
+function extractValues(instance, fields) {
+    const raw = typeof instance.toJSON === 'function'
+        ? instance.toJSON()
+        : typeof instance.dataValues === 'object' && instance.dataValues !== null
+            ? { ...instance.dataValues }
+            : { ...instance };
+    if (!fields || fields.length === 0)
+        return raw;
+    const result = {};
+    for (const f of fields) {
+        if (Object.prototype.hasOwnProperty.call(raw, f)) {
+            result[f] = raw[f];
+        }
+    }
+    return result;
+}
+function extractPreviousValues(instance, fields) {
+    // Prorm exposes _previousDataValues for changed fields
+    const prev = typeof instance._previousDataValues === 'object' && instance._previousDataValues !== null
+        ? { ...instance._previousDataValues }
+        : extractValues(instance, fields);
+    if (!fields || fields.length === 0)
+        return prev;
+    const result = {};
+    for (const f of fields) {
+        if (Object.prototype.hasOwnProperty.call(prev, f)) {
+            result[f] = prev[f];
+        }
+    }
+    return result;
+}
+// ==================== Decorator ====================
+const AUDIT_OPTIONS_KEY = '__orm_audit_options__';
+/**
+ * Mark a model class for automatic audit logging.
+ *
+ * Hooks are registered via `ModelClass.addHook` if the method exists, so this
+ * decorator is compatible with both Prorm-style models and plain mock classes
+ * that expose addHook manually in tests.
+ */
+function Audit(options = {}) {
+    return (target) => {
+        const auditTable = options.tableName ?? 'audit_log';
+        const trackFields = options.trackFields;
+        const userField = options.userField;
+        // Store options for introspection
+        target[AUDIT_OPTIONS_KEY] = { ...options, tableName: auditTable };
+        const log = getLog(target);
+        function getUser(instance) {
+            if (!userField)
+                return undefined;
+            return typeof instance.getDataValue === 'function'
+                ? instance.getDataValue(userField)
+                : instance[userField];
+        }
+        const beforeCreate = (instance) => {
+            log.push({
+                action: 'CREATE',
+                model: auditTable,
+                newValues: extractValues(instance, trackFields),
+                user: getUser(instance),
+                timestamp: new Date(),
+            });
+        };
+        const beforeUpdate = (instance) => {
+            log.push({
+                action: 'UPDATE',
+                model: auditTable,
+                oldValues: extractPreviousValues(instance, trackFields),
+                newValues: extractValues(instance, trackFields),
+                user: getUser(instance),
+                timestamp: new Date(),
+            });
+        };
+        const beforeDestroy = (instance) => {
+            log.push({
+                action: 'DELETE',
+                model: auditTable,
+                oldValues: extractValues(instance, trackFields),
+                user: getUser(instance),
+                timestamp: new Date(),
+            });
+        };
+        if (typeof target.addHook === 'function') {
+            target.addHook('beforeCreate', 'orm:audit:create', beforeCreate);
+            target.addHook('beforeUpdate', 'orm:audit:update', beforeUpdate);
+            target.addHook('beforeDestroy', 'orm:audit:destroy', beforeDestroy);
+        }
+        // Also store hooks on the class so tests can invoke them directly
+        target.__auditHooks__ = { beforeCreate, beforeUpdate, beforeDestroy };
+    };
+}
+/** Read the AuditOptions stored on a decorated class. */
+function getAuditOptions(target) {
+    return target[AUDIT_OPTIONS_KEY];
+}

package/dist/decorators/belongs-to-many.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * BelongsToMany decorator for the ORM.
+ *
+ * Defines a many-to-many relationship between models via a join table/model.
+ *
+ * Usage:
+ *
+ *   @BelongsToMany(() => Role, { through: 'user_roles' })
+ *   roles: Role[];
+ *
+ *   @BelongsToMany(() => Role, { through: UserRole, as: 'assignedRoles' })
+ *   assignedRoles: Role[];
+ *
+ *   // With options
+ *   @BelongsToMany(() => Tag, {
+ *     through: 'post_tags',
+ *     foreignKey: 'post_id',
+ *     otherKey: 'tag_id',
+ *     onDelete: 'CASCADE'
+ *   })
+ *   tags: Tag[];
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBelongsToMany = getBelongsToMany;
+exports.getAllBelongsToMany = getAllBelongsToMany;
+exports.BelongsToMany = BelongsToMany;
+exports.processBelongsToManyDecorators = processBelongsToManyDecorators;
+// ==================== Metadata Storage ====================
+const BELONGS_TO_MANY_KEY = '__orm_belongs_to_many__';
+/**
+ * Get all @BelongsToMany annotations attached to a model constructor.
+ */
+function getBelongsToMany(target) {
+    return target[BELONGS_TO_MANY_KEY] || [];
+}
+/**
+ * Get all belongsToMany associations including inherited ones.
+ */
+function getAllBelongsToMany(target) {
+    const associations = [];
+    let current = target;
+    while (current && current.prototype) {
+        const meta = getBelongsToMany(current);
+        associations.push(...meta);
+        current = Object.getPrototypeOf(current);
+        if (current === Object.prototype)
+            break;
+    }
+    return associations;
+}
+// ==================== Decorator ====================
+/**
+ * Define a many-to-many relationship.
+ *
+ * This decorator stores metadata on the model class that can be used
+ * by the ORM to establish the association at model initialization time.
+ *
+ * @param target - A function that returns the target model class
+ * @param options - Configuration for the association (through is required)
+ */
+function BelongsToMany(target, options) {
+    return function (prototype, propertyKey) {
+        const ModelClass = prototype.constructor;
+        if (!ModelClass[BELONGS_TO_MANY_KEY]) {
+            ModelClass[BELONGS_TO_MANY_KEY] = [];
+        }
+        ModelClass[BELONGS_TO_MANY_KEY].push({
+            target,
+            options: {
+                as: options.as || propertyKey.toString(),
+                through: options.through,
+                foreignKey: options.foreignKey,
+                otherKey: options.otherKey,
+                constraints: options.constraints,
+                onDelete: options.onDelete,
+                onUpdate: options.onUpdate,
+                targetKey: options.targetKey,
+                sourceKey: options.sourceKey,
+            },
+        });
+    };
+}
+/**
+ * Process @BelongsToMany decorators and create association configuration.
+ *
+ * Call this to get the raw association definitions from decorators.
+ *
+ * @param ModelClass - The model class with @BelongsToMany decorators
+ * @returns Array of association configurations
+ */
+function processBelongsToManyDecorators(ModelClass) {
+    const decorators = getAllBelongsToMany(ModelClass);
+    return decorators.map(({ target, options }) => {
+        const targetModel = target();
+        const foreignKey = typeof options.foreignKey === 'string'
+            ? options.foreignKey
+            : options.foreignKey?.name
+                ? options.foreignKey.name
+                : `${ModelClass.name}Id`;
+        return {
+            source: ModelClass,
+            target: targetModel,
+            foreignKey,
+            as: options.as || '',
+            options,
+        };
+    });
+}
+exports.default = {
+    BelongsToMany,
+    getBelongsToMany,
+    getAllBelongsToMany,
+    processBelongsToManyDecorators,
+};

package/dist/decorators/belongs-to.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * BelongsTo decorator for the ORM.
+ *
+ * Defines a many-to-one (inverse of hasOne/hasMany) relationship between models.
+ *
+ * Usage:
+ *
+ *   @BelongsTo(() => User)
+ *   user: User;
+ *
+ *   @BelongsTo(() => User, { as: 'author' })
+ *   author: User;
+ *
+ *   // With options
+ *   @BelongsTo(() => Category, {
+ *     foreignKey: { name: 'category_id', allowNull: false },
+ *     onDelete: 'CASCADE'
+ *   })
+ *   category: Category;
+ *
+ *   // Self-referential
+ *   @BelongsTo(() => User, { as: 'manager', foreignKey: 'manager_id' })
+ *   manager: User;
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBelongsTo = getBelongsTo;
+exports.getAllBelongsTo = getAllBelongsTo;
+exports.BelongsTo = BelongsTo;
+exports.processBelongsToDecorators = processBelongsToDecorators;
+// ==================== Metadata Storage ====================
+const BELONGS_TO_KEY = '__orm_belongs_to__';
+/**
+ * Get all @BelongsTo annotations attached to a model constructor.
+ */
+function getBelongsTo(target) {
+    return target[BELONGS_TO_KEY] || [];
+}
+/**
+ * Get all belongsTo associations including inherited ones.
+ */
+function getAllBelongsTo(target) {
+    const associations = [];
+    let current = target;
+    while (current && current.prototype) {
+        const meta = getBelongsTo(current);
+        associations.push(...meta);
+        current = Object.getPrototypeOf(current);
+        if (current === Object.prototype)
+            break;
+    }
+    return associations;
+}
+// ==================== Decorator ====================
+/**
+ * Define a many-to-one relationship.
+ *
+ * This decorator stores metadata on the model class that can be used
+ * by the ORM to establish the association at model initialization time.
+ *
+ * @param target - A function that returns the target model class
+ * @param options - Optional configuration for the association
+ */
+function BelongsTo(target, options = {}) {
+    return function (prototype, propertyKey) {
+        const ModelClass = prototype.constructor;
+        if (!ModelClass[BELONGS_TO_KEY]) {
+            ModelClass[BELONGS_TO_KEY] = [];
+        }
+        ModelClass[BELONGS_TO_KEY].push({
+            target,
+            options: {
+                as: options.as || propertyKey.toString(),
+                foreignKey: options.foreignKey,
+                constraints: options.constraints,
+                onDelete: options.onDelete,
+                onUpdate: options.onUpdate,
+                targetKey: options.targetKey,
+                sourceKey: options.sourceKey,
+            },
+        });
+    };
+}
+/**
+ * Process @BelongsTo decorators and create association configuration.
+ *
+ * Call this to get the raw association definitions from decorators.
+ *
+ * @param ModelClass - The model class with @BelongsTo decorators
+ * @returns Array of association configurations
+ */
+function processBelongsToDecorators(ModelClass) {
+    const decorators = getAllBelongsTo(ModelClass);
+    return decorators.map(({ target, options }) => {
+        const targetModel = target();
+        const foreignKey = typeof options.foreignKey === 'string'
+            ? options.foreignKey
+            : options.foreignKey?.name
+                ? options.foreignKey.name
+                : `${targetModel.name}Id`;
+        return {
+            source: ModelClass,
+            target: targetModel,
+            foreignKey,
+            as: options.as || '',
+            options,
+        };
+    });
+}
+exports.default = {
+    BelongsTo,
+    getBelongsTo,
+    getAllBelongsTo,
+    processBelongsToDecorators,
+};