perspectapi-ts-sdk 1.1.1

package/src/client/checkout-client.ts

@@ -0,0 +1,249 @@
+/**
+ * Checkout/Stripe client for PerspectAPI SDK
+ */
+
+import { BaseClient } from './base-client';
+import type {
+  CreateCheckoutSessionRequest,
+  CheckoutSession,
+  ApiResponse,
+} from '../types';
+
+export class CheckoutClient extends BaseClient {
+  constructor(http: any) {
+    super(http, '/api/v1');
+  }
+
+  /**
+   * Get CSRF token for a specific site
+   * @param siteName - The site name to get CSRF token for
+   */
+  async getCsrfToken(siteName: string): Promise<ApiResponse<{
+    csrf_token: string;
+    site_id: string;
+    site_name: string;
+  }>> {
+    return this.http.get(`/api/v1/csrf/token/${siteName}`);
+  }
+
+  /**
+   * Create Stripe checkout session with CSRF protection
+   * @param siteName - The site name for the checkout session
+   * @param data - Checkout session data (can include priceId for single item or line_items for multiple)
+   * @param csrfToken - Optional CSRF token (if not provided, will fetch automatically)
+   */
+  async createCheckoutSession(
+    siteName: string, 
+    data: CreateCheckoutSessionRequest,
+    csrfToken?: string
+  ): Promise<ApiResponse<CheckoutSession>> {
+    // If no CSRF token provided, fetch it first
+    let token = csrfToken;
+    if (!token) {
+      const csrfResponse = await this.getCsrfToken(siteName);
+      const csrfToken = csrfResponse.data?.csrf_token;
+
+      if (!csrfToken) {
+        throw new Error('Failed to obtain CSRF token');
+      }
+
+      token = csrfToken;
+    }
+
+    // Make the checkout request with CSRF token in headers
+    return this.http.request(this.buildPath(
+      this.siteScopedEndpoint(siteName, '/checkout/create-session')
+    ), {
+      method: 'POST',
+      body: data,
+      headers: {
+        'X-CSRF-Token': token
+      }
+    });
+  }
+
+  /**
+   * Get checkout session by ID
+   */
+  async getCheckoutSession(sessionId: string): Promise<ApiResponse<{
+    id: string;
+    status: string;
+    paymentStatus: string;
+    customerEmail?: string;
+    amountTotal: number;
+    currency: string;
+    metadata?: Record<string, string>;
+    createdAt: string;
+    expiresAt: string;
+  }>> {
+    return this.getSingle(`/checkout/sessions/${sessionId}`);
+  }
+
+  /**
+   * Get checkout sessions for organization
+   */
+  async getCheckoutSessions(params?: {
+    page?: number;
+    limit?: number;
+    status?: string;
+    customerEmail?: string;
+    startDate?: string;
+    endDate?: string;
+  }): Promise<ApiResponse<Array<{
+    id: string;
+    status: string;
+    paymentStatus: string;
+    customerEmail?: string;
+    amountTotal: number;
+    currency: string;
+    createdAt: string;
+  }>>> {
+    return this.getPaginated('/checkout/sessions', params);
+  }
+
+  /**
+   * Cancel checkout session
+   */
+  async cancelCheckoutSession(sessionId: string): Promise<ApiResponse<{
+    success: boolean;
+    message: string;
+  }>> {
+    return this.create(`/checkout/sessions/${sessionId}/cancel`, {});
+  }
+
+  /**
+   * Expire checkout session
+   */
+  async expireCheckoutSession(sessionId: string): Promise<ApiResponse<{
+    success: boolean;
+    message: string;
+  }>> {
+    return this.create(`/checkout/sessions/${sessionId}/expire`, {});
+  }
+
+  /**
+   * Get Stripe publishable key
+   */
+  async getStripePublishableKey(): Promise<ApiResponse<{
+    publishableKey: string;
+    mode: 'test' | 'live';
+  }>> {
+    return this.getSingle('/checkout/stripe/config');
+  }
+
+  /**
+   * Create payment intent (for custom checkout flows)
+   */
+  async createPaymentIntent(data: {
+    amount: number;
+    currency: string;
+    customerEmail?: string;
+    metadata?: Record<string, string>;
+    paymentMethodTypes?: string[];
+  }): Promise<ApiResponse<{
+    clientSecret: string;
+    id: string;
+    status: string;
+  }>> {
+    return this.create('/checkout/payment-intent', data);
+  }
+
+  /**
+   * Confirm payment intent
+   */
+  async confirmPaymentIntent(paymentIntentId: string, data: {
+    paymentMethodId: string;
+    returnUrl?: string;
+  }): Promise<ApiResponse<{
+    success: boolean;
+    status: string;
+    nextAction?: any;
+  }>> {
+    return this.create(`/checkout/payment-intent/${paymentIntentId}/confirm`, data);
+  }
+
+  /**
+   * Get payment methods for customer
+   */
+  async getPaymentMethods(customerId: string): Promise<ApiResponse<Array<{
+    id: string;
+    type: string;
+    card?: {
+      brand: string;
+      last4: string;
+      expMonth: number;
+      expYear: number;
+    };
+    createdAt: string;
+  }>>> {
+    return this.getSingle(`/checkout/customers/${customerId}/payment-methods`);
+  }
+
+  /**
+   * Create customer
+   */
+  async createCustomer(data: {
+    email: string;
+    name?: string;
+    phone?: string;
+    metadata?: Record<string, string>;
+  }): Promise<ApiResponse<{
+    id: string;
+    email: string;
+    name?: string;
+    createdAt: string;
+  }>> {
+    return this.create('/checkout/customers', data);
+  }
+
+  /**
+   * Get customer by ID
+   */
+  async getCustomer(customerId: string): Promise<ApiResponse<{
+    id: string;
+    email: string;
+    name?: string;
+    phone?: string;
+    metadata?: Record<string, string>;
+    createdAt: string;
+  }>> {
+    return this.getSingle(`/checkout/customers/${customerId}`);
+  }
+
+  /**
+   * Update customer
+   */
+  async updateCustomer(customerId: string, data: {
+    email?: string;
+    name?: string;
+    phone?: string;
+    metadata?: Record<string, string>;
+  }): Promise<ApiResponse<{
+    id: string;
+    email: string;
+    name?: string;
+    updatedAt: string;
+  }>> {
+    return this.update(`/checkout/customers/${customerId}`, data);
+  }
+
+  /**
+   * Get invoices for customer
+   */
+  async getCustomerInvoices(customerId: string, params?: {
+    page?: number;
+    limit?: number;
+    status?: string;
+  }): Promise<ApiResponse<Array<{
+    id: string;
+    number: string;
+    status: string;
+    amountPaid: number;
+    amountDue: number;
+    currency: string;
+    dueDate?: string;
+    createdAt: string;
+  }>>> {
+    return this.getPaginated(`/checkout/customers/${customerId}/invoices`, params);
+  }
+}

package/src/client/contact-client.ts

@@ -0,0 +1,203 @@
+/**
+ * Contact Forms client for PerspectAPI SDK
+ */
+
+import { BaseClient } from './base-client';
+import type {
+  ContactSubmission,
+  CreateContactRequest,
+  PaginatedResponse,
+  ApiResponse,
+} from '../types';
+
+export class ContactClient extends BaseClient {
+  constructor(http: any) {
+    super(http, '/api/v1');
+  }
+
+  /**
+   * Build a contact endpoint scoped to a site (without /sites prefix)
+   */
+  private contactEndpoint(siteName: string, endpoint: string): string {
+    return this.siteScopedEndpoint(siteName, endpoint, { includeSitesSegment: false });
+  }
+
+  /**
+   * Submit contact form
+   */
+  async submitContact(siteName: string, data: CreateContactRequest): Promise<ApiResponse<{
+    id: string;
+    message: string;
+    status: string;
+  }>> {
+    return this.create<CreateContactRequest, {
+      id: string;
+      message: string;
+      status: string;
+    }>(this.contactEndpoint(siteName, '/contact/submit'), data);
+  }
+
+  /**
+   * Get contact submission status
+   */
+  async getContactStatus(siteName: string, id: string): Promise<ApiResponse<{
+    id: string;
+    status: string;
+    submittedAt: string;
+    processedAt?: string;
+  }>> {
+    return this.getSingle(this.contactEndpoint(siteName, `/contact/status/${encodeURIComponent(id)}`));
+  }
+
+  /**
+   * Get all contact submissions (admin only)
+   */
+  async getContactSubmissions(siteName: string, params?: {
+    page?: number;
+    limit?: number;
+    status?: string;
+    startDate?: string;
+    endDate?: string;
+    search?: string;
+  }): Promise<PaginatedResponse<ContactSubmission>> {
+    return this.getPaginated<ContactSubmission>(this.contactEndpoint(siteName, '/contact/list'), params);
+  }
+
+  /**
+   * Get contact submission by ID (admin only)
+   */
+  async getContactSubmissionById(siteName: string, id: string): Promise<ApiResponse<ContactSubmission & {
+    ipAddress?: string;
+    userAgent?: string;
+    metadata?: Record<string, any>;
+  }>> {
+    return this.getSingle(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`));
+  }
+
+  /**
+   * Update contact submission status (admin only)
+   */
+  async updateContactStatus(siteName: string, id: string, status: string, notes?: string): Promise<ApiResponse<{
+    message: string;
+    status: string;
+  }>> {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status, notes });
+  }
+
+  /**
+   * Mark contact as read (admin only)
+   */
+  async markContactAsRead(siteName: string, id: string): Promise<ApiResponse<{ message: string }>> {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status: 'read' });
+  }
+
+  /**
+   * Mark contact as unread (admin only)
+   */
+  async markContactAsUnread(siteName: string, id: string): Promise<ApiResponse<{ message: string }>> {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status: 'unread' });
+  }
+
+  /**
+   * Archive contact submission (admin only)
+   */
+  async archiveContact(siteName: string, id: string): Promise<ApiResponse<{ message: string }>> {
+    return this.patch(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`), { status: 'archived' });
+  }
+
+  /**
+   * Delete contact submission (admin only)
+   */
+  async deleteContact(siteName: string, id: string): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(this.contactEndpoint(siteName, `/contact/${encodeURIComponent(id)}`));
+  }
+
+  /**
+   * Bulk update contact submissions (admin only)
+   */
+  async bulkUpdateContacts(siteName: string, data: {
+    ids: string[];
+    status?: string;
+    action: 'mark_read' | 'mark_unread' | 'archive' | 'delete';
+  }): Promise<ApiResponse<{
+    success: boolean;
+    updatedCount: number;
+    failedCount: number;
+  }>> {
+    return this.create(this.contactEndpoint(siteName, '/contact/bulk-update'), data);
+  }
+
+  /**
+   * Get contact form statistics (admin only)
+   */
+  async getContactStats(siteName: string, params?: {
+    startDate?: string;
+    endDate?: string;
+  }): Promise<ApiResponse<{
+    totalSubmissions: number;
+    unreadSubmissions: number;
+    readSubmissions: number;
+    archivedSubmissions: number;
+    submissionsByDay: Array<{
+      date: string;
+      count: number;
+    }>;
+    submissionsByStatus: Record<string, number>;
+    averageResponseTime?: number;
+  }>> {
+    return this.http.get(this.buildPath(this.contactEndpoint(siteName, '/contact/stats')), params);
+  }
+
+  /**
+   * Export contact submissions (admin only)
+   */
+  async exportContacts(siteName: string, params?: {
+    format?: 'csv' | 'json' | 'xlsx';
+    startDate?: string;
+    endDate?: string;
+    status?: string;
+  }): Promise<ApiResponse<{
+    downloadUrl: string;
+    expiresAt: string;
+  }>> {
+    return this.create(this.contactEndpoint(siteName, '/contact/export'), params || {});
+  }
+
+  /**
+   * Get contact form configuration
+   */
+  async getContactConfig(siteName: string): Promise<ApiResponse<{
+    turnstileEnabled: boolean;
+    rateLimitEnabled: boolean;
+    rateLimitWindow: number;
+    rateLimitMax: number;
+    requiredFields: string[];
+    customFields?: Array<{
+      name: string;
+      type: string;
+      required: boolean;
+      label: string;
+    }>;
+  }>> {
+    return this.getSingle(this.contactEndpoint(siteName, '/contact/config'));
+  }
+
+  /**
+   * Update contact form configuration (admin only)
+   */
+  async updateContactConfig(siteName: string, data: {
+    turnstileEnabled?: boolean;
+    rateLimitEnabled?: boolean;
+    rateLimitWindow?: number;
+    rateLimitMax?: number;
+    requiredFields?: string[];
+    customFields?: Array<{
+      name: string;
+      type: string;
+      required: boolean;
+      label: string;
+    }>;
+  }): Promise<ApiResponse<{ message: string }>> {
+    return this.update(this.contactEndpoint(siteName, '/contact/config'), data);
+  }
+}

package/src/client/content-client.ts

@@ -0,0 +1,112 @@
+/**
+ * Content Management client for PerspectAPI SDK
+ */
+
+import { BaseClient } from './base-client';
+import type {
+  Content,
+  CreateContentRequest,
+  UpdateContentRequest,
+  ContentQueryParams,
+  PaginatedResponse,
+  ApiResponse,
+} from '../types';
+
+export class ContentClient extends BaseClient {
+  constructor(http: any) {
+    super(http, '/api/v1');
+  }
+
+  /**
+   * Get all content with pagination and filtering for a site
+   */
+  async getContent(siteName: string, params?: ContentQueryParams): Promise<PaginatedResponse<Content>> {
+    return this.http.get(this.buildPath(this.siteScopedEndpoint(siteName)), params);
+  }
+
+  /**
+   * Get content by ID
+   */
+  async getContentById(id: number): Promise<ApiResponse<Content>> {
+    return this.getSingle<Content>(`/content/${id}`);
+  }
+
+  /**
+   * Get content by slug for a site
+   */
+  async getContentBySlug(siteName: string, slug: string): Promise<ApiResponse<Content>> {
+    return this.http.get(this.buildPath(
+      this.siteScopedEndpoint(siteName, `/slug/${encodeURIComponent(slug)}`)
+    ));
+  }
+
+  /**
+   * Create new content
+   */
+  async createContent(data: CreateContentRequest): Promise<ApiResponse<Content>> {
+    return this.create<CreateContentRequest, Content>('/content', data);
+  }
+
+  /**
+   * Update content
+   */
+  async updateContent(id: number, data: UpdateContentRequest): Promise<ApiResponse<Content>> {
+    return this.update<UpdateContentRequest, Content>(`/content/${id}`, data);
+  }
+
+  /**
+   * Partially update content
+   */
+  async patchContent(id: number, data: Partial<UpdateContentRequest>): Promise<ApiResponse<Content>> {
+    return this.patch<Partial<UpdateContentRequest>, Content>(`/content/${id}`, data);
+  }
+
+  /**
+   * Delete content
+   */
+  async deleteContent(id: number): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/content/${id}`);
+  }
+
+  /**
+   * Publish content
+   */
+  async publishContent(id: number): Promise<ApiResponse<Content>> {
+    return this.create<{ action: string }, Content>(`/content/${id}/publish`, { action: 'publish' });
+  }
+
+  /**
+   * Unpublish content
+   */
+  async unpublishContent(id: number): Promise<ApiResponse<Content>> {
+    return this.create<{ action: string }, Content>(`/content/${id}/publish`, { action: 'unpublish' });
+  }
+
+  /**
+   * Move content to trash
+   */
+  async trashContent(id: number): Promise<ApiResponse<Content>> {
+    return this.create<{ action: string }, Content>(`/content/${id}/publish`, { action: 'trash' });
+  }
+
+  /**
+   * Restore content from trash
+   */
+  async restoreContent(id: number): Promise<ApiResponse<Content>> {
+    return this.create<{ action: string }, Content>(`/content/${id}/publish`, { action: 'restore' });
+  }
+
+  /**
+   * Get content revisions
+   */
+  async getContentRevisions(id: number): Promise<ApiResponse<Content[]>> {
+    return this.getSingle<Content[]>(`/content/${id}/revisions`);
+  }
+
+  /**
+   * Duplicate content
+   */
+  async duplicateContent(id: number): Promise<ApiResponse<Content>> {
+    return this.create<Record<string, never>, Content>(`/content/${id}/duplicate`, {});
+  }
+}

package/src/client/organizations-client.ts

@@ -0,0 +1,106 @@
+/**
+ * Organizations Management client for PerspectAPI SDK
+ */
+
+import { BaseClient } from './base-client';
+import type {
+  Organization,
+  CreateOrganizationRequest,
+  PaginatedResponse,
+  ApiResponse,
+} from '../types';
+
+export class OrganizationsClient extends BaseClient {
+  constructor(http: any) {
+    super(http, '/api/v1');
+  }
+
+  /**
+   * Get all organizations
+   */
+  async getOrganizations(params?: { page?: number; limit?: number }): Promise<PaginatedResponse<Organization>> {
+    return this.getPaginated<Organization>('/organizations', params);
+  }
+
+  /**
+   * Get organization by ID
+   */
+  async getOrganizationById(id: number): Promise<ApiResponse<Organization>> {
+    return this.getSingle<Organization>(`/organizations/${id}`);
+  }
+
+  /**
+   * Create new organization
+   */
+  async createOrganization(data: CreateOrganizationRequest): Promise<ApiResponse<Organization>> {
+    return this.create<CreateOrganizationRequest, Organization>('/organizations', data);
+  }
+
+  /**
+   * Update organization
+   */
+  async updateOrganization(id: number, data: Partial<CreateOrganizationRequest>): Promise<ApiResponse<Organization>> {
+    return this.update<Partial<CreateOrganizationRequest>, Organization>(`/organizations/${id}`, data);
+  }
+
+  /**
+   * Delete organization
+   */
+  async deleteOrganization(id: number): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/organizations/${id}`);
+  }
+
+  /**
+   * Get organization members
+   */
+  async getOrganizationMembers(id: number): Promise<ApiResponse<Array<{
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    role: string;
+    joinedAt: string;
+  }>>> {
+    return this.getSingle(`/organizations/${id}/members`);
+  }
+
+  /**
+   * Add member to organization
+   */
+  async addOrganizationMember(id: number, data: {
+    email: string;
+    role: string;
+  }): Promise<ApiResponse<{ message: string }>> {
+    return this.create(`/organizations/${id}/members`, data);
+  }
+
+  /**
+   * Update organization member role
+   */
+  async updateOrganizationMember(id: number, userId: string, data: {
+    role: string;
+  }): Promise<ApiResponse<{ message: string }>> {
+    return this.update(`/organizations/${id}/members/${userId}`, data);
+  }
+
+  /**
+   * Remove member from organization
+   */
+  async removeOrganizationMember(id: number, userId: string): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/organizations/${id}/members/${userId}`);
+  }
+
+  /**
+   * Get organization settings
+   */
+  async getOrganizationSettings(id: number): Promise<ApiResponse<Record<string, any>>> {
+    return this.getSingle<Record<string, any>>(`/organizations/${id}/settings`);
+  }
+
+  /**
+   * Update organization settings
+   */
+  async updateOrganizationSettings(id: number, settings: Record<string, any>): Promise<ApiResponse<Record<string, any>>> {
+    return this.update<Record<string, any>>(`/organizations/${id}/settings`, settings);
+  }
+}