@purpleschool/gptbot 0.12.59 → 0.12.61

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasNodeSchema = exports.CanvasNodeErrorSchema = exports.CanvasNodeOutputSchema = exports.CanvasNodeParamsSchemaByType = exports.CanvasNodeParamsSchema = exports.HtmlGenOutputSchema = exports.VarGenOutputSchema = exports.MotionControlOutputSchema = exports.ColorPaletteOutputSchema = exports.AudioGenSTTOutputSchema = exports.AudioGenTTSOutputSchema = exports.VideoGenOutputSchema = exports.ImageGenOutputSchema = exports.TextGenOutputSchema = exports.VarBlockParamsSchema = exports.NoteParamsSchema = exports.FileBlockParamsSchema = exports.VideoBlockParamsSchema = exports.ImageBlockParamsSchema = exports.TextBlockParamsSchema = exports.HtmlGenParamsSchema = exports.VarGenParamsSchema = exports.MotionControlParamsSchema = exports.ColorPaletteParamsSchema = exports.AudioGenParamsSchema = exports.VideoGenParamsSchema = exports.ImageGenParamsSchema = exports.TextGenParamsSchema = exports.CanvasNodePositionSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../constants");
+const strictObject = (shape) => zod_1.z.object(shape).strict();
+exports.CanvasNodePositionSchema = zod_1.z.object({
+    topLeft: zod_1.z.object({
+        x: zod_1.z.number(),
+        y: zod_1.z.number(),
+    }),
+    bottomRight: zod_1.z.object({
+        x: zod_1.z.number(),
+        y: zod_1.z.number(),
+    }),
+});
+exports.TextGenParamsSchema = strictObject({
+    prompt: zod_1.z.string(),
+    model: zod_1.z.string(),
+});
+exports.ImageGenParamsSchema = strictObject({
+    prompt: zod_1.z.string(),
+    model: zod_1.z.string(),
+    aspectRatio: zod_1.z.string(),
+    resolution: zod_1.z.string().optional(),
+});
+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(),
+});
+exports.ColorPaletteParamsSchema = strictObject({
+    prompt: zod_1.z.string(),
+});
+exports.MotionControlParamsSchema = strictObject({
+    prompt: zod_1.z.string(),
+    imageUrl: zod_1.z.string(),
+    videoUrl: zod_1.z.string(),
+    characterOrientation: zod_1.z.union([zod_1.z.literal('image'), zod_1.z.literal('video')]),
+    mode: zod_1.z.union([zod_1.z.literal('720p'), zod_1.z.literal('1080p')]),
+});
+exports.VarGenParamsSchema = strictObject({
+    prompt: zod_1.z.string(),
+    model: zod_1.z.string(),
+    vars: zod_1.z.array(strictObject({
+        key: zod_1.z.string(),
+        description: zod_1.z.string(),
+    })),
+});
+exports.HtmlGenParamsSchema = strictObject({
+    prompt: zod_1.z.string(),
+    model: zod_1.z.string(),
+});
+exports.TextBlockParamsSchema = strictObject({
+    content: zod_1.z.string(),
+});
+exports.ImageBlockParamsSchema = strictObject({
+    url: zod_1.z.string(),
+});
+exports.VideoBlockParamsSchema = strictObject({
+    url: zod_1.z.string(),
+});
+exports.FileBlockParamsSchema = strictObject({
+    filename: zod_1.z.string(),
+    content: zod_1.z.string(),
+});
+exports.NoteParamsSchema = strictObject({
+    content: zod_1.z.string(),
+});
+exports.VarBlockParamsSchema = strictObject({
+    name: zod_1.z.string(),
+    value: zod_1.z.string(),
+});
+exports.TextGenOutputSchema = strictObject({
+    result: zod_1.z.string(),
+});
+exports.ImageGenOutputSchema = strictObject({
+    resultUrl: zod_1.z.string(),
+});
+exports.VideoGenOutputSchema = strictObject({
+    resultUrl: zod_1.z.string(),
+});
+exports.AudioGenTTSOutputSchema = strictObject({
+    resultUrl: zod_1.z.string(),
+});
+exports.AudioGenSTTOutputSchema = strictObject({
+    transcript: zod_1.z.string(),
+});
+exports.ColorPaletteOutputSchema = strictObject({
+    paletteName: zod_1.z.string(),
+    colors: zod_1.z.array(strictObject({
+        hex: zod_1.z.string(),
+        name: zod_1.z.string(),
+        usage: zod_1.z.string(),
+    })),
+});
+exports.MotionControlOutputSchema = strictObject({
+    resultUrl: zod_1.z.string(),
+});
+exports.VarGenOutputSchema = strictObject({
+    variables: zod_1.z.record(zod_1.z.string()),
+});
+exports.HtmlGenOutputSchema = strictObject({
+    html: zod_1.z.string(),
+});
+exports.CanvasNodeParamsSchema = zod_1.z.union([
+    exports.TextGenParamsSchema,
+    exports.ImageGenParamsSchema,
+    exports.VideoGenParamsSchema,
+    exports.AudioGenParamsSchema,
+    exports.ColorPaletteParamsSchema,
+    exports.MotionControlParamsSchema,
+    exports.VarGenParamsSchema,
+    exports.HtmlGenParamsSchema,
+    exports.TextBlockParamsSchema,
+    exports.ImageBlockParamsSchema,
+    exports.VideoBlockParamsSchema,
+    exports.FileBlockParamsSchema,
+    exports.NoteParamsSchema,
+    exports.VarBlockParamsSchema,
+]);
+exports.CanvasNodeParamsSchemaByType = {
+    [constants_1.CANVAS_NODE_TYPE.textGen]: exports.TextGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.imageGen]: exports.ImageGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.imageEdit]: exports.ImageGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.videoGen]: exports.VideoGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.videoEdit]: exports.VideoGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.ttsGen]: exports.AudioGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.sttGen]: exports.AudioGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.textBlock]: exports.TextBlockParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.imageBlock]: exports.ImageBlockParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.videoBlock]: exports.VideoBlockParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.fileBlock]: exports.FileBlockParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.note]: exports.NoteParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.colorPalette]: exports.ColorPaletteParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.motionControl]: exports.MotionControlParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.varGen]: exports.VarGenParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.varBlock]: exports.VarBlockParamsSchema,
+    [constants_1.CANVAS_NODE_TYPE.htmlGen]: exports.HtmlGenParamsSchema,
+};
+exports.CanvasNodeOutputSchema = zod_1.z.union([
+    exports.TextGenOutputSchema,
+    exports.ImageGenOutputSchema,
+    exports.VideoGenOutputSchema,
+    exports.AudioGenTTSOutputSchema,
+    exports.AudioGenSTTOutputSchema,
+    exports.ColorPaletteOutputSchema,
+    exports.MotionControlOutputSchema,
+    exports.VarGenOutputSchema,
+    exports.HtmlGenOutputSchema,
+]);
+exports.CanvasNodeErrorSchema = zod_1.z.object({
+    code: zod_1.z.string(),
+    message: zod_1.z.string(),
+    details: zod_1.z.record(zod_1.z.unknown()).optional(),
+    retryable: zod_1.z.boolean().optional(),
+});
+exports.CanvasNodeSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    canvasId: zod_1.z.string().uuid(),
+    nodeDefinitionId: zod_1.z.nativeEnum(constants_1.CANVAS_NODE_TYPE),
+    position: exports.CanvasNodePositionSchema,
+    status: zod_1.z.nativeEnum(constants_1.NODE_RUN_STATUS),
+    toolJobId: zod_1.z.string().uuid().nullable(),
+    params: exports.CanvasNodeParamsSchema.nullable(),
+    output: exports.CanvasNodeOutputSchema.nullable(),
+    error: exports.CanvasNodeErrorSchema.nullable(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/models/index.js

@@ -20,6 +20,8 @@ __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.schema"), exports);
+__exportStar(require("./canvas-edge.schema"), exports);
 __exportStar(require("./category.schema"), exports);
 __exportStar(require("./chat-with-messages.schema"), exports);
 __exportStar(require("./chat.schema"), exports);

package/build/models/webmaster.schema.js

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

package/commands/canvas/find-canvas-by-uuid-with-relations.query.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../models';
+
+export namespace FindCanvasByUuidWithRelationsQuery {
+    export const RequestSchema = CanvasSchema.pick({
+        uuid: true,
+    });
+
+    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/index.ts

@@ -1,5 +1,7 @@
 export * from './create-canvas.command';
 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 './save-canvas.command';
 export * from './update-canvas.command';

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { CANVAS_NODE_TYPE, INPUT_OUTPUT_TYPE } from '../../constants';
+import {
+    CanvasEdgeSchema,
+    CanvasNodeParamsSchema,
+    CanvasNodePositionSchema,
+    CanvasNodeSchema,
+    CanvasSchema,
+} from '../../models';
+
+export namespace SaveCanvasCommand {
+    export const RequestParamSchema = CanvasSchema.pick({
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const CanvasNodePayloadSchema = z.object({
+        uuid: z.string().uuid(),
+        nodeDefinitionId: z.nativeEnum(CANVAS_NODE_TYPE),
+        position: CanvasNodePositionSchema,
+        params: CanvasNodeParamsSchema.nullable().optional(),
+    });
+
+    export const CanvasEdgePayloadSchema = z.object({
+        sourceId: z.string().uuid(),
+        targetId: z.string().uuid(),
+        handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+    });
+
+    export const RequestSchema = z.object({
+        updatedAt: z.preprocess(
+            (value) => (typeof value === 'string' ? new Date(value) : value),
+            z.date(),
+        ),
+        nodes: z.array(CanvasNodePayloadSchema),
+        edges: z.array(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-edge/create-canvas-edge.command.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { INPUT_OUTPUT_TYPE } from '../../constants';
+import { CanvasEdgeSchema } from '../../models';
+
+export namespace CreateCanvasEdgeCommand {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        sourceId: z.string().uuid(),
+        targetId: z.string().uuid(),
+        handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasEdgeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-edge/delete-canvas-edge.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+
+export namespace DeleteCanvasEdgeCommand {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        sourceId: z.string().uuid(),
+        targetId: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            isDeleted: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-edge/find-canvas-edge-by-source-and-target.query.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { CanvasEdgeSchema } from '../../models';
+
+export namespace FindCanvasEdgeBySourceAndTargetQuery {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestQuerySchema = z.object({
+        sourceId: z.string().uuid(),
+        targetId: z.string().uuid(),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasEdgeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-edge/find-canvas-edges-by-canvas.query.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { CanvasEdgeSchema } from '../../models';
+
+export namespace FindCanvasEdgesByCanvasQuery {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(CanvasEdgeSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-edge/index.ts

@@ -0,0 +1,4 @@
+export * from './create-canvas-edge.command';
+export * from './delete-canvas-edge.command';
+export * from './find-canvas-edge-by-source-and-target.query';
+export * from './find-canvas-edges-by-canvas.query';

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/canvas-node/delete-canvas-node.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { CanvasNodeSchema } from '../../models';
+
+export namespace DeleteCanvasNodeCommand {
+    export const RequestParamSchema = CanvasNodeSchema.pick({
+        canvasId: true,
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            isDeleted: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-node/find-canvas-node-by-uuid.query.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { CanvasNodeSchema } from '../../models';
+
+export namespace FindCanvasNodeByUuidQuery {
+    export const RequestParamSchema = CanvasNodeSchema.pick({
+        canvasId: true,
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasNodeSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-node/find-canvas-nodes-by-canvas.query.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { CanvasNodeSchema } from '../../models';
+
+export namespace FindCanvasNodesByCanvasQuery {
+    export const RequestParamSchema = z.object({
+        canvasId: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(CanvasNodeSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-node/index.ts

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

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/index.ts

@@ -4,6 +4,8 @@ export * from './ai-vendor';
 export * from './auth';
 export * from './blog';
 export * from './canvas';
+export * from './canvas-node';
+export * from './canvas-edge';
 export * from './category';
 export * from './chat';
 export * from './course';

package/commands/webmaster/update-webmaster.command.ts

@@ -6,7 +6,34 @@ export namespace UpdateWebmasterCommand {
 
     export type RequestParam = z.infer<typeof RequestParamSchema>;
 
-    export const RequestSchema = WebmasterSchema.partial();
+    export const RequestSchema = WebmasterSchema.pick({
+        organization: true,
+        organizationType: true,
+        tin: true,
+        alias: true,
+    }).partial();
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: WebmasterSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}
+
+export namespace AdminUpdateWebmasterCommand {
+    export const RequestParamSchema = WebmasterSchema.pick({ uuid: true });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = WebmasterSchema.pick({
+        organization: true,
+        organizationType: true,
+        tin: true,
+        alias: true,
+        isPremium: true,
+    }).partial();
 
     export type Request = z.infer<typeof RequestSchema>;
 

package/constants/canvas-edge/enums/index.ts

@@ -0,0 +1 @@
+export * from './input-output-type.enum';

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

@@ -0,0 +1,9 @@
+export enum INPUT_OUTPUT_TYPE {
+    text = 'text',
+    image = 'image',
+    video = 'video',
+    sound = 'sound',
+    html = 'html',
+    palette = 'palette',
+    var = 'var',
+}

package/constants/canvas-edge/index.ts

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

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

@@ -0,0 +1,19 @@
+export enum CANVAS_NODE_TYPE {
+    textGen = 'textGen',
+    imageGen = 'imageGen',
+    imageEdit = 'imageEdit',
+    videoGen = 'videoGen',
+    videoEdit = 'videoEdit',
+    ttsGen = 'ttsGen',
+    sttGen = 'sttGen',
+    textBlock = 'textBlock',
+    imageBlock = 'imageBlock',
+    videoBlock = 'videoBlock',
+    fileBlock = 'fileBlock',
+    note = 'note',
+    colorPalette = 'colorPalette',
+    motionControl = 'motionControl',
+    varGen = 'varGen',
+    varBlock = 'varBlock',
+    htmlGen = 'htmlGen',
+}

package/constants/canvas-node/enums/index.ts

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

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

@@ -0,0 +1,8 @@
+export enum NODE_RUN_STATUS {
+    IDLE = 'IDLE',
+    PENDING = 'PENDING',
+    RUNNING = 'RUNNING',
+    COMPLETED = 'COMPLETED',
+    FAILED = 'FAILED',
+    CANCELLED = 'CANCELLED',
+}

package/constants/canvas-node/index.ts

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

package/constants/index.ts

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

package/helpers/image-generation/calculate-gpt-image-2-price-with-margin.helper.ts

@@ -52,10 +52,7 @@ export function estimateGptImage2OutputCostUsdFromTokens(params: {
     return (outputTokens / 1_000_000) * outputPricePer1MUsd;
 }
 
-export function applyTargetMargin(params: {
-    cost: number;
-    targetMargin?: number;
-}): number {
+export function applyTargetMargin(params: { cost: number; targetMargin?: number }): number {
     const { cost, targetMargin = DEFAULT_TARGET_MARGIN } = params;
     if (targetMargin < 0 || targetMargin >= 1) {
         throw new Error(`targetMargin must be in [0, 1), got ${targetMargin}`);
@@ -64,10 +61,7 @@ export function applyTargetMargin(params: {
     return cost / (1 - targetMargin);
 }
 
-export function convertUsdToStarsCeil(params: {
-    usd: number;
-    starPriceUsd?: number;
-}): number {
+export function convertUsdToStarsCeil(params: { usd: number; starPriceUsd?: number }): number {
     const { usd, starPriceUsd = DEFAULT_STAR_PRICE_USD } = params;
     if (starPriceUsd <= 0) {
         throw new Error(`starPriceUsd must be > 0, got ${starPriceUsd}`);
@@ -141,4 +135,4 @@ export function calculateGptImage2PriceInStarsByTier(params: {
         outputTokens,
         ...priced,
     };
-}
+}

package/models/canvas-edge.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+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),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type CanvasEdge = z.infer<typeof CanvasEdgeSchema>;