Move isBase64EncodedPayload check to encodePayloads util

Author: laurakwhit

src/lib/stores/schedules.ts

@@ -13,10 +13,7 @@ import type {
   SchedulePresetsParameters,
   ScheduleSpecParameters,
 } from '$lib/types/schedule';
-import {
-  encodePayloads,
-  isEncodedPayload,
-} from '$lib/utilities/encode-payload';
+import { encodePayloads } from '$lib/utilities/encode-payload';
 import { stringifyWithBigInt } from '$lib/utilities/parse-with-big-int';
 import { routeForSchedule, routeForSchedules } from '$lib/utilities/route-for';
 import {
@@ -226,13 +223,11 @@ export const submitEditSchedule = async (
   if (fields && Object.keys(fields).length > 0) {
     try {
       for (const [key, value] of Object.entries(fields)) {
-        if (!isEncodedPayload(value)) {
-          const encodedValue = await encodePayloads({
-            input: stringifyWithBigInt(value),
-            encoding: 'json/plain',
-          });
-          fields[key] = encodedValue[0];
-        }
+        const encodedValue = await encodePayloads({
+          input: stringifyWithBigInt(value),
+          encoding: 'json/plain',
+        });
+        fields[key] = encodedValue[0];
       }
     } catch (e) {
       error.set(`${translate('data-encoder.encode-error')}: ${e?.message}`);

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

@@ -8,7 +8,7 @@ import {
 import {
   encodePayloads,
   getSinglePayload,
-  isEncodedPayload,
+  isBase64EncodedPayload,
 } from './encode-payload';
 
 describe('getSinglePayload', () => {
@@ -33,10 +33,10 @@ describe('getSinglePayload', () => {
   });
 });
 
-describe('isEncodedPayload', () => {
+describe('isBase64EncodedPayload', () => {
   it('should return true for a base64-encoded payload', () => {
     expect(
-      isEncodedPayload({
+      isBase64EncodedPayload({
         metadata: { encoding: 'anNvbi9wbGFpbg==' },
         data: 'eyJmb28iOiJiYXIifQ==',
       }),
@@ -45,7 +45,7 @@ describe('isEncodedPayload', () => {
 
   it('should return true for a binary/null encoded payload', () => {
     expect(
-      isEncodedPayload({
+      isBase64EncodedPayload({
         metadata: { encoding: 'YmluYXJ5L251bGw=' },
         data: '',
       }),
@@ -54,31 +54,43 @@ describe('isEncodedPayload', () => {
 
   it('should return false for a decoded payload', () => {
     expect(
-      isEncodedPayload({
+      isBase64EncodedPayload({
         metadata: { encoding: 'json/plain' },
         data: { foo: 'bar' },
       }),
     ).toBe(false);
   });
 
   it('should return false for a raw string value', () => {
-    expect(isEncodedPayload('hello')).toBe(false);
+    expect(isBase64EncodedPayload('hello')).toBe(false);
   });
 
   it('should return false for a raw object value', () => {
-    expect(isEncodedPayload({ foo: 'bar' })).toBe(false);
+    expect(isBase64EncodedPayload({ foo: 'bar' })).toBe(false);
   });
 
   it('should return false for null', () => {
-    expect(isEncodedPayload(null)).toBe(false);
+    expect(isBase64EncodedPayload(null)).toBe(false);
   });
 
   it('should return false for undefined', () => {
-    expect(isEncodedPayload(undefined)).toBe(false);
+    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

@@ -11,10 +11,11 @@ import {
   stringifyWithBigInt,
 } from '$lib/utilities/parse-with-big-int';
 
-export const isEncodedPayload = (payload: Payload): boolean => {
-  const encoding = payload?.metadata?.encoding;
-  if (typeof encoding !== 'string' || typeof payload?.data !== 'string')
-    return false;
+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;
 };
 
@@ -66,18 +67,22 @@ 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);
+  if (isBase64EncodedPayload(parsedInput)) {
+    return [parsedInput];
+  }
+
+  let payloads = [
+    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;
 };