@opra/common 0.31.12 → 0.31.13

package/browser.js

@@ -350,6 +350,12 @@ var ResponsiveMap = class extends Map {
     };
     return new Proxy({}, finalHandler);
   }
+  toObject() {
+    return Object.keys(this.keys()).reduce((trg, k) => {
+      trg[k] = this.get(k);
+      return trg;
+    }, {});
+  }
   [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
     return this.entries();
   }
@@ -2148,9 +2154,10 @@ var FieldClass = class {
     this.deprecated = init.deprecated;
     this.examples = init.examples;
     this.format = init.format;
+    this.partialUpdate = init.partialUpdate;
   }
   exportSchema(options) {
-    const isAnonymous = !this.type.name || this.type.kind === "ComplexType" && this.type.isAnonymous;
+    const isAnonymous = !this.type?.name || this.type?.kind === "ComplexType" && this.type.isAnonymous;
     return omitUndefined({
       type: this.type ? isAnonymous ? this.type.exportSchema(options) : this.type.name : void 0,
       description: this.description,
@@ -2164,7 +2171,8 @@ var FieldClass = class {
       translatable: this.translatable,
       deprecated: this.deprecated,
       examples: this.examples,
-      format: this.format
+      format: this.format,
+      partialUpdate: this.partialUpdate
     });
   }
   generateCodec(codec, options) {
@@ -2175,7 +2183,8 @@ var FieldClass = class {
     let fn = this.type.generateCodec(codec, { ...options, designType: this.designType });
     if (this.isArray)
       fn = vg3.isArray(fn);
-    return !options?.partial && this.required ? vg3.required(fn) : vg3.optional(fn);
+    const partial = options?.partial && (this.partialUpdate || !this.isArray);
+    return !partial && this.required ? vg3.required(fn) : vg3.optional(fn);
   }
 };
 
@@ -2362,8 +2371,12 @@ var ComplexTypeClass = class extends DataType {
     return false;
   }
   generateCodec(codec, options) {
-    const schema = this._generateCodecSchema(codec, options);
-    const additionalFields = this.additionalFields instanceof DataType ? this.additionalFields.generateCodec(codec, options) : this.additionalFields;
+    const schema = this.generateCodecSchema(codec, options);
+    const additionalFields = this.additionalFields instanceof DataType ? this.additionalFields.generateCodec(codec, {
+      operation: options?.operation,
+      caseSensitive: options?.caseSensitive,
+      partial: options?.partial
+    }) : this.additionalFields;
     return vg4.isObject(schema, {
       ctor: this.ctor,
       additionalFields,
@@ -2371,34 +2384,78 @@ var ComplexTypeClass = class extends DataType {
       caseInSensitive: !options?.caseSensitive
     });
   }
+  generateCodecSchema(codec, options) {
+    const opts = {
+      ...options,
+      pick: (options?.pick || []).map((x) => x.toLowerCase()),
+      omit: (options?.omit || []).map((x) => x.toLowerCase()),
+      overwriteFields: options?.overwriteFields ? this._buildOverwriteFieldsTree(options.overwriteFields) : void 0
+    };
+    return this._generateCodecSchema(codec, opts);
+  }
   _generateCodecSchema(codec, options) {
     const schema = {};
-    const pickOption = (options?.pick || []).map((x) => x.toLowerCase());
-    const omitOption = (options?.omit || []).map((x) => x.toLowerCase());
-    const dedupedFieldNames = (options?.overwriteFields ? Array.from(/* @__PURE__ */ new Set([...this.fields.keys(), ...options?.overwriteFields.keys()])) : Array.from(this.fields.keys())).map((x) => x.toLowerCase());
-    for (const nameLower of dedupedFieldNames) {
-      const overwriteField = options?.overwriteFields?.get(nameLower);
-      const field = this.fields.get(nameLower);
-      if (!(field || overwriteField))
-        continue;
-      if (!overwriteField && (omitOption.find((x) => x === nameLower) || pickOption.length && !pickOption.find((x) => x === nameLower || x.startsWith(nameLower + "."))))
+    const overwriteFields = options?.overwriteFields;
+    const optionsPick = options?.pick || [];
+    const optionsOmit = options?.omit || [];
+    const fieldNames = [...this.fields.keys()];
+    if (overwriteFields) {
+      for (const k of Object.keys(overwriteFields)) {
+        if (!this.fields.has(k))
+          fieldNames.push(k);
+      }
+    }
+    for (const fieldName of fieldNames) {
+      const lowerName = fieldName.toLowerCase();
+      const overwriteFieldInit = overwriteFields?.[fieldName];
+      if (!overwriteFieldInit && (optionsOmit.find((x) => x === lowerName) || optionsPick.length && !optionsPick.find((x) => x === lowerName || x.startsWith(lowerName + "."))))
         continue;
+      const subOptions = {
+        ...options,
+        pick: optionsPick.filter((x) => x.startsWith(lowerName + ".")).map((x) => x.substring(x.indexOf(".") + 1)),
+        omit: optionsOmit.filter((x) => x.startsWith(lowerName + ".")).map((x) => x.substring(x.indexOf(".") + 1)),
+        overwriteFields: overwriteFieldInit?.overrideFields
+      };
       let f;
-      if (overwriteField) {
-        f = { ...overwriteField };
-        if (!field)
-          f.type = this.document.getDataType("any");
-        Object.setPrototypeOf(f, field || ApiField.prototype);
+      if (overwriteFieldInit) {
+        const field = this.fields.get(fieldName);
+        const init = { ...field, ...overwriteFieldInit, name: fieldName };
+        if (!(init.type instanceof DataType))
+          init.type = this.document.getDataType(init.type || "any");
+        f = new ApiField(this, init);
       } else
-        f = field;
-      schema[f.name] = f.generateCodec(codec, {
-        ...options,
-        pick: overwriteField ? [] : pickOption.filter((x) => x.startsWith(nameLower + ".")).map((x) => x.substring(x.indexOf(".") + 1)),
-        omit: overwriteField ? [] : omitOption.filter((x) => x.startsWith(nameLower + ".")).map((x) => x.substring(x.indexOf(".") + 1))
-      });
+        f = this.getField(fieldName);
+      schema[f.name] = f.generateCodec(codec, subOptions);
     }
     return schema;
   }
+  _buildOverwriteFieldsTree(obj) {
+    const tree = {};
+    for (let k of Object.keys(obj)) {
+      const v = obj[k];
+      if (!k.includes(".")) {
+        const field = this.fields.get(k);
+        if (field)
+          k = field.name;
+        tree[k] = { ...tree[k], ...v };
+        continue;
+      }
+      const keyPath = k.split(".");
+      let subTree = tree;
+      while (keyPath.length) {
+        let j = keyPath.shift();
+        const field = this.fields.get(j);
+        if (field)
+          j = field.name;
+        const treeItem = subTree[j] = subTree[j] || {};
+        if (keyPath.length) {
+          subTree = treeItem.overrideFields = treeItem.overrideFields || {};
+        } else
+          Object.assign(treeItem, v);
+      }
+    }
+    return tree;
+  }
 };
 
 // ../../build/common/esm/document/data-type/complex-type.js
@@ -11121,22 +11178,20 @@ var CrudOperation = class extends Endpoint {
     this.encodeReturning = vg7.isAny();
     this.returnType = init.returnType instanceof DataType ? init.returnType : this.resource.document.getDataType(init.returnType || "any");
     this.encodeReturning = this.returnType.generateCodec("encode", { operation: "read" });
-    if (init.options?.inputOverwriteFields)
-      this.inputOverwriteFields = new ResponsiveMap(init.options.inputOverwriteFields);
-    if (init.options?.outputOverwriteFields)
-      this.outputOverwriteFields = new ResponsiveMap(init.options.outputOverwriteFields);
+    this.inputOverwriteFields = init.options.inputOverwriteFields;
+    this.outputOverwriteFields = init.options.outputOverwriteFields;
   }
   exportSchema(options) {
     const schema = super.exportSchema(options);
     if (this.inputOverwriteFields) {
       const trg = schema.options.inputOverwriteFields = {};
-      Array.from(this.inputOverwriteFields.entries()).forEach(([k, o]) => {
+      Object.keys(this.inputOverwriteFields).forEach(([k, o]) => {
         trg[k] = ApiField.prototype.exportSchema.call(o, options);
       });
     }
     if (this.outputOverwriteFields) {
       const trg = schema.options.outputOverwriteFields = {};
-      Array.from(this.outputOverwriteFields.entries()).forEach(([k, o]) => {
+      Object.keys(this.outputOverwriteFields).forEach(([k, o]) => {
         trg[k] = ApiField.prototype.exportSchema.call(o, options);
       });
     }

package/cjs/document/data-type/complex-type-class.js

@@ -163,9 +163,13 @@ class ComplexTypeClass extends data_type_js_1.DataType {
         return false;
     }
     generateCodec(codec, options) {
-        const schema = this._generateCodecSchema(codec, options);
+        const schema = this.generateCodecSchema(codec, options);
         const additionalFields = this.additionalFields instanceof data_type_js_1.DataType
-            ? this.additionalFields.generateCodec(codec, options)
+            ? this.additionalFields.generateCodec(codec, {
+                operation: options?.operation,
+                caseSensitive: options?.caseSensitive,
+                partial: options?.partial
+            })
             : this.additionalFields;
         return vg.isObject(schema, {
             ctor: this.ctor,
@@ -174,45 +178,90 @@ class ComplexTypeClass extends data_type_js_1.DataType {
             caseInSensitive: !options?.caseSensitive
         });
     }
+    generateCodecSchema(codec, options) {
+        const opts = {
+            ...options,
+            pick: (options?.pick || []).map(x => x.toLowerCase()),
+            omit: (options?.omit || []).map(x => x.toLowerCase()),
+            overwriteFields: options?.overwriteFields ? this._buildOverwriteFieldsTree(options.overwriteFields) : undefined,
+        };
+        return this._generateCodecSchema(codec, opts);
+    }
     _generateCodecSchema(codec, options) {
         const schema = {};
-        const pickOption = (options?.pick || []).map(x => x.toLowerCase());
-        const omitOption = (options?.omit || []).map(x => x.toLowerCase());
-        const dedupedFieldNames = (options?.overwriteFields
-            ? Array.from(new Set([...this.fields.keys(), ...options?.overwriteFields.keys()]))
-            : Array.from(this.fields.keys())).map(x => x.toLowerCase());
-        for (const nameLower of dedupedFieldNames) {
-            const overwriteField = options?.overwriteFields?.get(nameLower);
-            const field = this.fields.get(nameLower);
-            /* istanbul ignore next */
-            if (!(field || overwriteField))
-                continue;
-            if (!overwriteField &&
-                (omitOption.find(x => x === nameLower) ||
-                    (pickOption.length && !pickOption.find(x => x === nameLower || x.startsWith(nameLower + '.')))))
+        const overwriteFields = options?.overwriteFields;
+        const optionsPick = options?.pick || [];
+        const optionsOmit = options?.omit || [];
+        const fieldNames = [...this.fields.keys()];
+        // Add field name from overwriteFields which doesn't exist in this.fields
+        if (overwriteFields) {
+            for (const k of Object.keys(overwriteFields)) {
+                if (!this.fields.has(k))
+                    fieldNames.push(k);
+            }
+        }
+        // Process fields
+        for (const fieldName of fieldNames) {
+            const lowerName = fieldName.toLowerCase();
+            const overwriteFieldInit = overwriteFields?.[fieldName];
+            // If field omitted or not in pick list we ignore it unless overwriteField defined
+            if (!overwriteFieldInit &&
+                (optionsOmit.find(x => x === lowerName) ||
+                    (optionsPick.length && !optionsPick.find(x => x === lowerName || x.startsWith(lowerName + '.')))))
                 continue;
+            const subOptions = {
+                ...options,
+                pick: optionsPick
+                    .filter(x => x.startsWith(lowerName + '.'))
+                    .map(x => x.substring(x.indexOf('.') + 1)),
+                omit: optionsOmit
+                    .filter(x => x.startsWith(lowerName + '.'))
+                    .map(x => x.substring(x.indexOf('.') + 1)),
+                overwriteFields: overwriteFieldInit?.overrideFields
+            };
             let f;
-            if (overwriteField) {
-                f = { ...overwriteField };
-                if (!field)
-                    f.type = this.document.getDataType('any');
-                Object.setPrototypeOf(f, field || field_js_1.ApiField.prototype);
+            if (overwriteFieldInit) {
+                const field = this.fields.get(fieldName);
+                const init = { ...field, ...overwriteFieldInit, name: fieldName };
+                if (!(init.type instanceof data_type_js_1.DataType))
+                    init.type = this.document.getDataType(init.type || 'any');
+                f = new field_js_1.ApiField(this, init);
             }
             else
-                f = field;
-            schema[f.name] = f.generateCodec(codec, {
-                ...options,
-                pick: overwriteField ? [] :
-                    pickOption
-                        .filter(x => x.startsWith(nameLower + '.'))
-                        .map(x => x.substring(x.indexOf('.') + 1)),
-                omit: overwriteField ? [] :
-                    omitOption
-                        .filter(x => x.startsWith(nameLower + '.'))
-                        .map(x => x.substring(x.indexOf('.') + 1)),
-            });
+                f = this.getField(fieldName);
+            schema[f.name] = f.generateCodec(codec, subOptions);
         }
         return schema;
     }
+    _buildOverwriteFieldsTree(obj) {
+        const tree = {};
+        for (let k of Object.keys(obj)) {
+            const v = obj[k];
+            if (!k.includes('.')) {
+                // Fix field name
+                const field = this.fields.get(k);
+                if (field)
+                    k = field.name;
+                tree[k] = { ...tree[k], ...v };
+                continue;
+            }
+            const keyPath = k.split('.');
+            let subTree = tree;
+            while (keyPath.length) {
+                let j = keyPath.shift();
+                // Fix field name
+                const field = this.fields.get(j);
+                if (field)
+                    j = field.name;
+                const treeItem = subTree[j] = subTree[j] || {};
+                if (keyPath.length) {
+                    subTree = treeItem.overrideFields = treeItem.overrideFields || {};
+                }
+                else
+                    Object.assign(treeItem, v);
+            }
+        }
+        return tree;
+    }
 }
 exports.ComplexTypeClass = ComplexTypeClass;

package/cjs/document/data-type/field-class.js

@@ -23,10 +23,11 @@ class FieldClass {
         this.deprecated = init.deprecated;
         this.examples = init.examples;
         this.format = init.format;
+        this.partialUpdate = init.partialUpdate;
     }
     exportSchema(options) {
-        const isAnonymous = !this.type.name ||
-            (this.type.kind === 'ComplexType' && this.type.isAnonymous);
+        const isAnonymous = !this.type?.name ||
+            (this.type?.kind === 'ComplexType' && this.type.isAnonymous);
         return (0, index_js_1.omitUndefined)({
             type: this.type
                 ? (isAnonymous ? this.type.exportSchema(options) : this.type.name)
@@ -43,6 +44,7 @@ class FieldClass {
             deprecated: this.deprecated,
             examples: this.examples,
             format: this.format,
+            partialUpdate: this.partialUpdate,
         });
     }
     generateCodec(codec, options) {
@@ -53,7 +55,8 @@ class FieldClass {
         let fn = this.type.generateCodec(codec, { ...options, designType: this.designType });
         if (this.isArray)
             fn = vg.isArray(fn);
-        return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);
+        const partial = options?.partial && (this.partialUpdate || !this.isArray);
+        return !partial && this.required ? vg.required(fn) : vg.optional(fn);
     }
 }
 exports.FieldClass = FieldClass;

package/cjs/document/resource/crud-operation.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CrudOperation = void 0;
 const tslib_1 = require("tslib");
 const vg = tslib_1.__importStar(require("valgen"));
-const index_js_1 = require("../../helpers/index.js");
 const data_type_js_1 = require("../data-type/data-type.js");
 const field_js_1 = require("../data-type/field.js");
 const endpoint_js_1 = require("./endpoint.js");
@@ -22,23 +21,21 @@ class CrudOperation extends endpoint_js_1.Endpoint {
         this.returnType = init.returnType instanceof data_type_js_1.DataType
             ? init.returnType : this.resource.document.getDataType(init.returnType || 'any');
         this.encodeReturning = this.returnType.generateCodec('encode', { operation: 'read' });
-        if (init.options?.inputOverwriteFields)
-            this.inputOverwriteFields = new index_js_1.ResponsiveMap(init.options.inputOverwriteFields);
-        if (init.options?.outputOverwriteFields)
-            this.outputOverwriteFields = new index_js_1.ResponsiveMap(init.options.outputOverwriteFields);
+        this.inputOverwriteFields = init.options.inputOverwriteFields;
+        this.outputOverwriteFields = init.options.outputOverwriteFields;
     }
     exportSchema(options) {
         const schema = super.exportSchema(options);
         if (this.inputOverwriteFields) {
             const trg = schema.options.inputOverwriteFields = {};
-            Array.from(this.inputOverwriteFields.entries())
+            Object.keys(this.inputOverwriteFields)
                 .forEach(([k, o]) => {
                 trg[k] = field_js_1.ApiField.prototype.exportSchema.call(o, options);
             });
         }
         if (this.outputOverwriteFields) {
             const trg = schema.options.outputOverwriteFields = {};
-            Array.from(this.outputOverwriteFields.entries())
+            Object.keys(this.outputOverwriteFields)
                 .forEach(([k, o]) => {
                 trg[k] = field_js_1.ApiField.prototype.exportSchema.call(o, options);
             });

package/cjs/helpers/responsive-map.js

@@ -154,6 +154,12 @@ class ResponsiveMap extends Map {
         };
         return new Proxy({}, finalHandler);
     }
+    toObject() {
+        return Object.keys(this.keys()).reduce((trg, k) => {
+            trg[k] = this.get(k);
+            return trg;
+        }, {});
+    }
     [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
         return this.entries();
     }

package/esm/document/data-type/complex-type-class.js

@@ -159,9 +159,13 @@ export class ComplexTypeClass extends DataType {
         return false;
     }
     generateCodec(codec, options) {
-        const schema = this._generateCodecSchema(codec, options);
+        const schema = this.generateCodecSchema(codec, options);
         const additionalFields = this.additionalFields instanceof DataType
-            ? this.additionalFields.generateCodec(codec, options)
+            ? this.additionalFields.generateCodec(codec, {
+                operation: options?.operation,
+                caseSensitive: options?.caseSensitive,
+                partial: options?.partial
+            })
             : this.additionalFields;
         return vg.isObject(schema, {
             ctor: this.ctor,
@@ -170,44 +174,89 @@ export class ComplexTypeClass extends DataType {
             caseInSensitive: !options?.caseSensitive
         });
     }
+    generateCodecSchema(codec, options) {
+        const opts = {
+            ...options,
+            pick: (options?.pick || []).map(x => x.toLowerCase()),
+            omit: (options?.omit || []).map(x => x.toLowerCase()),
+            overwriteFields: options?.overwriteFields ? this._buildOverwriteFieldsTree(options.overwriteFields) : undefined,
+        };
+        return this._generateCodecSchema(codec, opts);
+    }
     _generateCodecSchema(codec, options) {
         const schema = {};
-        const pickOption = (options?.pick || []).map(x => x.toLowerCase());
-        const omitOption = (options?.omit || []).map(x => x.toLowerCase());
-        const dedupedFieldNames = (options?.overwriteFields
-            ? Array.from(new Set([...this.fields.keys(), ...options?.overwriteFields.keys()]))
-            : Array.from(this.fields.keys())).map(x => x.toLowerCase());
-        for (const nameLower of dedupedFieldNames) {
-            const overwriteField = options?.overwriteFields?.get(nameLower);
-            const field = this.fields.get(nameLower);
-            /* istanbul ignore next */
-            if (!(field || overwriteField))
-                continue;
-            if (!overwriteField &&
-                (omitOption.find(x => x === nameLower) ||
-                    (pickOption.length && !pickOption.find(x => x === nameLower || x.startsWith(nameLower + '.')))))
+        const overwriteFields = options?.overwriteFields;
+        const optionsPick = options?.pick || [];
+        const optionsOmit = options?.omit || [];
+        const fieldNames = [...this.fields.keys()];
+        // Add field name from overwriteFields which doesn't exist in this.fields
+        if (overwriteFields) {
+            for (const k of Object.keys(overwriteFields)) {
+                if (!this.fields.has(k))
+                    fieldNames.push(k);
+            }
+        }
+        // Process fields
+        for (const fieldName of fieldNames) {
+            const lowerName = fieldName.toLowerCase();
+            const overwriteFieldInit = overwriteFields?.[fieldName];
+            // If field omitted or not in pick list we ignore it unless overwriteField defined
+            if (!overwriteFieldInit &&
+                (optionsOmit.find(x => x === lowerName) ||
+                    (optionsPick.length && !optionsPick.find(x => x === lowerName || x.startsWith(lowerName + '.')))))
                 continue;
+            const subOptions = {
+                ...options,
+                pick: optionsPick
+                    .filter(x => x.startsWith(lowerName + '.'))
+                    .map(x => x.substring(x.indexOf('.') + 1)),
+                omit: optionsOmit
+                    .filter(x => x.startsWith(lowerName + '.'))
+                    .map(x => x.substring(x.indexOf('.') + 1)),
+                overwriteFields: overwriteFieldInit?.overrideFields
+            };
             let f;
-            if (overwriteField) {
-                f = { ...overwriteField };
-                if (!field)
-                    f.type = this.document.getDataType('any');
-                Object.setPrototypeOf(f, field || ApiField.prototype);
+            if (overwriteFieldInit) {
+                const field = this.fields.get(fieldName);
+                const init = { ...field, ...overwriteFieldInit, name: fieldName };
+                if (!(init.type instanceof DataType))
+                    init.type = this.document.getDataType(init.type || 'any');
+                f = new ApiField(this, init);
             }
             else
-                f = field;
-            schema[f.name] = f.generateCodec(codec, {
-                ...options,
-                pick: overwriteField ? [] :
-                    pickOption
-                        .filter(x => x.startsWith(nameLower + '.'))
-                        .map(x => x.substring(x.indexOf('.') + 1)),
-                omit: overwriteField ? [] :
-                    omitOption
-                        .filter(x => x.startsWith(nameLower + '.'))
-                        .map(x => x.substring(x.indexOf('.') + 1)),
-            });
+                f = this.getField(fieldName);
+            schema[f.name] = f.generateCodec(codec, subOptions);
         }
         return schema;
     }
+    _buildOverwriteFieldsTree(obj) {
+        const tree = {};
+        for (let k of Object.keys(obj)) {
+            const v = obj[k];
+            if (!k.includes('.')) {
+                // Fix field name
+                const field = this.fields.get(k);
+                if (field)
+                    k = field.name;
+                tree[k] = { ...tree[k], ...v };
+                continue;
+            }
+            const keyPath = k.split('.');
+            let subTree = tree;
+            while (keyPath.length) {
+                let j = keyPath.shift();
+                // Fix field name
+                const field = this.fields.get(j);
+                if (field)
+                    j = field.name;
+                const treeItem = subTree[j] = subTree[j] || {};
+                if (keyPath.length) {
+                    subTree = treeItem.overrideFields = treeItem.overrideFields || {};
+                }
+                else
+                    Object.assign(treeItem, v);
+            }
+        }
+        return tree;
+    }
 }

package/esm/document/data-type/field-class.js

@@ -19,10 +19,11 @@ export class FieldClass {
         this.deprecated = init.deprecated;
         this.examples = init.examples;
         this.format = init.format;
+        this.partialUpdate = init.partialUpdate;
     }
     exportSchema(options) {
-        const isAnonymous = !this.type.name ||
-            (this.type.kind === 'ComplexType' && this.type.isAnonymous);
+        const isAnonymous = !this.type?.name ||
+            (this.type?.kind === 'ComplexType' && this.type.isAnonymous);
         return omitUndefined({
             type: this.type
                 ? (isAnonymous ? this.type.exportSchema(options) : this.type.name)
@@ -39,6 +40,7 @@ export class FieldClass {
             deprecated: this.deprecated,
             examples: this.examples,
             format: this.format,
+            partialUpdate: this.partialUpdate,
         });
     }
     generateCodec(codec, options) {
@@ -49,6 +51,7 @@ export class FieldClass {
         let fn = this.type.generateCodec(codec, { ...options, designType: this.designType });
         if (this.isArray)
             fn = vg.isArray(fn);
-        return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);
+        const partial = options?.partial && (this.partialUpdate || !this.isArray);
+        return !partial && this.required ? vg.required(fn) : vg.optional(fn);
     }
 }

package/esm/document/resource/crud-operation.js

@@ -1,5 +1,4 @@
 import * as vg from 'valgen';
-import { ResponsiveMap } from '../../helpers/index.js';
 import { DataType } from '../data-type/data-type.js';
 import { ApiField } from '../data-type/field.js';
 import { Endpoint } from './endpoint.js';
@@ -18,23 +17,21 @@ export class CrudOperation extends Endpoint {
         this.returnType = init.returnType instanceof DataType
             ? init.returnType : this.resource.document.getDataType(init.returnType || 'any');
         this.encodeReturning = this.returnType.generateCodec('encode', { operation: 'read' });
-        if (init.options?.inputOverwriteFields)
-            this.inputOverwriteFields = new ResponsiveMap(init.options.inputOverwriteFields);
-        if (init.options?.outputOverwriteFields)
-            this.outputOverwriteFields = new ResponsiveMap(init.options.outputOverwriteFields);
+        this.inputOverwriteFields = init.options.inputOverwriteFields;
+        this.outputOverwriteFields = init.options.outputOverwriteFields;
     }
     exportSchema(options) {
         const schema = super.exportSchema(options);
         if (this.inputOverwriteFields) {
             const trg = schema.options.inputOverwriteFields = {};
-            Array.from(this.inputOverwriteFields.entries())
+            Object.keys(this.inputOverwriteFields)
                 .forEach(([k, o]) => {
                 trg[k] = ApiField.prototype.exportSchema.call(o, options);
             });
         }
         if (this.outputOverwriteFields) {
             const trg = schema.options.outputOverwriteFields = {};
-            Array.from(this.outputOverwriteFields.entries())
+            Object.keys(this.outputOverwriteFields)
                 .forEach(([k, o]) => {
                 trg[k] = ApiField.prototype.exportSchema.call(o, options);
             });

package/esm/helpers/responsive-map.js

@@ -151,6 +151,12 @@ export class ResponsiveMap extends Map {
         };
         return new Proxy({}, finalHandler);
     }
+    toObject() {
+        return Object.keys(this.keys()).reduce((trg, k) => {
+            trg[k] = this.get(k);
+            return trg;
+        }, {});
+    }
     [(_a = kKeyMap, _b = kKeyOrder, _c = kWellKnownKeys, _d = kOptions, Symbol.iterator)]() {
         return this.entries();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "0.31.12",
+  "version": "0.31.13",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",

package/types/document/data-type/complex-type-class.d.ts

@@ -1,4 +1,4 @@
-import { Type } from 'ts-gems';
+import { RequiredSome, Type } from 'ts-gems';
 import * as vg from 'valgen';
 import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
@@ -30,5 +30,7 @@ export declare class ComplexTypeClass extends DataType {
     isTypeOf(t: Type | Function): boolean;
     extendsFrom(t: string | Type | DataType): boolean;
     generateCodec(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): vg.Validator;
-    protected _generateCodecSchema(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): vg.ObjectSchema;
+    generateCodecSchema(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): vg.ObjectSchema;
+    protected _generateCodecSchema(codec: 'decode' | 'encode', options?: RequiredSome<DataType.GenerateCodecOptions, 'pick' | 'omit'>): vg.ObjectSchema;
+    protected _buildOverwriteFieldsTree(obj: Record<string, DataType.OverrideFieldsConfig>): Record<string, DataType.OverrideFieldsConfig>;
 }

package/types/document/data-type/data-type.d.ts

@@ -1,6 +1,5 @@
-import { RequiredSome, Type } from 'ts-gems';
+import { RequiredSome, StrictOmit, Type } from 'ts-gems';
 import * as vg from 'valgen';
-import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { nodeInspectCustom } from '../utils/inspect.util.js';
@@ -39,13 +38,19 @@ export declare namespace DataType {
     }
     interface OwnProperties {
     }
+    type GenerateCodecField = StrictOmit<ApiField.InitArguments, 'type' | 'name'> & {
+        type?: DataType | string;
+    };
+    type OverrideFieldsConfig = GenerateCodecField & {
+        overrideFields?: Record<string, OverrideFieldsConfig>;
+    };
     interface GenerateCodecOptions {
         caseSensitive?: boolean;
         pick?: string[];
         omit?: string[];
         partial?: boolean;
         operation?: 'read' | 'write';
-        overwriteFields?: ResponsiveMap<ApiField.InitArguments>;
+        overwriteFields?: Record<string, OverrideFieldsConfig>;
         designType?: Type;
     }
 }

package/types/document/data-type/field-class.d.ts

@@ -22,6 +22,7 @@ export declare class FieldClass {
     deprecated?: boolean | string;
     examples?: any[] | Record<string, any>;
     format?: string;
+    partialUpdate?: boolean;
     constructor(owner: ComplexType, init: ApiField.InitArguments);
     exportSchema(options?: {
         webSafe?: boolean;

package/types/document/resource/crud-operation.d.ts

@@ -1,6 +1,5 @@
 import { StrictOmit } from 'ts-gems';
 import * as vg from 'valgen';
-import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DataType } from '../data-type/data-type.js';
 import { ApiField } from '../data-type/field.js';
@@ -18,8 +17,8 @@ export declare class CrudOperation extends Endpoint {
     decodeInput: vg.Validator;
     returnType: DataType;
     encodeReturning: vg.Validator;
-    inputOverwriteFields?: ResponsiveMap<ApiField.InitArguments>;
-    outputOverwriteFields?: ResponsiveMap<ApiField.InitArguments>;
+    inputOverwriteFields?: Record<string, ApiField.InitArguments>;
+    outputOverwriteFields?: Record<string, ApiField.InitArguments>;
     constructor(resource: Resource, name: string, init: CrudOperation.InitArguments);
     exportSchema(options?: {
         webSafe?: boolean;

package/types/helpers/responsive-map.d.ts

@@ -27,6 +27,7 @@ export declare class ResponsiveMap<V> extends Map<string, V> {
     delete(key: string): boolean;
     sort(compareFn?: (a: string, b: string) => number): this;
     getProxy(handler?: ProxyHandler<Record<string, V>>): Record<string, V>;
+    toObject(): Record<string, V>;
     [Symbol.iterator](): IterableIterator<[string, V]>;
     protected _getOriginalKey(key: string): string;
     protected _getStoringKey(key: string): string;

package/types/schema/data-type/field.interface.d.ts

@@ -10,7 +10,7 @@ export type Field = {
      */
     description?: string;
     /**
-     * Defines if the field value is an array
+     * Indicates if the field value is an array
      */
     isArray?: boolean;
     /**
@@ -18,19 +18,19 @@ export type Field = {
      */
     default?: any;
     /**
-     * Defines the fixed value of the field. The value of the field can not be any other value.
+     * Indicates the fixed value of the field. The value of the field can not be any other value.
      */
     fixed?: string | number | boolean;
     /**
-     * Defines if field value required in create operation
+     * Indicates if field value required in create operation
      */
     required?: boolean;
     /**
-     * Defines if the field is readonly
+     * Indicates if the field is readonly
      */
     readonly?: boolean;
     /**
-     * Defines if the field is writeonly
+     * Indicates if the field is writeonly
      */
     writeonly?: boolean;
     /**
@@ -47,8 +47,12 @@ export type Field = {
      */
     examples?: any[] | Record<string, any>;
     /**
-     * Defines if the field is deprecated and can be removed in the next
+     * Indicates if the field is deprecated and can be removed in the next
      */
     deprecated?: boolean | string;
     format?: string;
+    /**
+     * Indicates if partial update enabled for this field
+     */
+    partialUpdate?: boolean;
 };