@squiz/dx-common-lib 1.21.1-alpha.7 → 1.22.0

package/src/json-order/stringify.spec.ts

@@ -0,0 +1,170 @@
+import stringify from './stringify';
+import { PropertyMap } from './models';
+
+describe('stringify ', () => {
+  const expectString = (obj: object, map: PropertyMap | null, str: string) =>
+    expect(stringify(obj, map, '.', 0)).toEqual(str);
+
+  it('returns nothing for a blank JSON string', () => expectString({}, {}, '{}'));
+
+  it('throws error if separator is an empty string', () => {
+    expect(() => stringify({}, {}, '')).toThrowError('Separator should not be an empty string.');
+  });
+
+  it('ignores properties not found in source', () => expectString({}, { $: ['a'] }, '{}'));
+
+  it('returns regular json string if map is undefined', () =>
+    expectString({ a: '1', b: '2' }, null, '{"a":"1","b":"2"}'));
+
+  it('ignores properties not found in map', () => expectString({ a: '1', b: '2' }, { $: ['b'] }, '{"b":"2"}'));
+
+  it('returns first level object properties in order', () =>
+    expectString({ a: 2, b: 1 }, { $: ['b', 'a'] }, '{"b":1,"a":2}'));
+
+  it('returns first level array value in order', () =>
+    expectString({ a: ['2', 1, true] }, { $: ['a'] }, '{"a":["2",1,true]}'));
+
+  it('returns nested [array] > [object] properties in expected order', () =>
+    expectString({ a: [1, { c: '3', d: '2' }] }, { $: ['a'], '$.a.1': ['d', 'c'] }, '{"a":[1,{"d":"2","c":"3"}]}'));
+
+  it('ignores nested [array] > [object] properties partially not found in map', () =>
+    expectString({ a: [1, { b: 2, c: 3 }, 4] }, { $: ['a'], '$.a.1': ['c'] }, '{"a":[1,{"c":3},4]}'));
+
+  it('ignores nested [array] > [object] properties not found in map', () =>
+    expectString({ a: [1, { b: 2, c: 3 }, 4] }, { $: ['a'] }, '{"a":[1,{},4]}'));
+
+  it('handles multi-character prefix', () => {
+    expect(
+      stringify(
+        {
+          a: {
+            b: {
+              c: 3,
+              d: 4,
+            },
+            e: {
+              f: 4,
+              g: 5,
+            },
+            h: 6,
+          },
+          i: 7,
+        },
+        {
+          ab: ['i', 'a'],
+          'ab.a': ['e', 'h', 'b'],
+          'ab.a.e': ['g', 'f'],
+          'ab.a.b': ['d', 'c'],
+        },
+        '.',
+        0,
+      ),
+    ).toEqual('{"i":7,"a":{"e":{"g":5,"f":4},"h":6,"b":{"d":4,"c":3}}}');
+  });
+
+  it('handles multi-character separator', () => {
+    expect(
+      stringify(
+        {
+          a: {
+            b: {
+              c: 3,
+              d: 4,
+            },
+            e: {
+              f: 4,
+              g: 5,
+            },
+            h: 6,
+          },
+          i: 7,
+        },
+        {
+          $: ['i', 'a'],
+          '$~|a': ['e', 'h', 'b'],
+          '$~|a~|e': ['g', 'f'],
+          '$~|a~|b': ['d', 'c'],
+        },
+        '~|',
+        0,
+      ),
+    ).toEqual('{"i":7,"a":{"e":{"g":5,"f":4},"h":6,"b":{"d":4,"c":3}}}');
+  });
+
+  it('returns nested [object] > [object] properties in expected order', () =>
+    expectString(
+      {
+        a: {
+          b: {
+            c: 3,
+            d: 4,
+          },
+          e: {
+            f: 4,
+            g: 5,
+          },
+          h: 6,
+        },
+        i: 7,
+      },
+      {
+        $: ['i', 'a'],
+        '$.a': ['e', 'h', 'b'],
+        '$.a.e': ['g', 'f'],
+        '$.a.b': ['d', 'c'],
+      },
+      '{"i":7,"a":{"e":{"g":5,"f":4},"h":6,"b":{"d":4,"c":3}}}',
+    ));
+
+  it('returns nested [object] > [array] > [object] > [array] > [object] properties in expected order', () =>
+    expectString(
+      {
+        a: {
+          b: [
+            8,
+            {
+              c: 9,
+              d: [
+                {
+                  e: 12,
+                  f: {
+                    g: true,
+                    h: 'h',
+                  },
+                },
+                10,
+              ],
+            },
+            11,
+          ],
+        },
+        i: 7,
+      },
+      {
+        $: ['i', 'a'],
+        '$.a': ['b'],
+        '$.a.b.1': ['d', 'c'],
+        '$.a.b.1.d.0': ['f', 'e'],
+        '$.a.b.1.d.0.f': ['h', 'g'],
+      },
+      '{"i":7,"a":{"b":[8,{"d":[{"f":{"h":"h","g":true},"e":12},10],"c":9},11]}}',
+    ));
+
+  it('handles keys with different types of values', () =>
+    expectString(
+      {
+        a: 'a',
+        b: 2,
+        c: 2.3,
+        d: true,
+        e: false,
+        f: null,
+        g: {},
+        h: [],
+      },
+      {
+        $: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
+      },
+      '{"a":"a","b":2,"c":2.3,"d":true,"e":false,"f":null,"g":{},"h":[]}',
+    ));
+});

package/src/json-order/stringify.ts

@@ -0,0 +1,17 @@
+import { PropertyMap } from './models';
+import order from './order';
+
+/**
+ * Stringify a JS object while maintaining a particular property order:
+ *
+ * @param sourceObject an object with the properties in any order
+ * @param map the `PropertyMap` generated by the `parse` method.
+ * @param separator a non-empty `string` that controls what the key separator is in the generated map. Defaults to `~`.
+ * @param space a `number` used to insert white space into the output JSON string for readability purposes, as per the `JSON.stringify` [documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#Parameters)
+ * @returns the stringified source object ordered as per the map. If the map is unset, the response is a standard `JSON.stringify`.
+ */
+const stringify = (sourceObject: object, map: PropertyMap | null, separator = '~', space?: number): string => {
+  return JSON.stringify(order(sourceObject, map, separator), null, space);
+};
+
+export default stringify;

package/src/server-utils/errorMiddleware.spec.ts

@@ -10,6 +10,7 @@ const testRequest = {
 const testResponse: any = {
   status: jest.fn(() => testResponse),
   json: jest.fn(() => testResponse),
+  setHeader: jest.fn(() => testResponse),
 };
 
 class ComponentError extends ErrorWithHttpStatusCode {

package/src/server-utils/errorMiddleware.ts

@@ -5,6 +5,8 @@ export function errorMiddleware(error: any, req: Request, res: Response, _next:
   const statusCode = error.statusCode || 500;
   error.message = error?.message || 'An error occurred with no additional information available';
 
+  res = res.setHeader('cache-control', 'no-cache, no-store, max-age=0');
+
   if (error?.name === 'ComponentError') {
     req.log.error({
       message: error,