@purpleschool/gptbot 0.12.68 → 0.12.69

package/api/controllers/http/canvas-template.ts

@@ -0,0 +1,10 @@
+export const CANVAS_TEMPLATE_PRIVATE_CONTROLLER = 'private/canvas-template' as const;
+
+export const CANVAS_TEMPLATE_ROUTES = {
+    CREATE: '',
+    CREATE_CANVAS: (uuid: string) => `${uuid}`,
+    GET_ALL: '',
+    FIND_BY_UUID: (uuid: string) => `${uuid}`,
+    UPDATE: (uuid: string) => `${uuid}`,
+    DELETE: (uuid: string) => `${uuid}`,
+} as const;

package/api/controllers/http/index.ts

@@ -70,3 +70,5 @@ export * from './team-account';
 export * from './spell-corrector';
 export * from './tool-workspace';
 export * from './html-page-builder';
+
+export * from './canvas-template';

package/api/routes.ts

@@ -366,6 +366,19 @@ export const REST_API = {
         DELETE: (uuid: string) =>
             `${ROOT}/${CONTROLLERS.FOLDER_PRIVATE_CONTROLLER}/${CONTROLLERS.FOLDER_ROUTES.DELETE(uuid)}`,
     },
+
+    CANVAS_TEMPLATE_PRIVATE: {
+        CREATE_CANVAS: (uuid: string) =>
+            `${ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.CREATE_CANVAS(uuid)}`,
+        FIND_BY_UUID: (uuid: string) =>
+            `${ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.FIND_BY_UUID(uuid)}`,
+        GET_ALL: `${ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.GET_ALL}`,
+        CREATE: `${ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.CREATE}`,
+        UPDATE: (uuid: string) =>
+            `${ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.UPDATE(uuid)}`,
+        DELETE: (uuid: string) =>
+            `${ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.DELETE(uuid)}`,
+    },
     CANVAS_PRIVATE: {
         FIND_BY_UUID: (uuid: string) =>
             `${ROOT}/${CONTROLLERS.CANVAS_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_ROUTES.FIND_BY_UUID(uuid)}`,

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANVAS_TEMPLATE_ROUTES = exports.CANVAS_TEMPLATE_PRIVATE_CONTROLLER = void 0;
+exports.CANVAS_TEMPLATE_PRIVATE_CONTROLLER = 'private/canvas-template';
+exports.CANVAS_TEMPLATE_ROUTES = {
+    CREATE: '',
+    CREATE_CANVAS: (uuid) => `${uuid}`,
+    GET_ALL: '',
+    FIND_BY_UUID: (uuid) => `${uuid}`,
+    UPDATE: (uuid) => `${uuid}`,
+    DELETE: (uuid) => `${uuid}`,
+};

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

@@ -86,3 +86,4 @@ __exportStar(require("./team-account"), exports);
 __exportStar(require("./spell-corrector"), exports);
 __exportStar(require("./tool-workspace"), exports);
 __exportStar(require("./html-page-builder"), exports);
+__exportStar(require("./canvas-template"), exports);

package/build/api/routes.js

@@ -321,6 +321,14 @@ exports.REST_API = {
         UPDATE: (uuid) => `${exports.ROOT}/${CONTROLLERS.FOLDER_PRIVATE_CONTROLLER}/${CONTROLLERS.FOLDER_ROUTES.UPDATE(uuid)}`,
         DELETE: (uuid) => `${exports.ROOT}/${CONTROLLERS.FOLDER_PRIVATE_CONTROLLER}/${CONTROLLERS.FOLDER_ROUTES.DELETE(uuid)}`,
     },
+    CANVAS_TEMPLATE_PRIVATE: {
+        CREATE_CANVAS: (uuid) => `${exports.ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.CREATE_CANVAS(uuid)}`,
+        FIND_BY_UUID: (uuid) => `${exports.ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.FIND_BY_UUID(uuid)}`,
+        GET_ALL: `${exports.ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.GET_ALL}`,
+        CREATE: `${exports.ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.CREATE}`,
+        UPDATE: (uuid) => `${exports.ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.UPDATE(uuid)}`,
+        DELETE: (uuid) => `${exports.ROOT}/${CONTROLLERS.CANVAS_TEMPLATE_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_TEMPLATE_ROUTES.DELETE(uuid)}`,
+    },
     CANVAS_PRIVATE: {
         FIND_BY_UUID: (uuid) => `${exports.ROOT}/${CONTROLLERS.CANVAS_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_ROUTES.FIND_BY_UUID(uuid)}`,
         GET_ALL: `${exports.ROOT}/${CONTROLLERS.CANVAS_PRIVATE_CONTROLLER}/${CONTROLLERS.CANVAS_ROUTES.GET_ALL}`,

package/build/commands/canvas-template/create-canvas-from-template.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCanvasFromTemplateCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var CreateCanvasFromTemplateCommand;
+(function (CreateCanvasFromTemplateCommand) {
+    CreateCanvasFromTemplateCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    CreateCanvasFromTemplateCommand.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),
+        }),
+    });
+})(CreateCanvasFromTemplateCommand || (exports.CreateCanvasFromTemplateCommand = CreateCanvasFromTemplateCommand = {}));

package/build/commands/canvas-template/create-canvas-template.command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCanvasTemplateCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var CreateCanvasTemplateCommand;
+(function (CreateCanvasTemplateCommand) {
+    CreateCanvasTemplateCommand.RequestSchema = zod_1.z.object({
+        name: zod_1.z.string().trim().min(1),
+        description: zod_1.z.string().trim().min(1).optional().nullable(),
+        previewImageUrl: zod_1.z.string().url().optional().nullable(),
+        tags: zod_1.z.array(zod_1.z.string().trim().min(1)).default([]),
+        graph: models_1.CanvasTemplateGraphSchema,
+    });
+    CreateCanvasTemplateCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.CanvasTemplateSchema,
+    });
+})(CreateCanvasTemplateCommand || (exports.CreateCanvasTemplateCommand = CreateCanvasTemplateCommand = {}));

package/build/commands/canvas-template/delete-canvas-template.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteCanvasTemplateCommand = void 0;
+const zod_1 = require("zod");
+var DeleteCanvasTemplateCommand;
+(function (DeleteCanvasTemplateCommand) {
+    DeleteCanvasTemplateCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    DeleteCanvasTemplateCommand.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.object({
+            isDeleted: zod_1.z.boolean(),
+        }),
+    });
+})(DeleteCanvasTemplateCommand || (exports.DeleteCanvasTemplateCommand = DeleteCanvasTemplateCommand = {}));

package/build/commands/canvas-template/find-canvas-template-by-uuid.query.js

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

package/build/commands/canvas-template/find-canvas-templates.query.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindCanvasTemplatesQuery = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var FindCanvasTemplatesQuery;
+(function (FindCanvasTemplatesQuery) {
+    FindCanvasTemplatesQuery.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),
+        search: zod_1.z.string().trim().optional(),
+    });
+    FindCanvasTemplatesQuery.ResponseSchema = zod_1.z.object({
+        data: zod_1.z.array(models_1.CanvasTemplateSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+    });
+})(FindCanvasTemplatesQuery || (exports.FindCanvasTemplatesQuery = FindCanvasTemplatesQuery = {}));

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

@@ -0,0 +1,22 @@
+"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("./create-canvas-template.command"), exports);
+__exportStar(require("./create-canvas-from-template.command"), exports);
+__exportStar(require("./delete-canvas-template.command"), exports);
+__exportStar(require("./find-canvas-template-by-uuid.query"), exports);
+__exportStar(require("./find-canvas-templates.query"), exports);
+__exportStar(require("./update-canvas-template.command"), exports);

package/build/commands/canvas-template/update-canvas-template.command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCanvasTemplateCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var UpdateCanvasTemplateCommand;
+(function (UpdateCanvasTemplateCommand) {
+    UpdateCanvasTemplateCommand.RequestParamSchema = models_1.CanvasTemplateSchema.pick({
+        uuid: true,
+    });
+    UpdateCanvasTemplateCommand.RequestSchema = zod_1.z.object({
+        name: zod_1.z.string().trim().min(1).optional(),
+        description: zod_1.z.string().trim().min(1).optional().nullable(),
+        previewImageUrl: zod_1.z.string().url().optional().nullable(),
+        tags: zod_1.z.array(zod_1.z.string().trim().min(1)).optional(),
+        graph: models_1.CanvasTemplateGraphSchema.optional(),
+    });
+    UpdateCanvasTemplateCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.CanvasTemplateSchema,
+    });
+})(UpdateCanvasTemplateCommand || (exports.UpdateCanvasTemplateCommand = UpdateCanvasTemplateCommand = {}));

package/build/commands/index.js

@@ -65,3 +65,4 @@ __exportStar(require("./user-profile"), exports);
 __exportStar(require("./team-account"), exports);
 __exportStar(require("./team-to-subscription"), exports);
 __exportStar(require("./team-to-product"), exports);
+__exportStar(require("./canvas-template"), exports);

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasTemplateSchema = exports.CanvasTemplateGraphSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../constants");
+const canvas_node_schema_1 = require("./canvas-node.schema");
+const CanvasTemplateGraphNodeSchema = zod_1.z.object({
+    uuid: zod_1.z.string().trim().min(1),
+    nodeDefinitionId: zod_1.z.nativeEnum(constants_1.CANVAS_NODE_TYPE),
+    position: canvas_node_schema_1.CanvasNodePositionSchema,
+    params: canvas_node_schema_1.CanvasNodeParamsSchema.nullable().optional(),
+});
+const CanvasTemplateGraphEdgeSchema = zod_1.z.object({
+    sourceId: zod_1.z.string().trim().min(1),
+    targetId: zod_1.z.string().trim().min(1),
+    handle: zod_1.z.nativeEnum(constants_1.INPUT_OUTPUT_TYPE),
+});
+exports.CanvasTemplateGraphSchema = zod_1.z
+    .object({
+    nodes: zod_1.z.array(CanvasTemplateGraphNodeSchema),
+    edges: zod_1.z.array(CanvasTemplateGraphEdgeSchema),
+})
+    .superRefine((graph, ctx) => {
+    const nodeIds = new Set();
+    for (const [index, node] of graph.nodes.entries()) {
+        if (nodeIds.has(node.uuid)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['nodes', index, 'uuid'],
+                message: `Duplicate node id: ${node.uuid}`,
+            });
+            continue;
+        }
+        nodeIds.add(node.uuid);
+    }
+    for (const [index, edge] of graph.edges.entries()) {
+        if (!nodeIds.has(edge.sourceId)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['edges', index, 'sourceId'],
+                message: `Source node not found: ${edge.sourceId}`,
+            });
+        }
+        if (!nodeIds.has(edge.targetId)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['edges', index, 'targetId'],
+                message: `Target node not found: ${edge.targetId}`,
+            });
+        }
+    }
+});
+exports.CanvasTemplateSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().nullable(),
+    userId: zod_1.z.string().uuid().nullable(),
+    previewImageUrl: zod_1.z.string().url().nullable(),
+    tags: zod_1.z.array(zod_1.z.string()),
+    graph: exports.CanvasTemplateGraphSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/models/index.js

@@ -83,3 +83,4 @@ __exportStar(require("./user-profile.schema"), exports);
 __exportStar(require("./b2b"), exports);
 __exportStar(require("./json-value.schema"), exports);
 __exportStar(require("./team-account"), exports);
+__exportStar(require("./canvas-template.schema"), exports);

package/commands/canvas-template/create-canvas-from-template.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { CanvasEdgeSchema, CanvasNodeSchema, CanvasSchema } from '../../models';
+
+export namespace CreateCanvasFromTemplateCommand {
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    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-template/create-canvas-template.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+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(),
+        previewImageUrl: z.string().url().optional().nullable(),
+        tags: z.array(z.string().trim().min(1)).default([]),
+        graph: CanvasTemplateGraphSchema,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasTemplateSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export namespace DeleteCanvasTemplateCommand {
+    export const RequestParamSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    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-template/find-canvas-template-by-uuid.query.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { CanvasTemplateSchema } from '../../models';
+
+export namespace FindCanvasTemplateByUuidQuery {
+    export const RequestSchema = CanvasTemplateSchema.pick({
+        uuid: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasTemplateSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-template/find-canvas-templates.query.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+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(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(CanvasTemplateSchema),
+        page: z.number(),
+        totalPages: z.number(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/canvas-template/index.ts

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

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { CanvasTemplateSchema, CanvasTemplateGraphSchema } from '../../models';
+
+export namespace UpdateCanvasTemplateCommand {
+    export const RequestParamSchema = CanvasTemplateSchema.pick({
+        uuid: true,
+    });
+
+    export type RequestParam = z.infer<typeof RequestParamSchema>;
+
+    export const RequestSchema = z.object({
+        name: z.string().trim().min(1).optional(),
+        description: z.string().trim().min(1).optional().nullable(),
+        previewImageUrl: z.string().url().optional().nullable(),
+        tags: z.array(z.string().trim().min(1)).optional(),
+        graph: CanvasTemplateGraphSchema.optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: CanvasTemplateSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/index.ts

@@ -49,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/models/canvas-template.schema.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { INPUT_OUTPUT_TYPE, CANVAS_NODE_TYPE } from '../constants';
+import { CanvasNodeParamsSchema, CanvasNodePositionSchema } 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 CanvasTemplateGraphEdgeSchema = z.object({
+    sourceId: z.string().trim().min(1),
+    targetId: z.string().trim().min(1),
+    handle: z.nativeEnum(INPUT_OUTPUT_TYPE),
+});
+
+export const CanvasTemplateGraphSchema = z
+    .object({
+        nodes: z.array(CanvasTemplateGraphNodeSchema),
+        edges: z.array(CanvasTemplateGraphEdgeSchema),
+    })
+    .superRefine((graph, ctx) => {
+        const nodeIds = new Set<string>();
+        for (const [index, node] of graph.nodes.entries()) {
+            if (nodeIds.has(node.uuid)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['nodes', index, 'uuid'],
+                    message: `Duplicate node id: ${node.uuid}`,
+                });
+                continue;
+            }
+            nodeIds.add(node.uuid);
+        }
+
+        for (const [index, edge] of graph.edges.entries()) {
+            if (!nodeIds.has(edge.sourceId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['edges', index, 'sourceId'],
+                    message: `Source node not found: ${edge.sourceId}`,
+                });
+            }
+
+            if (!nodeIds.has(edge.targetId)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: ['edges', index, 'targetId'],
+                    message: `Target node not found: ${edge.targetId}`,
+                });
+            }
+        }
+    });
+
+export type CanvasTemplateGraph = z.infer<typeof CanvasTemplateGraphSchema>;
+
+export const CanvasTemplateSchema = z.object({
+    uuid: z.string().uuid(),
+    name: z.string(),
+    description: z.string().nullable(),
+    userId: z.string().uuid().nullable(),
+    previewImageUrl: z.string().url().nullable(),
+    tags: z.array(z.string()),
+    graph: CanvasTemplateGraphSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/index.ts

@@ -67,3 +67,5 @@ export * from './user-profile.schema';
 export * from './b2b';
 export * from './json-value.schema';
 export * from './team-account';
+
+export * from './canvas-template.schema';

package/package.json

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