// Demonstrates three compounding bugs in sequelize@6.37.8 nested savepoints:
//   1. Savepoint name collision across nesting levels (transaction.js:30-36)
//   2. Parent .name mutation on child create/rollback (query-interface.js:523-524, 560-561)
//   3. CLS not cleared on savepoint rollback (transaction.js:117-124)

const cls = require('cls-hooked');
const { Sequelize } = require('sequelize');

const namespace = cls.createNamespace('sq-repro');
Sequelize.useCLS(namespace);

const sequelize = new Sequelize(
  process.env.DATABASE_URL || 'postgres://postgres:postgres@localhost:5432/postgres',
  { logging: false },
);

async function main() {
  // cls-hooked requires an active context before set() works
  namespace.enter(namespace.createContext());

  // ---------------------------------------------------------------
  // BUG 1 + BUG 2a: pure flow, no workarounds
  // ---------------------------------------------------------------
  console.log('===== PART 1: pure flow (no workarounds) =====\n');

  const globalA = await sequelize.transaction({ autocommit: false });
  const globalANameAtCreation = globalA.name;
  console.log('globalA.id   =', globalA.id);
  console.log('globalA.name at creation =', globalANameAtCreation);

  const wrapperA = await sequelize.transaction({
    autocommit: false,
    transaction: globalA,
  });
  const wrapperANameAtCreation = wrapperA.name;
  console.log('wrapperA.id   =', wrapperA.id);
  console.log('wrapperA.name at creation =', wrapperANameAtCreation);
  console.log();

  console.log('=== BUG 2a: creating wrapperA stomped globalA.name ===');
  console.log('globalA.name was :', globalANameAtCreation);
  console.log('globalA.name now :', globalA.name);
  console.log('mutated ?         ', globalA.name !== globalANameAtCreation);
  console.log();

  const childA = await sequelize.transaction({
    autocommit: false,
    transaction: wrapperA,
  });
  console.log('childA.id   =', childA.id);
  console.log('childA.name =', childA.name);
  console.log();

  console.log('=== BUG 1: savepoint name collision ===');
  console.log('wrapperA.name (at creation) :', wrapperANameAtCreation);
  console.log('childA.name                 :', childA.name);
  console.log('collision ?                   ', wrapperANameAtCreation === childA.name);
  console.log();

  // Clean up part 1
  try { await childA.rollback(); } catch (e) { /* noop */ }
  try { await wrapperA.rollback(); } catch (e) { /* noop */ }
  try { await globalA.rollback(); } catch (e) { /* noop */ }

  // ---------------------------------------------------------------
  // BUG 2b + BUG 3: workaround Bug 1 so the others are unambiguous
  // ---------------------------------------------------------------
  console.log('===== PART 2: Bug 2b + Bug 3 (with Bug 1 worked around) =====\n');

  const globalB = await sequelize.transaction({ autocommit: false });
  const wrapperB = await sequelize.transaction({
    autocommit: false,
    transaction: globalB,
  });

  // Force a unique wrapperB.id so child names don't collide with wrapperB.name
  wrapperB.id = `wrap-${Date.now()}`;
  const wrapperBNameAtCreation = wrapperB.name;

  const childB = await sequelize.transaction({
    autocommit: false,
    transaction: wrapperB,
  });

  console.log('=== BUG 2b: creating childB stomped wrapperB.name ===');
  console.log('wrapperB.name was :', wrapperBNameAtCreation);
  console.log('wrapperB.name now :', wrapperB.name);
  console.log('mutated ?          ', wrapperB.name !== wrapperBNameAtCreation);
  console.log();

  // Bug 3: put childB into CLS (what sequelize.transaction(callback) does
  // automatically, and what test frameworks like ours do explicitly), then
  // roll it back and inspect CLS.
  namespace.set('transaction', childB);
  console.log('cls tx before childB.rollback(): is childB ?',
    namespace.get('transaction') === childB);

  await childB.rollback();

  const clsTx = namespace.get('transaction');
  console.log('=== BUG 3: CLS not cleared on savepoint rollback ===');
  console.log('cls tx after childB.rollback():');
  console.log('  is childB           ?', clsTx === childB);
  console.log('  is wrapperB         ?', clsTx === wrapperB);
  console.log('  is null             ?', clsTx === null);
  console.log('  finished flag on it :', clsTx && clsTx.finished);
  console.log();

  try {
    await sequelize.query('SELECT 1', { transaction: namespace.get('transaction') });
    console.log('subsequent query via CLS tx: OK');
  } catch (e) {
    console.log('subsequent query via CLS tx threw:');
    console.log('  ', e.message);
  }
  console.log();

  try { await wrapperB.rollback(); } catch (e) { /* noop */ }
  try { await globalB.rollback(); } catch (e) { /* noop */ }
  await sequelize.close();
}

main().catch((e) => {
  console.error('unexpected error:', e);
  process.exit(1);
});