@rulebricks/sdk 1.0.0 → 1.1.0

package/forge/rule.js

@@ -1,702 +0,0 @@
-"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;