@purpleschool/gptbot-tools 0.1.1 → 0.1.2

package/build/index.js

@@ -55,6 +55,7 @@ __exportStar(require("./ai-vendor"), exports);
 __exportStar(require("./marketplace-card"), exports);
 __exportStar(require("./analytics"), exports);
 __exportStar(require("./solving-edu-task"), exports);
+__exportStar(require("./spell-corrector"), exports);
 const common = __importStar(require("./common"));
 const paraphrase = __importStar(require("./paraphrase"));
 const tools = __importStar(require("./tools"));
@@ -73,6 +74,7 @@ const interiorDesign = __importStar(require("./interior-design"));
 const marketplaceCard = __importStar(require("./marketplace-card"));
 const analytics = __importStar(require("./analytics"));
 const solvingEduTask = __importStar(require("./solving-edu-task"));
+const spellCorrector = __importStar(require("./spell-corrector"));
 var ToolService;
 (function (ToolService) {
     ToolService.Common = common;
@@ -93,4 +95,5 @@ var ToolService;
     ToolService.MarketplaceCard = marketplaceCard;
     ToolService.Analytics = analytics;
     ToolService.SolvingEduTask = solvingEduTask;
+    ToolService.SpellCorrector = spellCorrector;
 })(ToolService || (exports.ToolService = ToolService = {}));

package/build/spell-corrector/commands/delete-all-spell-corrector-jobs.command.js

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteSpellCorrectorJobByUuidCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var DeleteSpellCorrectorJobByUuidCommand;
+(function (DeleteSpellCorrectorJobByUuidCommand) {
+    DeleteSpellCorrectorJobByUuidCommand.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(),
+    });
+    DeleteSpellCorrectorJobByUuidCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(DeleteSpellCorrectorJobByUuidCommand || (exports.DeleteSpellCorrectorJobByUuidCommand = DeleteSpellCorrectorJobByUuidCommand = {}));

package/build/spell-corrector/commands/get-spell-corrector-price.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSpellCorrectorPriceCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var GetSpellCorrectorPriceCommand;
+(function (GetSpellCorrectorPriceCommand) {
+    GetSpellCorrectorPriceCommand.RequestSchema = zod_1.z.object({
+        modelId: zod_1.z.string().uuid(),
+    });
+    GetSpellCorrectorPriceCommand.ResponseDataSchema = zod_1.z.object({
+        price: zod_1.z.number(),
+    });
+    GetSpellCorrectorPriceCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(GetSpellCorrectorPriceCommand.ResponseDataSchema);
+})(GetSpellCorrectorPriceCommand || (exports.GetSpellCorrectorPriceCommand = GetSpellCorrectorPriceCommand = {}));

package/build/spell-corrector/commands/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./spell-corrector.command"), exports);
+__exportStar(require("./get-spell-corrector-price.command"), exports);
+__exportStar(require("./retry-spell-corrector-job.command"), exports);
+__exportStar(require("./set-reaction-to-spell-corrector-job.command"), exports);
+__exportStar(require("./update-spell-corrector-job-title.command"), exports);
+__exportStar(require("./delete-all-spell-corrector-jobs.command"), exports);
+__exportStar(require("./delete-spell-corrector-job-by-uuid.command"), exports);

package/build/spell-corrector/commands/retry-spell-corrector-job.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetrySpellCorrectorJobCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var RetrySpellCorrectorJobCommand;
+(function (RetrySpellCorrectorJobCommand) {
+    RetrySpellCorrectorJobCommand.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(),
+        tokenReservationId: zod_1.z.string().uuid(),
+        precalculatedPrice: zod_1.z.number(),
+    });
+    RetrySpellCorrectorJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SpellCorrectorJobSchema);
+})(RetrySpellCorrectorJobCommand || (exports.RetrySpellCorrectorJobCommand = RetrySpellCorrectorJobCommand = {}));

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetReactionToSpellCorrectorJobCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+const common_1 = require("../../common");
+var SetReactionToSpellCorrectorJobCommand;
+(function (SetReactionToSpellCorrectorJobCommand) {
+    SetReactionToSpellCorrectorJobCommand.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().uuid(),
+        reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
+    });
+    SetReactionToSpellCorrectorJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SpellCorrectorJobSchema);
+})(SetReactionToSpellCorrectorJobCommand || (exports.SetReactionToSpellCorrectorJobCommand = SetReactionToSpellCorrectorJobCommand = {}));

package/build/spell-corrector/commands/spell-corrector.command.js

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

package/build/spell-corrector/commands/update-spell-corrector-job-title.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateSpellCorrectorJobTitleCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var UpdateSpellCorrectorJobTitleCommand;
+(function (UpdateSpellCorrectorJobTitleCommand) {
+    UpdateSpellCorrectorJobTitleCommand.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),
+    });
+    UpdateSpellCorrectorJobTitleCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SpellCorrectorJobSchema);
+})(UpdateSpellCorrectorJobTitleCommand || (exports.UpdateSpellCorrectorJobTitleCommand = UpdateSpellCorrectorJobTitleCommand = {}));

package/build/spell-corrector/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./routes"), exports);
+__exportStar(require("./commands"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./queries"), exports);

package/build/spell-corrector/models/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./spell-corrector-model.schema"), exports);
+__exportStar(require("./spell-corrector-job.schema"), exports);
+__exportStar(require("./spell-corrector-tool-config.schema"), exports);

package/build/spell-corrector/models/spell-corrector-job.schema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpellCorrectorJobSchema = void 0;
+const zod_1 = require("zod");
+const tools_1 = require("../../tools");
+const common_1 = require("../../common");
+exports.SpellCorrectorJobSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    userId: zod_1.z.string().nullable(),
+    unregisteredUserId: zod_1.z.string().nullable(),
+    userInput: zod_1.z.string(),
+    aiOutput: zod_1.z.string().nullable(),
+    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(),
+    dislikeReason: zod_1.z.string().nullable(),
+    modelId: zod_1.z.string(),
+    tokenReservationId: zod_1.z.string().nullable().optional(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    completedAt: zod_1.z.date().nullable(),
+});

package/build/spell-corrector/models/spell-corrector-model.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpellCorrectorModelSchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+exports.SpellCorrectorModelSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    title: zod_1.z.string(),
+    icon: zod_1.z.string(),
+    price: zod_1.z.number(),
+    aiModel: zod_1.z.string(),
+    reasoningEffort: zod_1.z.nativeEnum(common_1.REASONING_EFFORT).nullable().optional(),
+    order: zod_1.z.number(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/spell-corrector/models/spell-corrector-tool-config.schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpellCorrectorToolConfigSchema = void 0;
+const zod_1 = require("zod");
+const spell_corrector_model_schema_1 = require("./spell-corrector-model.schema");
+exports.SpellCorrectorToolConfigSchema = zod_1.z.object({
+    models: zod_1.z.array(spell_corrector_model_schema_1.SpellCorrectorModelSchema),
+    maxSymbols: zod_1.z.number(),
+});

package/build/spell-corrector/queries/find-spell-corrector-job-by-uuid.query.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindSpellCorrectorJobByUuidQuery = void 0;
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var FindSpellCorrectorJobByUuidQuery;
+(function (FindSpellCorrectorJobByUuidQuery) {
+    FindSpellCorrectorJobByUuidQuery.RequestSchema = models_1.SpellCorrectorJobSchema.pick({ uuid: true });
+    FindSpellCorrectorJobByUuidQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SpellCorrectorJobSchema);
+})(FindSpellCorrectorJobByUuidQuery || (exports.FindSpellCorrectorJobByUuidQuery = FindSpellCorrectorJobByUuidQuery = {}));

package/build/spell-corrector/queries/find-spell-corrector-jobs.query.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindSpellCorrectorJobsQuery = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var FindSpellCorrectorJobsQuery;
+(function (FindSpellCorrectorJobsQuery) {
+    FindSpellCorrectorJobsQuery.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'],
+    });
+    FindSpellCorrectorJobsQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.object({
+        data: zod_1.z.array(models_1.SpellCorrectorJobSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+    }));
+})(FindSpellCorrectorJobsQuery || (exports.FindSpellCorrectorJobsQuery = FindSpellCorrectorJobsQuery = {}));

package/build/spell-corrector/queries/get-spell-corrector-tool-config.query.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSpellCorrectorToolConfigQuery = void 0;
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var GetSpellCorrectorToolConfigQuery;
+(function (GetSpellCorrectorToolConfigQuery) {
+    GetSpellCorrectorToolConfigQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SpellCorrectorToolConfigSchema);
+})(GetSpellCorrectorToolConfigQuery || (exports.GetSpellCorrectorToolConfigQuery = GetSpellCorrectorToolConfigQuery = {}));

package/build/spell-corrector/queries/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./find-spell-corrector-job-by-uuid.query"), exports);
+__exportStar(require("./get-spell-corrector-tool-config.query"), exports);
+__exportStar(require("./find-spell-corrector-jobs.query"), exports);

package/build/spell-corrector/routes/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./spell-corrector.amqp.routes"), exports);

package/build/spell-corrector/routes/spell-corrector.amqp.routes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPELL_CORRECTOR_AMQP_ROUTES = void 0;
+exports.SPELL_CORRECTOR_AMQP_ROUTES = {
+    EXECUTE: 'tools.spell_corrector.execute.rpc',
+    GET_PRICE: 'tools.spell_corrector.get-price.rpc',
+    CONFIG: 'tools.spell_corrector.config.rpc',
+    GET_JOB: 'tools.spell_corrector.jobs.get.rpc',
+    LIST_JOBS: 'tools.spell_corrector.jobs.list.rpc',
+    SET_REACTION: 'tools.spell_corrector.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.spell_corrector.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.spell_corrector.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.spell_corrector.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.spell_corrector.jobs.retry.rpc',
+};

package/build/tools/enums/tool-type.enum.js

@@ -18,4 +18,5 @@ var TOOL_TYPE;
     TOOL_TYPE["IMAGE_GENERATION"] = "IMAGE_GENERATION";
     TOOL_TYPE["MARKETPLACE_CARD_GENERATION"] = "MARKETPLACE_CARD_GENERATION";
     TOOL_TYPE["INTERIOR_DESIGN"] = "INTERIOR_DESIGN";
+    TOOL_TYPE["SPELL_CORRECTOR"] = "SPELL_CORRECTOR";
 })(TOOL_TYPE || (exports.TOOL_TYPE = TOOL_TYPE = {}));

package/index.ts

@@ -16,6 +16,7 @@ export * from './ai-vendor';
 export * from './marketplace-card';
 export * from './analytics';
 export * from './solving-edu-task';
+export * from './spell-corrector';
 
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -35,6 +36,7 @@ import * as interiorDesign from './interior-design';
 import * as marketplaceCard from './marketplace-card';
 import * as analytics from './analytics';
 import * as solvingEduTask from './solving-edu-task';
+import * as spellCorrector from './spell-corrector';
 
 export namespace ToolService {
     export import Common = common;
@@ -55,4 +57,5 @@ export namespace ToolService {
     export import MarketplaceCard = marketplaceCard;
     export import Analytics = analytics;
     export import SolvingEduTask = solvingEduTask;
+    export import SpellCorrector = spellCorrector;
 }

package/package.json

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

package/spell-corrector/commands/delete-all-spell-corrector-jobs.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteAllSpellCorrectorJobsCommand {
+    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/spell-corrector/commands/delete-spell-corrector-job-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteSpellCorrectorJobByUuidCommand {
+    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/spell-corrector/commands/get-spell-corrector-price.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GetSpellCorrectorPriceCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseDataSchema = z.object({
+        price: z.number(),
+    });
+
+    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/commands/index.ts

@@ -0,0 +1,7 @@
+export * from './spell-corrector.command';
+export * from './get-spell-corrector-price.command';
+export * from './retry-spell-corrector-job.command';
+export * from './set-reaction-to-spell-corrector-job.command';
+export * from './update-spell-corrector-job-title.command';
+export * from './delete-all-spell-corrector-jobs.command';
+export * from './delete-spell-corrector-job-by-uuid.command';

package/spell-corrector/commands/retry-spell-corrector-job.command.ts

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

package/spell-corrector/commands/set-reaction-to-spell-corrector-job.command.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+import { USER_REACTION } from '../../common';
+
+export namespace SetReactionToSpellCorrectorJobCommand {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/commands/spell-corrector.command.ts

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

package/spell-corrector/commands/update-spell-corrector-job-title.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+
+export namespace UpdateSpellCorrectorJobTitleCommand {
+    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(SpellCorrectorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/index.ts

@@ -0,0 +1,4 @@
+export * from './routes';
+export * from './commands';
+export * from './models';
+export * from './queries';

package/spell-corrector/models/index.ts

@@ -0,0 +1,3 @@
+export * from './spell-corrector-model.schema';
+export * from './spell-corrector-job.schema';
+export * from './spell-corrector-tool-config.schema';

package/spell-corrector/models/spell-corrector-job.schema.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
+
+export const SpellCorrectorJobSchema = z.object({
+    uuid: z.string(),
+    userId: z.string().nullable(),
+    unregisteredUserId: z.string().nullable(),
+    userInput: z.string(),
+    aiOutput: z.string().nullable(),
+    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(),
+    dislikeReason: z.string().nullable(),
+    modelId: z.string(),
+    tokenReservationId: z.string().nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    completedAt: z.date().nullable(),
+});
+
+export type SpellCorrectorJob = z.infer<typeof SpellCorrectorJobSchema>;

package/spell-corrector/models/spell-corrector-model.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { REASONING_EFFORT } from '../../common';
+
+export const SpellCorrectorModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    icon: z.string(),
+    price: z.number(),
+    aiModel: z.string(),
+    reasoningEffort: z.nativeEnum(REASONING_EFFORT).nullable().optional(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type SpellCorrectorModel = z.infer<typeof SpellCorrectorModelSchema>;

package/spell-corrector/models/spell-corrector-tool-config.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { SpellCorrectorModelSchema } from './spell-corrector-model.schema';
+
+export const SpellCorrectorToolConfigSchema = z.object({
+    models: z.array(SpellCorrectorModelSchema),
+    maxSymbols: z.number(),
+});
+
+export type SpellCorrectorTool = z.infer<typeof SpellCorrectorToolConfigSchema>;

package/spell-corrector/queries/find-spell-corrector-job-by-uuid.query.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+
+export namespace FindSpellCorrectorJobByUuidQuery {
+    export const RequestSchema = SpellCorrectorJobSchema.pick({ uuid: true });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/queries/find-spell-corrector-jobs.query.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models';
+
+export namespace FindSpellCorrectorJobsQuery {
+    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(SpellCorrectorJobSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/queries/get-spell-corrector-tool-config.query.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorToolConfigSchema } from '../models';
+
+export namespace GetSpellCorrectorToolConfigQuery {
+    export const ResponseSchema = ICommandResponseSchema(SpellCorrectorToolConfigSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/spell-corrector/queries/index.ts

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

package/spell-corrector/routes/index.ts

@@ -0,0 +1 @@
+export * from './spell-corrector.amqp.routes';

package/spell-corrector/routes/spell-corrector.amqp.routes.ts

@@ -0,0 +1,12 @@
+export const SPELL_CORRECTOR_AMQP_ROUTES = {
+    EXECUTE: 'tools.spell_corrector.execute.rpc',
+    GET_PRICE: 'tools.spell_corrector.get-price.rpc',
+    CONFIG: 'tools.spell_corrector.config.rpc',
+    GET_JOB: 'tools.spell_corrector.jobs.get.rpc',
+    LIST_JOBS: 'tools.spell_corrector.jobs.list.rpc',
+    SET_REACTION: 'tools.spell_corrector.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.spell_corrector.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.spell_corrector.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.spell_corrector.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.spell_corrector.jobs.retry.rpc',
+} as const;

package/tools/enums/tool-type.enum.ts

@@ -14,4 +14,5 @@ export enum TOOL_TYPE {
     IMAGE_GENERATION = 'IMAGE_GENERATION',
     MARKETPLACE_CARD_GENERATION = 'MARKETPLACE_CARD_GENERATION',
     INTERIOR_DESIGN = 'INTERIOR_DESIGN',
+    SPELL_CORRECTOR = 'SPELL_CORRECTOR',
 }