@opra/common 0.33.13 → 1.0.0-alpha.2

package/esm/document/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/decorators/simple-type.decorator.js

@@ -0,0 +1,61 @@
+import omit from 'lodash.omit';
+import { OpraSchema } from '../../schema/index.js';
+import { CLASS_NAME_PATTERN, DATATYPE_METADATA, EXTRACT_TYPENAME_PATTERN } from '../constants.js';
+export function SimpleTypeDecoratorFactory(options) {
+    const decoratorChain = [];
+    /**
+     *
+     */
+    const decorator = function (target) {
+        let name;
+        if (!options?.embedded) {
+            if (options?.name) {
+                if (!CLASS_NAME_PATTERN.test(options.name))
+                    throw new TypeError(`"${options.name}" is not a valid type name`);
+                name = options.name;
+            }
+            else {
+                name = target.name.match(EXTRACT_TYPENAME_PATTERN)?.[1] || target.name;
+                name = name.toLowerCase();
+            }
+        }
+        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target) || {};
+        metadata.kind = OpraSchema.SimpleType.Kind;
+        metadata.name = name;
+        if (options)
+            Object.assign(metadata, omit(options, ['kind', 'name']));
+        Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
+    };
+    decorator.Example = (value, description) => {
+        decoratorChain.push((meta) => {
+            meta.examples = meta.examples || [];
+            meta.examples.push({
+                description,
+                value,
+            });
+        });
+        return decorator;
+    };
+    return decorator;
+}
+export function AttributeDecoratorFactory(options) {
+    return (target, propertyKey) => {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can't be decorated with Attribute`);
+        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
+        const designType = Reflect.getMetadata('design:type', target, propertyKey);
+        let format = 'string';
+        if (designType === Boolean)
+            format = 'boolean';
+        else if (designType === Number)
+            format = 'number';
+        metadata.kind = OpraSchema.SimpleType.Kind;
+        metadata.attributes = metadata.attributes || {};
+        metadata.attributes[propertyKey] = {
+            format: options?.format || format,
+            description: options?.description,
+            deprecated: options?.deprecated,
+        };
+        Reflect.defineMetadata(DATATYPE_METADATA, metadata, target.constructor);
+    };
+}

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

@@ -0,0 +1,174 @@
+import { resolveThunk } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { ApiDocument } from '../api-document.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { OpraDocumentError } from '../common/opra-document-error.js';
+import { BUILTIN, CLASS_NAME_PATTERN, kCtorMap } from '../constants.js';
+import { Base64Type, DateStringType, DateTimeStringType, DateTimeType, DateType, EmailType, FieldPathType, FilterType, ObjectIdType, OperationResult, TimeType, UrlType, UuidType, } from '../data-type/extended-types/index.js';
+import { AnyType, BigintType, BooleanType, IntegerType, NullType, NumberType, ObjectType, StringType, } from '../data-type/primitive-types/index.js';
+import { DataTypeFactory } from './data-type.factory.js';
+import { HttpApiFactory } from './http-api.factory.js';
+const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + OpraSchema.SpecVersion;
+/**
+ * @class ApiDocumentFactory
+ */
+export class ApiDocumentFactory {
+    /**
+     * Creates ApiDocument instance from given schema object
+     */
+    static async createDocument(schemaOrUrl, options) {
+        const factory = new ApiDocumentFactory();
+        const context = options instanceof DocumentInitContext ? options : new DocumentInitContext(options);
+        try {
+            const document = new ApiDocument();
+            await factory.initDocument(document, context, schemaOrUrl);
+            if (context.error.details.length)
+                throw context.error;
+            return document;
+        }
+        catch (e) {
+            try {
+                if (!(e instanceof OpraDocumentError)) {
+                    context.addError(e);
+                }
+            }
+            catch {
+                //
+            }
+            if (!context.error.message) {
+                const l = context.error.details.length;
+                context.error.message = `(${l}) error${l > 1 ? 's' : ''} found in document schema.`;
+                if (context.showErrorDetails) {
+                    context.error.message += context.error.details
+                        .map(d => {
+                        return `\n\n  - ${d.message}` + (d.path ? `\n    @${d.path}` : '');
+                    })
+                        .join('');
+                }
+            }
+            throw context.error;
+        }
+    }
+    /**
+     * Downloads schema from the given URL and creates the document instance   * @param url
+     */
+    async initDocument(document, context, schemaOrUrl) {
+        let init;
+        if (typeof schemaOrUrl === 'string') {
+            const resp = await fetch(schemaOrUrl, { method: 'GET' });
+            init = await resp.json();
+            if (!init)
+                return context.addError(`Invalid response returned from url: ${schemaOrUrl}`);
+            init.url = schemaOrUrl;
+        }
+        else
+            init = schemaOrUrl;
+        // Add builtin data types if this document is the root
+        if (!document[BUILTIN]) {
+            const builtinDocument = await this.createBuiltinDocument(context);
+            document.references.set('opra', builtinDocument);
+        }
+        init.spec = init.spec || OpraSchema.SpecVersion;
+        document.url = init.url;
+        if (init.info)
+            document.info = { ...init.info };
+        /** Add references  */
+        if (init.references) {
+            await context.enterAsync('.references', async () => {
+                let ns;
+                let r;
+                for ([ns, r] of Object.entries(init.references)) {
+                    r = await resolveThunk(r);
+                    await context.enterAsync(`[${ns}]`, async () => {
+                        if (!CLASS_NAME_PATTERN.test(ns))
+                            throw new TypeError(`Invalid namespace (${ns})`);
+                        if (r instanceof ApiDocument) {
+                            document.references.set(ns, r);
+                            return;
+                        }
+                        const refDoc = new ApiDocument();
+                        await this.initDocument(refDoc, context, r);
+                        document.references.set(ns, refDoc);
+                    });
+                }
+            });
+        }
+        if (init.types) {
+            await context.enterAsync('.types', async () => {
+                await DataTypeFactory.addDataTypes(context, document, init.types);
+            });
+        }
+        if (init.api) {
+            await context.enterAsync(`.api`, async () => {
+                if (init.api.protocol === 'http') {
+                    const api = await HttpApiFactory.createApi(context, document, init.api);
+                    if (api)
+                        document.api = api;
+                }
+                else
+                    context.addError(`Unknown service protocol (${init.api.protocol})`);
+            });
+        }
+    }
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    async createBuiltinDocument(context) {
+        const init = {
+            spec: OpraSchema.SpecVersion,
+            url: OPRA_SPEC_URL,
+            info: {
+                version: OpraSchema.SpecVersion,
+                title: 'Opra built-in types',
+                license: {
+                    url: 'https://github.com/oprajs/opra/blob/main/LICENSE',
+                    name: 'MIT',
+                },
+            },
+            types: [
+                // Primitive types
+                AnyType,
+                BigintType,
+                BooleanType,
+                IntegerType,
+                NullType,
+                NumberType,
+                ObjectType,
+                StringType,
+                // Extended types
+                Base64Type,
+                DateType,
+                DateStringType,
+                DateTimeType,
+                DateTimeStringType,
+                EmailType,
+                FieldPathType,
+                FilterType,
+                ObjectIdType,
+                OperationResult,
+                TimeType,
+                UrlType,
+                UuidType,
+            ],
+        };
+        const document = new ApiDocument();
+        document[BUILTIN] = true;
+        const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+        const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
+        const _ctorTypeMap = document.types[kCtorMap];
+        _ctorTypeMap.set(Object, 'object');
+        _ctorTypeMap.set(String, 'string');
+        _ctorTypeMap.set(Number, 'number');
+        _ctorTypeMap.set(Boolean, 'boolean');
+        _ctorTypeMap.set(Object, 'any');
+        _ctorTypeMap.set(Date, 'datetime');
+        _ctorTypeMap.set(BigIntConstructor, 'bigint');
+        _ctorTypeMap.set(ArrayBuffer, 'base64');
+        _ctorTypeMap.set(SharedArrayBuffer, 'base64');
+        _ctorTypeMap.set(BufferConstructor, 'base64');
+        await this.initDocument(document, context, init);
+        return document;
+    }
+}