prow-authority 3.6.3

package/src/v1/daos/service-dao.ts

@@ -0,0 +1,118 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/service-types';
+import { Modifiers } from '../common-types';
+
+class ServiceDao {
+  public readonly get = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `service`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `service`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into service (uuid, token, properties, preferences, created_date, modified_date, enabled, metadata, internal) values (?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.token,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.preferences || {}),
+        new Date(),
+        new Date(),
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly update = async (
+    params: Pick<DBRecord, `id`>,
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update service set
+        uuid = ?,
+        token = ?,
+        properties = ?,
+        preferences = ?,
+        modified_date = ?,
+        enabled = ?,
+        metadata = ?,
+        internal = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.token,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.preferences || {}),
+        new Date(),
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `service`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const serviceDao = new ServiceDao();
+export default serviceDao;

package/src/v1/daos/service-notification-dao.ts

@@ -0,0 +1,120 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/service-notification-types';
+import { Modifiers } from '../common-types';
+
+class ServiceNotificationDao {
+  public readonly get = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `service_notifications`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `service_notifications`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+
+  public readonly add = async (
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into service_notifications (service, event, template, scope, created_date, modified_date, \`default\`, enabled, metadata) values (?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.service,
+        data.event,
+        data.template,
+        JSON.stringify(data.scope || {}),
+        new Date(),
+        new Date(),
+        data.default,
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+
+  public readonly update = async (
+    params: Pick<DBRecord, `id`>,
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update service_notifications set
+        service = ?,
+        event = ?,
+        template = ?,
+        scope = ?,
+        modified_date = ?,
+        \`default\` = ?,
+        enabled = ?,
+        metadata = ?
+      where id = ?`;
+      const p = [
+        data.service,
+        data.event,
+        data.template,
+        JSON.stringify(data.scope || {}),
+        new Date(),
+        data.default,
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `service_notifications`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const serviceNotificationDao = new ServiceNotificationDao();
+export default serviceNotificationDao;

package/src/v1/daos/user-dao.ts

@@ -0,0 +1,127 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/user-types';
+import { Modifiers } from '../common-types';
+
+class UserDao {
+  public readonly get = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `user`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `user`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into \`user\` (uuid, email, password, properties, preferences, utm, referrer, omnipotent, created_date, modified_date, status, metadata) values (?,?,?,?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.uuid,
+        data.email,
+        data.password,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.preferences || {}),
+        JSON.stringify(data.utm || {}),
+        data.referrer,
+        data.omnipotent,
+        new Date(),
+        new Date(),
+        data.status,
+        JSON.stringify(data.metadata || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly update = async (
+    params: Pick<DBRecord, `id`>,
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update \`user\` set
+        uuid = ?,
+        email = ?,
+        password = ?,
+        properties = ?,
+        preferences = ?,
+        utm = ?,
+        referrer = ?,
+        omnipotent = ?,
+        modified_date = ?,
+        status = ?,
+        metadata = ?
+      where id = ?`;
+      const p = [
+        data.uuid,
+        data.email,
+        data.password,
+        JSON.stringify(data.properties || {}),
+        JSON.stringify(data.preferences || {}),
+        JSON.stringify(data.utm || {}),
+        data.referrer,
+        data.omnipotent,
+        new Date(),
+        data.status,
+        JSON.stringify(data.metadata || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `user`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const userDao = new UserDao();
+export default userDao;

package/src/v1/daos/user-organization-dao.ts

@@ -0,0 +1,123 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/admin/user-organization-types';
+import { Modifiers } from '../common-types';
+
+class UserOrganizationDao {
+  public readonly get = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `user_organization`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `user_organization`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly count = async (params: Where<DBRecord>): Promise<{ count: number }[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        count: `id`,
+        from: `user_organization`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly add = async (
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into user_organization (\`user\`, organization, role, invite, invited_by, preferences, created_date, modified_date, enabled, metadata) values (?,?,?,?,?,?,?,?,?,?)`;
+      const p = [
+        data.user,
+        data.organization,
+        data.role,
+        data.invite,
+        data.invited_by,
+        JSON.stringify(data.preferences || {}),
+        new Date(),
+        new Date(),
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (
+    params: Pick<DBRecord, `id`>,
+    data: Omit<DBRecord, `id` | `created_date` | `modified_date`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update user_organization set
+        \`user\` = ?,
+        organization = ?,
+        role = ?,
+        invite = ?,
+        invited_by = ?,
+        preferences = ?,
+        modified_date = ?,
+        enabled = ?,
+        metadata = ?
+      where id = ?`;
+      const p = [
+        data.user,
+        data.organization,
+        data.role,
+        data.invite,
+        data.invited_by,
+        JSON.stringify(data.preferences || {}),
+        new Date(),
+        data.enabled,
+        JSON.stringify(data.metadata || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly delete = async (
+    params: Pick<DBRecord, `id`>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `user_organization`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const userOrganizationDao = new UserOrganizationDao();
+export default userOrganizationDao;

package/src/v1/daos/user-policy-dao.ts

@@ -0,0 +1,109 @@
+import { Where } from '@beseif-solutions/utility-functions/dist/utils/sql-utils';
+import mySql from '../../helpers/mysql';
+import { DBRecord } from '../types/users/user-policy-types';
+import { Modifiers } from '../common-types';
+
+class UserPolicyDao {
+  public readonly get = async (
+    params: Pick<DBRecord, 'id'>
+  ): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `user_policy`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly list = async (params?: Where<DBRecord>, modifiers: Modifiers = {}): Promise<DBRecord[]> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        select: `*`,
+        from: `user_policy`,
+        where: params,
+        ...modifiers.order && { order: { by: modifiers.order.by, direction: modifiers.order.direction } },
+        ...modifiers.limit && {
+          limit: {
+            count: parseInt(modifiers.limit.count, 10),
+            ...modifiers.limit.from && { from: parseInt(modifiers.limit.from, 10) },
+          },
+        },
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly add = async (
+    data: Omit<DBRecord, 'id' | 'informed_date'>
+  ): Promise<{ insertId: number }> => {
+    try {
+      const q = `insert into user_policy (user, policy, version, metadata, internal, informed_date) values (?,?,?,?,?,?)`;
+      const p = [
+        data.user,
+        data.policy,
+        data.version,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        new Date(),
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly update = async (
+    params: Pick<DBRecord, 'id'>,
+    data: Omit<DBRecord, 'id' | 'informed_date'>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const q = `update user_policy set
+        user = ?,
+        policy = ?,
+        version = ?,
+        metadata = ?,
+        internal = ?
+      where id = ?`;
+      const p = [
+        data.user,
+        data.policy,
+        data.version,
+        JSON.stringify(data.metadata || {}),
+        JSON.stringify(data.internal || {}),
+        params.id,
+      ];
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+
+  public readonly delete = async (
+    params: Pick<DBRecord, 'id'>
+  ): Promise<{ affectedRows: number }> => {
+    try {
+      const { query: q, params: p } = await mySql.queryConstructor<DBRecord>({
+        delete: null,
+        from: `user_policy`,
+        where: params,
+      });
+      const response = await mySql.promiseQuery(q, p);
+      return response;
+    } catch (e) {
+      throw e;
+    }
+  };
+}
+
+const userPolicyDao = new UserPolicyDao();
+export default userPolicyDao;

package/src/v1/middlewares/auth/identity-token-middleware.ts

@@ -0,0 +1,51 @@
+import { NextFunction, Request, Response } from 'express';
+import APIError, { StatusCodes } from '../../../helpers/api-error';
+import identityTokenController from '../../controllers/auth/identity-token-controller';
+
+
+class IdentityTokenMiddleware {
+  public readonly exists = async (req: any, res: Response, next: NextFunction) => {
+    try {
+      const access_token = (req.headers.authorization || ``).replace(`Bearer `, ``).trim();
+      if (!access_token) {
+        throw new APIError({
+          code: StatusCodes.UNAUTHORIZED,
+          detail: `No authorization provided.`,
+        });
+      }
+
+      req[`id_access_token`] = access_token;
+      next();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.UNAUTHORIZED).json({ error: e.message || e });
+      }
+    }
+  };
+
+  public readonly validate = async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      if (!req[`id_access_token`]) {
+        throw new APIError({
+          code: StatusCodes.INTERNAL_SERVER_ERROR,
+          detail: `Middleware dependency broken: required id_access_token missing.`,
+        });
+      }
+
+      const user = await identityTokenController.check(req[`id_access_token`]);
+      req[`user`] = user;
+      next();
+    } catch (e) {
+      if (e instanceof APIError) {
+        res.status(e.code).json(e.data);
+      } else {
+        res.status(StatusCodes.UNAUTHORIZED).json({ error: e.message || e });
+      }
+    }
+  };
+}
+
+const identityTokenMiddleware = new IdentityTokenMiddleware();
+export default identityTokenMiddleware;