nesoi 3.3.20 → 3.3.21

package/lib/elements/entities/bucket/query/nql.schema.d.ts

@@ -13,6 +13,7 @@ export type NQL_Union = {
     inters: NQL_Intersection[];
     sort?: {
         key: string;
+        key_is_deep: boolean;
         dir: ('asc' | 'desc');
     }[];
     _debug_id?: number;
@@ -25,6 +26,7 @@ export type NQL_Intersection = {
 export type NQL_Rule = {
     meta: NQL_QueryMeta;
     fieldpath: string;
+    fieldpath_is_deep: boolean;
     op: NQL_Operation;
     case_i: boolean;
     not: boolean;
@@ -32,6 +34,7 @@ export type NQL_Rule = {
         static: any | any[];
     } | {
         param: string | string[];
+        param_is_deep: boolean;
     } | {
         param_with_$: string;
     } | {

package/lib/elements/entities/bucket/query/nql_compiler.d.ts

@@ -1,6 +1,6 @@
 import { NQL_AnyQuery, NQL_Union, NQL_Part, NQL_Node } from './nql.schema';
 import { AnyDaemon } from "../../../../engine/daemon";
-import { BucketMetadata } from "../../../../engine/transaction/trx_engine";
+import { NQLRunner } from './nql_engine';
 /**
  * @category NQL
  * */
@@ -9,11 +9,14 @@ export declare class NQL_RuleTree {
     private module;
     private bucketName;
     private query;
-    private customMetadata?;
+    private customBuckets;
     private debug;
     private static OpByType;
     root: NQL_Union;
-    constructor(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customMetadata?: BucketMetadata | undefined, debug?: boolean);
+    constructor(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customBuckets?: Record<string, {
+        scope: string;
+        nql: NQLRunner;
+    }>, debug?: boolean);
     parse(): Promise<void>;
     private parseUnion;
     private parseSort;
@@ -39,7 +42,10 @@ export declare class NQL_RuleTree {
  * @category NQL
  * */
 export declare class NQL_Compiler {
-    static build(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customMetadata?: BucketMetadata): Promise<NQL_CompiledQuery>;
+    static build(daemon: AnyDaemon, module: string, bucketName: string, query: NQL_AnyQuery, customBuckets?: Record<string, {
+        scope: string;
+        nql: NQLRunner;
+    }>): Promise<NQL_CompiledQuery>;
     static buildTree(tree: NQL_RuleTree): Promise<NQL_CompiledQuery>;
 }
 /**

package/lib/elements/entities/bucket/query/nql_compiler.js

@@ -13,7 +13,7 @@ class NQL_RuleTree {
     module;
     bucketName;
     query;
-    customMetadata;
+    customBuckets;
     debug;
     static OpByType = {
         'boolean': ['==', 'in', 'present'],
@@ -34,18 +34,19 @@ class NQL_RuleTree {
         'unknown': ['==', 'contains', 'contains_any', 'in', 'present']
     };
     root;
-    constructor(daemon, module, bucketName, query, customMetadata, debug = false) {
+    constructor(daemon, module, bucketName, query, customBuckets = {}, debug = false) {
         this.daemon = daemon;
         this.module = module;
         this.bucketName = bucketName;
         this.query = query;
-        this.customMetadata = customMetadata;
+        this.customBuckets = customBuckets;
         this.debug = debug;
     }
     async parse() {
         const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', this.bucketName);
-        const bucket = this.customMetadata || await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
-        this.root = await this.parseUnion(bucket, this.query);
+        const meta = await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
+        meta.scope = this.customBuckets[tag.short]?.scope || meta.scope;
+        this.root = await this.parseUnion(meta, this.query);
         if (this.debug) {
             console.log(this.describe());
         }
@@ -56,10 +57,10 @@ class NQL_RuleTree {
         }
     }
     // Parse NQL
-    async parseUnion(bucket, query, select) {
+    async parseUnion(meta, query, select) {
         const union = {
             meta: {
-                ...bucket,
+                ...meta,
                 avgTime: 0
             },
             inters: [
@@ -68,16 +69,17 @@ class NQL_RuleTree {
         };
         for (const key in query) {
             const value = query[key];
-            const parsedKey = await this.parseKey(bucket, key);
+            const parsedKey = await this.parseKey(meta, key);
             // Fieldpath term -> Condition
             if (parsedKey.type === 'fieldpath') {
-                const parsed = await this.parseValue(value, parsedKey, bucket, select);
+                const parsed = await this.parseValue(value, parsedKey, meta, select);
                 const rule = ('subquery' in parsed)
                     ? parsed.subquery.union
                     : {
-                        meta: { ...bucket },
+                        meta: { ...meta },
                         select,
                         fieldpath: parsedKey.fieldpath,
+                        fieldpath_is_deep: parsedKey.fieldpath.includes('.'),
                         value: parsed,
                         op: parsedKey.op,
                         case_i: parsedKey.case_i,
@@ -102,15 +104,15 @@ class NQL_RuleTree {
                 throw new Error('Graph Link not supported yet');
             }
             else if (parsedKey.type === 'and') {
-                const subInter = await this.parseUnion(bucket, value, select);
+                const subInter = await this.parseUnion(meta, value, select);
                 union.inters[0].rules.push(subInter);
             }
             else if (parsedKey.type === 'or') {
-                const subInter = await this.parseUnion(bucket, value, select);
+                const subInter = await this.parseUnion(meta, value, select);
                 union.inters.push({ meta: {}, rules: [subInter] });
             }
             else if (parsedKey.type === 'sort') {
-                union.sort = await this.parseSort(bucket, value);
+                union.sort = await this.parseSort(meta, value);
             }
         }
         if (!union.inters[0]?.rules.length) {
@@ -118,7 +120,7 @@ class NQL_RuleTree {
         }
         return union;
     }
-    parseSort(bucket, value) {
+    parseSort(meta, value) {
         if (!Array.isArray(value))
             value = [value];
         if (value.some(v => typeof v !== 'string')) {
@@ -138,11 +140,11 @@ class NQL_RuleTree {
             else {
                 throw new Error(`Invalid query sort direction '${key}', string must end with '@asc' or '@desc'`);
             }
-            const is_metadata_field = Object.values(bucket.meta).includes(key);
+            const is_metadata_field = Object.values(meta.meta).includes(key);
             if (!is_metadata_field) {
-                const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, key);
+                const fields = bucket_model_schema_1.$BucketModel.getField(meta.schema.model, key);
                 if (!fields.length) {
-                    throw new Error(`Field '${key}' not found on bucket '${bucket.schema.name}'`);
+                    throw new Error(`Field '${key}' not found on bucket '${meta.schema.name}'`);
                 }
                 for (const field of fields) {
                     if (![
@@ -154,12 +156,13 @@ class NQL_RuleTree {
             }
             sort.push({
                 key,
+                key_is_deep: key.includes('.'),
                 dir: vdir
             });
         }
         return sort;
     }
-    async parseKey(bucket, key) {
+    async parseKey(meta, key) {
         if (key === '#sort') {
             return { type: 'sort' };
         }
@@ -171,9 +174,9 @@ class NQL_RuleTree {
         }
         else if (key.startsWith('*')) {
             const linkName = key.slice(1);
-            const link = bucket.schema.graph.links[linkName];
+            const link = meta.schema.graph.links[linkName];
             if (!link) {
-                throw new Error(`Graph Link '${linkName}' doesn't exist on the bucket ${bucket}`);
+                throw new Error(`Graph Link '${linkName}' doesn't exist on the bucket ${meta}`);
             }
             const linkBucket = await daemon_1.Daemon.getBucketMetadata(this.daemon, link.bucket);
             return { type: 'graphlink', link: link.name, linkBucket: linkBucket.schema };
@@ -184,13 +187,13 @@ class NQL_RuleTree {
                 throw new Error(`Invalid term '${key}'`);
             }
             const [_, or, fieldpath, not, case_i, op] = term;
-            if (Object.values(bucket.meta).includes(fieldpath)) {
+            if (Object.values(meta.meta).includes(fieldpath)) {
                 const _op = this.parseOp([{ type: 'datetime', name: fieldpath }], op);
                 return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
             }
-            const fields = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, fieldpath);
+            const fields = bucket_model_schema_1.$BucketModel.getField(meta.schema.model, fieldpath);
             if (!fields.length) {
-                throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
+                throw new Error(`Field '${fieldpath}' not found on bucket '${meta.schema.name}'`);
             }
             const _op = this.parseOp(fields, op);
             return { type: 'fieldpath', or: !!or, fieldpath, not: !!not, case_i: !!case_i, op: _op };
@@ -253,7 +256,7 @@ class NQL_RuleTree {
                     throw new Error(`Cannot mix static and parameter values inside array value [${value}]`);
                 }
                 if (params.length > 0) {
-                    return { param: params };
+                    return { param: params, param_is_deep: params.some(p => p.includes('.')) };
                 }
                 else {
                     return { static: statyc };
@@ -262,7 +265,7 @@ class NQL_RuleTree {
             else {
                 // Parameter
                 if ('.' in value) {
-                    return { param: value['.'] };
+                    return { param: value['.'], param_is_deep: value['.'].includes('.') };
                 }
                 // Path Parameter
                 else if ('$' in value) {
@@ -292,24 +295,28 @@ class NQL_RuleTree {
                 }
                 const [_, or, refBucket, fieldpath] = refField;
                 const tag = dependency_1.Tag.fromNameOrShort(this.module, 'bucket', refBucket);
-                const bucket = await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
-                if (!bucket) {
-                    throw new Error(`Bucket '${bucket}' not found on module`);
+                const subMeta = await daemon_1.Daemon.getBucketMetadata(this.daemon, tag);
+                if (!subMeta) {
+                    throw new Error(`Bucket '${subMeta}' not found on module`);
                 }
-                const field = bucket_model_schema_1.$BucketModel.getField(bucket.schema.model, fieldpath);
+                subMeta.scope = this.customBuckets[tag.short]?.scope || subMeta.scope;
+                const field = bucket_model_schema_1.$BucketModel.getField(subMeta.schema.model, fieldpath);
                 if (!field) {
-                    throw new Error(`Field '${fieldpath}' not found on bucket '${bucket.schema.name}'`);
+                    throw new Error(`Field '${fieldpath}' not found on bucket '${subMeta.schema.name}'`);
                 }
-                const refInter = await this.parseUnion(bucket, value[key], fieldpath);
+                // The union belongs to the sub scope.
+                const refInter = await this.parseUnion(subMeta, value[key], fieldpath);
                 const rule = {
+                    // This rule belongs to the parent scope.
                     meta: { ...meta },
                     select,
                     fieldpath: parsedKey.fieldpath,
+                    fieldpath_is_deep: parsedKey.fieldpath.includes('.'),
                     case_i: parsedKey.case_i,
                     not: parsedKey.not,
                     op: parsedKey.op,
                     value: {
-                        subquery: { union: refInter, bucket: bucket.schema, select: fieldpath }
+                        subquery: { union: refInter, bucket: subMeta.schema, select: fieldpath }
                     }
                 };
                 if (!or) {
@@ -512,8 +519,8 @@ exports.NQL_RuleTree = NQL_RuleTree;
  * @category NQL
  * */
 class NQL_Compiler {
-    static async build(daemon, module, bucketName, query, customMetadata) {
-        const tree = new NQL_RuleTree(daemon, module, bucketName, query, customMetadata);
+    static async build(daemon, module, bucketName, query, customBuckets = {}) {
+        const tree = new NQL_RuleTree(daemon, module, bucketName, query, customBuckets);
         return this.buildTree(tree);
     }
     static async buildTree(tree) {
@@ -659,7 +666,7 @@ class NQL_Compiler {
                     // Close part (&1)
                     if (rule.part) {
                         // Rebuild Union on original tree as Condition
-                        buildNode.value = { param: `%__${rule.part}__%` };
+                        buildNode.value = { param: `%__${rule.part}__%`, param_is_deep: false };
                         if (rule.part == partStack.at(-1).i) {
                             // debugLog.push('⊙ [part] ' + rule.part);
                             orderedParts.push(parts[rule.part]);

package/lib/elements/entities/bucket/query/nql_engine.d.ts

@@ -24,7 +24,10 @@ export declare class NQL_Engine {
     private module;
     private runners;
     constructor(module: AnyModule);
-    run(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], param_templates?: Record<string, string>[], view?: $BucketView, customRunners?: Record<string, NQLRunner>): Promise<NQL_Result>;
+    run(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], param_templates?: Record<string, string>[], view?: $BucketView, customBuckets?: Record<string, {
+        scope: string;
+        nql: NQLRunner;
+    }>): Promise<NQL_Result>;
     linkExternal(bucket: AnyBucket): void;
 }
 export {};

package/lib/elements/entities/bucket/query/nql_engine.js

@@ -23,7 +23,7 @@ class NQL_Engine {
             }
         }
     }
-    async run(trx, query, pagination, params = [{}], param_templates = [], view, customRunners) {
+    async run(trx, query, pagination, params = [{}], param_templates = [], view, customBuckets) {
         if (!params.length)
             params = [{}];
         if (!param_templates.length)
@@ -35,10 +35,8 @@ class NQL_Engine {
             const part_i = query.execOrder[i];
             const part = query.parts[part_i];
             // Run part
-            const runners = customRunners
-                ? { ...this.runners, ...customRunners }
-                : this.runners;
-            const _runner = runners[part.union.meta.scope];
+            const _runner = Object.values(customBuckets || {}).find(b => b.scope === part.union.meta.scope)?.nql
+                || this.runners[part.union.meta.scope];
             const out = await _runner.run(trx, part, params, param_templates, pagination, view);
             result = out;
             // Part failed, return

package/lib/elements/entities/message/template/message_template_field.builder.d.ts

@@ -70,6 +70,7 @@ export declare class MessageTemplateFieldBuilder<Module extends $Module, Message
     private _required;
     private _defaultValue?;
     private _nullable;
+    private _rawName?;
     private _rules;
     constructor(type: $MessageTemplateFieldType, meta: Omit<$MessageTemplateFieldMeta, 'enum' | 'msg' | 'id'> & {
         enum?: {
@@ -97,6 +98,7 @@ export declare class MessageTemplateFieldBuilder<Module extends $Module, Message
     ], InputSuffix>;
     get nullable(): MessageTemplateFieldBuilder<Module, Message, Input | null, Output | null, Children, Optional, InputSuffix>;
     rule(rule: MessageTemplateRuleDef<Output, Message['#raw']>): this;
+    rawName(name: string): this;
     static build(builder: AnyMessageTemplateFieldBuilder, name: string, tree: ModuleTree, module: $Module, basePathRaw: string, basePathParsed: string): $MessageTemplateField;
     static buildMany(fields: MessageTemplateFieldBuilders, tree: ModuleTree, module: $Module, basePathRaw?: string, basePathParsed?: string, name?: string, key?: string): $MessageTemplateFields;
 }

package/lib/elements/entities/message/template/message_template_field.builder.js

@@ -138,6 +138,7 @@ class MessageTemplateFieldBuilder {
     _required = true;
     _defaultValue = undefined;
     _nullable = false;
+    _rawName;
     _rules = [];
     constructor(type, meta, alias, children) {
         this.type = type;
@@ -166,6 +167,10 @@ class MessageTemplateFieldBuilder {
         this._rules.push(rule);
         return this;
     }
+    rawName(name) {
+        this._rawName = name;
+        return this;
+    }
     // Build
     static build(builder, name, tree, module, basePathRaw, basePathParsed) {
         const pathRaw = basePathRaw + (builder.type === 'id' ? `${name}_id` : name);

package/lib/engine/daemon.d.ts

@@ -123,10 +123,29 @@ export declare class DaemonTrx<S extends $Space, M extends $Module, AuthUsers ex
      * authenticate this transaction prior to running.
      */
     private tokens?;
+    /**
+     *
+     */
+    private _origin?;
+    /**
+     * An idempotent transaction doesn't generate a commit/rollback.
+     */
+    private _idempotent;
     /**
      * @param trxEngine The transaction engine where to run the transaction.
      */
     constructor(trxEngine: AnyTrxEngine);
+    origin(origin: string): this;
+    /**
+     * Flags this transaction as idempotent.
+     * This means its not stored, neither commited/rolled back.
+     * This should generally be used for readonly transactions.
+     */
+    get idempotent(): this;
+    /**
+     * Inherit authentication from another transaction node.
+     */
+    idempotent_inherit(trx: AnyTrxNode): this;
     /**
      * Inherit authentication from another transaction node.
      */

package/lib/engine/daemon.js

@@ -176,12 +176,40 @@ class DaemonTrx {
      * authenticate this transaction prior to running.
      */
     tokens;
+    /**
+     *
+     */
+    _origin;
+    /**
+     * An idempotent transaction doesn't generate a commit/rollback.
+     */
+    _idempotent = false;
     /**
      * @param trxEngine The transaction engine where to run the transaction.
      */
     constructor(trxEngine) {
         this.trxEngine = trxEngine;
     }
+    origin(origin) {
+        this._origin = origin;
+        return this;
+    }
+    /**
+     * Flags this transaction as idempotent.
+     * This means its not stored, neither commited/rolled back.
+     * This should generally be used for readonly transactions.
+     */
+    get idempotent() {
+        this._idempotent = true;
+        return this;
+    }
+    /**
+     * Inherit authentication from another transaction node.
+     */
+    idempotent_inherit(trx) {
+        this._idempotent = trx.trx.idempotent;
+        return this;
+    }
     /**
      * Inherit authentication from another transaction node.
      */
@@ -211,7 +239,7 @@ class DaemonTrx {
             ...this.tokens
         };
         const users = inheritedAuth?.users;
-        return this.trxEngine.trx(fn, id, tokens, users);
+        return this.trxEngine.trx(fn, id, tokens, users, this._origin, this._idempotent);
     }
     /**
      * Run a method inside the transaction, and hold it until
@@ -220,13 +248,23 @@ class DaemonTrx {
      * @param fn A function to execute inside the transaction
      * @returns A `TrxStatus` containing metadata about the transaction and the function response
      */
-    run_and_hold(fn, id) {
+    async run_and_hold(fn, id) {
         const inheritedAuth = this._inherit.auth;
         const tokens = {
             ...inheritedAuth?.tokens,
             ...this.tokens
         };
         const users = inheritedAuth?.users;
+        // Idempotent transactions are not commited/rolled back, so they don't need to be held.
+        if (this._idempotent) {
+            const status = await this.trxEngine.trx(fn, id, tokens, users, this._origin, this._idempotent);
+            return {
+                id: status.id,
+                status,
+                commit: () => Promise.resolve(),
+                rollback: () => Promise.resolve(),
+            };
+        }
         return this.trxEngine.trx_hold(fn, id, tokens, users);
     }
 }

package/lib/engine/data/tree.d.ts

@@ -13,7 +13,6 @@ export declare class Tree {
      *
      * @deprecated Fieldpath was consolidated into Modelpath and Querypath.
      */
-    static get(obj: Record<string, any>, fieldpath: string, index?: '*' | 0 | (number | string)[]): any;
-    static getModelpath(obj: Record<string, any>, modelpath: string, index: (string | number)[]): any[];
+    static get(obj: Record<string, any>, fieldpath: string): any;
     static set(obj: Record<string, any>, fieldpath: string, replacer: (v: any, i: (number | string)[]) => any, __index?: (number | string)[]): void;
 }

package/lib/engine/data/tree.js

@@ -4,7 +4,6 @@
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tree = void 0;
-const error_1 = require("./error");
 /**
  * @category Engine
  * @subcategory Data
@@ -20,112 +19,25 @@ class Tree {
      *
      * @deprecated Fieldpath was consolidated into Modelpath and Querypath.
      */
-    static get(obj, fieldpath, index = '*') {
-        index = (!Array.isArray(index)) ? index : [...index];
+    static get(obj, fieldpath) {
+        if (!fieldpath.includes('.'))
+            return obj[fieldpath];
         const paths = fieldpath.split('.');
-        const pathIndexCount = paths.filter(p => p === '#').length;
-        if (Array.isArray(index) && pathIndexCount > index.length) {
-            throw error_1.NesoiError.Bucket.Fieldpath.InvalidIndexLength({ fieldpath, index });
-        }
         let ref = obj;
         for (let i = 0; i < paths.length; i++) {
             const path = paths[i];
-            if (path === '#') {
-                // 0 index, read the first item from the list
-                if (index === 0) {
-                    // This is a TypeAsObj, stay on the node
-                    if (typeof ref === 'object' && '__array' in ref) {
-                        // 
-                    }
-                    else {
-                        if (typeof ref !== 'object') {
-                            return undefined;
-                        }
-                        if (Array.isArray(ref)) {
-                            ref = ref[0];
-                        }
-                        else {
-                            ref = ref[Object.keys(ref)[0]];
-                        }
-                    }
-                }
-                // Null index, return a list of all items
-                else if (index === '*') {
-                    if (typeof ref !== 'object') {
-                        return undefined;
-                    }
-                    if (!Array.isArray(ref)) {
-                        ref = Object.values(ref);
-                    }
-                    const childPath = paths.slice(i + 1);
-                    if (childPath.length === 0) {
-                        return ref;
-                    }
-                    const out = [];
-                    ref.forEach((v) => {
-                        const deep = this.get(v, childPath.join('.'), '*');
-                        if (deep !== undefined)
-                            out.push(deep);
-                    });
-                    return out.flat(1);
-                }
-                // List of indices, advance on it
-                else {
-                    const idx = index.shift();
-                    if (idx === undefined) {
-                        return undefined;
-                    }
-                    ref = ref[idx];
-                }
-            }
-            else {
-                ref = ref?.[path];
-            }
+            ref = ref?.[path];
             if (ref === undefined) {
-                return ref;
+                return undefined;
             }
         }
         // When reading from a TypeAsObj,
         // advance on unions
         if (!ref && '__or' in obj) {
-            return this.get(obj.__or, fieldpath, index);
+            return this.get(obj.__or, fieldpath);
         }
         return ref;
     }
-    static getModelpath(obj, modelpath, index) {
-        const paths = modelpath.split('.');
-        let poll = [obj];
-        while (poll.length) {
-            const next = [];
-            for (const item of poll) {
-                const path = paths[item.i];
-                // '*'
-                if (path === '*') {
-                    if (typeof item !== 'object') {
-                        throw new Error(`Can't read *, item is not object (${item})`);
-                    }
-                    next.push(...Object.values(item));
-                }
-                else {
-                    const idx_str = path.match(/^\$(\d+)/)?.[1];
-                    let _path = path;
-                    // $0, $1..
-                    if (idx_str !== undefined) {
-                        const idx = parseInt(idx_str);
-                        if (idx >= index.length) {
-                            throw new Error(`Can't read $${idx}, too few indexes (${index.length})`);
-                        }
-                        _path = index[idx];
-                    }
-                    const n = typeof item === 'object' ? item[_path] : undefined;
-                    if (n)
-                        next.push(n);
-                }
-            }
-            poll = next;
-        }
-        return poll;
-    }
     static set(obj, fieldpath, replacer, __index = []) {
         const paths = fieldpath.split('.');
         class Ptr {

package/lib/engine/transaction/nodes/bucket.trx_node.d.ts

@@ -20,7 +20,7 @@ export declare class BucketTrxNode<M extends $Module, $ extends $Bucket> {
     private bucket?;
     constructor(trx: TrxNode<any, M, any>, tag: Tag);
     get no_tenancy(): this;
-    wrap(action: string, input: Record<string, any>, fn: (trx: AnyTrxNode, element: Bucket<M, $>) => Promise<any>, fmtTrxOut?: (out: any) => any): Promise<any>;
+    wrap(action: string, input: Record<string, any>, fn: (trx: AnyTrxNode, element: Bucket<M, $>) => Promise<any>, fmtTrxOut?: (out: any) => any, idempotent?: boolean): Promise<any>;
     /**
      * Returns one object by `id`, without pre-formatting,
      * or `undefined` if the object was not found.