medusa-strapi-plugin 0.0.13 → 0.0.16

package/src/modules/README.md

@@ -0,0 +1,113 @@
+# Custom Module
+
+A module is a package of reusable functionalities. It can be integrated into your Medusa application without affecting the overall system. You can create a module as part of a plugin.
+
+Learn more about modules in [this documentation](https://docs.medusajs.com/learn/fundamentals/modules).
+
+To create a module:
+
+## 1. Create a Data Model
+
+A data model represents a table in the database. You create a data model in a TypeScript or JavaScript file under the `models` directory of a module.
+
+For example, create the file `src/modules/blog/models/post.ts` with the following content:
+
+```ts
+import { model } from "@medusajs/framework/utils";
+
+const Post = model.define("post", {
+  id: model.id().primaryKey(),
+  title: model.text(),
+});
+
+export default Post;
+```
+
+## 2. Create a Service
+
+A module must define a service. A service is a TypeScript or JavaScript class holding methods related to a business logic or commerce functionality.
+
+For example, create the file `src/modules/blog/service.ts` with the following content:
+
+```ts
+import { MedusaService } from "@medusajs/framework/utils";
+import Post from "./models/post";
+
+class BlogModuleService extends MedusaService({
+  Post,
+}) {}
+
+export default BlogModuleService;
+```
+
+## 3. Export Module Definition
+
+A module must have an `index.ts` file in its root directory that exports its definition. The definition specifies the main service of the module.
+
+For example, create the file `src/modules/blog/index.ts` with the following content:
+
+```ts
+import BlogModuleService from "./service";
+import { Module } from "@medusajs/framework/utils";
+
+export const BLOG_MODULE = "blog";
+
+export default Module(BLOG_MODULE, {
+  service: BlogModuleService,
+});
+```
+
+## 4. Generate Migrations
+
+To generate migrations for your module, run the following command in the plugin's directory:
+
+```bash
+npx medusa plugin:db:generate
+```
+
+## Use Module
+
+You can use the module in customizations within the plugin or within the Medusa application using this plugin. When the plugin is added to a Medusa application, all its modules are registered as well.
+
+For example, to use the module in an API route:
+
+```ts
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import BlogModuleService from "../../../modules/blog/service";
+import { BLOG_MODULE } from "../../../modules/blog";
+
+export async function GET(
+  req: MedusaRequest,
+  res: MedusaResponse,
+): Promise<void> {
+  const blogModuleService: BlogModuleService = req.scope.resolve(BLOG_MODULE);
+
+  const posts = await blogModuleService.listPosts();
+
+  res.json({
+    posts,
+  });
+}
+```
+
+## Module Options
+
+When you register the plugin in the Medusa application, it can accept options. These options are passed to the modules within the plugin:
+
+```ts
+import { defineConfig } from "@medusajs/framework/utils";
+
+module.exports = defineConfig({
+  // ...
+  plugins: [
+    {
+      resolve: "@myorg/plugin-name",
+      options: {
+        apiKey: process.env.API_KEY,
+      },
+    },
+  ],
+});
+```
+
+Learn more about module options in [this documentation](https://docs.medusajs.com/learn/fundamentals/modules/options).

package/src/modules/strapi/index.ts

@@ -0,0 +1,10 @@
+import { Module } from "@medusajs/framework/utils";
+import createContentModelsLoader from "./loader/create-content-models";
+import StrapiModuleService from "./service";
+
+export const STRAPI_MODULE = "strapi";
+
+export default Module(STRAPI_MODULE, {
+  service: StrapiModuleService,
+  loaders: [createContentModelsLoader],
+});

package/src/modules/strapi/loader/create-content-models.ts

@@ -0,0 +1,144 @@
+import { LoaderOptions } from "@medusajs/framework/types";
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+} from "@medusajs/framework/utils";
+import qs from "qs";
+
+export type ModuleOptions = {
+  base_url: string;
+  api_key: string;
+  default_locale?: string;
+  system_id_key?: string;
+};
+
+export default async function syncContentModelsLoader({
+  container,
+  options,
+}: LoaderOptions<ModuleOptions>) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER);
+
+  if (!options?.base_url || !options?.api_key) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      "Strapi api key and base URL are required",
+    );
+  }
+
+  const systemIdKey = options.system_id_key || "systemId";
+
+  logger.debug(`Strapi baseURL: ${options.base_url}`);
+
+  // Validate that required content types exist with correct structure
+  await validateContentTypes(options, logger, systemIdKey);
+
+  logger.info("Connected to Strapi");
+}
+
+async function validateContentTypes(
+  options: ModuleOptions,
+  logger: any,
+  systemIdKey: string,
+) {
+  const requiredContentTypes = [
+    {
+      name: "products",
+      requiredFields: ["title", systemIdKey, "handle", "productType"],
+      relations: { variants: { fields: ["title", systemIdKey, "sku"] } },
+    },
+    {
+      name: "product-variants",
+      requiredFields: ["title", systemIdKey, "sku"],
+      relations: { product: {} },
+    },
+    {
+      name: "categories",
+      requiredFields: ["title", systemIdKey, "handle"],
+    },
+    {
+      name: "collections",
+      requiredFields: ["title", systemIdKey, "handle"],
+    },
+  ];
+
+  for (const contentType of requiredContentTypes) {
+    await validateContentType(options, logger, contentType, systemIdKey);
+  }
+}
+
+async function validateContentType(
+  options: ModuleOptions,
+  logger: any,
+  contentType: any,
+  systemIdKey: string,
+) {
+  logger.debug(`Validating content type: ${contentType.name}`);
+
+  const params = qs.stringify({
+    fields: contentType.requiredFields,
+    populate: contentType.relations || {},
+    pagination: { limit: 1 },
+  });
+
+  const response = await fetch(
+    `${options.base_url}/${contentType.name}?${params}`,
+    {
+      headers: {
+        Authorization: `Bearer ${options.api_key}`,
+        "Content-Type": "application/json",
+      },
+    },
+  );
+
+  if (!response.ok) {
+    let errorDetails = `HTTP ${response.status} ${response.statusText}`;
+    let errorMessage = `Content type '${contentType.name}' validation failed: ${errorDetails}`;
+
+    try {
+      const errorResponse = await response.json();
+      if (errorResponse.error) {
+        errorDetails += ` - ${JSON.stringify(errorResponse.error)}`;
+        logger.error(
+          `Strapi content type validation failed for '${contentType.name}':`,
+          errorResponse,
+        );
+
+        if (response.status === 404) {
+          errorMessage = `Content type '${contentType.name}' does not exist in Strapi. Please create it using the schema files provided in the 'strapi-schemas' directory.`;
+        }
+      }
+    } catch (parseError) {
+      logger.error("Failed to parse error response from Strapi", parseError);
+    }
+
+    throw new MedusaError(MedusaError.Types.INVALID_DATA, errorMessage);
+  }
+
+  const responseData = await response.json();
+  const { error } = responseData;
+
+  if (error) {
+    logger.error(
+      `Strapi returned an error for content type '${contentType.name}':`,
+      error,
+    );
+    logger.error("Full response:", responseData);
+
+    let errorMessage = `Content type '${contentType.name}' validation failed: ${
+      error.message || JSON.stringify(error)
+    }`;
+
+    // Check if it's a field-related error
+    if (error.message && error.message.includes("field")) {
+      errorMessage += `\n\nRequired fields for '${
+        contentType.name
+      }': ${contentType.requiredFields.join(", ")}`;
+      errorMessage += `\nPlease ensure all required fields exist in your Strapi content type.`;
+      errorMessage += `\nRefer to the schema files in the 'strapi-schemas' directory for the correct structure.`;
+    }
+
+    throw new MedusaError(MedusaError.Types.INVALID_DATA, errorMessage);
+  }
+
+  logger.debug(`Content type '${contentType.name}' validation passed`);
+}