@spscommerce/asst-api 0.0.1-beta.0

package/dist/msw.d.ts

@@ -0,0 +1,228 @@
+import * as msw from 'msw';
+import { ResponseResolver, RestRequest, RestContext, DefaultBodyType } from 'msw';
+import * as msw_lib_glossary_de6278a9 from 'msw/lib/glossary-de6278a9';
+import { A as AsstClient, V as VendorPartnerAttGroups, d as attrProdTypeSchema, T as TradingPartnerAccessByCompanyId } from './TradingPartnerAccessByCompanyId-479e3e57.js';
+import { c as ImportErrors, I as Import, a as ImportsStatus, b as ItemCategoriesSearch, E as Export } from './ItemCategoriesSearch-1bb945de.js';
+import { z } from 'zod';
+import 'ky-universal';
+import 'ky';
+
+/**
+ * Generate collection of MSW request handlers for `ImportsApi`
+ * @param client Assortment Client instance
+ * @returns An object containing functions to generate MSW request handlers
+ */
+declare function createImportsApiHandlers(client: AsstClient): {
+    getImportErrors: {
+        (resolver?: ResponseResolver<RestRequest<never, {
+            importId: string;
+            offset?: string;
+            limit?: string;
+        }>, RestContext, ImportErrors>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            importId: number;
+            count: number;
+            errors: {
+                attribute: string;
+                description: string;
+                importErrorId: number;
+                row: number;
+            }[];
+            hasNext: boolean;
+            totalCount: number;
+        };
+    };
+    getImports: {
+        (resolver?: ResponseResolver<RestRequest<never, {
+            status?: string;
+        }>, RestContext, Import>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            count: number;
+            imports: {
+                completedAt: number | null;
+                status: string;
+                errorCount: number;
+                importId: number;
+                name: string;
+                startedAt: string | null;
+                uploadedAt: string;
+            }[];
+        };
+    };
+    getImportsStatus: {
+        (resolver?: ResponseResolver<RestRequest<never, never>, RestContext, ImportsStatus[]>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            status: "QUEUED_FOR_IMPORT" | "IN_PROGRESS" | "DOC_FAILED" | "VALIDATION_FAILED" | "COMPLETED";
+            importId: number;
+            name: string;
+            completedAt?: string | null | undefined;
+            docInEventId?: string | null | undefined;
+            errorCount?: number | null | undefined;
+            invalidItemCount?: number | null | undefined;
+            totalItemCount?: number | null | undefined;
+            validItemCount?: number | null | undefined;
+        };
+    };
+    getVendorPartnerGroups: {
+        (resolver?: ResponseResolver<RestRequest<never, never>, RestContext, VendorPartnerAttGroups[]>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            partnerCompanyId: number;
+            partnerCompanyName: string;
+            partnerAttributeGroups: number[];
+        };
+    };
+    uploadImport: (resolver?: ResponseResolver) => msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+    generateImportTemplate: (resolver?: ResponseResolver) => msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+};
+
+/**
+ * Generate collection of MSW request handlers for `CategoriesApi`
+ * @param client Assortment Client instance
+ * @returns An object containing functions to generate MSW request handlers
+ */
+declare function createCategoriesApiHandlers(client: AsstClient): {
+    getCatalogs: {
+        (resolver?: ResponseResolver<RestRequest<never, {
+            categoryName?: string;
+        }>, RestContext, ItemCategoriesSearch>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            data: {
+                type: string;
+                name: string;
+                categoryid: number;
+                companyId: number;
+                isActive: number;
+                createdDate: number | null;
+                categorytimestamp: number | null;
+                typeId: number;
+                categorykey?: string | undefined;
+                description?: string | null | undefined;
+                categoryCatalogName?: string | null | undefined;
+            }[];
+            count: number;
+        };
+    };
+    getProductCodes: {
+        (resolver?: ResponseResolver<RestRequest<never, {
+            categoryName?: string;
+        }>, RestContext, ItemCategoriesSearch>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            data: {
+                type: string;
+                name: string;
+                categoryid: number;
+                companyId: number;
+                isActive: number;
+                createdDate: number | null;
+                categorytimestamp: number | null;
+                typeId: number;
+                categorykey?: string | undefined;
+                description?: string | null | undefined;
+                categoryCatalogName?: string | null | undefined;
+            }[];
+            count: number;
+        };
+    };
+    getSelectionCodes: {
+        (resolver?: ResponseResolver<RestRequest<never, {
+            categoryName?: string;
+        }>, RestContext, ItemCategoriesSearch>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            data: {
+                type: string;
+                name: string;
+                categoryid: number;
+                companyId: number;
+                isActive: number;
+                createdDate: number | null;
+                categorytimestamp: number | null;
+                typeId: number;
+                categorykey?: string | undefined;
+                description?: string | null | undefined;
+                categoryCatalogName?: string | null | undefined;
+            }[];
+            count: number;
+        };
+    };
+};
+
+/**
+ * Generate collection of MSW request handlers for `ExportsApi`
+ * @param client Assortment Client instance
+ * @returns An object containing functions to generate MSW request handlers
+ */
+declare function createExportsApiHandlers(client: AsstClient): {
+    add: (resolver?: ResponseResolver<RestRequest<Export>, RestContext>) => msw.RestHandler<msw_lib_glossary_de6278a9.M<msw_lib_glossary_de6278a9.h>>;
+};
+
+declare function pagedResultsSchema<T extends z.ZodTypeAny>(resultsType: T): z.ZodObject<{
+    next: z.ZodString;
+    previous: z.ZodString;
+    count: z.ZodNumber;
+    results: z.ZodArray<T, "many">;
+}, "strip", z.ZodTypeAny, {
+    count: number;
+    next: string;
+    previous: string;
+    results: T["_output"][];
+}, {
+    count: number;
+    next: string;
+    previous: string;
+    results: T["_input"][];
+}>;
+type PagedResults<T extends z.ZodTypeAny> = z.infer<ReturnType<typeof pagedResultsSchema<T>>>;
+
+/**
+ * Generate collection of MSW request handlers for `ProductTypesApi`
+ * @param client Assortment Client instance
+ * @returns An object containing functions to generate MSW request handlers
+ */
+declare function createProductTypesApiHandlers(client: AsstClient): {
+    getProductTypes: {
+        (resolver?: ResponseResolver<RestRequest<never, {
+            retailerIds: string;
+        }>, RestContext, PagedResults<typeof attrProdTypeSchema>>): msw.RestHandler<msw_lib_glossary_de6278a9.M<DefaultBodyType>>;
+        generateData(): {
+            count: number;
+            next: string;
+            previous: string;
+            results: {
+                description: string;
+                createdDate: number;
+                attrProdTypeId: number;
+                productType: string;
+                createdBy: string;
+                modifiedDate?: number | undefined;
+                modifiedBy?: string | undefined;
+                retailerId?: number | undefined;
+            }[];
+        };
+    };
+};
+
+/**
+ * Generate collection of MSW request handlers for `ProductTypesApi`
+ * @param client Assortment Client instance
+ * @returns An object containing functions to generate MSW request handlers
+ */
+declare function createTradingPartnerAccessApiHandlers(client: AsstClient): {
+    getAllTradingPartners: {
+        (resolver?: ResponseResolver<RestRequest<never>, RestContext, TradingPartnerAccessByCompanyId>): msw.RestHandler<msw_lib_glossary_de6278a9.M<msw_lib_glossary_de6278a9.h>>;
+        generateData(): {
+            count: number;
+            companyId: number;
+            companyType: string;
+            identityOrgId: string;
+            companyName: string;
+            connections: {
+                catalog_id: number;
+                catalog_name: string;
+                partner_company_name: string;
+                partner_company_id: number;
+            }[];
+        };
+    };
+};
+
+export { createCategoriesApiHandlers, createExportsApiHandlers, createImportsApiHandlers, createProductTypesApiHandlers, createTradingPartnerAccessApiHandlers };

package/dist/msw.js

@@ -0,0 +1,190 @@
+import {
+  BASE_URL,
+  BASE_URL2,
+  BASE_URL3,
+  BASE_URL4,
+  BASE_URL5,
+  attrProdTypeSchema,
+  tradingPartnerAccessByCompanyIdSchema
+} from "./chunk-RNUSCCKB.js";
+import "./chunk-LGP22FRF.js";
+import {
+  importErrorsSchema,
+  importSchema,
+  importsStatusSchema,
+  itemCategoriesSearchSchema,
+  vendorPartnerAttGroupsSchema,
+  z
+} from "./chunk-D3ML6E4G.js";
+
+// lib/imports/mockHandlers.ts
+import { generateMock } from "@anatine/zod-mock";
+import {
+  rest
+} from "msw";
+function createImportsApiHandlers(client) {
+  function getImportErrors(resolver = (_req, res, ctx) => {
+    const data = generateMock(importErrorsSchema);
+    res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest.get(`${client.getBaseUrl()}/${BASE_URL}/:importId/errors`, resolver);
+  }
+  getImportErrors.generateData = () => generateMock(importErrorsSchema);
+  function getImports(resolver = (_req, res, ctx) => {
+    const data = generateMock(importSchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest.get(
+      `${client.getBaseUrl()}/${BASE_URL}`,
+      resolver
+    );
+  }
+  getImports.generateData = () => generateMock(importSchema);
+  function getImportsStatus(resolver = (_req, res, ctx) => {
+    const data = generateMock(z.array(importsStatusSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest.get(`${client.getBaseUrl()}/${BASE_URL}/status`, resolver);
+  }
+  getImportsStatus.generateData = () => generateMock(importsStatusSchema);
+  function getVendorPartnerGroups(resolver = (_req, res, ctx) => {
+    const data = generateMock(z.array(vendorPartnerAttGroupsSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest.get(
+      `${client.getBaseUrl()}/${BASE_URL}/template/vendor-partner-groups`,
+      resolver
+    );
+  }
+  getVendorPartnerGroups.generateData = () => generateMock(vendorPartnerAttGroupsSchema);
+  function uploadImport(resolver = (_req, res, ctx) => {
+    return res(ctx.status(200));
+  }) {
+    return rest.post(`${client.getBaseUrl()}/${BASE_URL}`, resolver);
+  }
+  function generateImportTemplate(resolver = (_req, res, ctx) => {
+    return res(ctx.status(400, "Not supported"));
+  }) {
+    return rest.get(
+      `${client.getBaseUrl()}/${BASE_URL}/template/generate`,
+      resolver
+    );
+  }
+  return {
+    getImportErrors,
+    getImports,
+    getImportsStatus,
+    getVendorPartnerGroups,
+    uploadImport,
+    generateImportTemplate
+  };
+}
+
+// lib/categories/mockHandlers.ts
+import { generateMock as generateMock2 } from "@anatine/zod-mock";
+import {
+  rest as rest2
+} from "msw";
+function createCategoriesApiHandlers(client) {
+  function getCatalogs(resolver = (_req, res, ctx) => {
+    const data = generateMock2(itemCategoriesSearchSchema);
+    res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest2.get(
+      `${client.getBaseUrl()}/${BASE_URL5}/search-category?type=CATALOG`,
+      resolver
+    );
+  }
+  getCatalogs.generateData = () => generateMock2(itemCategoriesSearchSchema);
+  function getProductCodes(resolver = (_req, res, ctx) => {
+    const data = generateMock2(itemCategoriesSearchSchema);
+    res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest2.get(
+      `${client.getBaseUrl()}/${BASE_URL5}/search-category?type=PRODUCT_CODE`,
+      resolver
+    );
+  }
+  getProductCodes.generateData = () => generateMock2(itemCategoriesSearchSchema);
+  function getSelectionCodes(resolver = (_req, res, ctx) => {
+    const data = generateMock2(itemCategoriesSearchSchema);
+    res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest2.get(
+      `${client.getBaseUrl()}/${BASE_URL5}/search-category?type=SELECTION_CODE`,
+      resolver
+    );
+  }
+  getSelectionCodes.generateData = () => generateMock2(itemCategoriesSearchSchema);
+  return {
+    getCatalogs,
+    getProductCodes,
+    getSelectionCodes
+  };
+}
+
+// lib/exports/mockHandlers.ts
+import { rest as rest3 } from "msw";
+function createExportsApiHandlers(client) {
+  function add(resolver = (_req, res, ctx) => {
+    return res(ctx.status(200));
+  }) {
+    return rest3.post(`${client.getBaseUrl()}/${BASE_URL2}/add`, resolver);
+  }
+  return {
+    add
+  };
+}
+
+// lib/productTypes/mockHandlers.ts
+import { generateMock as generateMock3 } from "@anatine/zod-mock";
+import {
+  rest as rest4
+} from "msw";
+
+// lib/productTypes/models/PagedResults.ts
+function pagedResultsSchema(resultsType) {
+  return z.object({
+    next: z.string(),
+    previous: z.string(),
+    count: z.number(),
+    results: z.array(resultsType)
+  });
+}
+
+// lib/productTypes/mockHandlers.ts
+function createProductTypesApiHandlers(client) {
+  function getProductTypes(resolver = (_req, res, ctx) => {
+    const data = generateMock3(pagedResultsSchema(attrProdTypeSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest4.get(`${client.getBaseUrl()}/${BASE_URL3}/all`, resolver);
+  }
+  getProductTypes.generateData = () => generateMock3(pagedResultsSchema(attrProdTypeSchema));
+  return {
+    getProductTypes
+  };
+}
+
+// lib/tradingPartners/mockHandlers.ts
+import { generateMock as generateMock4 } from "@anatine/zod-mock";
+import { rest as rest5 } from "msw";
+function createTradingPartnerAccessApiHandlers(client) {
+  function getAllTradingPartners(resolver = (_req, res, ctx) => {
+    const data = generateMock4(tradingPartnerAccessByCompanyIdSchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return rest5.get(`${client.getBaseUrl()}/${BASE_URL4}/connections`, resolver);
+  }
+  getAllTradingPartners.generateData = () => generateMock4(tradingPartnerAccessByCompanyIdSchema);
+  return {
+    getAllTradingPartners
+  };
+}
+export {
+  createCategoriesApiHandlers,
+  createExportsApiHandlers,
+  createImportsApiHandlers,
+  createProductTypesApiHandlers,
+  createTradingPartnerAccessApiHandlers
+};