@omega.js/backend 0.1.0

package/test/events/auth-delete-conversion.test.js

@@ -0,0 +1,138 @@
+/**
+ * Test: auth:on-delete fires `user_delete` as a CANONICAL conversion
+ * ([#328](https://github.com/Omega-JS-Stack/omega/issues/328)).
+ *
+ * The handler used to reach `Manager.Analytics(...).event('user_delete')`
+ * directly — the right NAME, but past the consent gate and past the catalog's
+ * per-provider walk. It now goes through `deliverConversion`, which is what
+ * makes it the same kind of event as every other server conversion.
+ *
+ * THE DEDUPE ID IS `user_delete.<uid>`. An account is deleted once; a
+ * redelivered trigger must report the same event, not a second one.
+ *
+ * The load-bearing ordering detail: the consent snapshot is read from the user
+ * doc BEFORE the delete, because the delete is the moment it stops existing. An
+ * ABSENT snapshot GRANTS (the standing rule) — a legacy account predating the
+ * consent system is still counted.
+ *
+ * Real handler, real Manager, real ctx, real Firestore delete. The doc is
+ * seeded directly and the UserRecord is a plain object, so no Auth user exists
+ * and the emulator's own trigger never races this one.
+ *
+ * Run: npx omega test framework:events/auth-delete-conversion
+ */
+const onDelete = require('../../dist/manager/events/auth/on-delete.js');
+const defineCases = require('../../dist/vendor/devkit/test/define-cases.js');
+
+const EVENT_CONTEXT = {
+  eventType: 'providers/firebase.auth/eventTypes/user.delete',
+  resource: { service: 'firebaseauth.googleapis.com' },
+};
+
+function testUid() {
+  return `_test-delete-conversion-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+}
+
+// Record every console call the handler makes, restoring console afterward.
+async function withConsoleRecorder(fn) {
+  const calls = { log: [], debug: [], error: [] };
+  const original = { log: console.log, debug: console.debug, error: console.error };
+
+  console.log = (...args) => calls.log.push(args);
+  console.debug = (...args) => calls.debug.push(args);
+  console.error = (...args) => calls.error.push(args);
+
+  try {
+    await fn();
+    return calls;
+  } finally {
+    console.log = original.log;
+    console.debug = original.debug;
+    console.error = original.error;
+  }
+}
+
+/** Seed a user doc, run the real handler against it, hand back the delivery lines. */
+async function runHandler({ Manager, uid, doc }) {
+  const ctx = Manager.RouteContext({}, { functionName: 'omega_authOnDelete' });
+  const admin = Manager.libraries.admin;
+
+  await admin.firestore().doc(`users/${uid}`).set(doc);
+
+  const calls = await withConsoleRecorder(async () => {
+    await onDelete({
+      Manager: Manager,
+      ctx: ctx,
+      user: { uid: uid, email: `${uid}@test.invalid` },
+      context: EVENT_CONTEXT,
+      libraries: { admin: admin },
+    });
+  });
+
+  const delivery = calls.log
+    .map((args) => String(args[1]))
+    .filter((line) => line.startsWith('deliverConversion: '));
+
+  return { calls: calls, delivery: delivery };
+}
+
+module.exports = defineCases({
+  description: 'auth:on-delete fires the canonical user_delete conversion',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'a-deleted-account-fires-user-delete-with-the-uid-derived-dedupe-id',
+      async run({ assert, Manager, firestore }) {
+        const uid = testUid();
+
+        try {
+          const { delivery } = await runHandler({
+            Manager: Manager,
+            uid: uid,
+            doc: { auth: { uid: uid, email: `${uid}@test.invalid` } },
+          });
+
+          assert.equal(delivery.length, 1, `expected one conversion delivery, got ${delivery.length}: ${delivery.join(' | ')}`);
+          assert.equal(delivery[0].startsWith('deliverConversion: user_delete →'), true, delivery[0]);
+          assert.equal(delivery[0].includes(`(event_id=user_delete.${uid})`), true, `the uid is what the deletion is about: ${delivery[0]}`);
+
+          // GA4 only — an account ending is nothing an ad platform maps.
+          for (const provider of ['meta', 'tiktok']) {
+            assert.equal(delivery[0].includes(`${provider} skipped (no mapping)`), true, `${provider} has no mapping: ${delivery[0]}`);
+          }
+
+          // An account with no snapshot at all is still counted.
+          assert.equal(delivery[0].includes('ga4 skipped (consent'), false, `an absent snapshot grants: ${delivery[0]}`);
+          assert.equal(await firestore.exists(`users/${uid}`), false, 'the handler still deletes the doc');
+        } finally {
+          await firestore.delete(`users/${uid}`);
+        }
+      },
+    },
+
+    {
+      name: 'a-declined-snapshot-read-before-the-delete-blocks-the-fire',
+      async run({ assert, Manager, firestore }) {
+        const uid = testUid();
+
+        try {
+          const { delivery } = await runHandler({
+            Manager: Manager,
+            uid: uid,
+            doc: {
+              auth: { uid: uid, email: `${uid}@test.invalid` },
+              trackingConsent: { analytics: false, marketing: false, region: 'opt-in', version: 1 },
+            },
+          });
+
+          assert.equal(delivery.length, 1, delivery.join(' | '));
+          assert.equal(delivery[0].includes('ga4 skipped (consent: analytics)'), true, `the snapshot the doc carried still gates the fire after the doc is gone: ${delivery[0]}`);
+        } finally {
+          await firestore.delete(`users/${uid}`);
+        }
+      },
+    },
+  ],
+});

package/test/events/auth-delete-race.test.js

@@ -0,0 +1,211 @@
+const uuid = require('uuid');
+const defineCases = require('../../dist/vendor/devkit/test/define-cases.js');
+
+/**
+ * Test: auth:on-delete race condition
+ *
+ * Proves the emulator's async on-delete trigger clobbers freshly-recreated docs
+ * when you don't wait for it to settle, and that the mitigation strategies work.
+ *
+ * The production fix uses the emulator's bulk-clear REST API in deleteTestUsers()
+ * to avoid triggering on-delete at all during test setup.
+ */
+module.exports = defineCases({
+  description: 'auth:on-delete race condition (create → delete → recreate)',
+  type: 'group',
+  timeout: 120000,
+
+  tests: [
+    {
+      name: 'baseline-create-and-verify',
+      async run({ Manager, assert }) {
+        const admin = Manager.libraries.admin;
+        const testUid = '_test-race-baseline';
+        const testEmail = '_test.race-baseline@test.com';
+        const userRef = admin.firestore().doc(`users/${testUid}`);
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+
+        await admin.auth().createUser({
+          uid: testUid,
+          email: testEmail,
+          password: uuid.v4(),
+          emailVerified: true,
+        });
+
+        const ready = await pollUntilReady(userRef);
+        assert.ok(ready, 'on-create should complete and write api keys');
+
+        const doc = await userRef.get();
+        assert.ok(doc.data()?.api?.clientId, 'doc should have api.clientId');
+        assert.ok(doc.data()?.api?.privateKey, 'doc should have api.privateKey');
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+      },
+    },
+
+    {
+      name: 'no-wait-gets-clobbered',
+      async run({ Manager, assert, skip }) {
+        const admin = Manager.libraries.admin;
+        const testUid = '_test-race-no-wait';
+        const testEmail = '_test.race-no-wait@test.com';
+        const userRef = admin.firestore().doc(`users/${testUid}`);
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+
+        // Create and wait for doc to be fully ready
+        await admin.auth().createUser({
+          uid: testUid, email: testEmail,
+          password: uuid.v4(), emailVerified: true,
+        });
+        assert.ok(await pollUntilReady(userRef), 'First create should produce api keys');
+
+        // Delete auth user — do NOT wait for doc to disappear — then recreate
+        await admin.auth().deleteUser(testUid);
+        await admin.auth().createUser({
+          uid: testUid, email: testEmail,
+          password: uuid.v4(), emailVerified: true,
+        });
+        await pollUntilReady(userRef);
+
+        // The late on-delete clobbers the doc within a few seconds
+        await sleep(3000);
+        const doc = await userRef.get();
+        const survived = doc.exists && !!(doc.data()?.api?.clientId);
+
+        // The race resolves either way: when the emulator happens to finish
+        // the on-delete BEFORE the re-create's onCreate writes the doc, the
+        // dangerous late-clobber ordering never materializes that run —
+        // scheduler luck, not a regression. Only the clobber outcome is
+        // assertable; the benign ordering skips.
+        if (survived) {
+          await admin.auth().deleteUser(testUid).catch(() => {});
+          await pollUntilGone(userRef);
+          return skip('on-delete completed before the re-create this run — race did not manifest');
+        }
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+      },
+    },
+
+    {
+      name: 'wait-for-gone-survives',
+      async run({ Manager, assert }) {
+        const admin = Manager.libraries.admin;
+        const testUid = '_test-race-wait-gone';
+        const testEmail = '_test.race-wait-gone@test.com';
+        const userRef = admin.firestore().doc(`users/${testUid}`);
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+
+        await admin.auth().createUser({
+          uid: testUid, email: testEmail,
+          password: uuid.v4(), emailVerified: true,
+        });
+        assert.ok(await pollUntilReady(userRef), 'First create should produce api keys');
+
+        // Delete and WAIT for doc to disappear before recreating
+        await admin.auth().deleteUser(testUid);
+        await pollUntilGone(userRef);
+
+        await admin.auth().createUser({
+          uid: testUid, email: testEmail,
+          password: uuid.v4(), emailVerified: true,
+        });
+        assert.ok(await pollUntilReady(userRef), 'Second create should produce api keys');
+
+        await sleep(3000);
+        const doc = await userRef.get();
+        const survived = doc.exists && !!(doc.data()?.api?.clientId);
+
+        assert.ok(survived, 'Doc should survive when we wait for on-delete to settle first');
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+      },
+    },
+
+    {
+      name: 'force-delete-doc-survives',
+      async run({ Manager, assert }) {
+        const admin = Manager.libraries.admin;
+        const testUid = '_test-race-force-del';
+        const testEmail = '_test.race-force-del@test.com';
+        const userRef = admin.firestore().doc(`users/${testUid}`);
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+
+        await admin.auth().createUser({
+          uid: testUid, email: testEmail,
+          password: uuid.v4(), emailVerified: true,
+        });
+        assert.ok(await pollUntilReady(userRef), 'First create should produce api keys');
+
+        // Delete auth user AND force-delete the Firestore doc, then pause
+        await admin.auth().deleteUser(testUid);
+        await userRef.delete().catch(() => {});
+        await sleep(500);
+
+        await admin.auth().createUser({
+          uid: testUid, email: testEmail,
+          password: uuid.v4(), emailVerified: true,
+        });
+        assert.ok(await pollUntilReady(userRef), 'Second create should produce api keys');
+
+        await sleep(3000);
+        const doc = await userRef.get();
+        const survived = doc.exists && !!(doc.data()?.api?.clientId);
+
+        assert.ok(survived, 'Doc should survive when we force-delete the doc before recreating');
+
+        await admin.auth().deleteUser(testUid).catch(() => {});
+        await pollUntilGone(userRef);
+      },
+    },
+  ],
+});
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function pollUntilReady(userRef, maxWait = 15000) {
+  const interval = 300;
+  let waited = 0;
+
+  while (waited < maxWait) {
+    const doc = await userRef.get();
+    const data = doc.exists ? doc.data() : null;
+    if (data?.metadata?.tag === 'auth:on-create' && data.api?.clientId && data.api?.privateKey) {
+      return true;
+    }
+    await sleep(interval);
+    waited += interval;
+  }
+
+  return false;
+}
+
+async function pollUntilGone(userRef, maxWait = 10000) {
+  const interval = 200;
+  let waited = 0;
+
+  while (waited < maxWait) {
+    const doc = await userRef.get();
+    if (!doc.exists) {
+      return true;
+    }
+    await sleep(interval);
+    waited += interval;
+  }
+
+  await userRef.delete().catch(() => {});
+  return false;
+}

package/test/events/auth-on-create-log.test.js

@@ -0,0 +1,164 @@
+/**
+ * Test: auth:on-create logs ONE headline line
+ * ([#230](https://github.com/Omega-JS-Stack/omega/issues/230)).
+ *
+ * The handler used to dump the whole UserRecord (providerData, passwordHash,
+ * metadata) plus the event context onto its opening line — per created user, which
+ * buries a dev-boot seed. The headline is now `onCreate: <uid>` and nothing else
+ * — the address came off it in the #710 pass, so all four auth triggers spell
+ * their headline the one way the #657 sweep set; the full record stays reachable
+ * one level down, at debug — silent on a normal run, one `OMEGA_DEBUG=1` away.
+ *
+ * Real everything: a seeded persona's REAL UserRecord from the emulator's Auth,
+ * the real Manager and ctx, the real handler. The persona already has a user doc,
+ * so the handler logs its headline and returns at the "already exists" branch —
+ * no writes, nothing to clean up. The only stand-in is `console`, the sink.
+ *
+ * Run: npx omega test framework:events/auth-on-create-log
+ */
+
+const onCreate = require('../../dist/manager/events/auth/on-create.js');
+const defineCases = require('../../dist/vendor/devkit/test/define-cases.js');
+
+// Record every console call the thunk makes, restoring console afterward.
+async function withConsoleRecorder(fn) {
+  const calls = { log: [], debug: [], error: [] };
+  const original = { log: console.log, debug: console.debug, error: console.error };
+
+  console.log = (...args) => calls.log.push(args);
+  console.debug = (...args) => calls.debug.push(args);
+  console.error = (...args) => calls.error.push(args);
+
+  try {
+    await fn();
+    return calls;
+  } finally {
+    console.log = original.log;
+    console.debug = original.debug;
+    console.error = original.error;
+  }
+}
+
+// A call as one string, the way it lands in Cloud Logging: an address hides just
+// as well inside a payload ARGUMENT as in the message, so a scan that only reads
+// string args cannot see it. Same rendering email/marketing/remove-log-privacy
+// scans with.
+function render(args) {
+  return args.map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' ');
+}
+
+// The handler forwards the event context straight to the debug line and to the
+// consumer hook — this is the 1st-gen EventContext shape for a user creation.
+const EVENT_CONTEXT = {
+  eventType: 'providers/firebase.auth/eventTypes/user.create',
+  resource: { service: 'firebaseauth.googleapis.com' },
+};
+
+// The persona's user doc must already exist — that is what sends the handler down
+// its read-only "already exists" branch. Checked before every call so a missing doc
+// fails the test instead of quietly rewriting a shared account.
+async function assertDocExists({ assert, firestore, user }) {
+  const doc = await firestore.get(`users/${user.uid}`);
+
+  assert.equal(!!doc?.auth?.uid, true, `precondition: users/${user.uid} should already exist`);
+}
+
+// Run the thunk with the debug switch in a known state — the logger reads it live.
+async function withDebug(value, fn) {
+  const saved = process.env.OMEGA_DEBUG;
+
+  if (value === undefined) {
+    delete process.env.OMEGA_DEBUG;
+  } else {
+    process.env.OMEGA_DEBUG = value;
+  }
+
+  try {
+    return await fn();
+  } finally {
+    if (saved === undefined) {
+      delete process.env.OMEGA_DEBUG;
+    } else {
+      process.env.OMEGA_DEBUG = saved;
+    }
+  }
+}
+
+async function runHandler({ Manager, user, debug }) {
+  const ctx = Manager.RouteContext({}, { functionName: 'omega_authOnCreate' });
+  const admin = Manager.libraries.admin;
+
+  const calls = await withConsoleRecorder(async () => {
+    await withDebug(debug, async () => {
+      await onCreate({
+        Manager: Manager,
+        ctx: ctx,
+        user: user,
+        context: EVENT_CONTEXT,
+        libraries: { admin: admin },
+      });
+    });
+  });
+
+  return { calls: calls, headlines: calls.log.filter((args) => args[1] === `onCreate: ${user.uid}`) };
+}
+
+module.exports = defineCases({
+  description: 'auth:on-create logs one headline line, full record at debug',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'headline-is-the-uid-alone',
+      run: async ({ assert, Manager, accounts, firestore }) => {
+        const user = await Manager.libraries.admin.auth().getUser(accounts.basic.uid);
+
+        await assertDocExists({ assert: assert, firestore: firestore, user: user });
+
+        const { calls, headlines } = await runHandler({ Manager: Manager, user: user, debug: undefined });
+
+        assert.equal(headlines.length, 1, `expected one headline line, got ${headlines.length}`);
+        assert.equal(headlines[0][1], `onCreate: ${user.uid}`, headlines[0][1]);
+
+        // Prefix + message and nothing else — the record is off this line.
+        assert.equal(headlines[0].length, 2, `the headline carries a payload: ${JSON.stringify(headlines[0].slice(2)).slice(0, 200)}`);
+
+        // And the address is off every line, not just moved along the headline.
+        const leaked = calls.log.filter((args) => render(args).includes(user.email));
+
+        assert.equal(leaked.length, 0, `the email must not ride any log line: ${leaked.map(render).join(' | ').slice(0, 200)}`);
+      },
+    },
+
+    {
+      name: 'the-record-does-not-print-on-a-normal-run',
+      run: async ({ assert, Manager, accounts, firestore }) => {
+        const user = await Manager.libraries.admin.auth().getUser(accounts.basic.uid);
+
+        await assertDocExists({ assert: assert, firestore: firestore, user: user });
+
+        const { calls } = await runHandler({ Manager: Manager, user: user, debug: undefined });
+
+        assert.equal(calls.debug.length, 0, 'the record must stay behind the debug gate by default');
+        assert.equal(calls.log.filter((args) => args.includes(user)).length, 0, 'the record must not ride any log line');
+      },
+    },
+
+    {
+      name: 'the-full-record-is-reachable-with-omega-debug',
+      run: async ({ assert, Manager, accounts, firestore }) => {
+        const user = await Manager.libraries.admin.auth().getUser(accounts.basic.uid);
+
+        await assertDocExists({ assert: assert, firestore: firestore, user: user });
+
+        const { calls } = await runHandler({ Manager: Manager, user: user, debug: '1' });
+
+        const records = calls.debug.filter((args) => args.includes(user));
+
+        assert.equal(records.length, 1, 'the full UserRecord should log once at debug level');
+        assert.equal(records[0].includes(EVENT_CONTEXT), true, 'the event context should ride the debug line too');
+      },
+    },
+  ],
+});

package/test/events/auth-signup-conversion.test.js

@@ -0,0 +1,141 @@
+/**
+ * Test: auth:on-create fires NO conversion
+ * ([#577](https://github.com/Omega-JS-Stack/omega/issues/577), which moved the
+ * server half of `sign_up` off this trigger).
+ *
+ * The trigger used to fire it ([#385](https://github.com/Omega-JS-Stack/omega/issues/385) §4),
+ * and it fired blind: an auth trigger has no HTTP request behind it, so the
+ * registration reached Meta and TikTok with no IP, no user agent, no platform
+ * cookies and an attribution the browser had not posted yet. It now fires from
+ * the post-auth request that carries all four (`routes/user/signup`, covered by
+ * analytics/signup-conversion.test.js).
+ *
+ * Which makes THIS file's job the other half of that decision: the trigger must
+ * stay silent. Two fires with one dedupe id is one registration counted twice on
+ * platforms that merge them and two on the one that does not, so a well-meaning
+ * re-add here is exactly the regression worth a test.
+ *
+ * Real handler, real Manager, real ctx, real Firestore write. The record handed
+ * in is a UserRecord shape for a uid that has no doc yet — the branch a genuine
+ * new account takes. No Auth user is created, so the emulator's own trigger
+ * never races this one; the doc it writes is deleted afterwards.
+ *
+ * Run: npx omega test framework:events/auth-signup-conversion
+ */
+const onCreate = require('../../dist/manager/events/auth/on-create.js');
+const defineCases = require('../../dist/vendor/devkit/test/define-cases.js');
+
+const EVENT_CONTEXT = {
+  eventType: 'providers/firebase.auth/eventTypes/user.create',
+  resource: { service: 'firebaseauth.googleapis.com' },
+};
+
+// A brand-new account, in the UserRecord shape the 1st-gen trigger delivers.
+function newUserRecord(providerId) {
+  const uid = `_test-signup-conversion-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
+
+  return {
+    uid: uid,
+    email: `${uid}@test.invalid`,
+    displayName: 'Casey Buyer',
+    metadata: { creationTime: new Date().toISOString() },
+    providerData: [{ providerId: providerId, email: `${uid}@test.invalid`, displayName: 'Casey Buyer' }],
+  };
+}
+
+// Record every console call the handler makes, restoring console afterward.
+async function withConsoleRecorder(fn) {
+  const calls = { log: [], debug: [], error: [] };
+  const original = { log: console.log, debug: console.debug, error: console.error };
+
+  console.log = (...args) => calls.log.push(args);
+  console.debug = (...args) => calls.debug.push(args);
+  console.error = (...args) => calls.error.push(args);
+
+  try {
+    await fn();
+    return calls;
+  } finally {
+    console.log = original.log;
+    console.debug = original.debug;
+    console.error = original.error;
+  }
+}
+
+/** Run the real handler for a brand-new user; hand back any delivery lines. */
+async function runHandler({ Manager, user }) {
+  const ctx = Manager.RouteContext({}, { functionName: 'omega_authOnCreate' });
+  const admin = Manager.libraries.admin;
+
+  const calls = await withConsoleRecorder(async () => {
+    await onCreate({
+      Manager: Manager,
+      ctx: ctx,
+      user: user,
+      context: EVENT_CONTEXT,
+      libraries: { admin: admin },
+    });
+  });
+
+  const delivery = calls.log
+    .map((args) => String(args[1]))
+    .filter((line) => line.startsWith('deliverConversion: '));
+
+  return { calls: calls, delivery: delivery };
+}
+
+module.exports = defineCases({
+  description: 'auth:on-create writes the doc and fires no conversion (the post-auth request owns sign_up)',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'a-new-account-writes-its-doc-and-delivers-nothing',
+      async run({ assert, Manager, firestore }) {
+        const user = newUserRecord('password');
+
+        try {
+          const { delivery } = await runHandler({ Manager: Manager, user: user });
+
+          assert.deepEqual(delivery, [], `the trigger must fire no conversion — the post-auth request owns it: ${delivery.join(' | ')}`);
+
+          // And the account it is about actually landed.
+          assert.equal(await firestore.exists(`users/${user.uid}`), true, 'the handler still writes the user doc');
+        } finally {
+          await firestore.delete(`users/${user.uid}`);
+        }
+      },
+    },
+
+    {
+      name: 'a-provider-signup-delivers-nothing-either',
+      async run({ assert, Manager, firestore }) {
+        const user = newUserRecord('google.com');
+
+        try {
+          const { delivery } = await runHandler({ Manager: Manager, user: user });
+
+          assert.deepEqual(delivery, [], `no signup path fires from the trigger: ${delivery.join(' | ')}`);
+        } finally {
+          await firestore.delete(`users/${user.uid}`);
+        }
+      },
+    },
+
+    {
+      name: 'an-existing-account-fires-nothing',
+      async run({ assert, Manager, accounts, firestore }) {
+        // A provider link or a re-fired trigger is not a registration. The
+        // handler returns at its "already exists" branch, before any work.
+        const existing = await Manager.libraries.admin.auth().getUser(accounts.basic.uid);
+
+        assert.equal(await firestore.exists(`users/${existing.uid}`), true, 'precondition: the persona already has a doc');
+
+        const { delivery } = await runHandler({ Manager: Manager, user: existing });
+
+        assert.deepEqual(delivery, [], `an existing account must fire no conversion: ${delivery.join(' | ')}`);
+      },
+    },
+  ],
+});