@veap/database 0.1.0 → 0.1.2

package/dist/migrations/generator.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { AppError } from "@veap/kernel";
 const stub = `import type { Schema } from "@veap/database";
 
 export default {
@@ -16,6 +17,8 @@ export default {
   },
 };
 `;
+/** Migration names end up in a file name and in a table name, so keep them boring. */
+const NAME_PATTERN = /^[a-zA-Z0-9_]+$/;
 async function updateIndexFile(migrationsDir) {
     const indexFile = path.join(migrationsDir, "index.ts");
     const files = await fs.readdir(migrationsDir);
@@ -23,28 +26,50 @@ async function updateIndexFile(migrationsDir) {
         .filter((f) => f.endsWith(".ts") && f !== "index.ts")
         .sort();
     const imports = [];
+    const normalisers = [];
     const exports = [];
     for (const file of migrationFiles) {
         const name = file.replace(".ts", "");
         const varName = `m${name.replace(/[^a-zA-Z0-9]/g, "_")}`;
-        imports.push(`import { default as ${varName} } from "./${name}";`);
+        // A migration is either the scaffolded `export default { … }` object or a
+        // module with named `name`/`up`/`down` exports (every hand-written migration
+        // in the shipped apps). Importing the namespace and unwrapping `default`
+        // keeps both working, so regenerating the index never silently breaks a
+        // migration that was written by hand.
+        imports.push(`import * as ${varName}Raw from "./${name}";`);
+        normalisers.push(`const ${varName} = (${varName}Raw as { default?: unknown }).default ?? ${varName}Raw;`);
         exports.push(varName);
     }
     const content = `// This file is auto-generated by Veap CLI. Do not edit manually.
 ${imports.join("\n")}
 
+${normalisers.join("\n")}
+
 export const appMigrations = [
   ${exports.join(",\n  ")}
 ];
 `;
     await fs.writeFile(indexFile, content, "utf-8");
 }
+/**
+ * Writes a new migration file and regenerates the directory's `index.ts`.
+ *
+ * Used by the `veap make:migration` command; kept free of the console so it can
+ * be called from anywhere (tests, generators, plugins).
+ */
 export async function generateMigration(name, targetDir) {
+    const trimmed = (name ?? "").trim();
+    if (!trimmed) {
+        throw AppError.BadRequest("A migration name is required.");
+    }
+    if (!NAME_PATTERN.test(trimmed)) {
+        throw AppError.BadRequest(`The migration name "${trimmed}" may only contain letters, digits and underscores.`);
+    }
     const timestamp = new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14);
-    const fileName = `${timestamp}_${name}`;
-    let tableName = name;
-    if (name.startsWith("create_") && name.endsWith("_table")) {
-        tableName = name.replace("create_", "").replace("_table", "");
+    const fileName = `${timestamp}_${trimmed}`;
+    let tableName = trimmed;
+    if (trimmed.startsWith("create_") && trimmed.endsWith("_table")) {
+        tableName = trimmed.replace("create_", "").replace("_table", "");
     }
     const content = stub
         .replace(/{{name}}/g, fileName)
@@ -52,6 +77,16 @@ export async function generateMigration(name, targetDir) {
     const migrationsDir = targetDir || path.join(process.cwd(), "migrations");
     await fs.mkdir(migrationsDir, { recursive: true });
     const filePath = path.join(migrationsDir, `${fileName}.ts`);
+    // Two runs inside the same second would otherwise overwrite the first file.
+    try {
+        await fs.access(filePath);
+        throw AppError.Conflict(`The migration "${fileName}" already exists at ${filePath}.`);
+    }
+    catch (error) {
+        if (error instanceof AppError)
+            throw error;
+        // ENOENT: nothing to overwrite, keep going.
+    }
     await fs.writeFile(filePath, content, "utf-8");
     await updateIndexFile(migrationsDir);
     return { fileName, filePath };

package/dist/migrations/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./generator";
-export * from "./runner";
-export * from "./schema-builder";
+export * from "./generator.js";
+export * from "./runner.js";
+export * from "./schema-builder.js";

package/dist/migrations/index.js

@@ -1,3 +1,3 @@
-export * from "./generator";
-export * from "./runner";
-export * from "./schema-builder";
+export * from "./generator.js";
+export * from "./runner.js";
+export * from "./schema-builder.js";

package/dist/migrations/runner.d.ts

@@ -1,12 +1,37 @@
-import { Schema } from "./schema-builder";
+import { Schema } from "./schema-builder.js";
 export interface Migration {
     name: string;
     up: (db: any, schema: Schema) => Promise<void>;
     down?: (db: any, schema: Schema) => Promise<void>;
 }
-export declare function runMigrations(scope: string, migrations: Migration[]): Promise<void>;
+/**
+ * What one `runMigrations()` call actually did.
+ *
+ * Returned instead of a bare `void` so a caller — `veap migrate` above all —
+ * can report the run instead of guessing: an empty `ran` means nothing was
+ * pending, and `batch` is only set when migrations were applied.
+ */
+export interface MigrationRunResult {
+    scope: string;
+    /** Names of the migrations applied by this call, in execution order. */
+    ran: string[];
+    /** Batch the migrations of this call were recorded under. */
+    batch?: number;
+}
+export declare function runMigrations(scope: string, migrations: Migration[]): Promise<MigrationRunResult>;
+/**
+ * What one `rollbackMigrations()` call actually undid.
+ *
+ * Mirrors {@link MigrationRunResult} so `veap migrate:rollback` can report the
+ * reversed migrations instead of claiming a rollback that never happened.
+ */
+export interface MigrationRollbackResult {
+    scope: string;
+    /** Names of the migrations rolled back, in the order their `down()` ran. */
+    rolledBack: string[];
+}
 /**
  * Modern static migration rollback runner.
  * Reverts migrations in reverse order.
  */
-export declare function rollbackMigrations(scope: string, migrations: Migration[]): Promise<void>;
+export declare function rollbackMigrations(scope: string, migrations: Migration[]): Promise<MigrationRollbackResult>;

package/dist/migrations/runner.js

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
-import { getKnex } from "../connection";
-import { debug, warn } from "../logger";
-import { Schema } from "./schema-builder";
+import { getKnex } from "../connection.js";
+import { debug, warn } from "../logger.js";
+import { Schema } from "./schema-builder.js";
 async function ensureMigrationsTable(knex = getKnex()) {
     try {
         const hasTable = await knex.schema.hasTable("migrations");
@@ -27,6 +27,19 @@ async function ensureMigrationsTable(knex = getKnex()) {
         warn("veap:migration", "Failed to ensure migrations table:", error);
     }
 }
+async function acquireAdvisoryLockIfPostgres(tx, knex) {
+    const clientName = knex?.client?.config?.client || "";
+    if (typeof clientName === "string" &&
+        (clientName.includes("pg") || clientName.includes("postgres"))) {
+        const lockId = 123456;
+        try {
+            await tx.raw("SELECT pg_advisory_xact_lock(?)", [lockId]);
+        }
+        catch (_e) {
+            debug("veap:migration", "Could not acquire advisory lock, continuing...");
+        }
+    }
+}
 /**
  * Creates a compatibility DB adapter for migrations that provides `.execute(query)`
  * wrapping `trx.raw(query)`, while also being directly callable as a Knex query builder
@@ -54,27 +67,22 @@ function createMigrationDbAdapter(trx) {
     });
 }
 export async function runMigrations(scope, migrations) {
+    let result = { scope, ran: [] };
     if (migrations.length === 0)
-        return;
+        return result;
     let knex;
     try {
         knex = getKnex();
     }
     catch {
-        return;
+        return result;
     }
     if (!knex)
-        return;
+        return result;
     await ensureMigrationsTable(knex);
     await knex.transaction(async (tx) => {
-        // Acquire advisory lock (unique ID for migrations in Postgres)
-        const lockId = 123456;
-        try {
-            await tx.raw("SELECT pg_advisory_xact_lock(?)", [lockId]);
-        }
-        catch (_e) {
-            debug("veap:migration", "Could not acquire advisory lock, continuing...");
-        }
+        // Acquire advisory lock only if running on PostgreSQL
+        await acquireAdvisoryLockIfPostgres(tx, knex);
         debug("veap:migration", `Running migrations for scope: ${scope}`);
         // 1. Get executed migrations for this scope
         const executed = await tx("migrations")
@@ -111,39 +119,42 @@ export async function runMigrations(scope, migrations) {
                 throw error; // Rollback the whole batch on error
             }
         }
+        // Reported only once the whole batch is in: an error above rolls the
+        // transaction back, so nothing was applied and `ran` stays empty.
+        result = { scope, ran: pending.map((migration) => migration.name), batch };
     });
+    return result;
 }
 /**
  * Modern static migration rollback runner.
  * Reverts migrations in reverse order.
  */
 export async function rollbackMigrations(scope, migrations) {
+    let result = { scope, rolledBack: [] };
     if (migrations.length === 0)
-        return;
+        return result;
     let knex;
     try {
         knex = getKnex();
     }
     catch {
-        return;
+        return result;
     }
     if (!knex)
-        return;
+        return result;
     await ensureMigrationsTable(knex);
     await knex.transaction(async (tx) => {
-        // Acquire advisory lock
-        const lockId = 123456;
-        try {
-            await tx.raw("SELECT pg_advisory_xact_lock(?)", [lockId]);
-        }
-        catch (_e) {
-            debug("veap:migration", "Could not acquire advisory lock, continuing...");
-        }
-        // 1. Get executed migrations for this scope ordered by batch desc
+        // Acquire advisory lock only if running on PostgreSQL
+        await acquireAdvisoryLockIfPostgres(tx, knex);
+        // 1. The last batch first, and inside it the most recently executed
+        // migration first: a rollback has to walk the batch backwards, otherwise a
+        // table added to an existing one would be dropped before its own foreign
+        // keys, or after a table that depends on it.
         const executed = await tx("migrations")
-            .select("name", "batch")
+            .select("name", "batch", "executed_at")
             .where("scope", scope)
-            .orderBy("batch", "desc");
+            .orderBy("batch", "desc")
+            .orderBy("executed_at", "desc");
         if (executed.length === 0) {
             debug("veap:migration", `No migrations to rollback for ${scope}.`);
             return;
@@ -155,7 +166,7 @@ export async function rollbackMigrations(scope, migrations) {
             .map((m) => m.name);
         const dbAdapter = createMigrationDbAdapter(tx);
         const schema = new Schema(tx);
-        // Rollback in reverse order
+        const rolledBack = [];
         for (const name of toRollbackNames) {
             const migration = migrations.find((m) => m.name === name);
             if (migration && migration.down) {
@@ -166,6 +177,7 @@ export async function rollbackMigrations(scope, migrations) {
                         .where("name", name)
                         .where("scope", scope)
                         .delete();
+                    rolledBack.push(name);
                     debug("veap:migration", `[${scope}] Rolled back ${name}.`);
                 }
                 catch (error) {
@@ -174,5 +186,9 @@ export async function rollbackMigrations(scope, migrations) {
                 }
             }
         }
+        // Only reported once the transaction committed: an error above rolls it
+        // back, so nothing was undone.
+        result = { scope, rolledBack };
     });
+    return result;
 }

package/dist/migrations/schema-builder.js

@@ -1,4 +1,4 @@
-import { getKnex } from "../connection";
+import { getKnex } from "../connection.js";
 /**
  * Lightweight SQL helper for migrations, compatible with sql`...` template strings.
  */

package/dist/model.d.ts

@@ -1,7 +1,7 @@
-import { type CastType } from "./casts";
-import { ModelQueryBuilder } from "./query-builder";
-import { BelongsTo, BelongsToMany, HasMany, HasOne, MorphedByMany, MorphMany, MorphOne, MorphTo, MorphToMany } from "./relations";
-import type { GlobalScope } from "./scopes";
+import { type CastType } from "./casts.js";
+import { ModelQueryBuilder } from "./query-builder.js";
+import { BelongsTo, BelongsToMany, HasMany, HasOne, MorphedByMany, MorphMany, MorphOne, MorphTo, MorphToMany } from "./relations/index.js";
+import type { GlobalScope } from "./scopes.js";
 export declare abstract class Model<Attributes extends Record<string, any> = Record<string, any>> {
     [key: string]: any;
     /**

package/dist/model.js

@@ -1,13 +1,13 @@
 /** biome-ignore-all lint/correctness/noConstructorReturn: <ignore> */
 import crypto from "node:crypto";
-import { castAttribute, serializeForStorage } from "./casts";
-import { getKnex } from "./connection";
-import { DatabaseError } from "./errors";
-import { getDatabaseEventDispatcher } from "./events";
-import { Factory } from "./factory";
-import { ModelQueryBuilder } from "./query-builder";
-import { BelongsTo, BelongsToMany, HasMany, HasOne, MorphedByMany, MorphMany, MorphMap, MorphOne, MorphTo, MorphToMany, } from "./relations";
-import { toCamelCase, toSnakeCase } from "./utils";
+import { castAttribute, serializeForStorage } from "./casts.js";
+import { getKnex } from "./connection.js";
+import { DatabaseError } from "./errors.js";
+import { getDatabaseEventDispatcher } from "./events.js";
+import { Factory } from "./factory.js";
+import { ModelQueryBuilder } from "./query-builder.js";
+import { BelongsTo, BelongsToMany, HasMany, HasOne, MorphedByMany, MorphMany, MorphMap, MorphOne, MorphTo, MorphToMany, } from "./relations/index.js";
+import { toCamelCase, toSnakeCase } from "./utils.js";
 export class Model {
     /**
      * Database table name.
@@ -285,7 +285,7 @@ export class Model {
      * Executes a database transaction.
      */
     static async transaction(callback) {
-        const { transaction: runTrx } = await import("./connection");
+        const { transaction: runTrx } = await import("./connection.js");
         return await runTrx(callback);
     }
     /**
@@ -336,12 +336,15 @@ export class Model {
      */
     static async destroy(id) {
         const knex = getKnex();
+        const clientType = knex.client?.config?.client;
         if (this.softDeletes) {
             const col = toSnakeCase(this.deletedAtColumn || "deleted_at");
             const count = await knex(this.table)
                 .where(this.primaryKey, id)
                 .whereNull(col)
-                .update({ [col]: new Date() });
+                .update({
+                [col]: serializeForStorage(new Date(), "datetime", clientType),
+            });
             return count > 0;
         }
         const count = await knex(this.table).where(this.primaryKey, id).delete();
@@ -607,7 +610,18 @@ export class Model {
                 }
                 insertData[col] = serializeForStorage(v, castType, clientType);
             }
-            await knex(modelClass.table).insert(insertData);
+            const insertResult = await knex(modelClass.table)
+                .insert(insertData)
+                .returning(pk);
+            if (!this.getAttribute(pk)) {
+                if (Array.isArray(insertResult) && insertResult.length > 0) {
+                    const first = insertResult[0];
+                    const returnedId = typeof first === "object" && first !== null ? first[pk] : first;
+                    if (returnedId !== undefined && returnedId !== null) {
+                        this.setAttribute(pk, returnedId);
+                    }
+                }
+            }
             this.isNew = false;
             this._original = { ...this._attributes };
             await this.fireModelEvent("created");

package/dist/provider.d.ts

@@ -1,5 +1,5 @@
 import { ServiceProvider } from "@veap/kernel";
-import type { DatabaseConfig } from "./types";
+import type { DatabaseConfig } from "./types.js";
 export interface DatabaseProviderConfig {
     databaseUrl?: string;
     config?: DatabaseConfig;
@@ -9,4 +9,5 @@ export declare class DatabaseServiceProvider extends ServiceProvider {
     constructor(container: any, config?: DatabaseProviderConfig);
     register(): void;
     boot(): Promise<void>;
+    shutdown(): Promise<void>;
 }

package/dist/provider.js

@@ -1,7 +1,9 @@
-import { ConfigService, DATABASE, ServiceProvider } from "@veap/kernel";
+import { ConfigService, ServiceProvider } from "@veap/kernel";
 import knex from "knex";
-import { initDatabase, isSqliteDatabase, resolvePostgresSslConfig, resolveSqliteFilename, setKnex, } from "./connection";
-import { debug } from "./logger";
+import { getKnex, initDatabase, isSqliteDatabase, resolvePostgresSslConfig, resolveSqliteFilename, setKnex, } from "./connection.js";
+import { setDatabaseEventDispatcher } from "./events.js";
+import { debug, setDatabaseLogger } from "./logger.js";
+import { DATABASE } from "./tokens.js";
 export class DatabaseServiceProvider extends ServiceProvider {
     config;
     constructor(container, config) {
@@ -12,13 +14,54 @@ export class DatabaseServiceProvider extends ServiceProvider {
         // Port token registration
     }
     async boot() {
-        const configService = await this.container.resolve(ConfigService);
+        let configService = null;
+        if (this.container.has(ConfigService)) {
+            configService = await this.container.resolve(ConfigService);
+        }
+        else if (this.container.has("ConfigService")) {
+            configService = await this.container.resolve("ConfigService");
+        }
         const databaseUrl = this.config?.databaseUrl ||
-            configService.get("DATABASE_URL") ||
+            configService?.get?.("DATABASE_URL") ||
             process.env.DATABASE_URL ||
             process.env.DATABASE_FILE;
-        const isProd = configService.get("NODE_ENV") === "production" ||
+        const isProd = configService?.get?.("NODE_ENV") === "production" ||
             process.env.NODE_ENV === "production";
+        // Auto-wire EventDispatcher if bound to container
+        if (this.container.has("EventDispatcher")) {
+            try {
+                const dispatcher = (await this.container.resolve("EventDispatcher"));
+                if (dispatcher && typeof dispatcher.publish === "function") {
+                    setDatabaseEventDispatcher(dispatcher);
+                }
+            }
+            catch {
+                // Continue without event dispatcher
+            }
+        }
+        // Auto-wire Logger if bound to container
+        if (this.container.has("LOGGER")) {
+            try {
+                const logger = (await this.container.resolve("LOGGER"));
+                if (logger && typeof logger.info === "function") {
+                    setDatabaseLogger({
+                        debug: (ch, msg, ...args) => logger.debug
+                            ? logger.debug(`[${ch}] ${msg}`, ...args)
+                            : undefined,
+                        info: (ch, msg, ...args) => logger.info(`[${ch}] ${msg}`, ...args),
+                        warn: (ch, msg, ...args) => logger.warn
+                            ? logger.warn(`[${ch}] ${msg}`, ...args)
+                            : console.warn(`[${ch}] ${msg}`, ...args),
+                        error: (ch, msg, ...args) => logger.error
+                            ? logger.error(`[${ch}] ${msg}`, ...args)
+                            : console.error(`[${ch}] ${msg}`, ...args),
+                    });
+                }
+            }
+            catch {
+                // Continue with default logger
+            }
+        }
         if (this.config?.config) {
             const instance = initDatabase(this.config.config);
             this.container.register({ token: DATABASE, useValue: instance });
@@ -32,8 +75,8 @@ export class DatabaseServiceProvider extends ServiceProvider {
         const ssl = resolvePostgresSslConfig({
             databaseUrl: resolvedUrl,
             isProd,
-            rejectUnauthorizedEnv: configService.get("DATABASE_SSL_REJECT_UNAUTHORIZED"),
-            caCert: configService.get("DATABASE_SSL_CA"),
+            rejectUnauthorizedEnv: configService?.get?.("DATABASE_SSL_REJECT_UNAUTHORIZED"),
+            caCert: configService?.get?.("DATABASE_SSL_CA"),
         });
         const instance = knex({
             client,
@@ -55,4 +98,15 @@ export class DatabaseServiceProvider extends ServiceProvider {
             useValue: instance,
         });
     }
+    async shutdown() {
+        try {
+            const k = getKnex();
+            if (k && typeof k.destroy === "function") {
+                await k.destroy();
+            }
+        }
+        catch {
+            // Ignore if not initialized
+        }
+    }
 }

package/dist/query-builder.d.ts

@@ -1,5 +1,6 @@
 import type { Knex } from "knex";
-import type { Model } from "./model";
+import type { Model } from "./model.js";
+import type { PaginationResult } from "./types.js";
 export declare class ModelQueryBuilder<M extends Model = any> {
     modelClass: any;
     [key: string]: any;
@@ -65,6 +66,9 @@ export declare class ModelQueryBuilder<M extends Model = any> {
     take(count: number): this;
     offset(count: number): this;
     skip(count: number): this;
+    groupBy(...columns: any[]): this;
+    having(column: any, operatorOrValue?: any, value?: any): this;
+    distinct(...columns: any[]): this;
     join(table: string, first: string, operatorOrSecond: string, second?: string): this;
     leftJoin(table: string, first: string, operatorOrSecond: string, second?: string): this;
     /**
@@ -162,12 +166,8 @@ export declare class ModelQueryBuilder<M extends Model = any> {
     /**
      * Paginates results.
      */
-    paginate(page?: number, perPage?: number): Promise<{
-        data: M[];
-        total: number;
+    paginate(page?: number, perPage?: number): Promise<PaginationResult<M> & {
         page: number;
-        perPage: number;
-        lastPage: number;
     }>;
     /**
      * Bulk updates matching records.

package/dist/query-builder.js

@@ -1,9 +1,9 @@
-import { serializeForStorage } from "./casts";
-import { getKnex } from "./connection";
-import { DatabaseError } from "./errors";
-import { BelongsTo, BelongsToMany, MorphedByMany, MorphMany, MorphOne, MorphToMany, } from "./relations";
-import { eagerLoadRelations } from "./relations/eager-loader";
-import { toCamelCase, toSnakeCase } from "./utils";
+import { serializeForStorage } from "./casts.js";
+import { getKnex } from "./connection.js";
+import { DatabaseError } from "./errors.js";
+import { eagerLoadRelations } from "./relations/eager-loader.js";
+import { BelongsTo, BelongsToMany, MorphedByMany, MorphMany, MorphOne, MorphToMany, } from "./relations/index.js";
+import { toCamelCase, toSnakeCase } from "./utils.js";
 export class ModelQueryBuilder {
     modelClass;
     knexBuilder;
@@ -47,6 +47,14 @@ export class ModelQueryBuilder {
                                 : result;
                         };
                     }
+                    // 3. Delegate to Knex query builder if method exists (e.g. groupBy, having, distinct, joinRaw)
+                    if (target.knexBuilder &&
+                        typeof target.knexBuilder[prop] === "function") {
+                        return (...args) => {
+                            const result = target.knexBuilder[prop](...args);
+                            return result === target.knexBuilder ? receiver : result;
+                        };
+                    }
                 }
                 return Reflect.get(target, prop, receiver);
             },
@@ -270,6 +278,30 @@ export class ModelQueryBuilder {
     skip(count) {
         return this.offset(count);
     }
+    groupBy(...columns) {
+        const converted = columns.map((col) => typeof col === "string" ? toSnakeCase(col) : col);
+        this.knexBuilder.groupBy(...converted);
+        return this;
+    }
+    having(column, operatorOrValue, value) {
+        if (value === undefined) {
+            if (operatorOrValue === undefined) {
+                this.knexBuilder.having(column);
+            }
+            else {
+                this.knexBuilder.having(column, "=", operatorOrValue);
+            }
+        }
+        else {
+            this.knexBuilder.having(column, operatorOrValue, value);
+        }
+        return this;
+    }
+    distinct(...columns) {
+        const converted = columns.map((col) => typeof col === "string" ? toSnakeCase(col) : col);
+        this.knexBuilder.distinct(...converted);
+        return this;
+    }
     join(table, first, operatorOrSecond, second) {
         if (second === undefined) {
             this.knexBuilder.join(table, first, operatorOrSecond);
@@ -646,6 +678,7 @@ export class ModelQueryBuilder {
             data,
             total,
             page,
+            currentPage: page,
             perPage,
             lastPage,
         };
@@ -654,6 +687,7 @@ export class ModelQueryBuilder {
      * Bulk updates matching records.
      */
     async update(attributes) {
+        this.applyGlobalScopes();
         const converted = {};
         const casts = this.modelClass?.casts || {};
         const knex = getKnex();

package/dist/relations/belongs-to-many.d.ts

@@ -1,6 +1,6 @@
-import type { Model } from "../model";
-import type { ModelQueryBuilder } from "../query-builder";
-import { Relation } from "./relation";
+import type { Model } from "../model.js";
+import type { ModelQueryBuilder } from "../query-builder.js";
+import { Relation } from "./relation.js";
 export declare class BelongsToMany<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
     pivotTable: string;
     foreignPivotKey: string;

package/dist/relations/belongs-to-many.js

@@ -1,5 +1,5 @@
-import { getKnex } from "../connection";
-import { Relation } from "./relation";
+import { getKnex } from "../connection.js";
+import { Relation } from "./relation.js";
 export class BelongsToMany extends Relation {
     pivotTable;
     foreignPivotKey;

package/dist/relations/belongs-to.d.ts

@@ -1,6 +1,6 @@
-import type { Model } from "../model";
-import type { ModelQueryBuilder } from "../query-builder";
-import { Relation } from "./relation";
+import type { Model } from "../model.js";
+import type { ModelQueryBuilder } from "../query-builder.js";
+import { Relation } from "./relation.js";
 export declare class BelongsTo<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
     query(): ModelQueryBuilder<Related>;
     get(): Promise<Related | null>;

package/dist/relations/belongs-to.js

@@ -1,4 +1,4 @@
-import { Relation } from "./relation";
+import { Relation } from "./relation.js";
 export class BelongsTo extends Relation {
     query() {
         const foreignKeyValue = this.parent.getAttribute(this.foreignKey);

package/dist/relations/eager-loader.d.ts

@@ -1,4 +1,4 @@
-import type { Model } from "../model";
+import type { Model } from "../model.js";
 /**
  * Loads relations onto an array of model instances in bulk queries, avoiding N+1.
  */

package/dist/relations/eager-loader.js

@@ -1,4 +1,4 @@
-import { DatabaseError } from "../errors";
+import { DatabaseError } from "../errors.js";
 /**
  * Loads relations onto an array of model instances in bulk queries, avoiding N+1.
  */
@@ -11,6 +11,8 @@ export async function eagerLoadRelations(models, relations) {
     for (const rel of relations) {
         const parts = rel.split(".");
         const head = parts[0];
+        if (!head)
+            continue;
         const tail = parts.slice(1).join(".");
         if (!tree[head]) {
             tree[head] = [];