nesoi 3.2.9 → 3.3.0

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

@@ -14,7 +14,7 @@ class ControllerEndpoint {
         this.adapter = adapter;
         this.path = path;
     }
-    invoke(data, authn) {
+    invoke(data, auth) {
         const raw = {
             ...data,
             $: this.schema.msg.name
@@ -23,17 +23,17 @@ class ControllerEndpoint {
             Object.assign(raw, this.schema.implicit);
         }
         return this.adapter.trx(async (trx) => {
-            trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
+            await trx_node_1.TrxNode.checkAuth(trx, this.schema.auth);
             if (this.schema.target.type === 'job') {
-                return trx.job(this.schema.target.refName).run(raw);
+                return trx.job(this.schema.target.short).run(raw);
             }
             if (this.schema.target.type === 'resource') {
-                return trx.resource(this.schema.target.refName).run(raw);
+                return trx.resource(this.schema.target.short).run(raw);
             }
             if (this.schema.target.type === 'machine') {
-                return trx.machine(this.schema.target.refName).run(raw);
+                return trx.machine(this.schema.target.short).run(raw);
             }
-        }, authn);
+        }, auth);
     }
 }
 exports.ControllerEndpoint = ControllerEndpoint;
@@ -47,19 +47,19 @@ class ControllerTopic {
         this.adapter = adapter;
         this.path = path;
     }
-    async subscribe(fn, authn) {
-        const response = await this.adapter.trx(trx => {
-            trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
+    async subscribe(fn, auth) {
+        const response = await this.adapter.trx(async (trx) => {
+            await trx_node_1.TrxNode.checkAuth(trx, this.schema.auth);
             return trx.topic(this.schema.name).subscribe(fn);
-        }, authn);
+        }, auth);
         if (response.state === 'error') {
             throw error_1.NesoiError.Controller.SubscribeFailed({ topic: this.schema.alias });
         }
         return response.output;
     }
     async unsubscribe(id) {
-        const response = await this.adapter.trx(trx => {
-            trx_node_1.TrxNode.checkAuthn(trx, this.schema.authn);
+        const response = await this.adapter.trx(async (trx) => {
+            await trx_node_1.TrxNode.checkAuth(trx, this.schema.auth);
             return trx.topic(this.schema.name).unsubscribe(id);
         });
         if (response.state === 'error') {

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

@@ -1,6 +1,7 @@
+import { $BlockAuth } from "../../blocks/block.schema";
 import { $Message } from "../../entities/message/message.schema";
 import { AnyUsers } from "../../../engine/auth/authn";
-import { $Dependency } from "../../../engine/dependency";
+import { Tag } from "../../../engine/dependency";
 /**
  * @category Schemas
  * @subcategory Edge
@@ -8,13 +9,13 @@ import { $Dependency } from "../../../engine/dependency";
 export declare class $ControllerEndpoint {
     name: string;
     alias: string;
-    authn: string[];
+    auth: $BlockAuth[];
     tags: string[];
-    msg: $Dependency;
-    target: $Dependency;
+    msg: Tag;
+    target: Tag;
     implicit?: Record<string, any> | undefined;
     $t: string;
-    constructor(name: string, alias: string, authn: string[], tags: string[], msg: $Dependency, target: $Dependency, implicit?: Record<string, any> | undefined);
+    constructor(name: string, alias: string, auth: $BlockAuth[], tags: string[], msg: Tag, target: Tag, implicit?: Record<string, any> | undefined);
 }
 /**
  * @category Schemas
@@ -23,12 +24,12 @@ export declare class $ControllerEndpoint {
 export declare class $ControllerTopic {
     name: string;
     alias: string;
-    authn: string[];
+    auth: $BlockAuth[];
     tags: string[];
-    msgs: $Dependency[];
-    topic: $Dependency;
+    msgs: Tag[];
+    topic: Tag;
     $t: string;
-    constructor(name: string, alias: string, authn: string[], tags: string[], msgs: $Dependency[], topic: $Dependency);
+    constructor(name: string, alias: string, auth: $BlockAuth[], tags: string[], msgs: Tag[], topic: Tag);
 }
 /**
  * @category Schemas
@@ -37,11 +38,11 @@ export declare class $ControllerTopic {
 export declare class $ControllerGroup {
     name: string;
     alias: string;
-    authn: string[];
+    auth: $BlockAuth[];
     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>);
+    constructor(name: string, alias: string, auth: $BlockAuth[], groups?: Record<string, $ControllerGroup>, endpoints?: Record<string, $ControllerEndpoint>);
 }
 /**
  * @category Schemas
@@ -50,12 +51,12 @@ export declare class $ControllerGroup {
 export declare class $ControllerDomain extends $ControllerGroup {
     name: string;
     alias: string;
-    authn: string[];
+    auth: $BlockAuth[];
     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>);
+    constructor(name: string, alias: string, auth: $BlockAuth[], version: string, groups?: Record<string, $ControllerGroup>, endpoints?: Record<string, $ControllerEndpoint>);
 }
 /**
  * @category Schemas
@@ -65,12 +66,12 @@ export declare class $Controller {
     module: string;
     name: string;
     alias: string;
-    authn: string[];
-    input: $Dependency[];
+    auth: $BlockAuth[];
+    input: Tag[];
     domains: Record<string, $ControllerDomain>;
     topics: Record<string, $ControllerTopic>;
     $t: "controller";
     '#authn': AnyUsers;
     '#input': $Message;
-    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], domains?: Record<string, $ControllerDomain>, topics?: Record<string, $ControllerTopic>);
+    constructor(module: string, name: string, alias: string, auth: $BlockAuth[], input: Tag[], domains?: Record<string, $ControllerDomain>, topics?: Record<string, $ControllerTopic>);
 }

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

@@ -6,10 +6,10 @@ exports.$Controller = exports.$ControllerDomain = exports.$ControllerGroup = exp
  * @subcategory Edge
  */
 class $ControllerEndpoint {
-    constructor(name, alias, authn, tags, msg, target, implicit) {
+    constructor(name, alias, auth, tags, msg, target, implicit) {
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.tags = tags;
         this.msg = msg;
         this.target = target;
@@ -23,10 +23,10 @@ exports.$ControllerEndpoint = $ControllerEndpoint;
  * @subcategory Edge
  */
 class $ControllerTopic {
-    constructor(name, alias, authn, tags, msgs, topic) {
+    constructor(name, alias, auth, tags, msgs, topic) {
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.tags = tags;
         this.msgs = msgs;
         this.topic = topic;
@@ -39,10 +39,10 @@ exports.$ControllerTopic = $ControllerTopic;
  * @subcategory Edge
  */
 class $ControllerGroup {
-    constructor(name, alias, authn, groups = {}, endpoints = {}) {
+    constructor(name, alias, auth, groups = {}, endpoints = {}) {
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.groups = groups;
         this.endpoints = endpoints;
         this.$t = 'controller.group';
@@ -54,11 +54,11 @@ exports.$ControllerGroup = $ControllerGroup;
  * @subcategory Edge
  */
 class $ControllerDomain extends $ControllerGroup {
-    constructor(name, alias, authn, version, groups = {}, endpoints = {}) {
-        super(name, alias, authn, groups, endpoints);
+    constructor(name, alias, auth, version, groups = {}, endpoints = {}) {
+        super(name, alias, auth, groups, endpoints);
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.version = version;
         this.groups = groups;
         this.endpoints = endpoints;
@@ -71,11 +71,11 @@ exports.$ControllerDomain = $ControllerDomain;
  * @subcategory Edge
  */
 class $Controller {
-    constructor(module, name, alias, authn, input, domains = {}, topics = {}) {
+    constructor(module, name, alias, auth, input, domains = {}, topics = {}) {
         this.module = module;
         this.name = name;
         this.alias = alias;
-        this.authn = authn;
+        this.auth = auth;
         this.input = input;
         this.domains = domains;
         this.topics = topics;

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

@@ -1,13 +1,7 @@
 import { $Space } from "../../../schema";
 import { $Externals } from './externals.schema';
 import { ResolvedBuilderNode } from "../../../engine/dependency";
-import { MergeUnion } from "../../../engine/util/type";
-type MergeAllBuckets<Space extends $Space, Module extends keyof Space['modules'], Modules extends $Space['modules'] = Space['modules']> = MergeUnion<{
-    [M in keyof Modules]: {
-        [B in keyof Modules[M]['buckets'] as `${M & string}::${B & string}`]: Modules[M]['buckets'][B];
-    };
-}[keyof Modules]>;
-type ExternalBucketRefName<Space extends $Space, M extends keyof Space['modules'], AllBuckets = MergeAllBuckets<Space, M>> = Exclude<keyof AllBuckets, `${M & string}::${string}` | `${string}::${string}::${string}`>;
+import { ModuleTree } from "../../../engine/tree";
 /**
  * @category Builders
  * @subcategory Edge
@@ -16,23 +10,24 @@ export declare class ExternalsBuilder<Space extends $Space, ModuleName extends k
     private module;
     $b: "externals";
     name: string;
+    private values;
+    private enums;
     private buckets;
     private messages;
     private jobs;
     private machines;
-    private enums;
     constructor(module: string);
-    bucket<M extends keyof Space['modules'], B extends ExternalBucketRefName<Space, ModuleName>>(ref: B): this;
+    value<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['constants']['values']>(ref: `${M & string}::${B & string}`): this;
+    enum<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['constants']['enums']>(ref: `${M & string}::${B & string}`): this;
+    bucket<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['buckets']>(ref: `${M & string}::${B & string}`): this;
     message<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['messages']>(ref: `${M & string}::${B & string}`): this;
     job<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['jobs']>(ref: `${M & string}::${B & string}`): this;
     machine<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['machines']>(ref: `${M & string}::${B & string}`): this;
-    enum<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['constants']['enums']>(ref: `${M & string}::${B & string}`): this;
     static merge(to: AnyExternalsBuilder, from: AnyExternalsBuilder): void;
-    static build(node: ExternalsBuilderNode): $Externals;
+    static build(node: ExternalsBuilderNode, tree: ModuleTree): $Externals;
 }
 export type AnyExternalsBuilder = ExternalsBuilder<any, any>;
-export type ExternalsBuilderNode = ResolvedBuilderNode & {
+export type ExternalsBuilderNode = Omit<ResolvedBuilderNode, 'schema'> & {
     builder: AnyExternalsBuilder;
     schema?: $Externals;
 };
-export {};

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

@@ -12,30 +12,41 @@ class ExternalsBuilder {
         this.module = module;
         this.$b = 'externals';
         this.name = '*';
+        this.values = {};
+        this.enums = {};
         this.buckets = {};
         this.messages = {};
         this.jobs = {};
         this.machines = {};
-        this.enums = {};
+    }
+    value(ref) {
+        const tag = dependency_1.Tag.fromShort('constants.value', ref);
+        this.values[tag.short] = new dependency_1.Dependency(this.module, tag, { build: true, compile: true, runtime: true });
+        return this;
+    }
+    enum(ref) {
+        const tag = dependency_1.Tag.fromShort('constants.enum', ref);
+        this.enums[tag.short] = new dependency_1.Dependency(this.module, tag, { build: true, compile: true, runtime: true });
+        return this;
     }
     bucket(ref) {
-        this.buckets[ref] = new dependency_1.$Dependency(this.module, 'bucket', ref);
+        const tag = dependency_1.Tag.fromShort('bucket', ref);
+        this.buckets[tag.short] = new dependency_1.Dependency(this.module, tag, { build: true, compile: true, runtime: true });
         return this;
     }
     message(ref) {
-        this.messages[ref] = new dependency_1.$Dependency(this.module, 'message', ref);
+        const tag = dependency_1.Tag.fromShort('message', ref);
+        this.messages[tag.short] = new dependency_1.Dependency(this.module, tag, { build: true, compile: true, runtime: true });
         return this;
     }
     job(ref) {
-        this.jobs[ref] = new dependency_1.$Dependency(this.module, 'job', ref);
+        const tag = dependency_1.Tag.fromShort('job', ref);
+        this.jobs[tag.short] = new dependency_1.Dependency(this.module, tag, { build: true, compile: true, runtime: true });
         return this;
     }
     machine(ref) {
-        this.machines[ref] = new dependency_1.$Dependency(this.module, 'machine', ref);
-        return this;
-    }
-    enum(ref) {
-        this.enums[ref] = new dependency_1.$Dependency(this.module, 'enum', ref);
+        const tag = dependency_1.Tag.fromShort('machine', ref);
+        this.machines[tag.short] = new dependency_1.Dependency(this.module, tag, { build: true, compile: true, runtime: true });
         return this;
     }
     static merge(to, from) {
@@ -43,8 +54,29 @@ class ExternalsBuilder {
         Object.assign(to.jobs, from.jobs);
     }
     // Build
-    static build(node) {
-        node.schema = new externals_schema_1.$Externals(node.module, node.builder.buckets, node.builder.messages, node.builder.jobs, node.builder.machines, node.builder.enums);
+    static build(node, tree) {
+        const buckets = Object.entries(node.builder.buckets);
+        const messages = Object.entries(node.builder.messages);
+        const jobs = Object.entries(node.builder.jobs);
+        const machines = Object.entries(node.builder.machines);
+        const enums = Object.entries(node.builder.enums);
+        const values = Object.entries(node.builder.values);
+        // Static Externals
+        const module = tree.modules[node.tag.module];
+        const schema = module.schema;
+        for (const value of values) {
+            const tag = value[1].tag;
+            schema.constants.values[tag.short] = dependency_1.Tag.resolve(tag, tree);
+        }
+        for (const _enum of enums) {
+            const tag = _enum[1].tag;
+            schema.constants.enums[tag.short] = dependency_1.Tag.resolve(tag, tree);
+        }
+        for (const msg of messages) {
+            const tag = msg[1].tag;
+            schema.messages[tag.short] = dependency_1.Tag.resolve(tag, tree);
+        }
+        node.schema = new externals_schema_1.$Externals(node.tag.module, Object.fromEntries(values.map(e => [e[0], e[1].tag])), Object.fromEntries(enums.map(e => [e[0], e[1].tag])), Object.fromEntries(buckets.map(e => [e[0], e[1].tag])), Object.fromEntries(messages.map(e => [e[0], e[1].tag])), Object.fromEntries(jobs.map(e => [e[0], e[1].tag])), Object.fromEntries(machines.map(e => [e[0], e[1].tag])));
         return node.schema;
     }
 }

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

@@ -1,17 +1,18 @@
-import { $Dependency } from "../../../engine/dependency";
+import { Tag } from "../../../engine/dependency";
 /**
  * @category Schemas
  * @subcategory Edge
  */
 export declare class $Externals {
     name: string;
-    buckets: Record<string, $Dependency>;
-    messages: Record<string, $Dependency>;
-    jobs: Record<string, $Dependency>;
-    machines: Record<string, $Dependency>;
-    enums: Record<string, $Dependency>;
+    values: Record<string, Tag>;
+    enums: Record<string, Tag>;
+    buckets: Record<string, Tag>;
+    messages: Record<string, Tag>;
+    jobs: Record<string, Tag>;
+    machines: Record<string, Tag>;
     $t: "externals";
     module: string;
-    constructor(name: string, buckets?: Record<string, $Dependency>, messages?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>, enums?: Record<string, $Dependency>);
+    constructor(name: string, values?: Record<string, Tag>, enums?: Record<string, Tag>, buckets?: Record<string, Tag>, messages?: Record<string, Tag>, jobs?: Record<string, Tag>, machines?: Record<string, Tag>);
     static merge(to: $Externals, from: $Externals): void;
 }

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

@@ -6,22 +6,24 @@ exports.$Externals = void 0;
  * @subcategory Edge
  */
 class $Externals {
-    constructor(name, buckets = {}, messages = {}, jobs = {}, machines = {}, enums = {}) {
+    constructor(name, values = {}, enums = {}, buckets = {}, messages = {}, jobs = {}, machines = {}) {
         this.name = name;
+        this.values = values;
+        this.enums = enums;
         this.buckets = buckets;
         this.messages = messages;
         this.jobs = jobs;
         this.machines = machines;
-        this.enums = enums;
         this.$t = 'externals';
         this.module = this.name;
     }
     static merge(to, from) {
+        Object.assign(to.values, from.values);
+        Object.assign(to.enums, from.enums);
         Object.assign(to.buckets, from.buckets);
         Object.assign(to.messages, from.messages);
         Object.assign(to.jobs, from.jobs);
         Object.assign(to.machines, from.machines);
-        Object.assign(to.enums, from.enums);
     }
 }
 exports.$Externals = $Externals;

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

@@ -0,0 +1,45 @@
+import { ObjWithOptionalId } from "../../../../engine/data/obj";
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { $Bucket } from "../../..";
+import { BucketCacheSync } from '../cache/bucket_cache';
+import { MemoryBucketAdapter } from './memory.bucket_adapter';
+import { BrowserDBService } from './browserdb.service';
+/**
+ * @category Adapters
+ * @subcategory Entity
+ * */
+export declare class BrowserDBBucketAdapter<B extends $Bucket, Obj extends B['#data']> extends MemoryBucketAdapter<B, Obj> {
+    schema: B;
+    service: BrowserDBService;
+    private refName;
+    constructor(schema: B, service: BrowserDBService);
+    getQueryMeta(): {
+        scope: string;
+        avgTime: number;
+    };
+    private trxData;
+    private stage;
+    private flagDelete;
+    private getStore;
+    index(trx: AnyTrxNode): Promise<Obj[]>;
+    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<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;
+    }>;
+}
+export type AnyBrowserDBBucketAdapter = BrowserDBBucketAdapter<any, any>;

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserDBBucketAdapter = void 0;
+const trx_node_1 = require("../../../../engine/transaction/trx_node");
+const memory_bucket_adapter_1 = require("./memory.bucket_adapter");
+const browserdb_service_1 = require("./browserdb.service");
+const trx_1 = require("../../../../engine/transaction/trx");
+/**
+ * @category Adapters
+ * @subcategory Entity
+ * */
+class BrowserDBBucketAdapter extends memory_bucket_adapter_1.MemoryBucketAdapter {
+    constructor(schema, service) {
+        super(schema, undefined, service.config);
+        this.schema = schema;
+        this.service = service;
+        this.refName = `${schema.module}::${schema.name}`;
+    }
+    getQueryMeta() {
+        return {
+            scope: `browserdb.${this.schema.name}`,
+            avgTime: 100
+        };
+    }
+    /* */
+    trxData(trx) {
+        return trx_1.Trx.get(trx, this.service.name + '.trxData');
+    }
+    async stage(trx, objs) {
+        var _a;
+        const trxData = trx_1.Trx.get(trx, this.service.name + '.trxData');
+        if (trxData) {
+            for (const obj of objs) {
+                trxData[_a = this.refName] ?? (trxData[_a] = {});
+                trxData[this.refName][obj.id] = obj;
+            }
+        }
+        else {
+            const module = trx_node_1.TrxNode.getModule(trx);
+            const db = await browserdb_service_1.BrowserDBService.db(this.service, module);
+            const dbTrx = db.transaction(this.refName, 'readwrite');
+            const store = dbTrx.objectStore(this.refName);
+            for (const obj in objs) {
+                store.put(obj);
+            }
+            dbTrx.commit();
+        }
+    }
+    async flagDelete(trx, ids) {
+        var _a;
+        const trxData = trx_1.Trx.get(trx, this.service.name + '.trxData');
+        if (trxData) {
+            for (const id of ids) {
+                trxData[_a = this.refName] ?? (trxData[_a] = {});
+                trxData[this.refName][id] = { __delete: true };
+            }
+        }
+        else {
+            const module = trx_node_1.TrxNode.getModule(trx);
+            const db = await browserdb_service_1.BrowserDBService.db(this.service, module);
+            const dbTrx = db.transaction(this.refName, 'readwrite');
+            const store = dbTrx.objectStore(this.refName);
+            for (const id in ids) {
+                store.delete(id);
+            }
+            dbTrx.commit();
+        }
+    }
+    async getStore(trx, mode) {
+        const module = trx_node_1.TrxNode.getModule(trx);
+        const db = await browserdb_service_1.BrowserDBService.db(this.service, module);
+        const dbTrx = db.transaction(this.refName, mode);
+        return dbTrx.objectStore(this.refName);
+    }
+    /* Read operations */
+    async index(trx) {
+        const store = await this.getStore(trx, 'readonly');
+        const objs = await new Promise((resolve, reject) => {
+            const req = store.getAll();
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = e => reject(e);
+        });
+        this.data = {};
+        for (const obj of objs) {
+            this.data[obj.id] = obj;
+        }
+        Object.assign(this.data, this.trxData(trx));
+        return objs;
+    }
+    async get(trx, id) {
+        const trxData = this.trxData(trx)[this.refName];
+        if (id in trxData) {
+            return trxData[id];
+        }
+        const store = await this.getStore(trx, 'readonly');
+        const obj = await new Promise((resolve, reject) => {
+            const req = store.get(id);
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = e => reject(e);
+        });
+        this.data[obj.id] = obj;
+        return obj;
+    }
+    /* Write Operations */
+    async create(trx, obj) {
+        const _obj = await super.create(trx, obj);
+        await this.stage(trx, [_obj]);
+        return _obj;
+    }
+    async createMany(trx, objs) {
+        const _objs = await super.createMany(trx, objs);
+        await this.stage(trx, _objs);
+        return _objs;
+    }
+    async replace(trx, obj) {
+        const _obj = await super.replace(trx, obj);
+        await this.stage(trx, [_obj]);
+        return _obj;
+    }
+    async replaceMany(trx, objs) {
+        const _objs = await super.replaceMany(trx, objs);
+        await this.stage(trx, _objs);
+        return _objs;
+    }
+    async patch(trx, obj) {
+        const _obj = await super.patch(trx, obj);
+        await this.stage(trx, [_obj]);
+        return _obj;
+    }
+    async patchMany(trx, objs) {
+        const _objs = await super.patchMany(trx, objs);
+        await this.stage(trx, _objs);
+        return _objs;
+    }
+    async put(trx, obj) {
+        const _obj = await super.put(trx, obj);
+        await this.stage(trx, [_obj]);
+        return _obj;
+    }
+    async putMany(trx, objs) {
+        const _objs = await super.putMany(trx, objs);
+        await this.stage(trx, _objs);
+        return _objs;
+    }
+    async delete(trx, id) {
+        await super.delete(trx, id);
+        await this.flagDelete(trx, [id]);
+    }
+    async deleteMany(trx, ids) {
+        await super.deleteMany(trx, ids);
+        await this.flagDelete(trx, ids);
+    }
+    /* Cache Operations */
+    async syncOne(trx, id, lastObjUpdateEpoch) {
+        return super.syncOne(trx, id, lastObjUpdateEpoch);
+    }
+    async syncOneAndPast(trx, id, lastUpdateEpoch) {
+        return super.syncOneAndPast(trx, id, lastUpdateEpoch);
+    }
+    async syncAll(trx, lastHash, lastUpdateEpoch = 0) {
+        return super.syncAll(trx, lastHash, lastUpdateEpoch);
+    }
+}
+exports.BrowserDBBucketAdapter = BrowserDBBucketAdapter;

package/lib/elements/entities/bucket/adapters/browserdb.service.d.ts

@@ -0,0 +1,30 @@
+import { AnyTrx } from "../../../../engine/transaction/trx";
+import { TrxEngineWrapFn } from "../../../../engine/transaction/trx_engine.config";
+import { Service } from "../../../../engine/app/service";
+import { MemoryNQLRunner } from './memory.nql';
+import { BucketAdapterConfig } from './bucket_adapter';
+import { Module } from "../../../../engine/module";
+import { $Module } from "../../..";
+export type BrowserDBConfig = BucketAdapterConfig & {
+    dbName: string;
+    dbVersion: number;
+};
+export type BrowserDBTrxData = {
+    [tag: string]: {
+        [id: string | number]: Record<string, any> | {
+            __delete: true;
+        };
+    };
+};
+export declare class BrowserDBService<Name extends string = 'idb'> extends Service<Name, BrowserDBConfig> {
+    static defaultName: string;
+    private indexedDB;
+    connected: boolean;
+    private db;
+    nql: MemoryNQLRunner;
+    up(): Promise<void>;
+    down(): Promise<void>;
+    private connect;
+    static db(service: BrowserDBService, module: Module<any, $Module>): Promise<IDBDatabase>;
+    static wrap(service: string): (trx: AnyTrx, fn: TrxEngineWrapFn<any, any>, services: Record<string, any>) => Promise<any>;
+}