@reactionary/provider-fake 0.0.31 → 0.0.33

package/index.js

@@ -1,245 +1,15 @@
 // core/src/cache/redis-cache.ts
 import { Redis } from "@upstash/redis";
 
-// 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
-import * as crypto from "crypto";
 var BaseProvider = class {
-  constructor(schema, querySchema, mutationSchema, cache) {
+  constructor(schema, cache) {
     this.schema = schema;
-    this.querySchema = querySchema;
-    this.mutationSchema = mutationSchema;
-    this.instrumentation = createProviderInstrumentation(this.constructor.name);
     this.cache = cache;
   }
   /**
@@ -256,144 +26,41 @@ 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);
-        let cacheHits = 0;
-        let cacheMisses = 0;
-        const results = [];
-        for (const query of queries) {
-          let result = null;
-          const cacheInfo = this.getCacheEvaluation(query, session);
-          if (cacheInfo.canCache && cacheInfo.key) {
-            try {
-              result = await this.cache.get(cacheInfo.key, this.schema);
-              if (result) {
-                cacheHits++;
-                span.setAttribute("provider.cache.hit", true);
-              }
-            } catch (error) {
-              console.warn(`Cache get error for ${this.constructor.name}:`, error);
-            }
-          }
-          if (!result) {
-            const singleResult = await this.fetch([query], session);
-            result = singleResult[0];
-            cacheMisses++;
-            if (result && cacheInfo.canCache && cacheInfo.key) {
-              try {
-                await this.cache.put(cacheInfo.key, result, cacheInfo.cacheDurationInSeconds);
-              } catch (error) {
-                console.warn(`Cache put error for ${this.constructor.name}:`, error);
-              }
-            }
-          }
-          if (result) {
-            this.assert(result);
-            results.push(result);
-          }
-        }
-        span.setAttribute("provider.result.count", results.length);
-        span.setAttribute("provider.cache.hits", cacheHits);
-        span.setAttribute("provider.cache.misses", cacheMisses);
-        span.setAttribute("provider.cache.hit_ratio", cacheHits / (cacheHits + cacheMisses));
-        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 }
-    );
-  }
-  /**
-   * Provider-specific cache evaluation logic.
-   * Returns information about how this query should be cached.
-   * Override this method to enable caching with custom keys and TTL.
-   * Default implementation returns no caching.
-   */
-  getCacheEvaluation(query, session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id || "anonymous";
-    const queryHash = crypto.createHash("md5").update(JSON.stringify(query)).digest("hex").substring(0, 12);
-    const key = `${providerName}:${userId}:${queryHash}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
+  parseSingle(_body) {
+    const model = this.newModel();
+    return this.assert(model);
   }
 };
 
+// core/src/providers/analytics.provider.ts
+var AnalyticsProvider = class extends BaseProvider {
+};
+
+// core/src/providers/cart.provider.ts
+var CartProvider = class extends BaseProvider {
+};
+
 // core/src/providers/identity.provider.ts
 var IdentityProvider = class extends BaseProvider {
-  getCacheEvaluation(_query, session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const userId = session.identity?.id;
-    const key = userId ? `${providerName}:identity:${userId}` : `${providerName}:identity:anonymous`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
+};
+
+// 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
-import * as crypto2 from "crypto";
 var ProductProvider = class extends BaseProvider {
-  getCacheEvaluation(query, _session) {
-    const providerName = this.constructor.name.toLowerCase();
-    let key;
-    if (query.query === "slug") {
-      key = `${providerName}:product:slug:${query.slug}`;
-    } else if (query.query === "id") {
-      key = `${providerName}:product:id:${query.id}`;
-    } else {
-      const queryHash = crypto2.createHash("md5").update(JSON.stringify(query)).digest("hex").substring(0, 12);
-      key = `${providerName}:product:${queryHash}`;
-    }
-    return {
-      key,
-      cacheDurationInSeconds: 300,
-      // Products are moderately stable - 5 minutes
-      canCache: true
-    };
-  }
 };
 
 // core/src/providers/search.provider.ts
-import * as crypto3 from "crypto";
 var SearchProvider = class extends BaseProvider {
-  getCacheEvaluation(query, _session) {
-    const providerName = this.constructor.name.toLowerCase();
-    const searchHash = crypto3.createHash("md5").update(JSON.stringify(query.search)).digest("hex").substring(0, 12);
-    const key = `${providerName}:search:${searchHash}`;
-    return {
-      key,
-      cacheDurationInSeconds: 0,
-      canCache: false
-    };
-  }
 };
 
 // core/src/schemas/capabilities.schema.ts
@@ -741,42 +408,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";
@@ -796,104 +453,324 @@ 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/fake/src/providers/product.provider.ts
 import { base, en, Faker } from "@faker-js/faker";
+
+// 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;
+}
+
+// otel/src/metrics.ts
+import { metrics } from "@opentelemetry/api";
+
+// otel/src/provider-instrumentation.ts
+import { SpanKind as SpanKind3 } from "@opentelemetry/api";
+
+// otel/src/trace-decorator.ts
+import { SpanKind as SpanKind4, SpanStatusCode as SpanStatusCode4 } from "@opentelemetry/api";
+function safeSerialize(value, maxDepth = 3, currentDepth = 0) {
+  if (currentDepth >= maxDepth) {
+    return "[Max depth reached]";
+  }
+  if (value === null)
+    return "null";
+  if (value === void 0)
+    return "undefined";
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") {
+    return String(value);
+  }
+  if (type === "function") {
+    return `[Function: ${value.name || "anonymous"}]`;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof Error) {
+    return `[Error: ${value.message}]`;
+  }
+  if (Array.isArray(value)) {
+    if (value.length > 10) {
+      return `[Array(${value.length})]`;
+    }
+    try {
+      return JSON.stringify(value.map(
+        (item) => safeSerialize(item, maxDepth, currentDepth + 1)
+      ));
+    } catch {
+      return "[Array - circular reference]";
+    }
+  }
+  if (type === "object") {
+    try {
+      const keys = Object.keys(value);
+      if (keys.length > 20) {
+        return `[Object with ${keys.length} keys]`;
+      }
+      const simplified = {};
+      for (const key of keys.slice(0, 10)) {
+        simplified[key] = safeSerialize(
+          value[key],
+          maxDepth,
+          currentDepth + 1
+        );
+      }
+      return JSON.stringify(simplified);
+    } catch {
+      return "[Object - circular reference]";
+    }
+  }
+  return String(value);
+}
+function traced(options = {}) {
+  const {
+    captureArgs = true,
+    captureResult = true,
+    spanName,
+    spanKind = SpanKind4.INTERNAL
+  } = options;
+  return function(target, propertyKey, descriptor) {
+    if (typeof propertyKey === "object" && propertyKey && "kind" in propertyKey) {
+      const context = propertyKey;
+      const originalMethod = target;
+      const methodName = String(context.name);
+      return createTracedMethod(originalMethod, methodName, {
+        captureArgs,
+        captureResult,
+        spanName,
+        spanKind
+      });
+    }
+    if (descriptor && typeof descriptor.value === "function") {
+      const originalMethod = descriptor.value;
+      const methodName = String(propertyKey);
+      descriptor.value = createTracedMethod(originalMethod, methodName, {
+        captureArgs,
+        captureResult,
+        spanName,
+        spanKind
+      });
+      return descriptor;
+    }
+    return target;
+  };
+}
+function createTracedMethod(originalMethod, methodName, options) {
+  const { captureArgs, captureResult, spanName, spanKind } = options;
+  function tracedMethod(...args) {
+    const tracer = getTracer();
+    const className = this?.constructor?.name || "Unknown";
+    const effectiveSpanName = spanName || `${className}.${methodName}`;
+    const span = tracer.startSpan(effectiveSpanName, {
+      kind: spanKind,
+      attributes: {
+        "function.name": methodName,
+        "function.class": className
+      }
+    });
+    if (captureArgs && args.length > 0) {
+      args.forEach((arg, index) => {
+        try {
+          span.setAttribute(`function.args.${index}`, safeSerialize(arg));
+        } catch {
+          span.setAttribute(`function.args.${index}`, "[Serialization error]");
+        }
+      });
+      span.setAttribute("function.args.count", args.length);
+    }
+    const finalizeSpan = (result, isError = false) => {
+      if (!isError && captureResult && result !== void 0) {
+        try {
+          span.setAttribute("function.result", safeSerialize(result));
+        } catch {
+          span.setAttribute("function.result", "[Serialization error]");
+        }
+      }
+      if (isError) {
+        span.setStatus({
+          code: SpanStatusCode4.ERROR,
+          message: result instanceof Error ? result.message : String(result)
+        });
+        if (result instanceof Error) {
+          span.recordException(result);
+        }
+      } else {
+        span.setStatus({ code: SpanStatusCode4.OK });
+      }
+      span.end();
+    };
+    try {
+      const result = originalMethod.apply(this, args);
+      if (result instanceof Promise) {
+        return result.then((value) => {
+          finalizeSpan(value);
+          return value;
+        }).catch((error) => {
+          finalizeSpan(error, true);
+          throw error;
+        });
+      }
+      finalizeSpan(result);
+      return result;
+    } catch (error) {
+      finalizeSpan(error, true);
+      throw error;
+    }
+  }
+  Object.defineProperty(tracedMethod, "name", {
+    value: methodName,
+    configurable: true
+  });
+  return tracedMethod;
+}
+
+// providers/fake/src/providers/product.provider.ts
 var FakeProductProvider = class extends ProductProvider {
-  constructor(config, schema, querySchema, mutationSchema, cache) {
-    super(schema, querySchema, mutationSchema, cache);
+  constructor(config, schema, cache) {
+    super(schema, cache);
     this.config = config;
   }
-  async fetch(queries, session) {
-    const results = new Array();
-    for (const query of queries) {
-      const generator = new Faker({
-        seed: 42,
-        locale: [en, base]
-      });
-      const key = query.id || generator.commerce.isbn();
-      const slug = query.slug || generator.lorem.slug();
-      const product = {
-        identifier: {
+  @traced()
+  async getById(payload, _session) {
+    return this.parseSingle(payload);
+  }
+  async getBySlug(payload, _session) {
+    return this.parseSingle(payload);
+  }
+  parseSingle(body) {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base]
+    });
+    const key = body.slug || body.id;
+    const model = this.newModel();
+    Object.assign(model, {
+      identifier: {
+        key
+      },
+      name: generator.commerce.productName(),
+      slug: key,
+      attributes: [],
+      description: generator.commerce.productDescription(),
+      image: generator.image.urlPicsumPhotos({
+        width: 600,
+        height: 600
+      }),
+      images: [],
+      meta: {
+        cache: {
+          hit: false,
           key
         },
-        name: generator.commerce.productName(),
-        slug,
-        attributes: [],
-        description: generator.commerce.productDescription(),
-        image: generator.image.urlPicsumPhotos({
-          width: 600,
-          height: 600
-        }),
-        images: [],
-        meta: {
-          cache: {
-            hit: false,
-            key
-          },
-          placeholder: false
-        },
-        skus: []
-      };
-      results.push(product);
-    }
-    return results;
-  }
-  process(mutation, session) {
-    throw new Error("Method not implemented.");
+        placeholder: false
+      },
+      skus: []
+    });
+    return this.assert(model);
   }
 };
 
@@ -908,32 +785,19 @@ async function jitter(duration, deviation) {
 function gaussianRandom(mean, deviation) {
   const u = 1 - Math.random();
   const v = Math.random();
-  const z27 = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
-  return z27 * deviation + mean;
+  const z24 = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  return z24 * deviation + mean;
 }
 
 // providers/fake/src/providers/search.provider.ts
 var FakeSearchProvider = class extends SearchProvider {
-  constructor(config, schema, querySchema, mutationSchema, cache) {
-    super(schema, querySchema, mutationSchema, cache);
+  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) {
     await jitter(this.config.jitter.mean, this.config.jitter.deviation);
-    return this.parse({}, identifier);
-  }
-  parse(data, query) {
+    const query = payload.search;
     const querySpecificity = 20 - query.term.length - query.page - query.facets.length;
     const totalProducts = 10 * querySpecificity;
     const totalPages = Math.ceil(totalProducts / query.pageSize);
@@ -964,12 +828,12 @@ var FakeSearchProvider = class extends SearchProvider {
       });
     }
     const facetBase = ["color", "size"];
-    for (const base3 of facetBase) {
+    for (const base6 of facetBase) {
       const facet = {
         identifier: {
-          key: base3
+          key: base6
         },
-        name: base3,
+        name: base6,
         values: []
       };
       for (let i = 0; i < 10; i++) {
@@ -1013,71 +877,238 @@ var FakeSearchProvider = class extends SearchProvider {
   }
 };
 
+// providers/fake/src/core/initialize.ts
+function withFakeCapabilities(configuration, capabilities) {
+  return (cache) => {
+    const client = {};
+    if (capabilities.product) {
+      client.product = new FakeProductProvider(configuration, ProductSchema, cache);
+    }
+    if (capabilities.search) {
+      client.search = new FakeSearchProvider(configuration, SearchResultSchema, cache);
+    }
+    return client;
+  };
+}
+
+// providers/fake/src/providers/analytics.provider.ts
+var FakeAnalyticsProvider = class extends AnalyticsProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+};
+
+// providers/fake/src/providers/cart.provider.ts
+var FakeCartProvider = class extends CartProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.carts = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  async getById(payload, _session) {
+    const cartId = payload.cart.key;
+    if (!this.carts.has(cartId)) {
+      const model = this.newModel();
+      Object.assign(model, {
+        identifier: { key: cartId },
+        items: [],
+        meta: {
+          cache: {
+            hit: false,
+            key: cartId
+          },
+          placeholder: false
+        }
+      });
+      this.carts.set(cartId, this.assert(model));
+    }
+    const cart = this.carts.get(cartId);
+    if (!cart) {
+      throw new Error(`Cart with id ${cartId} not found`);
+    }
+    return cart;
+  }
+  async add(payload, session) {
+    const cart = await this.getById({ cart: payload.cart }, session);
+    const existingItemIndex = cart.items.findIndex(
+      (item) => item.product.key === payload.product.key
+    );
+    if (existingItemIndex >= 0) {
+      cart.items[existingItemIndex].quantity += payload.quantity;
+    } else {
+      cart.items.push({
+        identifier: { key: `item-${Date.now()}` },
+        product: payload.product,
+        quantity: payload.quantity
+      });
+    }
+    return this.assert(cart);
+  }
+  async remove(payload, session) {
+    const cart = await this.getById({ cart: payload.cart }, session);
+    cart.items = cart.items.filter(
+      (item) => item.identifier.key !== payload.item.key
+    );
+    return this.assert(cart);
+  }
+  async changeQuantity(payload, session) {
+    const cart = await this.getById({ cart: payload.cart }, session);
+    const item = cart.items.find(
+      (item2) => item2.identifier.key === payload.item.key
+    );
+    if (item) {
+      item.quantity = payload.quantity;
+    }
+    return this.assert(cart);
+  }
+};
+
 // providers/fake/src/providers/identity.provider.ts
-import { faker } from "@faker-js/faker";
+import { base as base3, en as en3, Faker as Faker3 } from "@faker-js/faker";
 var FakeIdentityProvider = class extends IdentityProvider {
-  constructor(config, schema, querySchema, mutationSchema, cache) {
-    super(schema, querySchema, mutationSchema, cache);
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.currentIdentity = null;
     this.config = config;
   }
-  async fetch(queries, session) {
-    const results = [];
-    for (const query of queries) {
-      const result = await this.get(session);
-      results.push(result);
+  async getSelf(_payload, _session) {
+    if (!this.currentIdentity) {
+      const model = this.newModel();
+      Object.assign(model, {
+        id: "anonymous",
+        type: "Anonymous",
+        issued: /* @__PURE__ */ new Date(),
+        expiry: new Date(Date.now() + 24 * 60 * 60 * 1e3),
+        // 24 hours from now
+        meta: {
+          cache: {
+            hit: false,
+            key: "anonymous"
+          },
+          placeholder: false
+        }
+      });
+      this.currentIdentity = this.assert(model);
     }
-    return results;
+    return this.currentIdentity;
   }
-  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;
+  async login(payload, _session) {
+    const generator = new Faker3({
+      seed: 42,
+      locale: [en3, base3]
+    });
+    const model = this.newModel();
+    Object.assign(model, {
+      id: generator.string.uuid(),
+      type: "Registered",
+      token: generator.string.alphanumeric(32),
+      issued: /* @__PURE__ */ new Date(),
+      expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3),
+      // 7 days from now
+      meta: {
+        cache: {
+          hit: false,
+          key: payload.username
+        },
+        placeholder: false
       }
-    }
-    return result;
+    });
+    this.currentIdentity = this.assert(model);
+    return this.currentIdentity;
   }
-  async login(payload, session) {
-    const base3 = this.newModel();
-    base3.id = faker.string.uuid();
-    base3.token = faker.string.uuid();
-    base3.issued = faker.date.recent();
-    base3.issued = faker.date.soon();
-    base3.type = "Registered";
-    return base3;
+  async logout(_payload, _session) {
+    const model = this.newModel();
+    Object.assign(model, {
+      id: "anonymous",
+      type: "Anonymous",
+      issued: /* @__PURE__ */ new Date(),
+      expiry: new Date(Date.now() + 24 * 60 * 60 * 1e3),
+      // 24 hours from now
+      meta: {
+        cache: {
+          hit: false,
+          key: "anonymous"
+        },
+        placeholder: false
+      }
+    });
+    this.currentIdentity = this.assert(model);
+    return this.currentIdentity;
   }
-  async get(session) {
-    const base3 = this.schema.parse(session.identity);
-    return base3;
+};
+
+// providers/fake/src/providers/inventory.provider.ts
+import { base as base4, en as en4, Faker as Faker4 } from "@faker-js/faker";
+var FakeInventoryProvider = class extends InventoryProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
   }
-  async logout(session) {
-    const base3 = this.newModel();
-    session.identity = base3;
-    return base3;
+  async getBySKU(payload, _session) {
+    let hash = 0;
+    const skuString = payload.sku;
+    for (let i = 0; i < skuString.length; i++) {
+      hash = (hash << 5) - hash + skuString.charCodeAt(i);
+      hash = hash & hash;
+    }
+    const generator = new Faker4({
+      seed: hash || 42,
+      locale: [en4, base4]
+    });
+    const model = this.newModel();
+    Object.assign(model, {
+      quantity: generator.number.int({ min: 0, max: 100 }),
+      meta: {
+        cache: {
+          hit: false,
+          key: payload.sku
+        },
+        placeholder: false
+      }
+    });
+    return this.assert(model);
   }
 };
 
-// providers/fake/src/core/initialize.ts
-function withFakeCapabilities(configuration, capabilities) {
-  return (cache) => {
-    const client = {};
-    if (capabilities.product) {
-      client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
-    }
-    if (capabilities.search) {
-      client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema, cache);
-    }
-    if (capabilities.identity) {
-      client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema, cache);
+// providers/fake/src/providers/price.provider.ts
+import { base as base5, en as en5, Faker as Faker5 } from "@faker-js/faker";
+var FakePriceProvider = class extends PriceProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  async getBySKU(payload, _session) {
+    let hash = 0;
+    const skuString = payload.sku.key;
+    for (let i = 0; i < skuString.length; i++) {
+      hash = (hash << 5) - hash + skuString.charCodeAt(i);
+      hash = hash & hash;
     }
-    return client;
-  };
-}
+    const generator = new Faker5({
+      seed: hash || 42,
+      locale: [en5, base5]
+    });
+    const model = this.newModel();
+    Object.assign(model, {
+      identifier: {
+        sku: payload.sku
+      },
+      value: {
+        cents: generator.number.int({ min: 100, max: 1e5 }),
+        currency: "USD"
+      },
+      meta: {
+        cache: {
+          hit: false,
+          key: payload.sku
+        },
+        placeholder: false
+      }
+    });
+    return this.assert(model);
+  }
+};
 
 // providers/fake/src/schema/capabilities.schema.ts
 var FakeCapabilitiesSchema = CapabilitiesSchema.pick({
@@ -1087,20 +1118,24 @@ var FakeCapabilitiesSchema = CapabilitiesSchema.pick({
 }).partial();
 
 // providers/fake/src/schema/configuration.schema.ts
-import { z as z26 } from "zod";
-var FakeConfigurationSchema = z26.looseInterface({
-  jitter: z26.looseInterface({
-    mean: z26.number().min(0).max(1e4),
-    deviation: z26.number().min(0).max(5e3)
+import { z as z23 } from "zod";
+var FakeConfigurationSchema = z23.looseInterface({
+  jitter: z23.looseInterface({
+    mean: z23.number().min(0).max(1e4),
+    deviation: z23.number().min(0).max(5e3)
   }).default({
     mean: 0,
     deviation: 0
   })
 });
 export {
+  FakeAnalyticsProvider,
   FakeCapabilitiesSchema,
+  FakeCartProvider,
   FakeConfigurationSchema,
   FakeIdentityProvider,
+  FakeInventoryProvider,
+  FakePriceProvider,
   FakeProductProvider,
   FakeSearchProvider,
   withFakeCapabilities