@reactionary/medusa 0.6.3

package/capabilities/category.capability.js

@@ -0,0 +1,216 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  CategoryIdentifierSchema,
+  CategoryCapability,
+  CategorySchema,
+  CategoryQueryByIdSchema,
+  CategoryQueryBySlugSchema,
+  CategoryQueryForBreadcrumbSchema,
+  CategoryQueryForChildCategoriesSchema,
+  CategoryQueryForTopCategoriesSchema,
+  createPaginatedResponseSchema,
+  Reactionary,
+  success,
+  error,
+  CategoryPaginatedResultSchema
+} from "@reactionary/core";
+import * as z from "zod";
+class MedusaCategoryCapability extends CategoryCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  factory;
+  async resolveCategoryIdByExternalId(externalId) {
+    const sdk = await this.medusaApi.getClient();
+    let offset = 0;
+    const limit = 50;
+    let candidate = void 0;
+    while (true) {
+      try {
+        const categoryResult = await sdk.store.category.list({
+          offset,
+          limit
+        });
+        if (categoryResult.product_categories.length === 0) {
+          break;
+        }
+        candidate = categoryResult.product_categories.find(
+          (cat) => cat.metadata?.["external_id"] === externalId
+        );
+        if (candidate) {
+          break;
+        }
+        offset += limit;
+      } catch (error2) {
+        throw new Error(
+          "Category not found " + externalId + " due to error: " + error2
+        );
+        break;
+      }
+    }
+    return candidate || null;
+  }
+  async getById(payload) {
+    const candidate = await this.resolveCategoryIdByExternalId(payload.id.key);
+    if (!candidate) {
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+    return success(this.parseSingle(candidate));
+  }
+  getBySlugPayload(payload) {
+    return {
+      handle: payload.slug,
+      limit: 1,
+      offset: 0
+    };
+  }
+  async getBySlug(payload) {
+    const sdk = await this.medusaApi.getClient();
+    const categoryResult = await sdk.store.category.list(this.getBySlugPayload(payload));
+    if (categoryResult.count === 0) {
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
+    }
+    return success(this.parseSingle(categoryResult.product_categories[0]));
+  }
+  async getBreadcrumbPathToCategory(payload) {
+    const actualCategoryId = await this.resolveCategoryIdByExternalId(
+      payload.id.key
+    );
+    if (!actualCategoryId) {
+      throw new Error("Category not found " + payload.id.key);
+    }
+    const sdk = await this.medusaApi.getClient();
+    const path = await sdk.store.category.retrieve(actualCategoryId.id, {
+      fields: "+metadata,+parent_category.metadata",
+      include_ancestors_tree: true
+    });
+    let results = new Array();
+    let current = path.product_category;
+    while (current) {
+      results.push(this.parseSingle(current));
+      current = current.parent_category;
+    }
+    results = results.reverse();
+    return success(results);
+  }
+  findChildCategoriesPayload(payload, actualParent) {
+    return {
+      fields: "+metadata,+parent_category.metadata",
+      parent_category_id: actualParent.id,
+      limit: payload.paginationOptions.pageSize,
+      offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize
+    };
+  }
+  async findChildCategories(payload) {
+    const sdk = await this.medusaApi.getClient();
+    const actualParent = await this.resolveCategoryIdByExternalId(
+      payload.parentId.key
+    );
+    if (!actualParent) {
+      throw new Error("Parent category not found " + payload.parentId.key);
+    }
+    const response = await sdk.store.category.list(this.findChildCategoriesPayload(payload, actualParent));
+    const result = this.parsePaginatedResult(response);
+    return success(result);
+  }
+  findTopCategoriesPayload(payload) {
+    return {
+      fields: "+metadata",
+      parent_category_id: "null",
+      limit: payload.paginationOptions.pageSize,
+      offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize
+    };
+  }
+  async findTopCategories(payload) {
+    const sdk = await this.medusaApi.getClient();
+    const response = await sdk.store.category.list(this.findTopCategoriesPayload(payload));
+    const result = this.parsePaginatedResult(response);
+    return success(result);
+  }
+  parseSingle(_body) {
+    const identifier = CategoryIdentifierSchema.parse({
+      key: _body.metadata?.["external_id"] || ""
+    });
+    const name = _body.name;
+    const slug = _body.handle;
+    const text = _body.description || _body.name || "";
+    const parentCategory = _body.parent_category_id ? { key: _body.parent_category?.metadata?.["external_id"] + "" || "" } : void 0;
+    const result = {
+      identifier,
+      name,
+      slug,
+      text,
+      parentCategory,
+      images: []
+    };
+    return this.factory.parseCategory(this.context, result);
+  }
+  parsePaginatedResult(body) {
+    const items = body.product_categories.map((x) => this.parseSingle(x));
+    const totalPages = Math.ceil(
+      (body.count ?? 0) / Math.max(body.product_categories.length, 1)
+    );
+    const pageNumber = body.count === 0 ? 1 : Math.floor(body.offset / body.product_categories.length) + 1;
+    const result = {
+      pageNumber,
+      pageSize: Math.max(body.product_categories.length, 1),
+      totalCount: body.count,
+      totalPages,
+      items
+    };
+    return this.factory.parseCategoryPaginatedResult(this.context, result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryByIdSchema,
+    outputSchema: CategorySchema
+  })
+], MedusaCategoryCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryBySlugSchema,
+    outputSchema: CategorySchema.nullable()
+  })
+], MedusaCategoryCapability.prototype, "getBySlug", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForBreadcrumbSchema,
+    outputSchema: z.array(CategorySchema)
+  })
+], MedusaCategoryCapability.prototype, "getBreadcrumbPathToCategory", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForChildCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], MedusaCategoryCapability.prototype, "findChildCategories", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: CategoryQueryForTopCategoriesSchema,
+    outputSchema: CategoryPaginatedResultSchema
+  })
+], MedusaCategoryCapability.prototype, "findTopCategories", 1);
+export {
+  MedusaCategoryCapability
+};