@opra/common 0.33.13 → 1.0.0-alpha.2

package/cjs/document/decorators/simple-type.decorator.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributeDecoratorFactory = exports.SimpleTypeDecoratorFactory = void 0;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+function SimpleTypeDecoratorFactory(options) {
+    const decoratorChain = [];
+    /**
+     *
+     */
+    const decorator = function (target) {
+        let name;
+        if (!options?.embedded) {
+            if (options?.name) {
+                if (!constants_js_1.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(constants_js_1.EXTRACT_TYPENAME_PATTERN)?.[1] || target.name;
+                name = name.toLowerCase();
+            }
+        }
+        const metadata = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, target) || {};
+        metadata.kind = index_js_1.OpraSchema.SimpleType.Kind;
+        metadata.name = name;
+        if (options)
+            Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name']));
+        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, target);
+    };
+    decorator.Example = (value, description) => {
+        decoratorChain.push((meta) => {
+            meta.examples = meta.examples || [];
+            meta.examples.push({
+                description,
+                value,
+            });
+        });
+        return decorator;
+    };
+    return decorator;
+}
+exports.SimpleTypeDecoratorFactory = SimpleTypeDecoratorFactory;
+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(constants_js_1.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 = index_js_1.OpraSchema.SimpleType.Kind;
+        metadata.attributes = metadata.attributes || {};
+        metadata.attributes[propertyKey] = {
+            format: options?.format || format,
+            description: options?.description,
+            deprecated: options?.deprecated,
+        };
+        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, target.constructor);
+    };
+}
+exports.AttributeDecoratorFactory = AttributeDecoratorFactory;

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

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiDocumentFactory = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const api_document_js_1 = require("../api-document.js");
+const document_init_context_js_1 = require("../common/document-init-context.js");
+const opra_document_error_js_1 = require("../common/opra-document-error.js");
+const constants_js_1 = require("../constants.js");
+const index_js_3 = require("../data-type/extended-types/index.js");
+const index_js_4 = require("../data-type/primitive-types/index.js");
+const data_type_factory_js_1 = require("./data-type.factory.js");
+const http_api_factory_js_1 = require("./http-api.factory.js");
+const OPRA_SPEC_URL = 'https://oprajs.com/spec/v' + index_js_2.OpraSchema.SpecVersion;
+/**
+ * @class ApiDocumentFactory
+ */
+class ApiDocumentFactory {
+    /**
+     * Creates ApiDocument instance from given schema object
+     */
+    static async createDocument(schemaOrUrl, options) {
+        const factory = new ApiDocumentFactory();
+        const context = options instanceof document_init_context_js_1.DocumentInitContext ? options : new document_init_context_js_1.DocumentInitContext(options);
+        try {
+            const document = new api_document_js_1.ApiDocument();
+            await factory.initDocument(document, context, schemaOrUrl);
+            if (context.error.details.length)
+                throw context.error;
+            return document;
+        }
+        catch (e) {
+            try {
+                if (!(e instanceof opra_document_error_js_1.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[constants_js_1.BUILTIN]) {
+            const builtinDocument = await this.createBuiltinDocument(context);
+            document.references.set('opra', builtinDocument);
+        }
+        init.spec = init.spec || index_js_2.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 (0, index_js_1.resolveThunk)(r);
+                    await context.enterAsync(`[${ns}]`, async () => {
+                        if (!constants_js_1.CLASS_NAME_PATTERN.test(ns))
+                            throw new TypeError(`Invalid namespace (${ns})`);
+                        if (r instanceof api_document_js_1.ApiDocument) {
+                            document.references.set(ns, r);
+                            return;
+                        }
+                        const refDoc = new api_document_js_1.ApiDocument();
+                        await this.initDocument(refDoc, context, r);
+                        document.references.set(ns, refDoc);
+                    });
+                }
+            });
+        }
+        if (init.types) {
+            await context.enterAsync('.types', async () => {
+                await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, document, init.types);
+            });
+        }
+        if (init.api) {
+            await context.enterAsync(`.api`, async () => {
+                if (init.api.protocol === 'http') {
+                    const api = await http_api_factory_js_1.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: index_js_2.OpraSchema.SpecVersion,
+            url: OPRA_SPEC_URL,
+            info: {
+                version: index_js_2.OpraSchema.SpecVersion,
+                title: 'Opra built-in types',
+                license: {
+                    url: 'https://github.com/oprajs/opra/blob/main/LICENSE',
+                    name: 'MIT',
+                },
+            },
+            types: [
+                // Primitive types
+                index_js_4.AnyType,
+                index_js_4.BigintType,
+                index_js_4.BooleanType,
+                index_js_4.IntegerType,
+                index_js_4.NullType,
+                index_js_4.NumberType,
+                index_js_4.ObjectType,
+                index_js_4.StringType,
+                // Extended types
+                index_js_3.Base64Type,
+                index_js_3.DateType,
+                index_js_3.DateStringType,
+                index_js_3.DateTimeType,
+                index_js_3.DateTimeStringType,
+                index_js_3.EmailType,
+                index_js_3.FieldPathType,
+                index_js_3.FilterType,
+                index_js_3.ObjectIdType,
+                index_js_3.OperationResult,
+                index_js_3.TimeType,
+                index_js_3.UrlType,
+                index_js_3.UuidType,
+            ],
+        };
+        const document = new api_document_js_1.ApiDocument();
+        document[constants_js_1.BUILTIN] = true;
+        const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
+        const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
+        const _ctorTypeMap = document.types[constants_js_1.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;
+    }
+}
+exports.ApiDocumentFactory = ApiDocumentFactory;