@forgecart/sdk 1.0.0 → 1.2.1

package/dist/admin-namespace.js

@@ -1,16 +1,19 @@
+"use strict";
 /**
  * @forgecart/sdk - Auto-generated TypeScript SDK
  *
  * This file was automatically generated and should not be manually edited.
  * To regenerate, run: npm run codegen:ts
  *
- * Generated at: 2025-12-12T11:13:16.730Z
+ * Generated at: 2025-12-15T07:01:16.361Z
  * Generator version: 1.0.0
  *
  * 🤖 Generated with ForgeCart SDK Generator
  */
-import { GraphQLClient } from 'graphql-request';
-import { createClient } from 'graphql-ws';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminNamespace = exports.AllEvents = exports.CatalogEvents = exports.PaymentEvents = exports.FulfillmentEvents = exports.CustomerEvents = exports.OrderEvents = exports.ProductEvents = void 0;
+const graphql_request_1 = require("graphql-request");
+const graphql_ws_1 = require("graphql-ws");
 const activeAdministratorDocument = `query activeAdministrator {
   activeAdministrator {
     id
@@ -3375,6 +3378,96 @@ const deleteCustomerNoteDocument = `mutation deleteCustomerNote($id: ID!) {
     message
   }
 }`;
+const deploymentsDocument = `query Deployments {
+  deployments {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+const deploymentDocument = `query Deployment($type: DeploymentType!) {
+  deployment(type: $type) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+const deploymentEnvDocument = `query DeploymentEnv($type: DeploymentType!) {
+  deploymentEnv(type: $type) {
+    key
+    value
+  }
+}`;
+const channelInfoDocument = `query ChannelInfo {
+  channelInfo {
+    id
+    code
+    name
+    domain
+    hasApplication
+    applicationName
+  }
+}`;
+const validateChannelTokenDocument = `query ValidateChannelToken {
+  validateChannelToken
+}`;
+const createDeploymentDocument = `mutation CreateDeployment($input: CreateDeploymentInput!) {
+  createDeployment(input: $input) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+const deleteDeploymentDocument = `mutation DeleteDeployment($type: DeploymentType!) {
+  deleteDeployment(type: $type)
+}`;
+const scaleDeploymentDocument = `mutation ScaleDeployment($input: ScaleDeploymentInput!) {
+  scaleDeployment(input: $input) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+const setDeploymentEnvDocument = `mutation SetDeploymentEnv($input: SetEnvInput!) {
+  setDeploymentEnv(input: $input)
+}`;
+const unsetDeploymentEnvDocument = `mutation UnsetDeploymentEnv($input: UnsetEnvInput!) {
+  unsetDeploymentEnv(input: $input)
+}`;
+const refreshDeploymentStatusDocument = `mutation RefreshDeploymentStatus($type: DeploymentType!) {
+  refreshDeploymentStatus(type: $type) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+const deploymentLogsDocument = `subscription DeploymentLogs($type: DeploymentType!) {
+  deploymentLogs(type: $type) {
+    timestamp
+    message
+    type
+  }
+}`;
 const entityDuplicatorsDocument = `query entityDuplicators {
   entityDuplicators {
     code
@@ -3404,6 +3497,18 @@ const duplicateEntityDocument = `mutation duplicateEntity($input: DuplicateEntit
     }
   }
 }`;
+const entityEventDocument = `subscription entityEvent($categories: [EventCategory!]) {
+  entityEvent(categories: $categories) {
+    channelId
+    eventName
+    eventClass
+    type
+    entityId
+    entity
+    input
+    timestamp
+  }
+}`;
 const facetDocument = `query facet($id: ID!) {
   facet(id: $id) {
     id
@@ -6782,9 +6887,29 @@ class BaseGraphQLClient {
         this.endpoint = config.endpoint || 'https://api.forgecart.com/admin-api';
         this.wsEndpoint = config.wsEndpoint || 'wss://api.forgecart.com/admin-api';
         this.config = config;
-        // Initialize HTTP client (as fallback)
-        this.httpClient = new GraphQLClient(this.endpoint, {
+        // Custom fetch that captures session token from response headers
+        const customFetch = async (url, options) => {
+            const response = await fetch(url, options);
+            // Capture session token from response header
+            const authToken = response.headers.get('forge-auth-token');
+            if (authToken && authToken !== this.authToken) {
+                this.authToken = authToken;
+                // Reconnect WebSocket with new token
+                if (this.wsClient) {
+                    this.wsConnected = false;
+                    this.wsClient.dispose();
+                    this.wsClient = null;
+                    this.wsInitializing = null;
+                    this.initializeWebSocket();
+                }
+            }
+            return response;
+        };
+        // Initialize HTTP client with custom fetch
+        this.httpClient = new graphql_request_1.GraphQLClient(this.endpoint, {
             headers: config.headers || {},
+            credentials: 'include',
+            fetch: customFetch,
         });
         // Initialize WebSocket connection immediately
         this.initializeWebSocket();
@@ -6878,6 +7003,10 @@ class BaseGraphQLClient {
      * Connects immediately and tracks connection state
      */
     initializeWebSocket() {
+        // Skip WebSocket if httpOnly mode is enabled
+        if (this.config.httpOnly) {
+            return;
+        }
         // Prevent multiple simultaneous initializations
         if (this.wsClient || this.wsInitializing) {
             return;
@@ -6897,7 +7026,20 @@ class BaseGraphQLClient {
                     keepAlive: 10000, // Send keep-alive pings every 10 seconds
                     connectionParams: async () => {
                         try {
-                            return this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {};
+                            const params = {};
+                            // Add session token if available
+                            if (this.authToken) {
+                                params.Authorization = `bearer ${this.authToken}`;
+                            }
+                            // Pass all configured headers (including forge-token for channel)
+                            if (this.config.headers) {
+                                Object.entries(this.config.headers).forEach(([key, value]) => {
+                                    if (value) {
+                                        params[key] = value;
+                                    }
+                                });
+                            }
+                            return params;
                         }
                         catch (error) {
                             console.error('Error in connectionParams:', error);
@@ -6936,7 +7078,7 @@ class BaseGraphQLClient {
                         },
                     },
                 };
-                this.wsClient = createClient(wsOptions);
+                this.wsClient = (0, graphql_ws_1.createClient)(wsOptions);
                 this.wsInitializing = null;
             }
             catch (error) {
@@ -7033,6 +7175,40 @@ class BaseGraphQLClient {
         }
     }
 }
+// Event categories for filtering
+exports.ProductEvents = [
+    'product.created', 'product.updated', 'product.deleted',
+    'product.variant.created', 'product.variant.updated', 'product.variant.deleted',
+    'product.option.created', 'product.option.updated', 'product.option.deleted',
+    'product.optionGroup.created', 'product.optionGroup.updated', 'product.optionGroup.deleted',
+    'product.variant.price.updated',
+];
+exports.OrderEvents = [
+    'order.stateTransition', 'order.placementStateTransition', 'order.line.event',
+    'order.paymentStateTransition', 'order.refundStateTransition',
+    'order.coupon.applied', 'order.coupon.removed',
+];
+exports.CustomerEvents = [
+    'customer.created', 'customer.updated', 'customer.deleted',
+    'customer.address.created', 'customer.address.updated', 'customer.address.deleted',
+    'customer.groupChange', 'customer.login', 'customer.loginfail',
+];
+exports.FulfillmentEvents = [
+    'fulfillment.created', 'fulfillment.stateTransition',
+];
+exports.PaymentEvents = [
+    'payment.stateTransition', 'payment.method.created', 'payment.method.updated', 'payment.method.deleted',
+];
+exports.CatalogEvents = [
+    'collection.created', 'collection.updated', 'collection.deleted', 'collection.modification',
+    'facet.created', 'facet.updated', 'facet.deleted',
+    'facetValue.created', 'facetValue.updated', 'facetValue.deleted',
+    'asset.created', 'asset.updated', 'asset.deleted',
+];
+exports.AllEvents = [
+    ...exports.ProductEvents, ...exports.OrderEvents, ...exports.CustomerEvents,
+    ...exports.FulfillmentEvents, ...exports.PaymentEvents, ...exports.CatalogEvents,
+];
 /**
  * Administrator operations
  */
@@ -7072,9 +7248,16 @@ class AdministratorOperations {
     }
     /**
      * login mutation
+     * Automatically sets the auth token on successful login
      */
     async login(variables) {
-        return await this.client.request(loginDocument, variables);
+        const response = await this.client.request(loginDocument, variables);
+        // Auto-set auth token if login was successful
+        const loginResult = response?.login;
+        if (loginResult && loginResult.__typename === 'CurrentUser' && loginResult.sessionToken) {
+            this.client.setAuthToken(loginResult.sessionToken);
+        }
+        return response;
     }
     /**
      * logout mutation
@@ -7977,6 +8160,89 @@ class CustomerOperations {
         return await this.client.request(deleteCustomerNoteDocument, variables);
     }
 }
+/**
+ * Deployment operations
+ */
+class DeploymentOperations {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Deployments query
+     */
+    async deployments() {
+        return await this.client.request(deploymentsDocument);
+    }
+    /**
+     * Deployment query
+     */
+    async deployment(variables) {
+        return await this.client.request(deploymentDocument, variables);
+    }
+    /**
+     * DeploymentEnv query
+     */
+    async deploymentEnv(variables) {
+        return await this.client.request(deploymentEnvDocument, variables);
+    }
+    /**
+     * ChannelInfo query
+     */
+    async channelInfo() {
+        return await this.client.request(channelInfoDocument);
+    }
+    /**
+     * ValidateChannelToken query
+     */
+    async validateChannelToken() {
+        return await this.client.request(validateChannelTokenDocument);
+    }
+    /**
+     * CreateDeployment mutation
+     */
+    async createDeployment(variables) {
+        return await this.client.request(createDeploymentDocument, variables);
+    }
+    /**
+     * DeleteDeployment mutation
+     */
+    async deleteDeployment(variables) {
+        return await this.client.request(deleteDeploymentDocument, variables);
+    }
+    /**
+     * ScaleDeployment mutation
+     */
+    async scaleDeployment(variables) {
+        return await this.client.request(scaleDeploymentDocument, variables);
+    }
+    /**
+     * SetDeploymentEnv mutation
+     */
+    async setDeploymentEnv(variables) {
+        return await this.client.request(setDeploymentEnvDocument, variables);
+    }
+    /**
+     * UnsetDeploymentEnv mutation
+     */
+    async unsetDeploymentEnv(variables) {
+        return await this.client.request(unsetDeploymentEnvDocument, variables);
+    }
+    /**
+     * RefreshDeploymentStatus mutation
+     */
+    async refreshDeploymentStatus(variables) {
+        return await this.client.request(refreshDeploymentStatusDocument, variables);
+    }
+    /**
+     * DeploymentLogs subscription
+     */
+    async *deploymentLogs(variables) {
+        const iterator = this.client.subscribe(deploymentLogsDocument, variables);
+        for await (const data of iterator) {
+            yield data;
+        }
+    }
+}
 /**
  * EntityDuplication operations
  */
@@ -7997,6 +8263,23 @@ class EntityDuplicationOperations {
         return await this.client.request(duplicateEntityDocument, variables);
     }
 }
+/**
+ * EntityEvents operations
+ */
+class EntityEventsOperations {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * entityEvent subscription
+     */
+    async *entityEvent(variables) {
+        const iterator = this.client.subscribe(entityEventDocument, variables);
+        for await (const data of iterator) {
+            yield data;
+        }
+    }
+}
 /**
  * Facet operations
  */
@@ -9122,8 +9405,17 @@ class ZoneOperations {
  * Admin namespace
  * Contains categorized operations for admin API
  */
-export class AdminNamespace {
+class AdminNamespace {
     constructor(config) {
+        // Event handler registry and state
+        this.eventRegistry = {
+            handlers: new Map(),
+            blockingHandlers: new Map(),
+        };
+        this.eventSubscription = null;
+        this.isListening = false;
+        this.retryCount = 0;
+        this.abortController = null;
         this.client = new BaseGraphQLClient(config);
         this.administrator = new AdministratorOperations(this.client);
         this.asset = new AssetOperations(this.client);
@@ -9135,7 +9427,9 @@ export class AdminNamespace {
         this.customFields = new CustomFieldsOperations(this.client);
         this.customerGroup = new CustomerGroupOperations(this.client);
         this.customer = new CustomerOperations(this.client);
+        this.deployment = new DeploymentOperations(this.client);
         this.entityDuplication = new EntityDuplicationOperations(this.client);
+        this.entityEvents = new EntityEventsOperations(this.client);
         this.facet = new FacetOperations(this.client);
         this.fulfillment = new FulfillmentOperations(this.client);
         this.globalSettings = new GlobalSettingsOperations(this.client);
@@ -9178,4 +9472,143 @@ export class AdminNamespace {
     dispose() {
         this.client.dispose();
     }
+    /**
+     * Register a non-blocking event handler
+     * The callback will be called for each matching event without waiting
+     */
+    registerEventHandler(eventName, callback) {
+        if (!this.eventRegistry.handlers.has(eventName)) {
+            this.eventRegistry.handlers.set(eventName, new Set());
+        }
+        this.eventRegistry.handlers.get(eventName).add(callback);
+        void this.ensureEventListening();
+        return {
+            unsubscribe: () => {
+                this.eventRegistry.handlers.get(eventName)?.delete(callback);
+            },
+        };
+    }
+    /**
+     * Register a blocking event handler
+     * The callback must complete within 1000ms or it will timeout
+     */
+    registerBlockingEventHandler(eventName, callback) {
+        if (!this.eventRegistry.blockingHandlers.has(eventName)) {
+            this.eventRegistry.blockingHandlers.set(eventName, new Set());
+        }
+        this.eventRegistry.blockingHandlers.get(eventName).add(callback);
+        void this.ensureEventListening();
+        return {
+            unsubscribe: () => {
+                this.eventRegistry.blockingHandlers.get(eventName)?.delete(callback);
+            },
+        };
+    }
+    /**
+     * Start listening to events with retry logic
+     */
+    async ensureEventListening() {
+        if (this.isListening)
+            return;
+        this.isListening = true;
+        this.retryCount = 0;
+        this.abortController = new AbortController();
+        await this.startSubscription();
+    }
+    async startSubscription() {
+        try {
+            this.eventSubscription = this.client.subscribe(entityEventDocument, {});
+            // Reset retry count on successful connection
+            this.retryCount = 0;
+            // Process events
+            for await (const result of this.eventSubscription) {
+                if (!this.isListening)
+                    break;
+                const event = result.entityEvent;
+                await this.dispatchEvent(event);
+            }
+        }
+        catch (error) {
+            if (this.isListening) {
+                console.error('Event subscription error:', error);
+                await this.handleReconnect();
+            }
+        }
+    }
+    async handleReconnect() {
+        const { maxRetries, baseDelayMs, maxDelayMs, backoffMultiplier } = AdminNamespace.RECONNECT_CONFIG;
+        if (this.retryCount >= maxRetries) {
+            this.isListening = false;
+            throw new Error(`Max reconnection attempts (${maxRetries}) exceeded`);
+        }
+        // Calculate delay with exponential backoff
+        const delay = Math.min(baseDelayMs * Math.pow(backoffMultiplier, this.retryCount), maxDelayMs);
+        this.retryCount++;
+        console.log(`Reconnecting in ${delay}ms (attempt ${this.retryCount}/${maxRetries})`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        await this.startSubscription();
+    }
+    /**
+     * Dispatch event to registered handlers
+     */
+    async dispatchEvent(event) {
+        const eventName = event.eventName;
+        // Non-blocking handlers (fire-and-forget)
+        const handlers = this.eventRegistry.handlers.get(eventName);
+        if (handlers) {
+            for (const handler of handlers) {
+                try {
+                    handler(event);
+                }
+                catch (error) {
+                    console.error(`Error in event handler for ${eventName}:`, error);
+                }
+            }
+        }
+        // Blocking handlers (with timeout)
+        const blockingHandlers = this.eventRegistry.blockingHandlers.get(eventName);
+        if (blockingHandlers) {
+            for (const handler of blockingHandlers) {
+                try {
+                    await this.executeWithTimeout(handler(event), AdminNamespace.BLOCKING_TIMEOUT_MS, `Blocking handler for ${eventName} exceeded ${AdminNamespace.BLOCKING_TIMEOUT_MS}ms`);
+                }
+                catch (error) {
+                    console.error(`Error in blocking event handler for ${eventName}:`, error);
+                    throw error; // Re-throw for blocking handlers
+                }
+            }
+        }
+    }
+    /**
+     * Execute promise with timeout
+     */
+    async executeWithTimeout(promise, timeoutMs, errorMessage) {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs)),
+        ]);
+    }
+    /**
+     * Stop all event listening
+     */
+    stopEventListening() {
+        this.isListening = false;
+        this.retryCount = 0;
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+        this.eventSubscription = null;
+        this.eventRegistry.handlers.clear();
+        this.eventRegistry.blockingHandlers.clear();
+    }
 }
+exports.AdminNamespace = AdminNamespace;
+// Reconnection configuration
+AdminNamespace.RECONNECT_CONFIG = {
+    maxRetries: 5,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+};
+AdminNamespace.BLOCKING_TIMEOUT_MS = 1000;