@lunora/notify 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/buildEngine-DlmjvnNk.mjs

@@ -1,65 +0,0 @@
-import { createNotification } from '@visulima/notification';
-import { retryMiddleware, circuitBreakerMiddleware } from '@visulima/notification/middleware';
-import { fcmProvider } from '@visulima/notification/providers/fcm';
-import { webPushProvider } from '@visulima/notification/providers/web-push';
-
-const isWebPushTarget = (target) => {
-  if (typeof target !== "string") {
-    return typeof target === "object" && target !== null && "endpoint" in target;
-  }
-  if (!target.startsWith("{")) {
-    return false;
-  }
-  try {
-    const parsed = JSON.parse(target);
-    return typeof parsed.endpoint === "string" && typeof parsed.keys === "object";
-  } catch {
-    return false;
-  }
-};
-const routingPushProvider = (options) => {
-  const pick = (target) => {
-    const provider = isWebPushTarget(target) ? options.webPush : options.fcm;
-    if (provider === void 0) {
-      throw new Error(
-        isWebPushTarget(target) ? "@lunora/notify: received a web-push target but no `webPush` channel is configured" : "@lunora/notify: received an FCM token target but no `fcm` channel is configured"
-      );
-    }
-    return provider;
-  };
-  return {
-    channel: "push",
-    id: "lunora-push-router",
-    initialize: async () => {
-      await options.webPush?.initialize();
-      await options.fcm?.initialize();
-    },
-    isAvailable: () => (options.webPush ?? options.fcm) !== void 0,
-    send: (payload) => {
-      const target = Array.isArray(payload.to) ? payload.to[0] : payload.to;
-      return pick(target).send(payload);
-    }
-  };
-};
-const buildEngine = (resolved) => {
-  const webPush = resolved.webPush === void 0 ? void 0 : webPushProvider(resolved.webPush);
-  const fcm = resolved.fcm === void 0 ? void 0 : fcmProvider(resolved.fcm);
-  const providers = {};
-  if (webPush !== void 0 || fcm !== void 0) {
-    providers.push = routingPushProvider({ fcm, webPush });
-  }
-  if (resolved.chat !== void 0) {
-    providers.chat = resolved.chat;
-  }
-  if (resolved.inApp !== void 0) {
-    providers.inapp = resolved.inApp;
-  }
-  if (resolved.webhook !== void 0) {
-    providers.webhook = resolved.webhook;
-  }
-  const engine = createNotification(providers);
-  engine.use(retryMiddleware()).use(circuitBreakerMiddleware());
-  return engine;
-};
-
-export { buildEngine, routingPushProvider };

package/dist/packem_shared/createNotify-bDWs4qBm.mjs

@@ -1,191 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-import { buildEngine } from './buildEngine-DlmjvnNk.mjs';
-import { memorySubscriptionStore } from './memorySubscriptionStore-DhS-YnLe.mjs';
-import { normalizeRegisterInput, targetOf, isGoneError } from './fcmId-B-YPgHi7.mjs';
-
-const resolveMaybeFactory = (value, env) => typeof value === "function" ? value(env) : value;
-const receiptError = (receipt) => receipt.successful ? void 0 : receipt.errorMessages.join("; ");
-const pushDeliveryStatus = (receipt, error) => {
-  if (receipt.successful) {
-    return "accepted";
-  }
-  return isGoneError(error) ? "gone" : "failed";
-};
-const mapWithConcurrency = async (items, limit, task) => {
-  const results = Array.from({ length: items.length });
-  let cursor = 0;
-  const worker = async () => {
-    while (cursor < items.length) {
-      const index = cursor;
-      cursor += 1;
-      results[index] = await task(items[index]);
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
-  return results;
-};
-const resolveProviders = (definition, env) => {
-  return {
-    chat: resolveMaybeFactory(definition.chat, env),
-    fcm: resolveMaybeFactory(definition.fcm, env),
-    inApp: resolveMaybeFactory(definition.inApp, env),
-    webhook: resolveMaybeFactory(definition.webhook, env),
-    webPush: resolveMaybeFactory(definition.webPush, env)
-  };
-};
-const runtimeCache = /* @__PURE__ */ new WeakMap();
-const runtimeFor = (definition, env) => {
-  let byEnv = runtimeCache.get(definition);
-  if (byEnv === void 0) {
-    byEnv = /* @__PURE__ */ new WeakMap();
-    runtimeCache.set(definition, byEnv);
-  }
-  let runtime = byEnv.get(env);
-  if (runtime === void 0) {
-    runtime = { warnedNoStore: false };
-    byEnv.set(env, runtime);
-  }
-  return runtime;
-};
-const createNotify = (definition, env, options = {}) => {
-  const runtime = runtimeFor(definition, env);
-  let engine;
-  if (options.engine === void 0) {
-    runtime.engine ??= buildEngine(resolveProviders(definition, env));
-    engine = runtime.engine;
-  } else {
-    engine = options.engine;
-  }
-  let store = definition.store?.(env);
-  if (store === void 0) {
-    runtime.fallbackStore ??= memorySubscriptionStore();
-    if (!options.silent && !runtime.warnedNoStore) {
-      runtime.warnedNoStore = true;
-      console.warn(
-        "@lunora/notify: no `store` configured — using a non-durable in-memory subscription store. Configure `store: (env) => d1SubscriptionStore(env.DB)` for production."
-      );
-    }
-    store = runtime.fallbackStore;
-  }
-  const subscriptionStore = store;
-  const concurrency = Math.max(1, options.concurrency ?? 10);
-  const { log, metrics } = options;
-  const countSend = (channel, provider, status, count = 1) => {
-    metrics?.count("notify.send", count, { channel, provider: provider ?? channel, status });
-  };
-  const warnFailedSend = (channel, provider, fields) => {
-    log?.warn(`notify ${channel} delivery failed`, { channel, provider: provider ?? channel, status: "failed", ...fields });
-  };
-  const observeSkip = (channel, reason) => {
-    metrics?.count("notify.skipped", 1, { channel, reason });
-  };
-  const resolveSubscription = async (target) => {
-    if (typeof target !== "string") {
-      return target;
-    }
-    const found = await subscriptionStore.get(target);
-    if (found === void 0) {
-      throw new LunoraError("BAD_REQUEST", `@lunora/notify: no registered subscription with id "${target}"`);
-    }
-    return found;
-  };
-  const deliver = async (subscription, payload, countInline) => {
-    const receipt = await engine.sendToChannel("push", { ...payload, to: targetOf(subscription) });
-    const error = receiptError(receipt);
-    const status = pushDeliveryStatus(receipt, error);
-    if (status === "accepted") {
-      await subscriptionStore.markStatus(subscription.id, "ok");
-    } else if (status === "gone") {
-      await subscriptionStore.delete(subscription.id);
-    } else {
-      await subscriptionStore.markStatus(subscription.id, "failed", error);
-    }
-    if (status === "failed") {
-      warnFailedSend("push", subscription.kind, { error, subscriptionId: subscription.id, userId: subscription.userId ?? null });
-    }
-    if (countInline) {
-      countSend("push", subscription.kind, status);
-    }
-    return { receipt, status };
-  };
-  const push = {
-    broadcast: async (payload, filter) => {
-      const subscriptions = await subscriptionStore.list(filter);
-      if (subscriptions.length === 0) {
-        observeSkip("push", "no-subscriptions-matched");
-      }
-      const rows = await mapWithConcurrency(subscriptions, concurrency, async (subscription) => {
-        const { receipt, status } = await deliver(subscription, payload, false);
-        return { kind: subscription.kind, receipt, status, subscription };
-      });
-      const buckets = /* @__PURE__ */ new Map();
-      for (const { kind, status } of rows) {
-        const key = `${kind}\0${status}`;
-        const bucket = buckets.get(key);
-        if (bucket === void 0) {
-          buckets.set(key, { count: 1, kind, status });
-        } else {
-          bucket.count += 1;
-        }
-      }
-      for (const { count, kind, status } of buckets.values()) {
-        countSend("push", kind, status, count);
-      }
-      const outcomes = rows.map(({ receipt, status, subscription }) => {
-        if (status === "accepted") {
-          return { id: subscription.id, status: "ok" };
-        }
-        const error = receiptError(receipt);
-        return status === "gone" ? { error, id: subscription.id, status: "expired" } : { error, id: subscription.id, status: "failed" };
-      });
-      return {
-        failed: outcomes.filter((outcome) => outcome.status === "failed").length,
-        outcomes,
-        pruned: outcomes.filter((outcome) => outcome.status === "expired").length,
-        sent: outcomes.filter((outcome) => outcome.status === "ok").length,
-        total: outcomes.length
-      };
-    },
-    list: (filter) => subscriptionStore.list(filter),
-    register: (input) => subscriptionStore.put(normalizeRegisterInput(input)),
-    send: async (target, payload) => {
-      const { receipt } = await deliver(await resolveSubscription(target), payload, true);
-      return receipt;
-    },
-    unregister: (id) => subscriptionStore.delete(id)
-  };
-  const sendToChannel = async (channel, payload) => {
-    if (engine.getProvider(channel) === void 0) {
-      observeSkip(channel, "channel-not-configured");
-      throw new LunoraError("BAD_REQUEST", `@lunora/notify: the "${channel}" channel is not configured in defineNotify(...)`);
-    }
-    const receipt = await engine.sendToChannel(channel, payload);
-    const status = receipt.successful ? "accepted" : "failed";
-    countSend(channel, receipt.provider, status);
-    if (status === "failed") {
-      warnFailedSend(channel, receipt.provider, { error: receiptError(receipt) });
-    }
-    return receipt;
-  };
-  const notify = {
-    chat: (payload) => sendToChannel("chat", payload),
-    inApp: (payload) => sendToChannel("inapp", payload),
-    push,
-    send: async (message) => {
-      const receipts = await engine.send(message);
-      for (const receipt of receipts) {
-        const channel = receipt.channel ?? "unknown";
-        const status = receipt.successful ? "accepted" : "failed";
-        countSend(channel, receipt.provider, status);
-        if (status === "failed") {
-          warnFailedSend(channel, receipt.provider, { error: receiptError(receipt) });
-        }
-      }
-      return receipts;
-    },
-    webhook: (payload) => sendToChannel("webhook", payload)
-  };
-  return { notify, push };
-};
-
-export { createNotify };

package/dist/packem_shared/d1SubscriptionStore-Dv3VPMI_.mjs

@@ -1,107 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const rowToSubscription = (row) => {
-  const subscription = {
-    createdAt: row.created_at,
-    id: row.id,
-    kind: row.kind,
-    lastSeenAt: row.last_seen_at,
-    userId: row.user_id
-  };
-  if (row.endpoint !== null) {
-    subscription.endpoint = row.endpoint;
-  }
-  if (row.p256dh !== null && row.auth !== null) {
-    subscription.keys = { auth: row.auth, p256dh: row.p256dh };
-  }
-  if (row.token !== null) {
-    subscription.token = row.token;
-  }
-  if (row.last_status !== null) {
-    subscription.lastStatus = row.last_status;
-  }
-  if (row.last_error !== null) {
-    subscription.lastError = row.last_error;
-  }
-  if (row.metadata !== null) {
-    try {
-      subscription.metadata = JSON.parse(row.metadata);
-    } catch {
-    }
-  }
-  return subscription;
-};
-const IDENTIFIER_PATTERN = /^[A-Za-z_]\w*$/u;
-const d1SubscriptionStore = (database, options = {}) => {
-  const table = options.tableName ?? "lunora_push_subscriptions";
-  if (!IDENTIFIER_PATTERN.test(table)) {
-    throw new LunoraError("BAD_REQUEST", `@lunora/notify: d1SubscriptionStore tableName "${table}" is not a bare SQL identifier`);
-  }
-  let schemaReady;
-  const ensureSchema = () => {
-    if (schemaReady === void 0) {
-      schemaReady = database.prepare(
-        `CREATE TABLE IF NOT EXISTS ${table} (id TEXT PRIMARY KEY, kind TEXT NOT NULL, endpoint TEXT, p256dh TEXT, auth TEXT, token TEXT, user_id TEXT, metadata TEXT, created_at INTEGER NOT NULL, last_seen_at INTEGER NOT NULL, last_status TEXT, last_error TEXT)`
-      ).run().then(() => void 0);
-      schemaReady.catch(() => {
-        schemaReady = void 0;
-      });
-    }
-    return schemaReady;
-  };
-  const put = async (subscription) => {
-    await ensureSchema();
-    await database.prepare(
-      `INSERT INTO ${table} (id, kind, endpoint, p256dh, auth, token, user_id, metadata, created_at, last_seen_at, last_status, last_error) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12) ON CONFLICT(id) DO UPDATE SET kind = ?2, endpoint = ?3, p256dh = ?4, auth = ?5, token = ?6, user_id = ?7, metadata = ?8, last_seen_at = ?10, last_status = ?11, last_error = ?12`
-    ).bind(
-      subscription.id,
-      subscription.kind,
-      subscription.endpoint ?? null,
-      subscription.keys?.p256dh ?? null,
-      subscription.keys?.auth ?? null,
-      subscription.token ?? null,
-      subscription.userId ?? null,
-      subscription.metadata === void 0 ? null : JSON.stringify(subscription.metadata),
-      subscription.createdAt,
-      subscription.lastSeenAt,
-      subscription.lastStatus ?? null,
-      subscription.lastError ?? null
-    ).run();
-    return subscription;
-  };
-  const get = async (id) => {
-    await ensureSchema();
-    const row = await database.prepare(`SELECT * FROM ${table} WHERE id = ?1`).bind(id).first();
-    return row === null ? void 0 : rowToSubscription(row);
-  };
-  const remove = async (id) => {
-    await ensureSchema();
-    await database.prepare(`DELETE FROM ${table} WHERE id = ?1`).bind(id).run();
-  };
-  const list = async (filter) => {
-    await ensureSchema();
-    const clauses = [];
-    const bindings = [];
-    if (filter?.kind !== void 0) {
-      bindings.push(filter.kind);
-      clauses.push(`kind = ?${bindings.length.toString()}`);
-    }
-    if (filter?.userId !== void 0) {
-      bindings.push(filter.userId);
-      clauses.push(filter.userId === null ? "user_id IS NULL" : `user_id = ?${bindings.length.toString()}`);
-      if (filter.userId === null) {
-        bindings.pop();
-      }
-    }
-    const where = clauses.length === 0 ? "" : ` WHERE ${clauses.join(" AND ")}`;
-    const { results } = await database.prepare(`SELECT * FROM ${table}${where}`).bind(...bindings).all();
-    return results.map((row) => rowToSubscription(row));
-  };
-  const markStatus = async (id, status, error) => {
-    await ensureSchema();
-    await database.prepare(`UPDATE ${table} SET last_status = ?2, last_error = ?3, last_seen_at = ?4 WHERE id = ?1`).bind(id, status, error ?? null, Date.now()).run();
-  };
-  return { delete: remove, get, list, markStatus, put };
-};
-
-export { d1SubscriptionStore };

package/dist/packem_shared/defineNotify-B6S_47C2.mjs

@@ -1,18 +0,0 @@
-const defineNotify = (config) => {
-  if (config.webPush !== void 0 && typeof config.webPush !== "function" && typeof config.webPush !== "object") {
-    throw new TypeError("defineNotify: `webPush` must be a WebPushConfig object or an `(env) => WebPushConfig` function");
-  }
-  if (config.fcm !== void 0 && typeof config.fcm !== "function" && typeof config.fcm !== "object") {
-    throw new TypeError("defineNotify: `fcm` must be an FcmConfig object or an `(env) => FcmConfig` function");
-  }
-  if (config.store !== void 0 && typeof config.store !== "function") {
-    throw new TypeError("defineNotify: `store` must be a function `(env) => SubscriptionStore` when provided");
-  }
-  if (config.webPush === void 0 && config.fcm === void 0) {
-    throw new TypeError("defineNotify: configure at least one push channel — `webPush` and/or `fcm`");
-  }
-  return { ...config, isLunoraNotify: true };
-};
-const isNotifyDefinition = (value) => typeof value === "object" && value !== null && value.isLunoraNotify === true;
-
-export { defineNotify, isNotifyDefinition };

package/dist/packem_shared/enqueuePushBroadcast-DiK7Hyja.mjs

@@ -1,4 +0,0 @@
-const enqueuePushBroadcast = (queue, job) => queue.send({ ...job, type: "lunora.push.broadcast" });
-const runPushBroadcastJob = (push, job) => push.broadcast(job.payload, job.filter);
-
-export { enqueuePushBroadcast, runPushBroadcastJob };

package/dist/packem_shared/fcmId-B-YPgHi7.mjs

@@ -1,68 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const fnv1a = (input) => {
-  let hash = 2166136261;
-  for (let index = 0; index < input.length; index += 1) {
-    hash ^= input.codePointAt(index) ?? 0;
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-};
-const webPushId = (endpoint) => `wp_${fnv1a(endpoint)}`;
-const fcmId = (token) => `fcm_${fnv1a(token)}`;
-const parseSubscription = (subscription) => {
-  if (typeof subscription !== "string") {
-    return subscription ?? {};
-  }
-  try {
-    return JSON.parse(subscription);
-  } catch (error) {
-    throw new LunoraError(
-      "BAD_REQUEST",
-      `@lunora/notify: register() web-push subscription is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-};
-const normalizeRegisterInput = (input, now = Date.now()) => {
-  if ("token" in input) {
-    const { token } = input;
-    if (typeof token !== "string" || token === "") {
-      throw new LunoraError("BAD_REQUEST", "@lunora/notify: register() fcm input requires a non-empty `token`");
-    }
-    return { createdAt: now, id: fcmId(token), kind: "fcm", lastSeenAt: now, metadata: input.metadata, token, userId: input.userId ?? null };
-  }
-  const subscription = parseSubscription(input.subscription);
-  const { endpoint } = subscription;
-  const p256dh = subscription.keys?.p256dh;
-  const auth = subscription.keys?.auth;
-  if (typeof endpoint !== "string" || endpoint === "" || typeof p256dh !== "string" || typeof auth !== "string") {
-    throw new LunoraError("BAD_REQUEST", "@lunora/notify: register() web-push subscription requires `endpoint` and `keys.{p256dh, auth}`");
-  }
-  return {
-    createdAt: now,
-    endpoint,
-    id: webPushId(endpoint),
-    keys: { auth, p256dh },
-    kind: "web-push",
-    lastSeenAt: now,
-    metadata: input.metadata,
-    userId: input.userId ?? null
-  };
-};
-const targetOf = (subscription) => {
-  if (subscription.kind === "fcm") {
-    return subscription.token ?? "";
-  }
-  return JSON.stringify({ endpoint: subscription.endpoint, keys: subscription.keys });
-};
-const WEB_PUSH_GONE_PATTERN = /\bhttp\s*4(?:04|10)\b/iu;
-const FCM_GONE_PATTERN = /\b(?:unregistered|not[\s-]?registered|registration-token-not-registered)\b/iu;
-const GONE_TEXT_FALLBACK = /\bsubscription (?:is )?(?:gone|expired|no longer valid)\b/iu;
-const isGoneError = (message) => {
-  if (message === void 0) {
-    return false;
-  }
-  return WEB_PUSH_GONE_PATTERN.test(message) || FCM_GONE_PATTERN.test(message) || GONE_TEXT_FALLBACK.test(message);
-};
-
-export { fcmId, isGoneError, normalizeRegisterInput, targetOf, webPushId };

package/dist/packem_shared/memorySubscriptionStore-DhS-YnLe.mjs

@@ -1,46 +0,0 @@
-const matches = (subscription, filter) => {
-  if (filter === void 0) {
-    return true;
-  }
-  if (filter.kind !== void 0 && subscription.kind !== filter.kind) {
-    return false;
-  }
-  if (filter.userId !== void 0 && (subscription.userId ?? null) !== filter.userId) {
-    return false;
-  }
-  return true;
-};
-const memorySubscriptionStore = () => {
-  const map = /* @__PURE__ */ new Map();
-  return {
-    delete: (id) => {
-      map.delete(id);
-      return Promise.resolve();
-    },
-    get: (id) => Promise.resolve(map.get(id)),
-    list: (filter) => {
-      const result = [];
-      for (const subscription of map.values()) {
-        if (matches(subscription, filter)) {
-          result.push(subscription);
-        }
-      }
-      return Promise.resolve(result);
-    },
-    markStatus: (id, status, error) => {
-      const existing = map.get(id);
-      if (existing !== void 0) {
-        map.set(id, { ...existing, lastError: error, lastSeenAt: Date.now(), lastStatus: status });
-      }
-      return Promise.resolve();
-    },
-    put: (subscription) => {
-      const existing = map.get(subscription.id);
-      const merged = existing === void 0 ? subscription : { ...existing, ...subscription, createdAt: existing.createdAt };
-      map.set(merged.id, merged);
-      return Promise.resolve(merged);
-    }
-  };
-};
-
-export { memorySubscriptionStore };