easy-ping 0.1.0

package/dist/adapter-f0OR2DhY.d.ts

@@ -0,0 +1,200 @@
+type Channel = "inApp" | "email" | "push" | "sms" | "slack";
+type DeliveryStatus = "pending" | "claimed" | "sent" | "failed" | "skipped";
+type DeliveryMode = "inline" | "deferred" | "worker" | "cron";
+type Frequency = "instant" | "daily" | "weekly" | "off";
+type SkipReason = "deduped" | "no-channels" | "no-recipient"
+/** Every declared channel lacks a provider — a misconfiguration, not a preference. */
+ | "channel-unavailable";
+type Recipient = {
+    userId: string;
+    email?: string | undefined;
+    phone?: string | undefined;
+    pushTokens?: readonly string[] | undefined;
+    timezone: string;
+    locale: string;
+};
+type NotificationRecord = {
+    id: string;
+    userId: string;
+    type: string;
+    payload: unknown;
+    actorId: string | null;
+    groupKey: string | null;
+    dedupeKey: string | null;
+    seenAt: Date | null;
+    readAt: Date | null;
+    archivedAt: Date | null;
+    createdAt: Date;
+};
+type DeliveryRecord = {
+    id: string;
+    notificationId: string;
+    channel: Channel;
+    status: DeliveryStatus;
+    attempts: number;
+    maxAttempts: number;
+    notBefore: Date;
+    claimedAt: Date | null;
+    claimedBy: string | null;
+    lastError: string | null;
+    updatedAt: Date;
+};
+
+type Scalar = string | number | boolean | Date | null;
+/**
+ * One operator per condition. Operators are tagged objects so a bare value is
+ * always an equality test; json columns therefore cannot be filtered, since an
+ * object value would be ambiguous.
+ */
+type WhereCondition = Scalar | {
+    in: readonly (string | number)[];
+} | {
+    lt: Date | number;
+} | {
+    lte: Date | number;
+} | {
+    gt: Date | number;
+} | {
+    gte: Date | number;
+} | {
+    not: Scalar;
+};
+type WhereClause = Record<string, WhereCondition>;
+type QueryOptions = {
+    limit?: number;
+    orderBy?: {
+        field: string;
+        direction: "asc" | "desc";
+    };
+};
+type UpsertOptions = {
+    onConflict: readonly string[];
+};
+/**
+ * Table access for plugins, scoped to the tables that plugin declared.
+ *
+ * Plugins could always declare tables via schema() but had no way to read
+ * them, so preferences had to bolt its queries onto the core adapter. That
+ * does not generalise to digests or push.
+ */
+type PluginStore = {
+    find<T = Record<string, unknown>>(table: string, where?: WhereClause, options?: QueryOptions): Promise<T[]>;
+    insert(table: string, rows: readonly Record<string, unknown>[]): Promise<number>;
+    upsert(table: string, rows: readonly Record<string, unknown>[], options: UpsertOptions): Promise<number>;
+    update(table: string, where: WhereClause, set: Record<string, unknown>): Promise<number>;
+    remove(table: string, where: WhereClause): Promise<number>;
+};
+
+type PreferenceRecord = {
+    userId: string;
+    type: string;
+    channel: Channel;
+    enabled: boolean;
+    frequency: Frequency;
+};
+type InsertNotification = {
+    id: string;
+    userId: string;
+    type: string;
+    payload: unknown;
+    actorId?: string | undefined;
+    groupKey?: string | undefined;
+    dedupeKey?: string | undefined;
+    deliveries: readonly InsertDelivery[];
+};
+type InsertDelivery = {
+    id: string;
+    channel: Channel;
+    maxAttempts: number;
+    notBefore: Date;
+};
+type ClaimArgs = {
+    limit: number;
+    leaseMs: number;
+    /** Unique per call, not per worker. See RFC 0003 §4. */
+    claimToken: string;
+    channels?: readonly Channel[] | undefined;
+    /** Scopes the claim to one send; without it inline/deferred flush the whole table. */
+    ids?: readonly string[] | undefined;
+    now?: Date | undefined;
+};
+type ClaimedDelivery = {
+    id: string;
+    notificationId: string;
+    channel: Channel;
+    attempts: number;
+    maxAttempts: number;
+    notification: {
+        userId: string;
+        type: string;
+        payload: unknown;
+        actorId: string | null;
+    };
+};
+type DeliveryOutcome = {
+    result: "sent";
+} | {
+    result: "failed";
+    error: string;
+    retryable: boolean;
+};
+type DeliveryRelease = {
+    id: string;
+    claimToken: string;
+    outcome: DeliveryOutcome;
+    /** Applied when a retryable failure re-arms the row. */
+    nextAttemptAt?: Date | undefined;
+};
+type FeedQuery = {
+    userId: string;
+    limit: number;
+    cursor?: string | undefined;
+    unreadOnly?: boolean | undefined;
+};
+type FeedPage = {
+    notifications: readonly NotificationRecord[];
+    nextCursor: string | null;
+};
+type DatabaseAdapter = {
+    readonly name: string;
+    /**
+     * How the adapter names stored fields. SQL adapters use snake_case columns;
+     * document stores keep the declared camelCase. The plugin store translates
+     * accordingly rather than assuming one of them.
+     */
+    readonly naming?: "snake_case" | "preserve";
+    /**
+     * True when json values must reach the driver as strings. postgres-js cannot
+     * bind a plain object; Mongo stores one natively.
+     */
+    readonly serializesJson?: boolean;
+    /** One transaction. A duplicate (userId, dedupeKey) is reported, not thrown. */
+    createNotifications(rows: readonly InsertNotification[]): Promise<{
+        created: readonly string[];
+        deduped: readonly string[];
+    }>;
+    /** Atomic lease: a returned row stays invisible to other callers until it expires. */
+    claimPendingDeliveries(args: ClaimArgs): Promise<readonly ClaimedDelivery[]>;
+    /** Writes terminal state even when claimToken is stale. See RFC 0003 §6. */
+    releaseDeliveries(releases: readonly DeliveryRelease[]): Promise<void>;
+    listNotifications(query: FeedQuery): Promise<FeedPage>;
+    countUnseen(userId: string): Promise<number>;
+    markSeen(userId: string, before: Date): Promise<void>;
+    markRead(userId: string, notificationIds: readonly string[]): Promise<number>;
+    markAllRead(userId: string): Promise<number>;
+    getFailedDeliveries(args: {
+        since: Date;
+        limit: number;
+    }): Promise<readonly DeliveryRecord[]>;
+    /**
+     * Generic table access for plugin-declared tables. Reached only through a
+     * PluginStore, which validates the table and every column against the
+     * plugin's own schema() before anything gets here.
+     */
+    queryTable(table: string, where: WhereClause, options: QueryOptions): Promise<Record<string, unknown>[]>;
+    insertRows(table: string, rows: readonly Record<string, unknown>[], onConflict?: readonly string[]): Promise<number>;
+    updateRows(table: string, where: WhereClause, set: Record<string, unknown>): Promise<number>;
+    deleteRows(table: string, where: WhereClause): Promise<number>;
+};
+
+export type { Channel as C, DatabaseAdapter as D, Frequency as F, InsertDelivery as I, NotificationRecord as N, PreferenceRecord as P, Recipient as R, SkipReason as S, DeliveryStatus as a, DeliveryMode as b, DeliveryRecord as c, ClaimArgs as d, ClaimedDelivery as e, DeliveryOutcome as f, DeliveryRelease as g, FeedPage as h, FeedQuery as i, InsertNotification as j, PluginStore as k };

package/dist/adapters/drizzle.cjs

@@ -0,0 +1,440 @@
+'use strict';
+
+var drizzleOrm = require('drizzle-orm');
+var pgCore = require('drizzle-orm/pg-core');
+
+// src/adapters/drizzle/adapter.ts
+
+// src/core/base64url.ts
+function encodeBase64Url(input) {
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64UrlBytes(value) {
+  try {
+    const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
+    return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  } catch {
+    return null;
+  }
+}
+function decodeBase64Url(value) {
+  const bytes = decodeBase64UrlBytes(value);
+  return bytes ? new TextDecoder().decode(bytes) : null;
+}
+
+// src/schema/declaration.ts
+var toSnakeCase = (value) => value.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+
+// src/core/store.ts
+var OPERATORS = ["in", "lt", "lte", "gt", "gte", "not"];
+var isOperator = (value) => typeof value === "object" && value !== null && !(value instanceof Date) && OPERATORS.some((op) => op in value);
+
+// src/adapters/drizzle/adapter.ts
+function toRows(result) {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && "rows" in result) {
+    const { rows } = result;
+    if (Array.isArray(rows)) return rows;
+  }
+  return [];
+}
+var str = (value) => String(value);
+var nullableStr = (value) => value == null ? null : String(value);
+var num = (value) => Number(value);
+var date = (value) => value instanceof Date ? value : new Date(String(value));
+var nullableDate = (value) => value == null ? null : value instanceof Date ? value : new Date(String(value));
+var ts = (value) => value.toISOString();
+var encodeCursor = (createdAt, id) => encodeBase64Url(`${createdAt.toISOString()}|${id}`);
+function decodeCursor(cursor) {
+  const decoded = decodeBase64Url(cursor);
+  if (!decoded) return null;
+  const [iso, id] = decoded.split("|");
+  if (!iso || !id) return null;
+  const createdAt = new Date(iso);
+  return Number.isNaN(createdAt.getTime()) ? null : { createdAt, id };
+}
+function toNotification(row) {
+  return {
+    id: str(row.id),
+    userId: str(row.user_id),
+    type: str(row.type),
+    payload: row.payload,
+    actorId: nullableStr(row.actor_id),
+    groupKey: nullableStr(row.group_key),
+    dedupeKey: nullableStr(row.dedupe_key),
+    seenAt: nullableDate(row.seen_at),
+    readAt: nullableDate(row.read_at),
+    archivedAt: nullableDate(row.archived_at),
+    createdAt: date(row.created_at)
+  };
+}
+function toDelivery(row) {
+  return {
+    id: str(row.id),
+    notificationId: str(row.notification_id),
+    channel: str(row.channel),
+    status: str(row.status),
+    attempts: num(row.attempts),
+    maxAttempts: num(row.max_attempts),
+    notBefore: date(row.not_before),
+    claimedAt: nullableDate(row.claimed_at),
+    claimedBy: nullableStr(row.claimed_by),
+    lastError: nullableStr(row.last_error),
+    updatedAt: date(row.updated_at)
+  };
+}
+var bind = (value) => value instanceof Date ? value.toISOString() : value;
+function whereSql(where) {
+  const entries = Object.entries(where);
+  if (entries.length === 0) return drizzleOrm.sql``;
+  const conditions = entries.map(([field, condition]) => {
+    const column = drizzleOrm.sql.identifier(toSnakeCase(field));
+    if (condition === null) return drizzleOrm.sql`${column} IS NULL`;
+    if (!isOperator(condition)) return drizzleOrm.sql`${column} = ${bind(condition)}`;
+    const operator = condition;
+    if ("in" in operator) {
+      const list = operator.in;
+      if (list.length === 0) return drizzleOrm.sql`FALSE`;
+      return drizzleOrm.sql`${column} IN (${drizzleOrm.sql.join(
+        list.map((item) => drizzleOrm.sql`${item}`),
+        drizzleOrm.sql`, `
+      )})`;
+    }
+    if ("lt" in operator) return drizzleOrm.sql`${column} < ${bind(operator.lt)}`;
+    if ("lte" in operator) return drizzleOrm.sql`${column} <= ${bind(operator.lte)}`;
+    if ("gt" in operator) return drizzleOrm.sql`${column} > ${bind(operator.gt)}`;
+    if ("gte" in operator) return drizzleOrm.sql`${column} >= ${bind(operator.gte)}`;
+    if ("not" in operator) {
+      return operator.not === null ? drizzleOrm.sql`${column} IS NOT NULL` : drizzleOrm.sql`${column} IS DISTINCT FROM ${bind(operator.not)}`;
+    }
+    return drizzleOrm.sql`TRUE`;
+  });
+  return drizzleOrm.sql` WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}`;
+}
+function drizzleAdapter(client, options = {}) {
+  const db = client;
+  const prefix = options.prefix ?? "";
+  const NOTIFICATION = drizzleOrm.sql.identifier(`${prefix}notification`);
+  const DELIVERY = drizzleOrm.sql.identifier(`${prefix}notification_delivery`);
+  const run = async (query, on = db) => toRows(await on.execute(query));
+  return {
+    name: "drizzle-pg",
+    naming: "snake_case",
+    serializesJson: true,
+    async createNotifications(input) {
+      if (input.length === 0) return { created: [], deduped: [] };
+      const now = /* @__PURE__ */ new Date();
+      return db.transaction(async (tx) => {
+        const values = input.map(
+          (row) => drizzleOrm.sql`(
+            ${row.id}::text,
+            ${row.userId}::text,
+            ${row.type}::text,
+            ${JSON.stringify(row.payload ?? null)}::jsonb,
+            ${row.actorId ?? null}::text,
+            ${row.groupKey ?? null}::text,
+            ${row.dedupeKey ?? null}::text,
+            ${ts(now)}::timestamptz
+          )`
+        );
+        const inserted = await run(
+          drizzleOrm.sql`
+            INSERT INTO ${NOTIFICATION} (id, user_id, type, payload, actor_id, group_key, dedupe_key, created_at)
+            VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}
+            ON CONFLICT (user_id, dedupe_key) DO NOTHING
+            RETURNING id
+          `,
+          tx
+        );
+        const created = new Set(inserted.map((row) => str(row.id)));
+        const deliveries = input.filter((row) => created.has(row.id)).flatMap(
+          (row) => row.deliveries.map(
+            (delivery) => drizzleOrm.sql`(
+                ${delivery.id}::text,
+                ${row.id}::text,
+                ${delivery.channel}::text,
+                ${delivery.maxAttempts}::integer,
+                ${ts(delivery.notBefore)}::timestamptz,
+                ${ts(now)}::timestamptz
+              )`
+          )
+        );
+        if (deliveries.length > 0) {
+          await tx.execute(drizzleOrm.sql`
+            INSERT INTO ${DELIVERY} (id, notification_id, channel, max_attempts, not_before, updated_at)
+            VALUES ${drizzleOrm.sql.join(deliveries, drizzleOrm.sql`, `)}
+          `);
+        }
+        return {
+          created: [...created],
+          deduped: input.filter((row) => !created.has(row.id)).map((row) => row.id)
+        };
+      });
+    },
+    async claimPendingDeliveries(args) {
+      const now = args.now ?? /* @__PURE__ */ new Date();
+      const staleBefore = new Date(now.getTime() - args.leaseMs);
+      const channelFilter = args.channels && args.channels.length > 0 ? drizzleOrm.sql`AND channel IN (${drizzleOrm.sql.join(
+        args.channels.map((channel) => drizzleOrm.sql`${channel}`),
+        drizzleOrm.sql`, `
+      )})` : drizzleOrm.sql``;
+      const idFilter = args.ids && args.ids.length > 0 ? drizzleOrm.sql`AND id IN (${drizzleOrm.sql.join(
+        args.ids.map((id) => drizzleOrm.sql`${id}`),
+        drizzleOrm.sql`, `
+      )})` : drizzleOrm.sql``;
+      const rows = await run(drizzleOrm.sql`
+        WITH claimed AS (
+          UPDATE ${DELIVERY}
+          SET status = 'claimed', claimed_at = ${ts(now)}::timestamptz, claimed_by = ${args.claimToken}::text
+          WHERE id IN (
+            SELECT id FROM ${DELIVERY}
+            WHERE (status = 'pending' OR (status = 'claimed' AND claimed_at < ${ts(staleBefore)}::timestamptz))
+              AND not_before <= ${ts(now)}::timestamptz
+              AND attempts < max_attempts
+              ${channelFilter}
+              ${idFilter}
+            ORDER BY not_before ASC, id ASC
+            LIMIT ${args.limit}
+            FOR UPDATE SKIP LOCKED
+          )
+          RETURNING id, notification_id, channel, attempts, max_attempts
+        )
+        SELECT c.id, c.notification_id, c.channel, c.attempts, c.max_attempts,
+               n.user_id, n.type, n.payload, n.actor_id
+        FROM claimed c
+        JOIN ${NOTIFICATION} n ON n.id = c.notification_id
+      `);
+      return rows.map((row) => ({
+        id: str(row.id),
+        notificationId: str(row.notification_id),
+        channel: str(row.channel),
+        attempts: num(row.attempts),
+        maxAttempts: num(row.max_attempts),
+        notification: {
+          userId: str(row.user_id),
+          type: str(row.type),
+          payload: row.payload,
+          actorId: nullableStr(row.actor_id)
+        }
+      }));
+    },
+    async releaseDeliveries(releases) {
+      if (releases.length === 0) return;
+      const now = /* @__PURE__ */ new Date();
+      const values = releases.map(({ id, outcome, nextAttemptAt }) => {
+        const retryable = outcome.result === "failed" && outcome.retryable;
+        const error = outcome.result === "failed" ? outcome.error.slice(0, 2e3) : null;
+        return drizzleOrm.sql`(
+          ${id}::text,
+          ${outcome.result}::text,
+          ${retryable}::boolean,
+          ${error}::text,
+          ${nextAttemptAt ? ts(nextAttemptAt) : null}::timestamptz
+        )`;
+      });
+      await db.execute(drizzleOrm.sql`
+        UPDATE ${DELIVERY} d
+        SET status = CASE
+              WHEN v.result = 'sent' THEN 'sent'
+              WHEN v.retryable AND d.attempts + 1 < d.max_attempts THEN 'pending'
+              ELSE 'failed'
+            END,
+            attempts = CASE WHEN v.result = 'sent' THEN d.attempts ELSE d.attempts + 1 END,
+            last_error = v.error,
+            not_before = COALESCE(v.not_before, d.not_before),
+            claimed_at = NULL,
+            claimed_by = NULL,
+            updated_at = ${ts(now)}::timestamptz
+        FROM (VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}) AS v(id, result, retryable, error, not_before)
+        WHERE d.id = v.id
+      `);
+    },
+    async listNotifications(query) {
+      const cursor = query.cursor ? decodeCursor(query.cursor) : null;
+      const rows = await run(drizzleOrm.sql`
+        SELECT * FROM ${NOTIFICATION}
+        WHERE user_id = ${query.userId}::text
+          AND archived_at IS NULL
+          ${query.unreadOnly ? drizzleOrm.sql`AND read_at IS NULL` : drizzleOrm.sql``}
+          ${cursor ? drizzleOrm.sql`AND (created_at, id) < (${ts(cursor.createdAt)}::timestamptz, ${cursor.id}::text)` : drizzleOrm.sql``}
+        ORDER BY created_at DESC, id DESC
+        LIMIT ${query.limit + 1}
+      `);
+      const page = rows.slice(0, query.limit).map(toNotification);
+      const last = page.at(-1);
+      return {
+        notifications: page,
+        nextCursor: rows.length > query.limit && last ? encodeCursor(last.createdAt, last.id) : null
+      };
+    },
+    async countUnseen(userId) {
+      const rows = await run(drizzleOrm.sql`
+        SELECT count(*)::int AS count FROM ${NOTIFICATION}
+        WHERE user_id = ${userId}::text AND seen_at IS NULL AND archived_at IS NULL
+      `);
+      return num(rows[0]?.count ?? 0);
+    },
+    async markSeen(userId, before) {
+      await db.execute(drizzleOrm.sql`
+        UPDATE ${NOTIFICATION} SET seen_at = ${ts(/* @__PURE__ */ new Date())}::timestamptz
+        WHERE user_id = ${userId}::text AND seen_at IS NULL AND created_at <= ${ts(before)}::timestamptz
+      `);
+    },
+    async markRead(userId, notificationIds) {
+      if (notificationIds.length === 0) return 0;
+      const rows = await run(drizzleOrm.sql`
+        UPDATE ${NOTIFICATION}
+        SET read_at = COALESCE(read_at, ${ts(/* @__PURE__ */ new Date())}::timestamptz)
+        WHERE user_id = ${userId}::text
+          AND id IN (${drizzleOrm.sql.join(
+        notificationIds.map((id) => drizzleOrm.sql`${id}`),
+        drizzleOrm.sql`, `
+      )})
+        RETURNING id
+      `);
+      return rows.length;
+    },
+    async markAllRead(userId) {
+      const rows = await run(drizzleOrm.sql`
+        UPDATE ${NOTIFICATION} SET read_at = ${ts(/* @__PURE__ */ new Date())}::timestamptz
+        WHERE user_id = ${userId}::text AND read_at IS NULL
+        RETURNING id
+      `);
+      return rows.length;
+    },
+    async queryTable(table, where, options2) {
+      const order = options2.orderBy ? drizzleOrm.sql` ORDER BY ${drizzleOrm.sql.identifier(toSnakeCase(options2.orderBy.field))} ${options2.orderBy.direction === "desc" ? drizzleOrm.sql`DESC` : drizzleOrm.sql`ASC`}` : drizzleOrm.sql``;
+      const limit = options2.limit ? drizzleOrm.sql` LIMIT ${options2.limit}` : drizzleOrm.sql``;
+      return run(
+        drizzleOrm.sql`SELECT * FROM ${drizzleOrm.sql.identifier(table)}${whereSql(where)}${order}${limit}`
+      );
+    },
+    async insertRows(table, rows, onConflict) {
+      if (rows.length === 0) return 0;
+      const columns = Object.keys(rows[0] ?? {});
+      if (columns.length === 0) return 0;
+      const values = rows.map(
+        (row) => drizzleOrm.sql`(${drizzleOrm.sql.join(
+          columns.map((column) => drizzleOrm.sql`${bind(row[column])}`),
+          drizzleOrm.sql`, `
+        )})`
+      );
+      const conflict = onConflict && onConflict.length > 0 ? drizzleOrm.sql` ON CONFLICT (${drizzleOrm.sql.join(
+        onConflict.map((field) => drizzleOrm.sql.identifier(toSnakeCase(field))),
+        drizzleOrm.sql`, `
+      )}) DO UPDATE SET ${drizzleOrm.sql.join(
+        columns.filter((column) => !onConflict.includes(column)).map(
+          (column) => drizzleOrm.sql`${drizzleOrm.sql.identifier(toSnakeCase(column))} = EXCLUDED.${drizzleOrm.sql.identifier(
+            toSnakeCase(column)
+          )}`
+        ),
+        drizzleOrm.sql`, `
+      )}` : drizzleOrm.sql``;
+      const inserted = await run(drizzleOrm.sql`
+        INSERT INTO ${drizzleOrm.sql.identifier(table)} (${drizzleOrm.sql.join(
+        columns.map((column) => drizzleOrm.sql.identifier(toSnakeCase(column))),
+        drizzleOrm.sql`, `
+      )})
+        VALUES ${drizzleOrm.sql.join(values, drizzleOrm.sql`, `)}${conflict}
+        RETURNING 1 AS ok
+      `);
+      return inserted.length;
+    },
+    async updateRows(table, where, set) {
+      const assignments = Object.entries(set).map(
+        ([field, value]) => drizzleOrm.sql`${drizzleOrm.sql.identifier(toSnakeCase(field))} = ${bind(value)}`
+      );
+      if (assignments.length === 0) return 0;
+      const rows = await run(drizzleOrm.sql`
+        UPDATE ${drizzleOrm.sql.identifier(table)}
+        SET ${drizzleOrm.sql.join(assignments, drizzleOrm.sql`, `)}${whereSql(where)}
+        RETURNING 1 AS ok
+      `);
+      return rows.length;
+    },
+    async deleteRows(table, where) {
+      const rows = await run(
+        drizzleOrm.sql`DELETE FROM ${drizzleOrm.sql.identifier(table)}${whereSql(where)} RETURNING 1 AS ok`
+      );
+      return rows.length;
+    },
+    async getFailedDeliveries(args) {
+      const rows = await run(drizzleOrm.sql`
+        SELECT * FROM ${DELIVERY}
+        WHERE status = 'failed' AND updated_at >= ${ts(args.since)}::timestamptz
+        ORDER BY updated_at DESC
+        LIMIT ${args.limit}
+      `);
+      return rows.map(toDelivery);
+    }
+  };
+}
+function createSchema(prefix = "") {
+  const name = (base) => `${prefix}${base}`;
+  const notification = pgCore.pgTable(
+    name("notification"),
+    {
+      id: pgCore.text("id").primaryKey(),
+      userId: pgCore.text("user_id").notNull(),
+      type: pgCore.text("type").notNull(),
+      payload: pgCore.jsonb("payload").notNull(),
+      actorId: pgCore.text("actor_id"),
+      groupKey: pgCore.text("group_key"),
+      dedupeKey: pgCore.text("dedupe_key"),
+      seenAt: pgCore.timestamp("seen_at", { withTimezone: true }),
+      readAt: pgCore.timestamp("read_at", { withTimezone: true }),
+      archivedAt: pgCore.timestamp("archived_at", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
+    },
+    (table) => [
+      pgCore.index(name("notification_feed_idx")).on(table.userId, table.createdAt.desc()),
+      pgCore.index(name("notification_unseen_idx")).on(table.userId).where(drizzleOrm.sql`${table.seenAt} is null`),
+      pgCore.index(name("notification_group_idx")).on(table.userId, table.groupKey),
+      // Postgres treats NULLs as distinct here, so unlimited rows may carry no
+      // dedupe key while a present one is enforced unique per user.
+      pgCore.uniqueIndex(name("notification_dedupe_idx")).on(table.userId, table.dedupeKey)
+    ]
+  );
+  const notificationDelivery = pgCore.pgTable(
+    name("notification_delivery"),
+    {
+      id: pgCore.text("id").primaryKey(),
+      notificationId: pgCore.text("notification_id").notNull().references(() => notification.id, { onDelete: "cascade" }),
+      channel: pgCore.text("channel").$type().notNull(),
+      status: pgCore.text("status").$type().notNull().default("pending"),
+      attempts: pgCore.integer("attempts").notNull().default(0),
+      maxAttempts: pgCore.integer("max_attempts").notNull().default(5),
+      notBefore: pgCore.timestamp("not_before", { withTimezone: true }).notNull().defaultNow(),
+      claimedAt: pgCore.timestamp("claimed_at", { withTimezone: true }),
+      claimedBy: pgCore.text("claimed_by"),
+      lastError: pgCore.text("last_error"),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+    },
+    (table) => [
+      pgCore.index(name("delivery_claim_idx")).on(table.status, table.notBefore),
+      pgCore.index(name("delivery_notification_idx")).on(table.notificationId)
+    ]
+  );
+  const notificationPreference = pgCore.pgTable(
+    name("notification_preference"),
+    {
+      userId: pgCore.text("user_id").notNull(),
+      type: pgCore.text("type").notNull(),
+      channel: pgCore.text("channel").$type().notNull(),
+      enabled: pgCore.boolean("enabled").notNull().default(true),
+      frequency: pgCore.text("frequency").$type().notNull().default("instant")
+    },
+    (table) => [pgCore.primaryKey({ columns: [table.userId, table.type, table.channel] })]
+  );
+  return { notification, notificationDelivery, notificationPreference };
+}
+var schema = createSchema();
+
+exports.createSchema = createSchema;
+exports.drizzleAdapter = drizzleAdapter;
+exports.schema = schema;
+//# sourceMappingURL=drizzle.cjs.map
+//# sourceMappingURL=drizzle.cjs.map