@reactionary/core 0.0.37 → 0.0.39

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

@@ -1,7 +1,36 @@
+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';
 import { BaseProvider } from './base.provider';
 export declare 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
+     */
     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
+     */
+    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;
+    protected getResourceName(): string;
 }

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

@@ -5,4 +5,5 @@ import { ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product
 export declare abstract class ProductProvider<T extends Product = Product> extends BaseProvider<T> {
     abstract getById(payload: ProductQueryById, session: Session): Promise<T>;
     abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T>;
+    protected getResourceName(): string;
 }

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

@@ -4,4 +4,5 @@ import { Session } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 export declare abstract class SearchProvider<T extends SearchResult = SearchResult> extends BaseProvider<T> {
     abstract queryByTerm(payload: SearchQueryByTerm, session: Session): Promise<SearchResult>;
+    protected getResourceName(): string;
 }

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

@@ -7,6 +7,7 @@ export declare const CapabilitiesSchema: z.ZodInterface<{
     cart: z.ZodBoolean;
     inventory: z.ZodBoolean;
     price: z.ZodBoolean;
+    category: z.ZodBoolean;
 }, {
     optional: never;
     defaulted: never;

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

@@ -46,3 +46,54 @@ export declare const BaseModelSchema: z.ZodInterface<{
 export type CacheInformation = z.infer<typeof CacheInformationSchema>;
 export type Meta = z.infer<typeof MetaSchema>;
 export type BaseModel = z.infer<typeof BaseModelSchema>;
+export declare const PaginationOptionsSchema: z.ZodInterface<{
+    pageNumber: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+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 declare function createPaginatedResponseSchema<ItemType extends z.ZodTypeAny>(itemSchema: ItemType): z.ZodObject<{
+    meta: z.ZodDefault<z.ZodInterface<{
+        cache: z.ZodDefault<z.ZodInterface<{
+            hit: z.ZodDefault<z.ZodBoolean>;
+            key: z.ZodDefault<z.ZodString>;
+        }, {
+            optional: never;
+            defaulted: never;
+            extra: Record<string, unknown>;
+        }>>;
+        placeholder: z.ZodDefault<z.ZodBoolean>;
+    }, {
+        optional: never;
+        defaulted: never;
+        extra: Record<string, unknown>;
+    }>>;
+    pageNumber: z.ZodNumber;
+    pageSize: z.ZodNumber;
+    totalCount: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    items: z.ZodArray<ItemType>;
+}, {}>;
+/**
+ * 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 declare const ImageSchema: z.ZodInterface<{
+    sourceUrl: z.ZodDefault<z.ZodString>;
+    altText: z.ZodDefault<z.ZodString>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+}, {
+    optional: never;
+    defaulted: never;
+    extra: Record<string, unknown>;
+}>;
+export type Image = z.infer<typeof ImageSchema>;