@reactionary/provider-commercetools 0.0.27

package/README.md

@@ -0,0 +1,11 @@
+# provider-commercetools
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build provider-commercetools` to build the library.
+
+## Running unit tests
+
+Run `nx test provider-commercetools` to execute the unit tests via [Jest](https://jestjs.io).

package/index.js

@@ -0,0 +1,1107 @@
+// providers/commercetools/src/core/client.ts
+import { ClientBuilder } from "@commercetools/ts-client";
+import { createApiBuilderFromCtpClient } from "@commercetools/platform-sdk";
+var ANONYMOUS_SCOPES = ["view_published_products", "manage_shopping_lists", "view_shipping_methods", "manage_customers", "view_product_selections", "view_categories", "view_project_settings", "manage_order_edits", "view_sessions", "view_standalone_prices", "manage_orders", "view_tax_categories", "view_cart_discounts", "view_discount_codes", "create_anonymous_token", "manage_sessions", "view_products", "view_types"];
+var GUEST_SCOPES = [...ANONYMOUS_SCOPES];
+var REGISTERED_SCOPES = [...GUEST_SCOPES];
+var CommercetoolsClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  getClient(token) {
+    if (token) {
+      return this.createClientWithToken(token);
+    }
+    return this.createAnonymousClient();
+  }
+  async login(username, password) {
+    const scopes = REGISTERED_SCOPES.map(
+      (scope) => `${scope}:${this.config.projectKey}`
+    ).join(" ");
+    const queryParams = new URLSearchParams({
+      grant_type: "password",
+      username,
+      password,
+      scope: scopes
+    });
+    const url = `${this.config.authUrl}/oauth/${this.config.projectKey}/customers/token?${queryParams.toString()}`;
+    const headers = {
+      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
+    };
+    const remote = await fetch(url, { method: "POST", headers });
+    const json = await remote.json();
+    return json;
+  }
+  async guest() {
+    const scopes = GUEST_SCOPES.map(
+      (scope) => `${scope}:${this.config.projectKey}`
+    ).join(" ");
+    const queryParams = new URLSearchParams({
+      grant_type: "client_credentials",
+      scope: scopes
+    });
+    const url = `${this.config.authUrl}/oauth/${this.config.projectKey}/anonymous/token?${queryParams.toString()}`;
+    const headers = {
+      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
+    };
+    const remote = await fetch(url, { method: "POST", headers });
+    const json = await remote.json();
+    return json;
+  }
+  async logout(token) {
+    const queryParams = new URLSearchParams({
+      token,
+      token_type_hint: "access_token"
+    });
+    const url = `${this.config.authUrl}/oauth/token/revoke?${queryParams.toString()}`;
+    const headers = {
+      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
+    };
+    const remote = await fetch(url, { method: "POST", headers });
+    return remote;
+  }
+  async introspect(token) {
+    const queryParams = new URLSearchParams({
+      token
+    });
+    const url = `${this.config.authUrl}/oauth/introspect?` + queryParams;
+    const headers = {
+      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
+    };
+    const remote = await fetch(url, { method: "POST", headers });
+    const json = await remote.json();
+    return json;
+  }
+  createAnonymousClient() {
+    const scopes = ANONYMOUS_SCOPES.map(
+      (scope) => `${scope}:${this.config.projectKey}`
+    ).join(" ");
+    const builder = this.createBaseClientBuilder().withClientCredentialsFlow({
+      host: this.config.authUrl,
+      projectKey: this.config.projectKey,
+      credentials: {
+        clientId: this.config.clientId,
+        clientSecret: this.config.clientSecret
+      },
+      scopes: [scopes]
+    });
+    return createApiBuilderFromCtpClient(builder.build());
+  }
+  createClientWithToken(token) {
+    const builder = this.createBaseClientBuilder().withExistingTokenFlow(`Bearer ${token}`, { force: true });
+    return createApiBuilderFromCtpClient(builder.build());
+  }
+  createBaseClientBuilder() {
+    const builder = new ClientBuilder().withProjectKey(this.config.projectKey).withQueueMiddleware({
+      concurrency: 20
+    }).withHttpMiddleware({
+      retryConfig: {
+        backoff: true,
+        maxRetries: 3,
+        retryDelay: 500,
+        retryOnAbort: true,
+        retryCodes: [500, 429, 420],
+        maxDelay: 5e3
+      },
+      enableRetry: true,
+      includeResponseHeaders: true,
+      maskSensitiveHeaderData: false,
+      host: this.config.apiUrl,
+      httpClient: fetch
+    });
+    return builder;
+  }
+};
+
+// core/src/cache/caching-strategy.ts
+var BaseCachingStrategy = class {
+  get(query, session) {
+    const q = query;
+    return {
+      key: q.sku,
+      cacheDurationInSeconds: 300,
+      canCache: true
+    };
+  }
+};
+
+// core/src/cache/redis-cache.ts
+import { Redis } from "@upstash/redis";
+var RedisCache = class {
+  constructor(strategy) {
+    this.strategy = strategy;
+    this.redis = Redis.fromEnv();
+  }
+  async get(query, session, schema) {
+    let result = null;
+    const cacheInformation = this.strategy.get(query, session);
+    if (cacheInformation.canCache && cacheInformation.key) {
+      const unvalidated = await this.redis.get(cacheInformation.key);
+      const parsed = schema.safeParse(unvalidated);
+      if (parsed.success) {
+        result = parsed.data;
+      }
+    }
+    return result;
+  }
+  put(query, session, value) {
+    const cacheInformation = this.strategy.get(query, session);
+    if (cacheInformation.canCache && cacheInformation.key) {
+      this.redis.set(cacheInformation.key, value, { ex: cacheInformation.cacheDurationInSeconds });
+    }
+  }
+};
+
+// core/src/providers/base.provider.ts
+var BaseProvider = class {
+  constructor(schema, querySchema, mutationSchema) {
+    this.schema = schema;
+    this.querySchema = querySchema;
+    this.mutationSchema = mutationSchema;
+  }
+  /**
+   * Validates that the final domain model constructed by the provider
+   * fulfills the schema as defined. This will throw an exception.
+   */
+  assert(value) {
+    return this.schema.parse(value);
+  }
+  /**
+   * Creates a new model entity based on the schema defaults.
+   */
+  newModel() {
+    return this.schema.parse({});
+  }
+  /**
+   * Retrieves a set of entities matching the list of queries. The size of
+   * the resulting list WILL always match the size of the query list. The
+   * result list will never contain nulls or undefined. The order
+   * of the results will match the order of the queries.
+   */
+  async query(queries, session) {
+    const results = await this.fetch(queries, session);
+    for (const result of results) {
+      this.assert(result);
+    }
+    return results;
+  }
+  /**
+   * Executes the listed mutations in order and returns the final state
+   * resulting from that set of operations.
+   */
+  async mutate(mutations, session) {
+    const result = await this.process(mutations, session);
+    this.assert(result);
+    return result;
+  }
+};
+
+// core/src/providers/cart.provider.ts
+var CartProvider = class extends BaseProvider {
+};
+
+// core/src/providers/identity.provider.ts
+var IdentityProvider = class extends BaseProvider {
+};
+
+// core/src/providers/inventory.provider.ts
+var InventoryProvider = class extends BaseProvider {
+};
+
+// core/src/providers/price.provider.ts
+var PriceProvider = class extends BaseProvider {
+};
+
+// core/src/providers/product.provider.ts
+var ProductProvider = class extends BaseProvider {
+};
+
+// core/src/providers/search.provider.ts
+var SearchProvider = class extends BaseProvider {
+};
+
+// core/src/schemas/capabilities.schema.ts
+import { z } from "zod";
+var CapabilitiesSchema = z.looseInterface({
+  product: z.boolean(),
+  search: z.boolean(),
+  analytics: z.boolean(),
+  identity: z.boolean(),
+  cart: z.boolean(),
+  inventory: z.boolean(),
+  price: z.boolean()
+});
+
+// core/src/schemas/session.schema.ts
+import { z as z4 } from "zod";
+
+// core/src/schemas/models/identity.model.ts
+import { z as z3 } from "zod";
+
+// core/src/schemas/models/base.model.ts
+import { z as z2 } from "zod";
+var CacheInformationSchema = z2.looseInterface({
+  hit: z2.boolean().default(false),
+  key: z2.string().default("")
+});
+var MetaSchema = z2.looseInterface({
+  cache: CacheInformationSchema.default(() => CacheInformationSchema.parse({})),
+  placeholder: z2.boolean().default(false).describe("Whether or not the entity exists in a remote system, or is a default placeholder.")
+});
+var BaseModelSchema = z2.looseInterface({
+  meta: MetaSchema.default(() => MetaSchema.parse({}))
+});
+
+// core/src/schemas/models/identity.model.ts
+var IdentityTypeSchema = z3.enum(["Anonymous", "Guest", "Registered"]);
+var IdentitySchema = BaseModelSchema.extend({
+  id: z3.string().default(""),
+  type: IdentityTypeSchema.default("Anonymous"),
+  token: z3.string().optional(),
+  issued: z3.coerce.date().default(/* @__PURE__ */ new Date()),
+  expiry: z3.coerce.date().default(/* @__PURE__ */ new Date())
+});
+
+// core/src/schemas/session.schema.ts
+var SessionSchema = z4.looseObject({
+  id: z4.string(),
+  identity: IdentitySchema.default(() => IdentitySchema.parse({}))
+});
+
+// core/src/schemas/models/cart.model.ts
+import { z as z6 } from "zod";
+
+// core/src/schemas/models/identifiers.model.ts
+import { z as z5 } from "zod";
+var FacetIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("").nonoptional()
+});
+var FacetValueIdentifierSchema = z5.looseInterface({
+  facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+  key: z5.string().default("")
+});
+var SKUIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("").nonoptional()
+});
+var ProductIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var SearchIdentifierSchema = z5.looseInterface({
+  term: z5.string().default(""),
+  page: z5.number().default(0),
+  pageSize: z5.number().default(20),
+  facets: z5.array(FacetValueIdentifierSchema.required()).default(() => [])
+});
+var CartIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var CartItemIdentifierSchema = z5.looseInterface({
+  key: z5.string().default("")
+});
+var PriceIdentifierSchema = z5.looseInterface({
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
+});
+
+// core/src/schemas/models/cart.model.ts
+var CartItemSchema = z6.looseInterface({
+  identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
+  product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  quantity: z6.number().default(0)
+});
+var CartSchema = BaseModelSchema.extend({
+  identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  items: z6.array(CartItemSchema).default(() => [])
+});
+
+// core/src/schemas/models/currency.model.ts
+import { z as z7 } from "zod";
+var CurrencySchema = z7.enum([
+  "AED",
+  "AFN",
+  "ALL",
+  "AMD",
+  "ANG",
+  "AOA",
+  "ARS",
+  "AUD",
+  "AWG",
+  "AZN",
+  "BAM",
+  "BBD",
+  "BDT",
+  "BGN",
+  "BHD",
+  "BIF",
+  "BMD",
+  "BND",
+  "BOB",
+  "BOV",
+  "BRL",
+  "BSD",
+  "BTN",
+  "BWP",
+  "BYN",
+  "BZD",
+  "CAD",
+  "CDF",
+  "CHE",
+  "CHF",
+  "CHW",
+  "CLF",
+  "CLP",
+  "CNY",
+  "COP",
+  "COU",
+  "CRC",
+  "CUC",
+  "CUP",
+  "CVE",
+  "CZK",
+  "DJF",
+  "DKK",
+  "DOP",
+  "DZD",
+  "EGP",
+  "ERN",
+  "ETB",
+  "EUR",
+  "FJD",
+  "FKP",
+  "GBP",
+  "GEL",
+  "GHS",
+  "GIP",
+  "GMD",
+  "GNF",
+  "GTQ",
+  "GYD",
+  "HKD",
+  "HNL",
+  "HRK",
+  "HTG",
+  "HUF",
+  "IDR",
+  "ILS",
+  "INR",
+  "IQD",
+  "IRR",
+  "ISK",
+  "JMD",
+  "JOD",
+  "JPY",
+  "KES",
+  "KGS",
+  "KHR",
+  "KMF",
+  "KPW",
+  "KRW",
+  "KWD",
+  "KYD",
+  "KZT",
+  "LAK",
+  "LBP",
+  "LKR",
+  "LRD",
+  "LSL",
+  "LYD",
+  "MAD",
+  "MDL",
+  "MGA",
+  "MKD",
+  "MMK",
+  "MNT",
+  "MOP",
+  "MRU",
+  "MUR",
+  "MVR",
+  "MWK",
+  "MXN",
+  "MXV",
+  "MYR",
+  "MZN",
+  "NAD",
+  "NGN",
+  "NIO",
+  "NOK",
+  "NPR",
+  "NZD",
+  "OMR",
+  "PAB",
+  "PEN",
+  "PGK",
+  "PHP",
+  "PKR",
+  "PLN",
+  "PYG",
+  "QAR",
+  "RON",
+  "RSD",
+  "RUB",
+  "RWF",
+  "SAR",
+  "SBD",
+  "SCR",
+  "SDG",
+  "SEK",
+  "SGD",
+  "SHP",
+  "SLE",
+  "SLL",
+  "SOS",
+  "SRD",
+  "SSP",
+  "STN",
+  "SYP",
+  "SZL",
+  "THB",
+  "TJS",
+  "TMT",
+  "TND",
+  "TOP",
+  "TRY",
+  "TTD",
+  "TVD",
+  "TWD",
+  "TZS",
+  "UAH",
+  "UGX",
+  "USD",
+  "USN",
+  "UYI",
+  "UYU",
+  "UYW",
+  "UZS",
+  "VED",
+  "VES",
+  "VND",
+  "VUV",
+  "WST",
+  "XAF",
+  "XAG",
+  "XAU",
+  "XBA",
+  "XBB",
+  "XBC",
+  "XBD",
+  "XCD",
+  "XDR",
+  "XOF",
+  "XPD",
+  "XPF",
+  "XPT",
+  "XSU",
+  "XTS",
+  "XUA",
+  "XXX",
+  "YER",
+  "ZAR",
+  "ZMW",
+  "ZWL"
+]);
+
+// core/src/schemas/models/inventory.model.ts
+import { z as z8 } from "zod";
+var InventorySchema = BaseModelSchema.extend({
+  quantity: z8.number().default(0)
+});
+
+// core/src/schemas/models/price.model.ts
+import { z as z9 } from "zod";
+var MonetaryAmountSchema = z9.looseInterface({
+  cents: z9.number().default(0).describe("The monetary amount in cent-precision."),
+  currency: CurrencySchema.default("XXX").describe("The currency associated with the amount, as a ISO 4217 standardized code.")
+});
+var PriceSchema = BaseModelSchema.extend({
+  identifier: PriceIdentifierSchema.default(() => PriceIdentifierSchema.parse({})),
+  value: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({}))
+});
+
+// core/src/schemas/models/product.model.ts
+import { z as z10 } from "zod";
+var SKUSchema = z10.looseInterface({
+  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
+});
+var ProductAttributeSchema = z10.looseInterface({
+  id: z10.string(),
+  name: z10.string(),
+  value: z10.string()
+});
+var ProductSchema = BaseModelSchema.extend({
+  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  name: z10.string().default(""),
+  slug: z10.string().default(""),
+  description: z10.string().default(""),
+  image: z10.string().url().default("https://placehold.co/400"),
+  images: z10.string().url().array().default(() => []),
+  attributes: z10.array(ProductAttributeSchema).default(() => []),
+  skus: z10.array(SKUSchema).default(() => [])
+});
+
+// core/src/schemas/models/search.model.ts
+import { z as z11 } from "zod";
+var SearchResultProductSchema = z11.looseInterface({
+  identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  image: z11.string().url().default("https://placehold.co/400"),
+  slug: z11.string().default("")
+});
+var SearchResultFacetValueSchema = z11.looseInterface({
+  identifier: FacetValueIdentifierSchema.default(() => FacetValueIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  count: z11.number().default(0),
+  active: z11.boolean().default(false)
+});
+var SearchResultFacetSchema = z11.looseInterface({
+  identifier: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
+  name: z11.string().default(""),
+  values: z11.array(SearchResultFacetValueSchema).default(() => [])
+});
+var SearchResultSchema = BaseModelSchema.extend({
+  identifier: SearchIdentifierSchema.default(() => SearchIdentifierSchema.parse({})),
+  products: z11.array(SearchResultProductSchema).default(() => []),
+  pages: z11.number().default(0),
+  facets: z11.array(SearchResultFacetSchema).default(() => [])
+});
+
+// core/src/schemas/mutations/base.mutation.ts
+import { z as z12 } from "zod";
+var BaseMutationSchema = z12.looseInterface({
+  mutation: z12.ZodLiteral
+});
+
+// core/src/schemas/mutations/cart.mutation.ts
+import { z as z13 } from "zod";
+var CartMutationItemAddSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("add"),
+  cart: CartIdentifierSchema.required(),
+  product: ProductIdentifierSchema.required(),
+  quantity: z13.number()
+});
+var CartMutationItemRemoveSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("remove"),
+  cart: CartIdentifierSchema.required(),
+  item: CartItemIdentifierSchema.required()
+});
+var CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
+  mutation: z13.literal("adjustQuantity"),
+  cart: CartIdentifierSchema.required(),
+  item: CartItemIdentifierSchema.required(),
+  quantity: z13.number()
+});
+var CartMutationSchema = z13.union([CartMutationItemAddSchema, CartMutationItemRemoveSchema, CartMutationItemQuantityChangeSchema]);
+
+// core/src/schemas/mutations/identity.mutation.ts
+import { z as z14 } from "zod";
+var IdentityMutationLoginSchema = BaseMutationSchema.extend({
+  mutation: z14.literal("login"),
+  username: z14.string(),
+  password: z14.string()
+});
+var IdentityMutationLogoutSchema = BaseMutationSchema.extend({
+  mutation: z14.literal("logout")
+});
+var IdentityMutationSchema = z14.union([IdentityMutationLoginSchema, IdentityMutationLogoutSchema]);
+
+// core/src/schemas/mutations/inventory.mutation.ts
+import { z as z15 } from "zod";
+var InventoryMutationSchema = z15.union([]);
+
+// core/src/schemas/mutations/price.mutation.ts
+import { z as z16 } from "zod";
+var PriceMutationSchema = z16.union([]);
+
+// core/src/schemas/mutations/product.mutation.ts
+import { z as z17 } from "zod";
+var ProductMutationSchema = z17.union([]);
+
+// core/src/schemas/mutations/search.mutation.ts
+import { z as z18 } from "zod";
+var SearchMutationSchema = z18.union([]);
+
+// core/src/schemas/queries/base.query.ts
+import { z as z19 } from "zod";
+var BaseQuerySchema = z19.looseInterface({
+  query: z19.ZodLiteral
+});
+
+// core/src/schemas/queries/cart.query.ts
+import { z as z20 } from "zod";
+var CartQueryByIdSchema = BaseQuerySchema.extend({
+  query: z20.literal("id"),
+  cart: CartIdentifierSchema.required()
+});
+var CartQuerySchema = z20.union([CartQueryByIdSchema]);
+
+// core/src/schemas/queries/identity.query.ts
+import { z as z21 } from "zod";
+var IdentityQuerySelfSchema = BaseQuerySchema.extend({
+  query: z21.literal("self")
+});
+var IdentityQuerySchema = z21.union([IdentityQuerySelfSchema]);
+
+// core/src/schemas/queries/inventory.query.ts
+import { z as z22 } from "zod";
+var InventoryQuerySchema = BaseQuerySchema.extend({
+  query: z22.literal("sku"),
+  sku: z22.string()
+});
+
+// core/src/schemas/queries/price.query.ts
+import { z as z23 } from "zod";
+var PriceQueryBySkuSchema = BaseQuerySchema.extend({
+  query: z23.literal("sku"),
+  sku: SKUIdentifierSchema.required()
+});
+var PriceQuerySchema = z23.union([PriceQueryBySkuSchema]);
+
+// core/src/schemas/queries/product.query.ts
+import { z as z24 } from "zod";
+var ProductQueryBySlugSchema = BaseQuerySchema.extend({
+  query: z24.literal("slug"),
+  slug: z24.string()
+});
+var ProductQueryByIdSchema = BaseQuerySchema.extend({
+  query: z24.literal("id"),
+  id: z24.string()
+});
+var ProductQuerySchema = z24.union([ProductQueryBySlugSchema, ProductQueryByIdSchema]);
+
+// core/src/schemas/queries/search.query.ts
+import { z as z25 } from "zod";
+var SearchQueryByTermSchema = BaseQuerySchema.extend({
+  query: z25.literal("term"),
+  search: SearchIdentifierSchema.required()
+});
+var SearchQuerySchema = z25.union([SearchQueryByTermSchema]);
+
+// providers/commercetools/src/providers/search.provider.ts
+var CommercetoolsSearchProvider = class extends SearchProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const results = [];
+    for (const query of queries) {
+      const result = await this.get(query.search);
+      results.push(result);
+    }
+    return results;
+  }
+  process(mutations, session) {
+    throw new Error("Method not implemented.");
+  }
+  async get(identifier) {
+    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).productProjections().search().get({
+      queryArgs: {
+        limit: identifier.pageSize,
+        offset: identifier.pageSize * identifier.page,
+        ["text.en-US"]: identifier.term
+      }
+    }).execute();
+    const parsed = this.parse(remote, identifier);
+    return parsed;
+  }
+  parse(remote, query) {
+    const result = super.newModel();
+    result.identifier = query;
+    for (const p of remote.body.results) {
+      const product = SearchResultProductSchema.parse({});
+      product.identifier.key = p.id;
+      product.name = p.name["en-US"];
+      if (p.masterVariant.images) {
+        product.image = p.masterVariant.images[0].url;
+      }
+      result.products.push(product);
+    }
+    result.pages = Math.ceil((remote.body.total || 0) / query.pageSize);
+    return result;
+  }
+};
+
+// providers/commercetools/src/providers/product.provider.ts
+var CommercetoolsProductProvider = class extends ProductProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const ids = queries.filter((x) => x.query === "id").map((x) => x.id);
+    const slugs = queries.filter((x) => x.query === "slug").map((x) => x.slug);
+    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).productProjections().get({
+      queryArgs: {
+        where: "slug(en-US in :slugs)",
+        "var.slugs": slugs
+      }
+    }).execute();
+    console.log("remote: ", remote);
+    const results = new Array();
+    for (const r of remote.body.results) {
+      const result = this.parse(r);
+      results.push(result);
+    }
+    return results;
+  }
+  process(mutation, session) {
+    throw new Error("Method not implemented.");
+  }
+  parse(data) {
+    const base = this.newModel();
+    base.identifier.key = data.id;
+    base.name = data.name["en-US"];
+    base.slug = data.slug["en-US"];
+    if (data.description) {
+      base.description = data.description["en-US"];
+    }
+    if (data.masterVariant.images) {
+      base.image = data.masterVariant.images[0].url;
+    }
+    const variants = [data.masterVariant, ...data.variants];
+    for (const variant of variants) {
+      base.skus.push({
+        identifier: {
+          key: variant.sku || ""
+        }
+      });
+    }
+    return base;
+  }
+};
+
+// providers/commercetools/src/providers/identity.provider.ts
+var CommercetoolsIdentityProvider = class extends IdentityProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const results = [];
+    for (const query of queries) {
+      const result = await this.get(session);
+      results.push(result);
+    }
+    return results;
+  }
+  async process(mutations, session) {
+    let result = this.newModel();
+    for (const mutation of mutations) {
+      switch (mutation.mutation) {
+        case "login":
+          result = await this.login(mutation, session);
+          break;
+        case "logout":
+          result = await this.logout(session);
+          break;
+      }
+    }
+    return result;
+  }
+  async get(session) {
+    const client = new CommercetoolsClient(this.config);
+    const base = this.newModel();
+    if (session.identity.token) {
+      const remote = await client.introspect(session.identity.token);
+      if (remote.active) {
+        const current = this.schema.safeParse(session.identity);
+        if (current.success) {
+          return current.data;
+        }
+      }
+    }
+    session.identity = base;
+    return base;
+  }
+  async login(payload, session) {
+    const client = new CommercetoolsClient(this.config);
+    const remote = await client.login(payload.username, payload.password);
+    const base = this.newModel();
+    if (remote && remote.access_token) {
+      base.issued = /* @__PURE__ */ new Date();
+      base.expiry = /* @__PURE__ */ new Date();
+      base.expiry.setSeconds(base.expiry.getSeconds() + remote.expires_in);
+      base.id = this.extractCustomerIdFromScopes(remote.scope);
+      base.token = remote.access_token;
+      base.type = "Registered";
+    }
+    session.identity = base;
+    return base;
+  }
+  async logout(session) {
+    const client = new CommercetoolsClient(this.config);
+    const base = this.newModel();
+    if (session.identity.token) {
+      const remote = await client.logout(session.identity.token);
+    }
+    session.identity = base;
+    return base;
+  }
+  extractCustomerIdFromScopes(scopes) {
+    const scopeList = scopes.split(" ");
+    const customerScope = scopeList.find((x) => x.startsWith("customer_id"));
+    const id = customerScope?.split(":")[1];
+    return id || "";
+  }
+};
+
+// providers/commercetools/src/providers/cart.provider.ts
+var CommercetoolsCartProvider = class extends CartProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const results = [];
+    for (const query of queries) {
+      if (query.cart.key) {
+        const client = this.getClient(session);
+        const remote = await client.withId({ ID: query.cart.key }).get().execute();
+        const result = this.composeCart(remote.body);
+        results.push(result);
+      }
+    }
+    return results;
+  }
+  async process(mutations, session) {
+    let cart = this.newModel();
+    for (const mutation of mutations) {
+      switch (mutation.mutation) {
+        case "add":
+          cart = await this.add(mutation, session);
+          break;
+        case "adjustQuantity":
+          cart = await this.adjust(mutation, session);
+          break;
+        case "remove":
+          cart = await this.remove(mutation, session);
+      }
+    }
+    return cart;
+  }
+  async adjust(payload, session) {
+    const client = this.getClient(session);
+    const existing = await client.withId({ ID: payload.cart.key }).get().execute();
+    const remote = await client.withId({ ID: payload.cart.key }).post({
+      body: {
+        version: existing.body.version,
+        actions: [
+          {
+            action: "changeLineItemQuantity",
+            lineItemId: payload.item.key,
+            quantity: payload.quantity
+          }
+        ]
+      }
+    }).execute();
+    const result = this.composeCart(remote.body);
+    return result;
+  }
+  async add(payload, session) {
+    const client = this.getClient(session);
+    let id = payload.cart.key;
+    let version = 0;
+    if (!id) {
+      const remoteCart = await client.post({
+        body: {
+          currency: "USD",
+          country: "US"
+        }
+      }).execute();
+      id = remoteCart.body.id;
+      version = remoteCart.body.version;
+    } else {
+      const existing = await client.withId({ ID: payload.cart.key }).get().execute();
+      version = existing.body.version;
+    }
+    const remoteAdd = await client.withId({ ID: id }).post({
+      body: {
+        version,
+        actions: [
+          {
+            action: "addLineItem",
+            quantity: payload.quantity,
+            productId: payload.product.key
+          }
+        ]
+      }
+    }).execute();
+    const result = this.composeCart(remoteAdd.body);
+    return result;
+  }
+  async remove(payload, session) {
+    const client = this.getClient(session);
+    const existing = await client.withId({ ID: payload.cart.key }).get().execute();
+    const remote = await client.withId({ ID: payload.cart.key }).post({
+      body: {
+        version: existing.body.version,
+        actions: [
+          {
+            action: "removeLineItem",
+            lineItemId: payload.item.key
+          }
+        ]
+      }
+    }).execute();
+    const result = this.composeCart(remote.body);
+    return result;
+  }
+  getClient(session) {
+    const client = new CommercetoolsClient(this.config).getClient(
+      session.identity.token
+    );
+    const cartClient = client.withProjectKey({ projectKey: this.config.projectKey }).carts();
+    return cartClient;
+  }
+  composeCart(remote) {
+    const result = this.newModel();
+    result.identifier.key = remote.id;
+    for (const remoteItem of remote.lineItems) {
+      const item = CartItemSchema.parse({});
+      item.identifier.key = remoteItem.id;
+      item.product.key = remoteItem.productId;
+      item.quantity = remoteItem.quantity;
+      result.items.push(item);
+    }
+    return result;
+  }
+};
+
+// providers/commercetools/src/providers/inventory.provider.ts
+var CommercetoolsInventoryProvider = class extends InventoryProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.cache = new RedisCache(new BaseCachingStrategy());
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const results = [];
+    for (const query of queries) {
+      let result = await this.cache.get(query, session, this.schema);
+      console.log("from cache: ", result);
+      if (!result) {
+        result = await this.get(query, session);
+        this.cache.put(query, session, result);
+      }
+      results.push(result);
+    }
+    return results;
+  }
+  process(mutations, session) {
+    throw new Error("Method not implemented.");
+  }
+  async get(query, session) {
+    const client = new CommercetoolsClient(this.config).getClient(
+      session.identity?.token
+    );
+    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).inventory().get({
+      queryArgs: {
+        where: "sku=:sku",
+        "var.sku": query.sku
+      }
+    }).execute();
+    const base = this.newModel();
+    if (remote.body.results.length > 0) {
+      const inv = remote.body.results[0];
+      base.quantity = inv.availableQuantity;
+    }
+    return base;
+  }
+};
+
+// providers/commercetools/src/providers/price.provider.ts
+var CommercetoolsPriceProvider = class extends PriceProvider {
+  constructor(config, schema, querySchema, mutationSchema) {
+    super(schema, querySchema, mutationSchema);
+    this.config = config;
+  }
+  async fetch(queries, session) {
+    const client = new CommercetoolsClient(this.config).getClient(
+      session.identity?.token
+    );
+    const queryArgs = {
+      where: "sku in :skus",
+      "var.skus": queries.map((x) => x.sku.key)
+    };
+    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).standalonePrices().get({
+      queryArgs
+    }).execute();
+    const results = new Array();
+    for (const query of queries) {
+      const base = this.newModel();
+      const matched = remote.body.results.find((x) => x.sku === query.sku.key);
+      if (matched) {
+        base.value = {
+          cents: matched.value.centAmount,
+          currency: "USD"
+        };
+      }
+      base.identifier = {
+        sku: {
+          key: query.sku.key
+        }
+      };
+      results.push(base);
+    }
+    return results;
+  }
+  process(mutation, session) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// providers/commercetools/src/core/initialize.ts
+function withCommercetoolsCapabilities(configuration, capabilities) {
+  const client = {};
+  if (capabilities.product) {
+    client.product = new CommercetoolsProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
+  }
+  if (capabilities.search) {
+    client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
+  }
+  if (capabilities.identity) {
+    client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
+  }
+  if (capabilities.cart) {
+    client.cart = new CommercetoolsCartProvider(configuration, CartSchema, CartQuerySchema, CartMutationSchema);
+  }
+  if (capabilities.inventory) {
+    client.inventory = new CommercetoolsInventoryProvider(configuration, InventorySchema, InventoryQuerySchema, InventoryMutationSchema);
+  }
+  if (capabilities.price) {
+    client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, PriceQuerySchema, PriceMutationSchema);
+  }
+  return client;
+}
+
+// providers/commercetools/src/schema/capabilities.schema.ts
+var CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
+  product: true,
+  search: true,
+  identity: true,
+  cart: true,
+  inventory: true,
+  price: true
+}).partial();
+
+// providers/commercetools/src/schema/configuration.schema.ts
+import { z as z26 } from "zod";
+var CommercetoolsConfigurationSchema = z26.looseInterface({
+  projectKey: z26.string(),
+  authUrl: z26.string(),
+  apiUrl: z26.string(),
+  clientId: z26.string(),
+  clientSecret: z26.string()
+});
+export {
+  CommercetoolsCapabilitiesSchema,
+  CommercetoolsCartProvider,
+  CommercetoolsClient,
+  CommercetoolsConfigurationSchema,
+  CommercetoolsIdentityProvider,
+  CommercetoolsInventoryProvider,
+  CommercetoolsPriceProvider,
+  CommercetoolsProductProvider,
+  CommercetoolsSearchProvider,
+  withCommercetoolsCapabilities
+};

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@reactionary/provider-commercetools",
+  "version": "0.0.27",
+  "dependencies": {
+    "@reactionary/core": "0.0.27",
+    "zod": "4.0.0-beta.20250430T185432",
+    "@commercetools/ts-client": "^3.2.2",
+    "@commercetools/platform-sdk": "^8.8.0"
+  }
+}

package/src/core/client.d.ts

@@ -0,0 +1,14 @@
+import { ClientBuilder } from '@commercetools/ts-client';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+export declare class CommercetoolsClient {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration);
+    getClient(token?: string): import("@commercetools/platform-sdk").ApiRoot;
+    login(username: string, password: string): Promise<any>;
+    guest(): Promise<any>;
+    logout(token: string): Promise<Response>;
+    introspect(token: string): Promise<any>;
+    createAnonymousClient(): import("@commercetools/platform-sdk").ApiRoot;
+    protected createClientWithToken(token: string): import("@commercetools/platform-sdk").ApiRoot;
+    protected createBaseClientBuilder(): ClientBuilder;
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,4 @@
+import { Client } from "@reactionary/core";
+import { CommercetoolsCapabilities } from "../schema/capabilities.schema";
+import { CommercetoolsConfiguration } from "../schema/configuration.schema";
+export declare function withCommercetoolsCapabilities(configuration: CommercetoolsConfiguration, capabilities: CommercetoolsCapabilities): Partial<Client>;

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from './core/client';
+export * from './core/initialize';
+export * from './providers/cart.provider';
+export * from './providers/identity.provider';
+export * from './providers/inventory.provider';
+export * from './providers/price.provider';
+export * from './providers/product.provider';
+export * from './providers/search.provider';
+export * from './schema/capabilities.schema';
+export * from './schema/configuration.schema';

package/src/providers/cart.provider.d.ts

@@ -0,0 +1,15 @@
+import { Cart, CartMutation, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartProvider, CartQuery, Session } from '@reactionary/core';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { z } from 'zod';
+import { Cart as CTCart } from '@commercetools/platform-sdk';
+export declare class CommercetoolsCartProvider<T extends Cart = Cart, Q extends CartQuery = CartQuery, M extends CartMutation = CartMutation> extends CartProvider<T, Q, M> {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutations: M[], session: Session): Promise<T>;
+    protected adjust(payload: CartMutationItemQuantityChange, session: Session): Promise<T>;
+    protected add(payload: CartMutationItemAdd, session: Session): Promise<T>;
+    protected remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
+    protected getClient(session: Session): import("@commercetools/platform-sdk").ByProjectKeyCartsRequestBuilder;
+    protected composeCart(remote: CTCart): T;
+}

package/src/providers/identity.provider.d.ts

@@ -0,0 +1,13 @@
+import { Identity, IdentityMutation, IdentityMutationLogin, IdentityProvider, IdentityQuery, Session } from '@reactionary/core';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import z from 'zod';
+export declare class CommercetoolsIdentityProvider<T extends Identity = Identity, Q extends IdentityQuery = IdentityQuery, M extends IdentityMutation = IdentityMutation> extends IdentityProvider<T, Q, M> {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutations: M[], session: Session): Promise<T>;
+    protected get(session: Session): Promise<T>;
+    protected login(payload: IdentityMutationLogin, session: Session): Promise<T>;
+    protected logout(session: Session): Promise<T>;
+    protected extractCustomerIdFromScopes(scopes: string): string;
+}

package/src/providers/inventory.provider.d.ts

@@ -0,0 +1,12 @@
+import { Inventory, InventoryProvider, InventoryQuery, RedisCache, Session } from '@reactionary/core';
+import z from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { InventoryMutation } from 'core/src/schemas/mutations/inventory.mutation';
+export declare class CommercetoolsInventoryProvider<T extends Inventory = Inventory, Q extends InventoryQuery = InventoryQuery, M extends InventoryMutation = InventoryMutation> extends InventoryProvider<T, Q, M> {
+    protected config: CommercetoolsConfiguration;
+    protected cache: RedisCache;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutations: M[], session: Session): Promise<T>;
+    protected get(query: Q, session: Session): Promise<T>;
+}

package/src/providers/price.provider.d.ts

@@ -0,0 +1,10 @@
+import { BaseMutation, Price, PriceProvider, PriceQuery, Session } from '@reactionary/core';
+import z from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { PriceMutation } from 'core/src/schemas/mutations/price.mutation';
+export declare class CommercetoolsPriceProvider<T extends Price = Price, Q extends PriceQuery = PriceQuery, M extends PriceMutation = PriceMutation> extends PriceProvider<T, Q, M> {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutation: BaseMutation[], session: Session): Promise<T>;
+}

package/src/providers/product.provider.d.ts

@@ -0,0 +1,11 @@
+import { ProductProvider, ProductQuery, Product, Session, BaseMutation, ProductMutation } from '@reactionary/core';
+import { z } from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { ProductProjection } from '@commercetools/platform-sdk';
+export declare class CommercetoolsProductProvider<T extends Product = Product, Q extends ProductQuery = ProductQuery, M extends ProductMutation = ProductMutation> extends ProductProvider<T, Q, M> {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: ProductQuery[], session: Session): Promise<T[]>;
+    protected process(mutation: BaseMutation[], session: Session): Promise<T>;
+    protected parse(data: ProductProjection): T;
+}

package/src/providers/search.provider.d.ts

@@ -0,0 +1,11 @@
+import { SearchIdentifier, SearchMutation, SearchProvider, SearchQuery, SearchResult, Session } from '@reactionary/core';
+import z from 'zod';
+import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+export declare class CommercetoolsSearchProvider<T extends SearchResult = SearchResult, Q extends SearchQuery = SearchQuery, M extends SearchMutation = SearchMutation> extends SearchProvider<T, Q, M> {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>);
+    protected fetch(queries: Q[], session: Session): Promise<T[]>;
+    protected process(mutations: M[], session: Session): Promise<T>;
+    get(identifier: SearchIdentifier): Promise<T>;
+    parse(remote: any, query: SearchIdentifier): T;
+}

package/src/schema/capabilities.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const CommercetoolsCapabilitiesSchema: z.ZodInterface<{
+    identity: z.ZodOptional<z.ZodBoolean>;
+    search: z.ZodOptional<z.ZodBoolean>;
+    product: z.ZodOptional<z.ZodBoolean>;
+    cart: z.ZodOptional<z.ZodBoolean>;
+    price: z.ZodOptional<z.ZodBoolean>;
+    inventory: z.ZodOptional<z.ZodBoolean>;
+}, {
+    optional: "identity" | "search" | "product" | "cart" | "price" | "inventory";
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;

package/src/schema/configuration.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const CommercetoolsConfigurationSchema: z.ZodInterface<{
+    projectKey: z.ZodString;
+    authUrl: z.ZodString;
+    apiUrl: z.ZodString;
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;