@purpleschool/gptbot-tools 0.0.55 → 0.0.56-presentation

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

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

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

package/music/index.ts

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

package/music/models/index.ts

@@ -0,0 +1,4 @@
+export * from './music-config.schema';
+export * from './music-job.schema';
+export * from './music-model.schema';
+export * from './music-track.schema';

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

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

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
+import { 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),
+        title: z.string().min(1).max(80),
+        style: z.string().min(1).max(1000),
+        vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER),
+    }),
+    z.object({
+        mode: z.literal(SUNO_MODE_TYPE.CUSTOM_INSTRUMENTAL),
+        title: z.string().min(1).max(80),
+        style: z.string().min(1).max(1000),
+    }),
+]);
+
+export type MusicJobParams = z.infer<typeof MusicJobParamsSchema>;
+
+export const MusicJobSchema = z.object({
+    uuid: z.string(),
+    prompt: z.string(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    externalId: z.string().nullable(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    modelId: z.string(),
+    price: z.number(),
+    params: MusicJobParamsSchema,
+    tracks: z.array(MusicTrackSchema),
+    attempts: z.array(z.any()),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    completedAt: z.date().nullable().optional(),
+    updatedAt: z.date(),
+});
+
+export type MusicJob = z.infer<typeof MusicJobSchema>;

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

@@ -0,0 +1,40 @@
+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 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,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type MusicModel = z.infer<typeof MusicModelSchema>;

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+export const MusicTrackSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    audioId: z.string(),
+    audioUrl: z.string(),
+    coverUrl: z.string(),
+    tags: z.string(),
+    duration: z.number(),
+
+    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

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

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

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

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

package/music/queries/index.ts

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

package/music/routes/index.ts

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

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

@@ -0,0 +1,13 @@
+export const MUSIC_AMQP_ROUTES = {
+    EXECUTE: 'tools.music.execute.rpc',
+    GENERATE_LYRICS: 'tools.music.generate-lyrics.rpc',
+    CONVERT_TO_WAV: 'tools.music.convert-to-wav.rpc',
+    CONFIG: 'tools.music.config.rpc',
+    GET_JOB: 'tools.music.jobs.get.rpc',
+    LIST_JOBS: 'tools.music.jobs.list.rpc',
+    SET_REACTION: 'tools.music.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.music.jobs.update-title.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/utils/calculate-music-generation-price.util.ts

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

package/music/utils/index.ts

@@ -0,0 +1 @@
+export * from './calculate-music-generation-price.util';

package/package.json

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

package/presentation/commands/build-blank-slide.command.ts

@@ -0,0 +1,15 @@
+import { ICommandResponseSchema } from '../../common';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../enums';
+import { z } from 'zod';
+import { SlideSchema } from '../models';
+
+export namespace BuildBlankSlideCommand {
+    export const RequestSchema = z.object({
+        slideContentType: z.nativeEnum(SLIDE_CONTENT_TYPE),
+        layoutId: z.nativeEnum(SLIDE_LAYOUT).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SlideSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/commands/generate-and-insert-slide.command.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../enums';
+import { SlideSchema } from '../models';
+
+export namespace GenerateAndInsertSlideCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
+        presentationId: z.string().uuid(),
+        contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+        prompt: z.string().min(1).max(1000).optional(),
+        title: z.string().max(80),
+        position: z.number().int().min(0),
+        layoutId: z.nativeEnum(SLIDE_LAYOUT).optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SlideSchema.array());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/commands/index.ts

@@ -1,11 +1,18 @@
+export * from './build-blank-slide.command';
 export * from './create-presentation.command';
 export * from './delete-all-user-presentations.command';
 export * from './delete-presentation.command';
 export * from './delete-slide-outline.command';
 export * from './generate-presentation-outline.command';
+export * from './generate-and-insert-slide.command';
 export * from './export-as-pptx.command';
 export * from './generate-slides.command';
 export * from './reposition-slide-outline.command';
 export * from './update-slide-outline.command';
 export * from './update-presentation.command';
 export * from './update-presentation-outline.command';
+export * from './update-presentation-slides.command';
+export * from './update-slide-image-slot.command';
+export * from './update-slide.command';
+export * from './presentation-paraphrase.command';
+export * from './presentation-generate-report.command';

package/presentation/commands/presentation-generate-report.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace PresentationGenerateReportCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+            docxUrl: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/commands/presentation-paraphrase.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace PresentationParaphraseCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        selectionText: z.string(),
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            output: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

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

package/presentation/commands/update-slide-image-slot.command.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { SlideImageSlotSchema } from '../models';
+import { SLIDE_IMAGE_SLOT_ACTION } from '../enums';
+
+export namespace UpdateSlideImageSlotCommand {
+    const ReplacePayload = z.object({
+        action: z.literal(SLIDE_IMAGE_SLOT_ACTION.REPLACE),
+        url: z.string().url(),
+    });
+
+    const GeneratePayload = z.object({
+        action: z.literal(SLIDE_IMAGE_SLOT_ACTION.GENERATE),
+        prompt: z.string().min(1).max(1000).optional(),
+    });
+
+    const UpdateImageSlotPayload = z.discriminatedUnion('action', [
+        ReplacePayload,
+        GeneratePayload,
+    ]);
+
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        slotId: z.string().uuid().optional(),
+        payload: UpdateImageSlotPayload,
+        userBalance: z.number(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            imageSlot: SlideImageSlotSchema,
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { SlideSchema, SlideUpdateSchema } from '../models';
+import { ICommandResponseSchema } from '../../common';
+
+export namespace UpdateSlideCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        data: SlideUpdateSchema,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(SlideSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/enums/index.ts

@@ -4,3 +4,7 @@ export * from './slide-image-job-status.enum';
 export * from './slide-image-slot-status.enum';
 export * from './slide-icon-slot-status.enum';
 export * from './slide-layout.enum';
+export * from './slide-image-slot-action.enum';
+export * from './presentation-ai-action-call-status.enum';
+export * from './presentation-ai-action-type.enum';
+export * from './presentation-ai-action-pricing-type.enum';

package/presentation/enums/presentation-ai-action-call-status.enum.ts

@@ -0,0 +1,5 @@
+export enum PRESENTATION_AI_ACTION_CALL_STATUS {
+    PROCESSING = 'processing',
+    COMPLETED = 'completed',
+    FAILED = 'failed',
+}

package/presentation/enums/presentation-ai-action-pricing-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_PRICING_TYPE {
+    PER_CHARACTER = 'PER_CHARACTER',
+    FLAT = 'FLAT',
+}

package/presentation/enums/presentation-ai-action-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_TYPE {
+    PARAPHRASE = 'PARAPHRASE',
+    GENERATE_REPORT = 'GENERATE_REPORT',
+}

package/presentation/enums/slide-image-slot-action.enum.ts

@@ -0,0 +1,4 @@
+export enum SLIDE_IMAGE_SLOT_ACTION {
+    REPLACE = 'REPLACE',
+    GENERATE = 'GENERATE',
+}

package/presentation/index.ts

@@ -4,3 +4,4 @@ export * from './models';
 export * from './enums';
 export * from './routes';
 export * from './queries';
+export * from './utils';

package/presentation/models/index.ts

@@ -7,3 +7,4 @@ export * from './slide-outline.schema';
 export * from './slide.schema';
 export * from './slide-image-slot.schema';
 export * from './slide-content.schema';
+export * from './presentation-ai-action.schema';

package/presentation/models/presentation-ai-action.schema.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { PRESENTATION_AI_ACTION_PRICING_TYPE, PRESENTATION_AI_ACTION_TYPE } from '../enums';
+
+export const PresentationAiActionPricingRulesSchema = z.discriminatedUnion('type', [
+    z.object({
+        type: z.literal(PRESENTATION_AI_ACTION_PRICING_TYPE.PER_CHARACTER),
+        price: z.number(),
+    }),
+    z.object({
+        type: z.literal(PRESENTATION_AI_ACTION_PRICING_TYPE.FLAT),
+        price: z.number(),
+    }),
+]);
+export type PresentationAiActionPricingRules = z.infer<
+    typeof PresentationAiActionPricingRulesSchema
+>;
+
+export const PresentationAiActionSchema = z.object({
+    uuid: z.string(),
+    type: z.nativeEnum(PRESENTATION_AI_ACTION_TYPE),
+    pricingRules: PresentationAiActionPricingRulesSchema,
+    maxPromptLength: z.number(),
+    aiModel: z.string(),
+    title: z.string(),
+    icon: z.string(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type PresentationAiAction = z.infer<typeof PresentationAiActionSchema>;

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

@@ -2,16 +2,19 @@ import { z } from 'zod';
 import { SlideContentTypeSchema } from './slide-content-type.schema';
 import { LanguageSchema } from '../../language';
 import { PresentationTemplateSchema } from './presentation-template.schema';
+import { PresentationAiActionSchema } from './presentation-ai-action.schema';
 
 export const PresentationConfigSchema = z.object({
     slideContentTypes: z.array(SlideContentTypeSchema),
     languages: z.array(LanguageSchema),
     templates: z.array(PresentationTemplateSchema),
+    aiActions: z.array(PresentationAiActionSchema),
     slideGenerationPrice: z.number(),
     maxSlides: z.number(),
     minSlides: z.number(),
     maxSlideTitleLength: z.number(),
     maxSlideOutlineLength: z.number(),
     maxPromptLength: z.number(),
+    imageGenerationPrice: z.number(),
 });
 export type PresentationConfig = z.infer<typeof PresentationConfigSchema>;

package/presentation/models/presentation.schema.ts

@@ -16,6 +16,8 @@ export const PresentationSchema = z.object({
     unregisteredUserId: z.string().uuid().nullable().optional(),
     slideCount: z.number(),
     isDeleted: z.boolean(),
+    lastContentUpdateAt: z.date().nullable(),
+    lastPptxExportedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });
@@ -29,5 +31,6 @@ export type PresentationWithSlides = z.infer<typeof PresentationWithSlidesSchema
 
 export const PresentationUpdateSchema = PresentationSchema.pick({
     title: true,
-});
+    templateId: true,
+}).partial();
 export type PresentationUpdate = z.infer<typeof PresentationUpdateSchema>;