@ftschopp/dynatable-migrations 1.2.6 → 1.3.1

package/src/core/loader.ts

@@ -1,256 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
-import { Migration, MigrationFile } from '../types';
-import { compareSemver } from './semver';
-
-/**
- * Load all migration files from directory
- */
-export class MigrationLoader {
-  private migrationsDir: string;
-
-  constructor(migrationsDir: string) {
-    this.migrationsDir = migrationsDir;
-  }
-
-  /**
-   * Calculate checksum of a file
-   */
-  calculateChecksum(filePath: string): string {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    return crypto.createHash('md5').update(content).digest('hex');
-  }
-
-  /**
-   * Load all migration files
-   */
-  async loadMigrations(): Promise<MigrationFile[]> {
-    if (!fs.existsSync(this.migrationsDir)) {
-      throw new Error(`Migrations directory not found: ${this.migrationsDir}`);
-    }
-
-    const files = fs
-      .readdirSync(this.migrationsDir)
-      .filter(
-        (f) =>
-          (f.endsWith('.ts') || f.endsWith('.js')) &&
-          !f.endsWith('.d.ts') &&
-          this.isValidMigrationFileName(f)
-      )
-      .sort((a, b) => {
-        // Sort by semver
-        const versionA = a.match(/^(\d+\.\d+\.\d+)/)?.[1] || '0.0.0';
-        const versionB = b.match(/^(\d+\.\d+\.\d+)/)?.[1] || '0.0.0';
-        return compareSemver(versionA, versionB);
-      });
-
-    const migrations: MigrationFile[] = [];
-
-    for (const file of files) {
-      const filePath = path.join(this.migrationsDir, file);
-      const migration = await this.loadMigration(filePath);
-
-      if (migration) {
-        migrations.push(migration);
-      }
-    }
-
-    return migrations;
-  }
-
-  /**
-   * Load single migration file
-   */
-  private async loadMigration(filePath: string): Promise<MigrationFile | null> {
-    // Convert to absolute path
-    const absolutePath = path.isAbsolute(filePath)
-      ? filePath
-      : path.resolve(process.cwd(), filePath);
-
-    let module: any;
-
-    // For TypeScript files, use require (ts-node must be registered)
-    if (absolutePath.endsWith('.ts')) {
-      // Register ts-node if not already registered
-      this.registerTsNode();
-
-      // Clear require cache to reload file
-      delete require.cache[absolutePath];
-
-      try {
-        module = require(absolutePath);
-      } catch (error: any) {
-        throw new Error(
-          `Failed to load TypeScript migration ${filePath}: ${error.message}. ` +
-            `Ensure ts-node is installed and the file has valid TypeScript syntax.`
-        );
-      }
-    } else {
-      // For JavaScript files, use dynamic import
-      try {
-        const fileUrl = `file://${absolutePath}`;
-        module = await import(fileUrl);
-      } catch (error: any) {
-        throw new Error(`Failed to load JavaScript migration ${filePath}: ${error.message}`);
-      }
-    }
-
-    const migration: Migration = module.migration || module.default;
-
-    if (!migration) {
-      console.warn(`Warning: No migration export found in ${filePath}`);
-      return null;
-    }
-
-    // Validate migration structure
-    this.validateMigration(migration, filePath);
-
-    const fileName = path.basename(filePath);
-    const { version, name } = this.parseMigrationFileName(fileName);
-
-    // Calculate checksum
-    const checksum = this.calculateChecksum(absolutePath);
-
-    return {
-      version,
-      name,
-      filePath,
-      migration,
-      checksum,
-    };
-  }
-
-  /**
-   * Register ts-node for TypeScript file loading
-   */
-  private registerTsNode(): void {
-    try {
-      // Check if ts-node is already registered
-      const tsNodeSymbol = Symbol.for('ts-node.register.instance');
-      if ((process as any)[tsNodeSymbol]) {
-        return; // Already registered
-      }
-
-      require('ts-node').register({
-        transpileOnly: true,
-        skipProject: true, // Don't use project tsconfig
-        compilerOptions: {
-          module: 'commonjs',
-          target: 'ES2020',
-          esModuleInterop: true,
-          moduleResolution: 'node',
-        },
-      });
-    } catch (error: any) {
-      if (error.code === 'MODULE_NOT_FOUND') {
-        throw new Error(
-          'ts-node is required to load TypeScript migrations. ' +
-            'Install it with: npm install ts-node'
-        );
-      }
-      // Other errors might mean ts-node is already registered differently
-      console.warn(`Warning: Could not register ts-node: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate migration file name format
-   * Expected: 1.0.0_migration_name.ts (semver format)
-   */
-  private isValidMigrationFileName(fileName: string): boolean {
-    // Match semver: 1.0.0_name.ts or 1.2.3_name.ts
-    return /^\d+\.\d+\.\d+_[\w-]+\.(ts|js)$/.test(fileName);
-  }
-
-  /**
-   * Parse version and name from file name
-   */
-  private parseMigrationFileName(fileName: string): {
-    version: string;
-    name: string;
-  } {
-    const match = fileName.match(/^(\d+\.\d+\.\d+)_([\w-]+)\.(ts|js)$/);
-
-    if (!match || !match[1] || !match[2]) {
-      throw new Error(
-        `Invalid migration file name format: ${fileName}. Expected: X.Y.Z_name.ts (semver)`
-      );
-    }
-
-    const version = match[1];
-    const name = match[2];
-
-    return { version, name };
-  }
-
-  /**
-   * Validate migration structure
-   */
-  private validateMigration(migration: Migration, filePath: string): void {
-    if (!migration.version) {
-      throw new Error(`Migration ${filePath} is missing 'version' property`);
-    }
-
-    if (!migration.name) {
-      throw new Error(`Migration ${filePath} is missing 'name' property`);
-    }
-
-    if (typeof migration.up !== 'function') {
-      throw new Error(`Migration ${filePath} is missing 'up' function or it's not a function`);
-    }
-
-    if (typeof migration.down !== 'function') {
-      throw new Error(`Migration ${filePath} is missing 'down' function or it's not a function`);
-    }
-  }
-
-  /**
-   * Get pending migrations (not yet applied)
-   */
-  async getPendingMigrations(appliedVersions: string[]): Promise<MigrationFile[]> {
-    const allMigrations = await this.loadMigrations();
-    return allMigrations.filter((m) => !appliedVersions.includes(m.version));
-  }
-
-  /**
-   * Get migration by version
-   */
-  async getMigration(version: string): Promise<MigrationFile | null> {
-    const migrations = await this.loadMigrations();
-    return migrations.find((m) => m.version === version) || null;
-  }
-
-  /**
-   * Generate next version number (increments patch by default)
-   */
-  async getNextVersion(): Promise<string> {
-    const migrations = await this.loadMigrations();
-
-    if (migrations.length === 0) {
-      return '0.1.0';
-    }
-
-    // Get last version
-    const lastMigration = migrations[migrations.length - 1];
-    if (!lastMigration) {
-      return '0.1.0';
-    }
-
-    const lastVersion = lastMigration.version;
-
-    // Parse semver and increment patch
-    const parts = lastVersion.split('.');
-    if (parts.length === 3 && parts[0] && parts[1] && parts[2]) {
-      const major = parseInt(parts[0], 10);
-      const minor = parseInt(parts[1], 10);
-      const patch = parseInt(parts[2], 10);
-
-      // Increment patch version
-      return `${major}.${minor}.${patch + 1}`;
-    }
-
-    return '0.1.0';
-  }
-
-}

package/src/core/lock-heartbeat.test.ts

@@ -1,78 +0,0 @@
-import { startLockHeartbeat } from './lock-heartbeat';
-import type { MigrationTracker } from '../types';
-
-beforeEach(() => {
-  jest.useFakeTimers();
-});
-
-afterEach(() => {
-  jest.useRealTimers();
-});
-
-function makeTracker(refresh: jest.Mock): MigrationTracker {
-  // Only the methods the heartbeat actually touches need to be present.
-  return {
-    refreshLock: refresh,
-  } as unknown as MigrationTracker;
-}
-
-describe('startLockHeartbeat', () => {
-  test('calls refreshLock every ~ttl/3 seconds', () => {
-    const refresh = jest.fn().mockResolvedValue(undefined);
-    const tracker = makeTracker(refresh);
-    const stop = startLockHeartbeat(tracker, 30); // every 10s
-
-    jest.advanceTimersByTime(10_000);
-    expect(refresh).toHaveBeenCalledTimes(1);
-
-    jest.advanceTimersByTime(10_000);
-    expect(refresh).toHaveBeenCalledTimes(2);
-
-    stop();
-  });
-
-  test('stop() clears the interval and prevents further refreshes', () => {
-    const refresh = jest.fn().mockResolvedValue(undefined);
-    const tracker = makeTracker(refresh);
-    const stop = startLockHeartbeat(tracker, 30);
-
-    jest.advanceTimersByTime(10_000);
-    stop();
-    jest.advanceTimersByTime(60_000);
-
-    expect(refresh).toHaveBeenCalledTimes(1);
-  });
-
-  test('clamps the interval to a 1s minimum even with absurdly small TTLs', () => {
-    const refresh = jest.fn().mockResolvedValue(undefined);
-    const tracker = makeTracker(refresh);
-    const stop = startLockHeartbeat(tracker, 0.5); // would compute < 1s
-
-    jest.advanceTimersByTime(999);
-    expect(refresh).toHaveBeenCalledTimes(0);
-    jest.advanceTimersByTime(1);
-    expect(refresh).toHaveBeenCalledTimes(1);
-
-    stop();
-  });
-
-  test('swallows refresh errors so transient failures do not crash the runner', async () => {
-    const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
-    const refresh = jest
-      .fn()
-      .mockRejectedValueOnce(Object.assign(new Error('boom'), { name: 'NetworkError' }));
-    const tracker = makeTracker(refresh);
-    const stop = startLockHeartbeat(tracker, 30);
-
-    jest.advanceTimersByTime(10_000);
-    // Let the rejected promise settle
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect(refresh).toHaveBeenCalledTimes(1);
-    expect(warn).toHaveBeenCalled();
-
-    stop();
-    warn.mockRestore();
-  });
-});

package/src/core/lock-heartbeat.ts

@@ -1,48 +0,0 @@
-import type { MigrationTracker } from '../types';
-
-/**
- * Periodically refreshes the migration lock so that migrations longer than
- * the lock TTL don't have their lock taken by another worker.
- *
- * Returns a stop function. Call it from the same `finally` that releases
- * the lock to make sure the interval doesn't leak.
- *
- * The heartbeat fires every `ttlSeconds / 3` seconds. Errors from the
- * underlying refresh are logged and swallowed: if the lock is genuinely
- * lost, the next tracker mutation will fail its ConditionCheck and the
- * runner will surface a clear `TransactionCanceledException` to the user.
- */
-export function startLockHeartbeat(
-  tracker: MigrationTracker,
-  ttlSeconds: number
-): () => void {
-  // Fire well before expiry so a single missed beat doesn't drop the lock.
-  const intervalMs = Math.max(1_000, Math.floor((ttlSeconds * 1000) / 3));
-  let active = true;
-
-  const handle = setInterval(() => {
-    if (!active) return;
-    void tracker.refreshLock().catch((err: unknown) => {
-      const name = (err as { name?: string } | null)?.name;
-      const message = (err as { message?: string } | null)?.message ?? String(err);
-      if (name === 'ConditionalCheckFailedException') {
-        console.warn(
-          '⚠️  Migration lock was taken by another process. ' +
-            'Subsequent tracker writes will fail.'
-        );
-      } else {
-        console.warn(`⚠️  Failed to refresh migration lock: ${message}`);
-      }
-    });
-  }, intervalMs);
-
-  // Don't keep the Node event loop alive just for the heartbeat.
-  if (typeof handle.unref === 'function') {
-    handle.unref();
-  }
-
-  return () => {
-    active = false;
-    clearInterval(handle);
-  };
-}

package/src/core/runner.test.ts

@@ -1,51 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-import { MigrationRunner } from './runner';
-import type { MigrationConfig } from '../types';
-
-const baseConfig: MigrationConfig = {
-  tableName: 'TestTable',
-  client: { region: 'us-east-1' },
-};
-
-function makeRunner() {
-  const client = DynamoDBDocumentClient.from(new DynamoDBClient({ region: 'us-east-1' }));
-  return new MigrationRunner(client, baseConfig);
-}
-
-describe('MigrationRunner.up - input validation', () => {
-  test('throws when limit is 0', async () => {
-    await expect(makeRunner().up({ limit: 0 })).rejects.toThrow(/positive integer/);
-  });
-
-  test('throws when limit is negative', async () => {
-    await expect(makeRunner().up({ limit: -3 })).rejects.toThrow(/positive integer/);
-  });
-
-  test('throws when limit is NaN', async () => {
-    await expect(makeRunner().up({ limit: NaN })).rejects.toThrow(/positive integer/);
-  });
-
-  test('throws when limit is a non-integer (1.5)', async () => {
-    await expect(makeRunner().up({ limit: 1.5 })).rejects.toThrow(/positive integer/);
-  });
-});
-
-describe('MigrationRunner.down - input validation', () => {
-  test('throws when steps is 0', async () => {
-    await expect(makeRunner().down(0)).rejects.toThrow(/positive integer/);
-  });
-
-  test('throws when steps is negative', async () => {
-    await expect(makeRunner().down(-5)).rejects.toThrow(/positive integer/);
-  });
-
-  test('throws when steps is NaN', async () => {
-    await expect(makeRunner().down(Number.NaN)).rejects.toThrow(/positive integer/);
-  });
-
-  test('throws when steps is a non-integer', async () => {
-    await expect(makeRunner().down(2.5)).rejects.toThrow(/positive integer/);
-  });
-});