@skychameleon/workflow 1.0.0 → 1.1.0

package/package.json

@@ -1,19 +1,30 @@
 {
   "name": "@skychameleon/workflow",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Everything about workflow",
   "license": "ISC",
   "type": "module",
   "scripts": {
+    "test": "npx tsx --test",
     "format": "npx prettier --write ."
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@skychameleon/core": "^1.0.3"
+    "@skychameleon/core": "^1.0.3",
+    "@types/node": "^25.3.3",
+    "tsx": "^4.21.0"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
   },
   "exports": {
-    "./workflow.schema": "./workflow/workflow.schema.d.ts"
+    "./workflow.schema": "./workflow/workflow.schema.ts",
+    "./edges": "./workflow/query-rule.schema.ts",
+    "./blocks": "./workflow/registry.ts"
+  },
+  "peerDependencies": {
+    "zod": "^3.22.0"
   }
-}
+}

package/workflow/blocks/base.schema.ts

@@ -0,0 +1,48 @@
+import z from "zod";
+import {
+  EntranceHandlerZod,
+  ExitHandlerZod,
+  type EntranceHandler,
+  type ExitHandler,
+} from "./shared/general.types";
+
+export const ChatBotBlockZodTypes = z.enum([
+  "send-file",
+  "send-msg",
+  "input-text",
+  "input-file",
+]);
+export type ChatBotBlockTypes = z.infer<typeof ChatBotBlockZodTypes>;
+
+export const MainBlockZodTypes = z.enum(["start", "var-set", "run-code"]);
+export type MainBlockTypes = z.infer<typeof MainBlockZodTypes>;
+
+export const BlockZodTypes = z.union([ChatBotBlockZodTypes, MainBlockZodTypes]);
+export type BlockTypes = z.infer<typeof BlockZodTypes>;
+
+export const BlockCategoryZod = z.enum(["pending", "action"]);
+export type BlockCategory = z.infer<typeof BlockCategoryZod>;
+
+export const createBaseBlockSchema = <
+  Type extends BlockTypes,
+  Category extends BlockCategory,
+>(
+  type: Type,
+  category: Category,
+) =>
+  z.object({
+    _id: z.string(),
+    index: z.number(),
+    category: z.literal(category),
+    type: z.literal(type),
+    label: z.string(),
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+    entrance: EntranceHandlerZod,
+    exit: ExitHandlerZod,
+  });
+
+export type BaseBlockSchema = z.infer<ReturnType<typeof createBaseBlockSchema>>
+export default createBaseBlockSchema;

package/workflow/blocks/chat_bot/input-file.schema.ts

@@ -1,16 +1,42 @@
-import type { BaseBlockSchema } from "../base.schema";
-import type { VarSetBlockSchema } from "../general/var-set.schema";
-import type {
-  AdditionalOptions,
-  InputVarChatBotType,
-  SendText,
+import type z from "zod";
+import createBaseBlockSchema from "../base.schema";
+import { VarSetBlockSchemaZod } from "../general/var-set.schema";
+import {
+  AdditionalOptionsZod,
+  InputVarChatBotTypeZod,
+  SendTextZod,
 } from "../shared/general.types";
 
 /**
  * Блок отвечающий за получения файла
  */
-export interface InputFileChatBotBlockSchema extends BaseBlockSchema<"input-file"> {
-  sendText: SendText;
-  varSet: Omit<VarSetBlockSchema<InputVarChatBotType>, "code">;
-  additionalOptions: Pick<AdditionalOptions, "back_button" | "skip_button">;
-}
+export const InputFileChatBotBlockSchemaZod = createBaseBlockSchema(
+  "input-file",
+  "pending",
+).extend({
+  sendText: SendTextZod,
+  varSet: VarSetBlockSchemaZod.omit({
+    code: true,
+  })
+    .pick({
+      name: true,
+      varType: true,
+      completion: true,
+    })
+    .refine(
+      (varSet) => InputVarChatBotTypeZod.safeParse(varSet.varType).success,
+      {
+        message:
+          "varType must be one of InputVarChatBotType values for input-text block",
+        path: ["varSet", "varType"],
+      },
+    ),
+  additionalOptions: AdditionalOptionsZod.pick({
+    back_button: true,
+    skip_button: true,
+  }),
+});
+type InputFileChatBotBlockSchema = z.infer<
+  typeof InputFileChatBotBlockSchemaZod
+>;
+export default InputFileChatBotBlockSchema;

package/workflow/blocks/chat_bot/input-text.schema.ts

@@ -1,35 +1,72 @@
-import type { BaseBlockSchema } from "../base.schema";
-import type { VarSetBlockSchema } from "../general/var-set.schema";
-import type {
-  AdditionalOptions,
-  CodeExpression,
-  InputVarChatBotType,
-  SendText,
+import z from "zod";
+import {
+  AdditionalOptionsZod,
+  CodeExpressionZod,
+  InputVarChatBotTypeZod,
+  SendTextZod,
 } from "../shared/general.types";
+import createBaseBlockSchema from "../base.schema";
+import { VarSetBlockSchemaZod } from "../general/var-set.schema";
 
 /**
  * Типы для составления клавиатуры
  * Если создается кодом - KeyboardCode, то он должен вернуть объекта типа KeyboardConstructor
  */
-export type KeyboardCode = CodeExpression;
-export type KeyboardConstructor = {
-  text:
-    | string
-    | {
-        useCodeExpression: boolean;
-        code: CodeExpression;
-      };
-  callback_data: string;
-}[];
+export const KeyboardCodeZod = CodeExpressionZod;
+export type KeyboardCode = z.infer<typeof KeyboardCodeZod>;
+
+export const KeyboardConstructorZod = z.array(
+  z.object({
+    text: z.union([
+      z.string(),
+      z.object({
+        useCodeExpression: z.boolean(),
+        code: KeyboardCodeZod,
+      }),
+    ]),
+    callback_data: z.string(),
+  }),
+);
+
+export type KeyboardConstructor = z.infer<typeof KeyboardConstructorZod>;
 
 /**
  * Блок отвечающий за получения текстового сообщения
  */
-export interface InputTextChatBotBlockSchema extends BaseBlockSchema<"input-text"> {
-  sendText: SendText;
-  validator: false | CodeExpression; // валидирует полученное сообщение, в случае не сопаставление можно выдать ошибку
-  convertor: false | CodeExpression; // конвертирует полученное сообщение в другое значение&тип
-  varSet: Omit<VarSetBlockSchema<InputVarChatBotType>, "code">;
-  keyboard: false | KeyboardConstructor | KeyboardCode;
-  additionalOptions: Pick<AdditionalOptions, "back_button" | "skip_button">;
-}
+export const InputTextChatBotBlockSchemaZod = createBaseBlockSchema(
+  "input-text",
+  "pending",
+).extend({
+  sendText: SendTextZod,
+  validator: z.union([z.literal(false), CodeExpressionZod]),
+  convertor: z.union([z.literal(false), CodeExpressionZod]),
+  varSet: VarSetBlockSchemaZod.omit({
+    code: true,
+  })
+    .pick({
+      name: true,
+      varType: true,
+      completion: true,
+    })
+    .refine(
+      (varSet) => InputVarChatBotTypeZod.safeParse(varSet.varType).success,
+      {
+        message:
+          "varType must be one of InputVarChatBotType values for input-text block",
+        path: ["varSet", "varType"],
+      },
+    ),
+  keyboard: z.union([
+    z.literal(false),
+    KeyboardCodeZod,
+    KeyboardConstructorZod,
+  ]),
+  additionalOptions: AdditionalOptionsZod.pick({
+    back_button: true,
+    skip_button: true,
+  }),
+});
+type InputTextChatBotBlockSchema = z.infer<
+  typeof InputTextChatBotBlockSchemaZod
+>;
+export default InputTextChatBotBlockSchema;

package/workflow/blocks/chat_bot/send-file.schema.ts

@@ -1,19 +1,37 @@
-import type { BaseBlockSchema } from "../base.schema";
-import type { VarSetBlockSchema } from "../general/var-set.schema";
-import type {
-  AdditionalOptions,
-  CodeExpression,
+import z from "zod";
+import createBaseBlockSchema from "../base.schema";
+import {
   VarType,
-  SendText,
+  SendTextZod,
+  AdditionalOptionsZod,
 } from "../shared/general.types";
+import { VarSetBlockSchemaZod } from "../general/var-set.schema";
 
 /**
  * Блок отвечающий за отправление файлов
  */
-export interface SendFileChatBotBlockSchema extends BaseBlockSchema<"send_file"> {
-  several: boolean;
-  sendText: SendText;
-  varSet: Omit<VarSetBlockSchema<VarType.BOOLEAN>, "code">;
-  errorText: string;
-  additionalOptions: Pick<AdditionalOptions, "send_other_chat">;
-}
+export const SendFileChatBotBlockSchemaZod = createBaseBlockSchema(
+  "send-file",
+  "action",
+).extend({
+  several: z.boolean(),
+  sendText: SendTextZod,
+  varSet: VarSetBlockSchemaZod.omit({
+    code: true,
+  })
+    .pick({
+      name: true,
+      varType: true,
+      completion: true,
+    })
+    .refine((varSet) => varSet.varType === VarType.BOOLEAN, {
+      message: "varType must be BOOLEAN for send-file block",
+      path: ["varSet", "varType"],
+    }),
+  errorText: z.string(),
+  additionalOptions: AdditionalOptionsZod.pick({
+    send_other_chat: true,
+  }),
+});
+type SendFileChatBotBlockSchema = z.infer<typeof SendFileChatBotBlockSchemaZod>;
+export default SendFileChatBotBlockSchema;

package/workflow/blocks/chat_bot/send-msg.schema.ts

@@ -0,0 +1,19 @@
+import z from "zod";
+import createBaseBlockSchema from "../base.schema";
+import { AdditionalOptionsZod, SendTextZod } from "../shared/general.types";
+
+/**
+ * Блок отвечающий за отправление текстового сообщения
+ */
+export const SendMsgChatBotBlockSchemaZod = createBaseBlockSchema(
+  "send-msg",
+  "action",
+).extend({
+  markdown: z.boolean(),
+  sendText: SendTextZod,
+  additionalOptions: AdditionalOptionsZod.pick({
+    send_other_chat: true,
+  }),
+});
+type SendMsgChatBotBlockSchema = z.infer<typeof SendMsgChatBotBlockSchemaZod>;
+export default SendMsgChatBotBlockSchema;

package/workflow/blocks/general/run-code.schema.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import createBaseBlockSchema from "../base.schema";
+import { CodeExpressionZod } from "../shared/general.types";
+
+/**
+ * Блок отвечающий за запуск кода
+ */
+export const RunCodeBlockSchemaZod = createBaseBlockSchema(
+  "start",
+  "action",
+).extend({
+  code: CodeExpressionZod,
+});
+type RunCodeBlockSchema = z.infer<typeof RunCodeBlockSchemaZod>;
+export default RunCodeBlockSchema;

package/workflow/blocks/general/start.schema.ts

@@ -0,0 +1,26 @@
+import z from "zod";
+import createBaseBlockSchema from "../base.schema";
+import { VarSetBlockSchemaZod } from "./var-set.schema";
+import { validateDuplicateVars } from "../validation/duplicate-vars.start";
+
+/**
+ * Блок отвечающий за запуск сценария и содержащий все необходимые переменные для работы
+ */
+export const StartBlockSchemaZod = createBaseBlockSchema(
+  "start",
+  "action",
+).extend({
+  vars: z
+    .array(
+      VarSetBlockSchemaZod.pick({
+        name: true,
+        varType: true,
+        code: true,
+        completion: true,
+      }),
+    )
+    .superRefine(validateDuplicateVars),
+});
+type StartBlockSchema = z.infer<typeof StartBlockSchemaZod>;
+
+export default StartBlockSchema;

package/workflow/blocks/general/var-set.schema.ts

@@ -0,0 +1,34 @@
+import z from "zod";
+import createBaseBlockSchema from "../base.schema";
+import {
+  CodeExpressionZod,
+  VarTypeZod,
+  InputVarChatBotTypeZod,
+  type VarType,
+} from "../shared/general.types";
+import { regexVarName } from "../validation/regex";
+
+export const CompletionTypesZod = z.enum(["function", "variable"]);
+export type CompletionTypes = z.infer<typeof CompletionTypesZod>;
+
+export const VarSetBlockSchemaZod = createBaseBlockSchema(
+  "var-set",
+  "action",
+).extend({
+  name: z.string().regex(regexVarName),
+  varType: z.union([VarTypeZod, InputVarChatBotTypeZod]),
+  code: CodeExpressionZod,
+  completion: z.union([
+    z.literal(false),
+    z.object({
+      label: z.string().optional(),
+      type: CompletionTypesZod.optional(),
+      detail: z.string().optional(),
+      info: z.string().optional(),
+      apply: z.string().optional(),
+    }),
+  ]),
+});
+
+type VarSetBlock = z.infer<typeof VarSetBlockSchemaZod>;
+export default VarSetBlock;

package/workflow/blocks/registry.ts

@@ -1,18 +1,35 @@
-import type { RunCodeBlockSchema } from "./general/run-code.schema.d.ts";
-import type { StartBlockSchema } from "./general/start.schema.d.ts";
-import type { VarSetBlockSchema } from "./general/var-set.schema.d.ts";
-import type { InputVarChatBotType, VarType } from "./shared/general.types.d.ts";
-import type { SendMsgChatBotBlockSchema } from "./chat_bot/send-msg.schema.d.ts";
-import type { SendFileChatBotBlockSchema } from "./chat_bot/send-file.schema.d.ts";
-import type { InputTextChatBotBlockSchema } from "./chat_bot/input-text.schema.d.ts";
-import type { InputFileChatBotBlockSchema } from "./chat_bot/input-file.schema.d.ts";
+import z from "zod";
+import { StartBlockSchemaZod } from "./general/start.schema.ts";
+import { VarSetBlockSchemaZod } from "./general/var-set.schema.ts";
+import { RunCodeBlockSchemaZod } from "./general/run-code.schema.ts";
+import { SendMsgChatBotBlockSchemaZod } from "./chat_bot/send-msg.schema.ts";
+import { SendFileChatBotBlockSchemaZod } from "./chat_bot/send-file.schema.ts";
+import { InputTextChatBotBlockSchemaZod } from "./chat_bot/input-text.schema.ts";
+import { InputFileChatBotBlockSchemaZod } from "./chat_bot/input-file.schema.ts";
 
-export type GeneralBlockSchema =
-  | StartBlockSchema
-  | VarSetBlockSchema<VarType | InputVarChatBotType>
-  | RunCodeBlockSchema;
-export type ChatBotBlockSchema =
-  | SendMsgChatBotBlockSchema
-  | SendFileChatBotBlockSchema
-  | InputTextChatBotBlockSchema
-  | InputFileChatBotBlockSchema;
+export const GeneralBlockSchemaZods = z.union([
+  StartBlockSchemaZod,
+  VarSetBlockSchemaZod,
+  RunCodeBlockSchemaZod,
+]);
+
+export type GeneralBlocksSchema = z.infer<typeof GeneralBlockSchemaZods>;
+
+export const ChatBotBlocksSchemaZods = z.union([
+  SendMsgChatBotBlockSchemaZod,
+  SendFileChatBotBlockSchemaZod,
+  InputTextChatBotBlockSchemaZod,
+  InputFileChatBotBlockSchemaZod,
+]);
+
+export type ChatBotBlocksSchema = z.infer<typeof ChatBotBlocksSchemaZods>;
+
+export default {
+  StartBlockSchemaZod,
+  VarSetBlockSchemaZod,
+  RunCodeBlockSchemaZod,
+  SendMsgChatBotBlockSchemaZod,
+  SendFileChatBotBlockSchemaZod,
+  InputTextChatBotBlockSchemaZod,
+  InputFileChatBotBlockSchemaZod
+}

package/workflow/blocks/shared/general.types.ts

@@ -0,0 +1,77 @@
+import z from "zod";
+
+export const CodeExpressionZod = z.string();
+export type CodeExpression = z.infer<typeof CodeExpressionZod>;
+/**
+ * Обработчик блока после выхода из основной логики бота
+ */
+export const ExitHandlerZod = z.union([
+  z.literal(false),
+  z.object({ code: z.string() }),
+]);
+export type ExitHandler = z.infer<typeof EntranceHandlerZod>;
+/**
+ * Обработчик блока перед входом в основную логику бота
+ */
+export const EntranceHandlerZod = z.union([
+  z.literal(false),
+  z.object({ code: z.string() }),
+]);
+export type EntranceHandler = z.infer<typeof EntranceHandlerZod>;
+
+export const DynamicTextZod = z.object({
+  useCodeExpression: z.boolean(),
+  code: CodeExpressionZod,
+});
+export type DynamicText = z.infer<typeof DynamicTextZod>;
+
+export const SendTextZod = z.union([z.string(), DynamicTextZod]);
+export type SendText = z.infer<typeof SendTextZod>;
+
+export const ChatIDZod = z.number();
+export type ChatID = z.infer<typeof ChatIDZod>;
+/**
+ * Дополнительные опции для чат-ботов
+ */
+export const AdditionalOptionsZod = z.object({
+  back_button: z.union([
+    z.literal(false),
+    z.string(),
+    z.object({
+      useCodeExpression: z.boolean(),
+      code: CodeExpressionZod,
+    }),
+  ]),
+  skip_button: z.union([
+    z.literal(false),
+    z.string(),
+    z.object({
+      useCodeExpression: z.boolean(),
+      code: CodeExpressionZod,
+    }),
+  ]),
+  send_other_chat: z.union([z.literal(false), ChatIDZod]),
+});
+export type AdditionalOptions = z.infer<typeof AdditionalOptionsZod>;
+
+/**
+ * Типы переменных
+ *
+ * Типы для полученных сообщений из чат-ботов
+ * Общие типы
+ */
+export enum InputVarChatBotType {
+  FILE = "file",
+}
+export const InputVarChatBotTypeZod = z.enum(InputVarChatBotType);
+
+export enum VarType {
+  STRING = "string",
+  NUMBER = "number",
+  BOOLEAN = "boolean",
+  OBJECT = "object",
+  ARRAY = "array",
+  FUNCTION = "function",
+  ANY = "any",
+}
+export const VarTypeZod = z.enum(VarType);

package/workflow/blocks/validation/duplicate-vars.start.ts

@@ -0,0 +1,22 @@
+import { ZodIssueCode } from "zod/v3";
+import type VarSetBlock from "../general/var-set.schema";
+import type z from "zod";
+
+export const validateDuplicateVars = (
+    vars: Pick<VarSetBlock, "name" | "varType" | "code" | "completion">[],
+    ctx: z.RefinementCtx,
+) => {
+    const seen = new Set<string>();
+
+    vars.forEach((v, index) => {
+        if (seen.has(v.name)) {
+            ctx.addIssue({
+                code: ZodIssueCode.custom,
+                message: `Переменная "${v.name}" уже объявлена в этом блоке`,
+                path: [index, "name"],
+            });
+        } else {
+            seen.add(v.name)
+        }
+    });
+};

package/workflow/blocks/validation/regex.ts

@@ -0,0 +1 @@
+export const regexVarName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/g;

package/workflow/edges/base.schema.ts

@@ -0,0 +1,19 @@
+import z from "zod";
+
+export const EdgeTypesZod = z.enum(["query-rule"]);
+export type EdgeTypes = z.infer<typeof EdgeTypesZod>;
+
+const createBaseEdgeSchemaZod = <Type extends EdgeTypes, Guard>(
+  type: Type,
+  guard: Guard,
+) =>
+  z.object({
+    _id: z.string(),
+    label: z.string().optional(),
+    type: z.literal(type),
+    priority: z.number(),
+    source: z.string(),
+    target: z.string(),
+    guards: guard,
+  });
+export default createBaseEdgeSchemaZod;

package/workflow/edges/query-rule.schema.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { VarTypeZod } from "../blocks/shared/general.types";
+import createBaseEdgeSchemaZod from "./base.schema";
+import { VarSetBlockSchemaZod } from "../blocks/general/var-set.schema";
+
+export enum LogicOperator {
+  AND = "and",
+  OR = "or",
+}
+export const LogicOperatorZod = z.enum(LogicOperator);
+export type LogicOperatorType = z.infer<typeof LogicOperatorZod>;
+
+export enum ConditionList {
+  EMPTY = "empty",
+  NOT_EMPTY = "not_empty",
+  EQUAL = "equal",
+  NOT_EQUAL = "not_equal",
+  LESS = "less",
+  LESS_OR_EQUAL = "less_or_equal",
+  GREATER = "greater",
+  GREATER_OR_EQUAL = "greater_or_equal",
+  IS_NULL = "is_null",
+  IS_NOT_NULL = "is_not_null",
+}
+export const ConditionListZod = z.enum(ConditionList);
+export type ConditionListType = z.infer<typeof ConditionListZod>;
+
+export const ValueModeZod = z.object({
+  mode: z.enum(["value", "variable", "expression"]),
+  value: z.string(),
+});
+export type ValueMode = z.infer<typeof ValueModeZod>;
+
+export const SingleRuleGuardSchema = z.object({
+  var: VarSetBlockSchemaZod.pick({
+    name: true,
+    varType: true,
+  }),
+  condition: ConditionListZod,
+  valueMode: ValueModeZod,
+});
+export type SingleRuleGuard = z.infer<typeof SingleRuleGuardSchema>;
+
+export interface RuleGuardGroupSchema {
+  operator: LogicOperator;
+  guards: (SingleRuleGuard | RuleGuardGroupSchema)[];
+}
+export const RuleGuardGroupSchemaZod: z.ZodType<RuleGuardGroupSchema> = z.lazy(
+  () =>
+    z.object({
+      operator: LogicOperatorZod,
+      guards: z.array(
+        z.union([SingleRuleGuardSchema, RuleGuardGroupSchemaZod]),
+      )
+    }),
+);
+
+export const QueryRuleEdgeSchemaZod = createBaseEdgeSchemaZod(
+  "query-rule",
+  RuleGuardGroupSchemaZod,
+);
+export type QueryRuleEdgeSchema = z.infer<typeof QueryRuleEdgeSchemaZod>;

package/workflow/validation/check-edge-to-blocks.ts

@@ -0,0 +1,31 @@
+import type z from "zod";
+import type { ChatBotBlocksSchema, GeneralBlocksSchema } from "../blocks/registry";
+import type { QueryRuleEdgeSchema } from "../edges/query-rule.schema"
+import { ZodIssueCode } from "zod/v3";
+
+
+export const checkEdgeToBlocks = (
+    blocks: (ChatBotBlocksSchema | GeneralBlocksSchema)[],
+    edges: QueryRuleEdgeSchema[],
+    ctx: z.RefinementCtx
+) => {
+    const blockIds = new Set(blocks.map(block => block._id))
+
+    edges.forEach((edge, index) => {
+        if (!blockIds.has(edge.source)) {
+            ctx.addIssue({
+                code: ZodIssueCode.custom,
+                message: `Связь "${edge._id}" ссылается на несуществующий блок source: "${edge.source}"`,
+                path: ["states", "edges", index, "source"]
+            })
+        }
+
+        if (!blockIds.has(edge.target)) {
+            ctx.addIssue({
+                code: ZodIssueCode.custom,
+                message: `Связь "${edge._id}" ссылается на несуществующий блок target: "${edge.target}"`,
+                path: ["states", "edges", index, "target"]
+            })
+        }
+    })
+}

package/workflow/validation/check-rule-var.ts

@@ -0,0 +1,25 @@
+import type z from "zod";
+import type { ChatBotBlocksSchema, GeneralBlocksSchema } from "../blocks/registry";
+import type { QueryRuleEdgeSchema } from "../edges/query-rule.schema"
+
+
+
+/**
+ * Проверяет, есть ли в текущем edge доступ к переменным в rule
+ * Для текущего rule в edge доступ к блокам имеющие переменную(ые) доступно только до edge
+ */
+export const checkRuleVar = (
+    blocks: (ChatBotBlocksSchema | GeneralBlocksSchema)[],
+    edges: QueryRuleEdgeSchema[],
+    ctx: z.RefinementCtx
+) => {
+    const blockIndexed = Object.groupBy(blocks, ({ index }) => index)
+
+    edges.forEach((edge) => {
+        const beginBlock = edge.source;
+        const block = blocks.find((block) => block._id == beginBlock)
+        if (!block) return
+
+
+    })
+}   

package/workflow/validation/duplicate-id-blocks.ts

@@ -0,0 +1,26 @@
+import type z from "zod";
+import type { ChatBotBlocksSchema, GeneralBlocksSchema } from "../blocks/registry";
+import { ZodIssueCode } from "zod/v3";
+
+/**
+ * Валидация блоков на id. Должны быть уникальными
+ */
+export const duplicateIdBlocks = (
+    blocks: (ChatBotBlocksSchema | GeneralBlocksSchema)[],
+    ctx: z.RefinementCtx
+) => {
+    const seen = new Set<string>();
+
+    blocks.forEach((block, index) => {
+        if (seen.has(block._id)) {
+
+            ctx.addIssue({
+                code: ZodIssueCode.custom,
+                message: `_id "${block._id}" с индексом ${block.index} уже используется`,
+                path: [index, "name"],
+            });
+        } else {
+            seen.add(block._id)
+        }
+    })
+}

package/workflow/validation/duplicate-id-edges.ts

@@ -0,0 +1,24 @@
+import type z from "zod";
+import { ZodIssueCode } from "zod/v3";
+import type { QueryRuleEdgeSchema } from "../edges/query-rule.schema";
+
+/**
+ * Валидация связей на id. Должны быть уникальными
+ */
+export const duplicateIdEdges = (
+    edges: QueryRuleEdgeSchema[],
+    ctx: z.RefinementCtx
+) => {
+    const seen = new Set<string>();
+    edges.forEach((edge, index) => {
+        if (seen.has(edge._id)) {
+            ctx.addIssue({
+                code: ZodIssueCode.custom,
+                message: `_id "${edge._id}" уже используется`,
+                path: [index, "name"],
+            });
+        } else {
+            seen.add(edge._id)
+        }
+    })
+}

package/workflow/workflow.schema.ts

@@ -0,0 +1,41 @@
+import z from "zod";
+import {
+  ChatBotBlocksSchemaZods,
+  GeneralBlockSchemaZods,
+} from "./blocks/registry";
+import {
+  QueryRuleEdgeSchemaZod,
+  type QueryRuleEdgeSchema,
+} from "./edges/query-rule.schema";
+import { checkEdgeToBlocks } from "./validation/check-edge-to-blocks";
+import { duplicateIdBlocks } from "./validation/duplicate-id-blocks";
+import { duplicateIdEdges } from "./validation/duplicate-id-edges";
+import { checkRuleVar } from "./validation/check-rule-var";
+
+export const MetadataSchemaZod = z.object({
+  name: z.string(),
+  description: z.string(),
+  exportedAt: z.iso.datetime(),
+});
+
+export type MetadataSchema = z.infer<typeof MetadataSchemaZod>;
+
+export const WorkflowSchemaZod = z.object({
+  metadata: MetadataSchemaZod,
+  states: z.object({
+    edges: z.array(QueryRuleEdgeSchemaZod)
+      .superRefine((edges, ctx) => duplicateIdEdges(edges, ctx)),
+    blocks: z.array(z.union([GeneralBlockSchemaZods, ChatBotBlocksSchemaZods]))
+      .superRefine((blocks, ctx) => duplicateIdBlocks(blocks, ctx)),
+  }),
+}).superRefine((data, ctx) => {
+  const { states } = data
+  const { edges, blocks } = states
+
+  checkEdgeToBlocks(blocks, edges, ctx)
+  // checkRuleVar(blocks, edges, ctx)
+});
+
+type WorkflowSchema = z.infer<typeof WorkflowSchemaZod>;
+
+export default WorkflowSchema;

package/workflow/blocks/base.schema.d.ts

@@ -1,19 +0,0 @@
-import type { EntranceHandler, ExitHandler } from "./shared/general.types";
-
-type ChatBotBlockTypes = "send_file" | "send_msg" | "input-text" | "input-file";
-
-type MainBlockTypes = "start" | "var_set" | "run_code";
-
-type BlockTypes = MainBlockTypes | ChatBotBlockTypes;
-
-export interface BaseBlockSchema<T extends BlockTypes> {
-  _id: string;
-  type: T;
-  label: string;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  entrance: EntranceHandler;
-  exit: ExitHandler;
-}

package/workflow/blocks/chat_bot/send-msg.schema.d.ts

@@ -1,11 +0,0 @@
-import type { BaseBlockSchema } from "../base.schema";
-import type { AdditionalOptions, SendText } from "../shared/general.types";
-
-/**
- * Блок отвечающий за отправление текстового сообщения
- */
-export interface SendMsgChatBotBlockSchema extends BaseBlockSchema<"send_msg"> {
-  markdown: boolean;
-  sendText: SendText;
-  additionalOptions: Pick<AdditionalOptions, "send_other_chat">;
-}

package/workflow/blocks/general/run-code.schema.d.ts

@@ -1,8 +0,0 @@
-import type { BaseBlockSchema } from "../base.schema";
-
-/**
- * Блок отвечающий за запуск кода
- */
-export interface RunCodeBlockSchema extends BaseBlockSchema<"run_code"> {
-  code: string;
-}

package/workflow/blocks/general/start.schema.d.ts

@@ -1,10 +0,0 @@
-import type { BaseBlockSchema } from "../base.schema";
-import type { VarType } from "../shared/general.types";
-import type { VarSetBlockSchema } from "./var-set.schema";
-
-/**
- * Блок отвечающий за запуск сценария и содержащий все необходимые переменные для работы
- */
-export interface StartBlockSchema extends BaseBlockSchema<"start"> {
-  vars: VarSetBlockSchema<VarType>[];
-}

package/workflow/blocks/general/var-set.schema.d.ts

@@ -1,25 +0,0 @@
-import type { BaseBlockSchema } from "../base.schema";
-import type { VarType, InputVarChatBotType } from "../shared/general.types";
-
-type CompletionTypes = `function` | `variable`;
-
-/**
- * Блок отвечающий за создание переменной в контексте клиента
- */
-export interface VarSetBlockSchema<
-  Type extends VarType | InputVarChatBotType,
-> extends BaseBlockSchema<"var_set"> {
-  name: string;
-  varType: Type;
-  code: string;
-  completion:
-    | false
-    | {
-        // для подсказки в редакторе-codemirror
-        label?: string;
-        type?: CompletionTypes;
-        detail?: string;
-        info?: string;
-        apply?: string;
-      };
-}

package/workflow/blocks/shared/general.types.d.ts

@@ -1,63 +0,0 @@
-export type CodeExpression = string;
-/**
- * Обработчик блока после выхода из основной логики бота
- */
-export type ExitHandler =
-  | false
-  | {
-      code: string;
-    };
-/**
- * Обработчик блока перед входом в основную логику бота
- */
-export type EntranceHandler =
-  | false
-  | {
-      code: string;
-    };
-
-interface DynamicText {
-  useCodeExpression: boolean;
-  code: CodeExpression;
-}
-export type SendText = string | DynamicText;
-export type ChatID = number;
-/**
- * Дополнительные опции для чат-ботов
- */
-export type AdditionalOptions = {
-  back_button:
-    | false
-    | string
-    | {
-        useCodeExpression: boolean;
-        code: CodeExpression;
-      };
-  skip_button:
-    | false
-    | string
-    | {
-        useCodeExpression: boolean;
-        code: CodeExpression;
-      };
-  send_other_chat: false | ChatID;
-};
-
-/**
- * Типы переменных
- *
- * Типы для полученных сообщений из чат-ботов
- * Общие типы
- */
-export enum InputVarChatBotType {
-  FILE = "file",
-}
-export enum VarType {
-  STRING = "string",
-  NUMBER = "number",
-  BOOLEAN = "boolean",
-  OBJECT = "object",
-  ARRAY = "array",
-  FUNCTION = "function",
-  ANY = "any",
-}

package/workflow/edges/base.schema.d.ts

@@ -1,9 +0,0 @@
-export type EdgeTypes = "query-rule";
-
-export interface BaseEdgeSchema<Type extends EdgeTypes, Guard> {
-  label?: string;
-  type: Type;
-  priority: number;
-  to: string;
-  guards: Guard;
-}

package/workflow/edges/query-rule.schema.d.ts

@@ -1,38 +0,0 @@
-import type { VarType } from "../blocks/shared/general.types";
-import type { BaseEdgeSchema } from "./base.schema";
-
-export enum LogicOperator {
-  AND = "and",
-  OR = "or",
-}
-export enum ConditionList {
-  EMPTY = "empty",
-  NOT_EMPTY = "not_empty",
-  EQUAL = "equal",
-  NOT_EQUAL = "not_equal",
-  LESS = "less",
-  LESS_OR_EQUAL = "less_or_equal",
-  GREATER = "greater",
-  GREATER_OR_EQUAL = "greater_or_equal",
-  IS_NULL = "is_null",
-  IS_NOT_NULL = "is_not_null",
-}
-
-export interface SingleRuleGuard {
-  var: string;
-  typeVar: VarType;
-  /*--*/
-  condition: ConditionList;
-  /*--*/
-  valueMode: {
-    mode: "value" | "variable" | "expression";
-    value: string;
-  };
-}
-
-export interface RuleGuardGroup {
-  operator: LogicOperator;
-  guards: (SingleRuleGuard | RuleGuardGroup)[];
-}
-
-export type QueryRuleEdgeSchema = BaseEdgeSchema<"query-rule", RuleGuardGroup>;

package/workflow/workflow.schema.d.ts

@@ -1,18 +0,0 @@
-import type { ChatBotBlockSchema, GeneralBlockSchema } from "./blocks/registry";
-import type { QueryRuleEdgeSchema } from "./edges/query-rule.schema";
-
-export interface Metadata {
-  name: string;
-  description: string;
-  exportedAt: string;
-}
-
-interface WorkflowSchema {
-  states: {
-    blocks: (GeneralBlockSchema | ChatBotBlockSchema)[];
-    edges: QueryRuleEdgeSchema[];
-  };
-  metadata: Metadata;
-}
-
-export default WorkflowSchema;