@volchoklv/newsletter-kit 1.0.0

package/dist/adapters/storage/index.d.ts

@@ -0,0 +1,215 @@
+import { S as StorageAdapter } from '../../types-BmajlhNp.js';
+export { e as SubscribeInput, h as Subscriber, i as SubscriptionStatus } from '../../types-BmajlhNp.js';
+
+/**
+ * Prisma schema required for this adapter:
+ *
+ * **PostgreSQL / Neon / MySQL:**
+ * ```prisma
+ * model NewsletterSubscriber {
+ *   id            String    @id @default(cuid())
+ *   email         String    @unique
+ *   status        String    @default("pending") // pending, confirmed, unsubscribed
+ *   token         String?   @unique
+ *   source        String?
+ *   tags          String[]  @default([])
+ *   metadata      Json?
+ *   consentIp     String?
+ *   consentAt     DateTime?
+ *   confirmedAt   DateTime?
+ *   unsubscribedAt DateTime?
+ *   createdAt     DateTime  @default(now())
+ *   updatedAt     DateTime  @updatedAt
+ *
+ *   @@index([status])
+ *   @@index([source])
+ * }
+ * ```
+ *
+ * **MongoDB:**
+ * ```prisma
+ * model NewsletterSubscriber {
+ *   id            String    @id @default(auto()) @map("_id") @db.ObjectId
+ *   email         String    @unique
+ *   status        String    @default("pending") // pending, confirmed, unsubscribed
+ *   token         String?   @unique
+ *   source        String?
+ *   tags          String[]  @default([])
+ *   metadata      Json?
+ *   consentIp     String?
+ *   consentAt     DateTime?
+ *   confirmedAt   DateTime?
+ *   unsubscribedAt DateTime?
+ *   createdAt     DateTime  @default(now())
+ *   updatedAt     DateTime  @updatedAt
+ *
+ *   @@index([status])
+ *   @@index([source])
+ * }
+ * ```
+ */
+interface PrismaClient {
+    newsletterSubscriber: {
+        upsert: (args: unknown) => Promise<unknown>;
+        findUnique: (args: unknown) => Promise<unknown>;
+        findFirst: (args: unknown) => Promise<unknown>;
+        findMany: (args: unknown) => Promise<unknown[]>;
+        update: (args: unknown) => Promise<unknown>;
+        delete: (args: unknown) => Promise<unknown>;
+        count: (args?: unknown) => Promise<number>;
+    };
+}
+interface PrismaAdapterConfig {
+    /** Your Prisma client instance */
+    prisma: PrismaClient;
+    /** Model name if different from 'newsletterSubscriber' */
+    modelName?: string;
+}
+/**
+ * Storage adapter for Prisma ORM
+ *
+ * @example
+ * ```ts
+ * import { createPrismaAdapter } from '@volchok/newsletter-kit/adapters/storage';
+ * import { prisma } from '@/lib/prisma';
+ *
+ * const storageAdapter = createPrismaAdapter({ prisma });
+ * ```
+ */
+declare function createPrismaAdapter(config: PrismaAdapterConfig): StorageAdapter;
+
+/**
+ * Supabase table schema (SQL):
+ *
+ * ```sql
+ * CREATE TABLE newsletter_subscribers (
+ *   id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+ *   email TEXT UNIQUE NOT NULL,
+ *   status TEXT DEFAULT 'pending' CHECK (status IN ('pending', 'confirmed', 'unsubscribed')),
+ *   token TEXT UNIQUE,
+ *   source TEXT,
+ *   tags TEXT[] DEFAULT '{}',
+ *   metadata JSONB,
+ *   consent_ip TEXT,
+ *   consent_at TIMESTAMPTZ,
+ *   confirmed_at TIMESTAMPTZ,
+ *   unsubscribed_at TIMESTAMPTZ,
+ *   created_at TIMESTAMPTZ DEFAULT NOW(),
+ *   updated_at TIMESTAMPTZ DEFAULT NOW()
+ * );
+ *
+ * -- Indexes
+ * CREATE INDEX idx_newsletter_subscribers_status ON newsletter_subscribers(status);
+ * CREATE INDEX idx_newsletter_subscribers_source ON newsletter_subscribers(source);
+ * CREATE INDEX idx_newsletter_subscribers_token ON newsletter_subscribers(token);
+ *
+ * -- Updated at trigger
+ * CREATE OR REPLACE FUNCTION update_updated_at()
+ * RETURNS TRIGGER AS $$
+ * BEGIN
+ *   NEW.updated_at = NOW();
+ *   RETURN NEW;
+ * END;
+ * $$ LANGUAGE plpgsql;
+ *
+ * CREATE TRIGGER newsletter_subscribers_updated_at
+ *   BEFORE UPDATE ON newsletter_subscribers
+ *   FOR EACH ROW
+ *   EXECUTE FUNCTION update_updated_at();
+ * ```
+ */
+interface SupabaseClient {
+    from: (table: string) => {
+        upsert: (data: unknown, options?: unknown) => Promise<{
+            data: unknown;
+            error: unknown;
+        }>;
+        select: (columns?: string) => {
+            eq: (column: string, value: unknown) => {
+                single: () => Promise<{
+                    data: unknown;
+                    error: unknown;
+                }>;
+                range: (from: number, to: number) => Promise<{
+                    data: unknown[];
+                    error: unknown;
+                }>;
+            };
+            contains: (column: string, value: unknown) => {
+                range: (from: number, to: number) => Promise<{
+                    data: unknown[];
+                    error: unknown;
+                }>;
+            };
+            order: (column: string, options?: unknown) => {
+                range: (from: number, to: number) => Promise<{
+                    data: unknown[];
+                    error: unknown;
+                }>;
+            };
+        };
+        update: (data: unknown) => {
+            eq: (column: string, value: unknown) => Promise<{
+                data: unknown;
+                error: unknown;
+            }>;
+        };
+        delete: () => {
+            eq: (column: string, value: unknown) => Promise<{
+                data: unknown;
+                error: unknown;
+            }>;
+        };
+    };
+}
+interface SupabaseAdapterConfig {
+    /** Your Supabase client instance */
+    supabase: SupabaseClient;
+    /** Table name if different from 'newsletter_subscribers' */
+    tableName?: string;
+}
+/**
+ * Storage adapter for Supabase
+ *
+ * @example
+ * ```ts
+ * import { createSupabaseAdapter } from '@volchok/newsletter-kit/adapters/storage';
+ * import { createClient } from '@supabase/supabase-js';
+ *
+ * const supabase = createClient(
+ *   process.env.SUPABASE_URL!,
+ *   process.env.SUPABASE_SERVICE_KEY!
+ * );
+ *
+ * const storageAdapter = createSupabaseAdapter({ supabase });
+ * ```
+ */
+declare function createSupabaseAdapter(config: SupabaseAdapterConfig): StorageAdapter;
+
+/**
+ * In-memory storage adapter
+ *
+ * Useful for:
+ * - Development and testing
+ * - Simple sites that don't need persistence
+ * - When you only want to send emails without storing subscribers
+ *
+ * WARNING: Data is lost when the server restarts!
+ *
+ * @example
+ * ```ts
+ * import { createMemoryAdapter } from '@volchok/newsletter-kit/adapters/storage';
+ *
+ * const storageAdapter = createMemoryAdapter();
+ * ```
+ */
+declare function createMemoryAdapter(): StorageAdapter;
+/**
+ * No-op storage adapter
+ *
+ * Use when you don't want to store subscribers at all,
+ * only send emails (e.g., when using Mailchimp which handles storage)
+ */
+declare function createNoopAdapter(): StorageAdapter;
+
+export { StorageAdapter, createMemoryAdapter, createNoopAdapter, createPrismaAdapter, createSupabaseAdapter };

package/dist/adapters/storage/index.js

@@ -0,0 +1,415 @@
+"use client";
+
+// src/utils/crypto.ts
+import { randomBytes } from "crypto";
+function generateToken(length = 32) {
+  return randomBytes(length).toString("hex");
+}
+
+// src/adapters/storage/prisma.ts
+function mapToSubscriber(record) {
+  return {
+    id: record.id,
+    email: record.email,
+    status: record.status,
+    source: record.source,
+    tags: record.tags,
+    metadata: record.metadata,
+    consentIp: record.consentIp,
+    consentAt: record.consentAt ? new Date(record.consentAt) : void 0,
+    confirmedAt: record.confirmedAt ? new Date(record.confirmedAt) : void 0,
+    unsubscribedAt: record.unsubscribedAt ? new Date(record.unsubscribedAt) : void 0,
+    createdAt: new Date(record.createdAt),
+    updatedAt: new Date(record.updatedAt)
+  };
+}
+function createPrismaAdapter(config) {
+  const { prisma } = config;
+  const model = prisma.newsletterSubscriber;
+  return {
+    async createSubscriber(input, token) {
+      const confirmToken = token || generateToken();
+      const record = await model.upsert({
+        where: { email: input.email.toLowerCase() },
+        update: {
+          token: confirmToken,
+          source: input.source,
+          tags: input.tags || [],
+          metadata: input.metadata,
+          consentIp: input.ip,
+          consentAt: /* @__PURE__ */ new Date(),
+          // Reset to pending if resubscribing
+          status: "pending",
+          unsubscribedAt: null
+        },
+        create: {
+          email: input.email.toLowerCase(),
+          token: confirmToken,
+          status: "pending",
+          source: input.source,
+          tags: input.tags || [],
+          metadata: input.metadata,
+          consentIp: input.ip,
+          consentAt: /* @__PURE__ */ new Date()
+        }
+      });
+      return mapToSubscriber(record);
+    },
+    async getSubscriberByEmail(email) {
+      const record = await model.findUnique({
+        where: { email: email.toLowerCase() }
+      });
+      return record ? mapToSubscriber(record) : null;
+    },
+    async getSubscriberByToken(token) {
+      const record = await model.findFirst({
+        where: { token }
+      });
+      return record ? mapToSubscriber(record) : null;
+    },
+    async confirmSubscriber(token) {
+      try {
+        const record = await model.update({
+          where: { token },
+          data: {
+            status: "confirmed",
+            confirmedAt: /* @__PURE__ */ new Date(),
+            token: null
+            // Clear token after use
+          }
+        });
+        return mapToSubscriber(record);
+      } catch {
+        return null;
+      }
+    },
+    async unsubscribe(email) {
+      try {
+        await model.update({
+          where: { email: email.toLowerCase() },
+          data: {
+            status: "unsubscribed",
+            unsubscribedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async listSubscribers(options) {
+      const where = {};
+      if (options?.status) {
+        where.status = options.status;
+      }
+      if (options?.source) {
+        where.source = options.source;
+      }
+      if (options?.tags?.length) {
+        where.tags = { hasSome: options.tags };
+      }
+      const [records, total] = await Promise.all([
+        model.findMany({
+          where,
+          take: options?.limit || 100,
+          skip: options?.offset || 0,
+          orderBy: { createdAt: "desc" }
+        }),
+        model.count({ where })
+      ]);
+      return {
+        subscribers: records.map((r) => mapToSubscriber(r)),
+        total
+      };
+    },
+    async deleteSubscriber(email) {
+      try {
+        await model.delete({
+          where: { email: email.toLowerCase() }
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async updateSubscriber(email, data) {
+      try {
+        const record = await model.update({
+          where: { email: email.toLowerCase() },
+          data: {
+            ...data.source !== void 0 && { source: data.source },
+            ...data.tags !== void 0 && { tags: data.tags },
+            ...data.metadata !== void 0 && { metadata: data.metadata }
+          }
+        });
+        return mapToSubscriber(record);
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// src/adapters/storage/supabase.ts
+function mapToSubscriber2(record) {
+  return {
+    id: record.id,
+    email: record.email,
+    status: record.status,
+    source: record.source,
+    tags: record.tags,
+    metadata: record.metadata,
+    consentIp: record.consent_ip,
+    consentAt: record.consent_at ? new Date(record.consent_at) : void 0,
+    confirmedAt: record.confirmed_at ? new Date(record.confirmed_at) : void 0,
+    unsubscribedAt: record.unsubscribed_at ? new Date(record.unsubscribed_at) : void 0,
+    createdAt: new Date(record.created_at),
+    updatedAt: new Date(record.updated_at)
+  };
+}
+function createSupabaseAdapter(config) {
+  const { supabase, tableName = "newsletter_subscribers" } = config;
+  return {
+    async createSubscriber(input, token) {
+      const confirmToken = token || generateToken();
+      const email = input.email.toLowerCase();
+      const { data, error } = await supabase.from(tableName).upsert(
+        {
+          email,
+          token: confirmToken,
+          status: "pending",
+          source: input.source,
+          tags: input.tags || [],
+          metadata: input.metadata,
+          consent_ip: input.ip,
+          consent_at: (/* @__PURE__ */ new Date()).toISOString(),
+          unsubscribed_at: null
+        },
+        { onConflict: "email" }
+      );
+      if (error) throw error;
+      const { data: record } = await supabase.from(tableName).select().eq("email", email).single();
+      return mapToSubscriber2(record);
+    },
+    async getSubscriberByEmail(email) {
+      const { data, error } = await supabase.from(tableName).select().eq("email", email.toLowerCase()).single();
+      if (error || !data) return null;
+      return mapToSubscriber2(data);
+    },
+    async getSubscriberByToken(token) {
+      const { data, error } = await supabase.from(tableName).select().eq("token", token).single();
+      if (error || !data) return null;
+      return mapToSubscriber2(data);
+    },
+    async confirmSubscriber(token) {
+      const { error } = await supabase.from(tableName).update({
+        status: "confirmed",
+        confirmed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        token: null
+      }).eq("token", token);
+      if (error) return null;
+      const { data } = await supabase.from(tableName).select().eq("token", null).single();
+      return data ? mapToSubscriber2(data) : null;
+    },
+    async unsubscribe(email) {
+      const { error } = await supabase.from(tableName).update({
+        status: "unsubscribed",
+        unsubscribed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }).eq("email", email.toLowerCase());
+      return !error;
+    },
+    async listSubscribers(options) {
+      const limit = options?.limit || 100;
+      const offset = options?.offset || 0;
+      let query = supabase.from(tableName).select();
+      if (options?.status) {
+        query = query.eq("status", options.status);
+      }
+      if (options?.source) {
+        query = query.eq("source", options.source);
+      }
+      if (options?.tags?.length) {
+        query = query.contains("tags", options.tags);
+      }
+      const { data, error } = await query.order("created_at", { ascending: false }).range(offset, offset + limit - 1);
+      if (error) throw error;
+      return {
+        subscribers: (data || []).map((r) => mapToSubscriber2(r)),
+        total: (data || []).length
+        // Note: Supabase doesn't return total count easily
+      };
+    },
+    async deleteSubscriber(email) {
+      const { error } = await supabase.from(tableName).delete().eq("email", email.toLowerCase());
+      return !error;
+    },
+    async updateSubscriber(email, data) {
+      const updateData = {};
+      if (data.source !== void 0) updateData.source = data.source;
+      if (data.tags !== void 0) updateData.tags = data.tags;
+      if (data.metadata !== void 0) updateData.metadata = data.metadata;
+      const { error } = await supabase.from(tableName).update(updateData).eq("email", email.toLowerCase());
+      if (error) return null;
+      return this.getSubscriberByEmail(email);
+    }
+  };
+}
+
+// src/adapters/storage/memory.ts
+function createMemoryAdapter() {
+  const subscribers = /* @__PURE__ */ new Map();
+  const tokenIndex = /* @__PURE__ */ new Map();
+  return {
+    async createSubscriber(input, token) {
+      const email = input.email.toLowerCase();
+      const confirmToken = token || generateToken();
+      const now = /* @__PURE__ */ new Date();
+      const existing = subscribers.get(email);
+      if (existing?.id) {
+        for (const [t, e] of tokenIndex.entries()) {
+          if (e === email) {
+            tokenIndex.delete(t);
+            break;
+          }
+        }
+      }
+      const subscriber = {
+        id: existing?.id || crypto.randomUUID(),
+        email,
+        status: "pending",
+        source: input.source,
+        tags: input.tags || [],
+        metadata: input.metadata,
+        consentIp: input.ip,
+        consentAt: now,
+        confirmedAt: void 0,
+        unsubscribedAt: void 0,
+        createdAt: existing?.createdAt || now,
+        updatedAt: now
+      };
+      subscribers.set(email, subscriber);
+      tokenIndex.set(confirmToken, email);
+      return { ...subscriber, id: confirmToken };
+    },
+    async getSubscriberByEmail(email) {
+      return subscribers.get(email.toLowerCase()) || null;
+    },
+    async getSubscriberByToken(token) {
+      const email = tokenIndex.get(token);
+      if (!email) return null;
+      return subscribers.get(email) || null;
+    },
+    async confirmSubscriber(token) {
+      const email = tokenIndex.get(token);
+      if (!email) return null;
+      const subscriber = subscribers.get(email);
+      if (!subscriber) return null;
+      const updated = {
+        ...subscriber,
+        status: "confirmed",
+        confirmedAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      subscribers.set(email, updated);
+      tokenIndex.delete(token);
+      return updated;
+    },
+    async unsubscribe(email) {
+      const subscriber = subscribers.get(email.toLowerCase());
+      if (!subscriber) return false;
+      const updated = {
+        ...subscriber,
+        status: "unsubscribed",
+        unsubscribedAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      subscribers.set(email.toLowerCase(), updated);
+      return true;
+    },
+    async listSubscribers(options) {
+      let results = Array.from(subscribers.values());
+      if (options?.status) {
+        results = results.filter((s) => s.status === options.status);
+      }
+      if (options?.source) {
+        results = results.filter((s) => s.source === options.source);
+      }
+      if (options?.tags?.length) {
+        results = results.filter(
+          (s) => options.tags.some((tag) => s.tags?.includes(tag))
+        );
+      }
+      results.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+      const total = results.length;
+      const offset = options?.offset || 0;
+      const limit = options?.limit || 100;
+      return {
+        subscribers: results.slice(offset, offset + limit),
+        total
+      };
+    },
+    async deleteSubscriber(email) {
+      const normalizedEmail = email.toLowerCase();
+      const existed = subscribers.has(normalizedEmail);
+      subscribers.delete(normalizedEmail);
+      for (const [token, e] of tokenIndex.entries()) {
+        if (e === normalizedEmail) {
+          tokenIndex.delete(token);
+          break;
+        }
+      }
+      return existed;
+    },
+    async updateSubscriber(email, data) {
+      const normalizedEmail = email.toLowerCase();
+      const subscriber = subscribers.get(normalizedEmail);
+      if (!subscriber) return null;
+      const updated = {
+        ...subscriber,
+        ...data.source !== void 0 && { source: data.source },
+        ...data.tags !== void 0 && { tags: data.tags },
+        ...data.metadata !== void 0 && { metadata: data.metadata },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      subscribers.set(normalizedEmail, updated);
+      return updated;
+    }
+  };
+}
+function createNoopAdapter() {
+  return {
+    async createSubscriber(input) {
+      return {
+        id: "noop",
+        email: input.email,
+        status: "pending",
+        source: input.source,
+        tags: input.tags,
+        metadata: input.metadata,
+        consentIp: input.ip,
+        consentAt: /* @__PURE__ */ new Date(),
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    },
+    async getSubscriberByEmail() {
+      return null;
+    },
+    async getSubscriberByToken() {
+      return null;
+    },
+    async confirmSubscriber() {
+      return null;
+    },
+    async unsubscribe() {
+      return true;
+    }
+  };
+}
+export {
+  createMemoryAdapter,
+  createNoopAdapter,
+  createPrismaAdapter,
+  createSupabaseAdapter
+};
+//# sourceMappingURL=index.js.map