@vtex/api 6.45.4

package/lib/clients/apps/catalogGraphQL/brand.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = `
+query GetBrand($id: ID!) {
+  brand (id: $id) {
+    id
+    name
+    text
+    keywords
+    siteTitle
+    active
+    menuHome
+    adWordsRemarketingCode
+    lomadeeCampaignCode
+    score
+  }
+}
+`;

package/lib/clients/apps/catalogGraphQL/category.d.ts

@@ -0,0 +1,11 @@
+export declare const query = "\nquery GetCategory($id: ID!) {\n  category (id: $id) {\n    id\n    name\n    title\n    parentCategoryId\n    description\n    isActive\n    globalCategoryId\n    score\n  }\n}\n";
+export interface Category {
+    id: string;
+    name: string;
+    title?: string;
+    parentCategoryId?: string;
+    description?: string;
+    isActive: boolean;
+    globalCategoryId: number;
+    score?: number;
+}

package/lib/clients/apps/catalogGraphQL/category.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = `
+query GetCategory($id: ID!) {
+  category (id: $id) {
+    id
+    name
+    title
+    parentCategoryId
+    description
+    isActive
+    globalCategoryId
+    score
+  }
+}
+`;

package/lib/clients/apps/catalogGraphQL/index.d.ts

@@ -0,0 +1,22 @@
+import { AppGraphQLClient } from '..';
+import { InstanceOptions, IOContext } from '../../..';
+import { RequestTracingConfig } from '../../../HttpClient';
+import { Brand } from './brand';
+import { Category } from './category';
+import { Product } from './product';
+import { SKU } from './sku';
+export declare class CatalogGraphQL extends AppGraphQLClient {
+    constructor(ctx: IOContext, opts?: InstanceOptions);
+    sku: (id: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        sku: SKU;
+    } | undefined>;
+    product: (id: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        product: Product;
+    } | undefined>;
+    category: (id: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        category: Category;
+    } | undefined>;
+    brand: (id: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        brand: Brand;
+    } | undefined>;
+}

package/lib/clients/apps/catalogGraphQL/index.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const __1 = require("..");
+const brand_1 = require("./brand");
+const category_1 = require("./category");
+const product_1 = require("./product");
+const sku_1 = require("./sku");
+class CatalogGraphQL extends __1.AppGraphQLClient {
+    constructor(ctx, opts) {
+        super('vtex.catalog-graphql@1.x', ctx, {
+            ...opts,
+            headers: {
+                ...opts && opts.headers,
+                cookie: `VtexIdclientAutCookie=${ctx.authToken}`,
+            }
+        });
+        this.sku = (id, tracingConfig) => {
+            const variables = {
+                identifier: {
+                    field: 'id',
+                    value: id,
+                },
+            };
+            return this.graphql
+                .query({
+                inflight: true,
+                query: sku_1.query,
+                variables,
+            }, {
+                forceMaxAge: 5,
+                tracing: {
+                    requestSpanNameSuffix: 'catalog-sku',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            })
+                .then(ramda_1.prop('data'));
+        };
+        this.product = (id, tracingConfig) => {
+            const variables = {
+                identifier: {
+                    field: 'id',
+                    value: id,
+                },
+            };
+            return this.graphql
+                .query({
+                inflight: true,
+                query: product_1.query,
+                variables,
+            }, {
+                forceMaxAge: 5,
+                tracing: {
+                    requestSpanNameSuffix: 'catalog-product',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            })
+                .then(ramda_1.prop('data'));
+        };
+        this.category = (id, tracingConfig) => this.graphql
+            .query({
+            inflight: true,
+            query: category_1.query,
+            variables: { id },
+        }, {
+            forceMaxAge: 5,
+            tracing: {
+                requestSpanNameSuffix: 'catalog-category',
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        })
+            .then(ramda_1.prop('data'));
+        this.brand = (id, tracingConfig) => this.graphql
+            .query({
+            inflight: true,
+            query: brand_1.query,
+            variables: { id },
+        }, {
+            forceMaxAge: 5,
+            tracing: {
+                requestSpanNameSuffix: 'catalog-brand',
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        })
+            .then(ramda_1.prop('data'));
+    }
+}
+exports.CatalogGraphQL = CatalogGraphQL;

package/lib/clients/apps/catalogGraphQL/product.d.ts

@@ -0,0 +1,25 @@
+export declare const query = "\nquery GetProduct ($identifier: ProductUniqueIdentifier!) {\n  product (identifier: $identifier) {\n    id\n    brandId\n    categoryId\n    departmentId\n    name\n    linkId\n    refId\n    isVisible\n    description\n    shortDescription\n    releaseDate\n    keywords\n    title\n    isActive\n    taxCode\n    metaTagDescription\n    supplierId\n    showWithoutStock\n    score\n    salesChannel {\n      id\n    }\n  }\n}\n";
+export interface Product {
+    id: string;
+    brandId: string;
+    categoryId: string;
+    departmentId: string;
+    name: string;
+    linkId: string;
+    refId?: string;
+    isVisible: boolean;
+    description?: string;
+    shortDescription?: string;
+    releaseDate?: string;
+    keywords: string[];
+    title?: string;
+    isActive: boolean;
+    taxCode?: string;
+    metaTagDescription?: string;
+    supplierId?: string;
+    showWithoutStock: boolean;
+    score?: number;
+    salesChannel?: Array<{
+        id: string;
+    }>;
+}

package/lib/clients/apps/catalogGraphQL/product.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = `
+query GetProduct ($identifier: ProductUniqueIdentifier!) {
+  product (identifier: $identifier) {
+    id
+    brandId
+    categoryId
+    departmentId
+    name
+    linkId
+    refId
+    isVisible
+    description
+    shortDescription
+    releaseDate
+    keywords
+    title
+    isActive
+    taxCode
+    metaTagDescription
+    supplierId
+    showWithoutStock
+    score
+    salesChannel {
+      id
+    }
+  }
+}
+`;

package/lib/clients/apps/catalogGraphQL/sku.d.ts

@@ -0,0 +1,26 @@
+export declare const query = "\nquery GetSKU ($identifier: SKUUniqueIdentifier!) {\n  sku (identifier: $identifier) {\n    id\n    productId\n    isActive\n    name\n    height\n    length\n    width\n    weightKg\n    packagedHeight\n    packagedWidth\n    packagedLength\n    packagedWeightKg\n    cubicWeight\n    isKit\n    creationDate\n    rewardValue\n    manufacturerCode\n    commercialConditionId\n    measurementUnit\n    unitMultiplier\n    modalType\n    kitItensSellApart\n  }\n}\n";
+export interface SKU {
+    id: string;
+    productId: string;
+    isActive: boolean;
+    name: string;
+    height?: number;
+    length?: number;
+    width?: number;
+    weightKg?: number;
+    packagedHeight?: number;
+    packagedWidth?: number;
+    packagedLength?: number;
+    packagedWeightKg?: number;
+    cubicWeight: number;
+    isKit: boolean;
+    creationDate: string;
+    rewardValue?: number;
+    estimatedDateArrival?: string;
+    manufacturerCode: string;
+    commercialConditionId: string;
+    measurementUnit: string;
+    unitMultiplier: number;
+    modalType?: string;
+    kitItensSellApart: boolean;
+}

package/lib/clients/apps/catalogGraphQL/sku.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.query = `
+query GetSKU ($identifier: SKUUniqueIdentifier!) {
+  sku (identifier: $identifier) {
+    id
+    productId
+    isActive
+    name
+    height
+    length
+    width
+    weightKg
+    packagedHeight
+    packagedWidth
+    packagedLength
+    packagedWeightKg
+    cubicWeight
+    isKit
+    creationDate
+    rewardValue
+    manufacturerCode
+    commercialConditionId
+    measurementUnit
+    unitMultiplier
+    modalType
+    kitItensSellApart
+  }
+}
+`;

package/lib/clients/apps/index.d.ts

@@ -0,0 +1,7 @@
+export * from './AppClient';
+export * from './AppGraphQLClient';
+export * from './Billing';
+export * from './Builder';
+export * from './MessagesGraphQL';
+export * from './Settings';
+export * from './catalogGraphQL';

package/lib/clients/apps/index.js

@@ -0,0 +1,12 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./AppClient"));
+__export(require("./AppGraphQLClient"));
+__export(require("./Billing"));
+__export(require("./Builder"));
+__export(require("./MessagesGraphQL"));
+__export(require("./Settings"));
+__export(require("./catalogGraphQL"));

package/lib/clients/external/ExternalClient.d.ts

@@ -0,0 +1,9 @@
+import { InstanceOptions } from '../../HttpClient/typings';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { IOClient } from '../IOClient';
+/**
+ * Used to perform calls to external endpoints for which you have declared outbound access policies in your manifest.
+ */
+export declare class ExternalClient extends IOClient {
+    constructor(baseURL: string, context: IOContext, options?: InstanceOptions);
+}

package/lib/clients/external/ExternalClient.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IOClient_1 = require("../IOClient");
+/**
+ * Used to perform calls to external endpoints for which you have declared outbound access policies in your manifest.
+ */
+class ExternalClient extends IOClient_1.IOClient {
+    constructor(baseURL, context, options) {
+        const { authToken } = context;
+        const headers = options && options.headers || {};
+        super(context, {
+            ...options,
+            baseURL,
+            headers: {
+                ...headers,
+                'Proxy-Authorization': authToken,
+            },
+        });
+    }
+}
+exports.ExternalClient = ExternalClient;

package/lib/clients/external/ID.d.ts

@@ -0,0 +1,23 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { ExternalClient } from './ExternalClient';
+export declare class ID extends ExternalClient {
+    constructor(context: IOContext, opts?: InstanceOptions);
+    getTemporaryToken: (tracingConfig?: RequestTracingConfig | undefined) => Promise<string>;
+    sendCodeToEmail: (token: string, email: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<any>;
+    getEmailCodeAuthenticationToken: (token: string, email: string, code: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<AuthenticationResponse>;
+    getPasswordAuthenticationToken: (token: string, email: string, password: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<AuthenticationResponse>;
+}
+export interface AuthenticationResponse {
+    promptMFA: boolean;
+    clientToken: any;
+    authCookie: {
+        Name: string;
+        Value: string;
+    };
+    accountAuthCookie: any;
+    expiresIn: number;
+    userId: string;
+    phoneNumber: string;
+    scope: any;
+}

package/lib/clients/external/ID.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ExternalClient_1 = require("./ExternalClient");
+const routes = {
+    SEND: '/accesskey/send',
+    START: '/start',
+    VALIDATE: '/accesskey/validate',
+    VALIDATE_CLASSIC: '/classic/validate',
+};
+const VTEXID_ENDPOINTS = {
+    STABLE: 'https://vtexid.vtex.com.br/api/vtexid/pub/authentication',
+};
+const endpoint = (env) => {
+    return VTEXID_ENDPOINTS[env] || env;
+};
+class ID extends ExternalClient_1.ExternalClient {
+    constructor(context, opts) {
+        super(endpoint(VTEXID_ENDPOINTS.STABLE), context, opts);
+        this.getTemporaryToken = (tracingConfig) => {
+            const metric = 'vtexid-temp-token';
+            return this.http.get(routes.START, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } }).then(({ authenticationToken }) => authenticationToken);
+        };
+        this.sendCodeToEmail = (token, email, tracingConfig) => {
+            const params = { authenticationToken: token, email };
+            const metric = 'vtexid-send-code';
+            return this.http.get(routes.SEND, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getEmailCodeAuthenticationToken = (token, email, code, tracingConfig) => {
+            const params = {
+                accesskey: code,
+                authenticationToken: token,
+                login: email,
+            };
+            const metric = 'vtexid-email-token';
+            return this.http.get(routes.VALIDATE, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getPasswordAuthenticationToken = (token, email, password, tracingConfig) => {
+            const params = {
+                authenticationToken: token,
+                login: email,
+                password,
+            };
+            const metric = 'vtexid-pass-token';
+            return this.http.get(routes.VALIDATE_CLASSIC, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+    }
+}
+exports.ID = ID;

package/lib/clients/external/Masterdata.d.ts

@@ -0,0 +1,93 @@
+import { InstanceOptions, IOContext, RequestTracingConfig } from '../..';
+import { ExternalClient } from './ExternalClient';
+export declare class MasterData extends ExternalClient {
+    constructor(ctx: IOContext, options?: InstanceOptions);
+    getSchema<T>({ dataEntity, schema }: GetSchemaInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    createOrUpdateSchema<T>({ dataEntity, schemaName, schemaBody }: CreateSchemaInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    getPublicSchema<T>({ dataEntity, schema }: GetSchemaInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    getDocument<T>({ dataEntity, id, fields }: GetDocumentInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    createDocument({ dataEntity, fields, schema }: CreateDocumentInput, tracingConfig?: RequestTracingConfig): Promise<DocumentResponse>;
+    createOrUpdateEntireDocument({ dataEntity, fields, id, schema }: CreateOrUpdateInput, tracingConfig?: RequestTracingConfig): Promise<DocumentResponse>;
+    createOrUpdatePartialDocument({ dataEntity, fields, id, schema }: CreateOrUpdateInput, tracingConfig?: RequestTracingConfig): Promise<DocumentResponse>;
+    updateEntireDocument({ dataEntity, id, fields, schema }: UpdateInput, tracingConfig?: RequestTracingConfig): Promise<void>;
+    updatePartialDocument({ dataEntity, id, fields, schema }: UpdateInput, tracingConfig?: RequestTracingConfig): Promise<void>;
+    searchDocuments<T>({ dataEntity, fields, where, pagination, schema, sort }: SearchInput, tracingConfig?: RequestTracingConfig): Promise<T[]>;
+    searchDocumentsWithPaginationInfo<T>({ dataEntity, fields, where, pagination, schema, sort }: SearchInput, tracingConfig?: RequestTracingConfig): Promise<{
+        data: T[];
+        pagination: {
+            total: number;
+            page: number;
+            pageSize: number;
+        };
+    }>;
+    scrollDocuments<T>({ dataEntity, fields, mdToken, schema, size, sort }: ScrollInput, tracingConfig?: RequestTracingConfig): Promise<{
+        mdToken: string;
+        data: ScrollResponse<T>;
+    }>;
+    deleteDocument({ dataEntity, id }: DeleteInput, tracingConfig?: RequestTracingConfig): Promise<import("../..").IOResponse<void>>;
+}
+interface PaginationArgs {
+    page: number;
+    pageSize: number;
+}
+interface DocumentResponse {
+    Id: string;
+    Href: string;
+    DocumentId: string;
+}
+interface GetSchemaInput {
+    dataEntity: string;
+    schema: string;
+}
+interface CreateSchemaInput {
+    dataEntity: string;
+    schemaName: string;
+    schemaBody: object;
+}
+interface GetDocumentInput {
+    dataEntity: string;
+    id: string;
+    fields: string[];
+}
+interface CreateDocumentInput {
+    dataEntity: string;
+    fields: object;
+    schema?: string;
+}
+interface CreateOrUpdateInput {
+    dataEntity: string;
+    fields: object;
+    id?: string;
+    schema?: string;
+}
+interface UpdateInput {
+    dataEntity: string;
+    id: string;
+    fields: object;
+    schema?: string;
+}
+interface SearchInput {
+    dataEntity: string;
+    fields: string[];
+    where?: string;
+    pagination: PaginationArgs;
+    schema?: string;
+    sort?: string;
+}
+interface ScrollInput {
+    dataEntity: string;
+    fields: string[];
+    schema?: string;
+    sort?: string;
+    size?: number;
+    mdToken?: string;
+}
+interface DeleteInput {
+    dataEntity: string;
+    id: string;
+}
+interface ScrollResponse<T> {
+    data: T[];
+    mdToken: string;
+}
+export {};