Fix schedule edit double-encoding header fields

src/lib/stores/schedules.ts

@@ -27,13 +27,6 @@ type ScheduleParameterArgs = {
   presets: SchedulePresetsParameters;
 };
 
-// TODO: Post Beta, add support of additional fields.
-// "startTime": "2022-07-04T03:18:59.668Z",
-// "endTime": "2022-07-04T03:18:59.668Z",
-// "jitter": "string",
-// "timezoneName": "string",
-// "timezoneData": "string"
-
 const getSearchAttributes = (
   attrs: (typeof setSearchAttributes.arguments)[0],
 ) => {
@@ -229,8 +222,7 @@ export const submitEditSchedule = async (
   const fields = body.schedule.action.startWorkflow?.header?.fields;
   if (fields && Object.keys(fields).length > 0) {
     try {
-      const entries = Object.entries(fields);
-      for (const [key, value] of entries) {
+      for (const [key, value] of Object.entries(fields)) {
         const encodedValue = await encodePayloads({
           input: stringifyWithBigInt(value),
           encoding: 'json/plain',

src/lib/utilities/encode-payload.test.ts

@@ -5,7 +5,11 @@ import {
   stringifyWithBigInt,
 } from '$lib/utilities/parse-with-big-int';
 
-import { encodePayloads, getSinglePayload } from './encode-payload';
+import {
+  encodePayloads,
+  getSinglePayload,
+  isBase64EncodedPayload,
+} from './encode-payload';
 
 describe('getSinglePayload', () => {
   it('should return single payload from single payload', () => {
@@ -29,7 +33,64 @@ describe('getSinglePayload', () => {
   });
 });
 
+describe('isBase64EncodedPayload', () => {
+  it('should return true for a base64-encoded payload', () => {
+    expect(
+      isBase64EncodedPayload({
+        metadata: { encoding: 'anNvbi9wbGFpbg==' },
+        data: 'eyJmb28iOiJiYXIifQ==',
+      }),
+    ).toBe(true);
+  });
+
+  it('should return true for a binary/null encoded payload', () => {
+    expect(
+      isBase64EncodedPayload({
+        metadata: { encoding: 'YmluYXJ5L251bGw=' },
+        data: '',
+      }),
+    ).toBe(true);
+  });
+
+  it('should return false for a decoded payload', () => {
+    expect(
+      isBase64EncodedPayload({
+        metadata: { encoding: 'json/plain' },
+        data: { foo: 'bar' },
+      }),
+    ).toBe(false);
+  });
+
+  it('should return false for a raw string value', () => {
+    expect(isBase64EncodedPayload('hello')).toBe(false);
+  });
+
+  it('should return false for a raw object value', () => {
+    expect(isBase64EncodedPayload({ foo: 'bar' })).toBe(false);
+  });
+
+  it('should return false for null', () => {
+    expect(isBase64EncodedPayload(null)).toBe(false);
+  });
+
+  it('should return false for undefined', () => {
+    expect(isBase64EncodedPayload(undefined)).toBe(false);
+  });
+});
+
 describe('encodePayloads', () => {
+  it('should return already-encoded payload as-is', async () => {
+    const alreadyEncoded = {
+      metadata: { encoding: 'anNvbi9wbGFpbg==' },
+      data: 'eyJmb28iOiJiYXIifQ==',
+    };
+    const payload = await encodePayloads({
+      input: stringifyWithBigInt(alreadyEncoded),
+      encoding: 'json/plain',
+    });
+    expect(payload).toEqual([alreadyEncoded]);
+  });
+
   it('should encode single simple string payload', async () => {
     const payload = await encodePayloads({
       input: stringifyWithBigInt('cats'),

src/lib/utilities/encode-payload.ts

@@ -4,12 +4,21 @@ import type { PayloadInputEncoding } from '$lib/models/payload-encoding';
 import { encodePayloadsWithCodec } from '$lib/services/data-encoder';
 import { dataEncoder } from '$lib/stores/data-encoder';
 import type { Payload } from '$lib/types';
+import { atob } from '$lib/utilities/atob';
 import { btoa } from '$lib/utilities/btoa';
 import {
   parseWithBigInt,
   stringifyWithBigInt,
 } from '$lib/utilities/parse-with-big-int';
 
+export const isBase64EncodedPayload = (value: unknown): value is Payload => {
+  if (!value || typeof value !== 'object') return false;
+  const { metadata, data } = value as Payload;
+  const encoding = metadata?.encoding;
+  if (typeof encoding !== 'string' || typeof data !== 'string') return false;
+  return atob(encoding) !== encoding;
+};
+
 export const getSinglePayload = (decodedValue: string): string => {
   if (decodedValue) {
     const parsedValue = parseWithBigInt(decodedValue);
@@ -58,18 +67,25 @@ export const encodePayloads = async ({
   messageType = '',
   encodeWithCodec = true,
 }: EncodePayloads): Promise<Payload[]> => {
-  let payloads = null;
+  if (!input) return null;
 
-  if (input) {
-    const parsedInput = parseWithBigInt(input);
-    payloads = [setBase64Payload(parsedInput, encoding, messageType)];
-    const endpoint = get(dataEncoder).endpoint;
-    if (endpoint && encodeWithCodec) {
-      const awaitData = await encodePayloadsWithCodec({
-        payloads: { payloads },
-      });
-      payloads = awaitData?.payloads ?? null;
-    }
+  const parsedInput = parseWithBigInt(input);
+  let payloads: Payload[] = isBase64EncodedPayload(parsedInput)
+    ? [parsedInput]
+    : [
+        setBase64Payload(
+          parsedInput,
+          encoding,
+          messageType,
+        ) as unknown as Payload,
+      ];
+
+  const endpoint = get(dataEncoder).endpoint;
+  if (endpoint && encodeWithCodec) {
+    const awaitData = await encodePayloadsWithCodec({
+      payloads: { payloads },
+    });
+    payloads = (awaitData?.payloads as Payload[]) ?? null;
   }
   return payloads;
 };