Release v1.32.0

packages/backend/package.json

@@ -105,5 +105,5 @@
     "tsconfig-paths": "^4.2.0",
     "type-fest": "4.10.3"
   },
-  "version": "1.31.4"
+  "version": "1.32.0"
 }

packages/backend/src/apps/custom-api/__tests__/actions/http-request.test.ts

@@ -226,4 +226,91 @@ describe('make http request', () => {
     mocks.httpRequest.mockRejectedValueOnce(disallowedIpError)
     await expect(makeRequestAction.run($)).rejects.toThrowError(StepError)
   })
+
+  describe('tests that data is valid JSON', () => {
+    // NOTE: caters for existing users that are sending strings in the data field
+    it.each(['[1, 2, 3]', 'meep meep'])(
+      'should not throw error if data is string',
+      async (testData: any) => {
+        $.step.parameters.method = 'POST'
+        $.step.parameters.data = testData
+        $.step.parameters.url = 'http://test.local/endpoint?1234'
+
+        mocks.httpRequest.mockReturnValue('mock response')
+
+        await makeRequestAction.run($).catch(() => null)
+        expect(mocks.httpRequest).toHaveBeenCalledWith(
+          expect.objectContaining({
+            url: $.step.parameters.url,
+            method: $.step.parameters.method,
+            data: $.step.parameters.data,
+          }),
+        )
+      },
+    )
+
+    it.each([
+      '{"abc": 123}',
+      '{"abc": "def", "ghi": 456, "jkl": {"nested": "nested-value"}}',
+      '{"abc": "def", "ghi": 456, "jkl": {"nested": {"nested-nested": "nested-nested-value"}}}',
+      JSON.stringify({ data: undefined }),
+      JSON.stringify({ data: null }),
+      null,
+      '',
+    ])(
+      'should not throw error if data is valid JSON or null or empty string',
+      async (testJSON: any) => {
+        $.step.parameters.method = 'POST'
+        $.step.parameters.data = testJSON
+
+        $.step.parameters.url = 'http://test.local/endpoint?1234'
+        mocks.httpRequest.mockReturnValue('mock response')
+
+        await makeRequestAction.run($).catch(() => null)
+        expect(mocks.httpRequest).toHaveBeenCalledWith(
+          expect.objectContaining({
+            url: $.step.parameters.url,
+            method: $.step.parameters.method,
+            data: $.step.parameters.data,
+          }),
+        )
+      },
+    )
+
+    it.each([
+      '{"abc": 123',
+      '"abc": 123}',
+      '{""abc"": "def"}',
+      '{"name": "zuck""}',
+      '{"name": "zuck", "age": "40}',
+      '{ this looks like json but isnt }',
+    ])(
+      'should throw error if data is not valid JSON',
+      async (testJSON: any) => {
+        $.step.parameters.method = 'POST'
+        $.step.parameters.data = testJSON
+        $.step.parameters.url = 'http://test.local/endpoint?1234'
+
+        mocks.httpRequest.mockReturnValue('mock response')
+        await expect(makeRequestAction.run($)).rejects.toThrowError(
+          'Invalid JSON data',
+        )
+      },
+    )
+  })
+
+  describe('escaping variables should maintain original type', () => {
+    it.each([
+      [true, true],
+      [false, false],
+      ['true', 'true'],
+      [123, 123],
+      ['string with "quotes" inside', 'string with \\"quotes\\" inside'],
+      ['string without quotes', 'string without quotes'],
+      ['{string with braces}', '{string with braces}'],
+    ])('should escape variables', (input, expected) => {
+      const escaped = makeRequestAction.preprocessVariable('data', input)
+      expect(escaped).toBe(expected)
+    })
+  })
 })

packages/backend/src/apps/custom-api/actions/http-request/index.ts

@@ -81,19 +81,28 @@ const action: IRawAction = {
     },
   ],
 
+  preprocessVariable(parameterKey: string, variableValue: unknown) {
+    if (parameterKey === 'data' && typeof variableValue === 'string') {
+      // NOTE: this removes the " from the start and end of the string
+      // as it is already added in the user input
+      return JSON.stringify(variableValue).slice(1, -1)
+    }
+    return variableValue
+  },
+
   async run($) {
     const method = $.step.parameters.method as TMethod
     const data = $.step.parameters.data as string
     const url = $.step.parameters.url as string
 
     try {
       const parsedS = requestSchema.parse($.step.parameters)
-      const { customHeaders } = parsedS
+      const { customHeaders, data: parsedData } = parsedS
 
       let response = await $.http.request({
         url,
         method,
-        data,
+        data: parsedData,
         maxRedirects: 0,
         headers: customHeaders,
         //  overwriting this to allow redirects to resolve

packages/backend/src/apps/custom-api/actions/http-request/schema.ts

@@ -47,4 +47,27 @@ export const requestSchema = z.object({
       return result
     })
     .nullish(),
+  data: z
+    .string()
+    .transform((str, ctx) => {
+      // Allow empty string
+      if (str === '') {
+        return str
+      }
+
+      try {
+        // NOTE: assume that user is trying to input JSON data if it starts with { or ends with }
+        if (str.startsWith('{') || str.endsWith('}')) {
+          JSON.parse(str) // to test for valid JSON
+        }
+        return str
+      } catch (e) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: 'Invalid JSON data',
+        })
+        return z.NEVER
+      }
+    })
+    .nullish(),
 })

packages/backend/src/apps/custom-api/common/add-headers.ts

@@ -2,8 +2,9 @@ import { TBeforeRequest } from '@plumber/types'
 
 const addHeaders: TBeforeRequest = async ($, requestConfig) => {
   const authData = $.auth.data
+  requestConfig.headers.set('Content-Type', 'application/json', false)
+
   if (authData?.headers) {
-    requestConfig.headers.set('Content-Type', 'application/json', true)
     Object.entries(authData.headers).forEach(([key, value]) =>
       requestConfig.headers.set(key, value),
     )

packages/backend/src/apps/formatter/__tests__/date-time.common.test.ts

@@ -64,5 +64,10 @@ describe('common date-time formatter functions', () => {
         expect(dateTime.toUnixInteger()).toEqual(1727452800)
       },
     )
+
+    it('supports parsing MyInfo Child date field', () => {
+      const dateTime = parseDateTime('dd/LL/yyyy', '25/03/2024')
+      expect(dateTime.toUnixInteger()).toEqual(1711296000)
+    })
   })
 })

packages/backend/src/apps/formatter/__tests__/date-time.format.test.ts

@@ -71,6 +71,54 @@ describe('convert date time', () => {
       toFormat: 'dd/LL/yy',
       expectedResult: '01/04/24',
     },
+    {
+      inputFormat: 'dd/LL/yy',
+      inputValue: '01/04/24',
+      toFormat: 'dd/LL/yyyy',
+      expectedResult: '01/04/2024',
+    },
+    {
+      inputFormat: 'dd/LL/yyyy',
+      inputValue: '01/04/2024',
+      toFormat: 'dd LLLL yyyy',
+      expectedResult: '01 April 2024',
+    },
+    {
+      inputFormat: 'dd LLLL yyyy',
+      inputValue: '01 April 2024',
+      toFormat: 'yyyy/LL/dd',
+      expectedResult: '2024/04/01',
+    },
+    {
+      inputFormat: 'yyyy/LL/dd',
+      inputValue: '2024/04/01',
+      toFormat: 'hh:mm a',
+      expectedResult: '12:00 am',
+    },
+    {
+      inputFormat: 'hh:mm a',
+      inputValue: '11:45 pm',
+      toFormat: 'hh:mm:ss a',
+      expectedResult: '11:45:00 pm',
+    },
+    {
+      inputFormat: 'hh:mm:ss a',
+      inputValue: '11:45:00 pm',
+      toFormat: 'hh:mm a',
+      expectedResult: '11:45 pm',
+    },
+    {
+      inputFormat: 'dd LLL yyyy hh:mm a',
+      inputValue: '01 Apr 2024 11:45 pm',
+      toFormat: 'dd LLL yyyy',
+      expectedResult: '01 Apr 2024',
+    },
+    {
+      inputFormat: 'dd LLL yyyy hh:mm:ss a',
+      inputValue: '01 Apr 2024 11:45:30 pm',
+      toFormat: 'hh:mm:ss a',
+      expectedResult: '11:45:30 pm',
+    },
   ])('can handle all supported input formats', (testParams) => {
     const { inputFormat, inputValue, toFormat, expectedResult } = testParams
     $.step.parameters = {

packages/backend/src/apps/formatter/actions/date-time/common/date-format-options.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod'
+
+import { ensureZodEnumValue } from '@/helpers/zod-utils'
+
+// These are the list of common input and output date format options
+export const commonDateFormats = [
+  'dd/LL/yy',
+  'dd/LL/yyyy',
+  'dd LLL yyyy',
+  'dd LLLL yyyy',
+  'yyyy/LL/dd',
+  'hh:mm a',
+  'hh:mm:ss a',
+  'dd LLL yyyy hh:mm a',
+  'dd LLL yyyy hh:mm:ss a',
+] as const
+
+const formatStringsEnum = z.enum(commonDateFormats)
+
+export const commonDateFormatOptions = [
+  {
+    label: 'DD/MM/YY',
+    description: '25/03/24',
+    value: ensureZodEnumValue(formatStringsEnum, 'dd/LL/yy'),
+  },
+  {
+    label: 'DD/MM/YYYY',
+    description: '25/03/2024',
+    value: ensureZodEnumValue(formatStringsEnum, 'dd/LL/yyyy'),
+  },
+  {
+    label: 'DD MMM YYYY',
+    description: '25 Mar 2024',
+    value: ensureZodEnumValue(formatStringsEnum, 'dd LLL yyyy'),
+  },
+  {
+    label: 'DD MMMM YYYY',
+    description: '25 March 2024',
+    value: ensureZodEnumValue(formatStringsEnum, 'dd LLLL yyyy'),
+  },
+  {
+    label: 'YYYY/MM/DD',
+    description: '2024/03/25',
+    value: ensureZodEnumValue(formatStringsEnum, 'yyyy/LL/dd'),
+  },
+  {
+    label: 'HH:mm (am/pm)',
+    description: '12:04 PM',
+    value: ensureZodEnumValue(formatStringsEnum, 'hh:mm a'),
+  },
+  {
+    label: 'HH:mm:ss (am/pm)',
+    description: '12:04:05 pm',
+    value: ensureZodEnumValue(formatStringsEnum, 'hh:mm:ss a'),
+  },
+  {
+    label: 'DD MMM YYYY HH:mm (am/pm)',
+    description: '25 Mar 2024 12:04 pm',
+    value: ensureZodEnumValue(formatStringsEnum, 'dd LLL yyyy hh:mm a'),
+  },
+  {
+    label: 'DD MMM YYYY HH:mm:ss (am/pm)',
+    description: '25 Mar 2024 12:04:05 pm',
+    value: ensureZodEnumValue(formatStringsEnum, 'dd LLL yyyy hh:mm:ss a'),
+  },
+]