@decaf-ts/core 0.12.0 → 0.13.0

package/lib/migrations/MigrationService.cjs

@@ -9,12 +9,50 @@ const errors_1 = require("./../persistence/errors.cjs");
 const logging_1 = require("@decaf-ts/logging");
 const decoration_1 = require("@decaf-ts/decoration");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
+const MigrationTaskBuilder_1 = require("./MigrationTaskBuilder.cjs");
+const TaskModel_1 = require("./../tasks/models/TaskModel.cjs");
+const StandardMigrationVersioning_1 = require("./StandardMigrationVersioning.cjs");
+const constants_3 = require("./../tasks/constants.cjs");
 class MigrationService extends services_1.ClientBasedService {
     constructor() {
         super();
+        this.versioning = new StandardMigrationVersioning_1.StandardMigrationVersioning();
+        this.queuedTaskChain = [];
         this.reference = MigrationService.name;
         this.precedence = null;
     }
+    static async migrateAdapters(adapters, cfg = {}, ...args) {
+        const flavours = cfg.flavours?.length ? new Set(cfg.flavours) : undefined;
+        const selected = adapters.filter((adapter) => !flavours || flavours.has(adapter.flavour));
+        const migratingAliases = new Set(adapters.map((adapter) => adapter.alias || adapter.flavour).filter(Boolean));
+        const taskEngineClient = cfg.taskService?.client;
+        const taskServiceAdapterAlias = taskEngineClient?.adapter?.alias || taskEngineClient?.adapter?.flavour;
+        if (taskServiceAdapterAlias &&
+            migratingAliases.has(taskServiceAdapterAlias)) {
+            throw new db_decorators_1.InternalError(`TaskEngine adapter alias "${taskServiceAdapterAlias}" cannot participate in the migration targets`);
+        }
+        const services = [];
+        for (const adapter of selected) {
+            const handlers = cfg.handlers?.[adapter.flavour] || {};
+            const migrationService = new MigrationService();
+            services.push(migrationService);
+            await migrationService.boot({
+                persistenceFlavour: adapter.flavour,
+                targetVersion: cfg.toVersion,
+                taskMode: !!cfg.taskMode,
+                // In multi-adapter task mode, run flavour-scoped migrations only.
+                includeGenericInTaskMode: !(cfg.taskMode && selected.length > 1),
+                retrieveLastVersion: handlers.retrieveLastVersion,
+                setCurrentVersion: handlers.setCurrentVersion,
+                taskService: cfg.taskService,
+            });
+            if (cfg.taskMode)
+                await migrationService.migrateViaTasks(undefined, undefined, ...args);
+            else
+                await migrationService.migrateNormally(undefined, undefined, ...args);
+        }
+        return services;
+    }
     async initialize(...args) {
         const { log, ctx } = (await this.logCtx(args, constants_2.PersistenceKeys.INITIALIZATION, true)).for(this.initialize);
         try {
@@ -27,134 +65,435 @@ class MigrationService extends services_1.ClientBasedService {
                 log.warn(`Persistence service not available. this may indicate poor initialization of the persistence layer (or not)`);
         }
         const cfg = Object.assign({}, args.length ? args[0] : constants_1.DefaultMigrationConfig, constants_1.DefaultMigrationConfig);
+        this.versioning = cfg.versioning || new StandardMigrationVersioning_1.StandardMigrationVersioning();
         this.transaction = cfg.persistMigrationSteps;
         return {
             config: cfg,
-            client: Adapter_1.Adapter.get(cfg.persistenceFlavour),
+            client: (cfg.persistenceFlavour
+                ? Adapter_1.Adapter.get(cfg.persistenceFlavour)
+                : undefined),
         };
     }
     async down(qr, adapter, ...args) {
         const { log } = this.logCtx(args, this.down);
         log.verbose((0, logging_1.style)("Cleaning up after all migrations").green.bold);
     }
+    normalizeVersion(raw, precedenceHint) {
+        return this.versioning.normalize(raw, precedenceHint);
+    }
+    extractPrecedenceTokens(migration) {
+        const precedence = migration.precedence;
+        if (!precedence)
+            return [];
+        const list = Array.isArray(precedence) ? precedence : [precedence];
+        return list
+            .map((entry) => {
+            if (!entry)
+                return undefined;
+            if (typeof entry === "string")
+                return undefined;
+            if (typeof entry === "function")
+                return entry.name;
+            if (typeof entry.reference === "string")
+                return entry.reference;
+            if (entry.constructor?.name)
+                return entry.constructor.name;
+            return undefined;
+        })
+            .filter((entry) => !!entry);
+    }
+    referencesMigration(candidate, target) {
+        const tokens = this.extractPrecedenceTokens(candidate);
+        if (!tokens.length)
+            return false;
+        return (tokens.includes(target.reference) ||
+            tokens.includes(target.migration?.constructor?.name));
+    }
+    precedenceHint(migration) {
+        return typeof migration.precedence === "string"
+            ? migration.precedence
+            : undefined;
+    }
+    compareByPrecedence(migration1, migration2) {
+        const m1 = migration1.migration;
+        const m2 = migration2.migration;
+        const m1ReferencesM2 = this.referencesMigration(m1, migration2);
+        const m2ReferencesM1 = this.referencesMigration(m2, migration1);
+        if (m1ReferencesM2 && !m2ReferencesM1)
+            return 1;
+        if (m2ReferencesM1 && !m1ReferencesM2)
+            return -1;
+        const p1 = this.extractPrecedenceTokens(m1);
+        const p2 = this.extractPrecedenceTokens(m2);
+        if (p1.length !== p2.length)
+            return p1.length - p2.length;
+        return 0;
+    }
     sort(migrations) {
-        return migrations.sort((migration1, migration2) => {
-            if (!migration1.precedence && !migration2.precedence)
-                throw new db_decorators_1.InternalError(`Only one migration can have a null precedence: ${migration1.reference} vs ${migration2.reference}`);
-            if (!migration1.precedence)
-                return 1;
-            if (!migration2.precedence)
-                return -1;
-            const precedences1 = Array.isArray(migration1.precedence)
-                ? migration1.precedence
-                : [migration1];
-            const precedences2 = Array.isArray(migration2.precedence)
-                ? migration2.precedence
-                : [migration2];
-            const includes1 = precedences1.every((p) => p === migration2);
-            const includes2 = precedences2.every((p) => p === migration1);
-            // sort when they reference each other
-            if (includes1 && !includes2)
-                return 1;
-            if (includes2 && !includes1)
-                return -1;
-            const anyNotIncluded1 = precedences1.find((p) => !precedences2.includes(p));
-            const allIncluded1 = precedences1.every((p) => precedences2.includes(p));
-            const anyNotIncluded2 = precedences2.find((p) => !precedences1.includes(p));
-            const allIncluded2 = precedences2.every((p) => precedences1.includes(p));
-            // solve all differences
-            if (anyNotIncluded1 && !anyNotIncluded2 && !allIncluded1 && !allIncluded2)
-                return 1;
-            if (!anyNotIncluded1 && anyNotIncluded2 && !allIncluded1 && !allIncluded2)
-                return -1;
-            if (!anyNotIncluded1 && !anyNotIncluded2 && allIncluded1 && !allIncluded2)
-                return -1;
-            if (!anyNotIncluded1 && !anyNotIncluded2 && !allIncluded1 && allIncluded2)
-                return 1;
-            if (!anyNotIncluded1 && !anyNotIncluded2 && allIncluded1 && !allIncluded2)
-                return -1;
-            if (!anyNotIncluded1 && !anyNotIncluded2 && !allIncluded1 && allIncluded2)
-                return 1;
-            if (!anyNotIncluded1 && anyNotIncluded2 && !allIncluded1 && !allIncluded2)
-                return 1;
-            if (!anyNotIncluded1 &&
-                !anyNotIncluded2 &&
-                !allIncluded1 &&
-                !allIncluded2)
-                return -1;
-            const size1 = precedences1.length;
-            const size2 = precedences2.length;
-            const res = size1 - size2;
-            if (res === 0) {
-                if (migration1.reference === migration2.reference)
-                    throw new db_decorators_1.InternalError(`Unable to sort migration precedence between ${migration1.reference} and ${migration2.reference}. should not be possible`);
-                return migration1.reference.localeCompare(migration2.reference);
-            }
-            return res;
+        const sorted = [...migrations].sort((migration1, migration2) => {
+            const semverDelta = this.versioning.compare(migration1.version, migration2.version);
+            if (semverDelta !== 0)
+                return semverDelta;
+            const precedenceDelta = this.compareByPrecedence(migration1, migration2);
+            if (precedenceDelta !== 0)
+                return precedenceDelta;
+            const flavourDelta = migration1.flavour.localeCompare(migration2.flavour);
+            if (flavourDelta !== 0)
+                return flavourDelta;
+            return migration1.reference.localeCompare(migration2.reference);
         });
+        for (let i = 0; i < sorted.length; i++) {
+            const left = sorted[i];
+            const right = sorted[i + 1];
+            if (!left || !right)
+                continue;
+            if (left.version !== right.version || left.flavour !== right.flavour)
+                continue;
+            if (this.compareByPrecedence(left, right) !== 0)
+                continue;
+            throw new db_decorators_1.InternalError(`Unable to deterministically sort flavour migrations for version ${left.version} and flavour ${left.flavour}: ${left.reference} vs ${right.reference}`);
+        }
+        return sorted;
     }
-    async migrate(qr, adapter, ...args) {
-        const { ctxArgs, log } = (await this.logCtx(args, constants_2.PersistenceKeys.MIGRATION, true)).for(this.migrate);
-        let m;
+    resolveMigration(migration) {
+        const meta = decoration_1.Metadata.get(migration.constructor, constants_2.PersistenceKeys.MIGRATION);
+        const flavour = meta?.flavour || migration.flavour || decoration_1.DefaultFlavour;
+        const reference = meta?.reference || migration.reference;
+        const precedenceHint = this.precedenceHint(migration);
+        return {
+            migration,
+            flavour,
+            reference,
+            version: this.normalizeVersion(reference, precedenceHint),
+        };
+    }
+    shouldIncludeMigration(migration, targetFlavour, includeGeneric = true) {
+        if (!targetFlavour)
+            return true;
+        if (migration.flavour === targetFlavour)
+            return true;
+        return includeGeneric && migration.flavour === decoration_1.DefaultFlavour;
+    }
+    collectMigrations(targetFlavour, includeGeneric = true) {
         const toBoot = decoration_1.Metadata.migrations();
         const migrations = [];
-        for (const [reference, mig] of toBoot) {
+        for (const [reference, MigrationClass] of toBoot) {
+            let migration;
             try {
-                log.silly(`loading migration ${reference}...`);
-                m = new mig();
-                log.verbose(`migration ${m.reference} instantiated`, 1);
+                migration = new MigrationClass();
             }
             catch (e) {
-                throw new db_decorators_1.InternalError(`failed to create migration ${mig.name}: ${e}`);
+                throw new db_decorators_1.InternalError(`failed to create migration ${reference}: ${e}`);
             }
-            migrations.push(m);
+            const resolved = this.resolveMigration(migration);
+            if (!this.shouldIncludeMigration(resolved, targetFlavour, includeGeneric))
+                continue;
+            migrations.push(resolved);
+        }
+        return migrations;
+    }
+    buildExecutionPlan(options) {
+        const fromVersion = options?.fromVersion
+            ? this.normalizeVersion(options.fromVersion)
+            : undefined;
+        const toVersion = options?.toVersion
+            ? this.normalizeVersion(options.toVersion)
+            : undefined;
+        const migrations = this.sort(this.collectMigrations(options?.targetFlavour, options?.includeGeneric));
+        return migrations.filter((migration) => {
+            if (fromVersion && !this.versioning.gt(migration.version, fromVersion))
+                return false;
+            if (toVersion && !this.versioning.lte(migration.version, toVersion))
+                return false;
+            return true;
+        });
+    }
+    async executeMigration(migration, ...args) {
+        const m = migration.migration;
+        let adapter;
+        let qr;
+        try {
+            adapter = Adapter_1.Adapter.get(migration.flavour);
+            if (!adapter)
+                throw new db_decorators_1.InternalError(`failed to create migration ${m.reference}. did you call Service.boot() or use the Persistence Service??`);
+            qr = adapter.client;
+        }
+        catch (e) {
+            throw new db_decorators_1.InternalError(`Failed to load adapter to migrate ${m.reference}: ${e}`);
         }
-        let sortedMigrations;
         try {
-            sortedMigrations = this.sort(migrations);
+            await m.up(qr, adapter, ...args);
         }
         catch (e) {
-            throw new db_decorators_1.InternalError(`Failed to sort migrations: ${e}`);
+            throw new errors_1.MigrationError(`failed to initialize migration ${m.reference}: ${e}`);
         }
-        log.debug(`sorted migration before execution: ${sortedMigrations.map((s) => s.reference)}`);
-        for (const m of sortedMigrations) {
-            let adapter;
-            let qr;
-            try {
-                const meta = decoration_1.Metadata.get(m.constructor, constants_2.PersistenceKeys.MIGRATION);
-                const flavour = meta?.flavour || m.flavour;
-                adapter = Adapter_1.Adapter.get(flavour);
-                if (!adapter)
-                    throw new db_decorators_1.InternalError(`failed to create migration ${m.reference}. did you call Service.boot() or use the Persistence Service??`);
-                qr = adapter.client;
-            }
-            catch (e) {
-                throw new db_decorators_1.InternalError(`Failed to load adapter to migrate ${m.reference}: ${e}`);
-            }
-            try {
-                await m.up(qr, adapter, ...ctxArgs);
-            }
-            catch (e) {
-                throw new errors_1.MigrationError(`failed to initialize migration ${m.reference}: ${e}`);
-            }
-            try {
-                await m.migrate(qr, adapter, ...ctxArgs);
-            }
-            catch (e) {
-                throw new errors_1.MigrationError(`failed to migrate ${m.reference}: ${e}`);
-            }
-            try {
-                await m.down(qr, adapter, ...ctxArgs);
+        try {
+            await m.migrate(qr, adapter, ...args);
+        }
+        catch (e) {
+            throw new errors_1.MigrationError(`failed to migrate ${m.reference}: ${e}`);
+        }
+        try {
+            await m.down(qr, adapter, ...args);
+        }
+        catch (e) {
+            throw new errors_1.MigrationError(`failed to conclude migration ${m.reference}: ${e}`);
+        }
+    }
+    buildMigrationTaskForPlan(plan, ...args) {
+        const stepArgs = [...args];
+        const builder = new MigrationTaskBuilder_1.MigrationTaskBuilder();
+        plan.forEach((migration) => {
+            const input = {
+                reference: migration.reference,
+                args: stepArgs,
+            };
+            builder.addMigrationStep(input);
+        });
+        return builder.build();
+    }
+    buildMigrationTasksForPlan(plan, ...args) {
+        const byVersion = new Map();
+        for (const migration of plan) {
+            const current = byVersion.get(migration.version) || [];
+            current.push(migration);
+            byVersion.set(migration.version, current);
+        }
+        return [...byVersion.entries()].map(([version, migrations]) => ({
+            version,
+            task: this.buildMigrationTaskForPlan(migrations, ...args),
+        }));
+    }
+    createMigrationTask(targetVersion, fromVersion, ...args) {
+        const cfg = this.config;
+        const taskMode = cfg.taskMode ?? false;
+        const includeGeneric = taskMode
+            ? cfg.includeGenericInTaskMode ?? true
+            : true;
+        const plan = this.buildExecutionPlan({
+            toVersion: targetVersion || cfg.targetVersion,
+            fromVersion,
+            targetFlavour: cfg.persistenceFlavour,
+            includeGeneric,
+        });
+        return this.buildMigrationTaskForPlan(plan, ...args);
+    }
+    createMigrationTasks(targetVersion, fromVersion, ...args) {
+        const cfg = this.config;
+        const taskMode = cfg.taskMode ?? false;
+        const includeGeneric = taskMode
+            ? cfg.includeGenericInTaskMode ?? true
+            : true;
+        const plan = this.buildExecutionPlan({
+            toVersion: targetVersion || cfg.targetVersion,
+            fromVersion,
+            targetFlavour: cfg.persistenceFlavour,
+            includeGeneric,
+        });
+        return this.buildMigrationTasksForPlan(plan, ...args);
+    }
+    migrationTaskIdsFromContext(taskKey, args) {
+        const last = args[args.length - 1];
+        const pending = last?.pending?.() || last?.pending || {};
+        const values = pending?.[taskKey];
+        if (!Array.isArray(values))
+            return [];
+        return values.filter((value) => typeof value === "string");
+    }
+    async migrate(qr, adapter, ...args) {
+        void qr;
+        void adapter;
+        if (this.config.taskMode)
+            await this.migrateViaTasks(undefined, undefined, ...args);
+        else
+            await this.migrateNormally(undefined, undefined, ...args);
+        return undefined;
+    }
+    async migrateNormally(qr, adapter, ...args) {
+        const { ctxArgs, log } = (await this.logCtx(args, constants_2.PersistenceKeys.MIGRATION, true)).for(this.migrateNormally);
+        void qr;
+        void adapter;
+        const cfg = this.config;
+        const targetFlavour = cfg.persistenceFlavour;
+        const includeGeneric = cfg.taskMode
+            ? cfg.includeGenericInTaskMode ?? true
+            : true;
+        const scopedAdapter = targetFlavour
+            ? Adapter_1.Adapter.get(targetFlavour)
+            : undefined;
+        let currentVersion;
+        if (cfg.retrieveLastVersion && scopedAdapter) {
+            const retrieved = await cfg.retrieveLastVersion(scopedAdapter, ...ctxArgs);
+            if (retrieved)
+                currentVersion = this.normalizeVersion(retrieved);
+        }
+        const plan = this.buildExecutionPlan({
+            fromVersion: currentVersion,
+            toVersion: cfg.targetVersion,
+            targetFlavour,
+            includeGeneric,
+        });
+        log.debug(`sorted migration before execution: ${plan.map((s) => `${s.reference}@${s.version}`)}`);
+        for (const migration of plan) {
+            await this.executeMigration(migration, ...ctxArgs);
+        }
+        if (cfg.setCurrentVersion && scopedAdapter) {
+            const finalVersion = cfg.targetVersion ||
+                plan[plan.length - 1]?.version ||
+                currentVersion ||
+                undefined;
+            if (finalVersion)
+                await cfg.setCurrentVersion(this.normalizeVersion(finalVersion), scopedAdapter, ...ctxArgs);
+        }
+        return undefined;
+    }
+    async migrateViaTasks(qr, adapter, ...args) {
+        const { ctx, ctxArgs, log } = (await this.logCtx(args, constants_2.PersistenceKeys.MIGRATION, true)).for(this.migrateViaTasks);
+        void qr;
+        void adapter;
+        const cfg = this.config;
+        const targetFlavour = cfg.persistenceFlavour;
+        const includeGeneric = cfg.includeGenericInTaskMode ?? true;
+        const scopedAdapter = targetFlavour
+            ? Adapter_1.Adapter.get(targetFlavour)
+            : undefined;
+        let currentVersion;
+        if (cfg.retrieveLastVersion && scopedAdapter) {
+            const retrieved = await cfg.retrieveLastVersion(scopedAdapter, ...ctxArgs);
+            if (retrieved)
+                currentVersion = this.normalizeVersion(retrieved);
+        }
+        const plan = this.buildExecutionPlan({
+            fromVersion: currentVersion,
+            toVersion: cfg.targetVersion,
+            targetFlavour,
+            includeGeneric,
+        });
+        log.debug(`sorted migration before execution: ${plan.map((s) => `${s.reference}@${s.version}`)}`);
+        this.queuedTaskChain = [];
+        if (plan.length) {
+            const tasks = this.buildMigrationTasksForPlan(plan, ...ctxArgs);
+            if (cfg.taskService) {
+                let dependsOnTaskId;
+                for (const versionTask of tasks) {
+                    if (dependsOnTaskId) {
+                        versionTask.task.dependencies = [
+                            ...(versionTask.task.dependencies || []),
+                            dependsOnTaskId,
+                        ];
+                    }
+                    const created = await cfg.taskService.push(versionTask.task, false, ...ctxArgs);
+                    dependsOnTaskId = created.id;
+                    this.queuedTaskChain.push({
+                        id: created.id,
+                        version: versionTask.version,
+                    });
+                    if (!created?.id) {
+                        log.warn(`TaskService.push returned missing id for version ${versionTask.version}`);
+                    }
+                    ctx.pushPending(constants_2.PersistenceKeys.MIGRATION, created.id);
+                }
             }
-            catch (e) {
-                throw new errors_1.MigrationError(`failed to conclude migration ${m.reference}: ${e}`);
+            else {
+                for (const migration of plan) {
+                    await this.executeMigration(migration, ...ctxArgs);
+                }
+                if (cfg.setCurrentVersion && scopedAdapter) {
+                    const finalVersion = cfg.targetVersion ||
+                        plan[plan.length - 1]?.version ||
+                        currentVersion ||
+                        undefined;
+                    if (finalVersion)
+                        await cfg.setCurrentVersion(this.normalizeVersion(finalVersion), scopedAdapter, ...ctxArgs);
+                }
             }
         }
         return undefined;
     }
+    async track(taskIds, ...args) {
+        const { ctxArgs } = (await this.logCtx(args, constants_2.PersistenceKeys.MIGRATION, true)).for(this.track);
+        const cfg = this.config;
+        if (!cfg.taskService || !cfg.taskMode)
+            return;
+        const explicitTaskIds = typeof taskIds === "string"
+            ? [taskIds]
+            : Array.isArray(taskIds)
+                ? taskIds
+                : undefined;
+        const queuedIds = this.queuedTaskChain.map((task) => task.id);
+        const pendingIds = this.migrationTaskIdsFromContext(constants_2.PersistenceKeys.MIGRATION, ctxArgs);
+        const ids = explicitTaskIds?.length
+            ? explicitTaskIds
+            : queuedIds.length
+                ? queuedIds
+                : pendingIds;
+        if (!ids.length)
+            return;
+        const versionByTaskId = this.queuedTaskChain.reduce((acc, task) => {
+            acc[task.id] = task.version;
+            return acc;
+        }, {});
+        const scopedAdapter = this.config.persistenceFlavour
+            ? Adapter_1.Adapter.get(this.config.persistenceFlavour)
+            : undefined;
+        for (const id of ids) {
+            const { tracker } = await cfg.taskService.track(id, ...ctxArgs);
+            await tracker.wait();
+            if (cfg.setCurrentVersion && scopedAdapter && versionByTaskId[id]) {
+                await cfg.setCurrentVersion(this.normalizeVersion(versionByTaskId[id]), scopedAdapter, ...ctxArgs);
+            }
+        }
+    }
+    async retry(taskIds, ...args) {
+        const { ctxArgs } = (await this.logCtx(args, constants_2.PersistenceKeys.MIGRATION, true)).for(this.retry);
+        const cfg = this.config;
+        if (!cfg.taskMode || !cfg.taskService) {
+            await this.migrateNormally(undefined, undefined, ...ctxArgs);
+            return;
+        }
+        const explicitTaskIds = typeof taskIds === "string"
+            ? [taskIds]
+            : Array.isArray(taskIds)
+                ? taskIds
+                : undefined;
+        const queuedIds = this.queuedTaskChain.map((task) => task.id);
+        const pendingIds = this.migrationTaskIdsFromContext(constants_2.PersistenceKeys.MIGRATION, ctxArgs);
+        const ids = explicitTaskIds?.length
+            ? explicitTaskIds
+            : queuedIds.length
+                ? queuedIds
+                : pendingIds;
+        if (!ids.length) {
+            await this.migrateViaTasks(undefined, undefined, ...ctxArgs);
+            return;
+        }
+        const taskRepo = cfg.taskService.client.tasks;
+        const updateRepo = typeof taskRepo?.override === "function"
+            ? taskRepo.override({ ignoreHandlers: true })
+            : taskRepo;
+        for (const id of ids) {
+            const tracked = await cfg.taskService.track(id, ...ctxArgs);
+            const task = tracked.task;
+            if (![constants_3.TaskStatus.FAILED, constants_3.TaskStatus.CANCELED].includes(task.status))
+                continue;
+            const patched = new TaskModel_1.TaskModel({
+                ...task,
+                status: constants_3.TaskStatus.PENDING,
+                error: undefined,
+                nextRunAt: undefined,
+                scheduledTo: undefined,
+                leaseOwner: undefined,
+                leaseExpiry: undefined,
+            });
+            await updateRepo.update(patched, ...ctxArgs);
+        }
+        return;
+    }
     async up(qr, adapter, ...args) {
         const { log } = this.logCtx(args, this.down);
         log.verbose((0, logging_1.style)("Setting up migration process").yellow.bold);
+        void qr;
+        void adapter;
     }
 }
 exports.MigrationService = MigrationService;

package/lib/migrations/MigrationService.d.ts

@@ -1,20 +1,63 @@
-import { Migration, MigrationConfig } from "./types";
+import { Migration, MigrationConfig, PersistenceMigrationConfig } from "./types";
 import { ClientBasedService } from "../services/services";
 import { Adapter } from "../persistence/Adapter";
 import { ContextOf } from "../persistence/types";
 import { ContextualArgs, MaybeContextualArg } from "../utils/ContextualLoggedClass";
+import { TaskModel } from "../tasks/models/TaskModel";
+import { MigrationVersioning } from "./MigrationVersioning";
+type ResolvedMigration = {
+    migration: Migration<any, any>;
+    flavour: string;
+    reference: string;
+    version: string;
+};
+type VersionTask = {
+    version: string;
+    task: TaskModel;
+};
 export declare class MigrationService<PERSIST extends boolean, A extends Adapter<any, any, any, any> = any, R = void> extends ClientBasedService<PERSIST extends boolean ? A : void, MigrationConfig<PERSIST>> implements Migration<any, A, R> {
+    protected versioning: MigrationVersioning;
+    protected queuedTaskChain: Array<{
+        id: string;
+        version: string;
+    }>;
     flavour?: string;
     readonly reference: string;
     readonly precedence: Migration<any, any> | Migration<any, any>[] | null;
     transaction: boolean;
     constructor();
+    static migrateAdapters<AD extends Adapter<any, any, any, any> = Adapter<any, any, any, any>>(adapters: AD[], cfg?: PersistenceMigrationConfig<AD>, ...args: MaybeContextualArg<ContextOf<AD>>): Promise<MigrationService<true, AD>[]>;
     initialize(...args: MaybeContextualArg<ContextOf<A>>): Promise<{
         config: MigrationConfig<PERSIST>;
         client: PERSIST extends boolean ? A : void;
     }>;
     down(qr: any, adapter: any, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
-    protected sort(migrations: Migration<any, any>[]): Migration<any, any, void>[];
+    protected normalizeVersion(raw: string, precedenceHint?: string): string;
+    protected extractPrecedenceTokens(migration: Migration<any, any>): string[];
+    protected referencesMigration(candidate: Migration<any, any>, target: ResolvedMigration): boolean;
+    protected precedenceHint(migration: Migration<any, any>): string | undefined;
+    protected compareByPrecedence(migration1: ResolvedMigration, migration2: ResolvedMigration): number;
+    protected sort(migrations: ResolvedMigration[]): ResolvedMigration[];
+    protected resolveMigration(migration: Migration<any, any>): ResolvedMigration;
+    protected shouldIncludeMigration(migration: ResolvedMigration, targetFlavour?: string, includeGeneric?: boolean): boolean;
+    protected collectMigrations(targetFlavour?: string, includeGeneric?: boolean): ResolvedMigration[];
+    protected buildExecutionPlan(options?: {
+        fromVersion?: string;
+        toVersion?: string;
+        targetFlavour?: string;
+        includeGeneric?: boolean;
+    }): ResolvedMigration[];
+    protected executeMigration(migration: ResolvedMigration, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
+    protected buildMigrationTaskForPlan(plan: ResolvedMigration[], ...args: ContextualArgs<ContextOf<any>>): TaskModel;
+    protected buildMigrationTasksForPlan(plan: ResolvedMigration[], ...args: ContextualArgs<ContextOf<any>>): VersionTask[];
+    createMigrationTask(targetVersion?: string, fromVersion?: string, ...args: ContextualArgs<ContextOf<any>>): TaskModel;
+    createMigrationTasks(targetVersion?: string, fromVersion?: string, ...args: ContextualArgs<ContextOf<any>>): VersionTask[];
+    protected migrationTaskIdsFromContext(taskKey: string, args: ContextualArgs<ContextOf<any>>): string[];
     migrate(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    migrateNormally(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    migrateViaTasks(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    track(taskIds?: string[] | string, ...args: MaybeContextualArg<ContextOf<any>>): Promise<void>;
+    retry(taskIds?: string[] | string, ...args: MaybeContextualArg<ContextOf<any>>): Promise<void>;
     up(qr: any, adapter: any, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
 }
+export {};