@csbeker/medusa-product-attributes 2.2.0

package/src/types/attribute/common.ts

@@ -0,0 +1,173 @@
+/**
+ * @interface
+ * 
+ * The data to update the attribute.
+ */
+export interface UpdateAttributeDTO {
+    /**
+     * The id of the attribute to update.
+     */
+    id: string
+    
+    /**
+     * The name of the attribute.
+     */
+    name?: string
+
+    /**
+     * The description of the attribute.
+     */
+    description?: string
+
+    /**
+     * Whether the attribute should be used as a Blueprint for options
+     * when creating them a product variant.
+     */
+    is_variant_defining?: boolean
+
+    /**
+     * Whether the attribute can be used to filter products.
+     */
+    is_filterable?: boolean
+
+    /**
+     * The handle of the attribute. The handle can be used to create slug URL paths.
+     * If not supplied, the value of the `handle` attribute of the attribute is set to the slug version of the `name` property.
+     */
+    handle?: string
+
+    /**
+     * Holds custom data in key-value pairs.
+     */
+    metadata?: Record<string, unknown>
+
+    /**
+     * The associated attribute values to create or update. If "id" is not provided, it will try to update an existent attribute,
+     * matching by "value", if not found, it will create a new one and "value" is required.
+     */
+    possible_values?: UpsertAttributeValueDTO[]
+
+    /**
+     * The associated product categories.
+     */
+    product_category_ids?: { id: string }[]
+}
+
+/**
+ * @interface
+ * 
+ * The data to update or create an attribute value.
+ */
+export interface UpsertAttributeValueDTO {
+    /**
+     * The id of the attribute value to update.
+     */
+    id?: string
+
+    /**
+     * The value of the attribute value.
+     */
+    value?: string
+
+    /**
+     * The rank of the attribute value. Useful to visually order it on dropdowns.
+     */
+    rank?: number
+
+    /**
+     * Holds custom data in key-value pairs.
+     */
+    metadata?: Record<string, unknown>
+
+    /**
+     * The id of the associated attribute.
+     */
+    attribute_id?: string
+}
+
+/**
+ * @interface
+ * 
+ * The data to create the attribute value.
+ */
+export interface CreateAttributeValueDTO {
+    value: string
+    rank: number
+    attribute_id: string
+    metadata?: Record<string, unknown>
+}
+
+/**
+ * @interface
+ * 
+ * The data to update or create an attribute value.
+ */
+export interface UpsertAttributeValueDTO {
+    /**
+     * The id of the attribute value to update.
+     */
+    id?: string
+
+    /**
+     * The value of the attribute value.
+     */
+    value?: string
+
+    /**
+     * The rank of the attribute value. Useful to visually order it on dropdowns.
+     */
+    rank?: number
+
+    /**
+     * Holds custom data in key-value pairs.
+     */
+    metadata?: Record<string, unknown>
+
+    /**
+     * The id of the associated attribute.
+     */
+    attribute_id?: string
+}
+
+/**
+ * @interface
+ * 
+ * The data to update an attribute value
+ */
+export interface UpdateAttributeValueDTO {
+    /**
+     * The id of the attribute value to update.
+     */
+    id: string
+
+    /**
+     * The value of the attribute value.
+     */
+    value?: string
+
+    /**
+     * The rank of the attribute value. Useful to visually order it on dropdowns.
+     */
+    rank?: number
+
+    /**
+     * Holds custom data in key-value pairs.
+     */
+    metadata?: Record<string, unknown>
+
+    /**
+     * The id of the associated attribute.
+     */
+    attribute_id?: string
+}
+
+export interface ProductAttributeValueDTO {
+    /**
+     * The value of the attribute value.
+     */
+    value: string;
+     /**
+     * The id of the associated attribute.
+     */
+    attribute_id: string;
+}

package/src/types/attribute/http/attribute/index.ts

@@ -0,0 +1,42 @@
+import { AttributeUIComponent } from '../../../../modules/attribute/types'
+import { AttributeSet } from '../attribute-set'
+
+export interface Attribute {
+  id: string
+  name: string
+  description: string | null
+  is_variant_defining: boolean
+  is_filterable: boolean
+  handle: string
+  ui_component: AttributeUIComponent
+  metadata: Record<string, unknown> | null
+  possible_values?: AttributePossibleValue[]
+  created_at: string
+  updated_at: string
+  values?: Array<{
+    id: string
+    value: string
+  }>
+  sets?: AttributeSet[]
+  product_categories?: Array<{
+    id: string
+    name: string
+  }>
+}
+
+export interface AttributePossibleValue {
+  id: string
+  value: string
+  rank: number
+  created_at: string
+  metadata: Record<string, unknown> | null
+}
+
+export interface AttributesResponse {
+  attributes: Attribute[]
+  count: number
+  offset: number
+  limit: number
+}
+
+export * from './admin'

package/src/types/attribute/http/attribute-set/index.ts

@@ -0,0 +1,10 @@
+import { Attribute } from "../attribute"
+
+export type AttributeSet = {
+    id: string
+    name: string
+    description?: string
+    handle: string
+    metadata: Record<string, unknown> | null
+    attributes: Attribute[]
+}

package/src/types/attribute/http/index.ts

@@ -0,0 +1,2 @@
+export * from './attribute'
+export * from './attribute-set'

package/src/types/attribute/index.ts

@@ -0,0 +1,2 @@
+export * from './http'
+export * from './common'

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './products-created-handler'

package/src/utils/products-created-handler.ts

@@ -0,0 +1,35 @@
+import {
+  MedusaContainer,
+  ProductDTO,
+} from "@medusajs/framework/types";
+
+import { ProductAttributeValueDTO } from "../types/attribute";
+import { createAttributeValueWorkflow } from "../workflows/attribute-value/workflow";
+import { validateAttributeValuesToLink } from "./validate-attribute-values-to-link";
+
+export const productsCreatedHookHandler = async ({
+  products,
+  additional_data,
+  container,
+}: {
+  products: ProductDTO[];
+  additional_data: Record<string, unknown> | undefined;
+  container: MedusaContainer;
+}) => {
+  const attributeValues = (additional_data?.values ?? []) as ProductAttributeValueDTO[];
+  const productIds = products.map((prod) => prod.id);
+
+  if (!attributeValues.length) {
+    return [];
+  }
+
+  await Promise.all(productIds.flatMap(prodId => attributeValues.map(async attrVal => {
+    return createAttributeValueWorkflow(container).run({
+      input: {
+        attribute_id: attrVal.attribute_id,
+        value: attrVal.value,
+        product_id: prodId,
+      }
+    })
+  })))
+};

package/src/utils/products-updated-handler.ts

@@ -0,0 +1,74 @@
+import { createAttributeValueWorkflow, deleteAttributeValueWorkflow } from "../workflows/attribute-value/workflow";
+
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils";
+import { MedusaContainer } from "@medusajs/framework";
+import { ProductAttributeValueDTO } from "../types/attribute";
+import { ProductDTO } from "@medusajs/framework/types";
+import attributeValueProduct from "../links/attribute-value-product";
+import { validateAttributeValuesToLink } from "./validate-attribute-values-to-link";
+
+export const productsUpdatedHookHandler = async ({
+  products,
+  additional_data,
+  container,
+}: {
+  products: ProductDTO[];
+  additional_data: Record<string, unknown> | undefined;
+  container: MedusaContainer;
+}) => {
+  const query = container.resolve(ContainerRegistrationKeys.QUERY)
+  
+  const attributeValues = (additional_data?.values ?? []) as ProductAttributeValueDTO[];
+  const productIds = products.map((prod) => prod.id);
+
+  if (!attributeValues.length) {
+    return [];
+  }
+
+  const updatedValueIds = (await Promise.all(productIds.map(async prodId => {
+    const { data: productValues } = await query.graph({
+      entity: attributeValueProduct.entryPoint,
+      fields: ['attribute_value.id', 'attribute_value.value', 'attribute_value.attribute_id'],
+      filters: {
+        product_id: prodId
+      }
+    })
+
+    return Promise.all(attributeValues.map(async attrVal => {
+      const unchangedProductValue = productValues.find(prodVal => 
+        prodVal.attribute_value.value === attrVal.value && prodVal.attribute_value.attribute_id === attrVal.attribute_id
+      )
+      if (unchangedProductValue) {
+        return unchangedProductValue.attribute_value.id as string
+      }
+
+      const { result } = await createAttributeValueWorkflow(container).run({
+        input: {
+          attribute_id: attrVal.attribute_id,
+          value: attrVal.value,
+          product_id: prodId,
+        }
+      })
+      return result.id
+    }))
+  }))).flat()
+
+  const { data: attributeValuesToDelete } = await query.graph({
+    entity: attributeValueProduct.entryPoint,
+    fields: ['attribute_value_id'],
+    filters: {
+      attribute_value_id: {
+        $nin: updatedValueIds
+      },
+      product_id: productIds
+    }
+  })
+
+  if (!attributeValuesToDelete.length) {
+    return;
+  }
+  
+  await deleteAttributeValueWorkflow(container).run({
+    input: attributeValuesToDelete.map(val => val.attribute_value_id)
+  })
+}; 

package/src/utils/validate-attribute-values-to-link.ts

@@ -0,0 +1,67 @@
+import {
+  ContainerRegistrationKeys,
+  MedusaError,
+  MedusaErrorTypes,
+} from "@medusajs/framework/utils";
+import { InferTypeOf, MedusaContainer, ProductCategoryDTO, ProductDTO } from "@medusajs/framework/types";
+
+import Attribute from "../modules/attribute/models/attribute";
+import { ProductAttributeValueDTO } from "../types/attribute";
+
+export const validateAttributeValuesToLink = async ({
+  attributeValues,
+  products,
+  container,
+}: {
+  attributeValues: ProductAttributeValueDTO[];
+  products: ProductDTO[];
+  container: MedusaContainer;
+}) => {
+  const query = container.resolve(ContainerRegistrationKeys.QUERY);
+
+  const attributeMap = new Map<string, InferTypeOf<typeof Attribute> & { product_categories?: ProductCategoryDTO[] }>()
+
+  for (const attrVal of attributeValues) {
+    const id = attrVal.attribute_id
+
+    if (!attributeMap.get(id)) {
+      const { data: [attribute] } = await query.graph({
+        entity: 'attribute',
+        fields: ['product_categories.*', 'possible_values.*'],
+        filters: {
+          id: id
+        }
+      }) 
+      
+      attributeMap.set(id, attribute)
+    }
+
+    const allowedValues = attributeMap.get(id)?.possible_values?.map(posVal => posVal.value)
+
+    if (allowedValues?.length && !allowedValues.includes(attrVal.value)) {
+      throw new MedusaError(MedusaErrorTypes.INVALID_DATA, `Attribute ${attrVal.attribute_id} doesn't define ${attrVal.value} as a possible_value`)
+    }
+  }
+
+  const attributeCategoryIds = Array.from(new Set(
+    Array.from(attributeMap.values())
+      .flatMap(attr => attr.product_categories?.map(cat => cat.id) || [])
+  ))
+
+  if (!attributeCategoryIds.length) {
+    // If all attributes are global, we don't enforce for product.categories to include the attribute.product_categories, since there are none
+    return;
+  }
+
+  const invalidProductIds: string[] = []
+  for (const product of products) {
+    const productCategoryIds = product.categories?.map(cat => cat.id)
+    if (!productCategoryIds?.some(prodCatId => attributeCategoryIds.includes(prodCatId))) {
+      invalidProductIds.push(product.id)
+    }
+  }
+
+  if (invalidProductIds.length) {
+    throw new MedusaError(MedusaErrorTypes.INVALID_DATA, `The following products aren't linked to any category from the requested attributes:\n${invalidProductIds.join(', ')}`)
+  }
+};

package/src/workflows/README.md

@@ -0,0 +1,79 @@
+# 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/attribute/index.ts

@@ -0,0 +1,2 @@
+export * from './workflows'
+export * from './steps'

package/src/workflows/attribute/steps/create-attribute-possible-values.ts

@@ -0,0 +1,29 @@
+import { StepResponse, createStep } from "@medusajs/framework/workflows-sdk"
+
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import AttributeModuleService from "../../../modules/attribute/service"
+import { CreateAttributeValueDTO } from "../../../types/attribute"
+
+export const createAttributePossibleValuesStepId = 'create-attribute-possible-values'
+
+export type CreateAttributePossibleValuesStepInput = CreateAttributeValueDTO[]
+
+export const createAttributePossibleValuesStep = createStep(
+    createAttributePossibleValuesStepId,
+    async (data: CreateAttributePossibleValuesStepInput, { container }) => {
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        const values = await service.createAttributePossibleValues(data)
+
+        return new StepResponse(values, values.map(val => val.id))
+    },
+    async (ids, { container }) => {
+        if (!ids?.length) {
+            return
+        }
+
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        await service.deleteAttributeValues(ids)
+    }
+)

package/src/workflows/attribute/steps/create-attributes.ts

@@ -0,0 +1,35 @@
+import { createStep, StepResponse } from "@medusajs/framework/workflows-sdk"
+import { CreateAttributeStepInput } from "../../../modules/attribute/types/attribute/common"
+import AttributeModuleService from "../../../modules/attribute/service"
+import attribute, { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import { kebabCase, toHandle } from "@medusajs/framework/utils"
+
+export const createAttributesStepId = 'create-attributes'
+
+export const createAttributesStep = createStep(
+    createAttributesStepId,
+    async (data: CreateAttributeStepInput, { container }) => {
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        const validated = data.map(attribute => {
+            let result = { ...attribute }
+            if (!attribute.handle) {
+                result.handle = toHandle(attribute.name)
+            }
+            return result
+        })
+
+        //@ts-expect-error
+        const created = await service.createAttributes(validated) as any[]
+        return new StepResponse(created, created.map(attribute => attribute.id))
+    },
+    async (createdIds: string[] | undefined, { container }) => {
+        if(!createdIds?.length) {
+            return
+        }
+
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        await service.deleteAttributes(createdIds)
+    }
+)

package/src/workflows/attribute/steps/delete-attribute.ts

@@ -0,0 +1,41 @@
+import { createStep, StepResponse } from "@medusajs/workflows-sdk"
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import AttributeModuleService from "../../../modules/attribute/service"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+
+export const deleteAttributeStepId = 'delete-attribute-step'
+
+type DeleteAttributeStepInput = {
+    id: string
+}
+
+export const deleteAttributeStep = createStep(
+    deleteAttributeStepId,
+    async ({ id }: DeleteAttributeStepInput, { container }) => {
+        const attributeModuleService = container.resolve(ATTRIBUTE_MODULE) as AttributeModuleService
+        const link = container.resolve(ContainerRegistrationKeys.LINK)
+        
+        await attributeModuleService.softDeleteAttributes(id)
+        await link.delete({
+            [ATTRIBUTE_MODULE]: {
+                attribute_id: id,
+            }
+        })
+        return new StepResponse(undefined, id)
+    },
+    async (id: string | undefined, { container }) => {
+        if (!id) {
+            return
+        }
+
+        const attributeModuleService = container.resolve(ATTRIBUTE_MODULE) as AttributeModuleService
+        const link = container.resolve(ContainerRegistrationKeys.LINK)
+        
+        await attributeModuleService.restoreAttributes(id)
+        await link.restore({
+            [ATTRIBUTE_MODULE]: {
+                attribute_id: id
+            }
+        })
+    }
+)

package/src/workflows/attribute/steps/index.ts

@@ -0,0 +1,4 @@
+export * from './create-attributes'
+export * from './update-attributes'
+export * from './create-attribute-possible-values'
+export * from './delete-attribute'

package/src/workflows/attribute/steps/update-attributes.ts

@@ -0,0 +1,45 @@
+import { StepResponse, WorkflowData, createStep } from "@medusajs/framework/workflows-sdk"
+
+import { ATTRIBUTE_MODULE } from "../../../modules/attribute"
+import AttributeModuleService from "../../../modules/attribute/service"
+import { UpdateAttributeDTO } from "../../../types/attribute"
+
+const updateAttributesStepId = 'update-attributes'
+
+export const updateAttributesStep = createStep(
+    updateAttributesStepId,
+    async (data: WorkflowData<UpdateAttributeDTO[]>, { container }) => {
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+
+        const prevData = await service.listAttributes({
+            id: data.map(attribute => attribute.id)
+        })
+
+        const normalized = data.map(attr => {
+            const { possible_values: values, ...attribute } = attr;
+            const valuesWithAttribute = values?.map(val => ({ ...val, attribute_id: attribute.id }))
+            return {
+                ...attr,
+                possible_values: valuesWithAttribute
+            }
+        })
+
+        const attributes = normalized.map((element) => {
+            const { product_category_ids, ...attr } = element
+            return attr
+        })
+
+        await service.updateAttributeWithUpsertOrReplacePossibleValues(normalized)
+
+        return new StepResponse(attributes, prevData)
+    },
+    async (prevData, { container }) => {
+        if (!prevData?.length) {
+            return
+        }
+
+        const service = container.resolve<AttributeModuleService>(ATTRIBUTE_MODULE)
+        //@ts-expect-error
+        await service.updateAttributes(prevData)
+    }
+)

package/src/workflows/attribute/workflows/create-attribute-possible-values.ts

@@ -0,0 +1,17 @@
+import { WorkflowResponse, createWorkflow } from "@medusajs/framework/workflows-sdk"
+
+import { CreateAttributeValueDTO } from "../../../types/attribute"
+import { createAttributePossibleValuesStep } from "../steps/create-attribute-possible-values"
+
+const createAttributePossibleValuesWorkflowId = 'create-attribute-possible-values'
+
+export type CreateAttributePossibleValuesWorkflowInput = CreateAttributeValueDTO[]
+
+export const createAttributePossibleValuesWorkflow = createWorkflow(
+    createAttributePossibleValuesWorkflowId,
+    (input: CreateAttributePossibleValuesWorkflowInput) => {
+        const createdValues = createAttributePossibleValuesStep(input)
+
+        return new WorkflowResponse(createdValues)
+    }
+)