@opra/common 0.26.4 → 0.27.0

package/cjs/document/type-document.js

@@ -6,13 +6,15 @@ const index_js_2 = require("../helpers/index.js");
 const index_js_3 = require("../schema/index.js");
 const constants_js_1 = require("./constants.js");
 const complex_type_js_1 = require("./data-type/complex-type.js");
+const data_type_js_1 = require("./data-type/data-type.js");
+const enum_type_js_1 = require("./data-type/enum-type.js");
 const document_base_js_1 = require("./document-base.js");
 class TypeDocument extends document_base_js_1.DocumentBase {
     constructor() {
         super();
         this._designCtorMap = new Map();
-        this._typeCache = new index_js_2.ResponsiveMap();
-        this._typesCacheByCtor = new Map();
+        this._typeIndex = new Map();
+        this._typeNsMap = new Map();
         this.references = new index_js_2.ResponsiveMap();
         this.types = new index_js_2.ResponsiveMap();
         const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
@@ -37,38 +39,45 @@ class TypeDocument extends document_base_js_1.DocumentBase {
             if (x)
                 arg0 = x;
         }
-        let dataType;
-        let name;
-        // Determine name
-        if (typeof arg0 === 'function') {
-            const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, arg0);
-            name = metadata?.name || arg0.name;
-        }
-        else if (typeof arg0 === 'function') {
-            const metadata = Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, arg0);
-            name = metadata?.name;
-        }
-        else
-            name = String(arg0);
         // Try to get instance from cache
         const t = typeof arg0 === 'string'
-            ? this._typeCache.get(arg0)
-            : this._typesCacheByCtor.get(arg0);
+            ? this._typeIndex.get(arg0.toLowerCase())
+            : this._typeIndex.get(arg0);
         if (t)
             return t;
-        // If cached as null, it means "not found"
+        // Determine name
+        let name;
+        if (typeof arg0 === 'string')
+            name = arg0;
+        else if (arg0 instanceof data_type_js_1.DataType)
+            name = arg0.name || '';
+        else {
+            const metadata = typeof arg0 === 'function'
+                ? Reflect.getMetadata(constants_js_1.DATATYPE_METADATA, arg0) : arg0?.[constants_js_1.DATATYPE_METADATA];
+            if (!metadata) {
+                /* istanbul ignore next */
+                if (!silent)
+                    throw new TypeError('Invalid argument');
+                return;
+            }
+            name = metadata.name;
+        }
+        // If cached as null, it means "not found" before
         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 = constants_js_1.NAMESPACE_PATTERN.exec(arg0);
             if (!m)
                 throw new TypeError(`Invalid data type name "${name}"`);
             // If given string has namespace pattern (ns:type_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;
@@ -81,61 +90,61 @@ class TypeDocument extends document_base_js_1.DocumentBase {
                 dataType = this.types.get(arg0);
                 // if not found, search in references (from last to first)
                 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 index_js_1.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 complex_type_js_1.ComplexType && dt.isTypeOf(arg0)) {
+                if (dt === arg0 ||
+                    ((dt instanceof complex_type_js_1.ComplexType || dt instanceof enum_type_js_1.EnumType) && dt.isTypeOf(arg0))) {
                     dataType = dt;
                     break;
                 }
             }
             // if not found, search in references (from last to first)
             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[constants_js_1.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 index_js_1.NotFoundError(`Data type "${name}" does not exists`);
+        return;
         /* istanbul ignore next */
         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';
@@ -188,8 +197,8 @@ class TypeDocument extends document_base_js_1.DocumentBase {
         return schema;
     }
     invalidate() {
-        this._typeCache.clear();
-        this._typesCacheByCtor.clear();
+        this._typeIndex.clear();
+        this._typeNsMap.clear();
     }
 }
 exports.TypeDocument = TypeDocument;

package/cjs/helpers/object-utils.js

@@ -4,10 +4,10 @@ exports.omitUndefined = exports.cloneObject = void 0;
 const tslib_1 = require("tslib");
 const putil_isplainobject_1 = tslib_1.__importDefault(require("putil-isplainobject"));
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const constants_js_1 = require("../document/constants.js");
 function cloneObject(obj, jsonOnly) {
     return (0, putil_merge_1.default)({}, obj, {
-        deep: true,
-        clone: true,
+        deep: (v) => (0, putil_isplainobject_1.default)(v) && !v[constants_js_1.DATATYPE_METADATA],
         filter: (source, key) => {
             const v = source[key];
             return v != null &&

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

@@ -8,6 +8,7 @@ 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("./resource/action.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/endpoint.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/collection.interface.js"), exports);
 tslib_1.__exportStar(require("./resource/container.interface.js"), exports);

package/cjs/schema/resource/action.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -153,11 +153,7 @@ export class ComplexTypeClass extends DataType {
         return false;
     }
     generateCodec(codec, options) {
-        const schema = {};
-        for (const f of this.fields.values()) {
-            // todo omit, pick
-            schema[f.name] = f.generateCodec(codec, options);
-        }
+        const schema = this._generateCodecSchema(codec, options);
         return vg.isObject(schema, {
             ctor: this.ctor,
             additionalFields: this.additionalFields ?? false,
@@ -165,4 +161,26 @@ export class ComplexTypeClass 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;
+    }
 }

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

@@ -1,6 +1,7 @@
 import * as vg from 'valgen';
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
+import { DATATYPE_METADATA } from '../constants.js';
 import { DataType } from './data-type.js';
 export class EnumTypeClass extends DataType {
     constructor(document, init) {
@@ -13,6 +14,9 @@ export class EnumTypeClass extends DataType {
         this.decode = vg.isEnum(Object.keys(this.values));
         this.encode = vg.isEnum(Object.keys(this.values));
     }
+    isTypeOf(t) {
+        return t[DATATYPE_METADATA] === this.enumObject?.[DATATYPE_METADATA];
+    }
     exportSchema() {
         const out = super.exportSchema();
         out.values = {};

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

@@ -18,7 +18,6 @@ export class MappedTypeClass extends ComplexTypeClass {
             }
         }
     }
-    // @ts-ignore
     exportSchema() {
         const out = super.exportSchema();
         Object.assign(out, omitUndefined({

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

@@ -8,6 +8,8 @@ import { EnumType } from '../data-type/enum-type.js';
 import { MappedType } from '../data-type/mapped-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';
 /**
  * @class TypeDocumentFactory
@@ -43,7 +45,7 @@ export 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);
@@ -83,13 +85,10 @@ export class TypeDocumentFactory {
     async createBuiltinTypeDocument() {
         const init = {
             version: OpraSchema.SpecVersion,
+            url: 'https://oprajs.com/spec/v1.0',
             info: {
                 version: OpraSchema.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'
@@ -98,7 +97,8 @@ export class TypeDocumentFactory {
             types: [AnyType, Base64Type, BigintType, BooleanType,
                 DateType, UuidType, IntegerType, NullType,
                 NumberType, ObjectType, ObjectIdType, StringType,
-                TimeType, TimestampType
+                TimeType, TimestampType,
+                OperationResult, MetadataMode,
             ]
         };
         const factory = new TypeDocumentFactory();
@@ -123,13 +123,14 @@ export class TypeDocumentFactory {
     async importDataType(thunk) {
         thunk = await resolveThunk(thunk);
         let name = '';
-        let schema;
+        // let schema: OpraSchema.DataType | undefined;
         let ctor;
         if (typeof thunk === 'string') {
             name = thunk;
-            schema = this.typeQueue.get(name);
+            thunk = this.typeQueue.get(name);
         }
-        else if (typeof thunk === 'function') {
+        let initArguments;
+        if (typeof thunk === 'function') {
             const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
             if (!metadata) {
                 // Check if is an internal type class like String, Number etc
@@ -139,14 +140,14 @@ export 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 (OpraSchema.isDataType(thunk)) {
                 name = thunk.name;
                 ctor = thunk.ctor || ctor;
-                schema = thunk;
+                initArguments = cloneObject(thunk);
             }
             else {
                 // It should be an enum object
@@ -154,13 +155,11 @@ export class TypeDocumentFactory {
                 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 : undefined);
+        ctor = ctor ?? (initArguments && (isConstructor(initArguments.ctor)) ? initArguments.ctor : undefined);
         if (name) {
             if (this.circularRefs.has(name.toLowerCase()))
                 throw new TypeError('Circular reference detected');
@@ -179,14 +178,13 @@ export class TypeDocumentFactory {
             this.circularRefs.set(ctor, 1);
         }
         try {
-            if (!OpraSchema.isDataType(schema))
+            if (!initArguments)
                 throw new TypeError(`No DataType schema determined`);
             // Create an empty DataType instance and add in to document.
             // This will help us for circular dependent data types
-            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')
                 ComplexType.apply(instance, [this.document, initArguments]);
@@ -199,7 +197,7 @@ export class TypeDocumentFactory {
             else if (initArguments.kind === 'UnionType')
                 UnionType.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 {
@@ -256,7 +254,7 @@ export class TypeDocumentFactory {
                                 fieldInit.type = await this.importDataType(enumObject);
                             }
                             else {
-                                const enumMeta = EnumType(enumObject);
+                                const enumMeta = EnumType(enumObject, { name: '' });
                                 fieldInit.type = await this.importDataType({ ...enumMeta, kind: 'EnumType', base: undefined });
                             }
                         }

package/esm/document/index.js

@@ -11,14 +11,18 @@ 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 './resource/resource.js';
-export * from './resource/crud-resource.js';
+export * from './resource/action.js';
 export * from './resource/collection.js';
 export * from './resource/container.js';
-export * from './resource/singleton.js';
-export * from './resource/storage.js';
+export * from './resource/crud-resource.js';
 export * from './resource/endpoint.js';
+export * from './resource/operation.js';
 export * from './resource/parameter.js';
+export * from './resource/resource.js';
+export * from './resource/singleton.js';
+export * from './resource/storage.js';
+export * from './resource/enums/metadata-mode.enum.js';
+export * from './resource/types/operation-result.type.js';
 export * from './interfaces/collection.interface.js';
 export * from './interfaces/singleton.interface.js';
 export * from './interfaces/storage.interface.js';

package/esm/document/resource/action-decorator.js

@@ -19,5 +19,11 @@ export function createActionDecorator(options, bannedProperties, list) {
         });
         return decorator;
     };
+    decorator.Returns = (t) => {
+        list.push((actionMetadata) => {
+            actionMetadata.returnType = t;
+        });
+        return decorator;
+    };
     return decorator;
 }

package/esm/document/resource/action.js

@@ -0,0 +1,28 @@
+import * as vg from 'valgen';
+import { DataType } from '../data-type/data-type.js';
+import { Endpoint } from './endpoint.js';
+/**
+ *
+ * @class Action
+ */
+export class Action extends Endpoint {
+    constructor(resource, name, init) {
+        super(resource, name, init);
+        this.resource = resource;
+        this.name = name;
+        this.kind = 'action';
+        this.encodeReturning = vg.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;
+    }
+}

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

@@ -24,48 +24,46 @@ export class CollectionClass extends CrudResource {
         // ------------------
         let endpoint = this.operations.get('create');
         if (endpoint) {
-            endpoint.returnType = this.type;
-            endpoint.decode = this.type.generateCodec('decode', {
+            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
+            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.encode = 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) {
+            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true});
             endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
         }
         // ------------------
         endpoint = this.operations.get('get');
         if (endpoint) {
+            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
+            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.encode = 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.encode = vg.isArray(this.type.generateCodec('encode', {
-                partial: true,
-                pick: endpoint.outputPickFields,
-                omit: endpoint.outputOmitFields,
-            }));
+            // endpoint.defineParameter('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
             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 });
@@ -75,32 +73,40 @@ export class CollectionClass 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 = vg.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('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
+            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.encode = 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('metadata', {enum: MetadataMode, isBuiltin: true, default: 'minimal'});
+            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) {
@@ -142,7 +148,7 @@ export class CollectionClass extends CrudResource {
                 value = value[primaryKey];
             const el = dataType.getField(primaryKey);
             let result;
-            if (el.type instanceof SimpleType)
+            if (value != null && el.type instanceof SimpleType)
                 result = el.type.decode(value);
             if (result == null)
                 throw new TypeError(`You must provide value of primary field(s) (${primaryKey})`);

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

@@ -1,5 +1,5 @@
 import { ResponsiveMap } from '../../helpers/index.js';
-import { Endpoint } from './endpoint.js';
+import { Operation } from './operation.js';
 import { Resource } from './resource.js';
 export class CrudResource extends Resource {
     constructor(parent, init) {
@@ -7,7 +7,7 @@ export class CrudResource extends Resource {
         this.operations = new ResponsiveMap();
         if (init.operations) {
             for (const [name, meta] of Object.entries(init.operations)) {
-                this.operations.set(name, new Endpoint(this, name, meta));
+                this.operations.set(name, new Operation(this, name, meta));
             }
         }
     }

package/esm/document/resource/endpoint.js

@@ -1,4 +1,3 @@
-import * as vg from 'valgen';
 import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { DataType } from '../data-type/data-type.js';
 import { Parameter } from './parameter.js';
@@ -10,8 +9,6 @@ export class Endpoint {
     constructor(resource, name, init) {
         this.resource = resource;
         this.name = name;
-        this.decode = vg.isAny();
-        this.encode = vg.isAny();
         Object.assign(this, init);
         this.parameters = new ResponsiveMap();
         if (init.parameters) {
@@ -20,6 +17,10 @@ export class Endpoint {
             }
         }
     }
+    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');

package/esm/document/resource/enums/metadata-mode.enum.js

@@ -0,0 +1,16 @@
+import { EnumType } from '../../data-type/enum-type.js';
+export var MetadataMode;
+(function (MetadataMode) {
+    MetadataMode["none"] = "none";
+    MetadataMode["minimal"] = "minimal";
+    MetadataMode["full"] = "full";
+})(MetadataMode || (MetadataMode = {}));
+EnumType(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',
+    }
+});