medusa-strapi-plugin 0.0.13 → 0.0.16

package/src/workflows/steps/upsert-categories-strapi.ts

@@ -0,0 +1,84 @@
+import { ProductCategoryDTO } from "@medusajs/framework/types";
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+import { Modules } from "@medusajs/framework/utils";
+
+type EntryProps = {
+  documentId: string;
+  categoryId: string;
+};
+
+type StepInput = {
+  categories: ProductCategoryDTO[];
+};
+
+export const upsertCategoriesStrapiStep = createStep(
+  "upsert-categories-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    const categories: EntryProps[] = [];
+    const originalMetadata: Record<string, any> = {};
+
+    try {
+      for (const category of input.categories) {
+        // Store original metadata for compensation
+        originalMetadata[category.id] = category.metadata;
+
+        const entry = await strapiModuleService.upsertCategory(category);
+        await productModuleService.updateProductCategories(category.id, {
+          metadata: {
+            ...category.metadata,
+            strapiId: entry.documentId,
+            strapiSyncedAt: new Date().valueOf(),
+          },
+        });
+        categories.push({
+          documentId: entry.documentId,
+          categoryId: category.id,
+        });
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error creating categories in Strapi: ${e.message}`,
+        { categories, originalMetadata },
+      );
+    }
+
+    return new StepResponse(categories, { categories, originalMetadata });
+  },
+  async (compensateInput, { container }) => {
+    if (!compensateInput) return;
+
+    const { categories, originalMetadata } = compensateInput;
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    // Revert metadata changes and delete created entries
+    for (const category of categories) {
+      try {
+        // Revert metadata to original state
+        if (originalMetadata[category.categoryId]) {
+          await productModuleService.updateProductCategories(
+            category.categoryId,
+            {
+              metadata: originalMetadata[category.categoryId],
+            },
+          );
+        }
+
+        // Delete the Strapi entry if it was created
+        await strapiModuleService.deleteCategory(category.categoryId);
+      } catch (error) {
+        console.error(
+          `Failed to compensate category ${category.categoryId}:`,
+          error,
+        );
+      }
+    }
+  },
+);

package/src/workflows/steps/upsert-collections-strapi.ts

@@ -0,0 +1,84 @@
+import { ProductCollectionDTO } from "@medusajs/framework/types";
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+import { Modules } from "@medusajs/framework/utils";
+
+type EntryProps = {
+  documentId: string;
+  collectionId: string;
+};
+
+type StepInput = {
+  collections: ProductCollectionDTO[];
+};
+
+export const upsertCollectionStrapiStep = createStep(
+  "upsert-collections-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    const collections: EntryProps[] = [];
+    const originalMetadata: Record<string, any> = {};
+
+    try {
+      for (const collection of input.collections) {
+        // Store original metadata for compensation
+        originalMetadata[collection.id] = collection.metadata;
+
+        const entry = await strapiModuleService.upsertCollection(collection);
+        await productModuleService.updateProductCollections(collection.id, {
+          metadata: {
+            ...collection.metadata,
+            strapiId: entry.documentId,
+            strapiSyncedAt: new Date().valueOf(),
+          },
+        });
+        collections.push({
+          documentId: entry.documentId,
+          collectionId: collection.id,
+        });
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error creating collections in Strapi: ${e.message}`,
+        { collections, originalMetadata },
+      );
+    }
+
+    return new StepResponse(collections, { collections, originalMetadata });
+  },
+  async (compensateInput, { container }) => {
+    if (!compensateInput) return;
+
+    const { collections, originalMetadata } = compensateInput;
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    // Revert metadata changes and delete created entries
+    for (const collection of collections) {
+      try {
+        // Revert metadata to original state
+        if (originalMetadata[collection.collectionId]) {
+          await productModuleService.updateProductCollections(
+            collection.collectionId,
+            {
+              metadata: originalMetadata[collection.collectionId],
+            },
+          );
+        }
+
+        // Delete the Strapi entry if it was created
+        await strapiModuleService.deleteCollection(collection.collectionId);
+      } catch (error) {
+        console.error(
+          `Failed to compensate collection ${collection.collectionId}:`,
+          error,
+        );
+      }
+    }
+  },
+);

package/src/workflows/steps/upsert-product-variants-strapi.ts

@@ -0,0 +1,83 @@
+import { ProductVariantDTO } from "@medusajs/framework/types";
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+import { Modules } from "@medusajs/framework/utils";
+
+type EntryProps = {
+  documentId: string;
+  variantId: string;
+};
+
+type StepInput = {
+  variants: ProductVariantDTO[];
+};
+
+export const upsertProductVariantsStrapiStep = createStep(
+  "upsert-product-variants-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    const variants: EntryProps[] = [];
+    const originalMetadata: Record<string, any> = {};
+
+    try {
+      for (const variant of input.variants) {
+        // Store original metadata for compensation
+        originalMetadata[variant.id] = variant.metadata;
+
+        const entry = await strapiModuleService.upsertProductVariant(variant);
+        if (entry) {
+          await productModuleService.updateProductVariants(variant.id, {
+            metadata: {
+              ...variant.metadata,
+              strapiId: entry.documentId,
+              strapiSyncedAt: new Date().valueOf(),
+            },
+          });
+          variants.push({
+            documentId: entry.documentId,
+            variantId: variant.id,
+          });
+        }
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error creating variants in Strapi: ${e.message}`,
+        { variants, originalMetadata },
+      );
+    }
+
+    return new StepResponse(variants, { variants, originalMetadata });
+  },
+  async (compensateInput, { container }) => {
+    if (!compensateInput) return;
+
+    const { variants, originalMetadata } = compensateInput;
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    // Revert metadata changes and delete created entries
+    for (const variant of variants) {
+      try {
+        // Revert metadata to original state
+        if (originalMetadata[variant.variantId]) {
+          await productModuleService.updateProductVariants(variant.variantId, {
+            metadata: originalMetadata[variant.variantId],
+          });
+        }
+
+        // Delete the Strapi entry if it was created
+        await strapiModuleService.deleteProductVariant(variant.variantId);
+      } catch (error) {
+        console.error(
+          `Failed to compensate variant ${variant.variantId}:`,
+          error,
+        );
+      }
+    }
+  },
+);

package/src/workflows/steps/upsert-products-strapi.ts

@@ -0,0 +1,81 @@
+import { ProductDTO } from "@medusajs/framework/types";
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+import { Modules } from "@medusajs/framework/utils";
+
+type EntryProps = {
+  documentId: string;
+  productId: string;
+};
+
+type StepInput = {
+  products: ProductDTO[];
+};
+
+export const upsertProductsStrapiStep = createStep(
+  "upsert-products-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    const products: EntryProps[] = [];
+    const originalMetadata: Record<string, any> = {};
+
+    try {
+      for (const product of input.products) {
+        // Store original metadata for compensation
+        originalMetadata[product.id] = product.metadata;
+
+        const entry = await strapiModuleService.upsertProduct(product);
+        await productModuleService.updateProducts(product.id, {
+          metadata: {
+            ...product.metadata,
+            strapiId: entry.documentId,
+            strapiSyncedAt: new Date().valueOf(),
+          },
+        });
+        products.push({
+          documentId: entry.documentId,
+          productId: product.id,
+        });
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error creating products in Strapi: ${e.message}`,
+        { products, originalMetadata },
+      );
+    }
+
+    return new StepResponse(products, { products, originalMetadata });
+  },
+  async (compensateInput, { container }) => {
+    if (!compensateInput) return;
+
+    const { products, originalMetadata } = compensateInput;
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+    const productModuleService = container.resolve(Modules.PRODUCT) as any;
+
+    // Revert metadata changes and delete created entries
+    for (const product of products) {
+      try {
+        // Revert metadata to original state
+        if (originalMetadata[product.productId]) {
+          await productModuleService.updateProducts(product.productId, {
+            metadata: originalMetadata[product.productId],
+          });
+        }
+
+        // Delete the Strapi entry if it was created
+        await strapiModuleService.deleteProduct(product.productId);
+      } catch (error) {
+        console.error(
+          `Failed to compensate product ${product.productId}:`,
+          error,
+        );
+      }
+    }
+  },
+);

package/src/workflows/upsert-categories-strapi.ts

@@ -0,0 +1,30 @@
+import { ProductCategoryDTO } from "@medusajs/framework/types";
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { useQueryGraphStep } from "@medusajs/core-flows";
+import { upsertCategoriesStrapiStep } from "./steps/upsert-categories-strapi";
+
+type WorkflowInput = {
+  category_ids: string[];
+};
+
+export const upsertCategoriesStrapiWorkflow = createWorkflow(
+  { name: "upsert-categories-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const { data } = useQueryGraphStep({
+      entity: "product_category",
+      fields: ["id", "name", "handle", "metadata"],
+      filters: {
+        id: input.category_ids,
+      },
+    });
+
+    const strapiCategories = upsertCategoriesStrapiStep({
+      categories: data as ProductCategoryDTO[],
+    });
+
+    return new WorkflowResponse(strapiCategories);
+  },
+);

package/src/workflows/upsert-collections-strapi.ts

@@ -0,0 +1,30 @@
+import { ProductCollectionDTO } from "@medusajs/framework/types";
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { useQueryGraphStep } from "@medusajs/core-flows";
+import { upsertCollectionStrapiStep } from "./steps/upsert-collections-strapi";
+
+type WorkflowInput = {
+  collection_ids: string[];
+};
+
+export const upsertCollectionsStrapiWorkflow = createWorkflow(
+  { name: "upsert-collection-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const { data } = useQueryGraphStep({
+      entity: "product_collection",
+      fields: ["id", "title", "handle", "metadata"],
+      filters: {
+        id: input.collection_ids,
+      },
+    });
+
+    const strapiCollections = upsertCollectionStrapiStep({
+      collections: data as ProductCollectionDTO[],
+    });
+
+    return new WorkflowResponse(strapiCollections);
+  },
+);

package/src/workflows/upsert-product-variants-strapi.ts

@@ -0,0 +1,30 @@
+import { ProductVariantDTO } from "@medusajs/framework/types";
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { useQueryGraphStep } from "@medusajs/core-flows";
+import { upsertProductVariantsStrapiStep } from "./steps/upsert-product-variants-strapi";
+
+type WorkflowInput = {
+  variant_ids: string[];
+};
+
+export const upsertProductVariantsStrapiWorkflow = createWorkflow(
+  { name: "upsert-product-variants-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const { data } = useQueryGraphStep({
+      entity: "product_variant",
+      fields: ["id", "title", "sku", "product_id", "metadata"],
+      filters: {
+        id: input.variant_ids,
+      },
+    });
+
+    const strapiVariants = upsertProductVariantsStrapiStep({
+      variants: data as ProductVariantDTO[],
+    });
+
+    return new WorkflowResponse(strapiVariants);
+  },
+);

package/src/workflows/upsert-products-strapi.ts

@@ -0,0 +1,36 @@
+import { ProductDTO } from "@medusajs/framework/types";
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { useQueryGraphStep } from "@medusajs/core-flows";
+import { upsertProductsStrapiStep } from "./steps/upsert-products-strapi";
+
+type WorkflowInput = {
+  product_ids: string[];
+};
+
+export const upsertProductsStrapiWorkflow = createWorkflow(
+  { name: "upsert-products-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const { data } = useQueryGraphStep({
+      entity: "product",
+      fields: [
+        "id",
+        "title",
+        "type.value",
+        "status",
+        "handle",
+        "variants.*",
+        "metadata",
+      ],
+      filters: { id: input.product_ids },
+    });
+
+    const strapiProducts = upsertProductsStrapiStep({
+      products: data as ProductDTO[],
+    });
+
+    return new WorkflowResponse(strapiProducts);
+  },
+);