@purpleschool/gptbot-tools 0.0.83 → 0.0.85

package/build/common/errors/errors.js

@@ -102,6 +102,21 @@ exports.ERRORS = {
             message: 'Задание на перефразирование не найдено',
             httpCode: 404,
         },
+        DELETE_ERROR: {
+            code: 'PARAPHRASE_JOB.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении задания на перефразирование',
+            httpCode: 500,
+        },
+        NOT_AN_OWNER: {
+            code: 'PARAPHRASE_JOB.NOT_AN_OWNER',
+            message: 'Пользователь не является владельцем задания на перефразирование',
+            httpCode: 403,
+        },
+        NOT_IN_FAILED_STATE_TO_RETRY: {
+            code: 'PARAPHRASE_JOB.NOT_IN_FAILED_STATE_TO_RETRY',
+            message: 'Задание на перефразирование не в состоянии "failed". Невозможно повторить',
+            httpCode: 400,
+        },
     },
     S3: {
         GET_FILE_STREAM_ERROR: {

package/build/music/models/music-track.schema.js

@@ -8,6 +8,7 @@ exports.MusicTrackSchema = zod_1.z.object({
     audioId: zod_1.z.string(),
     audioUrl: zod_1.z.string(),
     coverUrl: zod_1.z.string(),
+    prompt: zod_1.z.string().nullable(),
     tags: zod_1.z.string(),
     duration: zod_1.z.number(),
     genJobId: zod_1.z.string().nullable().optional(),

package/build/paraphrase/commands/delete-all-paraphrase-jobs.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAllParaphraseJobsCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var DeleteAllParaphraseJobsCommand;
+(function (DeleteAllParaphraseJobsCommand) {
+    DeleteAllParaphraseJobsCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+    });
+    DeleteAllParaphraseJobsCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(DeleteAllParaphraseJobsCommand || (exports.DeleteAllParaphraseJobsCommand = DeleteAllParaphraseJobsCommand = {}));

package/build/paraphrase/commands/delete-paraphrase-job-by-uuid.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteParaphraseJobByUuidCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var DeleteParaphraseJobByUuidCommand;
+(function (DeleteParaphraseJobByUuidCommand) {
+    DeleteParaphraseJobByUuidCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        uuid: zod_1.z.string(),
+    });
+    DeleteParaphraseJobByUuidCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(DeleteParaphraseJobByUuidCommand || (exports.DeleteParaphraseJobByUuidCommand = DeleteParaphraseJobByUuidCommand = {}));

package/build/paraphrase/commands/index.js

@@ -15,3 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./paraphrase.command"), exports);
+__exportStar(require("./delete-paraphrase-job-by-uuid.command"), exports);
+__exportStar(require("./delete-all-paraphrase-jobs.command"), exports);
+__exportStar(require("./set-reaction-to-paraphrase-job.command"), exports);
+__exportStar(require("./update-paraphrase-job-title.command"), exports);
+__exportStar(require("./retry-paraphrase-job.command"), exports);

package/build/paraphrase/commands/retry-paraphrase-job.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryParaphraseJobCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const paraphrase_job_schema_1 = require("../models/paraphrase-job.schema");
+var RetryParaphraseJobCommand;
+(function (RetryParaphraseJobCommand) {
+    RetryParaphraseJobCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        userBalance: zod_1.z.number(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+    });
+    RetryParaphraseJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(paraphrase_job_schema_1.ParaphraseJobSchema);
+})(RetryParaphraseJobCommand || (exports.RetryParaphraseJobCommand = RetryParaphraseJobCommand = {}));

package/build/paraphrase/commands/set-reaction-to-paraphrase-job.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetReactionToParaphraseJobCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const paraphrase_job_schema_1 = require("../models/paraphrase-job.schema");
+const common_1 = require("../../common");
+var SetReactionToParaphraseJobCommand;
+(function (SetReactionToParaphraseJobCommand) {
+    SetReactionToParaphraseJobCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        uuid: zod_1.z.string(),
+        reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    });
+    SetReactionToParaphraseJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(paraphrase_job_schema_1.ParaphraseJobSchema);
+})(SetReactionToParaphraseJobCommand || (exports.SetReactionToParaphraseJobCommand = SetReactionToParaphraseJobCommand = {}));

package/build/paraphrase/commands/update-paraphrase-job-title.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateParaphraseJobTitleCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const paraphrase_job_schema_1 = require("../models/paraphrase-job.schema");
+var UpdateParaphraseJobTitleCommand;
+(function (UpdateParaphraseJobTitleCommand) {
+    UpdateParaphraseJobTitleCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        title: zod_1.z.string().min(1).max(40),
+    });
+    UpdateParaphraseJobTitleCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(paraphrase_job_schema_1.ParaphraseJobSchema);
+})(UpdateParaphraseJobTitleCommand || (exports.UpdateParaphraseJobTitleCommand = UpdateParaphraseJobTitleCommand = {}));

package/build/paraphrase/models/paraphrase-job.schema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParaphraseJobSchema = void 0;
 const zod_1 = require("zod");
 const tools_1 = require("../../tools");
+const common_1 = require("../../common");
 exports.ParaphraseJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     userId: zod_1.z.string().nullable(),
@@ -12,6 +13,9 @@ exports.ParaphraseJobSchema = zod_1.z.object({
     aiTokenUsage: zod_1.z.number().nullable(),
     price: zod_1.z.number(),
     status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    title: zod_1.z.string(),
+    error: zod_1.z.string().nullable(),
+    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
     typeId: zod_1.z.string(),
     styleId: zod_1.z.string(),
     createdAt: zod_1.z.date(),

package/build/paraphrase/queries/find-paraphrase-jobs.query.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindParaphraseJobsQuery = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const paraphrase_job_schema_1 = require("../models/paraphrase-job.schema");
+var FindParaphraseJobsQuery;
+(function (FindParaphraseJobsQuery) {
+    FindParaphraseJobsQuery.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        title: zod_1.z.string().optional(),
+        limit: zod_1.z.coerce.number().min(1).optional(),
+        offset: zod_1.z.coerce.number().min(0).default(0).optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'At least userId or unregisteredUserId must be present',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    FindParaphraseJobsQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.object({
+        data: zod_1.z.array(paraphrase_job_schema_1.ParaphraseJobSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+    }));
+})(FindParaphraseJobsQuery || (exports.FindParaphraseJobsQuery = FindParaphraseJobsQuery = {}));

package/build/paraphrase/queries/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./find-paraphrase-job-by-uuid.query"), exports);
 __exportStar(require("./get-paraphrase-tool-config.query"), exports);
+__exportStar(require("./find-paraphrase-jobs.query"), exports);

package/build/paraphrase/routes/paraphrase.amqp.routes.js

@@ -5,4 +5,10 @@ exports.PARAPHRASE_AMQP_ROUTES = {
     EXECUTE: 'tools.paraphrase.execute.rpc',
     CONFIG: 'tools.paraphrase.config.rpc',
     GET_JOB: 'tools.paraphrase.jobs.get.rpc',
+    LIST_JOBS: 'tools.paraphrase.jobs.list.rpc',
+    SET_REACTION: 'tools.paraphrase.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.paraphrase.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.paraphrase.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.paraphrase.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.paraphrase.jobs.retry.rpc',
 };

package/common/errors/errors.ts

@@ -101,6 +101,21 @@ export const ERRORS = {
             message: 'Задание на перефразирование не найдено',
             httpCode: 404,
         },
+        DELETE_ERROR: {
+            code: 'PARAPHRASE_JOB.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении задания на перефразирование',
+            httpCode: 500,
+        },
+        NOT_AN_OWNER: {
+            code: 'PARAPHRASE_JOB.NOT_AN_OWNER',
+            message: 'Пользователь не является владельцем задания на перефразирование',
+            httpCode: 403,
+        },
+        NOT_IN_FAILED_STATE_TO_RETRY: {
+            code: 'PARAPHRASE_JOB.NOT_IN_FAILED_STATE_TO_RETRY',
+            message: 'Задание на перефразирование не в состоянии "failed". Невозможно повторить',
+            httpCode: 400,
+        },
     },
     S3: {
         GET_FILE_STREAM_ERROR: {

package/music/models/music-track.schema.ts

@@ -6,6 +6,7 @@ export const MusicTrackSchema = z.object({
     audioId: z.string(),
     audioUrl: z.string(),
     coverUrl: z.string(),
+    prompt: z.string().nullable(),
     tags: z.string(),
     duration: z.number(),
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.0.83",
+  "version": "0.0.85",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

package/paraphrase/commands/delete-all-paraphrase-jobs.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteAllParaphraseJobsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/paraphrase/commands/delete-paraphrase-job-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteParaphraseJobByUuidCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/paraphrase/commands/index.ts

@@ -1 +1,6 @@
 export * from './paraphrase.command';
+export * from './delete-paraphrase-job-by-uuid.command';
+export * from './delete-all-paraphrase-jobs.command';
+export * from './set-reaction-to-paraphrase-job.command';
+export * from './update-paraphrase-job-title.command';
+export * from './retry-paraphrase-job.command';

package/paraphrase/commands/retry-paraphrase-job.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
+
+export namespace RetryParaphraseJobCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userBalance: z.number(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ParaphraseJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/paraphrase/commands/set-reaction-to-paraphrase-job.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
+import { USER_REACTION } from '../../common';
+
+export namespace SetReactionToParaphraseJobCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string(),
+        reaction: z.nativeEnum(USER_REACTION).nullable(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ParaphraseJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/paraphrase/commands/update-paraphrase-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
+
+export namespace UpdateParaphraseJobTitleCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        title: z.string().min(1).max(40),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ParaphraseJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/paraphrase/models/paraphrase-job.schema.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
 
 export const ParaphraseJobSchema = z.object({
     uuid: z.string(),
@@ -10,6 +11,9 @@ export const ParaphraseJobSchema = z.object({
     aiTokenUsage: z.number().nullable(),
     price: z.number(),
     status: z.nativeEnum(JOB_STATUS),
+    title: z.string(),
+    error: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
     typeId: z.string(),
     styleId: z.string(),
     createdAt: z.date(),

package/paraphrase/queries/find-paraphrase-jobs.query.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
+
+export namespace FindParaphraseJobsQuery {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+            title: z.string().optional(),
+            limit: z.coerce.number().min(1).optional(),
+            offset: z.coerce.number().min(0).default(0).optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(ParaphraseJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/paraphrase/queries/index.ts

@@ -1,2 +1,3 @@
 export * from './find-paraphrase-job-by-uuid.query';
 export * from './get-paraphrase-tool-config.query';
+export * from './find-paraphrase-jobs.query';

package/paraphrase/routes/paraphrase.amqp.routes.ts

@@ -2,4 +2,10 @@ export const PARAPHRASE_AMQP_ROUTES = {
     EXECUTE: 'tools.paraphrase.execute.rpc',
     CONFIG: 'tools.paraphrase.config.rpc',
     GET_JOB: 'tools.paraphrase.jobs.get.rpc',
+    LIST_JOBS: 'tools.paraphrase.jobs.list.rpc',
+    SET_REACTION: 'tools.paraphrase.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.paraphrase.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.paraphrase.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.paraphrase.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.paraphrase.jobs.retry.rpc',
 } as const;