@opra/common 0.33.13 → 1.0.0-alpha.1

package/esm/document/http/decorators/http-operation-entity.decorator.js

@@ -0,0 +1,459 @@
+import { FilterRules } from '../../../filter/filter-rules.js';
+import { omitUndefined } from '../../../helpers/index.js';
+import { HttpStatusCode, MimeTypes } from '../../../http/index.js';
+import { DATATYPE_METADATA } from '../../constants.js';
+import { FieldPathType, FilterType } from '../../data-type/extended-types/index.js';
+import { IntegerType } from '../../data-type/primitive-types/index.js';
+import { HttpOperation } from '../http-operation.js';
+import { HttpOperationDecoratorFactory } from './http-operation.decorator.js';
+/** Implementation **/
+HttpOperation.Entity = {};
+/**
+ * HttpOperation.Entity.Create
+ */
+HttpOperation.Entity.Create = function (arg0, arg1) {
+    let args;
+    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
+        args = arg0;
+    }
+    else
+        args = { ...arg1, type: arg0 };
+    /** Initialize the decorator and the chain */
+    const decoratorChain = [];
+    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
+        description: args.description,
+        method: 'POST',
+        composition: 'Entity.Create',
+        requestBody: {
+            immediateFetch: true,
+            ...args.requestBody,
+            required: true,
+        },
+    }));
+    decorator
+        .QueryParam('projection', {
+        description: 'Determines fields projection',
+        type: new FieldPathType({
+            dataType: args.type,
+            allowSigns: 'each',
+        }),
+        isArray: true,
+        arraySeparator: ',',
+    })
+        .RequestContent(args.requestBody?.type || args.type)
+        .Response(HttpStatusCode.CREATED, {
+        description: 'Operation is successful. Returns OperationResult with "payload" field that contains the created resource.',
+        contentType: MimeTypes.opra_response_json,
+        type: args.type,
+        partial: 'deep',
+    })
+        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
+        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
+        contentType: MimeTypes.opra_response_json,
+    });
+    if (typeof args.type === 'function')
+        decorator.UseType(args.type);
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    return decorator;
+};
+/**
+ * HttpOperation.Entity.Delete
+ */
+HttpOperation.Entity.Delete = function (arg0, arg1) {
+    let args;
+    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
+        args = arg0;
+    }
+    else
+        args = { ...arg1, type: arg0 };
+    /** Initialize the decorator and the chain */
+    const decoratorChain = [];
+    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
+        description: args.description,
+        method: 'DELETE',
+        composition: 'Entity.Delete',
+    }));
+    decorator
+        .Response(HttpStatusCode.OK, {
+        description: 'Operation is successful. Returns OperationResult with "affected" field.',
+        contentType: MimeTypes.opra_response_json,
+    })
+        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
+        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
+        contentType: MimeTypes.opra_response_json,
+    });
+    if (typeof args.type === 'function')
+        decorator.UseType(args.type);
+    /**
+     *
+     */
+    decorator.KeyParam = (name, prmOptions) => {
+        decorator.PathParam(name, prmOptions);
+        decoratorChain.push((meta) => {
+            meta.path = (meta.path || '') + '@:' + name;
+            meta.compositionOptions = meta.compositionOptions || {};
+            meta.compositionOptions.keyParameter = name;
+        });
+        return decorator;
+    };
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    return decorator;
+};
+/**
+ * HttpOperation.Entity.DeleteMany
+ */
+HttpOperation.Entity.DeleteMany = function (arg0, arg1) {
+    let args;
+    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
+        args = arg0;
+    }
+    else
+        args = { ...arg1, type: arg0 };
+    /** Initialize the decorator and the chain */
+    const decoratorChain = [];
+    const filterRules = new FilterRules();
+    const filterType = new FilterType({ dataType: args.type });
+    filterType.rules = {};
+    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
+        description: args.description,
+        method: 'DELETE',
+        composition: 'Entity.DeleteMany',
+    }));
+    decorator
+        .Response(HttpStatusCode.OK, {
+        description: 'Operation is successful. Returns OperationResult with "affected" field.',
+        contentType: MimeTypes.opra_response_json,
+    })
+        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
+        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
+        contentType: MimeTypes.opra_response_json,
+    })
+        .QueryParam('filter', {
+        type: filterType,
+        description: 'Determines filter fields',
+    });
+    if (typeof args.type === 'function')
+        decorator.UseType(args.type);
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.Filter = (field, operators, description) => {
+        decoratorChain.push(() => {
+            filterRules.set(field, { operators, description });
+            filterType.rules = filterRules.toJSON();
+        });
+        return decorator;
+    };
+    return decorator;
+};
+/**
+ * HttpOperation.Entity.FindMany
+ */
+HttpOperation.Entity.FindMany = function (arg0, arg1) {
+    let args;
+    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
+        args = arg0;
+    }
+    else
+        args = { ...arg1, type: arg0 };
+    /** Initialize the decorator and the chain */
+    const decoratorChain = [];
+    const filterRules = new FilterRules();
+    const filterType = new FilterType({ dataType: args.type });
+    filterType.rules = {};
+    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
+        description: args.description,
+        method: 'GET',
+        composition: 'Entity.FindMany',
+    }));
+    decorator
+        .Response(HttpStatusCode.OK, {
+        description: 'Operation is successful. Returns OperationResult with "payload" field that contains list of resources.',
+        contentType: MimeTypes.opra_response_json,
+        type: args.type,
+        partial: 'deep',
+        isArray: true,
+    })
+        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
+        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
+        contentType: MimeTypes.opra_response_json,
+    })
+        .QueryParam('limit', {
+        description: 'Determines number of returning instances',
+        type: new IntegerType({ minValue: 1 }),
+    })
+        .QueryParam('skip', {
+        description: 'Determines number of returning instances',
+        type: new IntegerType({ minValue: 1 }),
+    })
+        .QueryParam('count', {
+        description: 'Counts all matching instances if enabled',
+        type: Boolean,
+    })
+        .QueryParam('projection', {
+        description: 'Determines fields projection',
+        type: new FieldPathType({
+            dataType: args.type,
+            allowSigns: 'each',
+        }),
+        isArray: true,
+        arraySeparator: ',',
+    })
+        .QueryParam('filter', {
+        type: filterType,
+        description: 'Determines filter fields',
+    })
+        .QueryParam('sort', {
+        description: 'Determines sort fields',
+        type: new FieldPathType({
+            dataType: args.type,
+            allowSigns: 'first',
+        }),
+        isArray: true,
+        arraySeparator: ',',
+    });
+    if (typeof args.type === 'function')
+        decorator.UseType(args.type);
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.DefaultSort = (...fields) => {
+        decoratorChain.push((operationMeta) => {
+            const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+            compositionOptions.defaultSort = fields;
+        });
+        return decorator;
+    };
+    decorator.SortFields = (...fields) => {
+        decoratorChain.push((operationMeta) => {
+            const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+            compositionOptions.sortFields = fields;
+        });
+        return decorator;
+    };
+    decorator.Filter = (field, operators, description) => {
+        decoratorChain.push(() => {
+            filterRules.set(field, { operators, description });
+            filterType.rules = filterRules.toJSON();
+        });
+        return decorator;
+    };
+    return decorator;
+};
+/**
+ * HttpOperation.Entity.Get
+ */
+HttpOperation.Entity.Get = function (arg0, arg1) {
+    let args;
+    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
+        args = arg0;
+    }
+    else
+        args = { ...arg1, type: arg0 };
+    /** Initialize the decorator and the chain */
+    const decoratorChain = [];
+    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
+        description: args.description,
+        method: 'GET',
+        composition: 'Entity.Get',
+    }));
+    decorator
+        .QueryParam('projection', {
+        description: 'Determines fields projection',
+        type: new FieldPathType({
+            dataType: args.type,
+            allowSigns: 'each',
+        }),
+        isArray: true,
+        arraySeparator: ',',
+    })
+        .Response(HttpStatusCode.OK, {
+        description: 'Operation is successful. Returns OperationResult with "payload" field that contains the resource asked for.',
+        contentType: MimeTypes.opra_response_json,
+        type: args.type,
+        partial: 'deep',
+    })
+        .Response(HttpStatusCode.NO_CONTENT, {
+        description: 'Operation is successful but no resource found',
+    })
+        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
+        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
+        contentType: MimeTypes.opra_response_json,
+    });
+    if (typeof args.type === 'function')
+        decorator.UseType(args.type);
+    /**
+     *
+     */
+    decorator.KeyParam = (name, prmOptions) => {
+        decorator.PathParam(name, prmOptions);
+        decoratorChain.push((meta) => {
+            meta.path = (meta.path || '') + '@:' + name;
+            meta.compositionOptions = meta.compositionOptions || {};
+            meta.compositionOptions.keyParameter = name;
+        });
+        return decorator;
+    };
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    return decorator;
+};
+/**
+ * HttpOperation.Entity.UpdateMany
+ */
+HttpOperation.Entity.UpdateMany = function (arg0, arg1) {
+    let args;
+    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
+        args = arg0;
+    }
+    else
+        args = { ...arg1, type: arg0 };
+    /** Initialize the decorator and the chain */
+    const decoratorChain = [];
+    const filterType = new FilterType({ dataType: args.type });
+    filterType.rules = {};
+    const filterRules = new FilterRules();
+    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
+        description: args.description,
+        method: 'PATCH',
+        composition: 'Entity.UpdateMany',
+        requestBody: {
+            immediateFetch: true,
+            partial: 'deep',
+            ...args.requestBody,
+            required: true,
+        },
+    }));
+    decorator.RequestContent(args.requestBody?.type || args.type);
+    if (typeof args.type === 'function')
+        decorator.UseType(args.type);
+    decorator
+        .Response(HttpStatusCode.OK, {
+        description: 'Operation is successful. Returns OperationResult with "affected" field.',
+        contentType: MimeTypes.opra_response_json,
+    })
+        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
+        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
+        contentType: MimeTypes.opra_response_json,
+    })
+        .QueryParam('filter', {
+        type: filterType,
+        description: 'Determines filter fields',
+    });
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.Filter = (field, operators, description) => {
+        decoratorChain.push(() => {
+            filterRules.set(field, { operators, description });
+            filterType.rules = filterRules.toJSON();
+        });
+        return decorator;
+    };
+    return decorator;
+};
+/**
+ * HttpOperation.Entity.Update
+ */
+HttpOperation.Entity.Update = function (arg0, arg1) {
+    let args;
+    if (typeof arg0 === 'object' && !arg0[DATATYPE_METADATA]) {
+        args = arg0;
+    }
+    else
+        args = { ...arg1, type: arg0 };
+    /** Initialize the decorator and the chain */
+    const decoratorChain = [];
+    const filterRules = new FilterRules();
+    const filterType = new FilterType({ dataType: args.type });
+    filterType.rules = {};
+    const decorator = HttpOperationDecoratorFactory(decoratorChain, omitUndefined({
+        description: args.description,
+        method: 'PATCH',
+        composition: 'Entity.Update',
+        requestBody: {
+            partial: 'deep',
+            ...args.requestBody,
+            required: true,
+        },
+    }));
+    decorator
+        .QueryParam('projection', {
+        description: 'Determines fields projection',
+        type: new FieldPathType({
+            dataType: args.type,
+            allowSigns: 'each',
+        }),
+        isArray: true,
+        arraySeparator: ',',
+    })
+        .QueryParam('filter', {
+        type: filterType,
+        description: 'Determines filter fields',
+    })
+        .RequestContent(args.requestBody?.type || args.type)
+        .Response(HttpStatusCode.OK, {
+        description: 'Operation is successful. Returns OperationResult with "payload" field that contains updated resource.',
+        contentType: MimeTypes.opra_response_json,
+        type: args.type,
+        partial: 'deep',
+    })
+        .Response(HttpStatusCode.NO_CONTENT, {
+        description: 'Operation is successful but no resource found',
+    })
+        .Response(HttpStatusCode.UNPROCESSABLE_ENTITY, {
+        description: 'The request was well-formed but was unable to process operation due to one or many errors.',
+        contentType: MimeTypes.opra_response_json,
+    });
+    if (typeof args.type === 'function')
+        decorator.UseType(args.type);
+    /**
+     *
+     */
+    decorator.KeyParam = (name, prmOptions) => {
+        decorator.PathParam(name, prmOptions);
+        decoratorChain.push((meta) => {
+            meta.path = (meta.path || '') + '@:' + name;
+            meta.compositionOptions = meta.compositionOptions || {};
+            meta.compositionOptions.keyParameter = name;
+        });
+        return decorator;
+    };
+    decoratorChain.push((operationMeta) => {
+        const compositionOptions = (operationMeta.compositionOptions = operationMeta.compositionOptions || {});
+        compositionOptions.type = getDataTypeName(args.type);
+    });
+    decorator.Filter = (field, operators, description) => {
+        decoratorChain.push(() => {
+            filterRules.set(field, { operators, description });
+            filterType.rules = filterRules.toJSON();
+        });
+        return decorator;
+    };
+    return decorator;
+};
+/**
+ *
+ * @param typ
+ */
+function getDataTypeName(typ) {
+    if (typeof typ === 'string')
+        return typ;
+    const metadata = Reflect.getMetadata(DATATYPE_METADATA, typ);
+    if (!metadata)
+        throw new TypeError(`Type (${typ}) is not decorated with any datatype decorators`);
+    if (metadata?.name)
+        return metadata.name;
+    throw new TypeError(`You should provide named data type but embedded one found`);
+}

package/esm/document/http/decorators/http-operation.decorator.js

@@ -0,0 +1,178 @@
+import omit from 'lodash.omit';
+import { MimeTypes } from '../../../http/index.js';
+import { OpraSchema } from '../../../schema/index.js';
+import { HTTP_CONTROLLER_METADATA } from '../../constants.js';
+export function HttpOperationDecoratorFactory(decoratorChain, options) {
+    /**
+     *
+     */
+    const decorator = ((target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can not be decorated`);
+        const operationMetadata = {
+            kind: OpraSchema.HttpOperation.Kind,
+            ...omit(options, ['kind']),
+        };
+        const resourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) ||
+            {});
+        resourceMetadata.operations = resourceMetadata.operations || {};
+        resourceMetadata.operations[propertyKey] = operationMetadata;
+        for (const fn of decoratorChain)
+            fn(operationMetadata);
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, resourceMetadata, target.constructor);
+    });
+    /**
+     *
+     */
+    decorator.Cookie = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'cookie',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'cookie' };
+            if (meta.parameters)
+                meta.parameters = meta.parameters.filter(p => !(p.location === 'cookie' && String(p.name) === String(name)));
+            else
+                meta.parameters = [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.Header = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'header',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'header' };
+            if (meta.parameters)
+                meta.parameters = meta.parameters.filter(p => !(p.location === 'header' && String(p.name) === String(name)));
+            else
+                meta.parameters = [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.QueryParam = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'query',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'query' };
+            if (meta.parameters)
+                meta.parameters = meta.parameters.filter(p => !(p.location === 'query' && String(p.name) === String(name)));
+            else
+                meta.parameters = [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.PathParam = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'path',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'path' };
+            if (meta.parameters)
+                meta.parameters = meta.parameters.filter(p => !(p.location === 'path' && String(p.name) === String(name)));
+            else
+                meta.parameters = [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.Response = (statusCode, responseOptions) => {
+        const responseMeta = { ...responseOptions, statusCode };
+        if (responseMeta.type) {
+            responseMeta.contentType = responseMeta.contentType || MimeTypes.opra_response_json;
+            responseMeta.contentEncoding = responseMeta.contentEncoding || 'utf-8';
+        }
+        decoratorChain.push((meta) => {
+            meta.responses = meta.responses || [];
+            meta.responses.push(responseMeta);
+        });
+        return decorator;
+    };
+    decorator.RequestContent = function (arg0) {
+        const contentMeta = typeof arg0 === 'object' ? arg0 : { type: arg0 };
+        if (contentMeta.type) {
+            contentMeta.contentType = contentMeta.contentType || MimeTypes.json;
+            contentMeta.contentEncoding = contentMeta.contentEncoding || 'utf-8';
+        }
+        decoratorChain.push((operationMetadata) => {
+            operationMetadata.requestBody = operationMetadata.requestBody || { required: true, content: [] };
+            operationMetadata.requestBody.content = operationMetadata.requestBody.content || [];
+            operationMetadata.requestBody.content.push(contentMeta);
+        });
+        return decorator;
+    };
+    decorator.MultipartContent = function (contentOpts, subInit) {
+        const contentMetadata = {
+            ...contentOpts,
+            contentType: contentOpts?.contentType || 'multipart/form-data',
+        };
+        decoratorChain.push((operationMetadata) => {
+            operationMetadata.requestBody = operationMetadata.requestBody || { required: true, content: [] };
+            operationMetadata.requestBody.content = operationMetadata.requestBody.content || [];
+            operationMetadata.requestBody.content.push(contentMetadata);
+        });
+        if (subInit) {
+            const configScope = {
+                Field(fieldName, opts) {
+                    contentMetadata.multipartFields = contentMetadata.multipartFields || [];
+                    contentMetadata.multipartFields.push({
+                        fieldName,
+                        fieldType: 'field',
+                        ...opts,
+                    });
+                    return configScope;
+                },
+                File(fieldName, opts) {
+                    contentMetadata.multipartFields = contentMetadata.multipartFields || [];
+                    contentMetadata.multipartFields.push({
+                        fieldName,
+                        fieldType: 'file',
+                        ...opts,
+                    });
+                    return configScope;
+                },
+            };
+            subInit(configScope);
+        }
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    return decorator;
+}

package/esm/document/http/http-api.js

@@ -0,0 +1,36 @@
+import { ResponsiveMap } from '../../helpers/index.js';
+import { ApiBase } from '../common/api-base.js';
+import { HttpController } from './http-controller.js';
+/**
+ * @class HttpApi
+ */
+export class HttpApi extends ApiBase {
+    constructor(owner) {
+        super(owner);
+        this.owner = owner;
+        // noinspection JSUnusedGlobalSymbols
+        this._controllerReverseMap = new WeakMap();
+        this.protocol = 'http';
+        this.controllers = new ResponsiveMap();
+    }
+    findController(arg0) {
+        return HttpController.prototype.findController.call(this, arg0);
+    }
+    findOperation(arg0, operationName) {
+        const controller = this.findController(arg0);
+        return controller?.operations.get(operationName);
+    }
+    toJSON() {
+        const schema = super.toJSON();
+        const out = {
+            ...schema,
+            protocol: this.protocol,
+            url: this.url,
+            controllers: {},
+        };
+        for (const [name, v] of this.controllers.entries()) {
+            out.controllers[name] = v.toJSON();
+        }
+        return out;
+    }
+}