@ssheleg/sheleg-dev 0.5.2 → 0.7.0

package/plugins/sheleg-dev/skills/ad-tracking/SKILL.md

@@ -220,19 +220,11 @@ fbq('track', 'PageView');
 
 ### Standard Events
 
-Meta defines 17 standard events. The most important for SaaS conversion funnels:
-
-| Event | When | Parameters | Notes |
-|---|---|---|---|
-| `PageView` | Every page load | (automatic from base code) | Fires from the init script |
-| `CompleteRegistration` | User signs up | `content_name` (method), `status: true` | Separate from GA4 `sign_up` |
-| `InitiateCheckout` | Checkout started | `value`, `currency`, `content_name`, `content_category`, `num_items` | |
-| `Purchase` | Purchase completed | `value` (required), `currency` (required), `content_name`, `content_category`, `content_type`, `contents[]` | `value` + `currency` are **mandatory** for optimisation |
-| `Subscribe` | Recurring subscription | `value`, `currency`, `predicted_ltv` | Distinct from one-time Purchase |
-| `Lead` | Lead form submitted | (optional params) | |
-| `ViewContent` | Key content viewed | `content_name`, `content_category` | |
-| `AddToCart` | Item added to cart | `content_name`, `value`, `currency` | |
-| `Search` | Search performed | `search_string` | |
+Meta defines 17 standard events. The four that carry a SaaS funnel are
+`CompleteRegistration`, `InitiateCheckout`, `Purchase` and `Subscribe`, and only
+`Purchase` has mandatory parameters: `value` and `currency`, without which Meta
+cannot optimise. The full table — every event, its parameters and the traps —
+is in `references/meta-linkedin.md` → **Standard events**.
 
 ### Deeper Meta and LinkedIn detail
 
@@ -241,68 +233,21 @@ firing wrapper, advanced matching (hashed identifiers, and what must never be
 sent) and CAPI deduplication.
 ## LinkedIn Insight Tag
 
-### Setup
-
-**Env var:** `NEXT_PUBLIC_LINKEDIN_PARTNER_ID` (numeric string)
-
-The LinkedIn Insight Tag is consent-gated (same pattern as Meta Pixel). It loads the `insight.min.js` script and includes a noscript pixel fallback.
-
-```javascript
-_linkedin_partner_id = "PARTNER_ID";
-window._linkedin_data_partner_ids = window._linkedin_data_partner_ids || [];
-window._linkedin_data_partner_ids.push(_linkedin_partner_id);
-```
-
-### Conversion Tracking
-
-LinkedIn conversions are configured in Campaign Manager (not in code). The Insight Tag automatically tracks page views, and you define URL-based conversion rules in the LinkedIn Campaign Manager:
-
-1. Campaign Manager → Analyze → Conversion tracking → Create conversion
-2. Define URL rules (e.g. `/thank-you`, `/onboarding`)
-3. LinkedIn Insight Tag automatically matches page loads to conversion rules
-
-For event-based conversions, use `window.lintrk('track', { conversion_id: 123456 })`.
-
-**Docs:**
-- [LinkedIn Insight Tag setup](https://www.linkedin.com/help/lms/answer/a418880)
-- [LinkedIn conversion tracking](https://www.linkedin.com/help/lms/answer/a423304)
-
----
+Consent-gated on the same wrapper as the Meta Pixel, env var
+`NEXT_PUBLIC_LINKEDIN_PARTNER_ID`. Conversions are configured in Campaign Manager
+rather than in code, so there is nothing to deduplicate and nothing that fails
+silently in the bundle — but a URL rule on a refreshable page counts every
+refresh. Setup snippet, the Campaign Manager steps and `lintrk` are in
+`references/meta-linkedin.md` → **LinkedIn conversion tracking**.
 
 ## User Identification
 
-### Cross-Platform Identification Strategy
-
-| Platform | Method | When | What it enables |
-|---|---|---|---|
-| GA4 | `user_id` via `gtag('config', TAG_ID, { user_id })` | After login/onboarding | Cross-device tracking, audience building |
-| GA4 | Enhanced Conversions via `gtag('set', 'user_data', { email })` | After login/onboarding | Better conversion attribution |
-| Meta Pixel | Advanced Matching via `fbq('init', PIXEL_ID, { em, fn })` | After login/onboarding | Better conversion attribution, larger custom audiences |
-| Mixpanel | `alias()` + `identify()` | After login/onboarding | Merge anonymous → identified user profiles |
-
-**All identification calls should be placed in a single identification component** that runs in the dashboard/authenticated layout. This ensures:
-- User data is sent once per session
-- All platforms receive identification data at the same time
-- Pre-login anonymous events merge into the identified profile
-
-### Alias vs Identify (Mixpanel)
-
-- `alias(userId, anonymousId)` — creates a permanent link between the anonymous and real user ID. Must be called **exactly once** per user, **before** `identify()`. Use a localStorage flag to prevent duplicate calls.
-- `identify(userId)` — sets the user ID for all subsequent events.
-
-### Timing
-
-Fire identification in a `useEffect` in the authenticated layout:
-
-```typescript
-useEffect(() => {
-  // 1. Mixpanel alias + identify
-  // 2. GA4 user_id + Enhanced Conversions
-  // 3. Meta Advanced Matching
-}, [userId, email, name]);
-```
-
----
+One rule the body keeps, because getting it wrong corrupts attribution rather
+than losing it: **identify before you track, never after**. An event fired for an
+anonymous id and re-attributed later is two users to every platform that already
+ingested it. The per-platform strategy, the Mixpanel `alias` vs `identify`
+distinction and the timing rules are in `references/event-tracking.md` →
+**User identification**.
 
 ## Event naming
 
@@ -316,9 +261,13 @@ schema and the full purchase / add_to_cart / begin_checkout set.
 
 **Deduplication is the part that silently doubles revenue.** A purchase fired
 from both the browser and the server (Conversions API, server-side GA4) must
-carry the SAME `event_id` / `transaction_id`, or both are counted. Test it by
-reloading the thank-you page: a purchase that increments twice is a
-deduplication bug, not a tracking success.
+carry the SAME `event_id` / `transaction_id`, or both are counted. Run
+`fixtures/assert-dedup-contract.mjs` rather than reloading the thank-you page:
+`pixel-and-capi-carry-one-event-id` and `pixel-and-capi-carry-one-event-name` fail an
+emitter that shares one field and not the other,
+`no-purchase-reported-before-the-charge-cleared` fails one that reports from the redirect,
+and `the-browser-event-is-kept` fails one that drops the pixel. `--self-test` deletes each
+rule and watches the matching assertion go red.
 
 **A purchase is not a browser event, and that decides where it comes from.**
 Every other event on the list is something a person did in a tab, so the browser

package/plugins/sheleg-dev/skills/ad-tracking/fixtures/README.md

@@ -0,0 +1,76 @@
+# Deduplication fixtures and the assertion pack
+
+**Copy this whole directory into your repository.** It is the executable half of what
+`SKILL.md` → *E-commerce* and `references/meta-linkedin.md` →
+*Deduplication with the Conversions API* state in prose: the three payloads one purchase
+produces, six assertions a correct emitter must pass, and a self-test that breaks the
+emitter one rule at a time so you can watch every assertion fail.
+
+```bash
+node assert-dedup-contract.mjs              # 6 assertions against the reference emitter
+node assert-dedup-contract.mjs --self-test  # break one rule at a time; every assertion must go red
+```
+
+No dependencies, no network, **no access token anywhere in this directory** — the sink
+collects what would have been sent.
+
+## Contents
+
+- [The fixtures](#the-fixtures)
+- [The assertions](#the-assertions)
+- [What each mutant deletes](#what-each-mutant-deletes)
+- [Why the browser side is read from the fixture](#why-the-browser-side-is-read-from-the-fixture)
+- [Placeholders](#placeholders)
+
+## The fixtures
+
+| File | What it is |
+|---|---|
+| `purchase-pixel-browser.json` | the four arguments of the browser call: `fbq('track', 'Purchase', custom_data, { eventID })` |
+| `purchase-capi-server.json` | the Conversions API request body the **webhook** sends for the same purchase |
+| `purchase-capi-from-thank-you-page.json` | the body a thank-you-page-sourced emitter sends for a session whose charge never cleared — **the payload that must never exist**, kept so the assertion can name it |
+
+The first two carry the same `event_id` and the byte-equal `event_name`, which is the
+contract. The third is the defect, recorded rather than described: it was produced by
+running the reference emitter with `webhook-sourced` removed.
+
+## The assertions
+
+| Assertion | What a wrong emitter does |
+|---|---|
+| `pixel-and-capi-carry-one-event-id` | generates an id per emission, so Meta counts one purchase twice |
+| `pixel-and-capi-carry-one-event-name` | sends `Purchase` from the browser and `purchase` from the server: a shared id that deduplicates nothing |
+| `no-purchase-reported-before-the-charge-cleared` | reports the purchase from the one place that cannot know the money moved |
+| `the-browser-event-is-kept` | drops the browser event, losing the click id, the consent state and the session |
+| `identifiers-reach-the-server-hashed` | puts the address itself in `user_data.em` |
+| `the-shipped-capi-fixture-is-what-a-correct-emitter-sends` | anything that changes the body — a ratchet, so the fixtures you copy are the reference output |
+
+## What each mutant deletes
+
+| Rule | The code it removes | The integration that ships without it |
+|---|---|---|
+| `shared-event-id` | reading the id written once at session creation | `crypto.randomUUID()` at each emission |
+| `exact-event-name` | the one `event_name` constant used by both sides | `'Purchase'` in the browser, a lowercased variant on the server |
+| `webhook-sourced` | the gate that keeps the thank-you page from reporting | fires the conversion where the redirect lands |
+| `keep-browser-event` | the pixel call | server-only, and blind to everything the browser carries |
+| `hashed-identifiers` | the SHA-256 of the identifier | hands the raw address to the wrapper, which hashes whatever it is given |
+
+## Why the browser side is read from the fixture
+
+`pixel-and-capi-carry-one-event-id` and `pixel-and-capi-carry-one-event-name` compare the
+server's output against `purchase-pixel-browser.json` rather than against the pixel call the
+same emitter just made. That is deliberate, and it is the correction of a first pass:
+reading both sides out of one emitter meant deleting `keep-browser-event` also turned those
+two assertions red, so neither the id rule nor the name rule was proven on its own. Two
+mechanisms that both explain a passing fixture leave both untested. The fixture is the
+browser's contract, held at a boundary the server does not control.
+
+`--self-test` fails if any rule has no fixture that isolates it, so this stays true.
+
+## Placeholders
+
+`usr_PLACEHOLDER_carol`, `prod_PLACEHOLDER_pro`, `fb.1.…PLACEHOLDERCLICKID`,
+`203.0.113.10` (a documentation address). The email is `placeholder@example.invalid` and
+the 64-hex string is its SHA-256 — a hash of a published placeholder, not of a person. No
+pixel id, no dataset id and no access token appear here: the token is a runtime secret and
+`references/performance-security.md` is where it belongs.

package/plugins/sheleg-dev/skills/ad-tracking/fixtures/assert-dedup-contract.mjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+// The assertions a correct purchase emitter must pass, and the proof that each one can
+// fail.
+//
+//   node assert-dedup-contract.mjs              # run them against the reference emitter
+//   node assert-dedup-contract.mjs --self-test  # break the emitter one rule at a time
+//
+// `--self-test` is what makes this evidence: for every assertion it deletes the rule whose
+// removal MUST turn that assertion red, and fails if the assertion still passes. It then
+// prints which fixture ISOLATES each rule — because two rules that both explain a passing
+// fixture mean neither is tested.
+//
+// The runner is duplicated from `stripe-billing/fixtures/assert-money-invariants.mjs` on
+// purpose. A reader installs one skill, not six, so a shared import would resolve to
+// nothing in the common case; this pack has to run from its own directory alone.
+//
+// No network, no filesystem writes, no clock, and no access token anywhere in this
+// directory — the sink collects what WOULD have been sent.
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import assert from 'node:assert/strict';
+import { createSink, createEmitter, RULES, EVENT_NAME } from './reference-emitter.mjs';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const fixture = (name) => JSON.parse(readFileSync(path.join(HERE, name), 'utf8'));
+
+const PIXEL_BROWSER = 'purchase-pixel-browser.json';
+const CAPI_SERVER = 'purchase-capi-server.json';
+const CAPI_FORBIDDEN = 'purchase-capi-from-thank-you-page.json';
+
+/** The purchase is read OUT of the fixture, so the values have one home. */
+function purchaseFrom(name, cleared) {
+  const event = fixture(name).data[0];
+  return {
+    conversionEventId: event.event_id,
+    value: event.custom_data.value,
+    currency: event.custom_data.currency,
+    contentIds: event.custom_data.content_ids,
+    numItems: event.custom_data.num_items,
+    externalId: event.user_data.external_id[0],
+    emailSha256: event.user_data.em[0],
+    // The raw address a wrong emitter would send instead. sha256 of this string is the
+    // `em` above, so the two fixtures are consistent and neither is a real person.
+    email: 'placeholder@example.invalid',
+    clientIpAddress: event.user_data.client_ip_address,
+    clientUserAgent: event.user_data.client_user_agent,
+    fbp: event.user_data.fbp,
+    fbc: event.user_data.fbc,
+    eventTime: event.event_time,
+    eventSourceUrl: event.event_source_url,
+    cleared,
+  };
+}
+
+/** Carol paid by card: the charge cleared, and the webhook says so. */
+const CLEARED = () => purchaseFrom(CAPI_SERVER, true);
+/** Bob chose a bank debit: the session completed, the money has not moved and may not. */
+const NOT_CLEARED = () => purchaseFrom(CAPI_FORBIDDEN, false);
+
+function harness(without = []) {
+  const sink = createSink();
+  return { sink, emitter: createEmitter(sink, { without }) };
+}
+
+/** The real sequence: the browser fires on the thank-you page, the webhook lands when it lands. */
+function runPurchase({ sink, emitter }, purchase) {
+  emitter.onThankYouPage(purchase);
+  if (purchase.cleared) emitter.onChargeCleared(purchase);
+  return sink;
+}
+
+export const INVARIANTS = [
+  {
+    id: 'pixel-and-capi-carry-one-event-id',
+    fixtures: [PIXEL_BROWSER, CAPI_SERVER],
+    states: 'one id, generated once and used by both sides, or the revenue counts twice',
+    breaks: ['shared-event-id'],
+    run({ sink, emitter }) {
+      runPurchase({ sink, emitter }, CLEARED());
+      // The browser side is read from the SHIPPED fixture rather than from the sink. That
+      // is deliberate: it keeps this assertion independent of whether the browser event
+      // fired at all, which is a different rule with its own fixture. Reading both sides
+      // out of one emitter is how the two got tangled on the first pass.
+      const pixelId = fixture(PIXEL_BROWSER)[3].eventID;
+      const serverId = sink.capi[0].data[0].event_id;
+      assert.equal(serverId, pixelId,
+        `the pixel carries ${pixelId} and the server sent ${serverId} — nothing will ever `
+        + 'deduplicate these two, and one purchase is two conversions');
+    },
+  },
+  {
+    id: 'pixel-and-capi-carry-one-event-name',
+    fixtures: [PIXEL_BROWSER, CAPI_SERVER],
+    states: 'Meta compares the name as well as the id, and the name is the half that is missed',
+    breaks: ['exact-event-name'],
+    run({ sink, emitter }) {
+      runPurchase({ sink, emitter }, CLEARED());
+      const pixelName = fixture(PIXEL_BROWSER)[1];   // the browser contract, not the sink
+      const serverName = sink.capi[0].data[0].event_name;
+      assert.equal(serverName, pixelName,
+        `'${pixelName}' in the browser and '${serverName}' on the server: a shared id `
+        + 'deduplicates nothing when the names differ');
+      assert.equal(serverName, EVENT_NAME);
+    },
+  },
+  {
+    id: 'no-purchase-reported-before-the-charge-cleared',
+    fixtures: [CAPI_FORBIDDEN],
+    states: 'the thank-you page has no idea whether the money moved, so it reports nothing',
+    breaks: ['webhook-sourced'],
+    run({ sink, emitter }) {
+      runPurchase({ sink, emitter }, NOT_CLEARED());
+      assert.equal(sink.capi.length, 0,
+        'a Conversions API purchase was sent for a charge that has not cleared — this is '
+        + 'the event that exists for every session that reached the page and for no refund');
+      assert.equal(sink.pixel.length, 0,
+        'a Purchase pixel fired for a session whose payment is still pending');
+      assert.notDeepEqual(sink.capi[0], fixture(CAPI_FORBIDDEN));
+    },
+  },
+  {
+    id: 'the-browser-event-is-kept',
+    fixtures: [PIXEL_BROWSER],
+    states: 'the browser event stays and stays subordinate — it carries the click ids',
+    breaks: ['keep-browser-event'],
+    run({ sink, emitter }) {
+      runPurchase({ sink, emitter }, CLEARED());
+      assert.equal(sink.pixel.length, 1,
+        'no browser event fired: the click id, the consent state and the session are lost, '
+        + 'and only the browser had them');
+      assert.equal(sink.pixel[0][0], 'track');
+    },
+  },
+  {
+    id: 'identifiers-reach-the-server-hashed',
+    fixtures: [CAPI_SERVER],
+    states: 'advanced matching sends hashes, never the address itself',
+    breaks: ['hashed-identifiers'],
+    run({ sink, emitter }) {
+      runPurchase({ sink, emitter }, CLEARED());
+      const userData = sink.capi[0].data[0].user_data;
+      for (const value of userData.em) {
+        assert.match(value, /^[0-9a-f]{64}$/,
+          `user_data.em carried ${JSON.stringify(value)} — a raw identifier, not a sha256`);
+      }
+      assert.ok(!JSON.stringify(userData).includes('@'),
+        'user_data carries something with an @ in it');
+    },
+  },
+  {
+    id: 'the-shipped-capi-fixture-is-what-a-correct-emitter-sends',
+    fixtures: [CAPI_SERVER, PIXEL_BROWSER],
+    states: 'the fixtures are the reference output, byte for byte — not an illustration',
+    // Broad by construction: it compares the whole body, so every rule that changes any
+    // field turns it red. It is here so a reader can trust the fixtures they copy.
+    breaks: ['shared-event-id', 'exact-event-name', 'hashed-identifiers', 'keep-browser-event'],
+    run({ sink, emitter }) {
+      runPurchase({ sink, emitter }, CLEARED());
+      assert.deepEqual(sink.capi[0], fixture(CAPI_SERVER));
+      assert.deepEqual(sink.pixel[0], fixture(PIXEL_BROWSER));
+    },
+  },
+];
+
+// ------------------------------------------------------------------------- runners
+
+async function runOne(invariant, without) {
+  const context = harness(without);
+  try {
+    await invariant.run(context);
+    return null;
+  } catch (error) {
+    return error.message.split('\n')[0];
+  }
+}
+
+async function runAll() {
+  let failed = 0;
+  for (const invariant of INVARIANTS) {
+    const why = await runOne(invariant, []);
+    if (why) {
+      failed += 1;
+      console.error(`FAIL ${invariant.id}\n     ${why}`);
+    } else {
+      console.log(`pass ${invariant.id} — ${invariant.states}`);
+    }
+  }
+  if (failed) {
+    console.error(`\n${failed} of ${INVARIANTS.length} deduplication assertions failed`);
+    return 1;
+  }
+  console.log(`\nOK: ${INVARIANTS.length} deduplication assertions hold against the emitter`);
+  return 0;
+}
+
+async function selfTest() {
+  const problems = [];
+  const matrix = [];
+  for (const invariant of INVARIANTS) {
+    const broke = [];
+    for (const rule of RULES) {
+      if (await runOne(invariant, [rule])) broke.push(rule);
+    }
+    matrix.push({ id: invariant.id, broke });
+    const expected = [...invariant.breaks].sort().join(', ');
+    const measured = [...broke].sort().join(', ');
+    if (expected !== measured) {
+      problems.push(`${invariant.id}: declares breaks [${expected || '-'}], measured [${measured || '-'}]`);
+    }
+    if (broke.length === 0) {
+      problems.push(`${invariant.id}: no mutant breaks it — the assertion cannot fail`);
+    }
+  }
+
+  const width = Math.max(...matrix.map((row) => row.id.length));
+  console.log(`\nassertion x mutant — ${RULES.length} mutants, `
+    + 'and which removed rule turns each assertion red\n');
+  for (const row of matrix) {
+    console.log(`  ${row.id.padEnd(width)}  ${row.broke.join(', ') || '(nothing)'}`);
+  }
+
+  console.log('\nisolation — the fixture that separates each rule from every other\n');
+  for (const rule of RULES) {
+    const isolating = matrix.filter((row) => row.broke.length === 1 && row.broke[0] === rule);
+    if (isolating.length) {
+      console.log(`  ${rule.padEnd(20)} ${isolating.map((r) => r.id).join(', ')}`);
+    } else {
+      problems.push(`no fixture isolates ${rule} — every assertion it breaks is also broken `
+        + 'by another rule, so neither is proven');
+    }
+  }
+
+  if (problems.length) {
+    console.error(`\nFAIL: ${problems.length} problem(s) with the assertion pack itself`);
+    for (const p of problems) console.error(`  - ${p}`);
+    return 1;
+  }
+  console.log(`\nOK: ${INVARIANTS.length} assertions, each watched failing; `
+    + `${RULES.length} rules, each isolated by a fixture`);
+  return 0;
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const mode = process.argv.includes('--self-test') ? selfTest : runAll;
+  process.exit(await mode());
+}

package/plugins/sheleg-dev/skills/ad-tracking/fixtures/manifest.json

@@ -0,0 +1,75 @@
+{
+  "skill": "ad-tracking",
+  "assertionPack": "assert-dedup-contract.mjs",
+  "referenceHandler": "reference-emitter.mjs",
+  "runbook": "README.md",
+  "note": "The single home of the invariant -> fixture -> document mapping. test/validate.py in this repository reads it: every fixture must be claimed by a row, every row's fixtures must exist, and every claiming document must still carry its phrase, name the invariant id, and name a path under fixtures/. A claim whose fixture is gone and a fixture nobody claims are both failures.",
+  "invariants": [
+    {
+      "id": "pixel-and-capi-carry-one-event-id",
+      "isolates": "shared-event-id",
+      "fixtures": ["purchase-pixel-browser.json", "purchase-capi-server.json"],
+      "claimedBy": [
+        {
+          "document": "SKILL.md",
+          "phrase": "carry the SAME `event_id` / `transaction_id`, or both are counted."
+        }
+      ]
+    },
+    {
+      "id": "pixel-and-capi-carry-one-event-name",
+      "isolates": "exact-event-name",
+      "fixtures": ["purchase-pixel-browser.json", "purchase-capi-server.json"],
+      "claimedBy": [
+        {
+          "document": "references/meta-linkedin.md",
+          "phrase": "**Two fields must match, not one.**"
+        }
+      ]
+    },
+    {
+      "id": "no-purchase-reported-before-the-charge-cleared",
+      "isolates": "webhook-sourced",
+      "fixtures": ["purchase-capi-from-thank-you-page.json"],
+      "claimedBy": [
+        {
+          "document": "SKILL.md",
+          "phrase": "**A purchase is not a browser event, and that decides where it comes from.**"
+        }
+      ]
+    },
+    {
+      "id": "the-browser-event-is-kept",
+      "isolates": "keep-browser-event",
+      "fixtures": ["purchase-pixel-browser.json"],
+      "claimedBy": [
+        {
+          "document": "SKILL.md",
+          "phrase": "**The browser event stays, and it stays subordinate.**"
+        }
+      ]
+    },
+    {
+      "id": "identifiers-reach-the-server-hashed",
+      "isolates": "hashed-identifiers",
+      "fixtures": ["purchase-capi-server.json"],
+      "claimedBy": [
+        {
+          "document": "references/meta-linkedin.md",
+          "phrase": "SHA-256 does **not** make a value safe to send"
+        }
+      ]
+    },
+    {
+      "id": "the-shipped-capi-fixture-is-what-a-correct-emitter-sends",
+      "isolates": null,
+      "fixtures": ["purchase-capi-server.json", "purchase-pixel-browser.json"],
+      "claimedBy": [
+        {
+          "document": "references/meta-linkedin.md",
+          "phrase": "the fixtures are the reference output rather than an illustration"
+        }
+      ]
+    }
+  ]
+}

package/plugins/sheleg-dev/skills/ad-tracking/fixtures/purchase-capi-from-thank-you-page.json

@@ -0,0 +1,32 @@
+{
+  "data": [
+    {
+      "event_name": "Purchase",
+      "event_time": 1767312000,
+      "event_id": "evtid_PLACEHOLDER_purchase_bob",
+      "event_source_url": "https://example.invalid/after",
+      "action_source": "website",
+      "user_data": {
+        "em": [
+          "34aeb9fb3be8b407bdd0beb712d571974bbddbb5bfc0e41cb666331ee5fcc47b"
+        ],
+        "external_id": [
+          "usr_PLACEHOLDER_bob"
+        ],
+        "client_ip_address": "203.0.113.10",
+        "client_user_agent": "Mozilla/5.0 (PLACEHOLDER user agent)",
+        "fbp": "fb.1.1767312000.9876543210",
+        "fbc": "fb.1.1767312000.PLACEHOLDERCLICKID"
+      },
+      "custom_data": {
+        "value": 29,
+        "currency": "USD",
+        "content_ids": [
+          "prod_PLACEHOLDER_pro"
+        ],
+        "content_type": "product",
+        "num_items": 1
+      }
+    }
+  ]
+}

package/plugins/sheleg-dev/skills/ad-tracking/fixtures/purchase-capi-server.json

@@ -0,0 +1,26 @@
+{
+  "data": [
+    {
+      "event_name": "Purchase",
+      "event_time": 1767398400,
+      "event_id": "evtid_PLACEHOLDER_purchase_carol",
+      "event_source_url": "https://example.invalid/after",
+      "action_source": "website",
+      "user_data": {
+        "em": ["34aeb9fb3be8b407bdd0beb712d571974bbddbb5bfc0e41cb666331ee5fcc47b"],
+        "external_id": ["usr_PLACEHOLDER_carol"],
+        "client_ip_address": "203.0.113.10",
+        "client_user_agent": "Mozilla/5.0 (PLACEHOLDER user agent)",
+        "fbp": "fb.1.1767398400.1234567890",
+        "fbc": "fb.1.1767398400.PLACEHOLDERCLICKID"
+      },
+      "custom_data": {
+        "value": 29.0,
+        "currency": "USD",
+        "content_ids": ["prod_PLACEHOLDER_pro"],
+        "content_type": "product",
+        "num_items": 1
+      }
+    }
+  ]
+}

package/plugins/sheleg-dev/skills/ad-tracking/fixtures/purchase-pixel-browser.json

@@ -0,0 +1,12 @@
+[
+  "track",
+  "Purchase",
+  {
+    "value": 29.0,
+    "currency": "USD",
+    "content_ids": ["prod_PLACEHOLDER_pro"],
+    "content_type": "product",
+    "num_items": 1
+  },
+  { "eventID": "evtid_PLACEHOLDER_purchase_carol" }
+]