@purpleschool/gptbot-tools 0.0.15 → 0.0.17

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { STTResponseSchema } from './stt-response.schema';
+import { USER_REACTION } from '../../common';
+
+export const STTJobSchema = z.object({
+    uuid: z.string(),
+    modelId: z.string(),
+    title: z.string(),
+    fileUrl: z.string(),
+    aiResponse: STTResponseSchema.nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    userId: z.string().nullable(),
+    unregisteredUserId: z.string().nullable(),
+    price: z.number(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    completedAt: z.date().nullable(),
+    updatedAt: z.date(),
+});
+
+export type STTJob = z.infer<typeof STTJobSchema>;

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { IconVariantsSchema } from '../../common';
+
+export const STTModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    pricePerMin: z.number(),
+    order: z.number(),
+    icons: IconVariantsSchema,
+    strategy: z.string().optional(),
+    maxDurationSeconds: z.number(),
+    maxSizeMB: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type STTModel = z.infer<typeof STTModelSchema>;

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const STTResponseSchema = z.object({
+    raw: z.object({}),
+    md: z.string(),
+});
+
+export type STTResponse = z.infer<typeof STTResponseSchema>;

package/stt/queries/find-stt-job-by-uuid.query.ts

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

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

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

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

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

package/stt/queries/index.ts

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

package/stt/routes/index.ts

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

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

@@ -0,0 +1,9 @@
+export const STT_AMQP_ROUTES = {
+    EXECUTE: 'tools.stt.execute.rpc',
+    CONFIG: 'tools.stt.config.rpc',
+    GET_JOB: 'tools.stt.jobs.get.rpc',
+    LIST_JOBS: 'tools.stt.jobs.list.rpc',
+    SET_REACTION: 'tools.stt.jobs.set_reaction.rpc',
+    SOFT_DELETE: 'tools.stt.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.stt.jobs.soft-delete-all.rpc',
+} as const;

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

@@ -1,5 +1,5 @@
 export enum JOB_STATUS {
-    PEDNING = 'pending',
+    PENDING = 'pending',
     PROCESSING = 'processing',
     COMPLETED = 'completed',
     FAILED = 'failed',

package/tools/models/tool-job.schema.ts

@@ -8,3 +8,5 @@ export const ToolJobSchema = z.object({
     createdAt: z.date(),
     updatedAt: z.date(),
 });
+
+export type ToolJob = z.infer<typeof ToolJobSchema>;

package/tools/models/tool.schema.ts

@@ -9,3 +9,5 @@ export const ToolSchema = z.object({
     createdAt: z.date(),
     updatedAt: z.date(),
 });
+
+export type Tool = z.infer<typeof ToolSchema>;

package/tools/routes/tools.aqmp.routes.ts

@@ -1,4 +1,4 @@
-export const TOOLS_AQMP_ROUTES = {
+export const TOOLS_AMQP_ROUTES = {
     JOB_COMPLETED: 'tools.job.completed',
     FIND_ALL: 'tools.find.all.rpc',
 };

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

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

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

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

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

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

package/tts/commands/tts.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { TTSJobSchema } from '../models/tts-job.schema';
+
+export namespace TTSCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
+        modelId: z.string(),
+        voiceId: z.string(),
+        userInput: z.string(),
+        params: z
+            .object({
+                speed: z.number().optional(),
+                similarity: z.number().optional(),
+                stability: z.number().optional(),
+                style: z.number().optional(),
+            })
+            .optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(TTSJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { TTSJobSchema } from '../models/tts-job.schema';
+
+export namespace UpdateTTSJobTitleCommand {
+    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 RequestParamsSchema = z.object({
+        uuid: z.string(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(TTSJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/tts/enums/index.ts

@@ -0,0 +1,2 @@
+export * from './tts-model-type.enum';
+export * from './tts-strategy.enum';

package/tts/enums/tts-model-type.enum.ts

@@ -0,0 +1,4 @@
+export enum TTSModelType {
+    ELEVENLABS_BASIC = 'ELEVENLABS_BASIC',
+    ELEVENLABS_ADVANCED = 'ELEVENLABS_ADVANCED',
+}

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

@@ -0,0 +1,3 @@
+export enum TTS_STRATEGY {
+    ELEVENLABS_TTS = 'ELEVENLABS_TTS',
+}

package/tts/index.ts

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

package/tts/models/index.ts

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

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { TTSModelSchema } from './tts-model.schema';
+
+export const TTSConfigSchema = z.object({
+    models: z.array(TTSModelSchema),
+});
+
+export type TTSConfig = z.infer<typeof TTSConfigSchema>;

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
+
+export const TTSJobParamsSchema = z.object({
+    speed: z.number().optional(),
+    similarity: z.number().optional(),
+    stability: z.number().optional(),
+    style: z.number().optional(),
+});
+export type TTSJobParams = z.infer<typeof TTSJobParamsSchema>;
+
+export const TTSJobSchema = z.object({
+    uuid: z.string(),
+    userInput: z.string(),
+    aiResponse: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    modelId: z.string(),
+    voiceId: z.string(),
+    price: z.number(),
+    userId: z.string().nullable(),
+    unregisteredUserId: z.string().nullable(),
+    isDeleted: z.boolean(),
+    params: TTSJobParamsSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    completedAt: z.date().nullable(),
+});
+
+export type TTSJob = z.infer<typeof TTSJobSchema>;

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

@@ -0,0 +1,62 @@
+import { IconVariantsSchema } from '../../common';
+import { z } from 'zod';
+
+export const TTSVoiceSchema = z.object({
+    id: z.string(),
+    externalId: z.string(),
+    icon: z.string(),
+    title: z.string(),
+    previewUrl: z.string(),
+    description: z.string(),
+    languages: z.array(
+        z.object({
+            code: z.string(),
+            title: z.string(),
+            icon: z.string(),
+            order: z.number(),
+        }),
+    ),
+    order: z.number(),
+});
+export type TTSVoice = z.infer<typeof TTSVoiceSchema>;
+
+export const TTSSliderSchema = z.object({
+    title: z.string(),
+    description: z.string(),
+    icons: IconVariantsSchema,
+    min: z.number(),
+    minLabel: z.string(),
+    max: z.number(),
+    maxLabel: z.string(),
+    step: z.number(),
+    default: z.number(),
+});
+export type TTSSlider = z.infer<typeof TTSSliderSchema>;
+
+export const TTSModelParams = z
+    .object({
+        speed: TTSSliderSchema,
+        stability: TTSSliderSchema,
+        similarity: TTSSliderSchema,
+        style: TTSSliderSchema,
+    })
+    .partial();
+export type TTSModelParams = z.infer<typeof TTSModelParams>;
+
+export const TTSModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.string(),
+    pricePerThousandSymbols: z.number(),
+    order: z.number(),
+    icons: IconVariantsSchema,
+    strategy: z.string().optional(),
+    maxInputLength: z.number(),
+    voices: z.array(TTSVoiceSchema),
+    params: TTSModelParams,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type TTSModel = z.infer<typeof TTSModelSchema>;

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

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

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

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

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

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

package/tts/queries/index.ts

@@ -0,0 +1,3 @@
+export * from './find-tts-job-by-id.query';
+export * from './find-tts-jobs.query';
+export * from './get-tts-config.query';

package/tts/routes/index.ts

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

package/tts/routes/tts.amqp.routes.ts

@@ -0,0 +1,10 @@
+export const TTS_AMQP_ROUTES = {
+    EXECUTE: 'tools.tts.execute.rpc',
+    CONFIG: 'tools.tts.config.rpc',
+    GET_JOB: 'tools.tts.jobs.get.rpc',
+    LIST_JOBS: 'tools.tts.jobs.list.rpc',
+    SET_REACTION: 'tools.tts.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.tts.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.tts.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.tts.jobs.soft-delete-all.rpc',
+} as const;