denotify-client 1.1.9 → 1.1.11

package/dist/triggers/trigger.js

@@ -1,14 +0,0 @@
-import { HandlerFunctionCall } from "./handler_function_call.js";
-import { HandlerOnchainEvent } from "./handler_onchain_event.js";
-import { HandlerFunctionCallV2 } from "./handler_function_call_v2.js";
-export class Trigger {
-    static SimpleToRaw(name, id, network, config) {
-        switch (id) {
-            case 'PollFunctionV2': return HandlerFunctionCallV2.SimpleToRaw(name, network, config);
-            case 'PollFunctionV1': return HandlerFunctionCall.SimpleToRaw(name, network, config);
-            case 'OnchainEventV1': return HandlerOnchainEvent.SimpleToRaw(name, network, config);
-            default:
-                throw new Error('Invalid Trigger ID');
-        }
-    }
-}

package/dist/types/types.js

@@ -1 +0,0 @@
-export {};

package/dist/util/filter.js

@@ -1,160 +0,0 @@
-import * as yup from 'yup';
-export class Filter {
-    static version() {
-        return 'v1';
-    }
-    static execute(record, groupsIn, version = 'v1') {
-        // Deep copy to so we can edit the object during recursion
-        const groups = JSON.parse(JSON.stringify(groupsIn));
-        let lhs = true;
-        for (const group of groups) {
-            const rhs = Filter.process(record, group.conditions);
-            lhs = Filter.execLogic(lhs, group.logic, rhs);
-        }
-        return lhs;
-    }
-    static process(record, conditions, lhs) {
-        const condition = conditions.shift();
-        if (!condition) {
-            if (lhs === undefined)
-                return true;
-            return lhs;
-        }
-        // lhs <logic> rhs
-        const rhs = Filter.execCondition(record, condition);
-        if (lhs === undefined || condition.logic === 'WHERE')
-            return Filter.process(record, conditions, rhs);
-        if (condition.logic === undefined)
-            throw new Error('Invalid filter. Condition must have logic value');
-        const next = Filter.execLogic(lhs, condition.logic, rhs);
-        return Filter.process(record, conditions, next);
-    }
-    static execLogic(lhs, logic, rhs) {
-        switch (logic) {
-            case 'AND': return lhs && rhs;
-            case 'OR': return lhs || rhs;
-            case 'XOR': return (lhs || rhs) && !(lhs && rhs);
-            case 'NAND': return !(lhs && rhs);
-            case 'NOR': return !(lhs && rhs);
-            case 'WHERE': return rhs;
-            default: throw new Error(`Invalid Filter. Bad logic value: ${logic}`);
-        }
-    }
-    static execCondition(record, condition) {
-        const data = record[condition.key];
-        if (condition.type === 'Number') {
-            if (typeof condition.constant !== 'number' || typeof data !== 'number')
-                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
-            const n = data;
-            const constant = condition.constant;
-            switch (condition.operation) {
-                case 'eq': return n === constant;
-                case '!eq': return n !== constant;
-                case 'gt': return n > constant;
-                case 'gte': return n >= constant;
-                case 'lt': return n < constant;
-                case 'lte': return n <= constant;
-                default: throw new Error('Invalid Filter. Operation does not match type');
-            }
-        }
-        if (condition.type === 'String') {
-            if (typeof condition.constant !== 'string' || typeof data !== 'string')
-                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
-            const str = data;
-            const constant = condition.constant;
-            switch (condition.operation) {
-                case 'contains': return str.includes(constant);
-                case '!contains': return !str.includes(constant);
-                case 'is': return str === constant;
-                case '!is': return str !== constant;
-                case 'isEmpty': return str === '';
-                case '!isEmpty': return str !== '';
-                default: throw new Error('Invalid Filter. Operation does not match type');
-            }
-        }
-        if (condition.type === 'Address') {
-            if (typeof condition.constant !== 'string' || typeof data !== 'string')
-                throw new Error(`Invalid filter. Type miss-match. Type: ${condition.type}, Variable: ${condition.constant}, Data: ${data}`);
-            const str = data;
-            const constant = condition.constant;
-            switch (condition.operation) {
-                case 'contains': return str.toLowerCase().includes(constant.toLowerCase());
-                case '!contains': return !str.toLowerCase().includes(constant.toLowerCase());
-                case 'is': return str.toLowerCase() === constant.toLowerCase();
-                case '!is': return str.toLowerCase() !== constant.toLowerCase();
-                case 'isEmpty': return str === '';
-                case '!isEmpty': return str !== '';
-                default: throw new Error('Invalid Filter. Operation does not match type');
-            }
-        }
-        throw new Error('Invalid Filter. Unknown Type');
-    }
-}
-export class FilterBuilder {
-    groups = [];
-    constructor() {
-        this.newGroup('WHERE');
-    }
-    static version() {
-        return Filter.version();
-    }
-    static new() {
-        return new FilterBuilder();
-    }
-    newGroup(logic) {
-        if (this.groups.length !== 0 && logic === 'WHERE')
-            throw new Error('Only the first groups can start with "WHERE"');
-        this.groups.push({ logic: 'WHERE', conditions: [] });
-        return this;
-    }
-    addCondition(logic, key, type, operation, constant) {
-        const group = this.groups[this.groups.length - 1];
-        if (group.conditions.length === 0 && logic !== 'WHERE')
-            throw new Error('Logic for the first condition of a group must be "WHERE"');
-        if (group.conditions.length > 0 && logic === 'WHERE')
-            throw new Error('Only the first condition of a group can be "WHERE"');
-        group.conditions.push({
-            logic,
-            key,
-            type,
-            operation,
-            constant
-        });
-        return this;
-    }
-    finalise() {
-        for (const group of this.groups) {
-            if (group.conditions.length === 0)
-                throw new Error('Bad Filter. All Groups must have atleast one condition');
-        }
-        return this.groups;
-    }
-    static schema() {
-        const logic = yup.string().oneOf(['AND', 'OR', 'XOR', 'NAND', 'NOR', 'WHERE']).required();
-        const condition = yup.object({
-            logic,
-            key: yup.string().required(),
-            type: yup.string().oneOf(['String', 'Address', 'Number']).required(),
-            operation: yup.string().when('type', ([type], schema) => {
-                switch (type) {
-                    case 'String': return schema.oneOf(['contains', '!contains', 'is', '!is', 'isEmpty', '!isEmpty']);
-                    case 'Address': return schema.oneOf(['is', '!is', 'isEmpty', '!isEmpty']);
-                    case 'Number': return schema.oneOf(['String', 'Address', 'Number']);
-                    default: throw new Error('Invalid Filter Data Type');
-                }
-            }),
-            constant: yup.mixed().when('type', ([type]) => {
-                switch (type) {
-                    case 'String': return yup.string();
-                    case 'Address': return yup.string();
-                    case 'Number': return yup.number();
-                    default: throw new Error('Invalid Filter Data Type');
-                }
-            }),
-        });
-        return yup.array().of(yup.object({
-            logic,
-            conditions: yup.array().of(condition)
-        }));
-    }
-}