sharetribe-flex-sdk 1.14.0

package/playground.js

@@ -0,0 +1,295 @@
+/* eslint-env node */
+/* eslint-disable no-console */
+
+// Don't show an error when devDependencies (i.e. colors) is imported
+/* eslint import/no-extraneous-dependencies: ["error", {"devDependencies": true}] */
+
+const colors = require('colors');
+const repl = require('repl');
+const commandLineArgs = require('command-line-args');
+const commandLineUsage = require('command-line-usage');
+const fs = require('fs');
+const open = require('open');
+const util = require('util');
+const sharetribeSdk = require('./src/index');
+const {LatLng, LatLgnBounds, UUID, Money, BigDecimal} = require('./src/types');
+
+// Welcome message when Playground starts
+const printWelcomeMessage = raw => {
+  colors.setTheme({
+    h1: 'yellow',
+    h2: 'yellow',
+    inline: 'gray',
+    block: 'gray',
+  });
+
+  if (raw) {
+    console.log('');
+    console.log('  # Playground (raw mode)'.h1);
+    console.log('  ');
+    console.log('  With the Marketplace API Playground you can test and try out the SDK with real results from the API.');
+    console.log('  ');
+    console.log('  ## Globals'.h2);
+    console.log('  ');
+    console.log('  The following globals are available:');
+    console.log('  ');
+    console.log(`  - ${'`sharetribeSdk`'.inline}: The SDK module`);
+    console.log(`  - ${'`printResponse`'.inline}: Helper function for pretty printing the API response.`);
+    console.log(`  - ${'`pr`'.inline}: Helper function for pretty printing the API response from the last command that ran (presumably an API call).`);
+    console.log(`  - ${'`apiDocs`'.inline}: Open the Marketplace API documentation in your browser.`);
+    console.log('  ');
+    console.log('  ## Example usage'.h2);
+    console.log('  ');
+    console.log('  Create new SDK instance:');
+    console.log('  ');
+    console.log('  ```'.block);
+    console.log('  const clientId = "<your clientId here>";'.block);
+    console.log('  const sdk = sharetribeSdk.createInstance({'.block);
+    console.log('    clientId,'.block);
+    console.log('    tokenStore: sharetribeSdk.tokenStore.memoryStore()'.block);
+    console.log('  });'.block);
+    console.log('  ```'.block);
+    console.log('  ');
+    console.log('  Print marketplace information:');
+    console.log('  ');
+    console.log('  sdk.marketplace.show().then(printResponse);'.block);
+    console.log('  ');
+    console.log('  Alternative version using pr():');
+    console.log('  ');
+    console.log('  sdk.marketplace.show();'.block);
+    console.log('  pr();'.block);
+    console.log('  ');
+    console.log('  Fetch 10 listings:');
+    console.log('  ');
+    console.log('  sdk.listings.query({per_page: 10}).then(response => {'.block);
+    console.log('    console.log("Fetched " + response.data.data.length + " listings.");'.block);
+    console.log('    response.data.data.forEach(listing => {'.block);
+    console.log('      console.log(listing.attributes.title);'.block);
+    console.log('    });'.block);
+    console.log('  });'.block);
+    console.log('  ');
+    console.log(`  Type ${'`.exit`'.inline} when you want to exit the Playground`);
+  } else {
+    console.log('');
+    console.log('  # Playground'.h1);
+    console.log('  ');
+    console.log('  With the Marketplace API Playground you can test and try out the SDK with real results from the API.');
+    console.log('  ');
+    console.log('  ## Globals'.h2);
+    console.log('  ');
+    console.log('  The following globals are available:');
+    console.log('  ');
+    console.log(`  - ${'`sharetribeSdk`'.inline}: The SDK module`);
+    console.log(`  - ${'`sdk`'.inline}: An SDK instance initialized with your client ID`);
+    console.log(`  - ${'`printResponse`'.inline}: Helper function for pretty printing the API response.`);
+    console.log(`  - ${'`apiDocs`'.inline}: Open the Marketplace API documentation in your browser.`);
+    console.log('  ');
+    console.log('  ## Example usage'.h2);
+    console.log('  ');
+    console.log('  Print marketplace information:');
+    console.log('  ');
+    console.log('  sdk.marketplace.show().then(printResponse);'.block);
+    console.log('  ');
+    console.log('  Alternative version using pr():');
+    console.log('  ');
+    console.log('  sdk.marketplace.show();'.block);
+    console.log('  pr();'.block);
+    console.log('  ');
+    console.log('  Fetch 10 listings:');
+    console.log('  ');
+    console.log('  ```'.block);
+    console.log('  sdk.listings.query({per_page: 10}).then(response => {'.block);
+    console.log('    console.log("Fetched " + response.data.data.length + " listings.");'.block);
+    console.log('    response.data.data.forEach(listing => {'.block);
+    console.log('      console.log(listing.attributes.title);'.block);
+    console.log('    });'.block);
+    console.log('  });'.block);
+    console.log('  ```'.block);
+    console.log('  ');
+    console.log(`  Type ${'`.exit`'.inline} when you want to exit the Playground`);
+  }
+};
+
+// CLI Usage information
+const optionDefinitions = [
+  {
+    name: 'help',
+    description: 'Display this usage guide.',
+    alias: 'h',
+    type: Boolean
+  },
+  {
+    name: 'clientid',
+    description: 'Your Marketplace API Client ID to initialize the SDK with. You create your Client ID in Flex Console: {underline https://flex-console.sharetribe.com/applications}.',
+    alias: 'c',
+    typeLabel: '{underline ID}',
+    type: String
+  },
+  {
+    name: 'user',
+    description: 'The email of the user to log in with. The SDK is initialized in an authenticated state.',
+    alias: 'u',
+    typeLabel: '{underline email}',
+    type: String
+  },
+  {
+    name: 'password',
+    description: 'The password of the user to log in with. The SDK is initialized in an authenticated state.',
+    alias: 's',
+    typeLabel: '{underline password}',
+    type: String
+  },
+  {
+    name: 'raw',
+    description: 'Start the playground without initializing the SDK.',
+    type: Boolean
+  },
+  {
+    name: 'script',
+    description: 'Execute a playground script, i.e. a file that contains one or more playground commands.',
+    typeLabel: '{underline script_file.js}',
+    type: String
+  },
+  {
+    name: 'apidocs',
+    description: 'Open the Marketplace API reference using default browser.',
+    type: Boolean
+  }
+];
+
+const printUsage = () => {
+  console.log(commandLineUsage([
+    {
+      header: 'Marketplace API Playground',
+      content: 'The easiest way to call the Flex Marketplace API using the JS SDK to try things out, to learn the APIs and to test your ideas.'
+    },
+    {
+      header: 'Options',
+      optionList: optionDefinitions
+    }
+  ]));
+};
+
+const printResponse = response => {
+  console.log(JSON.stringify(response.data, null, 4));
+  return response;
+}
+
+const printLastResponse = (ctx) =>
+      () => ctx._.then(printResponse);
+
+const apiDocs = () =>
+      open('https://www.sharetribe.com/api-reference/marketplace.html?javascript#marketplace-api')
+      .then(() => '');
+
+const setupContext = (ctx, sdk) => {
+  ctx.sharetribeSdk = sharetribeSdk;
+  if (sdk) {
+    ctx.sdk = sdk;
+  }
+  ctx.printResponse = printResponse;
+  ctx.pr = printLastResponse(ctx);
+  ctx.apiDocs = apiDocs;
+  ctx.LatLng = LatLng;
+  ctx.LatLngBounds = LatLgnBounds;
+  ctx.UUID = UUID;
+  ctx.Money = Money;
+  ctx.BigDecimal = BigDecimal;
+}
+
+const startRepl = (sdk, rawMode, src) =>
+      () => {
+        if (src) {
+          // Setup context
+          setupContext(global, sdk);
+
+          // Start REPL
+          console.log('Executing script...');
+          console.log();
+          repl.start({
+            prompt: '> ',
+            input: src,
+            output: process.stdout,
+            useGlobal: true,
+            writer: result => result instanceof Promise ? '' : util.inspect(result)
+          });
+        } else {
+          printWelcomeMessage(rawMode);
+          // Start REPL
+          const replInstance = repl.start('> ');
+
+          // Attach history
+          // Node versions prior to 10.11 don't support setupHistory
+          if (replInstance.setupHistory) {
+            replInstance.setupHistory('./.repl_history', () => null);
+          }
+
+          // Setup context
+          const ctx = replInstance.context;
+          setupContext(ctx, sdk);
+        }
+      }
+
+const exitOnFailure = msg =>
+      () => {
+        console.error(msg)
+        process.exit(1);
+      };
+
+// Parse command line args
+//
+const options = commandLineArgs(optionDefinitions);
+
+if (options.apidocs) {
+  apiDocs();
+  process.exit();
+}
+
+if (options.help || (!options.raw && options.clientid == null)) {
+  printUsage();
+  process.exit();
+};
+
+let scriptSrc;
+if (options.script) {
+  scriptSrc = fs.createReadStream(options.script);
+} else {
+  scriptSrc = null;
+}
+
+// If client ID is provided on start, instantiate and expose sdk
+if (options.clientid) {
+  const sdk = sharetribeSdk.createInstance({
+    clientId: options.clientid,
+    tokenStore: sharetribeSdk.tokenStore.memoryStore()
+  });
+
+  // If user auth info is given too, log in with the user.
+  if (options.user && options.password) {
+    console.log(`Initializing SDK instance with Client ID: ${options.clientid}...`)
+    sdk.marketplace.show()
+      .then(result => console.log(`Successfully connected to ${result.data.data.attributes.name} marketplace.`))
+      .catch(exitOnFailure(`Unable to access the Marketplace API with the given Client ID: ${options.clientid}.`))
+      .then(() => {
+        console.log(`Logging in user ${options.user}...`);
+        return sdk.login({
+          username: options.user,
+          password: options.password
+        });
+      })
+      .catch(exitOnFailure(`Unable to log in with the email: ${options.user} and password you gave.`))
+      .then(startRepl(sdk, false, scriptSrc));
+
+  // No user auth, just Client ID
+  } else {
+    console.log(`Initializing SDK instance with Client ID: ${options.clientid}...`)
+    sdk.marketplace.show()
+      .then(result => console.log(`Successfully connected to ${result.data.data.attributes.name} marketplace.`))
+      .catch(exitOnFailure(`Unable to access the Marketplace API with the given Client ID: ${options.clientid}.`))
+      .then(startRepl(sdk, false, scriptSrc));
+
+  }
+// Raw mode
+} else {
+  startRepl(null, true, scriptSrc)();
+}

package/src/browser_cookie_store.js

@@ -0,0 +1,26 @@
+import Cookies from 'js-cookie';
+
+const generateKey = (clientId, namespace) => `${namespace}-${clientId}-token`;
+
+const createStore = ({ clientId, secure }) => {
+  const expiration = 30; // 30 days
+  const namespace = 'st';
+  const key = generateKey(clientId, namespace);
+
+  const getToken = () => Cookies.getJSON(key);
+  const setToken = tokenData => {
+    const secureFlag = secure ? { secure: true } : {};
+    Cookies.set(key, tokenData, { expires: expiration, ...secureFlag });
+  };
+  const removeToken = () => {
+    Cookies.remove(key);
+  };
+
+  return {
+    getToken,
+    setToken,
+    removeToken,
+  };
+};
+
+export default createStore;

package/src/context_runner.js

@@ -0,0 +1,151 @@
+const DEBUG = false;
+
+const resolve = ctx => Promise.resolve(ctx);
+
+const buildCtx = (params = {}, middleware) => ({
+  ...params,
+  enterQueue: [...middleware].reverse(),
+  leaveStack: [],
+});
+
+const tryExecuteMw = (ctx, mw, stage) => {
+  /* eslint-disable no-console */
+  /* eslint-disable no-undef */
+  if (DEBUG) {
+    if (mw[stage]) {
+      console.log(`Executing ${mw.constructor.name}#${stage}`);
+    }
+  }
+  /* eslint-enable no-console */
+  /* eslint-enable no-undef */
+
+  return resolve(ctx)
+    .then(mw[stage] || resolve)
+    .catch(error => {
+      const errorCtx = error.ctx || ctx;
+      return Promise.resolve({
+        ...errorCtx,
+        error,
+        errorMiddleware: mw.constructor.name,
+        errorStage: stage,
+      });
+    });
+};
+
+const nextMw = ctx => {
+  const leaveStack = [...ctx.leaveStack];
+  const enterQueue = [...ctx.enterQueue];
+  let mw;
+  let type;
+
+  if (ctx.error) {
+    mw = leaveStack.shift();
+    type = 'error';
+  } else if (enterQueue.length) {
+    mw = enterQueue.pop();
+    leaveStack.unshift(mw);
+    type = 'enter';
+  } else {
+    mw = leaveStack.shift();
+    type = 'leave';
+  }
+  return [{ ...ctx, enterQueue, leaveStack }, mw, type];
+};
+
+const executeCtx = ctx => {
+  const [newCtx, mw, type] = nextMw(ctx);
+
+  if (mw) {
+    return tryExecuteMw(newCtx, mw, type).then(executeCtx);
+  }
+
+  if (newCtx.error) {
+    const { error, ...errorCtx } = newCtx;
+    error.ctx = errorCtx;
+    return Promise.reject(error);
+  }
+
+  return Promise.resolve(newCtx);
+};
+
+/**
+
+   ## contextRunner([interceptors]) => (ctx: Object) => Promise
+
+   `contextRunner` takes an array of interceptor objects and returns a
+   runnable function that takes context map (i.e. `ctx`) as a
+   parameter, executes the interceptor chain and returns a Promise.
+
+   ## Return value
+
+   After running the function returned by the context runner, a
+   Promise will be returned.
+
+   - If the result is successful a `Promise.resolve(ctx)` is returned
+   - If the result is unsuccessful a `Promise.resolve(error)` is
+   - returned. The `error` MUST be instance of Error, and it MUST
+   - contain key `ctx`, which contains the context map.
+
+   ## Interceptor
+
+   Interceptor is an object with `enter`, `leave` and `exit`
+   functions. The object implement all `enter`, `leave` and `exit`
+   functions, or some or none of them.
+
+   It might be beneficial to define interceptors as classes. This
+   helps debugging, because instead of `[Object object]` you are able
+   to see the name of the interceptor. However, if you define the
+   interceptor as a class, you should NOT use `this` in the class
+   methods. The methods will be called in unbinded fashion.
+
+   ### enter(ctx) => ctx
+
+   `enter` function will be called when the context runner is
+   executing the interceptor chain in the `enter` stage. The function
+   takes context map as a parameter and returns the context map. If
+   the interceptor does async operations, it can also return a
+   Promise. If an error occures during the execution, an Error can be
+   thrown.
+
+   ### leave(ctx) => ctx
+
+   `leave` function will be called when the context runner is
+   executing the interceptor chain in the `leave` stage. The function
+   takes context map as a parameter and returns the context map. If
+   the interceptor does async operations, it can also return a
+   Promise. If an error occures during the execution, an Error can be
+   thrown.
+
+   ### error(ctx) => ctx
+
+   `error` function will be called when the context runner is
+   executing the interceptor chain in the `error` stage. The runner
+   goes to an `error` stage, if a previously executed interceptor
+   threw an error or returned a rejected Promise.
+
+   In `error` stage, the context map will have `ctx.error` assigned to
+   the error that was thrown.
+
+   The error can be rescued by returning a context map where
+   `ctx.error` is falsy.
+
+   ## Example usage:
+
+   ```
+   class LocalSumNumbers {
+     enter({ numbers, ...ctx }) {
+       return { ...ctx, sum: numbers.reduce((a, b) => a + b, 0) }
+     }
+   }
+
+   contextRunner([
+     new LocalSumNumbers()
+   ])({ numbers: [1, 2, 3, 4 ]}).then((ctx) => {
+     console.log(ctx.sym) // prints 10
+   });
+   ```
+
+ */
+const contextRunner = middleware => params => executeCtx(buildCtx(params, middleware));
+
+export default contextRunner;

package/src/context_runner.test.js

@@ -0,0 +1,185 @@
+import contextRunner from './context_runner';
+
+describe('context runner', () => {
+  const createEnterMW = name => ctx => {
+    const { enters = [], ...newCtx } = ctx;
+    return { ...newCtx, enters: [...enters, name] };
+  };
+
+  const createLeaveMW = name => ctx => {
+    const { leaves = [], ...newCtx } = ctx;
+    return { ...newCtx, leaves: [...leaves, name] };
+  };
+
+  const createErrorRaiseMW = name => ctx => {
+    const { errors = [], ...newCtx } = ctx;
+    return { ...newCtx, errors: [...errors, name] };
+  };
+
+  const createErrorResolveMW = name => ctx => {
+    const { errors = [], ...newCtx } = ctx;
+    return { ...newCtx, errors: [...errors, name], error: null };
+  };
+
+  const enterRaiseMW = () => {
+    throw new Error('middleware enter failed');
+  };
+
+  const leaveRaiseMW = () => {
+    throw new Error('middleware leave failed');
+  };
+
+  const createTestMiddlewareEL = name => ({
+    enter: createEnterMW(name),
+    leave: createLeaveMW(name),
+  });
+
+  const createTestMiddlewareE = name => ({
+    enter: createEnterMW(name),
+  });
+
+  const createTestMiddlewareL = name => ({
+    leave: createLeaveMW(name),
+  });
+
+  const createTestMiddlewareELERaise = name => ({
+    enter: createEnterMW(name),
+    leave: createLeaveMW(name),
+    error: createErrorRaiseMW(name),
+  });
+
+  const createTestMiddlewareRaise = () => ({
+    enter: enterRaiseMW,
+  });
+
+  const createTestMiddlewareELEResolve = name => ({
+    enter: createEnterMW(name),
+    leave: createLeaveMW(name),
+    error: createErrorResolveMW(name),
+  });
+
+  const createTestMiddlewareELRaise = name => ({
+    enter: createEnterMW(name),
+    leave: leaveRaiseMW,
+  });
+
+  const createEnterTimeoutMW = name => ctx => {
+    const { enters = [], ...newCtx } = ctx;
+
+    return new Promise(resolve => {
+      // eslint-disable-next-line no-undef
+      setTimeout(() => {
+        resolve({ ...newCtx, enters: [...enters, name] });
+      }, 10);
+    });
+  };
+
+  const createLeaveTimeoutMW = name => ctx => {
+    const { leaves = [], ...newCtx } = ctx;
+
+    return new Promise(resolve => {
+      // eslint-disable-next-line no-undef
+      setTimeout(() => {
+        resolve({ ...newCtx, leaves: [...leaves, name] });
+      }, 10);
+    });
+  };
+
+  const createTestMiddlewareTimeoutEL = name => ({
+    enter: createEnterTimeoutMW(name),
+    leave: createLeaveTimeoutMW(name),
+  });
+
+  it('exists', () => {
+    expect(contextRunner).not.toBeNull();
+    expect(contextRunner).not.toBeUndefined();
+  });
+
+  it('executes enter and leave phases of middleware', () => {
+    const mw = createTestMiddlewareEL('one');
+    const runner = contextRunner([mw]);
+
+    return runner().then(ctx => {
+      expect(ctx.enters).toEqual(['one']);
+      expect(ctx.leaves).toEqual(['one']);
+    });
+  });
+
+  it('executes enters in given orders and leaves in reverse', () => {
+    const mw1 = createTestMiddlewareEL('one');
+    const mw2 = createTestMiddlewareEL('two');
+    const mw3 = createTestMiddlewareEL('three');
+    const runner = contextRunner([mw1, mw2, mw3]);
+
+    return runner().then(ctx => {
+      expect(ctx.enters).toEqual(['one', 'two', 'three']);
+      expect(ctx.leaves).toEqual(['three', 'two', 'one']);
+    });
+  });
+
+  it('calls enter and leave only on middleware that define them', () => {
+    const mw1 = createTestMiddlewareE('one');
+    const mw2 = createTestMiddlewareEL('two');
+    const mw3 = createTestMiddlewareL('three');
+    const runner = contextRunner([mw1, mw2, mw3]);
+
+    return runner().then(ctx => {
+      expect(ctx.enters).toEqual(['one', 'two']);
+      expect(ctx.leaves).toEqual(['three', 'two']);
+    });
+  });
+
+  it('calls error on all middlewares in stack', () => {
+    const mw1 = createTestMiddlewareELERaise('one');
+    const mw2 = createTestMiddlewareELERaise('two');
+    const mw3 = createTestMiddlewareRaise();
+    const runner = contextRunner([mw1, mw2, mw3]);
+
+    return runner().catch(error => {
+      const { ctx } = error;
+      expect(ctx.enters).toEqual(['one', 'two']);
+      expect(ctx.leaves).toBeUndefined();
+      expect(ctx.errors).toEqual(['two', 'one']);
+    });
+  });
+
+  it('middleware can resolve an error which leads to remaining leaves being called', () => {
+    const mw1 = createTestMiddlewareEL('one');
+    const mw2 = createTestMiddlewareELEResolve('two');
+    const mw3 = createTestMiddlewareRaise();
+    const runner = contextRunner([mw1, mw2, mw3]);
+
+    return runner().then(ctx => {
+      expect(ctx.enters).toEqual(['one', 'two']);
+      expect(ctx.leaves).toEqual(['one']);
+      expect(ctx.errors).toEqual(['two']);
+    });
+  });
+
+  it('leave raising trigger the error flow', () => {
+    const mw1 = createTestMiddlewareELERaise('one');
+    const mw2 = createTestMiddlewareELRaise('two');
+    const mw3 = createTestMiddlewareEL('three');
+    const runner = contextRunner([mw1, mw2, mw3]);
+
+    return runner().catch(error => {
+      const { ctx } = error;
+
+      expect(ctx.enters).toEqual(['one', 'two', 'three']);
+      expect(ctx.leaves).toEqual(['three']);
+      expect(ctx.errors).toEqual(['one']);
+    });
+  });
+
+  it('supports async operations', () => {
+    const mw1 = createTestMiddlewareTimeoutEL('one');
+    const mw2 = createTestMiddlewareTimeoutEL('two');
+    const mw3 = createTestMiddlewareTimeoutEL('three');
+    const runner = contextRunner([mw1, mw2, mw3]);
+
+    return runner().then(ctx => {
+      expect(ctx.enters).toEqual(['one', 'two', 'three']);
+      expect(ctx.leaves).toEqual(['three', 'two', 'one']);
+    });
+  });
+});

package/src/detect.js

@@ -0,0 +1,11 @@
+/**
+
+   Collection of functions for detecting browser/server capabilities.
+
+ */
+
+/* eslint-disable import/prefer-default-export */
+/* eslint-disable no-undef */
+
+export const hasBrowserCookies = () =>
+  typeof document === 'object' && typeof document.cookie === 'string';