@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/src/server/models/plugins/paginateDistinct.plugin.ts

@@ -0,0 +1,90 @@
+import { Schema, Document, FilterQuery } from 'mongoose';
+import { EJSON } from 'bson';
+import { PaginateOptions, QueryResult } from './utils';
+
+// type QueryResult = {
+//   results: Document[];
+//   page: number;
+//   limit: number;
+//   totalPages: number;
+//   totalResults: number;
+//   timestamp: number;
+// };
+
+// type PaginateOptions = {
+//   sortBy?: string;
+//   populate?: string;
+//   limit?: number;
+//   page?: number;
+//   field: string;
+// };
+
+const paginateDistinct = (schema: Schema): void => {
+  /**
+   * Query for documents with pagination
+   * @param {Object} [filter] - Mongo filter
+   * @param {Object} [options] - Query options
+   * @param {string} [options.sortBy] - Sorting criteria using the format: sortField:(desc|asc).
+   * Multiple sorting criteria should be separated by commas (,)
+   * @param {string} [options.populate] - Populate data fields. Hierarchy of fields should be separated by (.).
+   * Multiple populating criteria should be separated by commas (,)
+   * @param {number} [options.limit] - Maximum number of results per page (default = 10)
+   * @param {number} [options.page] - Current page (default = 1)
+   * @returns {Promise<QueryResult>}
+   */
+  schema.statics.paginateDistinct = async function (filter: FilterQuery<unknown>, options: PaginateOptions): Promise<QueryResult> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let sort: any;
+    if (options.sortBy) {
+      options.sortBy.split(',')
+        .forEach((sortOption: string) => {
+          const [key, order] = sortOption.split(':');
+          sort[key] = (order === 'desc') ? -1 : 1;
+        });
+    } else {
+      sort = { _id: -1 };
+    }
+
+    let limit = options.limit && parseInt(options.limit.toString(), 10) >= 0 ? parseInt(options.limit.toString(), 10) : 10;
+    limit = limit === 0 ? 9007199254740991 : limit;
+    const page = options.page && parseInt(options.page.toString(), 10) > 0 ? parseInt(options.page.toString(), 10) : 1;
+    const skip = (page - 1) * limit;
+
+    const groupAggregateObj = { $group: { _id: `$${options.field}` } };
+
+    const documentsCount = (await this.aggregate([groupAggregateObj])
+      .exec()).length;
+    const aggregateArr = [
+      { $match: EJSON.parse(filter.filter || '{}') },
+      groupAggregateObj,
+      { $sort: sort },
+      { $skip: skip },
+      { $limit: limit },
+    ];
+    const aggregatedDocs = (await this.aggregate(aggregateArr))
+      .filter((x) => x._id)
+      .map((x) => {
+        if (x[options.field!]) {
+          return x[options.field!][0];
+        }
+        return { name: x._id };
+      });
+
+    return Promise.all([documentsCount, aggregatedDocs])
+      .then((values: [number, Document[]]) => {
+        const [totalResults, results] = values;
+        const totalPages = Math.ceil(totalResults / limit);
+        const result: QueryResult = {
+          results,
+          page,
+          limit,
+          totalPages,
+          totalResults,
+          timestamp: new Date().getTime(),
+        };
+        return Promise.resolve(result);
+      });
+  };
+};
+
+export default paginateDistinct;

package/src/server/models/plugins/toJSON.plugin.ts

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable no-param-reassign */
+
+// import { Schema } from 'mongoose';
+
+const deleteAtPath = (obj: any, path: string[], index: number): void => {
+  if (index === path.length - 1) {
+    delete obj[path[index]];
+    return;
+  }
+  deleteAtPath(obj[path[index]], path, index + 1);
+};
+
+const toJSON = (schema: any): void => {
+  let transform: any;
+  if (schema.options.toJSON && schema.options.toJSON.transform) {
+    transform = schema.options.toJSON.transform;
+  }
+
+  schema.options.toJSON = Object.assign(schema.options.toJSON || {}, {
+    transform(doc: any, ret: any, options: any) {
+      Object.keys(schema.paths).forEach((path) => {
+        if (schema.paths[path].options && schema.paths[path].options.private) {
+          deleteAtPath(ret, path.split('.'), 0);
+        }
+      });
+
+      ret.id = ret._id.toString();
+      // delete ret._id;
+      // eslint-disable-next-line no-underscore-dangle
+      delete ret.__v;
+      delete ret.createdAt;
+      delete ret.updatedAt;
+      if (transform) {
+        return transform(doc, ret, options);
+      }
+    },
+  });
+};
+
+export default toJSON;

package/src/server/models/plugins/utils.ts

@@ -0,0 +1,34 @@
+import { FilterQuery, Model, Document } from 'mongoose';
+
+export type PaginateOptions = {
+  sortBy?: string;
+  populate?: string;
+  limit?: number;
+  page?: number;
+  field?: string;
+};
+
+interface PaginatedResponse<T> {
+  results: T[];
+  page: number;
+  limit: number;
+  totalPages: number;
+  totalResults: number;
+  timestamp: number;
+}
+
+export type QueryResult = {
+  results: Document[];
+  page: number;
+  limit: number;
+  totalPages: number;
+  totalResults: number;
+  timestamp: number;
+};
+
+export interface ExtededModelMembers<T> {
+  paginate(filter: FilterQuery<T>, options: PaginateOptions): Promise<PaginatedResponse<T>>;
+  paginateDistinct(filter: FilterQuery<T>, options: PaginateOptions): Promise<PaginatedResponse<T>>;
+}
+
+export type PluginExtededModel<T> = Model<T> & ExtededModelMembers<T>;

package/src/server/routes/ui/admin.ts

@@ -0,0 +1,29 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import express, { Request, Response } from 'express';
+import path from 'path';
+import httpStatus from 'http-status';
+
+import { catchAsync } from '@utils';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { authorization } from '@middlewares';
+import { Midleware } from '../../../types/Midleware';
+
+const router = express.Router();
+const rootDir = path.resolve(process.cwd());
+
+
+const adminController = catchAsync(async (req: Request, res: Response) => {
+    res.status(httpStatus.OK)
+        // .sendFile(path.normalize(path.join(`${__dirname}./../../../../mvc/views/react/admin/index.html`)));
+        .sendFile(path.normalize(path.join(rootDir, `/mvc/views/react/admin/index.html`)));
+
+});
+
+router.get(
+    '*',
+    ensureLoggedIn(),
+    authorization('admin') as Midleware,
+    adminController as Midleware
+);
+
+export default router;

package/src/server/routes/ui/auth.ts

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import express, { Request, Response } from 'express';
+import path from 'path';
+import httpStatus from 'http-status';
+
+import { catchAsync } from '@utils';
+import { Midleware } from '@types';
+
+const router = express.Router();
+const rootDir = path.resolve(process.cwd());
+
+
+const authController = catchAsync(async (req: Request, res: Response) => {
+    res.status(httpStatus.OK)
+    // .sendFile(path.normalize(path.join(`${__dirname}./../../../../mvc/views/react/auth/index.html`)));
+    .sendFile(path.normalize(path.join(rootDir, `/mvc/views/react/auth/index.html`)));
+
+});
+
+router.get('*', authController as Midleware);
+
+export default router;

package/src/server/routes/ui/index.ts

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import express, { Response } from 'express';
+import path from 'path';
+import httpStatus from 'http-status';
+
+import { catchAsync } from '@utils';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { ExtRequest } from '../../../types/ExtRequest';
+import { Midleware } from '../../../types/Midleware';
+
+const router = express.Router();
+const rootDir = path.resolve(process.cwd());
+
+const staticIndex = async (req: ExtRequest, res: Response) => {
+    res.status(httpStatus.OK)
+        .sendFile(path.normalize(path.join(rootDir, `/mvc/views/react/index2/index.html`)));
+}
+
+router.get(
+    '',
+    ensureLoggedIn(),
+    catchAsync(staticIndex) as Midleware
+);
+
+export default router;

package/src/server/routes/v1/app.route.ts

@@ -0,0 +1,48 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import { appController } from '@controllers';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { AppInfoRespSchema, AppRespSchema } from '@root/src/server/schemas/App.schema';
+import {
+    createApiResponse,
+    createPaginatedApiResponse,
+} from '@api-docs/openAPIResponseBuilders';
+import { SkipValid } from '@schemas/SkipValid.schema';
+import { RequestPaginationSchema } from '../../schemas/common/RequestPagination.schema';
+import { createRequestQuerySchema } from '../../schemas/utils/createRequestQuerySchema';
+
+export const registry = new OpenAPIRegistry();
+
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/app/info',
+    summary: "The current Syngrisi instance information.",
+    tags: ['App'],
+    responses: createApiResponse(AppInfoRespSchema, 'Success'),
+});
+
+router.get(
+    '/info',
+    validateRequest(SkipValid, 'get, /v1/app/info'),
+    appController.info as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/app',
+    summary: "List of applications (projects) with pagination, and optional filtering and sorting.",
+    tags: ['App'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(AppRespSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/app'),
+    appController.get as Midleware
+);
+
+export default router;

package/src/server/routes/v1/auth.route.ts

@@ -0,0 +1,88 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as authController from '@controllers/auth.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { AuthLoginSchema, AuthChangePasswordSchema, AuthApiKeyRespSchema, AuthLoginSuccessRespSchema, AuthChangePasswordFirstRunSchema } from '@schemas/Auth.schema';
+import { createApiResponse, createApiEmptyResponse } from '@api-docs/openAPIResponseBuilders';
+import { SkipValid } from '../../schemas/SkipValid.schema';
+import { createRequestBodySchema } from '../../schemas/utils/createRequestBodySchema';
+import { createRequestOpenApiBodySchema } from '../../schemas/utils/createRequestOpenApiBodySchema';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/auth/logout',
+    summary: 'Logout the current user.',
+    tags: ['Auth'],
+    responses: createApiEmptyResponse('Logout success'),
+});
+
+router.get(
+    '/logout',
+    validateRequest(SkipValid, 'get, /v1/auth/logout'),
+    authController.logout as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/auth/apikey',
+    summary: 'Generate a new API key for the current user.',
+    tags: ['Auth'],
+    responses: createApiResponse(AuthApiKeyRespSchema, 'API Key generated'),
+});
+
+router.get(
+    '/apikey',
+    validateRequest(SkipValid, 'get, /v1/auth/apikey'),
+    authController.apikey as Midleware
+);
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/auth/login',
+    summary: 'Login a user with username and password.',
+    tags: ['Auth'],
+    request: { body: createRequestOpenApiBodySchema(AuthLoginSchema) },
+    responses: createApiResponse(AuthLoginSuccessRespSchema, 'Login success'),
+});
+
+router.post(
+    '/login',
+    validateRequest(createRequestBodySchema(AuthLoginSchema), 'post, /v1/auth/login'),
+    authController.login as Midleware
+);
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/auth/change',
+    summary: 'Change the password for the current user.',
+    tags: ['Auth'],
+    request: { body: createRequestOpenApiBodySchema(AuthChangePasswordSchema) },
+    responses: createApiEmptyResponse('Password changed'),
+});
+
+router.post(
+    '/change',
+    validateRequest(createRequestBodySchema(AuthChangePasswordSchema), 'post, /v1/auth/change'),
+    authController.changePassword as Midleware
+);
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/auth/change_first_run',
+    summary: 'Change the password for the first run.',
+    tags: ['Auth'],
+    request: { body: createRequestOpenApiBodySchema(AuthChangePasswordFirstRunSchema) },
+    responses: createApiEmptyResponse('First run password changed'),
+});
+
+router.post(
+    '/change_first_run',
+    validateRequest(createRequestBodySchema(AuthChangePasswordFirstRunSchema),  'post, /v1/auth/change_first_run'),
+    authController.changePasswordFirstRun as Midleware
+);
+
+export default router;

package/src/server/routes/v1/baselines.route.ts

@@ -0,0 +1,52 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as baselineController from '@controllers/baseline.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { BaselineGetSchema, BaselinePutSchema } from '@schemas/Baseline.schema';
+import { createApiEmptyResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+import { createRequestOpenApiBodySchema } from '@schemas/utils/createRequestOpenApiBodySchema';
+import { createRequestBodySchema } from '@schemas/utils/createRequestBodySchema';
+import { commonValidations } from '@schemas/utils';
+import { getByIdParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/baselines',
+    summary: "List of baselines with pagination, and optional filtering and sorting.",
+    tags: ['Baselines'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(BaselineGetSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/baselines'),
+
+    baselineController.get as Midleware
+);
+
+registry.registerPath({
+    method: 'put',
+    path: '/v1/baselines/{id}',
+    summary: "Only for testing purposes for now",
+    tags: ['Baselines'],
+    request: { params: commonValidations.paramsId.params, body: createRequestOpenApiBodySchema(BaselinePutSchema) },
+    responses: createApiEmptyResponse('Success'),
+});
+
+router.put(
+    '/:id',
+    ensureLoggedIn(),
+    validateRequest(getByIdParamsSchema().merge(createRequestBodySchema(BaselinePutSchema)), 'put, /v1/baselines/{id}'),
+    baselineController.put as Midleware
+);
+
+export default router;

package/src/server/routes/v1/checks.route.ts

@@ -0,0 +1,85 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as checkController from '@controllers/check.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { CheckGetSchema, CheckUpdateSchema, CheckAcceptSchema } from '@schemas/Check.schema';
+import { createApiResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureLoggedIn } from '@middlewares/ensureLogin';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+import { createRequestOpenApiBodySchema } from '@schemas/utils/createRequestOpenApiBodySchema';
+import { createRequestBodySchema } from '@schemas/utils/createRequestBodySchema';
+import { commonValidations } from '@schemas/utils';
+import { getByIdParamsSchema } from '@schemas/utils/createRequestParamsSchema';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/checks',
+    summary: "List of checks with pagination, and optional filtering and sorting.",
+    tags: ['Checks'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(CheckGetSchema, 'Success'),
+});
+
+router.get(
+    '/',
+    ensureLoggedIn(),
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/checks'),
+    checkController.get as Midleware
+);
+
+registry.registerPath({
+    method: 'delete',
+    path: '/v1/checks/{id}',
+    summary: "Delete a check by ID",
+    tags: ['Checks'],
+    request: commonValidations.paramsId,
+    responses: createApiResponse(CheckGetSchema, 'Success'),
+});
+
+router.delete(
+    '/:id',
+    ensureLoggedIn(),
+    validateRequest(getByIdParamsSchema(), 'delete, /v1/checks/{id}'),
+    checkController.remove as Midleware
+);
+
+registry.registerPath({
+    method: 'put',
+    path: '/v1/checks/{id}',
+    summary: "Update a check by ID",
+    tags: ['Checks'],
+    request: { params: commonValidations.paramsId.params, body: createRequestOpenApiBodySchema(CheckUpdateSchema) },
+    responses: createApiResponse(CheckGetSchema, 'Success'),
+});
+
+router.put(
+    '/:id',
+    ensureLoggedIn(),
+    validateRequest(getByIdParamsSchema().merge(createRequestBodySchema(CheckUpdateSchema)), 'put, /v1/checks/{id}'),
+    checkController.update as Midleware
+);
+
+registry.registerPath({
+    method: 'put',
+    path: '/v1/checks/{id}/accept',
+    summary: "Accept a check by ID",
+    tags: ['Checks'],
+    request: { params: commonValidations.paramsId.params, body: createRequestOpenApiBodySchema(CheckAcceptSchema) },
+    responses: createApiResponse(CheckGetSchema, 'Success'),
+});
+
+router.put(
+    '/:id/accept',
+    ensureLoggedIn(),
+    validateRequest(createRequestBodySchema(CheckAcceptSchema), 'put, /v1/checks/{id}/accept'),
+    checkController.accept as Midleware
+);
+
+
+
+export default router;

package/src/server/routes/v1/client.route.ts

@@ -0,0 +1,123 @@
+import express from 'express';
+import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
+import * as clientController from '@controllers/client.controller';
+import { Midleware } from '@types';
+import { validateRequest } from '@utils/validateRequest';
+import { ClientStartSessionSchema, ClientCreateCheckSchema, ClientGetIdentSchema, ClientGetBaselinesSchema, ClientGetSnapshotsSchema, ClientStartSessionResponseSchema, ClientCreateCheckResponseSchema } from '@schemas/Client.schema';
+import { createApiResponse, createPaginatedApiResponse } from '@api-docs/openAPIResponseBuilders';
+import { ensureApiKey } from '@middlewares/ensureLogin';
+import { createRequestQuerySchema } from '@schemas/utils/createRequestQuerySchema';
+import { RequestPaginationSchema } from '@schemas/common/RequestPagination.schema';
+import { createRequestOpenApiBodySchema } from '@schemas/utils/createRequestOpenApiBodySchema';
+import { createRequestBodySchema } from '@schemas/utils/createRequestBodySchema';
+import { commonValidations } from '@schemas/utils';
+import { SkipValid } from '@schemas/SkipValid.schema';
+import { getByIdParamsSchema } from '../../schemas/utils/createRequestParamsSchema';
+import { IdentJSONStringSchema } from '../../schemas';
+
+export const registry = new OpenAPIRegistry();
+const router = express.Router();
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/client/startSession',
+    summary: "Start a client session",
+    tags: ['Client'],
+    request: { body: createRequestOpenApiBodySchema(ClientStartSessionSchema) },
+    responses: createApiResponse(ClientStartSessionResponseSchema, 'Success'),
+});
+
+router.post(
+    '/startSession',
+    ensureApiKey(),
+    validateRequest(createRequestBodySchema(ClientStartSessionSchema), '/v1/client/startSession'),
+    clientController.startSession as Midleware
+);
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/client/stopSession/{testid}',
+    summary: "Stop a client session by test ID",
+    tags: ['Client'],
+    request: commonValidations.paramsTestId,
+    responses: createApiResponse(ClientStartSessionResponseSchema, 'Success'),
+});
+
+router.post(
+    '/stopSession/:testid',
+    ensureApiKey(),
+    // validateRequest(SkipValid, '/v1/client/stopSession/{testid}'),
+    validateRequest(getByIdParamsSchema('testid'), '/v1/client/stopSession/{testid}'),
+    clientController.endSession as Midleware
+);
+
+registry.registerPath({
+    method: 'post',
+    path: '/v1/client/createCheck',
+    summary: "Create a client check",
+    tags: ['Client'],
+    request: { body: createRequestOpenApiBodySchema(ClientCreateCheckSchema) },
+    responses: createApiResponse(ClientCreateCheckResponseSchema, 'Success'),
+});
+
+router.post(
+    '/createCheck',
+    ensureApiKey(),
+    validateRequest(createRequestBodySchema(ClientCreateCheckSchema), '/v1/client/createCheck'),
+    clientController.createCheck as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/client/getIdent',
+    summary: "Set of fields that identify checks and baselines",
+    tags: ['Client'],
+    responses: createApiResponse(ClientGetIdentSchema, 'Success'),
+});
+
+router.get(
+    '/getIdent',
+    ensureApiKey(),
+    validateRequest(SkipValid, 'get, /v1/client/getIdent'),
+    clientController.getIdent as Midleware
+);
+
+const ExtRequestBaselineSchema = RequestPaginationSchema.extend(
+    {
+        filter: IdentJSONStringSchema,
+    }
+);
+registry.registerPath({
+    method: 'get',
+    path: '/v1/client/baselines',
+    summary: "Get client baselines",
+    tags: ['Client'],
+    // request: { query: RequestPaginationSchema },
+    request: { query: ExtRequestBaselineSchema },
+    responses: createPaginatedApiResponse(ClientGetBaselinesSchema, 'Success'),
+});
+
+router.get(
+    '/baselines',
+    ensureApiKey(),
+    validateRequest(createRequestQuerySchema(ExtRequestBaselineSchema), 'get, /v1/client/baselines'),
+    clientController.getBaselines as Midleware
+);
+
+registry.registerPath({
+    method: 'get',
+    path: '/v1/client/snapshots',
+    summary: "Get client snapshots",
+    tags: ['Client'],
+    request: { query: RequestPaginationSchema },
+    responses: createPaginatedApiResponse(ClientGetSnapshotsSchema, 'Success'),
+});
+
+router.get(
+    '/snapshots',
+    ensureApiKey(),
+    validateRequest(createRequestQuerySchema(RequestPaginationSchema), 'get, /v1/client/snapshots'),
+    clientController.getSnapshots as Midleware
+);
+
+export default router;