sharetribe-flex-sdk 1.14.0

package/src/interceptors/transit_request.test.js

@@ -0,0 +1,58 @@
+import { createTransitConverters } from '../serializer';
+import TransitRequest from './transit_request';
+
+describe('TransitRequest', () => {
+  it('encodes to Transit', () => {
+    const data = {
+      data: {
+        a: 1,
+        b: [2, 3],
+      },
+    };
+
+    const ctx = {
+      params: data,
+    };
+
+    const transitRequest = new TransitRequest();
+
+    const newCtx = transitRequest.enter(ctx);
+    const { writer } = createTransitConverters();
+
+    expect(newCtx).toEqual(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'Content-Type': 'application/transit+json',
+        }),
+        params: writer.write(data),
+      })
+    );
+  });
+
+  it('is idempotent', () => {
+    const data = {
+      data: {
+        a: 1,
+        b: [2, 3],
+      },
+    };
+
+    const ctx = {
+      params: data,
+    };
+
+    const transitRequest = new TransitRequest();
+
+    const newCtx = transitRequest.enter(transitRequest.enter(ctx));
+    const { writer } = createTransitConverters();
+
+    expect(newCtx).toEqual(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'Content-Type': 'application/transit+json',
+        }),
+        params: writer.write(data),
+      })
+    );
+  });
+});

package/src/interceptors/transit_response.js

@@ -0,0 +1,27 @@
+import _ from 'lodash';
+import { createTransitConverters } from '../serializer';
+
+/**
+   Transit encode the response
+ */
+export default class TransitResponse {
+  error(ctx) {
+    const { reader } = createTransitConverters(ctx.typeHandlers);
+
+    if (!ctx.error.response) {
+      return ctx;
+    }
+
+    return _.update({ ...ctx }, 'error.response.data', data => reader.read(data));
+  }
+
+  leave(ctx) {
+    const { reader } = createTransitConverters(ctx.typeHandlers);
+
+    if (!ctx.res) {
+      return ctx;
+    }
+
+    return _.update({ ...ctx }, 'res.data', data => reader.read(data));
+  }
+}

package/src/memory_store.js

@@ -0,0 +1,19 @@
+const createStore = () => {
+  let memo;
+
+  const getToken = () => memo;
+  const setToken = tokenData => {
+    memo = tokenData;
+  };
+  const removeToken = () => {
+    memo = null;
+  };
+
+  return {
+    getToken,
+    setToken,
+    removeToken,
+  };
+};
+
+export default createStore;

package/src/params_serializer.js

@@ -0,0 +1,65 @@
+import _ from 'lodash';
+import { UUID, LatLng, LatLngBounds } from './types';
+
+/**
+ * Takes a value for query string and returns it in encoded form.
+ *
+ * Uses `encodeURIComponent` with few exceptions:
+ *
+ * - Don't encode comma (,)
+ *
+ * Inspired by the `encode` function in Axios:
+ * https://github.com/mzabriskie/axios/blob/b8f6f5049cf3da8126a184b6b270316402b5b374/lib/helpers/buildURL.js#L5
+ */
+const encode = value => encodeURIComponent(value).replace(/%2C/gi, ',');
+
+/**
+ * Take `key` and `value` and return a key-value tuple where
+ * key and value are stringified.
+ *
+ * TODO Consider moving this function closer to the type definitions,
+ * maybe in types.js file(?).
+ */
+const serialize = (key, value) => {
+  let v;
+
+  if (value instanceof UUID) {
+    v = value.uuid;
+  } else if (value instanceof LatLng) {
+    v = `${value.lat},${value.lng}`;
+  } else if (value instanceof LatLngBounds) {
+    v = `${value.ne.lat},${value.ne.lng},${value.sw.lat},${value.sw.lng}`;
+  } else if (Array.isArray(value)) {
+    v = value;
+  } else if (value instanceof Date) {
+    v = value.toISOString();
+  } else if (value == null) {
+    v = value;
+  } else if (typeof value !== 'object') {
+    v = value;
+  } else {
+    throw new Error(`Don't know how to serialize query parameter '${key}': ${value}`);
+  }
+
+  // Ignore null and undefined values
+  if (v == null) {
+    return null;
+  }
+
+  return [key, encode(v)];
+};
+
+const paramsSerializer = params =>
+  _.compact(
+    _.map(params, (value, key) => {
+      const serialized = serialize(key, value);
+
+      if (serialized) {
+        return serialized.join('=');
+      }
+
+      return null;
+    })
+  ).join('&');
+
+export default paramsSerializer;

package/src/params_serializer.test.js

@@ -0,0 +1,58 @@
+import ps from './params_serializer';
+import { UUID, LatLng, LatLngBounds } from './types';
+
+describe('params serializer', () => {
+  it('serializes params Object', () => {
+    expect(ps({ a: 1 })).toEqual('a=1');
+    expect(ps({ a: 1, b: 'foo' })).toEqual('a=1&b=foo');
+  });
+
+  it('serializes UUID', () => {
+    expect(ps({ uuid: new UUID('0e0b60fe-d9a2-11e6-bf26-cec0c932ce01') })).toEqual(
+      'uuid=0e0b60fe-d9a2-11e6-bf26-cec0c932ce01'
+    );
+  });
+
+  it('serializes LatLng', () => {
+    expect(ps({ location: new LatLng(12.34, -56.70001) })).toEqual('location=12.34,-56.70001');
+  });
+
+  it('serializes LatLngBounds', () => {
+    expect(
+      ps({ bounds: new LatLngBounds(new LatLng(12.34, -56.70001), new LatLng(-45.67, 12)) })
+    ).toEqual('bounds=12.34,-56.70001,-45.67,12');
+  });
+
+  it('serializes array', () => {
+    expect(ps({ alphabets: ['a', 'b', 'c'] })).toEqual('alphabets=a,b,c');
+  });
+
+  it('serializes Date', () => {
+    expect(ps({ start: new Date('2018-07-01T00:00:00.000Z') })).toEqual(
+      'start=2018-07-01T00%3A00%3A00.000Z'
+    );
+  });
+
+  it('throws for Objects that it can not encode', () => {
+    class Point {
+      construct(x, y) {
+        this.x = x;
+        this.y = y;
+      }
+    }
+
+    expect(() => ps({ point: new Point(12, -5) })).toThrowError(
+      "Don't know how to serialize query parameter 'point': [object Object]"
+    );
+
+    expect(() => ps({ foo: { a: 1, b: 'bar' } })).toThrowError(
+      "Don't know how to serialize query parameter 'foo': [object Object]"
+    );
+  });
+
+  it('ignores null and undefined values', () => {
+    expect(
+      ps({ a: null, b: undefined, c: 'value', d: false, e: 0, f: '', g: [], h: [1, 2, 3] })
+    ).toEqual('c=value&d=false&e=0&f=&g=&h=1,2,3');
+  });
+});