@purpleschool/gptbot-tools 0.2.52 → 0.2.54

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

@@ -1,229 +0,0 @@
-import { z } from 'zod';
-import { JOB_STATUS } from '../../tools';
-import { USER_REACTION } from '../../common';
-import {
-    MUSIC_AUDIO_ACTION_TYPE,
-    MUSIC_GENERATION_ACTION_TYPE,
-    MUSIC_LYRICS_STRUCTURE,
-    MUSIC_VOCAL_GENDER,
-} from '../enums';
-import { MusicTrackSchema } from './music-track.schema';
-import { SUNO_MODE_TYPE } from '../enums/suno-mode-type.enum';
-
-export const MusicJobParamsSchema = z.discriminatedUnion('mode', [
-    z.object({
-        mode: z.literal(SUNO_MODE_TYPE.SIMPLE),
-        prompt: z.string().min(1).max(450),
-        style: z.string(),
-        vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER),
-    }),
-    z.object({
-        mode: z.literal(SUNO_MODE_TYPE.SIMPLE_INSTRUMENTAL),
-        prompt: z.string().min(1).max(450),
-        style: z.string(),
-    }),
-    z.object({
-        mode: z.literal(SUNO_MODE_TYPE.CUSTOM),
-        prompt: z.string().min(1).max(5000),
-        style: z.string().min(1).max(1000),
-        vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER),
-    }),
-    z.object({
-        mode: z.literal(SUNO_MODE_TYPE.CUSTOM_INSTRUMENTAL),
-        style: z.string().min(1).max(1000),
-    }),
-]);
-
-export type MusicJobParams = z.infer<typeof MusicJobParamsSchema>;
-
-export const MusicLyricsParamsSchema = z.object({
-    prompt: z.string().min(1).max(1000),
-    style: z.string().min(1).max(200).optional(),
-    structure: z.nativeEnum(MUSIC_LYRICS_STRUCTURE),
-});
-export type MusicLyricsParams = z.infer<typeof MusicLyricsParamsSchema>;
-
-export const MusicBackgroundParamsSchema = z.object({
-    prompt: z.string().min(1).max(450),
-    style: z.string(),
-});
-export type MusicBackgroundParams = z.infer<typeof MusicBackgroundParamsSchema>;
-
-export const MusicSeparateVocalsParamsSchema = z.object({
-    externalId: z.string().uuid(),
-    audioId: z.string().min(1),
-});
-export type MusicSeparateVocalsParams = z.infer<typeof MusicSeparateVocalsParamsSchema>;
-
-export const MusicUploadCoverParamsSchema = z.object({
-    audioId: z.string().uuid(),
-    uploadUrl: z.string().url(),
-    style: z.string().min(1).max(1000),
-    prompt: z.string().min(1).max(5000).optional(),
-    title: z.string().min(1).max(80).optional(),
-    negativeTags: z.string().max(1000).optional(),
-    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
-    instrumental: z.boolean().optional(),
-});
-export type MusicUploadCoverParams = z.infer<typeof MusicUploadCoverParamsSchema>;
-
-export const MusicUploadExtendParamsSchema = z.object({
-    audioId: z.string().uuid(),
-    uploadUrl: z.string().url(),
-    continueAt: z.number().positive(),
-    prompt: z.string().min(1).max(5000),
-    style: z.string().min(1).max(1000).optional(),
-    title: z.string().min(1).max(80).optional(),
-    negativeTags: z.string().max(1000).optional(),
-    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
-    instrumental: z.boolean().optional(),
-});
-export type MusicUploadExtendParams = z.infer<typeof MusicUploadExtendParamsSchema>;
-
-export const MusicAddInstrumentalParamsSchema = z.object({
-    audioId: z.string().uuid(),
-    uploadUrl: z.string().url(),
-    style: z.string().min(1).max(1000),
-    title: z.string().min(1).max(80).optional(),
-    negativeTags: z.string().max(1000).optional(),
-    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
-});
-export type MusicAddInstrumentalParams = z.infer<typeof MusicAddInstrumentalParamsSchema>;
-
-export const MusicAddVocalsParamsSchema = z.object({
-    audioId: z.string().uuid(),
-    uploadUrl: z.string().url(),
-    prompt: z.string().min(1).max(5000),
-    style: z.string().min(1).max(1000),
-    title: z.string().min(1).max(80).optional(),
-    negativeTags: z.string().max(1000).optional(),
-    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
-});
-export type MusicAddVocalsParams = z.infer<typeof MusicAddVocalsParamsSchema>;
-
-export const MusicEditRequestSchema = z
-    .object({
-        actionType: z.nativeEnum(MUSIC_AUDIO_ACTION_TYPE),
-        modelId: z.string().uuid().optional(),
-        params: z.unknown(),
-        userId: z.string().optional(),
-        unregisteredUserId: z.string().optional(),
-        userBalance: z.number(),
-    })
-    .superRefine((data, ctx) => {
-        const requiresModel = ![
-            MUSIC_AUDIO_ACTION_TYPE.REMOVE_VOCALS,
-            MUSIC_AUDIO_ACTION_TYPE.EXTRACT_VOCALS,
-        ].includes(data.actionType);
-
-        if (requiresModel && !data.modelId) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'modelId is required',
-                path: ['modelId'],
-            });
-        }
-
-        const paramsValidation =
-            data.actionType === MUSIC_AUDIO_ACTION_TYPE.REMOVE_VOCALS ||
-            data.actionType === MUSIC_AUDIO_ACTION_TYPE.EXTRACT_VOCALS
-                ? MusicSeparateVocalsParamsSchema.safeParse(data.params)
-                : data.actionType === MUSIC_AUDIO_ACTION_TYPE.COVER
-                  ? MusicUploadCoverParamsSchema.safeParse(data.params)
-                  : data.actionType === MUSIC_AUDIO_ACTION_TYPE.EXTEND
-                    ? MusicUploadExtendParamsSchema.safeParse(data.params)
-                    : data.actionType === MUSIC_AUDIO_ACTION_TYPE.ADD_INSTRUMENTAL
-                      ? MusicAddInstrumentalParamsSchema.safeParse(data.params)
-                      : MusicAddVocalsParamsSchema.safeParse(data.params);
-
-        if (!paramsValidation.success) {
-            for (const issue of paramsValidation.error.issues) {
-                ctx.addIssue({
-                    ...issue,
-                    path: ['params', ...issue.path],
-                });
-            }
-        }
-    });
-export type MusicEditRequest = z.infer<typeof MusicEditRequestSchema>;
-
-export const MusicEditActionResultSchema = z.object({
-    actionType: z.nativeEnum(MUSIC_AUDIO_ACTION_TYPE),
-    url: z.string(),
-    vocalUrl: z.string().optional(),
-    instrumentalUrl: z.string().optional(),
-    originUrl: z.string().optional(),
-    price: z.number(),
-});
-export type MusicEditActionResult = z.infer<typeof MusicEditActionResultSchema>;
-
-export const MusicAnyJobParamsSchema = z.union([
-    MusicJobParamsSchema,
-    MusicUploadCoverParamsSchema,
-    MusicUploadExtendParamsSchema,
-    MusicAddInstrumentalParamsSchema,
-    MusicAddVocalsParamsSchema,
-]);
-export type MusicAnyJobParams = z.infer<typeof MusicAnyJobParamsSchema>;
-
-export const MusicExecuteRequestSchema = z
-    .object({
-        actionType: z
-            .nativeEnum(MUSIC_GENERATION_ACTION_TYPE)
-            .optional()
-            .default(MUSIC_GENERATION_ACTION_TYPE.GENERATE),
-        modelId: z.string().uuid().optional(),
-        params: z.unknown(),
-    })
-    .superRefine((data, ctx) => {
-        if (data.actionType !== MUSIC_GENERATION_ACTION_TYPE.GENERATE_LYRICS && !data.modelId) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'modelId is required',
-                path: ['modelId'],
-            });
-        }
-
-        const paramsValidation =
-            data.actionType === MUSIC_GENERATION_ACTION_TYPE.GENERATE_LYRICS
-                ? MusicLyricsParamsSchema.safeParse(data.params)
-                : data.actionType === MUSIC_GENERATION_ACTION_TYPE.BACKGROUND
-                  ? MusicBackgroundParamsSchema.safeParse(data.params)
-                  : MusicJobParamsSchema.safeParse(data.params);
-
-        if (!paramsValidation.success) {
-            for (const issue of paramsValidation.error.issues) {
-                ctx.addIssue({
-                    ...issue,
-                    path: ['params', ...issue.path],
-                });
-            }
-        }
-    });
-export type MusicExecuteRequest = z.infer<typeof MusicExecuteRequestSchema>;
-
-export const MusicJobSchema = z.object({
-    uuid: z.string(),
-    prompt: z.string(),
-    reaction: z.nativeEnum(USER_REACTION).nullable(),
-    dislikeReason: z.string().nullable(),
-    externalId: z.string().nullable(),
-    title: z.string(),
-    status: z.nativeEnum(JOB_STATUS),
-    error: z.string().nullable(),
-    modelId: z.string(),
-    price: z.number(),
-    params: MusicAnyJobParamsSchema,
-    tracks: z.array(MusicTrackSchema),
-    attempts: z.array(z.any()),
-    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(),
-    updatedAt: z.date(),
-});
-
-export type MusicJob = z.infer<typeof MusicJobSchema>;

package/music/models/music-model-with-vendor.schema.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-import { MusicModelSchema } from './music-model.schema';
-
-export const MusicModelWithVendorSchema = MusicModelSchema.extend({
-    vendorId: z.string().uuid(),
-});
-
-export type MusicModelWithVendor = z.infer<typeof MusicModelWithVendorSchema>;

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

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-import { TOOL_MODEL_STATUS, IconVariantsSchema } from '../../common';
-import { MUSIC_GENERATION_STRATEGY, MUSIC_VOCAL_GENDER } from '../enums';
-import { SUNO_MODEL_TYPE } from '../enums';
-
-export const MusicModelParamsSchema = z.object({
-    vocalGender: z.object({
-        options: z.array(z.nativeEnum(MUSIC_VOCAL_GENDER)),
-    }),
-    styles: z.object({
-        maxStyles: z.number(),
-        options: z.array(
-            z.object({
-                title: z.string(),
-                style: z.string(),
-            }),
-        ),
-    }),
-});
-
-export type MusicModelParams = z.infer<typeof MusicModelParamsSchema>;
-
-export const MusicModelPricingRuleConditionSchema = z.object({
-    withoutSub: z.boolean().optional(),
-});
-export type MusicModelPricingRuleCondition = z.infer<typeof MusicModelPricingRuleConditionSchema>;
-
-export const MusicModelPricingRulesSchema = z.array(
-    z.object({
-        condition: MusicModelPricingRuleConditionSchema,
-        value: z.number(),
-    }),
-);
-export type MusicModelPricingRules = z.infer<typeof MusicModelPricingRulesSchema>;
-
-export const MusicModelSchema = z.object({
-    uuid: z.string(),
-    title: z.string(),
-    description: z.string(),
-    aiModel: z.nativeEnum(SUNO_MODEL_TYPE),
-    pricePerTrack: z.number(),
-    order: z.number(),
-    status: z.nativeEnum(TOOL_MODEL_STATUS),
-    icons: IconVariantsSchema,
-    strategy: z.nativeEnum(MUSIC_GENERATION_STRATEGY),
-    maxPromptLength: z.number(),
-    maxLyricsLength: z.number(),
-    params: MusicModelParamsSchema,
-    pricingRules: MusicModelPricingRulesSchema,
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type MusicModel = z.infer<typeof MusicModelSchema>;

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

@@ -1,15 +0,0 @@
-import { z } from 'zod';
-import { MusicTrackSchema } from './music-track.schema';
-
-export const MusicPlaylistSchema = z.object({
-    uuid: z.string().uuid(),
-    title: z.string(),
-    tracks: z.array(MusicTrackSchema).optional(),
-    trackCount: z.number(),
-    userId: z.string().uuid().nullable().optional(),
-    unregisteredUserId: z.string().uuid().nullable().optional(),
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type MusicPlaylist = z.infer<typeof MusicPlaylistSchema>;

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

@@ -1,35 +0,0 @@
-import { z } from 'zod';
-import { AttachedFileSchema } from '../../common';
-
-const MusicTrackAudioFileSchema = AttachedFileSchema.pick({
-    uuid: true,
-    url: true,
-    mimeType: true,
-}).extend({
-    duration: z.number().nullable(),
-    originalName: z.string().nullable().optional(),
-});
-
-export const MusicTrackSchema = z.object({
-    uuid: z.string(),
-    title: z.string(),
-    audioId: z.string(),
-    audioUrl: z.string(),
-    audioFile: MusicTrackAudioFileSchema.nullable().optional(),
-    coverUrl: z.string(),
-    prompt: z.string().nullable(),
-    fullLyrics: z.string().nullable().optional(),
-    tags: z.string(),
-    duration: z.number(),
-    waveformPeaks: z.array(z.number()),
-    isPublished: z.boolean().optional(),
-    postId: z.string().nullable().optional(),
-
-    genJobId: z.string().nullable().optional(),
-    editorJobId: z.string().nullable().optional(),
-
-    createdAt: z.date(),
-    updatedAt: z.date(),
-});
-
-export type MusicTrack = z.infer<typeof MusicTrackSchema>;

package/music/queries/find-music-job-by-id.query.ts

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

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

@@ -1,38 +0,0 @@
-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
-        .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(),
-        })
-        .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(MusicJobSchema),
-            page: z.number(),
-            totalPages: z.number(),
-            total: z.number(),
-        }),
-    );
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicPlaylistSchema } from '../models/music-playlist.schema';
-
-export namespace FindMusicPlaylistsQuery {
-    export const RequestSchema = z
-        .object({
-            userId: z.string().uuid().optional(),
-            unregisteredUserId: z.string().uuid().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.array(MusicPlaylistSchema));
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/music/queries/get-music-config-with-vendors.query.ts

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema, LocaleRequestSchema } from '../../common';
-import { MusicConfigWithVendorsSchema } from '../models';
-
-export namespace GetMusicConfigWithVendorsQuery {
-    export const RequestSchema = LocaleRequestSchema;
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(MusicConfigWithVendorsSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/music/queries/get-music-config.query.ts

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema, LocaleRequestSchema } from '../../common';
-import { MusicConfigSchema } from '../models';
-
-export namespace GetMusicConfigQuery {
-    export const RequestSchema = LocaleRequestSchema;
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(MusicConfigSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/music/routes/music-model.amqp.routes.ts

@@ -1,3 +0,0 @@
-export const MUSIC_MODEL_AMQP_ROUTES = {
-    GET_MODEL_BY_UUID: 'tools.music.model.get-by-uuid.rpc',
-} as const;

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

@@ -1,25 +0,0 @@
-export const MUSIC_AMQP_ROUTES = {
-    EXECUTE: 'tools.music.execute.rpc',
-    EDIT: 'tools.music.edit.rpc',
-    GET_PRICE: 'tools.music.get-price.rpc',
-    GENERATE_LYRICS: 'tools.music.generate-lyrics.rpc',
-    BOOST_STYLE: 'tools.music.boost-style.rpc',
-    CONVERT_TO_WAV: 'tools.music.convert-to-wav.rpc',
-    CONFIG: 'tools.music.config.rpc',
-    CONFIG_WITH_VENDORS: 'tools.music.config-with-vendors.rpc',
-    GET_JOB: 'tools.music.jobs.get.rpc',
-    LIST_JOBS: 'tools.music.jobs.list.rpc',
-    LIST_PLAYLISTS: 'tools.music.playlists.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',
-    CREATE_PLAYLIST: 'tools.music.playlists.create.rpc',
-    UPDATE_PLAYLIST: 'tools.music.playlists.update.rpc',
-    DELETE_PLAYLIST: 'tools.music.playlists.delete.rpc',
-    ADD_TRACK_TO_PLAYLIST: 'tools.music.playlists.add-track.rpc',
-    REMOVE_TRACK_FROM_PLAYLIST: 'tools.music.playlists.remove-track.rpc',
-    SOFT_DELETE: 'tools.music.jobs.soft-delete.rpc',
-    SOFT_DELETE_ALL: 'tools.music.jobs.soft-delete-all.rpc',
-    RETRY: 'tools.music.jobs.retry.rpc',
-} as const;

package/music/routes/music.http.routes.ts

@@ -1 +0,0 @@
-export const MUSIC_CONTROLLER = 'music';

package/music/utils/calculate-music-generation-price.util.ts

@@ -1,5 +0,0 @@
-export function calculateMusicGenerationPrice({ pricePerTrack }: { pricePerTrack: number }) {
-    const base = pricePerTrack;
-
-    return Math.ceil(base);
-}

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

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/get-paraphrase-price.command.ts

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-
-export namespace GetParaphrasePriceCommand {
-    export const RequestSchema = z.object({
-        typeId: 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/paraphrase/commands/paraphrase.command.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
-import { PARAPHRASING_INTENSITY } from '../enums';
-
-export namespace ParaphraseCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        prompt: z.string(),
-        typeId: z.string().uuid(),
-        styleId: z.string().uuid(),
-        intensity: z.nativeEnum(PARAPHRASING_INTENSITY),
-        tokenReservationId: z.string().uuid(),
-        precalculatedPrice: z.number(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(ParaphraseJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,17 +0,0 @@
-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(),
-        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(ParaphraseJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,30 +0,0 @@
-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().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(ParaphraseJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,16 +0,0 @@
-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/commands/update-paraphrase-job-title.command.ts

@@ -1,16 +0,0 @@
-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/enums/paraphrasing-intesity.enum.ts

@@ -1,5 +0,0 @@
-export enum PARAPHRASING_INTENSITY {
-    LOW = 'low',
-    MEDIUM = 'medium',
-    HIGH = 'high',
-}