@purpleschool/gptbot 0.12.59 → 0.12.61

package/models/canvas-node.schema.ts

@@ -0,0 +1,272 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE, NODE_RUN_STATUS } from '../constants';
+
+const strictObject = <T extends z.ZodRawShape>(shape: T): z.ZodObject<T, 'strict'> =>
+    z.object(shape).strict();
+
+export const CanvasNodePositionSchema = z.object({
+    topLeft: z.object({
+        x: z.number(),
+        y: z.number(),
+    }),
+    bottomRight: z.object({
+        x: z.number(),
+        y: z.number(),
+    }),
+});
+export type CanvasNodePosition = z.infer<typeof CanvasNodePositionSchema>;
+
+export const TextGenParamsSchema = strictObject({
+    prompt: z.string(),
+    model: z.string(),
+});
+export type TextGenParams = z.infer<typeof TextGenParamsSchema>;
+
+export const ImageGenParamsSchema = strictObject({
+    prompt: z.string(),
+    model: z.string(),
+    aspectRatio: z.string(),
+    resolution: z.string().optional(),
+});
+export type ImageGenParams = z.infer<typeof ImageGenParamsSchema>;
+
+export const VideoGenParamsSchema = strictObject({
+    prompt: z.string(),
+    duration: z.string(),
+    resolution: z.string(),
+});
+export type VideoGenParams = z.infer<typeof VideoGenParamsSchema>;
+
+export const AudioGenParamsSchema = strictObject({
+    mode: z.union([z.literal('tts'), z.literal('stt')]),
+    prompt: z.string(),
+    voice: z.string(),
+    model: z.string(),
+    stability: z.number(),
+    similarityBoost: z.number(),
+    audioFileUrl: z.string(),
+});
+export type AudioGenParams = z.infer<typeof AudioGenParamsSchema>;
+
+export const ColorPaletteParamsSchema = strictObject({
+    prompt: z.string(),
+});
+export type ColorPaletteParams = z.infer<typeof ColorPaletteParamsSchema>;
+
+export const MotionControlParamsSchema = strictObject({
+    prompt: z.string(),
+    imageUrl: z.string(),
+    videoUrl: z.string(),
+    characterOrientation: z.union([z.literal('image'), z.literal('video')]),
+    mode: z.union([z.literal('720p'), z.literal('1080p')]),
+});
+export type MotionControlParams = z.infer<typeof MotionControlParamsSchema>;
+
+export const VarGenParamsSchema = strictObject({
+    prompt: z.string(),
+    model: z.string(),
+    vars: z.array(
+        strictObject({
+            key: z.string(),
+            description: z.string(),
+        }),
+    ),
+});
+export type VarGenParams = z.infer<typeof VarGenParamsSchema>;
+
+export const HtmlGenParamsSchema = strictObject({
+    prompt: z.string(),
+    model: z.string(),
+});
+export type HtmlGenParams = z.infer<typeof HtmlGenParamsSchema>;
+
+export const TextBlockParamsSchema = strictObject({
+    content: z.string(),
+});
+export type TextBlockParams = z.infer<typeof TextBlockParamsSchema>;
+
+export const ImageBlockParamsSchema = strictObject({
+    url: z.string(),
+});
+export type ImageBlockParams = z.infer<typeof ImageBlockParamsSchema>;
+
+export const VideoBlockParamsSchema = strictObject({
+    url: z.string(),
+});
+export type VideoBlockParams = z.infer<typeof VideoBlockParamsSchema>;
+
+export const FileBlockParamsSchema = strictObject({
+    filename: z.string(),
+    content: z.string(),
+});
+export type FileBlockParams = z.infer<typeof FileBlockParamsSchema>;
+
+export const NoteParamsSchema = strictObject({
+    content: z.string(),
+});
+export type NoteParams = z.infer<typeof NoteParamsSchema>;
+
+export const VarBlockParamsSchema = strictObject({
+    name: z.string(),
+    value: z.string(),
+});
+export type VarBlockParams = z.infer<typeof VarBlockParamsSchema>;
+
+export const TextGenOutputSchema = strictObject({
+    result: z.string(),
+});
+export type TextGenOutput = z.infer<typeof TextGenOutputSchema>;
+
+export const ImageGenOutputSchema = strictObject({
+    resultUrl: z.string(),
+});
+export type ImageGenOutput = z.infer<typeof ImageGenOutputSchema>;
+
+export const VideoGenOutputSchema = strictObject({
+    resultUrl: z.string(),
+});
+export type VideoGenOutput = z.infer<typeof VideoGenOutputSchema>;
+
+export const AudioGenTTSOutputSchema = strictObject({
+    resultUrl: z.string(),
+});
+export type AudioGenTTSOutput = z.infer<typeof AudioGenTTSOutputSchema>;
+
+export const AudioGenSTTOutputSchema = strictObject({
+    transcript: z.string(),
+});
+export type AudioGenSTTOutput = z.infer<typeof AudioGenSTTOutputSchema>;
+
+export const ColorPaletteOutputSchema = strictObject({
+    paletteName: z.string(),
+    colors: z.array(
+        strictObject({
+            hex: z.string(),
+            name: z.string(),
+            usage: z.string(),
+        }),
+    ),
+});
+export type ColorPaletteOutput = z.infer<typeof ColorPaletteOutputSchema>;
+
+export const MotionControlOutputSchema = strictObject({
+    resultUrl: z.string(),
+});
+export type MotionControlOutput = z.infer<typeof MotionControlOutputSchema>;
+
+export const VarGenOutputSchema = strictObject({
+    variables: z.record(z.string()),
+});
+export type VarGenOutput = z.infer<typeof VarGenOutputSchema>;
+
+export const HtmlGenOutputSchema = strictObject({
+    html: z.string(),
+});
+export type HtmlGenOutput = z.infer<typeof HtmlGenOutputSchema>;
+
+export const CanvasNodeParamsSchema = z.union([
+    TextGenParamsSchema,
+    ImageGenParamsSchema,
+    VideoGenParamsSchema,
+    AudioGenParamsSchema,
+    ColorPaletteParamsSchema,
+    MotionControlParamsSchema,
+    VarGenParamsSchema,
+    HtmlGenParamsSchema,
+    TextBlockParamsSchema,
+    ImageBlockParamsSchema,
+    VideoBlockParamsSchema,
+    FileBlockParamsSchema,
+    NoteParamsSchema,
+    VarBlockParamsSchema,
+]);
+export type CanvasNodeParams = z.infer<typeof CanvasNodeParamsSchema>;
+
+export const CanvasNodeParamsSchemaByType = {
+    [CANVAS_NODE_TYPE.textGen]: TextGenParamsSchema,
+    [CANVAS_NODE_TYPE.imageGen]: ImageGenParamsSchema,
+    [CANVAS_NODE_TYPE.imageEdit]: ImageGenParamsSchema,
+    [CANVAS_NODE_TYPE.videoGen]: VideoGenParamsSchema,
+    [CANVAS_NODE_TYPE.videoEdit]: VideoGenParamsSchema,
+    [CANVAS_NODE_TYPE.ttsGen]: AudioGenParamsSchema,
+    [CANVAS_NODE_TYPE.sttGen]: AudioGenParamsSchema,
+    [CANVAS_NODE_TYPE.textBlock]: TextBlockParamsSchema,
+    [CANVAS_NODE_TYPE.imageBlock]: ImageBlockParamsSchema,
+    [CANVAS_NODE_TYPE.videoBlock]: VideoBlockParamsSchema,
+    [CANVAS_NODE_TYPE.fileBlock]: FileBlockParamsSchema,
+    [CANVAS_NODE_TYPE.note]: NoteParamsSchema,
+    [CANVAS_NODE_TYPE.colorPalette]: ColorPaletteParamsSchema,
+    [CANVAS_NODE_TYPE.motionControl]: MotionControlParamsSchema,
+    [CANVAS_NODE_TYPE.varGen]: VarGenParamsSchema,
+    [CANVAS_NODE_TYPE.varBlock]: VarBlockParamsSchema,
+    [CANVAS_NODE_TYPE.htmlGen]: HtmlGenParamsSchema,
+} as const;
+
+export const CanvasNodeOutputSchema = z.union([
+    TextGenOutputSchema,
+    ImageGenOutputSchema,
+    VideoGenOutputSchema,
+    AudioGenTTSOutputSchema,
+    AudioGenSTTOutputSchema,
+    ColorPaletteOutputSchema,
+    MotionControlOutputSchema,
+    VarGenOutputSchema,
+    HtmlGenOutputSchema,
+]);
+export type CanvasNodeOutput = z.infer<typeof CanvasNodeOutputSchema>;
+
+export const CanvasNodeErrorSchema = z.object({
+    code: z.string(),
+    message: z.string(),
+    details: z.record(z.unknown()).optional(),
+    retryable: z.boolean().optional(),
+});
+export type CanvasNodeError = z.infer<typeof CanvasNodeErrorSchema>;
+
+export type CanvasNodeParamsByType = {
+    [CANVAS_NODE_TYPE.textGen]: TextGenParams;
+    [CANVAS_NODE_TYPE.imageGen]: ImageGenParams;
+    [CANVAS_NODE_TYPE.imageEdit]: ImageGenParams;
+    [CANVAS_NODE_TYPE.videoGen]: VideoGenParams;
+    [CANVAS_NODE_TYPE.videoEdit]: VideoGenParams;
+    [CANVAS_NODE_TYPE.ttsGen]: AudioGenParams;
+    [CANVAS_NODE_TYPE.sttGen]: AudioGenParams;
+    [CANVAS_NODE_TYPE.textBlock]: TextBlockParams;
+    [CANVAS_NODE_TYPE.imageBlock]: ImageBlockParams;
+    [CANVAS_NODE_TYPE.videoBlock]: VideoBlockParams;
+    [CANVAS_NODE_TYPE.fileBlock]: FileBlockParams;
+    [CANVAS_NODE_TYPE.note]: NoteParams;
+    [CANVAS_NODE_TYPE.colorPalette]: ColorPaletteParams;
+    [CANVAS_NODE_TYPE.motionControl]: MotionControlParams;
+    [CANVAS_NODE_TYPE.varGen]: VarGenParams;
+    [CANVAS_NODE_TYPE.varBlock]: VarBlockParams;
+    [CANVAS_NODE_TYPE.htmlGen]: HtmlGenParams;
+};
+
+export type CanvasNodeOutputByType = {
+    [CANVAS_NODE_TYPE.textGen]: TextGenOutput;
+    [CANVAS_NODE_TYPE.imageGen]: ImageGenOutput;
+    [CANVAS_NODE_TYPE.imageEdit]: ImageGenOutput;
+    [CANVAS_NODE_TYPE.videoGen]: VideoGenOutput;
+    [CANVAS_NODE_TYPE.videoEdit]: VideoGenOutput;
+    [CANVAS_NODE_TYPE.ttsGen]: AudioGenTTSOutput;
+    [CANVAS_NODE_TYPE.sttGen]: AudioGenSTTOutput;
+    [CANVAS_NODE_TYPE.colorPalette]: ColorPaletteOutput;
+    [CANVAS_NODE_TYPE.motionControl]: MotionControlOutput;
+    [CANVAS_NODE_TYPE.varGen]: VarGenOutput;
+    [CANVAS_NODE_TYPE.htmlGen]: HtmlGenOutput;
+};
+
+export const CanvasNodeSchema = z.object({
+    uuid: z.string().uuid(),
+    canvasId: z.string().uuid(),
+    nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
+    position: CanvasNodePositionSchema,
+    status: z.nativeEnum(NODE_RUN_STATUS),
+    toolJobId: z.string().uuid().nullable(),
+    params: CanvasNodeParamsSchema.nullable(),
+    output: CanvasNodeOutputSchema.nullable(),
+    error: CanvasNodeErrorSchema.nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/index.ts

@@ -4,6 +4,8 @@ export * from './ai-model-formatted.schema';
 export * from './ai-model.schema';
 export * from './ai-vendor.schema';
 export * from './canvas.schema';
+export * from './canvas-node.schema';
+export * from './canvas-edge.schema';
 export * from './category.schema';
 export * from './chat-with-messages.schema';
 export * from './chat.schema';

package/models/webmaster.schema.ts

@@ -8,6 +8,7 @@ export const WebmasterSchema = z.object({
     organizationType: z.nativeEnum(ORGANIZATION_TYPE),
     tin: z.string().regex(/^\d{10}$|^\d{12}$/, 'ИНН должен быть длинной в 10 или 12 цифр'),
     alias: z.string(),
+    isPremium: z.boolean(),
 
     createdAt: z.date(),
     updatedAt: z.date(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.12.59",
+  "version": "0.12.61",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",