webflow-api 0.8.1 → 1.0.0

package/dist/WebflowClient.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.WebflowRequestError = exports.WebflowClient = void 0;
+var _isomorphicFetch = _interopRequireDefault(require("isomorphic-fetch"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_HOST = "webflow.com";
+const USER_AGENT = "Webflow Javascript SDK / 1.0";
+class WebflowRequestError extends Error {
+  constructor(error) {
+    super(error.err ? error.err : "Unknown error occured");
+    Object.assign(this, error);
+  }
+}
+exports.WebflowRequestError = WebflowRequestError;
+class WebflowClient {
+  constructor({
+    host,
+    token,
+    version,
+    headers,
+    mode
+  } = {}) {
+    this.host = host || DEFAULT_HOST;
+    this.headers = headers || {};
+    this.version = version;
+    this.token = token;
+    this.mode = mode;
+  }
+  getUri(path, query = {}) {
+    const hasQuery = Object.keys(query).length > 0;
+    const queryString = hasQuery ? `?${new URLSearchParams(query)}` : "";
+    return `https://api.${this.host}${path}${queryString}`;
+  }
+  getHeaders() {
+    const {
+      version,
+      token
+    } = this;
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": USER_AGENT
+    };
+
+    // set authorization header if token is set
+    if (token) headers.Authorization = `Bearer ${token}`;
+
+    // set the API version
+    if (version) headers["accept-version"] = version;
+
+    // merge headers with user headers;
+    return {
+      ...headers,
+      ...this.headers
+    };
+  }
+  async parseBody(res) {
+    const body = await res.json();
+
+    // append ratelimit meta data to response
+    if (res.headers) {
+      const limit = parseInt(res.headers.get("x-ratelimit-limit"), 10);
+      const remaining = parseInt(res.headers.get("x-ratelimit-remaining"), 10);
+      body._meta = {
+        rateLimit: {
+          limit,
+          remaining
+        }
+      };
+    }
+
+    // webflow error
+    if (body.err) throw new WebflowRequestError(body);
+    return body;
+  }
+  fetch(method, path, data, query) {
+    // build uri
+    const uri = this.getUri(path, query);
+
+    // build request options
+    const headers = this.getHeaders();
+    const opts = {
+      method,
+      headers,
+      mode: this.mode
+    };
+    if (data) opts.body = JSON.stringify(data);
+
+    // call fetch and wrap response
+    return (0, _isomorphicFetch.default)(uri, opts).then(this.parseBody.bind(this));
+  }
+
+  // Generic HTTP request handlers
+  get(path, query = {}) {
+    return this.fetch("GET", path, null, query);
+  }
+  post(path, data, query = {}) {
+    return this.fetch("POST", path, data, query);
+  }
+  put(path, data, query = {}) {
+    return this.fetch("PUT", path, data, query);
+  }
+  patch(path, data, query = {}) {
+    return this.fetch("PATCH", path, data, query);
+  }
+  delete(path, data, query = {}) {
+    return this.fetch("DELETE", path, data, query);
+  }
+}
+exports.WebflowClient = WebflowClient;
+var _default = WebflowClient;
+exports.default = _default;

package/dist/index.js

@@ -1,4 +1,10 @@
 "use strict";
 
-module.exports = require("./Webflow")["default"];
-module.exports.WebflowError = require("./WebflowError")["default"];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Webflow = require("./Webflow");
+var _default = _Webflow.Webflow;
+exports.default = _default;
+module.exports = exports.default;

package/index.d.ts

@@ -1,51 +1,76 @@
 declare class Webflow {
-  constructor(options: Webflow.WebflowOptions);
+  constructor(options: Webflow.Options);
 
   get<Result extends any>(
     path: string,
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<Result>;
   post<Data extends any, Result extends any>(
     path: string,
     data?: Data,
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<Result>;
   put<Data extends any, Result extends any>(
     path: string,
     data?: Data,
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<Result>;
   patch<Data extends any, Result extends any>(
     path: string,
     data?: Data,
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<Result>;
   delete<Result extends any>(
     path: string,
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<Result>;
 
-  info(query?: Webflow.WebflowQueryArg): Promise<Webflow.WebflowApiModel.Info>;
+  // meta
+  info(): Promise<Webflow.ApiModel.Info>;
+  installer(): Promise<Webflow.ApiModel.Installer>;
+
+  // oauth
+  authorizeUrl(params: {
+    client_id: string;
+    redirect_uri?: string;
+    state?: string;
+    scope?: string;
+    response_type?: string;
+  }): string;
+
+  accessToken(params: {
+    client_id: string;
+    client_secret: string;
+    redirect_uri?: string;
+    code: string;
+    grant_type?: string;
+  }): Promise<{
+    token_type: string;
+    access_token: string;
+  }>;
+
+  revokeToken(params: {
+    client_id: string;
+    client_secret: string;
+    access_token: string;
+  }): Promise<{ didRevoke: boolean }>;
 
   // sites
-
-  sites(
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Site[]>;
+  sites(query?: Webflow.QueryArg): Promise<Webflow.ApiModel.Site[]>;
 
   site(
     params: {
       siteId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Site>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.Site>;
 
   publishSite(
     data: {
       siteId: string;
       domains: string[];
     },
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<{ queued: boolean }>;
 
   // Domains
@@ -54,8 +79,8 @@ declare class Webflow {
     data: {
       siteId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Domain[]>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.Domain[]>;
 
   // Collections
 
@@ -63,45 +88,45 @@ declare class Webflow {
     data: {
       siteId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Collection[]>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.Collection[]>;
   collection(
     data: {
       collectionId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Collection>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.Collection>;
 
   // Users
   users(
     data: {
       siteId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.User[]>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.User[]>;
 
   user(
     data: {
       siteId: string;
       userId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.User>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.User>;
 
   updateUser(
     data: { siteId: string; userId: string } & Record<string, any>,
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.User>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.User>;
 
   removeUser(
     data: { siteId: string; userId: string },
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<{ deleted: number }>;
 
   inviteUser(
     data: { siteId: string; email: string },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.User>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.User>;
 
   // Items
 
@@ -109,61 +134,61 @@ declare class Webflow {
     data: {
       collectionId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.ItemsResponse>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.ItemsResponse>;
 
   item(
     data: {
       collectionId: string;
       itemId: string;
     },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.CollectionItem>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.CollectionItem>;
 
   createItem(
     // TODO: add a better data type
     data: { collectionId: string } & Record<string, any>,
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.CollectionItem>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.CollectionItem>;
 
   updateItem(
     // TODO: add a better data type
     data: { collectionId: string; itemId: string } & Record<string, any>,
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.CollectionItem>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.CollectionItem>;
 
   removeItem(
     data: { collectionId: string; itemId: string },
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<{ deleted: number }>;
 
   patchItem(
     // TODO: add a better data type
     data: { collectionId: string; itemId: string } & Record<string, any>,
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.CollectionItem>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.CollectionItem>;
 
   // Webhooks
 
   webhooks(
     data: { siteId: string },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Webhook[]>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.Webhook[]>;
 
   webhook(
     data: { siteId: string; webhookId: string },
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Webhook>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.Webhook>;
 
   createWebhook(
     // TODO: add a better data type
     data: { siteId: string } & Record<string, any>,
-    query?: Webflow.WebflowQueryArg
-  ): Promise<Webflow.WebflowApiModel.Webhook>;
+    query?: Webflow.QueryArg
+  ): Promise<Webflow.ApiModel.Webhook>;
 
   removeWebhook(
     data: { siteId: string; webhookId: string },
-    query?: Webflow.WebflowQueryArg
+    query?: Webflow.QueryArg
   ): Promise<{ deleted: number }>;
 }
 
@@ -172,15 +197,26 @@ declare namespace Webflow {
   class WebflowError extends Error {}
 
   // helper types / namespaces
-  type WebflowQueryArg = Record<string, any>;
+  type QueryArg = Record<string, any>;
 
-  interface WebflowOptions {
+  interface Options {
     token: string;
     endpoint?: string;
     version?: string;
+    mode?: string;
+    headers?: { [key: string]: string };
   }
 
-  namespace WebflowApiModel {
+  namespace ApiModel {
+    interface Installer {
+      user: {
+        _id: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+      };
+    }
+
     interface InfoApplication {
       _id: string;
       description: string;

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "webflow-api",
-  "version": "0.8.1",
-  "description": "SDK for the Webflow CMS API",
+  "description": "Webflow's official Node.js SDK for Data APIs",
+  "version": "1.0.0",
+  "types": "index.d.ts",
   "main": "dist/index.js",
-  "jsnext:main": "src/index.js",
+  "contributors": [
+    "John Agan (https://github.com/johnagan)"
+  ],
   "repository": {
     "url": "https://github.com/webflow/js-webflow-api.git",
     "type": "git"
   },
   "license": "MIT",
-  "types": "index.d.ts",
   "files": [
     "dist",
     "src",
@@ -18,35 +20,31 @@
     "index.d.ts"
   ],
   "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"
+    "compile": "BABEL_ENV=production babel --out-dir dist src/",
+    "build": " yarn clean && yarn compile",
+    "watch": "yarn build --watch",
+    "prepublish": "yarn build",
+    "clean": "rm -rf dist",
+    "lint": "eslint",
+    "test": "jest"
   },
   "devDependencies": {
-    "@babel/cli": "^7.17.6",
-    "@babel/core": "^7.17.8",
-    "@babel/preset-env": "^7.16.11",
-    "@babel/register": "^7.17.7",
-    "ava": "^4.1.0",
+    "@babel/cli": "^7.19.3",
+    "@babel/core": "^7.19.6",
+    "@babel/preset-env": "^7.19.4",
+    "@babel/register": "^7.18.9",
+    "@jest/globals": "^29.2.2",
+    "babel-jest": "^29.2.2",
+    "babel-plugin-add-module-exports": "^1.0.4",
     "eslint": "^8.12.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-import": "^2.25.2",
-    "nock": "^13.0.7",
-    "nyc": "^15.1.0"
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^29.2.2",
+    "nock": "^13.0.7"
   },
   "dependencies": {
-    "es6-error": "^4.0.0",
-    "isomorphic-fetch": "^3.0.0",
-    "qs": "^6.3.0"
-  },
-  "ava": {
-    "require": [
-      "@babel/register"
-    ]
+    "isomorphic-fetch": "^3.0.0"
   }
 }

package/src/ResponseWrapper.js

@@ -10,16 +10,16 @@ export default class ResponseWrapper {
       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) {
+      webhook: (first, ...rest) => {
         return this.api.webhook({ ...first, siteId: site._id }, ...rest);
       },
-      createWebhook(first, ...rest) {
+      createWebhook: (first, ...rest) => {
         return this.api.createWebhook({ ...first, siteId: site._id }, ...rest);
       },
-      removeWebhook(first, ...rest) {
+      removeWebhook: (first, ...rest) => {
         return this.api.removeWebhook({ ...first, siteId: site._id }, ...rest);
       },
-      publishSite(domains) {
+      publishSite: (domains) => {
         return this.api.publishSite({ siteId: site._id, domains });
       },
     };
@@ -36,25 +36,25 @@ export default class ResponseWrapper {
       ...collection,
 
       items: this.api.items.bind(this.api, { collectionId: collection._id }),
-      item(first, ...rest) {
+      item: (first, ...rest) => {
         return this.api.item(
           { ...first, collectionId: collection._id },
           ...rest
         );
       },
-      createItem(first, ...rest) {
+      createItem: (first, ...rest) => {
         return this.api.createItem(
           { ...first, collectionId: collection._id },
           ...rest
         );
       },
-      updateItem(first, ...rest) {
+      updateItem: (first, ...rest) => {
         return this.api.updateItem(
           { ...first, collectionId: collection._id },
           ...rest
         );
       },
-      removeItem(first, ...rest) {
+      removeItem: (first, ...rest) => {
         return this.api.removeItem(
           { ...first, collectionId: collection._id },
           ...rest
@@ -64,43 +64,40 @@ export default class ResponseWrapper {
   }
 
   item(item, collectionId) {
+    const itemId = item._id;
+    const ids = { itemId, collectionId };
     return {
       ...item,
 
-      update(first, ...rest) {
-        return this.api.updateItem(
-          { ...first, collectionId, itemId: item._id },
-          ...rest
-        );
+      update: (itemData, query) => {
+        return this.api.updateItem({ ...itemData, ...ids }, query);
+      },
+      remove: (query) => {
+        return this.api.removeItem(ids, query);
       },
-      remove: this.api.updateItem.bind(this.api, {
-        collectionId,
-        itemId: item._id,
-      }),
     };
   }
 
   user(user, siteId) {
+    const userId = user._id;
+    const ids = { userId, siteId };
+
     return {
       ...user,
-
-      update(first, ...rest) {
-        return this.api.updateUser({ ...first, siteId }, ...rest);
-      },
-      remove(first, ...rest) {
-        return this.api.removeUser({ ...first, siteId }, ...rest);
+      update: (userData) => {
+        return this.api.updateUser({ ...ids, ...userData });
       },
+      remove: this.api.removeUser.bind(this.api, ids),
     };
   }
 
   webhook(webhook, siteId) {
+    const webhookId = webhook._id;
+    const ids = { webhookId, siteId };
+
     return {
       ...webhook,
-
-      remove: this.api.removeWebhook.bind(this.api, {
-        siteId,
-        webhookId: webhook._id,
-      }),
+      remove: this.api.removeWebhook.bind(this.api, ids),
     };
   }
 }