@pb33f/cowboy-components 0.1.16 → 0.2.0

package/dist/services/ruleset-service.js

@@ -0,0 +1,316 @@
+export class RulesetService {
+    static checkRules(ruleset) {
+        ruleset.rules.forEach((rule, name) => {
+            if (rule.id !== name) {
+                rule.id = name;
+            }
+        });
+    }
+    static async getDefaultRuleset() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const defaultRuleset = await fetch(RulesetService.doctorEndpoint + '/rulesets/default', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await defaultRuleset.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to fetch default ruleset' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch default ruleset: ' + e });
+            }
+        });
+    }
+    static async getOWASPRuleset() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const owaspRuleset = await fetch(RulesetService.doctorEndpoint + '/rulesets/owasp', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await owaspRuleset.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to fetch owasp ruleset' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch owasp ruleset: ' + e });
+            }
+        });
+    }
+    static async getAllRuleset() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const allRuleset = await fetch(RulesetService.doctorEndpoint + '/rulesets/all', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await allRuleset.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to fetch all rules ruleset' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch all rules ruleset: ' + e });
+            }
+        });
+    }
+    static async getFunctions() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const functions = await fetch(RulesetService.doctorEndpoint + '/rulesets/functions', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await functions.json();
+                if (!apiResult) {
+                    reject({ details: 'unable to fetch functions' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch functions ' + e });
+            }
+        });
+    }
+    static async getFunctionSchema(functionId) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const functions = await fetch(RulesetService.doctorEndpoint + '/rulesets/functions/schemas/' + functionId, {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await functions.json();
+                if (!apiResult) {
+                    reject({ details: 'unable to fetch functions' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable fetch function schema ' + e });
+            }
+        });
+    }
+    static async applyRuleset(ruleset) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const functions = await fetch(RulesetService.doctorEndpoint + '/rulesets/session', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: ruleset
+                });
+                const apiResult = await functions.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to apply ruleset' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    static async convertToJSON(ruleset) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const converted = await fetch(RulesetService.doctorEndpoint + '/rulesets/convert', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: ruleset
+                });
+                const apiResult = await converted.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to apply ruleset' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    static async getSessionRuleset() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const functions = await fetch(RulesetService.doctorEndpoint + '/rulesets/session', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await functions.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to extract session ruleset' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to extract session ruleset' + e });
+            }
+        });
+    }
+    static async getSessionRulesetAsYAML() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const functions = await fetch(RulesetService.doctorEndpoint + '/rulesets/session/yaml', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await functions.text();
+                if (!apiResult) {
+                    reject({ detail: 'unable to extract session ruleset' });
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to extract session ruleset' + e });
+            }
+        });
+    }
+    static async getSessionRulesetMap() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const map = await fetch(RulesetService.doctorEndpoint + '/rulesets/session/map', {
+                    method: 'GET',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                const apiResult = await map.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to extract session ruleset map' });
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to extract session ruleset' + e });
+            }
+        });
+    }
+    static async validateRuleset(body, returnJSON = true) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                let jsonQuery = '';
+                if (returnJSON) {
+                    jsonQuery = '?json=true';
+                }
+                const functions = await fetch(RulesetService.doctorEndpoint + '/rulesets/validate' + jsonQuery, {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: body
+                });
+                const apiResult = await functions.json();
+                if (!apiResult) {
+                    reject({ detail: 'unable to validate ruleset' });
+                    return;
+                }
+                if (apiResult?.type && apiResult?.title && apiResult?.status) {
+                    reject(apiResult);
+                    return;
+                }
+                resolve(apiResult);
+            }
+            catch (e) {
+                reject({ detail: 'unable to validate ruleset' + e });
+            }
+        });
+    }
+    static async resetSessionRuleset() {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const functions = await fetch(RulesetService.doctorEndpoint + '/rulesets/session', {
+                    method: 'DELETE',
+                    credentials: 'include',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                });
+                if (functions.status !== 200) {
+                    reject({ detail: 'unable to reset session ruleset' });
+                    return;
+                }
+                resolve(null);
+            }
+            catch (e) {
+                reject({ detail: 'unable to extract session ruleset' + e });
+            }
+        });
+    }
+}
+RulesetService.doctorEndpoint = 'https://doctor.pb33f.io';