⚡ (engine) Improve engine overall robustness

packages/models/features/blocks/logic/code.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+import { blockBaseSchema } from '../baseSchemas'
+import { LogicBlockType } from './enums'
+
+export const codeOptionsSchema = z.object({
+  name: z.string(),
+  content: z.string().optional(),
+  shouldExecuteInParentContext: z.boolean().optional(),
+})
+
+export const codeBlockSchema = blockBaseSchema.and(
+  z.object({
+    type: z.enum([LogicBlockType.CODE]),
+    options: codeOptionsSchema,
+  })
+)
+
+export const defaultCodeOptions: CodeOptions = { name: 'Code snippet' }
+
+export type CodeBlock = z.infer<typeof codeBlockSchema>
+export type CodeOptions = z.infer<typeof codeOptionsSchema>

packages/models/features/blocks/logic/condition.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod'
+import { ItemType } from '../../items/enums'
+import { itemBaseSchema } from '../../items/baseSchemas'
+import { blockBaseSchema } from '../baseSchemas'
+import { LogicBlockType } from './enums'
+
+export enum LogicalOperator {
+  OR = 'OR',
+  AND = 'AND',
+}
+
+export enum ComparisonOperators {
+  EQUAL = 'Equal to',
+  NOT_EQUAL = 'Not equal',
+  CONTAINS = 'Contains',
+  GREATER = 'Greater than',
+  LESS = 'Less than',
+  IS_SET = 'Is set',
+}
+
+const comparisonSchema = z.object({
+  id: z.string(),
+  variableId: z.string().optional(),
+  comparisonOperator: z.nativeEnum(ComparisonOperators).optional(),
+  value: z.string().optional(),
+})
+
+const conditionContentSchema = z.object({
+  logicalOperator: z.nativeEnum(LogicalOperator),
+  comparisons: z.array(comparisonSchema),
+})
+
+export const conditionItemSchema = itemBaseSchema.and(
+  z.object({
+    type: z.literal(ItemType.CONDITION),
+    content: conditionContentSchema,
+  })
+)
+
+export const conditionBlockSchema = blockBaseSchema.and(
+  z.object({
+    type: z.enum([LogicBlockType.CONDITION]),
+    items: z.array(conditionItemSchema),
+  })
+)
+
+export const defaultConditionContent: ConditionContent = {
+  comparisons: [],
+  logicalOperator: LogicalOperator.AND,
+}
+
+export type ConditionItem = z.infer<typeof conditionItemSchema>
+export type Comparison = z.infer<typeof comparisonSchema>
+export type ConditionBlock = z.infer<typeof conditionBlockSchema>
+export type ConditionContent = z.infer<typeof conditionContentSchema>

packages/models/features/blocks/logic/enums.ts

@@ -0,0 +1,7 @@
+export enum LogicBlockType {
+  SET_VARIABLE = 'Set variable',
+  CONDITION = 'Condition',
+  REDIRECT = 'Redirect',
+  CODE = 'Code',
+  TYPEBOT_LINK = 'Typebot link',
+}

packages/models/features/blocks/logic/index.ts

@@ -0,0 +1,7 @@
+export * from './code'
+export * from './condition'
+export * from './enums'
+export * from './logicBlock'
+export * from './redirect'
+export * from './setVariable'
+export * from './typebotLink'

packages/models/features/blocks/logic/logicBlock.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+import { codeOptionsSchema, codeBlockSchema } from './code'
+import { conditionBlockSchema } from './condition'
+import { redirectOptionsSchema, redirectBlockSchema } from './redirect'
+import { setVariableOptionsSchema, setVariableBlockSchema } from './setVariable'
+import { typebotLinkOptionsSchema, typebotLinkBlockSchema } from './typebotLink'
+
+const logicBlockOptionsSchema = codeOptionsSchema
+  .or(redirectOptionsSchema)
+  .or(setVariableOptionsSchema)
+  .or(typebotLinkOptionsSchema)
+
+export const logicBlockSchema = codeBlockSchema
+  .or(conditionBlockSchema)
+  .or(redirectBlockSchema)
+  .or(typebotLinkBlockSchema)
+  .or(setVariableBlockSchema)
+
+export type LogicBlock = z.infer<typeof logicBlockSchema>
+export type LogicBlockOptions = z.infer<typeof logicBlockOptionsSchema>

packages/models/features/blocks/logic/redirect.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+import { blockBaseSchema } from '../baseSchemas'
+import { LogicBlockType } from './enums'
+
+export const redirectOptionsSchema = z.object({
+  url: z.string().optional(),
+  isNewTab: z.boolean(),
+})
+
+export const redirectBlockSchema = blockBaseSchema.and(
+  z.object({
+    type: z.enum([LogicBlockType.REDIRECT]),
+    options: redirectOptionsSchema,
+  })
+)
+
+export const defaultRedirectOptions: RedirectOptions = { isNewTab: false }
+
+export type RedirectBlock = z.infer<typeof redirectBlockSchema>
+export type RedirectOptions = z.infer<typeof redirectOptionsSchema>

packages/models/features/blocks/logic/setVariable.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+import { blockBaseSchema } from '../baseSchemas'
+import { LogicBlockType } from './enums'
+
+export const setVariableOptionsSchema = z.object({
+  variableId: z.string().optional(),
+  expressionToEvaluate: z.string().optional(),
+  isCode: z.boolean().optional(),
+})
+
+export const setVariableBlockSchema = blockBaseSchema.and(
+  z.object({
+    type: z.enum([LogicBlockType.SET_VARIABLE]),
+    options: setVariableOptionsSchema,
+  })
+)
+
+export const defaultSetVariablesOptions: SetVariableOptions = {}
+
+export type SetVariableBlock = z.infer<typeof setVariableBlockSchema>
+export type SetVariableOptions = z.infer<typeof setVariableOptionsSchema>

packages/models/features/blocks/logic/typebotLink.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod'
+import { blockBaseSchema } from '../baseSchemas'
+import { LogicBlockType } from './enums'
+
+export const typebotLinkOptionsSchema = z.object({
+  typebotId: z.string().optional(),
+  groupId: z.string().optional(),
+})
+
+export const typebotLinkBlockSchema = blockBaseSchema.and(
+  z.object({
+    type: z.enum([LogicBlockType.TYPEBOT_LINK]),
+    options: typebotLinkOptionsSchema,
+  })
+)
+
+export const defaultTypebotLinkOptions: TypebotLinkOptions = {}
+
+export type TypebotLinkBlock = z.infer<typeof typebotLinkBlockSchema>
+export type TypebotLinkOptions = z.infer<typeof typebotLinkOptionsSchema>