dashlibstorage/test/migration.test.js

import test from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import LibDashStore from '../src/index.js';
import { BetterSqlite3Provider } from '../src/providers/sqlite3/index.js';
import { createTenant } from './helpers.js';

test('schema migrations & posterminal version 2', async (t) => {
  const tempDir = mkdtempSync(join(tmpdir(), 'dash-migration-test-'));
  const dbPath = join(tempDir, 'test.db');
  const provider = new BetterSqlite3Provider({
    filename: dbPath,
    storageDir: join(tempDir, 'storage'),
  });

  t.after(() => {
    try {
      provider.db?.close?.();
    } catch {}
    rmSync(tempDir, { recursive: true, force: true });
  });

  await t.test('fresh database is initialized at version 2', async () => {
    await provider.initialize();
    const version = await provider.getSchemaVersion();
    assert.equal(version, 2, 'Schema version must be 2');

    const cols = provider.db.pragma('table_info("posterminal")').map((c) => c.name);
    assert.ok(cols.includes('sort'), 'posterminal must have sort column');
    assert.ok(cols.includes('enabled'), 'posterminal must have enabled column');
    assert.ok(cols.includes('clientversion'), 'posterminal must have clientversion column');
  });

  let tenant;
  let store;
  let terminalId;

  await t.test('posterminal store operations support sort, enabled, clientversion', async () => {
    store = await new LibDashStore(provider);
    tenant = await createTenant(store, { name: 'Migration Tenant' });

    const created = await store.posterminal.upsert(tenant.googleAuthId, {
      name: 'Terminal 1',
      sort: 5,
      enabled: true,
    });
    assert.equal(created.name, 'Terminal 1');
    assert.equal(created.sort, 5);
    assert.equal(created.enabled, 1);
    terminalId = created.id;

    // setClientversion
    const versionRes = await store.posterminal.setClientversion(terminalId, '2.1.0');
    assert.equal(versionRes.clientversion, '2.1.0');

    // list
    const list = await store.posterminal.list(tenant.googleAuthId);
    assert.equal(list.length, 1);
    assert.equal(list[0].sort, 5);
    assert.equal(list[0].enabled, 1);
    assert.equal(list[0].clientversion, '2.1.0');

    // patch update (clientversion is not updated via upsert; existing value is preserved)
    const updated = await store.posterminal.upsert(tenant.googleAuthId, {
      id: terminalId,
      sort: 10,
      enabled: false,
    });
    assert.equal(updated.sort, 10);
    assert.equal(updated.enabled, 0);
    assert.equal(updated.clientversion, '2.1.0');

    // pair with clientversion
    const paired = await store.posterminal.pair(terminalId, {
      token: 'tok_abc123',
      clientserial: 'POS-Device-1',
      pairedAt: '2026-10-29T03:00:00.000Z',
      clientversion: '3.0.0-beta',
    });
    assert.equal(paired.token, 'tok_abc123');
    assert.equal(paired.clientversion, '3.0.0-beta');

    const afterPair = await store.posterminal.findByToken('tok_abc123');
    assert.equal(afterPair.clientversion, '3.0.0-beta');
  });

  await t.test('downgrade from version 2 to version 1', async () => {
    const steps = await provider.downgradeSchema(1);
    assert.equal(steps, 1);
    const version = await provider.getSchemaVersion();
    assert.equal(version, 1);

    const cols = provider.db.pragma('table_info("posterminal")').map((c) => c.name);
    assert.ok(!cols.includes('sort'), 'sort column should be removed');
    assert.ok(!cols.includes('enabled'), 'enabled column should be removed');
    assert.ok(!cols.includes('clientversion'), 'clientversion column should be removed');
  });

  await t.test('upgrade from version 1 back to version 2 on re-initialize', async () => {
    await provider.initialize();
    const version = await provider.getSchemaVersion();
    assert.equal(version, 2);

    const cols = provider.db.pragma('table_info("posterminal")').map((c) => c.name);
    assert.ok(cols.includes('sort'), 'sort column should be restored');
    assert.ok(cols.includes('enabled'), 'enabled column should be restored');
    assert.ok(cols.includes('clientversion'), 'clientversion column should be restored');
  });

  await t.test('refuses to initialize if db schema version is higher than highest upgrade version', async () => {
    // Manually set database meta version to a future version (e.g. 99)
    provider.db.prepare(`UPDATE meta SET value = '99' WHERE "key" = 'version'`).run();
    const futureVersion = await provider.getSchemaVersion();
    assert.equal(futureVersion, 99);

    await assert.rejects(
      async () => {
        await provider.initialize();
      },
      (err) => {
        assert.match(err.message, /Refusing to start: database schema version \(99\) is higher than the highest version in the upgrade folder \(2\)/);
        return true;
      },
      'Should throw and refuse to initialize'
    );

    // Restore to version 2 so cleanup/subsequent steps stay consistent
    provider.db.prepare(`UPDATE meta SET value = '2' WHERE "key" = 'version'`).run();
  });
});