BREAKING CHANGE(scope): change scope, tools and package name

ts/cloudflare.classes.account.ts

@@ -0,0 +1,187 @@
+import plugins = require('./cloudflare.plugins');
+import * as interfaces from './cloudflare.interfaces';
+
+// interfaces
+import { TDnsRecord } from '@tsclass/tsclass';
+
+export class CloudflareAccount {
+  private authEmail: string;
+  private authKey: string;
+  constructor() {
+    // Nothing here
+  }
+
+  auth(optionsArg: { email: string; key: string }) {
+    this.authEmail = optionsArg.email;
+    this.authKey = optionsArg.key;
+  }
+
+  /**
+   * gets a zone id of a domain from cloudflare
+   * @param domainName
+   */
+  async getZoneId(domainName: string) {
+    let domain = new plugins.smartstring.Domain(domainName);
+    let zoneArray = await this.listZones(domain.zoneName);
+    let filteredResponse = zoneArray.filter(zoneArg => {
+      return zoneArg.name === domainName;
+    });
+    if (filteredResponse.length >= 1) {
+      return filteredResponse[0].id;
+    } else {
+      plugins.smartlog.defaultLogger.error(`the domain ${domainName} does not appear to be in this account!`);
+      throw new Error(`the domain ${domainName} does not appear to be in this account!`);
+    }
+  }
+
+  /**
+   * gets a record
+   * @param domainNameArg
+   * @param typeArg 
+   */
+  async getRecord(domainNameArg: string, typeArg: TDnsRecord): Promise<interfaces.ICflareRecord> {
+    let done = plugins.smartpromise.defer<interfaces.ICflareRecord>();
+    let result: interfaces.ICflareRecord;
+
+    let domain = new plugins.smartstring.Domain(domainNameArg);
+    this.listRecords(domain.zoneName).then(recordArrayArg => {
+      let filteredResponse = recordArrayArg.filter(recordArg => {
+        return recordArg.type === typeArg && recordArg.name === domainNameArg;
+      });
+      done.resolve(filteredResponse[0]);
+    });
+    return done.promise;
+  }
+
+  async createRecord(domainNameArg: string, typeArg: TDnsRecord, contentArg: string) {
+    let done = plugins.smartpromise.defer();
+    let domain = new plugins.smartstring.Domain(domainNameArg);
+    let domainIdArg = await this.getZoneId(domain.zoneName);
+    let dataObject = {
+      name: domain.fullName,
+      type: typeArg,
+      content: contentArg
+    };
+    this.request('POST', '/zones/' + domainIdArg + '/dns_records', dataObject).then(function(
+      responseArg
+    ) {
+      done.resolve(responseArg);
+    });
+    return done.promise;
+  }
+
+  removeRecord(domainNameArg: string, typeArg: TDnsRecord) {
+    let done = plugins.smartpromise.defer();
+    let domain = new plugins.smartstring.Domain(domainNameArg);
+    this.getRecord(domain.fullName, typeArg).then(responseArg => {
+      if (responseArg) {
+        let requestRoute: string =
+          '/zones/' + responseArg.zone_id + '/dns_records/' + responseArg.id;
+        this.request('DELETE', requestRoute).then(responseArg => {
+          done.resolve(responseArg);
+        });
+      } else {
+        done.reject();
+      }
+    });
+    return done.promise;
+  }
+
+  updateRecord(domainNameArg: string, typeArg: string, valueArg) {
+    let done = plugins.smartpromise.defer();
+    let domain = new plugins.smartstring.Domain(domainNameArg);
+    return done.promise;
+  }
+
+  /**
+   * list all records of a specified domain name
+   * @param domainNameArg - the domain name that you want to get the records from
+   */
+  async listRecords(domainNameArg: string): Promise<interfaces.ICflareRecord[]> {
+    let domain = new plugins.smartstring.Domain(domainNameArg);
+    let domainId = await this.getZoneId(domain.zoneName);
+    let responseArg: any = await this.request(
+      'GET',
+      '/zones/' + domainId + '/dns_records?per_page=100'
+    );
+    let result: interfaces.ICflareRecord[] = responseArg.result;
+    return result;
+  }
+
+  /**
+   * list all zones in the associated authenticated account
+   * @param domainName
+   */
+  async listZones(domainName?: string): Promise<interfaces.ICflareZone[]> {
+    // TODO: handle pagination
+    let requestRoute = `/zones?per_page=50`;
+
+    // may be optionally filtered by domain name
+    if (domainName) {
+      requestRoute = `${requestRoute}&name=${domainName}`;
+    }
+
+    let response: any = await this.request('GET', requestRoute);
+    let result = response.result;
+    return result;
+  }
+
+  async purgeZone(domainName: string) {
+    let domain = new plugins.smartstring.Domain(domainName);
+    let domainId = await this.getZoneId(domain.zoneName);
+    let requestUrl = `/zones/${domainId}/purge_cache`;
+    let payload = {
+      purge_everything: true
+    };
+    let respone = await this.request('DELETE', requestUrl, payload);
+  }
+
+  request(methodArg: string, routeArg: string, dataArg = {}) {
+    let done = plugins.smartpromise.defer();
+    let options: plugins.smartrequest.ISmartRequestOptions = {
+      method: methodArg,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Auth-Email': this.authEmail,
+        'X-Auth-Key': this.authKey,
+        'Content-Length': Buffer.byteLength(JSON.stringify(dataArg))
+      },
+      requestBody: dataArg
+    };
+
+    let retryCount = 0; // count the amount of retries
+
+    let makeRequest = async () => {
+      let response: any = await plugins.smartrequest.request(
+        `https://api.cloudflare.com/client/v4${routeArg}`,
+        options
+      );
+      if (response.statusCode === 200) {
+        done.resolve(response.body);
+      } else if (response.statusCode === 429) {
+        console.log('rate limited! Waiting for retry!');
+        retryRequest();
+      } else if (response.statusCode === 400) {
+        console.log(`bad request for route ${routeArg}! Going to retry!`);
+        retryRequest();
+      } else {
+        console.log(response.statusCode);
+        done.reject(new Error('request failed'));
+      }
+    };
+    let retryRequest = async (delayTimeArg = Math.floor(Math.random() * (60000 - 8000) + 8000)) => {
+      console.log(`retry started and waiting for ${delayTimeArg} ms`);
+      await plugins.smartdelay.delayFor(delayTimeArg);
+      if (retryCount < 10) {
+        retryCount++;
+        return await makeRequest();
+      }
+    };
+    makeRequest();
+    return done.promise;
+  }
+
+  private authCheck() {
+    return this.authEmail && this.authKey; // check if auth is available
+  }
+}