@reactionary/source 0.0.37 → 0.0.38

package/.env-template

@@ -0,0 +1,10 @@
+COMMERCETOOLS_API_URL=https://api.europe-west1.gcp.commercetools.com
+COMMERCETOOLS_AUTH_URL=https://auth.europe-west1.gcp.commercetools.com
+COMMERCETOOLS_CLIENT_ID=
+COMMERCETOOLS_CLIENT_SECRET=
+COMMERCETOOLS_PROJECT_KEY=
+
+OTEL_SERVICE_NAME=reactionary
+OTEL_LOG_LEVEL=info
+OTEL_TRACES_EXPORTER=console
+OTEL_METRICS_EXPORTER=console

package/.github/workflows/pull-request.yml

@@ -9,6 +9,8 @@ permissions:
   contents: read
   pull-requests: read
 
+concurrency: pull-request-${{ github.event.pull_request.number }}
+
 env:
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -24,14 +26,14 @@ jobs:
       - uses: pnpm/action-setup@v4
 
       - run: pnpm dlx nx-cloud start-ci-run --distribute-on="3 linux-medium-js" --stop-agents-after="build"
-      
+
       - uses: actions/setup-node@v4
         with:
           node-version: 23
           cache: 'pnpm'
-      
+
       - run: pnpm install
-      
+
       - uses: nrwl/nx-set-shas@v4
 
       - run: pnpm exec nx affected -t lint build

package/core/src/client/client.ts

@@ -7,6 +7,7 @@ import { PriceProvider } from "../providers/price.provider";
 import { InventoryProvider } from "../providers/inventory.provider";
 import { Cache } from "../cache/cache.interface";
 import { RedisCache } from "../cache/redis-cache";
+import { CategoryProvider } from "../providers/category.provider";
 
 export interface Client {
     product: ProductProvider,
@@ -16,7 +17,8 @@ export interface Client {
     cart: CartProvider,
     analytics: Array<AnalyticsProvider>,
     price: PriceProvider,
-    inventory: InventoryProvider
+    inventory: InventoryProvider,
+    category: CategoryProvider
 }
 
 export interface BuildClientOptions {
@@ -47,7 +49,7 @@ export function buildClient<T extends Partial<Client>>(
     }
 
     client.analytics = mergedAnalytics;
-    
+
     // Add cache to complete the client
     const completeClient = {
         ...client,

package/core/src/index.ts

@@ -16,6 +16,7 @@ export * from './providers/inventory.provider';
 export * from './providers/price.provider';
 export * from './providers/product.provider';
 export * from './providers/search.provider';
+export * from './providers/category.provider';
 
 export * from './schemas/capabilities.schema';
 export * from './schemas/session.schema';
@@ -29,6 +30,7 @@ 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/models/category.model';
 
 export * from './schemas/mutations/base.mutation';
 export * from './schemas/mutations/cart.mutation';
@@ -38,10 +40,4 @@ 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';
+export * from './schemas/queries';

package/core/src/providers/analytics.provider.ts

@@ -4,4 +4,9 @@ import { BaseProvider } from './base.provider';
 export abstract class AnalyticsProvider<
   T extends AnalyticsEvent = AnalyticsEvent
 > extends BaseProvider<T> {
-}
+
+
+  protected override getResourceName(): string {
+    return 'analytics';
+  }
+}

package/core/src/providers/base.provider.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
-import { BaseModel } from '../schemas/models/base.model';
+import { BaseModel, createPaginatedResponseSchema } from '../schemas/models/base.model';
 import { Cache } from '../cache/cache.interface';
+import { Session } from '../schemas/session.schema';
+import { IdentifierType } from '../schemas/models/identifiers.model';
 
 /**
  * Base capability provider, responsible for mutations (changes) and queries (fetches)
@@ -10,7 +12,7 @@ export abstract class BaseProvider<
   T extends BaseModel = BaseModel
 > {
   protected cache: Cache;
-  
+
   constructor(
     public readonly schema: z.ZodType<T>,
     cache: Cache
@@ -37,9 +39,37 @@ export abstract class BaseProvider<
    * Handler for parsing a response from a remote provider and converting it
    * into the typed domain model.
    */
-  protected parseSingle(_body: unknown): T {
+  protected parseSingle(_body: unknown, session: Session): T {
     const model = this.newModel();
 
     return this.assert(model);
   }
+
+
+  protected parsePaginatedResult(_body: unknown, session: Session): z.infer<ReturnType<typeof createPaginatedResponseSchema<typeof this.schema>>> {
+    return createPaginatedResponseSchema(this.schema).parse({});
+  }
+
+  protected generateCacheKeyPaginatedResult(resultSetName: string, res:  ReturnType<typeof this.parsePaginatedResult>, session: Session): string {
+    const type = this.getResourceName();
+    const langPart = session.languageContext.locale;
+    const currencyPart = session.languageContext.currencyCode || 'default';
+    const storePart = session.storeIdentifier?.key || 'default';
+    return `${type}-${resultSetName}-paginated|pageNumber:${res.pageNumber}|pageSize:${res.pageSize}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
+  }
+
+
+  protected generateCacheKeySingle(identifier: IdentifierType, session: Session): string {
+    const type = this.getResourceName();
+    const idPart = Object.entries(identifier).map(([k, v]) => `${k}:${(v as any).key}`).join('#');
+    const langPart = session.languageContext.locale;
+    const currencyPart = session.languageContext.currencyCode || 'default';
+    const storePart = session.storeIdentifier?.key || 'default';
+    return `${type}-${idPart}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
+  }
+
+  /**
+   * Returns the abstract resource name provided by the remote system.
+   */
+  protected abstract getResourceName(): string ;
 }

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

@@ -11,4 +11,10 @@ export abstract class CartProvider<
   public abstract add(payload: CartMutationItemAdd, session: Session): Promise<T>;
   public abstract remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
   public abstract changeQuantity(payload: CartMutationItemQuantityChange, session: Session): Promise<T>;
-}
+
+
+  protected override getResourceName(): string {
+    return 'cart';
+  }
+}
+

package/core/src/providers/category.provider.ts

@@ -0,0 +1,91 @@
+
+
+import { PaginationOptions } from "../schemas/models/base.model";
+import { Category } from "../schemas/models/category.model";
+import { CategoryIdentifier } from "../schemas/models/identifiers.model";
+import { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query";
+
+import { Session } from "../schemas/session.schema";
+import { BaseProvider } from "./base.provider";
+
+
+
+/**
+ * CategoryProvider
+ *
+ * This provider allows fetching of single or sets of categories.
+ *
+ * We only allow fetching one hierachy level at a time, for now. This is to avoid development patterns of "fetch 5000 categories in one go.."
+ *
+ */
+export abstract class CategoryProvider<
+  T extends Category = Category
+> extends BaseProvider<T> {
+  /**
+   * Get a single category by its ID. Cannot return null, because HOW did you come across a categories ID that does not exist?
+   *
+   * DISCUSSION: What do you persist in, say, a CMS or Recommendation engine? The seo slug or the ID?
+   * We have previous discussed, that the ID is not necessarily the DATABASE id, but rather an externally unique identifier for the category.
+   *
+   * So, if you persist that externally, you could actually end up with an ID that does not exist in the current system.
+   *
+   * For now, the result will be en empty category, but we should probably throw an error instead.
+   *
+   * Use case: You have received a list of category ids from a recommendation engine, and you need to show a tile of this.
+   * Future optimization: getByIds(ids: CategoryIdentifier[], session: Session): Promise<T[]>
+   * @param id
+   * @param session
+   */
+  public abstract getById(payload: CategoryQueryById, session: Session): Promise<T>;
+
+  /**
+   * Gets a single category by its seo slug
+   *
+   * Usecase: You are rendering a category page, and you have the slug from the URL.
+   * @param slug the slug
+   * @param session
+   */
+  public abstract getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null>;
+
+
+  /**
+   * Gets the breadcrumb path to the category, i.e. all parents up to the root.
+   * The returned order is from root to leaf.
+   *
+   * Usecase: You are rendering a category or product page, and you need to show the breadcrumb path.
+   * @param id
+   * @param session
+   */
+  public abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]>;
+
+  // hmm, this is not really good enough.... We need a type we can pass in that will allow us to specify the precise return type, but otoh we also need
+  // to be able to verify and assert the output type. FIXME
+
+  /**
+   * Finds all child categories of a given category.
+   *
+   * Usecase: You are rendering a top menu, or mega menu, and you need the show the child categories of a given category.
+   *
+   * NOTE: it is recommended to create a navigational service, that allows combining CMS and Static pages into this, rather than fetching categories directly.
+   *
+   * @param id The ID of the parent category.
+   * @param session The session information.
+   */
+  public abstract findChildCategories(payload: CategoryQueryForChildCategories, session: Session): Promise< ReturnType<typeof this.parsePaginatedResult>>;
+
+  /**
+   * Returns all top categories, i.e. categories without a parent.
+   *
+   * Usecase: You are rendering a top menu, or mega menu, and you need the show the top level categories.
+   * @param paginationOptions
+   * @param session
+   */
+  public abstract findTopCategories( payload: CategoryQueryForTopCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+
+
+  protected override getResourceName(): string {
+    return 'category';
+  }
+
+}
+

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

@@ -10,4 +10,8 @@ export abstract class IdentityProvider<
   public abstract getSelf(payload: IdentityQuerySelf, session: Session): Promise<T>;
   public abstract login(payload: IdentityMutationLogin, session: Session): Promise<T>;
   public abstract logout(payload: IdentityMutationLogout, session: Session): Promise<T>;
-}
+
+  protected override getResourceName(): string {
+    return 'identity';
+  }
+}

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

@@ -7,4 +7,8 @@ export abstract class InventoryProvider<
   T extends Inventory = Inventory
 > extends BaseProvider<T> {
   public abstract getBySKU(payload: InventoryQuery, session: Session): Promise<T>;
+
+  protected override getResourceName(): string {
+    return 'inventory';
+  }
 }

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

@@ -1,3 +1,4 @@
+import { Currency } from '../schemas/models/currency.model';
 import { Price } from '../schemas/models/price.model';
 import { PriceQueryBySku } from '../schemas/queries/price.query';
 import { Session } from '../schemas/session.schema';
@@ -6,5 +7,58 @@ import { BaseProvider } from './base.provider';
 export abstract class PriceProvider<
   T extends Price = Price
 > extends BaseProvider<T> {
+
+
+  /**
+   * Get a price by SKU.
+   *
+   * Note: This does not include any discounts or promotions that may apply.
+   * For B2B scenarios, this will be the base price, and any customer specific pricing
+   *
+   * Usecase: You are rendering a product page, and you need to show the price for a SKU.
+   * @param payload The SKU to query
+   * @param session The session information
+   */
   public abstract getBySKU(payload: PriceQueryBySku, session: Session): Promise<T>;
+
+
+  /**
+   * Fetch prices for multiple SKUs in one go.
+   *
+   * Usecase: You are rendering a product grid, and you need to show prices for multiple SKUs.
+   * @param payload The SKUs to query
+   * @param session The session information
+   */
+  public abstract getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]>;
+
+
+  /**
+   * Utility function to create an empty price result, with a value of -1.
+   * This is used when no price is found for a given SKU + currency combination.
+   * You should check for meta.placeholder to see if this is a real price or a placeholder.
+   * @param sku
+   * @param currency
+   * @returns
+   */
+  protected getEmptyPriceResult(sku: string, currency: Currency): T {
+    const base = this.newModel();
+    base.identifier = {
+      sku: { key: sku }
+    };
+    base.unitPrice = {
+      value: -1,
+      currency: currency,
+    };
+    base.meta = {
+      cache: { hit: false, key: `price-${sku}-${currency}` },
+      placeholder: true
+    };
+    return this.assert(base);
+  }
+
+
+
+  protected override getResourceName(): string {
+    return 'price';
+  }
 }

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

@@ -8,4 +8,8 @@ export abstract class ProductProvider<
 > extends BaseProvider<T> {
   public abstract getById(payload: ProductQueryById, session: Session): Promise<T>;
   public abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T>;
+
+  protected override getResourceName(): string {
+    return 'product';
+  }
 }

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

@@ -7,6 +7,12 @@ export abstract class SearchProvider<
   T extends SearchResult = SearchResult
 > extends BaseProvider<T> {
   public abstract queryByTerm(payload: SearchQueryByTerm, session: Session): Promise<SearchResult>;
+
+
+  protected override getResourceName(): string {
+    return 'product-search';
+  }
+
 }
 
 

package/core/src/schemas/capabilities.schema.ts

@@ -7,7 +7,8 @@ export const CapabilitiesSchema = z.looseInterface({
     identity: z.boolean(),
     cart: z.boolean(),
     inventory: z.boolean(),
-    price: z.boolean()
+    price: z.boolean(),
+    category: z.boolean()
 });
 
-export type Capabilities = z.infer<typeof CapabilitiesSchema>;
+export type Capabilities = z.infer<typeof CapabilitiesSchema>;

package/core/src/schemas/models/base.model.ts

@@ -16,4 +16,45 @@ export const BaseModelSchema = z.looseInterface({
 
 export type CacheInformation = z.infer<typeof CacheInformationSchema>;
 export type Meta = z.infer<typeof MetaSchema>;
-export type BaseModel = z.infer<typeof BaseModelSchema>;
+export type BaseModel = z.infer<typeof BaseModelSchema>;
+
+
+export const PaginationOptionsSchema = z.looseInterface({
+    pageNumber: z.number().default(1).describe('Current page number, starting from 1'),
+    pageSize: z.number().default(20).describe('Number of items per page'),
+});
+
+export type PaginationOptions = z.infer<typeof PaginationOptionsSchema>;
+
+/**
+ * This seemed like the right way to do it, but we need to be able to pass in the item schema even later than this
+ *
+ **/
+export function createPaginatedResponseSchema<ItemType extends z.ZodTypeAny>(
+  itemSchema: ItemType,
+) {
+  return z.object({
+    meta: MetaSchema.default(() => MetaSchema.parse({})),
+    pageNumber: z.number().min(1).describe('Current page number, starting from 1'),
+    pageSize: z.number().min(1).max(50).describe('Number of items per page'),
+    totalCount: z.number().min(0).describe('Total number of items available'),
+    totalPages: z.number().min(0).describe('Total number of pages available'),
+    items: z.array(itemSchema),
+  });
+}
+
+/**
+ * I posit, we should not have final urls in this, but rather assume the frontend has some kind of image transcoding/resizing service it will use to pass the image through, so
+ * what we really need is the original source url, and then some metadata about the image.
+ * Ie, rather than having distinct thumbnail and image fields, we just have a list of images, and the frontend will generate its own thumbnails as needed?
+ */
+export const ImageSchema = z.looseInterface({
+    sourceUrl: z.string().default('').describe('The original source URL of the image. Pass this through your image resizing and transcoding service to get the desired size, and generate thumbnails as needed'),
+    altText: z.string().default('').describe('Alternative text for the image, for accessibility purposes. Must always be set, and non-empty'),
+    width: z.number().optional().describe('Width of the original image, in pixels, if known'),
+    height: z.number().optional().describe('Height of the original image, in pixels, if known'),
+});
+
+export type Image = z.infer<typeof ImageSchema>;
+
+

package/core/src/schemas/models/cart.model.ts

@@ -1,17 +1,41 @@
 import { z } from 'zod';
 import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
 import { BaseModelSchema } from './base.model';
+import { MonetaryAmountSchema } from './price.model';
+
+export const CostBreakDownSchema = z.looseObject({
+    totalTax: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The amount of tax paid on the cart. This may include VAT, GST, sales tax, etc.'),
+    totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The amount of discount applied to the cart.'),
+    totalSurcharge: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The amount of surcharge applied to the cart.'),
+    totalShipping: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The amount of shipping fees for the cart.'),
+    totalProductPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total price of products in the cart.'),
+    grandTotal: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total price for the cart including all taxes, discounts, and shipping.'),
+});
+export type CostBreakDown = z.infer<typeof CostBreakDownSchema>;
+
+export const ItemCostBreakdownSchema = z.looseObject({
+    unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The price per single unit of the item.'),
+    unitDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The discount applied per single unit of the item.'),
+    totalPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total price for all units of the item.'),
+    totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total discount applied to all units of the item.'),
+});
+
+export type ItemCostBreakdown = z.infer<typeof ItemCostBreakdownSchema>;
 
 export const CartItemSchema = z.looseInterface({
     identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
     product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
-    quantity: z.number().default(0)
+    quantity: z.number().default(0),
+    price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({})),
 });
 
 export const CartSchema = BaseModelSchema.extend({
     identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
-    items: z.array(CartItemSchema).default(() => [])
+    items: z.array(CartItemSchema).default(() => []),
+    price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
+    name: z.string().default(''),
+    description: z.string().default(''),
 });
 
 export type CartItem = z.infer<typeof CartItemSchema>;
-export type Cart = z.infer<typeof CartSchema>;
+export type Cart = z.infer<typeof CartSchema>;

package/core/src/schemas/models/category.model.ts

@@ -0,0 +1,23 @@
+// getBySeoSlug
+// getBreadcrumbPathToCategory
+// getById
+// getByExternalId
+// getChildCategories
+
+
+import { z } from 'zod';
+import { BaseModelSchema, createPaginatedResponseSchema, ImageSchema } from './base.model';
+import { CategoryIdentifierSchema } from './identifiers.model';
+export const CategorySchema = BaseModelSchema.extend({
+    identifier:  CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
+    name: z.string().default(''),
+    slug: z.string().default(''),
+    text: z.string().default(''),
+    images: z.array(ImageSchema.required()).default(() => []),
+    parentCategory: CategoryIdentifierSchema.optional(),
+});
+
+export type Category = z.infer<typeof CategorySchema>;
+
+export const CategoryPaginatedResultSchema  = createPaginatedResponseSchema(CategorySchema);
+export type CategoryPaginatedResult = z.infer<typeof CategoryPaginatedResultSchema>;

package/core/src/schemas/models/identifiers.model.ts

@@ -36,10 +36,38 @@ export const PriceIdentifierSchema = z.looseInterface({
     sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
 });
 
+export const CategoryIdentifierSchema = z.looseInterface({
+  key: z.string().default('').nonoptional()
+});
+
+/**
+ * The target store the user is interacting with. Can change over time, and is not necessarily the same as the default store.
+ */
+export const WebStoreIdentifierSchema = z.looseInterface({
+    key: z.string().default('').nonoptional()
+});
+
+export const InventoryChannelIdentifierSchema= z.looseInterface({
+    key: z.string().default('online').nonoptional()
+});
+
+export const InventoryIdentifierSchema = z.looseInterface({
+    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+    channelId: InventoryChannelIdentifierSchema.default(() => InventoryChannelIdentifierSchema.parse({})),
+});
+
+
 export type ProductIdentifier = z.infer<typeof ProductIdentifierSchema>;
 export type SearchIdentifier = z.infer<typeof SearchIdentifierSchema>;
 export type FacetIdentifier = z.infer<typeof FacetIdentifierSchema>;
 export type FacetValueIdentifier = z.infer<typeof FacetValueIdentifierSchema>;
 export type CartIdentifier = z.infer<typeof CartIdentifierSchema>;
 export type CartItemIdentifier = z.infer<typeof CartItemIdentifierSchema>;
-export type PriceIdentifier = z.infer<typeof PriceIdentifierSchema>;
+export type PriceIdentifier = z.infer<typeof PriceIdentifierSchema>;
+export type CategoryIdentifier = z.infer<typeof CategoryIdentifierSchema>;
+export type WebStoreIdentifier = z.infer<typeof WebStoreIdentifierSchema>;
+export type InventoryIdentifier = z.infer<typeof InventoryIdentifierSchema>;
+export type InventoryChannelIdentifier = z.infer<typeof InventoryChannelIdentifierSchema>;
+
+
+export type IdentifierType = ProductIdentifier | SearchIdentifier | FacetIdentifier | FacetValueIdentifier | CartIdentifier | CartItemIdentifier | PriceIdentifier | CategoryIdentifier | WebStoreIdentifier | InventoryIdentifier;

package/core/src/schemas/models/inventory.model.ts

@@ -1,8 +1,12 @@
 import { z } from 'zod';
 import { BaseModelSchema } from './base.model';
+import { InventoryIdentifierSchema } from './identifiers.model';
 
 export const InventorySchema = BaseModelSchema.extend({
-    quantity: z.number().default(0)
+    identifier: InventoryIdentifierSchema.default(() => InventoryIdentifierSchema.parse({})),
+    sku: z.string().default(''),
+    quantity: z.number().default(0),
+    status: z.enum(['inStock', 'outOfStock', 'onBackOrder', 'preOrder', 'discontinued']).default('inStock'),
 });
 
-export type Inventory = z.infer<typeof InventorySchema>;
+export type Inventory = z.infer<typeof InventorySchema>;

package/core/src/schemas/models/price.model.ts

@@ -4,14 +4,22 @@ import { PriceIdentifierSchema } from './identifiers.model';
 import { CurrencySchema } from './currency.model';
 
 export const MonetaryAmountSchema = z.looseInterface({
-    cents: z.number().default(0).describe('The monetary amount in cent-precision.'),
+    value: z.number().default(0).describe('The monetary amount in decimal-precision.'),
     currency: CurrencySchema.default("XXX").describe('The currency associated with the amount, as a ISO 4217 standardized code.')
 });
 
+export const TieredPriceSchema = z.looseObject({
+    minimumQuantity: z.number().default(0).describe('The minimum quantity required to be eligible for the tiered price.'),
+    price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The monetary amount for the tiered price.'),
+});
+
+
 export const PriceSchema = BaseModelSchema.extend({
     identifier: PriceIdentifierSchema.default(() => PriceIdentifierSchema.parse({})),
-    value: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({}))
+    unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
+    tieredPrices: z.array(TieredPriceSchema).default(() => []),
 });
 
 export type MonetaryAmount = z.infer<typeof MonetaryAmountSchema>;
-export type Price = z.infer<typeof PriceSchema>;
+export type Price = z.infer<typeof PriceSchema>;
+export type TieredPrice = z.infer<typeof TieredPriceSchema>;

package/core/src/schemas/models/search.model.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSchema, SearchIdentifierSchema } from './identifiers.model';
-import { BaseModelSchema } from './base.model';
+import { BaseModelSchema, createPaginatedResponseSchema } from './base.model';
+import { create } from 'domain';
 
 export const SearchResultProductSchema = z.looseInterface({
     identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),
@@ -29,7 +30,8 @@ export const SearchResultSchema = BaseModelSchema.extend({
     facets: z.array(SearchResultFacetSchema).default(() => [])
 });
 
+
 export type SearchResultProduct = z.infer<typeof SearchResultProductSchema>;
 export type SearchResult = z.infer<typeof SearchResultSchema>;
 export type SearchResultFacet = z.infer<typeof SearchResultFacetSchema>;
-export type SearchResultFacetValue = z.infer<typeof SearchResultFacetValueSchema>;
+export type SearchResultFacetValue = z.infer<typeof SearchResultFacetValueSchema>;

package/core/src/schemas/queries/category.query.ts

@@ -0,0 +1,32 @@
+import z from "zod";
+import { CategoryIdentifierSchema } from "../models/identifiers.model";
+import { BaseQuerySchema } from "./base.query";
+import { PaginationOptionsSchema } from "../models/base.model";
+
+export const CategoryQueryById = BaseQuerySchema.extend({
+    id: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
+});
+
+export const CategoryQueryBySlug = BaseQuerySchema.extend({
+    slug: z.string().default(''),
+});
+
+export const CategoryQueryForBreadcrumb = BaseQuerySchema.extend({
+    id: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
+});
+
+export const CategoryQueryForChildCategories = BaseQuerySchema.extend({
+    parentId: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
+    paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({})),
+});
+
+export const CategoryQueryForTopCategories = BaseQuerySchema.extend({
+    paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({})),
+});
+
+
+export type CategoryQueryById = z.infer<typeof CategoryQueryById>;
+export type CategoryQueryBySlug = z.infer<typeof CategoryQueryBySlug>;
+export type CategoryQueryForBreadcrumb = z.infer<typeof CategoryQueryForBreadcrumb>;
+export type CategoryQueryForChildCategories = z.infer<typeof CategoryQueryForChildCategories>;
+export type CategoryQueryForTopCategories = z.infer<typeof CategoryQueryForTopCategories>;

package/core/src/schemas/queries/index.ts

@@ -0,0 +1,9 @@
+export * from './analytics.query';
+export * from './base.query';
+export * from './cart.query';
+export * from './category.query';
+export * from './identity.query';
+export * from './inventory.query';
+export * from './price.query';
+export * from './product.query';
+export * from './search.query';