@faststore/api 1.2.23

package/dist/platforms/vtex/clients/search/types/ProductSearchResult.d.ts

@@ -0,0 +1,199 @@
+export interface ProductSearchResult {
+    total: number;
+    products: Product[];
+    pagination: Pagination;
+    sampling: boolean;
+    options: Options;
+    translated: boolean;
+    locale: string;
+    query: string;
+    operator: string;
+    fuzzy: string;
+    correction: Correction;
+}
+export interface Correction {
+    misspelled: boolean;
+}
+export interface Options {
+    sorts: Sort[];
+    counts: Count[];
+}
+export interface Count {
+    count: number;
+    proxyURL: string;
+}
+export interface Sort {
+    field: string;
+    order: string;
+    active?: boolean;
+    proxyURL: string;
+}
+export interface Pagination {
+    count: number;
+    current: Current;
+    before: any[];
+    after: Current[];
+    perPage: number;
+    next: Current;
+    previous: First;
+    first: First;
+    last: Current;
+}
+export interface Current {
+    index: number;
+    proxyURL: string;
+}
+export interface First {
+    index: number;
+}
+export interface Product {
+    unitMultiplier: number;
+    year: number;
+    extraData: ExtraDatum[];
+    release: number;
+    discount: number;
+    reference: string;
+    split: Split;
+    collections: Collection[];
+    price: number;
+    customSort: number;
+    stickers: Sticker[];
+    id: string;
+    stock: number;
+    brand: string;
+    availableTradePolicies: string[];
+    categoryTrees: CategoryTree[];
+    images: Image[];
+    locationAttributes: any[];
+    tax: number;
+    productScore: number;
+    storeSplitAttribute: string;
+    brandID: string;
+    installment: Installment;
+    name: string;
+    boost: Boost;
+    skus: Sku[];
+    link: string;
+    wear: number;
+    description: string;
+    showIfNotAvailable: boolean;
+    clusterHighlights: ClusterHighlights;
+    categories: string[];
+    timestamp: number;
+    product: string;
+    oldPrice: number;
+    productSpecifications: any[];
+    url: string;
+    measurementUnit: string;
+    categoryIDS: string[];
+    textAttributes: TextAttribute[];
+    numberAttributes: NumberAttribute[];
+    headSku: string;
+    specificationGroups: string;
+    extraInfo: ExtraInfo;
+    oldPriceText: string;
+    priceText: string;
+}
+export interface Boost {
+    newness: number;
+    image: number;
+    revenue: number;
+    discount: number;
+    productScore: number;
+    click: number;
+    availableSpecsCount: number;
+    promotion: number;
+    order: number;
+}
+export interface CategoryTree {
+    categoryNames: string[];
+    categoryIDS: string[];
+}
+export interface ClusterHighlights {
+    the140: string;
+}
+export interface Collection {
+    id: string;
+    position: number;
+}
+export interface ExtraDatum {
+    value: string;
+    key: string;
+}
+export interface ExtraInfo {
+    sellerID: string;
+}
+export interface Image {
+    name: string;
+    value: string;
+}
+export interface Installment {
+    interest: boolean;
+    count: number;
+    paymentGroupName: string;
+    value: number;
+    paymentName: string;
+    valueText?: string;
+}
+export interface NumberAttribute {
+    labelKey: string;
+    value: number;
+    key: string;
+}
+export interface Sku {
+    images: Image[];
+    nameComplete: string;
+    complementName: string;
+    policies: Policy[];
+    videos: any[];
+    reference: string;
+    idWithSplit: string;
+    ean: string;
+    name: string;
+    attributes: ExtraDatum[];
+    id: string;
+    sellers: Seller[];
+}
+export interface Policy {
+    id: string;
+    sellers: Seller[];
+}
+export interface Seller {
+    default: boolean;
+    oldPrice?: number;
+    price?: number;
+    installment?: Installment;
+    name: string;
+    tax: number;
+    teasers: any[];
+    id: string;
+}
+export interface Split {
+    labelValue: string;
+    labelKey: string;
+}
+export interface Sticker {
+    image: string;
+    name: string;
+    location: string;
+    target: string;
+}
+export interface TextAttribute {
+    joinedValue: string;
+    isSku: boolean;
+    joinedKey: string;
+    joinedKeyTranslations: JoinedTranslations;
+    isFilter: boolean;
+    labelValue: string;
+    id: string[];
+    labelKey: string;
+    value: string;
+    key: string;
+    joinedValueTranslations: JoinedTranslations;
+    valueID?: string;
+}
+export interface JoinedTranslations {
+    spanish: string;
+    english: string;
+    italian: string;
+}

package/dist/platforms/vtex/index.d.ts

@@ -0,0 +1,144 @@
+import type { Loaders } from './loaders';
+import type { Clients } from './clients';
+export interface Options {
+    platform: 'vtex';
+    account: string;
+    environment: 'vtexcommercestable' | 'vtexcommercebeta';
+    channel: string;
+}
+export interface Context {
+    clients: Clients;
+    loaders: Loaders;
+}
+export declare type Resolver<R = unknown, A = unknown> = (root: R, args: A, ctx: Context, info: any) => any;
+export declare const getContextFactory: (options: Options) => (ctx: any) => any;
+export declare const getResolvers: (_: Options) => {
+    StoreCollection: Record<string, Resolver<import("./clients/commerce/types/Brand").Brand | (import("./clients/commerce/types/CategoryTree").CategoryTree & {
+        level: number;
+    }), unknown>>;
+    StoreAggregateOffer: Record<string, (root: import("./clients/commerce/types/Simulation").Simulation & {
+        product: import("./utils/enhanceSku").EnhancedSku;
+    }) => unknown>;
+    StoreProduct: Record<string, Resolver<import("./utils/enhanceSku").EnhancedSku, unknown>>;
+    StoreSeo: Record<string, Resolver<{
+        title?: string | undefined;
+        description?: string | undefined;
+    }, unknown>>;
+    StoreFacet: Record<string, Resolver<import("./clients/search/types/AttributeSearchResult").Attribute, unknown>>;
+    StoreFacetValue: Record<string, Resolver<import("./clients/search/types/AttributeSearchResult").Value, unknown>>;
+    StoreOffer: Record<string, Resolver<(import("./clients/commerce/types/Simulation").Item & {
+        product: import("./utils/enhanceSku").EnhancedSku;
+    }) | (import("./clients/commerce/types/OrderForm").OrderFormItem & {
+        product: Promise<import("./utils/enhanceSku").EnhancedSku>;
+    }), unknown>>;
+    StoreAggregateRating: Record<string, Resolver<unknown, unknown>>;
+    StoreReview: Record<string, Resolver<unknown, unknown>>;
+    StoreProductGroup: Record<string, Resolver<import("./clients/search/types/ProductSearchResult").Product, unknown>>;
+    StoreSearchResult: Record<string, Resolver<Pick<import("./clients/search").SearchArgs, "query" | "page" | "count" | "sort" | "selectedFacets" | "fuzzy">, unknown>>;
+    Query: {
+        product: (_: unknown, { locator }: import("../..").QueryProductArgs, ctx: Context) => Promise<import("./utils/enhanceSku").EnhancedSku>;
+        search: (_: unknown, { first, after: maybeAfter, sort, term, selectedFacets }: import("../..").QuerySearchArgs) => Promise<{
+            page: number;
+            count: number;
+            query: string | null | undefined;
+            sort: import("./clients/search").Sort;
+            selectedFacets: {
+                key: string;
+                value: string;
+            }[];
+        }>;
+        allProducts: (_: unknown, { first, after: maybeAfter }: import("../..").QueryAllProductsArgs, ctx: Context) => Promise<{
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string;
+                endCursor: string;
+                totalCount: number;
+            };
+            edges: {
+                node: import("./utils/enhanceSku").EnhancedSku;
+                cursor: string;
+            }[];
+        }>;
+        allCollections: (_: unknown, __: import("../..").QueryAllCollectionsArgs, ctx: Context) => Promise<{
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string;
+                endCursor: string;
+            };
+            edges: {
+                node: {
+                    type: string;
+                    id: number;
+                    name: string;
+                    isActive: boolean;
+                    title: string;
+                    metaTagDescription: string;
+                    imageURL: import("../..").Maybe<string>;
+                } | (import("./clients/commerce/types/CategoryTree").CategoryTree & {
+                    level: number;
+                });
+                cursor: string;
+            }[];
+        }>;
+    };
+    Mutation: {
+        validateCart: (_: unknown, { cart: { order: { orderNumber, acceptedOffer }, }, }: {
+            cart: import("../..").IStoreCart;
+        }, ctx: Context) => Promise<{
+            order: {
+                orderNumber: string;
+                acceptedOffer: {
+                    product: Promise<import("./utils/enhanceSku").EnhancedSku>;
+                    id: string;
+                    name: string;
+                    detailUrl: string;
+                    imageUrl: string;
+                    skuName: string;
+                    quantity: number;
+                    uniqueId: string;
+                    productId: string;
+                    refId: string;
+                    ean: string;
+                    priceValidUntil: string;
+                    price: number;
+                    tax: number;
+                    listPrice: number;
+                    sellingPrice: number;
+                    rewardValue: number;
+                    isGift: boolean;
+                    parentItemIndex: number | null;
+                    parentAssemblyBinding: import("../..").Maybe<string>;
+                    productCategoryIds: string;
+                    priceTags: string[];
+                    manualPrice: number;
+                    measurementUnit: string;
+                    additionalInfo: {
+                        brandName: string;
+                        brandId: string;
+                        offeringInfo: any;
+                        offeringType: any;
+                        offeringTypeId: any;
+                    };
+                    productCategories: Record<string, string>;
+                    productRefId: string;
+                    seller: string;
+                    sellerChain: string[];
+                    availability: string;
+                    unitMultiplier: number;
+                    skuSpecifications: import("./clients/commerce/types/OrderForm").SKUSpecification[];
+                    priceDefinition: {
+                        calculatedSellingPrice: number;
+                        sellingPrices: import("./clients/commerce/types/OrderForm").SellingPrice[];
+                        total: number;
+                    };
+                }[];
+            };
+            messages: {
+                text: any;
+                status: any;
+            }[];
+        } | null>;
+    };
+};

package/dist/platforms/vtex/loaders/index.d.ts

@@ -0,0 +1,7 @@
+import type { Options } from '..';
+import type { Clients } from '../clients';
+export declare type Loaders = ReturnType<typeof getLoaders>;
+export declare const getLoaders: (options: Options, clients: Clients) => {
+    skuLoader: import("dataloader")<import("../utils/facets").SelectedFacet[], import("../utils/enhanceSku").EnhancedSku, import("../utils/facets").SelectedFacet[]>;
+    simulationLoader: import("dataloader")<import("../clients/commerce/types/Simulation").PayloadItem[], import("../clients/commerce/types/Simulation").Simulation, import("../clients/commerce/types/Simulation").PayloadItem[]>;
+};

package/dist/platforms/vtex/loaders/simulation.d.ts

@@ -0,0 +1,5 @@
+import DataLoader from 'dataloader';
+import type { PayloadItem, Simulation } from '../clients/commerce/types/Simulation';
+import type { Options } from '..';
+import type { Clients } from '../clients';
+export declare const getSimulationLoader: (_: Options, clients: Clients) => DataLoader<PayloadItem[], Simulation, PayloadItem[]>;

package/dist/platforms/vtex/loaders/sku.d.ts

@@ -0,0 +1,6 @@
+import DataLoader from 'dataloader';
+import type { EnhancedSku } from '../utils/enhanceSku';
+import type { Options } from '..';
+import type { Clients } from '../clients';
+import type { SelectedFacet } from '../utils/facets';
+export declare const getSkuLoader: (_: Options, clients: Clients) => DataLoader<SelectedFacet[], EnhancedSku, SelectedFacet[]>;

package/dist/platforms/vtex/resolvers/aggregateOffer.d.ts

@@ -0,0 +1,7 @@
+import type { EnhancedSku } from '../utils/enhanceSku';
+import type { Simulation } from '../clients/commerce/types/Simulation';
+declare type Resolvers = (root: Simulation & {
+    product: EnhancedSku;
+}) => unknown;
+export declare const StoreAggregateOffer: Record<string, Resolvers>;
+export {};

package/dist/platforms/vtex/resolvers/aggregateRating.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '..';
+export declare const StoreAggregateRating: Record<string, Resolver>;

package/dist/platforms/vtex/resolvers/collection.d.ts

@@ -0,0 +1,8 @@
+import type { Resolver } from '..';
+import type { Brand } from '../clients/commerce/types/Brand';
+import type { CategoryTree } from '../clients/commerce/types/CategoryTree';
+declare type Root = Brand | (CategoryTree & {
+    level: number;
+});
+export declare const StoreCollection: Record<string, Resolver<Root>>;
+export {};

package/dist/platforms/vtex/resolvers/facet.d.ts

@@ -0,0 +1,5 @@
+import type { Resolver } from '..';
+import type { Attribute } from '../clients/search/types/AttributeSearchResult';
+declare type Root = Attribute;
+export declare const StoreFacet: Record<string, Resolver<Root>>;
+export {};

package/dist/platforms/vtex/resolvers/facetValue.d.ts

@@ -0,0 +1,5 @@
+import type { Resolver } from '..';
+import type { Value } from '../clients/search/types/AttributeSearchResult';
+declare type Root = Value;
+export declare const StoreFacetValue: Record<string, Resolver<Root>>;
+export {};

package/dist/platforms/vtex/resolvers/mutation.d.ts

@@ -0,0 +1,58 @@
+export declare const Mutation: {
+    validateCart: (_: unknown, { cart: { order: { orderNumber, acceptedOffer }, }, }: {
+        cart: import("../../..").IStoreCart;
+    }, ctx: import("..").Context) => Promise<{
+        order: {
+            orderNumber: string;
+            acceptedOffer: {
+                product: Promise<import("../utils/enhanceSku").EnhancedSku>;
+                id: string;
+                name: string;
+                detailUrl: string;
+                imageUrl: string;
+                skuName: string;
+                quantity: number;
+                uniqueId: string;
+                productId: string;
+                refId: string;
+                ean: string;
+                priceValidUntil: string;
+                price: number;
+                tax: number;
+                listPrice: number;
+                sellingPrice: number;
+                rewardValue: number;
+                isGift: boolean;
+                parentItemIndex: number | null;
+                parentAssemblyBinding: string | null;
+                productCategoryIds: string;
+                priceTags: string[];
+                manualPrice: number;
+                measurementUnit: string;
+                additionalInfo: {
+                    brandName: string;
+                    brandId: string;
+                    offeringInfo: any;
+                    offeringType: any;
+                    offeringTypeId: any;
+                };
+                productCategories: Record<string, string>;
+                productRefId: string;
+                seller: string;
+                sellerChain: string[];
+                availability: string;
+                unitMultiplier: number;
+                skuSpecifications: import("../clients/commerce/types/OrderForm").SKUSpecification[];
+                priceDefinition: {
+                    calculatedSellingPrice: number;
+                    sellingPrices: import("../clients/commerce/types/OrderForm").SellingPrice[];
+                    total: number;
+                };
+            }[];
+        };
+        messages: {
+            text: any;
+            status: any;
+        }[];
+    } | null>;
+};

package/dist/platforms/vtex/resolvers/offer.d.ts

@@ -0,0 +1,11 @@
+import type { EnhancedSku } from '../utils/enhanceSku';
+import type { Resolver } from '..';
+import type { Item } from '../clients/commerce/types/Simulation';
+import type { OrderFormItem } from '../clients/commerce/types/OrderForm';
+declare type Root = (Item & {
+    product: EnhancedSku;
+}) | (OrderFormItem & {
+    product: Promise<EnhancedSku>;
+});
+export declare const StoreOffer: Record<string, Resolver<Root>>;
+export {};

package/dist/platforms/vtex/resolvers/organization.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '..';
+export declare const StoreOrganization: Record<string, Resolver>;

package/dist/platforms/vtex/resolvers/product.d.ts

@@ -0,0 +1,5 @@
+import type { Resolver } from '..';
+import type { EnhancedSku } from '../utils/enhanceSku';
+declare type Root = EnhancedSku;
+export declare const StoreProduct: Record<string, Resolver<Root>>;
+export {};

package/dist/platforms/vtex/resolvers/productGroup.d.ts

@@ -0,0 +1,3 @@
+import type { Product } from '../clients/search/types/ProductSearchResult';
+import type { Resolver } from '..';
+export declare const StoreProductGroup: Record<string, Resolver<Product>>;

package/dist/platforms/vtex/resolvers/query.d.ts

@@ -0,0 +1,51 @@
+import type { QueryProductArgs, QueryAllCollectionsArgs, QueryAllProductsArgs, QuerySearchArgs } from '../../../__generated__/schema';
+import type { CategoryTree } from '../clients/commerce/types/CategoryTree';
+import type { Context } from '../index';
+export declare const Query: {
+    product: (_: unknown, { locator }: QueryProductArgs, ctx: Context) => Promise<import("../utils/enhanceSku").EnhancedSku>;
+    search: (_: unknown, { first, after: maybeAfter, sort, term, selectedFacets }: QuerySearchArgs) => Promise<{
+        page: number;
+        count: number;
+        query: string | null | undefined;
+        sort: import("../clients/search").Sort;
+        selectedFacets: {
+            key: string;
+            value: string;
+        }[];
+    }>;
+    allProducts: (_: unknown, { first, after: maybeAfter }: QueryAllProductsArgs, ctx: Context) => Promise<{
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor: string;
+            endCursor: string;
+            totalCount: number;
+        };
+        edges: {
+            node: import("../utils/enhanceSku").EnhancedSku;
+            cursor: string;
+        }[];
+    }>;
+    allCollections: (_: unknown, __: QueryAllCollectionsArgs, ctx: Context) => Promise<{
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor: string;
+            endCursor: string;
+        };
+        edges: {
+            node: {
+                type: string;
+                id: number;
+                name: string;
+                isActive: boolean;
+                title: string;
+                metaTagDescription: string;
+                imageURL: import("../../../__generated__/schema").Maybe<string>;
+            } | (CategoryTree & {
+                level: number;
+            });
+            cursor: string;
+        }[];
+    }>;
+};

package/dist/platforms/vtex/resolvers/review.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '..';
+export declare const StoreReview: Record<string, Resolver>;

package/dist/platforms/vtex/resolvers/searchResult.d.ts

@@ -0,0 +1,5 @@
+import type { Resolver } from '..';
+import type { SearchArgs } from '../clients/search';
+declare type Root = Omit<SearchArgs, 'type'>;
+export declare const StoreSearchResult: Record<string, Resolver<Root>>;
+export {};

package/dist/platforms/vtex/resolvers/seo.d.ts

@@ -0,0 +1,7 @@
+import type { Resolver } from '..';
+declare type Root = {
+    title?: string;
+    description?: string;
+};
+export declare const StoreSeo: Record<string, Resolver<Root>>;
+export {};

package/dist/platforms/vtex/resolvers/validateCart.d.ts

@@ -0,0 +1,71 @@
+import type { IStoreCart } from '../../../__generated__/schema';
+import type { Context } from '..';
+/**
+ * This resolver implements the optimistic cart behavior. The main idea in here
+ * is that we receive a cart from the UI (as query params) and we validate it with
+ * the commerce platform. If the cart is valid, we return null, if the cart is
+ * invalid according to the commerce platform, we return the new cart the UI should use
+ * instead
+ *
+ * The algoritm is something like:
+ * 1. Fetch orderForm from VTEX
+ * 2. Compute delta changes between the orderForm and the UI's cart
+ * 3. Update the orderForm in VTEX platform accordingly
+ * 4. If any chages were made, send to the UI the new cart. Null otherwise
+ */
+export declare const validateCart: (_: unknown, { cart: { order: { orderNumber, acceptedOffer }, }, }: {
+    cart: IStoreCart;
+}, ctx: Context) => Promise<{
+    order: {
+        orderNumber: string;
+        acceptedOffer: {
+            product: Promise<import("../utils/enhanceSku").EnhancedSku>;
+            id: string;
+            name: string;
+            detailUrl: string;
+            imageUrl: string;
+            skuName: string;
+            quantity: number;
+            uniqueId: string;
+            productId: string;
+            refId: string;
+            ean: string;
+            priceValidUntil: string;
+            price: number;
+            tax: number;
+            listPrice: number;
+            sellingPrice: number;
+            rewardValue: number;
+            isGift: boolean;
+            parentItemIndex: number | null;
+            parentAssemblyBinding: string | null;
+            productCategoryIds: string;
+            priceTags: string[];
+            manualPrice: number;
+            measurementUnit: string;
+            additionalInfo: {
+                brandName: string;
+                brandId: string;
+                offeringInfo: any;
+                offeringType: any;
+                offeringTypeId: any;
+            };
+            productCategories: Record<string, string>;
+            productRefId: string;
+            seller: string;
+            sellerChain: string[];
+            availability: string;
+            unitMultiplier: number;
+            skuSpecifications: import("../clients/commerce/types/OrderForm").SKUSpecification[];
+            priceDefinition: {
+                calculatedSellingPrice: number;
+                sellingPrices: import("../clients/commerce/types/OrderForm").SellingPrice[];
+                total: number;
+            };
+        }[];
+    };
+    messages: {
+        text: any;
+        status: any;
+    }[];
+} | null>;

package/dist/platforms/vtex/utils/enhanceSku.d.ts

@@ -0,0 +1,5 @@
+import type { Product, Sku } from '../clients/search/types/ProductSearchResult';
+export declare type EnhancedSku = Sku & {
+    isVariantOf: Product;
+};
+export declare const enhanceSku: (sku: Sku, product: Product) => EnhancedSku;

package/dist/platforms/vtex/utils/facets.d.ts

@@ -0,0 +1,12 @@
+export interface SelectedFacet {
+    key: string;
+    value: string;
+}
+/**
+ * Transform facets from the store to VTEX platform facets.
+ * For instance, the channel in Store becames trade-policy in VTEX's realm
+ * */
+export declare const transformSelectedFacet: ({ key, value }: SelectedFacet) => {
+    key: string;
+    value: string;
+};

package/dist/platforms/vtex/utils/slugify.d.ts

@@ -0,0 +1 @@
+export declare const slugify: (path: string) => string;

package/dist/platforms/vtex/utils/sort.d.ts

@@ -0,0 +1,10 @@
+export declare const SORT_MAP: {
+    readonly price_desc: "price:desc";
+    readonly price_asc: "price:asc";
+    readonly orders_desc: "orders:desc";
+    readonly name_desc: "name:desc";
+    readonly name_asc: "name:asc";
+    readonly release_desc: "release:desc";
+    readonly discount_desc: "discount:desc";
+    readonly score_desc: "";
+};

package/dist/typeDefs/index.d.ts

@@ -0,0 +1 @@
+export declare const typeDefs: string;