perspectapi-ts-sdk 1.1.1

package/src/client/products-client.ts

@@ -0,0 +1,247 @@
+/**
+ * Products Management client for PerspectAPI SDK
+ */
+
+import { BaseClient } from './base-client';
+import type {
+  Product,
+  CreateProductRequest,
+  PaginatedResponse,
+  ApiResponse,
+  ProductQueryParams,
+} from '../types';
+
+export class ProductsClient extends BaseClient {
+  constructor(http: any) {
+    super(http, '/api/v1');
+  }
+
+  /**
+   * Get all products for a site
+   */
+  async getProducts(siteName: string, params?: ProductQueryParams): Promise<PaginatedResponse<Product>> {
+    const normalizeList = (value: string | number | Array<string | number> | undefined): string | undefined => {
+      if (value === undefined || value === null) {
+        return undefined;
+      }
+      const values = Array.isArray(value) ? value : [value];
+      const normalized = values
+        .map(item => String(item).trim())
+        .filter(item => item.length > 0);
+
+      return normalized.length > 0 ? normalized.join(',') : undefined;
+    };
+
+    const normalizedParams: ProductQueryParams | undefined = params ? { ...params } : undefined;
+
+    if (normalizedParams) {
+      const normalizedCategories = normalizeList(normalizedParams.category as any);
+      if (normalizedCategories !== undefined) {
+        normalizedParams.category = normalizedCategories;
+      } else {
+        delete normalizedParams.category;
+      }
+
+      const normalizedCategoryIds = normalizeList(normalizedParams.category_id as any);
+      if (normalizedCategoryIds !== undefined) {
+        normalizedParams.category_id = normalizedCategoryIds;
+      } else {
+        delete normalizedParams.category_id;
+      }
+    }
+
+    return this.http.get(this.buildPath(this.siteScopedEndpoint(siteName, '/products')), normalizedParams);
+  }
+
+  /**
+   * Get product by ID
+   */
+  async getProductById(id: number): Promise<ApiResponse<Product>> {
+    return this.getSingle<Product>(`/products/${id}`);
+  }
+
+  /**
+   * Get product by SKU
+   */
+  async getProductBySku(sku: string): Promise<ApiResponse<Product>> {
+    return this.getSingle<Product>(`/products/sku/${sku}`);
+  }
+
+  /**
+   * Get product by slug and site name
+   */
+  async getProductBySlug(siteName: string, slug: string): Promise<ApiResponse<Product & { variants?: any[] }>> {
+    return this.http.get(this.buildPath(
+      this.siteScopedEndpoint(siteName, `/products/slug/${encodeURIComponent(slug)}`)
+    ));
+  }
+
+  /**
+   * Create new product
+   */
+  async createProduct(data: CreateProductRequest): Promise<ApiResponse<Product>> {
+    return this.create<CreateProductRequest, Product>('/products', data);
+  }
+
+  /**
+   * Update product
+   */
+  async updateProduct(id: number, data: Partial<CreateProductRequest>): Promise<ApiResponse<Product>> {
+    return this.update<Partial<CreateProductRequest>, Product>(`/products/${id}`, data);
+  }
+
+  /**
+   * Delete product
+   */
+  async deleteProduct(id: number): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/products/${id}`);
+  }
+
+  /**
+   * Activate product
+   */
+  async activateProduct(id: number): Promise<ApiResponse<Product>> {
+    return this.patch<{ isActive: boolean }, Product>(`/products/${id}`, { isActive: true });
+  }
+
+  /**
+   * Deactivate product
+   */
+  async deactivateProduct(id: number): Promise<ApiResponse<Product>> {
+    return this.patch<{ isActive: boolean }, Product>(`/products/${id}`, { isActive: false });
+  }
+
+  /**
+   * Get product variants
+   */
+  async getProductVariants(id: number): Promise<ApiResponse<Array<{
+    id: number;
+    name: string;
+    sku: string;
+    price: number;
+    inventory: number;
+    attributes: Record<string, any>;
+  }>>> {
+    return this.getSingle(`/products/${id}/variants`);
+  }
+
+  /**
+   * Add product variant
+   */
+  async addProductVariant(id: number, data: {
+    name: string;
+    sku: string;
+    price: number;
+    inventory?: number;
+    attributes?: Record<string, any>;
+  }): Promise<ApiResponse<{ message: string }>> {
+    return this.create(`/products/${id}/variants`, data);
+  }
+
+  /**
+   * Update product variant
+   */
+  async updateProductVariant(id: number, variantId: number, data: {
+    name?: string;
+    sku?: string;
+    price?: number;
+    inventory?: number;
+    attributes?: Record<string, any>;
+  }): Promise<ApiResponse<{ message: string }>> {
+    return this.update(`/products/${id}/variants/${variantId}`, data);
+  }
+
+  /**
+   * Delete product variant
+   */
+  async deleteProductVariant(id: number, variantId: number): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/products/${id}/variants/${variantId}`);
+  }
+
+  /**
+   * Get product inventory
+   */
+  async getProductInventory(id: number): Promise<ApiResponse<{
+    totalStock: number;
+    availableStock: number;
+    reservedStock: number;
+    lowStockThreshold: number;
+    isLowStock: boolean;
+  }>> {
+    return this.getSingle(`/products/${id}/inventory`);
+  }
+
+  /**
+   * Update product inventory
+   */
+  async updateProductInventory(id: number, data: {
+    quantity: number;
+    operation: 'add' | 'subtract' | 'set';
+    reason?: string;
+  }): Promise<ApiResponse<{ message: string; newQuantity: number }>> {
+    return this.create(`/products/${id}/inventory`, data);
+  }
+
+  /**
+   * Get product categories
+   */
+  async getProductCategories(id: number): Promise<ApiResponse<Array<{
+    id: number;
+    name: string;
+    slug: string;
+  }>>> {
+    return this.getSingle(`/products/${id}/categories`);
+  }
+
+  /**
+   * Add product to category
+   */
+  async addProductToCategory(id: number, categoryId: number): Promise<ApiResponse<{ message: string }>> {
+    return this.create(`/products/${id}/categories`, { categoryId });
+  }
+
+  /**
+   * Remove product from category
+   */
+  async removeProductFromCategory(id: number, categoryId: number): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/products/${id}/categories/${categoryId}`);
+  }
+
+  /**
+   * Get products by category slug
+   */
+  async getProductsByCategorySlug(
+    siteName: string,
+    categorySlug: string,
+    params?: {
+      page?: number;
+      limit?: number;
+      published?: boolean;
+      search?: string;
+    }
+  ): Promise<ApiResponse<{
+    data: Product[];
+    category: {
+      id: number;
+      name: string;
+      slug: string;
+      description?: string;
+    };
+    meta: {
+      count: number;
+      limit?: number;
+      offset?: number;
+    };
+  }>> {
+    const queryParams = params ? {
+      limit: params.limit,
+      offset: params.page ? (params.page - 1) * (params.limit || 20) : undefined,
+      published: params.published,
+      search: params.search
+    } : undefined;
+
+    return this.http.get(this.buildPath(
+      this.siteScopedEndpoint(siteName, `/products/category/${encodeURIComponent(categorySlug)}`)
+    ), queryParams);
+  }
+}

package/src/client/sites-client.ts

@@ -0,0 +1,148 @@
+/**
+ * Sites Management client for PerspectAPI SDK
+ */
+
+import { BaseClient } from './base-client';
+import type {
+  Site,
+  CreateSiteRequest,
+  PaginatedResponse,
+  ApiResponse,
+} from '../types';
+
+export class SitesClient extends BaseClient {
+  constructor(http: any) {
+    super(http, '/api/v1');
+  }
+
+  /**
+   * Get all sites
+   */
+  async getSites(params?: { 
+    page?: number; 
+    limit?: number;
+    organizationId?: number;
+  }): Promise<PaginatedResponse<Site>> {
+    return this.getPaginated<Site>('/sites', params);
+  }
+
+  /**
+   * Get site by ID
+   */
+  async getSiteById(id: number): Promise<ApiResponse<Site>> {
+    return this.getSingle<Site>(`/sites/${id}`);
+  }
+
+  /**
+   * Get site by name
+   */
+  async getSiteByName(name: string): Promise<ApiResponse<Site>> {
+    return this.getSingle<Site>(`/sites/name/${name}`);
+  }
+
+  /**
+   * Create new site
+   */
+  async createSite(data: CreateSiteRequest): Promise<ApiResponse<Site>> {
+    return this.create<CreateSiteRequest, Site>('/sites', data);
+  }
+
+  /**
+   * Update site
+   */
+  async updateSite(id: number, data: Partial<CreateSiteRequest>): Promise<ApiResponse<Site>> {
+    return this.update<Partial<CreateSiteRequest>, Site>(`/sites/${id}`, data);
+  }
+
+  /**
+   * Delete site
+   */
+  async deleteSite(id: number): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/sites/${id}`);
+  }
+
+  /**
+   * Activate site
+   */
+  async activateSite(id: number): Promise<ApiResponse<Site>> {
+    return this.patch<{ isActive: boolean }, Site>(`/sites/${id}`, { isActive: true });
+  }
+
+  /**
+   * Deactivate site
+   */
+  async deactivateSite(id: number): Promise<ApiResponse<Site>> {
+    return this.patch<{ isActive: boolean }, Site>(`/sites/${id}`, { isActive: false });
+  }
+
+  /**
+   * Get site configuration
+   */
+  async getSiteConfig(id: number): Promise<ApiResponse<Record<string, any>>> {
+    return this.getSingle<Record<string, any>>(`/sites/${id}/config`);
+  }
+
+  /**
+   * Update site configuration
+   */
+  async updateSiteConfig(id: number, config: Record<string, any>): Promise<ApiResponse<Record<string, any>>> {
+    return this.update<Record<string, any>>(`/sites/${id}/config`, config);
+  }
+
+  /**
+   * Get site analytics
+   */
+  async getSiteAnalytics(id: number, params?: {
+    startDate?: string;
+    endDate?: string;
+    metrics?: string[];
+  }): Promise<ApiResponse<{
+    pageViews: number;
+    uniqueVisitors: number;
+    bounceRate: number;
+    avgSessionDuration: number;
+    topPages: Array<{ path: string; views: number }>;
+  }>> {
+    return this.http.get(`/sites/${id}/analytics`, params);
+  }
+
+  /**
+   * Get site domains
+   */
+  async getSiteDomains(id: number): Promise<ApiResponse<Array<{
+    domain: string;
+    isPrimary: boolean;
+    isVerified: boolean;
+    createdAt: string;
+  }>>> {
+    return this.getSingle(`/sites/${id}/domains`);
+  }
+
+  /**
+   * Add domain to site
+   */
+  async addSiteDomain(id: number, data: {
+    domain: string;
+    isPrimary?: boolean;
+  }): Promise<ApiResponse<{ message: string }>> {
+    return this.create(`/sites/${id}/domains`, data);
+  }
+
+  /**
+   * Remove domain from site
+   */
+  async removeSiteDomain(id: number, domain: string): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/sites/${id}/domains/${encodeURIComponent(domain)}`);
+  }
+
+  /**
+   * Verify domain ownership
+   */
+  async verifySiteDomain(id: number, domain: string): Promise<ApiResponse<{
+    verified: boolean;
+    verificationMethod: string;
+    verificationValue: string;
+  }>> {
+    return this.create(`/sites/${id}/domains/${encodeURIComponent(domain)}/verify`, {});
+  }
+}

package/src/client/webhooks-client.ts

@@ -0,0 +1,199 @@
+/**
+ * Webhooks Management client for PerspectAPI SDK
+ */
+
+import { BaseClient } from './base-client';
+import type {
+  Webhook,
+  CreateWebhookRequest,
+  PaginatedResponse,
+  ApiResponse,
+} from '../types';
+
+export class WebhooksClient extends BaseClient {
+  constructor(http: any) {
+    super(http, '/api/v1');
+  }
+
+  /**
+   * Get all webhooks
+   */
+  async getWebhooks(params?: { 
+    page?: number; 
+    limit?: number;
+    provider?: string;
+    isActive?: boolean;
+  }): Promise<PaginatedResponse<Webhook>> {
+    return this.getPaginated<Webhook>('/webhooks', params);
+  }
+
+  /**
+   * Get webhook by ID
+   */
+  async getWebhookById(id: string): Promise<ApiResponse<Webhook>> {
+    return this.getSingle<Webhook>(`/webhooks/${id}`);
+  }
+
+  /**
+   * Create new webhook
+   */
+  async createWebhook(data: CreateWebhookRequest): Promise<ApiResponse<Webhook>> {
+    return this.create<CreateWebhookRequest, Webhook>('/webhooks', data);
+  }
+
+  /**
+   * Update webhook
+   */
+  async updateWebhook(id: string, data: Partial<CreateWebhookRequest>): Promise<ApiResponse<Webhook>> {
+    return this.update<Partial<CreateWebhookRequest>, Webhook>(`/webhooks/${id}`, data);
+  }
+
+  /**
+   * Delete webhook
+   */
+  async deleteWebhook(id: string): Promise<ApiResponse<{ message: string }>> {
+    return this.delete<{ message: string }>(`/webhooks/${id}`);
+  }
+
+  /**
+   * Activate webhook
+   */
+  async activateWebhook(id: string): Promise<ApiResponse<Webhook>> {
+    return this.patch<{ isActive: boolean }, Webhook>(`/webhooks/${id}`, { isActive: true });
+  }
+
+  /**
+   * Deactivate webhook
+   */
+  async deactivateWebhook(id: string): Promise<ApiResponse<Webhook>> {
+    return this.patch<{ isActive: boolean }, Webhook>(`/webhooks/${id}`, { isActive: false });
+  }
+
+  /**
+   * Test webhook
+   */
+  async testWebhook(id: string, data?: any): Promise<ApiResponse<{
+    success: boolean;
+    statusCode: number;
+    response: any;
+    duration: number;
+  }>> {
+    return this.create(`/webhooks/${id}/test`, data || {});
+  }
+
+  /**
+   * Get webhook events
+   */
+  async getWebhookEvents(id: string, params?: {
+    page?: number;
+    limit?: number;
+    status?: 'pending' | 'processing' | 'completed' | 'failed';
+    startDate?: string;
+    endDate?: string;
+  }): Promise<PaginatedResponse<{
+    id: string;
+    eventType: string;
+    status: string;
+    payload: any;
+    response?: any;
+    attempts: number;
+    createdAt: string;
+    processedAt?: string;
+  }>> {
+    return this.getPaginated(`/webhooks/${id}/events`, params);
+  }
+
+  /**
+   * Get webhook logs
+   */
+  async getWebhookLogs(id: string, params?: {
+    page?: number;
+    limit?: number;
+    level?: 'info' | 'warn' | 'error';
+    startDate?: string;
+    endDate?: string;
+  }): Promise<PaginatedResponse<{
+    id: string;
+    level: string;
+    message: string;
+    metadata?: any;
+    createdAt: string;
+  }>> {
+    return this.getPaginated(`/webhooks/${id}/logs`, params);
+  }
+
+  /**
+   * Get webhook statistics
+   */
+  async getWebhookStats(id?: string): Promise<ApiResponse<{
+    totalWebhooks: number;
+    activeWebhooks: number;
+    totalEvents: number;
+    successfulEvents: number;
+    failedEvents: number;
+    averageResponseTime: number;
+    eventsByProvider: Record<string, number>;
+    recentActivity: Array<{
+      date: string;
+      events: number;
+      successes: number;
+      failures: number;
+    }>;
+  }>> {
+    const endpoint = id ? `/webhooks/${id}/stats` : '/webhooks/stats';
+    return this.getSingle(endpoint);
+  }
+
+  /**
+   * Get supported webhook providers
+   */
+  async getWebhookProviders(): Promise<ApiResponse<Array<{
+    name: string;
+    displayName: string;
+    description: string;
+    supportedEvents: string[];
+    configurationFields: Array<{
+      name: string;
+      type: string;
+      required: boolean;
+      description: string;
+    }>;
+  }>>> {
+    return this.getSingle('/webhooks/providers');
+  }
+
+  /**
+   * Retry failed webhook event
+   */
+  async retryWebhookEvent(webhookId: string, eventId: string): Promise<ApiResponse<{
+    success: boolean;
+    message: string;
+  }>> {
+    return this.create(`/webhooks/${webhookId}/events/${eventId}/retry`, {});
+  }
+
+  /**
+   * Bulk retry failed webhook events
+   */
+  async bulkRetryWebhookEvents(webhookId: string, eventIds: string[]): Promise<ApiResponse<{
+    success: boolean;
+    retriedCount: number;
+    failedCount: number;
+  }>> {
+    return this.create(`/webhooks/${webhookId}/events/bulk-retry`, { eventIds });
+  }
+
+  /**
+   * Get webhook delivery attempts
+   */
+  async getWebhookDeliveryAttempts(webhookId: string, eventId: string): Promise<ApiResponse<Array<{
+    id: string;
+    attempt: number;
+    statusCode: number;
+    response: any;
+    duration: number;
+    createdAt: string;
+  }>>> {
+    return this.getSingle(`/webhooks/${webhookId}/events/${eventId}/attempts`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,74 @@
+/**
+ * PerspectAPI TypeScript SDK
+ * Cloudflare Workers compatible SDK for PerspectAPI
+ */
+
+// Main client
+export { PerspectApiClient, createPerspectApiClient } from './perspect-api-client';
+export { default } from './perspect-api-client';
+
+// Individual clients (for advanced usage)
+export { AuthClient } from './client/auth-client';
+export { ContentClient } from './client/content-client';
+export { ApiKeysClient } from './client/api-keys-client';
+export { OrganizationsClient } from './client/organizations-client';
+export { SitesClient } from './client/sites-client';
+export { ProductsClient } from './client/products-client';
+export { CategoriesClient } from './client/categories-client';
+export { WebhooksClient } from './client/webhooks-client';
+export { CheckoutClient } from './client/checkout-client';
+export { ContactClient } from './client/contact-client';
+
+// Base classes
+export { BaseClient } from './client/base-client';
+
+// Utilities
+export { HttpClient, createApiError } from './utils/http-client';
+
+// High-level data loaders
+export {
+  loadProducts,
+  loadProductBySlug,
+  loadPosts,
+  loadPages,
+  loadContentBySlug,
+  loadAllContent,
+  createCheckoutSession,
+  transformProduct,
+  transformContent
+} from './loaders';
+
+export type {
+  LoaderOptions,
+  LoadProductsOptions,
+  LoadProductBySlugOptions,
+  LoadContentOptions,
+  LoadContentBySlugOptions,
+  CheckoutSessionOptions,
+  LoaderLogger
+} from './loaders';
+
+// Types
+export type * from './types';
+
+// Re-export commonly used types for convenience
+export type {
+  PerspectApiConfig,
+  ApiResponse,
+  PaginatedResponse,
+  ApiError,
+  User,
+  Content,
+  Product,
+  ProductQueryParams,
+  MediaItem,
+  BlogPost,
+  Category,
+  Organization,
+  Site,
+  ApiKey,
+  Webhook,
+  ContactSubmission,
+  CheckoutSession,
+  PaymentGateway,
+} from './types';