Compteurs et files atomiques

class MockRef {
  constructor(value) {
    this.value = value;
  }
  async transaction(updateFunction) {
    const currentValue = this.value;
    const newValue = updateFunction(currentValue);
    if (newValue !== undefined) {
      this.value = newValue;
      console.log(`Counter updated to: ${this.value}`);
      return { committed: true, snapshot: { val: () => this.value } };
    }
    return { committed: false };
  }
  val() { return this.value; }
}

async function main() {
  const counterRef = new MockRef(0);
  console.log("Initial count:", counterRef.val());

  // Attempt to increment the counter
  await counterRef.transaction(currentCount => {
    return (currentCount || 0) + 1;
  });

  console.log("Final count (after one increment):");
  console.log(counterRef.val());
}

main();

class MockDatabase {
  constructor() {
    this.data = {};
  }
  ref(path) {
    return {
      push: (value) => {
        const key = `item_${Object.keys(this.data[path] || {}).length}_${Date.now()}`;
        if (!this.data[path]) {
          this.data[path] = {};
        }
        this.data[path][key] = value;
        console.log(`Added to ${path}: ${JSON.stringify(value)}`);
        return { key: key };
      },
      val: () => this.data[path]
    };
  }
}

async function main() {
  const mockDb = new MockDatabase();
  const queueRef = mockDb.ref("tasks");

  console.log("Adding tasks to the queue...");
  await queueRef.push({ action: "sendEmail", userId: "user123" });
  await queueRef.push({ action: "generateReport", reportId: "rpt456" });

  console.log("\nCurrent queue items:");
  console.log(JSON.stringify(queueRef.val(), null, 2));
}

main();

class MockDatabase {
  constructor(initialData = {}) {
    this.data = initialData;
  }
  ref(path) {
    const self = this;
    return {
      orderByChild: (child) => ({ limitToFirst: (count) => ({ once: async (eventType) => {
        if (eventType === 'value') {
          const items = Object.entries(self.data[path] || {})
            .map(([key, value]) => ({ key, value }))
            .sort((a, b) => (a.value[child] || 0) - (b.value[child] || 0));
          const result = {};
          items.slice(0, count).forEach(item => { result[item.key] = item.value; });
          return { val: () => result };
        }
      }}) }),
      child: (key) => ({ transaction: async (updateFunction) => {
        const currentValue = self.data[path] ? self.data[path][key] : null;
        const newValue = updateFunction(currentValue);
        if (newValue === null) {
          delete self.data[path][key];
          console.log(`Transaction removed item: ${key}`);
          return { committed: true, snapshot: { val: () => null } };
        } else if (newValue !== undefined) {
          if (!self.data[path]) self.data[path] = {};
          self.data[path][key] = newValue;
          console.log(`Transaction updated item: ${key}`);
          return { committed: true, snapshot: { val: () => newValue } };
        }
        return { committed: false, snapshot: { val: () => currentValue } };
      }}),
      val: () => self.data[path]
    };
  }
}

async function main() {
  const initialTasks = {
    "task_A": { action: "sendEmail", userId: "user123", timestamp: 1678888000000 },
    "task_B": { action: "generateReport", reportId: "rpt456", timestamp: 1678888010000 }
  };
  const mockDb = new MockDatabase({ tasks: initialTasks });
  const queueRef = mockDb.ref("tasks");

  console.log("Initial queue items:", JSON.stringify(queueRef.val(), null, 2));

  const snapshot = await queueRef.orderByChild('timestamp').limitToFirst(1).once('value');
  const firstItem = snapshot.val();

  if (firstItem) {
    const firstKey = Object.keys(firstItem)[0];
    console.log(`Attempting to process task with key ${firstKey}`);
    const transactionResult = await queueRef.child(firstKey).transaction(currentData => {
      return currentData ? null : undefined; // Delete if exists, abort if not
    });

    if (transactionResult.committed) {
      console.log(`Successfully processed and removed task: ${firstKey}`);
    } else {
      console.log("Failed to process task (already processed or aborted).");
    }
  }
  console.log("\nQueue items after processing:");
  console.log(JSON.stringify(queueRef.val(), null, 2));
}

main();