@reactionary/source 0.0.52 → 0.2.16

package/providers/medusa/src/providers/product.provider.ts

@@ -0,0 +1,261 @@
+import type { Cache, Image, NotFoundError, Product, ProductAttribute, ProductAttributeIdentifier, ProductAttributeValueIdentifier, ProductOptionIdentifier, ProductOptionValueIdentifier, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, ProductVariant, ProductVariantOption, RequestContext, Result } from '@reactionary/core';
+import {
+  CategoryIdentifierSchema,
+  ProductIdentifierSchema,
+  ProductProvider,
+  ProductQueryByIdSchema,
+  ProductQueryBySKUSchema,
+  ProductQueryBySlugSchema,
+  ProductSchema,
+  Reactionary,
+  success,
+  error,
+} from '@reactionary/core';
+import createDebug from 'debug';
+import type { MedusaAPI } from '../core/client.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+
+import type { StoreProduct, StoreProductImage, StoreProductVariant } from '@medusajs/types';
+
+const debug = createDebug('reactionary:medusa:product');
+
+export class MedusaProductProvider extends ProductProvider {
+  protected config: MedusaConfiguration;
+
+  constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, public medusaApi: MedusaAPI) {
+  super(cache, context);
+   this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ProductQueryByIdSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+  public override async getById(payload: ProductQueryById): Promise<Result<Product>> {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(`Fetching product by ID: ${payload.identifier.key}`);
+    }
+    let response;
+    try {
+      response = await client.store.product.retrieve(payload.identifier.key, {
+        fields: '+metadata,+categories.metadata.*',
+      });
+
+    } catch(error) {
+      if (debug.enabled) {
+        debug(`Product with ID: ${payload.identifier.key} not found, returning empty product. Error %O `, error);
+      }
+      return success(this.createEmptyProduct(payload.identifier.key));
+    }
+    return success(this.parseSingle(response.product));
+  }
+
+  @Reactionary({
+    inputSchema: ProductQueryBySlugSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+  public override async getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>> {
+    const client = await this.medusaApi.getClient();
+    if (debug.enabled) {
+      debug(`Fetching product by slug: ${payload.slug}`);
+    }
+
+    const response = await client.store.product.list({
+      handle: payload.slug,
+      limit: 1,
+      offset: 0,
+      fields: '+metadata.*',
+    });
+
+    if (debug.enabled) {
+      debug(`Found ${response.count} products for slug: ${payload.slug}`);
+    }
+
+    if (response.count === 0) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload
+      });
+    }
+    return success(this.parseSingle(response.products[0]));
+  }
+
+
+  @Reactionary({
+    inputSchema: ProductQueryBySKUSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+  public override async getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>> {
+    if (debug.enabled) {
+      debug(`Fetching product by SKU: ${Array.isArray(payload) ? payload.join(', ') : payload}`);
+    }
+    const sku = payload.variant.sku;
+    const product = await this.medusaApi.resolveProductForSKU(sku);
+
+    const variant = product.variants?.find((v) => v.sku === sku);
+    if (!variant) {
+      throw new Error(`Variant with SKU ${sku} not found`);
+    }
+    product.variants = [];
+    product.variants.push(variant);
+
+    // For simplicity, return the first matched product
+    return success(this.parseSingle(product));
+  }
+
+  protected parseSingle(_body: StoreProduct): Product {
+    const identifier = ProductIdentifierSchema.parse({ key: _body.id });
+    const name = _body.title;
+    const slug = _body.handle;
+    const description = _body.description || '' || _body.subtitle || '';
+    const parentCategories = [];
+    parentCategories.push(
+      ...
+      _body.categories?.map( (cat) => cat.metadata?.['external_id'] ).map( (id) => CategoryIdentifierSchema.parse({ key: id || '' }) ) || []
+    )
+    const sharedAttributes = this.parseAttributes(_body);
+
+    if (!_body.variants) {
+      debug('Product has no variants', _body);
+      throw new Error('Product has no variants ' + _body.id);
+    }
+    const mainVariant = this.parseVariant(_body.variants[0], _body);
+
+
+    const otherVariants = [];
+    if (_body.variants.length > 1) {
+      otherVariants.push(
+        ..._body.variants.slice(1).map( (variant) => this.parseVariant(variant, _body) )
+      );
+    }
+
+    const result = {
+      brand: '',
+      description,
+      identifier,
+      longDescription: '',
+      mainVariant,
+      manufacturer: '',
+      name,
+      options: [],
+      parentCategories,
+      published: true,
+      sharedAttributes,
+      slug,
+      variants: otherVariants,
+    } satisfies Product;
+
+    return result;
+  }
+
+  protected parseVariant(variant: StoreProductVariant, product: StoreProduct) {
+
+
+    const options = (variant.options ?? []).map( (option) => {
+
+      const optionId: ProductOptionIdentifier = { key: option.option_id || '' };
+      const title = option.option?.title || '?';
+      const valueIdentifier: ProductOptionValueIdentifier = { key: option.option_id || '', option: optionId };
+      const value = option.value || '';
+
+      const result: ProductVariantOption = {
+        identifier: optionId,
+        name: title,
+        value: {
+          identifier: valueIdentifier,
+          label: value,
+        },
+      }
+      return result;
+    });
+
+
+    const result: ProductVariant = {
+      identifier: {
+        sku: variant.sku || '',
+      },
+      name: variant.title || product.title,
+      upc: variant.upc || '',
+      ean: variant.ean || '',
+
+      images: (product.images || []).map((img: StoreProductImage) => {
+        return {
+          sourceUrl: img.url,
+          altText: variant.title || product.title || '',
+        } satisfies Image;
+      }),
+      options: options,
+      gtin: variant.ean ||  '',
+      barcode: variant.ean || ''
+    };
+
+    return result;
+  }
+
+  protected createSynthAttribute(key: string, name: string, value: string ): ProductAttribute {
+    const attributeIdentifier: ProductAttributeIdentifier = { key };
+    const valueIdentifier: ProductAttributeValueIdentifier = { key: `${key}-${value}`};
+
+    const attribute: ProductAttribute = {
+      identifier: { key },
+      name,
+      group: '',
+      values: [
+        {
+          identifier: valueIdentifier,
+          label: String(value),
+          value: value,
+        }
+      ]
+    };
+    return attribute;
+  }
+
+  protected parseAttributes(_body: StoreProduct): Array<ProductAttribute> {
+    const sharedAttributes = [];
+
+    if (_body.origin_country) {
+      sharedAttributes.push(this.createSynthAttribute('origin_country', 'Origin Country', _body.origin_country));
+    }
+
+    if (_body.height) {
+      sharedAttributes.push(this.createSynthAttribute('height', 'Height', String(_body.height)));
+    }
+
+    if (_body.weight) {
+      sharedAttributes.push(this.createSynthAttribute('weight', 'Weight', String(_body.weight)));
+    }
+
+    if (_body.length) {
+      sharedAttributes.push(this.createSynthAttribute('length', 'Length', String(_body.length)));
+    }
+
+    if (_body.width) {
+      sharedAttributes.push(this.createSynthAttribute('width', 'Width', String(_body.width)));
+    }
+
+    if (_body.material) {
+      sharedAttributes.push(this.createSynthAttribute('material', 'Material', _body.material));
+    }
+    if (_body.metadata) {
+      for (const [key, value] of Object.entries(_body.metadata)) {
+        sharedAttributes.push(this.createSynthAttribute(key, key, String(value)));
+      }
+    }
+    return sharedAttributes;
+  }
+}
+

package/providers/medusa/src/providers/profile.provider.ts

@@ -0,0 +1,392 @@
+import type {
+  InvalidInputError} from '@reactionary/core';
+import {
+  type Profile,
+  type ProfileMutationAddShippingAddress,
+  type ProfileMutationMakeShippingAddressDefault,
+  type ProfileMutationRemoveShippingAddress,
+  type ProfileMutationSetBillingAddress,
+  type ProfileMutationUpdate,
+  type ProfileMutationUpdateShippingAddress,
+  type ProfileQuerySelf as ProfileQueryById,
+  type RequestContext,
+  type Cache,
+  type Result,
+  type NotFoundError,
+  ProfileProvider,
+  Reactionary,
+  ProfileSchema,
+  ProfileMutationUpdateSchema,
+  ProfileMutationAddShippingAddressSchema,
+  ProfileMutationUpdateShippingAddressSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationSetBillingAddressSchema,
+  success,
+  type Address,
+  ProfileQueryByIdSchema,
+  error
+} from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import createDebug from 'debug';
+import type { StoreCreateCustomerAddress, StoreCustomer, StoreCustomerAddress } from '@medusajs/types';
+
+const debug = createDebug('reactionary:medusa:profile');
+/**
+ * Medusa Profile Provider
+ *
+ * Implements profile management using Medusa's customer APIs.
+ *
+ * TODO:
+ * - handle email and phone verification status properly using metadata or other means.
+ * - handle guest user scenarios (if applicable).
+ * - improve error handling and edge cases.
+ */
+export class MedusaProfileProvider extends ProfileProvider {
+  protected config: MedusaConfiguration;
+  protected includedFields = ['+metadata.*'];
+
+  constructor(
+    config: MedusaConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    public medusaApi: MedusaAPI
+  ) {
+    super(cache, context);
+
+    this.config = config;
+  }
+
+  @Reactionary({
+    inputSchema: ProfileQueryByIdSchema,
+    outputSchema: ProfileSchema,
+  })
+  public async getById(payload: ProfileQueryById): Promise<Result<Profile, NotFoundError>> {
+    debug('getById', payload);
+
+    const client = await this.medusaApi.getClient();
+    const customerResponse = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+
+    if (!customerResponse.customer) {
+      return error<NotFoundError>({
+        identifier: payload.identifier,
+        type: 'NotFound',
+      });
+    }
+
+    const model = this.parseSingle(customerResponse.customer);
+    return success(model);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationUpdateSchema,
+    outputSchema: ProfileSchema,
+  })
+  public async update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>> {
+    debug('update', payload);
+
+    const client = await this.medusaApi.getClient();
+
+    const customerResponse = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+    if (!customerResponse.customer) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+
+    const customer = customerResponse.customer;
+
+    const updatedResponse = await client.store.customer.update({
+      phone: payload.phone ?? customer.phone,
+    }, { fields: this.includedFields.join(',') });
+
+    const model = this.parseSingle(updatedResponse.customer);
+    return success(model);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public async addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>> {
+    debug('addShippingAddress', payload);
+
+    const client = await this.medusaApi.getClient();
+
+    const medusaAddress = this.createMedusaAddress(payload.address);
+
+    // check if any address with the same nickName exists
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+    if (!customer.customer) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+    const existingAddress = customer.customer.addresses.find(addr => addr.address_name === payload.address.identifier.nickName);
+    if (existingAddress) {
+      return error<InvalidInputError>({
+        type: 'InvalidInput',
+        error: {
+          message: 'Address with the same nickname already exists',
+        }
+      });
+    }
+
+    const response = await client.store.customer.createAddress(medusaAddress, { fields: this.includedFields.join(',') });
+    if (!response.customer) {
+      return error<InvalidInputError>({
+        type: 'InvalidInput',
+        error: {
+          message: 'Failed to add shipping address',
+        }
+      });
+    }
+
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationUpdateShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public async updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>> {
+    debug('updateShippingAddress', payload);
+
+    const client = await this.medusaApi.getClient();
+
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+    if (!customer.customer) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier  ,
+      });
+    }
+
+    const medusaAddress = this.createMedusaAddress(payload.address);
+
+    const existingAddress = customer.customer.addresses.find(addr => addr.address_name === payload.address.identifier.nickName);
+    if (!existingAddress) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.address.identifier
+      });
+    }
+
+    const response = await client.store.customer.updateAddress(existingAddress.id, medusaAddress , { fields: this.includedFields.join(',') });
+    if (!response.customer) {
+      return error<InvalidInputError>({
+        type: 'InvalidInput',
+        error: {
+          message: 'Failed to add shipping address',
+        }
+      })
+    }
+
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+
+
+
+
+
+  @Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public async removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>> {
+    debug('removeShippingAddress', payload);
+    const client = await this.medusaApi.getClient();
+
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+    if (!customer.customer) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+    const existingAddress = customer.customer.addresses.find(addr => addr.address_name === payload.addressIdentifier.nickName);
+    if (!existingAddress) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.addressIdentifier,
+      });
+    }
+
+    const response = await client.store.customer.deleteAddress(existingAddress.id,{ fields: this.includedFields.join(',') });
+    if (!response.deleted) {
+      return error<InvalidInputError>({
+        type: 'InvalidInput',
+        error: {
+          message: 'Failed to delete shipping address',
+        }
+      });
+    }
+
+    const customerAfterDelete = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+
+    const model = this.parseSingle(customerAfterDelete.customer!);
+    return success(model);
+  }
+
+
+  @Reactionary({
+    inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
+    outputSchema: ProfileSchema,
+  })
+  public async makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>> {
+    debug('makeShippingAddressDefault', payload);
+
+    const client = await this.medusaApi.getClient();
+
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+    if (!customer.customer) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+    const existingAddress = customer.customer.addresses.find(addr => addr.address_name === payload.addressIdentifier.nickName);
+
+    if (!existingAddress) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.addressIdentifier ,
+      });
+    }
+
+    const response = await client.store.customer.updateAddress(existingAddress.id, {
+      is_default_shipping: true
+    }, { fields: this.includedFields.join(',') }
+    );
+
+    const model = this.parseSingle(response.customer!);
+    return success(model);
+  }
+
+  @Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema,
+  })
+  public async setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>> {
+    debug('setBillingAddress', payload);
+
+
+    const client = await this.medusaApi.getClient();
+
+    const customerResponse = await client.store.customer.retrieve({ fields: this.includedFields.join(',') });
+    if (!customerResponse.customer) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.identifier,
+      });
+    }
+    let customer = customerResponse.customer;
+
+    // check that this nickname is not used by another address
+    const existingAddressWithNickname = customer.addresses.find(addr => addr.address_name === payload.address.identifier.nickName);
+    if (existingAddressWithNickname && !existingAddressWithNickname.is_default_billing) {
+      return error<InvalidInputError>({
+        type: 'InvalidInput',
+        error: {
+          message: 'Another address with the same nickname already exists',
+        }
+      });
+    }
+
+
+    const newAddr = this.createMedusaAddress(payload.address);
+    newAddr.is_default_billing = true;
+
+    // two scenarios: Either we already have a billing addres, in which case we update it, or we dont and we need to create it.
+    const existingBillingAddress = customer.addresses.find(addr => addr.is_default_billing);
+    if (existingBillingAddress) {
+      const updateAddressResponse = await client.store.customer.updateAddress(existingBillingAddress.id, newAddr, { fields: this.includedFields.join(',') });
+      customer = updateAddressResponse.customer;
+    } else {
+      const createAddressResponse = await client.store.customer.createAddress(newAddr, { fields: this.includedFields.join(',') });
+      customer = createAddressResponse.customer;
+    }
+
+    const model = this.parseSingle(customer);
+    return success(model);
+  }
+
+  protected createMedusaAddress(address: Address): StoreCreateCustomerAddress {
+    return {
+      address_name: address.identifier.nickName,
+      first_name: address.firstName,
+      last_name: address.lastName,
+      address_1: address.streetAddress,
+      address_2: address.streetNumber,
+      city: address.city,
+      province: address.region,
+      postal_code: address.postalCode,
+      country_code: address.countryCode,
+    } satisfies StoreCreateCustomerAddress;
+  }
+
+  protected parseAddress(address: StoreCustomerAddress): Address {
+    return {
+      identifier: {
+        nickName: address.address_name || '',
+      },
+      firstName: address.first_name || '',
+      lastName: address.last_name || '',
+      streetAddress: address.address_1 || '',
+      streetNumber: address.address_2 || '',
+      city: address.city || '',
+      region: address.province || '',
+      postalCode: address.postal_code || '',
+      countryCode: address.country_code || '',
+    }
+  }
+
+  protected parseSingle(customer: StoreCustomer): Profile {
+    const email = customer.email;
+    const emailVerified = customer.metadata?.['email_verified'] === 'true';
+
+    const phone = customer.phone || '';
+    const phoneVerified = customer.metadata?.['phone_verified'] === 'true';
+
+    const addresses = customer.addresses || [];
+    let billingAddress: Address | undefined = undefined;
+    let shippingAddress: Address | undefined = undefined;
+
+    const existingBillingAddress = customer.addresses.find(addr => addr.is_default_billing);
+    if (existingBillingAddress) {
+      billingAddress = this.parseAddress(existingBillingAddress);
+    }
+
+    const existingShippingAddress = customer.addresses.find(addr => addr.is_default_shipping);
+    if (existingShippingAddress) {
+      shippingAddress = this.parseAddress(existingShippingAddress);
+    }
+
+    const alternateShippingAddresses: Address[] = [];
+
+    alternateShippingAddresses.push(...addresses.filter(x => ! (x.is_default_billing || x.is_default_shipping)).map( addr => this.parseAddress(addr)));
+
+    return {
+      identifier: {
+        userId: customer.id,
+      },
+      email,
+      emailVerified,
+      phone,
+      phoneVerified,
+      billingAddress: billingAddress,
+      shippingAddress: shippingAddress,
+      alternateShippingAddresses: alternateShippingAddresses,
+      createdAt: new Date(customer.created_at || '').toISOString(),
+      updatedAt: new Date(customer.updated_at || '').toISOString()
+    } satisfies Profile;
+  }
+
+
+
+}

package/providers/medusa/src/schema/capabilities.schema.ts

@@ -0,0 +1,18 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import type { z } from 'zod';
+
+export const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
+    productSearch: true,
+    cart: true,
+    checkout: true,
+    category: true,
+    product: true,
+    price: true,
+    order: true,
+    orderSearch: true,
+    inventory: true,
+    identity: true,
+    profile: true
+}).partial();
+
+export type MedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

package/providers/medusa/src/schema/configuration.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const MedusaConfigurationSchema = z.looseObject({
+    publishable_key: z.string().describe('The publishable API key for the Medusa store. Used for all storefront operations.'),
+    adminApiKey: z.string().describe('The API key for Medusa admin operations. Needed for the few tasks that require admin access.'),
+    apiUrl: z.string().describe('The base URL for the Medusa API.'),
+    defaultCurrency: z.string().default(''),
+    allCurrencies: z.string().array().default([]),
+});
+
+export type MedusaConfiguration = z.infer<typeof MedusaConfigurationSchema>;