@reactionary/provider-commercetools 0.0.30 → 0.0.32

package/index.js

@@ -113,283 +113,19 @@ var CommercetoolsClient = class {
   }
 };
 
-// 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 });
-    }
-  }
-};
-
-// otel/src/trpc-middleware.ts
-import { TRPCError } from "@trpc/server";
-import {
-  SpanKind as SpanKind2,
-  SpanStatusCode as SpanStatusCode3
-} from "@opentelemetry/api";
-
-// otel/src/tracer.ts
-import {
-  trace,
-  SpanStatusCode,
-  context as otelContext
-} from "@opentelemetry/api";
-
-// otel/src/sdk.ts
-import { NodeSDK } from "@opentelemetry/sdk-node";
-var sdk = null;
-var isInitialized = false;
-var initializationPromise = null;
-function isBrowser() {
-  return typeof window !== "undefined" && typeof process === "undefined";
-}
-function ensureInitialized() {
-  if (isInitialized || initializationPromise) {
-    return;
-  }
-  if (isBrowser()) {
-    isInitialized = true;
-    return;
-  }
-  initializationPromise = Promise.resolve().then(() => {
-    sdk = new NodeSDK();
-    sdk.start();
-    isInitialized = true;
-    process.on("SIGTERM", async () => {
-      try {
-        await shutdownOtel();
-        if (process.env["OTEL_LOG_LEVEL"] === "debug") {
-          console.log("OpenTelemetry terminated successfully");
-        }
-      } catch (error) {
-        console.error("Error terminating OpenTelemetry", error);
-      }
-    });
-  });
-}
-async function shutdownOtel() {
-  if (sdk) {
-    await sdk.shutdown();
-    sdk = null;
-    isInitialized = false;
-  }
-}
-function isOtelInitialized() {
-  ensureInitialized();
-  return isInitialized;
-}
 
-// otel/src/tracer.ts
-import { SpanKind, SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
-var TRACER_NAME = "@reactionary/otel";
-var TRACER_VERSION = "0.0.1";
-var globalTracer = null;
-function getTracer() {
-  if (!globalTracer) {
-    isOtelInitialized();
-    globalTracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
-  }
-  return globalTracer;
-}
-function withSpan(name, fn, options) {
-  const tracer = getTracer();
-  return tracer.startActiveSpan(name, options || {}, async (span) => {
-    try {
-      const result = await fn(span);
-      span.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      if (error instanceof Error) {
-        span.recordException(error);
-      }
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-}
-function setSpanAttributes(span, attributes) {
-  Object.entries(attributes).forEach(([key, value]) => {
-    if (value !== void 0 && value !== null) {
-      span.setAttribute(key, value);
-    }
-  });
-}
-
-// otel/src/metrics.ts
-import { metrics } from "@opentelemetry/api";
-var METER_NAME = "@reactionary/otel";
-var METER_VERSION = "0.0.1";
-var globalMeter = null;
-function getMeter() {
-  if (!globalMeter) {
-    isOtelInitialized();
-    globalMeter = metrics.getMeter(METER_NAME, METER_VERSION);
-  }
-  return globalMeter;
-}
-var metricsInstance = null;
-function initializeMetrics() {
-  if (metricsInstance) {
-    return metricsInstance;
-  }
-  const meter = getMeter();
-  metricsInstance = {
-    requestCounter: meter.createCounter("reactionary.requests", {
-      description: "Total number of requests"
-    }),
-    requestDuration: meter.createHistogram("reactionary.request.duration", {
-      description: "Request duration in milliseconds",
-      unit: "ms"
-    }),
-    activeRequests: meter.createUpDownCounter("reactionary.requests.active", {
-      description: "Number of active requests"
-    }),
-    errorCounter: meter.createCounter("reactionary.errors", {
-      description: "Total number of errors"
-    }),
-    providerCallCounter: meter.createCounter("reactionary.provider.calls", {
-      description: "Total number of provider calls"
-    }),
-    providerCallDuration: meter.createHistogram("reactionary.provider.duration", {
-      description: "Provider call duration in milliseconds",
-      unit: "ms"
-    }),
-    cacheHitCounter: meter.createCounter("reactionary.cache.hits", {
-      description: "Total number of cache hits"
-    }),
-    cacheMissCounter: meter.createCounter("reactionary.cache.misses", {
-      description: "Total number of cache misses"
-    })
-  };
-  return metricsInstance;
-}
-function getMetrics() {
-  if (!metricsInstance) {
-    return initializeMetrics();
-  }
-  return metricsInstance;
-}
-
-// otel/src/provider-instrumentation.ts
-import { SpanKind as SpanKind3 } from "@opentelemetry/api";
-async function withProviderSpan(options, fn) {
-  const { providerName, operationType, operationName, attributes = {} } = options;
-  const metrics2 = getMetrics();
-  const spanName = `provider.${providerName}.${operationType}${operationName ? `.${operationName}` : ""}`;
-  const startTime = Date.now();
-  metrics2.providerCallCounter.add(1, {
-    "provider.name": providerName,
-    "provider.operation.type": operationType,
-    "provider.operation.name": operationName || "unknown"
-  });
-  return withSpan(
-    spanName,
-    async (span) => {
-      setSpanAttributes(span, {
-        "provider.name": providerName,
-        "provider.operation.type": operationType,
-        "provider.operation.name": operationName,
-        ...attributes
-      });
-      try {
-        const result = await fn(span);
-        const duration = Date.now() - startTime;
-        metrics2.providerCallDuration.record(duration, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown",
-          "status": "success"
-        });
-        return result;
-      } catch (error) {
-        const duration = Date.now() - startTime;
-        metrics2.providerCallDuration.record(duration, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown",
-          "status": "error"
-        });
-        metrics2.errorCounter.add(1, {
-          "provider.name": providerName,
-          "provider.operation.type": operationType,
-          "provider.operation.name": operationName || "unknown"
-        });
-        throw error;
-      }
-    },
-    { kind: SpanKind3.CLIENT }
-  );
-}
-function createProviderInstrumentation(providerName) {
-  return {
-    traceQuery: (operationName, fn, attributes) => {
-      return withProviderSpan(
-        {
-          providerName,
-          operationType: "query",
-          operationName,
-          attributes
-        },
-        fn
-      );
-    },
-    traceMutation: (operationName, fn, attributes) => {
-      return withProviderSpan(
-        {
-          providerName,
-          operationType: "mutation",
-          operationName,
-          attributes
-        },
-        fn
-      );
-    }
-  };
-}
+// core/src/decorators/trpc.decorators.ts
+import "reflect-metadata";
+var TRPC_QUERY_METADATA_KEY = Symbol("trpc:query");
+var TRPC_MUTATION_METADATA_KEY = Symbol("trpc:mutation");
 
 // core/src/providers/base.provider.ts
 var BaseProvider = class {
-  constructor(schema, querySchema, mutationSchema) {
+  constructor(schema, cache) {
     this.schema = schema;
-    this.querySchema = querySchema;
-    this.mutationSchema = mutationSchema;
-    this.instrumentation = createProviderInstrumentation(this.constructor.name);
+    this.cache = cache;
   }
   /**
    * Validates that the final domain model constructed by the provider
@@ -405,41 +141,12 @@ var BaseProvider = class {
     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.
+   * Handler for parsing a response from a remote provider and converting it
+   * into the typed domain model.
    */
-  async query(queries, session) {
-    return this.instrumentation.traceQuery(
-      "query",
-      async (span) => {
-        span.setAttribute("provider.query.count", queries.length);
-        const results = await this.fetch(queries, session);
-        for (const result of results) {
-          this.assert(result);
-        }
-        span.setAttribute("provider.result.count", results.length);
-        return results;
-      },
-      { queryCount: queries.length }
-    );
-  }
-  /**
-   * Executes the listed mutations in order and returns the final state
-   * resulting from that set of operations.
-   */
-  async mutate(mutations, session) {
-    return this.instrumentation.traceMutation(
-      "mutate",
-      async (span) => {
-        span.setAttribute("provider.mutation.count", mutations.length);
-        const result = await this.process(mutations, session);
-        this.assert(result);
-        return result;
-      },
-      { mutationCount: mutations.length }
-    );
+  parseSingle(_body) {
+    const model = this.newModel();
+    return this.assert(model);
   }
 };
 
@@ -812,42 +519,32 @@ var SearchResultSchema = BaseModelSchema.extend({
 
 // core/src/schemas/mutations/base.mutation.ts
 import { z as z12 } from "zod";
-var BaseMutationSchema = z12.looseInterface({
-  mutation: z12.ZodLiteral
-});
+var BaseMutationSchema = z12.looseInterface({});
 
 // 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]);
+var IdentityMutationLogoutSchema = BaseMutationSchema.extend({});
 
 // core/src/schemas/mutations/inventory.mutation.ts
 import { z as z15 } from "zod";
@@ -867,185 +564,143 @@ var SearchMutationSchema = z18.union([]);
 
 // core/src/schemas/queries/base.query.ts
 import { z as z19 } from "zod";
-var BaseQuerySchema = z19.looseInterface({
-  query: z19.ZodLiteral
-});
+var BaseQuerySchema = z19.looseInterface({});
 
 // 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]);
+var IdentityQuerySelfSchema = BaseQuerySchema.extend({});
 
 // core/src/schemas/queries/inventory.query.ts
-import { z as z22 } from "zod";
+import { z as z21 } from "zod";
 var InventoryQuerySchema = BaseQuerySchema.extend({
-  query: z22.literal("sku"),
-  sku: z22.string()
+  sku: z21.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";
+import { z as z22 } from "zod";
 var ProductQueryBySlugSchema = BaseQuerySchema.extend({
-  query: z24.literal("slug"),
-  slug: z24.string()
+  slug: z22.string()
 });
 var ProductQueryByIdSchema = BaseQuerySchema.extend({
-  query: z24.literal("id"),
-  id: z24.string()
+  id: z22.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);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     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) {
+  async queryByTerm(payload, _session) {
     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
+        limit: payload.search.pageSize,
+        offset: payload.search.pageSize * payload.search.page,
+        ["text.en-US"]: payload.search.term
       }
     }).execute();
-    const parsed = this.parse(remote, identifier);
-    return parsed;
+    return this.parseSearchResult(remote, payload);
   }
-  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;
-      }
+  parseSearchResult(remote, payload) {
+    const result = this.newModel();
+    const remoteData = remote;
+    result.identifier = payload.search;
+    for (const p of remoteData.body.results) {
+      const product = {
+        identifier: { key: p.id },
+        name: p.name["en-US"],
+        slug: p.slug?.["en-US"] || p.id,
+        image: p.masterVariant.images?.[0]?.url || "https://placehold.co/400"
+      };
       result.products.push(product);
     }
-    result.pages = Math.ceil((remote.body.total || 0) / query.pageSize);
-    return result;
+    result.pages = Math.ceil((remoteData.body.total || 0) / payload.search.pageSize);
+    result.meta = {
+      cache: { hit: false, key: payload.search.term },
+      placeholder: false
+    };
+    return this.assert(result);
   }
 };
 
 // providers/commercetools/src/providers/product.provider.ts
 var CommercetoolsProductProvider = class extends ProductProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     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);
+  async getById(payload, _session) {
+    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).productProjections().withId({ ID: payload.id }).get().execute();
+    return this.parse(remote.body);
+  }
+  async getBySlug(payload, _session) {
     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
+        where: "slug(en-US = :slug)",
+        "var.slug": payload.slug
       }
     }).execute();
-    console.log("remote: ", remote);
-    const results = new Array();
-    for (const r of remote.body.results) {
-      const result = this.parse(r);
-      results.push(result);
+    if (remote.body.results.length === 0) {
+      throw new Error(`Product with slug '${payload.slug}' not found`);
     }
-    return results;
-  }
-  process(mutation, session) {
-    throw new Error("Method not implemented.");
+    return this.parse(remote.body.results[0]);
   }
   parse(data) {
     const base = this.newModel();
-    base.identifier.key = data.id;
+    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) {
+    if (data.masterVariant.images && data.masterVariant.images.length > 0) {
       base.image = data.masterVariant.images[0].url;
     }
+    base.images = [];
+    base.attributes = [];
+    base.skus = [];
     const variants = [data.masterVariant, ...data.variants];
     for (const variant of variants) {
-      base.skus.push({
-        identifier: {
-          key: variant.sku || ""
-        }
-      });
+      if (variant.sku) {
+        base.skus.push({
+          identifier: { key: variant.sku }
+        });
+      }
     }
-    return base;
+    base.meta = {
+      cache: { hit: false, key: data.id },
+      placeholder: false
+    };
+    return this.assert(base);
   }
 };
 
 // providers/commercetools/src/providers/identity.provider.ts
 var CommercetoolsIdentityProvider = class extends IdentityProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     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) {
+  async getSelf(payload, session) {
     const client = new CommercetoolsClient(this.config);
     const base = this.newModel();
     if (session.identity.token) {
@@ -1053,12 +708,20 @@ var CommercetoolsIdentityProvider = class extends IdentityProvider {
       if (remote.active) {
         const current = this.schema.safeParse(session.identity);
         if (current.success) {
+          current.data.meta = {
+            cache: { hit: false, key: session.identity.id || "anonymous" },
+            placeholder: false
+          };
           return current.data;
         }
       }
     }
+    base.meta = {
+      cache: { hit: false, key: "anonymous" },
+      placeholder: false
+    };
     session.identity = base;
-    return base;
+    return this.assert(base);
   }
   async login(payload, session) {
     const client = new CommercetoolsClient(this.config);
@@ -1072,17 +735,25 @@ var CommercetoolsIdentityProvider = class extends IdentityProvider {
       base.token = remote.access_token;
       base.type = "Registered";
     }
+    base.meta = {
+      cache: { hit: false, key: base.id || "anonymous" },
+      placeholder: false
+    };
     session.identity = base;
-    return base;
+    return this.assert(base);
   }
-  async logout(session) {
+  async logout(payload, session) {
     const client = new CommercetoolsClient(this.config);
     const base = this.newModel();
     if (session.identity.token) {
-      const remote = await client.logout(session.identity.token);
+      await client.logout(session.identity.token);
     }
+    base.meta = {
+      cache: { hit: false, key: "anonymous" },
+      placeholder: false
+    };
     session.identity = base;
-    return base;
+    return this.assert(base);
   }
   extractCustomerIdFromScopes(scopes) {
     const scopeList = scopes.split(" ");
@@ -1094,55 +765,22 @@ var CommercetoolsIdentityProvider = class extends IdentityProvider {
 
 // providers/commercetools/src/providers/cart.provider.ts
 var CommercetoolsCartProvider = class extends CartProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     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);
-      }
+  async getById(payload, session) {
+    if (!payload.cart.key) {
+      const result = this.newModel();
+      result.meta = {
+        cache: { hit: false, key: "empty" },
+        placeholder: true
+      };
+      return this.assert(result);
     }
-    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;
+    const remote = await client.withId({ ID: payload.cart.key }).get().execute();
+    return this.composeCart(remote.body);
   }
   async add(payload, session) {
     const client = this.getClient(session);
@@ -1173,8 +811,7 @@ var CommercetoolsCartProvider = class extends CartProvider {
         ]
       }
     }).execute();
-    const result = this.composeCart(remoteAdd.body);
-    return result;
+    return this.composeCart(remoteAdd.body);
   }
   async remove(payload, session) {
     const client = this.getClient(session);
@@ -1190,8 +827,24 @@ var CommercetoolsCartProvider = class extends CartProvider {
         ]
       }
     }).execute();
-    const result = this.composeCart(remote.body);
-    return result;
+    return this.composeCart(remote.body);
+  }
+  async changeQuantity(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();
+    return this.composeCart(remote.body);
   }
   getClient(session) {
     const client = new CommercetoolsClient(this.config).getClient(
@@ -1210,41 +863,28 @@ var CommercetoolsCartProvider = class extends CartProvider {
       item.quantity = remoteItem.quantity;
       result.items.push(item);
     }
-    return result;
+    result.meta = {
+      cache: { hit: false, key: remote.id },
+      placeholder: false
+    };
+    return this.assert(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());
+  constructor(config, schema, cache) {
+    super(schema, cache);
     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) {
+  async getBySKU(payload, 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
+        "var.sku": payload.sku
       }
     }).execute();
     const base = this.newModel();
@@ -1252,73 +892,76 @@ var CommercetoolsInventoryProvider = class extends InventoryProvider {
       const inv = remote.body.results[0];
       base.quantity = inv.availableQuantity;
     }
-    return base;
+    base.meta = {
+      cache: { hit: false, key: payload.sku },
+      placeholder: false
+    };
+    return this.assert(base);
   }
 };
 
 // providers/commercetools/src/providers/price.provider.ts
 var CommercetoolsPriceProvider = class extends PriceProvider {
-  constructor(config, schema, querySchema, mutationSchema) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     this.config = config;
   }
-  async fetch(queries, session) {
+  async getBySKU(payload, 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)
+      where: "sku=:sku",
+      "var.sku": payload.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
-        }
+    const base = this.newModel();
+    if (remote.body.results.length > 0) {
+      const matched = remote.body.results[0];
+      base.value = {
+        cents: matched.value.centAmount,
+        currency: "USD"
       };
-      results.push(base);
     }
-    return results;
-  }
-  process(mutation, session) {
-    throw new Error("Method not implemented.");
+    base.identifier = {
+      sku: {
+        key: payload.sku.key
+      }
+    };
+    base.meta = {
+      cache: { hit: false, key: payload.sku.key },
+      placeholder: false
+    };
+    return this.assert(base);
   }
 };
 
 // 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;
+  return (cache) => {
+    const client = {};
+    if (capabilities.product) {
+      client.product = new CommercetoolsProductProvider(configuration, ProductSchema, cache);
+    }
+    if (capabilities.search) {
+      client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, cache);
+    }
+    if (capabilities.identity) {
+      client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, cache);
+    }
+    if (capabilities.cart) {
+      client.cart = new CommercetoolsCartProvider(configuration, CartSchema, cache);
+    }
+    if (capabilities.inventory) {
+      client.inventory = new CommercetoolsInventoryProvider(configuration, InventorySchema, cache);
+    }
+    if (capabilities.price) {
+      client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, cache);
+    }
+    return client;
+  };
 }
 
 // providers/commercetools/src/schema/capabilities.schema.ts
@@ -1332,13 +975,13 @@ var CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
 }).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()
+import { z as z23 } from "zod";
+var CommercetoolsConfigurationSchema = z23.looseInterface({
+  projectKey: z23.string(),
+  authUrl: z23.string(),
+  apiUrl: z23.string(),
+  clientId: z23.string(),
+  clientSecret: z23.string()
 });
 export {
   CommercetoolsCapabilitiesSchema,

package/package.json

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

package/src/core/initialize.d.ts

@@ -1,4 +1,4 @@
-import { Client } from "@reactionary/core";
+import { Client, Cache } 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>;
+export declare function withCommercetoolsCapabilities(configuration: CommercetoolsConfiguration, capabilities: CommercetoolsCapabilities): (cache: Cache) => Partial<Client>;

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

@@ -1,15 +1,14 @@
-import { Cart, CartMutation, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartProvider, CartQuery, Session } from '@reactionary/core';
+import { Cart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartProvider, CartQueryById, Session, Cache } 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> {
+export declare class CommercetoolsCartProvider<T extends Cart = Cart> extends CartProvider<T> {
     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>;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getById(payload: CartQueryById, session: Session): Promise<T>;
+    add(payload: CartMutationItemAdd, session: Session): Promise<T>;
+    remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
+    changeQuantity(payload: CartMutationItemQuantityChange, 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

@@ -1,13 +1,11 @@
-import { Identity, IdentityMutation, IdentityMutationLogin, IdentityProvider, IdentityQuery, Session } from '@reactionary/core';
+import { Identity, IdentityMutationLogin, IdentityProvider, IdentityQuerySelf, Session, Cache } 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> {
+export declare class CommercetoolsIdentityProvider<T extends Identity = Identity> extends IdentityProvider<T> {
     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>;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getSelf(payload: IdentityQuerySelf, session: Session): Promise<T>;
+    login(payload: IdentityMutationLogin, session: Session): Promise<T>;
+    logout(payload: Record<string, never>, session: Session): Promise<T>;
     protected extractCustomerIdFromScopes(scopes: string): string;
 }

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

@@ -1,12 +1,8 @@
-import { Inventory, InventoryProvider, InventoryQuery, RedisCache, Session } from '@reactionary/core';
+import { Inventory, InventoryProvider, InventoryQuery, Session, Cache } 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> {
+export declare class CommercetoolsInventoryProvider<T extends Inventory = Inventory> extends InventoryProvider<T> {
     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>;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getBySKU(payload: InventoryQuery, session: Session): Promise<T>;
 }

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

@@ -1,10 +1,8 @@
-import { BaseMutation, Price, PriceProvider, PriceQuery, Session } from '@reactionary/core';
+import { Price, PriceProvider, PriceQueryBySku, Session, Cache } 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> {
+export declare class CommercetoolsPriceProvider<T extends Price = Price> extends PriceProvider<T> {
     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>;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getBySKU(payload: PriceQueryBySku, session: Session): Promise<T>;
 }

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

@@ -1,11 +1,11 @@
-import { ProductProvider, ProductQuery, Product, Session, BaseMutation, ProductMutation } from '@reactionary/core';
+import { ProductProvider, Product, ProductQueryById, ProductQueryBySlug, Session, Cache } 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> {
+export declare class CommercetoolsProductProvider<T extends Product = Product> extends ProductProvider<T> {
     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>;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getById(payload: ProductQueryById, _session: Session): Promise<T>;
+    getBySlug(payload: ProductQueryBySlug, _session: Session): Promise<T>;
     protected parse(data: ProductProjection): T;
 }

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

@@ -1,11 +1,9 @@
-import { SearchIdentifier, SearchMutation, SearchProvider, SearchQuery, SearchResult, Session } from '@reactionary/core';
+import { SearchProvider, SearchQueryByTerm, SearchResult, Session, Cache } 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> {
+export declare class CommercetoolsSearchProvider<T extends SearchResult = SearchResult> extends SearchProvider<T> {
     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;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    queryByTerm(payload: SearchQueryByTerm, _session: Session): Promise<T>;
+    protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T;
 }