ts-prorm-orm 1.1.0

package/dist/models/indexes.js

@@ -0,0 +1,531 @@
+"use strict";
+/**
+ * Index and Constraint classes for the TypeScript ORM
+ * Supports single column, composite, unique, and partial indexes
+ * Supports foreign key constraints with cascade options
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintCollection = exports.IndexCollection = exports.Constraint = exports.Index = void 0;
+exports.generateIndexName = generateIndexName;
+exports.generateConstraintName = generateConstraintName;
+exports.generateUniqueConstraintName = generateUniqueConstraintName;
+exports.generateForeignKeyConstraintName = generateForeignKeyConstraintName;
+exports.generatePrimaryKeyConstraintName = generatePrimaryKeyConstraintName;
+exports.normalizeFields = normalizeFields;
+exports.buildIndexSQL = buildIndexSQL;
+exports.buildDropIndexSQL = buildDropIndexSQL;
+exports.buildConstraintSQL = buildConstraintSQL;
+exports.buildAddConstraintSQL = buildAddConstraintSQL;
+exports.buildDropConstraintSQL = buildDropConstraintSQL;
+/**
+ * Index class representing a database index
+ */
+class Index {
+    constructor(options) {
+        this.name = options.name || '';
+        this.unique = options.unique || false;
+        this.type = options.type;
+        this.using = options.using;
+        this.algorithm = options.algorithm;
+        this.fields = this.normalizeFields(options.fields || []);
+        this.where = options.where;
+        this.include = options.include;
+        this.expression = options.expression;
+        this.tableName = options.tableName;
+        this.fulltext = options.fulltext;
+        this.spatial = options.spatial;
+        this.parser = options.parser;
+        this.textSearchConfig = options.textSearchConfig;
+        this.gistOptions = options.gistOptions;
+    }
+    /**
+     * Normalize fields to IndexField array
+     */
+    normalizeFields(fields) {
+        return fields.map((f) => {
+            if (typeof f === 'string') {
+                return { name: f, order: 'ASC' };
+            }
+            return {
+                name: f.name,
+                length: f.length,
+                order: (f.order || 'ASC'),
+                collate: f.collate,
+            };
+        });
+    }
+    /**
+     * Get the field names as a simple string array
+     */
+    getFieldNames() {
+        return this.fields.map((f) => f.name);
+    }
+    /**
+     * Check if this is a partial index
+     */
+    isPartial() {
+        return !!this.where && Object.keys(this.where).length > 0;
+    }
+    /**
+     * Check if this is an expression index
+     */
+    isExpression() {
+        return !!this.expression;
+    }
+    /**
+     * Check if this is a composite index
+     */
+    isComposite() {
+        return this.fields.length > 1;
+    }
+    /**
+     * Convert to plain object
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            unique: this.unique,
+            type: this.type,
+            using: this.using,
+            algorithm: this.algorithm,
+            fields: this.fields,
+            where: this.where,
+            include: this.include,
+            expression: this.expression,
+            tableName: this.tableName,
+            fulltext: this.fulltext,
+            parser: this.parser,
+            textSearchConfig: this.textSearchConfig,
+        };
+    }
+    /**
+     * Check if this is a fulltext index
+     */
+    isFulltext() {
+        return !!this.fulltext;
+    }
+    /**
+     * Check if this is a GIN index
+     */
+    isGIN() {
+        return this.algorithm === 'gin';
+    }
+}
+exports.Index = Index;
+/**
+ * Constraint class representing a database constraint
+ */
+class Constraint {
+    constructor(options) {
+        this.name = options.name || '';
+        this.type = options.type;
+        this.fields = options.fields || [];
+        this.references = options.references;
+        this.onDelete = options.onDelete;
+        this.onUpdate = options.onUpdate;
+        this.check = options.check;
+        this.deferrable = options.deferrable;
+        this.tableName = options.tableName;
+    }
+    /**
+     * Check if this is a foreign key constraint
+     */
+    isForeignKey() {
+        return this.type === 'FOREIGN KEY';
+    }
+    /**
+     * Check if this is a unique constraint
+     */
+    isUnique() {
+        return this.type === 'UNIQUE';
+    }
+    /**
+     * Check if this is a primary key constraint
+     */
+    isPrimaryKey() {
+        return this.type === 'PRIMARY KEY';
+    }
+    /**
+     * Check if this is a check constraint
+     */
+    isCheck() {
+        return this.type === 'CHECK';
+    }
+    /**
+     * Get the ON DELETE action
+     */
+    getOnDelete() {
+        return this.onDelete;
+    }
+    /**
+     * Get the ON UPDATE action
+     */
+    getOnUpdate() {
+        return this.onUpdate;
+    }
+    /**
+     * Convert to plain object
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            fields: this.fields,
+            references: this.references,
+            onDelete: this.onDelete,
+            onUpdate: this.onUpdate,
+            check: this.check,
+            deferrable: this.deferrable,
+            tableName: this.tableName,
+        };
+    }
+}
+exports.Constraint = Constraint;
+/**
+ * Generate a unique index name based on table and fields
+ */
+function generateIndexName(tableName, fields) {
+    const fieldNames = Array.isArray(fields)
+        ? fields.map((f) => (typeof f === 'string' ? f : f.name)).join('_')
+        : fields;
+    return `idx_${tableName}_${fieldNames}`;
+}
+/**
+ * Generate constraint name with auto-naming convention
+ * - Primary key: table_pkey
+ * - Unique: table_field1_field2_key or custom name
+ * - Foreign key: table_field_fkey or table_field_referencedTable_fkey
+ */
+function generateConstraintName(tableName, type, fields, options) {
+    // If custom name is provided, use it
+    if (options?.name) {
+        return options.name;
+    }
+    const fieldStr = fields.join('_');
+    const refTable = options?.referencedTable;
+    switch (type) {
+        case 'PRIMARY KEY':
+            // Primary key: table_pkey
+            return `${tableName}_pkey`;
+        case 'UNIQUE':
+            // Unique: table_field1_field2_key or table_field_key for single field
+            if (fields.length === 1) {
+                return `${tableName}_${fields[0]}_key`;
+            }
+            return `${tableName}_${fieldStr}_key`;
+        case 'FOREIGN KEY':
+            // Foreign key: table_field_fkey or table_field_referencedTable_fkey for composite
+            if (refTable) {
+                return `${tableName}_${fieldStr}_${refTable}_fkey`;
+            }
+            return `${tableName}_${fieldStr}_fkey`;
+        case 'CHECK':
+            // Check: table_field_check
+            return `${tableName}_${fieldStr}_check`;
+        default: {
+            // This should never happen if all ConstraintType cases are handled
+            const unknownType = type;
+            return `${unknownType.toLowerCase().replace(' ', '_')}_${tableName}_${fieldStr}`;
+        }
+    }
+}
+/**
+ * Generate unique constraint name
+ */
+function generateUniqueConstraintName(tableName, fields, customName) {
+    if (customName) {
+        return customName;
+    }
+    if (fields.length === 1) {
+        return `${tableName}_${fields[0]}_key`;
+    }
+    return `${tableName}_${fields.join('_')}_key`;
+}
+/**
+ * Generate foreign key constraint name
+ */
+function generateForeignKeyConstraintName(tableName, fields, referencedTable, customName) {
+    if (customName) {
+        return customName;
+    }
+    const fieldStr = fields.join('_');
+    if (referencedTable) {
+        return `${tableName}_${fieldStr}_${referencedTable}_fkey`;
+    }
+    return `${tableName}_${fieldStr}_fkey`;
+}
+/**
+ * Generate primary key constraint name
+ */
+function generatePrimaryKeyConstraintName(tableName, customName) {
+    return customName || `${tableName}_pkey`;
+}
+/**
+ * Normalize fields to IndexField array
+ */
+function normalizeFields(fields) {
+    return fields.map((f) => {
+        if (typeof f === 'string') {
+            return { name: f, order: 'ASC' };
+        }
+        return {
+            name: f.name,
+            length: f.length,
+            order: (f.order || 'ASC'),
+            collate: f.collate,
+        };
+    });
+}
+/**
+ * Index collection for managing multiple indexes
+ */
+class IndexCollection {
+    constructor() {
+        this.indexes = new Map();
+    }
+    /**
+     * Add an index to the collection
+     */
+    addIndex(index) {
+        if (!index.name) {
+            throw new Error('Index must have a name');
+        }
+        this.indexes.set(index.name, index);
+    }
+    /**
+     * Get an index by name
+     */
+    getIndex(name) {
+        return this.indexes.get(name);
+    }
+    /**
+     * Get all indexes
+     */
+    getAllIndexes() {
+        return Array.from(this.indexes.values());
+    }
+    /**
+     * Remove an index by name
+     */
+    removeIndex(name) {
+        return this.indexes.delete(name);
+    }
+    /**
+     * Check if an index exists
+     */
+    hasIndex(name) {
+        return this.indexes.has(name);
+    }
+    /**
+     * Get the number of indexes
+     */
+    get size() {
+        return this.indexes.size;
+    }
+    /**
+     * Clear all indexes
+     */
+    clear() {
+        this.indexes.clear();
+    }
+}
+exports.IndexCollection = IndexCollection;
+/**
+ * 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());
+    }
+    /**
+     * 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();
+    }
+    /**
+     * Get all foreign key constraints
+     */
+    getForeignKeys() {
+        return this.getAllConstraints().filter((c) => c.isForeignKey());
+    }
+    /**
+     * Get all unique constraints
+     */
+    getUniqueConstraints() {
+        return this.getAllConstraints().filter((c) => c.isUnique());
+    }
+}
+exports.ConstraintCollection = ConstraintCollection;
+/**
+ * Build index SQL for a specific dialect
+ */
+function buildIndexSQL(dialect, indexName, tableName, fields, options) {
+    const escapeIdent = (name) => dialect === 'mysql' || dialect === 'mariadb' ? `\`${name}\`` : `"${name}"`;
+    const normalizedFields = normalizeFields(fields);
+    const fieldList = normalizedFields
+        .map((f) => {
+        let fieldStr = escapeIdent(f.name);
+        if (f.length) {
+            fieldStr += `(${f.length})`;
+        }
+        if (f.order) {
+            fieldStr += ` ${f.order}`;
+        }
+        return fieldStr;
+    })
+        .join(', ');
+    // Handle FULLTEXT index for MySQL/MariaDB
+    if (options?.fulltext && (dialect === 'mysql' || dialect === 'mariadb')) {
+        let sql = 'CREATE FULLTEXT';
+        if (options?.unique) {
+            sql += ' UNIQUE';
+        }
+        sql += ` INDEX ${escapeIdent(indexName)} ON ${escapeIdent(tableName)} (${fieldList})`;
+        if (options?.parser) {
+            sql += ` WITH PARSER ${options.parser}`;
+        }
+        return sql;
+    }
+    let sql = 'CREATE';
+    if (options?.unique) {
+        sql += ' UNIQUE';
+    }
+    if (options?.type) {
+        sql += ` INDEX ${options.type}`;
+    }
+    else {
+        sql += ' INDEX';
+    }
+    const escapedIndexName = escapeIdent(indexName);
+    const escapedTableName = escapeIdent(tableName);
+    sql += ` ${escapedIndexName} ON ${escapedTableName} (${fieldList})`;
+    // Add USING clause - algorithm takes precedence over using for PostgreSQL index algorithms
+    if (options?.algorithm) {
+        sql += ` USING ${options.algorithm}`;
+    }
+    else if (options?.using) {
+        sql += ` USING ${options.using}`;
+    }
+    return sql;
+}
+/**
+ * Build DROP INDEX SQL
+ */
+function buildDropIndexSQL(dialect, indexName, tableName) {
+    const escapeIdent = (name) => dialect === 'mysql' || dialect === 'mariadb' ? `\`${name}\`` : `"${name}"`;
+    if (dialect === 'mysql' || dialect === 'mariadb') {
+        if (!tableName) {
+            throw new Error('tableName is required for MySQL/MariaDB DROP INDEX');
+        }
+        // MySQL/MariaDB syntax: DROP INDEX index_name ON tbl_name
+        return `DROP INDEX ${escapeIdent(indexName)} ON ${escapeIdent(tableName)}`;
+    }
+    return `DROP INDEX ${escapeIdent(indexName)}`;
+}
+/**
+ * Build constraint SQL for a specific dialect
+ */
+function buildConstraintSQL(dialect, constraint, tableName) {
+    const escapeIdent = (name) => dialect === 'mysql' || dialect === 'mariadb' ? `\`${name}\`` : `"${name}"`;
+    const escapedFields = constraint.fields.map((f) => escapeIdent(f)).join(', ');
+    const escapedName = escapeIdent(constraint.name);
+    switch (constraint.type) {
+        case 'UNIQUE':
+            return `CONSTRAINT ${escapedName} UNIQUE (${escapedFields})`;
+        case 'PRIMARY KEY':
+            return `CONSTRAINT ${escapedName} PRIMARY KEY (${escapedFields})`;
+        case 'FOREIGN KEY': {
+            if (!constraint.references) {
+                throw new Error('Foreign key constraint requires references');
+            }
+            let sql = `CONSTRAINT ${escapedName} FOREIGN KEY (${escapedFields}) `;
+            sql += `REFERENCES ${escapeIdent(constraint.references.table)} (${escapeIdent(constraint.references.field)})`;
+            if (constraint.onDelete) {
+                sql += ` ON DELETE ${constraint.onDelete}`;
+            }
+            if (constraint.onUpdate) {
+                sql += ` ON UPDATE ${constraint.onUpdate}`;
+            }
+            if (constraint.deferrable) {
+                sql += ` DEFERRABLE ${constraint.deferrable}`;
+            }
+            return sql;
+        }
+        case 'CHECK':
+            if (!constraint.check) {
+                throw new Error('Check constraint requires check expression');
+            }
+            return `CONSTRAINT ${escapedName} CHECK (${constraint.check})`;
+        default:
+            throw new Error(`Unknown constraint type: ${constraint.type}`);
+    }
+}
+/**
+ * Build ADD CONSTRAINT SQL
+ */
+function buildAddConstraintSQL(dialect, constraint, tableName) {
+    const escapeIdent = (name) => dialect === 'mysql' || dialect === 'mariadb' ? `\`${name}\`` : `"${name}"`;
+    const constraintSql = buildConstraintSQL(dialect, constraint, tableName);
+    return `ALTER TABLE ${escapeIdent(tableName)} ADD ${constraintSql}`;
+}
+/**
+ * Build DROP CONSTRAINT SQL
+ */
+function buildDropConstraintSQL(dialect, constraintName, tableName) {
+    const escapeIdent = (name) => dialect === 'mysql' || dialect === 'mariadb' ? `\`${name}\`` : `"${name}"`;
+    return `ALTER TABLE ${escapeIdent(tableName)} DROP CONSTRAINT ${escapeIdent(constraintName)}`;
+}
+exports.default = {
+    Index,
+    IndexCollection,
+    Constraint,
+    ConstraintCollection,
+    generateIndexName,
+    generateConstraintName,
+    normalizeFields,
+    buildIndexSQL,
+    buildDropIndexSQL,
+    buildConstraintSQL,
+    buildAddConstraintSQL,
+    buildDropConstraintSQL,
+};