@csbeker/medusa-product-attributes 2.2.0

package/src/api/utils/middlewares.ts

@@ -0,0 +1,31 @@
+import { MedusaNextFunction, MedusaRequest, MedusaResponse } from "@medusajs/framework";
+import { arrayDifference, ContainerRegistrationKeys, deduplicate } from "@medusajs/framework/utils";
+import attributeProductCategory from "../../links/attribute-product-category";
+
+export const addGlobalAttributesIfNecessary = () => async (req: MedusaRequest, res: MedusaResponse, next: MedusaNextFunction) => {
+    const filterableFields = req.filterableFields || {}
+    const shouldIncludeGlobals = filterableFields.include_globals
+
+    if(!shouldIncludeGlobals) {
+        return next()
+    }
+
+    const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+    const { data: allAttributes } = await query.graph({
+        entity: 'attribute',
+        fields: ['id']
+    })
+    const { data: attributesWithCategories } = await query.graph({
+        entity: attributeProductCategory.entryPoint,
+        fields: ['attribute_id']
+    })
+
+    const alreadyFilteredAttributeIds = (filterableFields.id || []) as string[]
+    const allAttributesIds = allAttributes.map(attr => attr.id)
+    const attributesWithCategoriesIds = deduplicate(attributesWithCategories.map(attrCat => attrCat.attribute_id))
+    req.filterableFields.id = [
+        ...alreadyFilteredAttributeIds,
+        ...arrayDifference(allAttributesIds, attributesWithCategoriesIds)
+    ]
+    return next()
+}

package/src/jobs/README.md

@@ -0,0 +1,36 @@
+# Custom scheduled jobs
+
+A scheduled job is a function executed at a specified interval of time in the background of your Medusa application.
+
+A scheduled job is created in a TypeScript or JavaScript file under the `src/jobs` directory.
+
+For example, create the file `src/jobs/hello-world.ts` with the following content:
+
+```ts
+import {
+  MedusaContainer
+} from "@medusajs/framework/types";
+
+export default async function myCustomJob(container: MedusaContainer) {
+  const productService = container.resolve("product")
+
+  const products = await productService.listAndCountProducts();
+
+  // Do something with the products
+}
+
+export const config = {
+  name: "daily-product-report",
+  schedule: "0 0 * * *", // Every day at midnight
+};
+```
+
+A scheduled job file must export:
+
+- The function to be executed whenever it’s time to run the scheduled job.
+- A configuration object defining the job. It has three properties:
+  - `name`: a unique name for the job.
+  - `schedule`: a [cron expression](https://crontab.guru/).
+  - `numberOfExecutions`: an optional integer, specifying how many times the job will execute before being removed
+
+The `handler` is a function that accepts one parameter, `container`, which is a `MedusaContainer` instance used to resolve services.

package/src/links/README.md

@@ -0,0 +1,26 @@
+# Module Links
+
+A module link forms an association between two data models of different modules, while maintaining module isolation.
+
+Learn more about links in [this documentation](https://docs.medusajs.com/learn/fundamentals/module-links)
+
+For example:
+
+```ts
+import BlogModule from "../modules/blog"
+import ProductModule from "@medusajs/medusa/product"
+import { defineLink } from "@medusajs/framework/utils"
+
+export default defineLink(
+  ProductModule.linkable.product,
+  BlogModule.linkable.post
+)
+```
+
+This defines a link between the Product Module's `product` data model and the Blog Module (custom module)'s `post` data model.
+
+Then, in the Medusa application using this plugin, run the following command to sync the links to the database:
+
+```bash
+npx medusa db:migrate
+```

package/src/links/attribute-product-category.ts

@@ -0,0 +1,14 @@
+import { defineLink } from "@medusajs/framework/utils";
+import AttributeModule from '../modules/attribute'
+import ProductModule from "@medusajs/medusa/product";
+
+export default defineLink(
+    {
+        linkable: AttributeModule.linkable.attribute,
+        isList: true
+    },
+    {
+        linkable: ProductModule.linkable.productCategory,
+        isList: true
+    }
+)

package/src/links/attribute-value-product.ts

@@ -0,0 +1,14 @@
+import { defineLink } from "@medusajs/framework/utils"
+import AttributeModule from '../modules/attribute'
+import ProductModule from "@medusajs/medusa/product"
+
+export default defineLink(
+    {
+        linkable: AttributeModule.linkable.attributeValue,
+        isList: true,
+    },
+    {
+        linkable: ProductModule.linkable.product,
+        isList: true,
+    }
+)

package/src/modules/README.md

@@ -0,0 +1,116 @@
+# 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:genreate
+```
+
+## 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/attribute/events/index.ts

@@ -0,0 +1,4 @@
+export const AttributeWorkflowsEvents = {
+    CREATED: 'attribute.created',
+    UPDATED: 'attribute.updated',
+}

package/src/modules/attribute/index.ts

@@ -0,0 +1,8 @@
+import AttributeModuleService from "./service"
+import { Module } from "@medusajs/framework/utils"
+
+export const ATTRIBUTE_MODULE = 'attribute'
+
+export default Module(ATTRIBUTE_MODULE, {
+    service: AttributeModuleService,
+})