@reactionary/medusa 0.6.3

package/capabilities/profile.capability.js

@@ -0,0 +1,333 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  ProfileCapability,
+  Reactionary,
+  ProfileSchema,
+  ProfileMutationUpdateSchema,
+  ProfileMutationAddShippingAddressSchema,
+  ProfileMutationUpdateShippingAddressSchema,
+  ProfileMutationRemoveShippingAddressSchema,
+  ProfileMutationMakeShippingAddressDefaultSchema,
+  ProfileMutationSetBillingAddressSchema,
+  success,
+  ProfileQueryByIdSchema,
+  error
+} from "@reactionary/core";
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:profile");
+class MedusaProfileCapability extends ProfileCapability {
+  constructor(config, cache, context, medusaApi, factory) {
+    super(cache, context);
+    this.medusaApi = medusaApi;
+    this.config = config;
+    this.factory = factory;
+  }
+  config;
+  includedFields = ["+metadata.*"];
+  factory;
+  async getById(payload) {
+    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({
+        identifier: payload.identifier,
+        type: "NotFound"
+      });
+    }
+    const model = this.parseSingle(customerResponse.customer);
+    return success(model);
+  }
+  updatePayload(payload) {
+    const updateData = {};
+    if (payload.phone !== void 0) {
+      updateData.phone = payload.phone;
+    }
+    return updateData;
+  }
+  async update(payload) {
+    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({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const customer = customerResponse.customer;
+    const updatedResponse = await client.store.customer.update(this.updatePayload(payload), { fields: this.includedFields.join(",") });
+    const model = this.parseSingle(updatedResponse.customer);
+    return success(model);
+  }
+  addShippingAddressPayload(payload) {
+    return this.createMedusaAddress(payload.address);
+  }
+  async addShippingAddress(payload) {
+    debug("addShippingAddress", payload);
+    const client = await this.medusaApi.getClient();
+    const customer = await client.store.customer.retrieve({ fields: this.includedFields.join(",") });
+    if (!customer.customer) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.address.identifier.nickName);
+    if (existingAddress) {
+      return error({
+        type: "InvalidInput",
+        error: "Address with the same nickname already exists"
+      });
+    }
+    const response = await client.store.customer.createAddress(this.addShippingAddressPayload(payload), { fields: this.includedFields.join(",") });
+    if (!response.customer) {
+      return error({
+        type: "InvalidInput",
+        error: "Failed to add shipping address"
+      });
+    }
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+  updateShippingAddressPayload(payload) {
+    return this.createMedusaAddress(payload.address);
+  }
+  async updateShippingAddress(payload) {
+    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({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.address.identifier.nickName);
+    if (!existingAddress) {
+      return error({
+        type: "NotFound",
+        identifier: payload.address.identifier
+      });
+    }
+    const response = await client.store.customer.updateAddress(existingAddress.id, this.updateShippingAddressPayload(payload), { fields: this.includedFields.join(",") });
+    if (!response.customer) {
+      return error({
+        type: "InvalidInput",
+        error: "Failed to add shipping address"
+      });
+    }
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+  async removeShippingAddress(payload) {
+    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({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.addressIdentifier.nickName);
+    if (!existingAddress) {
+      return error({
+        type: "NotFound",
+        identifier: payload.addressIdentifier
+      });
+    }
+    const response = await client.store.customer.deleteAddress(existingAddress.id, { fields: this.includedFields.join(",") });
+    if (!response.deleted) {
+      return error({
+        type: "InvalidInput",
+        error: "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);
+  }
+  makeShippingAddressDefaultPayload(payload) {
+    return {
+      is_default_shipping: true
+    };
+  }
+  async makeShippingAddressDefault(payload) {
+    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({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    const existingAddress = customer.customer.addresses.find((addr) => addr.address_name === payload.addressIdentifier.nickName);
+    if (!existingAddress) {
+      return error({
+        type: "NotFound",
+        identifier: payload.addressIdentifier
+      });
+    }
+    const response = await client.store.customer.updateAddress(
+      existingAddress.id,
+      this.makeShippingAddressDefaultPayload(payload),
+      { fields: this.includedFields.join(",") }
+    );
+    const model = this.parseSingle(response.customer);
+    return success(model);
+  }
+  setBillingAddressPayload(payload) {
+    const newAddr = this.createMedusaAddress(payload.address);
+    newAddr.is_default_billing = true;
+    return newAddr;
+  }
+  async setBillingAddress(payload) {
+    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({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    let customer = customerResponse.customer;
+    const existingAddressWithNickname = customer.addresses.find((addr) => addr.address_name === payload.address.identifier.nickName);
+    if (existingAddressWithNickname && !existingAddressWithNickname.is_default_billing) {
+      return error({
+        type: "InvalidInput",
+        error: "Another address with the same nickname already exists"
+      });
+    }
+    const newAddr = this.setBillingAddressPayload(payload);
+    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);
+  }
+  createMedusaAddress(address) {
+    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
+    };
+  }
+  parseAddress(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 || ""
+    };
+  }
+  parseSingle(customer) {
+    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 = void 0;
+    let shippingAddress = void 0;
+    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 = [];
+    alternateShippingAddresses.push(...addresses.filter((x) => !(x.is_default_billing || x.is_default_shipping)).map((addr) => this.parseAddress(addr)));
+    const result = {
+      identifier: {
+        userId: customer.id
+      },
+      email,
+      emailVerified,
+      phone,
+      phoneVerified,
+      billingAddress,
+      shippingAddress,
+      alternateShippingAddresses,
+      createdAt: new Date(customer.created_at || "").toISOString(),
+      updatedAt: new Date(customer.updated_at || "").toISOString()
+    };
+    return this.factory.parseProfile(this.context, result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileQueryByIdSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileCapability.prototype, "update", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationAddShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileCapability.prototype, "addShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationUpdateShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileCapability.prototype, "updateShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationRemoveShippingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileCapability.prototype, "removeShippingAddress", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationMakeShippingAddressDefaultSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileCapability.prototype, "makeShippingAddressDefault", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProfileMutationSetBillingAddressSchema,
+    outputSchema: ProfileSchema
+  })
+], MedusaProfileCapability.prototype, "setBillingAddress", 1);
+export {
+  MedusaProfileCapability
+};

package/core/client.js

@@ -0,0 +1,269 @@
+import { Admin, Auth, Client, Store } from "@medusajs/js-sdk";
+import {
+  AnonymousIdentitySchema,
+  Reactionary,
+  RegisteredIdentitySchema
+} from "@reactionary/core";
+import createDebug from "debug";
+import {
+  MedusaSessionSchema
+} from "../index.js";
+const debug = createDebug("reactionary:medusa");
+const SESSION_KEY = "MEDUSA_PROVIDER";
+class RequestContextTokenStore {
+  constructor(context, keyPrefix = "__x") {
+    this.context = context;
+    this.keyPrefix = keyPrefix;
+  }
+  getItem(key) {
+    if (this.context.session[SESSION_KEY] === void 0) {
+      this.context.session[SESSION_KEY] = {};
+    }
+    const retVal = this.context.session[SESSION_KEY] ? this.context.session[SESSION_KEY][this.keyPrefix + "_" + key] || null : null;
+    if (debug.enabled) {
+      debug(
+        `Getting token item for key: ${this.keyPrefix + "_" + key} - Found: ${retVal ? "Yes" : "No"}`
+      );
+    }
+    return Promise.resolve(retVal);
+  }
+  setItem(key, value) {
+    if (this.context.session[SESSION_KEY] === void 0) {
+      this.context.session[SESSION_KEY] = {};
+    }
+    if (debug.enabled) {
+      debug(
+        `Setting token item for key: ${this.keyPrefix + "_" + key} - Value: ${value}`
+      );
+    }
+    this.context.session[SESSION_KEY][this.keyPrefix + "_" + key] = value;
+    return Promise.resolve();
+  }
+  removeItem(key) {
+    if (this.context.session[SESSION_KEY] === void 0) {
+      this.context.session[SESSION_KEY] = {};
+    }
+    if (debug.enabled) {
+      debug(`Removing token item for key: ${this.keyPrefix + "_" + key}`);
+    }
+    delete this.context.session[SESSION_KEY][this.keyPrefix + "_" + key];
+    return Promise.resolve();
+  }
+}
+class Medusa {
+  client;
+  admin;
+  store;
+  auth;
+  constructor(config) {
+    this.client = new Client(config);
+    this.admin = new Admin(this.client);
+    this.store = new Store(this.client);
+    this.auth = new Auth(this.client, config);
+  }
+}
+class MedusaAdminAPI {
+  config;
+  client;
+  context;
+  constructor(config, context) {
+    this.config = config;
+    this.context = context;
+    console.log(
+      "MedusaAdminClient config:",
+      this.config,
+      "Debug enabled:",
+      debug.enabled
+    );
+    this.client = new Medusa({
+      baseUrl: this.config.apiUrl,
+      apiKey: this.config.adminApiKey,
+      debug: true
+    });
+  }
+  async getClient() {
+    return this.client;
+  }
+}
+class MedusaAPI {
+  config;
+  client;
+  context;
+  constructor(config, context) {
+    this.config = config;
+    this.context = context;
+    console.log(
+      "MedusaClient config:",
+      this.config,
+      "Debug enabled:",
+      debug.enabled
+    );
+    this.client = void 0;
+  }
+  async getActiveRegion() {
+    const session = this.getSessionData();
+    if (session.selectedRegion) {
+      return session.selectedRegion;
+    }
+    const regions = await (await this.getClient()).store.region.list();
+    const allRegions = [];
+    for (const region of regions.regions) {
+      allRegions.push({
+        id: region.id,
+        name: region.name,
+        currency_code: region.currency_code
+      });
+    }
+    const selectedRegion = allRegions.find(
+      (r) => r.currency_code === this.context.languageContext.currencyCode.toLowerCase()
+    ) || allRegions[0];
+    this.context.languageContext.currencyCode = (selectedRegion || allRegions[0]).currency_code.toUpperCase();
+    this.setSessionData({
+      allRegions,
+      selectedRegion
+    });
+    return selectedRegion;
+  }
+  async resolveProductForSKU(sku) {
+    const adminClient = await new MedusaAdminAPI(
+      this.config,
+      this.context
+    ).getClient();
+    const productsResponse = await adminClient.admin.product.list({
+      limit: 1,
+      offset: 0,
+      fields: "+metadata.*,+categories.metadata.*,+external_id",
+      variants: {
+        $or: [{ ean: sku }, { upc: sku }, { barcode: sku }]
+      }
+    });
+    const product = productsResponse.products[0];
+    if (!product) {
+      throw new Error(`Product with SKU ${sku} not found`);
+    }
+    return product;
+  }
+  /**
+   * This function should not need to exist.
+   * It returns a product-id, given a SKU.
+   * @param sku
+   * @returns
+   */
+  async resolveVariantId(sku) {
+    const product = await this.resolveProductForSKU(sku);
+    const variant = product.variants?.find((v) => v.sku === sku);
+    if (!variant) {
+      throw new Error(`Variant with SKU ${sku} not found`);
+    }
+    return variant.id;
+  }
+  async getClient() {
+    if (!this.client) {
+      this.client = this.createAuthenticatedClient(this.context);
+    }
+    return await this.client;
+  }
+  getSessionData() {
+    return this.context.session[SESSION_KEY] ? this.context.session[SESSION_KEY] : MedusaSessionSchema.parse({});
+  }
+  setSessionData(sessionData) {
+    const existingData = this.context.session[SESSION_KEY];
+    this.context.session[SESSION_KEY] = {
+      ...existingData,
+      ...sessionData
+    };
+  }
+  async register(email, password, firstName, lastName, reqCtx) {
+    try {
+      const client = await this.getClient();
+      const tokenResponse = await client.auth.register(
+        "customer",
+        "emailpass",
+        {
+          email,
+          password
+        }
+      );
+      const customer = await client.store.customer.create({
+        email,
+        first_name: firstName,
+        last_name: lastName
+      });
+      const identity = await this.login(email, password, reqCtx);
+      return identity;
+    } catch (error) {
+      debug("Registration failed:", error);
+      throw new Error(
+        `Registration failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  async login(email, password, reqCtx) {
+    try {
+      const client = await this.getClient();
+      const authResult = await client.auth.login("customer", "emailpass", {
+        email,
+        password
+      });
+      if (typeof authResult === "string") {
+        const token = authResult;
+        if (token) {
+          await client.client.setToken(token);
+        }
+      }
+      const customerResponse = await client.store.customer.retrieve();
+      if (customerResponse.customer) {
+        const identity = {
+          id: {
+            userId: customerResponse.customer.id
+          },
+          type: "Registered"
+        };
+        return identity;
+      }
+      return {
+        type: "Anonymous"
+      };
+    } catch (error) {
+      debug("Login failed:", error);
+      throw new Error(
+        `Login failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  async logout(reqCtx) {
+    const identity = {
+      type: "Anonymous"
+    };
+    const client = await this.getClient();
+    try {
+      await client.auth.logout();
+      await client.client.clearToken();
+      return identity;
+    } catch (error) {
+      debug("Logout failed:", error);
+      await client.client.clearToken();
+      return identity;
+    }
+  }
+  async createAuthenticatedClient(reqCtx) {
+    const tokenStore = new RequestContextTokenStore(reqCtx);
+    const authenticatedClient = new Medusa({
+      baseUrl: this.config.apiUrl,
+      publishableKey: this.config.publishable_key,
+      debug: true,
+      auth: {
+        type: "jwt",
+        jwtTokenStorageMethod: "custom",
+        storage: tokenStore
+      }
+    });
+    return authenticatedClient;
+  }
+}
+export {
+  MedusaAPI,
+  MedusaAdminAPI,
+  RequestContextTokenStore,
+  SESSION_KEY
+};