apiclient.xyz/cloudflare
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

switch to official cloudflare api client while keeping class based approach

Browse Source
This commit is contained in:
Philipp Kunz
2024-06-15 19:47:09 +02:00
parent 1d2e0974b2
commit f39f8cd33c
9 changed files with 160 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
ts/cloudflare.classes.account.ts
View File

@ -13,24 +13,17 @@ export class CloudflareAccount {
public workerManager = new WorkerManager(this);
public zoneManager = new ZoneManager(this);
public apiAccount: plugins.cloudflare.Cloudflare;
/**
* 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;
this.apiAccount = new plugins.cloudflare.Cloudflare({
apiToken: this.authToken,
});
}
public convenience = {
@ -59,7 +52,7 @@ export class CloudflareAccount {
getRecord: async (
domainNameArg: string,
typeArg: plugins.tsclass.network.TDnsRecordType
): Promise<interfaces.ICflareRecord> => {
): Promise<plugins.ICloudflareTypes['Record']> => {
const domain = new plugins.smartstring.Domain(domainNameArg);
const recordArrayArg = await this.convenience.listRecords(domain.zoneName);
const filteredResponse = recordArrayArg.filter((recordArg) => {
@ -77,18 +70,14 @@ export class CloudflareAccount {
ttlArg = 1
): Promise<any> => {
const domain = new plugins.smartstring.Domain(domainNameArg);
const domainIdArg = await this.convenience.getZoneId(domain.zoneName);
const dataObject = {
const zoneId = await this.convenience.getZoneId(domain.zoneName);
const response = await this.apiAccount.dns.records.create({
zone_id: zoneId,
type: typeArg as any,
name: domain.fullName,
type: typeArg,
content: contentArg,
ttl: ttlArg,
};
const response = await this.request(
'POST',
'/zones/' + domainIdArg + '/dns_records',
dataObject
);
})
return response;
},
/**
@ -101,20 +90,36 @@ export class CloudflareAccount {
typeArg: plugins.tsclass.network.TDnsRecordType
): Promise<any> => {
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);
const zoneId = await this.convenience.getZoneId(domain.zoneName);
const records = await this.convenience.listRecords(domain.zoneName);
const recordToDelete = records.find((recordArg) => {
return recordArg.name === domainNameArg && recordArg.type === typeArg;
});
if (recordToDelete) {
await this.apiAccount.dns.records.delete(recordToDelete.id, {
zone_id: zoneId,
});
} else {
throw new Error(`could not remove record for ${domainNameArg} with type ${typeArg}`);
logger.log('warn', `record ${domainNameArg} of type ${typeArg} not found`);
}
},
/**
* 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}`);
const records = await this.convenience.listRecords(domainNameArg);
const recordsToDelete = records.filter((recordArg) => {
return recordArg.type === typeArg;
});
for (const recordToDelete of recordsToDelete) {
await this.apiAccount.dns.records.delete(recordToDelete.id, {
zone_id: recordToDelete.zone_id,
});
}
},
/**
* updates a record
* @param domainNameArg
@ -133,45 +138,40 @@ export class CloudflareAccount {
* 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<interfaces.ICflareRecord[]> => {
listRecords: async (domainNameArg: string) => {
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;
const zoneId = await this.convenience.getZoneId(domain.zoneName);
const records: plugins.ICloudflareTypes['Record'][] = [];
for await (const record of this.apiAccount.dns.records.list({
zone_id: zoneId,
})) {
records.push(record);
}
return records;
},
/**
* list all zones in the associated authenticated account
* @param domainName
*/
listZones: async (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}`;
listZones: async (domainName?: string) => {
const zones: plugins.ICloudflareTypes['Zone'][] = [];
for await (const zone of this.apiAccount.zones.list()) {
zones.push(zone);
}
const response: any = await this.request('GET', requestRoute);
const result = response.result;
return result;
return zones;
},
/**
* purges a zone
*/
purgeZone: async (domainName: string): Promise<void> => {
const domain = new plugins.smartstring.Domain(domainName);
const domainId = await this.convenience.getZoneId(domain.zoneName);
const requestUrl = `/zones/${domainId}/purge_cache`;
const payload = {
const zoneId = await this.convenience.getZoneId(domain.zoneName);
await this.apiAccount.cache.purge({
zone_id: zoneId,
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');
@ -186,105 +186,4 @@ export class CloudflareAccount {
await this.convenience.removeRecord(dnsChallenge.hostName, 'TXT');
},
};
public async request(
methodArg: string,
routeArg: string,
dataArg: any = {},
requestHeadersArg = {}
): Promise<any> {
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<plugins.smartrequest.IExtendedIncomingMessage> => {
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
}
}

45
ts/cloudflare.classes.zone.ts
View File

@ -1,50 +1,9 @@
import * as plugins from './cloudflare.plugins.js';
import * as interfaces from './interfaces/index.js';
export class CloudflareZone implements interfaces.ICflareZone {
public static createFromApiObject(apiObject: interfaces.ICflareZone) {
export class CloudflareZone {
public static createFromApiObject(apiObject: plugins.ICloudflareTypes['Zone']) {
const cloudflareZone = new CloudflareZone();
Object.assign(cloudflareZone, apiObject);
return cloudflareZone;
}
id: string;
name: string;
development_mode: number;
original_name_servers: string[];
original_registrar: string;
original_dnshost: string;
created_on: string;
modified_on: string;
name_servers: string[];
owner: {
id: string;
email: string;
owner_type: string;
};
permissions: string[];
plan: {
id: string;
name: string;
price: number;
currency: string;
frequency: string;
legacy_id: string;
is_subscribed: boolean;
can_subscribe: boolean;
};
plan_pending: {
id: string;
name: string;
price: number;
currency: string;
frequency: string;
legacy_id: string;
is_subscribed: string;
can_subscribe: string;
};
status: string;
paused: boolean;
type: string;
checked_on: string;
}

12
ts/cloudflare.plugins.ts
View File

@ -6,3 +6,15 @@ import * as smartstring from '@push.rocks/smartstring';
import * as tsclass from '@tsclass/tsclass';
export { smartlog, smartpromise, smartdelay, smartrequest, smartstring, tsclass };
// third party
import * as cloudflare from 'cloudflare';
import type { Zone } from 'cloudflare/resources/zones/zones.js';
import type { Record } from 'cloudflare/resources/dns/records.js';
export interface ICloudflareTypes {
Zone: Zone;
Record: Record;
}
export { cloudflare };

15
ts/interfaces/cloudflare.api.record.ts
View File

@ -1,15 +0,0 @@
export interface ICflareRecord {
id: string;
type: string;
name: string;
content: string;
proxiable: boolean;
proxied: boolean;
ttl: number;
locked: boolean;
zone_id: string;
zone_name: string;
created_on: string;
modified_on: string;
data: any;
}

41
ts/interfaces/cloudflare.api.zone.ts
View File

@ -1,41 +0,0 @@
export interface ICflareZone {
id: string;
name: string;
development_mode: number;
original_name_servers: string[];
original_registrar: string;
original_dnshost: string;
created_on: string;
modified_on: string;
name_servers: string[];
owner: {
id: string;
email: string;
owner_type: string;
};
permissions: string[];
plan: {
id: string;
name: string;
price: number;
currency: string;
frequency: string;
legacy_id: string;
is_subscribed: boolean;
can_subscribe: boolean;
};
plan_pending: {
id: string;
name: string;
price: number;
currency: string;
frequency: string;
legacy_id: string;
is_subscribed: string;
can_subscribe: string;
};
status: string;
paused: boolean;
type: string;
checked_on: string;
}

2
ts/interfaces/index.ts
View File

@ -1,3 +1 @@
export * from './cloudflare.api.record.js';
export * from './cloudflare.api.zone.js';
export * from './cloudflare.api.workerroute.js';