nesoi 3.0.0

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

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControllerBuilder = exports.ControllerDomainBuilder = exports.ControllerGroupBuilder = exports.ControllerEndpointBuilder = void 0;
+const controller_schema_1 = require("./controller.schema");
+const dependency_1 = require("../../../engine/dependency");
+class ControllerEndpointBuilder {
+    constructor(module, name) {
+        this.module = module;
+        this.name = name;
+        this._authn = [];
+        this._tags = [];
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    authn(providers) {
+        if (!Array.isArray(providers)) {
+            providers = [providers];
+        }
+        this._authn = providers;
+        return this;
+    }
+    tag(tag) {
+        this._tags.push(tag);
+        return this;
+    }
+    tags(tags) {
+        this._tags.push(...tags);
+        return this;
+    }
+    msg(msg) {
+        this._msg = new dependency_1.$Dependency(this.module, 'message', msg);
+        return this;
+    }
+    toJob(job) {
+        this._target = new dependency_1.$Dependency(this.module, 'job', job);
+        return this;
+    }
+    toResource(resource) {
+        this._target = new dependency_1.$Dependency(this.module, 'resource', resource);
+        return this;
+    }
+    toMachine(machine) {
+        this._target = new dependency_1.$Dependency(this.module, 'machine', machine);
+        return this;
+    }
+    static build(builder) {
+        return new controller_schema_1.$ControllerEndpoint(builder.name, builder._alias || builder.name, builder._authn, builder._tags, builder._msg, builder._target);
+    }
+}
+exports.ControllerEndpointBuilder = ControllerEndpointBuilder;
+class ControllerGroupBuilder {
+    constructor(module, name) {
+        this.module = module;
+        this.name = name;
+        this._authn = [];
+        this.groups = {};
+        this.endpoints = {};
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    authn(providers) {
+        if (!Array.isArray(providers)) {
+            providers = [providers];
+        }
+        this._authn = providers;
+        return this;
+    }
+    endpoint(name, $) {
+        const builder = new ControllerEndpointBuilder(this.module, name);
+        $(builder);
+        this.endpoints[name] = builder;
+        return this;
+    }
+    group(name, $) {
+        const builder = new ControllerGroupBuilder(this.module, name);
+        $(builder);
+        this.groups[name] = builder;
+        return this;
+    }
+    static build(builder) {
+        const endpoints = this.buildEndpoints(builder.endpoints);
+        const groups = this.buildGroups(builder.groups);
+        return new controller_schema_1.$ControllerGroup(builder.name, builder._alias || builder.name, builder._authn, groups, endpoints);
+    }
+    static buildGroups(builders) {
+        const groups = {};
+        for (const g in builders) {
+            const group = builders[g];
+            groups[g] = this.build(group);
+        }
+        return groups;
+    }
+    static buildEndpoints(builders) {
+        const endpoints = {};
+        for (const g in builders) {
+            const endpoint = builders[g];
+            endpoints[g] = ControllerEndpointBuilder.build(endpoint);
+        }
+        return endpoints;
+    }
+}
+exports.ControllerGroupBuilder = ControllerGroupBuilder;
+class ControllerDomainBuilder extends ControllerGroupBuilder {
+    constructor() {
+        super(...arguments);
+        this._version = 'v1';
+    }
+    version(version) {
+        this._version = version;
+        return this;
+    }
+    static build(builder) {
+        const group = ControllerGroupBuilder.build(builder);
+        return new controller_schema_1.$ControllerDomain(group.name, group.alias, group.authn, builder._version, group.groups, group.endpoints);
+    }
+}
+exports.ControllerDomainBuilder = ControllerDomainBuilder;
+class ControllerBuilder {
+    constructor(module, name) {
+        this.module = module;
+        this.name = name;
+        this.$b = 'controller';
+        this._authn = [];
+        this.domains = {};
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    authn(providers) {
+        if (!Array.isArray(providers)) {
+            providers = [providers];
+        }
+        this._authn = providers;
+        return this;
+    }
+    domain(name, $) {
+        const builder = new ControllerDomainBuilder(this.module, name);
+        $(builder);
+        const version = builder._version;
+        this.domains[name + '.' + version] = builder;
+        return this;
+    }
+    // Build
+    static build(node) {
+        const domains = this.buildDomains(node.builder.domains);
+        const input = Object.values(domains)
+            .map(domain => this.buildInput(domain))
+            .flat();
+        node.schema = new controller_schema_1.$Controller(node.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, domains);
+        return node.schema;
+    }
+    static buildInput(group) {
+        const input = [];
+        for (const e in group.endpoints) {
+            const endpoint = group.endpoints[e];
+            input.push(endpoint.msg);
+        }
+        for (const e in group.groups) {
+            const groupInput = this.buildInput(group.groups[e]);
+            input.push(...groupInput);
+        }
+        return input;
+    }
+    static buildDomains(builders) {
+        const domains = {};
+        for (const g in builders) {
+            const domain = builders[g];
+            domains[g] = ControllerDomainBuilder.build(domain);
+        }
+        return domains;
+    }
+}
+exports.ControllerBuilder = ControllerBuilder;

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

@@ -0,0 +1,6 @@
+import { ControllerAdapter } from './adapters/controller_adapter';
+import { $Controller } from './controller.schema';
+export type ControllerConfig<B extends $Controller, Providers extends Record<string, any>> = {
+    /** Adapter used by this Controller to communicate with a data source */
+    adapter?: (schema: B, providers: Providers) => ControllerAdapter;
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,22 @@
+import { $Module, $Space } from "../../../schema";
+import { Module } from "../../../engine/module";
+import { $Controller, $ControllerEndpoint } from './controller.schema';
+import { ControllerAdapter } from './adapters/controller_adapter';
+import { ControllerConfig } from './controller.config';
+import { AnyDaemon } from "../../../engine/daemon";
+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>>;
+}
+export declare class Controller<S extends $Space, M extends $Module, $ extends $Controller> {
+    schema: $;
+    config?: ControllerConfig<$, any> | undefined;
+    providers: Record<string, any>;
+    adapter: ControllerAdapter;
+    constructor(module: Module<S, M>, schema: $, config?: ControllerConfig<$, any> | undefined, providers?: Record<string, any>);
+    bind(daemon: AnyDaemon): void;
+}
+export type AnyController = Controller<any, any, any>;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = exports.ControllerEndpoint = void 0;
+const cli_controller_adapter_1 = require("./adapters/cli.controller_adapter");
+class ControllerEndpoint {
+    constructor(schema, adapter, path) {
+        this.schema = schema;
+        this.adapter = adapter;
+        this.path = path;
+    }
+    invoke(data) {
+        const raw = {
+            ...data,
+            $: this.schema.msg.name
+        };
+        return this.adapter.trx(async ($) => {
+            if (this.schema.target.type === 'job') {
+                return $.job(this.schema.target.refName).run(raw);
+            }
+            if (this.schema.target.type === 'resource') {
+                return $.resource(this.schema.target.refName).run(raw);
+            }
+            if (this.schema.target.type === 'machine') {
+                return $.machine(this.schema.target.refName).run(raw);
+            }
+        });
+    }
+}
+exports.ControllerEndpoint = ControllerEndpoint;
+class Controller {
+    constructor(module, schema, config, providers = {}) {
+        this.schema = schema;
+        this.config = config;
+        this.providers = providers;
+        this.adapter = config?.adapter?.(schema, providers) || new cli_controller_adapter_1.CLIControllerAdapter(schema);
+    }
+    bind(daemon) {
+        this.adapter.bind(daemon);
+    }
+}
+exports.Controller = Controller;

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

@@ -0,0 +1,44 @@
+import { $Message } from "../../entities/message/message.schema";
+import { AnyUsers } from "../../../engine/auth/authn";
+import { $Dependency } from "../../../engine/dependency";
+export declare class $ControllerEndpoint {
+    name: string;
+    alias: string;
+    authn: string[];
+    tags: string[];
+    msg: $Dependency;
+    target: $Dependency;
+    $t: string;
+    constructor(name: string, alias: string, authn: string[], tags: string[], msg: $Dependency, target: $Dependency);
+}
+export declare class $ControllerGroup {
+    name: string;
+    alias: string;
+    authn: string[];
+    groups: Record<string, $ControllerGroup>;
+    endpoints: Record<string, $ControllerEndpoint>;
+    $t: string;
+    constructor(name: string, alias: string, authn: string[], groups?: Record<string, $ControllerGroup>, endpoints?: Record<string, $ControllerEndpoint>);
+}
+export declare class $ControllerDomain extends $ControllerGroup {
+    name: string;
+    alias: string;
+    authn: string[];
+    version: string;
+    groups: Record<string, $ControllerGroup>;
+    endpoints: Record<string, $ControllerEndpoint>;
+    $t: string;
+    constructor(name: string, alias: string, authn: string[], version: string, groups?: Record<string, $ControllerGroup>, endpoints?: Record<string, $ControllerEndpoint>);
+}
+export declare class $Controller {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    input: $Dependency[];
+    domains: Record<string, $ControllerDomain>;
+    $t: "controller";
+    '#authn': AnyUsers;
+    '#input': $Message;
+    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], domains?: Record<string, $ControllerDomain>);
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Controller = exports.$ControllerDomain = exports.$ControllerGroup = exports.$ControllerEndpoint = void 0;
+class $ControllerEndpoint {
+    constructor(name, alias, authn, tags, msg, target) {
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.tags = tags;
+        this.msg = msg;
+        this.target = target;
+        this.$t = 'controller.endpoint';
+    }
+}
+exports.$ControllerEndpoint = $ControllerEndpoint;
+class $ControllerGroup {
+    constructor(name, alias, authn, groups = {}, endpoints = {}) {
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.groups = groups;
+        this.endpoints = endpoints;
+        this.$t = 'controller.group';
+    }
+}
+exports.$ControllerGroup = $ControllerGroup;
+class $ControllerDomain extends $ControllerGroup {
+    constructor(name, alias, authn, version, groups = {}, endpoints = {}) {
+        super(name, alias, authn, groups, endpoints);
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.version = version;
+        this.groups = groups;
+        this.endpoints = endpoints;
+        this.$t = 'controller.domain';
+    }
+}
+exports.$ControllerDomain = $ControllerDomain;
+class $Controller {
+    constructor(module, name, alias, authn, input, domains = {}) {
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.input = input;
+        this.domains = domains;
+        this.$t = 'controller';
+    }
+}
+exports.$Controller = $Controller;

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

@@ -0,0 +1,107 @@
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { NesoiObj, NewOrOldObj } 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 { $Bucket } from "../../..";
+export type BucketAdapterConfig = {
+    updatedAtField: string;
+};
+export declare abstract class BucketAdapter<Obj extends NesoiObj> {
+    protected schema: $Bucket;
+    protected nql: NQLRunner;
+    protected config: BucketAdapterConfig;
+    constructor(schema: $Bucket, nql: NQLRunner, config?: Partial<BucketAdapterConfig>);
+    /**
+     * **Dangerous!**
+     * This should only be used on inner adapters of bucket caches.
+     * Be extremely careful when implementing this on permanent storage adapters.
+     */
+    protected abstract deleteEverything(trx: AnyTrxNode): Promise<void>;
+    /**
+     * Return one entity by ID
+     */
+    abstract get(trx: AnyTrxNode, id: Obj['id']): Promise<undefined | Obj>;
+    /**
+     * Return all entities
+     */
+    abstract index(trx: AnyTrxNode): Promise<Obj[]>;
+    /**
+     * Return the results of a query
+     */
+    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[]>;
+    /**
+     * Create/update an entity and return it.
+     *
+     * - If the `obj` has an `id` property, it's a **replace**.
+     * - If not, it's a **create**.
+     */
+    abstract put(trx: AnyTrxNode, obj: NewOrOldObj<Obj>): Promise<Obj>;
+    /**
+     * Create/update 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**.
+     */
+    abstract putMany(trx: AnyTrxNode, objs: NewOrOldObj<Obj>[]): Promise<Obj[]>;
+    /**
+     * Delete an entity by ID
+     */
+    abstract delete(trx: AnyTrxNode, id: Obj['id']): Promise<void>;
+    /**
+     * 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'
+     * - If it does, check if it changed since lastObjUpdateEpoch
+     *      - If yes, return the updated object
+     *      - If not, return null
+     * @returns
+     *  - null: Object hasn't changed
+     *  - Obj: Object has changed
+     *  - 'deleted': Object was deleted
+     */
+    abstract syncOne(trx: AnyTrxNode, id: Obj['id'], lastObjUpdateEpoch: number): Promise<null | 'deleted' | BucketCacheSync<Obj>>;
+    /**
+     * Given an id, if the object was not deleted and has changed on source,
+     * sync the object and all objects of this bucket updated before it.
+     * @returns
+     *  - null: Object hasn't changed
+     *  - Obj[]: Object or past objects changed
+     *  - 'deleted': Object was deleted
+     */
+    abstract syncOneAndPast(trx: AnyTrxNode, id: Obj['id'], lastUpdateEpoch: number): Promise<null | 'deleted' | BucketCacheSync<Obj>[]>;
+    /**
+     * Resync the entire cache.
+     * - Hash the ids, check if it matches the incoming hash
+     *   - If yes, read all data that changed since last time
+     *   - If not, read all data and return a hard resync (previous data will be wiped)
+     @returns
+     *  - null: Cache hasn't changed
+     *  - { data: Obj[], hash: string, hard: true }: Cache has changed
+     */
+    abstract syncAll(trx: AnyTrxNode, lastHash?: string, lastUpdateEpoch?: number): Promise<null | {
+        sync: BucketCacheSync<Obj>[];
+        hash: string;
+        updateEpoch: number;
+        reset: boolean;
+    }>;
+    /**
+     * Returns a scope string, used to optimize queries.
+     * Should be the same for adapters that can be queried together.
+     */
+    abstract getQueryMeta(): {
+        scope: string;
+        avgTime: number;
+    };
+}
+export type AnyBucketAdapter = BucketAdapter<any>;

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

@@ -0,0 +1,41 @@
+"use strict";
+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'
+        };
+    }
+    /**
+     * Return the results of a query
+     */
+    async query(trx, query, pagination, 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);
+        if (config?.metadataOnly) {
+            return results.map(obj => ({
+                id: obj.id,
+                [this.config.updatedAtField]: this.getUpdateEpoch(obj)
+            }));
+        }
+        return results;
+    }
+    /* Cache Operations */
+    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 = datetime_1.NesoiDatetime.fromISO(objUpdateStr);
+        return objUpdate.epoch;
+    }
+}
+exports.BucketAdapter = BucketAdapter;

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

@@ -0,0 +1,37 @@
+import { BucketAdapter, BucketAdapterConfig } from './bucket_adapter';
+import { NesoiObj, NewOrOldObj } 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);
+    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[]>;
+    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;
+        }[];
+        hash: string;
+        updateEpoch: number;
+        reset: boolean;
+    } | null>;
+}

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryBucketAdapter = void 0;
+const bucket_adapter_1 = require("./bucket_adapter");
+const crypto_1 = require("crypto");
+const memory_nql_1 = require("./memory.nql");
+class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
+    constructor(schema, data = {}, config) {
+        const nql = new memory_nql_1.MemoryNQLRunner();
+        super(schema, nql, config);
+        this.schema = schema;
+        this.data = data;
+        nql.bind(this);
+    }
+    getQueryMeta() {
+        return {
+            scope: `memory.${this.schema.name}`,
+            avgTime: 10
+        };
+    }
+    /* Dangerous, used on cache only */
+    deleteEverything(trx) {
+        this.data = {};
+        return Promise.resolve();
+    }
+    /* Read operations */
+    index(trx) {
+        const objs = Object.values(this.data);
+        return Promise.resolve(objs);
+    }
+    get(trx, id) {
+        return Promise.resolve(this.data[id]);
+    }
+    /* Write Operations */
+    async put(trx, obj) {
+        if (!obj.id) {
+            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);
+    }
+    putMany(trx, objs) {
+        return Promise.all(objs.map(obj => this.put(trx, obj)));
+    }
+    delete(trx, id) {
+        delete this.data[id];
+        return Promise.resolve();
+    }
+    deleteMany(trx, ids) {
+        for (const id of ids) {
+            delete this.data[id];
+        }
+        return Promise.resolve();
+    }
+    /* Cache Operations */
+    async syncOne(trx, id, lastObjUpdateEpoch) {
+        // 1. Check if object was deleted
+        const obj = await this.get(trx, id);
+        if (!obj) {
+            return 'deleted';
+        }
+        // 2. Check if object was updated
+        const updateEpoch = this.getUpdateEpoch(obj);
+        const hasObjUpdated = updateEpoch > lastObjUpdateEpoch;
+        if (!hasObjUpdated) {
+            return null;
+        }
+        // 3. Return updated object and epoch
+        return {
+            obj,
+            updateEpoch
+        };
+    }
+    async syncOneAndPast(trx, id, lastUpdateEpoch) {
+        // 1. Check if object was deleted
+        const obj = await this.get(trx, id);
+        if (!obj) {
+            return 'deleted';
+        }
+        // 2. Check if object was updated
+        const objUpdateEpoch = this.getUpdateEpoch(obj);
+        const hasObjUpdated = objUpdateEpoch > lastUpdateEpoch;
+        if (!hasObjUpdated) {
+            return null;
+        }
+        // 3. Return all objects updated and the max epoch
+        let updateEpoch = 0;
+        const changed = Object.values(this.data)
+            .map(obj => {
+            const epoch = this.getUpdateEpoch(obj);
+            if (epoch > updateEpoch) {
+                updateEpoch = epoch;
+            }
+            return { obj, updateEpoch: epoch };
+        })
+            .filter(obj => obj.updateEpoch > lastUpdateEpoch);
+        if (!changed.length) {
+            return null;
+        }
+        return changed;
+    }
+    async syncAll(trx, lastHash, lastUpdateEpoch = 0) {
+        // 1. Hash the current ids
+        const idStr = Object.keys(this.data).sort().join('');
+        const hash = (0, crypto_1.createHash)('md5').update(idStr).digest('hex');
+        // 2. If hash changed, return a reset sync with all objects
+        if (hash !== lastHash) {
+            let updateEpoch = 0;
+            const sync = (await this.index(trx))
+                .map(obj => {
+                const epoch = this.getUpdateEpoch(obj);
+                if (epoch > updateEpoch) {
+                    updateEpoch = epoch;
+                }
+                return { obj, updateEpoch: epoch };
+            });
+            return {
+                sync,
+                hash,
+                updateEpoch,
+                reset: true
+            };
+        }
+        // 3. Find the data that changed and return it
+        let updateEpoch = 0;
+        const sync = Object.values(this.data)
+            .map(obj => {
+            const epoch = this.getUpdateEpoch(obj);
+            if (epoch > updateEpoch) {
+                updateEpoch = epoch;
+            }
+            return { obj, updateEpoch: epoch };
+        })
+            .filter(obj => obj.updateEpoch > lastUpdateEpoch);
+        if (!sync.length) {
+            return null;
+        }
+        return {
+            sync,
+            hash,
+            updateEpoch,
+            reset: false
+        };
+    }
+}
+exports.MemoryBucketAdapter = MemoryBucketAdapter;