@ftschopp/dynatable-migrations 1.3.1 → 2.0.0

package/dist/core/tracker.js

@@ -1,157 +1,154 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDBMigrationTracker = exports.DEFAULT_LOCK_TTL_SECONDS = void 0;
+exports.createMigrationTracker = exports.DEFAULT_LOCK_TTL_SECONDS = void 0;
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 const semver_1 = require("./semver");
 const errors_1 = require("./errors");
 /** Default lock TTL in seconds. Configurable via MigrationConfig.lockTtlSeconds. */
 exports.DEFAULT_LOCK_TTL_SECONDS = 300; // 5 minutes
-class DynamoDBMigrationTracker {
-    constructor(client, config) {
-        this.lockId = null;
-        this.client = client;
-        this.tableName = config.tableName;
-        this.trackingPrefix = config.trackingPrefix || '_SCHEMA#VERSION';
-        this.gsi1Name = config.gsi1Name || 'GSI1';
-        this.lockTtlSeconds = config.lockTtlSeconds ?? exports.DEFAULT_LOCK_TTL_SECONDS;
-    }
-    get lockKey() {
-        return {
-            PK: `${this.trackingPrefix}#LOCK`,
-            SK: `${this.trackingPrefix}#LOCK`,
-        };
-    }
+/**
+ * Create a DynamoDB-backed migration tracker.
+ *
+ * The tracker carries one piece of genuinely mutable state: the current
+ * lock id, set by `acquireLock()` and cleared by `releaseLock()`. Everything
+ * else is derived from the config or read from DynamoDB on demand.
+ */
+const createMigrationTracker = (client, config) => {
+    const tableName = config.tableName;
+    const trackingPrefix = config.trackingPrefix || '_SCHEMA#VERSION';
+    const lockTtlSeconds = config.lockTtlSeconds ?? exports.DEFAULT_LOCK_TTL_SECONDS;
+    let lockId = null;
+    const lockKey = {
+        PK: `${trackingPrefix}#LOCK`,
+        SK: `${trackingPrefix}#LOCK`,
+    };
     /** Throws if there is no active lock. Call before any tracker write. */
-    requireLock() {
-        if (!this.lockId) {
+    const requireLock = () => {
+        if (!lockId) {
             throw new Error('Tracker has no active lock; refusing to issue tracker mutations. ' +
                 'Call acquireLock() first.');
         }
-    }
+    };
     /** Builds a TransactWrite ConditionCheck that asserts we still own the lock. */
-    lockOwnershipCheck() {
-        this.requireLock();
+    const lockOwnershipCheck = () => {
+        requireLock();
         return {
             ConditionCheck: {
-                TableName: this.tableName,
-                Key: this.lockKey,
+                TableName: tableName,
+                Key: lockKey,
                 ConditionExpression: 'lockId = :lockId',
-                ExpressionAttributeValues: {
-                    ':lockId': this.lockId,
-                },
+                ExpressionAttributeValues: { ':lockId': lockId },
             },
         };
-    }
-    async initialize() {
-        // Check if current version pointer exists, if not create it
-        const current = await this.getCurrentVersion();
-        if (!current) {
-            // Create initial version pointer. The condition prevents two
-            // concurrent first-run inits from each writing the row — without
-            // it, both reads return null, both Puts succeed, and the second
-            // silently overwrites the first.
-            try {
-                await this.client.send(new lib_dynamodb_1.PutCommand({
-                    TableName: this.tableName,
-                    Item: {
-                        PK: `${this.trackingPrefix}#CURRENT`,
-                        SK: `${this.trackingPrefix}#CURRENT`,
-                        GSI1PK: 'SCHEMA#CURRENT',
-                        GSI1SK: 'v0000',
-                        currentVersion: 'v0000',
-                        updatedAt: new Date().toISOString(),
-                    },
-                    ConditionExpression: 'attribute_not_exists(PK)',
-                }));
-            }
-            catch (err) {
-                // Another worker initialized first — that's the desired post-state.
-                if (err?.name !== 'ConditionalCheckFailedException')
-                    throw err;
-            }
+    };
+    const getCurrentVersion = async () => {
+        const result = await client.send(new lib_dynamodb_1.GetCommand({
+            TableName: tableName,
+            Key: {
+                PK: `${trackingPrefix}#CURRENT`,
+                SK: `${trackingPrefix}#CURRENT`,
+            },
+        }));
+        return result.Item?.currentVersion || null;
+    };
+    const initialize = async () => {
+        const current = await getCurrentVersion();
+        if (current)
+            return;
+        // Create initial version pointer. The condition prevents two
+        // concurrent first-run inits from each writing the row — without
+        // it, both reads return null, both Puts succeed, and the second
+        // silently overwrites the first.
+        try {
+            await client.send(new lib_dynamodb_1.PutCommand({
+                TableName: tableName,
+                Item: {
+                    PK: `${trackingPrefix}#CURRENT`,
+                    SK: `${trackingPrefix}#CURRENT`,
+                    GSI1PK: 'SCHEMA#CURRENT',
+                    GSI1SK: 'v0000',
+                    currentVersion: 'v0000',
+                    updatedAt: new Date().toISOString(),
+                },
+                ConditionExpression: 'attribute_not_exists(PK)',
+            }));
+        }
+        catch (err) {
+            // Another worker initialized first — that's the desired post-state.
+            if (err?.name !== 'ConditionalCheckFailedException')
+                throw err;
         }
-    }
+    };
     /**
-     * Acquire a distributed lock to prevent concurrent migrations
+     * Acquire a distributed lock to prevent concurrent migrations.
+     *
+     * `expiresAt` is stored as an ISO 8601 string for consistency with every
+     * other timestamp in the tracker (`appliedAt`, `updatedAt`, `failedAt`,
+     * `rolledBackAt`, `acquiredAt`). ISO 8601 is lexicographically ordered the
+     * same way it's chronologically ordered, so the `<=` condition still
+     * compares correctly.
      */
-    async acquireLock() {
+    const acquireLock = async () => {
         const now = Date.now();
-        const expiresAt = now + this.lockTtlSeconds * 1000;
-        this.lockId = `lock-${now}-${Math.random().toString(36).substring(7)}`;
+        const nowIso = new Date(now).toISOString();
+        const expiresAtIso = new Date(now + lockTtlSeconds * 1000).toISOString();
+        const newLockId = `lock-${now}-${Math.random().toString(36).substring(7)}`;
+        lockId = newLockId;
         try {
-            await this.client.send(new lib_dynamodb_1.PutCommand({
-                TableName: this.tableName,
+            await client.send(new lib_dynamodb_1.PutCommand({
+                TableName: tableName,
                 Item: {
-                    ...this.lockKey,
-                    lockId: this.lockId,
-                    acquiredAt: new Date().toISOString(),
-                    expiresAt,
+                    ...lockKey,
+                    lockId: newLockId,
+                    acquiredAt: nowIso,
+                    expiresAt: expiresAtIso,
                 },
                 // Only succeed if lock doesn't exist or has expired. The `<=`
                 // covers the boundary where two clocks read the exact ms.
                 ConditionExpression: 'attribute_not_exists(PK) OR expiresAt <= :now',
-                ExpressionAttributeValues: {
-                    ':now': now,
-                },
+                ExpressionAttributeValues: { ':now': nowIso },
             }));
             return true;
         }
         catch (error) {
             if (error.name === 'ConditionalCheckFailedException') {
-                this.lockId = null;
+                lockId = null;
                 return false;
             }
             throw error;
         }
-    }
-    /**
-     * Extend the lock's expiration by another `lockTtlSeconds`. Throws
-     * `ConditionalCheckFailedException` if another worker has already taken
-     * the lock — callers should treat that as "we lost the race; stop
-     * making writes". Silent no-op if no lock is currently held.
-     */
-    async refreshLock() {
-        if (!this.lockId)
+    };
+    const refreshLock = async () => {
+        if (!lockId)
             return;
-        const newExpiresAt = Date.now() + this.lockTtlSeconds * 1000;
-        await this.client.send(new lib_dynamodb_1.UpdateCommand({
-            TableName: this.tableName,
-            Key: this.lockKey,
+        const newExpiresAtIso = new Date(Date.now() + lockTtlSeconds * 1000).toISOString();
+        await client.send(new lib_dynamodb_1.UpdateCommand({
+            TableName: tableName,
+            Key: lockKey,
             UpdateExpression: 'SET expiresAt = :exp',
             ConditionExpression: 'lockId = :lockId',
-            ExpressionAttributeValues: {
-                ':exp': newExpiresAt,
-                ':lockId': this.lockId,
-            },
+            ExpressionAttributeValues: { ':exp': newExpiresAtIso, ':lockId': lockId },
         }));
-    }
-    /**
-     * Release the distributed lock
-     */
-    async releaseLock() {
-        if (!this.lockId)
+    };
+    const releaseLock = async () => {
+        if (!lockId)
             return;
         try {
-            await this.client.send(new lib_dynamodb_1.DeleteCommand({
-                TableName: this.tableName,
-                Key: this.lockKey,
-                // Only delete if we own the lock
+            await client.send(new lib_dynamodb_1.DeleteCommand({
+                TableName: tableName,
+                Key: lockKey,
                 ConditionExpression: 'lockId = :lockId',
-                ExpressionAttributeValues: {
-                    ':lockId': this.lockId,
-                },
+                ExpressionAttributeValues: { ':lockId': lockId },
             }));
         }
         catch (error) {
-            // Lock may have expired or been taken by someone else
-            if (error.name !== 'ConditionalCheckFailedException') {
+            if (error.name !== 'ConditionalCheckFailedException')
                 throw error;
-            }
         }
         finally {
-            this.lockId = null;
+            lockId = null;
         }
-    }
+    };
     /**
      * Get all applied migrations with pagination support.
      *
@@ -159,15 +156,13 @@ class DynamoDBMigrationTracker {
      * `schemaDefinition` and `schemaChanges` blobs are intentionally omitted,
      * because no internal caller reads them and including them blows up the
      * 1MB-per-page budget (and consumed RCU) on tables with many migrations.
-     * If a future caller needs the full record, fetch by version with
-     * `getMigration(version)`.
      */
-    async getAppliedMigrations() {
-        const items = [];
+    const getAppliedMigrations = async () => {
+        const pages = [];
         let lastKey;
         do {
-            const result = await this.client.send(new lib_dynamodb_1.QueryCommand({
-                TableName: this.tableName,
+            const result = await client.send(new lib_dynamodb_1.QueryCommand({
+                TableName: tableName,
                 KeyConditionExpression: 'PK = :pk',
                 // `name` and `status` are DynamoDB reserved words; alias them.
                 ProjectionExpression: 'PK, SK, version, #name, #status, appliedAt, #ts, #err, checksum, failedAt, rolledBackAt, description',
@@ -177,84 +172,97 @@ class DynamoDBMigrationTracker {
                     '#ts': 'timestamp',
                     '#err': 'error',
                 },
-                ExpressionAttributeValues: {
-                    ':pk': this.trackingPrefix,
-                },
+                ExpressionAttributeValues: { ':pk': trackingPrefix },
                 ExclusiveStartKey: lastKey,
             }));
-            items.push(...(result.Items || []));
+            pages.push((result.Items ?? []));
             lastKey = result.LastEvaluatedKey;
         } while (lastKey);
-        return items;
-    }
-    async getCurrentVersion() {
-        const result = await this.client.send(new lib_dynamodb_1.GetCommand({
-            TableName: this.tableName,
-            Key: {
-                PK: `${this.trackingPrefix}#CURRENT`,
-                SK: `${this.trackingPrefix}#CURRENT`,
-            },
+        return pages.flat();
+    };
+    const getMigration = async (version) => {
+        const result = await client.send(new lib_dynamodb_1.GetCommand({
+            TableName: tableName,
+            Key: { PK: trackingPrefix, SK: version },
         }));
-        return result.Item?.currentVersion || null;
-    }
+        return result.Item || null;
+    };
+    /**
+     * Inspect a `TransactionCanceledException` raised by `markAsApplied` and
+     * either swallow it (idempotent re-apply) or re-throw a typed error.
+     */
+    const handleMarkAsAppliedCancellation = async (err, version) => {
+        const error = err;
+        if (error?.name !== 'TransactionCanceledException')
+            throw err;
+        const reasons = error.CancellationReasons ?? [];
+        const lockReason = reasons[0];
+        const migrationReason = reasons[1];
+        if (lockReason?.Code === 'ConditionalCheckFailed') {
+            throw new errors_1.MigrationLockLostError(version);
+        }
+        if (migrationReason?.Code === 'ConditionalCheckFailed') {
+            const current = await getMigration(version);
+            if (current?.status === 'applied') {
+                return;
+            }
+            throw new errors_1.MigrationAlreadyAppliedError(version, current?.status);
+        }
+        throw err;
+    };
     /**
      * Mark migration as applied using TransactWrite for atomicity
      * Handles both new migrations and re-applying rolled back migrations
      */
-    async markAsApplied(version, name, schemaDefinition, schemaChanges, checksum) {
-        this.requireLock();
+    const markAsApplied = async (version, name, schemaDefinition, schemaChanges, checksum) => {
+        requireLock();
         const now = new Date().toISOString();
-        // Check if migration record already exists (e.g., rolled back or failed)
-        const existing = await this.getMigration(version);
+        const existing = await getMigration(version);
         try {
             if (existing) {
-                // Update existing record (re-applying a rolled back or failed migration)
-                // Build dynamic update expression - DynamoDB doesn't accept undefined values
-                const setParts = ['#status = :status', 'appliedAt = :appliedAt', '#name = :name'];
+                // Update existing record (re-applying a rolled back or failed migration).
+                // Build expression and values purely from the optional fields.
+                const optionalFields = [
+                    ['schemaDefinition', schemaDefinition, ':schemaDef'],
+                    ['schemaChanges', schemaChanges, ':schemaChanges'],
+                    ['checksum', checksum, ':checksum'],
+                ];
+                const presentFields = optionalFields.filter(([, value]) => value !== undefined);
+                const setExpr = [
+                    '#status = :status',
+                    'appliedAt = :appliedAt',
+                    '#name = :name',
+                    ...presentFields.map(([field, , placeholder]) => `${field} = ${placeholder}`),
+                ].join(', ');
                 const expressionValues = {
                     ':status': 'applied',
                     ':appliedAt': now,
                     ':name': name,
+                    ...Object.fromEntries(presentFields.map(([, value, placeholder]) => [placeholder, value])),
                 };
-                if (schemaDefinition !== undefined) {
-                    setParts.push('schemaDefinition = :schemaDef');
-                    expressionValues[':schemaDef'] = schemaDefinition;
-                }
-                if (schemaChanges !== undefined) {
-                    setParts.push('schemaChanges = :schemaChanges');
-                    expressionValues[':schemaChanges'] = schemaChanges;
-                }
-                if (checksum !== undefined) {
-                    setParts.push('checksum = :checksum');
-                    expressionValues[':checksum'] = checksum;
-                }
-                await this.client.send(new lib_dynamodb_1.TransactWriteCommand({
+                await client.send(new lib_dynamodb_1.TransactWriteCommand({
                     TransactItems: [
-                        this.lockOwnershipCheck(),
+                        lockOwnershipCheck(),
                         {
                             Update: {
-                                TableName: this.tableName,
-                                Key: {
-                                    PK: this.trackingPrefix,
-                                    SK: version,
-                                },
-                                UpdateExpression: `SET ${setParts.join(', ')} REMOVE #error, failedAt, rolledBackAt`,
+                                TableName: tableName,
+                                Key: { PK: trackingPrefix, SK: version },
+                                UpdateExpression: `SET ${setExpr} REMOVE #error, failedAt, rolledBackAt`,
                                 ExpressionAttributeNames: {
                                     '#status': 'status',
                                     '#name': 'name',
                                     '#error': 'error',
                                 },
                                 ExpressionAttributeValues: expressionValues,
-                                // Only allow re-applying if not currently applied
                                 ConditionExpression: '#status <> :status',
                             },
                         },
                         {
                             Update: {
-                                TableName: this.tableName,
+                                TableName: tableName,
                                 Key: {
-                                    PK: `${this.trackingPrefix}#CURRENT`,
-                                    SK: `${this.trackingPrefix}#CURRENT`,
+                                    PK: `${trackingPrefix}#CURRENT`,
+                                    SK: `${trackingPrefix}#CURRENT`,
                                 },
                                 UpdateExpression: 'SET currentVersion = :version, updatedAt = :updatedAt, GSI1SK = :gsi1sk',
                                 ExpressionAttributeValues: {
@@ -268,15 +276,14 @@ class DynamoDBMigrationTracker {
                 }));
             }
             else {
-                // Create new migration record
-                await this.client.send(new lib_dynamodb_1.TransactWriteCommand({
+                await client.send(new lib_dynamodb_1.TransactWriteCommand({
                     TransactItems: [
-                        this.lockOwnershipCheck(),
+                        lockOwnershipCheck(),
                         {
                             Put: {
-                                TableName: this.tableName,
+                                TableName: tableName,
                                 Item: {
-                                    PK: this.trackingPrefix,
+                                    PK: trackingPrefix,
                                     SK: version,
                                     version,
                                     name,
@@ -294,10 +301,10 @@ class DynamoDBMigrationTracker {
                         },
                         {
                             Update: {
-                                TableName: this.tableName,
+                                TableName: tableName,
                                 Key: {
-                                    PK: `${this.trackingPrefix}#CURRENT`,
-                                    SK: `${this.trackingPrefix}#CURRENT`,
+                                    PK: `${trackingPrefix}#CURRENT`,
+                                    SK: `${trackingPrefix}#CURRENT`,
                                 },
                                 UpdateExpression: 'SET currentVersion = :version, updatedAt = :updatedAt, GSI1SK = :gsi1sk',
                                 ExpressionAttributeValues: {
@@ -312,82 +319,27 @@ class DynamoDBMigrationTracker {
             }
         }
         catch (err) {
-            await this.handleMarkAsAppliedCancellation(err, version);
-        }
-    }
-    /**
-     * Inspect a `TransactionCanceledException` raised by `markAsApplied` and
-     * either swallow it (idempotent re-apply) or re-throw a typed error.
-     *
-     * The TransactWrite items are: [lockOwnershipCheck, migrationRow, currentPointer].
-     * Each item produces an entry in `CancellationReasons`.
-     *   - reasons[0] failing → the lock was lost → MigrationLockLostError.
-     *   - reasons[1] failing → the migration row already exists in a state the
-     *     write refused. Re-fetch the record:
-     *       * status === 'applied' → idempotent re-apply, return silently.
-     *       * other states         → MigrationAlreadyAppliedError with the
-     *         current state, so the caller can decide what to do.
-     */
-    async handleMarkAsAppliedCancellation(err, version) {
-        const error = err;
-        if (error?.name !== 'TransactionCanceledException') {
-            throw err;
-        }
-        const reasons = error.CancellationReasons ?? [];
-        const lockReason = reasons[0];
-        const migrationReason = reasons[1];
-        if (lockReason?.Code === 'ConditionalCheckFailed') {
-            throw new errors_1.MigrationLockLostError(version);
+            await handleMarkAsAppliedCancellation(err, version);
         }
-        if (migrationReason?.Code === 'ConditionalCheckFailed') {
-            const current = await this.getMigration(version);
-            if (current?.status === 'applied') {
-                // Either we re-tried our own write or another worker applied the same
-                // version. Either way, the desired post-state is already satisfied.
-                return;
-            }
-            throw new errors_1.MigrationAlreadyAppliedError(version, current?.status);
-        }
-        throw err;
-    }
-    /**
-     * Mark migration as rolled back using TransactWrite for atomicity.
-     *
-     * @param previousVersion Optional. The version the CURRENT pointer should
-     *   move to after this rollback. When the caller already knows it (the
-     *   runner does — it loaded the applied list once at the top of `down()`),
-     *   passing it here skips a `getAppliedMigrations()` Query per rollback.
-     *   Without this hint, a multi-step rollback was N×(paginated Query of
-     *   the entire migration history). When omitted, the tracker falls back
-     *   to looking it up.
-     */
-    async markAsRolledBack(version, previousVersion) {
-        this.requireLock();
+    };
+    const markAsRolledBack = async (version, previousVersion) => {
+        requireLock();
         const now = new Date().toISOString();
-        let resolvedPrevious = previousVersion;
-        if (resolvedPrevious === undefined) {
-            // Find previous version
-            const migrations = await this.getAppliedMigrations();
-            const appliedMigrations = migrations
+        const resolvedPrevious = previousVersion ??
+            (await getAppliedMigrations()
+                .then((migrations) => migrations
                 .filter((m) => m.status === 'applied' && m.version !== version)
-                .sort((a, b) => (0, semver_1.compareSemver)(b.version, a.version));
-            resolvedPrevious = appliedMigrations[0]?.version || 'v0000';
-        }
-        // Use TransactWrite to atomically update record and pointer
-        await this.client.send(new lib_dynamodb_1.TransactWriteCommand({
+                .sort((a, b) => (0, semver_1.compareSemver)(b.version, a.version)))
+                .then((sorted) => sorted[0]?.version || 'v0000'));
+        await client.send(new lib_dynamodb_1.TransactWriteCommand({
             TransactItems: [
-                this.lockOwnershipCheck(),
+                lockOwnershipCheck(),
                 {
                     Update: {
-                        TableName: this.tableName,
-                        Key: {
-                            PK: this.trackingPrefix,
-                            SK: version,
-                        },
+                        TableName: tableName,
+                        Key: { PK: trackingPrefix, SK: version },
                         UpdateExpression: 'SET #status = :status, rolledBackAt = :timestamp',
-                        ExpressionAttributeNames: {
-                            '#status': 'status',
-                        },
+                        ExpressionAttributeNames: { '#status': 'status' },
                         ExpressionAttributeValues: {
                             ':status': 'rolled_back',
                             ':timestamp': now,
@@ -396,10 +348,10 @@ class DynamoDBMigrationTracker {
                 },
                 {
                     Update: {
-                        TableName: this.tableName,
+                        TableName: tableName,
                         Key: {
-                            PK: `${this.trackingPrefix}#CURRENT`,
-                            SK: `${this.trackingPrefix}#CURRENT`,
+                            PK: `${trackingPrefix}#CURRENT`,
+                            SK: `${trackingPrefix}#CURRENT`,
                         },
                         UpdateExpression: 'SET currentVersion = :version, updatedAt = :updatedAt, GSI1SK = :gsi1sk',
                         ExpressionAttributeValues: {
@@ -411,24 +363,19 @@ class DynamoDBMigrationTracker {
                 },
             ],
         }));
-    }
-    async markAsFailed(version, error) {
-        this.requireLock();
-        // Check if the migration record exists first
-        const existing = await this.getMigration(version);
+    };
+    const markAsFailed = async (version, error) => {
+        requireLock();
+        const existing = await getMigration(version);
         const now = new Date().toISOString();
         if (existing) {
-            // Update existing record, gated by lock ownership
-            await this.client.send(new lib_dynamodb_1.TransactWriteCommand({
+            await client.send(new lib_dynamodb_1.TransactWriteCommand({
                 TransactItems: [
-                    this.lockOwnershipCheck(),
+                    lockOwnershipCheck(),
                     {
                         Update: {
-                            TableName: this.tableName,
-                            Key: {
-                                PK: this.trackingPrefix,
-                                SK: version,
-                            },
+                            TableName: tableName,
+                            Key: { PK: trackingPrefix, SK: version },
                             UpdateExpression: 'SET #status = :status, #error = :error, failedAt = :timestamp',
                             ExpressionAttributeNames: {
                                 '#status': 'status',
@@ -445,15 +392,14 @@ class DynamoDBMigrationTracker {
             }));
         }
         else {
-            // Create new record for failed migration, gated by lock ownership
-            await this.client.send(new lib_dynamodb_1.TransactWriteCommand({
+            await client.send(new lib_dynamodb_1.TransactWriteCommand({
                 TransactItems: [
-                    this.lockOwnershipCheck(),
+                    lockOwnershipCheck(),
                     {
                         Put: {
-                            TableName: this.tableName,
+                            TableName: tableName,
                             Item: {
-                                PK: this.trackingPrefix,
+                                PK: trackingPrefix,
                                 SK: version,
                                 version,
                                 name: 'unknown',
@@ -467,24 +413,20 @@ class DynamoDBMigrationTracker {
                 ],
             }));
         }
-    }
-    async recordSchemaChange(change) {
-        this.requireLock();
-        const currentVersion = await this.getCurrentVersion();
+    };
+    const recordSchemaChange = async (change) => {
+        requireLock();
+        const currentVersion = await getCurrentVersion();
         if (!currentVersion || currentVersion === 'v0000') {
             throw new Error('Cannot record schema change: No migration has been applied yet');
         }
-        // Append to schemaChanges array, gated by lock ownership
-        await this.client.send(new lib_dynamodb_1.TransactWriteCommand({
+        await client.send(new lib_dynamodb_1.TransactWriteCommand({
             TransactItems: [
-                this.lockOwnershipCheck(),
+                lockOwnershipCheck(),
                 {
                     Update: {
-                        TableName: this.tableName,
-                        Key: {
-                            PK: this.trackingPrefix,
-                            SK: currentVersion,
-                        },
+                        TableName: tableName,
+                        Key: { PK: trackingPrefix, SK: currentVersion },
                         UpdateExpression: 'SET schemaChanges = list_append(if_not_exists(schemaChanges, :empty_list), :change)',
                         ExpressionAttributeValues: {
                             ':empty_list': [],
@@ -494,21 +436,26 @@ class DynamoDBMigrationTracker {
                 },
             ],
         }));
-    }
-    async getMigration(version) {
-        const result = await this.client.send(new lib_dynamodb_1.GetCommand({
-            TableName: this.tableName,
-            Key: {
-                PK: this.trackingPrefix,
-                SK: version,
-            },
-        }));
-        return result.Item || null;
-    }
-    async isApplied(version) {
-        const migration = await this.getMigration(version);
+    };
+    const isApplied = async (version) => {
+        const migration = await getMigration(version);
         return migration?.status === 'applied';
-    }
-}
-exports.DynamoDBMigrationTracker = DynamoDBMigrationTracker;
+    };
+    return {
+        lockTtlSeconds,
+        initialize,
+        acquireLock,
+        refreshLock,
+        releaseLock,
+        getAppliedMigrations,
+        getCurrentVersion,
+        markAsApplied,
+        markAsRolledBack,
+        markAsFailed,
+        recordSchemaChange,
+        getMigration,
+        isApplied,
+    };
+};
+exports.createMigrationTracker = createMigrationTracker;
 //# sourceMappingURL=tracker.js.map