@forgecart/sdk 1.2.5 → 1.2.6

package/src/client.generated.ts

@@ -0,0 +1,845 @@
+/* eslint-disable */
+/**
+ * AUTO-GENERATED FILE — DO NOT EDIT
+ *
+ * This file was generated by @forgecart/client-sdk-generators.
+ * Any manual changes will be overwritten on the next generation run.
+ */
+
+
+import { Observable, firstValueFrom } from 'rxjs';
+import { createClient as createWsClient, type Client as WsClient } from 'graphql-ws';
+import { uploadViaFetch } from './upload';
+import { HookSubscriptionManager, hookDispatchDocument, hookRespondDocument } from './sdk-hook-subscription.generated';
+import type { HookDispatchEvent, HookSubscription } from './sdk-hook-subscription.generated';
+import type { AdminHookPoint, AdminHookHandler } from './hook-event-map.generated';
+import { AdminNamespace } from './admin.generated';
+import type * as Admin from './admin.generated';
+import { ShopNamespace } from './shop.generated';
+import type * as Shop from './shop.generated';
+
+export interface ForgeCartAdminClientConfig {
+  endpoint: string;
+  channelToken: string;
+  adminSecret?: string;
+  uploadEndpoint?: string;
+  headers?: Record<string, string>;
+}
+
+export interface ForgeCartShopClientConfig {
+  endpoint: string;
+  channelToken: string;
+  uploadEndpoint?: string;
+  headers?: Record<string, string>;
+}
+
+export interface ForgeCartClientConfig {
+  endpoint: string;
+  channelToken: string;
+  adminSecret?: string;
+  uploadEndpoint?: string;
+  headers?: Record<string, string>;
+}
+
+export class SDKLogger {
+  private readonly prefix = "[ForgeCartSDK]";
+
+  info(message: string, data?: Record<string, unknown>): void {
+    console.log(this.prefix, message, data ?? "");
+  }
+
+  warn(message: string, data?: Record<string, unknown>): void {
+    console.warn(this.prefix, message, data ?? "");
+  }
+
+  error(message: string, data?: Record<string, unknown>): void {
+    console.error(this.prefix, message, data ?? "");
+  }
+}
+
+export interface GraphQLErrorResponse {
+  errors: Array<{ message: string; extensions?: Record<string, unknown> }>;
+}
+
+export class ClientError extends Error {
+  readonly response: GraphQLErrorResponse;
+
+  constructor(response: GraphQLErrorResponse, message: string) {
+    super(message);
+    this.response = response;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export type ErrorHandler = (error: ClientError) => void;
+
+/**
+ * An Observable that is also PromiseLike, so `await` resolves the first emitted value.
+ * Use `.subscribe()` for streaming, `await` for single-shot request-response.
+ */
+export class QueryObservable<T> extends Observable<T> implements PromiseLike<T> {
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+  ): PromiseLike<TResult1 | TResult2> {
+    return firstValueFrom(this).then(onfulfilled, onrejected);
+  }
+}
+
+export interface LoginSessionChannel {
+  id: string;
+  token: string;
+  code: string;
+  permissions: string[];
+}
+
+export interface LoginSession {
+  id: string;
+  token: string;
+  channels: LoginSessionChannel[];
+}
+
+export interface AdminLoginAdministrator {
+  id: string;
+  firstName: string;
+  lastName: string;
+  emailAddress: string;
+  avatarUrl: string | null;
+}
+
+export interface AdminExternalAuthResult {
+  session: LoginSession;
+  administrator: AdminLoginAdministrator;
+  requiresOnboarding: boolean;
+}
+export class BaseGraphQLClient {
+  private readonly logger = new SDKLogger();
+  private readonly endpoint: string;
+  private wsClient: WsClient | null = null;
+  private ownsWsClient = true;
+  private wsClientStale = false;
+  private authToken: string | null = null;
+  private transactionToken: string | null = null;
+  private errorHandler: ErrorHandler | null = null;
+
+  constructor(
+    endpoint: string,
+    private readonly baseHeaders: Record<string, string>,
+    private readonly uploadEndpoint?: string,
+  ) {
+    this.endpoint = endpoint.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+  }
+
+  private getWsClient(): WsClient {
+    if (this.wsClient && this.wsClientStale) {
+      this.disposeWsClient();
+      this.wsClientStale = false;
+    }
+    if (!this.wsClient) {
+      this.wsClient = createWsClient({
+        url: this.endpoint,
+        webSocketImpl: typeof WebSocket !== 'undefined'
+          ? WebSocket
+          : require('ws'),
+        connectionParams: () => ({
+          headers: this.getHeaders(),
+        }),
+        lazyCloseTimeout: 15_000,
+      });
+    }
+    return this.wsClient;
+  }
+
+  private getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = { ...this.baseHeaders };
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    if (this.transactionToken) {
+      headers["forgecart-transaction-token"] = this.transactionToken;
+    }
+    return headers;
+  }
+
+  setAuthToken(token: string): void {
+    if (this.authToken === token) return;
+    this.authToken = token;
+    this.disposeWsClient();
+    this.logger.info("Auth token set");
+  }
+
+  clearAuthToken(): void {
+    this.authToken = null;
+    this.disposeWsClient();
+    this.logger.info("Auth token cleared");
+  }
+
+  setTransactionToken(token: string): void {
+    this.transactionToken = token;
+    this.logger.info("Transaction token set");
+  }
+
+  clearTransactionToken(): void {
+    this.transactionToken = null;
+    this.logger.info("Transaction token cleared");
+  }
+
+  setErrorHandler(handler: ErrorHandler): void {
+    this.errorHandler = handler;
+  }
+
+  private notifyErrorHandler(error: ClientError): void {
+    if (this.errorHandler) {
+      this.errorHandler(error);
+    }
+  }
+
+  query<T>(document: string, variables?: Record<string, unknown>): QueryObservable<T> {
+    return new QueryObservable<T>((subscriber) => {
+      const client = this.getWsClient();
+      let disposed = false;
+
+      const cleanup = client.subscribe<Record<string, unknown>>(
+        {
+          query: document,
+          variables,
+          extensions: this.getPerOperationExtensions(),
+        },
+        {
+          next: (result) => {
+            if (disposed) return;
+            if (result.errors && result.errors.length > 0) {
+              const response: GraphQLErrorResponse = {
+                errors: result.errors.map((e) => ({
+                  message: e.message,
+                  extensions: e.extensions as Record<string, unknown> | undefined,
+                })),
+              };
+              const error = new ClientError(response, result.errors[0].message);
+              this.notifyErrorHandler(error);
+              subscriber.error(error);
+              return;
+            }
+            if (result.data) {
+              this.captureSessionToken(result as { extensions?: Record<string, unknown> });
+              subscriber.next(result.data as T);
+            }
+          },
+          error: (err) => {
+            if (disposed) return;
+            subscriber.error(err);
+          },
+          complete: () => {
+            if (disposed) return;
+            subscriber.complete();
+          },
+        },
+      );
+
+      return () => {
+        disposed = true;
+        cleanup();
+      };
+    });
+  }
+
+  mutate<T>(document: string, variables?: Record<string, unknown>): QueryObservable<T> {
+    if (variables && this.containsFiles(variables)) {
+      return this.upload<T>(document, variables);
+    }
+    return this.query<T>(document, variables);
+  }
+
+  subscribe<T>(document: string, variables?: Record<string, unknown>): Observable<T> {
+    return this.query<T>(document, variables);
+  }
+
+  upload<T>(document: string, variables: Record<string, unknown>): QueryObservable<T> {
+    return new QueryObservable<T>((subscriber) => {
+      const endpoint = this.resolveUploadEndpoint();
+      uploadViaFetch<T>(endpoint, document, variables, this.getHeaders())
+        .then((result) => {
+          this.captureSessionTokenFromUpload(result);
+          subscriber.next(result.data);
+          subscriber.complete();
+        })
+        .catch((err) => subscriber.error(err));
+    });
+  }
+
+  private getPerOperationExtensions(): Record<string, unknown> | undefined {
+    if (!this.transactionToken) return undefined;
+    return { "forgecart-transaction-token": this.transactionToken };
+  }
+
+  private captureSessionToken(result: { extensions?: Record<string, unknown> }): void {
+    if (!result.extensions) return;
+    const token = result.extensions["forgecart-auth-token"] as string | undefined;
+    if (token && !this.authToken) {
+      this.authToken = token;
+      this.wsClientStale = true;
+      this.logger.info("Session token captured from extensions");
+    }
+  }
+
+  private captureSessionTokenFromUpload(result: { extensions?: Record<string, unknown> }): void {
+    if (!result.extensions) return;
+    const token = result.extensions["forgecart-auth-token"] as string | undefined;
+    if (token && !this.authToken) {
+      this.authToken = token;
+      this.wsClientStale = true;
+      this.logger.info("Session token captured from upload response");
+    }
+  }
+
+  private containsFiles(obj: unknown): boolean {
+    if (obj === null || obj === undefined) return false;
+    if (typeof obj !== "object") return false;
+    if (typeof File !== "undefined" && obj instanceof File) return true;
+    if (typeof Blob !== "undefined" && obj instanceof Blob) return true;
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(obj)) return true;
+    if (Array.isArray(obj)) return obj.some((item) => this.containsFiles(item));
+    return Object.values(obj as Record<string, unknown>).some((val) => this.containsFiles(val));
+  }
+
+  private resolveUploadEndpoint(): string {
+    if (this.uploadEndpoint) return this.uploadEndpoint;
+    return this.endpoint.replace(/^ws:/, "http:").replace(/^wss:/, "https:");
+  }
+
+  private disposeWsClient(): void {
+    if (this.wsClient && this.ownsWsClient) {
+      this.wsClient.dispose();
+      this.wsClient = null;
+    }
+  }
+
+  dispose(): void {
+    this.disposeWsClient();
+  }
+
+  fork(transactionToken: string): BaseGraphQLClient {
+    const forked = new BaseGraphQLClient(this.endpoint, this.baseHeaders, this.uploadEndpoint);
+    forked.authToken = this.authToken;
+    forked.transactionToken = transactionToken;
+    forked.wsClient = this.wsClient;
+    forked.ownsWsClient = false;
+    return forked;
+  }
+}
+
+export function setAuthToken(client: BaseGraphQLClient, token: string): void {
+  client.setAuthToken(token);
+}
+
+export function clearAuthToken(client: BaseGraphQLClient): void {
+  client.clearAuthToken();
+}
+
+export function setTransactionToken(client: BaseGraphQLClient, token: string): void {
+  client.setTransactionToken(token);
+}
+
+export function clearTransactionToken(client: BaseGraphQLClient): void {
+  client.clearTransactionToken();
+}
+
+export class TransactionContext {
+  private readonly _admin: AdminNamespace;
+  private readonly _shop: ShopNamespace | undefined;
+
+  constructor(admin: AdminNamespace, shop?: ShopNamespace) {
+    this._admin = admin;
+    this._shop = shop;
+  }
+
+  get admin(): AdminNamespace {
+    return this._admin;
+  }
+
+  get shop(): ShopNamespace {
+    if (!this._shop) {
+      throw new Error('SHOP_NAMESPACE_NOT_AVAILABLE');
+    }
+    return this._shop;
+  }
+}
+
+export class ForgeCartAdminClient {
+  private readonly client: BaseGraphQLClient;
+  private readonly _namespace: AdminNamespace;
+
+  constructor(config: ForgeCartAdminClientConfig) {
+    const headers: Record<string, string> = { 'forgecart-token': config.channelToken, ...config.headers };
+    if (config.adminSecret) {
+      headers['forgecart-secret'] = config.adminSecret;
+    }
+    this.client = new BaseGraphQLClient(config.endpoint, headers, config.uploadEndpoint);
+    this._namespace = new AdminNamespace(this.client);
+  }
+
+  setAuthToken(token: string): void {
+    this.client.setAuthToken(token);
+  }
+
+  clearAuthToken(): void {
+    this.client.clearAuthToken();
+  }
+
+  setTransactionToken(token: string): void {
+    this.client.setTransactionToken(token);
+  }
+
+  clearTransactionToken(): void {
+    this.client.clearTransactionToken();
+  }
+
+  setErrorHandler(handler: ErrorHandler): void {
+    this.client.setErrorHandler(handler);
+  }
+
+  dispose(): void {
+    this.client.dispose();
+  }
+
+  query<T>(document: string, variables?: Record<string, unknown>): QueryObservable<T> {
+    return this.client.query<T>(document, variables);
+  }
+
+  mutate<T>(document: string, variables?: Record<string, unknown>): QueryObservable<T> {
+    return this.client.mutate<T>(document, variables);
+  }
+
+  private shopPeer: ForgeCartShopClient | null = null;
+
+  setShopPeer(shop: ForgeCartShopClient): void {
+    this.shopPeer = shop;
+  }
+
+  createScopedNamespace(transactionToken: string): AdminNamespace {
+    return new AdminNamespace(this.client.fork(transactionToken));
+  }
+
+  async withTransaction<T>(fn: (ctx: TransactionContext) => Promise<T>): Promise<T> {
+    const result = await firstValueFrom(this.transaction.beginTransaction()) as { beginTransaction: { token: string } };
+    const token = result.beginTransaction.token;
+    const adminNs = this.createScopedNamespace(token);
+    const shopNs = this.shopPeer?.createScopedNamespace(token);
+    const ctx = new TransactionContext(adminNs, shopNs);
+    try {
+      const value = await fn(ctx);
+      await firstValueFrom(this.transaction.commitTransaction({ token }));
+      return value;
+    } catch (error) {
+      await firstValueFrom(this.transaction.rollbackTransaction({ token })).catch(() => {});
+      throw error;
+    }
+  }
+
+  private hookManager: HookSubscriptionManager<TransactionContext> | null = null;
+
+  on<K extends AdminHookPoint>(
+    hookPoints: K[],
+    handler: AdminHookHandler<K>,
+  ): HookSubscription {
+    if (!this.hookManager) {
+      this.hookManager = new HookSubscriptionManager<TransactionContext>(
+        (hp) => this.client.subscribe<{ hookDispatched: HookDispatchEvent }>(hookDispatchDocument, { hookPoints: hp }),
+        (id, subscriberId, error) => this.client.mutate(hookRespondDocument, { input: { id, subscriberId, error } }),
+        (token) => {
+          const adminNs = this.createScopedNamespace(token);
+          const shopNs = this.shopPeer?.createScopedNamespace(token);
+          return new TransactionContext(adminNs, shopNs);
+        },
+      );
+    }
+    return this.hookManager.on(
+      hookPoints as string[],
+      handler as unknown as (ctx: TransactionContext, payload?: unknown) => Promise<void>,
+    );
+  }
+
+  async login(emailAddress: string, password: string): Promise<LoginSession> {
+    const result = await firstValueFrom(this.auth.login({ input: { emailAddress, password } })) as {
+      login: LoginSession;
+    };
+    this.client.setAuthToken(result.login.token);
+    if (this.shopPeer) {
+      this.shopPeer.setAuthToken(result.login.token);
+    }
+    return result.login;
+  }
+
+  async loginWithExternalStrategy(strategyCode: string, data: Record<string, unknown>): Promise<AdminExternalAuthResult> {
+    const result = await firstValueFrom(this.auth.authenticateWithExternalStrategy({ input: { strategyCode, data } })) as {
+      authenticateWithExternalStrategy: AdminExternalAuthResult;
+    };
+    this.client.setAuthToken(result.authenticateWithExternalStrategy.session.token);
+    if (this.shopPeer) {
+      this.shopPeer.setAuthToken(result.authenticateWithExternalStrategy.session.token);
+    }
+    return result.authenticateWithExternalStrategy;
+  }
+
+  async logout(): Promise<void> {
+    await firstValueFrom(this.auth.logout());
+    this.client.clearAuthToken();
+    if (this.shopPeer) {
+      this.shopPeer.clearAuthToken();
+    }
+  }
+  get entry(): Admin.EntryCategory {
+    return this._namespace.entry;
+  }
+  get fieldDefinition(): Admin.FieldDefinitionCategory {
+    return this._namespace.fieldDefinition;
+  }
+  get publish(): Admin.PublishCategory {
+    return this._namespace.publish;
+  }
+  get acfSchema(): Admin.AcfSchemaCategory {
+    return this._namespace.acfSchema;
+  }
+  get acf(): Admin.AcfCategory {
+    return this._namespace.acf;
+  }
+  get administrator(): Admin.AdministratorCategory {
+    return this._namespace.administrator;
+  }
+  get analyticsGateway(): Admin.AnalyticsGatewayCategory {
+    return this._namespace.analyticsGateway;
+  }
+  get asset(): Admin.AssetCategory {
+    return this._namespace.asset;
+  }
+  get audienceMembership(): Admin.AudienceMembershipCategory {
+    return this._namespace.audienceMembership;
+  }
+  get audienceSegment(): Admin.AudienceSegmentCategory {
+    return this._namespace.audienceSegment;
+  }
+  get auth(): Admin.AuthCategory {
+    return this._namespace.auth;
+  }
+  get settings(): Admin.SettingsCategory {
+    return this._namespace.settings;
+  }
+  get channel(): Admin.ChannelCategory {
+    return this._namespace.channel;
+  }
+  get collection(): Admin.CollectionCategory {
+    return this._namespace.collection;
+  }
+  get country(): Admin.CountryCategory {
+    return this._namespace.country;
+  }
+  get address(): Admin.AddressCategory {
+    return this._namespace.address;
+  }
+  get group(): Admin.GroupCategory {
+    return this._namespace.group;
+  }
+  get customerGroup(): Admin.CustomerGroupCategory {
+    return this._namespace.customerGroup;
+  }
+  get customer(): Admin.CustomerCategory {
+    return this._namespace.customer;
+  }
+  get deployment(): Admin.DeploymentCategory {
+    return this._namespace.deployment;
+  }
+  get facet(): Admin.FacetCategory {
+    return this._namespace.facet;
+  }
+  get fulfillmentRequest(): Admin.FulfillmentRequestCategory {
+    return this._namespace.fulfillmentRequest;
+  }
+  get fulfillment(): Admin.FulfillmentCategory {
+    return this._namespace.fulfillment;
+  }
+  get hookDispatch(): Admin.HookDispatchCategory {
+    return this._namespace.hookDispatch;
+  }
+  get hook(): Admin.HookCategory {
+    return this._namespace.hook;
+  }
+  get marketingAttribution(): Admin.MarketingAttributionCategory {
+    return this._namespace.marketingAttribution;
+  }
+  get marketingEvent(): Admin.MarketingEventCategory {
+    return this._namespace.marketingEvent;
+  }
+  get marketingIdentity(): Admin.MarketingIdentityCategory {
+    return this._namespace.marketingIdentity;
+  }
+  get onboarding(): Admin.OnboardingCategory {
+    return this._namespace.onboarding;
+  }
+  get coupon(): Admin.CouponCategory {
+    return this._namespace.coupon;
+  }
+  get draft(): Admin.DraftCategory {
+    return this._namespace.draft;
+  }
+  get modification(): Admin.ModificationCategory {
+    return this._namespace.modification;
+  }
+  get note(): Admin.NoteCategory {
+    return this._namespace.note;
+  }
+  get orderModification(): Admin.OrderModificationCategory {
+    return this._namespace.orderModification;
+  }
+  get order(): Admin.OrderCategory {
+    return this._namespace.order;
+  }
+  get payment(): Admin.PaymentCategory {
+    return this._namespace.payment;
+  }
+  get manageable(): Admin.ManageableCategory {
+    return this._namespace.manageable;
+  }
+  get plugin(): Admin.PluginCategory {
+    return this._namespace.plugin;
+  }
+  get optionGroup(): Admin.OptionGroupCategory {
+    return this._namespace.optionGroup;
+  }
+  get option(): Admin.OptionCategory {
+    return this._namespace.option;
+  }
+  get productOption(): Admin.ProductOptionCategory {
+    return this._namespace.productOption;
+  }
+  get productVariant(): Admin.ProductVariantCategory {
+    return this._namespace.productVariant;
+  }
+  get product(): Admin.ProductCategory {
+    return this._namespace.product;
+  }
+  get promotion(): Admin.PromotionCategory {
+    return this._namespace.promotion;
+  }
+  get role(): Admin.RoleCategory {
+    return this._namespace.role;
+  }
+  get scheduledJob(): Admin.ScheduledJobCategory {
+    return this._namespace.scheduledJob;
+  }
+  get search(): Admin.SearchCategory {
+    return this._namespace.search;
+  }
+  get seller(): Admin.SellerCategory {
+    return this._namespace.seller;
+  }
+  get shipping(): Admin.ShippingCategory {
+    return this._namespace.shipping;
+  }
+  get stock(): Admin.StockCategory {
+    return this._namespace.stock;
+  }
+  get subscription(): Admin.SubscriptionCategory {
+    return this._namespace.subscription;
+  }
+  get tax(): Admin.TaxCategory {
+    return this._namespace.tax;
+  }
+  get transaction(): Admin.TransactionCategory {
+    return this._namespace.transaction;
+  }
+  get zone(): Admin.ZoneCategory {
+    return this._namespace.zone;
+  }
+}
+
+export class ForgeCartShopClient {
+  private readonly client: BaseGraphQLClient;
+  private readonly _namespace: ShopNamespace;
+
+  constructor(config: ForgeCartShopClientConfig) {
+    const headers: Record<string, string> = { 'forgecart-token': config.channelToken, ...config.headers };
+    this.client = new BaseGraphQLClient(config.endpoint, headers, config.uploadEndpoint);
+    this._namespace = new ShopNamespace(this.client);
+  }
+
+  setAuthToken(token: string): void {
+    this.client.setAuthToken(token);
+  }
+
+  clearAuthToken(): void {
+    this.client.clearAuthToken();
+  }
+
+  setTransactionToken(token: string): void {
+    this.client.setTransactionToken(token);
+  }
+
+  clearTransactionToken(): void {
+    this.client.clearTransactionToken();
+  }
+
+  setErrorHandler(handler: ErrorHandler): void {
+    this.client.setErrorHandler(handler);
+  }
+
+  dispose(): void {
+    this.client.dispose();
+  }
+
+  query<T>(document: string, variables?: Record<string, unknown>): QueryObservable<T> {
+    return this.client.query<T>(document, variables);
+  }
+
+  mutate<T>(document: string, variables?: Record<string, unknown>): QueryObservable<T> {
+    return this.client.mutate<T>(document, variables);
+  }
+
+  createScopedNamespace(transactionToken: string): ShopNamespace {
+    return new ShopNamespace(this.client.fork(transactionToken));
+  }
+
+  async login(emailAddress: string, password: string): Promise<LoginSession> {
+    const result = await firstValueFrom(this.auth.login({ input: { emailAddress, password } })) as {
+      login: LoginSession;
+    };
+    this.client.setAuthToken(result.login.token);
+    return result.login;
+  }
+
+  async loginWithExternalStrategy(strategyCode: string, data: Record<string, unknown>): Promise<LoginSession> {
+    const result = await firstValueFrom(this.auth.authenticateWithExternalStrategy({ input: { strategyCode, data } })) as {
+      authenticateWithExternalStrategy: LoginSession;
+    };
+    this.client.setAuthToken(result.authenticateWithExternalStrategy.token);
+    return result.authenticateWithExternalStrategy;
+  }
+
+  async logout(): Promise<void> {
+    await firstValueFrom(this.auth.logout());
+    this.client.clearAuthToken();
+  }
+  get acf(): Shop.AcfCategory {
+    return this._namespace.acf;
+  }
+  get auth(): Shop.AuthCategory {
+    return this._namespace.auth;
+  }
+  get cart(): Shop.CartCategory {
+    return this._namespace.cart;
+  }
+  get checkout(): Shop.CheckoutCategory {
+    return this._namespace.checkout;
+  }
+  get collection(): Shop.CollectionCategory {
+    return this._namespace.collection;
+  }
+  get customer(): Shop.CustomerCategory {
+    return this._namespace.customer;
+  }
+  get facet(): Shop.FacetCategory {
+    return this._namespace.facet;
+  }
+  get hookDispatch(): Shop.HookDispatchCategory {
+    return this._namespace.hookDispatch;
+  }
+  get hook(): Shop.HookCategory {
+    return this._namespace.hook;
+  }
+  get marketingEvent(): Shop.MarketingEventCategory {
+    return this._namespace.marketingEvent;
+  }
+  get marketingIdentity(): Shop.MarketingIdentityCategory {
+    return this._namespace.marketingIdentity;
+  }
+  get order(): Shop.OrderCategory {
+    return this._namespace.order;
+  }
+  get payment(): Shop.PaymentCategory {
+    return this._namespace.payment;
+  }
+  get product(): Shop.ProductCategory {
+    return this._namespace.product;
+  }
+  get search(): Shop.SearchCategory {
+    return this._namespace.search;
+  }
+  get shipping(): Shop.ShippingCategory {
+    return this._namespace.shipping;
+  }
+  get subscription(): Shop.SubscriptionCategory {
+    return this._namespace.subscription;
+  }
+}
+
+export class ForgeCartClient {
+  private readonly _admin: ForgeCartAdminClient;
+  private readonly _shop: ForgeCartShopClient;
+
+  constructor(config: ForgeCartClientConfig) {
+    this._admin = new ForgeCartAdminClient({ endpoint: config.endpoint + '/admin-api', channelToken: config.channelToken, adminSecret: config.adminSecret, uploadEndpoint: config.uploadEndpoint ? config.uploadEndpoint + '/admin-api' : undefined, headers: config.headers });
+    this._shop = new ForgeCartShopClient({ endpoint: config.endpoint + '/shop-api', channelToken: config.channelToken, uploadEndpoint: config.uploadEndpoint ? config.uploadEndpoint + '/shop-api' : undefined, headers: config.headers });
+    this._admin.setShopPeer(this._shop);
+  }
+
+  setAuthToken(token: string): void {
+    this._admin.setAuthToken(token);
+    this._shop.setAuthToken(token);
+  }
+
+  clearAuthToken(): void {
+    this._admin.clearAuthToken();
+    this._shop.clearAuthToken();
+  }
+
+  setTransactionToken(token: string): void {
+    this._admin.setTransactionToken(token);
+    this._shop.setTransactionToken(token);
+  }
+
+  clearTransactionToken(): void {
+    this._admin.clearTransactionToken();
+    this._shop.clearTransactionToken();
+  }
+
+  get admin(): ForgeCartAdminClient {
+    return this._admin;
+  }
+  get shop(): ForgeCartShopClient {
+    return this._shop;
+  }
+}
+
+import { Module, type DynamicModule } from '@nestjs/common';
+
+@Module({})
+export class ForgeCartGraphQLModule {
+  static forAdmin(config: ForgeCartAdminClientConfig): DynamicModule {
+    const client = new ForgeCartAdminClient(config);
+    return {
+      module: ForgeCartGraphQLModule,
+      providers: [{ provide: ForgeCartAdminClient, useValue: client }],
+      exports: [ForgeCartAdminClient],
+    };
+  }
+  static forShop(config: ForgeCartShopClientConfig): DynamicModule {
+    const client = new ForgeCartShopClient(config);
+    return {
+      module: ForgeCartGraphQLModule,
+      providers: [{ provide: ForgeCartShopClient, useValue: client }],
+      exports: [ForgeCartShopClient],
+    };
+  }
+
+  static forRoot(config: ForgeCartClientConfig): DynamicModule {
+    const client = new ForgeCartClient(config);
+    return {
+      module: ForgeCartGraphQLModule,
+      providers: [
+        { provide: ForgeCartClient, useValue: client },
+        { provide: ForgeCartAdminClient, useValue: client.admin },
+        { provide: ForgeCartShopClient, useValue: client.shop },
+      ],
+      exports: [ForgeCartClient, ForgeCartAdminClient, ForgeCartShopClient],
+    };
+  }
+}