perspectapi-ts-sdk 1.1.1 → 1.3.0

package/dist/index.mjs

@@ -79,26 +79,26 @@ var HttpClient = class {
   /**
    * POST request
    */
-  async post(endpoint, body) {
-    return this.request(endpoint, { method: "POST", body });
+  async post(endpoint, body, options) {
+    return this.request(endpoint, { method: "POST", body, ...options });
   }
   /**
    * PUT request
    */
-  async put(endpoint, body) {
-    return this.request(endpoint, { method: "PUT", body });
+  async put(endpoint, body, options) {
+    return this.request(endpoint, { method: "PUT", body, ...options });
   }
   /**
    * DELETE request
    */
-  async delete(endpoint) {
-    return this.request(endpoint, { method: "DELETE" });
+  async delete(endpoint, options) {
+    return this.request(endpoint, { method: "DELETE", ...options });
   }
   /**
    * PATCH request
    */
-  async patch(endpoint, body) {
-    return this.request(endpoint, { method: "PATCH", body });
+  async patch(endpoint, body, options) {
+    return this.request(endpoint, { method: "PATCH", body, ...options });
   }
   /**
    * Build full URL with query parameters
@@ -124,6 +124,9 @@ var HttpClient = class {
       ...this.defaultHeaders,
       ...options.headers
     };
+    if (options.csrfToken) {
+      headers["X-CSRF-Token"] = options.csrfToken;
+    }
     const requestOptions = {
       method: options.method || "GET",
       headers
@@ -247,26 +250,26 @@ var BaseClient = class {
   /**
    * Handle create operations
    */
-  async create(endpoint, data) {
-    return this.http.post(this.buildPath(endpoint), data);
+  async create(endpoint, data, csrfToken) {
+    return this.http.post(this.buildPath(endpoint), data, { csrfToken });
   }
   /**
    * Handle update operations
    */
-  async update(endpoint, data) {
-    return this.http.put(this.buildPath(endpoint), data);
+  async update(endpoint, data, csrfToken) {
+    return this.http.put(this.buildPath(endpoint), data, { csrfToken });
   }
   /**
    * Handle partial update operations
    */
-  async patch(endpoint, data) {
-    return this.http.patch(this.buildPath(endpoint), data);
+  async patch(endpoint, data, csrfToken) {
+    return this.http.patch(this.buildPath(endpoint), data, { csrfToken });
   }
   /**
    * Handle delete operations
    */
-  async delete(endpoint) {
-    return this.http.delete(this.buildPath(endpoint));
+  async delete(endpoint, csrfToken) {
+    return this.http.delete(this.buildPath(endpoint), { csrfToken });
   }
 };
 
@@ -1133,9 +1136,15 @@ var ContactClient = class extends BaseClient {
   }
   /**
    * Submit contact form
+   * @param siteName - The site to submit contact form to
+   * @param data - Contact form data
+   * @param csrfToken - CSRF token (required for browser-based submissions)
    */
-  async submitContact(siteName, data) {
-    return this.create(this.contactEndpoint(siteName, "/contact/submit"), data);
+  async submitContact(siteName, data, csrfToken) {
+    if (typeof window !== "undefined" && !csrfToken && !data.turnstileToken) {
+      console.warn("CSRF token recommended for browser-based contact form submissions");
+    }
+    return this.create(this.contactEndpoint(siteName, "/contact/submit"), data, csrfToken);
   }
   /**
    * Get contact submission status
@@ -1217,6 +1226,201 @@ var ContactClient = class extends BaseClient {
   }
 };
 
+// src/client/newsletter-client.ts
+var NewsletterClient = class extends BaseClient {
+  constructor(http) {
+    super(http, "/api/v1");
+  }
+  /**
+   * Build a newsletter endpoint scoped to a site (without /sites prefix)
+   */
+  newsletterEndpoint(siteName, endpoint) {
+    return this.siteScopedEndpoint(siteName, endpoint, { includeSitesSegment: false });
+  }
+  /**
+   * Subscribe to newsletter
+   * @param siteName - The site to subscribe to
+   * @param data - Subscription data
+   * @param csrfToken - CSRF token (required for browser-based submissions)
+   */
+  async subscribe(siteName, data, csrfToken) {
+    if (typeof window !== "undefined" && !csrfToken && !data.turnstile_token) {
+      console.warn("CSRF token recommended for browser-based newsletter subscriptions");
+    }
+    return this.create(
+      this.newsletterEndpoint(siteName, "/newsletter/subscribe"),
+      data,
+      csrfToken
+    );
+  }
+  /**
+   * Confirm newsletter subscription via token
+   */
+  async confirmSubscription(siteName, token) {
+    return this.getSingle(
+      this.newsletterEndpoint(siteName, `/newsletter/confirm/${encodeURIComponent(token)}`)
+    );
+  }
+  /**
+   * Unsubscribe from newsletter
+   * @param siteName - The site to unsubscribe from
+   * @param data - Unsubscribe data
+   * @param csrfToken - CSRF token (required for browser-based submissions)
+   */
+  async unsubscribe(siteName, data, csrfToken) {
+    return this.create(
+      this.newsletterEndpoint(siteName, "/newsletter/unsubscribe"),
+      data,
+      csrfToken
+    );
+  }
+  /**
+   * One-click unsubscribe via token (GET request)
+   */
+  async unsubscribeByToken(siteName, token) {
+    return this.http.get(
+      this.buildPath(this.newsletterEndpoint(siteName, `/newsletter/unsubscribe/${encodeURIComponent(token)}`))
+    );
+  }
+  /**
+   * Update subscription preferences
+   * @param siteName - The site name
+   * @param email - Subscriber email
+   * @param preferences - New preferences
+   * @param csrfToken - CSRF token (required for browser-based submissions)
+   */
+  async updatePreferences(siteName, email, preferences, csrfToken) {
+    return this.patch(
+      this.newsletterEndpoint(siteName, "/newsletter/preferences"),
+      { email, ...preferences },
+      csrfToken
+    );
+  }
+  /**
+   * Get available newsletter lists
+   */
+  async getLists(siteName) {
+    return this.getSingle(
+      this.newsletterEndpoint(siteName, "/newsletter/lists")
+    );
+  }
+  /**
+   * Check subscription status by email
+   */
+  async getStatus(siteName, email) {
+    return this.http.get(
+      this.buildPath(this.newsletterEndpoint(siteName, "/newsletter/status")),
+      { email }
+    );
+  }
+  // Admin methods (require authentication)
+  /**
+   * Get all newsletter subscriptions (admin only)
+   */
+  async getSubscriptions(siteName, params) {
+    return this.getPaginated(
+      this.newsletterEndpoint(siteName, "/newsletter/subscriptions"),
+      params
+    );
+  }
+  /**
+   * Get subscription by ID (admin only)
+   */
+  async getSubscriptionById(siteName, id) {
+    return this.getSingle(
+      this.newsletterEndpoint(siteName, `/newsletter/subscriptions/${encodeURIComponent(id)}`)
+    );
+  }
+  /**
+   * Update subscription status (admin only)
+   */
+  async updateSubscriptionStatus(siteName, id, status, notes) {
+    return this.patch(
+      this.newsletterEndpoint(siteName, `/newsletter/subscriptions/${encodeURIComponent(id)}`),
+      { status, notes }
+    );
+  }
+  /**
+   * Delete subscription (admin only)
+   */
+  async deleteSubscription(siteName, id) {
+    return this.delete(
+      this.newsletterEndpoint(siteName, `/newsletter/subscriptions/${encodeURIComponent(id)}`)
+    );
+  }
+  /**
+   * Bulk update subscriptions (admin only)
+   */
+  async bulkUpdateSubscriptions(siteName, data) {
+    return this.create(
+      this.newsletterEndpoint(siteName, "/newsletter/subscriptions/bulk-update"),
+      data
+    );
+  }
+  /**
+   * Create newsletter list (admin only)
+   */
+  async createList(siteName, data) {
+    return this.create(
+      this.newsletterEndpoint(siteName, "/newsletter/lists"),
+      data
+    );
+  }
+  /**
+   * Update newsletter list (admin only)
+   */
+  async updateList(siteName, listId, data) {
+    return this.update(
+      this.newsletterEndpoint(siteName, `/newsletter/lists/${encodeURIComponent(listId)}`),
+      data
+    );
+  }
+  /**
+   * Delete newsletter list (admin only)
+   */
+  async deleteList(siteName, listId) {
+    return this.delete(
+      this.newsletterEndpoint(siteName, `/newsletter/lists/${encodeURIComponent(listId)}`)
+    );
+  }
+  /**
+   * Get newsletter statistics (admin only)
+   */
+  async getStatistics(siteName, params) {
+    return this.http.get(
+      this.buildPath(this.newsletterEndpoint(siteName, "/newsletter/statistics")),
+      params
+    );
+  }
+  /**
+   * Export newsletter subscriptions (admin only)
+   */
+  async exportSubscriptions(siteName, params) {
+    return this.create(
+      this.newsletterEndpoint(siteName, "/newsletter/export"),
+      params || {}
+    );
+  }
+  /**
+   * Import newsletter subscriptions (admin only)
+   */
+  async importSubscriptions(siteName, data) {
+    return this.create(
+      this.newsletterEndpoint(siteName, "/newsletter/import"),
+      data
+    );
+  }
+  /**
+   * Send test newsletter (admin only)
+   */
+  async sendTestNewsletter(siteName, data) {
+    return this.create(
+      this.newsletterEndpoint(siteName, "/newsletter/test"),
+      data
+    );
+  }
+};
+
 // src/perspect-api-client.ts
 var PerspectApiClient = class {
   http;
@@ -1231,6 +1435,7 @@ var PerspectApiClient = class {
   webhooks;
   checkout;
   contact;
+  newsletter;
   constructor(config) {
     if (!config.baseUrl) {
       throw new Error("baseUrl is required in PerspectApiConfig");
@@ -1246,6 +1451,7 @@ var PerspectApiClient = class {
     this.webhooks = new WebhooksClient(this.http);
     this.checkout = new CheckoutClient(this.http);
     this.contact = new ContactClient(this.http);
+    this.newsletter = new NewsletterClient(this.http);
   }
   /**
    * Update authentication token
@@ -1707,6 +1913,7 @@ export {
   ContactClient,
   ContentClient,
   HttpClient,
+  NewsletterClient,
   OrganizationsClient,
   PerspectApiClient,
   ProductsClient,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perspectapi-ts-sdk",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "TypeScript SDK for PerspectAPI - Cloudflare Workers compatible",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/client/base-client.ts

@@ -66,9 +66,10 @@ export abstract class BaseClient {
    */
   protected async create<T, R = T>(
     endpoint: string,
-    data: T
+    data: T,
+    csrfToken?: string
   ): Promise<ApiResponse<R>> {
-    return this.http.post<R>(this.buildPath(endpoint), data);
+    return this.http.post<R>(this.buildPath(endpoint), data, { csrfToken });
   }
 
   /**
@@ -76,9 +77,10 @@ export abstract class BaseClient {
    */
   protected async update<T, R = T>(
     endpoint: string,
-    data: T
+    data: T,
+    csrfToken?: string
   ): Promise<ApiResponse<R>> {
-    return this.http.put<R>(this.buildPath(endpoint), data);
+    return this.http.put<R>(this.buildPath(endpoint), data, { csrfToken });
   }
 
   /**
@@ -86,15 +88,16 @@ export abstract class BaseClient {
    */
   protected async patch<T, R = T>(
     endpoint: string,
-    data: T
+    data: T,
+    csrfToken?: string
   ): Promise<ApiResponse<R>> {
-    return this.http.patch<R>(this.buildPath(endpoint), data);
+    return this.http.patch<R>(this.buildPath(endpoint), data, { csrfToken });
   }
 
   /**
    * Handle delete operations
    */
-  protected async delete<T = any>(endpoint: string): Promise<ApiResponse<T>> {
-    return this.http.delete<T>(this.buildPath(endpoint));
+  protected async delete<T = any>(endpoint: string, csrfToken?: string): Promise<ApiResponse<T>> {
+    return this.http.delete<T>(this.buildPath(endpoint), { csrfToken });
   }
 }

package/src/client/contact-client.ts

@@ -24,17 +24,29 @@ export class ContactClient extends BaseClient {
 
   /**
    * Submit contact form
+   * @param siteName - The site to submit contact form to
+   * @param data - Contact form data
+   * @param csrfToken - CSRF token (required for browser-based submissions)
    */
-  async submitContact(siteName: string, data: CreateContactRequest): Promise<ApiResponse<{
+  async submitContact(
+    siteName: string, 
+    data: CreateContactRequest,
+    csrfToken?: string
+  ): Promise<ApiResponse<{
     id: string;
     message: string;
     status: string;
   }>> {
+    // CSRF token is required for browser submissions
+    if (typeof window !== 'undefined' && !csrfToken && !data.turnstileToken) {
+      console.warn('CSRF token recommended for browser-based contact form submissions');
+    }
+    
     return this.create<CreateContactRequest, {
       id: string;
       message: string;
       status: string;
-    }>(this.contactEndpoint(siteName, '/contact/submit'), data);
+    }>(this.contactEndpoint(siteName, '/contact/submit'), data, csrfToken);
   }
 
   /**