nesoi 3.1.0 → 3.1.2

package/lib/compiler/apps/monolyth/stages/2_build_typescript_stage.js

@@ -88,6 +88,7 @@ class BuildTypescriptStage {
         }
         libPaths.forEach(lib => {
             lib = space_1.Space.relPath(compiler.space, lib);
+            // TODO: flatten sub-directory of modules
             replacePaths[lib] = path.resolve(dirs.build, lib);
             tsPaths['.nesoi/*'] = [space_1.Space.path(compiler.space, '.nesoi') + '/*'];
             tsPaths[lib + '/*'] = [space_1.Space.path(compiler.space, lib) + '/*'];

package/lib/compiler/elements/bucket.element.d.ts

@@ -13,8 +13,8 @@ export declare class BucketElement extends Element<$Bucket> {
     };
     private buildModelFieldType;
     private buildCompositionType;
-    buildModelType(fields?: $BucketModelFields): ObjTypeAsObj;
-    buildModelpath(fields?: $BucketModelFields): Record<string, TypeAsObj>;
+    buildModelType(fields?: $BucketModelFields, singleLine?: boolean): ObjTypeAsObj;
+    buildModelpath(): Record<string, TypeAsObj>;
     buildQuerypath(fields?: $BucketModelFields): Record<string, TypeAsObj>;
     private buildGraphType;
     private buildViewsType;

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

@@ -65,7 +65,7 @@ class BucketElement extends element_1.Element {
             bucket
         };
     }
-    buildModelFieldType(field) {
+    buildModelFieldType(field, singleLine = false) {
         let type = 'unknown';
         if (field.type === 'boolean') {
             type = 'boolean';
@@ -91,10 +91,10 @@ class BucketElement extends element_1.Element {
                 }
             }
             else if (Array.isArray(options)) {
-                type = options.map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                type = options.map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v, undefined, singleLine));
             }
             else if (typeof options === 'object') {
-                type = Object.values(options || []).map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v));
+                type = Object.values(options || []).map(v => dump_helpers_1.DumpHelpers.dumpValueToType(v, undefined, singleLine));
             }
         }
         else if (field.type === 'file') {
@@ -110,7 +110,7 @@ class BucketElement extends element_1.Element {
             type = 'string';
         }
         else if (field.type === 'obj') {
-            type = this.buildModelType(field.children);
+            type = this.buildModelType(field.children, singleLine);
         }
         else if (field.type === 'unknown') {
             type = 'unknown';
@@ -118,7 +118,7 @@ class BucketElement extends element_1.Element {
         else if (field.type === 'dict') {
             type = this.buildModelType({
                 '[x in string]': field.children['#']
-            });
+            }, singleLine);
         }
         else if (field.type === 'list') {
             type = this.buildModelFieldType(field.children['#']);
@@ -130,12 +130,12 @@ class BucketElement extends element_1.Element {
             }
         }
         else if (field.type === 'union') {
-            const types = Object.values(this.buildModelType(field.children));
-            type = dump_helpers_1.DumpHelpers.dumpUnionType(types);
+            const types = Object.values(this.buildModelType(field.children, singleLine));
+            type = dump_helpers_1.DumpHelpers.dumpUnionType(types, singleLine);
         }
         if (!field.required) {
             type = '('
-                + dump_helpers_1.DumpHelpers.dumpType(type)
+                + dump_helpers_1.DumpHelpers.dumpType(type, singleLine)
                 + ' | null | undefined'
                 + ')';
         }
@@ -155,19 +155,31 @@ class BucketElement extends element_1.Element {
         });
         return composition;
     }
-    buildModelType(fields = this.schema.model.fields) {
+    buildModelType(fields = this.schema.model.fields, singleLine = false) {
         const model = {};
         Object.entries(fields).forEach(([key, field]) => {
-            model[key] = this.buildModelFieldType(field);
+            model[key] = this.buildModelFieldType(field, singleLine);
         });
         return model;
     }
-    buildModelpath(fields = this.schema.model.fields) {
-        const modelpath = {};
+    buildModelpath() {
+        const modelpath = {
+            '[x: string]': 'any'
+        };
+        // const fields = $BucketModel.getModelpaths(this.schema.model);
+        // console.log({fields});
+        // for (const k in fields) {
+        //     modelpath[k] = DumpHelpers.dumpUnionType(
+        //         fields[k].map(field => this.buildModelFieldType(field, true))
+        //         , true)
+        //     console.log(k, modelpath[k]);
+        // }
         return modelpath;
     }
     buildQuerypath(fields = this.schema.model.fields) {
-        const querypath = {};
+        const querypath = {
+            '[x: string]': 'any'
+        };
         return querypath;
     }
     buildGraphType() {

package/lib/compiler/elements/element.js

@@ -77,9 +77,10 @@ class Element {
             const msgName = name_helpers_1.NameHelpers.names(schema);
             return msgName.type;
         });
+        const _input = new Set(input);
         const output = schema['#output'] || this.makeOutputType(compiler, schema);
         return {
-            input: input.length ? input.join(' | ') : 'never',
+            input: _input.size ? [..._input].join(' | ') : 'never',
             output
         };
     }

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

@@ -81,7 +81,7 @@ class MachineElement extends element_1.Element {
             Object.entries(stateTransitions).forEach(([msg, msgTransitions]) => {
                 type[state][msg] = [];
                 Object.values(msgTransitions).forEach(transition => {
-                    const t = dump_helpers_1.DumpHelpers.dumpValueToType(transition, undefined, 4);
+                    const t = dump_helpers_1.DumpHelpers.dumpValueToType(transition, undefined, undefined, 4);
                     Object.assign(t, {
                         '#authn': element_1.Element.makeAuthnType(transition.authn),
                         '#input': element_1.Element.makeIOType(this.compiler, transition).input,
@@ -89,7 +89,7 @@ class MachineElement extends element_1.Element {
                     });
                     type[state][msg].push(t);
                 });
-                type[state][msg] = '[' + type[state][msg].map((v) => dump_helpers_1.DumpHelpers.dumpType(v, 4)).join(', ') + ']';
+                type[state][msg] = '[' + type[state][msg].map((v) => dump_helpers_1.DumpHelpers.dumpType(v, undefined, 4)).join(', ') + ']';
             });
         });
         return type;

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

@@ -161,8 +161,9 @@ class MessageElement extends element_1.Element {
                 output[key] = 'unknown';
             }
             if (!field.required || field.nullable) {
-                input[key] = '('
-                    + dump_helpers_1.DumpHelpers.dumpType(input[key])
+                const inkey = field.type === 'id' ? `${key}_id` : key;
+                input[inkey] = '('
+                    + dump_helpers_1.DumpHelpers.dumpType(input[inkey])
                     + (!field.required ? ' | undefined' : '')
                     + (field.nullable ? ' | null' : '')
                     + ')';

package/lib/compiler/helpers/dump_helpers.d.ts

@@ -3,11 +3,11 @@ type TransformTypes = {
     [x: string]: TransformTypes | ((v?: any) => TypeAsObj);
 };
 export declare class DumpHelpers {
-    static dumpUnionType(types: TypeAsObj[]): string;
-    static dumpIntersectionType(types: TypeAsObj[]): string;
-    static dumpType(type: TypeAsObj, d?: number): string;
-    static dumpSchema(val: any, d?: number): string;
+    static dumpUnionType(types: TypeAsObj[], singleLine?: boolean): string;
+    static dumpIntersectionType(types: TypeAsObj[], singleLine?: boolean): string;
+    static dumpType(type: TypeAsObj, singleLine?: boolean, d?: number): string;
+    static dumpSchema(val: any, singleLine?: boolean, d?: number): string;
     private static dumpFunction;
-    static dumpValueToType(value: any, transform?: TransformTypes, d?: number): TypeAsObj;
+    static dumpValueToType(value: any, transform?: TransformTypes, singleLine?: boolean, d?: number): TypeAsObj;
 }
 export {};

package/lib/compiler/helpers/dump_helpers.js

@@ -2,19 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DumpHelpers = void 0;
 class DumpHelpers {
-    static dumpUnionType(types) {
+    static dumpUnionType(types, singleLine = false) {
         if (types.length < 2)
-            return this.dumpType(types[0]);
-        return '(' + types.map(t => this.dumpType(t)).join(' | ') + ')';
+            return this.dumpType(types[0], singleLine);
+        return '(' + types.map(t => this.dumpType(t, singleLine)).join(' | ') + ')';
     }
-    static dumpIntersectionType(types) {
+    static dumpIntersectionType(types, singleLine = false) {
         if (types.length < 2)
-            return this.dumpType(types[0]);
-        return '(' + types.map(t => this.dumpType(t)).join(' | ') + ')';
+            return this.dumpType(types[0], singleLine);
+        return '(' + types.map(t => this.dumpType(t, singleLine)).join(' | ') + ')';
     }
-    static dumpType(type, d = 0) {
-        const pad0 = '    '.repeat(d);
-        const pad1 = '    '.repeat(d + 1);
+    static dumpType(type, singleLine = false, d = 0) {
+        const pad0 = singleLine ? ' ' : '    '.repeat(d);
+        const pad1 = singleLine ? ' ' : '    '.repeat(d + 1);
+        const lb = singleLine ? '' : '\n';
         let str = '';
         if (typeof type === 'undefined') {
             str = 'never';
@@ -27,20 +28,25 @@ class DumpHelpers {
         }
         else if (Array.isArray(type)) {
             if (type.length) {
-                str = '(' + type.map(t => this.dumpType(t)).join(' | ') + ')';
+                str = '(' + type.map(t => this.dumpType(t, singleLine)).join(' | ') + ')';
             }
             else {
                 str = 'never';
             }
         }
         else {
-            str = '{\n' +
+            str = '{' + lb +
                 Object.entries(type)
                     .filter(([key]) => !['__array', '__optional', '__or'].includes(key))
                     .map(([key, value]) => {
                     let k = key;
+                    // If key contains ${, it's a template string
+                    if (k.includes('${')) {
+                        // Put single quotes around non-alphanumeric keys
+                        k = '[_: `' + key + '`]';
+                    }
                     // If key is not a special [],
-                    if (!(k.startsWith('[') && k.endsWith(']'))
+                    else if (!(k.startsWith('[') && k.endsWith(']'))
                         && !(k.startsWith('`') && k.endsWith('`'))) {
                         // Put single quotes around non-alphanumeric keys
                         k = /[^\w]/.exec(key) ? `'${key}'` : key;
@@ -58,14 +64,14 @@ class DumpHelpers {
                         k += '?';
                     }
                     // Dump element type
-                    const t = this.dumpType(value, d + 1);
+                    const t = this.dumpType(value, singleLine, d + 1);
                     return `${pad1}${k}: ${t}`;
-                }).join(',\n')
-                + `\n${pad0}}`;
+                }).join(',' + lb)
+                + `${lb}${pad0}}`;
         }
         if (typeof type === 'object') {
             if (type.__or) {
-                str += ' | ' + this.dumpType(type.__or, d);
+                str += ' | ' + this.dumpType(type.__or, singleLine, d);
             }
             if (type.__array) {
                 str = `(${str})[]`;
@@ -76,9 +82,10 @@ class DumpHelpers {
         }
         return str;
     }
-    static dumpSchema(val, d = 0) {
-        const pad0 = '    '.repeat(d);
-        const pad1 = '    '.repeat(d + 1);
+    static dumpSchema(val, singleLine = false, d = 0) {
+        const pad0 = singleLine ? ' ' : '    '.repeat(d);
+        const pad1 = singleLine ? ' ' : '    '.repeat(d + 1);
+        const lb = singleLine ? '' : '\n';
         if (typeof val === 'undefined') {
             return 'undefined';
         }
@@ -95,22 +102,22 @@ class DumpHelpers {
             return val.description || 'undefined';
         }
         else if (Array.isArray(val)) {
-            return '[\n' +
+            return '[' + lb +
                 val.map(child => {
-                    return `${pad1}${this.dumpSchema(child, d + 1)}`;
-                }).join(',\n')
-                + `\n${pad0}]`;
+                    return `${pad1}${this.dumpSchema(child, singleLine, d + 1)}`;
+                }).join(',' + lb)
+                + `${lb}${pad0}]`;
         }
         else if (typeof val === 'object') {
             if ('__fn' in val) {
                 return val.__fn;
             }
-            return '{\n' +
+            return '{' + lb +
                 Object.entries(val).map(([key, child]) => {
                     const _key = key.match(/\W/) ? `'${key}'` : key;
-                    return `${pad1}${_key}: ${this.dumpSchema(child, d + 1)}`;
-                }).join(',\n')
-                + `\n${pad0}}`;
+                    return `${pad1}${_key}: ${this.dumpSchema(child, singleLine, d + 1)}`;
+                }).join(',' + lb)
+                + `${lb}${pad0}}`;
         }
         else if (typeof val === 'function') {
             return this.dumpFunction(val, pad0);
@@ -122,7 +129,7 @@ class DumpHelpers {
         // if not, we try to use the JS version.
         return `/* TS BRIDGE WARN: function not properly extracted from source. Attempting JS version (imports will not work) */ (${fn.toString()}) as any`;
     }
-    static dumpValueToType(value, transform = {}, d = 2) {
+    static dumpValueToType(value, transform = {}, singleLine = false, d = 2) {
         if (value === undefined) {
             return 'undefined';
         }
@@ -143,7 +150,7 @@ class DumpHelpers {
                 if (value.length === 0) {
                     return 'never[]';
                 }
-                return '[' + value.map((v) => DumpHelpers.dumpType(this.dumpValueToType(v, transform, d + 1), d)).join(', ') + ']';
+                return '[' + value.map((v) => DumpHelpers.dumpType(this.dumpValueToType(v, transform, singleLine, d + 1), singleLine, d)).join(', ') + ']';
             }
             else {
                 const obj = {};
@@ -158,7 +165,7 @@ class DumpHelpers {
                         obj[key] = transform[key](value);
                     }
                     else {
-                        obj[key] = this.dumpValueToType(value, transform[key], d + 1);
+                        obj[key] = this.dumpValueToType(value, transform[key], singleLine, d + 1);
                     }
                 });
                 return obj;

package/lib/compiler/typescript/typescript_compiler.js

@@ -271,6 +271,9 @@ class TypeScriptCompiler {
                     // string: A specific key
                     const parseObj = (node, path, nested = false) => {
                         return node.properties.map(prop => {
+                            if (ts.isSpreadAssignment(prop)) {
+                                return [];
+                            }
                             if (!ts.isPropertyAssignment(prop)) {
                                 throw new Error('A nesoi builder object property must be an assignment');
                             }

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

@@ -141,7 +141,7 @@ export declare abstract class BucketAdapter<Obj extends NesoiObj> {
     }): Promise<NQL_Result<MetadataOnly extends true ? {
         id: Obj['id'];
         [x: string]: any;
-    }[] : Obj[]>>;
+    } : Obj>>;
     /**
      * Return the epoch of the last update of an object
      * @param {Obj} obj An object of this bucket

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

@@ -6,6 +6,13 @@ import { BucketCacheSync } from '../cache/bucket_cache';
 /**
  * @category Adapters
  * @subcategory Entity
+ *
+ * > Every method that alters data makes a `Deep.copy` of the input
+ * > before processing it, to avoid side-effects to the input data
+ * > by modifying the external data on the adapter.
+ * > It also makes a `Deep.copy` of the data before outputting it,
+ * > to avoid side-effects on the adapter data by modifying the returned
+ * > object externally.
  * */
 export declare class MemoryBucketAdapter<B extends $Bucket, Obj extends B['#data']> extends BucketAdapter<Obj> {
     schema: B;

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

@@ -4,9 +4,17 @@ exports.MemoryBucketAdapter = void 0;
 const bucket_adapter_1 = require("./bucket_adapter");
 const crypto_1 = require("crypto");
 const memory_nql_1 = require("./memory.nql");
+const bucket_model_schema_1 = require("../model/bucket_model.schema");
 /**
  * @category Adapters
  * @subcategory Entity
+ *
+ * > Every method that alters data makes a `Deep.copy` of the input
+ * > before processing it, to avoid side-effects to the input data
+ * > by modifying the external data on the adapter.
+ * > It also makes a `Deep.copy` of the data before outputting it,
+ * > to avoid side-effects on the adapter data by modifying the returned
+ * > object externally.
  * */
 class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
     constructor(schema, data = {}, config) {
@@ -37,12 +45,14 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
     }
     /* Write Operations */
     async create(trx, obj) {
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
         const lastId = (await this.index(trx))
-            .map((obj) => parseInt(obj.id))
+            .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);
+        input.id = lastId + 1;
+        this.data[input.id] = input;
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        return Promise.resolve(output);
     }
     async createMany(trx, objs) {
         const out = [];
@@ -55,17 +65,16 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         if (!obj.id || !this.data[obj.id]) {
             throw new Error(`Object with id ${obj.id} not found for replace`);
         }
-        this.data[obj.id] = obj;
-        return Promise.resolve(obj);
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        this.data[input.id] = input;
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        return Promise.resolve(output);
     }
-    replaceMany(trx, objs) {
+    async replaceMany(trx, objs) {
         const out = [];
         for (const obj of objs) {
-            if (!obj.id || !this.data[obj.id]) {
-                throw new Error(`Object with id ${obj.id} not found for replace`);
-            }
-            this.data[obj.id] = obj;
-            out.push(obj);
+            const output = await this.replace(trx, obj);
+            out.push(output);
         }
         return Promise.resolve(out);
     }
@@ -73,39 +82,38 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         if (!obj.id || !this.data[obj.id]) {
             throw new Error(`Object with id ${obj.id} not found for patch`);
         }
-        const _input = this.data[obj.id];
-        const _obj = obj;
-        for (const key in _obj) {
-            if (_obj[key] === null) {
-                delete _input[key];
+        const data = this.data[obj.id];
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        for (const key in input) {
+            if (input[key] === null) {
+                delete data[key];
             }
-            else if (_obj[key] !== undefined) {
-                _input[key] = _obj[key];
+            else if (input[key] !== undefined) {
+                data[key] = input[key];
             }
         }
-        return Promise.resolve(_input);
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, data, this.config.meta);
+        return Promise.resolve(output);
     }
-    patchMany(trx, objs) {
+    async patchMany(trx, objs) {
         const out = [];
         for (const obj of objs) {
-            if (!obj.id || !this.data[obj.id]) {
-                throw new Error(`Object with id ${obj.id} not found for patch`);
-            }
-            // TODO: Implement patch
-            this.data[obj.id] = obj;
-            out.push(obj);
+            const output = await this.patch(trx, obj);
+            out.push(output);
         }
         return Promise.resolve(out);
     }
     async put(trx, obj) {
-        if (!obj.id) {
+        const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+        if (!input.id) {
             const lastId = (await this.index(trx))
-                .map((obj) => parseInt(obj.id))
+                .map((_obj) => parseInt(_obj.id))
                 .sort((a, b) => b - a)[0] || 0;
-            obj.id = lastId + 1;
+            input.id = lastId + 1;
         }
-        this.data[obj.id] = obj;
-        return Promise.resolve(obj);
+        this.data[input.id] = input;
+        const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+        return Promise.resolve(output);
     }
     async putMany(trx, objs) {
         const lastId = (await this.index(trx))
@@ -114,11 +122,13 @@ class MemoryBucketAdapter extends bucket_adapter_1.BucketAdapter {
         let id = lastId + 1;
         const out = [];
         for (const obj of objs) {
-            if (!obj.id) {
-                obj.id = id;
+            const input = bucket_model_schema_1.$BucketModel.copy(this.schema.model, obj, this.config.meta);
+            if (!input.id) {
+                input.id = id;
             }
-            this.data[obj.id] = obj;
-            out.push(obj);
+            this.data[input.id] = input;
+            const output = bucket_model_schema_1.$BucketModel.copy(this.schema.model, input, this.config.meta);
+            out.push(output);
             id++;
         }
         return Promise.resolve(out);

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

@@ -425,11 +425,13 @@ class Bucket {
                 continue;
             const linkObj = composition[link.name];
             if (!linkObj) {
-                throw error_1.NesoiError.Bucket.MissingComposition({ method: 'patch', bucket: this.schema.name, link: link.name });
+                if (mode === 'patch')
+                    continue;
+                throw error_1.NesoiError.Bucket.MissingComposition({ method: 'replace', bucket: this.schema.name, link: link.name });
             }
             if (link.many) {
                 if (!Array.isArray(linkObj)) {
-                    throw error_1.NesoiError.Bucket.CompositionValueShouldBeArray({ method: 'patch', bucket: this.schema.name, link: link.name });
+                    throw error_1.NesoiError.Bucket.CompositionValueShouldBeArray({ method: 'replace', bucket: this.schema.name, link: link.name });
                 }
                 for (const linkObjItem of linkObj) {
                     await trx.bucket(link.bucket.refName)[mode](linkObjItem);
@@ -525,20 +527,44 @@ class Bucket {
             }
         }
         // Delete compositions (with other key)
+        // Currently there's only 'self' key
+        //
+        // for(const link of Object.values(this.schema.graph.links)) {
+        //     if (link.rel !== 'composition') continue;
+        //     if (link.keyOwner !== 'other') continue;
+        //     const linked = await this.graph.readLink(trx, id, link.name, {
+        //         silent: true
+        //     }) as any;
+        //     if (!linked) continue;
+        //     if (link.many) {
+        //         for (const linkedItem of linked) {
+        //             await trx.bucket(link.bucket.refName).delete(linkedItem.id);
+        //         }
+        //     }
+        //     else {
+        //         await trx.bucket(link.bucket.refName).delete(linked.id);
+        //     }
+        // }
+        // Composition (with self key)
         for (const link of Object.values(this.schema.graph.links)) {
             if (link.rel !== 'composition')
                 continue;
-            if (link.keyOwner !== 'other')
+            if (link.keyOwner !== 'self')
                 continue;
-            const linked = await this.readLink(trx, id, link.name, {
-                silent: true
-            });
+            const linked = result
+                // If safe, avoid reading the object again inside readLink.
+                // Instead, use graph's readLink which takes the object.
+                ? await this.graph.readLink(trx, result.data[0], link.name, {
+                    silent: true
+                })
+                // If unsafe, read the link base by id.
+                : await this.readLink(trx, id, link.name, {
+                    silent: true
+                });
             if (!linked)
                 continue;
             if (link.many) {
-                for (const linkedItem of linked) {
-                    await trx.bucket(link.bucket.refName).delete(linkedItem.id);
-                }
+                await trx.bucket(link.bucket.refName).unsafe.deleteMany(linked.map((l) => l.id));
             }
             else {
                 await trx.bucket(link.bucket.refName).delete(linked.id);
@@ -550,24 +576,6 @@ class Bucket {
             await trash_1.Trash.add(trx, this.module, this.schema.name, obj);
         }
         await this.adapter.delete(trx, id);
-        // Composition (with self key)
-        for (const link of Object.values(this.schema.graph.links)) {
-            if (link.rel !== 'composition')
-                continue;
-            if (link.keyOwner !== 'self')
-                continue;
-            const linked = await this.readLink(trx, id, link.name, {
-                silent: true
-            });
-            if (!linked)
-                continue;
-            if (link.many) {
-                await trx.bucket(link.bucket.refName).unsafe.deleteMany(linked.map((l) => l.id));
-            }
-            else {
-                await trx.bucket(link.bucket.refName).delete(linked.id);
-            }
-        }
     }
     /**
      * Delete many entities

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

@@ -35,10 +35,7 @@ export declare class BucketCache<Obj extends NesoiObj> {
     constructor(bucketName: string, outerAdapter: AnyBucketAdapter, 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[] | {
-        [x: string]: any;
-        id: any;
-    }[]> | Obj[]>;
+    query(trx: AnyTrxNode, view: $BucketView, query: NQL_AnyQuery, pagination?: NQL_Pagination): Promise<NQL_Result<any> | Obj[]>;
     private syncOne;
     private syncOneAndPast;
     private syncAll;

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

@@ -18,14 +18,10 @@ export type BucketModelpathObjInfer<Builders extends BucketModelFieldBuilders<an
     };
 }[keyof Builders]>;
 export type BucketModelpathListInfer<Builder extends AnyBucketModelFieldBuilder> = {
-    [J in keyof Builder['#modelpath'] as `.$${number}${J & string}` | `.${number}${J & string}`]: Builder['#modelpath'][J];
-} & {
-    [J in keyof Builder['#modelpath'] as `.${'*'}${J & string}`]: Builder['#modelpath'][J][];
+    [J in keyof Builder['#modelpath'] as `.*${J & string}` | `.$${number}${J & string}` | `.${number}${J & string}`]: Builder['#modelpath'][J];
 };
 export type BucketModelpathDictInfer<Builder extends AnyBucketModelFieldBuilder> = {
-    [J in keyof Builder['#modelpath'] as `.$${number}${J & string}` | `.${string}${J & string}`]: Builder['#modelpath'][J];
-} & {
-    [J in keyof Builder['#modelpath'] as `.${'*'}${J & string}`]: Record<string, Builder['#modelpath'][J]>;
+    [J in keyof Builder['#modelpath'] as `.*${J & string}` | `.$${number}${J & string}` | `.${string}${J & string}`]: Builder['#modelpath'][J];
 };
 export type BucketModelpathUnionInfer<Builders extends AnyBucketModelFieldBuilder[]> = Builders[0]['#modelpath'] | Builders[1]['#modelpath'];
 export type BucketModelpathInfer<Def extends BucketModelDef<any, any>> = BucketModelpathRawInfer<ReturnType<Def>>;

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

@@ -1,4 +1,5 @@
 import { $Dependency } from "../../../../engine/dependency";
+import { BucketAdapterConfig } from '../adapters/bucket_adapter';
 export type $BucketModelFieldType = 'boolean' | 'date' | 'datetime' | 'duration' | 'decimal' | 'enum' | 'file' | 'float' | 'int' | 'string' | 'obj' | 'unknown' | 'dict' | 'list' | 'union';
 export type $BucketModelFieldCrypto = {
     algorithm: string;
@@ -67,5 +68,7 @@ export declare class $BucketModel {
     }, defaults?: Record<string, any>, hasFileField?: boolean, hasEncryptedField?: boolean);
     static getField(model: $BucketModel, modelpath: string): $BucketModelField[];
     static fieldsOfType(model: $BucketModel, type: $BucketModelFieldType): $BucketModelField[];
-    static forEachField(template: $BucketModel, predicate: (field: $BucketModelField, unionKey?: number) => Promise<void>): Promise<void>;
+    static forEachField(model: $BucketModel, predicate: (field: $BucketModelField, path: string) => void): void;
+    static copy<T extends Record<string, any>>(model: $BucketModel, obj: T, meta?: BucketAdapterConfig['meta']): T;
+    static getModelpaths(model: $BucketModel): Record<string, $BucketModelField[]>;
 }