pevey / medusa-auth-cognito Goto Github PK

import { CustomerService as MedusaCustomerService, Customer, CustomerGroup, setMetadata } from "@medusajs/medusa"
import { CreateCustomerInput, UpdateCustomerInput } from "@medusajs/medusa/dist/types/customers"
import { MedusaError } from "@medusajs/utils"
import { CustomerRepository } from "../repositories/customer"

export default class CustomerService extends MedusaCustomerService {
  private cognitoService: any
  protected readonly customerRepository_: typeof CustomerRepository
  private emailsMapByPassword = new Map<string, { email: string; action: "create" | "update" }>()

  constructor({ cognitoService, customerRepository }) {
    // @ts-ignore
    super(...arguments)
    this.cognitoService = cognitoService
    this.customerRepository_ = customerRepository
  }

  async create(customer: CreateCustomerInput): Promise<Customer> {
    return await this.atomicPhase_(async (manager) => {
      const { email, password } = customer
      this.emailsMapByPassword.set(password, { email, action: "create" })
      return await super.create(customer)
    })
  }

  async update(
    customerId: string,
    update: UpdateCustomerInput
  ) {
    return await this.atomicPhase_(async (manager) => {
      const customer = await this.retrieve(customerId, { select: ["email"] })
      const { email } = customer
      if (update.password) {
        this.emailsMapByPassword.set(update.password, { email, action: "update" })
      }
      return await super.update(customerId, update)
    })
  }

  async hasPassword_(password: string): Promise<string> {
    const { email, action } = this.emailsMapByPassword.get(password)
    const hash = 'cognito'

    try {
      if (action === "create") {
        const isCreated = await this.cognitoService.createCustomer(email, password)
        if (!isCreated) {
          this.emailsMapByPassword.delete(password)
          throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, "Could not create customer in Cognito")
        }
      } else {
        await this.cognitoService.setCustomerPassword(email, password).catch(() => {
          throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, "Could not update customer password in Cognito")
        })
      }
      
      return hash
    } finally {
      this.emailsMapByPassword.delete(password)
    }
  }

  async delete(customerId: string): Promise<Customer | void> {
    return await this.atomicPhase_(async (manager) => {
      const removedCustomer = await super.delete(customerId)
      await this.cognitoService.deleteCustomer(removedCustomer.email).catch(() => {
        throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, "Could not delete customer in Cognito")
      })
      return removedCustomer
    })
  }
}