medusa-strapi-plugin 0.0.13 → 0.0.16

package/src/subscribers/create-product.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertProductsStrapiWorkflow } from "../workflows/upsert-products-strapi";
+
+export default async function handleProductCreate({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await upsertProductsStrapiWorkflow(container as any).run({
+    input: {
+      product_ids: [data.id],
+    },
+  });
+
+  logger.log("Product created in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product.created",
+};

package/src/subscribers/create-variant.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertProductVariantsStrapiWorkflow } from "../workflows/upsert-product-variants-strapi";
+
+export default async function handleProductVariantCreate({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await upsertProductVariantsStrapiWorkflow(container as any).run({
+    input: {
+      variant_ids: [data.id],
+    },
+  });
+
+  logger.log("Product Variant created in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product-variant.created",
+};

package/src/subscribers/delete-category.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { deleteCategoriesStrapiWorkflow } from "../workflows/delete-categories-strapi";
+
+export default async function handleCategoryDelete({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await deleteCategoriesStrapiWorkflow(container as any).run({
+    input: {
+      category_ids: [data.id],
+    },
+  });
+
+  logger.log("Category deleted in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product-category.deleted",
+};

package/src/subscribers/delete-collection.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { deleteCollectionsStrapiWorkflow } from "../workflows/delete-collections-strapi";
+
+export default async function handleCollectionDelete({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await deleteCollectionsStrapiWorkflow(container as any).run({
+    input: {
+      collection_ids: [data.id],
+    },
+  });
+
+  logger.log("Collection deleted in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product-collection.deleted",
+};

package/src/subscribers/delete-product.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { deleteProductsStrapiWorkflow } from "../workflows/delete-products-strapi";
+
+export default async function handleProductDelete({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await deleteProductsStrapiWorkflow(container as any).run({
+    input: {
+      product_ids: [data.id],
+    },
+  });
+
+  logger.log("Product deleted in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product.deleted",
+};

package/src/subscribers/delete-variant.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { deleteProductVariantsStrapiWorkflow } from "../workflows/delete-product-variants-strapi";
+
+export default async function handleProductVariantDelete({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await deleteProductVariantsStrapiWorkflow(container as any).run({
+    input: {
+      variant_ids: [data.id],
+    },
+  });
+
+  logger.log("Product variant deleted in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product-variant.deleted",
+};

package/src/subscribers/sync-categories.ts

@@ -0,0 +1,44 @@
+import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertCategoriesStrapiWorkflow } from "../workflows/upsert-categories-strapi";
+
+export default async function syncCategoriesHandler({
+  container,
+}: SubscriberArgs<Record<string, unknown>>) {
+  const query = container.resolve(ContainerRegistrationKeys.QUERY);
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  const batchSize = 100;
+  let hasMore = true;
+  let offset = 0;
+  let totalCount = 0;
+
+  while (hasMore) {
+    const { data: categories, metadata: { count } = {} } = await query.graph({
+      entity: "product_category",
+      fields: ["id"],
+      pagination: {
+        skip: offset,
+        take: batchSize,
+      },
+    });
+
+    if (categories.length) {
+      await upsertCategoriesStrapiWorkflow(container as any).run({
+        input: {
+          category_ids: categories.map((category) => category.id),
+        },
+      });
+    }
+
+    hasMore = categories.length === batchSize;
+    offset += batchSize;
+    totalCount = count ?? 0;
+  }
+
+  logger.log(`Synced ${totalCount} categories to Strapi`);
+}
+
+export const config: SubscriberConfig = {
+  event: "strapi-categories.sync",
+};

package/src/subscribers/sync-collections.ts

@@ -0,0 +1,44 @@
+import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertCollectionsStrapiWorkflow } from "../workflows/upsert-collections-strapi";
+
+export default async function syncCollectionsHandler({
+  container,
+}: SubscriberArgs<Record<string, unknown>>) {
+  const query = container.resolve(ContainerRegistrationKeys.QUERY);
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  const batchSize = 100;
+  let hasMore = true;
+  let offset = 0;
+  let totalCount = 0;
+
+  while (hasMore) {
+    const { data: collections, metadata: { count } = {} } = await query.graph({
+      entity: "product_collection",
+      fields: ["id"],
+      pagination: {
+        skip: offset,
+        take: batchSize,
+      },
+    });
+
+    if (collections.length) {
+      await upsertCollectionsStrapiWorkflow(container as any).run({
+        input: {
+          collection_ids: collections.map((collection) => collection.id),
+        },
+      });
+    }
+
+    hasMore = collections.length === batchSize;
+    offset += batchSize;
+    totalCount = count ?? 0;
+  }
+
+  logger.log(`Synced ${totalCount} collections to Strapi`);
+}
+
+export const config: SubscriberConfig = {
+  event: "strapi-collections.sync",
+};

package/src/subscribers/sync-products.ts

@@ -0,0 +1,44 @@
+import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertProductsStrapiWorkflow } from "../workflows/upsert-products-strapi";
+
+export default async function syncProductsHandler({
+  container,
+}: SubscriberArgs<Record<string, unknown>>) {
+  const query = container.resolve(ContainerRegistrationKeys.QUERY);
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  const batchSize = 100;
+  let hasMore = true;
+  let offset = 0;
+  let totalCount = 0;
+
+  while (hasMore) {
+    const { data: products, metadata: { count } = {} } = await query.graph({
+      entity: "product",
+      fields: ["id"],
+      pagination: {
+        skip: offset,
+        take: batchSize,
+      },
+    });
+
+    if (products.length) {
+      await upsertProductsStrapiWorkflow(container as any).run({
+        input: {
+          product_ids: products.map((product) => product.id),
+        },
+      });
+    }
+
+    hasMore = products.length === batchSize;
+    offset += batchSize;
+    totalCount = count ?? 0;
+  }
+
+  logger.log(`Synced ${totalCount} products to Strapi`);
+}
+
+export const config: SubscriberConfig = {
+  event: "strapi-products.sync",
+};

package/src/subscribers/update-category.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertCategoriesStrapiWorkflow } from "../workflows/upsert-categories-strapi";
+
+export default async function handleCategoryUpdate({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await upsertCategoriesStrapiWorkflow(container as any).run({
+    input: {
+      category_ids: [data.id],
+    },
+  });
+
+  logger.log("Category updated in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product-category.updated",
+};

package/src/subscribers/update-collection.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertCollectionsStrapiWorkflow } from "../workflows/upsert-collections-strapi";
+
+export default async function handleCollectionUpdate({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await upsertCollectionsStrapiWorkflow(container as any).run({
+    input: {
+      collection_ids: [data.id],
+    },
+  });
+
+  logger.log("Collection updated in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product-collection.updated",
+};

package/src/subscribers/update-product.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertProductsStrapiWorkflow } from "../workflows/upsert-products-strapi";
+
+export default async function handleProductUpdate({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await upsertProductsStrapiWorkflow(container as any).run({
+    input: {
+      product_ids: [data.id],
+    },
+  });
+
+  logger.log("Product updated in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product.updated",
+};

package/src/subscribers/update-variant.ts

@@ -0,0 +1,25 @@
+import {
+  type SubscriberArgs,
+  type SubscriberConfig,
+} from "@medusajs/framework";
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { upsertProductVariantsStrapiWorkflow } from "../workflows/upsert-product-variants-strapi";
+
+export default async function handleProductVariantUpdate({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  await upsertProductVariantsStrapiWorkflow(container as any).run({
+    input: {
+      variant_ids: [data.id],
+    },
+  });
+
+  logger.log("Product Variant updated in Strapi");
+}
+
+export const config: SubscriberConfig = {
+  event: "product-variant.updated",
+};

package/src/workflows/README.md

@@ -0,0 +1,69 @@
+# Custom Workflows
+
+A workflow is a series of queries and actions that complete a task.
+
+The workflow is created in a TypeScript or JavaScript file under the `src/workflows` directory.
+
+For example:
+
+```ts
+import {
+  createStep,
+  createWorkflow,
+  WorkflowResponse,
+  StepResponse,
+} from "@medusajs/framework/workflows-sdk";
+
+const step1 = createStep("step-1", async () => {
+  return new StepResponse(`Hello from step one!`);
+});
+
+type WorkflowInput = {
+  name: string;
+};
+
+const step2 = createStep("step-2", async ({ name }: WorkflowInput) => {
+  return new StepResponse(`Hello ${name} from step two!`);
+});
+
+type WorkflowOutput = {
+  message1: string;
+  message2: string;
+};
+
+const helloWorldWorkflow = createWorkflow(
+  "hello-world",
+  (input: WorkflowInput) => {
+    const greeting1 = step1();
+    const greeting2 = step2(input);
+
+    return new WorkflowResponse({
+      message1: greeting1,
+      message2: greeting2,
+    });
+  },
+);
+
+export default helloWorldWorkflow;
+```
+
+## Execute Workflow
+
+You can execute the workflow from other resources, such as API routes, scheduled jobs, or subscribers.
+
+For example, to execute the workflow in an API route:
+
+```ts
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import myWorkflow from "../../../workflows/hello-world";
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const { result } = await myWorkflow(req.scope).run({
+    input: {
+      name: req.query.name as string,
+    },
+  });
+
+  res.send(result);
+}
+```

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

@@ -0,0 +1,20 @@
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { deleteCategoriesStrapiStep } from "./steps/delete-categories-strapi";
+
+type WorkflowInput = {
+  category_ids: string[];
+};
+
+export const deleteCategoriesStrapiWorkflow = createWorkflow(
+  { name: "delete-categories-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const strapiCategories = deleteCategoriesStrapiStep({
+      category_ids: input.category_ids,
+    });
+
+    return new WorkflowResponse(strapiCategories);
+  },
+);

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

@@ -0,0 +1,20 @@
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { deleteCollectionsStrapiStep } from "./steps/delete-collections-strapi";
+
+type WorkflowInput = {
+  collection_ids: string[];
+};
+
+export const deleteCollectionsStrapiWorkflow = createWorkflow(
+  { name: "delete-collections-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const strapiCollections = deleteCollectionsStrapiStep({
+      collection_ids: input.collection_ids,
+    });
+
+    return new WorkflowResponse(strapiCollections);
+  },
+);

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

@@ -0,0 +1,20 @@
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { deleteProductVariantsStrapiStep } from "./steps/delete-product-variants-strapi";
+
+type WorkflowInput = {
+  variant_ids: string[];
+};
+
+export const deleteProductVariantsStrapiWorkflow = createWorkflow(
+  { name: "delete-product-variants-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const strapiProductVariants = deleteProductVariantsStrapiStep({
+      variant_ids: input.variant_ids,
+    });
+
+    return new WorkflowResponse(strapiProductVariants);
+  },
+);

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

@@ -0,0 +1,20 @@
+import {
+  createWorkflow,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk";
+import { deleteProductsStrapiStep } from "./steps/delete-products-strapi";
+
+type WorkflowInput = {
+  product_ids: string[];
+};
+
+export const deleteProductsStrapiWorkflow = createWorkflow(
+  { name: "delete-products-strapi-workflow" },
+  (input: WorkflowInput) => {
+    const strapiProducts = deleteProductsStrapiStep({
+      product_ids: input.product_ids,
+    });
+
+    return new WorkflowResponse(strapiProducts);
+  },
+);

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

@@ -0,0 +1,29 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+
+type StepInput = {
+  category_ids: string[];
+};
+
+export const deleteCategoriesStrapiStep = createStep(
+  "delete-categories-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+
+    const categories: (string | null)[] = [];
+
+    try {
+      for (const category_id of input.category_ids) {
+        categories.push(await strapiModuleService.deleteCategory(category_id));
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error deleting categories in Strapi: ${e.message}`,
+      );
+    }
+
+    return new StepResponse(categories, categories);
+  },
+);

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

@@ -0,0 +1,31 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+
+type StepInput = {
+  collection_ids: string[];
+};
+
+export const deleteCollectionsStrapiStep = createStep(
+  "delete-collections-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+
+    const collections: (string | null)[] = [];
+
+    try {
+      for (const collection_id of input.collection_ids) {
+        collections.push(
+          await strapiModuleService.deleteCollection(collection_id),
+        );
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error deleting collections in Strapi: ${e.message}`,
+      );
+    }
+
+    return new StepResponse(collections, collections);
+  },
+);

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

@@ -0,0 +1,31 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+
+type StepInput = {
+  variant_ids: string[];
+};
+
+export const deleteProductVariantsStrapiStep = createStep(
+  "delete-product-variants-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+
+    const variants: (string | null)[] = [];
+
+    try {
+      for (const variant_id of input.variant_ids) {
+        variants.push(
+          await strapiModuleService.deleteProductVariant(variant_id),
+        );
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error deleting product variants in Strapi: ${e.message}`,
+      );
+    }
+
+    return new StepResponse(variants, variants);
+  },
+);

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

@@ -0,0 +1,29 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk";
+import { STRAPI_MODULE } from "../../modules/strapi";
+import StrapiModuleService from "../../modules/strapi/service";
+
+type StepInput = {
+  product_ids: string[];
+};
+
+export const deleteProductsStrapiStep = createStep(
+  "delete-products-strapi-step",
+  async (input: StepInput, { container }) => {
+    const strapiModuleService: StrapiModuleService =
+      container.resolve(STRAPI_MODULE);
+
+    const products: (string | null)[] = [];
+
+    try {
+      for (const product_id of input.product_ids) {
+        products.push(await strapiModuleService.deleteProduct(product_id));
+      }
+    } catch (e) {
+      return StepResponse.permanentFailure(
+        `Error deleting products in Strapi: ${e.message}`,
+      );
+    }
+
+    return new StepResponse(products, products);
+  },
+);