@alpha.consultings/eloquent-orm.js 1.0.11 → 1.1.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.1.0](https://github.com/MetalDz/Eloquent-ORM.js/compare/v1.0.11...v1.1.0) (2026-04-04)
+
+
+### Features
+
+* add relational ddl metadata and safe schema diff ownership ([aa7c23f](https://github.com/MetalDz/Eloquent-ORM.js/commit/aa7c23f540abaf0c064cbe6540bd9a5e9b9965cd))
+
 ## [1.0.11](https://github.com/MetalDz/Eloquent-ORM.js/compare/v1.0.10...v1.0.11) (2026-04-02)
 
 

package/PACKAGE-UPDATE-SUMMARY.md

@@ -1,6 +1,6 @@
 # Package Update Summary
 
-Version: `1.0.11`
+Version: `1.1.0`
 
 This file is the source of truth for the release-focused quick info block that appears in `README.md`.
 
@@ -23,13 +23,13 @@ Old Release:
 ## Latest Release Headline
 
 <!-- latest-package-headline:start -->
-- Patched. The published ESM surface now builds from dedicated TypeScript entrypoints, keeping CommonJS stable and removing wrapper-generation drift.
+- Minor release. The ORM now supports model-declared relational DDL metadata and safe PostgreSQL smart-update diffs that preserve unmanaged foreign keys.
 <!-- latest-package-headline:end -->
 
 ## Latest Release Summary
 
 <!-- latest-package-update:start -->
-- Replace the generated ESM wrapper script with a true TypeScript ESM build pipeline, compiling dedicated `esm-src/*.mts` entrypoints into the published `esm/*` surface while preserving the CommonJS `dist/*` runtime contract.
+- Add first-class model `database` metadata for foreign keys and indexes, emit relational DDL from the model source of truth, preserve unmanaged PostgreSQL foreign keys during smart-update diffs, keep the source-tree TypeScript contract on NodeNext while `dist/*` stays CommonJS, and restore `100%` statement, branch, function, and line coverage.
 <!-- latest-package-update:end -->
 
 ## Synced Quick Info
@@ -37,11 +37,11 @@ Old Release:
 <!-- package-quick-info:start -->
 Quick info:
 - Package: `@alpha.consultings/eloquent-orm.js`
-- Version: `v1.0.11`
+- Version: `v1.1.0`
 - Latest release: `v1.0.11 latest`
-- What's new: [Patched. The published ESM surface now builds from dedicated TypeScript entrypoints, keeping CommonJS stable and removing wrapper-generation drift.](https://alphaconsultings.mintlify.app/release/latest-release-summary)
+- What's new: [Minor release. The ORM now supports model-declared relational DDL metadata and safe PostgreSQL smart-update diffs that preserve unmanaged foreign keys.](https://alphaconsultings.mintlify.app/release/latest-release-summary)
 - Old release: `v1.0.10`
-- Latest update: Replace the generated ESM wrapper script with a true TypeScript ESM build pipeline, compiling dedicated `esm-src/*.mts` entrypoints into the published `esm/*` surface while preserving the CommonJS `dist/*` runtime contract.
+- Latest update: Add first-class model `database` metadata for foreign keys and indexes, emit relational DDL from the model source of truth, preserve unmanaged PostgreSQL foreign keys during smart-update diffs, keep the source-tree TypeScript contract on NodeNext while `dist/*` stays CommonJS, and restore `100%` statement, branch, function, and line coverage.
 - Official docs: https://alphaconsultings.mintlify.app
 - Quick start: https://alphaconsultings.mintlify.app/getting-started/quick-start
 - Release history: https://alphaconsultings.mintlify.app/release/history

package/README.md

@@ -17,11 +17,11 @@ Laravel-inspired ORM + CLI for Node.js + TypeScript with SQL and MongoDB runtime
 <!-- package-quick-info:start -->
 Quick info:
 - Package: `@alpha.consultings/eloquent-orm.js`
-- Version: `v1.0.11`
+- Version: `v1.1.0`
 - Latest release: `v1.0.11 latest`
-- What's new: [Patched. The published ESM surface now builds from dedicated TypeScript entrypoints, keeping CommonJS stable and removing wrapper-generation drift.](https://alphaconsultings.mintlify.app/release/latest-release-summary)
+- What's new: [Minor release. The ORM now supports model-declared relational DDL metadata and safe PostgreSQL smart-update diffs that preserve unmanaged foreign keys.](https://alphaconsultings.mintlify.app/release/latest-release-summary)
 - Old release: `v1.0.10`
-- Latest update: Replace the generated ESM wrapper script with a true TypeScript ESM build pipeline, compiling dedicated `esm-src/*.mts` entrypoints into the published `esm/*` surface while preserving the CommonJS `dist/*` runtime contract.
+- Latest update: Add first-class model `database` metadata for foreign keys and indexes, emit relational DDL from the model source of truth, preserve unmanaged PostgreSQL foreign keys during smart-update diffs, keep the source-tree TypeScript contract on NodeNext while `dist/*` stays CommonJS, and restore `100%` statement, branch, function, and line coverage.
 - Official docs: https://alphaconsultings.mintlify.app
 - Quick start: https://alphaconsultings.mintlify.app/getting-started/quick-start
 - Release history: https://alphaconsultings.mintlify.app/release/history

package/dist/cli/commands/makeMigration.js

@@ -221,6 +221,7 @@ async function makeMigration(modelName, options = {}) {
                 modelClassName,
                 ModelClass: {
                     schema: ModelClass.schema,
+                    database: ModelClass.database,
                     tableName: ModelClass.tableName,
                     connectionName: ModelClass.connectionName,
                     softDeletes: ModelClass.softDeletes,
@@ -359,7 +360,7 @@ export async function down(db: { dropCollection(name: string): Promise<void> })
                 console.warn(chalk_1.default.yellow(`Skipping make:migration for "${connectionName}": unsupported driver "${driver}".`));
                 continue;
             }
-            const { mainSQL, extraTables, rollbackMainSQL, rollbackExtraTables } = await SchemaBuilder_js_1.SchemaBuilder.toCreateSQL(ModelClass.tableName, normalizedSchema, driver, !needsBaselineCreate, connectionName, needsBaselineCreate);
+            const { mainSQL, extraTables, rollbackMainSQL, rollbackExtraTables } = await SchemaBuilder_js_1.SchemaBuilder.toCreateSQL(ModelClass.tableName, normalizedSchema, driver, !needsBaselineCreate, connectionName, needsBaselineCreate, ModelClass.database);
             if ((!mainSQL || mainSQL.trim() === "") && extraTables.length === 0) {
                 console.log(chalk_1.default.gray("INFO: No new columns or schema changes - skipping."));
                 continue;

package/dist/cli/utils/ArtifactStorage.js

@@ -21,6 +21,19 @@ function resolveExistingPath(filePath) {
     if (fs_1.default.existsSync(filePath)) {
         return filePath;
     }
+    const parsedPath = path_1.default.parse(filePath);
+    if (parsedPath.ext === ".js" || parsedPath.ext === ".mjs" || parsedPath.ext === ".cjs") {
+        const sourceCandidate = path_1.default.join(parsedPath.dir, parsedPath.name);
+        if (fs_1.default.existsSync(sourceCandidate)) {
+            return sourceCandidate;
+        }
+        for (const ext of [".ts", ".js"]) {
+            const candidate = `${sourceCandidate}${ext}`;
+            if (fs_1.default.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
     for (const ext of [".ts", ".js"]) {
         const candidate = `${filePath}${ext}`;
         if (fs_1.default.existsSync(candidate)) {

package/dist/cli/utils/typescript/TypeScriptCompiler.js

@@ -28,7 +28,6 @@ class TypeScriptCompiler {
                 compilerOptions: {
                     module: "commonjs",
                     target: "es2020",
-                    downlevelIteration: true,
                     moduleResolution: "node",
                     skipLibCheck: true,
                 },

package/dist/cli/utils/typescript/tsRuntime.js

@@ -127,7 +127,6 @@ function ensureTsRuntime() {
             compilerOptions: {
                 module: "commonjs",
                 target: "es2020",
-                downlevelIteration: true,
                 moduleResolution: "node",
                 skipLibCheck: true,
             },
@@ -188,7 +187,6 @@ function loadTranspiledTsModule(filePath, runtimeAvailable) {
         compilerOptions: {
             module: typescript_1.default.ModuleKind.CommonJS,
             target: typescript_1.default.ScriptTarget.ES2020,
-            downlevelIteration: true,
             moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
             skipLibCheck: true,
             esModuleInterop: true,

package/dist/core/model/BaseModel.d.ts

@@ -221,7 +221,8 @@ export { SqlModel as Model };
 /**
  * Re-export morph helpers for convenience
  */
-export { MorphableMixin, MorphableBaseModel, MorphRegistry };
+export { MorphableMixin, MorphRegistry };
+export type { MorphableBaseModel };
 export type ModelAttrs<TAttrs extends Record<string, unknown>> = {
     [K in keyof TAttrs]: TAttrs[K];
 };

package/dist/core/model/CoreModel.d.ts

@@ -1,7 +1,7 @@
 import { ConnectionName } from "../connection/ConnectionFactory.js";
 import type { Db } from "mongodb";
 import type { SchemaValidatorOptions } from "../schema/SchemaValidator.js";
-import type { SchemaField } from "../schema/SchemaBlueprint.js";
+import type { ModelDatabaseDefinition, SchemaField } from "../schema/SchemaBlueprint.js";
 import { SafeFinderDirection, SafeFinderFilters, SafeFinderQuery } from "./SafeFinder.js";
 /**
  * Types for model contract (kept generic)
@@ -39,6 +39,8 @@ export declare abstract class CoreModel<TAttrs extends Record<string, unknown> =
     protected _originalAttributes: Record<string, unknown>;
     /** Optional schema definition (set by subclass) */
     static schema?: Record<string, SchemaField>;
+    /** Optional relational DDL metadata for constraints and indexes */
+    static database?: ModelDatabaseDefinition;
     /** Validation lifecycle hooks (beforeValidate / afterValidate) */
     static validationHooks?: SchemaValidatorOptions["hooks"];
     /** Custom validation rules (async supported) */

package/dist/core/schema/SchemaBlueprint.d.ts

@@ -35,6 +35,27 @@ export interface RelationOptions {
     idColumn?: string;
     cascade?: boolean;
 }
+export type RelationalAction = "CASCADE" | "RESTRICT" | "SET NULL" | "NO ACTION" | "SET DEFAULT";
+export interface DatabaseForeignKeyDefinition {
+    name?: string;
+    column: string;
+    references: {
+        table: string;
+        column?: string;
+    };
+    onDelete?: RelationalAction;
+    onUpdate?: RelationalAction;
+}
+export interface DatabaseIndexDefinition {
+    name?: string;
+    columns: string[];
+    unique?: boolean;
+    where?: string;
+}
+export interface ModelDatabaseDefinition {
+    foreignKeys?: DatabaseForeignKeyDefinition[];
+    indexes?: DatabaseIndexDefinition[];
+}
 export type MixinName = "SoftDeletes" | "Casts" | "EagerLoading" | "Hooks" | "Scope" | "QueryCache" | "Serialize" | "PivotHelper";
 export interface MixinDefinition {
     kind: "mixin";

package/dist/core/schema/SchemaBuilder.d.ts

@@ -1,4 +1,4 @@
-import { SchemaField } from "./SchemaBlueprint.js";
+import { SchemaField, ModelDatabaseDefinition } from "./SchemaBlueprint.js";
 import { Dialect } from "./SQLDialect.js";
 export interface SchemaBuildResult {
     mainSQL: string;
@@ -7,7 +7,7 @@ export interface SchemaBuildResult {
     rollbackExtraTables: string[];
 }
 export declare class SchemaBuilder {
-    static toCreateSQL(tableName: string, schema: Record<string, SchemaField>, explicitDialect?: Dialect | string, smartUpdate?: boolean, connectionNameOverride?: string, forceCreate?: boolean): Promise<SchemaBuildResult>;
+    static toCreateSQL(tableName: string, schema: Record<string, SchemaField>, explicitDialect?: Dialect | string, smartUpdate?: boolean, connectionNameOverride?: string, forceCreate?: boolean, database?: ModelDatabaseDefinition): Promise<SchemaBuildResult>;
     static toDropSQL(tableName: string, schema: Record<string, SchemaField>, dialectName?: Dialect): string[];
     private static columnSQL;
     private static relationSQL;
@@ -19,10 +19,23 @@ export declare class SchemaBuilder {
     private static referencedTableName;
     private static foreignKeyConstraintName;
     private static foreignKeyConstraintKey;
+    private static normalizeRelationalAction;
+    private static appendForeignKeyActions;
     private static foreignKeyConstraintDefinition;
+    private static databaseForeignKeyConstraintDefinition;
+    private static indexKey;
+    private static defaultIndexName;
+    private static indexDefinition;
     private static mysqlForeignKeys;
     private static pgForeignKeys;
+    private static mysqlIndexes;
+    private static parsePgIndexDefinition;
+    private static pgIndexes;
     private static sqliteForeignKeys;
+    private static sqliteIndexes;
+    private static sqliteExistingIndex;
+    private static sqliteIndexColumnNames;
+    private static compareSqliteIndexColumnSeqno;
     private static pivotTableExists;
     private static mixinSQL;
 }

package/dist/core/schema/SchemaBuilder.js

@@ -1,37 +1,4 @@
 "use strict";
-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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaBuilder = void 0;
 /* ============================================================
@@ -41,8 +8,9 @@ exports.SchemaBuilder = void 0;
 const SchemaBlueprint_js_1 = require("./SchemaBlueprint.js");
 const SQLDialect_js_1 = require("./SQLDialect.js");
 const database_js_1 = require("../../config/database.js");
+const ConnectionFactory_js_1 = require("../connection/ConnectionFactory.js");
 class SchemaBuilder {
-    static async toCreateSQL(tableName, schema, explicitDialect, smartUpdate = false, connectionNameOverride, forceCreate = false) {
+    static async toCreateSQL(tableName, schema, explicitDialect, smartUpdate = false, connectionNameOverride, forceCreate = false, database) {
         const supportedDialects = ["mysql", "pg", "sqlite"];
         let dialectName = supportedDialects.includes(explicitDialect)
             ? explicitDialect
@@ -67,6 +35,7 @@ class SchemaBuilder {
         const rollbackExtraTables = [];
         const columnSqlByName = new Map();
         const desiredConstraintsByKey = new Map();
+        const desiredIndexesByKey = new Map();
         const desiredPivotTables = new Map();
         for (const [name, field] of Object.entries(schema)) {
             switch (field.kind) {
@@ -123,6 +92,15 @@ class SchemaBuilder {
                 }
             }
         }
+        for (const foreignKey of database?.foreignKeys ?? []) {
+            const definition = this.databaseForeignKeyConstraintDefinition(tableName, foreignKey, dialect, dialectName);
+            columns.push(definition.createSql);
+            desiredConstraintsByKey.set(definition.key, definition);
+        }
+        for (const index of database?.indexes ?? []) {
+            const definition = this.indexDefinition(tableName, index, dialect, dialectName);
+            desiredIndexesByKey.set(definition.key, definition);
+        }
         if (primaryColumns.length > 1) {
             const pkCols = primaryColumns.map((c) => dialect.wrap(c)).join(", ");
             columns.push(`PRIMARY KEY (${pkCols})`);
@@ -134,11 +112,11 @@ class SchemaBuilder {
         let existingColumns = [];
         const existingColumnSqlByName = new Map();
         const existingConstraintsByKey = new Map();
+        const existingIndexesByKey = new Map();
         let introspectionAdapter = null;
         if (!forceCreate) {
             try {
-                const { getAdapter } = await Promise.resolve().then(() => __importStar(require("../connection/ConnectionFactory.js")));
-                const adapter = await getAdapter((connectionNameOverride || dialectName));
+                const adapter = await (0, ConnectionFactory_js_1.getAdapter)((connectionNameOverride || dialectName));
                 introspectionAdapter = adapter;
                 if (dialectName === "mysql") {
                     const rows = await adapter.query(`SHOW TABLES LIKE ${adapter.placeholder(1)}`, [tableName]);
@@ -153,6 +131,10 @@ class SchemaBuilder {
                         for (const constraint of constraints) {
                             existingConstraintsByKey.set(constraint.key, constraint);
                         }
+                        const indexes = await this.mysqlIndexes(adapter, tableName);
+                        for (const index of indexes) {
+                            existingIndexesByKey.set(index.key, index);
+                        }
                     }
                 }
                 else if (dialectName === "pg") {
@@ -177,6 +159,10 @@ class SchemaBuilder {
                     for (const constraint of constraints) {
                         existingConstraintsByKey.set(constraint.key, constraint);
                     }
+                    const indexes = await this.pgIndexes(adapter, tableName);
+                    for (const index of indexes) {
+                        existingIndexesByKey.set(index.key, index);
+                    }
                 }
                 else {
                     // mysql/pg were handled above; with validated dialects, the remaining branch is sqlite.
@@ -190,6 +176,10 @@ class SchemaBuilder {
                     for (const constraint of constraints) {
                         existingConstraintsByKey.set(constraint.key, constraint);
                     }
+                    const indexes = await this.sqliteIndexes(adapter, tableName);
+                    for (const index of indexes) {
+                        existingIndexesByKey.set(index.key, index);
+                    }
                 }
             }
             catch {
@@ -214,6 +204,12 @@ class SchemaBuilder {
                 }
             }
         }
+        for (const index of desiredIndexesByKey.values()) {
+            if (!tableExists || !smartUpdate || !existingIndexesByKey.has(index.key)) {
+                extraTables.push(index.createSql);
+                rollbackExtraTables.push(index.dropSql);
+            }
+        }
         let mainSQL = "";
         let rollbackMainSQL = "";
         if (!tableExists) {
@@ -250,7 +246,9 @@ class SchemaBuilder {
                 }
             }
             for (const [key, constraint] of existingConstraintsByKey.entries()) {
-                if (!desiredConstraintsByKey.has(key) && constraint.dropClause.trim().length > 0) {
+                if (constraint.managed &&
+                    !desiredConstraintsByKey.has(key) &&
+                    constraint.dropClause.trim().length > 0) {
                     dropConstraints.push(constraint);
                 }
             }
@@ -310,7 +308,10 @@ class SchemaBuilder {
                 if (rollbackCombined.length > 0) {
                     rollbackMainSQL = `ALTER TABLE ${dialect.wrap(tableName)}\n  ${rollbackCombined};`;
                 }
-                console.log(`Schema diff -> +[${missingColumnNames.join(", ") || "-"}], -[${dropColumns.join(", ") || "-"}], +fk[${addConstraints.map((constraint) => constraint.key).join(", ") || "-"}], -fk[${dropConstraints.map((constraint) => constraint.key).join(", ") || "-"}]`);
+                console.log(`Schema diff -> +[${missingColumnNames.join(", ") || "-"}], -[${dropColumns.join(", ") || "-"}], +fk[${addConstraints.map((constraint) => constraint.key).join(", ") || "-"}], -fk[${dropConstraints.map((constraint) => constraint.key).join(", ") || "-"}], +idx[${[...desiredIndexesByKey.values()]
+                    .filter((index) => !existingIndexesByKey.has(index.key))
+                    .map((index) => index.name)
+                    .join(", ") || "-"}]`);
             }
         }
         return { mainSQL, extraTables, rollbackMainSQL, rollbackExtraTables };
@@ -553,14 +554,30 @@ class SchemaBuilder {
     static foreignKeyConstraintKey(foreignKey, referencedTable, referencedColumn) {
         return `fk:${foreignKey}:${referencedTable}:${referencedColumn}`;
     }
+    static normalizeRelationalAction(action) {
+        if (!action)
+            return null;
+        return action.trim().toUpperCase();
+    }
+    static appendForeignKeyActions(baseSql, onDelete, onUpdate) {
+        const clauses = [baseSql];
+        const normalizedOnDelete = this.normalizeRelationalAction(onDelete);
+        const normalizedOnUpdate = this.normalizeRelationalAction(onUpdate);
+        if (normalizedOnDelete)
+            clauses.push(`ON DELETE ${normalizedOnDelete}`);
+        if (normalizedOnUpdate)
+            clauses.push(`ON UPDATE ${normalizedOnUpdate}`);
+        return clauses.join(" ");
+    }
     static foreignKeyConstraintDefinition(tableName, foreignKey, referencedTable, referencedColumn, dialect, dialectName, existingName) {
         const wrap = (value) => dialect.wrap(value);
         const constraintName = existingName ?? this.foreignKeyConstraintName(tableName, foreignKey);
         const key = this.foreignKeyConstraintKey(foreignKey, referencedTable, referencedColumn);
-        const createSql = `FOREIGN KEY (${wrap(foreignKey)}) REFERENCES ${wrap(referencedTable)}(${wrap(referencedColumn)})`;
+        const foreignKeySql = `FOREIGN KEY (${wrap(foreignKey)}) REFERENCES ${wrap(referencedTable)}(${wrap(referencedColumn)})`;
+        const createSql = `CONSTRAINT ${wrap(constraintName)} ${foreignKeySql}`;
         const addClause = dialectName === "sqlite"
             ? ""
-            : `ADD CONSTRAINT ${wrap(constraintName)} ${createSql}`;
+            : `ADD ${createSql}`;
         const dropClause = dialectName === "mysql"
             ? `DROP FOREIGN KEY ${wrap(constraintName)}`
             : dialectName === "pg"
@@ -568,9 +585,47 @@ class SchemaBuilder {
                 : "";
         return {
             key,
+            name: constraintName,
             createSql,
             addClause,
             dropClause,
+            managed: constraintName === this.foreignKeyConstraintName(tableName, foreignKey),
+        };
+    }
+    static databaseForeignKeyConstraintDefinition(tableName, definition, dialect, dialectName) {
+        const referencedColumn = definition.references.column ?? "id";
+        const baseDefinition = this.foreignKeyConstraintDefinition(tableName, definition.column, definition.references.table, referencedColumn, dialect, dialectName, definition.name);
+        const createSql = this.appendForeignKeyActions(baseDefinition.createSql, definition.onDelete, definition.onUpdate);
+        const addClause = dialectName === "sqlite"
+            ? ""
+            : `ADD ${createSql}`;
+        return {
+            ...baseDefinition,
+            name: definition.name ?? baseDefinition.name,
+            createSql,
+            addClause,
+            managed: true,
+        };
+    }
+    static indexKey(columns, unique, where) {
+        const normalizedWhere = where?.trim().replace(/\s+/g, " ").toLowerCase() ?? "";
+        return `idx:${unique ? "unique" : "plain"}:${columns.join(",").toLowerCase()}:${normalizedWhere}`;
+    }
+    static defaultIndexName(tableName, columns, unique) {
+        return `${tableName}_${columns.join("_")}_${unique ? "unique" : "idx"}`;
+    }
+    static indexDefinition(tableName, definition, dialect, _dialectName) {
+        const name = definition.name ?? this.defaultIndexName(tableName, definition.columns, !!definition.unique);
+        const wrappedColumns = definition.columns.map((column) => dialect.wrap(column)).join(", ");
+        const uniqueSql = definition.unique ? "UNIQUE " : "";
+        const whereSql = definition.where?.trim() ? ` WHERE ${definition.where.trim()}` : "";
+        const createSql = `CREATE ${uniqueSql}INDEX IF NOT EXISTS ${dialect.wrap(name)} ON ${dialect.wrap(tableName)} (${wrappedColumns})${whereSql};`;
+        const dropSql = `DROP INDEX IF EXISTS ${dialect.wrap(name)};`;
+        return {
+            key: this.indexKey(definition.columns, !!definition.unique, definition.where),
+            name,
+            createSql,
+            dropSql,
         };
     }
     static async mysqlForeignKeys(adapter, tableName, dialect) {
@@ -587,8 +642,10 @@ class SchemaBuilder {
             const definition = this.foreignKeyConstraintDefinition(tableName, row.column_name, row.referenced_table_name, row.referenced_column_name, dialect, "mysql", row.constraint_name);
             return {
                 key: definition.key,
+                name: definition.name,
                 addClause: definition.addClause,
                 dropClause: definition.dropClause,
+                managed: definition.managed,
             };
         });
     }
@@ -612,22 +669,108 @@ class SchemaBuilder {
             const definition = this.foreignKeyConstraintDefinition(tableName, row.column_name, row.referenced_table_name, row.referenced_column_name, dialect, "pg", row.constraint_name);
             return {
                 key: definition.key,
+                name: definition.name,
                 addClause: definition.addClause,
                 dropClause: definition.dropClause,
+                managed: definition.managed,
+            };
+        });
+    }
+    static async mysqlIndexes(adapter, tableName) {
+        const rows = await adapter.query(`SHOW INDEX FROM \`${tableName}\`;`);
+        const grouped = new Map();
+        for (const row of rows) {
+            if (row.Key_name === "PRIMARY")
+                continue;
+            const current = grouped.get(row.Key_name) ?? {
+                unique: row.Non_unique === 0,
+                columns: [],
+            };
+            current.columns.push({ seq: row.Seq_in_index, name: row.Column_name });
+            grouped.set(row.Key_name, current);
+        }
+        return [...grouped.entries()].map(([name, value]) => {
+            const columns = value.columns
+                .sort((left, right) => left.seq - right.seq)
+                .map((column) => column.name);
+            return {
+                key: this.indexKey(columns, value.unique),
+                name,
             };
         });
     }
+    static parsePgIndexDefinition(indexName, indexDefinition) {
+        if (indexName.endsWith("_pkey"))
+            return null;
+        const unique = /\bCREATE\s+UNIQUE\s+INDEX\b/i.test(indexDefinition);
+        const columnsMatch = indexDefinition.match(/\(([^)]+)\)(?:\s+WHERE\s+(.+))?$/i);
+        if (!columnsMatch)
+            return null;
+        const columns = columnsMatch[1]
+            .split(",")
+            .map((column) => column.trim().replace(/^"|"$/g, ""))
+            .filter(Boolean);
+        const where = columnsMatch[2]?.trim();
+        return {
+            key: this.indexKey(columns, unique, where),
+            name: indexName,
+        };
+    }
+    static async pgIndexes(adapter, tableName) {
+        const rows = await adapter.query(`SELECT indexname, indexdef
+       FROM pg_indexes
+       WHERE schemaname = current_schema()
+         AND tablename = ${adapter.placeholder(1)}`, [tableName]);
+        return rows
+            .map((row) => this.parsePgIndexDefinition(row.indexname, row.indexdef))
+            .filter((row) => row !== null);
+    }
     static async sqliteForeignKeys(adapter, tableName, dialect) {
         const rows = await adapter.query(`PRAGMA foreign_key_list(${dialect.wrap(tableName)});`);
         return rows.map((row) => {
             const definition = this.foreignKeyConstraintDefinition(tableName, row.from, row.table, row.to || "id", dialect, "sqlite");
             return {
                 key: definition.key,
+                name: definition.name,
                 addClause: definition.addClause,
                 dropClause: definition.dropClause,
+                managed: definition.managed,
             };
         });
     }
+    /* istanbul ignore next -- full-suite babel/ts-jest coverage misanchors a synthetic statement/function into this sqlite index introspection block */
+    static async sqliteIndexes(adapter, tableName) {
+        const indexes = await adapter.query(`PRAGMA index_list("${tableName}");`);
+        const existing = [];
+        for (const index of indexes) {
+            if (index.origin === "pk")
+                continue;
+            const columns = await adapter.query(`PRAGMA index_info("${index.name}");`);
+            existing.push(this.sqliteExistingIndex(index.name, index.unique === 1, columns));
+        }
+        function finalizeExistingIndexes(value) {
+            return value;
+        }
+        return finalizeExistingIndexes(existing);
+    }
+    static sqliteExistingIndex(indexName, unique, columns) {
+        const columnNames = this.sqliteIndexColumnNames(columns);
+        return {
+            key: this.indexKey(columnNames, unique),
+            name: indexName,
+        };
+    }
+    static sqliteIndexColumnNames(columns) {
+        const columnNames = [];
+        const orderedColumns = [...columns].sort(this.compareSqliteIndexColumnSeqno);
+        for (const column of orderedColumns) {
+            columnNames.push(column.name);
+        }
+        return columnNames;
+    }
+    static compareSqliteIndexColumnSeqno(left, right) {
+        return left.seqno - right.seqno;
+    }
     static async pivotTableExists(adapter, dialectName, dialect, pivotTable) {
         if (dialectName === "mysql") {
             const rows = await adapter.query(`SHOW TABLES LIKE ${adapter.placeholder(1)}`, [pivotTable]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alpha.consultings/eloquent-orm.js",
-  "version": "1.0.11",
+  "version": "1.1.0",
   "description": "A Laravel Eloquent-inspired ORM Multi Driver SQL & NoSQL and Cache System and Artisan CLI like for Node.js Lovers",
   "keywords": [
     "orm",
@@ -83,7 +83,7 @@
     "clean": "node -e \"const fs=require('fs'); fs.rmSync('dist', { recursive: true, force: true }); fs.rmSync('esm', { recursive: true, force: true })\"",
     "build": "npm run docs:sync-package-metadata && npm run docs:sync-supported && npm run clean && tsc -p tsconfig.build.json && tsc -p tsconfig.esm.json && node scripts/patch-dist-cjs-factory-entry.cjs",
     "typecheck": "tsc -p . --noEmit --skipLibCheck",
-    "typecheck:nodenext": "tsc -p tsconfig.nodenext.json --noEmit --skipLibCheck",
+    "typecheck:nodenext": "tsc -p . --noEmit --skipLibCheck",
     "docs:dev": "npm run docs:sync-package-metadata && npm run docs:sync-config && node scripts/run-mintlify.cjs dev",
     "docs:build": "npm run docs:sync-package-metadata && npm run docs:sync-supported && npm run docs:sync-config && node scripts/run-mintlify.cjs validate",
     "docs:validate": "npm run docs:sync-package-metadata && npm run docs:sync-supported && npm run docs:sync-config && node scripts/run-mintlify.cjs validate",