import plugins = require('./cloudflare.plugins'); import { logger } from './cloudflare.logger'; import * as interfaces from './interfaces'; // interfaces import { WorkerManager } from './cloudflare.classes.workermanager'; import { ZoneManager } from './cloudflare.classes.zonemanager'; export class CloudflareAccount { private authToken: string; private accountIdentifier: string; public workerManager = new WorkerManager(this); public zoneManager = new ZoneManager(this); /** * constructor sets auth information on the CloudflareAccountInstance * @param optionsArg */ constructor(authTokenArg: string) { this.authToken = authTokenArg; } /** * gets you the account identifier */ public async getAccountIdentifier() { if (!this.accountIdentifier) { const route = `/accounts?page=1&per_page=20&direction=desc`; const response: any = await this.request('GET', route); this.accountIdentifier = response.result[0].id; } return this.accountIdentifier; } public convenience = { /** * gets a zone id of a domain from cloudflare * @param domainName */ getZoneId: async (domainName: string) => { const domain = new plugins.smartstring.Domain(domainName); const zoneArray = await this.convenience.listZones(domain.zoneName); const filteredResponse = zoneArray.filter((zoneArg) => { return zoneArg.name === domainName; }); if (filteredResponse.length >= 1) { return filteredResponse[0].id; } else { logger.log('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 */ getRecord: async ( domainNameArg: string, typeArg: plugins.tsclass.network.TDnsRecordType ): Promise => { const domain = new plugins.smartstring.Domain(domainNameArg); const recordArrayArg = await this.convenience.listRecords(domain.zoneName); const filteredResponse = recordArrayArg.filter((recordArg) => { return recordArg.type === typeArg && recordArg.name === domainNameArg; }); return filteredResponse[0]; }, /** * creates a record */ createRecord: async ( domainNameArg: string, typeArg: plugins.tsclass.network.TDnsRecordType, contentArg: string, ttlArg = 1 ): Promise => { const domain = new plugins.smartstring.Domain(domainNameArg); const domainIdArg = await this.convenience.getZoneId(domain.zoneName); const dataObject = { name: domain.fullName, type: typeArg, content: contentArg, ttl: ttlArg, }; const response = await this.request( 'POST', '/zones/' + domainIdArg + '/dns_records', dataObject ); return response; }, /** * removes a record from Cloudflare * @param domainNameArg * @param typeArg */ removeRecord: async ( domainNameArg: string, typeArg: plugins.tsclass.network.TDnsRecordType ): Promise => { const domain = new plugins.smartstring.Domain(domainNameArg); const cflareRecord = await this.convenience.getRecord(domain.fullName, typeArg); if (cflareRecord) { const requestRoute: string = `/zones/${cflareRecord.zone_id}/dns_records/${cflareRecord.id}`; return await this.request('DELETE', requestRoute); } else { throw new Error(`could not remove record for ${domainNameArg} with type ${typeArg}`); } }, /** * cleanrecord allows the cleaning of any previous records to avoid unwanted sideeffects */ cleanRecord: async (domainNameArg: string, typeArg: plugins.tsclass.network.TDnsRecordType) => { console.log(`cleaning record for ${domainNameArg}`); }, /** * updates a record * @param domainNameArg * @param typeArg * @param valueArg */ updateRecord: async ( domainNameArg: string, typeArg: plugins.tsclass.network.TDnsRecordType, valueArg ) => { // TODO: implement const domain = new plugins.smartstring.Domain(domainNameArg); }, /** * list all records of a specified domain name * @param domainNameArg - the domain name that you want to get the records from */ listRecords: async (domainNameArg: string): Promise => { const domain = new plugins.smartstring.Domain(domainNameArg); const domainId = await this.convenience.getZoneId(domain.zoneName); const responseArg: any = await this.request( 'GET', '/zones/' + domainId + '/dns_records?per_page=100' ); const result: interfaces.ICflareRecord[] = responseArg.result; return result; }, /** * list all zones in the associated authenticated account * @param domainName */ listZones: async (domainName?: string): Promise => { // TODO: handle pagination let requestRoute = `/zones?per_page=50`; // may be optionally filtered by domain name if (domainName) { requestRoute = `${requestRoute}&name=${domainName}`; } const response: any = await this.request('GET', requestRoute); const result = response.result; return result; }, /** * purges a zone */ purgeZone: async (domainName: string): Promise => { const domain = new plugins.smartstring.Domain(domainName); const domainId = await this.convenience.getZoneId(domain.zoneName); const requestUrl = `/zones/${domainId}/purge_cache`; const payload = { purge_everything: true, }; const respone = await this.request('DELETE', requestUrl, payload); }, // acme convenience functions acmeSetDnsChallenge: async (dnsChallenge: plugins.tsclass.network.IDnsChallenge) => { await this.convenience.cleanRecord(dnsChallenge.hostName, 'TXT'); await this.convenience.createRecord(dnsChallenge.hostName, 'TXT', dnsChallenge.challenge, 2); }, acmeRemoveDnsChallenge: async (dnsChallenge: plugins.tsclass.network.IDnsChallenge) => { await this.convenience.removeRecord(dnsChallenge.hostName, 'TXT'); }, }; public async request( methodArg: string, routeArg: string, dataArg: any = {}, requestHeadersArg = {} ): Promise { const options: plugins.smartrequest.ISmartRequestOptions = { method: methodArg, headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.authToken}`, 'Content-Length': Buffer.byteLength(JSON.stringify(dataArg)), ...requestHeadersArg, }, requestBody: dataArg, }; // route analysis const routeWithoutQuery = routeArg.split('?')[0]; let queryParams: string[] = []; if (routeArg.split('?').length > 1) { queryParams = routeArg.split('?')[1].split('&'); } // console.log(options); let retryCount = 0; // count the amount of retries let pageCount = 1; const getQueryParams = () => { let result = ''; if (queryParams.length > 0) { result += '?'; } else { return result; } let isFirst = true; for (const queryParam of queryParams) { if (!isFirst) { result += '&'; } isFirst = false; const queryParamSerialized = queryParam.split('='); if (queryParam === 'page') { result += `page=${pageCount}`; } else { result += queryParam; } } return result; }; const makeRequest = async (): Promise => { const requestUrl = `https://api.cloudflare.com/client/v4${routeWithoutQuery}${getQueryParams()}`; const response = await plugins.smartrequest.request(requestUrl, options); if (response.statusCode === 200) { if (response.body.result_info) { const rI = response.body.result_info; if (rI.total_count / rI.per_page > pageCount) { pageCount++; const subresponse = await makeRequest(); response.body.result = response.body.result.concat(subresponse.body.result); return response; } else { return response; } } else { return response; } } else if (response.statusCode === 429) { console.log('rate limited! Waiting for retry!'); return await retryRequest(); } else if (response.statusCode === 400) { console.log(`bad request for route ${requestUrl}!`); console.log(response.body); throw new Error(`request failed for ${requestUrl}`); } else { console.log(response.body); throw new Error(`request failed for ${requestUrl} with status${response.statusCode}}`); } }; const 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(); } }; const response = await makeRequest(); return response.body; } private authCheck() { return !!this.authToken; // check if auth is available } }