nesoi 3.0.0 → 3.0.3

package/lib/elements/blocks/resource/resource.js

@@ -87,7 +87,11 @@ class Resource extends block_1.Block {
     static query($) {
         const scope = $.job.scope;
         return $.trx.bucket(scope.bucket)
-            .query($.msg.query).all();
+            .query($.msg.query).page({
+            page: $.msg.page,
+            perPage: $.msg.perPage,
+            count: true
+        });
     }
     static create($) {
         const scope = $.job.scope;
@@ -101,25 +105,30 @@ class Resource extends block_1.Block {
     }
     static delete($) {
         const scope = $.job.scope;
-        if (!$.obj) {
-            return;
-        }
         return $.trx.bucket(scope.bucket)
-            .deleteOrFail($.obj.id);
+            .delete($.obj.id);
     }
     // Custom assertions
-    static async assertThat(trx, bucket, obj, type, arg) {
-        if (type === 'query is empty') {
-            return !(await trx.bucket(bucket.refName)
-                .query(arg)
-                .first());
-        }
-        if (type === 'has no link') {
-            if (!obj)
-                return true;
-            return !(await trx.bucket(bucket.refName)
-                .hasLink(obj.id, arg));
-        }
+    static assertThat(trx, bucket, obj, type, arg) {
+        return {
+            else: async (error) => {
+                let out = false;
+                if (type === 'query is empty') {
+                    out = !(await trx.bucket(bucket.refName)
+                        .query(arg)
+                        .first());
+                }
+                else if (type === 'has no link') {
+                    if (!obj)
+                        out = true;
+                    else {
+                        out = !(await trx.bucket(bucket.refName)
+                            .hasLink(obj.id, arg));
+                    }
+                }
+                return out || error;
+            }
+        };
     }
 }
 exports.Resource = Resource;

package/lib/elements/edge/controller/adapters/controller_adapter.d.ts

@@ -1,12 +1,13 @@
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from '../controller.schema';
 import { AnyDaemon } from "../../../../engine/daemon";
+import { AuthnRequest } from "../../../../engine/auth/authn";
 export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
 export declare abstract class ControllerAdapter {
     protected schema: $Controller;
     protected daemon?: AnyDaemon;
     constructor(schema: $Controller);
-    trx(fn: (trx: AnyTrxNode) => Promise<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
+    trx(fn: (trx: AnyTrxNode) => Promise<any>, authn?: AuthnRequest<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
     bind(daemon: AnyDaemon): void;
     protected abstract makeEndpoint(path: string, schema: $ControllerEndpoint): void;
     protected makeGroup(group: $ControllerGroup, root?: ControllerEndpointPath): void;

package/lib/elements/edge/controller/adapters/controller_adapter.js

@@ -1,15 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerAdapter = void 0;
+const log_1 = require("../../../../engine/util/log");
 class ControllerAdapter {
     constructor(schema) {
         this.schema = schema;
     }
-    trx(fn) {
+    async trx(fn, authn) {
         if (!this.daemon) {
             throw new Error('Controller not bound to a daemon');
         }
-        return this.daemon.trx(this.schema.module).run(fn);
+        try {
+            return await this.daemon.trx(this.schema.module)
+                .authn(authn)
+                .run(fn);
+        }
+        catch (e) {
+            log_1.Log.error('controller', this.schema.name, 'Unknown error', e);
+            throw e;
+        }
     }
     bind(daemon) {
         this.daemon = daemon;

package/lib/elements/edge/controller/controller.builder.d.ts

@@ -14,13 +14,12 @@ type MachinesSupportingMsg<M extends $Module, Msg extends $Message> = {
 export declare class ControllerEndpointBuilder<S extends $Space, M extends $Module, Msg extends $Message = never> {
     private module;
     private name;
-    private _alias?;
-    private _version?;
     private _authn;
+    private _alias?;
     private _tags;
     private _msg;
     private _target;
-    constructor(module: string, name: string);
+    constructor(module: string, name: string, _authn?: string[]);
     as(alias: string): this;
     authn<U extends keyof S['authnUsers']>(providers: U | U[]): this;
     tag(tag: string): this;
@@ -34,11 +33,11 @@ export declare class ControllerEndpointBuilder<S extends $Space, M extends $Modu
 export declare class ControllerGroupBuilder<S extends $Space, M extends $Module> {
     private module;
     protected name: string;
-    protected _alias?: string;
     protected _authn: string[];
+    protected _alias?: string;
     protected groups: Record<string, ControllerGroupBuilder<any, any>>;
     protected endpoints: Record<string, ControllerEndpointBuilder<any, any>>;
-    constructor(module: string, name: string);
+    constructor(module: string, name: string, _authn?: string[]);
     as(alias: string): this;
     authn<U extends keyof S['authnUsers']>(providers: U | U[]): this;
     endpoint(name: string, $: ControllerEndpointDef<S, M>): this;

package/lib/elements/edge/controller/controller.builder.js

@@ -4,10 +4,10 @@ exports.ControllerBuilder = exports.ControllerDomainBuilder = exports.Controller
 const controller_schema_1 = require("./controller.schema");
 const dependency_1 = require("../../../engine/dependency");
 class ControllerEndpointBuilder {
-    constructor(module, name) {
+    constructor(module, name, _authn = []) {
         this.module = module;
         this.name = name;
-        this._authn = [];
+        this._authn = _authn;
         this._tags = [];
     }
     as(alias) {
@@ -51,10 +51,10 @@ class ControllerEndpointBuilder {
 }
 exports.ControllerEndpointBuilder = ControllerEndpointBuilder;
 class ControllerGroupBuilder {
-    constructor(module, name) {
+    constructor(module, name, _authn = []) {
         this.module = module;
         this.name = name;
-        this._authn = [];
+        this._authn = _authn;
         this.groups = {};
         this.endpoints = {};
     }
@@ -70,13 +70,13 @@ class ControllerGroupBuilder {
         return this;
     }
     endpoint(name, $) {
-        const builder = new ControllerEndpointBuilder(this.module, name);
+        const builder = new ControllerEndpointBuilder(this.module, name, this._authn);
         $(builder);
         this.endpoints[name] = builder;
         return this;
     }
     group(name, $) {
-        const builder = new ControllerGroupBuilder(this.module, name);
+        const builder = new ControllerGroupBuilder(this.module, name, this._authn);
         $(builder);
         this.groups[name] = builder;
         return this;
@@ -139,7 +139,7 @@ class ControllerBuilder {
         return this;
     }
     domain(name, $) {
-        const builder = new ControllerDomainBuilder(this.module, name);
+        const builder = new ControllerDomainBuilder(this.module, name, this._authn);
         $(builder);
         const version = builder._version;
         this.domains[name + '.' + version] = builder;

package/lib/elements/edge/controller/controller.d.ts

@@ -4,12 +4,13 @@ import { $Controller, $ControllerEndpoint } from './controller.schema';
 import { ControllerAdapter } from './adapters/controller_adapter';
 import { ControllerConfig } from './controller.config';
 import { AnyDaemon } from "../../../engine/daemon";
+import { AuthnRequest } from "../../../engine/auth/authn";
 export declare class ControllerEndpoint<$ extends $ControllerEndpoint> {
     schema: $;
     adapter: ControllerAdapter;
     path: string;
     constructor(schema: $, adapter: ControllerAdapter, path: string);
-    invoke(data: Record<string, any>): Promise<import("../../../engine/transaction/trx").TrxStatus<any>>;
+    invoke(data: Record<string, any>, authn?: AuthnRequest<any>): Promise<import("../../../engine/transaction/trx").TrxStatus<any>>;
 }
 export declare class Controller<S extends $Space, M extends $Module, $ extends $Controller> {
     schema: $;

package/lib/elements/edge/controller/controller.js

@@ -2,28 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Controller = exports.ControllerEndpoint = void 0;
 const cli_controller_adapter_1 = require("./adapters/cli.controller_adapter");
+const trx_node_1 = require("../../../engine/transaction/trx_node");
 class ControllerEndpoint {
     constructor(schema, adapter, path) {
         this.schema = schema;
         this.adapter = adapter;
         this.path = path;
     }
-    invoke(data) {
+    invoke(data, authn) {
         const raw = {
             ...data,
             $: this.schema.msg.name
         };
-        return this.adapter.trx(async ($) => {
+        return this.adapter.trx(async (trx) => {
+            trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
             if (this.schema.target.type === 'job') {
-                return $.job(this.schema.target.refName).run(raw);
+                return trx.job(this.schema.target.refName).run(raw);
             }
             if (this.schema.target.type === 'resource') {
-                return $.resource(this.schema.target.refName).run(raw);
+                return trx.resource(this.schema.target.refName).run(raw);
             }
             if (this.schema.target.type === 'machine') {
-                return $.machine(this.schema.target.refName).run(raw);
+                return trx.machine(this.schema.target.refName).run(raw);
             }
-        });
+        }, authn);
     }
 }
 exports.ControllerEndpoint = ControllerEndpoint;

package/lib/elements/entities/bucket/adapters/bucket_adapter.d.ts

@@ -1,19 +1,24 @@
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
-import { NesoiObj, NewOrOldObj } from "../../../../engine/data/obj";
+import { NesoiObj, ObjWithOptionalId } from "../../../../engine/data/obj";
 import { BucketCacheSync } from '../cache/bucket_cache';
 import { NQL_AnyQuery, NQL_Pagination } from '../query/nql.schema';
-import { NQLRunner } from '../query/nql_engine';
+import { NQLRunner, NQL_Result } from '../query/nql_engine';
 import { $Bucket } from "../../..";
 export type BucketAdapterConfig = {
-    updatedAtField: string;
+    meta: {
+        created_at: string;
+        created_by: string;
+        updated_at: string;
+        updated_by: string;
+    };
 };
 export declare abstract class BucketAdapter<Obj extends NesoiObj> {
     protected schema: $Bucket;
-    protected nql: NQLRunner;
-    protected config: BucketAdapterConfig;
+    nql: NQLRunner;
+    config: BucketAdapterConfig;
     constructor(schema: $Bucket, nql: NQLRunner, config?: Partial<BucketAdapterConfig>);
     /**
-     * **Dangerous!**
+     * **DANGEROUS!**
      * This should only be used on inner adapters of bucket caches.
      * Be extremely careful when implementing this on permanent storage adapters.
      */
@@ -27,29 +32,50 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
      */
     abstract index(trx: AnyTrxNode): Promise<Obj[]>;
     /**
-     * Return the results of a query
+     * Create an entity and return it
+     *
+     * - This method should throw an exception if the obj `id` already exists
      */
-    query<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, config?: {
-        metadataOnly: MetadataOnly;
-    }): Promise<MetadataOnly extends true ? {
-        id: Obj['id'];
-        [x: string]: any;
-    }[] : Obj[]>;
+    abstract create(trx: AnyTrxNode, obj: ObjWithOptionalId<Obj>): Promise<Obj>;
+    /**
+     * Create many entities and return them
+     */
+    abstract createMany(trx: AnyTrxNode, objs: ObjWithOptionalId<Obj>[]): Promise<Obj[]>;
     /**
-     * Create/update an entity and return it.
+     * Replace an entity and return it.
      *
-     * - If the `obj` has an `id` property, it's a **replace**.
-     * - If not, it's a **create**.
+     * **WARNING**: This method **MUST NOT** replace the `created_by` and `created_at` fields.
      */
-    abstract put(trx: AnyTrxNode, obj: NewOrOldObj<Obj>): Promise<Obj>;
+    abstract replace(trx: AnyTrxNode, obj: Obj): Promise<Obj>;
     /**
-     * Create/update many entities and return them.
+     * Replace many entities and return them
      *
-     * For each `obj` of `objs`:
-     * - If the `obj` has an `id` property, it's a **replace**.
-     * - If not, it's a **create**.
+     * **WARNING**: This method **MUST NOT** replace the `created_by` and `created_at` fields.
      */
-    abstract putMany(trx: AnyTrxNode, objs: NewOrOldObj<Obj>[]): Promise<Obj[]>;
+    abstract replaceMany(trx: AnyTrxNode, objs: Obj[]): Promise<Obj[]>;
+    /**
+     * Patch (modify) an entity and return it
+     */
+    abstract patch(trx: AnyTrxNode, obj: Obj): Promise<Obj>;
+    /**
+     * Patch (modify) many entities and return them
+     */
+    abstract patchMany(trx: AnyTrxNode, objs: Obj[]): Promise<Obj[]>;
+    /**
+     * Put (Create or Replace) an entity and return it.
+     *
+     * - If the object does not contains an `id`, it's a `create`
+     * - If the object contains an `id`, it's a `replace`
+     *
+     * **WARNING**: This method **MUST NOT** replace the `created_by` and `created_at` fields on `replace`.
+     */
+    abstract put(trx: AnyTrxNode, obj: ObjWithOptionalId<Obj>): Promise<Obj>;
+    /**
+     * Put (Create or Replace) many entities and return them
+     *
+     * **WARNING**: This method **MUST NOT** replace the `created_by` and `created_at` fields on `replace`.
+     */
+    abstract putMany(trx: AnyTrxNode, objs: ObjWithOptionalId<Obj>[]): Promise<Obj[]>;
     /**
      * Delete an entity by ID
      */
@@ -58,7 +84,6 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
      * Delete many entities by their IDs
      */
     abstract deleteMany(trx: AnyTrxNode, ids: Obj['id'][]): Promise<void>;
-    getUpdateEpoch(obj: Obj): number;
     /**
      * Given an id, sync that object only.
      * - If the id doesn't exist on the source, return 'deleted'
@@ -103,5 +128,18 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
         scope: string;
         avgTime: number;
     };
+    /**
+     * Return the results of a query
+     */
+    query<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, params?: Record<string, any>, config?: {
+        metadataOnly: MetadataOnly;
+    }): Promise<NQL_Result<MetadataOnly extends true ? {
+        id: Obj['id'];
+        [x: string]: any;
+    }[] : Obj[]>>;
+    /**
+     * Return the epoch of the last update of an object
+     */
+    getUpdateEpoch(obj: Obj): number;
 }
 export type AnyBucketAdapter = BucketAdapter<any>;

package/lib/elements/entities/bucket/adapters/bucket_adapter.js

@@ -3,38 +3,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketAdapter = void 0;
 const trx_node_1 = require("../../../../engine/transaction/trx_node");
 const error_1 = require("../../../../engine/data/error");
-const datetime_1 = require("../../../../engine/data/datetime");
 const nql_compiler_1 = require("../query/nql_compiler");
 class BucketAdapter {
     constructor(schema, nql, config) {
         this.schema = schema;
         this.nql = nql;
         this.config = {
-            updatedAtField: config?.updatedAtField || 'updated_at'
+            meta: {
+                created_at: config?.meta?.created_at || 'created_at',
+                created_by: config?.meta?.created_by || 'created_by',
+                updated_at: config?.meta?.updated_at || 'updated_at',
+                updated_by: config?.meta?.updated_by || 'updated_by'
+            }
         };
     }
+    /* Generic Implementation */
     /**
      * Return the results of a query
      */
-    async query(trx, query, pagination, config) {
+    async query(trx, query, pagination, params, config) {
         const module = trx_node_1.TrxNode.getModule(trx);
-        const compiled = await nql_compiler_1.NQL_Compiler.build(module, this.schema.name, query);
-        const results = await module.nql.run(trx, compiled);
+        const refName = (module.name === this.schema.module
+            ? '' : `${this.schema.module}::`)
+            + this.schema.name;
+        const compiled = await nql_compiler_1.NQL_Compiler.build(module, refName, query);
+        const result = await module.nql.run(trx, compiled, pagination, params);
         if (config?.metadataOnly) {
-            return results.map(obj => ({
+            result.data = result.data.map(obj => ({
                 id: obj.id,
-                [this.config.updatedAtField]: this.getUpdateEpoch(obj)
+                [this.config.meta.updated_at]: this.getUpdateEpoch(obj)
             }));
         }
-        return results;
+        return result;
     }
-    /* Cache Operations */
+    /**
+     * Return the epoch of the last update of an object
+     */
     getUpdateEpoch(obj) {
-        const objUpdateStr = obj[this.config.updatedAtField];
-        if (!objUpdateStr) {
-            throw error_1.NesoiError.Bucket.NoUpdatedAtField({ bucket: 'TODO', id: obj.id, field: this.config.updatedAtField });
+        const objUpdate = obj[this.config.meta.updated_at];
+        if (!objUpdate) {
+            throw error_1.NesoiError.Bucket.NoUpdatedAtField({ bucket: 'TODO', id: obj.id, field: this.config.meta.updated_at });
         }
-        const objUpdate = datetime_1.NesoiDatetime.fromISO(objUpdateStr);
         return objUpdate.epoch;
     }
 }

package/lib/elements/entities/bucket/adapters/memory.bucket_adapter.d.ts

@@ -1,37 +1,36 @@
 import { BucketAdapter, BucketAdapterConfig } from './bucket_adapter';
-import { NesoiObj, NewOrOldObj } from "../../../../engine/data/obj";
+import { ObjWithOptionalId } from "../../../../engine/data/obj";
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 import { $Bucket } from "../../..";
-export declare class MemoryBucketAdapter<Obj extends NesoiObj> extends BucketAdapter<Obj> {
-    schema: $Bucket;
-    data: Record<Obj['id'], Obj>;
-    constructor(schema: $Bucket, data?: Record<Obj['id'], Obj>, config?: BucketAdapterConfig);
+import { BucketCacheSync } from '../cache/bucket_cache';
+export declare class MemoryBucketAdapter<B extends $Bucket, Obj extends B['#data']> extends BucketAdapter<Obj> {
+    schema: B;
+    data: NoInfer<Record<Obj['id'], Obj>>;
+    constructor(schema: B, data?: NoInfer<Record<Obj['id'], Obj>>, config?: BucketAdapterConfig);
     getQueryMeta(): {
         scope: string;
         avgTime: number;
     };
     protected deleteEverything(trx: AnyTrxNode): Promise<void>;
     index(trx: AnyTrxNode): Promise<Obj[]>;
-    get(trx: AnyTrxNode, id: Obj['id']): Promise<Awaited<Record<Obj["id"], Obj>[Obj["id"]]>>;
-    put(trx: AnyTrxNode, obj: NewOrOldObj<Obj>): Promise<any>;
-    putMany(trx: AnyTrxNode, objs: NewOrOldObj<Obj>[]): Promise<any[]>;
+    get(trx: AnyTrxNode, id: Obj['id']): Promise<Obj | undefined>;
+    create(trx: AnyTrxNode, obj: ObjWithOptionalId<Obj>): Promise<Obj>;
+    createMany(trx: AnyTrxNode, objs: ObjWithOptionalId<Obj>[]): Promise<Obj[]>;
+    replace(trx: AnyTrxNode, obj: ObjWithOptionalId<Obj>): Promise<Obj>;
+    replaceMany(trx: AnyTrxNode, objs: ObjWithOptionalId<Obj>[]): Promise<Obj[]>;
+    patch(trx: AnyTrxNode, obj: ObjWithOptionalId<Obj>): Promise<Obj>;
+    patchMany(trx: AnyTrxNode, objs: ObjWithOptionalId<Obj>[]): Promise<Obj[]>;
+    put(trx: AnyTrxNode, obj: ObjWithOptionalId<Obj>): Promise<Obj>;
+    putMany(trx: AnyTrxNode, objs: ObjWithOptionalId<Obj>[]): Promise<Obj[]>;
     delete(trx: AnyTrxNode, id: Obj['id']): Promise<void>;
     deleteMany(trx: AnyTrxNode, ids: Obj['id'][]): Promise<void>;
-    syncOne(trx: AnyTrxNode, id: Obj['id'], lastObjUpdateEpoch: number): Promise<"deleted" | {
-        obj: Awaited<Record<Obj["id"], Obj>[Obj["id"]]>;
-        updateEpoch: number;
-    } | null>;
-    syncOneAndPast(trx: AnyTrxNode, id: Obj['id'], lastUpdateEpoch: number): Promise<"deleted" | {
-        obj: Obj;
-        updateEpoch: number;
-    }[] | null>;
-    syncAll(trx: AnyTrxNode, lastHash?: string, lastUpdateEpoch?: number): Promise<{
-        sync: {
-            obj: Obj;
-            updateEpoch: number;
-        }[];
+    syncOne(trx: AnyTrxNode, id: Obj['id'], lastObjUpdateEpoch: number): Promise<null | 'deleted' | BucketCacheSync<Obj>>;
+    syncOneAndPast(trx: AnyTrxNode, id: Obj['id'], lastUpdateEpoch: number): Promise<null | 'deleted' | BucketCacheSync<Obj>[]>;
+    syncAll(trx: AnyTrxNode, lastHash?: string, lastUpdateEpoch?: number): Promise<null | {
+        sync: BucketCacheSync<Obj>[];
         hash: string;
         updateEpoch: number;
         reset: boolean;
-    } | null>;
+    }>;
 }
+export type AnyMemoryBucketAdapter = MemoryBucketAdapter<any, any>;

package/lib/elements/entities/bucket/adapters/memory.bucket_adapter.js

@@ -32,6 +32,59 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         return Promise.resolve(this.data[id]);
     }
     /* Write Operations */
+    async create(trx, obj) {
+        const lastId = (await this.index(trx))
+            .map((obj) => parseInt(obj.id))
+            .sort((a, b) => b - a)[0] || 0;
+        obj.id = lastId + 1;
+        this.data[obj.id] = obj;
+        return Promise.resolve(obj);
+    }
+    async createMany(trx, objs) {
+        const out = [];
+        for (const obj of objs) {
+            out.push(await this.create(trx, obj));
+        }
+        return out;
+    }
+    async replace(trx, obj) {
+        if (!obj.id || !this.data[obj.id]) {
+            throw new Error(`Object with id ${obj.id} not found for replace`);
+        }
+        this.data[obj.id] = obj;
+        return Promise.resolve(obj);
+    }
+    replaceMany(trx, objs) {
+        const out = [];
+        for (const obj of objs) {
+            if (!obj.id || !this.data[obj.id]) {
+                throw new Error(`Object with id ${obj.id} not found for replace`);
+            }
+            this.data[obj.id] = obj;
+            out.push(obj);
+        }
+        return Promise.resolve(out);
+    }
+    async patch(trx, obj) {
+        if (!obj.id || !this.data[obj.id]) {
+            throw new Error(`Object with id ${obj.id} not found for patch`);
+        }
+        // TODO: Implement patch
+        this.data[obj.id] = obj;
+        return Promise.resolve(obj);
+    }
+    patchMany(trx, objs) {
+        const out = [];
+        for (const obj of objs) {
+            if (!obj.id || !this.data[obj.id]) {
+                throw new Error(`Object with id ${obj.id} not found for patch`);
+            }
+            // TODO: Implement patch
+            this.data[obj.id] = obj;
+            out.push(obj);
+        }
+        return Promise.resolve(out);
+    }
     async put(trx, obj) {
         if (!obj.id) {
             const lastId = (await this.index(trx))
@@ -42,8 +95,21 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         this.data[obj.id] = obj;
         return Promise.resolve(obj);
     }
-    putMany(trx, objs) {
-        return Promise.all(objs.map(obj => this.put(trx, obj)));
+    async putMany(trx, objs) {
+        const lastId = (await this.index(trx))
+            .map((obj) => parseInt(obj.id))
+            .sort((a, b) => b - a)[0] || 0;
+        let id = lastId + 1;
+        const out = [];
+        for (const obj of objs) {
+            if (!obj.id) {
+                obj.id = id;
+            }
+            this.data[obj.id] = obj;
+            out.push(obj);
+            id++;
+        }
+        return Promise.resolve(out);
     }
     delete(trx, id) {
         delete this.data[id];

package/lib/elements/entities/bucket/adapters/memory.nql.d.ts

@@ -1,14 +1,18 @@
 import { NQLRunner } from '../query/nql_engine';
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
-import { NQL_Part } from '../query/nql.schema';
-import { MemoryBucketAdapter } from "../../..";
+import { NQL_Pagination, NQL_Part } from '../query/nql.schema';
+import { AnyMemoryBucketAdapter } from './memory.bucket_adapter';
 type Obj = Record<string, any>;
-type Objs = Record<string, Obj>;
 export declare class MemoryNQLRunner extends NQLRunner {
-    protected adapter?: MemoryBucketAdapter<any>;
+    protected adapter?: AnyMemoryBucketAdapter;
     constructor();
-    bind(adapter: MemoryBucketAdapter<any>): void;
-    run(trx: AnyTrxNode, part: NQL_Part, params: Obj): Promise<Objs>;
+    bind(adapter: AnyMemoryBucketAdapter): void;
+    run(trx: AnyTrxNode, part: NQL_Part, params: Obj, pagination?: NQL_Pagination): Promise<{
+        data: any[];
+        count: number | undefined;
+        page: number | undefined;
+        perPage: number | undefined;
+    }>;
     /**
      * Goes through each rule keeping a scoped white and black list to avoid
      * testing objects unnecessarily. Returns a dict of results by id.

package/lib/elements/entities/bucket/adapters/memory.nql.js

@@ -10,12 +10,47 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
     bind(adapter) {
         this.adapter = adapter;
     }
-    async run(trx, part, params) {
+    async run(trx, part, params, pagination) {
         if (!this.adapter) {
             throw new Error('No adapter bound to NQL Runner');
         }
         const data = this.adapter.data;
-        return this.filter(part, data, params);
+        let response;
+        // Empty query, don't filter data
+        if (part.union.inters.length === 0) {
+            response = data;
+        }
+        // Non-empty query
+        else {
+            response = await this.filter(part, data, params);
+        }
+        let output = Object.values(response);
+        if (part.union.order) {
+            const k = part.union.order.dir || this.adapter.config.meta.updated_at;
+            if (part.union.order.dir === 'asc') {
+                output.sort((a, b) => a[k] - b[k]);
+            }
+            else {
+                output.sort((a, b) => b[k] - a[k]);
+            }
+        }
+        let count = undefined;
+        if (pagination) {
+            if (pagination.count) {
+                count = output.length;
+            }
+            if (pagination.page || pagination.perPage) {
+                const a = ((pagination.page || 1) - 1) * (pagination.perPage || 10);
+                const b = a + (pagination.perPage || 10);
+                output = output.slice(a, b);
+            }
+        }
+        return {
+            data: output,
+            count,
+            page: pagination?.page,
+            perPage: pagination?.perPage
+        };
     }
     /**
      * Goes through each rule keeping a scoped white and black list to avoid
@@ -102,7 +137,7 @@ class MemoryNQLRunner extends nql_engine_1.NQLRunner {
                 return false;
             }
             // Fieldpath is a spread, apply rule to each item
-            if (rule.fieldpath.includes('.*')) {
+            if (rule.fieldpath.includes('.#')) {
                 for (const item of fieldValue) {
                     if (_obj(rule, item, params))
                         return true;