webflow-api 0.5.4

package/dist/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var isObjectEmpty = exports.isObjectEmpty = function isObjectEmpty(obj) {
+  return Object.keys(obj).length === 0;
+};
+
+var pick = exports.pick = function pick(obj) {
+  for (var _len = arguments.length, props = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    props[_key - 1] = arguments[_key];
+  }
+
+  var picked = {};
+
+  props.forEach(function (prop) {
+    if (obj[prop] !== undefined) {
+      picked[prop] = obj[prop];
+    }
+  });
+
+  return picked;
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "webflow-api",
+  "version": "0.5.4",
+  "description": "SDK for the Webflow CMS API",
+  "main": "dist/index.js",
+  "jsnext:main": "src/index.js",
+  "repository": {
+    "url": "https://github.com/webflow/js-webflow-api.git",
+    "type": "git"
+  },
+  "license": "MIT",
+  "types": "index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "LICENSE",
+    "yarn.lock"
+  ],
+  "scripts": {
+    "build": "BABEL_ENV=production babel --out-dir dist src/",
+    "lint": "eslint src",
+    "prepublish": "npm run build",
+    "report": "nyc report --reporter=html",
+    "test": "nyc ava",
+    "watch": "npm run build -- --watch",
+    "watch:test": "npm run test -- --watch"
+  },
+  "devDependencies": {
+    "ava": "^0.16.0",
+    "babel-cli": "^6.18.0",
+    "babel-core": "^6.18.2",
+    "babel-eslint": "^7.1.0",
+    "babel-plugin-add-module-exports": "^0.2.1",
+    "babel-preset-es2015": "^6.18.0",
+    "babel-preset-stage-1": "^6.16.0",
+    "babel-register": "^6.18.0",
+    "eslint": "^3.10.1",
+    "eslint-config-airbnb-base": "^10.0.1",
+    "eslint-plugin-import": "^2.2.0",
+    "nock": "^13.0.7",
+    "nyc": "^9.0.1"
+  },
+  "dependencies": {
+    "es6-error": "^4.0.0",
+    "isomorphic-fetch": "^3.0.0",
+    "qs": "^6.3.0"
+  },
+  "ava": {
+    "require": [
+      "babel-register"
+    ],
+    "babel": "inherit"
+  }
+}

package/src/ResponseWrapper.js

@@ -0,0 +1,72 @@
+export default class ResponseWrapper {
+  constructor(api) {
+    this.api = api;
+  }
+
+  site(site) {
+    return {
+      ...site,
+
+      collections: this.api.collections.bind(this.api, { siteId: site._id }),
+      webhooks: this.api.webhooks.bind(this.api, { siteId: site._id }),
+      domains: this.api.domains.bind(this.api, { siteId: site._id }),
+      webhook(first, ...rest) {
+        return this.api.webhook({ ...first, siteId: site._id }, ...rest);
+      },
+      createWebhook(first, ...rest) {
+        return this.api.createWebhook({ ...first, siteId: site._id }, ...rest);
+      },
+      removeWebhook(first, ...rest) {
+        return this.api.removeWebhook({ ...first, siteId: site._id }, ...rest);
+      },
+      publishSite(domains) {
+        return this.api.publishSite({ siteId: site._id, domains });
+      },
+    };
+  }
+
+  domain(domain) {
+    return {
+      ...domain,
+    };
+  }
+
+  collection(collection) {
+    return {
+      ...collection,
+
+      items: this.api.items.bind(this.api, { collectionId: collection._id }),
+      item(first, ...rest) {
+        return this.api.item({ ...first, collectionId: collection._id }, ...rest);
+      },
+      createItem(first, ...rest) {
+        return this.api.createItem({ ...first, collectionId: collection._id }, ...rest);
+      },
+      updateItem(first, ...rest) {
+        return this.api.updateItem({ ...first, collectionId: collection._id }, ...rest);
+      },
+      removeItem(first, ...rest) {
+        return this.api.removeItem({ ...first, collectionId: collection._id }, ...rest);
+      },
+    };
+  }
+
+  item(item, collectionId) {
+    return {
+      ...item,
+
+      update(first, ...rest) {
+        return this.api.updateItem({ ...first, collectionId, itemId: item._id }, ...rest);
+      },
+      remove: this.api.updateItem.bind(this.api, { collectionId, itemId: item._id }),
+    };
+  }
+
+  webhook(webhook, siteId) {
+    return {
+      ...webhook,
+
+      remove: this.api.removeWebhook.bind(this.api, { siteId, webhookId: webhook._id }),
+    };
+  }
+}

package/src/Webflow.js

@@ -0,0 +1,255 @@
+import fetch from 'isomorphic-fetch';
+import qs from 'qs';
+
+import { isObjectEmpty } from './utils';
+import ResponseWrapper from './ResponseWrapper';
+import WebflowError, { buildRequiredArgError } from './WebflowError';
+
+const DEFAULT_ENDPOINT = 'https://api.webflow.com';
+
+const buildMeta = (res) => {
+  if (!res || !res.headers) { return {}; }
+
+  return {
+    rateLimit: {
+      limit: parseInt(res.headers.get('x-ratelimit-limit'), 10),
+      remaining: parseInt(res.headers.get('x-ratelimit-remaining'), 10),
+    },
+  };
+};
+
+const responseHandler = res =>
+  res.json()
+    .catch(err =>
+      // Catch unexpected server errors where json isn't sent and rewrite
+      // with proper class (WebflowError)
+      Promise.reject(new WebflowError(err)))
+    .then((body) => {
+      if (res.status >= 400) {
+        const errOpts = {
+          code: body.code,
+          msg: body.msg,
+          _meta: buildMeta(res),
+        };
+
+        if (body.problems && body.problems.length > 0) {
+          errOpts.problems = body.problems;
+        }
+
+        const errMsg = (body && body.err) ? body.err : 'Unknown error occured';
+        const err = new WebflowError(errMsg);
+
+        return Promise.reject(Object.assign(err, errOpts));
+      }
+
+      body._meta = buildMeta(res); // eslint-disable-line no-param-reassign
+
+      return body;
+    });
+
+export default class Webflow {
+  constructor({
+    endpoint = DEFAULT_ENDPOINT,
+    token,
+    version = '1.0.0',
+  } = {}) {
+    if (!token) throw buildRequiredArgError('token');
+
+    this.responseWrapper = new ResponseWrapper(this);
+
+    this.endpoint = endpoint;
+    this.token = token;
+
+    this.headers = {
+      Accept: 'application/json',
+      Authorization: `Bearer ${token}`,
+      'accept-version': version,
+      'Content-Type': 'application/json',
+    };
+
+    this.authenticatedFetch = (method, path, data, query) => {
+      const queryString = query && !isObjectEmpty(query)
+        ? `?${qs.stringify(query)}`
+        : '';
+
+      const uri = `${this.endpoint}${path}${queryString}`;
+      const opts = {
+        method,
+        headers: this.headers,
+        mode: 'cors',
+      };
+
+      if (data) {
+        opts.body = JSON.stringify(data);
+      }
+
+      return fetch(uri, opts)
+        .then(responseHandler);
+    };
+  }
+
+  // Generic HTTP request handlers
+
+  get(path, query = {}) {
+    return this.authenticatedFetch('GET', path, false, query);
+  }
+
+  post(path, data, query = {}) {
+    return this.authenticatedFetch('POST', path, data, query);
+  }
+
+  put(path, data, query = {}) {
+    return this.authenticatedFetch('PUT', path, data, query);
+  }
+
+  patch(path, data, query = {}) {
+    return this.authenticatedFetch('PATCH', path, data, query);
+  }
+
+  delete(path, query = {}) {
+    return this.authenticatedFetch('DELETE', path, query);
+  }
+
+  // Meta
+
+  info(query = {}) {
+    return this.get('/info', query);
+  }
+
+  // Sites
+
+  sites(query = {}) {
+    return this.get('/sites', query).then(sites => sites.map(site => this.responseWrapper.site(site)));
+  }
+
+  site({ siteId }, query = {}) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+
+    return this.get(`/sites/${siteId}`, query).then(site => this.responseWrapper.site(site));
+  }
+
+  publishSite({ siteId, domains }) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+    if (!domains) return Promise.reject(buildRequiredArgError('domains'));
+
+    return this.post(`/sites/${siteId}/publish`, { domains });
+  }
+
+  // Domains
+
+  domains({ siteId }) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+
+    return this.get(`/sites/${siteId}/domains`).then(
+      domains => domains.map(domain => this.responseWrapper.domain(domain, siteId)),
+    );
+  }
+
+  // Collections
+
+  collections({ siteId }, query = {}) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+
+    return this.get(`/sites/${siteId}/collections`, query).then(
+      collections => collections.map(collection => this.responseWrapper.collection(collection)),
+    );
+  }
+
+  collection({ collectionId }, query = {}) {
+    if (!collectionId) return Promise.reject(buildRequiredArgError('collectionId'));
+
+    return this.get(`/collections/${collectionId}`, query).then(
+      collection => this.responseWrapper.collection(collection),
+    );
+  }
+
+  // Items
+
+  items({ collectionId }, query = {}) {
+    if (!collectionId) return Promise.reject(buildRequiredArgError('collectionId'));
+
+    return this.get(`/collections/${collectionId}/items`, query).then(
+      res => ({
+        ...res,
+
+        items: res.items.map(item => this.responseWrapper.item(item, collectionId)),
+      }),
+    );
+  }
+
+  item({ collectionId, itemId }, query = {}) {
+    if (!collectionId) return Promise.reject(buildRequiredArgError('collectionId'));
+    if (!itemId) return Promise.reject(buildRequiredArgError('siteId'));
+
+    return this.get(`/collections/${collectionId}/items/${itemId}`, query).then(
+      res => this.responseWrapper.item(res.items[0], collectionId),
+    );
+  }
+
+  createItem({ collectionId, ...data }, query = {}) {
+    if (!collectionId) return Promise.reject(buildRequiredArgError('collectionId'));
+
+    return this.post(`/collections/${collectionId}/items`, data, query).then(
+      item => this.responseWrapper.item(item, collectionId),
+    );
+  }
+
+  updateItem({ collectionId, itemId, ...data }, query = {}) {
+    if (!collectionId) return Promise.reject(buildRequiredArgError('collectionId'));
+    if (!itemId) return Promise.reject(buildRequiredArgError('itemId'));
+
+    return this.put(`/collections/${collectionId}/items/${itemId}`, data, query);
+  }
+
+  removeItem({ collectionId, itemId }, query = {}) {
+    if (!collectionId) return Promise.reject(buildRequiredArgError('collectionId'));
+    if (!itemId) return Promise.reject(buildRequiredArgError('itemId'));
+
+    return this.delete(`/collections/${collectionId}/items/${itemId}`, query);
+  }
+
+  patchItem({ collectionId, itemId, ...data }, query = {}) {
+    if (!collectionId) return Promise.reject(buildRequiredArgError('collectionId'));
+    if (!itemId) return Promise.reject(buildRequiredArgError('itemId'));
+
+    return this.patch(`/collections/${collectionId}/items/${itemId}`, data, query);
+  }
+
+  // Images
+
+  // TODO
+
+  // Webhooks
+
+  webhooks({ siteId }, query = {}) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+
+    return this.get(`/sites/${siteId}/webhooks`, query).then(
+      webhooks => webhooks.map(webhook => this.responseWrapper.webhook(webhook, siteId)),
+    );
+  }
+
+  webhook({ siteId, webhookId }, query = {}) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+    if (!webhookId) return Promise.reject(buildRequiredArgError('webhookId'));
+
+    return this.get(`/sites/${siteId}/webhooks/${webhookId}`, query).then(
+      webhook => this.responseWrapper.webhook(webhook, siteId),
+    );
+  }
+
+  createWebhook({ siteId, ...data }, query = {}) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+
+    return this.post(`/sites/${siteId}/webhooks`, data, query).then(
+      webhook => this.responseWrapper.webhook(webhook, siteId),
+    );
+  }
+
+  removeWebhook({ siteId, webhookId }, query = {}) {
+    if (!siteId) return Promise.reject(buildRequiredArgError('siteId'));
+    if (!webhookId) return Promise.reject(buildRequiredArgError('webhookId'));
+
+    return this.delete(`/sites/${siteId}/webhooks/${webhookId}`, query);
+  }
+}

package/src/WebflowError.js

@@ -0,0 +1,6 @@
+import ExtendableError from 'es6-error';
+
+export default class WebflowError extends ExtendableError {}
+
+export const buildRequiredArgError = name =>
+  new WebflowError(`Argument '${name}' is required but was not present`);

package/src/index.js

@@ -0,0 +1,2 @@
+module.exports = require('./Webflow');
+module.exports.WebflowError = require('./WebflowError').default;

package/src/utils.js

@@ -0,0 +1,13 @@
+export const isObjectEmpty = obj => Object.keys(obj).length === 0;
+
+export const pick = (obj, ...props) => {
+  const picked = {};
+
+  props.forEach((prop) => {
+    if (obj[prop] !== undefined) {
+      picked[prop] = obj[prop];
+    }
+  });
+
+  return picked;
+};