@lowdefy/operators-js 6.1.0 → 7.0.0

package/dist/operators/server/credential.schema.js

@@ -0,0 +1,20 @@
+/*
+  Copyright 2020-2026 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.
+*/ export default {
+    type: 'object',
+    params: {
+        description: 'A value the routine makes at runtime, such as a new API key or a secret derived with _hmac. Every string in it is replaced with [REDACTED] in the server logs for the rest of the request. The value is returned unchanged.'
+    }
+};

package/dist/operators/server/hmac.js

@@ -0,0 +1,72 @@
+/*
+  Copyright 2020-2026 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 crypto from 'crypto';
+import { ConfigError } from '@lowdefy/errors';
+import { type } from '@lowdefy/helpers';
+import { runClass } from '@lowdefy/operators';
+function createHmac(methodName) {
+    return function hmac(key, data) {
+        if (!type.isString(key)) {
+            throw new Error(`_hmac.${methodName} requires "key" to be a string.`);
+        }
+        if (!type.isString(data)) {
+            throw new Error(`_hmac.${methodName} requires "data" to be a string.`);
+        }
+        return crypto.createHmac(methodName, key).update(data, 'utf8').digest('hex');
+    };
+}
+const functions = {
+    sha256: createHmac('sha256'),
+    sha512: createHmac('sha512')
+};
+const meta = {
+    sha256: {
+        validTypes: [
+            'object'
+        ],
+        namedArgs: [
+            'key',
+            'data'
+        ]
+    },
+    sha512: {
+        validTypes: [
+            'object'
+        ],
+        namedArgs: [
+            'key',
+            'data'
+        ]
+    }
+};
+// Every refusal is thrown as a ConfigError, which the parser reports without the operator's
+// params as received: `key` is often a key derived from a secret, which the secret scrub does
+// not know.
+function _hmac({ params, location, methodName }) {
+    try {
+        return runClass({
+            functions,
+            location,
+            meta,
+            methodName,
+            operator: '_hmac',
+            params
+        });
+    } catch (error) {
+        throw new ConfigError(error.message);
+    }
+}
+_hmac.dynamic = false;
+export default _hmac;

package/dist/operators/server/hmac.schema.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2026 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.
+*/ export default {
+    type: 'object',
+    params: {
+        type: 'object',
+        required: [
+            'key',
+            'data'
+        ],
+        properties: {
+            key: {
+                type: 'string',
+                description: 'The secret key, as a UTF-8 string. Usually a _secret.'
+            },
+            data: {
+                type: 'string',
+                description: 'The UTF-8 string to sign.'
+            }
+        },
+        additionalProperties: false
+    }
+};

package/dist/operators/server/js.js

@@ -53,7 +53,7 @@ function js(operatorContext) {
                 })
         });
     } catch (error) {
-        throw new Error(`_js function execution error. Function: ${jsMap[hash].toString()}`, {
+        throw new Error(`_js function execution error. ${error.name}: ${error.message}`, {
             cause: error
         });
     }

package/dist/operators/server/organization.js

@@ -0,0 +1,40 @@
+/*
+  Copyright 2020-2026 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 { ConfigError, LowdefyInternalError } from '@lowdefy/errors';
+import { getFromObject } from '@lowdefy/operators';
+import { type } from '@lowdefy/helpers';
+// Reads the resolved pinned organization ({ id, slug, name }) the engine
+// retained from the startup ensure-by-slug. Evaluated at request time like
+// _secret / _payload - the org id is minted at creation and known only after
+// startup, so no build-time operator or config var can carry it.
+function _organization({ location, organization, params }) {
+    if (type.isNone(organization)) {
+        throw new ConfigError('_organization requires auth organizations to be configured - no organizations state is available.');
+    }
+    if (organization.policy === 'tenant') {
+        throw new ConfigError('_organization cannot resolve under the "tenant" organizations policy - there is no single pinned organization. Pass an explicit organization id instead.');
+    }
+    if (type.isNone(organization.pinned)) {
+        throw new LowdefyInternalError('The pinned organization has not been resolved - the startup ensure has not completed or failed.');
+    }
+    return getFromObject({
+        location,
+        object: organization.pinned,
+        operator: '_organization',
+        params
+    });
+}
+_organization.dynamic = true;
+export default _organization;

package/dist/operators/server/organization.schema.js

@@ -0,0 +1,59 @@
+/*
+  Copyright 2020-2026 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.
+*/ export default {
+    type: 'object',
+    params: {
+        oneOf: [
+            {
+                type: 'string',
+                enum: [
+                    'id',
+                    'slug',
+                    'name'
+                ],
+                description: 'Field of the resolved pinned organization to return.'
+            },
+            {
+                type: 'boolean',
+                enum: [
+                    true
+                ],
+                description: 'Return the resolved pinned organization.'
+            },
+            {
+                type: 'object',
+                properties: {
+                    key: {
+                        type: 'string',
+                        enum: [
+                            'id',
+                            'slug',
+                            'name'
+                        ],
+                        description: 'Field of the resolved pinned organization to return.'
+                    },
+                    default: {
+                        description: 'Default value if key does not exist.'
+                    },
+                    all: {
+                        type: 'boolean',
+                        description: 'Return the resolved pinned organization.'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    }
+};

package/dist/operators/shared/and.js

@@ -20,4 +20,7 @@ function _and({ params }) {
     return !!params.reduce((acc, el)=>acc && el, true);
 }
 _and.dynamic = false;
+_and.tracking = {
+    kind: 'pure'
+};
 export default _and;

package/dist/operators/shared/app.js

@@ -33,4 +33,7 @@ function _app({ arrayIndices, location, lowdefyApp, params }) {
     return value;
 }
 _app.dynamic = false;
+_app.tracking = {
+    kind: 'pure'
+};
 export default _app;

package/dist/operators/shared/args.js

@@ -23,4 +23,8 @@ function _args({ args, arrayIndices, location, params }) {
     });
 }
 _args.dynamic = false;
+// Reads only the args of its own parse frame, which no update changes.
+_args.tracking = {
+    kind: 'pure'
+};
 export default _args;

package/dist/operators/shared/array.js

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
-import { runInstance } from '@lowdefy/operators';
+import { runClass, runInstance } from '@lowdefy/operators';
 const prep = (args)=>{
     if (type.isNone(args[0])) {
         args[0] = [];
@@ -21,6 +21,17 @@ const prep = (args)=>{
     return args;
 };
 const meta = {
+    at: {
+        namedArgs: [
+            'on',
+            'index'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
     concat: {
         prep,
         validTypes: [
@@ -97,6 +108,28 @@ const meta = {
             'object'
         ]
     },
+    findLast: {
+        namedArgs: [
+            'on',
+            'callback'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    findLastIndex: {
+        namedArgs: [
+            'on',
+            'callback'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
     flat: {
         namedArgs: [
             'on',
@@ -108,6 +141,28 @@ const meta = {
             'object'
         ]
     },
+    flatMap: {
+        namedArgs: [
+            'on',
+            'callback'
+        ],
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
+    // Array.from is static; it builds a new array, e.g. of length n from { length: n }.
+    from: {
+        namedArgs: [
+            'on',
+            'callback'
+        ],
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
     includes: {
         namedArgs: [
             'on',
@@ -163,6 +218,29 @@ const meta = {
             'object'
         ]
     },
+    // Methods that change the array in place return the changed array, like splice, since the
+    // native return values (the new length, or the removed item) are rarely useful in config.
+    pop: {
+        prep,
+        validTypes: [
+            'array',
+            'null'
+        ],
+        singleArg: true,
+        returnInstance: true
+    },
+    push: {
+        namedArgs: [
+            'on'
+        ],
+        spreadArgs: 'items',
+        returnInstance: true,
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
     reduce: {
         namedArgs: [
             'on',
@@ -195,6 +273,15 @@ const meta = {
         ],
         singleArg: true
     },
+    shift: {
+        prep,
+        validTypes: [
+            'array',
+            'null'
+        ],
+        singleArg: true,
+        returnInstance: true
+    },
     slice: {
         namedArgs: [
             'on',
@@ -241,6 +328,18 @@ const meta = {
             'object'
         ]
     },
+    unshift: {
+        namedArgs: [
+            'on'
+        ],
+        spreadArgs: 'items',
+        returnInstance: true,
+        prep,
+        validTypes: [
+            'array',
+            'object'
+        ]
+    },
     length: {
         validTypes: [
             'array',
@@ -250,7 +349,20 @@ const meta = {
         property: true
     }
 };
+const functions = {
+    from: (arrayLike, callback)=>Array.from(arrayLike, callback)
+};
 function _array({ params, location, methodName }) {
+    if (methodName === 'from') {
+        return runClass({
+            functions,
+            location,
+            meta,
+            methodName,
+            operator: '_array',
+            params
+        });
+    }
     return runInstance({
         location,
         meta,
@@ -261,4 +373,7 @@ function _array({ params, location, methodName }) {
     });
 }
 _array.dynamic = false;
+_array.tracking = {
+    kind: 'pure'
+};
 export default _array;

package/dist/operators/shared/boolean.js

@@ -16,4 +16,7 @@
     return !!params;
 }
 _boolean.dynamic = false;
+_boolean.tracking = {
+    kind: 'pure'
+};
 export default _boolean;

package/dist/operators/shared/date.js

@@ -449,4 +449,20 @@ function _date({ params, location, methodName }) {
     });
 }
 _date.dynamic = true;
+// "now", and every instance method given no date (prep substitutes the current date), read the clock.
+_date.tracking = ({ methodName, params })=>{
+    if (type.isUndefined(methodName)) {
+        return {
+            kind: params === 'now' ? 'volatile' : 'pure'
+        };
+    }
+    if (methodName === 'now' || type.isNone(params)) {
+        return {
+            kind: 'volatile'
+        };
+    }
+    return {
+        kind: 'pure'
+    };
+};
 export default _date;

package/dist/operators/shared/divide.js

@@ -29,4 +29,7 @@ function _divide({ params }) {
     return params[0] / params[1];
 }
 _divide.dynamic = false;
+_divide.tracking = {
+    kind: 'pure'
+};
 export default _divide;

package/dist/operators/shared/eq.js

@@ -23,4 +23,7 @@ function _eq({ params }) {
     return params[0] === params[1];
 }
 _eq.dynamic = false;
+_eq.tracking = {
+    kind: 'pure'
+};
 export default _eq;

package/dist/operators/shared/error.js

@@ -34,4 +34,8 @@ function _error({ arrayIndices, error, location, params }) {
     });
 }
 _error.dynamic = true;
+// Reads only the caught error of its own parse frame, which no update changes.
+_error.tracking = {
+    kind: 'pure'
+};
 export default _error;

package/dist/operators/shared/function.js

@@ -29,4 +29,8 @@ function _function({ operatorPrefix, params, parser }) {
     };
 }
 _function.dynamic = true;
+// What the body reads is only known when it is called, often at render time.
+_function.tracking = {
+    kind: 'untracked'
+};
 export default _function;

package/dist/operators/shared/get.js

@@ -34,4 +34,7 @@ function _get({ arrayIndices, location, params }) {
     });
 }
 _get.dynamic = false;
+_get.tracking = {
+    kind: 'pure'
+};
 export default _get;

package/dist/operators/shared/gt.js

@@ -23,4 +23,7 @@ function _gt({ params }) {
     return params[0] > params[1];
 }
 _gt.dynamic = false;
+_gt.tracking = {
+    kind: 'pure'
+};
 export default _gt;

package/dist/operators/shared/gte.js

@@ -23,4 +23,7 @@ function _gte({ params }) {
     return params[0] >= params[1];
 }
 _gte.dynamic = false;
+_gte.tracking = {
+    kind: 'pure'
+};
 export default _gte;

package/dist/operators/shared/if.check.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2026 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 { getOperatorType, type } from '@lowdefy/helpers';
+// _if is not dynamic, so params that are one operator ({ _state: ifParams })
+// are evaluated first and may give a valid object. Array and primitive params
+// are left to the runtime error.
+const ifTest = {
+    id: 'if-test',
+    level: 'error',
+    description: '_if needs its condition under test.',
+    check: ({ params })=>type.isObject(params) && !('test' in params) && getOperatorType(params) === null ? '_if has no test key. Put the condition under test:.' : null
+};
+export default ifTest;

package/dist/operators/shared/if.js

@@ -22,4 +22,7 @@
     throw new Error(`_if takes a boolean type for parameter test.`);
 }
 _if.dynamic = false;
+_if.tracking = {
+    kind: 'pure'
+};
 export default _if;

package/dist/operators/shared/if_none.js

@@ -26,4 +26,7 @@ function _if_none({ params }) {
     return params[0];
 }
 _if_none.dynamic = false;
+_if_none.tracking = {
+    kind: 'pure'
+};
 export default _if_none;

package/dist/operators/shared/intl.js

@@ -12,7 +12,8 @@
   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 { runClass } from '@lowdefy/operators';
+*/ import { type } from '@lowdefy/helpers';
+import { runClass } from '@lowdefy/operators';
 function createFormatter({ IntlClass }) {
     const formatter = (on, options, locale)=>{
         return new IntlClass(locale, options).format(on);
@@ -92,4 +93,16 @@ function intl({ params, location, methodName }) {
     });
 }
 intl.dynamic = true;
+// Intl.DateTimeFormat formats the current time when given no date.
+intl.tracking = ({ methodName, params })=>{
+    if (methodName !== 'dateTimeFormat') {
+        return {
+            kind: 'pure'
+        };
+    }
+    const on = type.isArray(params) ? params[0] : params?.on;
+    return {
+        kind: type.isUndefined(on) ? 'volatile' : 'pure'
+    };
+};
 export default intl;

package/dist/operators/shared/json.js

@@ -59,4 +59,7 @@ function _json({ params, location, methodName }) {
     });
 }
 _json.dynamic = false;
+_json.tracking = {
+    kind: 'pure'
+};
 export default _json;

package/dist/operators/shared/locale.js

@@ -29,4 +29,11 @@ function _locale({ arrayIndices, location, params, i18n }) {
     });
 }
 _locale.dynamic = true;
+// i18n changes reach the engine through the full render-time pass, which evaluates every block.
+_locale.tracking = {
+    kind: 'read',
+    keys: ()=>[
+            'i18n'
+        ]
+};
 export default _locale;

package/dist/operators/shared/log.js

@@ -18,4 +18,8 @@
     return params;
 }
 _log.dynamic = true;
+// Pure for its output. Its console output only happens on the passes that evaluate its block.
+_log.tracking = {
+    kind: 'pure'
+};
 export default _log;

package/dist/operators/shared/lt.js

@@ -23,4 +23,7 @@ function _lt({ params }) {
     return params[0] < params[1];
 }
 _lt.dynamic = false;
+_lt.tracking = {
+    kind: 'pure'
+};
 export default _lt;

package/dist/operators/shared/lte.js

@@ -23,4 +23,7 @@ function _lte({ params }) {
     return params[0] <= params[1];
 }
 _lte.dynamic = false;
+_lte.tracking = {
+    kind: 'pure'
+};
 export default _lte;

package/dist/operators/shared/math.js

@@ -282,5 +282,11 @@ function _math({ params, location, methodName }) {
     });
 }
 _math.dynamic = false;
+_math.tracking = ({ methodName, params })=>{
+    const method = methodName ?? params;
+    return {
+        kind: method === 'random' ? 'volatile' : 'pure'
+    };
+};
 _math.meta = meta;
 export default _math;