@commet/node 0.10.1 → 1.0.0

package/dist/index.mjs

@@ -3,23 +3,84 @@ var CustomersResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
+  /**
+   * Create a customer (idempotent with externalId)
+   */
   async create(params, options) {
-    return this.httpClient.post("/customers", params, options);
+    return this.httpClient.post(
+      "/customers",
+      {
+        billingEmail: params.email,
+        externalId: params.externalId,
+        legalName: params.legalName,
+        displayName: params.displayName,
+        domain: params.domain,
+        website: params.website,
+        timezone: params.timezone,
+        language: params.language,
+        industry: params.industry,
+        metadata: params.metadata,
+        address: params.address
+      },
+      options
+    );
   }
-  async retrieve(customerId, options) {
-    const params = options?.expand ? { expand: options.expand.join(",") } : void 0;
-    return this.httpClient.get(`/customers/${customerId}`, params);
+  /**
+   * Create multiple customers in batch
+   */
+  async createBatch(params, options) {
+    const customers = params.customers.map((c) => ({
+      billingEmail: c.email,
+      externalId: c.externalId,
+      legalName: c.legalName,
+      displayName: c.displayName,
+      domain: c.domain,
+      website: c.website,
+      timezone: c.timezone,
+      language: c.language,
+      industry: c.industry,
+      metadata: c.metadata,
+      address: c.address
+    }));
+    return this.httpClient.post("/customers/batch", { customers }, options);
   }
+  /**
+   * Get a customer by ID
+   */
+  async get(customerId) {
+    return this.httpClient.get(`/customers/${customerId}`);
+  }
+  /**
+   * Update a customer
+   */
   async update(customerId, params, options) {
-    return this.httpClient.put(`/customers/${customerId}`, params, options);
+    return this.httpClient.put(
+      `/customers/${customerId}`,
+      {
+        billingEmail: params.email,
+        externalId: params.externalId,
+        legalName: params.legalName,
+        displayName: params.displayName,
+        domain: params.domain,
+        website: params.website,
+        timezone: params.timezone,
+        language: params.language,
+        industry: params.industry,
+        metadata: params.metadata
+      },
+      options
+    );
   }
+  /**
+   * List customers with optional filters
+   */
   async list(params) {
     return this.httpClient.get("/customers", params);
   }
   /**
-   * Deactivate a customer (soft delete)
+   * Archive a customer
    */
-  async deactivate(customerId, options) {
+  async archive(customerId, options) {
     return this.httpClient.put(
       `/customers/${customerId}`,
       { isActive: false },
@@ -28,58 +89,134 @@ var CustomersResource = class {
   }
 };
 
+// src/resources/plans.ts
+var PlansResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * List all available plans
+   *
+   * @example
+   * ```typescript
+   * // List public plans
+   * const plans = await commet.plans.list();
+   *
+   * // Include private plans
+   * const allPlans = await commet.plans.list({ includePrivate: true });
+   * ```
+   */
+  async list(params) {
+    return this.httpClient.get("/plans", params);
+  }
+  /**
+   * Get a specific plan by ID
+   *
+   * @example
+   * ```typescript
+   * const plan = await commet.plans.get('plan_xxx');
+   * console.log(plan.data.name); // "Pro"
+   * console.log(plan.data.prices); // [{ billingInterval: 'monthly', price: 9900 }]
+   * ```
+   */
+  async get(planId) {
+    return this.httpClient.get(`/plans/${planId}`);
+  }
+};
+
+// src/resources/portal.ts
+var PortalResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Get a portal URL
+   *
+   * @example
+   * ```typescript
+   * const portal = await commet.portal.getUrl({ externalId: 'user_123' });
+   * ```
+   */
+  async getUrl(params, options) {
+    return this.httpClient.post("/portal/request-access", params, options);
+  }
+};
+
 // src/resources/seats.ts
 var SeatsResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
+  /**
+   * Add seats
+   *
+   * @example
+   * ```typescript
+   * await commet.seats.add({
+   *   externalId: 'user_123',
+   *   seatType: 'editor',
+   *   count: 5
+   * });
+   * ```
+   */
   async add(params, options) {
-    return this.httpClient.post(
-      "/seats",
-      {
-        customerId: params.customerId,
-        externalId: params.externalId,
-        seatType: params.seatType,
-        count: params.count
-      },
-      options
-    );
+    return this.httpClient.post("/seats", params, options);
   }
+  /**
+   * Remove seats
+   *
+   * @example
+   * ```typescript
+   * await commet.seats.remove({
+   *   externalId: 'user_123',
+   *   seatType: 'editor',
+   *   count: 2
+   * });
+   * ```
+   */
   async remove(params, options) {
-    return this.httpClient.delete(
-      "/seats",
-      {
-        customerId: params.customerId,
-        externalId: params.externalId,
-        seatType: params.seatType,
-        count: params.count
-      },
-      options
-    );
+    return this.httpClient.delete("/seats", params, options);
   }
+  /**
+   * Set seats to a specific count
+   *
+   * @example
+   * ```typescript
+   * await commet.seats.set({
+   *   externalId: 'user_123',
+   *   seatType: 'editor',
+   *   count: 10
+   * });
+   * ```
+   */
   async set(params, options) {
-    return this.httpClient.put(
-      "/seats",
-      {
-        customerId: params.customerId,
-        externalId: params.externalId,
-        seatType: params.seatType,
-        count: params.count
-      },
-      options
-    );
+    return this.httpClient.put("/seats", params, options);
   }
-  async bulkUpdate(params, options) {
-    return this.httpClient.put(
-      "/seats/bulk",
-      {
-        customerId: params.customerId,
-        externalId: params.externalId,
-        seats: params.seats
-      },
-      options
-    );
+  /**
+   * Set all seat types
+   *
+   * @example
+   * ```typescript
+   * await commet.seats.setAll({
+   *   externalId: 'user_123',
+   *   seats: { editor: 10, viewer: 50 }
+   * });
+   * ```
+   */
+  async setAll(params, options) {
+    return this.httpClient.put("/seats/bulk", params, options);
   }
+  /**
+   * Get balance for a seat type
+   *
+   * @example
+   * ```typescript
+   * const balance = await commet.seats.getBalance({
+   *   externalId: 'user_123',
+   *   seatType: 'editor'
+   * });
+   * ```
+   */
   async getBalance(params) {
     return this.httpClient.get("/seats/balance", {
       customerId: params.customerId,
@@ -87,15 +224,22 @@ var SeatsResource = class {
       seatType: params.seatType
     });
   }
+  /**
+   * Get all seat balances
+   *
+   * @example
+   * ```typescript
+   * const balances = await commet.seats.getAllBalances({
+   *   externalId: 'user_123'
+   * });
+   * ```
+   */
   async getAllBalances(params) {
     return this.httpClient.get("/seats/balances", {
       customerId: params.customerId,
       externalId: params.externalId
     });
   }
-  async listEvents(params) {
-    return this.httpClient.get("/seats/events", params);
-  }
 };
 
 // src/resources/subscriptions.ts
@@ -104,29 +248,15 @@ var SubscriptionsResource = class {
     this.httpClient = httpClient;
   }
   /**
-   * Create a subscription with multiple items (products)
+   * Create a subscription with a plan
    *
    * @example
    * ```typescript
-   * // Free plan - Multiple products
    * await commet.subscriptions.create({
-   *   externalId: "org_123",
-   *   items: [
-   *     { priceId: "price_tasks_free", quantity: 1 },
-   *     { priceId: "price_usage_free" },
-   *     { priceId: "price_seats_free", initialSeats: 1 }
-   *   ]
-   * });
-   *
-   * // Pro plan upgrade
-   * await commet.subscriptions.create({
-   *   customerId: "cus_xxx",
-   *   items: [
-   *     { priceId: "price_tasks_pro" },
-   *     { priceId: "price_usage_pro" },
-   *     { priceId: "price_seats_pro", initialSeats: 5 }
-   *   ],
-   *   status: "active"
+   *   externalId: 'user_123',
+   *   planCode: 'pro', // autocomplete works after `commet pull`
+   *   billingInterval: 'yearly',
+   *   initialSeats: { editor: 5 }
    * });
    * ```
    */
@@ -134,44 +264,47 @@ var SubscriptionsResource = class {
     return this.httpClient.post("/subscriptions", params, options);
   }
   /**
-   * Retrieve a subscription by ID
+   * Get the active subscription for a customer
+   *
+   * @example
+   * ```typescript
+   * const sub = await commet.subscriptions.get({ externalId: 'user_123' });
+   * ```
    */
-  async retrieve(subscriptionId, options) {
-    const params = options?.expand ? { expand: options.expand.join(",") } : void 0;
-    return this.httpClient.get(`/subscriptions/${subscriptionId}`, params);
+  async get(params) {
+    return this.httpClient.get("/subscriptions/active", params);
   }
   /**
-   * List subscriptions with optional filters
+   * Change the plan of a subscription (upgrade/downgrade)
    *
    * @example
    * ```typescript
-   * // List all active subscriptions for a customer
-   * await commet.subscriptions.list({
-   *   customerId: "cus_xxx",
-   *   status: "active"
-   * });
-   *
-   * // Using externalId
-   * await commet.subscriptions.list({
-   *   externalId: "my-customer-123"
+   * await commet.subscriptions.changePlan('sub_xxx', {
+   *   planCode: 'enterprise' // autocomplete works after `commet pull`
    * });
    * ```
    */
-  async list(params) {
-    return this.httpClient.get("/subscriptions", params);
+  async changePlan(subscriptionId, params, options) {
+    return this.httpClient.post(
+      `/subscriptions/${subscriptionId}/change-plan`,
+      params,
+      options
+    );
   }
   /**
    * Cancel a subscription
    *
    * @example
    * ```typescript
-   * await commet.subscriptions.cancel("sub_xxx");
+   * await commet.subscriptions.cancel('sub_xxx', {
+   *   reason: 'switched_to_competitor'
+   * });
    * ```
    */
-  async cancel(subscriptionId, options) {
+  async cancel(subscriptionId, params, options) {
     return this.httpClient.post(
       `/subscriptions/${subscriptionId}/cancel`,
-      {},
+      params || {},
       options
     );
   }
@@ -182,28 +315,59 @@ var UsageResource = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
-  async create(params, options) {
+  /**
+   * Track a usage event
+   *
+   * @example
+   * ```typescript
+   * await commet.usage.track({
+   *   externalId: 'user_123',
+   *   eventType: 'api_call',
+   *   idempotencyKey: `evt_${requestId}`,
+   *   properties: { endpoint: '/users', method: 'GET' }
+   * });
+   * ```
+   */
+  async track(params, options) {
     const eventData = {
-      ...params,
-      ts: params.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+      eventType: params.eventType,
+      customerId: params.customerId,
+      externalId: params.externalId,
+      idempotencyKey: params.idempotencyKey,
+      ts: params.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      properties: params.properties ? Object.entries(params.properties).map(([property, value]) => ({
+        property,
+        value
+      })) : void 0
     };
     return this.httpClient.post("/usage/events", eventData, options);
   }
-  async createBatch(params, options) {
-    return this.httpClient.post("/usage/events/batch", params, options);
-  }
-  async retrieve(eventId) {
-    return this.httpClient.get(`/usage/events/${eventId}`);
-  }
-  async list(params) {
-    return this.httpClient.get("/usage/events", params);
-  }
-  async delete(eventId, options) {
-    return this.httpClient.delete(
-      `/usage/events/${eventId}`,
-      void 0,
-      options
-    );
+  /**
+   * Track multiple usage events in a batch
+   *
+   * @example
+   * ```typescript
+   * await commet.usage.trackBatch({
+   *   events: [
+   *     { externalId: 'user_123', eventType: 'api_call', idempotencyKey: 'evt_1' },
+   *     { externalId: 'user_456', eventType: 'api_call', idempotencyKey: 'evt_2' }
+   *   ]
+   * });
+   * ```
+   */
+  async trackBatch(params, options) {
+    const events = params.events.map((event) => ({
+      eventType: event.eventType,
+      customerId: event.customerId,
+      externalId: event.externalId,
+      idempotencyKey: event.idempotencyKey,
+      ts: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      properties: event.properties ? Object.entries(event.properties).map(([property, value]) => ({
+        property,
+        value
+      })) : void 0
+    }));
+    return this.httpClient.post("/usage/events/batch", { events }, options);
   }
 };
 
@@ -406,7 +570,6 @@ var CommetHTTPClient = class {
       let responseData;
       let responseText;
       try {
-        const responseClone = response.clone();
         responseData = await response.json();
         responseText = "";
       } catch (jsonError) {
@@ -421,6 +584,12 @@ var CommetHTTPClient = class {
             responseText
           );
         }
+        if (response.status === 404) {
+          return {
+            success: false,
+            error: "Resource not found"
+          };
+        }
         throw new CommetAPIError(
           `Invalid JSON response: ${response.status} ${response.statusText}`,
           response.status,
@@ -546,9 +715,11 @@ var Commet = class {
     this.environment = config.environment || "sandbox";
     this.httpClient = new CommetHTTPClient(config, this.environment);
     this.customers = new CustomersResource(this.httpClient);
+    this.plans = new PlansResource(this.httpClient);
     this.usage = new UsageResource(this.httpClient);
     this.seats = new SeatsResource(this.httpClient);
     this.subscriptions = new SubscriptionsResource(this.httpClient);
+    this.portal = new PortalResource(this.httpClient);
     this.webhooks = new Webhooks();
     if (config.debug) {
       console.log(`[Commet SDK] Initialized in ${this.environment} mode`);