@rulebricks/sdk 1.0.0

package/forge/rule.js

@@ -0,0 +1,702 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rule = exports.Condition = exports.RuleTest = void 0;
+const types_js_1 = require("./types.js");
+const operators_js_1 = require("./operators.js");
+class RuleTest {
+    constructor() {
+        this.id = this.generateId();
+        this.name = "Untitled Test";
+        this.request = {};
+        this.response = {};
+        this.critical = false;
+        this.lastExecuted = null;
+        this.testState = null;
+        this.error = null;
+        this.success = null;
+    }
+    generateId() {
+        return Array.from({ length: 21 }, () => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"[Math.floor(Math.random() * 62)]).join("");
+    }
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    expect(request, response) {
+        this.request = request;
+        this.response = response;
+        return this;
+    }
+    isCritical(critical = true) {
+        this.critical = critical;
+        return this;
+    }
+    toDict() {
+        return {
+            id: this.id,
+            name: this.name,
+            request: this.request,
+            response: this.response,
+            critical: this.critical,
+            lastExecuted: this.lastExecuted,
+            testState: this.testState,
+            error: this.error,
+            success: this.success,
+        };
+    }
+    static fromJSON(data) {
+        const jsonData = typeof data === "string" ? JSON.parse(data) : data;
+        if (typeof jsonData !== "object") {
+            throw new Error("Input must be a dictionary or JSON object");
+        }
+        const test = new RuleTest();
+        test.id = jsonData.id || test.generateId();
+        test.name = jsonData.name || "Untitled Test";
+        test.request = jsonData.request || {};
+        test.response = jsonData.response || {};
+        test.critical = jsonData.critical || false;
+        test.lastExecuted = jsonData.lastExecuted || null;
+        test.testState = jsonData.testState || null;
+        test.error = jsonData.error || null;
+        test.success = jsonData.success || null;
+        return test;
+    }
+}
+exports.RuleTest = RuleTest;
+class Condition {
+    constructor(rule, conditions = {}, index = null, settings = {}) {
+        this.rule = rule;
+        this.request = {};
+        this.response = {};
+        this.index = index;
+        this.conditions = conditions;
+        this.settings = Object.assign({ enabled: true, groupId: null, priority: 0, schedule: [], or: false }, settings);
+    }
+    // Helper to process dynamic values
+    processDynamicValues(arg) {
+        if (arg && typeof arg === "object" && arg.$rb) {
+            return arg;
+        }
+        else if (Array.isArray(arg)) {
+            return arg.map((item) => this.processDynamicValues(item));
+        }
+        else if (arg && typeof arg === "object") {
+            return Object.entries(arg).reduce((acc, [key, value]) => {
+                acc[key] = this.processDynamicValues(value);
+                return acc;
+            }, {});
+        }
+        return arg;
+    }
+    when(conditions) {
+        for (const [fieldName, [operator, args]] of Object.entries(conditions)) {
+            if (!(fieldName in this.rule.fields)) {
+                throw new Error(`Field '${fieldName}' is not defined in request schema`);
+            }
+            if (this.index !== null) {
+                // Editing existing condition
+                this.rule.conditions[this.index].request[fieldName] = {
+                    op: operator,
+                    args: args.map((arg) => this.processDynamicValues(arg)),
+                };
+            }
+            else {
+                // Creating new condition
+                this.conditions[fieldName] = [operator, args];
+            }
+        }
+        return this;
+    }
+    then(responses) {
+        for (const [fieldName, value] of Object.entries(responses)) {
+            if (!(fieldName in this.rule.responseFields)) {
+                throw new Error(`Field '${fieldName}' is not defined in response schema`);
+            }
+        }
+        if (this.index !== null) {
+            // Editing existing condition
+            for (const [fieldName, value] of Object.entries(responses)) {
+                this.rule.conditions[this.index].response[fieldName] = {
+                    value: this.processDynamicValues(value),
+                };
+            }
+            return this;
+        }
+        else {
+            // Creating new condition
+            this.response = responses;
+            const condition = {
+                request: {},
+                response: {},
+                settings: this.settings,
+            };
+            // Process conditions
+            for (const [fieldName, [operator, args]] of Object.entries(this.conditions)) {
+                condition.request[fieldName] = {
+                    op: operator,
+                    args: args.map((arg) => this.processDynamicValues(arg)),
+                };
+            }
+            // Process responses
+            for (const [fieldName, value] of Object.entries(this.response)) {
+                condition.response[fieldName] = {
+                    value: this.processDynamicValues(value),
+                };
+            }
+            this.rule.conditions.push(condition);
+            return this.rule;
+        }
+    }
+    setPriority(priority) {
+        this.settings.priority = priority;
+        if (this.index !== null) {
+            this.rule.conditions[this.index].settings.priority = priority;
+        }
+        return this;
+    }
+    enable() {
+        this.settings.enabled = true;
+        if (this.index !== null) {
+            this.rule.conditions[this.index].settings.enabled = true;
+        }
+        return this;
+    }
+    disable() {
+        this.settings.enabled = false;
+        if (this.index !== null) {
+            this.rule.conditions[this.index].settings.enabled = false;
+        }
+        return this;
+    }
+    delete() {
+        if (this.index !== null) {
+            this.rule.conditions.splice(this.index, 1);
+        }
+    }
+    toString() {
+        return this.index !== null ? `<Condition: Row ${this.index}>` : "<Condition: New>";
+    }
+    [Symbol.toStringTag]() {
+        return this.toString();
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.toString();
+    }
+    toJSON() {
+        return {
+            request: this.request,
+            response: this.response,
+            settings: this.settings,
+        };
+    }
+}
+exports.Condition = Condition;
+class Rule {
+    constructor() {
+        this.id = this.generateUUID();
+        this.name = "Untitled Rule";
+        this.description = "";
+        this.folderId = null;
+        this.slug = this.generateSlug();
+        this.createdAt = new Date().toISOString();
+        this.updatedAt = this.createdAt;
+        this.updatedBy = "Rulebricks Forge SDK";
+        this.published = false;
+        this.sampleRequest = {};
+        this.sampleResponse = {};
+        this.testRequest = {};
+        this.testSuite = [];
+        this.fields = {};
+        this.responseFields = {};
+        this.conditions = [];
+        this.groups = {};
+        this.publishedRequestSchema = null;
+        this.publishedResponseSchema = null;
+        this.publishedConditions = null;
+        this.publishedGroups = {};
+        this.history = [];
+        this.form = null;
+        this.accessGroups = [];
+        this.settings = {
+            testing: false,
+            schemaValidation: false,
+            allProperties: false,
+            lockSchema: false,
+        };
+    }
+    generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    generateSlug(length = 10) {
+        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+        return Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+    }
+    getFieldType(field) {
+        if (field instanceof operators_js_1.BooleanField)
+            return types_js_1.RuleType.BOOLEAN;
+        if (field instanceof operators_js_1.NumberField)
+            return types_js_1.RuleType.NUMBER;
+        if (field instanceof operators_js_1.StringField)
+            return types_js_1.RuleType.STRING;
+        if (field instanceof operators_js_1.DateField)
+            return types_js_1.RuleType.DATE;
+        if (field instanceof operators_js_1.ListField)
+            return types_js_1.RuleType.LIST;
+        return types_js_1.RuleType.STRING; // Default fallback
+    }
+    setWorkspace(client) {
+        this.workspace = client;
+        return this;
+    }
+    setName(name) {
+        this.name = name;
+        this.slug = this.generateSlug();
+        return this;
+    }
+    setDescription(description) {
+        this.description = description;
+        return this;
+    }
+    setFolder(folderName, createIfMissing = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.workspace) {
+                throw new Error("A Rulebricks client is required to set a folder by name");
+            }
+            const folders = yield this.workspace.assets.listFolders();
+            let folder = folders.find((f) => f.name === folderName);
+            if (!folder && createIfMissing) {
+                if (folders.some((f) => f.name === folderName)) {
+                    throw new Error("Folder name conflicts with an existing folder");
+                }
+                folder = yield this.workspace.assets.upsertFolder({ name: folderName });
+            }
+            if (!folder) {
+                throw new Error(`Folder '${folderName}' not found and createIfMissing is false`);
+            }
+            this.folderId = folder.id || null;
+            return this;
+        });
+    }
+    setFolderById(folderId) {
+        this.folderId = folderId;
+        return this;
+    }
+    setAlias(alias) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.workspace) {
+                throw new Error("A Rulebricks client is required to set an alias");
+            }
+            if (alias.length < 3) {
+                throw new Error("Alias must be at least 3 characters long");
+            }
+            if (alias.includes("/") || alias.includes("\\") || alias.includes(" ")) {
+                throw new Error("Alias cannot contain slashes or spaces");
+            }
+            const validChars = /^[a-zA-Z0-9\-_]+$/;
+            if (!validChars.test(alias)) {
+                throw new Error("Alias cannot contain special characters");
+            }
+            const rules = yield this.workspace.assets.listRules();
+            if (rules.some((r) => r.slug === alias)) {
+                throw new Error("Alias conflicts with an existing rule");
+            }
+            this.slug = alias;
+            return this;
+        });
+    }
+    addBooleanField(name, description = "", defaultValue = false) {
+        const field = new operators_js_1.BooleanField(name, description, defaultValue);
+        this.fields[name] = field;
+        return field;
+    }
+    addNumberField(name, description = "", defaultValue = 0) {
+        const field = new operators_js_1.NumberField(name, description, defaultValue);
+        this.fields[name] = field;
+        return field;
+    }
+    addStringField(name, description = "", defaultValue = "") {
+        const field = new operators_js_1.StringField(name, description, defaultValue);
+        this.fields[name] = field;
+        return field;
+    }
+    addDateField(name, description = "", defaultValue) {
+        const field = new operators_js_1.DateField(name, description, defaultValue);
+        this.fields[name] = field;
+        return field;
+    }
+    addListField(name, description = "", defaultValue = []) {
+        const field = new operators_js_1.ListField(name, description, defaultValue);
+        this.fields[name] = field;
+        return field;
+    }
+    enableContinuousTesting(enabled = true) {
+        this.settings.testing = enabled;
+        return this;
+    }
+    enableSchemaValidation(enabled = true) {
+        this.settings.schemaValidation = enabled;
+        return this;
+    }
+    requireAllProperties(enabled = true) {
+        this.settings.allProperties = enabled;
+        return this;
+    }
+    lockSchema(enabled = true) {
+        this.settings.lockSchema = enabled;
+        return this;
+    }
+    addAccessGroup(groupName, createIfMissing = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.workspace) {
+                throw new Error("A Rulebricks client is required to manage access groups");
+            }
+            const existingGroups = yield this.workspace.users.listGroups();
+            let group = existingGroups.find((g) => g.name === groupName);
+            if (!group && !createIfMissing) {
+                throw new Error(`User group '${groupName}' not found and createIfMissing is False`);
+            }
+            if (!group && createIfMissing) {
+                group = yield this.workspace.users.createGroup({ name: groupName });
+            }
+            if (!this.accessGroups.includes(groupName)) {
+                this.accessGroups.push(groupName);
+            }
+            return this;
+        });
+    }
+    removeAccessGroup(groupName) {
+        const index = this.accessGroups.indexOf(groupName);
+        if (index !== -1) {
+            this.accessGroups.splice(index, 1);
+        }
+        return this;
+    }
+    addBooleanResponse(name, description = "", defaultValue = false) {
+        const field = new operators_js_1.BooleanField(name, description, defaultValue);
+        this.responseFields[name] = field;
+        return field;
+    }
+    addNumberResponse(name, description = "", defaultValue = 0) {
+        const field = new operators_js_1.NumberField(name, description, defaultValue);
+        this.responseFields[name] = field;
+        return field;
+    }
+    addStringResponse(name, description = "", defaultValue = "") {
+        const field = new operators_js_1.StringField(name, description, defaultValue);
+        this.responseFields[name] = field;
+        return field;
+    }
+    addDateResponse(name, description = "", defaultValue) {
+        const field = new operators_js_1.DateField(name, description, defaultValue);
+        this.responseFields[name] = field;
+        return field;
+    }
+    addListResponse(name, description = "", defaultValue = []) {
+        const field = new operators_js_1.ListField(name, description, defaultValue);
+        this.responseFields[name] = field;
+        return field;
+    }
+    findConditions(conditions) {
+        return this.conditions
+            .map((condition, index) => {
+            let matchesAll = Object.entries(conditions).every(([field, [operator, args]]) => {
+                const request = condition.request[field];
+                if (!request)
+                    return false;
+                if (request.op !== operator)
+                    return false;
+                // Handle dynamic values
+                const requestArgs = request.args.map((arg) => typeof arg === "object" && arg.$rb ? arg.name.toUpperCase() : String(arg));
+                const searchArgs = args.map((arg) => typeof arg === "object" && arg.$rb ? arg.name.toUpperCase() : String(arg));
+                return JSON.stringify(requestArgs) === JSON.stringify(searchArgs);
+            });
+            if (matchesAll) {
+                const convertedRequest = {};
+                for (const [field, value] of Object.entries(condition.request)) {
+                    convertedRequest[field] = [value.op, value.args];
+                }
+                return new Condition(this, convertedRequest, index, condition.settings);
+            }
+            return null;
+        })
+            .filter((condition) => condition !== null);
+    }
+    // Helper method to get proper field instances
+    getField(name, type) {
+        const field = this.fields[name];
+        if (!field) {
+            throw new Error(`Field '${name}' not found in request schema`);
+        }
+        const expectedType = this.getFieldType(field);
+        if (expectedType !== type) {
+            throw new Error(`Field '${name}' is not a ${type.toLowerCase()} field`);
+        }
+        return field;
+    }
+    getBooleanField(name) {
+        return this.getField(name, types_js_1.RuleType.BOOLEAN);
+    }
+    getNumberField(name) {
+        return this.getField(name, types_js_1.RuleType.NUMBER);
+    }
+    getStringField(name) {
+        return this.getField(name, types_js_1.RuleType.STRING);
+    }
+    getDateField(name) {
+        return this.getField(name, types_js_1.RuleType.DATE);
+    }
+    getListField(name) {
+        return this.getField(name, types_js_1.RuleType.LIST);
+    }
+    when(conditions = {}) {
+        const condition = new Condition(this, conditions);
+        return condition;
+    }
+    any(conditions) {
+        const condition = new Condition(this, conditions, null, { or: true });
+        return condition;
+    }
+    getConditions() {
+        return this.conditions;
+    }
+    getConditionCount() {
+        return this.conditions.length;
+    }
+    addTest(test) {
+        const existingTest = this.findTestById(test.id);
+        if (existingTest) {
+            Object.assign(existingTest, {
+                name: test.name,
+                request: test.request,
+                response: test.response,
+                critical: test.critical,
+            });
+        }
+        else {
+            this.testSuite.push(test);
+        }
+        return this;
+    }
+    removeTest(testId) {
+        this.testSuite = this.testSuite.filter((t) => t.id !== testId);
+        return this;
+    }
+    findTestById(testId) {
+        return this.testSuite.find((t) => t.id === testId);
+    }
+    findTestByName(name) {
+        return this.testSuite.find((t) => t.name === name);
+    }
+    update() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.workspace) {
+                throw new Error("Workspace not set. Call setWorkspace() before updating the rule.");
+            }
+            const ruleData = this.toDict();
+            yield this.workspace.assets.importRule({ rule: ruleData });
+            return this;
+        });
+    }
+    publish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.workspace) {
+                throw new Error("A Rulebricks client is required to publish a rule");
+            }
+            const ruleData = this.toDict();
+            ruleData._publish = true;
+            yield this.workspace.assets.importRule({ rule: ruleData });
+            return this;
+        });
+    }
+    fromWorkspace(ruleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.workspace) {
+                throw new Error("A Rulebricks client is required to load a rule from the workspace");
+            }
+            const ruleData = yield this.workspace.assets.exportRule({ id: ruleId });
+            const rule = Rule.fromJSON(ruleData);
+            Object.assign(this, rule);
+            return this;
+        });
+    }
+    toDict() {
+        let sampleRequest = this.sampleRequest || {};
+        let sampleResponse = this.sampleResponse || {};
+        for (const [name, field] of Object.entries(this.fields)) {
+            const parts = name.split(".");
+            let current = sampleRequest;
+            for (const part of parts.slice(0, -1)) {
+                current = current[part] = current[part] || {};
+            }
+            current[parts[parts.length - 1]] = field.defaultValue;
+        }
+        for (const [name, field] of Object.entries(this.responseFields)) {
+            const parts = name.split(".");
+            let current = sampleResponse;
+            for (const part of parts.slice(0, -1)) {
+                current = current[part] = current[part] || {};
+            }
+            current[parts[parts.length - 1]] = field.defaultValue;
+        }
+        const caseAndSpace = (str) => {
+            let titleCase = str.replace(/\w\S*/g, (text) => text.charAt(0).toUpperCase() + text.substring(1).toLowerCase());
+            // Replace underscores and any special characters with spaces
+            return titleCase.replace(/_/g, " ").replace(/[^a-zA-Z0-9 ]/g, "");
+        };
+        const fields = Object.entries(this.fields).map(([name, field]) => ({
+            name: caseAndSpace(name),
+            key: field.key || name,
+            type: field.type,
+            description: field.description,
+            defaultValue: field.defaultValue,
+            show: true,
+        }));
+        const responseFields = Object.entries(this.responseFields).map(([name, field]) => ({
+            name: caseAndSpace(name),
+            key: field.key || name,
+            type: field.type,
+            description: field.description,
+            defaultValue: field.defaultValue,
+            show: true,
+        }));
+        return {
+            id: this.id,
+            name: this.name,
+            description: this.description,
+            tag: this.folderId,
+            slug: this.slug,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            updatedBy: this.updatedBy,
+            settings: this.settings,
+            accessGroups: this.accessGroups,
+            requestSchema: fields,
+            responseSchema: responseFields,
+            conditions: this.conditions,
+            testSuite: this.testSuite.map((test) => test.toDict()),
+            published_requestSchema: this.publishedRequestSchema,
+            published_responseSchema: this.publishedResponseSchema,
+            published_conditions: this.publishedConditions,
+            published_groups: this.publishedGroups,
+            form: this.form,
+            history: this.history,
+            published: this.published,
+            sampleRequest: sampleRequest,
+            sampleResponse: sampleResponse,
+            testRequest: this.testRequest,
+            groups: this.groups,
+            no_conditions: this.conditions.length,
+        };
+    }
+    toJSON() {
+        return JSON.stringify(this.toDict(), (_, value) => {
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            return value;
+        }, 2);
+    }
+    static fromJSON(data) {
+        const jsonData = typeof data === "string" ? JSON.parse(data) : data;
+        const rule = new Rule();
+        rule.id = jsonData.id;
+        rule.name = jsonData.name;
+        rule.description = jsonData.description;
+        rule.folderId = jsonData.tag;
+        rule.slug = jsonData.slug;
+        rule.createdAt = jsonData.createdAt;
+        rule.updatedAt = jsonData.updatedAt;
+        rule.updatedBy = jsonData.updatedBy;
+        rule.settings = jsonData.settings;
+        rule.accessGroups = jsonData.accessGroups;
+        rule.conditions = jsonData.conditions;
+        rule.publishedRequestSchema = jsonData.publishedRequestSchema || null;
+        rule.publishedResponseSchema = jsonData.publishedResponseSchema || null;
+        rule.publishedConditions = jsonData.publishedConditions || null;
+        rule.publishedGroups = jsonData.publishedGroups || {};
+        rule.form = jsonData.form || null;
+        rule.history = jsonData.history || [];
+        rule.published = jsonData.published;
+        rule.testRequest = jsonData.testRequest || {};
+        rule.groups = jsonData.groups || {};
+        const caseAndSpace = (str) => {
+            let titleCase = str.replace(/\w\S*/g, (text) => text.charAt(0).toUpperCase() + text.substring(1).toLowerCase());
+            // Replace underscores and any special characters with spaces
+            return titleCase.replace(/_/g, " ").replace(/[^a-zA-Z0-9 ]/g, "");
+        };
+        // Convert request schema to fields
+        jsonData.requestSchema.forEach((fieldData) => {
+            const field = {
+                key: fieldData.key,
+                // start case and replace underscores and any special characters with spaces
+                name: fieldData.name || caseAndSpace(fieldData.key),
+                type: fieldData.type,
+                description: fieldData.description,
+                defaultValue: fieldData.defaultValue,
+                operators: {},
+            };
+            rule.fields[fieldData.name] = field;
+        });
+        // Convert response schema to fields
+        jsonData.responseSchema.forEach((fieldData) => {
+            const field = {
+                key: fieldData.key,
+                name: fieldData.name || caseAndSpace(fieldData.key),
+                type: fieldData.type,
+                description: fieldData.description,
+                defaultValue: fieldData.defaultValue,
+                operators: {},
+            };
+            rule.responseFields[fieldData.name] = field;
+        });
+        // Convert test suite
+        rule.testSuite = (jsonData.testSuite || []).map((testData) => RuleTest.fromJSON(testData));
+        return rule;
+    }
+    getEditorUrl() {
+        if (!this.workspace) {
+            throw new Error("Workspace not configured. Call setWorkspace() first.");
+        }
+        return `https://rulebricks.com/dashboard/${this.id}`;
+    }
+    toTable() {
+        const header = ["Condition", ...Object.keys(this.fields), "Response"];
+        const rows = [];
+        this.conditions.forEach((condition, index) => {
+            const row = [`#${index + 1}`];
+            // Add request conditions
+            Object.keys(this.fields).forEach((fieldName) => {
+                const cond = condition.request[fieldName];
+                row.push(cond ? `${cond.op} ${cond.args.join(", ")}` : "-");
+            });
+            // Add response
+            const responseStr = Object.entries(condition.response)
+                .map(([key, value]) => `${key}: ${value.value}`)
+                .join(", ");
+            row.push(responseStr || "-");
+            rows.push(row);
+        });
+        // Format as ASCII table
+        const maxLengths = header.map((_, colIndex) => Math.max(header[colIndex].length, ...rows.map((row) => row[colIndex].length)));
+        const separator = maxLengths.map((len) => "-".repeat(len)).join("-+-");
+        const formatRow = (row) => row.map((cell, i) => cell.padEnd(maxLengths[i])).join(" | ");
+        return [formatRow(header), separator, ...rows.map(formatRow)].join("\n");
+    }
+    toString() {
+        return `Rule(name="${this.name}", id="${this.id}", conditions=${this.conditions.length})`;
+    }
+}
+exports.Rule = Rule;