prow-authority 3.6.3

package/src/v1/controllers/admin/user-organization-controller.ts

@@ -0,0 +1,172 @@
+import { JSON2 } from "@beseif-solutions/utility-functions/dist/utils/json-utils";
+import { Where } from "@beseif-solutions/utility-functions/dist/utils/sql-utils";
+import { DeepPartial } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+import { Schema, Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import userOrganizationDao from "../../daos/user-organization-dao";
+import { addUserOrganizationSchema, updateUserOrganizationSchema } from "../../schemas/admin/user-organization-schemas";
+import { DBRecord, UserOrganization, UserOrganizationRole } from "../../types/admin/user-organization-types";
+import organizationController from "./organization-controller";
+import { Date2, Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import userController from "./user-controller";
+import { UserStatus } from "../../types/admin/user-types";
+import { newUUIDv4 } from "@beseif-solutions/utility-functions/dist/utils/string-utils";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<UserOrganization, `id` | `created_date` | `modified_date`>;
+
+type Update = DeepPartial<Add>;
+
+class UserOrganizationCtrl {
+  public readonly get = async (id: number): Promise<UserOrganization[]> => {
+    try {
+      const db = await userOrganizationDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<UserOrganization>, options: Modifiers = {}): Promise<UserOrganization[]> => {
+    try {
+      const db = await userOrganizationDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly count = async (params: Where<UserOrganization>): Promise<{ count: number }> => {
+    try {
+      const response = (await userOrganizationDao.count({ ...params }))[0];
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly add = async (data: Add): Promise<UserOrganization[]> => {
+    try {
+      Validator.validate(addUserOrganizationSchema, data);
+      await this.check(data);
+
+      const { insertId } = await userOrganizationDao.add({
+        user: data.user,
+        organization: data.organization,
+        role: data.role,
+        invite: data.invite,
+        invited_by: data.invited_by,
+        preferences: data.preferences,
+        enabled: data.enabled,
+        metadata: data.metadata,
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<UserOrganization[]> => {
+    try {
+      Validator.validate(updateUserOrganizationSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) { throw new Error(`Organization with id ${id} doesn't exist`); }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as UserOrganization;
+
+      await this.check(merged, old);
+
+      const { affectedRows } = await userOrganizationDao.update({ id: id }, {
+        user: merged.user,
+        organization: merged.organization,
+        role: merged.role,
+        invite: merged.invite,
+        invited_by: merged.invited_by,
+        preferences: merged.preferences,
+        enabled: merged.enabled,
+        metadata: merged.metadata,
+      });
+
+      if (affectedRows <= 0) { throw new Error(`Could not update organization with id ${id}`); }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      Validator.validate(Schema.number(), id);
+      const { affectedRows } = await userOrganizationDao.delete({ id: id });
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | UserOrganization, old?: UserOrganization): Promise<void> => {
+    try {
+      if (!old || data.user !== old.user) {
+        const user = (await userController.list({ id: data.user, status: { is: UserStatus.Blocked, inverse: true } }, { password: false }))[0];
+        if (!user) { throw new Error(`No user ${data.user} found`); }
+        if (user.omnipotent) { throw new Error(`Invalid user ${data.user} provided`); }
+      }
+
+      if (data.invited_by && (!old || data.invited_by !== old.invited_by)) {
+        const invitedBy = (await userController.list({ id: data.invited_by, status: { is: UserStatus.Blocked, inverse: true } }, { password: false }))[0];
+        if (!invitedBy) { throw new Error(`No user ${data.invited_by} found`); }
+      }
+
+      if (!old || data.organization !== old.organization) {
+        const organization = (await organizationController.list({ id: data.organization }))[0];
+        if (!organization) { throw new Error(`No organization ${data.organization} found`); }
+      }
+
+      if (!old) {
+        const related = (await this.list({ organization: data.organization, user: data.user }))[0];
+        if (related) { throw new Error(`User ${data.user} is already on organization ${data.organization}`); }
+      }
+
+      if (data.role === UserOrganizationRole.Owner) {
+        const owner = (await this.list({ organization: data.organization, role: UserOrganizationRole.Owner }))[0];
+        if (owner && owner.user !== data.user) { throw new Error(`Only one owner is allowed per organization`); }
+      }
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly getFreeInvite = async (id: number): Promise<string> => {
+    try {
+      let uuid: string;
+      do {
+        uuid = newUUIDv4({ case: `lower` });
+        const exists = (await userOrganizationDao.list({ invite: uuid, organization: id }))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<UserOrganization[]> => {
+    try {
+      const response: UserOrganization[] = [];
+
+      for (const record of records) {
+        const p: UserOrganization = {
+          id: record.id,
+          user: record.user,
+          organization: record.organization,
+          role: record.role,
+          invite: record.invite,
+          invited_by: record.invited_by,
+          preferences: record.preferences,
+          created_date: new Date2(record.created_date).format(Formats.ISO),
+          modified_date: new Date2(record.modified_date).format(Formats.ISO),
+          enabled: record.enabled ? true : false,
+          metadata: record.metadata,
+        };
+
+        response.push(p);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const userOrganizationController = new UserOrganizationCtrl();
+export default userOrganizationController;

package/src/v1/controllers/admin/user-policy-controller.ts

@@ -0,0 +1,164 @@
+import { Date2, Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Where } from "@beseif-solutions/utility-functions/dist/utils/sql-utils";
+import { DeepPartial } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+import { Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import APIError, { StatusCodes } from '../../../helpers/api-error';
+import userPolicyDao from '../../daos/user-policy-dao';
+import { addUserPolicySchema, updateUserPolicySchema } from '../../schemas/admin/user-policy-schemas';
+import { DBRecord, UserPolicy } from '../../types/users/user-policy-types';
+import { Modifiers } from '../../common-types';
+import policyController from './policy-controller';
+import policyVersionController from './policy-version-controller';
+import userController from './user-controller';
+import { JSON2 } from "@beseif-solutions/utility-functions/dist/utils/json-utils";
+
+type Add = Omit<UserPolicy, 'id' | 'informed_date'>;
+type Update = DeepPartial<Omit<UserPolicy, 'id' | 'informed_date'>>;
+
+class UserPolicyController {
+  public readonly get = async (id: number): Promise<UserPolicy[]> => {
+    try {
+      const db = await userPolicyDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<UserPolicy>, options: Modifiers = {}): Promise<UserPolicy[]> => {
+    try {
+      const db = await userPolicyDao.list(params, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (data: Add): Promise<UserPolicy[]> => {
+    try {
+      await Validator.validateAsync(addUserPolicySchema, data);
+      await this.check(data);
+
+      const { insertId } = await userPolicyDao.add({
+        user: data.user,
+        policy: data.policy,
+        version: data.version,
+        metadata: data.metadata || {},
+        internal: data.internal || {},
+      });
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<UserPolicy[]> => {
+    try {
+      await Validator.validateAsync(updateUserPolicySchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `User policy with id ${id} not found.`,
+        });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as UserPolicy;
+      await this.check(merged, old);
+
+      const { affectedRows } = await userPolicyDao.update({ id: id }, {
+        user: merged.user,
+        policy: merged.policy,
+        version: merged.version,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      });
+
+      if (affectedRows <= 0) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Could not update user policy with id ${id}`,
+        });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const userPolicy = (await this.get(id))[0];
+      if (!userPolicy) {
+        throw new APIError({
+          code: StatusCodes.NOT_FOUND,
+          detail: `User policy with id ${id} not found.`,
+        });
+      }
+
+      const { affectedRows } = await userPolicyDao.delete({ id: id });
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly check = async (data: Add | UserPolicy, old?: UserPolicy): Promise<void> => {
+    try {
+      // verify user exists
+      if (!old || data.user !== old.user) {
+        const user = (await userController.get(data.user, { password: false }))[0];
+        if (!user) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `User with id ${data.user} not found.`,
+          });
+        }
+      }
+
+      // verify policy exists
+      if (!old || data.policy !== old.policy) {
+        const policy = (await policyController.get(data.policy))[0];
+        if (!policy) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `Policy with id ${data.policy} not found.`,
+          });
+        }
+      }
+
+      // verify version exists and belongs to policy
+      if (!old || data.version !== old.version || data.policy !== old.policy) {
+        const version = (await policyVersionController.get(data.version))[0];
+        if (!version) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `Policy version with id ${data.version} not found.`,
+          });
+        }
+
+        if (version.policy !== data.policy) {
+          throw new APIError({
+            code: StatusCodes.BAD_REQUEST,
+            detail: `Policy version ${data.version} does not belong to policy ${data.policy}.`,
+          });
+        }
+      }
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (data: DBRecord[]): Promise<UserPolicy[]> => {
+    try {
+      const response: UserPolicy[] = data.map((record) => ({
+        id: record.id,
+        user: record.user,
+        policy: record.policy,
+        version: record.version,
+        metadata: record.metadata,
+        internal: record.internal,
+        informed_date: new Date2(record.informed_date).format(Formats.ISO),
+      }));
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const userPolicyController = new UserPolicyController();
+export default userPolicyController;

package/src/v1/controllers/auth/@deprecated oauth-controller.ts

@@ -0,0 +1,191 @@
+// import { newUUIDv4 } from '@beseif-solutions/utility-functions/dist/utils/string-utils';
+// import { Validator } from '@beseif-solutions/utility-functions/dist/utils/validation-utils';
+// import APIError, { StatusCodes } from '../../../helpers/api-error';
+// import nconf from '../../../helpers/config';
+// import tokenDao from '../../daos/token-dao';
+// import { refreshSchema } from '../../schemas/auth-schemas';
+// import { AccessInformation, BearerAuthorization, RefreshInformation } from '../../types/auth-types';
+// import { User, UserStatus } from '../../types/user-types';
+// import userCtrl from '../user-controller';
+
+// class OAuthController {
+
+// public readonly checkToken = async (token: string): Promise<User> => {
+//   try {
+//     const payload = jwt.verify(token, nconf.get(`SECRET`));
+//     if (!payload) { throw new Error(`Invalid token`); }
+
+//     const user = await authDao.findUserLoginById(payload[`id`]);
+//     if (!user) { throw new Error(`Invalid or expired token`); }
+
+//     return await this.getUser(user);
+//   } catch (e) { throw e; }
+// };
+
+// // oauth credentials
+// public readonly login = async (username: string, password: string): Promise<{ success: boolean, user?: UserLogin }> => {
+//   try {
+//     const user = await authDao.findUserLoginByUsername(username);
+//     if (!user || !(await bcrypt.compare(password, user.password))) { return { success: false }; }
+//     return { success: true, user: user };
+//   } catch (e) { throw e; }
+// };
+
+// public readonly startOAuthSession = async (data: StartOAuth): Promise<Session> => {
+//   try {
+//     if (data.response_type !== `code`) { throw new Error(`This OAuth implementation only allows code response_type`); }
+//     if (data.access_type !== `offline`) { throw new Error(`This OAuth implementation only allows offline access_type`); }
+//     if (_.some(data.scope.split(` `), (scope) => !SCOPES.includes(scope))) { throw new Error(`Invalid requested scope: ${data.scope}`); }
+
+//     const client = await authDao.findOAuthClientById(data.client_id);
+//     if (!client) { throw new Error(`Invalid client_id`); }
+
+//     if (!client.redirects.includes(data.redirect_uri)) { throw new Error(`Invalid redirect`); }
+
+//     const session = await authDao.addOAuthSession({
+//       client_id: client.id,
+//       redirect_uri: data.redirect_uri,
+//       scope: data.scope,
+//     });
+
+//     return {
+//       token: session.token,
+//       client: client,
+//     };
+//   } catch (e) { throw e; }
+// };
+
+// public readonly recoverOAuthSession = async (token: string): Promise<Session> => {
+//   try {
+//     const session = await authDao.findOAuthSessionByToken(token);
+//     if (!session) { throw new Error(`Invalid session token`); }
+
+//     const client = await authDao.findOAuthClientById(session.client_id);
+//     if (!client) { throw new Error(`Invalid client_id`); }
+
+//     return {
+//       token: session.token,
+//       client: client,
+//     };
+//   } catch (e) { throw e; }
+// };
+
+// public readonly setUserOnOAuthSession = async (token: string, id: number): Promise<Session> => {
+//   try {
+//     const user = await authDao.findUserLoginById(id);
+
+//     const session = await authDao.updateOAuthSession(token, { user: user.id });
+
+//     const client = await authDao.findOAuthClientById(session.client_id);
+//     if (!client) { throw new Error(`Invalid client_id`); }
+
+//     return {
+//       token: session.token,
+//       client: client,
+//       user: await this.getUser(user),
+//     };
+//   } catch (e) { throw e; }
+// };
+
+// public readonly grantOAuthSession = async (token: string): Promise<{ redirect: string }> => {
+//   try {
+//     const session = await authDao.findOAuthSessionByToken(token);
+//     if (!session) { throw new Error(`Invalid session token`); }
+//     if (!session.user) { throw new Error(`Invalid session`); }
+
+//     const { code } = await authDao.addOAuthCode({ session: session.token });
+
+//     const MAX_CONNECT_TIME = 30000;
+//     setTimeout(async (t: string, c: string) => {
+//       await authDao.deleteOAuthSessionByToken(t);
+//       await authDao.deleteOAuthCodeByCode(c);
+//     }, MAX_CONNECT_TIME, token, code);
+
+
+//     const url = new URL(session.redirect_uri);
+//     url.searchParams.set(`code`, code);
+
+//     return { redirect: url.toString() };
+//   } catch (e) { throw e; }
+// };
+
+// public readonly cancelOauthSession = async (token: string): Promise<{ redirect: string }> => {
+//   try {
+//     const session = await authDao.findOAuthSessionByToken(token);
+//     if (!session) { throw new Error(`Invalid session token`); }
+
+//     await authDao.deleteOAuthSessionByToken(token);
+
+//     const url = new URL(session.redirect_uri);
+//     url.searchParams.set(`error`, `access_denied`);
+//     url.searchParams.set(`error_description`, `User cancelled the OAuth process`);
+
+//     return { redirect: url.toString() };
+//   } catch (e) { throw e; }
+// };
+
+// // exchange code / refresh token
+// public readonly oauthToken = async (data: Exchange): Promise<OAuth> => {
+//   try {
+//     const client = await authDao.findOAuthClientById(data.client_id);
+//     if (!client) { throw new Error(`Invalid code: not client_id`); }
+
+//     if (client.secret !== data.client_secret) { throw new Error(`Invalid code: client_secret`); }
+
+//     let id: string;
+//     let refresh: string;
+//     let user: User;
+//     if (data.grant_type === `authorization_code`) {
+//       const code = await authDao.findOAuthCodeByCode(data.code);
+//       if (!code) { throw new Error(`Invalid code: not found`); }
+
+//       const session = await authDao.findOAuthSessionByToken(code.session);
+//       if (!session) { throw new Error(`Expired code`); }
+
+//       if (data.redirect_uri !== session.redirect_uri) { throw new Error(`Invalid code: redirect_uri`); }
+//       if (data.client_id !== session.client_id) { throw new Error(`Invalid code: client_id`); }
+//       if (data.scope !== session.scope) { throw new Error(`Invalid code: scope`); }
+
+//       user = await authDao.findUserLoginById(session.user);
+//       if (!user) { throw new Error(`Invalid code: no user`); }
+
+//       id = jwt.sign(`${user.id}`, nconf.get(`SECRET`));
+//       await authDao.addOAuthLogin({ id: id });
+
+//       refresh = jwt.sign(id, nconf.get(`SECRET`));
+
+//       await authDao.deleteOAuthSessionByToken(session.token);
+//       await authDao.deleteOAuthCodeByCode(data.code);
+//     } else if (data.grant_type === `refresh_token`) {
+//       id = jwt.verify(data.refresh_token, nconf.get(`SECRET`)) as string;
+
+//       const login = await authDao.findOAuthLoginById(id);
+//       if (!login) { throw new Error(`Invalid refresh_token`); }
+
+//       const userId = parseInt(jwt.verify(login.id, nconf.get(`SECRET`)) as string, 10);
+//       user = await authDao.findUserLoginById(userId);
+//       if (!user) { throw new Error(`Invalid refresh_code: no user`); }
+//     } else { throw new Error(`This OAuth implementation doesn't allow specified grant_type`); }
+
+//     const EXPIRATION = 3600;
+//     const token = jwt.sign({ id: user.id }, nconf.get(`SECRET`), { expiresIn: EXPIRATION });
+//     return {
+//       id_token: id,
+//       token_type: `Bearer`,
+//       access_token: token,
+//       expires_in: EXPIRATION,
+//       refresh_token: refresh,
+//     };
+//   } catch (e) { throw e; }
+// };
+
+// // revoke token
+// public readonly revokeToken = async (id: string): Promise<void> => {
+//   try {
+//     await authDao.deleteOAuthLoginById(id);
+//   } catch (e) { throw e; }
+// };
+
+// }
+// const oauthController = new OAuthController();
+// export default oauthController;