@opra/common 0.31.12 → 0.32.0

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) {
@@ -2172,7 +2180,11 @@ var FieldClass = class {
       return vg3.isUndefined();
     if (options?.operation === "write" && this.readonly)
       return vg3.isUndefined();
-    let fn = this.type.generateCodec(codec, { ...options, designType: this.designType });
+    let fn = this.type.generateCodec(codec, {
+      ...options,
+      designType: this.designType,
+      partial: options?.partial && (this.partialUpdate || !this.isArray)
+    });
     if (this.isArray)
       fn = vg3.isArray(fn);
     return !options?.partial && this.required ? vg3.required(fn) : vg3.optional(fn);
@@ -2362,43 +2374,92 @@ 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,
       name: this.name,
-      caseInSensitive: !options?.caseSensitive
+      caseInSensitive: !options?.caseSensitive,
+      onFail: options?.onFail
     });
   }
+  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
@@ -2641,20 +2702,20 @@ var TypeDocument = class extends DocumentBase {
   getComplexType(nameOrCtor, silent) {
     if (nameOrCtor === Object)
       nameOrCtor = "object";
-    const t = this.getDataType(nameOrCtor);
-    if (!t && silent)
-      return;
-    if (t && t.kind === opra_schema_ns_exports.ComplexType.Kind)
-      return t;
-    throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+    const t = this.getDataType(nameOrCtor, silent);
+    if (t) {
+      if (t && t.kind === opra_schema_ns_exports.ComplexType.Kind)
+        return t;
+      throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+    }
   }
   getSimpleType(nameOrCtor, silent) {
-    const t = this.getDataType(nameOrCtor);
-    if (!t && silent)
-      return;
-    if (t && t.kind === opra_schema_ns_exports.SimpleType.Kind)
-      return t;
-    throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+    const t = this.getDataType(nameOrCtor, silent);
+    if (t) {
+      if (t && t.kind === opra_schema_ns_exports.SimpleType.Kind)
+        return t;
+      throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+    }
   }
   getEnumType(nameOrCtor, silent) {
     const t = this.getDataType(nameOrCtor);
@@ -2675,7 +2736,7 @@ var TypeDocument = class extends DocumentBase {
       for (const [ns, r] of this.references.entries()) {
         if (ns.toLowerCase() === "opra")
           continue;
-        references[ns] = r.url ? r.url : r.exportSchema(options);
+        references[ns] = r.exportSchema(options);
         i++;
       }
       if (i)
@@ -3396,7 +3457,10 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
   }
   async addReferences(references) {
     const { document } = this;
-    for (const [ns, r] of Object.entries(references)) {
+    let ns;
+    let r;
+    for ([ns, r] of Object.entries(references)) {
+      r = await r;
       if (typeof r === "string") {
         document.references.set(ns, await this.initDocumentFromUrl(r));
       } else if (r instanceof TypeDocument)
@@ -11121,22 +11185,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,56 +163,106 @@ 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,
             additionalFields,
             name: this.name,
-            caseInSensitive: !options?.caseSensitive
+            caseInSensitive: !options?.caseSensitive,
+            onFail: options?.onFail
         });
     }
+    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) {
@@ -50,7 +52,11 @@ class FieldClass {
             return vg.isUndefined();
         if (options?.operation === 'write' && this.readonly)
             return vg.isUndefined();
-        let fn = this.type.generateCodec(codec, { ...options, designType: this.designType });
+        let fn = this.type.generateCodec(codec, {
+            ...options,
+            designType: this.designType,
+            partial: options?.partial && (this.partialUpdate || !this.isArray)
+        });
         if (this.isArray)
             fn = vg.isArray(fn);
         return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);

package/cjs/document/factory/type-document-factory.js

@@ -108,7 +108,10 @@ class TypeDocumentFactory {
     }
     async addReferences(references) {
         const { document } = this;
-        for (const [ns, r] of Object.entries(references)) {
+        let ns;
+        let r;
+        for ([ns, r] of Object.entries(references)) {
+            r = await r;
             if (typeof r === 'string') {
                 document.references.set(ns, await this.initDocumentFromUrl(r));
             }

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/document/type-document.js

@@ -148,20 +148,20 @@ class TypeDocument extends document_base_js_1.DocumentBase {
     getComplexType(nameOrCtor, silent) {
         if (nameOrCtor === Object)
             nameOrCtor = 'object';
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === index_js_3.OpraSchema.ComplexType.Kind)
-            return t;
-        throw new index_js_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        const t = this.getDataType(nameOrCtor, silent);
+        if (t) {
+            if (t && t.kind === index_js_3.OpraSchema.ComplexType.Kind)
+                return t;
+            throw new index_js_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        }
     }
     getSimpleType(nameOrCtor, silent) {
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === index_js_3.OpraSchema.SimpleType.Kind)
-            return t;
-        throw new index_js_1.NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        const t = this.getDataType(nameOrCtor, silent);
+        if (t) {
+            if (t && t.kind === index_js_3.OpraSchema.SimpleType.Kind)
+                return t;
+            throw new index_js_1.NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        }
     }
     getEnumType(nameOrCtor, silent) {
         const t = this.getDataType(nameOrCtor);
@@ -182,7 +182,7 @@ class TypeDocument extends document_base_js_1.DocumentBase {
             for (const [ns, r] of this.references.entries()) {
                 if (ns.toLowerCase() === 'opra')
                     continue;
-                references[ns] = r.url ? r.url : r.exportSchema(options);
+                references[ns] = r.exportSchema(options);
                 i++;
             }
             if (i)

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,55 +159,105 @@ 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,
             additionalFields,
             name: this.name,
-            caseInSensitive: !options?.caseSensitive
+            caseInSensitive: !options?.caseSensitive,
+            onFail: options?.onFail
         });
     }
+    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) {
@@ -46,7 +48,11 @@ export class FieldClass {
             return vg.isUndefined();
         if (options?.operation === 'write' && this.readonly)
             return vg.isUndefined();
-        let fn = this.type.generateCodec(codec, { ...options, designType: this.designType });
+        let fn = this.type.generateCodec(codec, {
+            ...options,
+            designType: this.designType,
+            partial: options?.partial && (this.partialUpdate || !this.isArray)
+        });
         if (this.isArray)
             fn = vg.isArray(fn);
         return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);

package/esm/document/factory/type-document-factory.js

@@ -105,7 +105,10 @@ export class TypeDocumentFactory {
     }
     async addReferences(references) {
         const { document } = this;
-        for (const [ns, r] of Object.entries(references)) {
+        let ns;
+        let r;
+        for ([ns, r] of Object.entries(references)) {
+            r = await r;
             if (typeof r === 'string') {
                 document.references.set(ns, await this.initDocumentFromUrl(r));
             }

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/document/type-document.js

@@ -145,20 +145,20 @@ export class TypeDocument extends DocumentBase {
     getComplexType(nameOrCtor, silent) {
         if (nameOrCtor === Object)
             nameOrCtor = 'object';
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.ComplexType.Kind)
-            return t;
-        throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        const t = this.getDataType(nameOrCtor, silent);
+        if (t) {
+            if (t && t.kind === OpraSchema.ComplexType.Kind)
+                return t;
+            throw new NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
+        }
     }
     getSimpleType(nameOrCtor, silent) {
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === OpraSchema.SimpleType.Kind)
-            return t;
-        throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        const t = this.getDataType(nameOrCtor, silent);
+        if (t) {
+            if (t && t.kind === OpraSchema.SimpleType.Kind)
+                return t;
+            throw new NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        }
     }
     getEnumType(nameOrCtor, silent) {
         const t = this.getDataType(nameOrCtor);
@@ -179,7 +179,7 @@ export class TypeDocument extends DocumentBase {
             for (const [ns, r] of this.references.entries()) {
                 if (ns.toLowerCase() === 'opra')
                     continue;
-                references[ns] = r.url ? r.url : r.exportSchema(options);
+                references[ns] = r.exportSchema(options);
                 i++;
             }
             if (i)

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.32.0",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -46,7 +46,7 @@
     "putil-varhelpers": "^1.6.5",
     "reflect-metadata": "^0.1.13",
     "uid": "^2.0.1",
-    "valgen": "^4.2.5"
+    "valgen": "^4.3.1"
   },
   "devDependencies": {
     "@browsery/fs": "^0.4.0",
@@ -56,7 +56,7 @@
     "@types/lodash.omit": "^4.5.9",
     "@types/validator": "^13.11.7",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^2.5.0"
+    "ts-gems": "^2.7.1"
   },
   "engines": {
     "node": ">=16.0",

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,20 @@ 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[];
+        pick?: string[] | readonly string[];
+        omit?: string[] | readonly string[];
         partial?: boolean;
         operation?: 'read' | 'write';
-        overwriteFields?: ResponsiveMap<ApiField.InitArguments>;
+        overwriteFields?: Record<string, OverrideFieldsConfig>;
         designType?: Type;
+        onFail?: vg.OnFailFunction;
     }
 }

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/factory/type-document-factory.d.ts

@@ -2,7 +2,6 @@ import { PartialSome, StrictOmit, Type } from 'ts-gems';
 import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { ThunkAsync } from '../../types.js';
-import type { ApiDocument } from '../api-document.js';
 import { ComplexType } from '../data-type/complex-type.js';
 import { DataType } from '../data-type/data-type.js';
 import { EnumType } from '../data-type/enum-type.js';
@@ -10,9 +9,10 @@ import { MappedType } from '../data-type/mapped-type.js';
 import { MixinType } from '../data-type/mixin-type.js';
 import { SimpleType } from '../data-type/simple-type.js';
 import { TypeDocument } from '../type-document.js';
+type ReferenceUnion = string | OpraSchema.TypeDocument | TypeDocument;
 export declare namespace TypeDocumentFactory {
     interface InitArguments extends PartialSome<StrictOmit<OpraSchema.TypeDocument, 'references' | 'types'>, 'version'> {
-        references?: Record<string, string | OpraSchema.ApiDocument | ApiDocument>;
+        references?: Record<string, ReferenceUnion | Promise<ReferenceUnion>>;
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[] | Record<string, OpraSchema.DataType>;
         noBuiltinTypes?: boolean;
     }
@@ -49,8 +49,9 @@ export declare class TypeDocumentFactory {
     protected initDocument(init: TypeDocumentFactory.InitArguments): Promise<TypeDocument>;
     initDocumentFromUrl(url: string): Promise<TypeDocument>;
     protected createBuiltinTypeDocument(): Promise<TypeDocument>;
-    protected addReferences(references: Record<string, string | OpraSchema.TypeDocument | TypeDocument>): Promise<void>;
+    protected addReferences(references: Record<string, ReferenceUnion | Promise<ReferenceUnion>>): Promise<void>;
     protected importDataType(thunk: ThunkAsync<string | Type | EnumType.EnumObject | EnumType.EnumArray | OpraSchema.DataType>): Promise<DataType>;
     protected prepareDataTypeInitArguments(schema: TypeDocumentFactory.DataTypeInitializer | OpraSchema.DataType, ctor?: Type): Promise<TypeDocumentFactory.DataTypeInitializer | undefined>;
     protected createDataTypeInstance(kind: OpraSchema.DataType.Kind, name?: string): DataType;
 }
+export {};

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;
 };

package/types/types.d.ts

@@ -1,11 +1,7 @@
-import { Builtin, DeepPickWritable, Type } from 'ts-gems';
-export type PartialInput<T> = DeepNullablePartial<DeepPickWritable<T>>;
-export type PartialOutput<T> = DeepNullablePartial<T>;
-type DeepNullablePartial<T> = T extends Builtin ? T : T extends Promise<infer U> ? Promise<DeepNullablePartial<U>> : T extends (infer U)[] ? DeepNullablePartial<U>[] : {
-    [P in keyof T]?: DeepNullablePartial<Exclude<T[P], undefined>> | null;
-};
+import { DeepPickWritable, HighDeepNullish, Type } from 'ts-gems';
+export type PartialInput<T> = HighDeepNullish<DeepPickWritable<T>>;
+export type PartialOutput<T> = HighDeepNullish<T>;
 export type Thunk<T> = T | (() => T);
-export type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export type ThunkAsync<T> = Thunk<T> | Thunk<Promise<T>>;
 export type TypeThunk<T = any> = Thunk<Type<T>>;
 export type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
-export {};