@opra/common 0.30.1 → 0.31.1

package/browser.js

@@ -871,22 +871,22 @@ __export(opra_schema_ns_exports, {
   Container: () => Container,
   EnumType: () => EnumType,
   MappedType: () => MappedType,
+  MixinType: () => MixinType,
   SimpleType: () => SimpleType,
   Singleton: () => Singleton,
   SpecVersion: () => SpecVersion,
   Storage: () => Storage,
-  UnionType: () => UnionType,
   isCollection: () => isCollection,
   isComplexType: () => isComplexType,
   isContainer: () => isContainer,
   isDataType: () => isDataType,
   isEnumType: () => isEnumType,
   isMappedType: () => isMappedType,
+  isMixinType: () => isMixinType,
   isResource: () => isResource,
   isSimpleType: () => isSimpleType,
   isSingleton: () => isSingleton,
-  isStorage: () => isStorage,
-  isUnionType: () => isUnionType
+  isStorage: () => isStorage
 });
 
 // ../../build/common/esm/schema/data-type/complex-type.interface.js
@@ -913,11 +913,11 @@ var MappedType;
   MappedType3.Kind = "MappedType";
 })(MappedType || (MappedType = {}));
 
-// ../../build/common/esm/schema/data-type/union-type.interface.js
-var UnionType;
-(function(UnionType3) {
-  UnionType3.Kind = "UnionType";
-})(UnionType || (UnionType = {}));
+// ../../build/common/esm/schema/data-type/mixin-type.interface.js
+var MixinType;
+(function(MixinType3) {
+  MixinType3.Kind = "MixinType";
+})(MixinType || (MixinType = {}));
 
 // ../../build/common/esm/schema/resource/collection.interface.js
 var Collection;
@@ -948,7 +948,7 @@ var SpecVersion = "1.0";
 
 // ../../build/common/esm/schema/type-guards.js
 function isDataType(obj) {
-  return obj && typeof obj === "object" && (obj.kind === ComplexType.Kind || obj.kind === EnumType.Kind || obj.kind === MappedType.Kind || obj.kind === SimpleType.Kind || obj.kind === UnionType.Kind);
+  return obj && typeof obj === "object" && (obj.kind === ComplexType.Kind || obj.kind === EnumType.Kind || obj.kind === MappedType.Kind || obj.kind === SimpleType.Kind || obj.kind === MixinType.Kind);
 }
 __name(isDataType, "isDataType");
 function isComplexType(obj) {
@@ -959,10 +959,10 @@ function isSimpleType(obj) {
   return obj && typeof obj === "object" && obj.kind === SimpleType.Kind;
 }
 __name(isSimpleType, "isSimpleType");
-function isUnionType(obj) {
-  return obj && typeof obj === "object" && obj.kind === UnionType.Kind;
+function isMixinType(obj) {
+  return obj && typeof obj === "object" && obj.kind === MixinType.Kind;
 }
-__name(isUnionType, "isUnionType");
+__name(isMixinType, "isMixinType");
 function isMappedType(obj) {
   return obj && typeof obj === "object" && obj.kind === MappedType.Kind;
 }
@@ -1427,11 +1427,13 @@ var FieldClass = class {
     this.default = init.default;
     this.fixed = init.fixed;
     this.required = init.required;
+    this.nullish = init.nullish;
     this.readonly = init.readonly;
     this.writeonly = init.writeonly;
     this.exclusive = init.exclusive;
     this.deprecated = init.deprecated;
     this.examples = init.examples;
+    this.format = init.format;
   }
   exportSchema(options) {
     return omitUndefined({
@@ -1441,11 +1443,13 @@ var FieldClass = class {
       default: this.default,
       fixed: this.fixed,
       required: this.required,
+      nullish: this.nullish,
       readonly: this.readonly,
       writeonly: this.writeonly,
       exclusive: this.exclusive,
       deprecated: this.deprecated,
-      examples: this.examples
+      examples: this.examples,
+      format: this.format
     });
   }
   generateCodec(codec, options) {
@@ -1507,8 +1511,8 @@ var ComplexTypeClass = class extends DataType {
     const own = this.own = {};
     own.ctor = init.ctor;
     if (init.base) {
-      if (!(init.base.kind === "ComplexType" || init.base.kind === "MappedType" || init.base.kind === "UnionType"))
-        throw new TypeError('"base" argument must be one of ComplexType or MappedType or UnionType');
+      if (!(init.base.kind === "ComplexType" || init.base.kind === "MappedType" || init.base.kind === "MixinType"))
+        throw new TypeError('"base" argument must be one of ComplexType or MappedType or MixinType');
       own.ctor = own.ctor || init.base.ctor;
     }
     own.additionalFields = init?.additionalFields;
@@ -2408,24 +2412,24 @@ var MappedType2 = /* @__PURE__ */ __name(function(...args) {
 MappedType2.prototype = MappedTypeClass.prototype;
 MappedType2._applyMixin = () => void 0;
 
-// ../../build/common/esm/document/data-type/union-type.js
+// ../../build/common/esm/document/data-type/mixin-type.js
 import "reflect-metadata";
 import merge9 from "putil-merge";
 
-// ../../build/common/esm/document/data-type/union-type-class.js
-var UnionTypeClass = class extends ComplexType2 {
+// ../../build/common/esm/document/data-type/mixin-type-class.js
+var MixinTypeClass = class extends ComplexType2 {
   static {
-    __name(this, "UnionTypeClass");
+    __name(this, "MixinTypeClass");
   }
   constructor(document, init) {
     super(document, init);
-    this.kind = opra_schema_ns_exports.UnionType.Kind;
+    this.kind = opra_schema_ns_exports.MixinType.Kind;
     const own = this.own;
     own.types = [];
-    const UnionType3 = Object.getPrototypeOf(this).constructor;
+    const MixinType3 = Object.getPrototypeOf(this).constructor;
     for (const base of init.types) {
-      if (!(base instanceof ComplexType2 || base instanceof UnionType3 || base instanceof MappedType2))
-        throw new TypeError(`${opra_schema_ns_exports.UnionType.Kind} shall contain ${opra_schema_ns_exports.ComplexType.Kind}, ${opra_schema_ns_exports.UnionType.Kind} of ${opra_schema_ns_exports.MappedType.Kind} types.`);
+      if (!(base instanceof ComplexType2 || base instanceof MixinType3 || base instanceof MappedType2))
+        throw new TypeError(`${opra_schema_ns_exports.MixinType.Kind} shall contain ${opra_schema_ns_exports.ComplexType.Kind}, ${opra_schema_ns_exports.MixinType.Kind} of ${opra_schema_ns_exports.MappedType.Kind} types.`);
       own.types.push(base);
       if (base.additionalFields === true && this.additionalFields !== true) {
         this.additionalFields = true;
@@ -2444,11 +2448,11 @@ var UnionTypeClass = class extends ComplexType2 {
   }
 };
 
-// ../../build/common/esm/document/data-type/union-type.js
-var UnionType2 = /* @__PURE__ */ __name(function(...args) {
+// ../../build/common/esm/document/data-type/mixin-type.js
+var MixinType2 = /* @__PURE__ */ __name(function(...args) {
   if (this) {
     const [document, init] = args;
-    merge9(this, new UnionTypeClass(document, init), { descriptor: true });
+    merge9(this, new MixinTypeClass(document, init), { descriptor: true });
     return;
   }
   const clasRefs = [...args].filter((x) => !!x);
@@ -2456,9 +2460,9 @@ var UnionType2 = /* @__PURE__ */ __name(function(...args) {
     throw new TypeError("No Class has been provided");
   if (clasRefs.length === 1)
     return clasRefs[0];
-  class UnionClass {
+  class MixinClass {
     static {
-      __name(this, "UnionClass");
+      __name(this, "MixinClass");
     }
     constructor() {
       for (const c of clasRefs)
@@ -2466,22 +2470,22 @@ var UnionType2 = /* @__PURE__ */ __name(function(...args) {
     }
   }
   const metadata = {
-    kind: opra_schema_ns_exports.UnionType.Kind,
+    kind: opra_schema_ns_exports.MixinType.Kind,
     types: []
   };
-  Reflect.defineMetadata(DATATYPE_METADATA, metadata, UnionClass);
+  Reflect.defineMetadata(DATATYPE_METADATA, metadata, MixinClass);
   for (const c of clasRefs) {
     const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, c);
-    if (!(itemMeta && (itemMeta.kind === opra_schema_ns_exports.ComplexType.Kind || itemMeta.kind === opra_schema_ns_exports.UnionType.Kind || itemMeta.kind === opra_schema_ns_exports.MappedType.Kind)))
-      throw new TypeError(`Class "${c.name}" is not a ${opra_schema_ns_exports.ComplexType.Kind}, ${opra_schema_ns_exports.UnionType.Kind} or ${opra_schema_ns_exports.MappedType.Kind}`);
+    if (!(itemMeta && (itemMeta.kind === opra_schema_ns_exports.ComplexType.Kind || itemMeta.kind === opra_schema_ns_exports.MixinType.Kind || itemMeta.kind === opra_schema_ns_exports.MappedType.Kind)))
+      throw new TypeError(`Class "${c.name}" is not a ${opra_schema_ns_exports.ComplexType.Kind}, ${opra_schema_ns_exports.MixinType.Kind} or ${opra_schema_ns_exports.MappedType.Kind}`);
     metadata.types.push(c);
-    mergePrototype(UnionClass.prototype, c.prototype);
+    mergePrototype(MixinType2.prototype, c.prototype);
   }
-  UnionType2._applyMixin(UnionClass, ...clasRefs);
-  return UnionClass;
-}, "UnionType");
-UnionType2.prototype = UnionTypeClass.prototype;
-UnionType2._applyMixin = () => void 0;
+  MixinType2._applyMixin(MixinClass, ...clasRefs);
+  return MixinClass;
+}, "MixinType");
+MixinType2.prototype = MixinTypeClass.prototype;
+MixinType2._applyMixin = () => void 0;
 
 // ../../build/common/esm/document/resource/enums/metadata-mode.enum.js
 var MetadataMode;
@@ -2573,6 +2577,7 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
     return document;
   }
   async initDocument(init) {
+    init.version = init.version || opra_schema_ns_exports.SpecVersion;
     this.document.url = init.url;
     if (init.info)
       Object.assign(this.document.info, init.info);
@@ -2729,8 +2734,8 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
         EnumType2.apply(instance, [this.document, initArguments]);
       else if (initArguments.kind === "MappedType")
         MappedType2.apply(instance, [this.document, initArguments]);
-      else if (initArguments.kind === "UnionType")
-        UnionType2.apply(instance, [this.document, initArguments]);
+      else if (initArguments.kind === "MixinType")
+        MixinType2.apply(instance, [this.document, initArguments]);
       else
         throw new TypeError(`Invalid data type schema: ${String(initArguments)}`);
       return instance;
@@ -2804,7 +2809,7 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
         throw new TypeError("MappedType.type property must address to a ComplexType");
       initArguments.base = dataType;
     }
-    if (initArguments.kind === "UnionType") {
+    if (initArguments.kind === "MixinType") {
       const oldTypes = initArguments.types;
       initArguments.types = [];
       for (const type of oldTypes)
@@ -2831,8 +2836,8 @@ var TypeDocumentFactory = class _TypeDocumentFactory {
       case opra_schema_ns_exports.SimpleType.Kind:
         Object.setPrototypeOf(dataType, SimpleType2.prototype);
         break;
-      case opra_schema_ns_exports.UnionType.Kind:
-        Object.setPrototypeOf(dataType, UnionType2.prototype);
+      case opra_schema_ns_exports.MixinType.Kind:
+        Object.setPrototypeOf(dataType, MixinType2.prototype);
         break;
       default:
         throw new TypeError(`Unknown DataType kind (${kind})`);
@@ -10411,8 +10416,11 @@ var CrudResource = class extends Resource {
       }
     }
   }
-  getOperation(name) {
-    return this.operations.get(name);
+  getOperation(operation) {
+    const op = this.operations.get(operation);
+    if (!op)
+      throw new Error(`${this.name} resource does not support "${operation}" operations`);
+    return op;
   }
   exportSchema(options) {
     const schema = super.exportSchema(options);
@@ -10449,7 +10457,7 @@ var CollectionClass = class extends CrudResource {
       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,
+        partial: false,
         pick: endpoint.options.inputPickFields,
         omit: endpoint.options.inputOmitFields,
         operation: "write",
@@ -10508,6 +10516,7 @@ var CollectionClass = class extends CrudResource {
       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.options.inputPickFields,
         omit: endpoint.options.inputOmitFields,
         operation: "write",
@@ -12087,6 +12096,7 @@ export {
   MappedType2 as MappedType,
   MetadataMode,
   MethodNotAllowedError,
+  MixinType2 as MixinType,
   NAMESPACE_PATTERN,
   NotAcceptableError,
   NotFoundError,
@@ -12112,7 +12122,6 @@ export {
   TypeDocument,
   TypeDocumentFactory,
   UnauthorizedError,
-  UnionType2 as UnionType,
   UnprocessableEntityError,
   ValidationError,
   cloneObject,

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

@@ -19,8 +19,8 @@ class ComplexTypeClass extends data_type_js_1.DataType {
         const own = this.own = {};
         own.ctor = init.ctor;
         if (init.base) {
-            if (!(init.base.kind === 'ComplexType' || init.base.kind === 'MappedType' || init.base.kind === 'UnionType'))
-                throw new TypeError('"base" argument must be one of ComplexType or MappedType or UnionType');
+            if (!(init.base.kind === 'ComplexType' || init.base.kind === 'MappedType' || init.base.kind === 'MixinType'))
+                throw new TypeError('"base" argument must be one of ComplexType or MappedType or MixinType');
             own.ctor = own.ctor || init.base.ctor;
         }
         own.additionalFields = init?.additionalFields;

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

@@ -15,11 +15,13 @@ class FieldClass {
         this.default = init.default;
         this.fixed = init.fixed;
         this.required = init.required;
+        this.nullish = init.nullish;
         this.readonly = init.readonly;
         this.writeonly = init.writeonly;
         this.exclusive = init.exclusive;
         this.deprecated = init.deprecated;
         this.examples = init.examples;
+        this.format = init.format;
     }
     exportSchema(options) {
         return (0, index_js_1.omitUndefined)({
@@ -30,11 +32,13 @@ class FieldClass {
             default: this.default,
             fixed: this.fixed,
             required: this.required,
+            nullish: this.nullish,
             readonly: this.readonly,
             writeonly: this.writeonly,
             exclusive: this.exclusive,
             deprecated: this.deprecated,
-            examples: this.examples
+            examples: this.examples,
+            format: this.format,
         });
     }
     generateCodec(codec, options) {

package/cjs/document/data-type/{union-type-class.js → mixin-type-class.js}

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnionTypeClass = void 0;
+exports.MixinTypeClass = void 0;
 const index_js_1 = require("../../schema/index.js");
 const complex_type_js_1 = require("./complex-type.js");
 const mapped_type_js_1 = require("./mapped-type.js");
-class UnionTypeClass extends complex_type_js_1.ComplexType {
+class MixinTypeClass extends complex_type_js_1.ComplexType {
     constructor(document, init) {
         super(document, init);
-        this.kind = index_js_1.OpraSchema.UnionType.Kind;
+        this.kind = index_js_1.OpraSchema.MixinType.Kind;
         const own = this.own;
         own.types = [];
-        const UnionType = Object.getPrototypeOf(this).constructor;
+        const MixinType = Object.getPrototypeOf(this).constructor;
         for (const base of init.types) {
-            if (!(base instanceof complex_type_js_1.ComplexType || base instanceof UnionType || base instanceof mapped_type_js_1.MappedType))
-                throw new TypeError(`${index_js_1.OpraSchema.UnionType.Kind} shall contain ${index_js_1.OpraSchema.ComplexType.Kind}, ` +
-                    `${index_js_1.OpraSchema.UnionType.Kind} of ${index_js_1.OpraSchema.MappedType.Kind} types.`);
+            if (!(base instanceof complex_type_js_1.ComplexType || base instanceof MixinType || base instanceof mapped_type_js_1.MappedType))
+                throw new TypeError(`${index_js_1.OpraSchema.MixinType.Kind} shall contain ${index_js_1.OpraSchema.ComplexType.Kind}, ` +
+                    `${index_js_1.OpraSchema.MixinType.Kind} of ${index_js_1.OpraSchema.MappedType.Kind} types.`);
             own.types.push(base);
             if (base.additionalFields === true && this.additionalFields !== true) {
                 // @ts-ignore
@@ -35,4 +35,4 @@ class UnionTypeClass extends complex_type_js_1.ComplexType {
         return out;
     }
 }
-exports.UnionTypeClass = UnionTypeClass;
+exports.MixinTypeClass = MixinTypeClass;

package/cjs/document/data-type/{union-type.js → mixin-type.js}

@@ -1,51 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnionType = void 0;
+exports.MixinType = void 0;
 const tslib_1 = require("tslib");
 require("reflect-metadata");
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
-const union_type_class_js_1 = require("./union-type-class.js");
+const mixin_type_class_js_1 = require("./mixin-type-class.js");
 /**
- * @class UnionType
+ * @class MixinType
  */
-exports.UnionType = function (...args) {
+exports.MixinType = function (...args) {
     // Constructor
     if (this) {
         const [document, init] = args;
-        (0, putil_merge_1.default)(this, new union_type_class_js_1.UnionTypeClass(document, init), { descriptor: true });
+        (0, putil_merge_1.default)(this, new mixin_type_class_js_1.MixinTypeClass(document, init), { descriptor: true });
         return;
     }
-    // UnionType helper
+    // MixinType helper
     // Filter undefined items
     const clasRefs = [...args].filter(x => !!x);
     if (!clasRefs.length)
         throw new TypeError('No Class has been provided');
     if (clasRefs.length === 1)
         return clasRefs[0];
-    class UnionClass {
+    class MixinClass {
         constructor() {
             for (const c of clasRefs)
                 (0, index_js_1.inheritPropertyInitializers)(this, c);
         }
     }
     const metadata = {
-        kind: index_js_2.OpraSchema.UnionType.Kind,
+        kind: index_js_2.OpraSchema.MixinType.Kind,
         types: []
     };
-    Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, UnionClass);
+    Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, MixinClass);
     for (const c of clasRefs) {
         const itemMeta = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, c);
-        if (!(itemMeta && (itemMeta.kind === index_js_2.OpraSchema.ComplexType.Kind || itemMeta.kind === index_js_2.OpraSchema.UnionType.Kind ||
+        if (!(itemMeta && (itemMeta.kind === index_js_2.OpraSchema.ComplexType.Kind || itemMeta.kind === index_js_2.OpraSchema.MixinType.Kind ||
             itemMeta.kind === index_js_2.OpraSchema.MappedType.Kind)))
-            throw new TypeError(`Class "${c.name}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}, ${index_js_2.OpraSchema.UnionType.Kind} or ${index_js_2.OpraSchema.MappedType.Kind}`);
+            throw new TypeError(`Class "${c.name}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}, ${index_js_2.OpraSchema.MixinType.Kind} or ${index_js_2.OpraSchema.MappedType.Kind}`);
         metadata.types.push(c);
-        (0, index_js_1.mergePrototype)(UnionClass.prototype, c.prototype);
+        (0, index_js_1.mergePrototype)(exports.MixinType.prototype, c.prototype);
     }
-    exports.UnionType._applyMixin(UnionClass, ...clasRefs);
-    return UnionClass;
+    exports.MixinType._applyMixin(MixinClass, ...clasRefs);
+    return MixinClass;
 };
-exports.UnionType.prototype = union_type_class_js_1.UnionTypeClass.prototype;
-exports.UnionType._applyMixin = () => void 0;
+exports.MixinType.prototype = mixin_type_class_js_1.MixinTypeClass.prototype;
+exports.MixinType._applyMixin = () => void 0;

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

@@ -9,8 +9,8 @@ const index_js_3 = require("../data-type/builtin/index.js");
 const complex_type_js_1 = require("../data-type/complex-type.js");
 const enum_type_js_1 = require("../data-type/enum-type.js");
 const mapped_type_js_1 = require("../data-type/mapped-type.js");
+const mixin_type_js_1 = require("../data-type/mixin-type.js");
 const simple_type_js_1 = require("../data-type/simple-type.js");
-const union_type_js_1 = require("../data-type/union-type.js");
 const metadata_mode_enum_js_1 = require("../resource/enums/metadata-mode.enum.js");
 const operation_result_type_js_1 = require("../resource/types/operation-result.type.js");
 const type_document_js_1 = require("../type-document.js");
@@ -43,6 +43,7 @@ class TypeDocumentFactory {
         return document;
     }
     async initDocument(init) {
+        init.version = init.version || index_js_2.OpraSchema.SpecVersion;
         this.document.url = init.url;
         if (init.info)
             Object.assign(this.document.info, init.info);
@@ -200,8 +201,8 @@ class TypeDocumentFactory {
                 enum_type_js_1.EnumType.apply(instance, [this.document, initArguments]);
             else if (initArguments.kind === 'MappedType')
                 mapped_type_js_1.MappedType.apply(instance, [this.document, initArguments]);
-            else if (initArguments.kind === 'UnionType')
-                union_type_js_1.UnionType.apply(instance, [this.document, initArguments]);
+            else if (initArguments.kind === 'MixinType')
+                mixin_type_js_1.MixinType.apply(instance, [this.document, initArguments]);
             else
                 throw new TypeError(`Invalid data type schema: ${String(initArguments)}`);
             return instance;
@@ -285,7 +286,7 @@ class TypeDocumentFactory {
                 throw new TypeError('MappedType.type property must address to a ComplexType');
             initArguments.base = dataType;
         }
-        if (initArguments.kind === 'UnionType') {
+        if (initArguments.kind === 'MixinType') {
             const oldTypes = initArguments.types;
             initArguments.types = [];
             for (const type of oldTypes)
@@ -312,8 +313,8 @@ class TypeDocumentFactory {
             case index_js_2.OpraSchema.SimpleType.Kind:
                 Object.setPrototypeOf(dataType, simple_type_js_1.SimpleType.prototype);
                 break;
-            case index_js_2.OpraSchema.UnionType.Kind:
-                Object.setPrototypeOf(dataType, union_type_js_1.UnionType.prototype);
+            case index_js_2.OpraSchema.MixinType.Kind:
+                Object.setPrototypeOf(dataType, mixin_type_js_1.MixinType.prototype);
                 break;
             default:
                 throw new TypeError(`Unknown DataType kind (${kind})`);

package/cjs/document/index.js

@@ -13,7 +13,7 @@ tslib_1.__exportStar(require("./data-type/field.js"), exports);
 tslib_1.__exportStar(require("./data-type/enum-type.js"), exports);
 tslib_1.__exportStar(require("./data-type/mapped-type.js"), exports);
 tslib_1.__exportStar(require("./data-type/simple-type.js"), exports);
-tslib_1.__exportStar(require("./data-type/union-type.js"), exports);
+tslib_1.__exportStar(require("./data-type/mixin-type.js"), exports);
 tslib_1.__exportStar(require("./resource/action.js"), exports);
 tslib_1.__exportStar(require("./resource/collection.js"), exports);
 tslib_1.__exportStar(require("./resource/container.js"), exports);

package/cjs/document/resource/collection-class.js

@@ -33,7 +33,7 @@ class CollectionClass extends crud_resource_js_1.CrudResource {
             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,
+                partial: false,
                 pick: endpoint.options.inputPickFields,
                 omit: endpoint.options.inputOmitFields,
                 operation: 'write',
@@ -100,6 +100,7 @@ class CollectionClass extends crud_resource_js_1.CrudResource {
             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.options.inputPickFields,
                 omit: endpoint.options.inputOmitFields,
                 operation: 'write',

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

@@ -14,8 +14,11 @@ class CrudResource extends resource_js_1.Resource {
             }
         }
     }
-    getOperation(name) {
-        return this.operations.get(name);
+    getOperation(operation) {
+        const op = this.operations.get(operation);
+        if (!op)
+            throw new Error(`${this.name} resource does not support "${operation}" operations`);
+        return op;
     }
     exportSchema(options) {
         const schema = super.exportSchema(options);

package/cjs/schema/data-type/mixin-type.interface.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MixinType = void 0;
+var MixinType;
+(function (MixinType) {
+    MixinType.Kind = 'MixinType';
+})(MixinType || (exports.MixinType = MixinType = {}));

package/cjs/schema/opra-schema.ns.js

@@ -7,7 +7,7 @@ tslib_1.__exportStar(require("./data-type/enum-type.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type/field.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type/simple-type.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type/mapped-type.interface.js"), exports);
-tslib_1.__exportStar(require("./data-type/union-type.interface.js"), exports);
+tslib_1.__exportStar(require("./data-type/mixin-type.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/action.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/endpoint.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/collection.interface.js"), exports);

package/cjs/schema/type-guards.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isContainer = exports.isStorage = exports.isSingleton = exports.isCollection = exports.isResource = exports.isEnumType = exports.isMappedType = exports.isUnionType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
+exports.isContainer = exports.isStorage = exports.isSingleton = exports.isCollection = exports.isResource = exports.isEnumType = exports.isMappedType = exports.isMixinType = exports.isSimpleType = exports.isComplexType = exports.isDataType = void 0;
 const complex_type_interface_js_1 = require("./data-type/complex-type.interface.js");
 const enum_type_interface_js_1 = require("./data-type/enum-type.interface.js");
 const mapped_type_interface_js_1 = require("./data-type/mapped-type.interface.js");
+const mixin_type_interface_js_1 = require("./data-type/mixin-type.interface.js");
 const simple_type_interface_js_1 = require("./data-type/simple-type.interface.js");
-const union_type_interface_js_1 = require("./data-type/union-type.interface.js");
 const collection_interface_js_1 = require("./resource/collection.interface.js");
 const container_interface_js_1 = require("./resource/container.interface.js");
 const singleton_interface_js_1 = require("./resource/singleton.interface.js");
@@ -16,7 +16,7 @@ function isDataType(obj) {
             obj.kind === enum_type_interface_js_1.EnumType.Kind ||
             obj.kind === mapped_type_interface_js_1.MappedType.Kind ||
             obj.kind === simple_type_interface_js_1.SimpleType.Kind ||
-            obj.kind === union_type_interface_js_1.UnionType.Kind);
+            obj.kind === mixin_type_interface_js_1.MixinType.Kind);
 }
 exports.isDataType = isDataType;
 function isComplexType(obj) {
@@ -27,10 +27,10 @@ function isSimpleType(obj) {
     return obj && typeof obj === 'object' && obj.kind === simple_type_interface_js_1.SimpleType.Kind;
 }
 exports.isSimpleType = isSimpleType;
-function isUnionType(obj) {
-    return obj && typeof obj === 'object' && obj.kind === union_type_interface_js_1.UnionType.Kind;
+function isMixinType(obj) {
+    return obj && typeof obj === 'object' && obj.kind === mixin_type_interface_js_1.MixinType.Kind;
 }
-exports.isUnionType = isUnionType;
+exports.isMixinType = isMixinType;
 function isMappedType(obj) {
     return obj && typeof obj === 'object' && obj.kind === mapped_type_interface_js_1.MappedType.Kind;
 }

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

@@ -15,8 +15,8 @@ export class ComplexTypeClass extends DataType {
         const own = this.own = {};
         own.ctor = init.ctor;
         if (init.base) {
-            if (!(init.base.kind === 'ComplexType' || init.base.kind === 'MappedType' || init.base.kind === 'UnionType'))
-                throw new TypeError('"base" argument must be one of ComplexType or MappedType or UnionType');
+            if (!(init.base.kind === 'ComplexType' || init.base.kind === 'MappedType' || init.base.kind === 'MixinType'))
+                throw new TypeError('"base" argument must be one of ComplexType or MappedType or MixinType');
             own.ctor = own.ctor || init.base.ctor;
         }
         own.additionalFields = init?.additionalFields;

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

@@ -11,11 +11,13 @@ export class FieldClass {
         this.default = init.default;
         this.fixed = init.fixed;
         this.required = init.required;
+        this.nullish = init.nullish;
         this.readonly = init.readonly;
         this.writeonly = init.writeonly;
         this.exclusive = init.exclusive;
         this.deprecated = init.deprecated;
         this.examples = init.examples;
+        this.format = init.format;
     }
     exportSchema(options) {
         return omitUndefined({
@@ -26,11 +28,13 @@ export class FieldClass {
             default: this.default,
             fixed: this.fixed,
             required: this.required,
+            nullish: this.nullish,
             readonly: this.readonly,
             writeonly: this.writeonly,
             exclusive: this.exclusive,
             deprecated: this.deprecated,
-            examples: this.examples
+            examples: this.examples,
+            format: this.format,
         });
     }
     generateCodec(codec, options) {

package/esm/document/data-type/{union-type-class.js → mixin-type-class.js}

@@ -1,17 +1,17 @@
 import { OpraSchema } from '../../schema/index.js';
 import { ComplexType } from './complex-type.js';
 import { MappedType } from './mapped-type.js';
-export class UnionTypeClass extends ComplexType {
+export class MixinTypeClass extends ComplexType {
     constructor(document, init) {
         super(document, init);
-        this.kind = OpraSchema.UnionType.Kind;
+        this.kind = OpraSchema.MixinType.Kind;
         const own = this.own;
         own.types = [];
-        const UnionType = Object.getPrototypeOf(this).constructor;
+        const MixinType = Object.getPrototypeOf(this).constructor;
         for (const base of init.types) {
-            if (!(base instanceof ComplexType || base instanceof UnionType || base instanceof MappedType))
-                throw new TypeError(`${OpraSchema.UnionType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ` +
-                    `${OpraSchema.UnionType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
+            if (!(base instanceof ComplexType || base instanceof MixinType || base instanceof MappedType))
+                throw new TypeError(`${OpraSchema.MixinType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ` +
+                    `${OpraSchema.MixinType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
             own.types.push(base);
             if (base.additionalFields === true && this.additionalFields !== true) {
                 // @ts-ignore

package/esm/document/data-type/{union-type.js → mixin-type.js}

@@ -3,45 +3,45 @@ import merge from 'putil-merge';
 import { inheritPropertyInitializers, mergePrototype, } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
-import { UnionTypeClass } from './union-type-class.js';
+import { MixinTypeClass } from './mixin-type-class.js';
 /**
- * @class UnionType
+ * @class MixinType
  */
-export const UnionType = function (...args) {
+export const MixinType = function (...args) {
     // Constructor
     if (this) {
         const [document, init] = args;
-        merge(this, new UnionTypeClass(document, init), { descriptor: true });
+        merge(this, new MixinTypeClass(document, init), { descriptor: true });
         return;
     }
-    // UnionType helper
+    // MixinType helper
     // Filter undefined items
     const clasRefs = [...args].filter(x => !!x);
     if (!clasRefs.length)
         throw new TypeError('No Class has been provided');
     if (clasRefs.length === 1)
         return clasRefs[0];
-    class UnionClass {
+    class MixinClass {
         constructor() {
             for (const c of clasRefs)
                 inheritPropertyInitializers(this, c);
         }
     }
     const metadata = {
-        kind: OpraSchema.UnionType.Kind,
+        kind: OpraSchema.MixinType.Kind,
         types: []
     };
-    Reflect.defineMetadata(DATATYPE_METADATA, metadata, UnionClass);
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, MixinClass);
     for (const c of clasRefs) {
         const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, c);
-        if (!(itemMeta && (itemMeta.kind === OpraSchema.ComplexType.Kind || itemMeta.kind === OpraSchema.UnionType.Kind ||
+        if (!(itemMeta && (itemMeta.kind === OpraSchema.ComplexType.Kind || itemMeta.kind === OpraSchema.MixinType.Kind ||
             itemMeta.kind === OpraSchema.MappedType.Kind)))
-            throw new TypeError(`Class "${c.name}" is not a ${OpraSchema.ComplexType.Kind}, ${OpraSchema.UnionType.Kind} or ${OpraSchema.MappedType.Kind}`);
+            throw new TypeError(`Class "${c.name}" is not a ${OpraSchema.ComplexType.Kind}, ${OpraSchema.MixinType.Kind} or ${OpraSchema.MappedType.Kind}`);
         metadata.types.push(c);
-        mergePrototype(UnionClass.prototype, c.prototype);
+        mergePrototype(MixinType.prototype, c.prototype);
     }
-    UnionType._applyMixin(UnionClass, ...clasRefs);
-    return UnionClass;
+    MixinType._applyMixin(MixinClass, ...clasRefs);
+    return MixinClass;
 };
-UnionType.prototype = UnionTypeClass.prototype;
-UnionType._applyMixin = () => void 0;
+MixinType.prototype = MixinTypeClass.prototype;
+MixinType._applyMixin = () => void 0;

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

@@ -6,8 +6,8 @@ import { AnyType, Base64Type, BigintType, BooleanType, DateType, IntegerType, Nu
 import { ComplexType } from '../data-type/complex-type.js';
 import { EnumType } from '../data-type/enum-type.js';
 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 { UnionType } from '../data-type/union-type.js';
 import { MetadataMode } from '../resource/enums/metadata-mode.enum.js';
 import { OperationResult } from '../resource/types/operation-result.type.js';
 import { TypeDocument } from '../type-document.js';
@@ -40,6 +40,7 @@ export class TypeDocumentFactory {
         return document;
     }
     async initDocument(init) {
+        init.version = init.version || OpraSchema.SpecVersion;
         this.document.url = init.url;
         if (init.info)
             Object.assign(this.document.info, init.info);
@@ -197,8 +198,8 @@ export class TypeDocumentFactory {
                 EnumType.apply(instance, [this.document, initArguments]);
             else if (initArguments.kind === 'MappedType')
                 MappedType.apply(instance, [this.document, initArguments]);
-            else if (initArguments.kind === 'UnionType')
-                UnionType.apply(instance, [this.document, initArguments]);
+            else if (initArguments.kind === 'MixinType')
+                MixinType.apply(instance, [this.document, initArguments]);
             else
                 throw new TypeError(`Invalid data type schema: ${String(initArguments)}`);
             return instance;
@@ -282,7 +283,7 @@ export class TypeDocumentFactory {
                 throw new TypeError('MappedType.type property must address to a ComplexType');
             initArguments.base = dataType;
         }
-        if (initArguments.kind === 'UnionType') {
+        if (initArguments.kind === 'MixinType') {
             const oldTypes = initArguments.types;
             initArguments.types = [];
             for (const type of oldTypes)
@@ -309,8 +310,8 @@ export class TypeDocumentFactory {
             case OpraSchema.SimpleType.Kind:
                 Object.setPrototypeOf(dataType, SimpleType.prototype);
                 break;
-            case OpraSchema.UnionType.Kind:
-                Object.setPrototypeOf(dataType, UnionType.prototype);
+            case OpraSchema.MixinType.Kind:
+                Object.setPrototypeOf(dataType, MixinType.prototype);
                 break;
             default:
                 throw new TypeError(`Unknown DataType kind (${kind})`);

package/esm/document/index.js

@@ -10,7 +10,7 @@ export * from './data-type/field.js';
 export * from './data-type/enum-type.js';
 export * from './data-type/mapped-type.js';
 export * from './data-type/simple-type.js';
-export * from './data-type/union-type.js';
+export * from './data-type/mixin-type.js';
 export * from './resource/action.js';
 export * from './resource/collection.js';
 export * from './resource/container.js';

package/esm/document/resource/collection-class.js

@@ -29,7 +29,7 @@ export class CollectionClass extends CrudResource {
             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,
+                partial: false,
                 pick: endpoint.options.inputPickFields,
                 omit: endpoint.options.inputOmitFields,
                 operation: 'write',
@@ -96,6 +96,7 @@ export class CollectionClass extends CrudResource {
             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.options.inputPickFields,
                 omit: endpoint.options.inputOmitFields,
                 operation: 'write',

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

@@ -11,8 +11,11 @@ export class CrudResource extends Resource {
             }
         }
     }
-    getOperation(name) {
-        return this.operations.get(name);
+    getOperation(operation) {
+        const op = this.operations.get(operation);
+        if (!op)
+            throw new Error(`${this.name} resource does not support "${operation}" operations`);
+        return op;
     }
     exportSchema(options) {
         const schema = super.exportSchema(options);

package/esm/schema/data-type/mixin-type.interface.js

@@ -0,0 +1,4 @@
+export var MixinType;
+(function (MixinType) {
+    MixinType.Kind = 'MixinType';
+})(MixinType || (MixinType = {}));

package/esm/schema/opra-schema.ns.js

@@ -4,7 +4,7 @@ export * from './data-type/enum-type.interface.js';
 export * from './data-type/field.interface.js';
 export * from './data-type/simple-type.interface.js';
 export * from './data-type/mapped-type.interface.js';
-export * from './data-type/union-type.interface.js';
+export * from './data-type/mixin-type.interface.js';
 export * from './resource/action.interface.js';
 export * from './resource/endpoint.interface.js';
 export * from './resource/collection.interface.js';

package/esm/schema/type-guards.js

@@ -1,8 +1,8 @@
 import { ComplexType } from './data-type/complex-type.interface.js';
 import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
+import { MixinType } from './data-type/mixin-type.interface.js';
 import { SimpleType } from './data-type/simple-type.interface.js';
-import { UnionType } from './data-type/union-type.interface.js';
 import { Collection } from './resource/collection.interface.js';
 import { Container } from './resource/container.interface.js';
 import { Singleton } from './resource/singleton.interface.js';
@@ -13,7 +13,7 @@ export function isDataType(obj) {
             obj.kind === EnumType.Kind ||
             obj.kind === MappedType.Kind ||
             obj.kind === SimpleType.Kind ||
-            obj.kind === UnionType.Kind);
+            obj.kind === MixinType.Kind);
 }
 export function isComplexType(obj) {
     return obj && typeof obj === 'object' && obj.kind === ComplexType.Kind;
@@ -21,8 +21,8 @@ export function isComplexType(obj) {
 export function isSimpleType(obj) {
     return obj && typeof obj === 'object' && obj.kind === SimpleType.Kind;
 }
-export function isUnionType(obj) {
-    return obj && typeof obj === 'object' && obj.kind === UnionType.Kind;
+export function isMixinType(obj) {
+    return obj && typeof obj === 'object' && obj.kind === MixinType.Kind;
 }
 export function isMappedType(obj) {
     return obj && typeof obj === 'object' && obj.kind === MappedType.Kind;

package/package.json

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

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

@@ -7,14 +7,14 @@ import type { ComplexType } from './complex-type.js';
 import { DataType } from './data-type.js';
 import { ApiField } from './field.js';
 import type { MappedType } from './mapped-type.js';
-import type { UnionType } from './union-type.js';
+import type { MixinType } from './mixin-type.js';
 /**
  * @class ComplexType
  */
 export declare class ComplexTypeClass extends DataType {
     readonly kind: OpraSchema.DataType.Kind;
     readonly ctor: Type;
-    readonly base?: ComplexType | UnionType | MappedType;
+    readonly base?: ComplexType | MixinType | MappedType;
     readonly own: ComplexType.OwnProperties;
     readonly fields: ResponsiveMap<ApiField>;
     readonly abstract?: boolean;

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

@@ -8,7 +8,7 @@ import { ComplexTypeClass } from './complex-type-class.js';
 import { DataType } from './data-type.js';
 import { ApiField } from './field.js';
 import type { MappedType } from './mapped-type.js';
-import type { UnionType } from './union-type.js';
+import type { MixinType } from './mixin-type.js';
 /**
  * Callable class pattern for ComplexType
  */
@@ -29,7 +29,7 @@ export declare const ComplexType: ComplexTypeConstructor;
  */
 export declare namespace ComplexType {
     interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.ComplexType, 'ctor' | 'abstract'> {
-        base?: ComplexType | MappedType | UnionType;
+        base?: ComplexType | MappedType | MixinType;
         fields?: Record<string, ApiField.InitArguments>;
         additionalFields?: boolean | DataType | 'error';
     }

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

@@ -11,13 +11,15 @@ export declare class FieldClass {
     description?: string;
     isArray?: boolean;
     default?: any;
-    fixed?: string | number;
+    fixed?: string | number | boolean;
     required?: boolean;
+    nullish?: boolean;
     readonly?: boolean;
     writeonly?: boolean;
     exclusive?: boolean;
     deprecated?: boolean | string;
     examples?: any[] | Record<string, any>;
+    format?: string;
     constructor(owner: ComplexType, init: ApiField.InitArguments);
     exportSchema(options?: {
         webSafe?: boolean;

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

@@ -4,11 +4,11 @@ import type { ApiDocument } from '../api-document.js';
 import type { ComplexType } from './complex-type.js';
 import { ComplexTypeClass } from './complex-type-class.js';
 import type { MappedType } from './mapped-type.js';
-import type { UnionType } from './union-type.js';
+import type { MixinType } from './mixin-type';
 export declare class MappedTypeClass extends ComplexTypeClass {
     readonly kind: OpraSchema.DataType.Kind;
     readonly own: MappedType.OwnProperties;
-    readonly base: ComplexType | UnionType | MappedType;
+    readonly base: ComplexType | MixinType | MappedType;
     readonly omit?: Field.Name[];
     readonly pick?: Field.Name[];
     constructor(document: ApiDocument, init: MappedType.InitArguments);

package/types/document/data-type/{union-type-class.d.ts → mixin-type-class.d.ts}

@@ -2,11 +2,11 @@ import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { ComplexType } from './complex-type.js';
 import { MappedType } from './mapped-type.js';
-import type { UnionType } from './union-type.js';
-export declare class UnionTypeClass extends ComplexType {
+import type { MixinType } from './mixin-type';
+export declare class MixinTypeClass extends ComplexType {
     readonly kind: OpraSchema.DataType.Kind;
-    readonly own: UnionType.OwnProperties;
-    readonly types: (ComplexType | UnionType | MappedType)[];
-    constructor(document: ApiDocument, init: UnionType.InitArguments);
+    readonly own: MixinType.OwnProperties;
+    readonly types: (ComplexType | MixinType | MappedType)[];
+    constructor(document: ApiDocument, init: MixinType.InitArguments);
     exportSchema(): any;
 }

package/types/document/data-type/{union-type.d.ts → mixin-type.d.ts}

@@ -4,40 +4,40 @@ import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { ComplexType } from './complex-type.js';
 import { MappedType } from './mapped-type.js';
-import { UnionTypeClass } from './union-type-class.js';
+import { MixinTypeClass } from './mixin-type-class.js';
 /**
- * Type definition of UnionType constructor type
- * @type UnionTypeConstructor
+ * Type definition of MixinType constructor type
+ * @type MixinTypeConstructor
  */
-export interface UnionTypeConstructor {
-    prototype: UnionType;
-    new (document: ApiDocument, init: UnionType.InitArguments): UnionType;
+export interface MixinTypeConstructor {
+    prototype: MixinType;
+    new (document: ApiDocument, init: MixinType.InitArguments): MixinType;
     <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;
     _applyMixin(target: Type, ...sources: [Type]): void;
 }
 /**
- * Type definition of UnionType prototype
- * @type UnionType
+ * Type definition of MixinType prototype
+ * @type MixinType
  */
-export interface UnionType extends UnionTypeClass {
+export interface MixinType extends MixinTypeClass {
 }
 /**
- * @class UnionType
+ * @class MixinType
  */
-export declare const UnionType: UnionTypeConstructor;
+export declare const MixinType: MixinTypeConstructor;
 /**
- * @namespace UnionType
+ * @namespace MixinType
  */
-export declare namespace UnionType {
+export declare namespace MixinType {
     interface InitArguments extends ComplexType.InitArguments {
-        types: (ComplexType | UnionType | MappedType)[];
+        types: (ComplexType | MixinType | MappedType)[];
     }
     interface Metadata extends StrictOmit<ComplexType.Metadata, 'kind' | 'base' | 'name'> {
-        kind: OpraSchema.UnionType.Kind;
+        kind: OpraSchema.MixinType.Kind;
         base?: Type;
         types: Type[];
     }
     interface OwnProperties extends ComplexType.OwnProperties {
-        types: (ComplexType | UnionType | MappedType)[];
+        types: (ComplexType | MixinType | MappedType)[];
     }
 }

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

@@ -1,4 +1,4 @@
-import { StrictOmit, Type } from 'ts-gems';
+import { PartialSome, StrictOmit, Type } from 'ts-gems';
 import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { ThunkAsync } from '../../types.js';
@@ -7,11 +7,11 @@ import { ComplexType } from '../data-type/complex-type.js';
 import { DataType } from '../data-type/data-type.js';
 import { EnumType } from '../data-type/enum-type.js';
 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 { UnionType } from '../data-type/union-type.js';
 import { TypeDocument } from '../type-document.js';
 export declare namespace TypeDocumentFactory {
-    interface InitArguments extends StrictOmit<OpraSchema.TypeDocument, 'references' | 'types'> {
+    interface InitArguments extends PartialSome<StrictOmit<OpraSchema.TypeDocument, 'references' | 'types'>, 'version'> {
         references?: Record<string, string | OpraSchema.ApiDocument | ApiDocument>;
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[] | Record<string, OpraSchema.DataType>;
         noBuiltinTypes?: boolean;
@@ -20,8 +20,8 @@ export declare namespace TypeDocumentFactory {
         kind: OpraSchema.ComplexType.Kind;
     }) | (SimpleType.InitArguments & {
         kind: OpraSchema.SimpleType.Kind;
-    }) | (UnionType.InitArguments & {
-        kind: OpraSchema.UnionType.Kind;
+    }) | (MixinType.InitArguments & {
+        kind: OpraSchema.MixinType.Kind;
     }) | (MappedType.InitArguments & {
         kind: OpraSchema.MappedType.Kind;
     }) | (EnumType.InitArguments & {

package/types/document/index.d.ts

@@ -10,7 +10,7 @@ export * from './data-type/field.js';
 export * from './data-type/enum-type.js';
 export * from './data-type/mapped-type.js';
 export * from './data-type/simple-type.js';
-export * from './data-type/union-type.js';
+export * from './data-type/mixin-type.js';
 export * from './resource/action.js';
 export * from './resource/collection.js';
 export * from './resource/container.js';

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

@@ -7,7 +7,7 @@ import { Resource } from './resource.js';
 export declare abstract class CrudResource extends Resource {
     operations: ResponsiveMap<CrudOperation>;
     protected constructor(parent: ApiDocument | Container, init: Resource.InitArguments);
-    getOperation(name: string): CrudOperation | undefined;
+    getOperation(operation: string): CrudOperation | undefined;
     exportSchema(options?: {
         webSafe?: boolean;
     }): OpraSchema.ResourceBase & {

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

@@ -2,11 +2,11 @@ import { StrictOmit, Type } from 'ts-gems';
 import type { DataType, DataTypeBase } from './data-type.interface.js';
 import type { Field } from './field.interface.js';
 import type { MappedType } from './mapped-type.interface.js';
-import type { UnionType } from './union-type.interface.js';
+import type { MixinType } from './mixin-type.interface.js';
 export interface ComplexType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: ComplexType.Kind;
     ctor?: Type;
-    base?: DataType.Name | ComplexType | UnionType | MappedType;
+    base?: DataType.Name | ComplexType | MixinType | MappedType;
     abstract?: boolean;
     fields?: Record<Field.Name, Field | DataType.Name>;
     additionalFields?: boolean | 'error' | string | DataType;

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

@@ -1,12 +1,12 @@
 import type { ComplexType } from './complex-type.interface.js';
 import type { EnumType } from './enum-type.interface.js';
 import type { MappedType } from './mapped-type.interface.js';
+import type { MixinType } from './mixin-type.interface';
 import type { SimpleType } from './simple-type.interface.js';
-import type { UnionType } from './union-type.interface.js';
-export type DataType = SimpleType | EnumType | ComplexType | MappedType | UnionType;
+export type DataType = SimpleType | EnumType | ComplexType | MappedType | MixinType;
 export declare namespace DataType {
     type Name = string;
-    type Kind = ComplexType.Kind | EnumType.Kind | MappedType.Kind | SimpleType.Kind | UnionType.Kind;
+    type Kind = ComplexType.Kind | EnumType.Kind | MappedType.Kind | SimpleType.Kind | MixinType.Kind;
 }
 export interface DataTypeBase {
     kind: DataType.Kind;

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

@@ -5,19 +5,50 @@ export declare namespace Field {
 }
 export type Field = {
     type: DataType.Name | DataType;
+    /**
+     * Defines the description of the field
+     */
     description?: string;
+    /**
+     * Defines if the field value is an array
+     */
     isArray?: boolean;
+    /**
+     * Defines the default value of the field
+     */
     default?: any;
+    /**
+     * Defines 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
+     */
     required?: boolean;
+    /**
+     * Defines if field value be nullish (undefined, null or empty)
+     */
+    nullish?: boolean;
+    /**
+     * Defines if the field is readonly
+     */
     readonly?: boolean;
+    /**
+     * Defines if the field is writeonly
+     */
     writeonly?: boolean;
-    format?: string;
-    fixed?: string | number;
-    examples?: any[] | Record<string, any>;
-    deprecated?: boolean | string;
     /**
      * If true, this Field will not be included in results by default.
      * The client side should include the Field name in the "include" query parameter.
      */
     exclusive?: boolean;
+    /**
+     * Defines example values for the field
+     */
+    examples?: any[] | Record<string, any>;
+    /**
+     * Defines if the field is deprecated and can be removed in the next
+     */
+    deprecated?: boolean | string;
+    format?: string;
 };

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

@@ -0,0 +1,12 @@
+import { StrictOmit } from 'ts-gems';
+import type { ComplexType } from './complex-type.interface.js';
+import type { DataType } from './data-type.interface.js';
+import type { MappedType } from './mapped-type.interface.js';
+export interface MixinType extends StrictOmit<ComplexType, 'kind'> {
+    kind: MixinType.Kind;
+    types: (DataType.Name | ComplexType | MixinType | MappedType)[];
+}
+export declare namespace MixinType {
+    const Kind = "MixinType";
+    type Kind = 'MixinType';
+}

package/types/schema/opra-schema.ns.d.ts

@@ -4,7 +4,7 @@ export * from './data-type/enum-type.interface.js';
 export * from './data-type/field.interface.js';
 export * from './data-type/simple-type.interface.js';
 export * from './data-type/mapped-type.interface.js';
-export * from './data-type/union-type.interface.js';
+export * from './data-type/mixin-type.interface.js';
 export * from './resource/action.interface.js';
 export * from './resource/endpoint.interface.js';
 export * from './resource/collection.interface.js';

package/types/schema/type-guards.d.ts

@@ -2,8 +2,8 @@ import { ComplexType } from './data-type/complex-type.interface.js';
 import { DataType } from './data-type/data-type.interface.js';
 import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
+import { MixinType } from './data-type/mixin-type.interface.js';
 import { SimpleType } from './data-type/simple-type.interface.js';
-import { UnionType } from './data-type/union-type.interface.js';
 import { Collection } from './resource/collection.interface.js';
 import { Container } from './resource/container.interface.js';
 import { Resource } from './resource/resource.interface.js';
@@ -12,7 +12,7 @@ import { Storage } from './resource/storage.interface.js';
 export declare function isDataType(obj: any): obj is DataType;
 export declare function isComplexType(obj: any): obj is ComplexType;
 export declare function isSimpleType(obj: any): obj is SimpleType;
-export declare function isUnionType(obj: any): obj is UnionType;
+export declare function isMixinType(obj: any): obj is MixinType;
 export declare function isMappedType(obj: any): obj is MappedType;
 export declare function isEnumType(obj: any): obj is EnumType;
 export declare function isResource(obj: any): obj is Resource;

package/cjs/schema/data-type/union-type.interface.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnionType = void 0;
-var UnionType;
-(function (UnionType) {
-    UnionType.Kind = 'UnionType';
-})(UnionType || (exports.UnionType = UnionType = {}));

package/esm/schema/data-type/union-type.interface.js

@@ -1,4 +0,0 @@
-export var UnionType;
-(function (UnionType) {
-    UnionType.Kind = 'UnionType';
-})(UnionType || (UnionType = {}));

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

@@ -1,12 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import type { ComplexType } from './complex-type.interface.js';
-import type { DataType } from './data-type.interface.js';
-import type { MappedType } from './mapped-type.interface.js';
-export interface UnionType extends StrictOmit<ComplexType, 'kind'> {
-    kind: UnionType.Kind;
-    types: (DataType.Name | ComplexType | UnionType | MappedType)[];
-}
-export declare namespace UnionType {
-    const Kind = "UnionType";
-    type Kind = 'UnionType';
-}