@iann29/rastro 0.9.0 → 0.10.1

package/src/component/metaFake.ts

@@ -0,0 +1,277 @@
+import { SAMPLE_SEED } from "../ui/seed.js";
+import {
+  actId,
+  MetaGraphError,
+  type GraphAd,
+  type GraphPixel,
+  type GraphSpendRow,
+  type MetaGraph,
+} from "./metaGraph.js";
+
+/*
+ * The Meta Graph API under RASTRO_META_FAKE=true: the sample agency of
+ * `@iann29/rastro/ui/sample` (four clients, their ad accounts, catalog and
+ * spend per ad per day), so the example host's demo and the screens' sample
+ * show the same numbers. Any token works except one containing "invalid",
+ * which Meta refuses like an expired token. A token
+ * `rastro-fake-sample-token:<days>` moves every date by that many whole days,
+ * so a demo seeded today reads the sample as its last 30 days, sync after
+ * sync. Conversions API sends are accepted. No network call is made.
+ */
+
+const BUSINESS = { id: "sample-business", name: "Connection Company" };
+const USAGE = { pct: 0, regainMs: null };
+const DAY_MS = 86_400_000;
+const FAKE_SHORT_TOKEN = "rastro-fake-user-token:";
+const FAKE_LONG_TOKEN = "rastro-fake-long-token:";
+const FAKE_SHORT_MS = 2 * 60 * 60 * 1000;
+const FAKE_LONG_MS = 60 * DAY_MS;
+const SHIFT_TOKEN = /^rastro-fake-sample-token:(-?\d{1,5})$/;
+
+/** The whole days a fake token moves the sample by (0 for any other). */
+export function fakeShiftDays(token: string): number {
+  const match = SHIFT_TOKEN.exec(token);
+  return match ? Number(match[1]) : 0;
+}
+
+const shiftDate = (date: string, days: number) =>
+  days === 0
+    ? date
+    : new Date(Date.parse(`${date}T00:00:00Z`) + days * DAY_MS)
+        .toISOString()
+        .slice(0, 10);
+
+/** `total` split over `weights` in whole units, largest remainder first. */
+function spread(total: number, weights: readonly number[]): number[] {
+  const sum = weights.reduce((acc, weight) => acc + weight, 0);
+  if (sum <= 0) return weights.map(() => 0);
+  const raw = weights.map((weight) => (weight / sum) * total);
+  const out = raw.map((value) => Math.floor(value + 1e-9));
+  let left = total - out.reduce((acc, value) => acc + value, 0);
+  const order = raw
+    .map((value, index) => ({ index, rest: value - (out[index] ?? 0) }))
+    .sort((a, b) => b.rest - a.rest || a.index - b.index);
+  for (const { index } of order) {
+    if (left <= 0) break;
+    out[index] = (out[index] ?? 0) + 1;
+    left -= 1;
+  }
+  return out;
+}
+
+type Day = { dayStart: number; spendCents: number | null };
+
+/**
+ * One period of one ad as Meta would report it: the day's spend, and the
+ * sample's reach (48 impressions per real spent, 2.1% of them clicked) spread
+ * over the days by spend, so the period sums to the sample's totals.
+ */
+function periodRows(
+  ad: { adId: string },
+  meta: Omit<
+    GraphSpendRow,
+    "adId" | "date" | "spendCents" | "impressions" | "clicks" | "conversations"
+  >,
+  days: readonly Day[],
+): GraphSpendRow[] {
+  const cents = days.map((day) => day.spendCents ?? 0);
+  const total = cents.reduce((acc, value) => acc + value, 0);
+  const impressions = Math.round((total / 100) * 48);
+  const clicks = Math.round(impressions * 0.021);
+  const dayImpressions = spread(impressions, cents);
+  const dayClicks = spread(clicks, cents);
+  return days.flatMap((day, index) =>
+    (day.spendCents ?? 0) > 0
+      ? [
+          {
+            adId: ad.adId,
+            date: new Date(day.dayStart).toISOString().slice(0, 10),
+            spendCents: day.spendCents ?? 0,
+            impressions: dayImpressions[index] ?? 0,
+            clicks: dayClicks[index] ?? 0,
+            conversations: 0,
+            ...meta,
+          },
+        ]
+      : [],
+  );
+}
+
+interface FakeAccount {
+  adAccountId: string;
+  name: string;
+  currency: string;
+  timezone: string;
+  pixelId: string | null;
+  pixelName: string | null;
+  ads: GraphAd[];
+  rows: GraphSpendRow[];
+}
+
+let accounts: FakeAccount[] | null = null;
+
+function fixtures(): FakeAccount[] {
+  accounts ??= SAMPLE_SEED.map((site) => {
+    const ads: GraphAd[] = [];
+    const rows: GraphSpendRow[] = [];
+    for (const campaign of site.campaigns) {
+      for (const adset of campaign.adsets) {
+        for (const ad of adset.ads) {
+          const names = {
+            adName: ad.name,
+            adsetId: adset.adsetId,
+            adsetName: adset.name,
+            campaignId: campaign.campaignId,
+            campaignName: campaign.name,
+          };
+          ads.push({
+            adId: ad.adId,
+            name: ad.name,
+            effectiveStatus: ad.adStatus,
+            adsetId: adset.adsetId,
+            adsetName: adset.name,
+            campaignId: campaign.campaignId,
+            campaignName: campaign.name,
+            creativeType: ad.creativeType,
+            thumbnailUrl: null,
+          });
+          rows.push(...periodRows(ad, names, ad.daily));
+          if (ad.previousDaily) {
+            rows.push(...periodRows(ad, names, ad.previousDaily));
+          }
+        }
+      }
+    }
+    return {
+      ...site.adAccount,
+      pixelId: site.pixelId,
+      pixelName: site.pixelId ? `Pixel ${site.name}` : null,
+      ads,
+      rows,
+    };
+  });
+  return accounts;
+}
+
+function checkToken(token: string) {
+  if (token.includes("invalid")) {
+    throw new MetaGraphError(
+      "token",
+      "Error validating access token: the session is invalid (fake)",
+      190,
+    );
+  }
+}
+
+function account(adAccountId: string): FakeAccount {
+  const found = fixtures().find(
+    (row) => row.adAccountId === actId(adAccountId),
+  );
+  if (!found) {
+    throw new MetaGraphError(
+      "permission",
+      "ad account not reachable (fake)",
+      200,
+    );
+  }
+  return found;
+}
+
+export function fakeMetaGraph(): MetaGraph {
+  return {
+    async exchangeCode(_app, code) {
+      // Any code logs in except one containing "invalid", refused like an
+      // expired token; the token it yields reads the unshifted sample. A
+      // code containing "user-token" yields a short-lived user token, as a
+      // login without a system user configuration does; any other, a system
+      // user token that never expires.
+      checkToken(code);
+      const clean = code.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 64);
+      return code.includes("user-token")
+        ? {
+            accessToken: `${FAKE_SHORT_TOKEN}${clean}`,
+            expiresInMs: FAKE_SHORT_MS,
+          }
+        : {
+            accessToken: `rastro-fake-login-token:${clean}`,
+            expiresInMs: null,
+          };
+    },
+    async debugToken(_app, token) {
+      checkToken(token);
+      if (token.startsWith(FAKE_SHORT_TOKEN)) {
+        return { type: "USER", expiresAt: Date.now() + FAKE_SHORT_MS };
+      }
+      if (token.startsWith(FAKE_LONG_TOKEN)) {
+        return { type: "USER", expiresAt: Date.now() + FAKE_LONG_MS };
+      }
+      return { type: "SYSTEM_USER", expiresAt: null };
+    },
+    async exchangeLongLived(_app, token) {
+      checkToken(token);
+      return {
+        accessToken: `${FAKE_LONG_TOKEN}${token.slice(FAKE_SHORT_TOKEN.length)}`,
+        expiresInMs: FAKE_LONG_MS,
+      };
+    },
+    async me(token) {
+      checkToken(token);
+      return { ...BUSINESS };
+    },
+    async adAccounts(token) {
+      checkToken(token);
+      return fixtures().map((row) => ({
+        adAccountId: row.adAccountId,
+        name: row.name,
+        currency: row.currency,
+        timezone: row.timezone,
+        accountStatus: 1,
+      }));
+    },
+    async adPixels(token, adAccountId): Promise<GraphPixel[]> {
+      checkToken(token);
+      const row = account(adAccountId);
+      return row.pixelId && row.pixelName
+        ? [{ pixelId: row.pixelId, name: row.pixelName }]
+        : [];
+    },
+    async ads(token, adAccountId, adIds) {
+      checkToken(token);
+      const all = account(adAccountId).ads;
+      return {
+        ads: adIds ? all.filter((ad) => adIds.includes(ad.adId)) : [...all],
+        usage: USAGE,
+        complete: true,
+      };
+    },
+    async insights(token, adAccountId, since, until) {
+      checkToken(token);
+      const days = fakeShiftDays(token);
+      return {
+        rows: account(adAccountId)
+          .rows.map((row) => ({ ...row, date: shiftDate(row.date, days) }))
+          .filter((row) => row.date >= since && row.date <= until),
+        usage: USAGE,
+        complete: true,
+      };
+    },
+    async pixel(token, pixelId) {
+      checkToken(token);
+      if (!fixtures().some((row) => row.pixelId === pixelId)) {
+        throw new MetaGraphError(
+          "permission",
+          "pixel not reachable (fake)",
+          200,
+        );
+      }
+      return { id: pixelId };
+    },
+    async thumbnail() {
+      return null;
+    },
+    async conversions(token, _pixelId, payload) {
+      checkToken(token);
+      return { eventsReceived: payload.data.length, fbtraceId: "fake-trace" };
+    },
+  };
+}