ts-prorm-orm 1.1.0 → 1.2.1

package/dist/models/indexes.d.ts

@@ -0,0 +1,325 @@
+/**
+ * Index and Constraint classes for the TypeScript ORM
+ * Supports single column, composite, unique, and partial indexes
+ * Supports foreign key constraints with cascade options
+ */
+import { WhereOptions } from '../types';
+/**
+ * Index field definition
+ */
+export interface IndexField {
+    name: string;
+    length?: number;
+    order?: 'ASC' | 'DESC';
+    collate?: string;
+}
+/**
+ * Options for creating an index
+ */
+export interface IndexOptions {
+    name?: string;
+    unique?: boolean;
+    type?: string;
+    using?: string;
+    algorithm?: 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hstore' | 'rum' | 'zombodb' | 'spatial';
+    fields?: (string | IndexField)[];
+    where?: WhereOptions;
+    /** Include columns for covering index (PostgreSQL 11+, MySQL 8.0.17+) */
+    include?: string[];
+    /** Expression for expression-based indexes (e.g., LOWER(column)) */
+    expression?: string;
+    /** MySQL/MariaDB: FULLTEXT index */
+    fulltext?: boolean;
+    /** MySQL/MariaDB: SPATIAL index for geometry columns */
+    spatial?: boolean;
+    /** MySQL/MariaDB: parser for full-text index */
+    parser?: string;
+    /** PostgreSQL: text search configuration for GIN index */
+    textSearchConfig?: string;
+    /** PostGIS: GIST index options */
+    gistOptions?: {
+        /** Use geography instead of geometry */
+        geography?: boolean;
+        /** Geometry type constraint (e.g., 'POINT', 'POLYGON') */
+        geometryType?: string;
+        /** SRID constraint (e.g., 4326 for WGS84) */
+        srid?: number;
+    };
+}
+/**
+ * Constraint type
+ */
+export type ConstraintType = 'UNIQUE' | 'PRIMARY KEY' | 'FOREIGN KEY' | 'CHECK';
+/**
+ * Foreign key reference
+ */
+export interface ForeignKeyReference {
+    table: string;
+    field: string;
+}
+/**
+ * Constraint definition options
+ */
+export interface ConstraintOptions {
+    name?: string;
+    type: ConstraintType;
+    fields?: string[];
+    references?: ForeignKeyReference;
+    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | 'SET DEFAULT';
+    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    check?: string;
+    deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
+}
+/**
+ * Index class representing a database index
+ */
+export declare class Index {
+    readonly name: string;
+    readonly unique: boolean;
+    readonly type?: string;
+    readonly using?: string;
+    readonly algorithm?: 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin' | 'hstore' | 'rum' | 'zombodb' | 'spatial';
+    readonly fields: IndexField[];
+    readonly where?: WhereOptions;
+    readonly include?: string[];
+    readonly expression?: string;
+    readonly tableName?: string;
+    readonly fulltext?: boolean;
+    readonly spatial?: boolean;
+    readonly parser?: string;
+    readonly textSearchConfig?: string;
+    readonly gistOptions?: {
+        geography?: boolean;
+        geometryType?: string;
+        srid?: number;
+    };
+    constructor(options: IndexOptions & {
+        tableName?: string;
+    });
+    /**
+     * Normalize fields to IndexField array
+     */
+    private normalizeFields;
+    /**
+     * Get the field names as a simple string array
+     */
+    getFieldNames(): string[];
+    /**
+     * Check if this is a partial index
+     */
+    isPartial(): boolean;
+    /**
+     * Check if this is an expression index
+     */
+    isExpression(): boolean;
+    /**
+     * Check if this is a composite index
+     */
+    isComposite(): boolean;
+    /**
+     * Convert to plain object
+     */
+    toJSON(): IndexOptions & {
+        tableName?: string;
+    };
+    /**
+     * Check if this is a fulltext index
+     */
+    isFulltext(): boolean;
+    /**
+     * Check if this is a GIN index
+     */
+    isGIN(): boolean;
+}
+/**
+ * Constraint class representing a database constraint
+ */
+export declare class Constraint {
+    readonly name: string;
+    readonly type: ConstraintType;
+    readonly fields: string[];
+    readonly references?: ForeignKeyReference;
+    readonly onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION' | 'SET DEFAULT';
+    readonly onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    readonly check?: string;
+    readonly deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE';
+    readonly tableName?: string;
+    constructor(options: ConstraintOptions & {
+        tableName?: string;
+    });
+    /**
+     * Check if this is a foreign key constraint
+     */
+    isForeignKey(): boolean;
+    /**
+     * Check if this is a unique constraint
+     */
+    isUnique(): boolean;
+    /**
+     * Check if this is a primary key constraint
+     */
+    isPrimaryKey(): boolean;
+    /**
+     * Check if this is a check constraint
+     */
+    isCheck(): boolean;
+    /**
+     * Get the ON DELETE action
+     */
+    getOnDelete(): string | undefined;
+    /**
+     * Get the ON UPDATE action
+     */
+    getOnUpdate(): string | undefined;
+    /**
+     * Convert to plain object
+     */
+    toJSON(): ConstraintOptions & {
+        tableName?: string;
+    };
+}
+/**
+ * Generate a unique index name based on table and fields
+ */
+export declare function generateIndexName(tableName: string, fields: string[] | IndexField[]): string;
+/**
+ * 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
+ */
+export declare function generateConstraintName(tableName: string, type: ConstraintType, fields: string[], options?: {
+    /** Custom name override */
+    name?: string;
+    /** Referenced table for foreign keys */
+    referencedTable?: string;
+    /** Composite key flag */
+    composite?: boolean;
+}): string;
+/**
+ * Generate unique constraint name
+ */
+export declare function generateUniqueConstraintName(tableName: string, fields: string[], customName?: string): string;
+/**
+ * Generate foreign key constraint name
+ */
+export declare function generateForeignKeyConstraintName(tableName: string, fields: string[], referencedTable?: string, customName?: string): string;
+/**
+ * Generate primary key constraint name
+ */
+export declare function generatePrimaryKeyConstraintName(tableName: string, customName?: string): string;
+/**
+ * Normalize fields to IndexField array
+ */
+export declare function normalizeFields(fields: string[] | IndexField[]): IndexField[];
+/**
+ * Index collection for managing multiple indexes
+ */
+export declare class IndexCollection {
+    private indexes;
+    /**
+     * Add an index to the collection
+     */
+    addIndex(index: Index): void;
+    /**
+     * Get an index by name
+     */
+    getIndex(name: string): Index | undefined;
+    /**
+     * Get all indexes
+     */
+    getAllIndexes(): Index[];
+    /**
+     * Remove an index by name
+     */
+    removeIndex(name: string): boolean;
+    /**
+     * Check if an index exists
+     */
+    hasIndex(name: string): boolean;
+    /**
+     * Get the number of indexes
+     */
+    get size(): number;
+    /**
+     * Clear all indexes
+     */
+    clear(): void;
+}
+/**
+ * Constraint collection for managing multiple constraints
+ */
+export declare class ConstraintCollection {
+    private constraints;
+    /**
+     * Add a constraint to the collection
+     */
+    addConstraint(constraint: Constraint): void;
+    /**
+     * Get a constraint by name
+     */
+    getConstraint(name: string): Constraint | undefined;
+    /**
+     * Get all constraints
+     */
+    getAllConstraints(): Constraint[];
+    /**
+     * Remove a constraint by name
+     */
+    removeConstraint(name: string): boolean;
+    /**
+     * Check if a constraint exists
+     */
+    hasConstraint(name: string): boolean;
+    /**
+     * Get the number of constraints
+     */
+    get size(): number;
+    /**
+     * Clear all constraints
+     */
+    clear(): void;
+    /**
+     * Get all foreign key constraints
+     */
+    getForeignKeys(): Constraint[];
+    /**
+     * Get all unique constraints
+     */
+    getUniqueConstraints(): Constraint[];
+}
+/**
+ * Build index SQL for a specific dialect
+ */
+export declare function buildIndexSQL(dialect: 'postgres' | 'mysql' | 'sqlite' | 'mariadb', indexName: string, tableName: string, fields: string[] | IndexField[], options?: IndexOptions): string;
+/**
+ * Build DROP INDEX SQL
+ */
+export declare function buildDropIndexSQL(dialect: 'postgres' | 'mysql' | 'sqlite' | 'mariadb', indexName: string, tableName?: string): string;
+/**
+ * Build constraint SQL for a specific dialect
+ */
+export declare function buildConstraintSQL(dialect: 'postgres' | 'mysql' | 'sqlite' | 'mariadb', constraint: Constraint, tableName: string): string;
+/**
+ * Build ADD CONSTRAINT SQL
+ */
+export declare function buildAddConstraintSQL(dialect: 'postgres' | 'mysql' | 'sqlite' | 'mariadb', constraint: Constraint, tableName: string): string;
+/**
+ * Build DROP CONSTRAINT SQL
+ */
+export declare function buildDropConstraintSQL(dialect: 'postgres' | 'mysql' | 'sqlite' | 'mariadb', constraintName: string, tableName: string): string;
+declare const _default: {
+    Index: typeof Index;
+    IndexCollection: typeof IndexCollection;
+    Constraint: typeof Constraint;
+    ConstraintCollection: typeof ConstraintCollection;
+    generateIndexName: typeof generateIndexName;
+    generateConstraintName: typeof generateConstraintName;
+    normalizeFields: typeof normalizeFields;
+    buildIndexSQL: typeof buildIndexSQL;
+    buildDropIndexSQL: typeof buildDropIndexSQL;
+    buildConstraintSQL: typeof buildConstraintSQL;
+    buildAddConstraintSQL: typeof buildAddConstraintSQL;
+    buildDropConstraintSQL: typeof buildDropConstraintSQL;
+};
+export default _default;