@csbeker/medusa-product-attributes 2.2.0

package/src/modules/attribute/migrations/Migration20250505144933.ts

@@ -0,0 +1,26 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20250505144933 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table if exists "attribute_set" drop constraint if exists "attribute_set_handle_unique";`);
+    this.addSql(`create table if not exists "attribute_set" ("id" text not null, "name" text not null, "description" text null, "handle" text not null, "metadata" jsonb null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "attribute_set_pkey" primary key ("id"));`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_ATTRIBUTE_SET_NAME" ON "attribute_set" (name) WHERE deleted_at IS NULL;`);
+    this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "IDX_attribute_set_handle_unique" ON "attribute_set" (handle) WHERE deleted_at IS NULL;`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_attribute_set_deleted_at" ON "attribute_set" (deleted_at) WHERE deleted_at IS NULL;`);
+
+    this.addSql(`create table if not exists "attribute_set_attributes" ("attribute_set_id" text not null, "attribute_id" text not null, constraint "attribute_set_attributes_pkey" primary key ("attribute_set_id", "attribute_id"));`);
+
+    this.addSql(`alter table if exists "attribute_set_attributes" add constraint "attribute_set_attributes_attribute_set_id_foreign" foreign key ("attribute_set_id") references "attribute_set" ("id") on update cascade on delete cascade;`);
+    this.addSql(`alter table if exists "attribute_set_attributes" add constraint "attribute_set_attributes_attribute_id_foreign" foreign key ("attribute_id") references "attribute" ("id") on update cascade on delete cascade;`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`alter table if exists "attribute_set_attributes" drop constraint if exists "attribute_set_attributes_attribute_set_id_foreign";`);
+
+    this.addSql(`drop table if exists "attribute_set" cascade;`);
+
+    this.addSql(`drop table if exists "attribute_set_attributes" cascade;`);
+  }
+
+}

package/src/modules/attribute/migrations/Migration20250505201747.ts

@@ -0,0 +1,23 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20250505201747 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`create table if not exists "attribute_possible_value" ("id" text not null, "value" text not null, "rank" integer not null, "metadata" jsonb null, "attribute_id" text not null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "attribute_possible_value_pkey" primary key ("id"));`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_attribute_possible_value_attribute_id" ON "attribute_possible_value" (attribute_id) WHERE deleted_at IS NULL;`);
+    this.addSql(`CREATE INDEX IF NOT EXISTS "IDX_attribute_possible_value_deleted_at" ON "attribute_possible_value" (deleted_at) WHERE deleted_at IS NULL;`);
+    this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "UQ_attribute_id_value" ON "attribute_possible_value" (attribute_id, value) WHERE deleted_at IS NULL;`);
+
+    this.addSql(`alter table if exists "attribute_possible_value" drop constraint if exists "attribute_possible_value_attribute_id_foreign";`);
+    this.addSql(`alter table if exists "attribute_possible_value" add constraint "attribute_possible_value_attribute_id_foreign" foreign key ("attribute_id") references "attribute" ("id") on update cascade;`);
+
+    this.addSql(`drop index if exists "UQ_attribute_id_value";`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "attribute_possible_value" cascade;`);
+
+    this.addSql(`CREATE UNIQUE INDEX IF NOT EXISTS "UQ_attribute_id_value" ON "attribute_value" (attribute_id, value) WHERE deleted_at IS NULL;`);
+  }
+
+}

package/src/modules/attribute/migrations/Migration20250506162300.ts

@@ -0,0 +1,13 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20250506162300 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table if exists "attribute_value" drop column if exists "rank";`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`alter table if exists "attribute_value" add column if not exists "rank" integer not null;`);
+  }
+
+}

package/src/modules/attribute/migrations/Migration20250611160552.ts

@@ -0,0 +1,13 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20250611160552 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table if exists "attribute" add column if not exists "ui_component" text check ("ui_component" in ('select', 'multivalue', 'unit', 'toggle', 'text-area', 'color_picker')) not null default 'select';`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`alter table if exists "attribute" drop column if exists "ui_component";`);
+  }
+
+}

package/src/modules/attribute/migrations/Migration20250611173345.ts

@@ -0,0 +1,17 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20250611173345 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table if exists "attribute" drop constraint if exists "attribute_ui_component_check";`);
+
+    this.addSql(`alter table if exists "attribute" add constraint "attribute_ui_component_check" check("ui_component" in ('select', 'multivalue', 'unit', 'toggle', 'text_area', 'color_picker'));`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`alter table if exists "attribute" drop constraint if exists "attribute_ui_component_check";`);
+
+    this.addSql(`alter table if exists "attribute" add constraint "attribute_ui_component_check" check("ui_component" in ('select', 'multivalue', 'unit', 'toggle', 'text-area', 'color_picker'));`);
+  }
+
+}

package/src/modules/attribute/migrations/Migration20250612192857.ts

@@ -0,0 +1,17 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20250612192857 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`alter table if exists "attribute_possible_value" drop constraint if exists "attribute_possible_value_attribute_id_foreign";`);
+
+    this.addSql(`alter table if exists "attribute_possible_value" add constraint "attribute_possible_value_attribute_id_foreign" foreign key ("attribute_id") references "attribute" ("id") on update cascade on delete cascade;`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`alter table if exists "attribute_possible_value" drop constraint if exists "attribute_possible_value_attribute_id_foreign";`);
+
+    this.addSql(`alter table if exists "attribute_possible_value" add constraint "attribute_possible_value_attribute_id_foreign" foreign key ("attribute_id") references "attribute" ("id") on update cascade;`);
+  }
+
+}

package/src/modules/attribute/models/attribute-possible-value.ts

@@ -0,0 +1,20 @@
+import Attribute from "./attribute";
+import { model } from "@medusajs/framework/utils";
+
+const AttributePossibleValue = model.define('attribute_possible_value', {
+    id: model.id({ prefix: 'attrposval' }).primaryKey(),
+    value: model.text(),
+    rank: model.number(),
+    metadata: model.json().nullable(),
+    attribute: model.belongsTo(() => Attribute, {
+        mappedBy: 'possible_values',
+    })
+}).indexes([
+    {
+        on: ['attribute_id', 'value'],
+        name: 'UQ_attribute_id_value',
+        unique: true,
+    }
+])
+
+export default AttributePossibleValue

package/src/modules/attribute/models/attribute-set.ts

@@ -0,0 +1,18 @@
+import Attribute from "./attribute"
+import { model } from "@medusajs/framework/utils"
+
+const AttributeSet = model.define('attribute_set', {
+    id: model.id({ prefix: 'attrset' }).primaryKey(),
+    name: model.text().index('IDX_ATTRIBUTE_SET_NAME').searchable(),
+    description: model.text().nullable(),
+    handle: model.text().unique(),
+    metadata: model.json().nullable(),
+    attributes: model.manyToMany(() => Attribute, {
+        mappedBy: 'sets',
+        pivotTable: 'attribute_set_attributes',
+        join_column: 'attribute_set_id',
+        inverseJoinColumn: 'attribute_id',
+    }),
+})
+
+export default AttributeSet 

package/src/modules/attribute/models/attribute-value.ts

@@ -0,0 +1,13 @@
+import Attribute from "./attribute";
+import { model } from "@medusajs/framework/utils";
+
+const AttributeValue = model.define('attribute_value', {
+    id: model.id({ prefix: 'attrval' }).primaryKey(),
+    value: model.text(),
+    metadata: model.json().nullable(),
+    attribute: model.belongsTo(() => Attribute, {
+        mappedBy: 'values',
+    })
+})
+
+export default AttributeValue

package/src/modules/attribute/models/attribute.ts

@@ -0,0 +1,23 @@
+import { AttributeUIComponent } from "../types"
+import AttributePossibleValue from "./attribute-possible-value"
+import AttributeSet from "./attribute-set"
+import AttributeValue from "./attribute-value"
+import { model } from "@medusajs/framework/utils"
+
+const Attribute = model.define('attribute', {
+    id: model.id({ prefix: 'attr' }).primaryKey(),
+    name: model.text().index('IDX_ATTRIBUTE_NAME').searchable(),
+    description: model.text().nullable(),
+    is_variant_defining: model.boolean().default(true),
+    is_filterable: model.boolean().default(true),
+    handle: model.text().unique(),
+    ui_component: model.enum(Object.values(AttributeUIComponent)).default(AttributeUIComponent.SELECT),
+    metadata: model.json().nullable(),
+    possible_values: model.hasMany(() => AttributePossibleValue),
+    values: model.hasMany(() => AttributeValue),
+    sets: model.manyToMany(() => AttributeSet, { mappedBy: 'attributes' }),
+}).cascades({
+    delete: ['values', 'possible_values']
+})
+
+export default Attribute

package/src/modules/attribute/service.ts

@@ -0,0 +1,102 @@
+import {
+    arrayDifference,
+  InjectManager,
+  InjectTransactionManager,
+  MedusaContext,
+  MedusaService,
+} from "@medusajs/framework/utils";
+import Attribute from "./models/attribute";
+import { Context, DAL, InferTypeOf } from "@medusajs/framework/types";
+import { EntityManager } from "@mikro-orm/knex";
+import {
+  CreateAttributeValueDTO,
+  UpdateAttributeDTO,
+  UpsertAttributeValueDTO,
+  UpdateAttributeValueDTO,
+} from "../../types/attribute";
+import AttributeValue from "./models/attribute-value";
+import AttributeSet from "./models/attribute-set";
+import AttributePossibleValue from "./models/attribute-possible-value";
+
+type Attribute = InferTypeOf<typeof Attribute>
+type AttributePossibleValue = InferTypeOf<typeof AttributePossibleValue>
+
+type InjectedDependencies = {
+  attributeRepository: DAL.RepositoryService<Attribute>;
+  attributePossibleValueRepository: DAL.RepositoryService<AttributePossibleValue>;
+};
+
+class AttributeModuleService extends MedusaService({
+  Attribute,
+  AttributeValue,
+  AttributeSet,
+  AttributePossibleValue,
+}) {
+  protected attributeRepository_: DAL.RepositoryService<Attribute>;
+  protected attributePossibleValueRepository_: DAL.RepositoryService<AttributePossibleValue>;
+
+  constructor({
+    attributeRepository,
+    attributePossibleValueRepository,
+  }: InjectedDependencies) {
+    super(...arguments);
+    this.attributeRepository_ = attributeRepository;
+    this.attributePossibleValueRepository_ = attributePossibleValueRepository;
+  }
+
+  /**
+   *
+   * @param input
+   * @param sharedContext
+   *
+   * Useful to update attribute, allowing to upsert possible_values in the same operation. If "id"
+   * is not provided for "possible_values" entries, it will lookup the DB by attributePossibleValue.value,
+   * to update or create accordingly.
+   *
+   * Assumes caller will eventually refetch entities, for now, to reduce complexity of this
+   * method and concentrate on upserting like ProductOption - ProductOptionValue from Medusa
+   */
+  @InjectManager()
+  async updateAttributeWithUpsertOrReplacePossibleValues(
+    input: UpdateAttributeDTO | UpdateAttributeDTO[],
+    @MedusaContext() sharedContext?: Context<EntityManager>
+  ) {
+    const normalizedInput = Array.isArray(input) ? input : [input];
+
+    return this.updateAttributeWithUpsertOrReplacePossibleValues_(
+      normalizedInput,
+      sharedContext
+    );
+  }
+
+  @InjectTransactionManager()
+  protected async updateAttributeWithUpsertOrReplacePossibleValues_(
+    input: UpdateAttributeDTO[],
+    @MedusaContext() sharedContext?: Context<EntityManager>
+  ) {
+    // When debugging this, it only seems to have the id proprty returned
+    // so i refetch the entities
+    const upsertedValues = await this.attributePossibleValueRepository_.upsert(
+      input.flatMap((element) => element.possible_values),
+      sharedContext
+    );
+
+    // const upsertedValues = await this.listAttributePossibleValues({
+    //   id: upsertedValuesWithoutFields.map(val => val.id)
+    // }, undefined, sharedContext)
+
+    const attributesInput = input.map(toUpdate => {
+      const { possible_values, product_category_ids, ...attribute } = toUpdate;
+      return {
+        ...attribute,
+        possible_values: upsertedValues
+          .filter(val => val.attribute_id === attribute.id)
+          .map(upserted => ({ id: upserted.id }))
+      }
+    });
+
+    return this.attributeRepository_.upsertWithReplace(attributesInput, { relations: ['possible_values'] }, sharedContext)
+  }
+}
+
+export default AttributeModuleService;

package/src/modules/attribute/types/attribute/common.ts

@@ -0,0 +1,94 @@
+import { AdminCreateAttributeType } from "../../../../api/admin/plugin/attributes/validators"
+
+export enum AttributeUIComponent {
+    SELECT = 'select', // ui component with list of values which are represented in possible value table
+    MULTIVALUE = 'multivalue',
+    UNIT = 'unit', // cantimeters, grams etc which are represented in scale table
+    TOGGLE = 'toggle',
+    TEXTAREA = 'text_area',
+    COLOR_PICKER = 'color_picker'
+}
+
+export type CreateAttributesWorkflowInput = {
+    attributes: AdminCreateAttributeType[]
+}
+
+export type CreateAttributeStepInput = Omit<AdminCreateAttributeType, 'product_category_ids'>[]
+
+// Attributes
+
+/**
+ * @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 product categories
+     */
+    product_category_ids?: 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> | null
+}

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

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

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

@@ -0,0 +1 @@
+export * from './mutations'

package/src/modules/attribute/types/attribute-set/mutations.ts

@@ -0,0 +1,7 @@
+export type CreateAttributeSetDTO = {
+    name: string
+    handle?: string
+    description?: string
+    metadata?: Record<string, unknown> | null
+    attributes?: string[]
+}

package/src/modules/attribute/types/attribute-value/index.ts

@@ -0,0 +1 @@
+export * from './mutations'

package/src/modules/attribute/types/attribute-value/mutations.ts

@@ -0,0 +1,5 @@
+export type CreateProductAttributeValueDTO = {
+    attribute_id: string;
+    product_id: string;
+    value: string;
+}

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

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

package/src/providers/README.md

@@ -0,0 +1,30 @@
+## Module Providers
+
+You can create module providers, such as Notification or File Module Providers under a sub-directory of this directory. For example, `src/providers/my-notification`.
+
+Then, you register them in the Medusa application as `plugin-name/providers/my-notification`:
+
+```ts
+module.exports = defineConfig({
+  // ...
+  modules: [
+    {
+      resolve: "@medusajs/medusa/notification",
+      options: {
+        providers: [
+          {
+            resolve: "@myorg/plugin-name/providers/my-notification",
+            id: "my-notification",
+            options: {
+              channels: ["email"],
+              // provider options...
+            },
+          },
+        ],
+      },
+    },
+  ],
+})
+```
+
+Learn more in [this documentation](https://docs.medusajs.com/learn/fundamentals/plugins/create).

package/src/subscribers/README.md

@@ -0,0 +1,59 @@
+# Custom subscribers
+
+Subscribers handle events emitted in the Medusa application.
+
+The subscriber is created in a TypeScript or JavaScript file under the `src/subscribers` directory.
+
+For example, create the file `src/subscribers/product-created.ts` with the following content:
+
+```ts
+import {
+  type SubscriberConfig,
+} from "@medusajs/framework"
+
+// subscriber function
+export default async function productCreateHandler() {
+  console.log("A product was created")
+}
+
+// subscriber config
+export const config: SubscriberConfig = {
+  event: "product.created",
+}
+```
+
+A subscriber file must export:
+
+- The subscriber function that is an asynchronous function executed whenever the associated event is triggered.
+- A configuration object defining the event this subscriber is listening to.
+
+## Subscriber Parameters
+
+A subscriber receives an object having the following properties:
+
+- `event`: An object holding the event's details. It has a `data` property, which is the event's data payload.
+- `container`: The Medusa container. Use it to resolve modules' main services and other registered resources.
+
+```ts
+import type {
+  SubscriberArgs,
+  SubscriberConfig,
+} from "@medusajs/framework"
+
+export default async function productCreateHandler({
+  event: { data },
+  container,
+}: SubscriberArgs<{ id: string }>) {
+  const productId = data.id
+
+  const productModuleService = container.resolve("product")
+
+  const product = await productModuleService.retrieveProduct(productId)
+
+  console.log(`The product ${product.title} was created`)
+}
+
+export const config: SubscriberConfig = {
+  event: "product.created",
+}
+```