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

package/dist/core/schema/SchemaBuilder.js

@@ -1,54 +1,22 @@
 "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;
 /* ============================================================
  * SchemaBuilder v4.0
  * Auto-detects CREATE / ALTER / DROP COLUMN schema differences
  * ============================================================ */
-const SchemaBlueprint_1 = require("./SchemaBlueprint");
-const SQLDialect_1 = require("./SQLDialect");
-const database_1 = require("../../config/database");
+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
-            : (database_1.dbConfig.default || "mysql");
+            : (database_js_1.dbConfig.default || "mysql");
         if (!supportedDialects.includes(dialectName)) {
-            const maybe = explicitDialect ? database_1.dbConfig.connections[explicitDialect] : undefined;
+            const maybe = explicitDialect ? database_js_1.dbConfig.connections[explicitDialect] : undefined;
             const driver = maybe?.driver;
             if (driver && supportedDialects.includes(driver)) {
                 dialectName = driver;
@@ -57,8 +25,8 @@ class SchemaBuilder {
         if (!supportedDialects.includes(dialectName)) {
             throw new Error(`ERROR: Unsupported dialect: ${explicitDialect}`);
         }
-        const dialect = new SQLDialect_1.SQLDialect(dialectName);
-        const errors = (0, SchemaBlueprint_1.validateSchema)(schema);
+        const dialect = new SQLDialect_js_1.SQLDialect(dialectName);
+        const errors = (0, SchemaBlueprint_js_1.validateSchema)(schema);
         if (errors.length > 0)
             throw new Error(`ERROR: Schema validation failed for ${tableName}:\n${errors.join("\n")}`);
         const columns = [];
@@ -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")));
-                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 };
@@ -321,7 +322,7 @@ class SchemaBuilder {
     static toDropSQL(tableName, schema, dialectName = "mysql") {
         const dropSQL = [];
         const pivotTables = [];
-        const dialect = new SQLDialect_1.SQLDialect(dialectName);
+        const dialect = new SQLDialect_js_1.SQLDialect(dialectName);
         for (const [, field] of Object.entries(schema)) {
             if (field.kind === "relation" && field.relation === "belongsToMany" && field.model) {
                 const modelA = tableName.toLowerCase();
@@ -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/dist/core/schema/SchemaValidator.d.ts

@@ -2,7 +2,7 @@
  * 🧠 SchemaValidator
  * Runtime validation engine for models with hooks and custom rules.
  */
-import type { ValidationRule } from "./SchemaBlueprint";
+import type { ValidationRule } from "./SchemaBlueprint.js";
 export interface ValidationError {
     field: string;
     message: string;

package/dist/core/security/AbstractSecurity.d.ts

@@ -1,4 +1,4 @@
-import { SecurityContract } from "./SecurityContract";
+import { SecurityContract } from "./SecurityContract.js";
 /**
  * 🧠 AbstractSecurity
  * Base class for all ORM security modules.

package/dist/core/security/EnvKeySecurity.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSecurity } from "./AbstractSecurity";
+import { AbstractSecurity } from "./AbstractSecurity.js";
 /**
  * 🔑 EnvKeySecurity
  * Requires a migration key from environment and user confirmation.

package/dist/core/security/EnvKeySecurity.js

@@ -7,12 +7,12 @@ exports.EnvKeySecurity = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const crypto_1 = __importDefault(require("crypto"));
 const readline_1 = __importDefault(require("readline"));
-const AbstractSecurity_1 = require("./AbstractSecurity");
+const AbstractSecurity_js_1 = require("./AbstractSecurity.js");
 /**
  * 🔑 EnvKeySecurity
  * Requires a migration key from environment and user confirmation.
  */
-class EnvKeySecurity extends AbstractSecurity_1.AbstractSecurity {
+class EnvKeySecurity extends AbstractSecurity_js_1.AbstractSecurity {
     async init() {
         this.hashKey = process.env.ELOQUENT_MIGRATION_KEY
             ? crypto_1.default.createHash("sha256").update(process.env.ELOQUENT_MIGRATION_KEY).digest("hex")

package/dist/core/security/NoSecurity.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSecurity } from "./AbstractSecurity";
+import { AbstractSecurity } from "./AbstractSecurity.js";
 /**
  * 🚧 NoSecurity
  * Used when no security checks are required (e.g., local dev or testing).

package/dist/core/security/NoSecurity.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoSecurity = void 0;
-const AbstractSecurity_1 = require("./AbstractSecurity");
+const AbstractSecurity_js_1 = require("./AbstractSecurity.js");
 /**
  * 🚧 NoSecurity
  * Used when no security checks are required (e.g., local dev or testing).
  */
-class NoSecurity extends AbstractSecurity_1.AbstractSecurity {
+class NoSecurity extends AbstractSecurity_js_1.AbstractSecurity {
     async confirmPrivilege() {
         return true; // Always allow
     }

package/dist/core/security/SecurityFactory.d.ts

@@ -1,4 +1,4 @@
-import { SecurityContract } from "./SecurityContract";
+import { SecurityContract } from "./SecurityContract.js";
 /**
  * 🧠 SecurityFactory
  * Chooses the appropriate security module dynamically.

package/dist/core/security/SecurityFactory.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecurityFactory = void 0;
-const EnvKeySecurity_1 = require("./EnvKeySecurity");
-const NoSecurity_1 = require("./NoSecurity");
+const EnvKeySecurity_js_1 = require("./EnvKeySecurity.js");
+const NoSecurity_js_1 = require("./NoSecurity.js");
 const chalk_1 = __importDefault(require("chalk"));
 /**
  * 🧠 SecurityFactory
@@ -17,11 +17,11 @@ class SecurityFactory {
         switch (mode.toLowerCase()) {
             case "envkey":
                 console.log(chalk_1.default.gray("🔐 Security mode: EnvKey"));
-                return new EnvKeySecurity_1.EnvKeySecurity();
+                return new EnvKeySecurity_js_1.EnvKeySecurity();
             case "none":
             default:
                 console.log(chalk_1.default.gray("🔓 Security mode: Disabled (NoSecurity)"));
-                return new NoSecurity_1.NoSecurity();
+                return new NoSecurity_js_1.NoSecurity();
         }
     }
 }

package/dist/core/security/index.d.ts

@@ -1,5 +1,5 @@
-export * from "./SecurityContract";
-export * from "./AbstractSecurity";
-export * from "./NoSecurity";
-export * from "./EnvKeySecurity";
-export * from "./SecurityFactory";
+export * from "./SecurityContract.js";
+export * from "./AbstractSecurity.js";
+export * from "./NoSecurity.js";
+export * from "./EnvKeySecurity.js";
+export * from "./SecurityFactory.js";

package/dist/core/security/index.js

@@ -14,8 +14,8 @@ 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 });
-__exportStar(require("./SecurityContract"), exports);
-__exportStar(require("./AbstractSecurity"), exports);
-__exportStar(require("./NoSecurity"), exports);
-__exportStar(require("./EnvKeySecurity"), exports);
-__exportStar(require("./SecurityFactory"), exports);
+__exportStar(require("./SecurityContract.js"), exports);
+__exportStar(require("./AbstractSecurity.js"), exports);
+__exportStar(require("./NoSecurity.js"), exports);
+__exportStar(require("./EnvKeySecurity.js"), exports);
+__exportStar(require("./SecurityFactory.js"), exports);

package/dist/index.d.ts

@@ -3,13 +3,13 @@
  * Only exports from this file are semver-tracked and supported for consumers.
  * Deep imports into internal `dist/core/*`, `dist/cli/*`, or `src/*` paths are private.
  */
-export { BaseModel, Model, SqlModel, MongoModel, MorphRegistry, type ORMRecord, type ModelAttrs, type ModelInstance, type TypedRelation, type PivotRelation, } from "./core/model/BaseModel";
-export { PivotHelperMixin } from "./core/orm/mixins/PivotHelperMixin";
-export { Factory, type PlainObject, type ModelCtor, type FactoryCtor, } from "./cli/utils/factories/Factory";
-export { CoreModel, type ModelEventHooks, } from "./core/model/CoreModel";
-export { column, validate, relation, mixin, validateSchema, type ColumnType, type ColumnOptions, type ValidationRule, type RelationType, type RelationOptions, type MixinName, type MixinDefinition, type ColumnDefinition, type RelationDefinition, type SchemaField, } from "./core/schema/SchemaBlueprint";
-export { SchemaValidator, type ValidationError, type SchemaValidatorOptions, type ValidationHooks, type CustomRuleFunction, type CustomRuleResult, } from "./core/schema/SchemaValidator";
-export { SchemaBuilder, type SchemaBuildResult } from "./core/schema/SchemaBuilder";
-export { CacheManager } from "./core/cache/CacheManager";
-export { setupCache } from "./core/cache/setupCache";
-export { registerModels, isModelRegistered, setModelRegistryStrictMode, isModelRegistryStrictMode, type RegisterModelsOptions, } from "./core/orm/mixins/utils/modelRegistration";
+export { BaseModel, Model, SqlModel, MongoModel, MorphRegistry, type ORMRecord, type ModelAttrs, type ModelInstance, type TypedRelation, type PivotRelation, } from "./core/model/BaseModel.js";
+export { PivotHelperMixin } from "./core/orm/mixins/PivotHelperMixin.js";
+export { Factory, type PlainObject, type ModelCtor, type FactoryCtor, } from "./cli/utils/factories/Factory.js";
+export { CoreModel, type ModelEventHooks, } from "./core/model/CoreModel.js";
+export { column, validate, relation, mixin, validateSchema, type ColumnType, type ColumnOptions, type ValidationRule, type RelationType, type RelationOptions, type MixinName, type MixinDefinition, type ColumnDefinition, type RelationDefinition, type SchemaField, } from "./core/schema/SchemaBlueprint.js";
+export { SchemaValidator, type ValidationError, type SchemaValidatorOptions, type ValidationHooks, type CustomRuleFunction, type CustomRuleResult, } from "./core/schema/SchemaValidator.js";
+export { SchemaBuilder, type SchemaBuildResult } from "./core/schema/SchemaBuilder.js";
+export { CacheManager } from "./core/cache/CacheManager.js";
+export { setupCache } from "./core/cache/setupCache.js";
+export { registerModels, isModelRegistered, setModelRegistryStrictMode, isModelRegistryStrictMode, type RegisterModelsOptions, } from "./core/orm/mixins/utils/modelRegistration.js";

package/dist/index.js

@@ -6,33 +6,33 @@ exports.isModelRegistryStrictMode = exports.setModelRegistryStrictMode = exports
  * Only exports from this file are semver-tracked and supported for consumers.
  * Deep imports into internal `dist/core/*`, `dist/cli/*`, or `src/*` paths are private.
  */
-var BaseModel_1 = require("./core/model/BaseModel");
-Object.defineProperty(exports, "BaseModel", { enumerable: true, get: function () { return BaseModel_1.BaseModel; } });
-Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return BaseModel_1.Model; } });
-Object.defineProperty(exports, "SqlModel", { enumerable: true, get: function () { return BaseModel_1.SqlModel; } });
-Object.defineProperty(exports, "MongoModel", { enumerable: true, get: function () { return BaseModel_1.MongoModel; } });
-Object.defineProperty(exports, "MorphRegistry", { enumerable: true, get: function () { return BaseModel_1.MorphRegistry; } });
-var PivotHelperMixin_1 = require("./core/orm/mixins/PivotHelperMixin");
-Object.defineProperty(exports, "PivotHelperMixin", { enumerable: true, get: function () { return PivotHelperMixin_1.PivotHelperMixin; } });
-Object.defineProperty(exports, "Factory", { enumerable: true, get: function () { return require("./cli/utils/factories/Factory").Factory; } });
-var CoreModel_1 = require("./core/model/CoreModel");
-Object.defineProperty(exports, "CoreModel", { enumerable: true, get: function () { return CoreModel_1.CoreModel; } });
-var SchemaBlueprint_1 = require("./core/schema/SchemaBlueprint");
-Object.defineProperty(exports, "column", { enumerable: true, get: function () { return SchemaBlueprint_1.column; } });
-Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return SchemaBlueprint_1.validate; } });
-Object.defineProperty(exports, "relation", { enumerable: true, get: function () { return SchemaBlueprint_1.relation; } });
-Object.defineProperty(exports, "mixin", { enumerable: true, get: function () { return SchemaBlueprint_1.mixin; } });
-Object.defineProperty(exports, "validateSchema", { enumerable: true, get: function () { return SchemaBlueprint_1.validateSchema; } });
-var SchemaValidator_1 = require("./core/schema/SchemaValidator");
-Object.defineProperty(exports, "SchemaValidator", { enumerable: true, get: function () { return SchemaValidator_1.SchemaValidator; } });
-var SchemaBuilder_1 = require("./core/schema/SchemaBuilder");
-Object.defineProperty(exports, "SchemaBuilder", { enumerable: true, get: function () { return SchemaBuilder_1.SchemaBuilder; } });
-var CacheManager_1 = require("./core/cache/CacheManager");
-Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return CacheManager_1.CacheManager; } });
-var setupCache_1 = require("./core/cache/setupCache");
-Object.defineProperty(exports, "setupCache", { enumerable: true, get: function () { return setupCache_1.setupCache; } });
-var modelRegistration_1 = require("./core/orm/mixins/utils/modelRegistration");
-Object.defineProperty(exports, "registerModels", { enumerable: true, get: function () { return modelRegistration_1.registerModels; } });
-Object.defineProperty(exports, "isModelRegistered", { enumerable: true, get: function () { return modelRegistration_1.isModelRegistered; } });
-Object.defineProperty(exports, "setModelRegistryStrictMode", { enumerable: true, get: function () { return modelRegistration_1.setModelRegistryStrictMode; } });
-Object.defineProperty(exports, "isModelRegistryStrictMode", { enumerable: true, get: function () { return modelRegistration_1.isModelRegistryStrictMode; } });
+var BaseModel_js_1 = require("./core/model/BaseModel.js");
+Object.defineProperty(exports, "BaseModel", { enumerable: true, get: function () { return BaseModel_js_1.BaseModel; } });
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return BaseModel_js_1.Model; } });
+Object.defineProperty(exports, "SqlModel", { enumerable: true, get: function () { return BaseModel_js_1.SqlModel; } });
+Object.defineProperty(exports, "MongoModel", { enumerable: true, get: function () { return BaseModel_js_1.MongoModel; } });
+Object.defineProperty(exports, "MorphRegistry", { enumerable: true, get: function () { return BaseModel_js_1.MorphRegistry; } });
+var PivotHelperMixin_js_1 = require("./core/orm/mixins/PivotHelperMixin.js");
+Object.defineProperty(exports, "PivotHelperMixin", { enumerable: true, get: function () { return PivotHelperMixin_js_1.PivotHelperMixin; } });
+Object.defineProperty(exports, "Factory", { enumerable: true, get: function () { return require("./cli/utils/factories/Factory.js").Factory; } });
+var CoreModel_js_1 = require("./core/model/CoreModel.js");
+Object.defineProperty(exports, "CoreModel", { enumerable: true, get: function () { return CoreModel_js_1.CoreModel; } });
+var SchemaBlueprint_js_1 = require("./core/schema/SchemaBlueprint.js");
+Object.defineProperty(exports, "column", { enumerable: true, get: function () { return SchemaBlueprint_js_1.column; } });
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return SchemaBlueprint_js_1.validate; } });
+Object.defineProperty(exports, "relation", { enumerable: true, get: function () { return SchemaBlueprint_js_1.relation; } });
+Object.defineProperty(exports, "mixin", { enumerable: true, get: function () { return SchemaBlueprint_js_1.mixin; } });
+Object.defineProperty(exports, "validateSchema", { enumerable: true, get: function () { return SchemaBlueprint_js_1.validateSchema; } });
+var SchemaValidator_js_1 = require("./core/schema/SchemaValidator.js");
+Object.defineProperty(exports, "SchemaValidator", { enumerable: true, get: function () { return SchemaValidator_js_1.SchemaValidator; } });
+var SchemaBuilder_js_1 = require("./core/schema/SchemaBuilder.js");
+Object.defineProperty(exports, "SchemaBuilder", { enumerable: true, get: function () { return SchemaBuilder_js_1.SchemaBuilder; } });
+var CacheManager_js_1 = require("./core/cache/CacheManager.js");
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return CacheManager_js_1.CacheManager; } });
+var setupCache_js_1 = require("./core/cache/setupCache.js");
+Object.defineProperty(exports, "setupCache", { enumerable: true, get: function () { return setupCache_js_1.setupCache; } });
+var modelRegistration_js_1 = require("./core/orm/mixins/utils/modelRegistration.js");
+Object.defineProperty(exports, "registerModels", { enumerable: true, get: function () { return modelRegistration_js_1.registerModels; } });
+Object.defineProperty(exports, "isModelRegistered", { enumerable: true, get: function () { return modelRegistration_js_1.isModelRegistered; } });
+Object.defineProperty(exports, "setModelRegistryStrictMode", { enumerable: true, get: function () { return modelRegistration_js_1.setModelRegistryStrictMode; } });
+Object.defineProperty(exports, "isModelRegistryStrictMode", { enumerable: true, get: function () { return modelRegistration_js_1.isModelRegistryStrictMode; } });