@veap/database 0.1.0 → 0.1.2

package/README.md

@@ -1,5 +1,6 @@
-[![CI](https://github.com/veapjs/veap-database/actions/workflows/ci.yml/badge.svg)](https://github.com/veapjs/veap-database/actions/workflows/ci.yml)
-[![Release](https://github.com/veapjs/veap-database/actions/workflows/release.yml/badge.svg)](https://github.com/veapjs/veap-database/actions/workflows/release.yml)
+[![CI](https://github.com/veapjs/veap-database/actions/workflows/CI.yml/badge.svg)](https://github.com/veapjs/veap-database/actions/workflows/CI.yml)
+[![Release](https://github.com/veapjs/veap-database/actions/workflows/RELEASE.yml/badge.svg)](https://github.com/veapjs/veap-database/actions/workflows/RELEASE.yml)
+[![Version](https://img.shields.io/npm/v/@veap/database?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/@veap/database)
 
 # @veap/database
 

package/dist/casts.js

@@ -57,7 +57,7 @@ export function serializeForStorage(value, type, clientType) {
     }
     switch (type) {
         case "json":
-            return JSON.stringify(value);
+            return typeof value === "string" ? value : JSON.stringify(value);
         case "boolean":
             if (clientType?.includes("sqlite")) {
                 return value ? 1 : 0;

package/dist/cli/commands/make-migration.d.ts

@@ -0,0 +1,13 @@
+import { Command, type CommandInput, type Output } from "@veap/kernel/cli";
+/**
+ * `veap make:migration {name}` — scaffolds a migration in the host project.
+ *
+ * The file lands in the project the console was started in (by default
+ * `<project>/migrations`) and the directory's `index.ts` is regenerated, so the
+ * new migration is picked up by `.withMigrations(appMigrations)`.
+ */
+export declare class MakeMigrationCommand extends Command {
+    static signature: string;
+    static description: string;
+    handle(input: CommandInput, output: Output): Promise<number>;
+}

package/dist/cli/commands/make-migration.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { Command } from "@veap/kernel/cli";
+import { generateMigration } from "../../migrations/generator.js";
+/**
+ * `veap make:migration {name}` — scaffolds a migration in the host project.
+ *
+ * The file lands in the project the console was started in (by default
+ * `<project>/migrations`) and the directory's `index.ts` is regenerated, so the
+ * new migration is picked up by `.withMigrations(appMigrations)`.
+ */
+export class MakeMigrationCommand extends Command {
+    static signature = "make:migration {name : Name of the migration, e.g. create_posts_table} {--dir=path : Directory relative to the project root (default: migrations)}";
+    static description = "Create a new migration file in the application";
+    async handle(input, output) {
+        const name = input.argument("name") ?? "";
+        const dir = input.option("dir");
+        const directory = path.resolve(this.context.root, typeof dir === "string" && dir.trim() !== "" ? dir.trim() : "migrations");
+        const { filePath } = await generateMigration(name, directory);
+        const relative = path.relative(this.context.root, filePath);
+        output.success(`Created migration: ${relative}`);
+        output.info('Run "veap migrate" to apply the pending migrations.');
+        return 0;
+    }
+}

package/dist/cli/commands/migrate-rollback.d.ts

@@ -0,0 +1,14 @@
+import { Command, type CommandInput, type Output } from "@veap/kernel/cli";
+/**
+ * `veap migrate:rollback` — undoes the last batch of the scope.
+ *
+ * Runs each migration's `down()` in the reverse of the order it was applied, and
+ * deletes the `migrations` rows it undid, so a `veap migrate` afterwards
+ * re-applies exactly what was rolled back. In production the command asks first;
+ * `--force` answers that question for an unattended run.
+ */
+export declare class MigrateRollbackCommand extends Command {
+    static signature: string;
+    static description: string;
+    handle(input: CommandInput, output: Output): Promise<number>;
+}

package/dist/cli/commands/migrate-rollback.js

@@ -0,0 +1,41 @@
+import { Command } from "@veap/kernel/cli";
+import { rollbackMigrations } from "../../migrations/runner.js";
+import { confirmToProceed } from "../confirmation.js";
+import { hasDatabaseConnection, resolveRegisteredMigrations, resolveScope, } from "../migrations.js";
+/**
+ * `veap migrate:rollback` — undoes the last batch of the scope.
+ *
+ * Runs each migration's `down()` in the reverse of the order it was applied, and
+ * deletes the `migrations` rows it undid, so a `veap migrate` afterwards
+ * re-applies exactly what was rolled back. In production the command asks first;
+ * `--force` answers that question for an unattended run.
+ */
+export class MigrateRollbackCommand extends Command {
+    static signature = "migrate:rollback {--scope=app : Migration scope to roll back}";
+    static description = "Roll back the last batch of application migrations";
+    async handle(input, output) {
+        const scope = resolveScope(input);
+        const migrations = await resolveRegisteredMigrations(this.context.container);
+        if (migrations.length === 0) {
+            output.warn("No application migrations are registered. Add them to the application with `.withMigrations(appMigrations)`.");
+            return 0;
+        }
+        if (!hasDatabaseConnection()) {
+            output.error("No database connection is available. Set DATABASE_URL (or register DatabaseServiceProvider) before rolling migrations back.");
+            return 1;
+        }
+        const proceed = await confirmToProceed(this.context, output, "Roll back the last batch of migrations");
+        if (!proceed)
+            return 1;
+        const result = await rollbackMigrations(scope, migrations);
+        if (result.rolledBack.length === 0) {
+            output.info(`Nothing to roll back for scope "${scope}".`);
+            return 0;
+        }
+        for (const name of result.rolledBack) {
+            output.success(`Rolled back: ${name}`);
+        }
+        output.info(`${result.rolledBack.length} migration(s) rolled back (scope "${scope}").`);
+        return 0;
+    }
+}

package/dist/cli/commands/migrate-status.d.ts

@@ -0,0 +1,16 @@
+import { Command, type CommandInput, type Output } from "@veap/kernel/cli";
+/**
+ * `veap migrate:status` — what is applied and what is still pending.
+ *
+ * Compares the migrations the application registered against the rows recorded
+ * in the `migrations` table for the scope, so the answer is about *this*
+ * application, not about the whole database. Rows recorded under the scope that
+ * the application no longer declares are reported separately: they are the
+ * signature of a renamed or deleted migration file, which `migrate` would
+ * otherwise never mention again.
+ */
+export declare class MigrateStatusCommand extends Command {
+    static signature: string;
+    static description: string;
+    handle(input: CommandInput, output: Output): Promise<number>;
+}

package/dist/cli/commands/migrate-status.js

@@ -0,0 +1,79 @@
+import { Command } from "@veap/kernel/cli";
+import { getKnex } from "../../connection.js";
+import { hasDatabaseConnection, resolveRegisteredMigrations, resolveScope, } from "../migrations.js";
+/** `executed_at` comes back as a Date, an epoch number or a string, per driver. */
+function formatRanAt(value) {
+    if (value === null || value === undefined)
+        return "—";
+    const date = value instanceof Date
+        ? value
+        : typeof value === "number"
+            ? new Date(value)
+            : undefined;
+    if (date && !Number.isNaN(date.getTime())) {
+        return date.toISOString().replace("T", " ").slice(0, 19);
+    }
+    const text = String(value).trim();
+    return text === "" ? "—" : text.replace("T", " ").slice(0, 19);
+}
+/**
+ * `veap migrate:status` — what is applied and what is still pending.
+ *
+ * Compares the migrations the application registered against the rows recorded
+ * in the `migrations` table for the scope, so the answer is about *this*
+ * application, not about the whole database. Rows recorded under the scope that
+ * the application no longer declares are reported separately: they are the
+ * signature of a renamed or deleted migration file, which `migrate` would
+ * otherwise never mention again.
+ */
+export class MigrateStatusCommand extends Command {
+    static signature = "migrate:status {--scope=app : Migration scope to inspect}";
+    static description = "Show the status of the application migrations";
+    async handle(input, output) {
+        const scope = resolveScope(input);
+        const migrations = await resolveRegisteredMigrations(this.context.container);
+        if (!hasDatabaseConnection()) {
+            output.error("No database connection is available. Set DATABASE_URL (or register DatabaseServiceProvider) before reading the migration status.");
+            return 1;
+        }
+        const knex = getKnex();
+        const recorded = (await knex.schema.hasTable("migrations"))
+            ? await knex("migrations")
+                .select("name", "batch", "executed_at")
+                .where("scope", scope)
+            : [];
+        const byName = new Map(recorded.map((row) => [row.name, row]));
+        const rows = [];
+        let ran = 0;
+        let pending = 0;
+        for (const migration of migrations) {
+            const row = byName.get(migration.name);
+            if (row) {
+                ran += 1;
+                rows.push([
+                    migration.name,
+                    "Ran",
+                    String(row.batch),
+                    formatRanAt(row.executed_at),
+                ]);
+                continue;
+            }
+            pending += 1;
+            rows.push([migration.name, "Pending", "—", "—"]);
+        }
+        if (rows.length === 0) {
+            output.info(`No application migrations are registered for scope "${scope}".`);
+        }
+        else {
+            output.table(["Migration", "Status", "Batch", "Ran at"], rows);
+            output.info(`${ran} ran, ${pending} pending (scope "${scope}").`);
+        }
+        const unknown = recorded.filter((row) => !migrations.some((migration) => migration.name === row.name));
+        if (unknown.length > 0) {
+            output.warn(`${unknown.length} migration(s) recorded for scope "${scope}" are not part of this application: ${unknown
+                .map((row) => row.name)
+                .join(", ")}.`);
+        }
+        return 0;
+    }
+}

package/dist/cli/commands/migrate.d.ts

@@ -0,0 +1,13 @@
+import { Command, type CommandInput, type Output } from "@veap/kernel/cli";
+/**
+ * `veap migrate` — applies every pending application migration, in one batch.
+ *
+ * In production the command asks before touching the database; `--force` answers
+ * that question for an unattended run, and `--no-interaction` without `--force`
+ * resolves it to "no" instead of hanging.
+ */
+export declare class MigrateCommand extends Command {
+    static signature: string;
+    static description: string;
+    handle(input: CommandInput, output: Output): Promise<number>;
+}

package/dist/cli/commands/migrate.js

@@ -0,0 +1,40 @@
+import { Command } from "@veap/kernel/cli";
+import { runMigrations } from "../../migrations/runner.js";
+import { confirmToProceed } from "../confirmation.js";
+import { hasDatabaseConnection, resolveRegisteredMigrations, resolveScope, } from "../migrations.js";
+/**
+ * `veap migrate` — applies every pending application migration, in one batch.
+ *
+ * In production the command asks before touching the database; `--force` answers
+ * that question for an unattended run, and `--no-interaction` without `--force`
+ * resolves it to "no" instead of hanging.
+ */
+export class MigrateCommand extends Command {
+    static signature = "migrate {--scope=app : Migration scope to run}";
+    static description = "Run the pending application migrations";
+    async handle(input, output) {
+        const scope = resolveScope(input);
+        const migrations = await resolveRegisteredMigrations(this.context.container);
+        if (migrations.length === 0) {
+            output.warn("No application migrations are registered. Add them to the application with `.withMigrations(appMigrations)`.");
+            return 0;
+        }
+        if (!hasDatabaseConnection()) {
+            output.error("No database connection is available. Set DATABASE_URL (or register DatabaseServiceProvider) before running migrations.");
+            return 1;
+        }
+        const proceed = await confirmToProceed(this.context, output, "Run the pending migrations");
+        if (!proceed)
+            return 1;
+        const result = await runMigrations(scope, migrations);
+        if (result.ran.length === 0) {
+            output.info(`Nothing to migrate for scope "${scope}".`);
+            return 0;
+        }
+        for (const name of result.ran) {
+            output.success(`Migrated: ${name}`);
+        }
+        output.info(`${result.ran.length} migration(s) applied in batch ${result.batch} (scope "${scope}").`);
+        return 0;
+    }
+}

package/dist/cli/confirmation.d.ts

@@ -0,0 +1,14 @@
+import type { CommandContext, Output } from "@veap/kernel/cli";
+/**
+ * The gate every command that changes the database goes through.
+ *
+ * Outside production it stays silent: `veap migrate` on a developer machine is a
+ * routine step and should not need a confirmation. Inside production the command
+ * asks first, and `--force` is how an unattended run says yes — a pipeline runs
+ * `veap migrate --force`. Passing `--no-interaction` without `--force` resolves
+ * the prompt to its default ("no"), so an unattended run can never touch
+ * production data by accident, and it can never hang waiting for input either.
+ */
+export declare function confirmToProceed(context: CommandContext, output: Output, 
+/** Sentence describing the action, e.g. "Run the pending migrations". */
+action: string): Promise<boolean>;

package/dist/cli/confirmation.js

@@ -0,0 +1,26 @@
+/** Environments in which changing the database asks for a confirmation first. */
+const GUARDED_ENVIRONMENTS = new Set(["production", "prod"]);
+/**
+ * The gate every command that changes the database goes through.
+ *
+ * Outside production it stays silent: `veap migrate` on a developer machine is a
+ * routine step and should not need a confirmation. Inside production the command
+ * asks first, and `--force` is how an unattended run says yes — a pipeline runs
+ * `veap migrate --force`. Passing `--no-interaction` without `--force` resolves
+ * the prompt to its default ("no"), so an unattended run can never touch
+ * production data by accident, and it can never hang waiting for input either.
+ */
+export async function confirmToProceed(context, output, 
+/** Sentence describing the action, e.g. "Run the pending migrations". */
+action) {
+    if (context.flags.force)
+        return true;
+    if (!GUARDED_ENVIRONMENTS.has(context.env))
+        return true;
+    // No quotes around the environment name on purpose: this question is also
+    // rendered inside the non-TTY error message, where nested quotes read badly.
+    const confirmed = await output.confirm(`The application is running in ${context.env}. ${action}?`, { default: false });
+    if (!confirmed)
+        output.warn("Cancelled.");
+    return confirmed;
+}

package/dist/cli/migrations.d.ts

@@ -0,0 +1,20 @@
+import type { Container } from "@veap/kernel";
+import type { CommandInput } from "@veap/kernel/cli";
+/**
+ * Tokens a host application publishes its migration list under: the explicit
+ * `APP_MIGRATIONS` symbol or the string alias used by older scaffolds.
+ */
+export declare const MIGRATION_TOKENS: readonly [import("@veap/kernel").Token<any[]>, "AppMigrations"];
+/** Default scope every migration command operates on. */
+export declare const DEFAULT_MIGRATION_SCOPE = "app";
+/** The scope a migration command was asked for (`--scope`, default `app`). */
+export declare function resolveScope(input: CommandInput): string;
+/**
+ * The migration list the host application registered, if any.
+ *
+ * Read from the container, which is where `.withMigrations(appMigrations)` puts
+ * it, so no command has to guess how a project declares its migrations.
+ */
+export declare function resolveRegisteredMigrations(container: Container): Promise<any[]>;
+/** `true` when `DatabaseServiceProvider` booted and a Knex instance exists. */
+export declare function hasDatabaseConnection(): boolean;

package/dist/cli/migrations.js

@@ -0,0 +1,41 @@
+import { getKnex } from "../connection.js";
+import { APP_MIGRATIONS } from "../tokens.js";
+/**
+ * Tokens a host application publishes its migration list under: the explicit
+ * `APP_MIGRATIONS` symbol or the string alias used by older scaffolds.
+ */
+export const MIGRATION_TOKENS = [APP_MIGRATIONS, "AppMigrations"];
+/** Default scope every migration command operates on. */
+export const DEFAULT_MIGRATION_SCOPE = "app";
+/** The scope a migration command was asked for (`--scope`, default `app`). */
+export function resolveScope(input) {
+    const scope = input.option("scope");
+    return typeof scope === "string" && scope.trim() !== ""
+        ? scope.trim()
+        : DEFAULT_MIGRATION_SCOPE;
+}
+/**
+ * The migration list the host application registered, if any.
+ *
+ * Read from the container, which is where `.withMigrations(appMigrations)` puts
+ * it, so no command has to guess how a project declares its migrations.
+ */
+export async function resolveRegisteredMigrations(container) {
+    for (const token of MIGRATION_TOKENS) {
+        if (!container.has(token))
+            continue;
+        const migrations = await container.resolve(token);
+        if (Array.isArray(migrations) && migrations.length > 0)
+            return migrations;
+    }
+    return [];
+}
+/** `true` when `DatabaseServiceProvider` booted and a Knex instance exists. */
+export function hasDatabaseConnection() {
+    try {
+        return Boolean(getKnex());
+    }
+    catch {
+        return false;
+    }
+}

package/dist/composition.d.ts

@@ -0,0 +1,15 @@
+import { ServiceProvider } from "@veap/kernel";
+declare module "@veap/kernel" {
+    interface ApplicationBuilder {
+        /**
+         * Registers host application migrations with IoC and configures MigrationServiceProvider.
+         */
+        withMigrations(migrations: any[]): this;
+    }
+}
+declare class MigrationsConfigProvider extends ServiceProvider {
+    private migrations;
+    constructor(container: any, migrations?: any[]);
+    register(): void;
+}
+export { MigrationsConfigProvider };

package/dist/composition.js

@@ -0,0 +1,26 @@
+import { ApplicationBuilder, ServiceProvider } from "@veap/kernel";
+import { MigrationServiceProvider } from "./migration-provider.js";
+import { APP_MIGRATIONS } from "./tokens.js";
+class MigrationsConfigProvider extends ServiceProvider {
+    migrations;
+    constructor(container, migrations = []) {
+        super(container);
+        this.migrations = migrations;
+    }
+    register() {
+        this.container.register({
+            token: APP_MIGRATIONS,
+            useValue: this.migrations,
+        });
+        this.container.register({
+            token: "AppMigrations",
+            useValue: this.migrations,
+        });
+    }
+}
+if (!ApplicationBuilder.prototype.withMigrations) {
+    ApplicationBuilder.prototype.withMigrations = function (migrations) {
+        return this.use((c) => new MigrationsConfigProvider(c, migrations)).use(MigrationServiceProvider);
+    };
+}
+export { MigrationsConfigProvider };

package/dist/connection.d.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { type Knex } from "knex";
-import type { DatabaseConfig, PostgresSslConfig, PostgresSslOptions, TransactionOptions } from "./types";
+import type { DatabaseConfig, PostgresSslConfig, PostgresSslOptions, TransactionOptions } from "./types.js";
 /**
  * AsyncLocalStorage holding the currently active Knex transaction for the asynchronous execution context.
  */

package/dist/connection.js

@@ -2,8 +2,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs";
 import path from "node:path";
 import knex from "knex";
-import { DatabaseError } from "./errors";
-import { debug, warn } from "./logger";
+import { DatabaseError } from "./errors.js";
+import { debug, warn } from "./logger.js";
 const globalForDb = globalThis;
 /**
  * AsyncLocalStorage holding the currently active Knex transaction for the asynchronous execution context.
@@ -90,9 +90,13 @@ export function resolveSqliteFilename(filename) {
     }
     if (!clean.startsWith(":memory:")) {
         try {
-            fs.mkdirSync(path.dirname(path.resolve(clean)), {
-                recursive: true,
-            });
+            if (typeof process !== "undefined" && process.versions?.node) {
+                /* turbopackIgnore: true */
+                const resolvedPath = path.resolve(clean);
+                fs.mkdirSync(path.dirname(resolvedPath), {
+                    recursive: true,
+                });
+            }
         }
         catch {
             // Read-only filesystem etc. Let the driver surface its own error.

package/dist/factory.d.ts

@@ -1,4 +1,4 @@
-import type { Model } from "./model";
+import type { Model } from "./model.js";
 export declare abstract class Factory<M extends Model = any> {
     private static get registry();
     /**

package/dist/factory.js

@@ -1,4 +1,4 @@
-import { DatabaseError } from "./errors";
+import { DatabaseError } from "./errors.js";
 export class Factory {
     static get registry() {
         const g = globalThis;

package/dist/index.d.ts

@@ -1,17 +1,19 @@
 export { default as knex, type Knex } from "knex";
-export * from "./casts";
-export * from "./connection";
-export * from "./errors";
-export * from "./events";
-export * from "./factory";
-export * from "./logger";
-export * from "./migration-provider";
-export * from "./migrations/index";
-export * from "./model";
-export * from "./provider";
-export * from "./query-builder";
-export * from "./relations/index";
-export * from "./scopes";
-export * from "./seeder";
-export * from "./types";
-export * from "./utils";
+export * from "./casts.js";
+export * from "./composition.js";
+export * from "./connection.js";
+export * from "./errors.js";
+export * from "./events.js";
+export * from "./factory.js";
+export * from "./logger.js";
+export * from "./migration-provider.js";
+export * from "./migrations/index.js";
+export * from "./model.js";
+export * from "./provider.js";
+export * from "./query-builder.js";
+export * from "./relations/index.js";
+export * from "./scopes.js";
+export * from "./seeder.js";
+export * from "./tokens.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/index.js

@@ -1,17 +1,19 @@
 export { default as knex } from "knex";
-export * from "./casts";
-export * from "./connection";
-export * from "./errors";
-export * from "./events";
-export * from "./factory";
-export * from "./logger";
-export * from "./migration-provider";
-export * from "./migrations/index";
-export * from "./model";
-export * from "./provider";
-export * from "./query-builder";
-export * from "./relations/index";
-export * from "./scopes";
-export * from "./seeder";
-export * from "./types";
-export * from "./utils";
+export * from "./casts.js";
+export * from "./composition.js";
+export * from "./connection.js";
+export * from "./errors.js";
+export * from "./events.js";
+export * from "./factory.js";
+export * from "./logger.js";
+export * from "./migration-provider.js";
+export * from "./migrations/index.js";
+export * from "./model.js";
+export * from "./provider.js";
+export * from "./query-builder.js";
+export * from "./relations/index.js";
+export * from "./scopes.js";
+export * from "./seeder.js";
+export * from "./tokens.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/migration-provider.d.ts

@@ -1,5 +1,15 @@
 import { ServiceProvider } from "@veap/kernel";
+import type { CommandEntry } from "@veap/kernel/cli";
 export declare class MigrationServiceProvider extends ServiceProvider {
+    private migrations?;
+    constructor(container: any, migrations?: any[]);
+    /**
+     * Migration commands, harvested by the console for the host application:
+     * `veap make:migration` scaffolds one, `veap migrate` applies the pending
+     * ones, `veap migrate:status` reports them and `veap migrate:rollback` undoes
+     * the last batch.
+     */
+    commands(): CommandEntry[];
     register(): void;
     boot(): Promise<void>;
 }

package/dist/migration-provider.js

@@ -1,15 +1,59 @@
 import { ServiceProvider } from "@veap/kernel";
-import { runMigrations } from "./migrations/runner";
+import { MakeMigrationCommand } from "./cli/commands/make-migration.js";
+import { MigrateCommand } from "./cli/commands/migrate.js";
+import { MigrateRollbackCommand } from "./cli/commands/migrate-rollback.js";
+import { MigrateStatusCommand } from "./cli/commands/migrate-status.js";
+import { runMigrations } from "./migrations/runner.js";
+import { APP_MIGRATIONS } from "./tokens.js";
 export class MigrationServiceProvider extends ServiceProvider {
+    migrations;
+    constructor(container, migrations) {
+        super(container);
+        this.migrations = migrations;
+    }
+    /**
+     * Migration commands, harvested by the console for the host application:
+     * `veap make:migration` scaffolds one, `veap migrate` applies the pending
+     * ones, `veap migrate:status` reports them and `veap migrate:rollback` undoes
+     * the last batch.
+     */
+    commands() {
+        return [
+            MakeMigrationCommand,
+            MigrateCommand,
+            MigrateStatusCommand,
+            MigrateRollbackCommand,
+        ];
+    }
     register() {
-        // No bindings needed
+        if (this.migrations?.length) {
+            this.container.register({
+                token: APP_MIGRATIONS,
+                useValue: this.migrations,
+            });
+            this.container.register({
+                token: "AppMigrations",
+                useValue: this.migrations,
+            });
+        }
     }
     async boot() {
-        if (this.container.has("AppMigrations")) {
-            const appMigrations = await this.container.resolve("AppMigrations");
-            if (appMigrations?.length) {
-                await runMigrations("app", appMigrations);
+        // Under the console (`VEAP_CLI=1`) migrations are an explicit action: the
+        // `veap migrate` command runs them, and every other command — `list`
+        // included — must leave the database untouched.
+        if (process.env.VEAP_CLI === "1")
+            return;
+        let appMigrations = this.migrations;
+        if (!appMigrations?.length) {
+            if (this.container.has(APP_MIGRATIONS)) {
+                appMigrations = await this.container.resolve(APP_MIGRATIONS);
             }
+            else if (this.container.has("AppMigrations")) {
+                appMigrations = await this.container.resolve("AppMigrations");
+            }
+        }
+        if (appMigrations?.length) {
+            await runMigrations("app", appMigrations);
         }
     }
 }

package/dist/migrations/generator.d.ts

@@ -1,4 +1,13 @@
-export declare function generateMigration(name: string, targetDir?: string): Promise<{
+export interface GeneratedMigration {
+    /** Timestamped file name without the extension, e.g. `20261014120000_create_posts_table`. */
     fileName: string;
+    /** Absolute path of the written migration file. */
     filePath: string;
-}>;
+}
+/**
+ * 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 declare function generateMigration(name: string, targetDir?: string): Promise<GeneratedMigration>;