@opra/common 0.25.5 → 0.26.0

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActionDecorator = void 0;
+const constants_js_1 = require("../constants.js");
+function createActionDecorator(options, bannedProperties, list) {
+    const decorator = ((target, propertyKey) => {
+        if (typeof propertyKey === 'string' && bannedProperties.includes(propertyKey))
+            throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
+        const resourceMetadata = (Reflect.getOwnMetadata(constants_js_1.RESOURCE_METADATA, target.constructor) || {});
+        resourceMetadata.actions = resourceMetadata.actions || {};
+        const actionMeta = { ...options };
+        resourceMetadata.actions[propertyKey] = actionMeta;
+        for (const fn of list)
+            fn(actionMeta);
+        Reflect.defineMetadata(constants_js_1.RESOURCE_METADATA, resourceMetadata, target.constructor);
+    });
+    decorator.Parameter = (name, arg0) => {
+        const parameterOptions = typeof arg0 === 'string' || typeof arg0 === 'function' ? { type: arg0 } : { ...arg0 };
+        list.push((operationMeta) => {
+            operationMeta.parameters = operationMeta.parameters || {};
+            operationMeta.parameters[name] = { ...parameterOptions };
+        });
+        return decorator;
+    };
+    return decorator;
+}
+exports.createActionDecorator = createActionDecorator;

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

@@ -5,20 +5,14 @@ const tslib_1 = require("tslib");
 const vg = tslib_1.__importStar(require("valgen"));
 const index_js_1 = require("../../exception/index.js");
 const index_js_2 = require("../../filter/index.js");
-const object_utils_js_1 = require("../../helpers/object-utils.js");
 const index_js_3 = require("../../i18n/index.js");
 const index_js_4 = require("../../schema/index.js");
 const simple_type_js_1 = require("../data-type/simple-type.js");
-const generate_codec_js_1 = require("../utils/generate-codec.js");
-const resource_js_1 = require("./resource.js");
-class CollectionClass extends resource_js_1.Resource {
-    constructor(document, init) {
-        super(document, init);
-        this._decoders = {};
-        this._encoders = {};
+const crud_resource_js_1 = require("./crud-resource.js");
+class CollectionClass extends crud_resource_js_1.CrudResource {
+    constructor(parent, init) {
+        super(parent, init);
         this.kind = index_js_4.OpraSchema.Collection.Kind;
-        this.controller = init.controller;
-        this.operations = { ...init.operations };
         const dataType = this.type = init.type;
         // Validate key fields
         this.primaryKey = init.primaryKey
@@ -31,15 +25,98 @@ class CollectionClass extends resource_js_1.Resource {
             if (!(field?.type instanceof simple_type_js_1.SimpleType))
                 throw new TypeError(`Only Simple type allowed for primary keys but "${f}" is a ${field.type.kind}`);
         });
+        // ------------------
+        let endpoint = this.operations.get('create');
+        if (endpoint) {
+            endpoint.returnType = this.type;
+            endpoint.decode = this.type.generateCodec('decode', {
+                partial: true,
+                pick: endpoint.inputPickFields,
+                omit: endpoint.inputOmitFields,
+            });
+            endpoint.encode = 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 });
+        }
+        // ------------------
+        endpoint = this.operations.get('deleteMany');
+        if (endpoint) {
+            endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
+        }
+        // ------------------
+        endpoint = this.operations.get('get');
+        if (endpoint) {
+            endpoint.returnType = this.type;
+            endpoint.encode = 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 });
+        }
+        // ------------------
+        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('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.defineParameter('sort', { type: 'string', isArray: true, isBuiltin: true });
+            endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
+            endpoint.defineParameter('limit', { type: 'integer', isBuiltin: true });
+            endpoint.defineParameter('skip', { type: 'integer', isBuiltin: true });
+            endpoint.defineParameter('distinct', { type: 'boolean', isBuiltin: true });
+            endpoint.defineParameter('count', { type: 'boolean', isBuiltin: true });
+        }
+        // ------------------
+        endpoint = this.operations.get('update');
+        if (endpoint) {
+            endpoint.returnType = this.type;
+            endpoint.decode = this.type.generateCodec('decode', {
+                pick: endpoint.inputPickFields,
+                omit: endpoint.inputOmitFields,
+            });
+            endpoint.encode = 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 });
+        }
+        // ------------------
+        endpoint = this.operations.get('updateMany');
+        if (endpoint) {
+            endpoint.decode = this.type.generateCodec('decode', {
+                pick: endpoint.inputPickFields,
+                omit: endpoint.inputOmitFields,
+            });
+            endpoint.defineParameter('filter', { type: 'string', isBuiltin: true });
+        }
     }
-    exportSchema() {
+    getOperation(name) {
+        return super.getOperation(name);
+    }
+    exportSchema(options) {
         return {
-            ...super.exportSchema(),
-            ...(0, object_utils_js_1.omitUndefined)({
-                type: this.type.name || 'object',
-                operations: this.operations,
+            ...super.exportSchema(options),
+            type: this.type.name || 'object',
+            ...{
                 primaryKey: this.primaryKey
-            })
+            }
         };
     }
     parseKeyValue(value) {
@@ -83,7 +160,7 @@ class CollectionClass extends resource_js_1.Resource {
         const normalized = this.type.normalizeFieldPath(fields);
         if (!normalized)
             return;
-        const findManyOp = this.operations.findMany;
+        const findManyOp = this.getOperation('findMany');
         const sortFields = findManyOp && findManyOp.sortFields;
         (Array.isArray(normalized) ? normalized : [normalized]).forEach(field => {
             if (!sortFields?.find(x => x === field))
@@ -102,7 +179,7 @@ class CollectionClass extends resource_js_1.Resource {
             if (!(ast.left instanceof index_js_2.OpraFilter.QualifiedIdentifier && ast.left.field))
                 throw new TypeError(`Invalid filter query. Left side should be a data field.`);
             // Check if filtering accepted for given field
-            const findManyOp = this.operations.findMany;
+            const findManyOp = this.getOperation('findMany');
             const fieldLower = ast.left.value.toLowerCase();
             const filterDef = (findManyOp && findManyOp.filters || [])
                 .find(f => f.field.toLowerCase() === fieldLower);
@@ -144,31 +221,5 @@ class CollectionClass extends resource_js_1.Resource {
         }
         return ast;
     }
-    getDecoder(endpoint) {
-        let decoder = this._decoders[endpoint];
-        if (decoder)
-            return decoder;
-        const options = {
-            partial: endpoint !== 'create'
-        };
-        if (endpoint !== 'create')
-            options.omit = [...this.primaryKey];
-        decoder = (0, generate_codec_js_1.generateCodec)(this.type, 'decode', options);
-        this._decoders[endpoint] = decoder;
-        return decoder;
-    }
-    getEncoder(endpoint) {
-        let encoder = this._encoders[endpoint];
-        if (encoder)
-            return encoder;
-        const options = {
-            partial: true
-        };
-        encoder = (0, generate_codec_js_1.generateCodec)(this.type, 'encode', options);
-        if (endpoint === 'findMany')
-            return vg.isArray(encoder);
-        this._encoders[endpoint] = encoder;
-        return encoder;
-    }
 }
 exports.CollectionClass = CollectionClass;

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

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionDecorator = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const action_decorator_js_1 = require("./action-decorator.js");
+const operation_decorator_js_1 = require("./operation-decorator.js");
+const resource_decorator_js_1 = require("./resource-decorator.js");
+const operationProperties = ['create', 'delete', 'deleteMany', 'get', 'findMany', 'update', 'updateMany'];
+function CollectionDecorator(type, options) {
+    return (0, resource_decorator_js_1.ResourceDecorator)(index_js_2.OpraSchema.Collection.Kind, { ...options, type });
+}
+exports.CollectionDecorator = CollectionDecorator;
+Object.assign(CollectionDecorator, resource_decorator_js_1.ResourceDecorator);
+/*
+ * Action PropertyDecorator
+ */
+(function (CollectionDecorator) {
+    /**
+     * Action PropertyDecorator
+     */
+    function Action(options) {
+        const list = [];
+        return (0, action_decorator_js_1.createActionDecorator)(options, operationProperties, list);
+    }
+    CollectionDecorator.Action = Action;
+    function Create(options) {
+        const list = [];
+        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('create', options, list);
+        decorator.InputMaxContentSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.inputMaxContentSize = sizeInBytes);
+            return decorator;
+        };
+        decorator.InputPickFields = (...fields) => {
+            list.push(operationMeta => operationMeta.inputPickFields = fields);
+            return decorator;
+        };
+        decorator.InputOmitFields = (...fields) => {
+            list.push(operationMeta => operationMeta.inputOmitFields = fields);
+            return decorator;
+        };
+        decorator.OutputPickFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputPickFields = fields);
+            return decorator;
+        };
+        decorator.OutputOmitFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputOmitFields = fields);
+            return decorator;
+        };
+        return decorator;
+    }
+    CollectionDecorator.Create = Create;
+    function Delete(options) {
+        const list = [];
+        return (0, operation_decorator_js_1.createOperationDecorator)('delete', options, list);
+    }
+    CollectionDecorator.Delete = Delete;
+    function DeleteMany(options) {
+        const list = [];
+        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('deleteMany', options, list);
+        decorator.Filter = (field, operators, notes) => {
+            if (typeof operators === 'string')
+                operators = operators.split(/\s*[,| ]\s*/);
+            list.push(operationMeta => {
+                operationMeta.filters = operationMeta.filters || [];
+                operationMeta.filters.push((0, index_js_1.omitUndefined)({ field, operators, notes }));
+            });
+            return decorator;
+        };
+        return decorator;
+    }
+    CollectionDecorator.DeleteMany = DeleteMany;
+    function Get(options) {
+        const list = [];
+        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('get', options, list);
+        decorator.OutputPickFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputPickFields = fields);
+            return decorator;
+        };
+        decorator.OutputOmitFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputOmitFields = fields);
+            return decorator;
+        };
+        return decorator;
+    }
+    CollectionDecorator.Get = Get;
+    function FindMany(options) {
+        const list = [];
+        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('findMany', options, list);
+        decorator.SortFields = (...fields) => {
+            list.push(operationMeta => operationMeta.sortFields = fields);
+            return decorator;
+        };
+        decorator.DefaultSort = (...fields) => {
+            list.push(operationMeta => operationMeta.defaultSort = fields);
+            return decorator;
+        };
+        decorator.Filter = (field, operators, notes) => {
+            if (typeof operators === 'string')
+                operators = operators.split(/\s*[,| ]\s*/);
+            list.push(operationMeta => {
+                operationMeta.filters = operationMeta.filters || [];
+                operationMeta.filters.push((0, index_js_1.omitUndefined)({ field, operators, notes }));
+            });
+            return decorator;
+        };
+        decorator.OutputPickFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputPickFields = fields);
+            return decorator;
+        };
+        decorator.OutputOmitFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputOmitFields = fields);
+            return decorator;
+        };
+        return decorator;
+    }
+    CollectionDecorator.FindMany = FindMany;
+})(CollectionDecorator || (exports.CollectionDecorator = CollectionDecorator = {}));
+/*
+ * Update PropertyDecorator
+ */
+(function (CollectionDecorator) {
+    function Update(options) {
+        const list = [];
+        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('update', options, list);
+        decorator.InputMaxContentSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.inputMaxContentSize = sizeInBytes);
+            return decorator;
+        };
+        decorator.InputPickFields = (...fields) => {
+            list.push(operationMeta => operationMeta.inputPickFields = fields);
+            return decorator;
+        };
+        decorator.InputOmitFields = (...fields) => {
+            list.push(operationMeta => operationMeta.inputOmitFields = fields);
+            return decorator;
+        };
+        decorator.OutputPickFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputPickFields = fields);
+            return decorator;
+        };
+        decorator.OutputOmitFields = (...fields) => {
+            list.push(operationMeta => operationMeta.outputOmitFields = fields);
+            return decorator;
+        };
+        return decorator;
+    }
+    CollectionDecorator.Update = Update;
+})(CollectionDecorator || (exports.CollectionDecorator = CollectionDecorator = {}));
+/*
+ * UpdateMany PropertyDecorator
+ */
+(function (CollectionDecorator) {
+    function UpdateMany(arg0) {
+        const list = [];
+        const options = typeof arg0 === 'string' ? { description: arg0 } : { ...arg0 };
+        const decorator = (0, operation_decorator_js_1.createOperationDecorator)('updateMany', options, list);
+        decorator.InputMaxContentSize = (sizeInBytes) => {
+            list.push(operationMeta => operationMeta.inputMaxContentSize = sizeInBytes);
+            return decorator;
+        };
+        decorator.InputPickFields = (...fields) => {
+            list.push(operationMeta => operationMeta.inputPickFields = fields);
+            return decorator;
+        };
+        decorator.InputOmitFields = (...fields) => {
+            list.push(operationMeta => operationMeta.inputOmitFields = fields);
+            return decorator;
+        };
+        decorator.Filter = (field, operators, notes) => {
+            if (typeof operators === 'string')
+                operators = operators.split(/\s*[,| ]\s*/);
+            list.push(operationMeta => {
+                operationMeta.filters = operationMeta.filters || [];
+                operationMeta.filters.push((0, index_js_1.omitUndefined)({ field, operators, notes }));
+            });
+            return decorator;
+        };
+        return decorator;
+    }
+    CollectionDecorator.UpdateMany = UpdateMany;
+})(CollectionDecorator || (exports.CollectionDecorator = CollectionDecorator = {}));

package/cjs/document/resource/collection.js

@@ -4,21 +4,21 @@ exports.Collection = void 0;
 const tslib_1 = require("tslib");
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const constants_js_1 = require("../constants.js");
-const collection_decorator_js_1 = require("../decorators/collection-decorator.js");
 const collection_class_js_1 = require("./collection-class.js");
+const collection_decorator_js_1 = require("./collection-decorator.js");
 /**
  * @class Collection
  * @decorator Collection
  */
 exports.Collection = function (...args) {
-    // Decorator
+    // ClassDecorator
     if (!this) {
         const [type, options] = args;
         return exports.Collection[constants_js_1.DECORATOR].call(undefined, type, options);
     }
     // Constructor
-    const [document, init] = args;
-    (0, putil_merge_1.default)(this, new collection_class_js_1.CollectionClass(document, init), { descriptor: true });
+    const [parent, init] = args;
+    (0, putil_merge_1.default)(this, new collection_class_js_1.CollectionClass(parent, init), { descriptor: true });
 };
 exports.Collection.prototype = collection_class_js_1.CollectionClass.prototype;
 Object.assign(exports.Collection, collection_decorator_js_1.CollectionDecorator);

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerClass = void 0;
+const index_js_1 = require("../../exception/index.js");
+const index_js_2 = require("../../helpers/index.js");
+const index_js_3 = require("../../schema/index.js");
+const resource_js_1 = require("./resource.js");
+class ContainerClass extends resource_js_1.Resource {
+    constructor(owner, init) {
+        super(owner instanceof ContainerClass ? owner.document : owner, init);
+        this.kind = index_js_3.OpraSchema.Container.Kind;
+        this.resources = new index_js_2.ResponsiveMap();
+        this.parent = owner instanceof ContainerClass ? owner : undefined;
+    }
+    exportSchema(options) {
+        const schema = super.exportSchema(options);
+        if (this.resources.size) {
+            const resources = schema.resources = {};
+            for (const [name, r] of this.resources.entries()) {
+                resources[name] = r.exportSchema(options);
+            }
+        }
+        return schema;
+    }
+    getResource(path, silent) {
+        let resource;
+        if (path.includes('/')) {
+            const arr = path.split('/');
+            let i;
+            const l = arr.length;
+            let container = this;
+            for (i = 0; i < l; i++) {
+                resource = container.resources.get(arr[i]);
+                if (resource instanceof ContainerClass)
+                    container = resource;
+                else
+                    break;
+            }
+            // If no resource found or walking through path not completed
+            if (!resource || i < l - 1)
+                resource = undefined;
+        }
+        else
+            resource = this.resources.get(path);
+        if (resource || silent)
+            return resource;
+        throw new index_js_1.ResourceNotFoundError(path);
+    }
+    getContainer(path, silent) {
+        const t = this.getResource(path);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.Container.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Container`);
+    }
+    getCollection(path, silent) {
+        const t = this.getResource(path);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.Collection.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
+    }
+    getSingleton(path, silent) {
+        const t = this.getResource(path);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.Singleton.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
+    }
+    getStorage(path, silent) {
+        const t = this.getResource(path);
+        if (!t && silent)
+            return;
+        if (t && t.kind === index_js_3.OpraSchema.Storage.Kind)
+            return t;
+        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Storage`);
+    }
+}
+exports.ContainerClass = ContainerClass;

package/cjs/document/resource/container-decorator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerDecorator = void 0;
+const index_js_1 = require("../../schema/index.js");
+const action_decorator_js_1 = require("./action-decorator.js");
+const resource_decorator_js_1 = require("./resource-decorator.js");
+function ContainerDecorator(options) {
+    return (0, resource_decorator_js_1.ResourceDecorator)(index_js_1.OpraSchema.Container.Kind, options);
+}
+exports.ContainerDecorator = ContainerDecorator;
+Object.assign(ContainerDecorator, resource_decorator_js_1.ResourceDecorator);
+/*
+ * Action PropertyDecorator
+ */
+(function (ContainerDecorator) {
+    /**
+     * Action PropertyDecorator
+     */
+    function Action(options) {
+        const list = [];
+        return (0, action_decorator_js_1.createActionDecorator)(options, [], list);
+    }
+    ContainerDecorator.Action = Action;
+})(ContainerDecorator || (exports.ContainerDecorator = ContainerDecorator = {}));

package/cjs/document/resource/container.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Container = void 0;
+const tslib_1 = require("tslib");
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const constants_js_1 = require("../constants.js");
+const container_class_js_1 = require("./container-class.js");
+const container_decorator_js_1 = require("./container-decorator.js");
+/**
+ * @class Container
+ * @decorator Container
+ */
+exports.Container = function (...args) {
+    // ClassDecorator
+    if (!this) {
+        const [options] = args;
+        return exports.Container[constants_js_1.DECORATOR].call(undefined, options);
+    }
+    // Constructor
+    const [parent, init] = args;
+    (0, putil_merge_1.default)(this, new container_class_js_1.ContainerClass(parent, init), { descriptor: true });
+    if (init.resources) {
+        const container = this;
+        init.resources.forEach(r => container.resources.set(r.name, r));
+    }
+};
+exports.Container.prototype = container_class_js_1.ContainerClass.prototype;
+Object.assign(exports.Container, container_decorator_js_1.ContainerDecorator);
+exports.Container[constants_js_1.DECORATOR] = container_decorator_js_1.ContainerDecorator;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudResource = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const endpoint_js_1 = require("./endpoint.js");
+const resource_js_1 = require("./resource.js");
+class CrudResource extends resource_js_1.Resource {
+    constructor(parent, init) {
+        super(parent, init);
+        this.operations = new index_js_1.ResponsiveMap();
+        if (init.operations) {
+            for (const [name, meta] of Object.entries(init.operations)) {
+                this.operations.set(name, new endpoint_js_1.Endpoint(this, name, meta));
+            }
+        }
+    }
+    getOperation(name) {
+        return this.operations.get(name);
+    }
+    exportSchema(options) {
+        const schema = super.exportSchema(options);
+        if (this.operations.size) {
+            schema.operations = {};
+            for (const operation of this.operations.values()) {
+                schema.operations[operation.name] = operation.exportSchema(options);
+            }
+        }
+        return schema;
+    }
+}
+exports.CrudResource = CrudResource;

package/cjs/document/resource/endpoint.js

@@ -1,49 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EndpointParameter = exports.Endpoint = void 0;
+exports.Endpoint = void 0;
+const tslib_1 = require("tslib");
+const vg = tslib_1.__importStar(require("valgen"));
 const index_js_1 = require("../../helpers/index.js");
+const data_type_js_1 = require("../data-type/data-type.js");
+const parameter_js_1 = require("./parameter.js");
 /**
  *
  * @class Endpoint
  */
 class Endpoint {
-    constructor(init) {
+    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 index_js_1.ResponsiveMap();
         if (init.parameters) {
             for (const [n, p] of Object.entries(init.parameters)) {
-                this.parameters.set(n, new EndpointParameter(p));
+                this.defineParameter(n, p);
             }
         }
     }
-    exportSchema() {
+    defineParameter(name, init) {
+        const type = init.type && init.type instanceof data_type_js_1.DataType
+            ? init.type : this.resource.document.getDataType(init.type || 'any');
+        const prm = new parameter_js_1.Parameter(name, {
+            ...init,
+            type
+        });
+        this.parameters.set(prm.name, prm);
+        return prm;
+    }
+    exportSchema(options) {
         const schema = (0, index_js_1.omitUndefined)({
             description: this.description
         });
         if (this.parameters.size) {
             schema.parameters = {};
             for (const [name, param] of this.parameters.entries()) {
-                schema.parameters[name] = param.exportSchema();
+                if (!param.isBuiltin)
+                    schema.parameters[name] = param.exportSchema(options);
             }
         }
         return schema;
     }
 }
 exports.Endpoint = Endpoint;
-/**
- *
- * @class EndpointParameter
- */
-class EndpointParameter {
-    constructor(init) {
-        Object.assign(this, init);
-    }
-    exportSchema() {
-        return (0, index_js_1.omitUndefined)({
-            type: typeof this.type === 'string' ? this.type : this.type.exportSchema(),
-            description: this.description,
-            isArray: this.isArray
-        });
-    }
-}
-exports.EndpointParameter = EndpointParameter;