@purpleschool/gptbot-tools 0.2.31-stage → 0.2.32-stage

package/image-editor/queries/find-image-jobs.query.ts

@@ -1,12 +1,16 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { ImageEditorJobSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindImageJobsQuery {
     export const RequestSchema = z.object({
         userId: z.string().uuid().optional(),
         unregisteredUserId: z.string().uuid().optional(),
         title: z.string().optional(),
+        isFavorite: z.coerce.boolean().optional(),
+        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+        status: z.nativeEnum(JOB_STATUS).optional(),
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
     });

package/image-editor/routes/image-editor.amqp.routes.ts

@@ -6,6 +6,7 @@ export const IMAGE_EDITOR_AMQP_ROUTES = {
     LIST_JOBS: 'tools.image.jobs.list.rpc',
     SET_REACTION: 'tools.image.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.image.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.image.jobs.update-favorite.rpc',
     UPDATE_JOB: 'tools.image.jobs.update.rpc',
     SOFT_DELETE: 'tools.image.jobs.soft-delete.rpc',
     SOFT_DELETE_ALL: 'tools.image.jobs.soft-delete-all.rpc',

package/image-generation/commands/index.ts

@@ -6,6 +6,7 @@ export * from './soft-delete-image-generation-job-by-uuid.command';
 export * from './soft-delete-image-generation-jobs-by-criteria.command';
 export * from './set-reaction-to-image-generation-job.command';
 export * from './update-image-generation-job-title.command';
+export * from './update-image-generation-job-favorite.command';
 export * from './update-published-status-image-generation-jobs.command';
 export * from './image-generation-model';
 export * from './retry-image-generation-job.command';

package/image-generation/commands/update-image-generation-job-favorite.command.ts

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

package/image-generation/models/image-generation-job.schema.ts

@@ -35,6 +35,7 @@ export const ImageGenerationJobSchema = z.object({
     callOrigin: z.nativeEnum(STATISTICS_CALL_ORIGIN),
     postId: z.string().nullable(),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     internalError: z.string().nullable(),
     tokenReservationId: z.string().nullable().optional(),
     createdAt: z.date(),

package/image-generation/queries/find-image-generation-jobs.query.ts

@@ -3,6 +3,7 @@ import { JOB_SCOPE } from '../../common';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { ImageGenerationJobSchema } from '../models';
 import { STATISTICS_CALL_ORIGIN } from '@purpleschool/rugpt-lib-common';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindImageGenerationJobsQuery {
     export const RequestSchema = z
@@ -11,6 +12,9 @@ export namespace FindImageGenerationJobsQuery {
             unregisteredUserId: z.string().uuid().optional(),
             scope: z.nativeEnum(JOB_SCOPE).optional().default(JOB_SCOPE.TOOL),
             title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).default(0).optional(),
             callOrigin: z.nativeEnum(STATISTICS_CALL_ORIGIN).optional(),

package/image-generation/routes/image-generation.amqp.routes.ts

@@ -7,6 +7,7 @@ export const IMAGE_GENERATION_AMQP_ROUTES = {
     LIST_JOBS: 'tools.image-generation.jobs.list.rpc',
     SET_REACTION: 'tools.image-generation.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.image-generation.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.image-generation.jobs.update-favorite.rpc',
     UPDATE_JOB: 'tools.image-generation.jobs.update.rpc',
     SOFT_DELETE: 'tools.image-generation.jobs.soft-delete.rpc',
     SOFT_DELETE_ALL: 'tools.image-generation.jobs.soft-delete-all.rpc',

package/interior-design/commands/index.ts

@@ -4,5 +4,6 @@ export * from './retry-interior-design-job.command';
 export * from './set-reaction-to-interior-design-job.command';
 export * from './interior-design.command';
 export * from './update-interior-design-job-title.command';
+export * from './update-interior-design-job-favorite.command';
 export * from './interior-design-model';
 export * from './get-interior-design-price.command';

package/interior-design/commands/update-interior-design-job-favorite.command.ts

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

package/interior-design/models/interior-design-job.schema.ts

@@ -32,6 +32,7 @@ export const InteriorDesignJobSchema = z.object({
     tokenReservationId: z.string().nullable().optional(),
     jobSource: z.nativeEnum(INTERIOR_DESIGN_JOB_SOURCE),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     createdAt: z.date(),
     completedAt: z.date().nullable().optional(),
     updatedAt: z.date(),

package/interior-design/queries/find-interior-design-jobs.query.ts

@@ -1,12 +1,16 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { InteriorDesignJobSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindInteriorDesignJobsQuery {
     export const RequestSchema = z.object({
         userId: z.string().uuid().optional(),
         unregisteredUserId: z.string().uuid().optional(),
         title: z.string().optional(),
+        isFavorite: z.coerce.boolean().optional(),
+        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+        status: z.nativeEnum(JOB_STATUS).optional(),
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).default(0).optional(),
     });

package/interior-design/routes/interior-design.amqp.routes.ts

@@ -6,6 +6,7 @@ export const INTERIOR_DESIGN_AMQP_ROUTES = {
     LIST_JOBS: 'tools.interior-design.jobs.list.rpc',
     SET_REACTION: 'tools.interior-design.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.interior-design.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.interior-design.jobs.update-favorite.rpc',
     SOFT_DELETE: 'tools.interior-design.jobs.soft-delete.rpc',
     SOFT_DELETE_ALL: 'tools.interior-design.jobs.soft-delete-all.rpc',
     RETRY: 'tools.interior-design.jobs.retry.rpc',

package/marketplace-card/commands/index.ts

@@ -6,3 +6,4 @@ export * from './retry-marketplace-card-job.command';
 export * from './get-marketplace-card-price.command';
 export * from './soft-delete-all-marketplace-card-jobs.command';
 export * from './update-title-marketplace-card-job.command';
+export * from './update-marketplace-card-job-favorite.command';

package/marketplace-card/commands/update-marketplace-card-job-favorite.command.ts

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

package/marketplace-card/models/marketplace-card-job.schema.ts

@@ -46,6 +46,7 @@ export const MarketplaceCardJobSchema = z.object({
     userId: z.string().nullable().optional(),
     unregisteredUserId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     createdAt: z.date(),
     completedAt: z.date().nullable().optional(),
     updatedAt: z.date(),

package/marketplace-card/queries/find-marketplace-card-jobs.query.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { MarketplaceCardJobSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindMarketplaceCardJobsQuery {
     export const RequestSchema = z
@@ -8,6 +9,9 @@ export namespace FindMarketplaceCardJobsQuery {
             userId: z.string().uuid().optional(),
             unregisteredUserId: z.string().uuid().optional(),
             title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).default(0).optional(),
         })

package/marketplace-card/routes/marketplace-card.amqp.routes.ts

@@ -9,5 +9,6 @@ export const MARKETPLACE_CARD_AMQP_ROUTES = {
     SOFT_DELETE: 'tools.marketplace-card.soft-delete.rpc',
     RETRY: 'tools.marketplace-card.jobs.retry.rpc',
     UPDATE_TITLE: 'tools.marketplace-card.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.marketplace-card.jobs.update-favorite.rpc',
     SOFT_DELETE_ALL: 'tools.marketplace-card.jobs.soft-delete-all.rpc',
 } as const;

package/music/commands/index.ts

@@ -5,6 +5,7 @@ export * from './set-reaction-to-music-job.command';
 export * from './generate-music.command';
 export * from './get-music-price.command';
 export * from './update-music-job-title.command';
+export * from './update-music-job-favorite.command';
 export * from './convert-to-wav.command';
 export * from './generate-lyrics.command';
 export * from './music-model';

package/music/commands/update-music-job-favorite.command.ts

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

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

@@ -48,6 +48,7 @@ export const MusicJobSchema = z.object({
     userId: z.string().nullable().optional(),
     unregisteredUserId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     tokenReservationId: z.string().nullable().optional(),
     createdAt: z.date(),
     completedAt: z.date().nullable().optional(),

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { MusicJobSchema } from '../models/music-job.schema';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindMusicJobsQuery {
     export const RequestSchema = z
@@ -8,6 +9,9 @@ export namespace FindMusicJobsQuery {
             userId: z.string().uuid().optional(),
             unregisteredUserId: z.string().uuid().optional(),
             title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).default(0).optional(),
         })

package/music/routes/music.amqp.routes.ts

@@ -8,6 +8,7 @@ export const MUSIC_AMQP_ROUTES = {
     LIST_JOBS: 'tools.music.jobs.list.rpc',
     SET_REACTION: 'tools.music.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.music.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.music.jobs.update-favorite.rpc',
     UPDATE_JOB: 'tools.music.jobs.update.rpc',
     SOFT_DELETE: 'tools.music.jobs.soft-delete.rpc',
     SOFT_DELETE_ALL: 'tools.music.jobs.soft-delete-all.rpc',

package/package.json

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

package/paraphrase/commands/index.ts

@@ -3,5 +3,6 @@ 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 './update-paraphrase-job-favorite.command';
 export * from './retry-paraphrase-job.command';
 export * from './get-paraphrase-price.command';

package/paraphrase/commands/update-paraphrase-job-favorite.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 UpdateParaphraseJobFavoriteCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        isFavorite: z.boolean(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(ParaphraseJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindParaphraseJobsQuery {
     export const RequestSchema = z
@@ -8,6 +9,9 @@ export namespace FindParaphraseJobsQuery {
             userId: z.string().uuid().optional(),
             unregisteredUserId: z.string().uuid().optional(),
             title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).default(0).optional(),
         })

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

@@ -6,6 +6,7 @@ export const PARAPHRASE_AMQP_ROUTES = {
     LIST_JOBS: 'tools.paraphrase.jobs.list.rpc',
     SET_REACTION: 'tools.paraphrase.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.paraphrase.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.paraphrase.jobs.update-favorite.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/presentation/commands/index.ts

@@ -12,6 +12,7 @@ export * from './reposition-slide-outline.command';
 export * from './reposition-slide.command';
 export * from './update-slide-outline.command';
 export * from './update-presentation.command';
+export * from './update-presentation-favorite.command';
 export * from './update-presentation-outline.command';
 export * from './update-presentation-slides.command';
 export * from './update-slide-image-slot.command';

package/presentation/commands/update-presentation-favorite.command.ts

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

package/presentation/models/presentation.schema.ts

@@ -20,6 +20,7 @@ export const PresentationSchema = z.object({
     unregisteredUserId: z.string().uuid().nullable().optional(),
     slideCount: z.number(),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     tokenReservationId: z.string().nullable().optional(),
     lastContentUpdateAt: z.date().nullable(),
     lastPptxExportedAt: z.date().nullable(),

package/presentation/queries/find-presentations.query.ts

@@ -1,12 +1,16 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { PresentationSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindPresentationsQuery {
     export const RequestSchema = z.object({
         userId: z.string().uuid().optional(),
         unregisteredUserId: z.string().uuid().optional(),
         title: z.string().optional(),
+        isFavorite: z.coerce.boolean().optional(),
+        createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+        status: z.nativeEnum(JOB_STATUS).optional(),
         limit: z.coerce.number().min(1).optional(),
         offset: z.coerce.number().min(0).optional(),
     });

package/presentation/routes/presentation.routes.ts

@@ -12,6 +12,7 @@ export const PRESENTATION_AMQP_ROUTES = {
     FIND_OUTLINE: 'tools.presentation.find-outline.rpc',
     EXPORT_AS_PPTX: 'tools.presentation.export-as-pptx.rpc',
     UPDATE_PRESENTATION: 'tools.presentation.update-presentation.rpc',
+    UPDATE_PRESENTATION_FAVORITE: 'tools.presentation.update-presentation-favorite.rpc',
     DELETE_ALL_USER_PRESENTATIONS: 'tools.presentation.delete-all-user-presentations.rpc',
     BUILD_BLANK_SLIDE: 'tools.presentation.build-blank-slide.rpc',
     UPDATE_PRESENTATION_SLIDES: 'tools.presentation.update-presentation-slides.rpc',

package/solving-edu-task/commands/index.ts

@@ -5,3 +5,4 @@ export * from './retry-solving-edu-task-job.command';
 export * from './set-reaction-to-solving-edu-task-job.command';
 export * from './solving-edu-task.command';
 export * from './update-solving-edu-task-job-title.command';
+export * from './update-solving-edu-task-job-favorite.command';

package/solving-edu-task/commands/update-solving-edu-task-job-favorite.command.ts

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

package/solving-edu-task/models/solving-edu-task-job.schema.ts

@@ -27,6 +27,7 @@ export const SolvingEduTaskJobSchema = z.object({
     unregisteredUserId: z.string().nullable().optional(),
     tokenReservationId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     createdAt: z.date(),
     completedAt: z.date().nullable().optional(),
     updatedAt: z.date(),

package/solving-edu-task/queries/find-solving-edu-task-jobs.query.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { SolvingEduTaskJobSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindSolvingEduTaskJobsQuery {
     export const RequestSchema = z
@@ -8,6 +9,9 @@ export namespace FindSolvingEduTaskJobsQuery {
             userId: z.string().uuid().optional(),
             unregisteredUserId: z.string().uuid().optional(),
             title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).default(0).optional(),
         })

package/solving-edu-task/routes/solving-edu-task.amqp.routes.ts

@@ -6,6 +6,7 @@ export const SOLVING_EDU_TASK_AMQP_ROUTES = {
     LIST_JOBS: 'tools.solving-edu-task.jobs.list.rpc',
     SET_REACTION: 'tools.solving-edu-task.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.solving-edu-task.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.solving-edu-task.jobs.update-favorite.rpc',
     SOFT_DELETE: 'tools.solving-edu-task.jobs.soft-delete.rpc',
     SOFT_DELETE_ALL: 'tools.solving-edu-task.jobs.soft-delete-all.rpc',
     RETRY: 'tools.solving-edu-task.jobs.retry.rpc',

package/spell-corrector/commands/index.ts

@@ -3,5 +3,6 @@ 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 './update-spell-corrector-job-favorite.command';
 export * from './delete-all-spell-corrector-jobs.command';
 export * from './delete-spell-corrector-job-by-uuid.command';

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { SpellCorrectorJobSchema } from '../models/spell-corrector-job.schema';
+
+export namespace UpdateSpellCorrectorJobFavoriteCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        isFavorite: z.boolean(),
+    });
+    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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { SpellCorrectorJobSchema } from '../models';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindSpellCorrectorJobsQuery {
     export const RequestSchema = z
@@ -8,6 +9,9 @@ export namespace FindSpellCorrectorJobsQuery {
             userId: z.string().uuid().optional(),
             unregisteredUserId: z.string().uuid().optional(),
             title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).default(0).optional(),
         })

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

@@ -6,6 +6,7 @@ export const SPELL_CORRECTOR_AMQP_ROUTES = {
     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',
+    UPDATE_FAVORITE: 'tools.spell_corrector.jobs.update-favorite.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/stt/commands/index.ts

@@ -5,3 +5,4 @@ export * from './set-reaction-to-stt-job.command';
 export * from './stt.command';
 export * from './get-stt-price.command';
 export * from './update-stt-job-title.command';
+export * from './update-stt-job-favorite.command';

package/stt/commands/update-stt-job-favorite.command.ts

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

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

@@ -21,6 +21,7 @@ export const STTJobSchema = z.object({
     price: z.number(),
     tokenReservationId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     createdAt: z.date(),
     completedAt: z.date().nullable(),
     updatedAt: z.date(),

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { JOB_SCOPE } from '../../common';
 import { ICommandResponseSchema } from '../../common/models/command-response.schema';
 import { STTJobSchema } from '../models/stt-job.schema';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
 
 export namespace FindSTTJobsQuery {
     export const RequestSchema = z
@@ -10,6 +11,9 @@ export namespace FindSTTJobsQuery {
             unregisteredUserId: z.string().uuid().optional(),
             scope: z.nativeEnum(JOB_SCOPE).optional().default(JOB_SCOPE.TOOL),
             title: z.string().optional(),
+            isFavorite: z.coerce.boolean().optional(),
+            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
+            status: z.nativeEnum(JOB_STATUS).optional(),
             limit: z.coerce.number().min(1).optional(),
             offset: z.coerce.number().min(0).optional(),
         })

package/stt/routes/stt.amqp.routes.ts

@@ -8,5 +8,6 @@ export const STT_AMQP_ROUTES = {
     SOFT_DELETE: 'tools.stt.jobs.soft-delete.rpc',
     SOFT_DELETE_ALL: 'tools.stt.jobs.soft-delete-all.rpc',
     UPDATE_TITLE: 'tools.stt.jobs.update-title.rpc',
+    UPDATE_FAVORITE: 'tools.stt.jobs.update-favorite.rpc',
     RETRY: 'tools.stt.jobs.retry.rpc',
 } as const;

package/tools/enums/index.ts

@@ -2,3 +2,4 @@ export * from './job-status.enum';
 export * from './tool-type.enum';
 export * from './tool-content-type.enum';
 export * from './tool-group.enum';
+export * from './job-sort.enum'

package/tools/enums/job-sort.enum.ts

@@ -0,0 +1,4 @@
+export enum JOB_SORT {
+    DESC = 'desc',
+    ASC = "asc"
+}

package/tts/commands/index.ts

@@ -5,3 +5,4 @@ export * from './set-reaction-to-tts-job.command';
 export * from './tts.command';
 export * from './get-tts-price.command';
 export * from './update-tts-job-title.command';
+export * from './update-tts-job-favorite.command';

package/tts/commands/update-tts-job-favorite.command.ts

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

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

@@ -27,6 +27,7 @@ export const TTSJobSchema = z.object({
     unregisteredUserId: z.string().nullable(),
     tokenReservationId: z.string().nullable().optional(),
     isDeleted: z.boolean(),
+    isFavorite: z.boolean(),
     params: TTSJobParamsSchema,
     createdAt: z.date(),
     updatedAt: z.date(),