prow-authority 3.6.3

package/src/v1/routes/admin/user-policy-router.ts

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import userPolicyController from '../../controllers/admin/user-policy-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class UserPolicyRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await userPolicyController.get(parseInt(req.params[`id`], 10));
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly list = async (req: Request, res: Response) => {
+    try {
+      const response = await userPolicyController.list(req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly add = async (req: Request, res: Response) => {
+    try {
+      const response = await userPolicyController.add(req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly update = async (req: Request, res: Response) => {
+    try {
+      const response = await userPolicyController.update(parseInt(req.params[`id`], 10), req.body);
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly delete = async (req: Request, res: Response) => {
+    try {
+      const response = await userPolicyController.delete(parseInt(req.params[`id`], 10));
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+    this.router.get(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const userPolicyRouter = (new UserPolicyRouter()).router;
+export default userPolicyRouter;

package/src/v1/routes/admin/user-router.ts

@@ -0,0 +1,89 @@
+import { Request, Router, Response } from 'express';
+import userController from '../../controllers/admin/user-controller';
+import httpcodes from 'http-status-codes';
+import APIError from '../../../helpers/api-error';
+
+class UserRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly get = async (req: Request, res: Response) => {
+    try {
+      const response = await userController.get(parseInt(req.params[`id`], 10), { password: false });
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly list = async (req: Request, res: Response) => {
+    try {
+      const response = await userController.list(req.body, { password: false });
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly add = async (req: Request, res: Response) => {
+    try {
+      const response = await userController.add(req.body, { password: false });
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly update = async (req: Request, res: Response) => {
+    try {
+      const response = await userController.update(parseInt(req.params[`id`], 10), req.body, { password: false });
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly delete = async (req: Request, res: Response) => {
+    try {
+      const response = await userController.delete(parseInt(req.params[`id`], 10));
+      res.json(response);
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+    this.router.get(`/:id`, this.get);
+    this.router.post(`/list`, this.list);
+    this.router.post(`/`, this.add);
+    this.router.put(`/:id`, this.update);
+    this.router.delete(`/:id`, this.delete);
+  };
+}
+
+const userRouter = (new UserRouter()).router;
+export default userRouter;

package/src/v1/routes/auth/@deprecated auth-router.ts

@@ -0,0 +1,199 @@
+// import { Request, Response, Router } from 'express';
+// import APIError, { StatusCodes } from '../../helpers/api-error';
+// import identityTokenController from '../controllers/auth/identity-token-controller';
+// import identityTokenMiddleware from '../middlewares/identity-token-middleware';
+// import userMiddleware from '../middlewares/user-middleware';
+// import confirmationCtrl from '../controllers/auth/confirmation-controller';
+
+// export class AuthRouter {
+//   router: Router;
+
+//   constructor() {
+//     this.router = Router();
+//     this.init();
+//   }
+
+//   // session credentials
+//   private readonly login = async (req: Request, res: Response) => {
+//     try {
+//       const response = await identityTokenController.login(req.body);
+//       res.setHeader(`Cache-Control`, `no-store`).json(response);
+//     } catch (e: any) {
+//       if (e instanceof APIError) {
+//         res.status(e.code).json(e.data);
+//       } else {
+//         res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+//       }
+//     }
+//   };
+
+//   private readonly confirm = async (req: Request, res: Response) => {
+//     try {
+//       const response = await confirmationCtrl.confirm(req[`user`], req.body);
+//       res.setHeader(`Cache-Control`, `no-store`).json(response);
+//     } catch (e: any) {
+//       if (e instanceof APIError) {
+//         res.status(e.code).json(e.data);
+//       } else {
+//         res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+//       }
+//     }
+//   };
+
+//   // // oauth credentials
+//   // private readonly accountPage = async (req: Request, res: Response) => {
+//   //   try {
+//   //     const { token } = req.body;
+
+//   //     let session: Session;
+//   //     if (token) {
+//   //       try {
+//   //         session = await authController.recoverOAuthSession(token);
+//   //       } catch (e) { }
+//   //     }
+
+//   //     if (!session) {
+//   //       const data = Validator.validate(Schema.object({
+//   //         client_id: Schema.requiredString(),
+//   //         redirect_uri: Schema.requiredString(),
+//   //         response_type: Schema.requiredString(),
+//   //         scope: Schema.requiredString(),
+//   //         access_type: Schema.requiredString(),
+//   //       }), req.query as any);
+//   //       session = await authController.startOAuthSession(data);
+//   //     }
+
+//   //     const page = new File2({ path: __dirname, filename: `../../../static/login.html` });
+//   //     const html = new String2(page.toString()).compile(session);
+
+//   //     res.status(httpcodes.OK).send(html);
+//   //   } catch (e) {
+//   //     const page = new File2({ path: __dirname, filename: `../../../static/error.html` });
+//   //     const html = new String2(page.toString()).compile({ error: e.message });
+//   //     res.status(httpcodes.INTERNAL_SERVER_ERROR).send(html);
+//   //   }
+//   // };
+
+//   // private readonly accountCheck = async (req: Request, res: Response) => {
+//   //   try {
+//   //     const { username, password, token } = req.body;
+
+//   //     const { success, user } = await authController.login(username, password);
+
+//   //     if (!success) {
+//   //       // TODO
+//   //       res.redirect(`/auth/account`);
+//   //       return;
+//   //     }
+
+//   //     const session = await authController.setUserOnOAuthSession(token, user.id);
+
+//   //     const page = new File2({ path: __dirname, filename: `../../../static/grant.html` });
+//   //     const html = new String2(page.toString()).compile(session);
+
+//   //     res.status(httpcodes.OK).send(html);
+//   //   } catch (e) {
+//   //     const page = new File2({ path: __dirname, filename: `../../../static/error.html` });
+//   //     const html = new String2(page.toString()).compile({ error: e.message });
+//   //     res.status(httpcodes.INTERNAL_SERVER_ERROR).send(html);
+//   //   }
+//   // };
+
+//   // private readonly cancelAccess = async (req: Request, res: Response) => {
+//   //   try {
+//   //     const { token } = req.body;
+//   //     const { redirect } = await authController.cancelOauthSession(token);
+//   //     res.redirect(redirect);
+//   //   } catch (e) {
+//   //     const page = new File2({ path: __dirname, filename: `../../../static/error.html` });
+//   //     const html = new String2(page.toString()).compile({ error: e.message });
+//   //     res.status(httpcodes.INTERNAL_SERVER_ERROR).send(html);
+//   //   }
+//   // };
+
+//   // private readonly grantAccess = async (req: Request, res: Response) => {
+//   //   try {
+//   //     const { token } = req.body;
+//   //     const { redirect } = await authController.grantOAuthSession(token);
+//   //     res.redirect(redirect);
+//   //   } catch (e) {
+//   //     const page = new File2({ path: __dirname, filename: `../../../static/error.html` });
+//   //     const html = new String2(page.toString()).compile({ error: e.message });
+//   //     res.status(httpcodes.INTERNAL_SERVER_ERROR).send(html);
+//   //   }
+//   // };
+
+//   // private readonly oauthToken = async (req: Request, res: Response) => {
+//   //   try {
+//   //     const data = Validator.validate(Schema.alternatives(a, b), req.body);
+
+//   //     const response = await authController.oauthToken(data);
+//   //     res.json(response);
+//   //   } catch (e) {
+//   //     // TODO: route error logic
+//   //     res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+//   //   }
+//   // };
+
+//   // private readonly revokeToken = async (req: Request, res: Response) => {
+//   //   try {
+//   //     const { id } = await Validator.validate(Schema.object({ id: Schema.requiredString() }), req.body);
+//   //     await authController.revokeToken(id);
+//   //     res.json({ done: true });
+//   //   } catch (e) {
+//   //     // TODO: route error logic
+//   //     res.status(httpcodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+//   //   }
+//   // };
+
+
+//   private readonly refresh = async (req: Request, res: Response) => {
+//     try {
+//       const response = await identityTokenController.refresh(req[`access_token`], req.body);
+//       res.setHeader(`Cache-Control`, `no-store`).json(response);
+//     } catch (e: any) {
+//       if (e instanceof APIError) {
+//         res.status(e.code).json(e.data);
+//       } else {
+//         res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+//       }
+//     }
+//   };
+
+//   private readonly user = async (req: Request, res: Response) => {
+//     try {
+//       const response = req[`user`];
+//       res.json(response);
+//     } catch (e) {
+//       res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+//     }
+//   };
+
+//   private readonly init = () => {
+//     // static credentials
+
+//     // session credentials
+//     this.router.post(`/user`, this.login);
+
+//     // oauth credentials
+//     // this.router.all(`/account`, this.accountPage);
+//     // this.router.post(`/account/check`, this.accountCheck);
+//     // this.router.post(`/account/grant`, this.grantAccess);
+//     // this.router.post(`/account/cancel`, this.cancelAccess);
+
+//     // this.router.post(`/token`, this.oauthToken);
+//     // this.router.post(`/revoke`, this.revokeToken);
+
+//     this.router.use(identityTokenMiddleware.exists);
+//     this.router.post(`/user/refresh`, this.refresh);
+
+//     this.router.use(identityTokenMiddleware.validate);
+//     this.router.post(`/user/confirm`, userMiddleware.pending, this.confirm);
+
+//     this.router.get(`/user`, this.user);
+//   };
+// }
+
+
+// const authRouter = (new AuthRouter()).router;
+// export default authRouter;

package/src/v1/routes/auth/identity-token-router.ts

@@ -0,0 +1,147 @@
+import { Request, Response, Router } from 'express';
+import APIError, { StatusCodes } from '../../../helpers/api-error';
+import identityTokenController from '../../controllers/auth/identity-token-controller';
+import identityTokenMiddleware from '../../middlewares/auth/identity-token-middleware';
+import { admin } from '../../middlewares/static/static-middleware';
+
+export class IdentityTokenRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly validateRecaptcha = async (req: Request, res: Response) => {
+    try {
+      const response = await identityTokenController.validateRecaptcha(req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      console.log(e);
+
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly socialGoogle = async (req: Request, res: Response) => {
+    try {
+      const response = await identityTokenController.socialGoogle(req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly requestOTP = async (req: Request, res: Response) => {
+    try {
+      await identityTokenController.requestOTP(req.body);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly validateOTP = async (req: Request, res: Response) => {
+    try {
+      const response = await identityTokenController.validateOTP(req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly admin = async (req: Request, res: Response) => {
+    try {
+      const response = await identityTokenController.admin(req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly token = async (req: Request, res: Response) => {
+    try {
+      const response = await identityTokenController.token(req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly refresh = async (req: Request, res: Response) => {
+    try {
+      const response = await identityTokenController.refresh(req[`id_access_token`], req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly delete = async (req: Request, res: Response) => {
+    try {
+      await identityTokenController.delete(req[`user`], req[`id_access_token`]);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+
+    // admin: bypass identity token
+    this.router.post(`/admin`, admin, this.admin);
+
+    this.router.post(`/recaptcha`, this.validateRecaptcha);
+
+    this.router.patch(`/otp`, this.requestOTP);
+    this.router.post(`/otp`, this.validateOTP);
+
+    this.router.post(`/social/google`, this.socialGoogle);
+
+    this.router.post(`/token`, this.token);
+
+    this.router.use(identityTokenMiddleware.exists);
+    this.router.post(`/token/refresh`, this.refresh);
+
+    this.router.use(identityTokenMiddleware.validate);
+    this.router.delete(`/token`, this.delete);
+
+
+  };
+}
+
+
+const identityTokenRouter = (new IdentityTokenRouter()).router;
+export default identityTokenRouter;

package/src/v1/routes/auth/organization-token-router.ts

@@ -0,0 +1,70 @@
+import { Request, Response, Router } from 'express';
+import APIError, { StatusCodes } from '../../../helpers/api-error';
+import organizationTokenController from '../../controllers/auth/organization-token-controller';
+import identityTokenMiddleware from '../../middlewares/auth/identity-token-middleware';
+import organizationTokenMiddleware from '../../middlewares/auth/organization-token-middleware';
+import userMiddleware from '../../middlewares/users/user-middleware';
+
+export class OrganizationTokenRouter {
+  router: Router;
+
+  constructor() {
+    this.router = Router();
+    this.init();
+  }
+
+  private readonly token = async (req: Request, res: Response) => {
+    try {
+      const response = await organizationTokenController.token(req[`user`], req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly refresh = async (req: Request, res: Response) => {
+    try {
+      const response = await organizationTokenController.refresh(req[`org_access_token`], req.body);
+      res.setHeader(`Cache-Control`, `no-store`).json(response);
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly delete = async (req: Request, res: Response) => {
+    try {
+      await organizationTokenController.delete(req[`environment`], req[`org_access_token`]);
+      res.status(StatusCodes.NO_CONTENT).json();
+    } catch (e: any) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: e.message || e });
+      }
+    }
+  };
+
+  private readonly init = () => {
+    this.router.post(`/token`, identityTokenMiddleware.exists, identityTokenMiddleware.validate, userMiddleware.active, this.token);
+
+    this.router.use(organizationTokenMiddleware.exists);
+    this.router.post(`/token/refresh`, this.refresh);
+
+    this.router.use(organizationTokenMiddleware.validate);
+    this.router.delete(`/token`, this.delete);
+
+
+  };
+}
+
+
+const organizationTokenRouter = (new OrganizationTokenRouter()).router;
+export default organizationTokenRouter;