@opra/common 0.26.5 → 0.27.2

package/browser.js

@@ -144,8 +144,7 @@ import isPlainObject from "putil-isplainobject";
 import merge from "putil-merge";
 function cloneObject(obj, jsonOnly) {
   return merge({}, obj, {
-    deep: true,
-    clone: true,
+    deep: (v) => isPlainObject(v) && !v[DATATYPE_METADATA],
     filter: (source, key) => {
       const v = source[key];
       return v != null && !jsonOnly || typeof v !== "function" && (typeof v !== "object" || isPlainObject(v) || Array.isArray(v));
@@ -1023,7 +1022,7 @@ var colorReset = "\x1B[0m";
 var colorFgYellow = "\x1B[33m";
 var colorFgMagenta = "\x1B[35m";
 
-// ../../build/common/esm/document/resource/endpoint.js
+// ../../build/common/esm/document/resource/action.js
 import * as vg2 from "valgen";
 
 // ../../build/common/esm/document/data-type/data-type.js
@@ -1117,7 +1116,6 @@ var Endpoint = class {
   constructor(resource, name, init) {
     this.resource = resource;
     this.name = name;
-    this.encodeReturning = vg2.isAny();
     Object.assign(this, init);
     this.parameters = new ResponsiveMap();
     if (init.parameters) {
@@ -1125,10 +1123,9 @@ var Endpoint = class {
         this.defineParameter(n, p);
       }
     }
-    if (init.returnType) {
-      this.returnType = init.returnType instanceof DataType ? init.returnType : this.resource.document.getDataType(init.returnType);
-      this.encodeReturning = this.returnType.generateCodec("encode");
-    }
+  }
+  getFullPath(documentPath) {
+    return this.resource.getFullPath(documentPath) + (this.kind === "action" ? (documentPath ? "/actions/" : "/") + this.name : "");
   }
   defineParameter(name, init) {
     const type = init.type && init.type instanceof DataType ? init.type : this.resource.document.getDataType(init.type || "any");
@@ -1164,11 +1161,17 @@ var Action = class extends Endpoint {
     this.resource = resource;
     this.name = name;
     this.kind = "action";
+    this.encodeReturning = vg2.isAny();
+    if (init.returnType)
+      this.returnType = init.returnType instanceof DataType ? init.returnType : this.resource.document.getDataType(init.returnType);
+    this.returnMime = init.returnMime;
   }
   exportSchema(options) {
     const schema = super.exportSchema(options);
     if (this.returnType)
       schema.returnType = this.returnType.name ? this.returnType.name : this.returnType.exportSchema(options);
+    if (this.returnMime)
+      schema.returnMime = this.returnMime;
     return schema;
   }
 };
@@ -1198,10 +1201,13 @@ var Resource = class _Resource {
       }
     }
   }
-  getFullPath() {
-    if (this.parent && this.parent.name)
-      return this.parent?.getFullPath() + "/" + this.name;
-    return this.name;
+  getFullPath(documentPath) {
+    if (this === this.document.root)
+      return documentPath ? "/root" : "/";
+    let out = this.parent?.getFullPath(documentPath);
+    if (!out?.endsWith("/"))
+      out += "/";
+    return out + (documentPath ? "resources/" : "") + this.name;
   }
   exportSchema(options) {
     const schema = omitUndefined({
@@ -1653,10 +1659,7 @@ var ComplexTypeClass = class extends DataType {
     return false;
   }
   generateCodec(codec, options) {
-    const schema = {};
-    for (const f of this.fields.values()) {
-      schema[f.name] = f.generateCodec(codec, options);
-    }
+    const schema = this._generateCodecSchema(codec, options);
     return vg4.isObject(schema, {
       ctor: this.ctor,
       additionalFields: this.additionalFields ?? false,
@@ -1664,6 +1667,24 @@ var ComplexTypeClass = class extends DataType {
       caseInSensitive: !options?.caseSensitive
     });
   }
+  _generateCodecSchema(codec, options) {
+    const schema = {};
+    const pickOption = (options?.pick || []).map((x) => x.toLowerCase());
+    const omitOption = (options?.omit || []).map((x) => x.toLowerCase());
+    for (const f of this.fields.values()) {
+      const nameLower = f.name.toLowerCase();
+      if (omitOption.find((x) => x === nameLower))
+        continue;
+      if (pickOption.length && !pickOption.find((x) => x === nameLower || x.startsWith(nameLower + ".")))
+        continue;
+      schema[f.name] = f.generateCodec(codec, {
+        ...options,
+        pick: pickOption.filter((x) => x.startsWith(nameLower + ".")).map((x) => x.substring(x.indexOf(".") + 1)),
+        omit: omitOption.filter((x) => x.startsWith(nameLower + ".")).map((x) => x.substring(x.indexOf(".") + 1))
+      });
+    }
+    return schema;
+  }
 };
 
 // ../../build/common/esm/document/data-type/complex-type.js
@@ -1679,6 +1700,83 @@ ComplexType2.prototype = ComplexTypeClass.prototype;
 Object.assign(ComplexType2, ComplexTypeDecorator);
 ComplexType2[DECORATOR] = ComplexTypeDecorator;
 
+// ../../build/common/esm/document/data-type/enum-type.js
+import "reflect-metadata";
+import merge6 from "putil-merge";
+
+// ../../build/common/esm/document/data-type/enum-type-class.js
+import * as vg5 from "valgen";
+var EnumTypeClass = class extends DataType {
+  static {
+    __name(this, "EnumTypeClass");
+  }
+  constructor(document, init) {
+    super(document, init);
+    this.kind = opra_schema_ns_exports.EnumType.Kind;
+    this.enumObject = init.enumObject;
+    this.base = init.base;
+    this.ownValues = { ...init.values };
+    this.values = { ...this.base?.values, ...this.ownValues };
+    this.decode = vg5.isEnum(Object.keys(this.values));
+    this.encode = vg5.isEnum(Object.keys(this.values));
+  }
+  isTypeOf(t) {
+    return t[DATATYPE_METADATA] === this.enumObject?.[DATATYPE_METADATA];
+  }
+  exportSchema() {
+    const out = super.exportSchema();
+    out.values = {};
+    Object.entries(this.values).forEach(([k, i]) => {
+      out.values[k] = omitUndefined({ key: i.key, description: i.description });
+    });
+    return out;
+  }
+  generateCodec(codec) {
+    if (codec === "encode")
+      return this.encode;
+    else
+      return this.decode;
+  }
+};
+
+// ../../build/common/esm/document/data-type/enum-type.js
+var EnumType2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [enumSource, options] = args;
+    let values = {};
+    if (Array.isArray(enumSource)) {
+      values = {};
+      enumSource.forEach((k) => {
+        const description = options?.meanings?.[k];
+        values[k] = omitUndefined({ description });
+      });
+    } else {
+      Object.keys(enumSource).forEach((k) => {
+        const description = options?.meanings?.[k];
+        values[enumSource[k]] = omitUndefined({ key: k, description });
+      });
+    }
+    const metadata = {
+      kind: opra_schema_ns_exports.EnumType.Kind,
+      values,
+      base: options?.base,
+      name: options?.name,
+      description: options?.description
+    };
+    Object.defineProperty(enumSource, DATATYPE_METADATA, {
+      value: metadata,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+    return metadata;
+  }
+  const [document, init] = args;
+  merge6(this, new EnumTypeClass(document, init), { descriptor: true });
+  return;
+}, "EnumType");
+EnumType2.prototype = EnumTypeClass.prototype;
+
 // ../../build/common/esm/document/document-base.js
 var DocumentBase = class {
   static {
@@ -1710,8 +1808,8 @@ var TypeDocument = class extends DocumentBase {
   constructor() {
     super();
     this._designCtorMap = /* @__PURE__ */ new Map();
-    this._typeCache = new ResponsiveMap();
-    this._typesCacheByCtor = /* @__PURE__ */ new Map();
+    this._typeIndex = /* @__PURE__ */ new Map();
+    this._typeNsMap = /* @__PURE__ */ new Map();
     this.references = new ResponsiveMap();
     this.types = new ResponsiveMap();
     const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
@@ -1735,30 +1833,37 @@ var TypeDocument = class extends DocumentBase {
       if (x)
         arg0 = x;
     }
-    let dataType;
-    let name;
-    if (typeof arg0 === "function") {
-      const metadata = Reflect.getMetadata(DATATYPE_METADATA, arg0);
-      name = metadata?.name || arg0.name;
-    } else if (typeof arg0 === "function") {
-      const metadata = Reflect.getMetadata(DATATYPE_METADATA, arg0);
-      name = metadata?.name;
-    } else
-      name = String(arg0);
-    const t = typeof arg0 === "string" ? this._typeCache.get(arg0) : this._typesCacheByCtor.get(arg0);
+    const t = typeof arg0 === "string" ? this._typeIndex.get(arg0.toLowerCase()) : this._typeIndex.get(arg0);
     if (t)
       return t;
+    let name;
+    if (typeof arg0 === "string")
+      name = arg0;
+    else if (arg0 instanceof DataType)
+      name = arg0.name || "";
+    else {
+      const metadata = typeof arg0 === "function" ? Reflect.getMetadata(DATATYPE_METADATA, arg0) : arg0?.[DATATYPE_METADATA];
+      if (!metadata) {
+        if (!silent)
+          throw new TypeError("Invalid argument");
+        return;
+      }
+      name = metadata.name;
+    }
     if (t === null) {
       if (silent)
         return;
       throw new Error(`Data type "${name}" does not exists`);
     }
+    let dataType;
+    let ns = "";
     if (typeof arg0 === "string" && arg0) {
       const m = NAMESPACE_PATTERN.exec(arg0);
       if (!m)
         throw new TypeError(`Invalid data type name "${name}"`);
       if (m[2]) {
-        const ref = this.references.get(m[1]);
+        ns = m[1];
+        const ref = this.references.get(ns);
         if (!ref) {
           if (silent)
             return;
@@ -1768,59 +1873,57 @@ var TypeDocument = class extends DocumentBase {
       } else {
         dataType = this.types.get(arg0);
         if (!dataType) {
-          const references = Array.from(this.references.values()).reverse();
-          for (const ref of references) {
+          const references = Array.from(this.references.keys()).reverse();
+          for (const refNs of references) {
+            const ref = this.references.get(refNs);
             dataType = ref.getDataType(name, true);
-            if (dataType)
+            if (dataType) {
+              ns = refNs;
               break;
+            }
           }
         }
       }
-      if (dataType) {
-        this._typeCache.set(arg0, dataType);
-        return dataType;
-      }
-      if (!silent)
-        throw new NotFoundError(`Data type "${arg0}" does not exists`);
-      return;
-    }
-    if (typeof arg0 === "function") {
+    } else {
       const types = Array.from(this.types.values()).reverse();
       for (const dt of types) {
-        if (dt instanceof ComplexType2 && dt.isTypeOf(arg0)) {
+        if (dt === arg0 || (dt instanceof ComplexType2 || dt instanceof EnumType2) && dt.isTypeOf(arg0)) {
           dataType = dt;
           break;
         }
       }
       if (!dataType) {
-        const references = Array.from(this.references.values()).reverse();
-        for (const ref of references) {
+        const references = Array.from(this.references.keys()).reverse();
+        for (const refNs of references) {
+          const ref = this.references.get(refNs);
           dataType = ref.getDataType(arg0, true);
-          if (dataType)
+          if (dataType) {
+            ns = refNs;
             break;
+          }
         }
       }
-      if (dataType)
-        this._typesCacheByCtor.set(arg0, dataType);
-      if (dataType)
-        return dataType;
-      if (!silent)
-        throw new Error(`No data type mapping found for class "${name}"`);
-      return;
     }
-    if (typeof arg0 === "object") {
-      const metadata = arg0[DATATYPE_METADATA];
-      if (metadata && metadata.name) {
-        dataType = this.getDataType(metadata.name, true);
-        if (dataType)
-          return dataType;
-        if (!silent)
-          throw new Error(`No data type mapping found for class "${name}"`);
-      }
+    if (dataType) {
+      this._typeIndex.set(arg0, dataType);
+      if (ns)
+        this._typeNsMap.set(dataType, ns);
+      return dataType;
     }
+    if (!silent)
+      throw new NotFoundError(`Data type "${name}" does not exists`);
+    return;
     if (!silent)
       throw new TypeError("Invalid argument");
   }
+  /**
+   *
+   */
+  getDataTypeNs(arg0, silent) {
+    const dt = this.getDataType(arg0, silent);
+    if (dt)
+      return this._typeNsMap.get(dt);
+  }
   getComplexType(nameOrCtor, silent) {
     if (nameOrCtor === Object)
       nameOrCtor = "object";
@@ -1873,8 +1976,8 @@ var TypeDocument = class extends DocumentBase {
     return schema;
   }
   invalidate() {
-    this._typeCache.clear();
-    this._typesCacheByCtor.clear();
+    this._typeIndex.clear();
+    this._typeNsMap.clear();
   }
 };
 
@@ -1931,7 +2034,7 @@ __name(__decorate, "__decorate");
 
 // ../../build/common/esm/document/data-type/simple-type.js
 import "reflect-metadata";
-import merge6 from "putil-merge";
+import merge7 from "putil-merge";
 
 // ../../build/common/esm/document/data-type/simple-type.decorator.js
 import omit3 from "lodash.omit";
@@ -1950,7 +2053,7 @@ function SimpleTypeDecorator(options) {
 __name(SimpleTypeDecorator, "SimpleTypeDecorator");
 
 // ../../build/common/esm/document/data-type/simple-type-class.js
-import * as vg5 from "valgen";
+import * as vg6 from "valgen";
 var SimpleTypeClass = class extends DataType {
   static {
     __name(this, "SimpleTypeClass");
@@ -1959,8 +2062,8 @@ var SimpleTypeClass = class extends DataType {
     super(document, init);
     this.kind = opra_schema_ns_exports.SimpleType.Kind;
     this.base = init.base;
-    this.decode = init.decoder || init.base?.decode || vg5.isAny();
-    this.encode = init.encoder || init.base?.encode || vg5.isAny();
+    this.decode = init.decoder || init.base?.decode || vg6.isAny();
+    this.encode = init.encoder || init.base?.encode || vg6.isAny();
   }
   exportSchema(options) {
     const out = super.exportSchema(options);
@@ -1986,7 +2089,7 @@ var SimpleType2 = /* @__PURE__ */ __name(function(...args) {
     return SimpleType2[DECORATOR](options);
   }
   const [document, init] = args;
-  merge6(this, new SimpleTypeClass(document, init), { descriptor: true });
+  merge7(this, new SimpleTypeClass(document, init), { descriptor: true });
 }, "SimpleType");
 SimpleType2.prototype = SimpleTypeClass.prototype;
 Object.assign(SimpleType2, SimpleTypeDecorator);
@@ -2216,80 +2319,6 @@ TimestampType = __decorate([
   })
 ], TimestampType);
 
-// ../../build/common/esm/document/data-type/enum-type.js
-import "reflect-metadata";
-import merge7 from "putil-merge";
-
-// ../../build/common/esm/document/data-type/enum-type-class.js
-import * as vg6 from "valgen";
-var EnumTypeClass = class extends DataType {
-  static {
-    __name(this, "EnumTypeClass");
-  }
-  constructor(document, init) {
-    super(document, init);
-    this.kind = opra_schema_ns_exports.EnumType.Kind;
-    this.enumObject = init.enumObject;
-    this.base = init.base;
-    this.ownValues = { ...init.values };
-    this.values = { ...this.base?.values, ...this.ownValues };
-    this.decode = vg6.isEnum(Object.keys(this.values));
-    this.encode = vg6.isEnum(Object.keys(this.values));
-  }
-  exportSchema() {
-    const out = super.exportSchema();
-    out.values = {};
-    Object.entries(this.values).forEach(([k, i]) => {
-      out.values[k] = omitUndefined({ key: i.key, description: i.description });
-    });
-    return out;
-  }
-  generateCodec(codec) {
-    if (codec === "encode")
-      return this.encode;
-    else
-      return this.decode;
-  }
-};
-
-// ../../build/common/esm/document/data-type/enum-type.js
-var EnumType2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [enumSource, options] = args;
-    let values = {};
-    if (Array.isArray(enumSource)) {
-      values = {};
-      enumSource.forEach((k) => {
-        const description = options?.meanings?.[k];
-        values[k] = omitUndefined({ description });
-      });
-    } else {
-      Object.keys(enumSource).forEach((k) => {
-        const description = options?.meanings?.[k];
-        values[enumSource[k]] = omitUndefined({ key: k, description });
-      });
-    }
-    const metadata = {
-      kind: opra_schema_ns_exports.EnumType.Kind,
-      values,
-      base: options?.base,
-      name: options?.name,
-      description: options?.description
-    };
-    Object.defineProperty(enumSource, DATATYPE_METADATA, {
-      value: metadata,
-      enumerable: false,
-      configurable: true,
-      writable: true
-    });
-    return metadata;
-  }
-  const [document, init] = args;
-  merge7(this, new EnumTypeClass(document, init), { descriptor: true });
-  return;
-}, "EnumType");
-EnumType2.prototype = EnumTypeClass.prototype;
-
 // ../../build/common/esm/document/data-type/mapped-type.js
 import "reflect-metadata";
 import merge8 from "putil-merge";
@@ -2461,6 +2490,66 @@ var UnionType2 = /* @__PURE__ */ __name(function(...args) {
 UnionType2.prototype = UnionTypeClass.prototype;
 UnionType2._applyMixin = () => void 0;
 
+// ../../build/common/esm/document/resource/enums/metadata-mode.enum.js
+var MetadataMode;
+(function(MetadataMode2) {
+  MetadataMode2["none"] = "none";
+  MetadataMode2["minimal"] = "minimal";
+  MetadataMode2["full"] = "full";
+})(MetadataMode || (MetadataMode = {}));
+EnumType2(MetadataMode, {
+  name: "MetadataMode",
+  description: 'Parameter "enumeration" that controls how metadata information sent',
+  meanings: {
+    "none": "Specifies that the service will include NO metadata information in the response",
+    "minimal": "Specifies that the service will include ALL metadata information in the response",
+    "full": "Specifies that the service will include MINIMAL metadata information in the response"
+  }
+});
+
+// ../../build/common/esm/document/resource/types/operation-result.type.js
+var OperationResult = class OperationResult2 {
+  static {
+    __name(this, "OperationResult");
+  }
+  constructor(init) {
+    if (init)
+      Object.assign(this, init);
+  }
+};
+__decorate([
+  ApiField()
+], OperationResult.prototype, "context", void 0);
+__decorate([
+  ApiField()
+], OperationResult.prototype, "contextUrl", void 0);
+__decorate([
+  ApiField()
+], OperationResult.prototype, "type", void 0);
+__decorate([
+  ApiField()
+], OperationResult.prototype, "typeUrl", void 0);
+__decorate([
+  ApiField()
+], OperationResult.prototype, "affected", void 0);
+__decorate([
+  ApiField()
+], OperationResult.prototype, "count", void 0);
+__decorate([
+  ApiField()
+], OperationResult.prototype, "totalMatches", void 0);
+__decorate([
+  ApiField({ type: "any" })
+], OperationResult.prototype, "payload", void 0);
+__decorate([
+  ApiField({ type: "object" })
+], OperationResult.prototype, "errors", void 0);
+OperationResult = __decorate([
+  ComplexType2({
+    description: "Operation result"
+  })
+], OperationResult);
+
 // ../../build/common/esm/document/factory/type-document-factory.js
 var TypeDocumentFactory = class _TypeDocumentFactory {
   static {
@@ -2496,7 +2585,7 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
       Object.assign(this.document.info, init.info);
     if (!init?.noBuiltinTypes) {
       const builtinDocument = await this.createBuiltinTypeDocument();
-      this.document.references.set("Opra", builtinDocument);
+      this.document.references.set("opra", builtinDocument);
     }
     if (init.references)
       await this.addReferences(init.references);
@@ -2533,14 +2622,10 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
   async createBuiltinTypeDocument() {
     const init = {
       version: opra_schema_ns_exports.SpecVersion,
+      url: "https://oprajs.com/spec/v1.0",
       info: {
         version: opra_schema_ns_exports.SpecVersion,
         title: "Opra built-in types",
-        contact: [
-          {
-            url: "https://github.com/oprajs/opra"
-          }
-        ],
         license: {
           url: "https://github.com/oprajs/opra/blob/main/LICENSE",
           name: "MIT"
@@ -2560,7 +2645,9 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
         ObjectIdType,
         StringType,
         TimeType,
-        TimestampType
+        TimestampType,
+        OperationResult,
+        MetadataMode
       ]
     };
     const factory = new _TypeDocumentFactory();
@@ -2583,12 +2670,13 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
   async importDataType(thunk) {
     thunk = await resolveThunk(thunk);
     let name = "";
-    let schema;
     let ctor;
     if (typeof thunk === "string") {
       name = thunk;
-      schema = this.typeQueue.get(name);
-    } else if (typeof thunk === "function") {
+      thunk = this.typeQueue.get(name);
+    }
+    let initArguments;
+    if (typeof thunk === "function") {
       const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
       if (!metadata) {
         const dataType = this.document.getDataType(thunk, true);
@@ -2597,25 +2685,23 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
         throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
       }
       name = metadata.name;
-      schema = metadata;
+      initArguments = cloneObject(metadata);
       ctor = thunk;
     } else if (typeof thunk === "object") {
       if (opra_schema_ns_exports.isDataType(thunk)) {
         name = thunk.name;
         ctor = thunk.ctor || ctor;
-        schema = thunk;
+        initArguments = cloneObject(thunk);
       } else {
         const metadata = thunk[DATATYPE_METADATA];
         if (!metadata)
           throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
         name = metadata.name;
-        const dataType = this.document.getDataType(name, true);
-        if (dataType)
-          return dataType;
-        schema = cloneObject(metadata);
+        initArguments = cloneObject(metadata);
+        initArguments.enumObject = thunk;
       }
     }
-    ctor = ctor ?? (schema && isConstructor(schema.ctor) ? schema.ctor : void 0);
+    ctor = ctor ?? (initArguments && isConstructor(initArguments.ctor) ? initArguments.ctor : void 0);
     if (name) {
       if (this.circularRefs.has(name.toLowerCase()))
         throw new TypeError("Circular reference detected");
@@ -2634,12 +2720,11 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
       this.circularRefs.set(ctor, 1);
     }
     try {
-      if (!opra_schema_ns_exports.isDataType(schema))
+      if (!initArguments)
         throw new TypeError(`No DataType schema determined`);
-      const instance = this.createDataTypeInstance(schema.kind, name);
+      const instance = this.createDataTypeInstance(initArguments.kind, name);
       if (name)
         this.document.types.set(name, instance);
-      const initArguments = cloneObject(schema);
       await this.prepareDataTypeInitArguments(initArguments, ctor);
       if (initArguments.kind === "ComplexType")
         ComplexType2.apply(instance, [this.document, initArguments]);
@@ -2652,7 +2737,7 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
       else if (initArguments.kind === "UnionType")
         UnionType2.apply(instance, [this.document, initArguments]);
       else
-        throw new TypeError(`Invalid data type schema: ${String(schema)}`);
+        throw new TypeError(`Invalid data type schema: ${String(initArguments)}`);
       return instance;
     } finally {
       if (name) {
@@ -2702,7 +2787,7 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
               if (enumObject[DATATYPE_METADATA]) {
                 fieldInit.type = await this.importDataType(enumObject);
               } else {
-                const enumMeta = EnumType2(enumObject);
+                const enumMeta = EnumType2(enumObject, { name: "" });
                 fieldInit.type = await this.importDataType({ ...enumMeta, kind: "EnumType", base: void 0 });
               }
             } else {
@@ -10291,6 +10376,9 @@ var Operation = class extends Endpoint {
     this.name = name;
     this.kind = "operation";
     this.decodeInput = vg7.isAny();
+    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");
   }
 };
 
@@ -10342,20 +10430,20 @@ var CollectionClass = class extends CrudResource {
     });
     let endpoint = this.operations.get("create");
     if (endpoint) {
-      endpoint.returnType = this.type;
-      endpoint.decode = this.type.generateCodec("decode", {
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.decodeInput = this.type.generateCodec("decode", {
         partial: true,
         pick: endpoint.inputPickFields,
         omit: endpoint.inputOmitFields
       });
-      endpoint.encodeReturning = this.type.generateCodec("encode", {
+      endpoint.returnType = this.type;
+      endpoint.encodeReturning = endpoint.returnType.generateCodec("encode", {
         partial: true,
         pick: endpoint.outputPickFields,
         omit: endpoint.outputOmitFields
       });
-      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
     }
     endpoint = this.operations.get("deleteMany");
     if (endpoint) {
@@ -10363,24 +10451,18 @@ var CollectionClass = class extends CrudResource {
     }
     endpoint = this.operations.get("get");
     if (endpoint) {
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
       endpoint.returnType = this.type;
-      endpoint.encodeReturning = this.type.generateCodec("encode", {
+      endpoint.encodeReturning = endpoint.returnType.generateCodec("encode", {
         partial: true,
         pick: endpoint.outputPickFields,
         omit: endpoint.outputOmitFields
       });
-      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
     }
     endpoint = this.operations.get("findMany");
     if (endpoint) {
-      endpoint.returnType = this.type;
-      endpoint.encodeReturning = vg8.isArray(this.type.generateCodec("encode", {
-        partial: true,
-        pick: endpoint.outputPickFields,
-        omit: endpoint.outputOmitFields
-      }));
       endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
       endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
       endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
@@ -10390,30 +10472,36 @@ var CollectionClass = class extends CrudResource {
       endpoint.defineParameter("skip", { type: "integer", isBuiltin: true });
       endpoint.defineParameter("distinct", { type: "boolean", isBuiltin: true });
       endpoint.defineParameter("count", { type: "boolean", isBuiltin: true });
+      endpoint.returnType = this.type;
+      endpoint.encodeReturning = vg8.isArray(this.type.generateCodec("encode", {
+        partial: true,
+        pick: endpoint.outputPickFields,
+        omit: endpoint.outputOmitFields
+      }));
     }
     endpoint = this.operations.get("update");
     if (endpoint) {
-      endpoint.returnType = this.type;
-      endpoint.decode = this.type.generateCodec("decode", {
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.decodeInput = this.type.generateCodec("decode", {
         pick: endpoint.inputPickFields,
         omit: endpoint.inputOmitFields
       });
-      endpoint.encodeReturning = this.type.generateCodec("encode", {
+      endpoint.returnType = this.type;
+      endpoint.encodeReturning = endpoint.returnType.generateCodec("encode", {
         partial: true,
         pick: endpoint.outputPickFields,
         omit: endpoint.outputOmitFields
       });
-      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
     }
     endpoint = this.operations.get("updateMany");
     if (endpoint) {
-      endpoint.decode = this.type.generateCodec("decode", {
+      endpoint.defineParameter("filter", { type: "string", isBuiltin: true });
+      endpoint.decodeInput = this.type.generateCodec("decode", {
         pick: endpoint.inputPickFields,
         omit: endpoint.inputOmitFields
       });
-      endpoint.defineParameter("filter", { type: "string", isBuiltin: true });
     }
   }
   getOperation(name) {
@@ -10450,7 +10538,7 @@ var CollectionClass = class extends CrudResource {
         value = value[primaryKey];
       const el = dataType.getField(primaryKey);
       let result;
-      if (el.type instanceof SimpleType2)
+      if (value != null && el.type instanceof SimpleType2)
         result = el.type.decode(value);
       if (result == null)
         throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);
@@ -10748,48 +10836,48 @@ var SingletonClass = class extends CrudResource {
     this.type = init.type;
     let endpoint = this.operations.get("create");
     if (endpoint) {
-      endpoint.returnType = this.type;
-      endpoint.decode = this.type.generateCodec("decode", {
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.decodeInput = this.type.generateCodec("decode", {
         partial: true,
         pick: endpoint.inputPickFields,
         omit: endpoint.inputOmitFields
       });
-      endpoint.encodeReturning = this.type.generateCodec("encode", {
+      endpoint.returnType = this.type;
+      endpoint.encodeReturning = endpoint.returnType.generateCodec("encode", {
         partial: true,
         pick: endpoint.outputPickFields,
         omit: endpoint.outputOmitFields
       });
-      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
     }
     endpoint = this.operations.get("get");
     if (endpoint) {
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
       endpoint.returnType = this.type;
-      endpoint.encodeReturning = this.type.generateCodec("encode", {
+      endpoint.encodeReturning = endpoint.returnType.generateCodec("encode", {
         partial: true,
         pick: endpoint.outputPickFields,
         omit: endpoint.outputOmitFields
       });
-      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
     }
     endpoint = this.operations.get("update");
     if (endpoint) {
-      endpoint.returnType = this.type;
-      endpoint.decode = this.type.generateCodec("decode", {
+      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
+      endpoint.decodeInput = this.type.generateCodec("decode", {
         pick: endpoint.inputPickFields,
         omit: endpoint.inputOmitFields
       });
-      endpoint.encodeReturning = this.type.generateCodec("encode", {
+      endpoint.returnType = this.type;
+      endpoint.encodeReturning = endpoint.returnType.generateCodec("encode", {
         partial: true,
         pick: endpoint.outputPickFields,
         omit: endpoint.outputOmitFields
       });
-      endpoint.defineParameter("pick", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("omit", { type: "string", isArray: true, isBuiltin: true });
-      endpoint.defineParameter("include", { type: "string", isArray: true, isBuiltin: true });
     }
   }
   getOperation(name) {
@@ -11883,6 +11971,7 @@ export {
   DATATYPE_METADATA,
   DECORATOR,
   DataType,
+  Endpoint,
   EnumType2 as EnumType,
   FailedDependencyError,
   ForbiddenError,
@@ -11893,12 +11982,14 @@ export {
   InternalServerError,
   IssueSeverity,
   MappedType2 as MappedType,
+  MetadataMode,
   MethodNotAllowedError,
   NAMESPACE_PATTERN,
   NotAcceptableError,
   NotFoundError,
   OmitType,
   Operation,
+  OperationResult,
   OpraException,
   opra_filter_ns_exports as OpraFilter,
   opra_schema_ns_exports as OpraSchema,