webflow-api 1.0.3 → 1.1.0

package/src/wrapper/item.ts

@@ -0,0 +1,218 @@
+import { Client, QueryString, PaginationFilter } from "../core";
+import { ResponseWrapper } from ".";
+import { Item } from "../api";
+
+export class ItemWrapper implements Item.IItem {
+  "published-on"?: string | null;
+  "published-by"?: string | null;
+  "updated-on": string;
+  "created-on": string;
+  "updated-by": string;
+  "created-by": string;
+  _archived: boolean;
+  _draft: boolean;
+  _cid: string;
+  name: string;
+  slug: string;
+  _id: string;
+
+  constructor(private client: Client, item: Item.IItem) {
+    Object.assign(this, item);
+  }
+
+  /**************************************************************
+   * Static Methods
+   **************************************************************/
+
+  /**
+   * Create a new Item
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.collectionId The Collection ID
+   * @param params.fields The Item fields to create
+   * @returns The created Item
+   */
+  static async create(
+    client: Client,
+    { collectionId, fields }: { collectionId: string; fields: any }
+  ) {
+    const res = await Item.create(client, { collectionId, fields });
+    const item = new ItemWrapper(client, res.data);
+    return ResponseWrapper<typeof item>(res, item);
+  }
+
+  /**
+   * Get a single Item
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.collectionId The Collection ID
+   * @param params.itemId The Item ID
+   * @returns A single Item
+   */
+  static async getOne(
+    client: Client,
+    itemParams: { collectionId: string; itemId: string }
+  ) {
+    const res = await Item.getOne(client, itemParams);
+    const item = new ItemWrapper(client, res.data.items[0]);
+    return ResponseWrapper<typeof item>(res, item);
+  }
+
+  /**
+   * Get a list of Items
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.collectionId The Collection ID
+   * @param params.limit The number of items to return (optional)
+   * @param params.offset The number of items to skip (optional)
+   * @returns A list of Items
+   */
+  static async list(
+    client: Client,
+    { collectionId, limit, offset }: { collectionId: string } & PaginationFilter
+  ) {
+    const res = await Item.list(client, { collectionId, limit, offset });
+    const items = res.data.items.map((i) => new ItemWrapper(client, i));
+    return ResponseWrapper<typeof items>(res, items);
+  }
+
+  /**
+   * Remove a single Item
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.collectionId The Collection ID
+   * @param params.itemId The Item ID
+   * @returns The result from the removal
+   */
+  static async remove(
+    client: Client,
+    { collectionId, itemId }: { collectionId: string; itemId: string }
+  ) {
+    const res = await Item.remove(client, { collectionId, itemId });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**
+   * Publishes a list of Items
+   * @param client The Webflow client
+   * @param params The request parameters
+   * @param params.collectionId The Collection ID
+   * @param params.itemIds The list of Item IDs to publish
+   * @param params.live Publish to live site
+   * @returns The result of the publish
+   */
+  static async publish(
+    client: Client,
+    {
+      collectionId,
+      itemIds,
+      live,
+    }: { collectionId: string; itemIds: string[]; live: boolean }
+  ) {
+    const res = await Item.publish(client, { collectionId, itemIds, live });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**
+   * Unpublishes a list of Items
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.collectionId The Collection ID
+   * @param params.live Unpublish from the live site
+   * @returns The result of the unpublish
+   */
+  static async unpublish(
+    client: Client,
+    {
+      collectionId,
+      itemIds,
+      live,
+    }: { collectionId: string; itemIds: string[]; live: boolean }
+  ) {
+    const res = await Item.unpublish(client, { collectionId, itemIds, live });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**
+   * Update a single Item
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.collectionId The Collection ID
+   * @param params.itemId The Item ID
+   * @param params.fields The fields to update
+   * @returns The updated Item
+   */
+  static async update(
+    client: Client,
+    {
+      collectionId,
+      itemId,
+      fields,
+    }: { collectionId: string; itemId: string; fields: any }
+  ) {
+    const res = await Item.update(client, {
+      collectionId,
+      fields,
+      itemId,
+    });
+
+    const item = new ItemWrapper(client, res.data);
+    return ResponseWrapper<typeof item>(res, item);
+  }
+
+  /**
+   * Patch a single Item
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.collectionId The Collection ID
+   * @param params.itemId The Item ID
+   * @param params.fields The fields to patch
+   * @returns The patched Item
+   */
+  static async patch(
+    client: Client,
+    {
+      collectionId,
+      itemId,
+      fields,
+    }: { collectionId: string; itemId: string; fields: any },
+    params?: QueryString
+  ) {
+    const res = await Item.patch(client, {
+      collectionId,
+      fields,
+      itemId,
+    });
+
+    const item = new ItemWrapper(client, res.data);
+    return ResponseWrapper<typeof item>(res, item);
+  }
+
+  /**************************************************************
+   * Instance Methods
+   **************************************************************/
+
+  /**
+   * Update a single Item
+   * @param fields The fields to update
+   * @returns The updated Item
+   */
+  update({ ...fields }) {
+    return ItemWrapper.update(this.client, {
+      collectionId: this._cid,
+      itemId: this._id,
+      fields,
+    });
+  }
+
+  /**
+   * Remove a single Item
+   * @returns The result from the removal
+   */
+  remove() {
+    return ItemWrapper.remove(this.client, {
+      collectionId: this._cid,
+      itemId: this._id,
+    });
+  }
+}

package/src/wrapper/membership.ts

@@ -0,0 +1,138 @@
+import { Client, PaginationFilter } from "../core";
+import { ResponseWrapper } from ".";
+import { Membership } from "../api";
+
+export class MembershipWrapper implements Membership.IUser {
+  emailVerified: boolean;
+  lastUpdated?: string;
+  createdOn: string;
+  _id: string;
+  data: any;
+
+  constructor(
+    private client: Client,
+    private siteId: string,
+    membership: Membership.IUser
+  ) {
+    Object.assign(this, membership);
+  }
+
+  /**************************************************************
+   * Static Methods
+   **************************************************************/
+
+  /**
+   * Get a single User
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.siteId The site ID
+   * @param params.userId The user ID
+   * @returns A single User
+   */
+  static async getOne(
+    client: Client,
+    { userId, siteId }: { siteId: string; userId: string }
+  ) {
+    const res = await Membership.getOne(client, { userId, siteId });
+    const user = ResponseWrapper<typeof res.data>(res);
+    return new MembershipWrapper(client, siteId, user);
+  }
+
+  /**
+   * Get a list of Users
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.siteId The site ID
+   * @param params.limit The number of items to return (optional)
+   * @param params.offset The number of items to skip (optional)
+   * @returns A list of Users
+   */
+  static async list(
+    client: Client,
+    { siteId, limit, offset }: { siteId: string } & PaginationFilter
+  ) {
+    const res = await Membership.list(client, { siteId, limit, offset });
+    const users = res.data.users.map(
+      (u) => new MembershipWrapper(client, siteId, u)
+    );
+    return ResponseWrapper<typeof users>(res, users);
+  }
+
+  /**
+   * Update a User
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.siteId The site ID
+   * @param params.userId The user ID
+   * @param params.data The data to update
+   * @returns The updated User
+   */
+  static async update(
+    client: Client,
+    { userId, siteId, data }: { userId: string; siteId: string; data: any }
+  ) {
+    const res = await Membership.update(client, { userId, siteId, data });
+    const user = ResponseWrapper<typeof res.data>(res);
+    return new MembershipWrapper(client, siteId, user);
+  }
+
+  /**
+   * Invite a User to a site
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.siteId The site ID
+   * @param params.email The email address of the user to invite
+   * @returns The newly created User
+   */
+  static async invite(
+    client: Client,
+    { siteId, email }: { siteId: string; email: string }
+  ) {
+    const res = await Membership.invite(client, { siteId, email });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**
+   * Remove a User
+   * @param client The Webflow client
+   * @param params The params for the request
+   * @param params.siteId The site ID
+   * @param params.userId The user ID
+   * @returns The result of the remove
+   */
+  static async remove(
+    client: Client,
+    { siteId, userId }: { siteId: string; userId: string }
+  ) {
+    const res = await Membership.remove(client, { userId, siteId });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**************************************************************
+   * Instance Methods
+   **************************************************************/
+
+  /**
+   * Update a User
+   * @param data The data to update
+   * @returns The updated User
+   */
+  async update(data: any) {
+    return MembershipWrapper.update(this.client, {
+      siteId: this.siteId,
+      userId: this._id,
+      data,
+    });
+  }
+
+  /**
+   * Remove a User
+   * @returns The result of the remove
+   */
+  async remove() {
+    return MembershipWrapper.remove(this.client, {
+      siteId: this.siteId,
+      userId: this._id,
+    });
+  }
+}

package/src/wrapper/response.ts

@@ -0,0 +1,25 @@
+import { AxiosResponse } from "axios";
+
+export type MetaResponse<T> = T & {
+  _meta: {
+    rateLimit: {
+      limit: number;
+      remaining: number;
+    };
+  };
+};
+
+/**
+ * Wraps an HTTP response with Webflow Rate Limiting information
+ * @param response The HTTP response
+ * @param data The data to use (defaults to response.data)
+ * @returns The response with Webflow Rate Limiting information
+ */
+export function ResponseWrapper<T>(response: AxiosResponse, data?: T) {
+  const limit = parseInt(response.headers["x-ratelimit-limit"], 10);
+  const remaining = parseInt(response.headers["x-ratelimit-remaining"], 10);
+
+  const result: MetaResponse<T> = data || response.data;
+  result._meta = { rateLimit: { limit, remaining } };
+  return result;
+}

package/src/wrapper/site.ts

@@ -0,0 +1,164 @@
+import {
+  CreateWebhookParams,
+  CollectionWrapper,
+  ResponseWrapper,
+  WebhookWrapper,
+} from ".";
+import { Client, QueryString } from "../core";
+import { Site } from "../api";
+
+export class SiteWrapper implements Site.ISite {
+  lastPublished: string;
+  previewUrl: string;
+  createdOn: string;
+  shortName: string;
+  timezone: string;
+  database: string;
+  name: string;
+  _id: string;
+
+  constructor(private client: Client, site: Site.ISite) {
+    Object.assign(this, site);
+  }
+
+  /**************************************************************
+   * Static Methods
+   **************************************************************/
+
+  /**
+   * Get a single Site
+   * @param client The Webflow client
+   * @param params The Site information
+   * @param params.siteId The Site ID
+   * @returns The Site
+   */
+  static async getOne(client: Client, { siteId }: { siteId: string }) {
+    const res = await Site.getOne(client, { siteId });
+    const site = new SiteWrapper(client, res.data);
+    return ResponseWrapper<typeof site>(res, site);
+  }
+
+  /**
+   * Get a list of Sites available
+   * @param client The Webflow client
+   * @param params The query parameters (optional)
+   * @returns A list of Sites
+   */
+  static async list(client: Client, params?: QueryString) {
+    const res = await Site.list(client, params);
+    const sites = res.data.map((s) => new SiteWrapper(client, s));
+    return ResponseWrapper<typeof sites>(res, sites);
+  }
+
+  /**
+   * Get a list of Domains for a Site
+   * @param client The Webflow client
+   * @param params The Site information
+   * @param params.siteId The Site ID
+   * @returns A list of Domains
+   */
+  static async domains(client: Client, { siteId }: { siteId: string }) {
+    const res = await Site.domains(client, { siteId });
+    return ResponseWrapper<typeof res.data>(res, res.data);
+  }
+
+  /**
+   * Publish a Site
+   * @param client The Webflow client
+   * @param params The Site information
+   * @param params.siteId The Site ID
+   * @param params.domain The domains to publish
+   * @returns The result of the publish
+   */
+  static async publish(
+    client: Client,
+    { siteId, domains }: { siteId: string; domains: string[] }
+  ) {
+    const res = await Site.publish(client, { siteId, domains });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**************************************************************
+   * Instance Methods
+   **************************************************************/
+
+  /**
+   * Get a list of domains for a site
+   * @returns A list of domains
+   */
+  async domains() {
+    const res = await Site.domains(this.client, { siteId: this._id });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**
+   * Publish a site
+   * @param domains The domains to publish to
+   * @returns The publish result
+   */
+  async publishSite(domains: string[]) {
+    const res = await Site.publish(this.client, { siteId: this._id, domains });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**
+   * Get a single Collection
+   * @param params The params for the request
+   * @param params.collectionId The collection ID
+   * @returns A single Collection
+   */
+  async collection({ collectionId }: { collectionId: string }) {
+    return CollectionWrapper.getOne(this.client, { collectionId });
+  }
+
+  /**
+   * Get a list of Collections
+   * @returns A list of Collections
+   */
+  async collections() {
+    return CollectionWrapper.list(this.client, { siteId: this._id });
+  }
+
+  /**
+   * Get a single Webhook
+   * @param params The params for the request
+   * @param params.webhookId The webhook ID
+   * @returns A single Webhook
+   */
+  async webhook({ webhookId }: { webhookId: string }) {
+    return WebhookWrapper.getOne(this.client, { siteId: this._id, webhookId });
+  }
+
+  /**
+   * Get a list of Webhooks
+   * @param params The query string parameters (optional)
+   * @returns A list of Webhooks
+   */
+  async webhooks(params?: QueryString) {
+    return WebhookWrapper.list(this.client, { siteId: this._id }, params);
+  }
+
+  /**
+   * Remove a Webhook
+   * @param params The query string parameters (optional)
+   * @param params.webhookId The Webhook ID
+   * @returns The result of the removal
+   */
+  async removeWebhook({ webhookId }: { webhookId: string }) {
+    return WebhookWrapper.remove(this.client, { siteId: this._id, webhookId });
+  }
+
+  /**
+   * Create a new Webhook
+   * @param params1 The params for the request
+   * @param params1.url The URL to send the webhook to
+   * @param params1.triggerType The event to trigger the webhook
+   * @param params1.filter The filter to apply to the webhook (optional: form_submission only)
+   * @param params The query string parameters (optional)
+   * @returns The created webhook
+   */
+  async createWebhook({ triggerType, filter, url }: CreateWebhookParams) {
+    const _params = { url, siteId: this._id, triggerType, filter };
+    return WebhookWrapper.create(this.client, _params);
+  }
+}

package/src/wrapper/webhook.ts

@@ -0,0 +1,116 @@
+import { ResponseWrapper } from ".";
+import { Client, QueryString } from "../core";
+import { Webhook } from "../api";
+
+export type CreateWebhookParams = {
+  url: string;
+  siteId: string;
+  triggerType: string;
+  filter?: Webhook.Filter;
+};
+
+export class WebhookWrapper implements Webhook.IWebhook {
+  triggerType: Webhook.TriggerType;
+  triggerId: string;
+  createdOn: string;
+  lastUsed?: string;
+  site: string;
+  _id: string;
+  filter?: {
+    name: string;
+  };
+
+  constructor(private client: Client, webhook: Webhook.IWebhook) {
+    Object.assign(this, webhook);
+  }
+
+  /**************************************************************
+   * Static Methods
+   **************************************************************/
+
+  /**
+   * Get a Webhook
+   * @param client The Webflow client
+   * @param params The Webhook params
+   * @param params.siteId The Site ID
+   * @param params.webhookId The Webhook ID
+   * @returns The Webhook
+   */
+  static async getOne(
+    client: Client,
+    { siteId, webhookId }: { siteId: string; webhookId: string }
+  ) {
+    const res = await Webhook.getOne(client, { siteId, webhookId });
+    const webhook = new WebhookWrapper(client, res.data);
+    return ResponseWrapper<typeof webhook>(res, webhook);
+  }
+
+  /**
+   * List Webhooks
+   * @param client The Webflow client
+   * @param param1 The Webhook params
+   * @param param1.siteId The Site ID
+   * @param params Query string params (optional)
+   * @returns A list of Webhooks
+   */
+  static async list(
+    client: Client,
+    { siteId }: { siteId: string },
+    params?: QueryString
+  ) {
+    const res = await Webhook.list(client, { siteId }, params);
+    const webhooks = res.data.map((w) => new WebhookWrapper(client, w));
+    return ResponseWrapper<typeof webhooks>(res, webhooks);
+  }
+
+  /**
+   * Remove a Webhook
+   * @param client The Webflow client
+   * @param params The Webhook params
+   * @param params.siteId The Site ID
+   * @param params.webhookId The Webhook ID
+   * @returns The result of the removal
+   */
+  static async remove(
+    client: Client,
+    { siteId, webhookId }: { siteId: string; webhookId: string }
+  ) {
+    const res = await Webhook.remove(client, { siteId, webhookId });
+    return ResponseWrapper<typeof res.data>(res);
+  }
+
+  /**
+   * Create a Webhook
+   * @param client The Webflow client
+   * @param param1 The Webhook params
+   * @param param1.siteId The Site ID
+   * @param param1.url The URL to send the Webhook to
+   * @param param1.triggerType The event to trigger the Webhook
+   * @param param1.filter The filter to use (optional: form_submission only)
+   * @returns The created Webhook
+   */
+  static async create(
+    client: Client,
+    { triggerType, siteId, filter, url }: CreateWebhookParams
+  ) {
+    const args = { triggerType, siteId, filter, url };
+    const res = await Webhook.create(client, args);
+    const _webhook = new WebhookWrapper(client, res.data);
+    return ResponseWrapper<typeof _webhook>(res, _webhook);
+  }
+
+  /**************************************************************
+   * Instance Methods
+   **************************************************************/
+
+  /**
+   * Remove a Webhook
+   * @returns The result of the removal
+   */
+  async remove() {
+    return WebhookWrapper.remove(this.client, {
+      webhookId: this._id,
+      siteId: this.site,
+    });
+  }
+}