@reactionary/core 0.0.32 → 0.0.34

package/index.js

@@ -1,764 +1,40 @@
-// core/src/cache/redis-cache.ts
-import { Redis } from "@upstash/redis";
-var RedisCache = class {
-  constructor() {
-    this.redis = Redis.fromEnv();
-  }
-  async get(key, schema) {
-    if (!key) {
-      return null;
-    }
-    const unvalidated = await this.redis.get(key);
-    const parsed = schema.safeParse(unvalidated);
-    if (parsed.success) {
-      return parsed.data;
-    }
-    return null;
-  }
-  async put(key, value, ttlSeconds) {
-    if (!key) {
-      return;
-    }
-    const options = ttlSeconds ? { ex: ttlSeconds } : void 0;
-    await this.redis.set(key, value, options);
-  }
-  async del(keys) {
-    const keyArray = Array.isArray(keys) ? keys : [keys];
-    for (const key of keyArray) {
-      if (key.includes("*")) {
-        const matchingKeys = await this.redis.keys(key);
-        if (matchingKeys.length > 0) {
-          await this.redis.del(...matchingKeys);
-        }
-      } else {
-        await this.redis.del(key);
-      }
-    }
-  }
-  async keys(pattern) {
-    return await this.redis.keys(pattern);
-  }
-  async clear(pattern) {
-    const searchPattern = pattern || "*";
-    const keys = await this.redis.keys(searchPattern);
-    if (keys.length > 0) {
-      await this.redis.del(...keys);
-    }
-  }
-  async getStats() {
-    const keys = await this.redis.keys("*");
-    return {
-      hits: 0,
-      // Would need to track this separately
-      misses: 0,
-      // Would need to track this separately  
-      size: keys.length
-    };
-  }
-};
-
-// core/src/cache/noop-cache.ts
-var NoOpCache = class {
-  async get(_key, _schema) {
-    return null;
-  }
-  async put(_key, _value, _ttlSeconds) {
-    return;
-  }
-  async del(_keys) {
-    return;
-  }
-  async keys(_pattern) {
-    return [];
-  }
-  async clear(_pattern) {
-    return;
-  }
-  async getStats() {
-    return {
-      hits: 0,
-      misses: 0,
-      size: 0
-    };
-  }
-};
-
-// core/src/client/client.ts
-function buildClient(providerFactories, options = {}) {
-  let client = {};
-  const sharedCache = options.cache || new RedisCache();
-  const mergedAnalytics = [];
-  for (const factory of providerFactories) {
-    const provider = factory(sharedCache);
-    client = {
-      ...client,
-      ...provider
-    };
-    if (provider.analytics) {
-      mergedAnalytics.push(...provider.analytics);
-    }
-  }
-  client.analytics = mergedAnalytics;
-  const completeClient = {
-    ...client,
-    cache: sharedCache
-  };
-  return completeClient;
-}
-function createCache() {
-  return new RedisCache();
-}
-
-// core/src/client/client-builder.ts
-var ClientBuilder = class _ClientBuilder {
-  constructor() {
-    this.factories = [];
-  }
-  withCapability(factory) {
-    const newBuilder = new _ClientBuilder();
-    newBuilder.factories = [...this.factories, factory];
-    newBuilder.cache = this.cache;
-    return newBuilder;
-  }
-  withCache(cache) {
-    const newBuilder = new _ClientBuilder();
-    newBuilder.factories = [...this.factories];
-    newBuilder.cache = cache;
-    return newBuilder;
-  }
-  build() {
-    let client = {};
-    const sharedCache = this.cache || new NoOpCache();
-    const mergedAnalytics = [];
-    for (const factory of this.factories) {
-      const provider = factory(sharedCache);
-      client = {
-        ...client,
-        ...provider
-      };
-      if (provider.analytics) {
-        mergedAnalytics.push(...provider.analytics);
-      }
-    }
-    if (mergedAnalytics.length > 0) {
-      client["analytics"] = mergedAnalytics;
-    }
-    const completeClient = {
-      ...client,
-      cache: sharedCache
-    };
-    return completeClient;
-  }
-};
-
-// 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");
-function trpcQuery(options = {}) {
-  return function(target, propertyKey, descriptor) {
-    const metadata = {
-      methodName: String(propertyKey),
-      isQuery: true,
-      isMutation: false,
-      options
-    };
-    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, metadata, target, propertyKey);
-    const existingMethods = Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target.constructor) || [];
-    existingMethods.push({ propertyKey, metadata });
-    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, existingMethods, target.constructor);
-  };
-}
-function trpcMutation(options = {}) {
-  return function(target, propertyKey, descriptor) {
-    const metadata = {
-      methodName: String(propertyKey),
-      isQuery: false,
-      isMutation: true,
-      options
-    };
-    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, metadata, target, propertyKey);
-    const existingMethods = Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target.constructor) || [];
-    existingMethods.push({ propertyKey, metadata });
-    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, existingMethods, target.constructor);
-  };
-}
-function getTRPCQueryMethods(target) {
-  const constructor = typeof target === "function" ? target : target.constructor;
-  return Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, constructor) || [];
-}
-function getTRPCMutationMethods(target) {
-  const constructor = typeof target === "function" ? target : target.constructor;
-  return Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, constructor) || [];
-}
-function getAllTRPCMethods(target) {
-  return [
-    ...getTRPCQueryMethods(target),
-    ...getTRPCMutationMethods(target)
-  ];
-}
-function isTRPCQuery(target, methodName) {
-  return !!Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target, methodName);
-}
-function isTRPCMutation(target, methodName) {
-  return !!Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target, methodName);
-}
-function isTRPCMethod(target, methodName) {
-  return isTRPCQuery(target, methodName) || isTRPCMutation(target, methodName);
-}
-
-// core/src/providers/base.provider.ts
-var BaseProvider = class {
-  constructor(schema, cache) {
-    this.schema = schema;
-    this.cache = cache;
-  }
-  /**
-   * 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({});
-  }
-  /**
-   * Handler for parsing a response from a remote provider and converting it
-   * into the typed domain model.
-   */
-  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 {
-};
-
-// 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({});
-
-// core/src/schemas/mutations/cart.mutation.ts
-import { z as z13 } from "zod";
-var CartMutationItemAddSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  product: ProductIdentifierSchema.required(),
-  quantity: z13.number()
-});
-var CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  item: CartItemIdentifierSchema.required()
-});
-var CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  item: CartItemIdentifierSchema.required(),
-  quantity: z13.number()
-});
-
-// core/src/schemas/mutations/identity.mutation.ts
-import { z as z14 } from "zod";
-var IdentityMutationLoginSchema = BaseMutationSchema.extend({
-  username: z14.string(),
-  password: z14.string()
-});
-var IdentityMutationLogoutSchema = BaseMutationSchema.extend({});
-
-// 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({});
-
-// core/src/schemas/queries/cart.query.ts
-import { z as z20 } from "zod";
-var CartQueryByIdSchema = BaseQuerySchema.extend({
-  cart: CartIdentifierSchema.required()
-});
-var CartQuerySchema = z20.union([CartQueryByIdSchema]);
-
-// core/src/schemas/queries/identity.query.ts
-var IdentityQuerySelfSchema = BaseQuerySchema.extend({});
-
-// core/src/schemas/queries/inventory.query.ts
-import { z as z21 } from "zod";
-var InventoryQuerySchema = BaseQuerySchema.extend({
-  sku: z21.string()
-});
-
-// core/src/schemas/queries/price.query.ts
-var PriceQueryBySkuSchema = BaseQuerySchema.extend({
-  sku: SKUIdentifierSchema.required()
-});
-
-// core/src/schemas/queries/product.query.ts
-import { z as z22 } from "zod";
-var ProductQueryBySlugSchema = BaseQuerySchema.extend({
-  slug: z22.string()
-});
-var ProductQueryByIdSchema = BaseQuerySchema.extend({
-  id: z22.string()
-});
-
-// core/src/schemas/queries/search.query.ts
-var SearchQueryByTermSchema = BaseQuerySchema.extend({
-  search: SearchIdentifierSchema.required()
-});
-export {
-  AnalyticsProvider,
-  BaseModelSchema,
-  BaseMutationSchema,
-  BaseProvider,
-  BaseQuerySchema,
-  CacheInformationSchema,
-  CapabilitiesSchema,
-  CartIdentifierSchema,
-  CartItemIdentifierSchema,
-  CartItemSchema,
-  CartMutationItemAddSchema,
-  CartMutationItemQuantityChangeSchema,
-  CartMutationItemRemoveSchema,
-  CartProvider,
-  CartQueryByIdSchema,
-  CartQuerySchema,
-  CartSchema,
-  ClientBuilder,
-  CurrencySchema,
-  FacetIdentifierSchema,
-  FacetValueIdentifierSchema,
-  IdentityMutationLoginSchema,
-  IdentityMutationLogoutSchema,
-  IdentityProvider,
-  IdentityQuerySelfSchema,
-  IdentitySchema,
-  IdentityTypeSchema,
-  InventoryMutationSchema,
-  InventoryProvider,
-  InventoryQuerySchema,
-  InventorySchema,
-  MetaSchema,
-  MonetaryAmountSchema,
-  NoOpCache,
-  PriceIdentifierSchema,
-  PriceMutationSchema,
-  PriceProvider,
-  PriceQueryBySkuSchema,
-  PriceSchema,
-  ProductAttributeSchema,
-  ProductIdentifierSchema,
-  ProductMutationSchema,
-  ProductProvider,
-  ProductQueryByIdSchema,
-  ProductQueryBySlugSchema,
-  ProductSchema,
-  RedisCache,
-  SKUIdentifierSchema,
-  SKUSchema,
-  SearchIdentifierSchema,
-  SearchMutationSchema,
-  SearchProvider,
-  SearchQueryByTermSchema,
-  SearchResultFacetSchema,
-  SearchResultFacetValueSchema,
-  SearchResultProductSchema,
-  SearchResultSchema,
-  SessionSchema,
-  TRPC_MUTATION_METADATA_KEY,
-  TRPC_QUERY_METADATA_KEY,
-  buildClient,
-  createCache,
-  getAllTRPCMethods,
-  getTRPCMutationMethods,
-  getTRPCQueryMethods,
-  isTRPCMethod,
-  isTRPCMutation,
-  isTRPCQuery,
-  trpcMutation,
-  trpcQuery
-};
+export * from "./cache/cache.interface";
+export * from "./cache/cache-evaluation.interface";
+export * from "./cache/redis-cache";
+export * from "./cache/noop-cache";
+export * from "./client/client";
+export * from "./client/client-builder";
+export * from "./decorators/trpc.decorators";
+export * from "./providers/analytics.provider";
+export * from "./providers/base.provider";
+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 "./schemas/capabilities.schema";
+export * from "./schemas/session.schema";
+export * from "./schemas/models/base.model";
+export * from "./schemas/models/cart.model";
+export * from "./schemas/models/currency.model";
+export * from "./schemas/models/identifiers.model";
+export * from "./schemas/models/identity.model";
+export * from "./schemas/models/inventory.model";
+export * from "./schemas/models/price.model";
+export * from "./schemas/models/product.model";
+export * from "./schemas/models/search.model";
+export * from "./schemas/mutations/base.mutation";
+export * from "./schemas/mutations/cart.mutation";
+export * from "./schemas/mutations/identity.mutation";
+export * from "./schemas/mutations/inventory.mutation";
+export * from "./schemas/mutations/price.mutation";
+export * from "./schemas/mutations/product.mutation";
+export * from "./schemas/mutations/search.mutation";
+export * from "./schemas/queries/base.query";
+export * from "./schemas/queries/cart.query";
+export * from "./schemas/queries/identity.query";
+export * from "./schemas/queries/inventory.query";
+export * from "./schemas/queries/price.query";
+export * from "./schemas/queries/product.query";
+export * from "./schemas/queries/search.query";