@bunnyapp/api-client 1.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Bunny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# bunny-node
+
+A node sdk for Bunny CRM
+
+## Setup
+
+Install the latest package.
+
+```sh
+npm install bunny --save
+```
+
+Create a Bunny api client using either a valid access token or client credentials.
+
+### Access Token
+
+The benefit of providing an accessToken is the request will be faster as an access token does not need to be generated. The
+downside of this approach is that if the token expires then your requests will start to fail.
+
+```js
+const Bunny = require("bunny");
+const bunny = new Bunny({
+  baseUrl: "https://<subdomain>.bunny.com",
+  accessToken: "<bunny-access-token>",
+});
+```
+
+### Client Credentials
+
+Alternately you can provide clientId, clientSecret, & scope. In this case the client will generate an access token and if the token expires it will generate another one.
+
+```js
+const Bunny = require("bunny");
+const bunny = new Bunny({
+  baseUrl: "https://<subdomain>.bunny.com",
+  clientId: "<bunny-client-id>",
+  clientSecret: "<bunny-client-secret>",
+  scope: "standard:read standard:write",
+});
+```
+
+## Convenience methods
+
+This SDK wrappers several of the common Bunny API requests.
+
+```js
+bunny.createSubscription(
+  accountName,
+  firstName,
+  lastName,
+  email,
+  productPlanCode,
+  options
+);
+bunny.createTenant(name, code, platformCode, subscriptionId);
+bunny.trackUsage(featureCode, quantity, tenantCode, usageAt);
+```
+
+## Perform a query
+
+If the convenience methods on this SDK are not enough and you need more control over queries or mutations then you can make an async request against the Bunny GraphQL API.
+
+```js
+let query = `query tenants ($filter: String, $limit: Int) {
+    tenants (filter: $filter, limit: $limit) {
+        platform {
+            id
+            name
+            code
+        }
+        id
+        name
+        code
+    }
+}`;
+
+let variables = {
+  filter: "",
+  limit: 10,
+};
+
+let res = await bunny.query(query, variables);
+```
+
+## Validate a webhook payload
+
+When Bunny sends a webhook request it includes a `x-bunny-signature` header which can be used to validate the authenticity of the payload body.
+
+Bunny will provide a signing token which you will need to store in your application and use for validating the webhook.
+
+```js
+let signature = req.headers["x-bunny-signature"];
+let payload = req.body;
+let signingToken = "<secret signing token>";
+
+let valid = bunny.webhooks.validate(signature, payload, signingToken);
+```
+
+## Test
+
+Run unit tests
+
+```sh
+npm test
+```

package/index.js

@@ -0,0 +1 @@
+module.exports = require("./src");

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@bunnyapp/api-client",
+  "version": "1.0.7",
+  "description": "Node.js client for Bunny CRM",
+  "main": "index.js",
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "node_modules/.bin/mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bunnyapp/bunny-node.git"
+  },
+  "keywords": [
+    "crm",
+    "billing",
+    "saas",
+    "subscriptions"
+  ],
+  "author": "Rich Chetwynd",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/bunnyapp/bunny-node/issues"
+  },
+  "homepage": "https://github.com/bunnyapp/bunny-node#readme",
+  "dependencies": {
+    "axios": "^0.26.0",
+    "safe-buffer": "^5.2.1",
+    "scmp": "^2.1.0"
+  },
+  "devDependencies": {
+    "mocha": "^9.2.0",
+    "sinon": "^14.0.0"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "index.js",
+    "src/"
+  ]
+}

package/src/helpers/create-subscription.js

@@ -0,0 +1,39 @@
+const query = `mutation subscriptionCreate ($attributes: SubscriptionAttributes!) {
+  subscriptionCreate (attributes: $attributes) {
+      errors
+      subscription {
+          id
+          trialStartDate
+          trialEndDate
+          startDate
+          endDate
+          state
+          productPlan {
+            name
+          }
+      }
+  }
+}`;
+
+module.exports = async function (
+  accountName,
+  firstName,
+  lastName,
+  email,
+  productPlanCode,
+  options = {}
+) {
+  let variables = {
+    attributes: {
+      accountName: accountName,
+      firstName: firstName,
+      lastName: lastName,
+      email: email,
+      productPlanCode: productPlanCode,
+      tenantCode: options["tenantCode"]?.toString(),
+      trialStartDate: options["trialStartDate"],
+      trial: options["trial"],
+    },
+  };
+  return this.query(query, variables);
+};

package/src/helpers/create-tenant.js

@@ -0,0 +1,26 @@
+const query = `mutation tenantCreate ($attributes: TenantAttributes!, $subscriptionId: ID!) {
+  tenantCreate (attributes: $attributes, subscriptionId: $subscriptionId) {
+    tenant {
+      code
+      id
+      name
+      platform {
+        id
+        name
+        code
+      }
+    }
+  }
+}`;
+
+module.exports = async function (name, code, platformCode, subscriptionId) {
+  let variables = {
+    attributes: {
+      name: name,
+      code: code,
+      platformCode: platformCode,
+    },
+    subscriptionId: subscriptionId,
+  };
+  return this.query(query, variables);
+};

package/src/helpers/track-usage.js

@@ -0,0 +1,41 @@
+const query = `mutation featureUsageCreate ($attributes: FeatureUsageAttributes!) {
+    featureUsageCreate (attributes: $attributes) {
+        errors
+        featureUsage {
+            id
+            quantity
+            usageAt
+            tenant {
+                id
+                code
+                name
+            }
+            feature {
+                id
+                code
+                name
+            }
+        }
+    }
+}`;
+
+module.exports = async function (
+  featureCode,
+  quantity,
+  tenantCode,
+  usageAt = null
+) {
+  let variables = {
+    attributes: {
+      quantity: quantity,
+      tenantCode: tenantCode,
+      featureCode: featureCode,
+    },
+  };
+
+  if (usageAt) {
+    variables["attributes"]["usageAt"] = usageAt;
+  }
+
+  return this.query(query, variables);
+};

package/src/helpers/update-tenant.js

@@ -0,0 +1,25 @@
+const query = `mutation tenantUpdate ($id: ID!, $attributes: TenantAttributes!) {
+  tenantUpdate (id: $id, attributes: $attributes) {
+    tenant {
+      code
+      id
+      name
+      platform {
+        id
+        name
+        code
+      }
+    }
+  }
+}`;
+
+module.exports = async function (id, code, name) {
+  let variables = {
+    id: id,
+    attributes: {
+      code: code?.toString(),
+      name: name,
+    },
+  };
+  return this.query(query, variables);
+};

package/src/index.js

@@ -0,0 +1,90 @@
+var assert = require("assert");
+var axios = require("axios");
+
+var Webhooks = require("./webhooks");
+
+class Bunny {
+  constructor(options = {}) {
+    if (!(this instanceof Bunny)) return new Bunny();
+    assert(options.baseUrl, "Bunny base url required");
+
+    this.options = options;
+
+    if (options.accessToken == undefined) {
+      assert(options.clientId, "Bunny API clientId required");
+      assert(options.clientSecret, "Bunny API clientSecret required");
+      assert(options.scope, "Bunny API scope required");
+    }
+
+    this.client = axios.create({
+      headers: {
+        "User-Agent": "Bunny-node",
+      },
+      baseURL: options.baseUrl,
+    });
+
+    this.client.interceptors.response.use(null, async (error) => {
+      if (
+        error.config &&
+        error.response &&
+        error.response.status === 401 &&
+        !error.config.retry &&
+        error.config.url != "/oauth/token"
+      ) {
+        const accessToken = await this.fetchAccessToken();
+
+        error.config.retry = true;
+        error.config.headers["Authorization"] = `bearer ${accessToken}`;
+
+        return axios.request(error.config);
+      }
+
+      return Promise.reject(error);
+    });
+
+    this.webhooks = new Webhooks(options.webhookSigningToken);
+  }
+
+  async fetchAccessToken() {
+    const params = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this.options.clientId,
+      client_secret: this.options.clientSecret,
+      scope: this.options.scope,
+    });
+
+    let res = await this.client.post("/oauth/token", params, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+    });
+
+    return res?.data?.access_token;
+  }
+
+  async query(query, variables) {
+    let body = {
+      query,
+      variables,
+    };
+
+    if (this.options.accessToken == undefined) {
+      this.options.accessToken = await this.fetchAccessToken();
+    }
+
+    let res = await this.client.post("/graphql", body, {
+      headers: {
+        Authorization: `bearer ${this.options.accessToken}`,
+      },
+    });
+
+    return res.data;
+  }
+}
+
+Bunny.prototype.createSubscription = require("./helpers/create-subscription.js");
+Bunny.prototype.createTenant = require("./helpers/create-tenant.js");
+Bunny.prototype.updateTenant = require("./helpers/update-tenant.js");
+Bunny.prototype.trackUsage = require("./helpers/track-usage.js");
+
+module.exports = Bunny;

package/src/webhooks.js

@@ -0,0 +1,24 @@
+const crypto = require("crypto");
+const scmp = require("scmp");
+const Buffer = require("safe-buffer").Buffer;
+
+class Webhooks {
+  constructor(signingToken = null) {
+    this.signingToken = signingToken;
+  }
+  validate(signature, payload, signingToken = null) {
+    let key = signingToken || this.signingToken;
+
+    let payloadSignature = crypto
+      .createHmac("sha1", key)
+      .update(JSON.stringify(payload))
+      .digest("hex");
+
+    const ps = Buffer.from(payloadSignature, "hex");
+    const s = Buffer.from(signature, "hex");
+
+    return scmp(ps, s);
+  }
+}
+
+module.exports = Webhooks;