nesoi 3.2.2 → 3.2.4

package/lib/compiler/elements/constants.element.js

@@ -38,7 +38,7 @@ class ConstantsElement extends element_1.Element {
             });
             enums[key] = {
                 '#data': data,
-                name: dump_helpers_1.DumpHelpers.dumpValueToType(key),
+                name: dump_helpers_1.DumpHelpers.dumpValueToType(val.name),
                 options: type
             };
         });

package/lib/compiler/error.d.ts

@@ -6,6 +6,7 @@ export declare class CompilerError extends Error {
     static UnmetModuleDependency(from: string, name: string): CompilerError;
     static UnmetDependency(from: string, name: string): CompilerError;
     static CircularDependency(): CompilerError;
+    static ExternalEnumNotFound(name: string): CompilerError;
 }
 export declare class HelperError extends Error {
     constructor(message: string);

package/lib/compiler/error.js

@@ -23,6 +23,9 @@ class CompilerError extends Error {
     static CircularDependency() {
         return new CompilerError('Circular dependency found while building.');
     }
+    static ExternalEnumNotFound(name) {
+        return new CompilerError(`External enum '${name}' not found`);
+    }
 }
 exports.CompilerError = CompilerError;
 class HelperError extends Error {

package/lib/compiler/stages/4_build_schemas_stage.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuildSchemasStage = void 0;
 const log_1 = require("../../engine/util/log");
+const error_1 = require("../error");
 /**
  * [Compiler Stage #4]
  * Build the node schemas, following the graph resolved on previous steps.
@@ -41,6 +42,19 @@ class BuildSchemasStage {
                 return;
             }
             await module.buildNode(node, this.compiler.tree);
+            // Inject external enums on the module schema
+            if (node.type === 'externals') {
+                const schema = node.schema;
+                for (const e in schema.enums) {
+                    const enumDep = schema.enums[e];
+                    const enumModule = this.compiler.modules[enumDep.module].module;
+                    const constants = enumModule.schema.constants;
+                    if (!constants.enums[enumDep.name]) {
+                        throw error_1.CompilerError.ExternalEnumNotFound(e);
+                    }
+                    module.schema.constants.enums[enumDep.refName] = constants.enums[enumDep.name];
+                }
+            }
         });
         const t = new Date().getTime();
         log_1.Log.debug('compiler', 'stage.build_schemas', `[t: ${(t - t0) / 1000} ms]`);

package/lib/compiler/treeshake.js

@@ -21,11 +21,13 @@ class Treeshake {
         const buckets = b.buckets;
         const messages = b.messages;
         const jobs = b.jobs;
+        const enums = b.enums;
         log_1.Log.trace('compiler', 'treeshake', `${'  '.repeat(depth)} └ Treeshaking node ${(0, log_1.scopeTag)($b, node.name)}`);
         node.dependencies = [
             ...Object.values(buckets),
             ...Object.values(messages),
-            ...Object.values(jobs)
+            ...Object.values(jobs),
+            ...Object.values(enums).map(dep => new dependency_1.$Dependency(node.module, 'constants', `${dep.module}::*`))
         ];
         node.dependencies = this.cleanNodeDependencies(node);
     }

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

@@ -20,11 +20,13 @@ export declare class ExternalsBuilder<Space extends $Space, ModuleName extends k
     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;
     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;
 }

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

@@ -16,6 +16,7 @@ class ExternalsBuilder {
         this.messages = {};
         this.jobs = {};
         this.machines = {};
+        this.enums = {};
     }
     bucket(ref) {
         this.buckets[ref] = new dependency_1.$Dependency(this.module, 'bucket', ref);
@@ -33,13 +34,17 @@ class ExternalsBuilder {
         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);
+        return this;
+    }
     static merge(to, from) {
         Object.assign(to.buckets, from.buckets);
         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.schema = new externals_schema_1.$Externals(node.module, node.builder.buckets, node.builder.messages, node.builder.jobs, node.builder.machines, node.builder.enums);
         return node.schema;
     }
 }

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

@@ -9,8 +9,9 @@ export declare class $Externals {
     messages: Record<string, $Dependency>;
     jobs: Record<string, $Dependency>;
     machines: Record<string, $Dependency>;
+    enums: Record<string, $Dependency>;
     $t: "externals";
     module: string;
-    constructor(name: string, buckets?: Record<string, $Dependency>, messages?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>);
+    constructor(name: string, buckets?: Record<string, $Dependency>, messages?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>, enums?: Record<string, $Dependency>);
     static merge(to: $Externals, from: $Externals): void;
 }

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

@@ -6,12 +6,13 @@ exports.$Externals = void 0;
  * @subcategory Edge
  */
 class $Externals {
-    constructor(name, buckets = {}, messages = {}, jobs = {}, machines = {}) {
+    constructor(name, buckets = {}, messages = {}, jobs = {}, machines = {}, enums = {}) {
         this.name = name;
         this.buckets = buckets;
         this.messages = messages;
         this.jobs = jobs;
         this.machines = machines;
+        this.enums = enums;
         this.$t = 'externals';
         this.module = this.name;
     }
@@ -20,6 +21,7 @@ class $Externals {
         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/bucket.d.ts

@@ -4,6 +4,7 @@ import { $Module, ViewName, ViewObj } from "../../../schema";
 import { $Bucket } from './bucket.schema';
 import { BucketAdapter } from './adapters/bucket_adapter';
 import { BucketConfig } from './bucket.config';
+import { AnyBucketCache } from './cache/bucket_cache';
 import { BucketGraph } from './graph/bucket_graph';
 import { NQL_AnyQuery, NQL_Pagination } from './query/nql.schema';
 import { CreateObj, PatchObj, PutObj } from './bucket.types';
@@ -32,7 +33,7 @@ export declare class Bucket<M extends $Module, $ extends $Bucket> {
     private config?;
     services: Record<string, IService>;
     adapter: BucketAdapter<$['#data']>;
-    private cache?;
+    cache?: AnyBucketCache;
     graph: BucketGraph<M, $>;
     private views;
     drive?: DriveAdapter;

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

@@ -45,7 +45,7 @@ class Bucket {
         this.views = views;
         // Cache
         if (this.config?.cache) {
-            this.cache = new bucket_cache_1.BucketCache(this.schema.name, this.adapter, this.config.cache);
+            this.cache = new bucket_cache_1.BucketCache(this, this.config.cache);
         }
         // Drive
         if (this.config?.drive) {
@@ -79,8 +79,9 @@ class Bucket {
             : this.getTenancyQuery(trx);
         let raw;
         // With Tenancy
+        const adapter = this.cache || this.adapter;
         if (tenancy) {
-            const result = await this.adapter.query(trx, {
+            const result = await adapter.query(trx, {
                 id,
                 '#and': tenancy
             }, { perPage: 1 }, undefined, options?.query_view ? { view: options?.query_view } : undefined);
@@ -88,9 +89,7 @@ class Bucket {
         }
         // Without Tenancy
         else {
-            raw = this.cache
-                ? await this.cache.get(trx, id)
-                : await this.adapter.get(trx, id);
+            raw = await adapter.get(trx, id);
         }
         // Empty result
         if (!raw) {
@@ -119,15 +118,14 @@ class Bucket {
             : this.getTenancyQuery(trx);
         let raws;
         // With Tenancy
+        const adapter = this.cache || this.adapter;
         if (tenancy) {
-            const result = await this.adapter.query(trx, tenancy, undefined, options?.query_view ? [{ view: options?.query_view }] : undefined);
+            const result = await adapter.query(trx, tenancy, undefined, options?.query_view ? [{ view: options?.query_view }] : undefined);
             raws = result.data;
         }
         // Without Tenancy
         else {
-            raws = this.cache
-                ? await this.cache.index(trx)
-                : await this.adapter.index(trx);
+            raws = await this.adapter.index(trx);
         }
         // Encryption
         if (this.schema.model.hasEncryptedField) {
@@ -426,9 +424,10 @@ class Bucket {
         // Read old object, if safe, to check if it exists
         let oldObj;
         if (!options?.unsafe) {
+            const adapter = this.cache || this.adapter;
             // With Tenancy
             if (tenancy) {
-                const result = await this.adapter.query(trx, {
+                const result = await adapter.query(trx, {
                     id: obj.id,
                     '#and': tenancy
                 }, { perPage: 1 }, undefined, {
@@ -438,9 +437,7 @@ class Bucket {
             }
             // Without Tenancy
             else {
-                oldObj = this.cache
-                    ? await this.cache.get(trx, obj['id'])
-                    : await this.adapter.get(trx, obj['id']);
+                oldObj = await adapter.get(trx, obj['id']);
             }
             // Empty response
             if (!oldObj) {
@@ -716,7 +713,8 @@ class Bucket {
             '#and': tenancy
         };
         // Query
-        const result = await this.adapter.query(trx, query, pagination, options?.params);
+        const adapter = this.cache || this.adapter;
+        const result = await adapter.query(trx, query, pagination, options?.params);
         if (!result.data.length)
             return result;
         // Encryption

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

@@ -1,10 +1,9 @@
 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';
 import { NQL_Result } from '../query/nql_engine';
+import { AnyBucket } from '../bucket';
 export type BucketCacheSync<T> = {
     obj: T;
     updateEpoch: number;
@@ -14,28 +13,33 @@ export type BucketCacheSync<T> = {
  * @subcategory Entity
  * */
 export declare class BucketCacheEntry<Obj extends NesoiObj> {
+    __update_epoch: number;
+    __sync_epoch: number;
     id: Obj['id'];
-    obj: Obj;
-    updateEpoch: number;
-    syncEpoch: number;
-    constructor(id: Obj['id'], obj: Obj, updateEpoch: number, syncEpoch: number);
+    constructor(obj: Obj, __update_epoch: number, __sync_epoch: number);
 }
 /**
  * @category Elements
  * @subcategory Entity
  * */
 export declare class BucketCache<Obj extends NesoiObj> {
-    private bucketName;
-    private outerAdapter;
+    private bucket;
     private config;
     private lastUpdateEpoch?;
     private lastSyncEpoch?;
     private lastHash?;
     private innerAdapter;
-    constructor(bucketName: string, outerAdapter: AnyBucketAdapter, config: NonNullable<BucketConfig<any, any, any>['cache']>);
+    private outerAdapter;
+    constructor(bucket: AnyBucket, config: NonNullable<BucketConfig<any, 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<NQL_Result<any> | Obj[]>;
+    query<MetadataOnly extends boolean>(trx: AnyTrxNode, query: NQL_AnyQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], config?: {
+        view?: string;
+        metadataOnly?: MetadataOnly;
+    }): Promise<NQL_Result<MetadataOnly extends true ? {
+        id: Obj['id'];
+        [x: string]: any;
+    } : Obj>>;
     private syncOne;
     private syncOneAndPast;
     private syncAll;

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

@@ -4,16 +4,18 @@ exports.BucketCache = exports.BucketCacheEntry = void 0;
 const log_1 = require("../../../../engine/util/log");
 const memory_bucket_adapter_1 = require("../adapters/memory.bucket_adapter");
 const datetime_1 = require("../../../../engine/data/datetime");
+const bucket_schema_1 = require("../bucket.schema");
+const bucket_model_schema_1 = require("../model/bucket_model.schema");
+const bucket_graph_schema_1 = require("../graph/bucket_graph.schema");
 /**
  * @category Elements
  * @subcategory Entity
  * */
 class BucketCacheEntry {
-    constructor(id, obj, updateEpoch, syncEpoch) {
-        this.id = id;
-        this.obj = obj;
-        this.updateEpoch = updateEpoch;
-        this.syncEpoch = syncEpoch;
+    constructor(obj, __update_epoch, __sync_epoch) {
+        this.__update_epoch = __update_epoch;
+        this.__sync_epoch = __sync_epoch;
+        Object.assign(this, obj);
     }
 }
 exports.BucketCacheEntry = BucketCacheEntry;
@@ -22,28 +24,43 @@ exports.BucketCacheEntry = BucketCacheEntry;
  * @subcategory Entity
  * */
 class BucketCache {
-    constructor(bucketName, outerAdapter, config) {
-        this.bucketName = bucketName;
-        this.outerAdapter = outerAdapter;
+    constructor(bucket, config) {
+        this.bucket = bucket;
         this.config = config;
-        this.innerAdapter = this.config?.adapter || new memory_bucket_adapter_1.MemoryBucketAdapter({}, {});
+        const innerSchema = new bucket_schema_1.$Bucket(bucket.schema.module, bucket.schema.name, '[cache] ' + bucket.schema.alias, new bucket_model_schema_1.$BucketModel({
+            ...bucket.schema.model.fields,
+            __update_epoch: new bucket_model_schema_1.$BucketModelField('__update_epoch', '__update_epoch', 'int', '__update_epoch', true),
+            __sync_epoch: new bucket_model_schema_1.$BucketModelField('__sync_epoch', '__sync_epoch', 'int', '__sync_epoch', true),
+        }), new bucket_graph_schema_1.$BucketGraph(), {});
+        this.innerAdapter = this.config?.adapter || new memory_bucket_adapter_1.MemoryBucketAdapter(innerSchema, {});
+        this.outerAdapter = bucket.adapter;
     }
     async get(trx, id) {
         const mode = this.config?.mode?.get;
         if (mode === 'one') {
             const { action, sync } = await this.syncOne(trx, id);
-            log_1.Log.debug('bucket', this.bucketName, `CACHE get.one, ${action}`);
-            return sync?.obj;
+            log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE get.one, ${action}`);
+            if (!sync)
+                return undefined;
+            const { __update_epoch, __sync_epoch, ...obj } = sync;
+            return obj;
         }
         if (mode === 'past') {
             const { action, sync } = await this.syncOneAndPast(trx, id);
-            log_1.Log.debug('bucket', this.bucketName, `CACHE get.past, ${action}`);
-            return sync?.obj;
+            log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE get.past, ${action}`);
+            if (!sync)
+                return undefined;
+            const { __update_epoch, __sync_epoch, ...obj } = sync;
+            return obj;
         }
         if (mode === 'all') {
             const { action, sync } = await this.syncAll(trx);
-            log_1.Log.debug('bucket', this.bucketName, `CACHE get.sync, ${action}`);
-            return sync.find(s => s.obj.id === id)?.obj;
+            log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE get.all, ${action}`);
+            const one = sync.find(s => s.id === id);
+            if (!one)
+                return undefined;
+            const { __update_epoch, __sync_epoch, ...obj } = one;
+            return one;
         }
         return this.outerAdapter.get(trx, id);
     }
@@ -51,50 +68,69 @@ class BucketCache {
         const mode = this.config?.mode?.index;
         if (mode === 'all') {
             const { action, sync } = await this.syncAll(trx);
-            log_1.Log.debug('bucket', this.bucketName, `CACHE index.sync, ${action}`);
-            return sync.map(s => s.obj);
+            log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE index.all, ${action}`);
+            const data = [];
+            for (const e of sync) {
+                const { __update_epoch, __sync_epoch, ...obj } = e;
+                data.push(obj);
+            }
+            return data;
         }
         return this.outerAdapter.index(trx);
     }
-    async query(trx, view, query, pagination) {
+    async query(trx, query, pagination, params, config) {
         const mode = this.config?.mode?.query;
+        let data;
         if (mode === 'incremental') {
-            const { action, sync } = await this.syncQuery(trx, view, query, pagination);
-            log_1.Log.debug('bucket', this.bucketName, `CACHE query.incremental, ${action}`);
-            return sync.map(s => s.obj);
+            const { action, sync } = await this.syncQuery(trx, query, pagination, params);
+            log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE query.incremental, ${action}`);
+            data = sync;
         }
-        if (mode === 'all') {
+        else if (mode === 'all') {
             const { action, sync } = await this.syncAll(trx);
-            log_1.Log.debug('bucket', this.bucketName, `CACHE query.sync, ${action}`);
-            return this.innerAdapter.query(trx, query);
+            log_1.Log.debug('bucket', this.bucket.schema.name, `CACHE query.all, ${action}`);
+            const entries = (await this.innerAdapter.query(trx, query, pagination, params, undefined, this.innerAdapter.nql)).data;
+            data = [];
+            for (const e of entries) {
+                const { __update_epoch, __sync_epoch, ...obj } = e;
+                data.push(obj);
+            }
+        }
+        else {
+            data = (await this.outerAdapter.query(trx, query, pagination, params)).data;
+        }
+        for (const entry of data) {
+            delete entry['__update_epoch'];
+            delete entry['__sync_epoch'];
         }
-        return this.outerAdapter.query(trx, query);
+        if (config?.view) {
+            data = await this.bucket.buildMany(trx, data, config.view);
+        }
+        return { data };
     }
     /* Cache modes */
     async syncOne(trx, id) {
-        const localObj = await this.innerAdapter.get(trx, id);
+        let localObj = await this.innerAdapter.get(trx, id);
         if (!localObj) {
             const obj = await this.outerAdapter.get(trx, id);
             if (obj) {
-                const entry = new BucketCacheEntry(obj.id, obj, this.outerAdapter.getUpdateEpoch(obj), this.lastSyncEpoch);
+                const entry = new BucketCacheEntry(obj, this.outerAdapter.getUpdateEpoch(obj), this.lastSyncEpoch);
                 await this.innerAdapter.create(trx, entry);
                 return { action: 'update', sync: entry };
             }
-            return { action: 'keep' };
+            return { action: 'none' };
         }
-        const sync = await this.outerAdapter.syncOne(trx, id, localObj.updateEpoch);
+        const sync = await this.outerAdapter.syncOne(trx, id, localObj.__update_epoch);
         if (sync === null) {
-            return { action: 'keep', sync: localObj };
+            return { action: 'none', sync: localObj };
         }
         if (sync === 'deleted') {
             await this.innerAdapter.delete(trx, id);
             return { action: 'delete' };
         }
-        localObj.obj = sync.obj;
-        localObj.updateEpoch = sync.updateEpoch;
-        localObj.syncEpoch = datetime_1.NesoiDatetime.now().epoch;
+        localObj = new BucketCacheEntry(sync.obj, sync.updateEpoch, datetime_1.NesoiDatetime.now().epoch);
         await this.innerAdapter.put(trx, localObj);
-        return { action: 'update', sync };
+        return { action: 'update', sync: localObj };
     }
     async syncOneAndPast(trx, id) {
         const localObj = await this.innerAdapter.get(trx, id);
@@ -102,54 +138,52 @@ class BucketCache {
             const obj = await this.outerAdapter.get(trx, id);
             if (obj) {
                 await this.innerAdapter.create(trx, obj);
-                return { action: 'update', sync: {
-                        obj,
-                        updateEpoch: this.outerAdapter.getUpdateEpoch(obj)
-                    } };
+                return { action: 'update', sync: new BucketCacheEntry(obj, this.outerAdapter.getUpdateEpoch(obj), datetime_1.NesoiDatetime.now().epoch) };
             }
-            return { action: 'keep' };
+            return { action: 'none' };
         }
-        const sync = await this.outerAdapter.syncOneAndPast(trx, id, localObj.updateEpoch);
+        const sync = await this.outerAdapter.syncOneAndPast(trx, id, localObj.__update_epoch);
         if (sync === null) {
-            return { action: 'keep', sync: localObj };
+            return { action: 'none', sync: localObj };
         }
         if (sync === 'deleted') {
             await this.innerAdapter.delete(trx, id);
             return { action: 'delete' };
         }
-        await this.innerAdapter.putMany(trx, sync.map(s => s.obj));
-        return { action: 'update', sync: sync.find(s => s.obj.id === id) };
+        const entries = sync.map(s => new BucketCacheEntry(s.obj, s.updateEpoch, datetime_1.NesoiDatetime.now().epoch));
+        await this.innerAdapter.putMany(trx, entries);
+        return { action: 'update', sync: entries.find(e => e.id === id) };
     }
     async syncAll(trx) {
         const sync = await this.outerAdapter.syncAll(trx, this.lastHash, this.lastUpdateEpoch);
         if (sync === null) {
             const all = await this.innerAdapter.index(trx);
-            return { action: 'keep', sync: all };
+            return { action: 'none', sync: all };
         }
         this.lastUpdateEpoch = sync.updateEpoch;
         this.lastHash = sync.hash;
         this.lastSyncEpoch = datetime_1.NesoiDatetime.now().epoch;
-        const entries = sync.sync.map(s => new BucketCacheEntry(s.obj.id, s.obj, s.updateEpoch, this.lastSyncEpoch));
+        const entries = sync.sync.map(s => new BucketCacheEntry(s.obj, s.updateEpoch, this.lastSyncEpoch));
         if (sync.reset) {
             await this.innerAdapter.deleteEverything(trx);
             await this.innerAdapter.putMany(trx, entries);
-            return { action: 'reset', sync: sync.sync };
+            return { action: 'reset', sync: entries };
         }
         await this.innerAdapter.putMany(trx, entries);
-        return { action: 'update', sync: sync.sync };
+        return { action: 'update', sync: entries };
     }
-    async syncQuery(trx, view, query, pagination) {
+    async syncQuery(trx, query, pagination, params) {
         // 1. Query id and epoch from outer adapter
-        const outerMetadata = await this.outerAdapter.query(trx, query, pagination, undefined, {
+        const outerMetadata = await this.outerAdapter.query(trx, query, pagination, params, {
             metadataOnly: true
         });
         if (!outerMetadata.data.length) {
-            return { action: 'keep', sync: [] };
+            return { action: 'none', sync: [] };
         }
         // 2. Read ids from the inner adapter
         const innerData = await this.innerAdapter.query(trx, {
             'id in': outerMetadata.data.map(obj => obj.id)
-        });
+        }, undefined, undefined, undefined, this.innerAdapter.nql);
         // 3. Filter modified query results
         const outerEpoch = {};
         for (const i in outerMetadata.data) {
@@ -159,18 +193,18 @@ class BucketCache {
         const queryResults = {};
         const modifiedIds = [];
         for (const i in innerData.data) {
-            const obj = innerData.data[i];
-            const epoch = outerEpoch[obj.id];
-            if (!epoch || epoch > obj.updateEpoch) {
-                modifiedIds.push(obj.id);
+            const entry = innerData.data[i];
+            const epoch = outerEpoch[entry.id];
+            if (!epoch || epoch > entry.__update_epoch) {
+                modifiedIds.push(entry.id);
             }
             else {
-                queryResults[obj.id] = obj;
+                queryResults[entry.id] = entry;
             }
         }
         // 4. Nothing changed, return current data
         if (!modifiedIds.length) {
-            return { action: 'keep', sync: innerData.data };
+            return { action: 'none', sync: innerData.data };
         }
         // 5. Query modified objects to outer adapter and merge them on results
         const outerData = await this.outerAdapter.query(trx, {
@@ -184,7 +218,7 @@ class BucketCache {
                 updateEpoch
             };
         }
-        return { action: 'update', sync: Object.values(queryResults) };
+        return { action: 'update', sync: Object.values(queryResults).map(r => new BucketCacheEntry(r.obj, r.updateEpoch, datetime_1.NesoiDatetime.now().epoch)) };
     }
 }
 exports.BucketCache = BucketCache;

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

@@ -5,6 +5,7 @@ const trx_node_1 = require("../../../../engine/transaction/trx_node");
 const log_1 = require("../../../../engine/util/log");
 const error_1 = require("../../../../engine/data/error");
 const memory_bucket_adapter_1 = require("../adapters/memory.bucket_adapter");
+const bucket_cache_1 = require("../cache/bucket_cache");
 /**
  * @category Elements
  * @subcategory Entity
@@ -31,7 +32,8 @@ class BucketGraph {
             : this.bucket.getTenancyQuery(trx);
         // Query
         const otherBucket = trx_node_1.TrxNode.getModule(trx).buckets[schema.bucket.refName];
-        const links = await otherBucket.adapter.query(trx, {
+        const adapter = otherBucket.cache || otherBucket.adapter;
+        const links = await adapter.query(trx, {
             ...schema.query,
             '#and': tenancy
         }, {
@@ -77,10 +79,11 @@ class BucketGraph {
         // let tempData: Record<string, any> = {};
         let tempAdapter;
         if (otherBucket.adapter instanceof memory_bucket_adapter_1.MemoryBucketAdapter) {
-            tempAdapter = otherBucket.adapter;
+            tempAdapter = otherBucket.cache || otherBucket.adapter;
         }
         else {
-            const allLinks = await otherBucket.adapter.query(trx, {
+            const adapter = otherBucket.cache || otherBucket.adapter;
+            const allLinks = await adapter.query(trx, {
                 ...schema.query,
                 '#and': tenancy
             }, undefined, objs.map(obj => ({ ...obj })));
@@ -91,9 +94,13 @@ class BucketGraph {
         }
         const links = [];
         for (const obj of objs) {
-            const result = await tempAdapter.query(trx, schema.query, {
-                perPage: schema.many ? undefined : 1,
-            }, [{ ...obj }], undefined, tempAdapter.nql);
+            const result = tempAdapter instanceof bucket_cache_1.BucketCache
+                ? await tempAdapter.query(trx, schema.query, {
+                    perPage: schema.many ? undefined : 1,
+                }, [{ ...obj }], undefined)
+                : await tempAdapter.query(trx, schema.query, {
+                    perPage: schema.many ? undefined : 1,
+                }, [{ ...obj }], undefined, tempAdapter.nql);
             if (schema.many) {
                 links.push(result.data);
             }

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

@@ -146,7 +146,7 @@ class $BucketModel {
                         path: i.toString(),
                         obj: val,
                         copy: entry.copy[entry.path],
-                        field: entry.field.children['*']
+                        field: entry.field.children['#']
                     })));
                 }
                 else if (entry.field.type === 'dict') {
@@ -157,7 +157,7 @@ class $BucketModel {
                         path,
                         obj: val,
                         copy: entry.copy[entry.path],
-                        field: entry.field.children['*']
+                        field: entry.field.children['#']
                     })));
                 }
                 else if (entry.field.type === 'obj') {