@purpleschool/gptbot 0.12.62 → 0.12.64

package/api/controllers/http/canvas-node-definition.ts

@@ -0,0 +1,5 @@
+export const CANVAS_NODE_DEFINITION_PRIVATE_CONTROLLER = 'private/canvas-node-definitions';
+
+export const CANVAS_NODE_DEFINITION_ROUTES = {
+    GET: '',
+} as const;

package/api/controllers/http/canvas.ts

@@ -8,4 +8,5 @@ export const CANVAS_ROUTES = {
     SAVE: (uuid: string) => `${uuid}/save`,
     UPDATE: (uuid: string) => `${uuid}`,
     DELETE: (uuid: string) => `${uuid}`,
+    RUN: (uuid: string) => `${uuid}/run`,
 } as const;

package/api/controllers/http/index.ts

@@ -5,6 +5,7 @@ export * from './ai-vendor';
 export * from './auth';
 export * from './blog';
 export * from './canvas';
+export * from './canvas-node-definition';
 export * from './canvas-node';
 export * from './canvas-edge';
 export * from './category';

package/build/api/controllers/http/canvas-node-definition.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANVAS_NODE_DEFINITION_ROUTES = exports.CANVAS_NODE_DEFINITION_PRIVATE_CONTROLLER = void 0;
+exports.CANVAS_NODE_DEFINITION_PRIVATE_CONTROLLER = 'private/canvas-node-definitions';
+exports.CANVAS_NODE_DEFINITION_ROUTES = {
+    GET: '',
+};

package/build/api/controllers/http/canvas.js

@@ -10,4 +10,5 @@ exports.CANVAS_ROUTES = {
     SAVE: (uuid) => `${uuid}/save`,
     UPDATE: (uuid) => `${uuid}`,
     DELETE: (uuid) => `${uuid}`,
+    RUN: (uuid) => `${uuid}/run`,
 };

package/build/api/controllers/http/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./ai-vendor"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./blog"), exports);
 __exportStar(require("./canvas"), exports);
+__exportStar(require("./canvas-node-definition"), exports);
 __exportStar(require("./canvas-node"), exports);
 __exportStar(require("./canvas-edge"), exports);
 __exportStar(require("./category"), exports);

package/build/commands/canvas/find-canvases-by-user.query.js

@@ -8,6 +8,7 @@ var FindCanvasesByUserQuery;
     FindCanvasesByUserQuery.RequestSchema = zod_1.z.object({
         limit: zod_1.z.coerce.number().min(1).default(10),
         offset: zod_1.z.coerce.number().min(0).default(0),
+        name: zod_1.z.string().trim().optional(),
     });
     FindCanvasesByUserQuery.ResponseSchema = zod_1.z.object({
         data: zod_1.z.array(models_1.CanvasSchema),

package/build/commands/canvas/index.js

@@ -19,5 +19,6 @@ __exportStar(require("./delete-canvas.command"), exports);
 __exportStar(require("./find-canvas-by-uuid.query"), exports);
 __exportStar(require("./find-canvas-by-uuid-with-relations.query"), exports);
 __exportStar(require("./find-canvases-by-user.query"), exports);
+__exportStar(require("./run-canvas.command"), exports);
 __exportStar(require("./save-canvas.command"), exports);
 __exportStar(require("./update-canvas.command"), exports);

package/build/commands/canvas/run-canvas.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunCanvasCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+const save_canvas_command_1 = require("./save-canvas.command");
+var RunCanvasCommand;
+(function (RunCanvasCommand) {
+    RunCanvasCommand.RequestParamSchema = models_1.CanvasSchema.pick({
+        uuid: true,
+    });
+    RunCanvasCommand.RequestSchema = zod_1.z.object({
+        updatedAt: zod_1.z.preprocess((value) => (typeof value === 'string' ? new Date(value) : value), zod_1.z.date()),
+        nodes: zod_1.z.array(save_canvas_command_1.SaveCanvasCommand.CanvasNodePayloadSchema),
+        edges: zod_1.z.array(save_canvas_command_1.SaveCanvasCommand.CanvasEdgePayloadSchema),
+    });
+    RunCanvasCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.CanvasSchema.extend({
+            nodes: zod_1.z.array(models_1.CanvasNodeSchema),
+            edges: zod_1.z.array(models_1.CanvasEdgeSchema),
+        }),
+    });
+})(RunCanvasCommand || (exports.RunCanvasCommand = RunCanvasCommand = {}));

package/build/commands/canvas-node/find-canvas-node-definitions-with-configs.query.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindCanvasNodeDefinitionsWithConfigsQuery = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var FindCanvasNodeDefinitionsWithConfigsQuery;
+(function (FindCanvasNodeDefinitionsWithConfigsQuery) {
+    FindCanvasNodeDefinitionsWithConfigsQuery.ResponseSchema = zod_1.z.object({
+        data: models_1.CanvasNodeDefinitionsWithConfigsSchema,
+    });
+})(FindCanvasNodeDefinitionsWithConfigsQuery || (exports.FindCanvasNodeDefinitionsWithConfigsQuery = FindCanvasNodeDefinitionsWithConfigsQuery = {}));

package/build/commands/canvas-node/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./create-canvas-node.command"), exports);
 __exportStar(require("./delete-canvas-node.command"), exports);
 __exportStar(require("./find-canvas-node-by-uuid.query"), exports);
+__exportStar(require("./find-canvas-node-definitions-with-configs.query"), exports);
 __exportStar(require("./find-canvas-nodes-by-canvas.query"), exports);
 __exportStar(require("./update-canvas-node.command"), exports);

package/build/commands/team-account/find-team-accounts-by-name.command.js

@@ -6,10 +6,28 @@ const models_1 = require("../../models");
 const constants_1 = require("../../constants");
 var FindTeamAccountsByNameCommand;
 (function (FindTeamAccountsByNameCommand) {
+    const BooleanQuerySchema = zod_1.z
+        .union([zod_1.z.boolean(), zod_1.z.string().trim().toLowerCase()])
+        .transform((value, ctx) => {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (value === 'true') {
+            return true;
+        }
+        if (value === 'false') {
+            return false;
+        }
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'Expected boolean value: true or false',
+        });
+        return zod_1.z.NEVER;
+    });
     FindTeamAccountsByNameCommand.RequestSchema = zod_1.z.object({
         name: zod_1.z.string().trim().min(1).optional(),
         creatorEmail: zod_1.z.string().trim().min(1).optional(),
-        hasPaidSubscription: zod_1.z.boolean().optional(),
+        hasPaidSubscription: BooleanQuerySchema.optional(),
         limit: zod_1.z.coerce.number().int().min(1).max(100).default(20).optional(),
         offset: zod_1.z.coerce.number().int().min(0).default(0).optional(),
         sortBy: zod_1.z

package/build/constants/canvas/enums/canvas-status.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANVAS_STATUS = void 0;
+var CANVAS_STATUS;
+(function (CANVAS_STATUS) {
+    CANVAS_STATUS["IDLE"] = "IDLE";
+    CANVAS_STATUS["RUNNING"] = "RUNNING";
+    CANVAS_STATUS["FAILED"] = "FAILED";
+})(CANVAS_STATUS || (exports.CANVAS_STATUS = CANVAS_STATUS = {}));

package/build/constants/canvas/enums/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./canvas-status.enum"), exports);

package/build/constants/canvas/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enums"), exports);

package/build/constants/index.js

@@ -56,6 +56,7 @@ __exportStar(require("./tool-html-page-builder"), exports);
 __exportStar(require("./feedback"), exports);
 __exportStar(require("./daily-streak"), exports);
 __exportStar(require("./cabinet"), exports);
+__exportStar(require("./canvas"), exports);
 __exportStar(require("./canvas-node"), exports);
 __exportStar(require("./canvas-edge"), exports);
 __exportStar(require("./webmaster"), exports);

package/build/models/canvas-node-definition.schema.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasNodeDefinitionsWithConfigsSchema = exports.CanvasNodeDefinitionWithConfigSchema = exports.CanvasNodeDefinitionSchema = exports.CanvasNodeDefinitionToolConfigSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../constants");
+const icon_variants_schema_1 = require("./icon-variants.schema");
+const tools_1 = require("./tools");
+const createCanvasNodeDefinitionNoConfigSchema = (nodeType) => zod_1.z.object({
+    nodeType: zod_1.z.literal(nodeType),
+    toolType: zod_1.z.null(),
+    config: zod_1.z.null(),
+});
+exports.CanvasNodeDefinitionToolConfigSchema = zod_1.z.discriminatedUnion('nodeType', [
+    zod_1.z.object({
+        nodeType: zod_1.z.literal(constants_1.CANVAS_NODE_TYPE.imageGen),
+        toolType: zod_1.z.literal(constants_1.TOOL_CONTENT_TYPE.IMAGE_GENERATION),
+        config: tools_1.ImageGenerationConfigSchema,
+    }),
+    zod_1.z.object({
+        nodeType: zod_1.z.literal(constants_1.CANVAS_NODE_TYPE.imageEdit),
+        toolType: zod_1.z.literal(constants_1.TOOL_CONTENT_TYPE.IMAGE_EDITOR),
+        config: tools_1.ImageEditorConfigSchema,
+    }),
+    zod_1.z.object({
+        nodeType: zod_1.z.literal(constants_1.CANVAS_NODE_TYPE.ttsGen),
+        toolType: zod_1.z.literal(constants_1.TOOL_CONTENT_TYPE.TEXT_TO_SPEECH),
+        config: tools_1.TTSConfigSchema,
+    }),
+    zod_1.z.object({
+        nodeType: zod_1.z.literal(constants_1.CANVAS_NODE_TYPE.sttGen),
+        toolType: zod_1.z.literal(constants_1.TOOL_CONTENT_TYPE.SPEECH_TO_TEXT),
+        config: tools_1.STTConfigSchema,
+    }),
+    zod_1.z.object({
+        nodeType: zod_1.z.literal(constants_1.CANVAS_NODE_TYPE.videoGen),
+        toolType: zod_1.z.literal(constants_1.TOOL_CONTENT_TYPE.VIDEO),
+        config: tools_1.VideoConfigSchema,
+    }),
+    zod_1.z.object({
+        nodeType: zod_1.z.literal(constants_1.CANVAS_NODE_TYPE.videoEdit),
+        toolType: zod_1.z.literal(constants_1.TOOL_CONTENT_TYPE.VIDEO_EDITOR),
+        config: tools_1.VideoEditorConfigSchema,
+    }),
+    zod_1.z.object({
+        nodeType: zod_1.z.literal(constants_1.CANVAS_NODE_TYPE.htmlGen),
+        toolType: zod_1.z.literal(constants_1.TOOL_CONTENT_TYPE.HTML_PAGE_BUILDER),
+        config: tools_1.HtmlPageBuilderConfigSchema,
+    }),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.textGen),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.textBlock),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.imageBlock),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.videoBlock),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.fileBlock),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.note),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.colorPalette),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.motionControl),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.varGen),
+    createCanvasNodeDefinitionNoConfigSchema(constants_1.CANVAS_NODE_TYPE.varBlock),
+]);
+exports.CanvasNodeDefinitionSchema = zod_1.z.object({
+    type: zod_1.z.nativeEnum(constants_1.CANVAS_NODE_TYPE),
+    label: zod_1.z.string(),
+    icons: icon_variants_schema_1.IconVariantsSchema,
+    inputPoints: zod_1.z.array(zod_1.z.nativeEnum(constants_1.INPUT_OUTPUT_TYPE)),
+    outputPoints: zod_1.z.array(zod_1.z.nativeEnum(constants_1.INPUT_OUTPUT_TYPE)),
+    toolType: zod_1.z.nativeEnum(constants_1.TOOL_CONTENT_TYPE).nullable(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});
+exports.CanvasNodeDefinitionWithConfigSchema = zod_1.z.object({
+    nodeDefinition: exports.CanvasNodeDefinitionSchema,
+    config: exports.CanvasNodeDefinitionToolConfigSchema,
+});
+exports.CanvasNodeDefinitionsWithConfigsSchema = zod_1.z.record(zod_1.z.nativeEnum(constants_1.CANVAS_NODE_TYPE), exports.CanvasNodeDefinitionWithConfigSchema);

package/build/models/canvas-node.schema.js

@@ -26,18 +26,27 @@ exports.ImageGenParamsSchema = strictObject({
 });
 exports.VideoGenParamsSchema = strictObject({
     prompt: zod_1.z.string(),
-    duration: zod_1.z.string(),
-    resolution: zod_1.z.string(),
-});
-exports.AudioGenParamsSchema = strictObject({
-    mode: zod_1.z.union([zod_1.z.literal('tts'), zod_1.z.literal('stt')]),
-    prompt: zod_1.z.string(),
-    voice: zod_1.z.string(),
     model: zod_1.z.string(),
-    stability: zod_1.z.number(),
-    similarityBoost: zod_1.z.number(),
-    audioFileUrl: zod_1.z.string(),
+    duration: zod_1.z.string().optional(),
+    aspectRatio: zod_1.z.string().optional(),
+    resolution: zod_1.z.string().optional(),
 });
+exports.AudioGenParamsSchema = zod_1.z.discriminatedUnion('mode', [
+    strictObject({
+        mode: zod_1.z.literal('tts'),
+        prompt: zod_1.z.string(),
+        model: zod_1.z.string(),
+        voice: zod_1.z.string(),
+        stability: zod_1.z.number(),
+        similarityBoost: zod_1.z.number(),
+    }),
+    strictObject({
+        mode: zod_1.z.literal('stt'),
+        prompt: zod_1.z.string(),
+        model: zod_1.z.string(),
+        audioFileId: zod_1.z.string().uuid(),
+    }),
+]);
 exports.ColorPaletteParamsSchema = strictObject({
     prompt: zod_1.z.string(),
 });

package/build/models/canvas.schema.js

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CanvasSchema = void 0;
 const zod_1 = require("zod");
+const constants_1 = require("../constants");
 exports.CanvasSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     name: zod_1.z.string(),
     userId: zod_1.z.string().uuid(),
+    status: zod_1.z.nativeEnum(constants_1.CANVAS_STATUS),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });

package/build/models/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./ai-model-formatted.schema"), exports);
 __exportStar(require("./ai-model.schema"), exports);
 __exportStar(require("./ai-vendor.schema"), exports);
 __exportStar(require("./canvas.schema"), exports);
+__exportStar(require("./canvas-node-definition.schema"), exports);
 __exportStar(require("./canvas-node.schema"), exports);
 __exportStar(require("./canvas-edge.schema"), exports);
 __exportStar(require("./category.schema"), exports);

package/build/models/tools/image-editor/image-editor-model.schema.js

@@ -11,10 +11,13 @@ exports.ImageEditorModelParamsSchema = zod_1.z.object({
         acceptedTypes: zod_1.z.array(zod_1.z.string()),
     }),
     aspectRatio: zod_1.z
-        .record(zod_1.z.string(), zod_1.z.object({
-        width: zod_1.z.number(),
-        height: zod_1.z.number(),
-    }))
+        .record(zod_1.z.string(), zod_1.z.union([
+        zod_1.z.object({
+            width: zod_1.z.number(),
+            height: zod_1.z.number(),
+        }),
+        zod_1.z.string(),
+    ]))
         .optional(),
 });
 exports.ImageEditorModelPricingRuleConditionSchema = zod_1.z.object({

package/commands/canvas/find-canvases-by-user.query.ts

@@ -5,6 +5,7 @@ export namespace FindCanvasesByUserQuery {
     export const RequestSchema = z.object({
         limit: z.coerce.number().min(1).default(10),
         offset: z.coerce.number().min(0).default(0),
+        name: z.string().trim().optional(),
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/canvas/index.ts

@@ -3,5 +3,6 @@ export * from './delete-canvas.command';
 export * from './find-canvas-by-uuid.query';
 export * from './find-canvas-by-uuid-with-relations.query';
 export * from './find-canvases-by-user.query';
+export * from './run-canvas.command';
 export * from './save-canvas.command';
 export * from './update-canvas.command';

package/commands/canvas/run-canvas.command.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../models';
+import { SaveCanvasCommand } from './save-canvas.command';
+
+export namespace RunCanvasCommand {
+    export const RequestParamSchema = CanvasSchema.pick({
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        updatedAt: z.preprocess(
+            (value) => (typeof value === 'string' ? new Date(value) : value),
+            z.date(),
+        ),
+        nodes: z.array(SaveCanvasCommand.CanvasNodePayloadSchema),
+        edges: z.array(SaveCanvasCommand.CanvasEdgePayloadSchema),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasSchema.extend({
+            nodes: z.array(CanvasNodeSchema),
+            edges: z.array(CanvasEdgeSchema),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-node/find-canvas-node-definitions-with-configs.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { CanvasNodeDefinitionsWithConfigsSchema } from '../../models';
+
+export namespace FindCanvasNodeDefinitionsWithConfigsQuery {
+    export const ResponseSchema = z.object({
+        data: CanvasNodeDefinitionsWithConfigsSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-node/index.ts

@@ -1,5 +1,6 @@
 export * from './create-canvas-node.command';
 export * from './delete-canvas-node.command';
 export * from './find-canvas-node-by-uuid.query';
+export * from './find-canvas-node-definitions-with-configs.query';
 export * from './find-canvas-nodes-by-canvas.query';
 export * from './update-canvas-node.command';

package/commands/team-account/find-team-accounts-by-name.command.ts

@@ -3,10 +3,33 @@ import { TeamAccountWithBalanceSchema } from '../../models';
 import { SORT_ORDER, TEAM_ACCOUNT_ADMIN_SORT_BY } from '../../constants';
 
 export namespace FindTeamAccountsByNameCommand {
+    const BooleanQuerySchema = z
+        .union([z.boolean(), z.string().trim().toLowerCase()])
+        .transform((value, ctx) => {
+            if (typeof value === 'boolean') {
+                return value;
+            }
+
+            if (value === 'true') {
+                return true;
+            }
+
+            if (value === 'false') {
+                return false;
+            }
+
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'Expected boolean value: true or false',
+            });
+
+            return z.NEVER;
+        });
+    
     export const RequestSchema = z.object({
         name: z.string().trim().min(1).optional(),
         creatorEmail: z.string().trim().min(1).optional(),
-        hasPaidSubscription: z.boolean().optional(),
+        hasPaidSubscription: BooleanQuerySchema.optional(),
         limit: z.coerce.number().int().min(1).max(100).default(20).optional(),
         offset: z.coerce.number().int().min(0).default(0).optional(),
         sortBy: z

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/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/helpers/image-generation/calculate-gpt-image-2-price-with-margin.helper.ts

@@ -135,4 +135,4 @@ export function calculateGptImage2PriceInStarsByTier(params: {
         outputTokens,
         ...priced,
     };
-}
+}

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

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE, INPUT_OUTPUT_TYPE, TOOL_CONTENT_TYPE } from '../constants';
+import { IconVariantsSchema } from './icon-variants.schema';
+import {
+    HtmlPageBuilderConfigSchema,
+    ImageEditorConfigSchema,
+    ImageGenerationConfigSchema,
+    STTConfigSchema,
+    TTSConfigSchema,
+    VideoEditorConfigSchema,
+    VideoConfigSchema,
+} from './tools';
+
+const createCanvasNodeDefinitionNoConfigSchema = (nodeType: CANVAS_NODE_TYPE) =>
+    z.object({
+        nodeType: z.literal(nodeType),
+        toolType: z.null(),
+        config: z.null(),
+    });
+
+export const CanvasNodeDefinitionToolConfigSchema = z.discriminatedUnion('nodeType', [
+    z.object({
+        nodeType: z.literal(CANVAS_NODE_TYPE.imageGen),
+        toolType: z.literal(TOOL_CONTENT_TYPE.IMAGE_GENERATION),
+        config: ImageGenerationConfigSchema,
+    }),
+    z.object({
+        nodeType: z.literal(CANVAS_NODE_TYPE.imageEdit),
+        toolType: z.literal(TOOL_CONTENT_TYPE.IMAGE_EDITOR),
+        config: ImageEditorConfigSchema,
+    }),
+    z.object({
+        nodeType: z.literal(CANVAS_NODE_TYPE.ttsGen),
+        toolType: z.literal(TOOL_CONTENT_TYPE.TEXT_TO_SPEECH),
+        config: TTSConfigSchema,
+    }),
+    z.object({
+        nodeType: z.literal(CANVAS_NODE_TYPE.sttGen),
+        toolType: z.literal(TOOL_CONTENT_TYPE.SPEECH_TO_TEXT),
+        config: STTConfigSchema,
+    }),
+    z.object({
+        nodeType: z.literal(CANVAS_NODE_TYPE.videoGen),
+        toolType: z.literal(TOOL_CONTENT_TYPE.VIDEO),
+        config: VideoConfigSchema,
+    }),
+    z.object({
+        nodeType: z.literal(CANVAS_NODE_TYPE.videoEdit),
+        toolType: z.literal(TOOL_CONTENT_TYPE.VIDEO_EDITOR),
+        config: VideoEditorConfigSchema,
+    }),
+    z.object({
+        nodeType: z.literal(CANVAS_NODE_TYPE.htmlGen),
+        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),
+    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.fileBlock),
+    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.note),
+    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.colorPalette),
+    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.motionControl),
+    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.varGen),
+    createCanvasNodeDefinitionNoConfigSchema(CANVAS_NODE_TYPE.varBlock),
+]);
+export type CanvasNodeDefinitionToolConfig = z.infer<typeof CanvasNodeDefinitionToolConfigSchema>;
+
+export const CanvasNodeDefinitionSchema = z.object({
+    type: z.nativeEnum(CANVAS_NODE_TYPE),
+    label: z.string(),
+    icons: IconVariantsSchema,
+    inputPoints: z.array(z.nativeEnum(INPUT_OUTPUT_TYPE)),
+    outputPoints: z.array(z.nativeEnum(INPUT_OUTPUT_TYPE)),
+    toolType: z.nativeEnum(TOOL_CONTENT_TYPE).nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type CanvasNodeDefinition = z.infer<typeof CanvasNodeDefinitionSchema>;
+
+export const CanvasNodeDefinitionWithConfigSchema = z.object({
+    nodeDefinition: CanvasNodeDefinitionSchema,
+    config: CanvasNodeDefinitionToolConfigSchema,
+});
+export type CanvasNodeDefinitionWithConfig = z.infer<typeof CanvasNodeDefinitionWithConfigSchema>;
+
+export const CanvasNodeDefinitionsWithConfigsSchema = z.record(
+    z.nativeEnum(CANVAS_NODE_TYPE),
+    CanvasNodeDefinitionWithConfigSchema,
+);
+export type CanvasNodeDefinitionsWithConfigs = z.infer<
+    typeof CanvasNodeDefinitionsWithConfigsSchema
+>;

package/models/canvas-node.schema.ts

@@ -32,20 +32,29 @@ export type ImageGenParams = z.infer<typeof ImageGenParamsSchema>;
 
 export const VideoGenParamsSchema = strictObject({
     prompt: z.string(),
-    duration: z.string(),
-    resolution: z.string(),
+    model: z.string(),
+    duration: z.string().optional(),
+    aspectRatio: z.string().optional(),
+    resolution: z.string().optional(),
 });
 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 const AudioGenParamsSchema = z.discriminatedUnion('mode', [
+    strictObject({
+        mode: z.literal('tts'),
+        prompt: z.string(),
+        model: z.string(),
+        voice: z.string(),
+        stability: z.number(),
+        similarityBoost: z.number(),
+    }),
+    strictObject({
+        mode: z.literal('stt'),
+        prompt: z.string(),
+        model: z.string(),
+        audioFileId: z.string().uuid(),
+    }),
+]);
 export type AudioGenParams = z.infer<typeof AudioGenParamsSchema>;
 
 export const ColorPaletteParamsSchema = strictObject({

package/models/canvas.schema.ts

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

@@ -4,6 +4,7 @@ export * from './ai-model-formatted.schema';
 export * from './ai-model.schema';
 export * from './ai-vendor.schema';
 export * from './canvas.schema';
+export * from './canvas-node-definition.schema';
 export * from './canvas-node.schema';
 export * from './canvas-edge.schema';
 export * from './category.schema';

package/models/tools/image-editor/image-editor-model.schema.ts

@@ -11,10 +11,13 @@ export const ImageEditorModelParamsSchema = z.object({
     aspectRatio: z
         .record(
             z.string(),
-            z.object({
-                width: z.number(),
-                height: z.number(),
-            }),
+            z.union([
+                z.object({
+                    width: z.number(),
+                    height: z.number(),
+                }),
+                z.string(),
+            ]),
         )
         .optional(),
 });

package/package.json

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