@zintrust/core 0.1.27 → 0.1.28

package/src/migrations/MigratorFactory.js

@@ -1,339 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,92 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}