@purpleschool/gptbot 0.12.96 → 0.12.98-stage-2

package/commands/{ai-studio/canvas-edge → canvas-edge}/create-canvas-edge.command.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { INPUT_OUTPUT_TYPE } from '../../../constants';
-import { CanvasEdgeSchema } from '../../../models';
+import { INPUT_OUTPUT_TYPE } from '../../constants';
+import { CanvasEdgeSchema } from '../../models';
 
 export namespace CreateCanvasEdgeCommand {
     export const RequestParamSchema = z.object({
@@ -12,8 +12,7 @@ export namespace CreateCanvasEdgeCommand {
     export const RequestSchema = z.object({
         sourceId: z.string().uuid(),
         targetId: z.string().uuid(),
-        sourceHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
-        targetHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+        handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/{ai-studio/canvas-edge → canvas-edge}/find-canvas-edge-by-source-and-target.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema } from '../../../models';
+import { CanvasEdgeSchema } from '../../models';
 
 export namespace FindCanvasEdgeBySourceAndTargetQuery {
     export const RequestParamSchema = z.object({

package/commands/{ai-studio/canvas-edge → canvas-edge}/find-canvas-edges-by-canvas.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema } from '../../../models';
+import { CanvasEdgeSchema } from '../../models';
 
 export namespace FindCanvasEdgesByCanvasQuery {
     export const RequestParamSchema = z.object({

package/commands/canvas-node/create-canvas-node.command.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE } from '../../constants';
+import { CanvasNodeParamsSchema, CanvasNodePositionSchema, CanvasNodeSchema } from '../../models';
+
+export namespace CreateCanvasNodeCommand {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
+        position: CanvasNodePositionSchema,
+        params: CanvasNodeParamsSchema.nullable().optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasNodeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/{ai-studio/canvas-node → canvas-node}/delete-canvas-node.command.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { CanvasNodeBaseSchema } from '../../../models';
+import { CanvasNodeSchema } from '../../models';
 
 export namespace DeleteCanvasNodeCommand {
-    export const RequestParamSchema = CanvasNodeBaseSchema.pick({
+    export const RequestParamSchema = CanvasNodeSchema.pick({
         canvasId: true,
         uuid: true,
     });

package/commands/{ai-studio/canvas-node → canvas-node}/find-canvas-node-by-uuid.query.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { CanvasNodeBaseSchema, CanvasNodeSchema } from '../../../models';
+import { CanvasNodeSchema } from '../../models';
 
 export namespace FindCanvasNodeByUuidQuery {
-    export const RequestParamSchema = CanvasNodeBaseSchema.pick({
+    export const RequestParamSchema = CanvasNodeSchema.pick({
         canvasId: true,
         uuid: true,
     });

package/commands/{ai-studio/canvas-node → canvas-node}/find-canvas-node-definitions-with-configs.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasNodeDefinitionsWithConfigsSchema } from '../../../models';
+import { CanvasNodeDefinitionsWithConfigsSchema } from '../../models';
 
 export namespace FindCanvasNodeDefinitionsWithConfigsQuery {
     export const ResponseSchema = z.object({

package/commands/{ai-studio/canvas-node → canvas-node}/find-canvas-nodes-by-canvas.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasNodeSchema } from '../../../models';
+import { CanvasNodeSchema } from '../../models';
 
 export namespace FindCanvasNodesByCanvasQuery {
     export const RequestParamSchema = z.object({

package/commands/{ai-studio/canvas-node → canvas-node}/index.ts

@@ -1,4 +1,3 @@
-export * from './count-canvas-nodes-by-canvas.query';
 export * from './create-canvas-node.command';
 export * from './delete-canvas-node.command';
 export * from './find-canvas-node-by-uuid.query';

package/commands/canvas-node/update-canvas-node.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE } from '../../constants';
+import { CanvasNodeParamsSchema, CanvasNodePositionSchema, CanvasNodeSchema } from '../../models';
+
+export namespace UpdateCanvasNodeCommand {
+    export const RequestParamSchema = CanvasNodeSchema.pick({
+        canvasId: true,
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE).optional(),
+        position: CanvasNodePositionSchema.optional(),
+        params: CanvasNodeParamsSchema.nullable().optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasNodeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/{ai-studio/canvas-template → canvas-template}/create-canvas-from-template.command.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../../models';
+import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../models';
 
 export namespace CreateCanvasFromTemplateCommand {
     export const RequestParamSchema = z.object({

package/commands/{ai-studio/canvas-template → canvas-template}/create-canvas-template.command.ts

@@ -1,17 +1,12 @@
 import { z } from 'zod';
-import {
-    CanvasTemplateGraphSchema,
-    CanvasTemplateSchema,
-    CanvasTemplateTagSchema,
-} from '../../../models';
+import { CanvasTemplateSchema, CanvasTemplateGraphSchema } from '../../models';
 
 export namespace CreateCanvasTemplateCommand {
     export const RequestSchema = z.object({
         name: z.string().trim().min(1),
         description: z.string().trim().min(1).optional().nullable(),
-        isPopular: z.boolean().optional().default(false),
         previewImageUrl: z.string().url().optional().nullable(),
-        tags: z.array(CanvasTemplateTagSchema).default([]),
+        tags: z.array(z.string().trim().min(1)).default([]),
         graph: CanvasTemplateGraphSchema,
     });
 

package/commands/{ai-studio/canvas-template → canvas-template}/delete-canvas-template.command.ts

@@ -1,9 +1,8 @@
 import { z } from 'zod';
-import { CanvasTemplateSchema } from '../../../models';
 
 export namespace DeleteCanvasTemplateCommand {
-    export const RequestParamSchema = CanvasTemplateSchema.pick({
-        uuid: true,
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
     });
 
     export type RequestParam = z.infer<typeof RequestParamSchema>;

package/commands/{ai-studio/canvas-template → canvas-template}/find-canvas-template-by-uuid.query.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { CanvasTemplateSchema } from '../../../models';
+import { CanvasTemplateSchema } from '../../models';
 
 export namespace FindCanvasTemplateByUuidQuery {
     export const RequestSchema = CanvasTemplateSchema.pick({

package/commands/{ai-studio/canvas-template → canvas-template}/find-canvas-templates.query.ts

@@ -1,15 +1,11 @@
 import { z } from 'zod';
-import { CanvasTemplateSchema } from '../../../models';
+import { CanvasTemplateSchema } from '../../models';
 
 export namespace FindCanvasTemplatesQuery {
     export const RequestSchema = z.object({
         limit: z.coerce.number().min(1).default(10),
         offset: z.coerce.number().min(0).default(0),
         search: z.string().trim().optional(),
-        isPopular: z
-            .union([z.boolean(), z.enum(['true', 'false'])])
-            .transform((value) => (typeof value === 'boolean' ? value : value === 'true'))
-            .optional(),
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/{ai-studio/canvas-template → canvas-template}/index.ts

@@ -1,8 +1,6 @@
-export * from './create-canvas-from-template.command';
-export * from './create-canvas-from-generated-template.command';
 export * from './create-canvas-template.command';
+export * from './create-canvas-from-template.command';
 export * from './delete-canvas-template.command';
-export * from './generate-canvas-template-by-prompt.command';
 export * from './find-canvas-template-by-uuid.query';
 export * from './find-canvas-templates.query';
 export * from './update-canvas-template.command';

package/commands/{ai-studio/canvas-template → canvas-template}/update-canvas-template.command.ts

@@ -1,9 +1,5 @@
 import { z } from 'zod';
-import {
-    CanvasTemplateSchema,
-    CanvasTemplateGraphSchema,
-    CanvasTemplateTagSchema,
-} from '../../../models';
+import { CanvasTemplateSchema, CanvasTemplateGraphSchema } from '../../models';
 
 export namespace UpdateCanvasTemplateCommand {
     export const RequestParamSchema = CanvasTemplateSchema.pick({
@@ -15,9 +11,8 @@ export namespace UpdateCanvasTemplateCommand {
     export const RequestSchema = z.object({
         name: z.string().trim().min(1).optional(),
         description: z.string().trim().min(1).optional().nullable(),
-        isPopular: z.boolean().optional(),
         previewImageUrl: z.string().url().optional().nullable(),
-        tags: z.array(CanvasTemplateTagSchema).optional(),
+        tags: z.array(z.string().trim().min(1)).optional(),
         graph: CanvasTemplateGraphSchema.optional(),
     });
 

package/commands/category/create-category.command.ts

@@ -2,12 +2,14 @@ import { z } from 'zod';
 import { CategorySchema } from '../../models';
 
 export namespace CreateCategoryCommand {
-    export const RequestSchema = CategorySchema.pick({
-        mainCategoryId: true,
-        type: true,
-        order: true,
-        contentType: true,
-        marks: true,
+    export const RequestSchema = CategorySchema.omit({
+        uuid: true,
+        name: true,
+        prompt: true,
+        placeholder: true,
+        seoName: true,
+        createdAt: true,
+        updatedAt: true,
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/course/create-course.command.ts

@@ -2,11 +2,15 @@ import { z } from 'zod';
 import { CourseSchema } from '../../models';
 
 export namespace CreateCourseCommand {
-    export const RequestSchema = CourseSchema.pick({
-        alias: true,
-        author: true,
-        videoId: true,
-        status: true,
+    export const RequestSchema = CourseSchema.omit({
+        uuid: true,
+        title: true,
+        subtitle: true,
+        prerequisites: true,
+        description: true,
+        skills: true,
+        createdAt: true,
+        updatedAt: true,
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/index.ts

@@ -3,11 +3,9 @@ export * from './ai-model';
 export * from './ai-vendor';
 export * from './auth';
 export * from './blog';
-export * from './ai-studio/canvas';
-export * from './ai-studio/canvas-node';
-export * from './ai-studio/canvas-edge';
-export * from './ai-studio/canvas-template';
-export * from './ai-studio/canvas-tool';
+export * from './canvas';
+export * from './canvas-node';
+export * from './canvas-edge';
 export * from './category';
 export * from './chat';
 export * from './course';
@@ -30,7 +28,6 @@ export * from './telegram-auth';
 export * from './telegram-profile';
 export * from './tools';
 export * from './unregistered-user';
-export * from './update-post';
 export * from './user';
 export * from './user-to-subscription';
 export * from './user-to-task';
@@ -52,3 +49,5 @@ export * from './user-profile';
 export * from './team-account';
 export * from './team-to-subscription';
 export * from './team-to-product';
+
+export * from './canvas-template';

package/commands/page/create-page.command.ts

@@ -3,14 +3,16 @@ import { PageSchema } from '../../models';
 import { z } from 'zod';
 
 export namespace CreatePageCommand {
-    export const RequestSchema = PageSchema.pick({
-        alias: true,
-        categoryId: true,
-        aIModelId: true,
-        toolId: true,
-        toolOptionId: true,
-        toolModelId: true,
-        type: true,
+    export const RequestSchema = PageSchema.omit({
+        uuid: true,
+        createdAt: true,
+        updatedAt: true,
+        metaTitle: true,
+        metaDescription: true,
+        title: true,
+        subTitle: true,
+        seoTextMd: true,
+        toolTitle: true,
     })
         .refine(
             (data) => {

package/commands/prompt/create-prompt.command.ts

@@ -2,8 +2,12 @@ import z from 'zod';
 import { PromptSchema } from '../../models';
 
 export namespace CreatePromptCommand {
-    export const RequestSchema = PromptSchema.pick({
-        topicId: true,
+    export const RequestSchema = PromptSchema.omit({
+        uuid: true,
+        title: true,
+        content: true,
+        createdAt: true,
+        updatedAt: true,
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/prompt-category/create-prompt-category.command.ts

@@ -2,9 +2,13 @@ import z from 'zod';
 import { PromptCategorySchema } from '../../models';
 
 export namespace CreatePromptCategoryCommand {
-    export const RequestSchema = PromptCategorySchema.pick({
-        icon: true,
-        alias: true,
+    export const RequestSchema = PromptCategorySchema.omit({
+        uuid: true,
+        title: true,
+        metaTitle: true,
+        metaDescription: true,
+        createdAt: true,
+        updatedAt: true,
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/prompt-topic/create-prompt-topic.command.ts

@@ -2,9 +2,15 @@ import z from 'zod';
 import { PromptTopicSchema } from '../../models';
 
 export namespace CreatePromptTopicCommand {
-    export const RequestSchema = PromptTopicSchema.pick({
-        categoryId: true,
-        alias: true,
+    export const RequestSchema = PromptTopicSchema.omit({
+        uuid: true,
+        title: true,
+        content: true,
+        metaTitle: true,
+        metaDescription: true,
+        seoText: true,
+        createdAt: true,
+        updatedAt: true,
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/question/create-question.command.ts

@@ -2,8 +2,12 @@ import { z } from 'zod';
 import { QuestionSchema } from '../../models';
 
 export namespace CreateQuestionCommand {
-    export const RequestSchema = QuestionSchema.pick({
-        pageId: true,
+    export const RequestSchema = QuestionSchema.omit({
+        uuid: true,
+        createdAt: true,
+        updatedAt: true,
+        question: true,
+        answer: true,
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/tools/diagrams/get-diagrams-price.command.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 export namespace GetDiagramsPriceCommand {
     export const RequestSchema = z.object({
         modelId: z.string().uuid(),
-        promptLenght: z.number().max(100000),
+        promptLenght: z.number().max(10000),
         chartTypeUuid: z.string().uuid(),
         fileIds: z.array(z.string().uuid()).optional().default([]),
         jobId: z.string().uuid().optional(),

package/commands/tools/marketplace-card/execute-marketplace-card.command.ts

@@ -20,7 +20,6 @@ export namespace ExecuteMarketplaceCardCommand {
             customStylePrompt: z.string().nullable().optional(),
             inputImages: z.array(z.string()),
             backgroundDescription: z.string().nullable().optional(),
-            descriptionGenerationId: z.string().uuid().nullable().optional(),
         })
         .superRefine((data, ctx) => {
             const hasPreset = Boolean(data.stylePresetId);

package/commands/tools/marketplace-card/index.ts

@@ -1,5 +1,4 @@
 export * from './execute-marketplace-card.command';
-export * from './generate-marketplace-card-description.command';
 export * from './find-marketplace-card-job-by-uuid.command';
 export * from './find-marketplace-card-jobs.command';
 export * from './get-marketplace-card-config.command';

package/commands/user/get-client-country-code.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export namespace GetClientCountryCodeCommand {
+    export const RequestSchema = z.object({});
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            countryCode: z.string().nullable(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/user/index.ts

@@ -1,5 +1,6 @@
 export * from './check-email.command';
 export * from './find-user-by-uuid.command';
+export * from './get-client-country-code.command';
 export * from './get-me.command';
 export * from './patch-locale.command';
 export * from './up-token-bonus-balance.command';

package/commands/user/send-telegram-notification.command.ts

@@ -1,10 +1,17 @@
 import { z } from 'zod';
+import { LOCALE } from '@purpleschool/rugpt-lib-common';
 import { UserFilterSchema } from '../../models';
 
 export namespace SendTelegramNotificationCommand {
+    export const MessageMdSchema = z.object({
+        [LOCALE.RU]: z.string(),
+        [LOCALE.EN]: z.string(),
+    });
+    export type MessageMd = z.infer<typeof MessageMdSchema>;
+
     export const RequestSchema = z.object({
         filters: UserFilterSchema,
-        messageMd: z.string(),
+        messageMd: MessageMdSchema,
     });
     export type Request = z.infer<typeof RequestSchema>;
 

package/constants/canvas/enums/canvas-status.enum.ts

@@ -0,0 +1,5 @@
+export enum CANVAS_STATUS {
+    IDLE = 'IDLE',
+    RUNNING = 'RUNNING',
+    FAILED = 'FAILED',
+}

package/constants/canvas/enums/index.ts

@@ -0,0 +1 @@
+export * from './canvas-status.enum';

package/constants/canvas/index.ts

@@ -0,0 +1 @@
+export * from './enums';

package/constants/canvas-edge/enums/input-output-type.enum.ts

@@ -6,6 +6,4 @@ export enum INPUT_OUTPUT_TYPE {
     html = 'html',
     palette = 'palette',
     var = 'var',
-    firstFrame = 'firstFrame',
-    lastFrame = 'lastFrame',
 }

package/constants/canvas-node/enums/canvas-node-type.enum.ts

@@ -16,5 +16,4 @@ export enum CANVAS_NODE_TYPE {
     varGen = 'varGen',
     varBlock = 'varBlock',
     htmlGen = 'htmlGen',
-    audioBlock = 'audioBlock',
 }

package/constants/index.ts

@@ -40,6 +40,7 @@ export * from './tool-html-page-builder';
 export * from './feedback';
 export * from './daily-streak';
 export * from './cabinet';
+export * from './canvas';
 export * from './canvas-node';
 export * from './canvas-edge';
 export * from './webmaster';

package/constants/tool-video/enums/index.ts

@@ -7,5 +7,3 @@ export * from './veo-person-allow.enum';
 export * from './veo-job-params-type.enum';
 export * from './video-resolution.enum';
 export * from './video-pricing-rule-type.enum';
-export * from './video-generation-model-limitation.enum';
-export * from './video-publish-moderation-status.enum';

package/models/canvas-edge.schema.ts

@@ -4,8 +4,7 @@ import { INPUT_OUTPUT_TYPE } from '../constants';
 export const CanvasEdgeSchema = z.object({
     sourceId: z.string().uuid(),
     targetId: z.string().uuid(),
-    sourceHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
-    targetHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+    handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/models/canvas-node-definition.schema.ts

@@ -10,8 +10,6 @@ import {
     VideoEditorConfigSchema,
     VideoConfigSchema,
 } from './tools';
-import { AiModelWithUnlockedBySchema } from './ai-model.schema';
-import { AiVendorSchema } from './ai-vendor.schema';
 
 const createCanvasNodeDefinitionNoConfigSchema = (nodeType: CANVAS_NODE_TYPE) =>
     z.object({
@@ -20,19 +18,7 @@ const createCanvasNodeDefinitionNoConfigSchema = (nodeType: CANVAS_NODE_TYPE) =>
         config: z.null(),
     });
 
-export const CanvasTextGenerationConfigSchema = z.array(
-    AiVendorSchema.extend({
-        models: z.array(AiModelWithUnlockedBySchema),
-    }),
-);
-export type CanvasTextGenerationConfig = z.infer<typeof CanvasTextGenerationConfigSchema>;
-
 export const CanvasNodeDefinitionToolConfigSchema = z.discriminatedUnion('nodeType', [
-    z.object({
-        nodeType: z.literal(CANVAS_NODE_TYPE.textGen),
-        toolType: z.null(),
-        config: CanvasTextGenerationConfigSchema,
-    }),
     z.object({
         nodeType: z.literal(CANVAS_NODE_TYPE.imageGen),
         toolType: z.literal(TOOL_CONTENT_TYPE.IMAGE_GENERATION),
@@ -68,6 +54,7 @@ export const CanvasNodeDefinitionToolConfigSchema = z.discriminatedUnion('nodeTy
         toolType: z.literal(TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER),
         config: HtmlPageBuilderConfigSchema,
     }),
+    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.textGen),
     createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.textBlock),
     createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.imageBlock),
     createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.videoBlock),
@@ -77,7 +64,6 @@ export const CanvasNodeDefinitionToolConfigSchema = z.discriminatedUnion('nodeTy
     createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.motionControl),
     createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.varGen),
     createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.varBlock),
-    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.audioBlock),
 ]);
 export type CanvasNodeDefinitionToolConfig = z.infer<typeof CanvasNodeDefinitionToolConfigSchema>;