@purpleschool/gptbot 0.12.98-stage-2 → 0.12.98

package/constants/tool-video/enums/video-publish-moderation-status.enum.ts

@@ -0,0 +1,5 @@
+export enum VIDEO_PUBLISH_MODERATION_STATUS {
+    NOT_CHECKED = 'NOT_CHECKED',
+    PASSED = 'PASSED',
+    FAILED = 'FAILED',
+}

package/models/canvas-edge.schema.ts

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

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

@@ -10,6 +10,8 @@ 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({
@@ -18,7 +20,19 @@ 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),
@@ -54,7 +68,6 @@ 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),
@@ -64,6 +77,7 @@ 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>;
 

package/models/canvas-node.schema.ts

@@ -4,6 +4,13 @@ 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 CanvasFileRefSchema = strictObject({
+    fileId: z.string().uuid(),
+    url: z.string().url(),
+    text: z.string().nullable(),
+});
+export type CanvasFileRef = z.infer<typeof CanvasFileRefSchema>;
+
 export const CanvasNodePositionSchema = z.object({
     topLeft: z.object({
         x: z.number(),
@@ -16,15 +23,18 @@ export const CanvasNodePositionSchema = z.object({
 });
 export type CanvasNodePosition = z.infer<typeof CanvasNodePositionSchema>;
 
+// PARAMS SHEMA
 export const TextGenParamsSchema = strictObject({
     prompt: z.string(),
-    model: z.string(),
+    modelId: z.string(),
+    modelName: z.string(),
 });
 export type TextGenParams = z.infer<typeof TextGenParamsSchema>;
 
 export const ImageGenParamsSchema = strictObject({
     prompt: z.string(),
-    model: z.string(),
+    modelId: z.string(),
+    modelName: z.string(),
     aspectRatio: z.string(),
     resolution: z.string().optional(),
 });
@@ -32,8 +42,9 @@ export type ImageGenParams = z.infer<typeof ImageGenParamsSchema>;
 
 export const VideoGenParamsSchema = strictObject({
     prompt: z.string(),
-    model: z.string(),
-    duration: z.string().optional(),
+    modelId: z.string(),
+    modelName: z.string(),
+    duration: z.string(),
     aspectRatio: z.string().optional(),
     resolution: z.string().optional(),
 });
@@ -43,7 +54,8 @@ export const AudioGenParamsSchema = z.discriminatedUnion('mode', [
     strictObject({
         mode: z.literal('tts'),
         prompt: z.string(),
-        model: z.string(),
+        modelId: z.string(),
+        modelName: z.string(),
         voice: z.string(),
         stability: z.number(),
         similarityBoost: z.number(),
@@ -51,14 +63,14 @@ export const AudioGenParamsSchema = z.discriminatedUnion('mode', [
     strictObject({
         mode: z.literal('stt'),
         prompt: z.string(),
-        model: z.string(),
-        audioFileId: z.string().uuid(),
+        modelId: z.string(),
+        modelName: z.string(),
     }),
 ]);
 export type AudioGenParams = z.infer<typeof AudioGenParamsSchema>;
 
 export const ColorPaletteParamsSchema = strictObject({
-    prompt: z.string(),
+    prompt: z.string().optional(),
 });
 export type ColorPaletteParams = z.infer<typeof ColorPaletteParamsSchema>;
 
@@ -73,71 +85,39 @@ 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(),
-        }),
-    ),
+    modelId: z.string(),
+    modelName: z.string(),
 });
 export type VarGenParams = z.infer<typeof VarGenParamsSchema>;
 
 export const HtmlGenParamsSchema = strictObject({
     prompt: z.string(),
-    model: z.string(),
+    modelId: z.string(),
+    modelName: 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 NoParamsSchema = z.null();
+export type NoParams = z.infer<typeof NoParamsSchema>;
 
+// OUTPUT SHEMA
 export const TextGenOutputSchema = strictObject({
     result: z.string(),
 });
 export type TextGenOutput = z.infer<typeof TextGenOutputSchema>;
 
 export const ImageGenOutputSchema = strictObject({
-    resultUrl: z.string(),
+    images: z.array(CanvasFileRefSchema).min(1),
 });
 export type ImageGenOutput = z.infer<typeof ImageGenOutputSchema>;
 
 export const VideoGenOutputSchema = strictObject({
-    resultUrl: z.string(),
+    video: CanvasFileRefSchema,
 });
 export type VideoGenOutput = z.infer<typeof VideoGenOutputSchema>;
 
 export const AudioGenTTSOutputSchema = strictObject({
-    resultUrl: z.string(),
+    audio: CanvasFileRefSchema,
 });
 export type AudioGenTTSOutput = z.infer<typeof AudioGenTTSOutputSchema>;
 
@@ -147,14 +127,7 @@ export const AudioGenSTTOutputSchema = strictObject({
 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(),
-        }),
-    ),
+    colors: z.array(z.string().regex(/^#[0-9A-Fa-f]{6}$/)).max(7),
 });
 export type ColorPaletteOutput = z.infer<typeof ColorPaletteOutputSchema>;
 
@@ -169,27 +142,46 @@ export const VarGenOutputSchema = strictObject({
 export type VarGenOutput = z.infer<typeof VarGenOutputSchema>;
 
 export const HtmlGenOutputSchema = strictObject({
+    sessionId: z.string(),
     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 TextBlockOutputSchema = strictObject({
+    text: z.string(),
+});
+export type TextBlockOutput = z.infer<typeof TextBlockOutputSchema>;
+
+export const ImageBlockOutputSchema = strictObject({
+    image: CanvasFileRefSchema,
+});
+export type ImageBlockOutput = z.infer<typeof ImageBlockOutputSchema>;
+
+export const VideoBlockOutputSchema = strictObject({
+    video: CanvasFileRefSchema,
+});
+export type VideoBlockOutput = z.infer<typeof VideoBlockOutputSchema>;
+
+export const FileBlockOutputSchema = strictObject({
+    file: CanvasFileRefSchema,
+});
+export type FileBlockOutput = z.infer<typeof FileBlockOutputSchema>;
+
+export const NoteOutputSchema = strictObject({
+    content: z.string(),
+});
+export type NoteOutput = z.infer<typeof NoteOutputSchema>;
+
+export const VarBlockOutputSchema = strictObject({
+    name: z.string(),
+    value: z.string(),
+});
+export type VarBlockOutput = z.infer<typeof VarBlockOutputSchema>;
+
+export const AudioBlockOutputSchema = strictObject({
+    audio: CanvasFileRefSchema.nullable().optional(),
+});
+export type AudioBlockOutput = z.infer<typeof AudioBlockOutputSchema>;
 
 export const CanvasNodeParamsSchemaByType = {
     [CANVAS_NODE_TYPE.textGen]: TextGenParamsSchema,
@@ -199,30 +191,39 @@ export const CanvasNodeParamsSchemaByType = {
     [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.textBlock]: NoParamsSchema,
+    [CANVAS_NODE_TYPE.imageBlock]: NoParamsSchema,
+    [CANVAS_NODE_TYPE.videoBlock]: NoParamsSchema,
+    [CANVAS_NODE_TYPE.fileBlock]: NoParamsSchema,
+    [CANVAS_NODE_TYPE.note]: NoParamsSchema,
     [CANVAS_NODE_TYPE.colorPalette]: ColorPaletteParamsSchema,
     [CANVAS_NODE_TYPE.motionControl]: MotionControlParamsSchema,
     [CANVAS_NODE_TYPE.varGen]: VarGenParamsSchema,
-    [CANVAS_NODE_TYPE.varBlock]: VarBlockParamsSchema,
+    [CANVAS_NODE_TYPE.varBlock]: NoParamsSchema,
     [CANVAS_NODE_TYPE.htmlGen]: HtmlGenParamsSchema,
+    [CANVAS_NODE_TYPE.audioBlock]: NoParamsSchema,
 } 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 CanvasNodeOutputSchemaByType = {
+    [CANVAS_NODE_TYPE.textGen]: TextGenOutputSchema,
+    [CANVAS_NODE_TYPE.imageGen]: ImageGenOutputSchema,
+    [CANVAS_NODE_TYPE.imageEdit]: ImageGenOutputSchema,
+    [CANVAS_NODE_TYPE.videoGen]: VideoGenOutputSchema,
+    [CANVAS_NODE_TYPE.videoEdit]: VideoGenOutputSchema,
+    [CANVAS_NODE_TYPE.ttsGen]: AudioGenTTSOutputSchema,
+    [CANVAS_NODE_TYPE.sttGen]: AudioGenSTTOutputSchema,
+    [CANVAS_NODE_TYPE.textBlock]: TextBlockOutputSchema,
+    [CANVAS_NODE_TYPE.imageBlock]: ImageBlockOutputSchema,
+    [CANVAS_NODE_TYPE.videoBlock]: VideoBlockOutputSchema,
+    [CANVAS_NODE_TYPE.fileBlock]: FileBlockOutputSchema,
+    [CANVAS_NODE_TYPE.note]: NoteOutputSchema,
+    [CANVAS_NODE_TYPE.colorPalette]: ColorPaletteOutputSchema,
+    [CANVAS_NODE_TYPE.motionControl]: MotionControlOutputSchema,
+    [CANVAS_NODE_TYPE.varGen]: VarGenOutputSchema,
+    [CANVAS_NODE_TYPE.varBlock]: VarBlockOutputSchema,
+    [CANVAS_NODE_TYPE.htmlGen]: HtmlGenOutputSchema,
+    [CANVAS_NODE_TYPE.audioBlock]: AudioBlockOutputSchema,
+} as const;
 
 export const CanvasNodeErrorSchema = z.object({
     code: z.string(),
@@ -240,17 +241,19 @@ export type CanvasNodeParamsByType = {
     [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.textBlock]: NoParams;
+    [CANVAS_NODE_TYPE.imageBlock]: NoParams;
+    [CANVAS_NODE_TYPE.videoBlock]: NoParams;
+    [CANVAS_NODE_TYPE.fileBlock]: NoParams;
+    [CANVAS_NODE_TYPE.note]: NoParams;
     [CANVAS_NODE_TYPE.colorPalette]: ColorPaletteParams;
     [CANVAS_NODE_TYPE.motionControl]: MotionControlParams;
     [CANVAS_NODE_TYPE.varGen]: VarGenParams;
-    [CANVAS_NODE_TYPE.varBlock]: VarBlockParams;
+    [CANVAS_NODE_TYPE.varBlock]: NoParams;
     [CANVAS_NODE_TYPE.htmlGen]: HtmlGenParams;
+    [CANVAS_NODE_TYPE.audioBlock]: NoParams;
 };
+export type CanvasNodeParams = CanvasNodeParamsByType[keyof CanvasNodeParamsByType];
 
 export type CanvasNodeOutputByType = {
     [CANVAS_NODE_TYPE.textGen]: TextGenOutput;
@@ -260,22 +263,170 @@ export type CanvasNodeOutputByType = {
     [CANVAS_NODE_TYPE.videoEdit]: VideoGenOutput;
     [CANVAS_NODE_TYPE.ttsGen]: AudioGenTTSOutput;
     [CANVAS_NODE_TYPE.sttGen]: AudioGenSTTOutput;
+    [CANVAS_NODE_TYPE.textBlock]: TextBlockOutput;
+    [CANVAS_NODE_TYPE.imageBlock]: ImageBlockOutput;
+    [CANVAS_NODE_TYPE.videoBlock]: VideoBlockOutput;
+    [CANVAS_NODE_TYPE.fileBlock]: FileBlockOutput;
+    [CANVAS_NODE_TYPE.note]: NoteOutput;
     [CANVAS_NODE_TYPE.colorPalette]: ColorPaletteOutput;
     [CANVAS_NODE_TYPE.motionControl]: MotionControlOutput;
     [CANVAS_NODE_TYPE.varGen]: VarGenOutput;
+    [CANVAS_NODE_TYPE.varBlock]: VarBlockOutput;
     [CANVAS_NODE_TYPE.htmlGen]: HtmlGenOutput;
+    [CANVAS_NODE_TYPE.audioBlock]: AudioBlockOutput;
+};
+export type CanvasNodeOutput = CanvasNodeOutputByType[keyof CanvasNodeOutputByType];
+
+export const validateCanvasNodeParamsByType = (
+    nodeDefinitionId: CANVAS_NODE_TYPE,
+    params: unknown,
+    ctx: z.RefinementCtx,
+): void => {
+    if (params === null || params === undefined) {
+        return;
+    }
+
+    const schema = CanvasNodeParamsSchemaByType[nodeDefinitionId];
+    const result = schema.safeParse(params);
+    if (result.success) {
+        return;
+    }
+
+    for (const issue of result.error.issues) {
+        ctx.addIssue({
+            ...issue,
+            path: ['params', ...issue.path],
+        });
+    }
+};
+
+export const validateCanvasNodeOutputByType = (
+    nodeDefinitionId: CANVAS_NODE_TYPE,
+    output: unknown,
+    ctx: z.RefinementCtx,
+): void => {
+    if (output === null || output === undefined) {
+        return;
+    }
+
+    const schema = CanvasNodeOutputSchemaByType[nodeDefinitionId];
+    const result = schema.safeParse(output);
+    if (result.success) {
+        return;
+    }
+
+    for (const issue of result.error.issues) {
+        ctx.addIssue({
+            ...issue,
+            path: ['output', ...issue.path],
+        });
+    }
 };
 
-export const CanvasNodeSchema = z.object({
+export const CanvasNodeBaseSchema = 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(),
+    params: z.unknown().nullable(),
+    output: z.unknown().nullable(),
     error: CanvasNodeErrorSchema.nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });
+
+export const CanvasNodeSchema = z.discriminatedUnion('nodeDefinitionId', [
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.textGen),
+        params: TextGenParamsSchema.nullable(),
+        output: TextGenOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.imageGen),
+        params: ImageGenParamsSchema.nullable(),
+        output: ImageGenOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.imageEdit),
+        params: ImageGenParamsSchema.nullable(),
+        output: ImageGenOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.videoGen),
+        params: VideoGenParamsSchema.nullable(),
+        output: VideoGenOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.videoEdit),
+        params: VideoGenParamsSchema.nullable(),
+        output: VideoGenOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.ttsGen),
+        params: AudioGenParamsSchema.nullable(),
+        output: AudioGenTTSOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.sttGen),
+        params: AudioGenParamsSchema.nullable(),
+        output: AudioGenSTTOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.textBlock),
+        params: NoParamsSchema,
+        output: TextBlockOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.imageBlock),
+        params: NoParamsSchema,
+        output: ImageBlockOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.videoBlock),
+        params: NoParamsSchema,
+        output: VideoBlockOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.fileBlock),
+        params: NoParamsSchema,
+        output: FileBlockOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.note),
+        params: NoParamsSchema,
+        output: NoteOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.colorPalette),
+        params: ColorPaletteParamsSchema.nullable(),
+        output: ColorPaletteOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.motionControl),
+        params: MotionControlParamsSchema.nullable(),
+        output: MotionControlOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.varGen),
+        params: VarGenParamsSchema.nullable(),
+        output: VarGenOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.varBlock),
+        params: NoParamsSchema,
+        output: VarBlockOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.htmlGen),
+        params: HtmlGenParamsSchema.nullable(),
+        output: HtmlGenOutputSchema.nullable(),
+    }),
+    CanvasNodeBaseSchema.extend({
+        nodeDefinitionId: z.literal(CANVAS_NODE_TYPE.audioBlock),
+        params: NoParamsSchema,
+        output: AudioBlockOutputSchema.nullable(),
+    }),
+]);
+export type CanvasNode = z.infer<typeof CanvasNodeSchema>;

package/models/canvas-template.schema.ts

@@ -1,18 +1,23 @@
 import { z } from 'zod';
 import { INPUT_OUTPUT_TYPE, CANVAS_NODE_TYPE } from '../constants';
-import { CanvasNodeParamsSchema, CanvasNodePositionSchema } from './canvas-node.schema';
+import { CanvasNodePositionSchema, validateCanvasNodeParamsByType } from './canvas-node.schema';
 
-const CanvasTemplateGraphNodeSchema = z.object({
-    uuid: z.string().trim().min(1),
-    nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
-    position: CanvasNodePositionSchema,
-    params: CanvasNodeParamsSchema.nullable().optional(),
-});
+const CanvasTemplateGraphNodeSchema = z
+    .object({
+        uuid: z.string().trim().min(1),
+        nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
+        position: CanvasNodePositionSchema,
+        params: z.unknown().nullable().optional(),
+    })
+    .superRefine((node, ctx) => {
+        validateCanvasNodeParamsByType(node.nodeDefinitionId, node.params, ctx);
+    });
 
 const CanvasTemplateGraphEdgeSchema = z.object({
     sourceId: z.string().trim().min(1),
     targetId: z.string().trim().min(1),
-    handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+    sourceHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+    targetHandle: z.nativeEnum(INPUT_OUTPUT_TYPE),
 });
 
 export const CanvasTemplateGraphSchema = z
@@ -55,14 +60,33 @@ export const CanvasTemplateGraphSchema = z
 
 export type CanvasTemplateGraph = z.infer<typeof CanvasTemplateGraphSchema>;
 
+export const CanvasTemplateTagSchema = z.object({
+    icons: z.object({
+        svg: z.string(),
+        png: z.string(),
+    }),
+    alias: z.string().trim().min(1),
+    title: z.string().trim().min(1),
+});
+export type CanvasTemplateTag = z.infer<typeof CanvasTemplateTagSchema>;
+
 export const CanvasTemplateSchema = z.object({
     uuid: z.string().uuid(),
     name: z.string(),
     description: z.string().nullable(),
-    userId: z.string().uuid().nullable(),
+    isPopular: z.boolean(),
     previewImageUrl: z.string().url().nullable(),
-    tags: z.array(z.string()),
+    tags: z.array(CanvasTemplateTagSchema),
     graph: CanvasTemplateGraphSchema,
     createdAt: z.date(),
     updatedAt: z.date(),
 });
+
+export const GeneratedCanvasTemplateSchema = z.object({
+    name: z.string().trim().min(1),
+    description: z.string().trim().min(1),
+    previewImageUrl: z.string().url().nullable(),
+    tags: z.array(CanvasTemplateTagSchema),
+    graph: CanvasTemplateGraphSchema,
+});
+export type GeneratedCanvasTemplate = z.infer<typeof GeneratedCanvasTemplateSchema>;

package/models/canvas.schema.ts

@@ -1,11 +1,9 @@
 import { z } from 'zod';
-import { CANVAS_STATUS } from '../constants';
 
 export const CanvasSchema = z.object({
     uuid: z.string().uuid(),
     name: z.string(),
     userId: z.string().uuid(),
-    status: z.nativeEnum(CANVAS_STATUS),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/models/index.ts

@@ -50,6 +50,8 @@ export * from './tool-group.schema';
 export * from './tool.schema';
 export * from './unlocked-by-subscription.schema';
 export * from './unregistered-user.schema';
+export * from './update-post.schema';
+export * from './update-post-translation.schema';
 export * from './user-task.schema';
 export * from './user-to-product.schema';
 export * from './user-to-subscription.schema';

package/models/post.schema.ts

@@ -5,7 +5,7 @@ export const PostSchema = z.object({
     uuid: z.string().uuid(),
     title: z.string(),
     alias: z.string(),
-    image: z.string(),
+    image: z.nullable(z.string()),
     content: z.string(),
     author: z.string(),
     contentPreview: z.nullable(z.string()),

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

@@ -1,2 +1,3 @@
 export * from './marketplace-card-config.schema';
+export * from './marketplace-card-description-generation.schema';
 export * from './marketplace-card-job.schema';

package/models/tools/marketplace-card/marketplace-card-description-generation.schema.ts

@@ -0,0 +1,17 @@
+import { TOOL_JOB_STATUS } from '../../../constants';
+import { z } from 'zod';
+
+export const MarketplaceCardDescriptionGenerationSchema = z.object({
+    uuid: z.string().uuid(),
+    status: z.nativeEnum(TOOL_JOB_STATUS),
+    title: z.string().nullable(),
+    subtitle: z.string().nullable(),
+    advantages: z.array(z.string()),
+    tags: z.array(z.string()),
+    backgroundDescription: z.string().nullable(),
+    price: z.number(),
+});
+
+export type MarketplaceCardDescriptionGeneration = z.infer<
+    typeof MarketplaceCardDescriptionGenerationSchema
+>;