@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/src/server/schemas/Logs.schema.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { commonValidations } from './utils';
+
+const LogGetSchema = z.object({
+    _id: commonValidations.id,
+    level: z.string().min(1).openapi({
+        description: 'Log level',
+        example: 'info'
+    }),
+    message: z.string().min(1).openapi({
+        description: 'Log message',
+        example: 'User logged in'
+    }),
+    timestamp: commonValidations.date.openapi({
+        description: 'Timestamp of the log entry',
+        example: '2024-05-26T10:49:19.896Z'
+    }),
+    meta: z.object({}).optional().openapi({
+        description: 'Additional metadata for the log entry',
+        example: { userId: '66519e582c2c701cc438ce59' }
+    }),
+    id: commonValidations.id,
+});
+
+const LogCreateSchema = z.object({
+    level: z.string().min(1).openapi({
+        description: 'Log level',
+        example: 'info'
+    }).optional(),
+    message: z.string().min(1).openapi({
+        description: 'Log message',
+        example: 'User logged in'
+    }).optional(),
+    meta: z.object({}).optional().openapi({
+        description: 'Additional metadata for the log entry',
+        example: { userId: '66519e582c2c701cc438ce59' }
+    }),
+});
+
+const LogCreateRespSchema = commonValidations.success;
+
+const LogDistinctSchema = z.object({
+    field: z.string().min(1).openapi({
+        description: 'Field name for distinct query',
+        example: 'level'
+    }),
+});
+
+const LogDistinctResponseSchema = z.array(z.string()).openapi({
+    description: 'Array of distinct log levels',
+    example: ["debug", "error", "info", "warn"]
+});
+
+
+export {
+    LogGetSchema,
+    LogCreateSchema,
+    LogDistinctSchema,
+    LogDistinctResponseSchema,
+    LogCreateRespSchema
+};

package/src/server/schemas/Runs.schema.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { commonValidations } from './utils';
+
+const RunResponseSchema = z.object({
+    _id: commonValidations.id,
+    name: z.string().min(1).openapi({
+        description: 'Name of the run',
+        example: 'DEBUG (VIKTAR)'
+    }),
+    app: commonValidations.id.openapi({
+        description: 'App identifier',
+        example: '6651dd45b9c3e1e0b8c1ce26'
+    }),
+    ident: z.string().uuid().openapi({
+        description: 'Identifier for the run',
+        example: '7a930247-e422-4833-8ab6-b136c23d07e9'
+    }),
+    createdDate: z.string().datetime().openapi({
+        description: 'Creation date of the run',
+        example: '2024-05-25T13:15:26.592Z'
+    }),
+    parameters: z.array(z.unknown()).openapi({
+        description: 'Parameters of the run',
+        example: []
+    }),
+    updatedDate: z.string().datetime().openapi({
+        description: 'Last update date of the run',
+        example: '2024-05-25T13:15:30.969Z'
+    }),
+    id: commonValidations.id.openapi({
+        description: 'Run identifier',
+        example: '6651e46e85f83573a821d1f4'
+    }),
+});
+
+const RunGetSchema = z.object({
+    _id: commonValidations.id,
+    name: z.string().min(1).openapi({
+        description: 'Name of the run',
+        example: 'Sample Run'
+    }),
+    // additional fields here...
+});
+
+export { RunGetSchema, RunResponseSchema };

package/src/server/schemas/Settings.schema.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { commonValidations } from './utils';
+
+const SettingsGetSchema = z.object({
+    name: z.string().min(1).openapi({
+        description: 'Name of the setting',
+        example: 'example_setting'
+    }),
+    value: z.any().openapi({
+        description: 'Value of the setting',
+        example: 'example_value'
+    }),
+    description: z.string().optional().openapi({
+        description: 'Description of the setting',
+        example: 'This is an example setting.'
+    }),
+});
+
+const SettingsUpdateSchema = z.object({
+    value: z.any().openapi({
+        description: 'New value for the setting',
+        example: 'new_example_value'
+    }),
+    enabled: z.boolean().optional().openapi({
+        description: 'Enable or disable the setting',
+        example: true
+    }),
+});
+
+const SettingsResponseSchema = z.array(
+    z.object({
+        _id: commonValidations.id,
+        name: z.string().min(1).openapi({
+            description: 'Name of the setting',
+            example: 'first_run'
+        }),
+        label: z.string().min(1).openapi({
+            description: 'Label of the setting',
+            example: 'First Run'
+        }),
+        description: z.string().min(1).openapi({
+            description: 'Description of the setting',
+            example: 'Indicates if the application is running the first time'
+        }),
+        type: z.string().min(1).openapi({
+            description: 'Type of the setting',
+            example: 'Boolean'
+        }),
+        value: z.any().openapi({
+            description: 'Value of the setting',
+            example: false
+        }),
+        enabled: z.boolean().openapi({
+            description: 'Indicates if the setting is enabled',
+            example: true
+        }),
+        __v: z.number().openapi({
+            description: 'Version key',
+            example: 0
+        }),
+    })
+);
+
+const SettingsNameParamSchema = z.object({
+    name: z.string().min(1).openapi({
+        description: 'Name of the setting to update',
+        example: 'example_setting'
+    }),
+});
+
+export { SettingsGetSchema, SettingsUpdateSchema, SettingsNameParamSchema, SettingsResponseSchema };

package/src/server/schemas/SkipValid.schema.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const SkipValid = z.any();

package/src/server/schemas/SnapshotDiff.schema.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+export const SnapshotDiffSchema = z.object({
+    isSameDimensions: z.boolean(),
+    dimensionDifference: z.object({
+        width: z.number(),
+        height: z.number()
+    }),
+    rawMisMatchPercentage: z.number(),
+    misMatchPercentage: z.string(),
+    analysisTime: z.number(),
+    executionTotalTime: z.string(),
+    stabMethod: z.string().optional(),
+    vOffset: z.number().optional(),
+
+});
+
+export type SnapshotDiff = z.infer<typeof SnapshotDiffSchema> & { getBuffer: (() => Buffer) | null, totalCheckHandleTime?: string };

package/src/server/schemas/Snapshots.schema.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { commonValidations } from './utils';
+
+const SnapshotSchema = z.object({
+    _id: commonValidations.id,
+    name: z.string().min(1).openapi({
+        description: 'Name of the snapshot',
+        example: 'Login page'
+    }),
+    filename: z.string().min(1).openapi({
+        description: 'Filename of the snapshot',
+        example: '6651dd4f7c9186e315910b24.png'
+    }),
+    imghash: z.string().min(1).openapi({
+        description: 'Image hash of the snapshot',
+        example: '96e8359554f12142bc19e44288295aa67a59cd128e242b6756651bf8e3d9f34caa7f587367ca8e5cdcfbaaf180adfd8825250fc7485784c41de11a9c08c1f9ab'
+    }),
+    createdDate: z.string().datetime().openapi({
+        description: 'Creation date of the snapshot',
+        example: '2024-05-25T13:15:30.946Z'
+    }),
+    id: commonValidations.id.openapi({
+        description: 'Snapshot identifier',
+        example: '6651e47285f83573a821d20e'
+    }),
+    stabMethod: z.string().optional(),
+    vOffset: z.number().optional(),
+})
+const SnapshotsResponseSchema = z.array(
+    SnapshotSchema
+);
+
+// const SnapshotUpdateSchema = SnapshotSchema.omit({
+//     _id: true,
+//     id: true
+// }).partial();
+
+// export type SnapshotUpdateType = z.infer<typeof SnapshotUpdateSchema>;
+
+export type SnapshotType = z.infer<typeof SnapshotSchema>;
+
+export { SnapshotsResponseSchema };

package/src/server/schemas/Suite.schema.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { commonValidations } from './utils';
+
+const SuiteGetSchema = z.object({
+    _id: commonValidations.id,
+    name: z.string().min(1).openapi({
+        description: 'Name of the suite',
+        example: 'Smoke tests'
+    }),
+    tags: z.array(z.string()).openapi({
+        description: 'Tags associated with the suite',
+        example: []
+    }),
+    app: commonValidations.id.openapi({
+        description: 'Application identifier',
+        example: '666b3b82db17d34ecdbd06f6'
+    }),
+    createdDate: commonValidations.date.openapi({
+        description: 'Creation date of the suite',
+        example: '2024-06-13T18:33:38.617Z'
+    }),
+    updatedDate: commonValidations.date.openapi({
+        description: 'Last update date of the suite',
+        example: '2024-06-13T19:55:40.114Z'
+    }),
+    id: commonValidations.id.openapi({
+        description: 'ID of the suite',
+        example: '666b3b828833d0cf24a670d7'
+    })
+});
+
+// export type SuiteType = z.infer<typeof SuiteGetSchema>;
+
+export { SuiteGetSchema };

package/src/server/schemas/Test.schema.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import { commonValidations } from './utils';
+
+const TestGetSchema = z.object({
+    _id: commonValidations.id,
+    name: z.string().min(1).openapi({
+        description: 'Name of the test',
+        example: 'Get IP'
+    }),
+    status: z.string().openapi({
+        description: 'Status of the test',
+        example: 'Failed'
+    }),
+    browserName: z.string().openapi({
+        description: 'Name of the browser',
+        example: 'chrome'
+    }),
+    browserVersion: z.string().openapi({
+        description: 'Version of the browser',
+        example: '125'
+    }),
+    branch: z.string().openapi({
+        description: 'Branch name',
+        example: 'master'
+    }),
+    tags: z.array(z.string()).openapi({
+        description: 'Tags associated with the test',
+        example: ['@smoke', '@regression']
+    }),
+    viewport: z.string().openapi({
+        description: 'Viewport size',
+        example: '1366x768'
+    }),
+    os: z.string().openapi({
+        description: 'Operating system',
+        example: 'macOS'
+    }),
+    app: commonValidations.id.openapi({
+        description: 'Application identifier',
+        example: '6651dd45b9c3e1e0b8c1ce26'
+    }),
+    blinking: z.number().openapi({
+        description: 'Blinking count',
+        example: 0
+    }),
+    updatedDate: commonValidations.date.openapi({
+        description: 'Last update date of the test',
+        example: '2024-06-13T19:55:40.108Z'
+    }),
+    startDate: commonValidations.date.openapi({
+        description: 'Start date of the test',
+        example: '2024-06-13T19:54:28.409Z'
+    }),
+    checks: z.array(commonValidations.id).openapi({
+        description: 'List of checks associated with the test',
+        example: ['666b4e7e421977cbf466b458', '666b4ebc421977cbf466b47c']
+    }),
+    suite: commonValidations.id.openapi({
+        description: 'Suite identifier',
+        example: '666b3b828833d0cf24a670d7'
+    }),
+    run: commonValidations.id.openapi({
+        description: 'Run identifier',
+        example: '666b4e74421977cbf466b443'
+    }),
+    creatorId: commonValidations.id.openapi({
+        description: 'Creator identifier',
+        example: '66519e582c2c701cc438ce59'
+    }),
+    creatorUsername: z.string().openapi({
+        description: 'Username of the creator',
+        example: 'Guest'
+    }),
+    markedAs: z.string().openapi({
+        description: 'Marked as status',
+        example: 'Unaccepted'
+    }),
+    calculatedViewport: z.string().openapi({
+        description: 'Calculated viewport size',
+        example: '1366x768'
+    }),
+    id: commonValidations.id.openapi({
+        description: 'ID of the test',
+        example: '666b4e74421977cbf466b446'
+    })
+});
+
+// export type TestType = z.infer<typeof TestGetSchema>;
+
+const UpdateTestSchema = TestGetSchema.omit({ id: true, _id: true }).partial();
+
+export type UpdateTestType = z.infer<typeof UpdateTestSchema>;
+
+const TestAcceptSchema = z.object({
+    id: commonValidations.id,
+});
+
+const validIds = [
+    'suite',
+    'run',
+    'markedAs',
+    'creatorId',
+    'creatorUsername',
+    'name',
+    'status',
+    'browserName',
+    'browserVersion',
+    'branch',
+    'tags',
+    'viewport',
+    'os',
+    'app',
+    'startDate',
+
+] as const;
+
+export const TestDistinctRequestFieldParamsSchema = z.object({
+    field: z.enum(validIds).openapi({
+        description: 'Parameter identifier',
+        example: 'suite'
+    })
+});
+
+const TestDistinctSchema = TestGetSchema;
+
+export { TestGetSchema, TestAcceptSchema, TestDistinctSchema };

package/src/server/schemas/TestDistinct.schema.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+
+const validIds = [
+    'suite',
+    'run',
+    'markedAs',
+    'creatorId',
+    'creatorUsername',
+    'name',
+    'status',
+    'browserName',
+    'browserVersion',
+    'branch',
+    'tags',
+    'viewport',
+    'os',
+    'app',
+    'startDate',
+    'filter',
+] as const;
+
+const TestDistinctRequestParamsSchema = z.object({
+    id: z.enum(validIds).openapi({
+        description: 'Parameter identifier',
+        example: 'suite'
+    })
+});
+
+const TestDistinctResponseSchema = z.object({
+    name: z.string().min(1).openapi({
+        description: 'Distinct field value',
+        example: 'chrome'
+    })
+});
+
+export { TestDistinctRequestParamsSchema, TestDistinctResponseSchema };

package/src/server/schemas/User.schema.ts

@@ -0,0 +1,59 @@
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+import { commonValidations } from '@schemas/utils';
+
+extendZodWithOpenApi(z);
+
+export type User = z.infer<typeof UserSchema>;
+
+
+export const UserSchema = z.object({
+  username: z.string().min(1, 'UserSchema: the username name is empty').openapi({ example: "johndoe@example.com" }),
+  firstName: z.string().min(1, 'UserSchema: the firstName name is empty').openapi({ example: "John" }),
+  lastName: z.string().min(1, 'UserSchema: the lastName name is empty').openapi({ example: "Doe" }),
+  role: z.enum(['admin', 'reviewer', 'user']),
+  password: z.string().optional(),
+  token: z.string().optional(),
+  apiKey: z.string().optional(),
+  createdDate: z.date().optional().openapi({ example: "2024-05-25T15:23:21.150Z" }),
+  updatedDate: z.date().optional().openapi({ example: "2024-05-26T15:23:21.150Z" }),
+  expiration: z.date().optional(),
+  meta: z.record(z.any()).optional(),
+  _id: commonValidations.id.openapi({ example: "6bbF35cAB3C59dA969edAe79" }),
+  id: commonValidations.id.openapi({ example: "6bbF35cAB3C59dA969edAe79" }),
+})
+
+export const UserCreateReqSchema =
+  z.object({
+    username: z.string().min(1, 'UserSchema: the username name is empty').openapi({ example: "johndoe@example.com" }),
+    firstName: z.string().min(1, 'UserSchema: the firstName name is empty').openapi({ example: "John" }),
+    lastName: z.string().min(1, 'UserSchema: the lastName name is empty').openapi({ example: "Doe" }),
+    role: z.enum(['admin', 'reviewer', 'user']),
+    email: z.string().optional(),
+    password: z.string(),
+  })
+
+export type UserCreateReq = z.infer<typeof UserCreateReqSchema>
+
+export const UserCurrentRespSchema = z.object({
+  _id: commonValidations.id.openapi({ example: "6bbF35cAB3C59dA969edAe79" }),
+  id: commonValidations.id.openapi({ example: "6bbF35cAB3C59dA969edAe79" }),
+  username: z.string().min(1, 'UserSchema: the username name is empty').openapi({ example: "johndoe@example.com" }),
+  firstName: z.string().min(1, 'UserSchema: the firstName name is empty').openapi({ example: "John" }),
+  lastName: z.string().min(1, 'UserSchema: the lastName name is empty').openapi({ example: "Doe" }),
+  role: z.enum(['admin', 'reviewer', 'user']),
+})
+
+export const UserGetRespSchema = UserCurrentRespSchema;
+
+export const UserCreateRespSchema = z.object({
+  username: z.string().min(1, 'UserSchema: the username name is empty').openapi({ example: "johndoe@example.com" }),
+  firstName: z.string().min(1, 'UserSchema: the firstName name is empty').openapi({ example: "John" }),
+  lastName: z.string().min(1, 'UserSchema: the lastName name is empty').openapi({ example: "Doe" }),
+  role: z.enum(['admin', 'reviewer', 'user']),
+  createdDate: z.date().optional().openapi({ example: "2024-05-25T15:23:21.150Z" }),
+  updatedDate: z.date().optional().openapi({ example: "2024-05-26T15:23:21.150Z" }),
+  _id: commonValidations.id.openapi({ example: "6bbF35cAB3C59dA969edAe79" }),
+  id: commonValidations.id.openapi({ example: "6bbF35cAB3C59dA969edAe79" }),
+})
+

package/src/server/schemas/common/ApiError.schema.ts

@@ -0,0 +1,23 @@
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+
+extendZodWithOpenApi(z);
+
+export const ApiErrorSchema = z.object({
+    name: z.string().openapi({
+      description: 'Name of the error type',
+      example: 'Error'
+    }),
+    message: z.string().openapi({
+      description: 'Detailed message describing the error',
+      example: "cannot remove run with id: '6651e46e85f83573a821d1f4', not found"
+    }),
+    status: z.number().openapi({
+      description: 'HTTP status code that corresponds to the error',
+      example: 404
+    }),
+    stacktrace: z.string().openapi({
+      description: 'Stack trace of the error for debugging purposes',
+      example: "Error: cannot remove run with id: '6651e46e85f83573a821d1f4', not found\\n    at Object.remove2 (/Users/exadel/Projects/SYNGRISI/packages/syngrisi/src/server/services/run.service.ts:27:15)\\n    at processTicksAndRejections (node:internal/process/task_queues:95:5)\\n    at /Users/exadel/Projects/SYNGRISI/packages/syngrisi/src/server/controllers/runs.controller.ts:25:20"
+    })
+  });

package/src/server/schemas/common/Error.schema.ts

@@ -0,0 +1,19 @@
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+
+extendZodWithOpenApi(z);
+
+export const ApiErrorSchema = z.object({
+    name: z.string().openapi({
+      description: 'Name of the error type',
+      example: 'Error'
+    }),
+    message: z.string().openapi({
+      description: 'Detailed message describing the error',
+      example: "cannot remove run with id: '6651e46e85f83573a821d1f4', not found"
+    }),
+    stacktrace: z.string().openapi({
+      description: 'Stack trace of the error for debugging purposes',
+      example: "Error: cannot remove run with id: '6651e46e85f83573a821d1f4', not found\\n    at Object.remove2 (/Users/exadel/Projects/SYNGRISI/packages/syngrisi/src/server/services/run.service.ts:27:15)\\n    at processTicksAndRejections (node:internal/process/task_queues:95:5)\\n    at /Users/exadel/Projects/SYNGRISI/packages/syngrisi/src/server/controllers/runs.controller.ts:25:20"
+    })
+  });

package/src/server/schemas/common/RequestPagination.schema.ts

@@ -0,0 +1,16 @@
+
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+import { requestQueryFilterSchema } from './requestQueryFilterSchema.schema';
+import { commonValidations } from '../utils';
+extendZodWithOpenApi(z);
+
+export const RequestPaginationSchema =
+    z.object({
+        filter: requestQueryFilterSchema.optional(),
+        limit: commonValidations.positiveNumberString.optional().openapi({example: "10"}),
+        page: commonValidations.positiveNumberString.optional().openapi({example: "1"}),
+        sortBy: z.string().optional().openapi({example: "name:desc"}),
+        populate: z.string().optional().openapi({example: "test"}),
+    });
+

package/src/server/schemas/common/Version.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+
+const VersionSchema = z.string()
+  .regex(/^\d+\.\d+\.\d+$/, 'Version must be in the format "x.y.z"')
+  .transform((value) => {
+    const parts = value.split('.');
+    return {
+      major: parseInt(parts[0]),
+      minor: parseInt(parts[1]),
+      patch: parseInt(parts[2]),
+    };
+  });
+
+export default VersionSchema;

package/src/server/schemas/common/requestQueryFilterSchema.schema.ts

@@ -0,0 +1,32 @@
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import { z } from 'zod';
+
+extendZodWithOpenApi(z);
+
+export const requestQueryFilterSchema = z
+    .string()
+    .optional()
+    .refine((data) => {
+        if(!data) return false
+        try {
+            const parsed = JSON.parse(data);
+
+            // Define a recursive schema to support nested objects and arrays
+            const valueSchema = z.lazy(() => z.union([
+                z.string(),
+                z.number(),
+                z.boolean(),
+                z.array(z.any()),
+                z.record(z.any())
+            ]));
+
+            const schema = z.record(valueSchema);
+            schema.parse(parsed);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }, {
+        message: "Invalid JSON string or does not match the required schema",
+    })
+    .openapi({ example: '{"key1": "value1", "key2": 123, "key3": true, "$and":[{"name":"CheckName"}]}' });

package/src/server/schemas/index.ts

@@ -0,0 +1,4 @@
+export * from "./CreateCheck.shema";
+export * from "./GetBaseline.shema";
+export * from "./App.schema";
+export * from "./common/Version.schema";

package/src/server/schemas/utils/commonValidations.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+
+import VersionSchema from '@schemas/common/Version.schema';
+extendZodWithOpenApi(z);
+
+const mongooseIdRegex = /^[0-9a-fA-F]{24}$/;
+const id = z
+  .string()
+  .regex(mongooseIdRegex, {
+    message: 'Invalid Mongoose ObjectId format: /^[0-9a-fA-F]{24}$/',
+  })
+  .openapi({
+    description: 'baseline ID',
+    example: "6bbF35cAB3C59dA969edAe79"
+  });
+
+export const commonValidations = {
+  id,
+  version: VersionSchema.openapi({ example: "1.1.2" }),
+  positiveNumberString: z.string().refine(value => {
+    const num = Number(value);
+    return Number.isInteger(num) && num >= 0;
+  }, {
+    message: "String must be a positive number or 0"
+  }),
+  password: z.string()
+    .min(6)
+    .regex(/(?=.*[0-9])/, "Password must include a number")
+    .regex(/(?=.*[a-z])/, "Password must include a lowercase letter")
+    .regex(/(?=.*[A-Z])/, "Password must include an uppercase letter")
+    .refine(value => {
+      return /(?=.*[!@#$%^&*(),.?":{}|<>-])/.test(value);
+    }, {
+      message: "Password must include a special symbol"
+    })
+    .openapi({ example: "Aa1!IJASSNOJ" }),
+  username: z.string().min(1).openapi({ example: "john.doe@example.com" }),
+  // TODO: workaround TBD
+  date: z.string().refine(val => {
+    const date = new Date(val);
+    return !isNaN(date.getTime());
+  }, {
+    message: 'Invalid date format'
+  }),
+  paramsId: { params: z.object({ id }) },
+  paramsTestId: { params: z.object({ testid: id }) },
+  success: z.object({
+    message: z.literal("success")
+  }),
+};

package/src/server/schemas/utils/createRequestBodySchema.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const createRequestBodySchema = (schema: z.ZodTypeAny) => z.object({ body: schema })