nesoi 3.4.2 → 3.4.4

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

@@ -6,6 +6,8 @@ const date_1 = require("../../../../engine/data/date");
 const datetime_1 = require("../../../../engine/data/datetime");
 const decimal_1 = require("../../../../engine/data/decimal");
 const duration_1 = require("../../../../engine/data/duration");
+const log_1 = require("../../../../engine/util/log");
+const parse_1 = require("../../../../engine/util/parse");
 /**
  * @category Elements
  * @subcategory Entity
@@ -19,7 +21,7 @@ class BucketModel {
         this.alias = bucket.alias;
         this.schema = bucket.model;
     }
-    copy(obj, op, serialize, modelpath) {
+    copy(obj, op, serialize, modelpath_or_roots) {
         const meta = this.config?.meta || {
             created_at: 'created_at',
             created_by: 'created_by',
@@ -28,11 +30,12 @@ class BucketModel {
         };
         const copy = {};
         const modelpath_results = [];
-        const paths = modelpath?.split('.');
-        let poll = paths
+        const roots = Array.isArray(modelpath_or_roots) ? modelpath_or_roots : undefined;
+        const paths = Array.isArray(modelpath_or_roots) ? undefined : modelpath_or_roots?.split('.');
+        const poll = paths
             // Specific modelpath requested, start with root field only
             ? [{
-                    path: paths[0],
+                    key: paths[0],
                     obj,
                     copy,
                     field: this.schema.fields[paths[0]],
@@ -40,300 +43,309 @@ class BucketModel {
                     modelpath: { i: 0, asterisk_values: [] }
                 }]
             // No modelpath, use all fields
-            : Object.entries(this.schema.fields).map(([path, field]) => ({
-                path, obj, copy, field, depth: 0
+            : Object.entries(this.schema.fields)
+                .filter(([_, field]) => !roots || roots.includes(field.path))
+                .map(([path, field]) => ({
+                key: path,
+                obj,
+                copy,
+                field,
+                depth: 0
             }));
+        modelpath_results.push(...this.runCopyCmdPoll(op, poll, paths, serialize));
+        copy[meta.created_by] = obj[meta.created_by];
+        copy[meta.updated_by] = obj[meta.updated_by];
+        const meta_as_json = serialize?.();
+        const created_at = obj[meta.created_at];
+        if (typeof created_at === 'string') {
+            copy[meta.created_at] = meta_as_json ? created_at : datetime_1.NesoiDatetime.fromISO(obj[created_at]);
+        }
+        else if (created_at instanceof datetime_1.NesoiDatetime) {
+            copy[meta.created_at] = meta_as_json ? created_at.toISO() : created_at;
+        }
+        const updated_at = obj[meta.updated_at];
+        if (typeof updated_at === 'string') {
+            copy[meta.updated_at] = meta_as_json ? updated_at : datetime_1.NesoiDatetime.fromISO(obj[updated_at]);
+        }
+        else if (updated_at instanceof datetime_1.NesoiDatetime) {
+            copy[meta.updated_at] = meta_as_json ? updated_at.toISO() : updated_at;
+        }
+        if (paths)
+            return modelpath_results;
+        return copy;
+    }
+    runCopyCmdPoll(op, poll, modelpath, serialize) {
+        const modelpath_results = [];
         while (poll.length) {
             const next = [];
-            for (const entry of poll) {
-                if (entry.is_union_option) {
-                    const alreadyParsed = entry.copy[entry.path] !== undefined;
-                    if (alreadyParsed)
-                        continue;
-                }
-                const val = entry.obj[entry.path];
-                if (val === undefined) {
-                    delete entry.copy[entry.path];
-                    continue;
-                }
-                if (val === null) {
-                    delete entry.copy[entry.path];
-                    continue;
-                }
-                const isLeafPath = entry.modelpath
-                    ? entry.modelpath.i === (paths?.length ?? 0) - 1
+            for (const cmd of poll) {
+                const isLeafPath = cmd.modelpath
+                    ? cmd.modelpath.i === (modelpath?.length ?? 0) - 1
                     : false;
-                const nextPath = (!entry.modelpath || isLeafPath)
-                    ? undefined
-                    : paths[entry.modelpath.i + 1];
-                const addChildrenToQueue = !entry.modelpath
-                    || entry.modelpath.i >= (paths.length - 1)
-                    || nextPath === '*';
-                if (entry.field.type === 'list') {
-                    if (!Array.isArray(val))
-                        continue;
-                    entry.copy[entry.path] = [];
-                    // Leaf path or no modelpath = add entire list to queue
-                    if (addChildrenToQueue) {
-                        next.push(...val.map((_, i) => ({
-                            path: i.toString(),
-                            obj: val,
-                            copy: entry.copy[entry.path],
-                            field: entry.field.children['#'],
-                            depth: entry.depth + 1,
-                            modelpath: entry.modelpath ? {
-                                i: entry.modelpath.i + 1,
-                                asterisk_values: [...entry.modelpath.asterisk_values, ...(nextPath === '*' ? [i.toString()] : [])]
-                            } : undefined
-                        })));
-                    }
-                    // Branch path = add next path to queue
-                    else {
-                        next.push({
-                            path: nextPath,
-                            obj: val,
-                            copy: entry.copy[entry.path],
-                            field: entry.field.children['#'],
-                            depth: entry.depth + 1,
-                            modelpath: entry.modelpath ? {
-                                i: entry.modelpath.i + 1,
-                                asterisk_values: entry.modelpath.asterisk_values
-                            } : undefined
-                        });
-                    }
-                }
-                else if (entry.field.type === 'dict') {
-                    if (typeof val !== 'object' || Array.isArray(val))
-                        continue;
-                    entry.copy[entry.path] = {};
-                    // Leaf path or no modelpath = add entire dict to queue
-                    if (addChildrenToQueue) {
-                        next.push(...Object.keys(val).map((path) => ({
-                            path,
-                            obj: val,
-                            copy: entry.copy[entry.path],
-                            field: entry.field.children['#'],
-                            depth: entry.depth + 1,
-                            modelpath: entry.modelpath ? {
-                                i: entry.modelpath.i + 1,
-                                asterisk_values: [...entry.modelpath.asterisk_values, ...(nextPath === '*' ? [path] : [])]
-                            } : undefined
-                        })));
-                    }
-                    // Branch path = add next path to queue
-                    else {
-                        next.push({
-                            path: nextPath,
-                            obj: val,
-                            copy: entry.copy[entry.path],
-                            field: entry.field.children['#'],
-                            depth: entry.depth + 1,
-                            modelpath: entry.modelpath ? {
-                                i: entry.modelpath.i + 1,
-                                asterisk_values: entry.modelpath.asterisk_values
-                            } : undefined
-                        });
-                    }
-                }
-                else if (entry.field.type === 'obj') {
-                    if (typeof val !== 'object' || Array.isArray(val))
-                        continue;
-                    // disambiguate between dict and obj when obj comes first
-                    // on a union
-                    const objectHasValidFields = Object.keys(val).some(key => key in entry.field.children);
-                    if (!objectHasValidFields)
-                        continue;
-                    entry.copy[entry.path] = {};
-                    // Leaf path or no modelpath = add entire dict to queue
-                    if (addChildrenToQueue) {
-                        next.push(...Object.keys(entry.field.children).map(path => ({
-                            path: path,
-                            obj: val,
-                            copy: entry.copy[entry.path],
-                            field: entry.field.children[path],
-                            depth: entry.depth + 1,
-                            modelpath: entry.modelpath ? {
-                                i: entry.modelpath.i + 1,
-                                asterisk_values: [...entry.modelpath.asterisk_values, ...(nextPath === '*' ? [path] : [])]
-                            } : undefined
-                        })));
-                    }
-                    // Branch path = add next path to queue
-                    else {
-                        next.push({
-                            path: nextPath,
-                            obj: val,
-                            copy: entry.copy[entry.path],
-                            field: entry.field.children[nextPath],
-                            depth: entry.depth + 1,
-                            modelpath: entry.modelpath ? {
-                                i: entry.modelpath.i + 1,
-                                asterisk_values: entry.modelpath.asterisk_values
-                            } : undefined
-                        });
-                    }
-                }
-                else if (entry.field.type === 'union') {
-                    const options = Object.entries(entry.field.children);
-                    // Add union options to queue with flag
-                    // This flag avoids reparsing a value if an earlier option already did it
-                    next.push(...options.map(([_, option], i) => ({
-                        ...entry,
-                        field: option,
-                        is_union_option: i === options.length - 1 ? 'last' : true
-                    })));
-                    continue;
-                }
-                else if (entry.field.type === 'enum') {
-                    const v = entry.obj[entry.path];
-                    const options = entry.field.meta.enum.options;
-                    if (!(v in options)) {
-                        if (entry.is_union_option !== true) {
-                            throw error_1.NesoiError.Bucket.Model.InvalidEnum({ bucket: this.alias, value: v, options: Object.keys(options) });
-                        }
-                    }
-                    entry.copy[entry.path] = entry.obj[entry.path];
-                }
-                else if (entry.field.type === 'date') {
-                    const v = entry.obj[entry.path];
-                    if (serialize?.(entry)) {
-                        if (op === 'load') {
-                            try {
-                                entry.copy[entry.path] = date_1.NesoiDate.fromISO(v);
-                            }
-                            catch {
-                                if (entry.is_union_option !== true) {
-                                    throw error_1.NesoiError.Bucket.Model.InvalidISODate({ bucket: this.alias, value: v });
-                                }
-                                continue;
-                            }
-                        }
-                        else if (op === 'save') {
-                            try {
-                                entry.copy[entry.path] = v.toISO();
-                            }
-                            catch {
-                                if (entry.is_union_option !== true) {
-                                    throw error_1.NesoiError.Bucket.Model.InvalidNesoiDate({ bucket: this.alias, value: v });
-                                }
-                                continue;
-                            }
-                        }
-                    }
-                    else {
-                        entry.copy[entry.path] = entry.obj[entry.path];
-                    }
-                }
-                else if (entry.field.type === 'datetime') {
-                    const v = entry.obj[entry.path];
-                    if (serialize?.(entry)) {
-                        if (op === 'load') {
-                            try {
-                                entry.copy[entry.path] = datetime_1.NesoiDatetime.fromISO(v);
-                            }
-                            catch {
-                                if (entry.is_union_option !== true) {
-                                    throw error_1.NesoiError.Bucket.Model.InvalidISODatetime({ bucket: this.alias, value: v });
-                                }
-                                continue;
-                            }
-                        }
-                        else if (op === 'save') {
-                            try {
-                                entry.copy[entry.path] = v.toISO();
-                            }
-                            catch {
-                                if (entry.is_union_option !== true) {
-                                    throw error_1.NesoiError.Bucket.Model.InvalidNesoiDatetime({ bucket: this.alias, value: v });
-                                }
-                                continue;
-                            }
-                        }
-                    }
-                    else {
-                        entry.copy[entry.path] = entry.obj[entry.path];
-                    }
-                }
-                else if (entry.field.type === 'decimal') {
-                    const meta = entry.field.meta.decimal;
-                    const v = entry.obj[entry.path];
-                    if (serialize?.(entry)) {
-                        if ((op === 'load' && typeof v !== 'string') || (op === 'save' && !(v instanceof decimal_1.NesoiDecimal))) {
-                            if (entry.is_union_option !== true) {
-                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDecimal({ bucket: this.alias, value: v });
-                            }
-                            continue;
+                if (cmd.field.type === 'union') {
+                    const options = Object.values(cmd.field.children);
+                    let unionErrors = [];
+                    for (const option of options) {
+                        try {
+                            // Clean field for next attempt
+                            delete cmd.copy[cmd.key];
+                            // Attempt union option
+                            modelpath_results.push(...this.runCopyCmdPoll(op, [{
+                                    ...cmd,
+                                    field: option
+                                }], modelpath, serialize));
+                            // Success, clear errors and proceed
+                            unionErrors = [];
+                            break;
                         }
-                        if (op === 'load')
-                            entry.copy[entry.path] = new decimal_1.NesoiDecimal(v, meta?.left, meta?.right);
-                        if (op === 'save')
-                            entry.copy[entry.path] = v.toString();
-                    }
-                    else {
-                        if (!(v instanceof decimal_1.NesoiDecimal)) {
-                            if (entry.is_union_option !== true) {
-                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDecimal({ bucket: this.alias, value: v });
-                            }
-                            continue;
+                        catch (e) {
+                            unionErrors.push(e);
                         }
-                        entry.copy[entry.path] = v;
                     }
-                }
-                else if (entry.field.type === 'duration') {
-                    const v = entry.obj[entry.path];
-                    if (serialize?.(entry)) {
-                        if ((op === 'load' && typeof v !== 'string') || (op === 'save' && !(v instanceof duration_1.NesoiDuration))) {
-                            if (entry.is_union_option !== true) {
-                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDuration({ bucket: this.alias, value: v });
-                            }
-                            continue;
-                        }
-                        if (op === 'load')
-                            entry.copy[entry.path] = duration_1.NesoiDuration.fromString(v);
-                        if (op === 'save')
-                            entry.copy[entry.path] = v.toString();
-                    }
-                    else {
-                        if (!(v instanceof duration_1.NesoiDuration)) {
-                            if (entry.is_union_option !== true) {
-                                throw error_1.NesoiError.Bucket.Model.InvalidNesoiDuration({ bucket: this.alias, value: v });
-                            }
-                            continue;
-                        }
-                        entry.copy[entry.path] = v;
+                    if (unionErrors.length) {
+                        throw error_1.NesoiError.Message.ValueDoesntMatchUnion({ alias: cmd.field.alias, path: '', value: cmd.obj[cmd.key], unionErrors });
                     }
                 }
                 else {
-                    entry.copy[entry.path] = entry.obj[entry.path];
+                    const as_json = serialize?.(cmd);
+                    next.push(...this.runCopyCmd(op, cmd, modelpath, as_json));
                 }
                 if (isLeafPath) {
                     modelpath_results.push({
-                        value: entry.copy[entry.path],
-                        index: entry.modelpath.asterisk_values
+                        value: cmd.copy[cmd.key],
+                        index: cmd.modelpath.asterisk_values
                     });
                 }
             }
             poll = next;
         }
-        copy[meta.created_by] = obj[meta.created_by];
-        copy[meta.updated_by] = obj[meta.updated_by];
-        if (serialize?.()) {
-            if (op === 'load') {
-                copy[meta.created_at] = obj[meta.created_at] ? datetime_1.NesoiDatetime.fromISO(obj[meta.created_at]) : undefined;
-                copy[meta.updated_at] = obj[meta.updated_at] ? datetime_1.NesoiDatetime.fromISO(obj[meta.updated_at]) : undefined;
+        return modelpath_results;
+    }
+    runCopyCmd(op, cmd, modelpath, as_json = false) {
+        const next = [];
+        const value = cmd.obj[cmd.key];
+        if (value === undefined || value === null) {
+            if (cmd.field.path !== 'id' && cmd.field.required) {
+                if (op === 'load') {
+                    log_1.Log.warn('bucket.model', this.alias, `Object with id ${cmd.obj.id} missing required field '${cmd.field.path}' during read`);
+                }
+                else {
+                    throw error_1.NesoiError.Bucket.Model.FieldRequired({ bucket: this.alias, field: cmd.field.alias });
+                }
+            }
+            delete cmd.copy[cmd.key];
+            return [];
+        }
+        const isLeafPath = cmd.modelpath
+            ? cmd.modelpath.i === (modelpath?.length ?? 0) - 1
+            : false;
+        const nextPath = (!cmd.modelpath || isLeafPath)
+            ? undefined
+            : modelpath[cmd.modelpath.i + 1];
+        const addChildrenToQueue = !cmd.modelpath
+            || cmd.modelpath.i >= (modelpath.length - 1) // is leaf or inner field
+            || nextPath === '*';
+        if (cmd.field.type === 'list') {
+            if (!Array.isArray(value)) {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'list' });
+            }
+            cmd.copy[cmd.key] = [];
+            // Leaf path or no modelpath = add entire list to queue
+            if (addChildrenToQueue) {
+                next.push(...value.map((_, i) => ({
+                    key: i.toString(),
+                    obj: value,
+                    copy: cmd.copy[cmd.key],
+                    field: cmd.field.children['#'],
+                    depth: cmd.depth + 1,
+                    modelpath: cmd.modelpath ? {
+                        i: cmd.modelpath.i + 1,
+                        asterisk_values: [...cmd.modelpath.asterisk_values, ...(nextPath === '*' ? [i.toString()] : [])]
+                    } : undefined
+                })));
+            }
+            // Branch path = add next path to queue
+            else {
+                next.push({
+                    key: nextPath,
+                    obj: value,
+                    copy: cmd.copy[cmd.key],
+                    field: cmd.field.children['#'],
+                    depth: cmd.depth + 1,
+                    modelpath: cmd.modelpath ? {
+                        i: cmd.modelpath.i + 1,
+                        asterisk_values: cmd.modelpath.asterisk_values
+                    } : undefined
+                });
+            }
+            return next;
+        }
+        else if (cmd.field.type === 'dict') {
+            if (typeof value !== 'object' || Array.isArray(value)) {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'dict' });
+            }
+            cmd.copy[cmd.key] = {};
+            // Leaf path or no modelpath = add entire dict to queue
+            if (addChildrenToQueue) {
+                next.push(...Object.keys(value).map((key) => ({
+                    key,
+                    obj: value,
+                    copy: cmd.copy[cmd.key],
+                    field: cmd.field.children['#'],
+                    depth: cmd.depth + 1,
+                    modelpath: cmd.modelpath ? {
+                        i: cmd.modelpath.i + 1,
+                        asterisk_values: [...cmd.modelpath.asterisk_values, ...(nextPath === '*' ? [key] : [])]
+                    } : undefined
+                })));
+            }
+            // Branch path = add next path to queue
+            else if (nextPath in value) {
+                next.push({
+                    key: nextPath,
+                    obj: value,
+                    copy: cmd.copy[cmd.key],
+                    field: cmd.field.children['#'],
+                    depth: cmd.depth + 1,
+                    modelpath: cmd.modelpath ? {
+                        i: cmd.modelpath.i + 1,
+                        asterisk_values: cmd.modelpath.asterisk_values
+                    } : undefined
+                });
+            }
+            return next;
+        }
+        else if (cmd.field.type === 'obj') {
+            if (typeof value !== 'object' || Array.isArray(value)) {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'obj' });
+            }
+            if (op === 'save') {
+                const missingKeys = Object.entries(cmd.field.children)
+                    .filter(([key, child]) => child.required
+                    && key !== 'id'
+                    && !(key in cmd.obj[cmd.key]));
+                if (missingKeys.length) {
+                    throw new Error(`Object with id ${cmd.obj.id} from bucket ${this.alias} is missing keys`);
+                }
+            }
+            else {
+                const matchingKeys = Object.entries(cmd.field.children)
+                    .filter(([key, child]) => !child.required
+                    || (key !== 'id' && key in cmd.obj[cmd.key]));
+                if (!matchingKeys.length) {
+                    throw new Error(`Object with id ${cmd.obj.id} from bucket ${this.alias} has no matching keys`);
+                }
+            }
+            cmd.copy[cmd.key] = {};
+            // Leaf path or no modelpath = add entire dict to queue
+            if (addChildrenToQueue) {
+                next.push(...Object.keys(cmd.field.children).map(path => ({
+                    key: path,
+                    obj: value,
+                    copy: cmd.copy[cmd.key],
+                    field: cmd.field.children[path],
+                    depth: cmd.depth + 1,
+                    modelpath: cmd.modelpath ? {
+                        i: cmd.modelpath.i + 1,
+                        asterisk_values: [...cmd.modelpath.asterisk_values, ...(nextPath === '*' ? [path] : [])]
+                    } : undefined
+                })));
+            }
+            // Branch path = add next path to queue
+            else {
+                next.push({
+                    key: nextPath,
+                    obj: value,
+                    copy: cmd.copy[cmd.key],
+                    field: cmd.field.children[nextPath],
+                    depth: cmd.depth + 1,
+                    modelpath: cmd.modelpath ? {
+                        i: cmd.modelpath.i + 1,
+                        asterisk_values: cmd.modelpath.asterisk_values
+                    } : undefined
+                });
+            }
+            return next;
+        }
+        else if (cmd.field.type === 'enum') {
+            if (typeof value !== 'string') {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'obj' });
+            }
+            const options = cmd.field.meta.enum.options;
+            if (!(value in options)) {
+                throw error_1.NesoiError.Bucket.Model.InvalidEnum({ bucket: this.alias, value, options: Object.keys(options) });
             }
-            else if (op === 'save') {
-                copy[meta.created_at] = obj[meta.created_at]?.toISO?.();
-                copy[meta.updated_at] = obj[meta.updated_at]?.toISO?.();
+            cmd.copy[cmd.key] = cmd.obj[cmd.key];
+            return [];
+        }
+        else if (cmd.field.type === 'date') {
+            if (value instanceof date_1.NesoiDate) {
+                cmd.copy[cmd.key] = as_json ? value.toISO() : value;
+            }
+            else if (typeof value === 'string') {
+                const date = date_1.NesoiDate.fromISO(value);
+                cmd.copy[cmd.key] = as_json ? date.toISO() : date;
+            }
+            else {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'date' });
+            }
+        }
+        else if (cmd.field.type === 'datetime') {
+            if (value instanceof datetime_1.NesoiDatetime) {
+                cmd.copy[cmd.key] = as_json ? value.toISO() : value;
+            }
+            else if (typeof value === 'string') {
+                const datetime = datetime_1.NesoiDatetime.fromISO(value);
+                cmd.copy[cmd.key] = as_json ? datetime.toISO() : datetime;
+            }
+            else {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'datetime' });
+            }
+        }
+        else if (cmd.field.type === 'decimal') {
+            if (value instanceof decimal_1.NesoiDecimal) {
+                cmd.copy[cmd.key] = as_json ? value.toString() : value;
+            }
+            else if (typeof value === 'string') {
+                const meta = cmd.field.meta.decimal;
+                const decimal = new decimal_1.NesoiDecimal(value, meta?.left, meta?.right);
+                cmd.copy[cmd.key] = as_json ? decimal.toString() : decimal;
+            }
+            else {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'decimal' });
             }
         }
+        else if (cmd.field.type === 'duration') {
+            if (value instanceof duration_1.NesoiDuration) {
+                cmd.copy[cmd.key] = as_json ? value.toString() : value;
+            }
+            else if (typeof value === 'string') {
+                const duration = duration_1.NesoiDuration.fromString(value);
+                cmd.copy[cmd.key] = as_json ? duration.toString() : duration;
+            }
+            else {
+                throw error_1.NesoiError.Message.InvalidFieldType({ alias: cmd.field.alias, path: '', value, type: 'decimal' });
+            }
+        }
+        else if (cmd.field.type === 'int') {
+            cmd.copy[cmd.key] = (0, parse_1.parseInt_)({ alias: cmd.field.alias }, [], cmd.obj[cmd.key]);
+        }
+        else if (cmd.field.type === 'float') {
+            cmd.copy[cmd.key] = (0, parse_1.parseFloat_)({ alias: cmd.field.alias }, [], cmd.obj[cmd.key]);
+        }
+        else if (cmd.field.type === 'string') {
+            cmd.copy[cmd.key] = (0, parse_1.parseString)({ alias: cmd.field.alias }, [], cmd.obj[cmd.key]);
+        }
+        else if (cmd.field.type === 'literal') {
+            cmd.copy[cmd.key] = (0, parse_1.parseLiteral)({ alias: cmd.field.alias }, [], cmd.obj[cmd.key], cmd.field.meta.literal.template);
+        }
+        else if (cmd.field.type === 'boolean') {
+            cmd.copy[cmd.key] = (0, parse_1.parseBoolean)({ alias: cmd.field.alias }, [], cmd.obj[cmd.key]);
+        }
         else {
-            copy[meta.created_at] = obj[meta.created_at];
-            copy[meta.updated_at] = obj[meta.updated_at];
+            cmd.copy[cmd.key] = cmd.obj[cmd.key];
         }
-        if (modelpath)
-            return modelpath_results;
-        return copy;
+        return next;
     }
 }
 exports.BucketModel = BucketModel;

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

@@ -15,7 +15,7 @@ export type NQL_Result<T = Obj> = {
  * @category NQL
  * */
 export declare abstract class NQLRunner {
-    abstract run(trx: AnyTrxNode, part: NQL_Part, params: Record<string, any>[], param_templates: Record<string, string>[], pagination?: NQL_Pagination, view?: $BucketView): Promise<NQL_Result>;
+    abstract run(trx: AnyTrxNode, part: NQL_Part, params: Record<string, any>[], param_templates: Record<string, string>[], pagination?: NQL_Pagination, view?: $BucketView, serialize?: boolean): Promise<NQL_Result>;
 }
 /**
  * @category NQL
@@ -27,7 +27,7 @@ export declare class NQL_Engine {
     run(trx: AnyTrxNode, query: NQL_CompiledQuery, pagination?: NQL_Pagination, params?: Record<string, any>[], param_templates?: Record<string, string>[], view?: $BucketView, customBuckets?: Record<string, {
         scope: string;
         nql: NQLRunner;
-    }>): Promise<NQL_Result>;
+    }>, serialize?: boolean): Promise<NQL_Result>;
     linkExternal(bucket: AnyBucket): void;
 }
 export {};

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

@@ -23,7 +23,7 @@ class NQL_Engine {
             }
         }
     }
-    async run(trx, query, pagination, params = [{}], param_templates = [], view, customBuckets) {
+    async run(trx, query, pagination, params = [{}], param_templates = [], view, customBuckets, serialize) {
         if (!params.length)
             params = [{}];
         let result = {
@@ -35,7 +35,7 @@ class NQL_Engine {
             // Run part
             const _runner = Object.values(customBuckets || {}).find(b => b.scope === part.union.meta.scope)?.nql
                 || this.runners[part.union.meta.scope];
-            const out = await _runner.run(trx, part, params, param_templates, pagination, view);
+            const out = await _runner.run(trx, part, params, param_templates, pagination, view, serialize);
             result = out;
             // Part failed, return
             // Failure here is only when a single value is expected,