@zintrust/core 0.1.28 → 0.1.30

package/src/migrations/MigratorFactory.js

@@ -0,0 +1,339 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../config/logger.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import * as path from '../node-singletons/path.js';
+import { MigrationDiscovery } from './MigrationDiscovery.js';
+import { MigrationLoader } from './MigrationLoader.js';
+import { MigrationLock } from './MigrationLock.js';
+import { SqliteMaintenance } from '../orm/maintenance/SqliteMaintenance.js';
+import { MigrationStore } from '../orm/migrations/MigrationStore.js';
+function nowIso() {
+    // MySQL/MariaDB DATETIME does not accept ISO8601 with timezone (e.g. trailing 'Z').
+    // Use a portable UTC datetime string.
+    return new Date().toISOString().slice(0, 19).replace('T', ' ');
+}
+function createCtx(options) {
+    const projectRoot = options.projectRoot;
+    const globalDir = MigrationDiscovery.resolveDir(projectRoot, options.globalDir);
+    const extension = options.extension;
+    const service = typeof options.service === 'string' && options.service.length > 0 ? options.service : null;
+    const separateTracking = options.separateTracking === true;
+    const includeGlobal = options.includeGlobal !== false;
+    const lockFile = options.lockFile ?? path.join(projectRoot, '.zintrust', 'migrate.lock');
+    const serviceDir = service === null
+        ? null
+        : MigrationDiscovery.resolveDir(projectRoot, path.join('services', service, Env.get('MIGRATIONS_SERVICE_DIR', 'database/migrations')));
+    return {
+        options,
+        projectRoot,
+        globalDir,
+        extension,
+        lockFile,
+        separateTracking,
+        includeGlobal,
+        service,
+        serviceDir,
+    };
+}
+function keyForTarget(t) {
+    return `${t.scope}:${t.service}`;
+}
+function getTargets(ctx) {
+    if (!ctx.separateTracking)
+        return [{ scope: 'global', service: '' }];
+    if (ctx.service === null) {
+        return [{ scope: 'global', service: '' }];
+    }
+    const targets = [];
+    // Prefer rolling back service migrations before global ones.
+    targets.push({ scope: 'service', service: ctx.service });
+    if (ctx.includeGlobal)
+        targets.push({ scope: 'global', service: '' });
+    return targets;
+}
+function getTargetForMigration(ctx, migration) {
+    if (!ctx.separateTracking)
+        return { scope: 'global', service: '' };
+    if (ctx.service === null)
+        return { scope: 'global', service: '' };
+    const serviceDir = ctx.serviceDir;
+    if (serviceDir !== null) {
+        const prefix = serviceDir.endsWith(path.sep) ? serviceDir : `${serviceDir}${path.sep}`;
+        if (migration.filePath.startsWith(prefix)) {
+            return { scope: 'service', service: ctx.service };
+        }
+    }
+    return { scope: 'global', service: '' };
+}
+function getMigrationDirs(ctx) {
+    const dirs = [];
+    if (ctx.includeGlobal) {
+        dirs.push(ctx.globalDir);
+    }
+    if (ctx.serviceDir !== null) {
+        dirs.push(ctx.serviceDir);
+    }
+    return dirs;
+}
+async function discover(ctx) {
+    const files = getMigrationDirs(ctx).flatMap((dir) => MigrationDiscovery.listMigrationFiles(dir, ctx.extension));
+    const loaded = [];
+    // Build a serial chain to keep ordering without `await` inside a loop.
+    let chain = Promise.resolve();
+    for (const file of files) {
+        chain = chain.then(async () => {
+            loaded.push(await MigrationLoader.load(file));
+        });
+    }
+    await chain;
+    return loaded.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function runSerial(items, fn) {
+    let chain = Promise.resolve();
+    for (const item of items) {
+        chain = chain.then(async () => fn(item));
+    }
+    await chain;
+}
+async function withLock(ctx, fn) {
+    const release = MigrationLock.acquire(ctx.lockFile);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}
+async function applyOneMigration(params) {
+    const { db, migration, scope, service, batch } = params;
+    await MigrationStore.insertRunning(db, {
+        name: migration.name,
+        scope,
+        service,
+        batch,
+    });
+    try {
+        await db.transaction(async () => {
+            await migration.up(db);
+            await MigrationStore.markStatus(db, {
+                name: migration.name,
+                scope,
+                service,
+                status: 'completed',
+                appliedAt: nowIso(),
+            });
+        });
+    }
+    catch (error) {
+        await MigrationStore.markStatus(db, {
+            name: migration.name,
+            scope,
+            service,
+            status: 'failed',
+        });
+        Logger.error('Migration failed', { migration: migration.name, error });
+        throw error;
+    }
+}
+async function rollbackOneMigration(params) {
+    const { db, name, migrationMap, scope, service, errorLabel } = params;
+    const m = migrationMap.get(name);
+    if (m === undefined) {
+        const label = errorLabel === 'rollback' ? 'rollback' : 'reset';
+        throw ErrorFactory.createCliError(`Cannot ${label} '${name}' because its migration file is missing.`);
+    }
+    await db.transaction(async () => {
+        await m.down(db);
+        await MigrationStore.deleteRecord(db, { name, scope, service });
+    });
+}
+async function rollbackTargetBatch(params) {
+    const { db, target, migrationMap, count } = params;
+    const last = await MigrationStore.getLastCompletedBatch(db, target.scope, target.service);
+    if (last <= 0)
+        return 0;
+    const targetMinBatch = Math.max(1, last - count + 1);
+    const rows = await MigrationStore.listCompletedInBatchesGte(db, {
+        scope: target.scope,
+        service: target.service,
+        minBatch: targetMinBatch,
+    });
+    const appliedNames = rows.map((r) => r.name);
+    if (appliedNames.length === 0)
+        return 0;
+    let rolledBack = 0;
+    await runSerial(appliedNames, async (name) => {
+        await rollbackOneMigration({
+            db,
+            name,
+            migrationMap,
+            scope: target.scope,
+            service: target.service,
+            errorLabel: 'rollback',
+        });
+        rolledBack++;
+    });
+    return rolledBack;
+}
+async function resetTarget(params) {
+    const { db, target, migrationMap } = params;
+    const names = await MigrationStore.listAllCompletedNames(db, {
+        scope: target.scope,
+        service: target.service,
+    });
+    if (names.length === 0)
+        return 0;
+    let rolledBack = 0;
+    await runSerial(names, async (name) => {
+        await rollbackOneMigration({
+            db,
+            name,
+            migrationMap,
+            scope: target.scope,
+            service: target.service,
+            errorLabel: 'reset',
+        });
+        rolledBack++;
+    });
+    return rolledBack;
+}
+async function applyPendingMigrations(ctx, db, migrations) {
+    const targets = getTargets(ctx);
+    const appliedByTarget = new Map();
+    const batchByTarget = new Map();
+    await Promise.all(targets.map(async (t) => {
+        const key = keyForTarget(t);
+        appliedByTarget.set(key, await MigrationStore.getAppliedMap(db, t.scope, t.service));
+        batchByTarget.set(key, (await MigrationStore.getLastCompletedBatch(db, t.scope, t.service)) + 1);
+    }));
+    const pending = migrations.filter((m) => {
+        const target = getTargetForMigration(ctx, m);
+        const appliedMap = appliedByTarget.get(keyForTarget(target));
+        const row = appliedMap?.get(m.name);
+        if (row?.status === 'completed')
+            return false;
+        // Check for collision with existing migrations (same identifying suffix)
+        // This allows multiple projects to share a DB without re-running shared migrations
+        // Use \d+ to support variable timestamp length (default 14, but robust to 15+)
+        const match = new RegExp(/^(\d{14,})(_.+)$/).exec(m.name);
+        if (match && appliedMap) {
+            const suffix = match[2];
+            for (const appliedName of appliedMap.keys()) {
+                if (appliedName !== m.name && appliedName.endsWith(suffix)) {
+                    Logger.info(`Skipping migration '${m.name}' — migration '${appliedName}' with the same suffix ('${suffix}') has already been applied`);
+                    return false;
+                }
+            }
+        }
+        return true;
+    });
+    if (pending.length === 0)
+        return { applied: 0, pending: 0, appliedNames: [] };
+    let appliedCount = 0;
+    const appliedNames = [];
+    await runSerial(pending, async (m) => {
+        const target = getTargetForMigration(ctx, m);
+        const batch = batchByTarget.get(keyForTarget(target)) ?? 1;
+        await applyOneMigration({
+            db,
+            migration: m,
+            scope: target.scope,
+            service: target.service,
+            batch,
+        });
+        appliedCount++;
+        appliedNames.push(m.name);
+    });
+    return { applied: appliedCount, pending: pending.length - appliedCount, appliedNames };
+}
+function buildStatus(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        await MigrationStore.ensureTable(db);
+        const migrations = await discover(ctx);
+        const targets = getTargets(ctx);
+        const appliedByTarget = new Map();
+        await Promise.all(targets.map(async (t) => {
+            appliedByTarget.set(keyForTarget(t), await MigrationStore.getAppliedMap(db, t.scope, t.service));
+        }));
+        return migrations.map((m) => {
+            const target = getTargetForMigration(ctx, m);
+            const row = appliedByTarget.get(keyForTarget(target))?.get(m.name);
+            return {
+                name: m.name,
+                applied: row?.status === 'completed',
+                batch: typeof row?.batch === 'number' ? row.batch : null,
+                status: typeof row?.status === 'string' ? row.status : null,
+                appliedAt: typeof row?.appliedAt === 'string' ? row.appliedAt : null,
+            };
+        });
+    };
+}
+function buildMigrate(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            await MigrationStore.ensureTable(db);
+            const migrations = await discover(ctx);
+            return applyPendingMigrations(ctx, db, migrations);
+        });
+    };
+}
+function buildRollback(ctx) {
+    return async (steps) => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            await MigrationStore.ensureTable(db);
+            const targets = getTargets(ctx);
+            const count = Math.max(1, steps);
+            const discovered = await discover(ctx);
+            const migrationMap = new Map(discovered.map((m) => [m.name, m]));
+            let rolledBack = 0;
+            await runSerial(targets, async (target) => {
+                rolledBack += await rollbackTargetBatch({ db, target, migrationMap, count });
+            });
+            return { rolledBack };
+        });
+    };
+}
+function buildReset(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            await MigrationStore.ensureTable(db);
+            const targets = getTargets(ctx);
+            const discovered = await discover(ctx);
+            const migrationMap = new Map(discovered.map((m) => [m.name, m]));
+            let rolledBack = 0;
+            await runSerial(targets, async (target) => {
+                rolledBack += await resetTarget({ db, target, migrationMap });
+            });
+            return { rolledBack };
+        });
+    };
+}
+function buildFresh(ctx) {
+    return async () => {
+        const db = ctx.options.db;
+        return withLock(ctx, async () => {
+            if (db.getType() === 'sqlite') {
+                await SqliteMaintenance.dropAllTables(db);
+            }
+            await MigrationStore.ensureTable(db);
+            const migrations = await discover(ctx);
+            return applyPendingMigrations(ctx, db, migrations);
+        });
+    };
+}
+export const MigratorFactory = Object.freeze({
+    create(options) {
+        const ctx = createCtx(options);
+        return {
+            status: buildStatus(ctx),
+            migrate: buildMigrate(ctx),
+            rollbackLastBatch: buildRollback(ctx),
+            resetAll: buildReset(ctx),
+            fresh: buildFresh(ctx),
+        };
+    },
+});

package/src/migrations/enum/index.d.ts

@@ -0,0 +1,93 @@
+export declare const ColumnType: {
+    readonly STRING: "STRING";
+    readonly INTEGER: "INTEGER";
+    readonly BIGINT: "BIGINT";
+    readonly UUID: "UUID";
+    readonly REAL: "REAL";
+    readonly BOOLEAN: "BOOLEAN";
+    readonly TEXT: "TEXT";
+    readonly JSON: "JSON";
+    readonly TIMESTAMP: "TIMESTAMP";
+    readonly BLOB: "BLOB";
+    readonly VARCHAR: "VARCHAR";
+    readonly INT: "INT";
+    readonly FLOAT: "FLOAT";
+    readonly TINYINT_1: "TINYINT(1)";
+    readonly TINYINT: "TINYINT";
+    readonly JSONB: "JSONB";
+    readonly DATETIME: "DATETIME";
+    readonly BYTEA: "BYTEA";
+    readonly FOREIGN_KEY: "FOREIGN_KEY";
+    readonly NORMAL: "NORMAL";
+    readonly UNIQUE: "UNIQUE";
+    readonly NON_UNIQUE: "NON_UNIQUE";
+    readonly ADD_COLUMN: "ADD_COLUMN";
+    readonly DROP_COLUMN: "DROP_COLUMN";
+    readonly CREATE_INDEX: "CREATE_INDEX";
+    readonly DROP_INDEX: "DROP_INDEX";
+    readonly ADD_FOREIGN_KEY: "ADD_FOREIGN_KEY";
+    readonly DROP_FOREIGN_KEY: "DROP_FOREIGN_KEY";
+    readonly SERIAL: "SERIAL";
+    readonly IDENTITY: "IDENTITY";
+    readonly AUTOINCREMENT: "AUTOINCREMENT";
+    readonly CURRENT_TIMESTAMP: "CURRENT_TIMESTAMP";
+    readonly NULLABLE: "NULLABLE";
+    readonly NOT_NULLABLE: "NOT_NULLABLE";
+    readonly SQL: "SQL";
+    readonly UNSIGNED: "UNSIGNED";
+    readonly CASCADE: "CASCADE";
+    readonly SETNULL: "SET NULL";
+    readonly RESTRICT: "RESTRICT";
+    readonly NOACTION: "NO ACTION";
+    readonly SETDEFAULT: "SET DEFAULT";
+    readonly BIGSERIAL: "BIGSERIAL";
+    readonly AUTO_INCREMENT: "AUTO_INCREMENT";
+    readonly IDENTITY_1_1: "IDENTITY(1,1)";
+    readonly NOT_NULL: "NOT NULL";
+    readonly PRIMARY_KEY: "PRIMARY KEY";
+    readonly DEFAULT_NULL: "DEFAULT NULL";
+    readonly INDEX: "INDEX";
+    readonly IF_EXISTS: "IF EXISTS";
+    readonly IF_NOT_EXISTS: "IF NOT EXISTS";
+    readonly CONSTRAINT: "CONSTRAINT";
+    readonly FOREIGN_KEY_S: "FOREIGN KEY";
+    readonly DROP_COLUMN_S: "DROP COLUMN";
+    readonly ADD_COLUMN_S: "ADD COLUMN";
+    readonly DROP_INDEX_S: "DROP INDEX";
+    readonly DROP_TABLE_S: "DROP TABLE";
+    readonly ALTER_TABLE_S: "ALTER TABLE";
+    readonly CREATE_INDEX_S: "CREATE INDEX";
+    readonly CREATE_TABLE_S: "CREATE TABLE";
+    readonly REFERENCES: "REFERENCES";
+    readonly ON_DELETE: "ON DELETE";
+    readonly ON_UPDATE: "ON UPDATE";
+    readonly ON: "ON";
+    readonly ADD: "ADD";
+    readonly DROP: "DROP";
+};
+export declare const AdaptersEnum: {
+    readonly mysql: "mysql";
+    readonly postgresql: "postgresql";
+    readonly sqlite: "sqlite";
+    readonly d1: "d1";
+    readonly d1Remote: "d1-remote";
+    readonly sqlserver: "sqlserver";
+    readonly auroraDataApi: "aurora-data-api";
+};
+export declare const SchOther: {
+    readonly TYPE: "type";
+    readonly NUMBER: "number";
+    readonly TABLE: "table";
+    readonly COLUMN: "column";
+    readonly FOREIGN_KEY: "foreign key";
+    readonly REFERENCED_TABLE: "referenced table";
+    readonly REFERENCED_COLUMN: "referenced column";
+    readonly INDEX: "index";
+    readonly CREATED_AT: "created_at";
+    readonly UPDATED_AT: "updated_at";
+    readonly ID: "id";
+};
+export type SupportedDriverK = keyof typeof AdaptersEnum;
+export type SupportedDriver = typeof AdaptersEnum.sqlite | typeof AdaptersEnum.d1 | typeof AdaptersEnum.d1Remote | typeof AdaptersEnum.postgresql | typeof AdaptersEnum.mysql | typeof AdaptersEnum.sqlserver | typeof AdaptersEnum.auroraDataApi;
+export declare function isSqliteFamily(driver: SupportedDriver): boolean;
+//# sourceMappingURL=index.d.ts.map

package/src/migrations/enum/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/migrations/enum/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwEb,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;;;CAQf,CAAC;AAEX,eAAO,MAAM,QAAQ;;;;;;;;;;;;CAYX,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,YAAY,CAAC;AAEzD,MAAM,MAAM,eAAe,GACvB,OAAO,YAAY,CAAC,MAAM,GAC1B,OAAO,YAAY,CAAC,EAAE,GACtB,OAAO,YAAY,CAAC,QAAQ,GAC5B,OAAO,YAAY,CAAC,UAAU,GAC9B,OAAO,YAAY,CAAC,KAAK,GACzB,OAAO,YAAY,CAAC,SAAS,GAC7B,OAAO,YAAY,CAAC,aAAa,CAAC;AAEtC,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAI/D"}

package/src/migrations/enum/index.js

@@ -0,0 +1,92 @@
+export const ColumnType = {
+    STRING: 'STRING',
+    INTEGER: 'INTEGER',
+    BIGINT: 'BIGINT',
+    UUID: 'UUID',
+    REAL: 'REAL',
+    BOOLEAN: 'BOOLEAN',
+    TEXT: 'TEXT',
+    JSON: 'JSON',
+    TIMESTAMP: 'TIMESTAMP',
+    BLOB: 'BLOB',
+    VARCHAR: 'VARCHAR',
+    INT: 'INT',
+    FLOAT: 'FLOAT',
+    TINYINT_1: 'TINYINT(1)',
+    TINYINT: 'TINYINT',
+    JSONB: 'JSONB',
+    DATETIME: 'DATETIME',
+    BYTEA: 'BYTEA',
+    FOREIGN_KEY: 'FOREIGN_KEY',
+    NORMAL: 'NORMAL',
+    UNIQUE: 'UNIQUE',
+    NON_UNIQUE: 'NON_UNIQUE',
+    ADD_COLUMN: 'ADD_COLUMN',
+    DROP_COLUMN: 'DROP_COLUMN',
+    CREATE_INDEX: 'CREATE_INDEX',
+    DROP_INDEX: 'DROP_INDEX',
+    ADD_FOREIGN_KEY: 'ADD_FOREIGN_KEY',
+    DROP_FOREIGN_KEY: 'DROP_FOREIGN_KEY',
+    SERIAL: 'SERIAL',
+    IDENTITY: 'IDENTITY',
+    AUTOINCREMENT: 'AUTOINCREMENT',
+    CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP',
+    NULLABLE: 'NULLABLE',
+    NOT_NULLABLE: 'NOT_NULLABLE',
+    SQL: 'SQL',
+    UNSIGNED: 'UNSIGNED',
+    CASCADE: 'CASCADE',
+    SETNULL: 'SET NULL',
+    RESTRICT: 'RESTRICT',
+    NOACTION: 'NO ACTION',
+    SETDEFAULT: 'SET DEFAULT',
+    BIGSERIAL: 'BIGSERIAL',
+    AUTO_INCREMENT: 'AUTO_INCREMENT',
+    IDENTITY_1_1: 'IDENTITY(1,1)',
+    NOT_NULL: 'NOT NULL',
+    PRIMARY_KEY: 'PRIMARY KEY',
+    DEFAULT_NULL: 'DEFAULT NULL',
+    INDEX: 'INDEX',
+    IF_EXISTS: 'IF EXISTS',
+    IF_NOT_EXISTS: 'IF NOT EXISTS',
+    CONSTRAINT: 'CONSTRAINT',
+    FOREIGN_KEY_S: 'FOREIGN KEY',
+    DROP_COLUMN_S: 'DROP COLUMN',
+    ADD_COLUMN_S: 'ADD COLUMN',
+    DROP_INDEX_S: 'DROP INDEX',
+    DROP_TABLE_S: 'DROP TABLE',
+    ALTER_TABLE_S: 'ALTER TABLE',
+    CREATE_INDEX_S: 'CREATE INDEX',
+    CREATE_TABLE_S: 'CREATE TABLE',
+    REFERENCES: 'REFERENCES',
+    ON_DELETE: 'ON DELETE',
+    ON_UPDATE: 'ON UPDATE',
+    ON: 'ON',
+    ADD: 'ADD',
+    DROP: 'DROP',
+};
+export const AdaptersEnum = {
+    mysql: 'mysql',
+    postgresql: 'postgresql',
+    sqlite: 'sqlite',
+    d1: 'd1',
+    d1Remote: 'd1-remote',
+    sqlserver: 'sqlserver',
+    auroraDataApi: 'aurora-data-api',
+};
+export const SchOther = {
+    TYPE: 'type',
+    NUMBER: 'number',
+    TABLE: 'table',
+    COLUMN: 'column',
+    FOREIGN_KEY: 'foreign key',
+    REFERENCED_TABLE: 'referenced table',
+    REFERENCED_COLUMN: 'referenced column',
+    INDEX: 'index',
+    CREATED_AT: 'created_at',
+    UPDATED_AT: 'updated_at',
+    ID: 'id',
+};
+export function isSqliteFamily(driver) {
+    return (driver === AdaptersEnum.sqlite || driver === AdaptersEnum.d1 || driver === AdaptersEnum.d1Remote);
+}

package/src/migrations/schema/Blueprint.d.ts

@@ -0,0 +1,5 @@
+import type { Blueprint } from '../schema/types';
+export declare const MigrationBlueprint: Readonly<{
+    create(tableName: string): Blueprint;
+}>;
+//# sourceMappingURL=Blueprint.d.ts.map

package/src/migrations/schema/Blueprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Blueprint.d.ts","sourceRoot":"","sources":["../../../../src/migrations/schema/Blueprint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,SAAS,EASV,MAAM,0BAA0B,CAAC;AA2NlC,eAAO,MAAM,kBAAkB;sBACX,MAAM,GAAG,SAAS;EAMpC,CAAC"}