@labdigital/commercetools-mock 2.0.0 → 2.1.0

package/dist/index.cjs

@@ -53,10 +53,12 @@ var import_assert = __toESM(require("assert"), 1);
 var CommercetoolsError = class extends Error {
   info;
   statusCode;
+  errors;
   constructor(info, statusCode = 400) {
     super(info.message);
     this.info = info;
     this.statusCode = statusCode || 500;
+    this.errors = info.errors ?? [];
   }
 };
 
@@ -1256,6 +1258,16 @@ var OAuth2Store = class {
     this.tokens.push(token);
     return token;
   }
+  getCustomerToken(scope, customerId) {
+    const token = {
+      access_token: (0, import_crypto.randomBytes)(16).toString("base64"),
+      token_type: "Bearer",
+      expires_in: 172800,
+      scope: scope ? `${scope} custome_id:${customerId}` : `customer_id: ${customerId}`
+    };
+    this.tokens.push(token);
+    return token;
+  }
   validateToken(token) {
     if (!this.validate)
       return true;
@@ -1277,16 +1289,36 @@ var getBearerToken = (request) => {
   return void 0;
 };
 
+// src/lib/password.ts
+var hashPassword = (clearPassword) => Buffer.from(clearPassword).toString("base64");
+
 // src/oauth/server.ts
 var OAuth2Server = class {
   store;
+  customerRepository;
   constructor(options) {
     this.store = new OAuth2Store(options.validate);
   }
+  setCustomerRepository(repository) {
+    this.customerRepository = repository;
+  }
   createRouter() {
     const router = import_express.default.Router();
     router.use(import_body_parser.default.urlencoded({ extended: true }));
+    router.use(this.validateClientCredentials.bind(this));
     router.post("/token", this.tokenHandler.bind(this));
+    router.post(
+      "/:projectKey/customers/token",
+      this.customerTokenHandler.bind(this)
+    );
+    router.post(
+      "/:projectKey/in-store/key=:storeKey/customers/token",
+      this.inStoreCustomerTokenHandler.bind(this)
+    );
+    router.post(
+      "/:projectKey/anonymous/token",
+      this.anonymousTokenHandler.bind(this)
+    );
     return router;
   }
   createMiddleware() {
@@ -1317,7 +1349,7 @@ var OAuth2Server = class {
       next();
     };
   }
-  async tokenHandler(request, response, next) {
+  async validateClientCredentials(request, response, next) {
     const authHeader = request.header("Authorization");
     if (!authHeader) {
       return next(
@@ -1342,6 +1374,13 @@ var OAuth2Server = class {
         )
       );
     }
+    request.credentials = {
+      clientId: credentials.name,
+      clientSecret: credentials.pass
+    };
+    next();
+  }
+  async tokenHandler(request, response, next) {
     const grantType = request.query.grant_type || request.body.grant_type;
     if (!grantType) {
       return next(
@@ -1356,8 +1395,15 @@ var OAuth2Server = class {
     }
     if (grantType === "client_credentials") {
       const token = this.store.getClientToken(
-        credentials.name,
-        credentials.pass,
+        request.credentials.clientId,
+        request.credentials.clientSecret,
+        request.query.scope?.toString()
+      );
+      return response.status(200).send(token);
+    } else if (grantType === "refresh_token") {
+      const token = this.store.getClientToken(
+        request.credentials.clientId,
+        request.credentials.clientSecret,
         request.query.scope?.toString()
       );
       return response.status(200).send(token);
@@ -1373,6 +1419,69 @@ var OAuth2Server = class {
       );
     }
   }
+  async customerTokenHandler(request, response, next) {
+    const grantType = request.query.grant_type || request.body.grant_type;
+    if (!grantType) {
+      return next(
+        new CommercetoolsError(
+          {
+            code: "invalid_request",
+            message: "Missing required parameter: grant_type."
+          },
+          400
+        )
+      );
+    }
+    if (grantType === "password") {
+      const username = request.query.username || request.body.username;
+      const password = hashPassword(
+        request.query.password || request.body.password
+      );
+      const scope = request.query.scope?.toString() || request.body.scope?.toString();
+      const result = this.customerRepository.query(
+        { projectKey: request.params.projectKey },
+        {
+          where: [`email = "${username}"`, `password = "${password}"`]
+        }
+      );
+      if (result.count === 0) {
+        return next(
+          new CommercetoolsError(
+            {
+              code: "invalid_customer_account_credentials",
+              message: "Customer account with the given credentials not found."
+            },
+            400
+          )
+        );
+      }
+      const customer = result.results[0];
+      const token = this.store.getCustomerToken(scope, customer.id);
+      return response.status(200).send(token);
+    }
+  }
+  async inStoreCustomerTokenHandler(request, response, next) {
+    return next(
+      new CommercetoolsError(
+        {
+          code: "invalid_client",
+          message: "Not implemented yet in commercetools-mock"
+        },
+        401
+      )
+    );
+  }
+  async anonymousTokenHandler(request, response, next) {
+    return next(
+      new CommercetoolsError(
+        {
+          code: "invalid_client",
+          message: "Not implemented yet in commercetools-mock"
+        },
+        401
+      )
+    );
+  }
 };
 
 // src/projectAPI.ts
@@ -2849,11 +2958,29 @@ var CustomerRepository = class extends AbstractResourceRepository {
     return "customer";
   }
   create(context, draft) {
+    const results = this._storage.query(context.projectKey, this.getTypeId(), {
+      where: [`email="${draft.email.toLocaleLowerCase()}"`]
+    });
+    if (results.count > 0) {
+      throw new CommercetoolsError({
+        code: "CustomerAlreadyExists",
+        statusCode: 400,
+        message: "There is already an existing customer with the provided email.",
+        errors: [
+          {
+            code: "DuplicateField",
+            message: `Customer with email '${draft.email}' already exists.`,
+            duplicateValue: draft.email,
+            field: "email"
+          }
+        ]
+      });
+    }
     const resource = {
       ...getBaseResourceProperties(),
       authenticationMode: draft.authenticationMode || "Password",
-      email: draft.email,
-      password: draft.password ? Buffer.from(draft.password).toString("base64") : void 0,
+      email: draft.email.toLowerCase(),
+      password: draft.password ? hashPassword(draft.password) : void 0,
       isEmailVerified: draft.isEmailVerified || false,
       addresses: []
     };
@@ -2891,7 +3018,7 @@ var CustomerRepository = class extends AbstractResourceRepository {
         return;
       }
       if (authMode === "Password") {
-        resource.password = password ? Buffer.from(password).toString("base64") : void 0;
+        resource.password = password ? hashPassword(password) : void 0;
         return;
       }
       throw new CommercetoolsError(
@@ -6021,7 +6148,7 @@ var MyCustomerService = class extends AbstractService {
   }
   signIn(request, response) {
     const { email, password } = request.body;
-    const encodedPassword = Buffer.from(password).toString("base64");
+    const encodedPassword = hashPassword(password);
     const result = this.repository.query(getRepositoryContext(request), {
       where: [`email = "${email}"`, `password = "${encodedPassword}"`]
     });
@@ -6458,6 +6585,7 @@ var CommercetoolsMock = class {
   }
   createApp(options) {
     this._repositories = createRepositories(this._storage);
+    this._oauth2.setCustomerRepository(this._repositories.customer);
     const app = (0, import_express6.default)();
     const projectRouter = import_express6.default.Router({ mergeParams: true });
     projectRouter.use(import_express6.default.json());
@@ -6483,6 +6611,13 @@ var CommercetoolsMock = class {
     );
     app.use((err, req, resp, next) => {
       if (err instanceof CommercetoolsError) {
+        if (err.errors?.length > 0) {
+          return resp.status(err.statusCode).send({
+            statusCode: err.statusCode,
+            message: err.message,
+            errors: err.errors
+          });
+        }
         return resp.status(err.statusCode).send({
           statusCode: err.statusCode,
           message: err.message,