create-ailk 0.1.0

package/templates/apps/api/src/routes/content/slug.ts

@@ -0,0 +1,9 @@
+/**
+ * Slug allowlist for D14a content-write routes.
+ *
+ * Re-exported from `@working-theory/content-adapters` (single source of truth, per
+ * issue #398). The adapter sanitizes slug + type before any path
+ * construction or git argument; this regex is the route-layer fail-fast
+ * mirror so malformed input gets a 400 before reaching the adapter.
+ */
+export { SLUG_PATTERN } from "@working-theory/content-adapters";

package/templates/apps/api/src/routes/content/update.ts

@@ -0,0 +1,111 @@
+/**
+ * PATCH /v1/content/:type/:slug
+ *
+ * Updates an existing page of `:type` at `:slug`. Paid-licensed deploys only.
+ *
+ * Optimistic locking is mandatory: the request MUST carry an `If-Match`
+ * header containing the `version` token returned by a prior read or write.
+ * Missing/empty header → 409. Stale token → 409 with `details.currentVersion`
+ * echoed so the caller can re-fetch and retry.
+ *
+ * 404 when the page does not exist.
+ *
+ * Adapter errors (`AdapterWriteError("not_found" | "conflict" | …)`) are
+ * translated by the hoisted `mapAdapterError` from `@working-theory/content-adapters`
+ * (issue #398) — single source of truth across the API + MCP surfaces.
+ */
+import {
+  FrontmatterSchema,
+  SCHEMA_ORG_TYPES,
+  type SchemaOrgType,
+} from "@working-theory/content-adapters";
+import type { FastifyPluginAsync, FastifyReply } from "fastify";
+import { z } from "zod";
+
+import { getContentAdapter } from "../../lib/content-adapter.js";
+import {
+  adapterErrorResponse,
+  conflictError,
+  validationError,
+  type ErrorBody,
+} from "../../lib/errors.js";
+import { requirePaidTier } from "../../lib/require-paid-tier.js";
+
+import { SLUG_PATTERN } from "./slug.js";
+
+const paramsSchema = z.object({
+  type: z.enum(SCHEMA_ORG_TYPES),
+  slug: z.string().regex(SLUG_PATTERN),
+});
+
+const writeBodySchema = FrontmatterSchema.extend({ body: z.string().min(1) });
+
+function send(reply: FastifyReply, status: number, body: ErrorBody) {
+  return reply.status(status).send(body);
+}
+
+export const updatePageRoute: FastifyPluginAsync = async (fastify) => {
+  fastify.patch<{
+    Params: { type: string; slug: string };
+    Body: unknown;
+  }>(
+    "/v1/content/:type/:slug",
+     
+    { preHandler: requirePaidTier },
+    async (request, reply) => {
+      const params = paramsSchema.safeParse(request.params);
+      if (!params.success) {
+        const err = validationError("Invalid type or slug", {
+          issues: params.error.issues,
+        });
+        return send(reply, err.status, err.body);
+      }
+
+      const ifMatch = request.headers["if-match"];
+      if (typeof ifMatch !== "string" || ifMatch.length === 0) {
+        const err = conflictError(
+          "Missing required If-Match header (version token)",
+        );
+        return send(reply, err.status, err.body);
+      }
+
+      const parsed = writeBodySchema.safeParse(request.body);
+      if (!parsed.success) {
+        const err = validationError("Invalid request body", {
+          issues: parsed.error.issues,
+        });
+        return send(reply, err.status, err.body);
+      }
+
+      const { type, slug } = params.data;
+      const { body: pageBody, ...page } = parsed.data;
+
+      if (page.type !== type || page.slug !== slug) {
+        const err = validationError(
+          "Body `type`/`slug` must match URL params",
+          {
+            url: { type, slug },
+            body: { type: page.type, slug: page.slug },
+          },
+        );
+        return send(reply, err.status, err.body);
+      }
+
+      try {
+        const adapter = getContentAdapter();
+        const result = await adapter.updatePage(
+          type as SchemaOrgType,
+          slug,
+          { ...page, body: pageBody },
+          { ifMatch },
+        );
+        return reply.status(200).send(result);
+      } catch (error) {
+        const err = adapterErrorResponse(error, { type, slug });
+        if (err) return send(reply, err.status, err.body);
+        request.log.error({ err: error }, "[Content] updatePage failed");
+        return reply.status(500).send({ error: "Internal server error" });
+      }
+    },
+  );
+};

package/templates/apps/api/src/routes/leads/__tests__/index.test.ts

@@ -0,0 +1,415 @@
+/**
+ * @file index.test.ts
+ * Route-level inject tests for POST /api/leads/:kind
+ *
+ * Property under test: attacker-supplied `id` in the request body is never
+ * persisted. buildInput() explicitly destructures only known fields (first wall).
+ * The discriminatedUnion .strict() schema rejects unknown keys (second wall).
+ *
+ * These tests exercise both walls together at the HTTP boundary.
+ *
+ * Real dependencies (Issue #507):
+ *   - appendLeadRecord (lead-capture-store): real — writes to LEAD_CAPTURE_FILE temp file
+ *   - writeLeadFallback (file-fallback): real — writes to AILK_INBOX_FALLBACK_DIR temp dir
+ *   - enrichLead (enrichment-shim): real — pass-through shim (no network calls in tests)
+ *
+ * Mocked:
+ *   - prisma (lib/prisma.js): manual mock via __mocks__/prisma.ts — inbox models added
+ *   - @working-theory/email: external package boundary — stays mocked
+ *   - @working-theory/license: consumed by enrichment-shim; stays mocked to avoid license key dep
+ */
+
+import * as fs from "fs/promises";
+
+import type { FastifyInstance } from "fastify";
+
+// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts activates the auto-mock (Jest requires explicit call for local files)
+jest.mock("../../../lib/prisma.js");
+
+jest.mock("@working-theory/email", () => ({
+  sendLeadNotification: jest.fn().mockResolvedValue({
+    ok: true,
+    messageId: "msg-test",
+  }),
+}));
+
+// @working-theory/license: consumed transitively by enrichment-shim; mocked to avoid
+// needing a license key in tests.
+jest.mock("@working-theory/license", () => ({
+  checkLicense: jest.fn().mockResolvedValue({
+    tier: "free",
+    plan: null,
+    features: [],
+    expiresAt: null,
+    revoked: false,
+  }),
+}));
+
+import {
+  leadSubmitRoute,
+  leadSubscribeRoute,
+  leadCallbackRoute,
+} from "../index";
+import { prisma } from "../../../lib/prisma.js";
+import { setupLeadFileEnv } from "../../../__tests__/factories/lead-fixture";
+
+const fileEnv = setupLeadFileEnv("index");
+
+// ─── Suite setup ──────────────────────────────────────────────────────────────
+
+describe("POST /api/leads — id isolation", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
+    process.env.DATABASE_URL = "postgres://stub";
+
+    const fastify = require("fastify")();
+    await fastify.register(leadSubmitRoute);
+    await fastify.register(leadSubscribeRoute);
+    await fastify.register(leadCallbackRoute);
+    app = fastify;
+  });
+
+  afterEach(async () => {
+    await app.close();
+    delete process.env.AILK_LEAD_NOTIFICATION_TO;
+    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
+    delete process.env.DATABASE_URL;
+    delete process.env.LEAD_CAPTURE_FILE_DISABLED;
+    delete process.env.LEAD_CAPTURE_INCLUDE_IP;
+  });
+
+  it("POST /api/leads/lead — attacker-supplied id is not returned (server uuid used)", async () => {
+    const serverGeneratedId = "cuid-lead-server-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        id: "attacker",
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "test@example.com",
+        payload: { message: "hello" },
+      },
+    });
+
+    // buildInput drops `id` before it reaches validation or persistence.
+    // The schema's .strict() would also reject it — both walls active.
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      const body = res.json();
+      expect(body.id).not.toBe("attacker");
+      expect(body.id).toBe(serverGeneratedId);
+    }
+  });
+
+  it("POST /api/leads/subscribe — attacker-supplied id is not returned (server uuid used)", async () => {
+    const serverGeneratedId = "cuid-sub-server-1";
+    (prisma.subscriber.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/subscribe",
+      payload: {
+        id: "attacker",
+        kind: "subscribe",
+        siteId: "site-abc",
+        email: "sub@example.com",
+        source: "footer",
+      },
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      const body = res.json();
+      expect(body.id).not.toBe("attacker");
+      expect(body.id).toBe(serverGeneratedId);
+    }
+  });
+
+  it("POST /api/leads/callback — attacker-supplied id is not returned (server uuid used)", async () => {
+    const serverGeneratedId = "cuid-cb-server-1";
+    (prisma.callback.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/callback",
+      payload: {
+        id: "attacker",
+        kind: "callback",
+        siteId: "site-abc",
+        name: "Alice",
+        phone: "+15551234567",
+        payload: { notes: "urgent" },
+      },
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      const body = res.json();
+      expect(body.id).not.toBe("attacker");
+      expect(body.id).toBe(serverGeneratedId);
+    }
+  });
+
+  // ── Lead capture store integration cases ──────────────────────────────────
+
+  it("file-on-success — appendLeadRecord writes to LEAD_CAPTURE_FILE on successful DB persist", async () => {
+    const serverGeneratedId = "cuid-file-success-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "test@example.com",
+        payload: { message: "hello" },
+      },
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      expect(res.json().id).toBe(serverGeneratedId);
+      const record = await fileEnv.readLastCaptureRecord();
+      expect(record.id).toBe(serverGeneratedId);
+      expect(record.source).toBe("contact");
+    }
+  });
+
+  it("dual-write — real lead-capture-store AND DB are both invoked on success", async () => {
+    const serverGeneratedId = "cuid-dual-write-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "dual@example.com",
+        payload: { message: "dual-write test" },
+      },
+    });
+
+    if (res.statusCode === 201) {
+      expect(prisma.lead.create).toHaveBeenCalledTimes(1);
+      const record = await fileEnv.readLastCaptureRecord();
+      expect(typeof record.id).toBe("string");
+    }
+  });
+
+  it("disabled — appendLeadRecord is skipped when LEAD_CAPTURE_FILE_DISABLED=true", async () => {
+    process.env.LEAD_CAPTURE_FILE_DISABLED = "true";
+
+    const serverGeneratedId = "cuid-disabled-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "disabled@example.com",
+        payload: { message: "no file" },
+      },
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      // The real lead-capture-store short-circuits when LEAD_CAPTURE_FILE_DISABLED=true.
+      // The capture file must not be written.
+      await expect(
+        fs.access(fileEnv.getCaptureFilePath()),
+      ).rejects.toThrow();
+    }
+  });
+
+  it("config_missing — 503 with lead_capture_not_configured when file disabled and no DATABASE_URL", async () => {
+    process.env.LEAD_CAPTURE_FILE_DISABLED = "true";
+    delete process.env.DATABASE_URL;
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "nocapture@example.com",
+        payload: { message: "no config" },
+      },
+    });
+
+    expect(res.statusCode).toBe(503);
+    const body = res.json();
+    expect(body.error).toBe("lead_capture_not_configured");
+    expect(body.message).toBe("Lead capture is not configured.");
+    expect(prisma.lead.create).not.toHaveBeenCalled();
+  });
+
+  it("IP-include — metadata.ip present in capture record when LEAD_CAPTURE_INCLUDE_IP=true", async () => {
+    process.env.LEAD_CAPTURE_INCLUDE_IP = "true";
+    const serverGeneratedId = "cuid-ip-include-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      headers: { "x-forwarded-for": "1.2.3.4" },
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "ip@example.com",
+        payload: { message: "ip test" },
+      },
+    });
+
+    if (res.statusCode === 201) {
+      const record = await fileEnv.readLastCaptureRecord();
+      expect((record.metadata as Record<string, unknown>)).toHaveProperty("ip");
+    }
+  });
+
+  // ── buildInput branch coverage ─────────────────────────────────────────────
+
+  it("lead — payload absent from body defaults to empty object via ?? (payload ?? {} branch)", async () => {
+    const serverGeneratedId = "cuid-nopayload-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const bodyWithoutPayload: Record<string, unknown> = {
+      kind: "lead",
+      siteId: "site-abc",
+      source: "contact",
+      email: "nopayload@example.com",
+      payload: undefined,
+    };
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: bodyWithoutPayload,
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      expect(res.json().id).toBe(serverGeneratedId);
+    }
+  });
+
+  it("callback — preferredTime included when provided (preferredTime spread branch)", async () => {
+    const serverGeneratedId = "cuid-callback-ptime-1";
+    (prisma.callback.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/callback",
+      payload: {
+        kind: "callback",
+        siteId: "site-abc",
+        name: "Alice",
+        phone: "+15551234567",
+        preferredTime: "morning",
+        payload: { notes: "prefers AM" },
+      },
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      expect(res.json().id).toBe(serverGeneratedId);
+    }
+  });
+
+  it("callback — payload absent from body defaults to empty object via ?? (callback payload ?? {} branch)", async () => {
+    const serverGeneratedId = "cuid-callback-nopayload-1";
+    (prisma.callback.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const bodyWithoutPayload: Record<string, unknown> = {
+      kind: "callback",
+      siteId: "site-abc",
+      name: "Bob",
+      phone: "+15559876543",
+      payload: undefined,
+    };
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/callback",
+      payload: bodyWithoutPayload,
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      expect(res.json().id).toBe(serverGeneratedId);
+    }
+  });
+
+  // ── emailKind branch coverage ──────────────────────────────────────────────
+
+  it("email skipped — emailKind=skipped logged when env vars are unset", async () => {
+    delete process.env.AILK_LEAD_NOTIFICATION_TO;
+    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
+    const serverGeneratedId = "cuid-email-skipped-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "skipped@example.com",
+        payload: { message: "test" },
+      },
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      const body = res.json();
+      expect(body.id).toBe(serverGeneratedId);
+      expect(body.email).toHaveProperty("skipped", true);
+    }
+  });
+
+  it("email error — emailKind=error logged when sendLeadNotification returns ok:false", async () => {
+    const { sendLeadNotification } = jest.requireMock("@working-theory/email");
+    (sendLeadNotification as jest.Mock).mockResolvedValueOnce({
+      ok: false,
+      error: { kind: "send_error", message: "SMTP timeout" },
+    });
+    const serverGeneratedId = "cuid-email-error-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "erroremail@example.com",
+        payload: { message: "test" },
+      },
+    });
+
+    expect([201, 400]).toContain(res.statusCode);
+    if (res.statusCode === 201) {
+      const body = res.json();
+      expect(body.id).toBe(serverGeneratedId);
+      expect(body.email).toHaveProperty("ok", false);
+    }
+  });
+});

package/templates/apps/api/src/routes/leads/__tests__/track.test.ts

@@ -0,0 +1,165 @@
+/**
+ * @file track.test.ts
+ * Verifies that track('lead-captured', ...) fires after successful persistence
+ * and does NOT fire on validation/persistence failure.
+ *
+ * Real dependencies (Issue #507):
+ *   - appendLeadRecord (lead-capture-store): real — writes to LEAD_CAPTURE_FILE temp file
+ *   - writeLeadFallback (file-fallback): real — writes to AILK_INBOX_FALLBACK_DIR temp dir
+ *   - enrichLead (enrichment-shim): real — pass-through shim
+ *
+ * Mocked:
+ *   - @working-theory/analytics/server: external package boundary — stays mocked
+ *   - prisma (lib/prisma.js): manual mock via __mocks__/prisma.ts
+ *   - @working-theory/email: external package boundary — stays mocked
+ *   - @working-theory/license: consumed by enrichment-shim; stays mocked
+ */
+
+import type { FastifyInstance } from "fastify";
+
+const mockTrack = jest.fn().mockResolvedValue(undefined);
+
+jest.mock("@working-theory/analytics/server", () => ({
+  track: (...args: unknown[]) => mockTrack(...args),
+}));
+
+// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts activates the auto-mock (Jest requires explicit call for local files)
+jest.mock("../../../lib/prisma.js");
+
+jest.mock("@working-theory/email", () => ({
+  sendLeadNotification: jest
+    .fn()
+    .mockResolvedValue({ ok: true, messageId: "msg-test" }),
+}));
+
+// @working-theory/license: consumed transitively by enrichment-shim; mocked to avoid
+// needing a license key in tests.
+jest.mock("@working-theory/license", () => ({
+  checkLicense: jest.fn().mockResolvedValue({
+    tier: "free",
+    plan: null,
+    features: [],
+    expiresAt: null,
+    revoked: false,
+  }),
+}));
+
+import { leadSubmitRoute } from "../index";
+import { prisma } from "../../../lib/prisma.js";
+import { setupLeadFileEnv } from "../../../__tests__/factories/lead-fixture";
+
+setupLeadFileEnv("track");
+
+// ─── Suite setup ──────────────────────────────────────────────────────────────
+
+describe("POST /api/leads — track() telemetry", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
+    process.env.DATABASE_URL = "postgres://stub";
+
+    const fastify = require("fastify")();
+    await fastify.register(leadSubmitRoute);
+    app = fastify;
+  });
+
+  afterEach(async () => {
+    await app.close();
+    delete process.env.AILK_LEAD_NOTIFICATION_TO;
+    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
+    delete process.env.DATABASE_URL;
+  });
+
+  it("calls track('lead-captured') with source and locale on successful submission", async () => {
+    const serverGeneratedId = "cuid-track-success-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "newsletter",
+        email: "test@example.com",
+        payload: { locale: "en-US" },
+      },
+    });
+
+    if (res.statusCode === 201) {
+      expect(mockTrack).toHaveBeenCalledTimes(1);
+      expect(mockTrack).toHaveBeenCalledWith(
+        "lead-captured",
+        expect.objectContaining({ source: "newsletter" }),
+      );
+    }
+  });
+
+  it("does NOT call track() when both DB and file fallback fail (persist_failed → 503)", async () => {
+    (prisma.lead.create as jest.Mock).mockRejectedValue(
+      new Error("DB connection refused"),
+    );
+
+    // Make the real writeLeadFallback fail by pointing it at a non-writable path.
+    process.env.AILK_INBOX_FALLBACK_DIR = "/nonexistent-readonly-path-ailk-test";
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        email: "fail@example.com",
+        payload: {},
+      },
+    });
+
+    expect(res.statusCode).toBe(503);
+    expect(mockTrack).not.toHaveBeenCalled();
+  });
+
+  it("does NOT call track() when validation fails (missing required field → 400 or 503)", async () => {
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        // missing email — required field for lead kind
+        kind: "lead",
+        siteId: "site-abc",
+        source: "contact",
+        payload: {},
+      },
+    });
+
+    // The route may return 400 (invalid_input) or 503 (config_missing).
+    expect(mockTrack).not.toHaveBeenCalled();
+  });
+
+  it("track() props contain only source and locale — no PII fields", async () => {
+    const serverGeneratedId = "cuid-pii-check-1";
+    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/lead",
+      payload: {
+        kind: "lead",
+        siteId: "site-abc",
+        source: "landing-page",
+        email: "pii@example.com",
+        payload: { name: "Alice" },
+      },
+    });
+
+    if (res.statusCode === 201 && mockTrack.mock.calls.length > 0) {
+      const [, props] = mockTrack.mock.calls[0];
+      expect(props).not.toHaveProperty("email");
+      expect(props).not.toHaveProperty("name");
+      expect(props).not.toHaveProperty("ip");
+    }
+  });
+});