ts-prorm-orm 1.1.0

package/dist/models/constraints.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Constraint management for the TypeScript ORM
+ * Handles constraint creation for PRIMARY KEY, UNIQUE, FOREIGN KEY, and CHECK constraints
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintCollection = exports.Constraint = void 0;
+exports.generateConstraintName = generateConstraintName;
+exports.buildPrimaryKeyConstraint = buildPrimaryKeyConstraint;
+exports.buildUniqueConstraint = buildUniqueConstraint;
+exports.buildForeignKeyConstraint = buildForeignKeyConstraint;
+exports.buildCheckConstraint = buildCheckConstraint;
+exports.buildConstraintSQL = buildConstraintSQL;
+exports.normalizeConstraintFields = normalizeConstraintFields;
+exports.primaryKey = primaryKey;
+exports.unique = unique;
+exports.foreignKey = foreignKey;
+exports.check = check;
+/**
+ * Generate a unique constraint name
+ */
+function generateConstraintName(type, tableName, fields) {
+    const typePrefix = type.toLowerCase().replace(' ', '_');
+    const fieldStr = fields.join('_');
+    const timestamp = Date.now().toString(36).slice(-4);
+    return `${typePrefix}_${tableName}_${fieldStr}_${timestamp}`;
+}
+/**
+ * Constraint class representing a database constraint
+ */
+class Constraint {
+    constructor(options) {
+        // Support both name and constraintName
+        this.name = options.name || options.constraintName || '';
+        this.type = options.type;
+        this.fields = options.fields || [];
+        this.references = options.references;
+        this.where = options.where;
+        this.check = options.check;
+        this.deferrable = options.deferrable;
+        this.match = options.match;
+        this.tableName = options.tableName;
+    }
+    /**
+     * Get field names as string array
+     */
+    getFieldNames() {
+        if (this.fields.length === 0)
+            return [];
+        if (typeof this.fields[0] === 'string') {
+            return this.fields;
+        }
+        return this.fields.map((f) => f.name);
+    }
+    /**
+     * Check if this is a composite constraint
+     */
+    isComposite() {
+        return this.fields.length > 1;
+    }
+    /**
+     * Convert to plain object
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            fields: this.fields,
+            references: this.references,
+            where: this.where,
+            check: this.check,
+            deferrable: this.deferrable,
+            tableName: this.tableName,
+        };
+    }
+}
+exports.Constraint = Constraint;
+/**
+ * Constraint collection for managing multiple constraints
+ */
+class ConstraintCollection {
+    constructor() {
+        this.constraints = new Map();
+    }
+    /**
+     * Add a constraint to the collection
+     */
+    addConstraint(constraint) {
+        if (!constraint.name) {
+            throw new Error('Constraint must have a name');
+        }
+        this.constraints.set(constraint.name, constraint);
+    }
+    /**
+     * Get a constraint by name
+     */
+    getConstraint(name) {
+        return this.constraints.get(name);
+    }
+    /**
+     * Get all constraints
+     */
+    getAllConstraints() {
+        return Array.from(this.constraints.values());
+    }
+    /**
+     * Get constraints by type
+     */
+    getConstraintsByType(type) {
+        return this.getAllConstraints().filter((c) => c.type === type);
+    }
+    /**
+     * Remove a constraint by name
+     */
+    removeConstraint(name) {
+        return this.constraints.delete(name);
+    }
+    /**
+     * Check if a constraint exists
+     */
+    hasConstraint(name) {
+        return this.constraints.has(name);
+    }
+    /**
+     * Get the number of constraints
+     */
+    get size() {
+        return this.constraints.size;
+    }
+    /**
+     * Clear all constraints
+     */
+    clear() {
+        this.constraints.clear();
+    }
+}
+exports.ConstraintCollection = ConstraintCollection;
+// ==================== Constraint Builders ====================
+/**
+ * Escape an identifier for a specific dialect.
+ * MySQL/MariaDB use backticks by default; Postgres and SQLite use double quotes.
+ */
+function escapeConstraintIdent(name, dialect = 'postgres') {
+    return dialect === 'mysql' || dialect === 'mariadb' ? `\`${name}\`` : `"${name}"`;
+}
+/**
+ * Build a primary key constraint
+ */
+function buildPrimaryKeyConstraint(tableName, fields, constraintName, dialect = 'postgres') {
+    const name = constraintName || `pk_${tableName}`;
+    const fieldList = fields.map((f) => escapeConstraintIdent(f, dialect)).join(', ');
+    return `CONSTRAINT ${escapeConstraintIdent(name, dialect)} PRIMARY KEY (${fieldList})`;
+}
+/**
+ * Build a unique constraint
+ */
+function buildUniqueConstraint(tableName, fields, constraintName, dialect = 'postgres') {
+    const name = constraintName || `uq_${tableName}_${fields.join('_')}`;
+    const fieldList = fields.map((f) => escapeConstraintIdent(f, dialect)).join(', ');
+    return `CONSTRAINT ${escapeConstraintIdent(name, dialect)} UNIQUE (${fieldList})`;
+}
+/**
+ * Build a foreign key constraint
+ */
+function buildForeignKeyConstraint(tableName, fields, references, constraintName, dialect = 'postgres') {
+    const name = constraintName || `fk_${tableName}_${fields.join('_')}_${references.table}`;
+    const fieldList = fields.map((f) => escapeConstraintIdent(f, dialect)).join(', ');
+    // Handle composite key fields on referenced table
+    const refFields = references.fields && references.fields.length > 0 ? references.fields : [references.field];
+    const refFieldList = refFields.map((f) => escapeConstraintIdent(f, dialect)).join(', ');
+    let sql = `CONSTRAINT ${escapeConstraintIdent(name, dialect)} FOREIGN KEY (${fieldList}) REFERENCES ${escapeConstraintIdent(references.table, dialect)}(${refFieldList})`;
+    // Add MATCH clause (PostgreSQL)
+    if (references.match && references.match !== 'SIMPLE') {
+        sql += ` MATCH ${references.match}`;
+    }
+    if (references.onDelete) {
+        sql += ` ON DELETE ${references.onDelete}`;
+    }
+    if (references.onUpdate) {
+        sql += ` ON UPDATE ${references.onUpdate}`;
+    }
+    if (references.deferrable) {
+        sql += ` DEFERRABLE ${references.deferrable}`;
+    }
+    return sql;
+}
+/**
+ * Build a check constraint
+ */
+function buildCheckConstraint(tableName, check, constraintName, dialect = 'postgres') {
+    const name = constraintName || `chk_${tableName}_${Date.now()}`;
+    return `CONSTRAINT ${escapeConstraintIdent(name, dialect)} CHECK (${check})`;
+}
+/**
+ * Build constraint SQL for a specific dialect
+ */
+function buildConstraintSQL(dialect, constraint, tableName) {
+    const fields = constraint.getFieldNames();
+    switch (constraint.type) {
+        case 'PRIMARY KEY':
+            return buildPrimaryKeyConstraint(tableName, fields, constraint.name, dialect);
+        case 'UNIQUE':
+            return buildUniqueConstraint(tableName, fields, constraint.name, dialect);
+        case 'FOREIGN KEY':
+            if (!constraint.references) {
+                throw new Error('Foreign key constraint requires references');
+            }
+            return buildForeignKeyConstraint(tableName, fields, constraint.references, constraint.name, dialect);
+        case 'CHECK':
+            if (!constraint.check) {
+                throw new Error('Check constraint requires a check expression');
+            }
+            return buildCheckConstraint(tableName, constraint.check, constraint.name, dialect);
+        default:
+            throw new Error(`Unsupported constraint type: ${constraint.type}`);
+    }
+}
+/**
+ * Normalize fields to string array
+ */
+function normalizeConstraintFields(fields) {
+    return fields.map((f) => {
+        if (typeof f === 'string') {
+            return f;
+        }
+        return f.name;
+    });
+}
+// ==================== Convenience Factory Methods ====================
+/**
+ * Create a primary key constraint
+ */
+function primaryKey(fields, options) {
+    const constraintName = options?.name || `pk_${options?.tableName || 'table'}`;
+    return new Constraint({
+        name: constraintName,
+        type: 'PRIMARY KEY',
+        fields,
+        tableName: options?.tableName,
+    });
+}
+/**
+ * Create a unique constraint
+ */
+function unique(fields, options) {
+    const tableName = options?.tableName || 'table';
+    const fieldStr = Array.isArray(fields)
+        ? fields.map((f) => (typeof f === 'string' ? f : f.name)).join('_')
+        : '';
+    const constraintName = options?.name || `uq_${tableName}_${fieldStr}`;
+    return new Constraint({
+        name: constraintName,
+        type: 'UNIQUE',
+        fields,
+        tableName: options?.tableName,
+    });
+}
+/**
+ * Create a foreign key constraint
+ */
+function foreignKey(fields, references, options) {
+    const tableName = options?.tableName || 'table';
+    const fieldStr = Array.isArray(fields)
+        ? fields.map((f) => (typeof f === 'string' ? f : f.name)).join('_')
+        : '';
+    const constraintName = options?.name || `fk_${tableName}_${fieldStr}_${references.table}`;
+    return new Constraint({
+        name: constraintName,
+        type: 'FOREIGN KEY',
+        fields,
+        references,
+        tableName: options?.tableName,
+    });
+}
+/**
+ * Create a check constraint
+ */
+function check(check, options) {
+    const tableName = options?.tableName || 'table';
+    const constraintName = options?.name || `chk_${tableName}`;
+    return new Constraint({
+        name: constraintName,
+        type: 'CHECK',
+        fields: [],
+        check,
+        tableName: options?.tableName,
+    });
+}