perspectapi-ts-sdk 2.8.3 → 3.0.1

package/dist/index.js

@@ -716,43 +716,6 @@ var AuthClient = class extends BaseClient {
   async getCsrfToken() {
     return this.http.get(this.buildPath("/csrf"));
   }
-  /**
-   * Sign up a new user
-   */
-  async signUp(data) {
-    return this.create("/signup", data);
-  }
-  /**
-   * Sign in user
-   */
-  async signIn(data) {
-    const response = await this.create("/authenticate", data);
-    if (response.data && "token" in response.data && response.data.token) {
-      this.http.setAuth(response.data.token);
-    }
-    return response;
-  }
-  /**
-   * Activate user account
-   */
-  async activateAccount(activationKey) {
-    return this.getSingle(`/activate/${activationKey}`);
-  }
-  /**
-   * Request password reset
-   */
-  async forgotPassword(email) {
-    return this.create("/forgotpassword", { email });
-  }
-  /**
-   * Reset password with token
-   */
-  async resetPassword(resetToken, password) {
-    return this.create(
-      `/passwordreset/${resetToken}`,
-      { password }
-    );
-  }
   /**
    * Get current user profile
    */
@@ -1589,115 +1552,114 @@ var CategoriesClient = class extends BaseClient {
     super(http, "/api/v1", cache);
   }
   /**
-   * Get all categories
+   * Get all categories for a site
    */
-  async getCategories(params) {
-    return this.getPaginated("/categories", params);
-  }
-  /**
-   * Get category by ID
-   */
-  async getCategoryById(id) {
-    return this.getSingle(`/categories/${id}`);
-  }
-  /**
-   * Get category by slug
-   */
-  async getCategoryBySlug(slug) {
-    return this.getSingle(`/categories/slug/${slug}`);
+  async getCategories(siteName, params, cachePolicy) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    return this.fetchWithCache(
+      endpoint,
+      params,
+      this.buildCategoryTags(siteName),
+      cachePolicy,
+      () => this.http.get(path, params)
+    );
   }
   /**
-   * Get product category by slug (for products)
+   * Get category by ID (validates it belongs to the site)
    */
-  async getProductCategoryBySlug(siteName, slug, cachePolicy) {
-    const endpoint = this.siteScopedEndpoint(
-      siteName,
-      `/product_category/slug/${encodeURIComponent(slug)}`,
-      { includeSitesSegment: false }
-    );
+  async getCategoryById(siteName, id, cachePolicy) {
+    const endpoint = this.siteScopedEndpoint(siteName, `/categories/${id}`, { includeSitesSegment: false });
     const path = this.buildPath(endpoint);
     return this.fetchWithCache(
       endpoint,
       void 0,
-      this.buildCategoryTags(siteName, slug),
+      this.buildCategoryTags(siteName, `categories:id:${id}`),
       cachePolicy,
       () => this.http.get(path)
     );
   }
   /**
-   * Create new category
+   * Get product categories for a site
    */
-  async createCategory(data) {
-    return this.create("/categories", data);
-  }
-  /**
-   * Update category
-   */
-  async updateCategory(id, data) {
-    return this.update(`/categories/${id}`, data);
-  }
-  /**
-   * Delete category
-   */
-  async deleteCategory(id) {
-    return this.delete(`/categories/${id}`);
-  }
-  /**
-   * Get category tree (hierarchical structure)
-   */
-  async getCategoryTree(rootId) {
-    const endpoint = rootId ? `/categories/tree/${rootId}` : "/categories/tree";
-    return this.getSingle(endpoint);
-  }
-  /**
-   * Get category children
-   */
-  async getCategoryChildren(id) {
-    return this.getSingle(`/categories/${id}/children`);
-  }
-  /**
-   * Get category parent
-   */
-  async getCategoryParent(id) {
-    return this.getSingle(`/categories/${id}/parent`);
+  async getProductCategories(siteName, params, cachePolicy) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories/product", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    return this.fetchWithCache(
+      endpoint,
+      params,
+      this.buildCategoryTags(siteName, "categories:product"),
+      cachePolicy,
+      () => this.http.get(path, params)
+    );
   }
   /**
-   * Move category to new parent
+   * Create new category for a site
    */
-  async moveCategoryToParent(id, parentId) {
-    return this.patch(`/categories/${id}`, { parentId });
+  async createCategory(siteName, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.post(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName) });
+    }
+    return result;
   }
   /**
-   * Get category breadcrumb path
+   * Create new product category for a site
    */
-  async getCategoryBreadcrumb(id) {
-    return this.getSingle(`/categories/${id}/breadcrumb`);
+  async createProductCategory(siteName, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories/product", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.post(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName, "categories:product") });
+    }
+    return result;
   }
   /**
-   * Get category content/products
+   * Update category (validates it belongs to the site)
    */
-  async getCategoryContent(id, params) {
-    return this.http.get(`/categories/${id}/content`, params);
+  async updateCategory(siteName, id, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, `/categories/${id}`, { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.put(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName, `categories:id:${id}`) });
+    }
+    return result;
   }
   /**
-   * Bulk update category order
+   * Delete category (validates it belongs to the site)
    */
-  async updateCategoryOrder(updates) {
-    return this.create("/categories/reorder", { updates });
+  async deleteCategory(siteName, id, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, `/categories/${id}`, { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.delete(path, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName) });
+    }
+    return result;
   }
   /**
-   * Search categories
+   * Associate pages or products with categories
    */
-  async searchCategories(query, params) {
-    return this.http.get(`/categories/search`, { q: query, ...params });
+  async associateCategories(siteName, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories/associate", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.post(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName) });
+    }
+    return result;
   }
-  buildCategoryTags(siteName, slug) {
+  buildCategoryTags(siteName, extraTag) {
     const tags = /* @__PURE__ */ new Set(["categories"]);
     if (siteName) {
       tags.add(`categories:site:${siteName}`);
     }
-    if (slug) {
-      tags.add(`categories:product:${siteName}:${slug}`);
+    if (extraTag) {
+      tags.add(extraTag);
     }
     return Array.from(tags.values());
   }

package/dist/index.mjs

@@ -654,43 +654,6 @@ var AuthClient = class extends BaseClient {
   async getCsrfToken() {
     return this.http.get(this.buildPath("/csrf"));
   }
-  /**
-   * Sign up a new user
-   */
-  async signUp(data) {
-    return this.create("/signup", data);
-  }
-  /**
-   * Sign in user
-   */
-  async signIn(data) {
-    const response = await this.create("/authenticate", data);
-    if (response.data && "token" in response.data && response.data.token) {
-      this.http.setAuth(response.data.token);
-    }
-    return response;
-  }
-  /**
-   * Activate user account
-   */
-  async activateAccount(activationKey) {
-    return this.getSingle(`/activate/${activationKey}`);
-  }
-  /**
-   * Request password reset
-   */
-  async forgotPassword(email) {
-    return this.create("/forgotpassword", { email });
-  }
-  /**
-   * Reset password with token
-   */
-  async resetPassword(resetToken, password) {
-    return this.create(
-      `/passwordreset/${resetToken}`,
-      { password }
-    );
-  }
   /**
    * Get current user profile
    */
@@ -1527,115 +1490,114 @@ var CategoriesClient = class extends BaseClient {
     super(http, "/api/v1", cache);
   }
   /**
-   * Get all categories
+   * Get all categories for a site
    */
-  async getCategories(params) {
-    return this.getPaginated("/categories", params);
-  }
-  /**
-   * Get category by ID
-   */
-  async getCategoryById(id) {
-    return this.getSingle(`/categories/${id}`);
-  }
-  /**
-   * Get category by slug
-   */
-  async getCategoryBySlug(slug) {
-    return this.getSingle(`/categories/slug/${slug}`);
+  async getCategories(siteName, params, cachePolicy) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    return this.fetchWithCache(
+      endpoint,
+      params,
+      this.buildCategoryTags(siteName),
+      cachePolicy,
+      () => this.http.get(path, params)
+    );
   }
   /**
-   * Get product category by slug (for products)
+   * Get category by ID (validates it belongs to the site)
    */
-  async getProductCategoryBySlug(siteName, slug, cachePolicy) {
-    const endpoint = this.siteScopedEndpoint(
-      siteName,
-      `/product_category/slug/${encodeURIComponent(slug)}`,
-      { includeSitesSegment: false }
-    );
+  async getCategoryById(siteName, id, cachePolicy) {
+    const endpoint = this.siteScopedEndpoint(siteName, `/categories/${id}`, { includeSitesSegment: false });
     const path = this.buildPath(endpoint);
     return this.fetchWithCache(
       endpoint,
       void 0,
-      this.buildCategoryTags(siteName, slug),
+      this.buildCategoryTags(siteName, `categories:id:${id}`),
       cachePolicy,
       () => this.http.get(path)
     );
   }
   /**
-   * Create new category
+   * Get product categories for a site
    */
-  async createCategory(data) {
-    return this.create("/categories", data);
-  }
-  /**
-   * Update category
-   */
-  async updateCategory(id, data) {
-    return this.update(`/categories/${id}`, data);
-  }
-  /**
-   * Delete category
-   */
-  async deleteCategory(id) {
-    return this.delete(`/categories/${id}`);
-  }
-  /**
-   * Get category tree (hierarchical structure)
-   */
-  async getCategoryTree(rootId) {
-    const endpoint = rootId ? `/categories/tree/${rootId}` : "/categories/tree";
-    return this.getSingle(endpoint);
-  }
-  /**
-   * Get category children
-   */
-  async getCategoryChildren(id) {
-    return this.getSingle(`/categories/${id}/children`);
-  }
-  /**
-   * Get category parent
-   */
-  async getCategoryParent(id) {
-    return this.getSingle(`/categories/${id}/parent`);
+  async getProductCategories(siteName, params, cachePolicy) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories/product", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    return this.fetchWithCache(
+      endpoint,
+      params,
+      this.buildCategoryTags(siteName, "categories:product"),
+      cachePolicy,
+      () => this.http.get(path, params)
+    );
   }
   /**
-   * Move category to new parent
+   * Create new category for a site
    */
-  async moveCategoryToParent(id, parentId) {
-    return this.patch(`/categories/${id}`, { parentId });
+  async createCategory(siteName, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.post(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName) });
+    }
+    return result;
   }
   /**
-   * Get category breadcrumb path
+   * Create new product category for a site
    */
-  async getCategoryBreadcrumb(id) {
-    return this.getSingle(`/categories/${id}/breadcrumb`);
+  async createProductCategory(siteName, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories/product", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.post(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName, "categories:product") });
+    }
+    return result;
   }
   /**
-   * Get category content/products
+   * Update category (validates it belongs to the site)
    */
-  async getCategoryContent(id, params) {
-    return this.http.get(`/categories/${id}/content`, params);
+  async updateCategory(siteName, id, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, `/categories/${id}`, { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.put(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName, `categories:id:${id}`) });
+    }
+    return result;
   }
   /**
-   * Bulk update category order
+   * Delete category (validates it belongs to the site)
    */
-  async updateCategoryOrder(updates) {
-    return this.create("/categories/reorder", { updates });
+  async deleteCategory(siteName, id, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, `/categories/${id}`, { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.delete(path, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName) });
+    }
+    return result;
   }
   /**
-   * Search categories
+   * Associate pages or products with categories
    */
-  async searchCategories(query, params) {
-    return this.http.get(`/categories/search`, { q: query, ...params });
+  async associateCategories(siteName, data, csrfToken) {
+    const endpoint = this.siteScopedEndpoint(siteName, "/categories/associate", { includeSitesSegment: false });
+    const path = this.buildPath(endpoint);
+    const result = await this.http.post(path, data, { csrfToken });
+    if (this.cache) {
+      await this.cache.invalidate({ tags: this.buildCategoryTags(siteName) });
+    }
+    return result;
   }
-  buildCategoryTags(siteName, slug) {
+  buildCategoryTags(siteName, extraTag) {
     const tags = /* @__PURE__ */ new Set(["categories"]);
     if (siteName) {
       tags.add(`categories:site:${siteName}`);
     }
-    if (slug) {
-      tags.add(`categories:product:${siteName}:${slug}`);
+    if (extraTag) {
+      tags.add(extraTag);
     }
     return Array.from(tags.values());
   }

package/package.json

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

package/src/client/auth-client.ts

@@ -1,13 +1,13 @@
 /**
  * Authentication client for PerspectAPI SDK
+ *
+ * Admin and site user authentication is OTP-based.
+ * Site user OTP methods are on SiteUsersClient.
  */
 
 import { BaseClient } from './base-client';
 import type { CacheManager } from '../cache/cache-manager';
 import type {
-  SignUpRequest,
-  SignInRequest,
-  AuthResponse,
   User,
   ApiResponse,
 } from '../types';
@@ -24,54 +24,6 @@ export class AuthClient extends BaseClient {
     return this.http.get<{ token: string }>(this.buildPath('/csrf'));
   }
 
-  /**
-   * Sign up a new user
-   */
-  async signUp(data: SignUpRequest): Promise<ApiResponse<{ message: string; userId: string }>> {
-    return this.create<SignUpRequest, { message: string; userId: string }>('/signup', data);
-  }
-
-  /**
-   * Sign in user
-   */
-  async signIn(data: SignInRequest): Promise<ApiResponse<AuthResponse>> {
-    const response = await this.create<SignInRequest, AuthResponse>('/authenticate', data);
-    
-    // Update HTTP client with JWT if provided
-    if (response.data && 'token' in response.data && response.data.token) {
-      this.http.setAuth(response.data.token);
-    }
-    
-    return response;
-  }
-
-  /**
-   * Activate user account
-   */
-  async activateAccount(activationKey: string): Promise<ApiResponse<{ message: string }>> {
-    return this.getSingle<{ message: string }>(`/activate/${activationKey}`);
-  }
-
-  /**
-   * Request password reset
-   */
-  async forgotPassword(email: string): Promise<ApiResponse<{ message: string }>> {
-    return this.create<{ email: string }, { message: string }>('/forgotpassword', { email });
-  }
-
-  /**
-   * Reset password with token
-   */
-  async resetPassword(
-    resetToken: string,
-    password: string
-  ): Promise<ApiResponse<{ message: string }>> {
-    return this.create<{ password: string }, { message: string }>(
-      `/passwordreset/${resetToken}`,
-      { password }
-    );
-  }
-
   /**
    * Get current user profile
    */