chore: use schema to validate input

kevinkim-ogp · kevinkim-ogp · commit f84d759957f8 · 2025-06-11T14:28:50.000+08:00
diff --git a/packages/backend/src/apps/toolbox/__tests__/actions/for-each/schema.test.ts b/packages/backend/src/apps/toolbox/__tests__/actions/for-each/schema.test.ts
@@ -0,0 +1,249 @@
+import { describe, expect, it } from 'vitest'
+
+import { inputSchema } from '../../../actions/for-each/schema'
+
+describe('inputSchema', () => {
+  describe('table input format', () => {
+    it('should parse valid table input', () => {
+      const validTableInput = JSON.stringify({
+        rows: [
+          {
+            data: { name: 'John', age: 25 },
+            rowId: 'row1',
+          },
+          {
+            data: { name: 'Jane', age: 30 },
+          },
+        ],
+        columns: [
+          { id: 'name', name: 'Name', value: 'name' },
+          { id: 'age', name: 'Age', value: 'age' },
+        ],
+      })
+
+      const result = inputSchema.safeParse(validTableInput)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        const { type, items } = result.data
+        expect(type).toBe('table')
+        if (type === 'table') {
+          expect(items.rows).toHaveLength(2)
+          expect(items.columns).toHaveLength(2)
+          expect(items.rows[0].data.name).toBe('John')
+          expect(items.rows[0].rowId).toBe('row1')
+          expect(items.rows[1].rowId).toBeUndefined()
+        }
+      }
+    })
+
+    it('should parse table input without rowId', () => {
+      const validTableInput = JSON.stringify({
+        rows: [
+          {
+            data: { name: 'Alice', score: 95.5 },
+          },
+        ],
+        columns: [
+          { id: 'name', name: 'Name', value: 'name' },
+          { id: 'score', name: 'Score', value: 'score' },
+        ],
+      })
+
+      const result = inputSchema.safeParse(validTableInput)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('table')
+        if (result.data.type === 'table') {
+          expect(result.data.items.rows[0].data.score).toBe(95.5)
+        }
+      }
+    })
+
+    it('should trim whitespace before processing', () => {
+      const validTableInput = JSON.stringify({
+        rows: [{ data: { name: 'John' } }],
+        columns: [{ id: 'name', name: 'Name', value: 'name' }],
+      })
+
+      const result = inputSchema.safeParse(`  ${validTableInput}  `)
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('table')
+      }
+    })
+
+    it('should reject table input with missing rows', () => {
+      const invalidTableInput = JSON.stringify({
+        columns: [{ id: 'name', name: 'Name', value: 'name' }],
+      })
+
+      const result = inputSchema.safeParse(invalidTableInput)
+
+      expect(result.success).toBe(false)
+      if (result.success === false) {
+        expect(result.error.issues[0].message).toBe(
+          'Invalid table format: must have rows and columns',
+        )
+      }
+    })
+
+    it('should reject table input with missing columns', () => {
+      const invalidTableInput = JSON.stringify({
+        rows: [
+          {
+            data: { name: 'John' },
+          },
+        ],
+      })
+
+      const result = inputSchema.safeParse(invalidTableInput)
+
+      expect(result.success).toBe(false)
+      if (result.success === false) {
+        expect((result as any).error.issues[0].message).toBe(
+          'Invalid table format: must have rows and columns',
+        )
+      }
+    })
+
+    it('should reject table input with invalid row structure', () => {
+      const invalidTableInput = JSON.stringify({
+        rows: [
+          {
+            invalidField: 'test',
+          },
+        ],
+        columns: [{ id: 'name', name: 'Name', value: 'name' }],
+      })
+
+      const result = inputSchema.safeParse(invalidTableInput)
+
+      expect(result.success).toBe(false)
+      if (result.success === false) {
+        expect(result.error.issues[0].message).toBe(
+          'Invalid table format: must have rows and columns',
+        )
+      }
+    })
+
+    it('should reject table input with invalid column structure', () => {
+      const invalidTableInput = JSON.stringify({
+        rows: [
+          {
+            data: { name: 'John' },
+          },
+        ],
+        columns: [
+          { id: 'name', name: 'Name' }, // missing 'value' field
+        ],
+      })
+
+      const result = inputSchema.safeParse(invalidTableInput)
+
+      expect(result.success).toBe(false)
+      if (result.success === false) {
+        expect(result.error.issues[0].message).toBe(
+          'Invalid table format: must have rows and columns',
+        )
+      }
+    })
+
+    it.each([
+      '{ "rows": [invalid json',
+      '{"item1": value1, "item2": "value2"}',
+      'item1,item2}',
+    ])('should reject malformed JSON', (malformedJson) => {
+      const result = inputSchema.safeParse(malformedJson)
+
+      expect(result.success).toBe(false)
+      if (result.success === false) {
+        expect(result.error.issues[0].message).toBe('Invalid JSON format')
+      }
+    })
+  })
+
+  describe('checkbox input format', () => {
+    it('should parse single item', () => {
+      const result = inputSchema.safeParse('item1')
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('checkbox')
+        expect(result.data.items).toEqual(['item1'])
+      }
+    })
+
+    it('should parse multiple comma-separated items', () => {
+      const result = inputSchema.safeParse('item1,item2,item3')
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('checkbox')
+        expect(result.data.items).toEqual(['item1', 'item2', 'item3'])
+      }
+    })
+
+    it('should handle items with spaces', () => {
+      const result = inputSchema.safeParse('item 1, item 2 , item 3')
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('checkbox')
+        expect(result.data.items).toEqual(['item 1', ' item 2 ', ' item 3'])
+      }
+    })
+
+    it('should handle empty items in comma-separated list', () => {
+      const result = inputSchema.safeParse('item1,,item3')
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('checkbox')
+        expect(result.data.items).toEqual(['item1', '', 'item3'])
+      }
+    })
+
+    it('should trim whitespace for checkbox input', () => {
+      const result = inputSchema.safeParse('  item1,item2  ')
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('checkbox')
+        expect(result.data.items).toEqual(['item1', 'item2'])
+      }
+    })
+
+    it('should handle single comma (results in two empty items)', () => {
+      const result = inputSchema.safeParse(',')
+
+      expect(result.success).toBe(true)
+      if (result.success) {
+        expect(result.data.type).toBe('checkbox')
+        expect(result.data.items).toEqual(['', ''])
+      }
+    })
+  })
+
+  describe('edge cases and validation', () => {
+    it('should reject empty string', () => {
+      const result = inputSchema.safeParse('')
+
+      expect(result.success).toBe(false)
+      if (result.success === false) {
+        expect(result.error.issues[0].message).toBe('Input cannot be empty')
+      }
+    })
+
+    it('should reject whitespace-only string', () => {
+      const result = inputSchema.safeParse('   ')
+
+      expect(result.success).toBe(false)
+      if (result.success === false) {
+        expect(result.error.issues[0].message).toBe('Input cannot be empty')
+      }
+    })
+  })
+})
diff --git a/packages/backend/src/apps/toolbox/actions/for-each/index.ts b/packages/backend/src/apps/toolbox/actions/for-each/index.ts
@@ -3,6 +3,7 @@ import { IRawAction } from '@plumber/types'
 import StepError from '@/errors/step'
 
 import getDataOutMetadata from './get-data-out-metadata'
+import { inputSchema } from './schema'
 
 const action: IRawAction = {
   name: 'For each',
@@ -14,42 +15,35 @@ const action: IRawAction = {
       label: 'Choose items',
       description:
         'Supported items include rows in Tiles/M365 Excel and FormSG checkboxes',
-      key: 'forEachInputList',
+      key: 'items',
       type: 'string' as const,
       required: true,
       variables: true,
-      variableTypes: ['array', 'multiple-row-object'],
+      variableTypes: ['array', 'table'],
     },
   ],
 
   getDataOutMetadata,
 
   async run($) {
-    const { forEachInputList } = $.step.parameters as {
-      forEachInputList: string
-    }
+    const { items: rawItems } = $.step.parameters
+    const parsedResult = inputSchema.safeParse(rawItems)
 
-    try {
-      const isJsonString =
-        forEachInputList.includes('[') || forEachInputList.includes('{')
-      const inputList = isJsonString
-        ? JSON.parse(forEachInputList)
-        : forEachInputList.split(',').map((item) => item.trim())
-
-      $.setActionItem({
-        raw: {
-          iterations: isJsonString ? inputList.rows.length : inputList.length,
-        },
-      })
-    } catch (err) {
-      console.error(err)
+    if (!parsedResult.success) {
       throw new StepError(
         'Invalid input list',
         'Select a valid input list',
         $.step.position,
         $.app.name,
       )
     }
+
+    const { type, items } = parsedResult.data
+    $.setActionItem({
+      raw: {
+        iterations: type === 'checkbox' ? items.length : items.rows.length,
+      },
+    })
   },
 }
 
diff --git a/packages/backend/src/apps/toolbox/actions/for-each/schema.ts b/packages/backend/src/apps/toolbox/actions/for-each/schema.ts
@@ -0,0 +1,77 @@
+import { z } from 'zod'
+
+// Define specific schemas for each input type
+const tableInputSchema = z.object({
+  rows: z.array(
+    z.object({
+      data: z.record(z.string(), z.string().or(z.number())),
+      rowId: z.string().optional(), // only for tiles
+    }),
+  ),
+  columns: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      value: z.string(),
+    }),
+  ),
+})
+
+// Create a discriminated union based on input format
+export const inputSchema = z
+  .string()
+  .min(1, 'Input cannot be empty')
+  .transform((str, ctx) => {
+    const trimmed = str.trim()
+
+    if (trimmed.length === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Input cannot be empty',
+      })
+      return z.NEVER
+    }
+
+    // Handle table input (JSON object)
+    if (trimmed.startsWith('{') || trimmed.endsWith('}')) {
+      try {
+        const parsed = JSON.parse(trimmed)
+        const result = tableInputSchema.safeParse(parsed)
+
+        if (!result.success) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'Invalid table format: must have rows and columns',
+          })
+          return z.NEVER
+        }
+
+        return {
+          type: 'table' as const,
+          items: result.data,
+        }
+      } catch (error) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: 'Invalid JSON format',
+        })
+        return z.NEVER
+      }
+    }
+
+    // Handle checkbox input (comma-separated values)
+    const items = trimmed.split(',')
+
+    if (items.length === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'No valid items found in comma-separated input',
+      })
+      return z.NEVER
+    }
+
+    return {
+      type: 'checkbox' as const,
+      items,
+    }
+  })
