JWT & SendGrid - 實作電商忘記密碼

                            Table "public.customer"
       Column       |           Type           | Collation | Nullable | Default
--------------------+--------------------------+-----------+----------+---------
 id                 | character varying        |           | not null |
 email              | character varying        |           | not null |
 first_name         | character varying        |           |          |
 last_name          | character varying        |           |          |
 billing_address_id | character varying        |           |          |
 password_hash      | character varying        |           |          |
 phone              | character varying        |           |          |
 has_account        | boolean                  |           | not null | false
 created_at         | timestamp with time zone |           | not null | now()
 updated_at         | timestamp with time zone |           | not null | now()
 deleted_at         | timestamp with time zone |           |          |
 metadata           | jsonb                    |           |          |

import { EntityRepository, Repository } from "typeorm";
import { User } from "../models/user";

@EntityRepository(User)
export class UserRepository extends Repository<User> {}

class UserSerivce {
  constructor() {
    // DI...
  }

  async retrieve(userId: string, config: FindConfig<User> = {}): Promise<User> {
    // ...
  }

  async retrieveByApiToken(
    apiToken: string,
    relations: string[] = []
  ): Promise<User> {
    // ...
  }

  async retrieveByEmail(
    email: string,
    config: FindConfig<User> = {}
  ): Promise<User> {
    // ...
  }

  async update(userId: string, update: UpdateUserInput): Promise<User> {
    // ...
  }

  async delete(userId: string): Promise<void> {
    // ...
  }
}

// Ref: https://github.com/medusajs/medusa/blob/233d6904f89d6f25789c879f123df7d069dfdb66/packages/medusa/src/api/routes/store/customers/reset-password-token.ts

export default async (req, res) => {
  const validated = (await validator(
    StorePostCustomersCustomerPasswordTokenReq,
    req.body
  )) as StorePostCustomersCustomerPasswordTokenReq;

  // Get user service through DI
  const customerService: CustomerService = req.scope.resolve(
    "customerService"
  ) as CustomerService;

  const customer = await customerService.retrieveRegisteredByEmail(
    validated.email
  );

  // Will generate a token and send it to the customer via an email provider
  const manager: EntityManager = req.scope.resolve("manager");
  await manager.transaction(async (transactionManager) => {
    return await customerService
      .withTransaction(transactionManager)
      .generateResetPasswordToken(customer.id);
  });

  res.sendStatus(204);
};

// Ref: https://github.com/medusajs/medusa/blob/233d6904f89d6f25789c879f123df7d069dfdb66/packages/medusa/src/services/user.ts#L321

/**
   * Generate a JSON Web token, that will be sent to a user, that wishes to
   * reset password.
   * The token will be signed with the users current password hash as a secret
   * a long side a payload with userId and the expiry time for the token, which
   * is always 15 minutes.
   * @param {string} userId - the id of the user to reset password for
   * @return {string} the generated JSON web token
   */
  async generateResetPasswordToken(userId: string): Promise<string> {
    return await this.atomicPhase_(async (transactionManager) => {
      const user = await this.retrieve(userId, {
        select: ["id", "email", "password_hash"],
      })
      const secret = user.password_hash   // Use this user's password as hash secret
      const expiry = Math.floor(Date.now() / 1000) + 60 * 15   // 15 mins
      const payload = { user_id: user.id, email: user.email, exp: expiry }
      const token = jwt.sign(payload, secret)

      // Notify subscribers
      await this.eventBus_
        .withTransaction(transactionManager)
        .emit(UserService.Events.PASSWORD_RESET, {
          email: user.email,
          token,
        })

      return token
    })
  }

class CustomerPasswordResetSubscriber {
  private sendgridService_;

  // `user.password_reset` -> Triggered when a customer requests to reset their password.
  // Ref: https://github.com/medusajs/medusa/blob/5af39e7beba1eecff4750aa470d9aa4135112923/docs/content/advanced/backend/subscribers/events-list.md#customer-events
  constructor({ eventBusService, sendgridService }) {
    eventBusService.subscribe("user.password_reset", this.handlePasswordReset);
    this.sendgridService_ = sendgridService;
  }

  handlePasswordReset = async (rawData: CustomerPasswordResetData) => {
    try {
      console.log("[SEND EMAIL] Customer password reset");
      console.log("Received raw data: ", rawData);

      const segments = rawData.token.split(".");
      let payload = "";
      if (segments.length === 3) {
        payload = segments[1]; // Second part is base64 encoded payload
      }
      if (!payload) {
        console.error(`Invalid token: ${rawData.token}`);
        console.error(
          `Failed to send customer password reset email ${rawData.email}`
        );
      }
      const decodedPayload: DecodedTokenPayload = JSON.parse(
        Buffer.from(payload, "base64").toString("ascii")
      );
      console.log("Received decoded token payload: ", decodedPayload);

      const resetPasswordUrl = `${projectConfig.store_cors}/account/resetPassword?token=${rawData.token}`;

      const sendOptions: SendOptions = {
        templateId: process.env.SENDGRID_RESET_PASSWORD_ID,
        from: process.env.SENDGRID_FROM,
        to: rawData.email, // old email
        dynamicTemplateData: {
          name: "Madi",
          content: `Customer password reset. Please click this url to reset your password. ${resetPasswordUrl}`,
        },
      };
      console.log("Send email options: ", sendOptions);

      const result = await this.sendgridService_.sendEmail(sendOptions);
      if (result?.[0]?.statusCode === 202) {
        console.log(
          `Successfully send customer password reset email to ${rawData.email}`
        );
      } else {
        console.error(
          `Failed to send customer password reset email to ${rawData.email}`
        );
      }
    } catch (err) {
      console.error(err);
    }
  };
}