import { NotifizzClient } from "@notifizz/nodejs";

const client = new NotifizzClient(
  process.env.NOTIFIZZ_AUTH_SECRET_KEY!,
  process.env.NOTIFIZZ_SDK_SECRET_KEY!,
  process.env.NOTIFIZZ_WEBHOOK_SIGNING_SECRET, // optional, required only for dispatch()
  { schemaMode: "strict" },                    // optional, NotifizzClientOptions
);

await client.track("order.shipped", {
  orderId: "ORD-4521",
  userId: "u_42",
  carrier: "FedEx",
});

// With a caller-supplied idempotency key (recommended for retried jobs):
await client.track(
  "order.shipped",
  { orderId: "ORD-4521", userId: "u_42" },
  { idempotencyKey: `order-shipped:${orderId}` },
);

await client.track("order.shipped", { orderId }, { occurredAt: shippedAt });

import { NotifizzClient, z } from "@notifizz/nodejs";

const client = new NotifizzClient(authKey, sdkKey, signingSecret);

const ORDER_SHIPPED = client.declareEvent("order.shipped", {
  description: "An order has been handed to the carrier and a tracking URL is available",
  schema: z.object({
    orderId: z.string(),
    userId: z.string(),
    carrier: z.enum(["FedEx", "UPS", "DHL"]),
    trackingUrl: z.string().url(),
  }),
  idempotencyFields: ["orderId"],
});

// Use the returned constant for type-safe track() — TS infers `'order.shipped'`.
await client.track(ORDER_SHIPPED, { orderId: "ORD-1", userId: "u_42", carrier: "FedEx", trackingUrl: "..." });

const client = new NotifizzClient(authKey, sdkKey, signingSecret, {
  schemaMode: "strict", // 'soft' (default) | 'strict'
  onError: (eventName, reason, payload) => {
    logger.error({ eventName, reason }, "notifizz strict-mode rejection");
  },
});

// No enricher on this service? Leave the signing secret out explicitly:
const trackOnly = new NotifizzClient(authKey, sdkKey, undefined, { schemaMode: "strict" });

NOTIFIZZ_SCHEMA_MODE=strict npm test

{
  "ok": true,
  "result": {
    "enrichers": [...],
    "events": [
      {
        "name": "order.shipped",
        "description": "...",
        "schema": { "type": "object", "required": [...], "properties": {...} },
        "idempotencyFields": ["orderId"]
      }
    ]
  }
}

const token = client.generateHashedToken("u_42");
// Return token to your frontend via your own API endpoint.

const result = await client.identify({
  environmentId,
  subjectA: { type: "AppUserSubject", identifier: "u_42" },
  subjectB: { type: "EmailSubject", identifier: "alice@example.com" },
  consentBasis: "transactional",
});
// result.action → 'merged' | 'already_linked' | 'created_and_linked' | 'noop'

await client.detach({
  environmentId,
  subject: { type: "AppUserSubject", identifier: "u_42" },
});
// action → 'detached' | 'already_detached' | 'not_found'

import { NotifizzClient, z } from "@notifizz/nodejs";

const client = new NotifizzClient(authKey, sdkKey, signingSecret);

client.enricher("fetchUser", {
  description: "Live user profile from the application database",
  input: z.object({ userId: z.string() }),
  output: z.object({
    id: z.string(),
    email: z.string(),
    displayName: z.string(),
  }),
  cache: { ttl: "1h" },
  handler: async ({ userId }) => {
    const user = await db.users.findOne({ id: userId });
    return { id: user.id, email: user.email, displayName: user.name };
  },
});

client.enrichProfileData({
  cache: { ttl: "1h" },
  handler: async ({ id, email }) => ({
    name: "Alice Martin",
    phone: "+33 1 23 45 67 89",
    customerType: "VIP",
  }),
});

const registered = client.enrichers();
console.log(registered.map((r) => r.name));

app.listen(3000, () => {
  client.ready();
});

// Client and schemas
import {
  NotifizzClient,
  z, // bundled Zod — the zero-config path
  type NotifizzClientOptions,
  type SchemaMode,
  type TrackOptions,
} from "@notifizz/nodejs";

// Errors
import {
  TrackRejectedError, // thrown by track() under schemaMode: 'strict'
  type TrackRejectionReason,
  EventRegistrationError,
  InvalidEventNameError,
  EnricherRegistrationError,
  EnricherInputValidationError,
  EnricherHmacVerificationError,
  EnricherNotFoundError,
  EnricherHandlerError,
} from "@notifizz/nodejs";

// Enricher + dispatch types and helpers
import {
  signDispatchPayload, // HMAC over a `payload` string — for testing dispatch with synthetic signed requests
  TIMESTAMP_TOLERANCE_MS,
  type EnricherOptions,
  type EnricherCachePolicy,
  type EnricherSchemaInput,
  type EnricherRegistration,
  type EnrichProfileDataOptions,
  type DiscoveryResponse,
  type DispatchEnvelope,
  type DispatchPayload,
  type DispatchResponse,
  type DispatchError,
  type DispatchErrorCode,
  type DiscoveryResult,
} from "@notifizz/nodejs";

// Event declaration
import {
  validateEventName,
  EVENT_NAME_MAX_LENGTH,
  type DeclareEventOptions,
  type DeclaredEventRegistration,
  type DeclaredEventDiscoveryEntry,
  type DeclaredEventSchemaInput,
} from "@notifizz/nodejs";

// Local development — see the enrichers protocol reference
import { startDevTunnel, type DevTunnelOptions, type DevTunnelHandle } from "@notifizz/nodejs";

app.listen(port, () => {
  client.config({ discoveryUrl: "https://api.example.com/notifizz" });
});

try {
  await client.track("order.shipped", { orderId, userId });
} catch (e) {
  logger.error({ err: e, orderId }, "notifizz track failed");
  throw e;
}

try {
  // ...
} catch (e) {
  if (e instanceof EnricherInputValidationError) {
    // ...
  }
}