@lowdefy/operators 4.0.0-alpha.1 → 4.0.0-alpha.7

package/dist/index.js

@@ -12,6 +12,10 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import NodeParser from './nodeParser.js';
+*/ import getFromArray from './getFromArray.js';
+import getFromObject from './getFromObject.js';
+import NodeParser from './nodeParser.js';
+import runClass from './runClass.js';
+import runInstance from './runInstance.js';
 import WebParser from './webParser.js';
-export { NodeParser, WebParser };
+export { getFromArray, getFromObject, NodeParser, runClass, runInstance, WebParser };

package/dist/nodeParser.js

@@ -13,22 +13,16 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer, type } from '@lowdefy/helpers';
-import commonOperators from './common/index.js';
-import nodeOperators from './node/index.js';
 let NodeParser = class NodeParser {
     async init() {
-        const operators = this.operators;
-        const operations = this.operations;
-        await Promise.all(Object.keys(operators).map(async (operator)=>{
-            const fn = await import(`./${operators[operator]}.js`);
-            operations[operator] = fn.default;
-            if (operations[operator].init) {
-                await operations[operator].init();
+        await Promise.all(Object.values(this.operators).map(async (operator)=>{
+            if (operator.init) {
+                await operator.init();
             }
         }));
     }
     parse({ args , input , location  }) {
-        const operations = this.operations;
+        const operators = this.operators;
         const secrets = this.secrets;
         const payload = this.payload;
         const user = this.user;
@@ -41,7 +35,7 @@ let NodeParser = class NodeParser {
         if (args && !type.isArray(args)) {
             throw new Error('Operator parser args must be an array.');
         }
-        if (location && !type.isString(location)) {
+        if (!type.isString(location)) {
             throw new Error('Operator parser location must be a string.');
         }
         const errors = [];
@@ -50,14 +44,14 @@ let NodeParser = class NodeParser {
                 const key = Object.keys(value)[0];
                 const [op, methodName] = key.split('.');
                 try {
-                    if (!type.isUndefined(operations[op])) {
-                        const res = operations[op]({
+                    if (!type.isUndefined(operators[op])) {
+                        const res = operators[op]({
                             args,
                             arrayIndices: [],
                             env: 'node',
                             location,
                             methodName,
-                            operations: operations,
+                            operators: operators,
                             params: value[key],
                             secrets,
                             payload,
@@ -81,18 +75,12 @@ let NodeParser = class NodeParser {
             errors
         };
     }
-    constructor({ payload , secrets , user  } = {
-    }){
+    constructor({ payload , secrets , user , operators  }){
+        this.operators = operators;
         this.payload = payload;
         this.secrets = secrets;
         this.user = user;
         this.parse = this.parse.bind(this);
-        this.operators = {
-            ...commonOperators,
-            ...nodeOperators
-        };
-        this.operations = {
-        };
     }
 };
 export default NodeParser;

package/dist/webParser.js

@@ -13,30 +13,19 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { applyArrayIndices, serializer, type } from '@lowdefy/helpers';
-import commonOperators from './common/index.js';
-import webOperators from './web/index.js';
 let WebParser = class WebParser {
     async init() {
         if (!type.isObject(this.context._internal.lowdefy)) {
             throw new Error('context._internal.lowdefy must be an object.');
         }
-        if (!type.isArray(this.context._internal.operators)) {
-            throw new Error('context._internal.operators must be an array.');
-        }
-        const operators = this.operators;
-        const operations = this.operations;
-        await Promise.all(this.context._internal.operators.map(async (operator)=>{
-            if (operators[operator]) {
-                const fn = await import(`./${operators[operator]}.js`);
-                operations[operator] = fn.default;
-                if (operations[operator].init) {
-                    await operations[operator].init();
-                }
+        await Promise.all(Object.values(this.operators).map(async (operator)=>{
+            if (operator.init) {
+                await operator.init();
             }
         }));
     }
     parse({ actions , args , arrayIndices , event , input , location  }) {
-        const operations = this.operations;
+        const operators = this.operators;
         const context = this.context;
         if (type.isUndefined(input)) {
             return {
@@ -50,7 +39,7 @@ let WebParser = class WebParser {
         if (args && !type.isArray(args)) {
             throw new Error('Operator parser args must be an array.');
         }
-        if (location && !type.isString(location)) {
+        if (!type.isString(location)) {
             throw new Error('Operator parser location must be a string.');
         }
         const errors = [];
@@ -60,8 +49,8 @@ let WebParser = class WebParser {
                 const key = Object.keys(value)[0];
                 const [op, methodName] = key.split('.');
                 try {
-                    if (!type.isUndefined(operations[op])) {
-                        const res = operations[op]({
+                    if (!type.isUndefined(operators[op])) {
+                        const res = operators[op]({
                             eventLog: context.eventLog,
                             actions,
                             args,
@@ -69,22 +58,17 @@ let WebParser = class WebParser {
                             context: context,
                             env: 'web',
                             event,
-                            input: inputs ? inputs[context.id] : {
-                            },
-                            location: location ? applyArrayIndices(arrayIndices, location) : null,
-                            lowdefyGlobal: lowdefyGlobal || {
-                            },
-                            menus: menus || {
-                            },
+                            input: inputs ? inputs[context.id] : {},
+                            location: applyArrayIndices(arrayIndices, location),
+                            lowdefyGlobal: lowdefyGlobal || {},
+                            menus: menus || {},
                             methodName,
-                            operations: operations,
+                            operators: operators,
                             params: value[key],
                             requests: context.requests,
                             state: context.state,
-                            urlQuery: urlQuery || {
-                            },
-                            user: user || {
-                            },
+                            urlQuery: urlQuery || {},
+                            user: user || {},
                             parser: this
                         });
                         return res;
@@ -104,16 +88,11 @@ let WebParser = class WebParser {
             errors
         };
     }
-    constructor({ context  }){
+    constructor({ context , operators  }){
         this.context = context;
         this.init = this.init.bind(this);
         this.parse = this.parse.bind(this);
-        this.operators = {
-            ...commonOperators,
-            ...webOperators
-        };
-        this.operations = {
-        };
+        this.operators = operators;
     }
 };
 export default WebParser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/operators",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.7",
   "licence": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -38,23 +38,16 @@
     "test:watch": "jest --coverage --watch"
   },
   "dependencies": {
-    "@lowdefy/format": "4.0.0-alpha.1",
-    "@lowdefy/helpers": "4.0.0-alpha.1",
-    "@lowdefy/nunjucks": "4.0.0-alpha.1",
-    "change-case": "4.1.2",
-    "deep-diff": "1.0.2",
-    "js-yaml": "4.1.0",
-    "mingo": "4.2.0",
-    "uuid": "8.3.2"
+    "@lowdefy/helpers": "4.0.0-alpha.7"
   },
   "devDependencies": {
-    "@swc/cli": "0.1.52",
-    "@swc/core": "1.2.112",
-    "@swc/jest": "0.2.9",
-    "jest": "27.3.1"
+    "@swc/cli": "0.1.55",
+    "@swc/core": "1.2.135",
+    "@swc/jest": "0.2.17",
+    "jest": "27.5.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c97a8fa6b5a641e7d50df09f5601a9c586eeb65a"
+  "gitHead": "52ec14639d00de910cf9b8ab25bf933ca891cff5"
 }

package/dist/common/and.js

@@ -1,23 +0,0 @@
-/*
-  Copyright 2020-2021 Lowdefy, Inc
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/ import { type } from '@lowdefy/helpers';
-function _and({ params , location  }) {
-    if (!type.isArray(params)) {
-        throw new Error(`Operator Error: _and takes an array type. Received: ${JSON.stringify(params)} at ${location}.`);
-    }
-    return !!params.reduce((acc, el)=>acc && el
-    , true);
-}
-export default _and;

package/dist/common/args.js

@@ -1,25 +0,0 @@
-/*
-  Copyright 2020-2021 Lowdefy, Inc
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/ import getFromObject from '../getFromObject.js';
-function _args({ args , arrayIndices , location , params  }) {
-    return getFromObject({
-        arrayIndices,
-        location,
-        object: args,
-        operator: '_args',
-        params
-    });
-}
-export default _args;

package/dist/common/array.js

@@ -1,261 +0,0 @@
-/*
-  Copyright 2020-2021 Lowdefy, Inc
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/ import { type } from '@lowdefy/helpers';
-import runInstance from '../runInstance.js';
-const prep = (args)=>{
-    if (type.isNone(args[0])) {
-        args[0] = [];
-    }
-    return args;
-};
-const meta = {
-    concat: {
-        prep,
-        validTypes: [
-            'array'
-        ]
-    },
-    copyWithin: {
-        namedArgs: [
-            'on',
-            'target',
-            'start',
-            'end'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    every: {
-        namedArgs: [
-            'on',
-            'callback'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    fill: {
-        namedArgs: [
-            'on',
-            'value',
-            'start',
-            'end'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    filter: {
-        namedArgs: [
-            'on',
-            'callback'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    find: {
-        namedArgs: [
-            'on',
-            'callback'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    findIndex: {
-        namedArgs: [
-            'on',
-            'callback'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    flat: {
-        namedArgs: [
-            'on',
-            'depth'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    includes: {
-        namedArgs: [
-            'on',
-            'value'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    indexOf: {
-        namedArgs: [
-            'on',
-            'value'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    join: {
-        namedArgs: [
-            'on',
-            'separator'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    lastIndexOf: {
-        namedArgs: [
-            'on',
-            'value'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    map: {
-        namedArgs: [
-            'on',
-            'callback'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    reduce: {
-        namedArgs: [
-            'on',
-            'callback',
-            'initialValue'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    reduceRight: {
-        namedArgs: [
-            'on',
-            'callback',
-            'initialValue'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    reverse: {
-        prep,
-        validTypes: [
-            'array'
-        ],
-        singleArg: true
-    },
-    slice: {
-        namedArgs: [
-            'on',
-            'start',
-            'end'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    some: {
-        namedArgs: [
-            'on',
-            'callback'
-        ],
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    sort: {
-        namedArgs: [
-            'on'
-        ],
-        prep,
-        validTypes: [
-            'array'
-        ]
-    },
-    splice: {
-        namedArgs: [
-            'on',
-            'start',
-            'deleteCount'
-        ],
-        spreadArgs: 'insert',
-        returnInstance: true,
-        prep,
-        validTypes: [
-            'array',
-            'object'
-        ]
-    },
-    length: {
-        validTypes: [
-            'array'
-        ],
-        prep,
-        property: true
-    }
-};
-function _array({ params , location , methodName  }) {
-    return runInstance({
-        location,
-        meta,
-        methodName,
-        operator: '_array',
-        params,
-        instanceType: 'array'
-    });
-}
-export default _array;

package/dist/common/change_case.js

@@ -1,139 +0,0 @@
-/*
-  Copyright 2020-2021 Lowdefy, Inc
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-*/ /* eslint-disable import/namespace */ import { camelCase, capitalCase, constantCase, dotCase, headerCase, noCase, paramCase, pascalCase, pathCase, sentenceCase, snakeCase } from 'change-case';
-import { get, type } from '@lowdefy/helpers';
-import runClass from '../runClass.js';
-const changeCase = {
-    camelCase,
-    capitalCase,
-    constantCase,
-    dotCase,
-    headerCase,
-    noCase,
-    paramCase,
-    pascalCase,
-    pathCase,
-    sentenceCase,
-    snakeCase
-};
-const prepRegex = (prop, location)=>{
-    const regex = type.isString(prop) ? {
-        pattern: prop
-    } : prop;
-    if (!type.isObject(regex)) {
-        throw new Error(`Operator Error: regex must be string or an object. Received ${JSON.stringify(prop)} at ${location}.`);
-    }
-    try {
-        return new RegExp(regex.pattern, regex.flags || 'gm');
-    } catch (e) {
-        throw new Error(`Operator Error: ${e.message}. Received: ${JSON.stringify(prop)} at ${location}.`);
-    }
-};
-const prep = (args, { location  })=>{
-    const options = args[1];
-    if (!type.isNone(options) && !type.isObject(options)) {
-        throw new Error(`Operator Error: options must be an object. Received ${JSON.stringify(options)} at ${location}.`);
-    }
-    if (type.isObject(options)) {
-        if (options.splitRegexp) {
-            options.splitRegexp = prepRegex(options.splitRegexp, location);
-        }
-        if (options.stripRegexp) {
-            options.stripRegexp = prepRegex(options.stripRegexp, location);
-        }
-    }
-    return args;
-};
-const convertArray = ({ methodName , on , options  })=>{
-    return on.map((item)=>{
-        if (type.isString(item)) {
-            return changeCase[methodName](item, options);
-        }
-        return item;
-    });
-};
-const convertObject = ({ methodName , on , options  })=>{
-    const result = {
-    };
-    const keyConverter = get(options, 'convertKeys') ? (key)=>changeCase[methodName](key, options)
-     : (key)=>key
-    ;
-    const valueConverter = get(options, 'convertValues', {
-        default: true
-    }) ? (val)=>changeCase[methodName](val, options)
-     : (val)=>val
-    ;
-    Object.entries(on).forEach(([key, value])=>{
-        if (type.isString(value)) {
-            result[keyConverter(key)] = valueConverter(value);
-        } else {
-            result[keyConverter(key)] = value;
-        }
-    });
-    return result;
-};
-const makeCaseChanger = ({ methodName  })=>(on, options = {
-    })=>{
-        if (type.isString(on)) {
-            return changeCase[methodName](on, options);
-        }
-        if (type.isArray(on)) {
-            return convertArray({
-                methodName,
-                on,
-                options
-            });
-        }
-        if (type.isObject(on)) {
-            return convertObject({
-                methodName,
-                on,
-                options
-            });
-        }
-        return on;
-    }
-;
-const functions = {
-};
-const meta = {
-};
-Object.keys(changeCase).forEach((methodName)=>{
-    functions[methodName] = makeCaseChanger({
-        methodName
-    });
-    meta[methodName] = {
-        namedArgs: [
-            'on',
-            'options'
-        ],
-        validTypes: [
-            'array',
-            'object'
-        ],
-        prep
-    };
-});
-function change_case({ params , location , methodName  }) {
-    return runClass({
-        functions,
-        location,
-        meta,
-        methodName,
-        operator: '_change_case',
-        params
-    });
-}
-export default change_case;