@purpleschool/gptbot 0.0.1

package/commands/message/create-message.command.ts

@@ -0,0 +1,20 @@
+import { MessageSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace CreateMessageCommand {
+    export const RequestSchema = MessageSchema.pick({
+        text: true,
+    });
+
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: MessageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/message/index.ts

@@ -0,0 +1 @@
+export * from './create-message.command';

package/commands/page/create-page.command.ts

@@ -0,0 +1,18 @@
+import { PageSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace CreatePageCommand {
+    export const RequestSchema = PageSchema.omit({
+        uuid: true,
+        createdAt: true,
+        updatedAt: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/delete-page.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { PageSchema } from '../../models';
+
+export namespace DeletePageCommand {
+    export const RequestSchema = PageSchema.pick({
+        uuid: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        isDeleted: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/page/find-page.command.ts

@@ -0,0 +1,22 @@
+import { PageSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace FindPageCommand {
+    export const RequestSchema = PageSchema.pick({
+        uuid: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(PageSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+
+    export const ResponseByUUIDSchema = z.object({
+        data: PageSchema,
+    });
+
+    export type ResponseByUUID = z.infer<typeof ResponseByUUIDSchema>;
+}

package/commands/page/index.ts

@@ -0,0 +1,4 @@
+export * from './update-page.command';
+export * from './delete-page.command';
+export * from './create-page.command';
+export * from './find-page.command';

package/commands/page/update-page.command.ts

@@ -0,0 +1,24 @@
+import { PageSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace UpdatePageCommand {
+    export const RequestSchema = PageSchema.omit({
+        createdAt: true,
+        updatedAt: true,
+        uuid: true,
+    }).partial();
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: PageSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/question/create-question.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { QuestionSchema } from '../../models';
+
+export namespace CreateQuestionCommand {
+    export const RequestSchema = QuestionSchema.omit({
+        uuid: true,
+        createdAt: true,
+        updatedAt: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: QuestionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/question/delete-question.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { QuestionSchema } from '../../models';
+
+export namespace DeleteQuestionCommand {
+    export const RequestSchema = QuestionSchema.pick({
+        uuid: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        isDeleted: z.boolean(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/question/find-question.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { QuestionSchema } from '../../models';
+
+export namespace FindQuestionCommand {
+    export const RequestSchema = QuestionSchema.pick({
+        uuid: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(QuestionSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+
+    export const ResponseByUUIDSchema = z.object({
+        data: QuestionSchema,
+    });
+
+    export type ResponseByUUID = z.infer<typeof ResponseByUUIDSchema>;
+}

package/commands/question/index.ts

@@ -0,0 +1,4 @@
+export * from './update-question.command';
+export * from './delete-question.command';
+export * from './create-question.command';
+export * from './find-question.command';

package/commands/question/update-question.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { QuestionSchema } from '../../models';
+
+export namespace UpdateQuestionCommand {
+    export const RequestSchema = QuestionSchema.omit({
+        createdAt: true,
+        updatedAt: true,
+        uuid: true,
+    }).partial();
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: QuestionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/unregistered-user/create-unregistered-user.command.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export namespace UnregisteredUserCommand {
+    export const ResponseSchema = z.object({
+        data: z.object({
+            accessToken: z.string(),
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/unregistered-user/index.ts

@@ -0,0 +1 @@
+export * from './create-unregistered-user.command';

package/commands/user/find-user.command.ts

@@ -0,0 +1,16 @@
+import { UserSchema } from '../../models';
+import { z } from 'zod';
+
+export namespace FindUserCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: UserSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/user/index.ts

@@ -0,0 +1 @@
+export * from './find-user.command';

package/constants/errors/errors.ts

@@ -0,0 +1,183 @@
+export const ERRORS = {
+    INTERNAL_SERVER_ERROR: { code: 'A001', message: 'Ошибка севера', httpCode: 500 },
+    FORBIDDEN_API: { code: 'C001', message: 'Ошибка авторизации', httpCode: 403 },
+    CREATE_USER: {
+        code: 'U01',
+        message: 'Произошла ошибка при создании пользователя',
+        httpCode: 500,
+    },
+    LOGIN_ERROR: { code: 'U02', message: 'Неверный логин или пароль', httpCode: 401 },
+    RESTORE_PASSWORD: {
+        code: 'U03',
+        message: 'Возникла ошибка при восстановлении пароля',
+        httpCode: 401,
+    },
+    AUTH_INCORRECT_PASSWORD: {
+        code: 'U02',
+        message: 'Неверный пароль',
+        httpCode: 401,
+    },
+    REGISTER_ERROR: { code: 'U01', message: 'Произошла ошибка при регистрации', httpCode: 500 },
+    REGISTER_CONFLICT: { code: 'U04', message: 'Пользователь уже зарегистрирован', httpCode: 409 },
+    USER_NOT_FOUND: { code: 'A002', message: 'Пользователь не найден', httpCode: 404 },
+    USER_CONFLICT: { code: 'A003', message: 'Пользователь не найден', httpCode: 409 },
+
+    USER_NOT_CREATED: {
+        code: 'A004',
+        message: 'Произошла ошибка при создании пользователя',
+        httpCode: 500,
+    },
+    PASSWORD_NOT_RESET: {
+        code: 'A005',
+        message: 'Произошла ошибка при сбросе пароля',
+        httpCode: 500,
+    },
+    USER_NOT_UPDATED: {
+        code: 'A006',
+        message: 'Произошла ошибка при обновлении пользователя',
+        httpCode: 500,
+    },
+    USER_NOT_EMAIL: {
+        code: 'A007',
+        message: 'Произошла ошибка при поиске пользователя по Email',
+        httpCode: 500,
+    },
+    USER_NOT_ID: {
+        code: 'A008',
+        message: 'Произошла ошибка при поиске пользователя по uuid',
+        httpCode: 500,
+    },
+    PAGE_NOT_FOUND_BY_UUID: {
+        code: 'A009',
+        message: 'Страница с таким uuid не найдена',
+        httpCode: 404,
+    },
+    PAGE_DELETE_ERROR: { code: 'A010', message: 'Страница не была удалена', httpCode: 500 },
+    PAGE_CREATE_ERROR: { code: 'A011', message: 'Страница не была создана', httpCode: 500 },
+    PAGE_CREATE_ALIAS_CONFLICT: {
+        code: 'A012',
+        message: 'alias должен быть уникальный',
+        httpCode: 409,
+    },
+    PAGE_FIND_ERROR: { code: 'A013', message: 'Страница не найдена', httpCode: 404 },
+    PAGES_FIND_ERROR: { code: 'A014', message: 'Страницы не найдены', httpCode: 404 },
+    PAGE_UPDATE_ERROR: { code: 'A015', message: 'Страница не была обновлена', httpCode: 500 },
+    CATEGORY_NOT_FOUND_BY_UUID: {
+        code: 'A016',
+        message: 'Категория с таким uuid не найдена',
+        httpCode: 404,
+    },
+    CATEGORY_DELETE_ERROR: { code: 'A017', message: 'Категория не была удалена', httpCode: 500 },
+    CATEGORY_CREATE_ERROR: { code: 'A018', message: 'Категория не была создана', httpCode: 500 },
+    CATEGORY_FIND_ERROR: { code: 'A019', message: 'Категория не найдена', httpCode: 404 },
+    CATEGORIES_FIND_ERROR: {
+        code: 'A020',
+        message: 'Категории не найдены',
+        httpCode: 404,
+    },
+    CATEGORY_UPDATE_ERROR: { code: 'A021', message: 'Страница не была обновлена', httpCode: 500 },
+    QUESTION_NOT_FOUND_BY_UUID: {
+        code: 'A022',
+        message: 'Вопрос с таким uuid не найден',
+        httpCode: 404,
+    },
+    QUESTION_DELETE_ERROR: { code: 'A023', message: 'Вопрос не был удалён', httpCode: 500 },
+    QUESTION_CREATE_ERROR: { code: 'A024', message: 'Вопрос не был создан', httpCode: 500 },
+    QUESTION_FIND_ERROR: { code: 'A025', message: 'Категория не найдена', httpCode: 404 },
+    QUESTIONS_FIND_ERROR: {
+        code: 'A026',
+        message: 'Вопросы не найдены',
+        httpCode: 404,
+    },
+    QUESTION_UPDATE_ERROR: { code: 'A027', message: 'Вопрос не был обновлен', httpCode: 500 },
+    SESSION_CREATE_ERROR: {
+        code: 'A028',
+        message: 'Недоступно по юридическим причинам',
+        httpCode: 451,
+    },
+    AI_MODULE_DELETE_ERROR: {
+        code: 'A029',
+        message: 'Модель искусственного интеллекта не была удалена',
+        httpCode: 500,
+    },
+    AI_MODULE_CREATE_ERROR: {
+        code: 'A030',
+        message: 'Модель искусственного интеллекта не была создана',
+        httpCode: 500,
+    },
+    AI_MODULE_FIND_ERROR: {
+        code: 'A031',
+        message: 'Модель искусственного интеллекта не найдена',
+        httpCode: 404,
+    },
+    AI_MODULES_FIND_ERROR: {
+        code: 'A032',
+        message: 'Модели искусственного интеллекта не найдены',
+        httpCode: 404,
+    },
+    AI_MODULE_UPDATE_ERROR: {
+        code: 'A033',
+        message: 'Модель искусственного интеллекта не была обновлена',
+        httpCode: 500,
+    },
+    AI_MODULE_NOT_FOUND_BY_UUID: {
+        code: 'A034',
+        message: 'Модель искусственного интеллекта с таким uuid не найдена',
+        httpCode: 404,
+    },
+    CHAT_DELETE_ERROR: {
+        code: 'A035',
+        message: 'Чат не был удалён',
+        httpCode: 500,
+    },
+    CHAT_CREATE_ERROR: {
+        code: 'A036',
+        message: 'Чат не был создан',
+        httpCode: 500,
+    },
+    CHAT_FIND_ERROR: {
+        code: 'A037',
+        message: 'Чат не найден',
+        httpCode: 404,
+    },
+    CHATS_FIND_ERROR: {
+        code: 'A038',
+        message: 'Чаты не найдены',
+        httpCode: 404,
+    },
+    CHAT_UPDATE_ERROR: {
+        code: 'A039',
+        message: 'Чат не был обновлен',
+        httpCode: 500,
+    },
+    CHAT_NOT_FOUND_BY_UUID: {
+        code: 'A040',
+        message: 'Чат с таким uuid не найден',
+        httpCode: 404,
+    },
+    MESSAGE_CREATE_ERROR: {
+        code: 'A041',
+        message: 'Сообщение не было создано',
+        httpCode: 500,
+    },
+    FORBIDDEN_ROLE_ERROR: {
+        code: 'E000',
+        message: 'Forbidden',
+        httpCode: 403,
+    },
+    FORBIDDEN_CHAT_LIMIT_ERROR: {
+        code: 'E000',
+        message: 'Forbidden',
+        httpCode: 403,
+    },
+    FORBIDDEN_MESSAGES_LIMIT_ERROR: {
+        code: 'E000',
+        message: 'Forbidden',
+        httpCode: 403,
+    },
+    MESSAGE_UPDATE_ERROR: {
+        code: 'A042',
+        message: 'Сообщение не было создано',
+        httpCode: 500,
+    },
+};

package/constants/errors/index.ts

@@ -0,0 +1,2 @@
+export * from './errors';
+export * from './verbose';

package/constants/errors/verbose.ts

@@ -0,0 +1,7 @@
+export const VERBOSE = {
+    PASSWORD_SUCCESSFULLY_RESTORED: {
+        code: 'SM005',
+        message:
+            'Вам на почту выслано письмо с подтверждением сброса пароля. Проверьте свой почтовый ящик!',
+    },
+} as const;

package/constants/index.ts

@@ -0,0 +1,2 @@
+export * from './errors';
+export * from './roles';

package/constants/roles/index.ts

@@ -0,0 +1 @@
+export * from './role';

package/constants/roles/role.ts

@@ -0,0 +1,7 @@
+export const ROLE = {
+    USER: 'user',
+    ADMIN: 'admin',
+} as const;
+
+export type TRole = typeof ROLE;
+export type TRolesKey = (typeof ROLE)[keyof typeof ROLE];

package/index.ts

@@ -0,0 +1 @@
+export * from './constants';

package/models/ai-model.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const AiModelSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    description: z.nullable(z.string()),
+    model: z.string(),
+    tokenMultiplicator: z.number(),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/category.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const CategorySchema = z.object({
+    uuid: z.string().uuid(),
+    mainCategory: z.nullable(z.string().uuid()),
+    name: z.string().min(3).max(16384),
+    prompt: z.string().min(3).max(16384),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/chat.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const ChatSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.nullable(z.string().uuid()),
+    unregisteredUserId: z.nullable(z.string().uuid()),
+    categoryId: z.string().uuid(),
+    aIModelId: z.string().uuid(),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/index.ts

@@ -0,0 +1,8 @@
+export * from './user.schema';
+export * from './page.schema';
+export * from './category.schema';
+export * from './question.schema';
+export * from './unregistered-user.schema';
+export * from './chat.schema';
+export * from './message.schema';
+export * from './ai-model.schema';

package/models/message.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const MessageSchema = z.object({
+    uuid: z.string().uuid(),
+    text: z.string(),
+    chatId: z.nullable(z.string().uuid()),
+    role: z.string(),
+    tokenUsage: z.number(),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/page.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const PageSchema = z.object({
+    uuid: z.string().uuid(),
+    metaTitle: z.string().min(3).max(16384),
+    metaDescription: z.string().min(3).max(16384),
+    title: z.string().min(3).max(16384),
+    subTitle: z.string().min(3).max(16384),
+    seoTextMd: z.string().min(3).max(16384),
+    alias: z.string().min(3).max(16384),
+    categoryId: z.string().uuid(),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/question.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const QuestionSchema = z.object({
+    uuid: z.string().uuid(),
+    question: z.string().min(3).max(16384),
+    answer: z.string().min(3).max(16384),
+    pageId: z.string().uuid(),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/unregistered-user.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const UnregisteredUserSchema = z.object({
+    uuid: z.string().uuid(),
+    ip: z.string(),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/user.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const UserSchema = z.object({
+    uuid: z.string().uuid(),
+    email: z.string().email(),
+    ip: z.string(),
+    password: z.string(),
+    passwordHash: z.string(),
+    restoreTokenHash: z.string(),
+    tokenBonusBalance: z.string(),
+    role: z.string(),
+
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@purpleschool/gptbot",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "prepublish": "rm -rf build && tsc",
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "zod": "^3.22.4"
+  }
+}