@whizzes/wbsc 0.0.1-early-dev-8

package/README.md

@@ -0,0 +1 @@
+# wsfc

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@whizzes/wbsc",
+  "version": "0.0.1-early-dev-8",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.d.ts",
+  "files": [
+    "./src"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./types": "./src/types/index.ts"
+  },
+  "scripts": {
+    "types": "tsc --emitDeclarationOnly",
+    "check": "tsc --noEmit",
+    "format": "prettier . --write . && eslint . --fix",
+    "generate": "graphql-codegen --config codegen.yml -r dotenv/config",
+    "lint": "prettier --check . && eslint .",
+    "test": "vitest --config ./vitest.config.ts"
+  },
+  "author": "Whizzes Developers <developers@whizzes.io>",
+  "license": "NOLICENSE",
+  "description": "",
+  "devDependencies": {
+    "@graphql-codegen/cli": "^5.0.5",
+    "@graphql-codegen/typescript": "^4.1.6",
+    "@graphql-codegen/typescript-operations": "^4.6.0",
+    "@graphql-codegen/typescript-urql": "^4.0.0",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@sinclair/typebox": "^0.34.33",
+    "@typescript-eslint/eslint-plugin": "^8.31.0",
+    "@typescript-eslint/parser": "^8.31.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
+  },
+  "peerDependencies": {
+    "@urql/core": "^5.1.1",
+    "@urql/exchange-auth": "^2.2.1",
+    "graphql-tag": "^2.12.6"
+  },
+  "resolutions": {
+    "graphql": "^16.10.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,61 @@
+import type { Client, CombinedError, OperationResult } from '@urql/core';
+
+export class WizardGraphQLClientError extends Error {
+  readonly graphQLError: CombinedError;
+
+  constructor(graphQLError: CombinedError, message: string) {
+    super(message);
+
+    this.name = 'WizardGraphQLClientError';
+    this.graphQLError = graphQLError;
+  }
+}
+
+export class WizardGraphQLDomainError<ErrorCodeEnum> extends Error {
+  readonly code: ErrorCodeEnum;
+
+  constructor(code: ErrorCodeEnum, message: string) {
+    super(message);
+
+    this.name = 'WizardGraphQLDomainError';
+    this.code = code;
+  }
+}
+
+export class WizardGraphQLClient<ErrorCodeEnum> {
+  protected client: Client;
+
+  protected constructor(client: Client) {
+    this.client = client;
+  }
+
+  /**
+   *
+   * @param operation - The GraphQL operation result
+   * @param opName - The name of the GraphQL operation
+   * @returns - The error object if present, otherwise null
+   */
+  unwrapError(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    operation: OperationResult<any, any>,
+    opName: string
+  ) {
+    if (operation.error) {
+      throw new WizardGraphQLClientError(
+        operation.error,
+        operation.error.message
+      );
+    }
+
+    if (operation.data[opName]?.error) {
+      const domainError = operation.data[opName].error;
+
+      if (domainError.code && domainError.message) {
+        throw new WizardGraphQLDomainError<ErrorCodeEnum>(
+          domainError.code,
+          domainError.message
+        );
+      }
+    }
+  }
+}

package/src/core/product/gql/ProductsList.gql

@@ -0,0 +1,9 @@
+query ProductsList($channel: ChannelCode!) {
+  products(channelCode: $channel) {
+    edges {
+      node {
+        ...ProductsListFields
+      }
+    }
+  }
+}

package/src/core/product/gql/ProductsListFields.Fragment.gql

@@ -0,0 +1,45 @@
+fragment ProductsListFields on Product {
+  channelCode
+  id
+  name
+  slug
+  description
+  metadata
+  defaultVariantId
+  defaultVariant {
+    id
+    channelCode
+    sku
+    productId
+    requiresShipping
+    images {
+      id
+      channelCode
+      height
+      width
+      url
+      thumbnailUrl
+      size
+      mimeType
+      useCase
+      createdAt
+      updatedAt
+    }
+    prices {
+      variantId
+      channelCode
+      currency
+      price
+    }
+  }
+  position
+  categories {
+    id
+    name
+    path
+    position
+    isActive
+    createdAt
+    updatedAt
+  }
+}

package/src/core/product/index.ts

@@ -0,0 +1 @@
+export { ProductService } from './service';

package/src/core/product/service.ts

@@ -0,0 +1,34 @@
+import { WizardGraphQLClient } from '../../client';
+import {
+  ProductsListDocument
+} from '../../types';
+
+import type { Client } from '@urql/core';
+import type {
+  ProductErrorCode,
+  ProductsListFieldsFragment
+} from '../../types';
+
+export class ProductService extends WizardGraphQLClient<ProductErrorCode> {
+  constructor(urqlClient: Client) {
+    super(urqlClient);
+  }
+
+  async listProducts(
+    channel: string,
+  ): Promise<ProductsListFieldsFragment[]> {
+    const response = await this.client
+      .query(ProductsListDocument, {
+        channel
+      })
+      .toPromise();
+
+    this.unwrapError(response, 'products');
+
+    return (
+      response.data?.products?.edges?.map(
+        (edge: { node: ProductsListFieldsFragment }) => edge.node
+      ) || []
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from './core/product';
+
+import { ProductService } from './core/product';
+
+import type { Client as URQLClient } from '@urql/core';
+
+export class WizardStorefrontClient {
+  readonly baseURL: URL;
+  readonly urqlClient: URQLClient;
+  readonly product: ProductService;
+
+  constructor(baseURL: URL, graphQLClient: URQLClient) {
+    this.baseURL = baseURL;
+    this.urqlClient = graphQLClient;
+    this.product = new ProductService(graphQLClient);
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,1062 @@
+import gql from 'graphql-tag';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
+export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: { input: string; output: string; }
+  String: { input: string; output: string; }
+  Boolean: { input: boolean; output: boolean; }
+  Int: { input: number; output: number; }
+  Float: { input: number; output: number; }
+  CategoryLabel: { input: any; output: any; }
+  ChannelCode: { input: any; output: any; }
+  DateTime: { input: any; output: any; }
+  Decimal: { input: any; output: any; }
+  Email: { input: any; output: any; }
+  JsonSchema: { input: any; output: any; }
+  JsonString: { input: any; output: any; }
+  Slug: { input: any; output: any; }
+  UUID: { input: any; output: any; }
+  Upload: { input: any; output: any; }
+};
+
+export type ActorType = {
+  __typename?: 'ActorType';
+  actorId: Scalars['String']['output'];
+  actorType: ActorTypeKind;
+};
+
+export enum ActorTypeKind {
+  Admin = 'ADMIN',
+  Customer = 'CUSTOMER',
+  Integration = 'INTEGRATION',
+  Service = 'SERVICE',
+  Storefront = 'STOREFRONT'
+}
+
+export type AuthError = {
+  __typename?: 'AuthError';
+  code: AuthErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum AuthErrorCode {
+  InvalidCredentials = 'INVALID_CREDENTIALS',
+  Unauthorized = 'UNAUTHORIZED',
+  Unknown = 'UNKNOWN'
+}
+
+/** Platform Category belonging to a Channel. */
+export type Category = {
+  __typename?: 'Category';
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  id: Scalars['UUID']['output'];
+  isActive: Scalars['Boolean']['output'];
+  name: Scalars['String']['output'];
+  path: Array<Scalars['CategoryLabel']['output']>;
+  position: Scalars['Int']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export type CategoryConnection = {
+  __typename?: 'CategoryConnection';
+  /** A list of edges. */
+  edges: Array<CategoryEdge>;
+  /** A list of nodes. */
+  nodes: Array<Category>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  totalCount: Scalars['Int']['output'];
+  totalPages: Scalars['Int']['output'];
+};
+
+export type CategoryCreate = {
+  __typename?: 'CategoryCreate';
+  category?: Maybe<Category>;
+  error?: Maybe<CategoryError>;
+};
+
+export type CategoryCreateInput = {
+  isActive: Scalars['Boolean']['input'];
+  name: Scalars['String']['input'];
+  path: Array<Scalars['CategoryLabel']['input']>;
+  position: Scalars['Int']['input'];
+};
+
+export type CategoryDelete = {
+  __typename?: 'CategoryDelete';
+  error?: Maybe<CategoryError>;
+};
+
+/** An edge in a connection. */
+export type CategoryEdge = {
+  __typename?: 'CategoryEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node: Category;
+};
+
+export type CategoryError = {
+  __typename?: 'CategoryError';
+  code: CategoryErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum CategoryErrorCode {
+  DatabaseError = 'DATABASE_ERROR'
+}
+
+/** A user's Channel Role */
+export type ChannelRole = {
+  __typename?: 'ChannelRole';
+  channel: Scalars['ChannelCode']['output'];
+  role: Role;
+};
+
+export type CmsError = {
+  __typename?: 'CmsError';
+  code: CmsErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum CmsErrorCode {
+  CollectionContentTypeMismatch = 'COLLECTION_CONTENT_TYPE_MISMATCH',
+  EntryCollectionMismatch = 'ENTRY_COLLECTION_MISMATCH',
+  EntryValidationError = 'ENTRY_VALIDATION_ERROR',
+  FieldAlreadyExists = 'FIELD_ALREADY_EXISTS',
+  SerdeError = 'SERDE_ERROR',
+  Unknown = 'UNKNOWN'
+}
+
+/** CMS Content-Type */
+export type ContentType = {
+  __typename?: 'ContentType';
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  name: Scalars['String']['output'];
+  schema: Scalars['JsonSchema']['output'];
+  slug: Scalars['Slug']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export type ContentTypeConnection = {
+  __typename?: 'ContentTypeConnection';
+  /** A list of edges. */
+  edges: Array<ContentTypeEdge>;
+  /** A list of nodes. */
+  nodes: Array<ContentType>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  totalCount: Scalars['Int']['output'];
+  totalPages: Scalars['Int']['output'];
+};
+
+export type ContentTypeCreate = {
+  __typename?: 'ContentTypeCreate';
+  contentType?: Maybe<ContentType>;
+  error?: Maybe<CmsError>;
+};
+
+export type ContentTypeCreateInput = {
+  name: Scalars['String']['input'];
+  schema: Scalars['JsonSchema']['input'];
+  slug: Scalars['Slug']['input'];
+};
+
+/** An edge in a connection. */
+export type ContentTypeEdge = {
+  __typename?: 'ContentTypeEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node: ContentType;
+};
+
+/** Platform Customer belonging to a Channel. */
+export type Customer = {
+  __typename?: 'Customer';
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  deletedAt?: Maybe<Scalars['DateTime']['output']>;
+  email?: Maybe<Scalars['Email']['output']>;
+  id: Scalars['UUID']['output'];
+  name: Scalars['String']['output'];
+  phoneNumber?: Maybe<Scalars['String']['output']>;
+  surname?: Maybe<Scalars['String']['output']>;
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export type CustomerConnection = {
+  __typename?: 'CustomerConnection';
+  /** A list of edges. */
+  edges: Array<CustomerEdge>;
+  /** A list of nodes. */
+  nodes: Array<Customer>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  totalCount: Scalars['Int']['output'];
+  totalPages: Scalars['Int']['output'];
+};
+
+export type CustomerCreate = {
+  __typename?: 'CustomerCreate';
+  customer?: Maybe<Customer>;
+  error?: Maybe<CustomerError>;
+};
+
+export type CustomerCreateInput = {
+  email: Scalars['Email']['input'];
+  name: Scalars['String']['input'];
+  phone?: InputMaybe<Scalars['String']['input']>;
+  surname?: InputMaybe<Scalars['String']['input']>;
+};
+
+/** An edge in a connection. */
+export type CustomerEdge = {
+  __typename?: 'CustomerEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node: Customer;
+};
+
+export type CustomerError = {
+  __typename?: 'CustomerError';
+  code: CustomerErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum CustomerErrorCode {
+  DatabaseError = 'DATABASE_ERROR'
+}
+
+export type EntriesFilterInput = {
+  collectionSlug: Scalars['Slug']['input'];
+};
+
+/** CMS Entry */
+export type Entry = {
+  __typename?: 'Entry';
+  channelCode: Scalars['ChannelCode']['output'];
+  collectionSlug: Scalars['Slug']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  id: Scalars['UUID']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+  value: Scalars['JsonString']['output'];
+};
+
+/** CMS Collection */
+export type EntryCollection = {
+  __typename?: 'EntryCollection';
+  channelCode: Scalars['ChannelCode']['output'];
+  contentTypeSlug: Scalars['Slug']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  description?: Maybe<Scalars['String']['output']>;
+  name: Scalars['String']['output'];
+  slug: Scalars['Slug']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export type EntryCollectionConnection = {
+  __typename?: 'EntryCollectionConnection';
+  /** A list of edges. */
+  edges: Array<EntryCollectionEdge>;
+  /** A list of nodes. */
+  nodes: Array<EntryCollection>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  totalCount: Scalars['Int']['output'];
+  totalPages: Scalars['Int']['output'];
+};
+
+export type EntryCollectionCreate = {
+  __typename?: 'EntryCollectionCreate';
+  collection?: Maybe<EntryCollection>;
+  error?: Maybe<CmsError>;
+};
+
+export type EntryCollectionCreateInput = {
+  contentTypeSlug: Scalars['Slug']['input'];
+  description?: InputMaybe<Scalars['String']['input']>;
+  name: Scalars['String']['input'];
+  slug: Scalars['Slug']['input'];
+};
+
+/** An edge in a connection. */
+export type EntryCollectionEdge = {
+  __typename?: 'EntryCollectionEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node: EntryCollection;
+};
+
+export type EntryConnection = {
+  __typename?: 'EntryConnection';
+  /** A list of edges. */
+  edges: Array<EntryEdge>;
+  /** A list of nodes. */
+  nodes: Array<Entry>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  totalCount: Scalars['Int']['output'];
+  totalPages: Scalars['Int']['output'];
+};
+
+export type EntryCreate = {
+  __typename?: 'EntryCreate';
+  entry?: Maybe<Entry>;
+  error?: Maybe<CmsError>;
+};
+
+export type EntryCreateInput = {
+  collectionSlug: Scalars['Slug']['input'];
+  value: Scalars['JsonString']['input'];
+};
+
+/** An edge in a connection. */
+export type EntryEdge = {
+  __typename?: 'EntryEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node: Entry;
+};
+
+/** Platform Image */
+export type Image = {
+  __typename?: 'Image';
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  height: Scalars['Int']['output'];
+  id: Scalars['UUID']['output'];
+  mimeType: MimeType;
+  providerId: Scalars['String']['output'];
+  size: Scalars['Int']['output'];
+  thumbnailUrl?: Maybe<Scalars['String']['output']>;
+  updatedAt: Scalars['DateTime']['output'];
+  url: Scalars['String']['output'];
+  useCase: UseCase;
+  width: Scalars['Int']['output'];
+};
+
+/**
+ * The ISO 4217 currency code.
+ *
+ * ```
+ * use serde::{Deserialize, Serialize};
+ *
+ * assert_eq!(serde_json::to_string(&Currency::Euro).unwrap(), "\"EUR\"");
+ * assert_eq!(serde_json::to_string(&Currency::UnitedStatesDollar).unwrap(), "\"USD\"");
+ * assert_eq!(serde_json::to_string(&Currency::AustralianDollar).unwrap(), "\"AUD\"");
+ * ```
+ *
+ * Read More: [Currency Codes](https://developer.paypal.com/api/rest/reference/currency-codes/)
+ */
+export enum Iso4217 {
+  Ars = 'ARS',
+  Brl = 'BRL',
+  Clp = 'CLP',
+  Cop = 'COP',
+  Crc = 'CRC',
+  Dop = 'DOP',
+  Eur = 'EUR',
+  Gtq = 'GTQ',
+  Mxn = 'MXN',
+  Pab = 'PAB',
+  Pen = 'PEN',
+  Pyg = 'PYG',
+  Usd = 'USD',
+  Uyu = 'UYU',
+  Ved = 'VED'
+}
+
+export type MagicLinkSend = {
+  __typename?: 'MagicLinkSend';
+  error?: Maybe<AuthError>;
+};
+
+export type MagicLinkVerify = {
+  __typename?: 'MagicLinkVerify';
+  error?: Maybe<AuthError>;
+};
+
+export type Me = {
+  __typename?: 'Me';
+  error?: Maybe<AuthError>;
+  user?: Maybe<User>;
+};
+
+/**
+ * Image file MIME Types
+ *
+ * # Reference
+ *
+ * - [MIME Types][1]
+ *
+ * [1]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types
+ */
+export enum MimeType {
+  /** Heic Image (HEIC) */
+  Heic = 'HEIC',
+  /** Joint Photographic Expert Group image (JPEG) */
+  Jpeg = 'JPEG',
+  /** Portable Network Graphics (PNG) */
+  Png = 'PNG',
+  /** WebP Image (WEBP) */
+  Webp = 'WEBP'
+}
+
+export type Mutation = {
+  __typename?: 'Mutation';
+  /** Creates a Category */
+  categoryCreate: CategoryCreate;
+  /** Deletes a Category */
+  categoryDelete: CategoryDelete;
+  /** Creates a CMS Content-Type */
+  contentTypeCreate: ContentTypeCreate;
+  /** Creates a Customer */
+  customerCreate: CustomerCreate;
+  /** Creates a CMS Entry Collection */
+  entryCollectionCreate: EntryCollectionCreate;
+  /** Creates a CMS Entry */
+  entryCreate: EntryCreate;
+  magicLinkSend: MagicLinkSend;
+  magicLinkVerify: MagicLinkVerify;
+  /**
+   * Creates a order.
+   * This order is created with a default status of `Cart`.
+   */
+  orderCreate: OrderCreate;
+  /** Update the customer of an order. */
+  orderCustomerUpdate: OrderCustomerUpdate;
+  /** Add line item to an order. */
+  orderLineItemAdd: OrderLineItemAdd;
+  /** Appends a Category to a Product */
+  productCategoryAppend: ProductCategoryAppend;
+  /** Creates a Product */
+  productCreate: ProductCreate;
+  /** Updates a Product */
+  productUpdate: ProductUpdate;
+  /**
+   * start checkout process
+   * This will update the order status to `Address` or `Payment` depending on the order type.
+   */
+  startCheckout: OrderStartCheckout;
+  /** List Users */
+  userCreate: UserCreate;
+  /** Uploads an Image and attaches it to a Product Variant */
+  variantImageUpload: VariantImageUpload;
+  /** Creates a price for a Product Variant */
+  variantPriceCreate: VariantPriceCreate;
+};
+
+
+export type MutationCategoryCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: CategoryCreateInput;
+};
+
+
+export type MutationCategoryDeleteArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  path: Array<Scalars['CategoryLabel']['input']>;
+};
+
+
+export type MutationContentTypeCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: ContentTypeCreateInput;
+};
+
+
+export type MutationCustomerCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: CustomerCreateInput;
+};
+
+
+export type MutationEntryCollectionCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: EntryCollectionCreateInput;
+};
+
+
+export type MutationEntryCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: EntryCreateInput;
+};
+
+
+export type MutationMagicLinkSendArgs = {
+  email: Scalars['Email']['input'];
+};
+
+
+export type MutationMagicLinkVerifyArgs = {
+  email: Scalars['Email']['input'];
+  token: Scalars['String']['input'];
+};
+
+
+export type MutationOrderCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: OrderCreateInput;
+};
+
+
+export type MutationOrderCustomerUpdateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: OrderCustomerUpdateInput;
+};
+
+
+export type MutationOrderLineItemAddArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: OrderLineItemAddInput;
+};
+
+
+export type MutationProductCategoryAppendArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: ProductCategoryAppendInput;
+};
+
+
+export type MutationProductCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: ProductCreateInput;
+};
+
+
+export type MutationProductUpdateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  id: Scalars['UUID']['input'];
+  input: ProductUpdateInput;
+};
+
+
+export type MutationStartCheckoutArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: OrderStartCheckoutInput;
+};
+
+
+export type MutationUserCreateArgs = {
+  channelCode: Scalars['ChannelCode']['input'];
+};
+
+
+export type MutationVariantImageUploadArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: VariantImageUploadInput;
+};
+
+
+export type MutationVariantPriceCreateArgs = {
+  channel: Scalars['ChannelCode']['input'];
+  input: VariantPriceCreateInput;
+};
+
+/** Platform Order belonging to a Channel. */
+export type Order = {
+  __typename?: 'Order';
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  customer: Customer;
+  customerId?: Maybe<Scalars['UUID']['output']>;
+  id: Scalars['UUID']['output'];
+  lineItems: Array<OrderLineItem>;
+  orderEvents: Array<OrderEvent>;
+  orderNumber: Scalars['Int']['output'];
+  state: OrderState;
+  total: Scalars['Decimal']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export enum OrderAction {
+  AddAddress = 'ADD_ADDRESS',
+  AddPayment = 'ADD_PAYMENT',
+  Advance = 'ADVANCE',
+  CancelOrder = 'CANCEL_ORDER',
+  ConfirmOrder = 'CONFIRM_ORDER',
+  Revert = 'REVERT',
+  SelectDelivery = 'SELECT_DELIVERY',
+  StartCheckout = 'START_CHECKOUT'
+}
+
+export type OrderConnection = {
+  __typename?: 'OrderConnection';
+  /** A list of edges. */
+  edges: Array<OrderEdge>;
+  /** A list of nodes. */
+  nodes: Array<Order>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  totalCount: Scalars['Int']['output'];
+  totalPages: Scalars['Int']['output'];
+};
+
+export type OrderCreate = {
+  __typename?: 'OrderCreate';
+  error?: Maybe<OrderError>;
+  order?: Maybe<Order>;
+};
+
+export type OrderCreateInput = {
+  customerId?: InputMaybe<Scalars['UUID']['input']>;
+};
+
+export type OrderCustomerUpdate = {
+  __typename?: 'OrderCustomerUpdate';
+  error?: Maybe<OrderError>;
+  order?: Maybe<Order>;
+};
+
+export type OrderCustomerUpdateInput = {
+  customerId: Scalars['UUID']['input'];
+  orderId: Scalars['UUID']['input'];
+};
+
+/** An edge in a connection. */
+export type OrderEdge = {
+  __typename?: 'OrderEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node: Order;
+};
+
+export type OrderError = {
+  __typename?: 'OrderError';
+  code: OrderErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum OrderErrorCode {
+  DatabaseError = 'DATABASE_ERROR'
+}
+
+export type OrderEvent = {
+  __typename?: 'OrderEvent';
+  action: OrderAction;
+  actor?: Maybe<ActorType>;
+  eventTimestamp: Scalars['DateTime']['output'];
+};
+
+export type OrderLineItem = {
+  __typename?: 'OrderLineItem';
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  id: Scalars['UUID']['output'];
+  orderId: Scalars['UUID']['output'];
+  quantity: Scalars['Int']['output'];
+  totalPrice: Scalars['Decimal']['output'];
+  unitPrice: Scalars['Decimal']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+  variant: Variant;
+  variantId: Scalars['UUID']['output'];
+};
+
+export type OrderLineItemAdd = {
+  __typename?: 'OrderLineItemAdd';
+  error?: Maybe<OrderError>;
+  orderLineItem?: Maybe<OrderLineItem>;
+};
+
+export type OrderLineItemAddInput = {
+  orderId: Scalars['UUID']['input'];
+  quantity: Scalars['Int']['input'];
+  variantId: Scalars['UUID']['input'];
+};
+
+export type OrderStartCheckout = {
+  __typename?: 'OrderStartCheckout';
+  error?: Maybe<OrderError>;
+  order?: Maybe<Order>;
+};
+
+export type OrderStartCheckoutInput = {
+  orderId: Scalars['UUID']['input'];
+};
+
+export enum OrderState {
+  Address = 'ADDRESS',
+  Cancel = 'CANCEL',
+  Cart = 'CART',
+  Complete = 'COMPLETE',
+  Confirm = 'CONFIRM',
+  Delivery = 'DELIVERY',
+  Payment = 'PAYMENT'
+}
+
+/** Information about pagination in a connection */
+export type PageInfo = {
+  __typename?: 'PageInfo';
+  /** When paginating forwards, the cursor to continue. */
+  endCursor?: Maybe<Scalars['String']['output']>;
+  /** When paginating forwards, are there more items? */
+  hasNextPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, are there more items? */
+  hasPreviousPage: Scalars['Boolean']['output'];
+  /** When paginating backwards, the cursor to continue. */
+  startCursor?: Maybe<Scalars['String']['output']>;
+};
+
+/** Platform Variant Price */
+export type Price = {
+  __typename?: 'Price';
+  channelCode: Scalars['ChannelCode']['output'];
+  currency: Iso4217;
+  price: Scalars['Decimal']['output'];
+  variantId: Scalars['UUID']['output'];
+};
+
+/** Platform Product */
+export type Product = {
+  __typename?: 'Product';
+  categories: Array<Category>;
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  defaultVariant: Variant;
+  defaultVariantId: Scalars['UUID']['output'];
+  description: Scalars['JsonString']['output'];
+  id: Scalars['UUID']['output'];
+  metadata?: Maybe<Scalars['JsonString']['output']>;
+  name: Scalars['String']['output'];
+  position: Scalars['Int']['output'];
+  publishAt: Scalars['DateTime']['output'];
+  slug: Scalars['Slug']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export type ProductCategoryAppend = {
+  __typename?: 'ProductCategoryAppend';
+  error?: Maybe<ProductError>;
+};
+
+export type ProductCategoryAppendInput = {
+  categoryId: Scalars['UUID']['input'];
+  productId: Scalars['UUID']['input'];
+};
+
+export type ProductConnection = {
+  __typename?: 'ProductConnection';
+  /** A list of edges. */
+  edges: Array<ProductEdge>;
+  /** A list of nodes. */
+  nodes: Array<Product>;
+  /** Information to aid in pagination. */
+  pageInfo: PageInfo;
+  totalCount: Scalars['Int']['output'];
+  totalPages: Scalars['Int']['output'];
+};
+
+export type ProductCreate = {
+  __typename?: 'ProductCreate';
+  error?: Maybe<ProductError>;
+  product?: Maybe<Product>;
+};
+
+export type ProductCreateInput = {
+  name: Scalars['String']['input'];
+};
+
+/** An edge in a connection. */
+export type ProductEdge = {
+  __typename?: 'ProductEdge';
+  /** A cursor for use in pagination */
+  cursor: Scalars['String']['output'];
+  /** The item at the end of the edge */
+  node: Product;
+};
+
+export type ProductError = {
+  __typename?: 'ProductError';
+  code: ProductErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum ProductErrorCode {
+  DatabaseError = 'DATABASE_ERROR'
+}
+
+export type ProductUpdate = {
+  __typename?: 'ProductUpdate';
+  error?: Maybe<ProductError>;
+  product?: Maybe<Product>;
+};
+
+export type ProductUpdateInput = {
+  description?: InputMaybe<Scalars['JsonString']['input']>;
+  metadata?: InputMaybe<Scalars['JsonString']['input']>;
+  name?: InputMaybe<Scalars['String']['input']>;
+  position?: InputMaybe<Scalars['Int']['input']>;
+  slug?: InputMaybe<Scalars['Slug']['input']>;
+};
+
+export type Query = {
+  __typename?: 'Query';
+  /** Retrieves Categories */
+  categories: CategoryConnection;
+  /** Retrieves CMS Content Types */
+  contentTypes: ContentTypeConnection;
+  /** Retrieves Customers */
+  customers: CustomerConnection;
+  /** Retrieves CMS Entries */
+  entries: EntryConnection;
+  /** Retrieves CMS Entry Collections */
+  entryCollections: EntryCollectionConnection;
+  me: Me;
+  /** Retrieves Orders */
+  orders: OrderConnection;
+  /** Retrieves Products */
+  products: ProductConnection;
+  /** List Users */
+  users: Scalars['String']['output'];
+};
+
+
+export type QueryCategoriesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  channelCode: Scalars['ChannelCode']['input'];
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryContentTypesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  channelCode: Scalars['ChannelCode']['input'];
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryCustomersArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  channelCode: Scalars['ChannelCode']['input'];
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryEntriesArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  channelCode: Scalars['ChannelCode']['input'];
+  filter: EntriesFilterInput;
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryEntryCollectionsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  channelCode: Scalars['ChannelCode']['input'];
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryOrdersArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  channelCode: Scalars['ChannelCode']['input'];
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryProductsArgs = {
+  after?: InputMaybe<Scalars['String']['input']>;
+  before?: InputMaybe<Scalars['String']['input']>;
+  channelCode: Scalars['ChannelCode']['input'];
+  first?: InputMaybe<Scalars['Int']['input']>;
+  last?: InputMaybe<Scalars['Int']['input']>;
+};
+
+
+export type QueryUsersArgs = {
+  channelCode: Scalars['ChannelCode']['input'];
+};
+
+/**
+ * Channel Role is a role that a user can have in a channel.
+ * The roles are:
+ * - Owner
+ * - Admin
+ * - Staff
+ */
+export enum Role {
+  Admin = 'ADMIN',
+  Owner = 'OWNER',
+  Staff = 'STAFF'
+}
+
+export enum UseCase {
+  /** Profile Picture for a user instance */
+  Avatar = 'AVATAR',
+  /** Logo associated to a brand */
+  Logo = 'LOGO',
+  /** Image associated to a product variant */
+  ProductVariant = 'PRODUCT_VARIANT'
+}
+
+/** Wizard Platform User */
+export type User = {
+  __typename?: 'User';
+  channels: Array<ChannelRole>;
+  createdAt: Scalars['DateTime']['output'];
+  deletedAt?: Maybe<Scalars['DateTime']['output']>;
+  email: Scalars['Email']['output'];
+  id: Scalars['UUID']['output'];
+  name: Scalars['String']['output'];
+  surname: Scalars['String']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export type UserCreate = {
+  __typename?: 'UserCreate';
+  error?: Maybe<UserError>;
+  user?: Maybe<User>;
+};
+
+export type UserError = {
+  __typename?: 'UserError';
+  code: UserErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum UserErrorCode {
+  DatabaseError = 'DATABASE_ERROR'
+}
+
+/** Platform Product Variant */
+export type Variant = {
+  __typename?: 'Variant';
+  channelCode: Scalars['ChannelCode']['output'];
+  createdAt: Scalars['DateTime']['output'];
+  id: Scalars['UUID']['output'];
+  images: Array<Image>;
+  prices: Array<Price>;
+  product: Product;
+  productId: Scalars['UUID']['output'];
+  requiresShipping: Scalars['Boolean']['output'];
+  sku?: Maybe<Scalars['String']['output']>;
+  updatedAt: Scalars['DateTime']['output'];
+};
+
+export type VariantError = {
+  __typename?: 'VariantError';
+  code: VariantErrorCode;
+  message: Scalars['String']['output'];
+};
+
+export enum VariantErrorCode {
+  DatabaseError = 'DATABASE_ERROR',
+  ImageUploadError = 'IMAGE_UPLOAD_ERROR'
+}
+
+export type VariantImageUpload = {
+  __typename?: 'VariantImageUpload';
+  error?: Maybe<VariantError>;
+  image?: Maybe<Image>;
+};
+
+export type VariantImageUploadInput = {
+  file: Scalars['Upload']['input'];
+  variantId: Scalars['UUID']['input'];
+};
+
+export type VariantPriceCreate = {
+  __typename?: 'VariantPriceCreate';
+  error?: Maybe<VariantError>;
+  price?: Maybe<Price>;
+};
+
+export type VariantPriceCreateInput = {
+  currency: Iso4217;
+  price: Scalars['Decimal']['input'];
+  variantId: Scalars['UUID']['input'];
+};
+
+export type ProductsListQueryVariables = Exact<{
+  channel: Scalars['ChannelCode']['input'];
+}>;
+
+
+export type ProductsListQuery = { __typename?: 'Query', products: { __typename?: 'ProductConnection', edges: Array<{ __typename?: 'ProductEdge', node: { __typename?: 'Product', channelCode: any, id: any, name: string, slug: any, description: any, metadata?: any | null, defaultVariantId: any, position: number, defaultVariant: { __typename?: 'Variant', id: any, channelCode: any, sku?: string | null, productId: any, requiresShipping: boolean, images: Array<{ __typename?: 'Image', id: any, channelCode: any, height: number, width: number, url: string, thumbnailUrl?: string | null, size: number, mimeType: MimeType, useCase: UseCase, createdAt: any, updatedAt: any }>, prices: Array<{ __typename?: 'Price', variantId: any, channelCode: any, currency: Iso4217, price: any }> }, categories: Array<{ __typename?: 'Category', id: any, name: string, path: Array<any>, position: number, isActive: boolean, createdAt: any, updatedAt: any }> } }> } };
+
+export type ProductsListFieldsFragment = { __typename?: 'Product', channelCode: any, id: any, name: string, slug: any, description: any, metadata?: any | null, defaultVariantId: any, position: number, defaultVariant: { __typename?: 'Variant', id: any, channelCode: any, sku?: string | null, productId: any, requiresShipping: boolean, images: Array<{ __typename?: 'Image', id: any, channelCode: any, height: number, width: number, url: string, thumbnailUrl?: string | null, size: number, mimeType: MimeType, useCase: UseCase, createdAt: any, updatedAt: any }>, prices: Array<{ __typename?: 'Price', variantId: any, channelCode: any, currency: Iso4217, price: any }> }, categories: Array<{ __typename?: 'Category', id: any, name: string, path: Array<any>, position: number, isActive: boolean, createdAt: any, updatedAt: any }> };
+
+export const ProductsListFieldsFragmentDoc = gql`
+    fragment ProductsListFields on Product {
+  channelCode
+  id
+  name
+  slug
+  description
+  metadata
+  defaultVariantId
+  defaultVariant {
+    id
+    channelCode
+    sku
+    productId
+    requiresShipping
+    images {
+      id
+      channelCode
+      height
+      width
+      url
+      thumbnailUrl
+      size
+      mimeType
+      useCase
+      createdAt
+      updatedAt
+    }
+    prices {
+      variantId
+      channelCode
+      currency
+      price
+    }
+  }
+  position
+  categories {
+    id
+    name
+    path
+    position
+    isActive
+    createdAt
+    updatedAt
+  }
+}
+    `;
+export const ProductsListDocument = gql`
+    query ProductsList($channel: ChannelCode!) {
+  products(channelCode: $channel) {
+    edges {
+      node {
+        ...ProductsListFields
+      }
+    }
+  }
+}
+    ${ProductsListFieldsFragmentDoc}`;