ts-prorm-orm 1.1.0

package/dist/models/decorators.js

@@ -0,0 +1,445 @@
+"use strict";
+/**
+ * Model Decorators for TypeScript
+ *
+ * Provides decorators for defining models:
+ * - @Table - Configure table options
+ * - @Attribute - Define a column attribute
+ * - @PrimaryKey - Mark as primary key
+ * - @AutoIncrement - Enable auto-increment
+ * - @NotNull - Add NOT NULL constraint
+ * - @Default - Set default value
+ * - @Unique - Add UNIQUE constraint
+ * - @Comment - Add column comment
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = Table;
+exports.Attribute = Attribute;
+exports.Column = Column;
+exports.AllowNull = AllowNull;
+exports.PrimaryKey = PrimaryKey;
+exports.AutoIncrement = AutoIncrement;
+exports.NotNull = NotNull;
+exports.Default = Default;
+exports.Unique = Unique;
+exports.Comment = Comment;
+exports.HasOne = HasOne;
+exports.HasMany = HasMany;
+exports.BelongsTo = BelongsTo;
+exports.BelongsToMany = BelongsToMany;
+exports.getModelMetadata = getModelMetadata;
+exports.getAttributeMetadata = getAttributeMetadata;
+exports.getAssociationMetadata = getAssociationMetadata;
+exports.getModelAttributes = getModelAttributes;
+exports.clearMetadata = clearMetadata;
+/**
+ * @example
+ * ```typescript
+ * import { Model, DataTypes, InferAttributes, InferCreationAttributes } from 'orm';
+ * import { Table, Attribute, PrimaryKey, AutoIncrement, NotNull, Default } from 'orm/decorators';
+ *
+ * @Table({ tableName: 'users', timestamps: true })
+ * export class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
+ *   @Attribute(DataTypes.INTEGER)
+ *   @PrimaryKey
+ *   @AutoIncrement
+ *   declare id: number;
+ *
+ *   @Attribute(DataTypes.STRING)
+ *   @NotNull
+ *   declare name: string;
+ *
+ *   @Attribute(DataTypes.DATE)
+ *   @Default(DataTypes.NOW)
+ *   declare createdAt: Date;
+ * }
+ * ```
+ */
+const data_types_1 = require("./data-types");
+// ==================== Metadata Storage ====================
+/**
+ * Storage for model and attribute metadata
+ */
+const modelMetadata = new Map();
+const attributeMetadata = new Map();
+const associationMetadata = new Map();
+// ==================== Decorators ====================
+/**
+ * Define model options (use on model class)
+ *
+ * @example
+ * @Table({ tableName: 'users', timestamps: true })
+ */
+function Table(options = {}) {
+    return function (target) {
+        const modelName = target.name;
+        modelMetadata.set(modelName, {
+            tableName: options.tableName,
+            schema: options.schema,
+            schemaDelimiter: options.schemaDelimiter,
+            modelName: options.modelName,
+            timestamps: options.timestamps,
+            createdAt: options.createdAt,
+            updatedAt: options.updatedAt,
+            deletedAt: options.deletedAt,
+            underscored: options.underscored,
+            freezeTableName: options.freezeTableName,
+            hooks: options.hooks,
+            indexes: options.indexes,
+            comment: options.comment,
+            collate: options.collate,
+            primaryKey: options.primaryKey,
+            // Prorm also treats an explicit `paranoid: true` (independent of `deletedAt`)
+            // as enabling soft-deletes; capture it so callers (Prorm.addModel) can honor it.
+            paranoid: options.paranoid,
+            defaultScope: options.defaultScope,
+            scopes: options.scopes,
+            validate: options.validate,
+            name: options.name,
+            getterMethods: options.getterMethods,
+            setterMethods: options.setterMethods,
+            version: options.version,
+        });
+        return target;
+    };
+}
+/**
+ * Define a model attribute/column
+ *
+ * @example
+ * @Attribute(DataTypes.STRING)
+ * @Attribute(DataTypes.INTEGER)
+ */
+function Attribute(type) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        if (!attributeMetadata.has(modelName)) {
+            attributeMetadata.set(modelName, new Map());
+        }
+        const attrs = attributeMetadata.get(modelName);
+        const fieldName = String(propertyKey);
+        attrs.set(fieldName, {
+            type,
+            allowNull: true,
+        });
+    };
+}
+/**
+ * Column decorator - alias for Attribute
+ */
+function Column(type) {
+    return Attribute(type);
+}
+/**
+ * AllowNull decorator - mark attribute as nullable (default)
+ */
+function AllowNull(allowNull = true) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        const attrs = attributeMetadata.get(modelName);
+        if (attrs) {
+            const fieldName = String(propertyKey);
+            const attr = attrs.get(fieldName);
+            if (attr) {
+                attr.allowNull = allowNull;
+            }
+        }
+    };
+}
+/**
+ * Mark attribute as primary key
+ *
+ * @example
+ * @Attribute(DataTypes.INTEGER)
+ * @PrimaryKey
+ */
+function PrimaryKey() {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        const attrs = attributeMetadata.get(modelName);
+        if (attrs) {
+            const fieldName = String(propertyKey);
+            let attr = attrs.get(fieldName);
+            if (!attr) {
+                attr = { type: data_types_1.DataTypes.INTEGER() };
+                attrs.set(fieldName, attr);
+            }
+            attr.primaryKey = true;
+            attr.allowNull = false;
+        }
+    };
+}
+/**
+ * Enable auto-increment on attribute
+ *
+ * @example
+ * @Attribute(DataTypes.INTEGER)
+ * @AutoIncrement
+ */
+function AutoIncrement() {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        const attrs = attributeMetadata.get(modelName);
+        if (attrs) {
+            const fieldName = String(propertyKey);
+            const attr = attrs.get(fieldName);
+            if (attr) {
+                attr.autoIncrement = true;
+            }
+        }
+    };
+}
+/**
+ * Add NOT NULL constraint
+ *
+ * @example
+ * @Attribute(DataTypes.STRING)
+ * @NotNull
+ */
+function NotNull() {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        const attrs = attributeMetadata.get(modelName);
+        if (attrs) {
+            const fieldName = String(propertyKey);
+            const attr = attrs.get(fieldName);
+            if (attr) {
+                attr.notNull = true;
+                attr.allowNull = false;
+            }
+        }
+    };
+}
+/**
+ * Set default value
+ *
+ * @example
+ * @Default('value')
+ * @Default(DataTypes.NOW)
+ * @Default(() => Math.random())
+ */
+function Default(value) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        const attrs = attributeMetadata.get(modelName);
+        if (attrs) {
+            const fieldName = String(propertyKey);
+            const attr = attrs.get(fieldName);
+            if (attr) {
+                attr.defaultValue = value;
+            }
+        }
+    };
+}
+/**
+ * Add UNIQUE constraint
+ *
+ * @example
+ * @Unique
+ * @Unique('unique_name')
+ */
+function Unique(nameOrOptions) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        const attrs = attributeMetadata.get(modelName);
+        if (attrs) {
+            const fieldName = String(propertyKey);
+            const attr = attrs.get(fieldName);
+            if (attr) {
+                attr.unique = typeof nameOrOptions === 'string' ? nameOrOptions : true;
+            }
+        }
+    };
+}
+/**
+ * Add comment to column
+ *
+ * @example
+ * @Comment('User email address')
+ */
+function Comment(text) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        const attrs = attributeMetadata.get(modelName);
+        if (attrs) {
+            const fieldName = String(propertyKey);
+            const attr = attrs.get(fieldName);
+            if (attr) {
+                attr.comment = text;
+            }
+        }
+    };
+}
+// ==================== Association Decorators ====================
+/**
+ * Define a hasOne association
+ *
+ * @example
+ * @HasOne(() => Profile)
+ * declare profile: HasOne<Profile>;
+ */
+function HasOne(targetFn, options = {}) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        if (!associationMetadata.has(modelName)) {
+            associationMetadata.set(modelName, []);
+        }
+        const fieldName = String(propertyKey);
+        associationMetadata.get(modelName).push({
+            type: 'hasOne',
+            propertyKey: fieldName,
+            target: targetFn,
+            as: options.as || fieldName,
+            foreignKey: options.foreignKey,
+            sourceKey: options.sourceKey,
+            onDelete: options.onDelete,
+            onUpdate: options.onUpdate,
+            hooks: options.hooks,
+        });
+    };
+}
+/**
+ * Define a hasMany association
+ *
+ * @example
+ * @HasMany(() => Post)
+ * declare posts: HasMany<Post>;
+ */
+function HasMany(targetFn, options = {}) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        if (!associationMetadata.has(modelName)) {
+            associationMetadata.set(modelName, []);
+        }
+        const fieldName = String(propertyKey);
+        associationMetadata.get(modelName).push({
+            type: 'hasMany',
+            propertyKey: fieldName,
+            target: targetFn,
+            as: options.as || fieldName,
+            foreignKey: options.foreignKey,
+            sourceKey: options.sourceKey,
+            onDelete: options.onDelete,
+            onUpdate: options.onUpdate,
+            hooks: options.hooks,
+        });
+    };
+}
+/**
+ * Define a belongsTo association
+ *
+ * @example
+ * @BelongsTo(() => User)
+ * declare user: BelongsTo<User>;
+ */
+function BelongsTo(targetFn, options = {}) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        if (!associationMetadata.has(modelName)) {
+            associationMetadata.set(modelName, []);
+        }
+        const fieldName = String(propertyKey);
+        associationMetadata.get(modelName).push({
+            type: 'belongsTo',
+            propertyKey: fieldName,
+            target: targetFn,
+            as: options.as || fieldName,
+            foreignKey: options.foreignKey,
+            targetKey: options.targetKey,
+            onDelete: options.onDelete,
+            onUpdate: options.onUpdate,
+            hooks: options.hooks,
+        });
+    };
+}
+/**
+ * Define a belongsToMany association
+ *
+ * @example
+ * @BelongsToMany(() => Role, { through: UserRole })
+ * declare roles: BelongsToMany<Role>;
+ */
+function BelongsToMany(targetFn, options) {
+    return function (target, propertyKey) {
+        const modelName = target.constructor?.name;
+        if (!modelName)
+            return;
+        if (!associationMetadata.has(modelName)) {
+            associationMetadata.set(modelName, []);
+        }
+        const fieldName = String(propertyKey);
+        associationMetadata.get(modelName).push({
+            type: 'belongsToMany',
+            propertyKey: fieldName,
+            target: targetFn,
+            as: options.as || fieldName,
+            foreignKey: options.foreignKey,
+            otherKey: options.otherKey,
+            through: options.through,
+            onDelete: options.onDelete,
+            onUpdate: options.onUpdate,
+            hooks: options.hooks,
+        });
+    };
+}
+// ==================== Utility Functions ====================
+/**
+ * Get model metadata
+ */
+function getModelMetadata(modelName) {
+    return modelMetadata.get(modelName);
+}
+/**
+ * Get attribute metadata for a model
+ */
+function getAttributeMetadata(modelName) {
+    return attributeMetadata.get(modelName);
+}
+/**
+ * Get association metadata (from @HasOne/@HasMany/@BelongsTo/@BelongsToMany)
+ * recorded for a model.
+ */
+function getAssociationMetadata(modelName) {
+    return associationMetadata.get(modelName);
+}
+/**
+ * Extract all attributes from a model class
+ */
+function getModelAttributes(model) {
+    const modelName = model.name;
+    const attrs = attributeMetadata.get(modelName);
+    if (!attrs) {
+        return {};
+    }
+    return Object.fromEntries(attrs);
+}
+/**
+ * Clear all metadata (useful for testing)
+ */
+function clearMetadata() {
+    modelMetadata.clear();
+    attributeMetadata.clear();
+    associationMetadata.clear();
+}

package/dist/models/index.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Models module exports
+ */
+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.Model = exports.ModelManager = void 0;
+__exportStar(require("./data-types"), exports);
+__exportStar(require("./operators"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./associations"), exports);
+__exportStar(require("./scopes"), exports);
+var model_manager_1 = require("./model-manager");
+Object.defineProperty(exports, "ModelManager", { enumerable: true, get: function () { return model_manager_1.ModelManager; } });
+__exportStar(require("./scopes"), exports);
+__exportStar(require("./model-manager"), exports);
+__exportStar(require("./methods"), exports);
+// Export the base Model class for decorator-based definitions
+var model_1 = require("./model");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_1.Model; } });