omni-sync-sdk 0.1.1 → 0.2.0

package/dist/index.js

@@ -63,9 +63,8 @@ var OmniSyncClient = class {
         headers: {
           Authorization: `Bearer ${this.apiKey}`,
           "Content-Type": "application/json",
-          "X-SDK-Version": "0.1.0",
+          "X-SDK-Version": "0.1.1",
           "ngrok-skip-browser-warning": "true"
-          // Skip ngrok warning page for dev tunnels
         },
         body: body ? JSON.stringify(body) : void 0,
         signal: controller.signal
@@ -135,6 +134,147 @@ var OmniSyncClient = class {
   async deleteProduct(productId) {
     await this.request("DELETE", `/api/v1/products/${productId}`);
   }
+  /**
+   * Convert a SIMPLE product to VARIABLE product
+   *
+   * @example
+   * ```typescript
+   * const product = await omni.convertToVariable('prod_123');
+   * console.log('Product type:', product.type); // 'VARIABLE'
+   * ```
+   */
+  async convertToVariable(productId) {
+    return this.request("PATCH", `/api/v1/products/${productId}/convert-to-variable`);
+  }
+  /**
+   * Convert a VARIABLE product to SIMPLE product
+   * Note: This will delete all variants
+   *
+   * @example
+   * ```typescript
+   * const product = await omni.convertToSimple('prod_123');
+   * console.log('Product type:', product.type); // 'SIMPLE'
+   * ```
+   */
+  async convertToSimple(productId) {
+    return this.request("PATCH", `/api/v1/products/${productId}/convert-to-simple`);
+  }
+  /**
+   * Publish a product to specific platforms
+   *
+   * @example
+   * ```typescript
+   * const result = await omni.publishProduct('prod_123', ['SHOPIFY', 'WOOCOMMERCE']);
+   * console.log('Publish results:', result.results);
+   * ```
+   */
+  async publishProduct(productId, platforms) {
+    return this.request("POST", `/api/v1/products/${productId}/publish`, {
+      platforms
+    });
+  }
+  // -------------------- Variants --------------------
+  /**
+   * Create a new variant for a product
+   *
+   * @example
+   * ```typescript
+   * const variant = await omni.createVariant('prod_123', {
+   *   sku: 'PROD-SM-RED',
+   *   name: 'Small / Red',
+   *   attributes: { size: 'S', color: 'Red' },
+   *   price: 29.99,
+   *   inventory: 100,
+   * });
+   * ```
+   */
+  async createVariant(productId, data) {
+    return this.request("POST", `/api/v1/products/${productId}/variants`, data);
+  }
+  /**
+   * Bulk save variants (create, update, delete in one operation)
+   *
+   * @example
+   * ```typescript
+   * const result = await omni.bulkSaveVariants('prod_123', {
+   *   variants: [
+   *     { sku: 'SM-RED', attributes: { size: 'S', color: 'Red' }, stock: 10, isEnabled: true },
+   *     { id: 'var_456', sku: 'MD-BLUE', attributes: { size: 'M', color: 'Blue' }, stock: 5, isEnabled: true },
+   *     { id: 'var_789', sku: 'LG-GREEN', attributes: {}, stock: 0, isEnabled: false, isDeleted: true },
+   *   ],
+   * });
+   * console.log(`Created: ${result.created}, Updated: ${result.updated}, Deleted: ${result.deleted}`);
+   * ```
+   */
+  async bulkSaveVariants(productId, data) {
+    return this.request(
+      "POST",
+      `/api/v1/products/${productId}/variants/bulk`,
+      data
+    );
+  }
+  /**
+   * Update a variant
+   *
+   * @example
+   * ```typescript
+   * const variant = await omni.updateVariant('prod_123', 'var_456', {
+   *   price: 34.99,
+   *   salePrice: 29.99,
+   * });
+   * ```
+   */
+  async updateVariant(productId, variantId, data) {
+    return this.request(
+      "PATCH",
+      `/api/v1/products/${productId}/variants/${variantId}`,
+      data
+    );
+  }
+  /**
+   * Delete a variant
+   *
+   * @example
+   * ```typescript
+   * await omni.deleteVariant('prod_123', 'var_456');
+   * ```
+   */
+  async deleteVariant(productId, variantId) {
+    await this.request("DELETE", `/api/v1/products/${productId}/variants/${variantId}`);
+  }
+  /**
+   * Get inventory for a specific variant
+   *
+   * @example
+   * ```typescript
+   * const inventory = await omni.getVariantInventory('prod_123', 'var_456');
+   * console.log('Available:', inventory.available);
+   * ```
+   */
+  async getVariantInventory(productId, variantId) {
+    return this.request(
+      "GET",
+      `/api/v1/products/${productId}/variants/${variantId}/inventory`
+    );
+  }
+  /**
+   * Update inventory for a specific variant
+   *
+   * @example
+   * ```typescript
+   * const inventory = await omni.updateVariantInventory('prod_123', 'var_456', {
+   *   newTotal: 50,
+   *   reason: 'Restocked from supplier',
+   * });
+   * ```
+   */
+  async updateVariantInventory(productId, variantId, data) {
+    return this.request(
+      "PATCH",
+      `/api/v1/products/${productId}/variants/${variantId}/inventory`,
+      data
+    );
+  }
   // -------------------- Orders --------------------
   /**
    * Get a list of orders with pagination
@@ -167,6 +307,209 @@ var OmniSyncClient = class {
   async updateOrder(orderId, data) {
     return this.request("PATCH", `/api/v1/orders/${orderId}`, data);
   }
+  /**
+   * Update order status
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.updateOrderStatus('order_123', 'shipped');
+   * ```
+   */
+  async updateOrderStatus(orderId, status) {
+    return this.request("PATCH", `/api/v1/orders/${orderId}/status`, { status });
+  }
+  /**
+   * Update order payment method
+   * Note: Only WooCommerce supports syncing payment method changes back to platform
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.updatePaymentMethod('order_123', 'credit_card');
+   * ```
+   */
+  async updatePaymentMethod(orderId, paymentMethod) {
+    return this.request("PATCH", `/api/v1/orders/${orderId}/payment-method`, {
+      paymentMethod
+    });
+  }
+  /**
+   * Update order notes
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.updateOrderNotes('order_123', 'Customer requested gift wrapping');
+   * ```
+   */
+  async updateOrderNotes(orderId, notes) {
+    return this.request("PATCH", `/api/v1/orders/${orderId}/notes`, { notes });
+  }
+  /**
+   * Get refunds for an order
+   * Returns refunds from the source platform (Shopify/WooCommerce only)
+   *
+   * @example
+   * ```typescript
+   * const refunds = await omni.getOrderRefunds('order_123');
+   * console.log('Total refunds:', refunds.length);
+   * ```
+   */
+  async getOrderRefunds(orderId) {
+    return this.request("GET", `/api/v1/orders/${orderId}/refunds`);
+  }
+  /**
+   * Create a refund for an order
+   * Creates refund on the source platform (Shopify/WooCommerce only)
+   *
+   * @example
+   * ```typescript
+   * // Full refund
+   * const refund = await omni.createRefund('order_123', {
+   *   type: 'full',
+   *   restockInventory: true,
+   *   notifyCustomer: true,
+   *   reason: 'Customer request',
+   * });
+   *
+   * // Partial refund
+   * const partialRefund = await omni.createRefund('order_123', {
+   *   type: 'partial',
+   *   items: [
+   *     { lineItemId: 'item_456', quantity: 1 },
+   *   ],
+   *   restockInventory: true,
+   * });
+   * ```
+   */
+  async createRefund(orderId, data) {
+    return this.request("POST", `/api/v1/orders/${orderId}/refunds`, data);
+  }
+  /**
+   * Update order shipping address
+   * Syncs to source platform (Shopify/WooCommerce only)
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.updateOrderShipping('order_123', {
+   *   firstName: 'John',
+   *   lastName: 'Doe',
+   *   line1: '456 New Address',
+   *   city: 'Los Angeles',
+   *   state: 'CA',
+   *   country: 'US',
+   *   postalCode: '90001',
+   * });
+   * ```
+   */
+  async updateOrderShipping(orderId, data) {
+    return this.request("PATCH", `/api/v1/orders/${orderId}/shipping`, data);
+  }
+  /**
+   * Cancel an order
+   * Works for Shopify and WooCommerce orders that haven't been fulfilled
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.cancelOrder('order_123');
+   * console.log('Order status:', order.status); // 'cancelled'
+   * ```
+   */
+  async cancelOrder(orderId) {
+    return this.request("POST", `/api/v1/orders/${orderId}/cancel`);
+  }
+  /**
+   * Fulfill an order (mark as shipped)
+   * Works for Shopify and WooCommerce orders
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.fulfillOrder('order_123', {
+   *   trackingNumber: '1Z999AA10123456784',
+   *   trackingCompany: 'UPS',
+   *   notifyCustomer: true,
+   * });
+   * ```
+   */
+  async fulfillOrder(orderId, data) {
+    return this.request("POST", `/api/v1/orders/${orderId}/fulfill`, data || {});
+  }
+  /**
+   * Sync draft orders from connected platforms
+   *
+   * @example
+   * ```typescript
+   * const result = await omni.syncDraftOrders();
+   * console.log('Draft orders synced');
+   * ```
+   */
+  async syncDraftOrders() {
+    return this.request("POST", "/api/v1/orders/sync-drafts");
+  }
+  /**
+   * Complete a draft order (convert to regular order)
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.completeDraftOrder('draft_123', {
+   *   paymentPending: false,
+   * });
+   * ```
+   */
+  async completeDraftOrder(orderId, data) {
+    return this.request("POST", `/api/v1/orders/${orderId}/complete-draft`, data || {});
+  }
+  /**
+   * Send invoice for a draft order
+   *
+   * @example
+   * ```typescript
+   * await omni.sendDraftInvoice('draft_123', {
+   *   to: 'customer@example.com',
+   *   subject: 'Your Invoice',
+   *   customMessage: 'Thank you for your order!',
+   * });
+   * ```
+   */
+  async sendDraftInvoice(orderId, data) {
+    return this.request(
+      "POST",
+      `/api/v1/orders/${orderId}/send-invoice`,
+      data || {}
+    );
+  }
+  /**
+   * Delete a draft order
+   *
+   * @example
+   * ```typescript
+   * await omni.deleteDraftOrder('draft_123');
+   * ```
+   */
+  async deleteDraftOrder(orderId) {
+    await this.request("DELETE", `/api/v1/orders/${orderId}/draft`);
+  }
+  /**
+   * Update a draft order
+   *
+   * @example
+   * ```typescript
+   * const order = await omni.updateDraftOrder('draft_123', {
+   *   note: 'Updated customer note',
+   *   email: 'newemail@example.com',
+   *   shippingAddress: {
+   *     firstName: 'John',
+   *     lastName: 'Doe',
+   *     address1: '123 Main St',
+   *     city: 'New York',
+   *     province: 'NY',
+   *     country: 'US',
+   *     zip: '10001',
+   *   },
+   * });
+   * ```
+   */
+  async updateDraftOrder(orderId, data) {
+    return this.request("PATCH", `/api/v1/orders/${orderId}/draft`, data);
+  }
   // -------------------- Inventory --------------------
   /**
    * Update inventory for a product
@@ -179,7 +522,74 @@ var OmniSyncClient = class {
    * Get current inventory for a product
    */
   async getInventory(productId) {
-    return this.request("GET", `/api/v1/products/${productId}/inventory`);
+    return this.request("GET", `/api/v1/inventory/${productId}`);
+  }
+  /**
+   * Edit inventory manually with reason for audit trail
+   *
+   * @example
+   * ```typescript
+   * const inventory = await omni.editInventory({
+   *   productId: 'prod_123',
+   *   newTotal: 100,
+   *   reason: 'Restocked from warehouse',
+   * });
+   * ```
+   */
+  async editInventory(data) {
+    return this.request("POST", "/api/v1/inventory/edit", data);
+  }
+  /**
+   * Get inventory sync status for all products in the store
+   *
+   * @example
+   * ```typescript
+   * const status = await omni.getInventorySyncStatus();
+   * console.log(`${status.pending} products pending sync`);
+   * console.log(`Last sync: ${status.lastSyncAt}`);
+   * ```
+   */
+  async getInventorySyncStatus() {
+    return this.request("GET", "/api/v1/inventory/sync-status");
+  }
+  /**
+   * Get inventory for multiple products at once
+   *
+   * @example
+   * ```typescript
+   * const inventories = await omni.getBulkInventory(['prod_123', 'prod_456', 'prod_789']);
+   * inventories.forEach(inv => {
+   *   console.log(`${inv.productId}: ${inv.available} available`);
+   * });
+   * ```
+   */
+  async getBulkInventory(productIds) {
+    return this.request("POST", "/api/v1/inventory/bulk", { productIds });
+  }
+  /**
+   * Reconcile inventory between OmniSync and connected platforms
+   * Detects and optionally fixes discrepancies
+   *
+   * @example
+   * ```typescript
+   * // Reconcile single product (dry run)
+   * const result = await omni.reconcileInventory({ productId: 'prod_123' });
+   *
+   * // Reconcile all products with auto-fix
+   * const summary = await omni.reconcileInventory({ autoFix: true });
+   * console.log(`Reconciled ${summary.reconciled} products`);
+   * ```
+   */
+  async reconcileInventory(options) {
+    const queryParams = {};
+    if (options?.productId) queryParams.productId = options.productId;
+    if (options?.autoFix) queryParams.autoFix = "true";
+    return this.request(
+      "POST",
+      "/api/v1/inventory/reconcile",
+      void 0,
+      queryParams
+    );
   }
   // -------------------- Sync --------------------
   /**