@purpleschool/gptbot-tools 0.2.51 → 0.2.53

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

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicJobParamsSchema, MusicJobSchema } from '../models/music-job.schema';
-import { LocaleSchema } from '../../common';
-
-export namespace RetryMusicJobCommand {
-    export const RequestSchema = z.object({
-        locale: LocaleSchema,
-        uuid: z.string().uuid(),
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        tokenReservationId: z.string().uuid(),
-        precalculatedPrice: z.number(),
-        modelId: z.string().uuid().optional(),
-        params: MusicJobParamsSchema.optional(),
-        userHasActiveSubscriptionOrProduct: z.boolean(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

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

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

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

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

package/music/commands/update-music-playlist.command.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicPlaylistSchema } from '../models/music-playlist.schema';
-
-export namespace UpdateMusicPlaylistCommand {
-    export const RequestSchema = z
-        .object({
-            uuid: z.string().uuid(),
-            title: z.string().min(1).max(80).trim(),
-            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(MusicPlaylistSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/music/commands/update-published-status-music-jobs.command.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicJobSchema } from '../models';
-
-export namespace UpdatePublishedStatusMusicJobsCommand {
-    export const RequestSchema = z.object({
-        criteria: z.object({
-            uuid: z.string().uuid(),
-            userId: z.string().uuid().nullable().optional(),
-            unregisteredUserId: z.string().uuid().nullable().optional(),
-        }),
-        data: z
-            .object({
-                musicTrackId: z.string().uuid(),
-                isPublished: z.boolean(),
-                postId: z.string().nullable().optional(),
-            })
-            .refine((data) => (data.isPublished ? !!data.postId : true), {
-                message: 'Post ID is required when track is published',
-                path: ['postId'],
-            }),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/music/enums/music-action-type.enum.ts

@@ -1,10 +0,0 @@
-export enum MUSIC_ACTION_TYPE {
-    LYRICS = 'LYRICS',
-    BOOST_STYLE = 'BOOST_STYLE',
-    REMOVE_VOCALS = 'REMOVE_VOCALS',
-    EXTRACT_VOCALS = 'EXTRACT_VOCALS',
-    COVER = 'COVER',
-    EXTEND = 'EXTEND',
-    ADD_INSTRUMENTAL = 'ADD_INSTRUMENTAL',
-    ADD_VOCALS = 'ADD_VOCALS',
-}

package/music/enums/music-audio-action-type.enum.ts

@@ -1,8 +0,0 @@
-export enum MUSIC_AUDIO_ACTION_TYPE {
-    REMOVE_VOCALS = 'removeVocals',
-    EXTRACT_VOCALS = 'extractVocals',
-    COVER = 'cover',
-    EXTEND = 'extend',
-    ADD_INSTRUMENTAL = 'addInstrumental',
-    ADD_VOCALS = 'addVocals',
-}

package/music/enums/music-generation-action-type.enum.ts

@@ -1,6 +0,0 @@
-export enum MUSIC_GENERATION_ACTION_TYPE {
-    GENERATE = 'generate',
-    GIFT = 'gift',
-    BACKGROUND = 'background',
-    GENERATE_LYRICS = 'generateLyrics',
-}

package/music/enums/music-lyrics-structure.enum.ts

@@ -1,5 +0,0 @@
-export enum MUSIC_LYRICS_STRUCTURE {
-    VERSE_CHORUS = 'verse_chorus',
-    WITH_BRIDGE = 'with_bridge',
-    FREE = 'free',
-}

package/music/enums/music-pricing-rule-type.enum.ts

@@ -1,3 +0,0 @@
-export enum MUSIC_PRICING_RULE_TYPE {
-    FLAT = 'flat',
-}

package/music/enums/music-strategy.enum.ts

@@ -1,4 +0,0 @@
-export enum MUSIC_GENERATION_STRATEGY {
-    SUNO_POLLING = 'SUNO_POLLING',
-    SUNO_CALLBACK = 'SUNO_CALLBACK',
-}

package/music/enums/music-vocal-gender.enum.ts

@@ -1,4 +0,0 @@
-export enum MUSIC_VOCAL_GENDER {
-    MALE = 'm',
-    FEMALE = 'f',
-}

package/music/enums/suno-mode-type.enum.ts

@@ -1,6 +0,0 @@
-export enum SUNO_MODE_TYPE {
-    SIMPLE = 'simple',
-    SIMPLE_INSTRUMENTAL = 'simple_instrumental',
-    CUSTOM = 'custom',
-    CUSTOM_INSTRUMENTAL = 'custom_instrumental',
-}

package/music/enums/suno-model-type.enum.ts

@@ -1,7 +0,0 @@
-export enum SUNO_MODEL_TYPE {
-    V4 = 'V4',
-    V4_5 = 'V4_5',
-    V4_5PLUS = 'V4_5PLUS',
-    V5 = 'V5',
-    V5_5 = 'V5_5',
-}

package/music/models/music-config-with-vendors.schema.ts

@@ -1,12 +0,0 @@
-import { z } from 'zod';
-import { AiVendorSchema } from '../../ai-vendor';
-import { MusicModelWithVendorSchema } from './music-model-with-vendor.schema';
-import { MusicAudioActionPricesSchema } from './music-config.schema';
-
-export const MusicConfigWithVendorsSchema = z.object({
-    vendors: z.array(AiVendorSchema),
-    models: z.array(MusicModelWithVendorSchema),
-    audioActionPrices: MusicAudioActionPricesSchema,
-});
-
-export type MusicConfigWithVendors = z.infer<typeof MusicConfigWithVendorsSchema>;

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

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-import { MusicModelSchema } from './music-model.schema';
-import { MUSIC_AUDIO_ACTION_TYPE } from '../enums';
-
-export const MusicAudioActionPricesSchema = z.record(
-    z.nativeEnum(MUSIC_AUDIO_ACTION_TYPE),
-    z.number(),
-);
-
-export const MusicConfigSchema = z.object({
-    models: z.array(MusicModelSchema),
-    audioActionPrices: MusicAudioActionPricesSchema,
-});
-
-export type MusicConfig = z.infer<typeof MusicConfigSchema>;
-export type MusicAudioActionPrices = z.infer<typeof MusicAudioActionPricesSchema>;

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,11 +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 = MusicJobSchema.pick({ uuid: true });
-    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>;
-}