sharetribe-flex-sdk 1.14.0

package/src/serializer.js

@@ -0,0 +1,279 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_sdkType"] }] */
+
+import transit from 'transit-js';
+import _ from 'lodash';
+import { UUID, LatLng, Money, BigDecimal, toType } from './types';
+
+/**
+   Composes two readers (sdk type and app type) so that:
+
+  ```
+  class MyCustomUuid {
+    constructor(uuid) {
+      this.myUuid = uuid;
+    }
+  }
+
+  const sdkTypeReader = {
+     sdkType: UUID,
+     reader: v => new UUID(v),
+  };
+
+  const appTypeReader = {
+     sdkType: UUID,
+
+     // type of reader function: UUID -> MyCustomUuid
+     reader: v => new MyCustomUuid(v.uuid),
+  }
+
+  Composition creates a new reader:
+
+  {
+     sdkType: UUID,
+     reader: v => new MyCustomUuid(new UUID(v))
+  }
+  ```
+ */
+const composeReader = (sdkTypeReader, appTypeReader) => {
+  const sdkTypeReaderFn = sdkTypeReader.reader;
+  const appTypeReaderFn = appTypeReader ? appTypeReader.reader : _.identity;
+
+  return rep => appTypeReaderFn(sdkTypeReaderFn(rep));
+};
+
+/**
+   Type map from Transit tags to type classes
+ */
+const typeMap = {
+  u: UUID,
+  geo: LatLng,
+  mn: Money,
+  f: BigDecimal,
+};
+
+/**
+   List of SDK type readers
+ */
+const sdkTypeReaders = [
+  {
+    sdkType: UUID,
+    reader: rep => new UUID(rep),
+  },
+  {
+    sdkType: LatLng,
+    reader: ([lat, lng]) => new LatLng(lat, lng),
+  },
+  {
+    sdkType: Money,
+    reader: ([amount, currency]) => new Money(amount, currency),
+  },
+  {
+    sdkType: BigDecimal,
+    reader: rep => new BigDecimal(rep),
+  },
+];
+
+/**
+   List of SDK type writers
+ */
+const sdkTypeWriters = [
+  {
+    sdkType: UUID,
+    writer: v => v.uuid,
+  },
+  {
+    sdkType: LatLng,
+    writer: v => [v.lat, v.lng],
+  },
+  {
+    sdkType: Money,
+    writer: v => [v.amount, v.currency],
+  },
+  {
+    sdkType: BigDecimal,
+    writer: v => v.value,
+  },
+];
+
+/**
+   Take `appTypeReaders` param and construct a list of read handlers
+   from `appTypeReaders`, `sdkTypeReaders` and `typeMap`.
+*/
+const constructReadHandlers = appTypeReaders =>
+  _.fromPairs(
+    _.map(typeMap, (typeClass, tag) => {
+      const sdkTypeReader = _.find(sdkTypeReaders, r => r.sdkType === typeClass);
+      const appTypeReader = _.find(appTypeReaders, r => r.sdkType === typeClass);
+
+      return [tag, composeReader(sdkTypeReader, appTypeReader)];
+    })
+  );
+
+const writeHandlers = _.flatten(
+  _.map(typeMap, (typeClass, tag) => {
+    const sdkTypeWriter = _.find(sdkTypeWriters, w => w.sdkType === typeClass);
+
+    const handler = transit.makeWriteHandler({
+      tag: () => tag,
+      rep: sdkTypeWriter.writer,
+    });
+
+    return [typeClass, handler];
+  })
+);
+
+/**
+   Builds JS objects from Transit maps
+ */
+const mapBuilder = {
+  init: () => ({}),
+  add: (ret, key, val) => {
+    /* eslint-disable no-param-reassign */
+    ret[key] = val;
+    return ret;
+  },
+  finalize: _.identity,
+};
+
+export const reader = (appTypeReaders = []) => {
+  const handlers = constructReadHandlers(appTypeReaders);
+
+  return transit.reader('json', {
+    handlers: {
+      ...handlers,
+
+      // Convert keywords to plain strings.
+      // The conversion loses the information that the
+      // string was originally a keyword. However, the API
+      // can coerse strings to keywords, so it's ok to send strings
+      // to the API when keywords is expected.
+      ':': rep => rep,
+
+      // Convert set to an array
+      // The conversion loses the information that the
+      // array was originally a set. However, the API
+      // can coerse arrays to sets, so it's ok to send arrays
+      // to the API when set is expected.
+      set: rep => rep,
+
+      // Convert list to an array
+      list: rep => rep,
+    },
+    mapBuilder,
+  });
+};
+
+const MapHandler = [
+  Object,
+  transit.makeWriteHandler({
+    tag: () => 'map',
+    rep: v =>
+      _.reduce(
+        v,
+        (map, val, key) => {
+          map.set(transit.keyword(key), val);
+          return map;
+        },
+        transit.map()
+      ),
+  }),
+];
+
+export const writer = (appTypeWriters = [], opts = {}) => {
+  const { verbose } = opts;
+  const transitType = verbose ? 'json-verbose' : 'json';
+
+  return transit.writer(transitType, {
+    handlers: transit.map([...writeHandlers, ...MapHandler]),
+
+    // Use transform to transform app types to sdk types before sdk
+    // types are encoded by transit.
+    transform: v => {
+      // Check _.isObject for two reasons:
+      // 1. _.isObject makes sure the value is not null, so the null check can be omitted in the canHandle implementation
+      // 2. Perf. No need to run canHandle for primitives
+      if (_.isObject(v)) {
+        if (v._sdkType) {
+          return toType(v);
+        }
+
+        const appTypeWriter = _.find(
+          appTypeWriters,
+          w =>
+            // Check if the value is an application type instance
+            (w.appType && v instanceof w.appType) ||
+            // ...or if the canHandle returns true.
+            (w.canHandle && w.canHandle(v))
+        );
+
+        if (appTypeWriter) {
+          return appTypeWriter.writer(v);
+        }
+      }
+
+      return v;
+    },
+
+    // This is only needed for the REPL
+    // TODO This could be stripped out for production build
+    handlerForForeign: (x, handlers) => {
+      if (Array.isArray(x)) {
+        return handlers.get('array');
+      }
+      if (typeof x === 'object') {
+        return handlers.get('map');
+      }
+
+      return null;
+    },
+  });
+};
+
+export const createTransitConverters = (typeHandlers = [], opts) => {
+  const { readers, writers } = typeHandlers.reduce(
+    (memo, handler) => {
+      const r = {
+        sdkType:
+          handler.sdkType ||
+          // DEPRECATED Use handler.sdkType instead of handler.type
+          handler.type,
+        reader: handler.reader,
+      };
+      const w = {
+        sdkType:
+          handler.sdkType ||
+          // DEPRECATED Use handler.sdkType instead of handler.type
+          handler.type,
+        appType:
+          handler.appType ||
+          // DEPRECATED Use handler.appType instead of handler.customType
+          handler.customType,
+        canHandle: handler.canHandle,
+        writer: handler.writer,
+      };
+
+      memo.readers.push(r);
+      memo.writers.push(w);
+
+      return memo;
+    },
+    { readers: [], writers: [] }
+  );
+
+  return {
+    reader: reader(readers),
+    writer: writer(writers, opts),
+  };
+};
+
+export const read = (str, opts = {}) => {
+  const { typeHandlers = [] } = opts;
+  const converters = createTransitConverters(typeHandlers);
+  return converters.reader.read(str);
+};
+
+export const write = (data, opts = {}) => {
+  const { typeHandlers = [], verbose = false } = opts;
+  const converters = createTransitConverters(typeHandlers, { verbose });
+  return converters.writer.write(data);
+};

package/src/serializer.test.js

@@ -0,0 +1,229 @@
+import transit from 'transit-js';
+import { reader, writer } from './serializer';
+import { UUID, LatLng, Money, BigDecimal } from './types';
+
+describe('serializer', () => {
+  it('reads and writes transit', () => {
+    const testData = {
+      a: 1,
+      b: 2,
+      c: [3, 4, 5],
+      d: {
+        e: true,
+      },
+    };
+
+    const r = reader();
+    const w = writer();
+
+    expect(r.read(w.write(testData))).toEqual(testData);
+  });
+
+  it('reads and writes transit JSON verbose', () => {
+    const testData = {
+      a: 1,
+      b: 2,
+      c: [3, 4, 5],
+      d: {
+        e: true,
+      },
+    };
+
+    const r = reader();
+    const w = writer([], { verbose: true });
+
+    expect(r.read(w.write(testData))).toEqual(testData);
+  });
+
+  it('writes map keys as symbols', () => {
+    const testData = {
+      a: 1,
+      b: { c: { d: 2 } }, // handles nested objects recursively
+      e: [{ f: 3 }, { g: 4 }], // handles nested objects in arrays
+    };
+
+    const expectedData = transit.map();
+    expectedData.set(transit.keyword('a'), 1);
+
+    const b = transit.map();
+    const c = transit.map();
+
+    c.set(transit.keyword('d'), 2);
+    b.set(transit.keyword('c'), c);
+
+    const f = transit.map();
+    f.set(transit.keyword('f'), 3);
+    const g = transit.map();
+    g.set(transit.keyword('g'), 4);
+
+    expectedData.set(transit.keyword('b'), b);
+    expectedData.set(transit.keyword('e'), [f, g]);
+
+    const w = writer();
+    const transitReader = transit.reader();
+
+    expect(transit.equals(transitReader.read(w.write(testData)), expectedData)).toEqual(true);
+  });
+
+  it('decodes a set to an array', () => {
+    const testData = transit.set(['b', 'a', 'b', 'b']);
+
+    const decoded = reader().read(transit.writer().write(testData));
+
+    expect(decoded).toHaveLength(2);
+    expect(decoded).toEqual(expect.arrayContaining(['a', 'b']));
+  });
+
+  it('decodes a list to an array', () => {
+    const testData = transit.list(['a', 'b']);
+
+    const decoded = reader().read(transit.writer().write(testData));
+
+    expect(decoded).toEqual(expect.arrayContaining(['a', 'b']));
+  });
+
+  it('handles UUIDs', () => {
+    const testData = {
+      id: new UUID('69c3d77a-db3f-11e6-bf26-cec0c932ce01'),
+    };
+
+    const roundTrip = reader().read(writer().write(testData));
+    expect(roundTrip).toEqual(testData);
+    expect(roundTrip.id).toBeInstanceOf(UUID);
+  });
+
+  it('handles LatLngs', () => {
+    const testData = {
+      location: new LatLng(12.34, 56.78),
+    };
+
+    const roundTrip = reader().read(writer().write(testData));
+    expect(roundTrip).toEqual(testData);
+    expect(roundTrip.location).toBeInstanceOf(LatLng);
+  });
+
+  it('handles Money', () => {
+    const testData = {
+      price: new Money(5000, 'EUR'),
+    };
+
+    const roundTrip = reader().read(writer().write(testData));
+    expect(roundTrip).toEqual(testData);
+    expect(roundTrip.price).toBeInstanceOf(Money);
+  });
+
+  it('handles BigDecimals', () => {
+    const testData = {
+      percentage: new BigDecimal('1.00000000000000000000000000001'),
+    };
+
+    const roundTrip = reader().read(writer().write(testData));
+    expect(roundTrip).toEqual(testData);
+
+    expect(roundTrip.percentage).toBeInstanceOf(BigDecimal);
+  });
+
+  it('handles types that are plain objects', () => {
+    const uuid = '69c3d77a-db3f-11e6-bf26-cec0c932ce01';
+
+    const roundTrip = reader().read(writer().write({ uuid, _sdkType: 'UUID' }));
+    expect(roundTrip).toEqual(new UUID(uuid));
+    expect(roundTrip).toBeInstanceOf(UUID);
+  });
+
+  it('allows you to add your own reader handlers for predefined types', () => {
+    class MyCustomUuid {
+      constructor(str) {
+        this.myCustomerUuidRepresentation = str;
+      }
+    }
+
+    const r = reader([
+      {
+        sdkType: UUID,
+        reader: v => new MyCustomUuid(v.uuid),
+      },
+    ]);
+
+    const w = writer();
+
+    const data = '69c3d77a-db3f-11e6-bf26-cec0c932ce01';
+
+    expect(r.read(w.write({ id: new UUID(data) })).id).toEqual(new MyCustomUuid(data));
+  });
+
+  it('allows you to add your own writers handlers for predefined types', () => {
+    class MyCustomUuid {
+      constructor(str) {
+        this.myCustomUuidRepresentation = str;
+      }
+    }
+
+    const r = reader();
+
+    const w = writer([
+      {
+        sdkType: UUID,
+        appType: MyCustomUuid,
+        writer: v => new UUID(v.myCustomUuidRepresentation),
+      },
+    ]);
+
+    const data = '69c3d77a-db3f-11e6-bf26-cec0c932ce01';
+
+    expect(r.read(w.write({ id: new MyCustomUuid(data) })).id).toEqual(new UUID(data));
+  });
+
+  it('allows you to add your own writer handlers for predefined types using plain objects', () => {
+    const myUuid = uuid => ({
+      myType: 'My plain object UUID type',
+      myUuidValue: uuid,
+    });
+
+    const r = reader();
+
+    const w = writer([
+      {
+        sdkType: UUID,
+        canHandle: v => v.myType === 'My plain object UUID type',
+        writer: v => new UUID(v.myUuidValue),
+      },
+    ]);
+
+    const data = '69c3d77a-db3f-11e6-bf26-cec0c932ce01';
+
+    expect(r.read(w.write({ id: myUuid(data) })).id).toEqual(new UUID(data));
+
+    // Test that adding a custom writer doesn't break the default writer
+    expect(r.read(w.write({ id: new UUID(data) })).id).toEqual(new UUID(data));
+  });
+
+  it('allows you to add your own writer handlers for any type of data', () => {
+    const myArrayMoney = ['_my_money', 100, 'USD'];
+    const myFnUuid = uuid => {
+      const fn = () => uuid;
+      fn.isMyFnUuid = true;
+      return fn;
+    };
+
+    const r = reader();
+
+    const w = writer([
+      {
+        appType: UUID,
+        canHandle: v => v.isMyFnUuid,
+        writer: v => new UUID(v()),
+      },
+      {
+        appType: Money,
+        canHandle: v => v[0] === '_my_money',
+        writer: v => new Money(v[1], v[2]),
+      },
+    ]);
+
+    const data = '69c3d77a-db3f-11e6-bf26-cec0c932ce01';
+
+    expect(r.read(w.write({ id: myFnUuid(data) })).id).toEqual(new UUID(data));
+    expect(r.read(w.write({ money: myArrayMoney })).money).toEqual(new Money(100, 'USD'));
+  });
+});

package/src/token_store.js

@@ -0,0 +1,15 @@
+import { hasBrowserCookies } from './detect';
+import browserCookieStore from './browser_cookie_store';
+import memoryStore from './memory_store';
+
+/* eslint-disable import/prefer-default-export */
+
+export const createDefaultTokenStore = (tokenStore, clientId, secure) => {
+  if (hasBrowserCookies()) {
+    return browserCookieStore({ clientId, secure });
+  }
+
+  // Token store was not given and we can't use browser cookie store.
+  // Default to in-memory store.
+  return memoryStore();
+};

package/src/types.js

@@ -0,0 +1,108 @@
+/* eslint no-underscore-dangle: ["error", { "allow": ["_sdkType"] }] */
+
+/**
+   UUID type
+   @constructor
+   @param {string} uuid - UUID represented as string
+ */
+export class UUID {
+  constructor(uuid) {
+    this._sdkType = this.constructor._sdkType;
+    this.uuid = uuid;
+  }
+}
+UUID._sdkType = 'UUID';
+
+export class LatLng {
+  constructor(lat, lng) {
+    this._sdkType = this.constructor._sdkType;
+    this.lat = lat;
+    this.lng = lng;
+  }
+}
+LatLng._sdkType = 'LatLng';
+
+export class LatLngBounds {
+  constructor(ne, sw) {
+    this._sdkType = this.constructor._sdkType;
+    this.ne = ne;
+    this.sw = sw;
+  }
+}
+LatLngBounds._sdkType = 'LatLngBounds';
+
+/**
+   Money type to represent money
+
+   - `amount`: The money amount in `minor` unit. In most cases, the minor unit means cents.
+               However, in currencies without cents, e.g. Japanese Yen, the `amount` value
+               is the number of Yens.
+   - `currency`: ISO 4217 currency code
+
+   Examples:
+
+   ```
+   new Money(5000, "USD") // $50
+   new Money(150, "EUR")  // 1.5€
+   new Money(2500, "JPY") // ¥2500
+   ```
+*/
+export class Money {
+  constructor(amount, currency) {
+    this._sdkType = this.constructor._sdkType;
+    this.amount = amount;
+    this.currency = currency;
+  }
+}
+Money._sdkType = 'Money';
+
+/**
+  Type to represent arbitrary precision decimal value.
+
+  It's recommended to use a library such as decimal.js to make decimal
+  calculations.
+*/
+export class BigDecimal {
+  constructor(value) {
+    this._sdkType = this.constructor._sdkType;
+    this.value = value;
+  }
+}
+BigDecimal._sdkType = 'BigDecimal';
+
+export const toType = value => {
+  // eslint-disable-next-line no-underscore-dangle
+  const type = value && value._sdkType;
+
+  switch (type) {
+    case 'LatLng':
+      return new LatLng(value.lat, value.lng);
+    case 'LatLngBounds':
+      return new LatLngBounds(value.ne, value.sw);
+    case 'UUID':
+      return new UUID(value.uuid);
+    case 'Money':
+      return new Money(value.amount, value.currency);
+    case 'BigDecimal':
+      return new BigDecimal(value.value);
+    default:
+      return value;
+  }
+};
+
+//
+// JSON replacer
+//
+// Deprecated
+//
+// The _sdkType field is added to the type object itself,
+// so the use of replacer is not needed. The function exists purely
+// for backwards compatibility. We don't want to remove it in case
+// applications are using it.
+//
+export const replacer = (key, value) => value;
+
+//
+// JSON reviver
+//
+export const reviver = (key, value) => toType(value);

package/src/types.test.js

@@ -0,0 +1,75 @@
+import { UUID, LatLng, LatLngBounds, Money, BigDecimal, replacer, reviver } from './types';
+
+describe('JSON parse/stringify', () => {
+  const testData = {
+    uuid: new UUID('27786d1c-f16b-411b-b1fc-176969a91338'),
+    latlng: new LatLng(12.34, 45.56),
+    latlngbounds: new LatLngBounds(new LatLng(12.34, 23.45), new LatLng(34.56, 45.67)),
+    money: new Money(5000, 'USD'),
+    bigdecimal: new BigDecimal('1.00000000000000000000000000001'),
+  };
+
+  /* eslint-disable quote-props */
+  /* eslint-disable quotes */
+  /* eslint-disable comma-dangle */
+  const expectedJsonRep = {
+    uuid: {
+      uuid: '27786d1c-f16b-411b-b1fc-176969a91338',
+      _sdkType: 'UUID',
+    },
+    latlng: {
+      lat: 12.34,
+      lng: 45.56,
+      _sdkType: 'LatLng',
+    },
+    latlngbounds: {
+      ne: {
+        lat: 12.34,
+        lng: 23.45,
+        _sdkType: 'LatLng',
+      },
+      sw: {
+        lat: 34.56,
+        lng: 45.67,
+        _sdkType: 'LatLng',
+      },
+      _sdkType: 'LatLngBounds',
+    },
+    money: {
+      amount: 5000,
+      currency: 'USD',
+      _sdkType: 'Money',
+    },
+    bigdecimal: {
+      value: '1.00000000000000000000000000001',
+      _sdkType: 'BigDecimal',
+    },
+  };
+  /* eslint-enable quote-props */
+  /* eslint-enable quotes */
+  /* eslint-enable comma-dangle */
+
+  it('deprecated, serializes types with replacer', () => {
+    const jsonRep = JSON.parse(JSON.stringify(testData, replacer));
+
+    expect(jsonRep).toEqual(expectedJsonRep);
+  });
+
+  it('serializes types', () => {
+    const jsonRep = JSON.parse(JSON.stringify(testData));
+
+    expect(jsonRep).toEqual(expectedJsonRep);
+  });
+
+  it('deprecated. deserializes types after serializing them with replacer', () => {
+    const parsed = JSON.parse(JSON.stringify(testData, replacer), reviver);
+
+    expect(parsed).toEqual(testData);
+  });
+
+  it('deserializes types', () => {
+    const parsed = JSON.parse(JSON.stringify(testData), reviver);
+
+    expect(parsed).toEqual(testData);
+  });
+});