nesoi 3.0.0

package/lib/elements/entities/bucket/bucket.builder.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketBuilder = void 0;
+const bucket_graph_builder_1 = require("./graph/bucket_graph.builder");
+const bucket_view_builder_1 = require("./view/bucket_view.builder");
+const bucket_schema_1 = require("./bucket.schema");
+const bucket_model_builder_1 = require("./model/bucket_model.builder");
+const bucket_model_convert_1 = require("./model/bucket_model.convert");
+const bucket_model_field_builder_1 = require("./model/bucket_model_field.builder");
+const bucket_graph_link_builder_1 = require("./graph/bucket_graph_link.builder");
+const dependency_1 = require("../../../engine/dependency");
+const constants_schema_1 = require("../constants/constants.schema");
+const error_1 = require("../../../engine/data/error");
+class BucketBuilder {
+    constructor(module, name) {
+        this.module = module;
+        this.name = name;
+        this.$b = 'bucket';
+        this._graph = {};
+        this._views = {};
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    extend(name) {
+        this._extend = new dependency_1.$Dependency(this.module, 'bucket', name);
+        return this;
+    }
+    model($) {
+        const fieldBuilder = new bucket_model_field_builder_1.BucketModelFieldFactory(this.module);
+        const fields = $(fieldBuilder);
+        const builder = new bucket_model_builder_1.BucketModelBuilder(this.module).fields(fields);
+        this._model = bucket_model_builder_1.BucketModelBuilder.build(builder);
+        return this;
+    }
+    graph($) {
+        const linkFactory = new bucket_graph_link_builder_1.BucketGraphLinkFactory(this.module);
+        const links = $(linkFactory);
+        this._graph = links;
+        return this;
+    }
+    view(name, $) {
+        const view = new bucket_view_builder_1.BucketViewBuilder(name);
+        view.fields($);
+        this._views[name] = view;
+        return this;
+    }
+    // Build
+    static build(node, tree) {
+        // If there's an external bucket linked, merge some of
+        // the information before starting.
+        let $ext;
+        const extend = node.builder._extend;
+        if (extend) {
+            $ext = tree.getSchema(extend);
+            // Model
+            node.builder._model = Object.assign({}, $ext?.model || {}, node.builder._model);
+            // Enums
+            // (In order to avoid having to import constants definitions for extended buckets)
+            const constants = tree.getSchema({
+                module: extend.module,
+                type: 'constants',
+                name: '*'
+            });
+            this.mergeModelEnums(node.builder._model.fields, constants);
+        }
+        const graph = BucketBuilder.buildGraph(node, tree, extend);
+        const views = BucketBuilder.buildViews(node.builder, graph, tree, extend);
+        BucketBuilder.checkComposition(node, graph);
+        node.schema = new bucket_schema_1.$Bucket(node.builder.module, node.builder.name, node.builder._alias || $ext?.alias || node.builder.name, node.builder._model, graph, views, extend);
+        return node.schema;
+    }
+    static mergeModelEnums(fields, constants) {
+        Object.values(fields).forEach(field => {
+            if (field.type === 'enum' && typeof field._enum?.options === 'string') {
+                field._enum = {
+                    options: constants_schema_1.$ConstantEnum.keys(constants.enums[field._enum.options])
+                };
+            }
+            if (field.children) {
+                this.mergeModelEnums(field.children, constants);
+            }
+        });
+    }
+    static buildGraph(node, tree, extend) {
+        const links = {};
+        if (extend) {
+            const ext = tree.getSchema(extend);
+            Object.assign(links, ext.graph.links);
+        }
+        const graphBuilder = new bucket_graph_builder_1.BucketGraphBuilder().links(node.builder._graph);
+        const graph = bucket_graph_builder_1.BucketGraphBuilder.build(node, graphBuilder);
+        Object.values(graph.links).forEach(link => {
+            if (link.keyOwner === 'other') {
+                link.selfKey || (link.selfKey = 'id');
+                link.otherKey || (link.otherKey = node.builder.name + '_id');
+            }
+            else if (link.keyOwner === 'self') {
+                link.selfKey || (link.selfKey = link.bucket.name + '_id');
+                link.otherKey || (link.otherKey = 'id');
+            }
+        });
+        graph.links = Object.assign(graph.links, links);
+        return graph;
+    }
+    static buildViews(builder, graph, tree, extend) {
+        const views = {
+            default: (0, bucket_model_convert_1.convertToView)(builder._model, 'default')
+        };
+        if (extend) {
+            const ext = tree.getSchema(extend);
+            Object.assign(views, ext.views);
+        }
+        for (const v in builder._views) {
+            views[v] = bucket_view_builder_1.BucketViewBuilder.build(builder._views[v], builder._model, graph, views);
+        }
+        return views;
+    }
+    static checkComposition(node, graph) {
+        Object.values(graph.links).forEach(link => {
+            if (link.rel === 'composition') {
+                if (link.pivotBucket) {
+                    throw error_1.NesoiError.Builder.Bucket.CompositionWithPivotNotAllowed();
+                }
+            }
+        });
+    }
+}
+exports.BucketBuilder = BucketBuilder;

package/lib/elements/entities/bucket/bucket.config.d.ts

@@ -0,0 +1,29 @@
+import { BucketAdapter } from './adapters/bucket_adapter';
+import { $Bucket } from './bucket.schema';
+export type BucketConfig<B extends $Bucket, Providers extends Record<string, any>> = {
+    /** Adapter used by this bucket to communicate with a data source */
+    adapter?: (schema: B, providers: Providers) => BucketAdapter<B['#data']>;
+    /** Settings for the app cache of this bucket */
+    cache?: {
+        /** Inner adapter used by the cache to manage cache entry data */
+        adapter?: BucketAdapter<B['#data']>;
+        /** Cache mode for each read method. Undefined on a method means no cache for that method. */
+        mode?: {
+            /** Cache mode for `get`:
+             * - **one**: Update/delete the object, then return
+             * - **past**: Update/delete the object and update all objects modified before it, then return
+             * - **all**: Update/reset the cache, then return
+            */
+            get?: 'one' | 'past' | 'all';
+            /** Cache mode for `index`:
+             * - **all**: Update/reset the cache, then return
+            */
+            index?: 'all';
+            /** Cache mode for `query`:
+             * - **incremental**: Query ids only, then query data for modified entries only, save them and return
+             * - **all**: Update/reset the cache, then query the inner adapter and return
+            */
+            query?: 'incremental' | 'all';
+        };
+    };
+};

package/lib/elements/entities/bucket/bucket.config.js

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

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

@@ -0,0 +1,36 @@
+import { AnyTrxNode } from "../../../engine/transaction/trx_node";
+import { NesoiObj, NewOrOldObj } from "../../../engine/data/obj";
+import { $Module, ViewName, ViewObj } from "../../../schema";
+import { $Bucket } from './bucket.schema';
+import { AnyBucketAdapter, BucketAdapter } from './adapters/bucket_adapter';
+import { BucketConfig } from './bucket.config';
+import { BucketGraph } from './graph/bucket_graph';
+import { NQL_AnyQuery, NQL_Order, NQL_Pagination } from './query/nql.schema';
+export declare class Bucket<M extends $Module, $ extends $Bucket> {
+    schema: $;
+    private config?;
+    providers: Record<string, any>;
+    private adapter;
+    private cache?;
+    graph: BucketGraph<M, $>;
+    private views;
+    constructor(schema: $, config?: BucketConfig<$, any> | undefined, providers?: Record<string, any>);
+    readOne<Obj = $['#data']>(trx: AnyTrxNode, id: (Obj & NesoiObj)['id']): Promise<Obj | undefined>;
+    readAll<Obj = $['#data']>(trx: AnyTrxNode, pagination?: NQL_Pagination, order?: NQL_Order<$['#fieldpath']>): Promise<Obj[]>;
+    viewOne<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, id: (Obj & NesoiObj)['id'], view: V): Promise<Obj | undefined>;
+    viewAll<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, view: V, pagination?: NQL_Pagination, order?: NQL_Order<$['#fieldpath']>): Promise<Obj[]>;
+    buildOne<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, obj: $['#data'], view: V): Promise<Obj>;
+    buildAll<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, objs: $['#data'][], view: V): Promise<Obj[]>;
+    put<Obj = $['#data']>(trx: AnyTrxNode, obj: NewOrOldObj<Obj & NesoiObj>): Promise<Obj>;
+    delete(trx: AnyTrxNode, id: $['#data']['id']): Promise<void>;
+    deleteMany(trx: AnyTrxNode, ids: $['#data']['id'][]): Promise<void>;
+    query<V extends ViewName<$>, Obj extends ViewObj<$, V>>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, view?: V): Promise<Obj[]>;
+    static getQueryMeta(bucket: AnyBucket): {
+        bucket: $Bucket;
+        scope: string;
+        avgTime: number;
+    };
+    static getQueryRunner(bucket: AnyBucket): AnyBucketAdapter["nql"];
+    static getAdapter(bucket: AnyBucket): BucketAdapter<NesoiObj>;
+}
+export type AnyBucket = Bucket<$Module, $Bucket>;

package/lib/elements/entities/bucket/bucket.infer.d.ts

@@ -0,0 +1,22 @@
+import { $BucketViewField, $BucketViewFields } from './view/bucket_view.schema';
+import { BucketViewFieldBuilder, BucketViewFieldBuilderTree } from './view/bucket_view_field.builder';
+export type $BucketViewFieldsInfer<Builder extends BucketViewFieldBuilderTree> = Builder extends (...args: any[]) => $BucketViewFields ? ReturnType<Builder> : {
+    [K in keyof Builder]: Builder[K] extends BucketViewFieldBuilderTree ? ($BucketViewField & {
+        '#data': $BucketViewFieldsInfer<Builder[K]>;
+    }) : Builder[K] extends BucketViewFieldBuilder<any, any, any> ? $BucketViewField & {
+        '#data': Builder[K] extends BucketViewFieldBuilder<infer X, any> ? X : never;
+    } : never;
+};
+export type $BucketViewDataInfer<Builder extends BucketViewFieldBuilderTree> = {
+    [K in keyof Builder]: Builder[K] extends BucketViewFieldBuilderTree ? $BucketViewDataInfer<Builder[K]> : Builder[K] extends BucketViewFieldBuilder<infer X, any> ? X : never;
+};
+export type $BucketViewFieldBuilderInfer<Data> = {
+    [K in keyof Data]: BucketViewFieldBuilder<Data[K], any>;
+};
+/**
+ * [Fieldpaths]
+ *
+ * The code below works but is very slow.
+ * It's here for reference and should be deleted in the future.
+ * It's been replaced by a generic Fieldpath on the builder.
+ */

package/lib/elements/entities/bucket/bucket.infer.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * [Fieldpaths]
+ *
+ * The code below works but is very slow.
+ * It's here for reference and should be deleted in the future.
+ * It's been replaced by a generic Fieldpath on the builder.
+ */
+// type IsAnyOrUnknown<T> = Exclude<any extends T ? true : false, true> extends never ? true : false
+// type $BucketFieldpathInferStep<
+//     Data extends Record<string, Record<string, any> | any[]>
+// > = MergeUnion<{
+//     [P in keyof Data]: 
+//         // If the prefixed object is any or unknown, ignore it
+//         IsAnyOrUnknown<Data[P]> extends true ? never
+//         : NonNullable<Data[P]> extends object ?
+//             // If the prefixed object is a list, return
+//             // an object where the key ends with '*' and it's
+//             // a single element of the list
+//             NonNullable<Data[P]> extends any[] ? { [_ in `${P & string}*`]: ListItem<Data[P]> }
+//             // If the prefixed object is a dict, return
+//             // an object where the key ends with '*' and it's
+//             // a single element of the dict
+//             : string extends keyof NonNullable<Data[P]> ? { [_ in `${P & string}*`]: DictItem<Data[P]> }
+//             // If it's an object, add it to the union
+//             // based on the type
+//             : {
+//                 [K in keyof NonNullable<Data[P]>]:
+//                     IsAnyOrUnknown<NonNullable<Data[P][K]>> extends true
+//                         // any
+//                         ? {[_ in `${P & string}${K & string}`]: any}
+//                         : NonNullable<Data[P][K]> extends any[]
+//                             // array (prop and prop.*)
+//                             ? (
+//                                 {[_ in `${P & string}${K & string}`]: ObjItem<Data[P], K>}
+//                                 | { [_ in `${P & string}${K & string}.*`]: ListItem<Data[P][K]> }
+//                             )
+//                             // dict (prop and prop.*)
+//                             : string extends keyof NonNullable<Data[P][K]>
+//                                 ? (
+//                                     {[_ in `${P & string}${K & string}`]: ObjItem<Data[P], K>}
+//                                     | { [_ in `${P & string}${K & string}.*`]: DictItem<Data[P][K]> }
+//                                 )
+//                                 // simple type
+//                                 : {[_ in `${P & string}${K & string}`]: ObjItem<Data[P], K>}
+//             }[keyof NonNullable<Data[P]>]
+//         // Primitive
+//         : never
+//         // : { [_ in (P extends `${infer X}.` ? X : P)]: Data[P] }
+// }[keyof Data]>
+// type $BucketFieldpathInferNext<
+//     Data,
+//     ObjectFields extends object = {
+//         [K in keyof Data as (
+//             // Exclude injected keys, to avoid duplicate nexts
+//             Data[`${K & string}.*` & keyof Data] extends never ?
+//                 // any/unknown, not an object
+//                 IsAnyOrUnknown<Data[K]> extends true ?
+//                     never
+//                 : NonNullable<Data[K]> extends object ?
+//                     NonNullable<Data[K]> extends NesoiDate ? never
+//                     : `${K & string}.`
+//                 : never
+//             : never
+//         )]: Data[K]
+//     }
+// > = ObjectFields[keyof ObjectFields] extends never ? never : ObjectFields
+// /**
+//  * Infer the #fieldpaths from a type
+//  */
+// export type $BucketFieldpathInfer<
+//     Data extends Record<string, any>,
+//     Input extends Record<string, any> = { '': Data },
+//     Step extends object = $BucketFieldpathInferStep<Input>,
+//     Next extends Record<string, any> = $BucketFieldpathInferNext<Step>
+// // > = {
+// //     step: Step,
+// //     // next: Next
+// //     next: Next extends never ? never : $BucketFieldpathInfer<any, Next>
+// // }
+// > = MergeUnion<{
+//     step: Step,
+//     next: Next extends never ? never : $BucketFieldpathInfer<any, Next>
+// }['step'|'next']>

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

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bucket = void 0;
+const error_1 = require("../../../engine/data/error");
+const bucket_view_1 = require("./view/bucket_view");
+const memory_bucket_adapter_1 = require("./adapters/memory.bucket_adapter");
+const bucket_cache_1 = require("./cache/bucket_cache");
+const log_1 = require("../../../engine/util/log");
+const bucket_graph_1 = require("./graph/bucket_graph");
+class Bucket {
+    constructor(schema, config, providers = {}) {
+        this.schema = schema;
+        this.config = config;
+        this.providers = providers;
+        // Config
+        this.adapter = this.config?.adapter?.(schema, providers) || new memory_bucket_adapter_1.MemoryBucketAdapter(schema, {});
+        // Graph
+        this.graph = new bucket_graph_1.BucketGraph(this);
+        // Views
+        const views = {};
+        for (const v in schema.views) {
+            views[v] = new bucket_view_1.BucketView(this, schema.views[v]);
+        }
+        this.views = views;
+        // Cache
+        if (this.config?.cache) {
+            this.cache = new bucket_cache_1.BucketCache(this.schema.name, this.adapter, this.config.cache);
+        }
+    }
+    // Get
+    async readOne(trx, id) {
+        if (typeof id !== 'string' && typeof id !== 'number') {
+            throw error_1.NesoiError.Bucket.InvalidId({ bucket: this.schema.alias, id });
+        }
+        log_1.Log.debug('bucket', this.schema.name, `Get id=${id}`);
+        const raw = this.cache
+            ? await this.cache.get(trx, id)
+            : await this.adapter.get(trx, id);
+        if (!raw)
+            return undefined;
+        return raw;
+    }
+    async readAll(trx, pagination, order) {
+        log_1.Log.debug('bucket', this.schema.name, 'Index');
+        const raws = this.cache
+            ? await this.cache.index(trx)
+            : await this.adapter.index(trx);
+        return raws;
+    }
+    async viewOne(trx, id, view) {
+        if (typeof id !== 'string' && typeof id !== 'number') {
+            throw error_1.NesoiError.Bucket.InvalidId({ bucket: this.schema.alias, id });
+        }
+        log_1.Log.debug('bucket', this.schema.name, `View id=${id}, v=${view}`);
+        const obj = await this.readOne(trx, id);
+        if (!obj) {
+            return;
+        }
+        return this.buildOne(trx, obj, view);
+    }
+    async viewAll(trx, view, pagination, order) {
+        log_1.Log.debug('bucket', this.schema.name, `View all, v=${view}`);
+        const objs = await this.readAll(trx);
+        return this.buildAll(trx, objs, view);
+    }
+    async buildOne(trx, obj, view) {
+        if (!(view in this.views)) {
+            throw error_1.NesoiError.Bucket.ViewNotFound({ bucket: this.schema.alias, view: view });
+        }
+        return this.views[view].parse(trx, obj);
+    }
+    async buildAll(trx, objs, view) {
+        return Promise.all(objs.map(obj => this.buildOne(trx, obj, view)));
+    }
+    // Put
+    async put(trx, obj) {
+        log_1.Log.debug('bucket', this.schema.name, `Put id=${obj['id'] || 'new'}`, obj);
+        const raw = await this.adapter.put(trx, obj);
+        return raw;
+    }
+    // Delete
+    async delete(trx, id) {
+        if (typeof id !== 'string' && typeof id !== 'number') {
+            throw error_1.NesoiError.Bucket.InvalidId({ bucket: this.schema.alias, id });
+        }
+        log_1.Log.debug('bucket', this.schema.name, `Delete id=${id}`);
+        await this.adapter.delete(trx, id);
+    }
+    async deleteMany(trx, ids) {
+        log_1.Log.debug('bucket', this.schema.name, `Delete Many ids=${ids}`);
+        await this.adapter.deleteMany(trx, ids);
+    }
+    // Query
+    async query(trx, query, pagination, view) {
+        log_1.Log.trace('bucket', this.schema.name, 'Query', query);
+        const v = (view ? this.views[view] : null) || this.views['default'];
+        if (!v) {
+            throw error_1.NesoiError.Bucket.Query.ViewNotFound(this.schema.name, view || 'default');
+        }
+        const raws = this.cache
+            ? await this.cache.query(trx, v.schema, query, pagination)
+            : await this.adapter.query(trx, query, pagination);
+        if (!raws.length)
+            return [];
+        if (view) {
+            return this.buildAll(trx, raws, view);
+        }
+        else {
+            return raws;
+        }
+    }
+    static getQueryMeta(bucket) {
+        return {
+            ...bucket.adapter.getQueryMeta(),
+            bucket: bucket.schema
+        };
+    }
+    static getQueryRunner(bucket) {
+        return bucket.adapter.nql;
+    }
+    static getAdapter(bucket) {
+        return bucket.adapter;
+    }
+}
+exports.Bucket = Bucket;

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

@@ -0,0 +1,24 @@
+import { $BucketGraph } from './graph/bucket_graph.schema';
+import { $BucketViews } from './view/bucket_view.schema';
+import { $BucketModel } from './model/bucket_model.schema';
+import { NesoiObj } from "../../../engine/data/obj";
+import { $Dependency } from "../../../engine/dependency";
+export declare class $Bucket {
+    module: string;
+    name: string;
+    alias: string;
+    model: $BucketModel;
+    graph: $BucketGraph;
+    views: $BucketViews;
+    extended?: $Dependency | undefined;
+    $t: "bucket";
+    '#data': NesoiObj;
+    '#composition': Record<string, {
+        bucket: $Bucket;
+        many: boolean;
+        optional: boolean;
+    }>;
+    '#fieldpath': {};
+    '#defaults': Record<string, any>;
+    constructor(module: string, name: string, alias: string, model: $BucketModel, graph: $BucketGraph, views: $BucketViews, extended?: $Dependency | undefined);
+}

package/lib/elements/entities/bucket/bucket.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Bucket = void 0;
+class $Bucket {
+    constructor(module, name, alias, model, graph, views, extended) {
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.model = model;
+        this.graph = graph;
+        this.views = views;
+        this.extended = extended;
+        this.$t = 'bucket';
+    }
+}
+exports.$Bucket = $Bucket;

package/lib/elements/entities/bucket/bucket.types.d.ts

@@ -0,0 +1,32 @@
+import { NewOrOldObj } from "../../../engine/data/obj";
+import { $Bucket } from './bucket.schema';
+import { DeepPartialNullable } from "../../../engine/util/deep";
+export type PutObj<$ extends $Bucket> = NewOrOldObj<$['#data']> & (keyof $['#composition'] extends never ? {} : {
+    '#composition': {
+        [K in keyof $['#composition']]: $['#composition'][K]['many'] extends true ? (PutObj<$['#composition'][K]['bucket']> | ($['#composition'][K]['optional'] extends true ? undefined : never))[] : PutObj<$['#composition'][K]['bucket']> | ($['#composition'][K]['optional'] extends true ? undefined : never);
+    };
+});
+export type CreateObj<$ extends $Bucket> = Omit<$['#data'], 'id' | keyof $['#defaults']> & {
+    [K in keyof $['#defaults']]?: $['#data'][K];
+} & (string extends keyof $['#composition'] ? {} : keyof $['#composition'] extends never ? {} : {
+    '#composition': {
+        [K in keyof $['#composition']]: $['#composition'][K]['many'] extends true ? (PutObj<$['#composition'][K]['bucket']> | ($['#composition'][K]['optional'] extends true ? undefined : never))[] : PutObj<$['#composition'][K]['bucket']> | ($['#composition'][K]['optional'] extends true ? undefined : never);
+    };
+});
+export type ReplaceObj<$ extends $Bucket> = $['#data'] & (string extends keyof $['#composition'] ? {} : keyof $['#composition'] extends never ? {} : {
+    '#composition': {
+        [K in keyof $['#composition']]: $['#composition'][K]['many'] extends true ? ReplaceObj<$['#composition'][K]['bucket']>[] : ReplaceObj<$['#composition'][K]['bucket']>;
+    };
+});
+export type PatchObj<$ extends $Bucket> = DeepPartialNullable<$['#data']> & {
+    id: $['#data']['id'];
+} & (string extends keyof $['#composition'] ? {} : keyof $['#composition'] extends never ? {} : {
+    '#composition'?: {
+        [K in keyof $['#composition']]?: $['#composition'][K]['many'] extends true ? PatchObj<$['#composition'][K]['bucket']>[] : Omit<PatchObj<$['#composition'][K]['bucket']>, 'id'>;
+    };
+});
+export type PatchResourceObj<$ extends $Bucket> = DeepPartialNullable<Omit<$['#data'], 'id'>> & (keyof $['#composition'] extends never ? {} : {
+    '#composition'?: {
+        [K in keyof $['#composition']]?: $['#composition'][K]['many'] extends true ? PatchObj<$['#composition'][K]['bucket']>[] : PatchResourceObj<$['#composition'][K]['bucket']>;
+    };
+});

package/lib/elements/entities/bucket/bucket.types.js

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

package/lib/elements/entities/bucket/cache/bucket_cache.d.ts

@@ -0,0 +1,35 @@
+import { BucketConfig } from '../bucket.config';
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { NesoiObj } from "../../../../engine/data/obj";
+import { AnyBucketAdapter } from '../adapters/bucket_adapter';
+import { $BucketView } from '../view/bucket_view.schema';
+import { NQL_AnyQuery, NQL_Pagination } from '../query/nql.schema';
+export type BucketCacheSync<T> = {
+    obj: T;
+    updateEpoch: number;
+};
+export declare class BucketCacheEntry<Obj extends NesoiObj> {
+    id: Obj['id'];
+    obj: Obj;
+    updateEpoch: number;
+    syncEpoch: number;
+    constructor(id: Obj['id'], obj: Obj, updateEpoch: number, syncEpoch: number);
+}
+export declare class BucketCache<Obj extends NesoiObj> {
+    private bucketName;
+    private outerAdapter;
+    private config;
+    private lastUpdateEpoch?;
+    private lastSyncEpoch?;
+    private lastHash?;
+    private innerAdapter;
+    constructor(bucketName: string, outerAdapter: AnyBucketAdapter, config: NonNullable<BucketConfig<any, any>['cache']>);
+    get(trx: AnyTrxNode, id: NesoiObj['id']): Promise<any>;
+    index(trx: AnyTrxNode): Promise<any[]>;
+    query(trx: AnyTrxNode, view: $BucketView, query: NQL_AnyQuery, pagination?: NQL_Pagination): Promise<any[]>;
+    private syncOne;
+    private syncOneAndPast;
+    private syncAll;
+    private syncQuery;
+}
+export type AnyBucketCache = BucketCache<any>;