@opra/common 0.33.13 → 1.0.0-alpha.10

package/cjs/document/data-type/simple-type.js

@@ -1,25 +1,110 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleType = void 0;
-const tslib_1 = require("tslib");
 require("reflect-metadata");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const ts_gems_1 = require("ts-gems");
+const valgen_1 = require("valgen");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
-const simple_type_decorator_js_1 = require("./simple-type.decorator.js");
-const simple_type_class_js_1 = require("./simple-type-class.js");
+const simple_type_decorator_js_1 = require("../decorators/simple-type.decorator.js");
+const data_type_js_1 = require("./data-type.js");
 /**
- * @class SimpleType
+ * SimpleType constructor
  */
 exports.SimpleType = function (...args) {
     // Decorator
-    if (!this) {
-        const [options] = args;
-        return exports.SimpleType[constants_js_1.DECORATOR](options);
-    }
+    if (!this)
+        return exports.SimpleType[constants_js_1.DECORATOR](...args);
     // Constructor
-    const [document, init] = args;
-    (0, putil_merge_1.default)(this, new simple_type_class_js_1.SimpleTypeClass(document, init), { descriptor: true });
+    const [owner, initArgs, context] = args;
+    data_type_js_1.DataType.call(this, owner, initArgs, context);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = index_js_2.OpraSchema.SimpleType.Kind;
+    if (initArgs.base) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(initArgs.base instanceof exports.SimpleType)) {
+            throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+        }
+        _this.base = initArgs.base;
+    }
+    _this.properties = initArgs.properties;
+    _this.ownNameMappings = { ...initArgs.nameMappings };
+    _this.nameMappings = { ..._this.base?.nameMappings, ...initArgs.nameMappings };
+    _this.ownAttributes = (0, index_js_1.cloneObject)(initArgs.attributes || {});
+    _this.attributes = _this.base ? (0, index_js_1.cloneObject)(_this.base.attributes) : {};
+    if (_this.ownAttributes) {
+        for (const [k, el] of Object.entries(_this.ownAttributes)) {
+            if (_this.attributes[k]?.sealed)
+                throw new TypeError(`Sealed attribute "${k}" can not be overwritten`);
+            _this.attributes[k] = el;
+        }
+    }
+    _this._generateDecoder = initArgs.generateDecoder;
+    _this._generateEncoder = initArgs.generateEncoder;
 };
-exports.SimpleType.prototype = simple_type_class_js_1.SimpleTypeClass.prototype;
-Object.assign(exports.SimpleType, simple_type_decorator_js_1.SimpleTypeDecorator);
-exports.SimpleType[constants_js_1.DECORATOR] = simple_type_decorator_js_1.SimpleTypeDecorator;
+/**
+ *
+ * @class SimpleType
+ */
+class SimpleTypeClass extends data_type_js_1.DataType {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof data_type_js_1.DataType))
+            baseType = this.node.getDataType(baseType);
+        if (!(baseType instanceof exports.SimpleType))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
+    }
+    generateCodec(codec, options, properties) {
+        const prop = {
+            ...this.properties,
+            ...properties,
+        };
+        if (codec === 'decode') {
+            let t = this;
+            while (t) {
+                if (t._generateDecoder)
+                    return t._generateDecoder(prop, options?.documentElement || this.owner);
+                t = this.base;
+            }
+            return valgen_1.isAny;
+        }
+        let t = this;
+        while (t) {
+            if (t._generateEncoder)
+                return t._generateEncoder(prop, options?.documentElement || this.owner);
+            t = this.base;
+        }
+        return valgen_1.isAny;
+    }
+    toJSON() {
+        const attributes = (0, index_js_1.omitUndefined)(this.ownAttributes);
+        let properties;
+        if (this.properties && typeof this.properties.toJSON === 'function') {
+            properties = this.properties.toJSON(this.properties, this.owner);
+        }
+        else
+            properties = this.properties || {};
+        properties = Object.keys(this.attributes).reduce((o, k) => {
+            if (properties[k] !== undefined)
+                o[k] = properties[k];
+            return o;
+        }, {});
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        const out = (0, index_js_1.omitUndefined)({
+            ...data_type_js_1.DataType.prototype.toJSON.apply(this),
+            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
+            attributes: attributes && Object.keys(attributes).length ? attributes : undefined,
+            properties: Object.keys(properties).length ? properties : undefined,
+        });
+        if (Object.keys(this.ownNameMappings).length)
+            out.nameMappings = { ...this.ownNameMappings };
+        return out;
+    }
+}
+exports.SimpleType.prototype = SimpleTypeClass.prototype;
+Object.assign(exports.SimpleType, simple_type_decorator_js_1.SimpleTypeDecoratorFactory);
+exports.SimpleType[constants_js_1.DECORATOR] = simple_type_decorator_js_1.SimpleTypeDecoratorFactory;
+exports.SimpleType.Attribute = simple_type_decorator_js_1.AttributeDecoratorFactory;

package/cjs/document/data-type/utils/create-mapped-class.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMappedClass = void 0;
+const index_js_1 = require("../../../helpers/index.js");
+const index_js_2 = require("../../../schema/index.js");
+const constants_js_1 = require("../../constants.js");
+const mapped_type_js_1 = require("../mapped-type.js");
+const get_is_inherited_predicate_fn_js_1 = require("./get-is-inherited-predicate-fn.js");
+function createMappedClass(source, config, options) {
+    const isInheritedPredicate = (0, get_is_inherited_predicate_fn_js_1.getIsInheritedPredicateFn)(config.pick, config.omit);
+    const sourceName = typeof source === 'string' ? source.charAt(0).toUpperCase() + source.substring(1) : source.name;
+    const className = options?.name || sourceName + 'Mapped';
+    const MappedClass = {
+        [className]: class {
+            constructor() {
+                if (typeof source === 'function')
+                    (0, index_js_1.inheritPropertyInitializers)(this, source, isInheritedPredicate);
+            }
+        },
+    }[className];
+    if (typeof source === 'function')
+        (0, index_js_1.mergePrototype)(MappedClass.prototype, source.prototype);
+    if (typeof source === 'function') {
+        const m = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, source);
+        if (!m)
+            throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
+        if (!(m.kind === index_js_2.OpraSchema.ComplexType.Kind ||
+            m.kind === index_js_2.OpraSchema.MappedType.Kind ||
+            m.kind === index_js_2.OpraSchema.MixinType.Kind)) {
+            throw new TypeError(`Class "${source}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}`);
+        }
+    }
+    const metadata = {
+        ...options,
+        kind: 'MappedType',
+        base: source,
+    };
+    if (config.pick)
+        metadata.pick = config.pick;
+    if (config.omit)
+        metadata.omit = config.omit;
+    if (config.partial)
+        metadata.partial = config.partial;
+    if (config.required)
+        metadata.required = config.required;
+    Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, MappedClass);
+    if (typeof source === 'function') {
+        mapped_type_js_1.MappedType._applyMixin(MappedClass, source, {
+            ...config,
+            isInheritedPredicate,
+        });
+    }
+    return MappedClass;
+}
+exports.createMappedClass = createMappedClass;

package/cjs/document/data-type/utils/get-is-inherited-predicate-fn.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsInheritedPredicateFn = void 0;
+function getIsInheritedPredicateFn(pick, omit) {
+    const pickKeys = pick?.map(x => String(x).toLowerCase());
+    const omitKeys = omit?.map(x => String(x).toLowerCase());
+    return (propertyName) => {
+        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
+            return false;
+        if (pickKeys)
+            return pickKeys.includes(propertyName.toLowerCase());
+        return true;
+    };
+}
+exports.getIsInheritedPredicateFn = getIsInheritedPredicateFn;

package/cjs/document/{data-type/field-decorator.js → decorators/api-field-decorator.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldDecorator = void 0;
+exports.ApiFieldDecorator = void 0;
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
-function FieldDecorator(options) {
+function ApiFieldDecorator(options) {
     return function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
             throw new TypeError(`Symbol properties can't be used as a field`);
@@ -12,15 +12,15 @@ function FieldDecorator(options) {
         metadata.kind = index_js_2.OpraSchema.ComplexType.Kind;
         metadata.fields = metadata.fields || {};
         const designType = Reflect.getMetadata('design:type', target, propertyKey);
-        const elemMeta = metadata.fields[propertyKey] = {
+        const elemMeta = (metadata.fields[propertyKey] = {
             ...options,
-            designType
-        };
+        });
         if (designType === Array) {
             elemMeta.isArray = true;
-            delete elemMeta.designType;
         }
+        else
+            elemMeta.type = elemMeta.type || designType;
         Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, (0, index_js_1.omitUndefined)(metadata), target.constructor);
     };
 }
-exports.FieldDecorator = FieldDecorator;
+exports.ApiFieldDecorator = ApiFieldDecorator;

package/cjs/document/{data-type → decorators}/complex-type.decorator.js

@@ -7,7 +7,17 @@ const index_js_1 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
 function ComplexTypeDecorator(options) {
     return function (target) {
-        const name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
+        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;
+            }
+        }
         let metadata = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, target);
         if (!metadata) {
             metadata = {};

package/cjs/document/decorators/http-controller.decorator.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpControllerDecoratorFactory = void 0;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const CLASS_NAME_PATTERN = /^(.*)(Collection|Singleton|Resource|Controller)$/;
+function HttpControllerDecoratorFactory(options) {
+    const decoratorChain = [];
+    /**
+     *
+     */
+    const decorator = function (target) {
+        let name = options?.name;
+        if (!name)
+            name = CLASS_NAME_PATTERN.exec(target.name)?.[1] || target.name;
+        const metadata = {};
+        const baseMetadata = Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        if (baseMetadata)
+            (0, putil_merge_1.default)(metadata, baseMetadata, { deep: true });
+        const oldMetadata = Reflect.getOwnMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, target);
+        if (oldMetadata)
+            (0, putil_merge_1.default)(metadata, oldMetadata, { deep: true });
+        (0, putil_merge_1.default)(metadata, {
+            kind: index_js_1.OpraSchema.HttpController.Kind,
+            name,
+            path: name,
+            ...(0, lodash_omit_1.default)(options, ['kind', 'name', 'instance', 'endpoints', 'key']),
+        }, { deep: true });
+        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, metadata, target);
+        for (const fn of decoratorChain)
+            fn(metadata);
+        Reflect.defineMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, metadata, target);
+    };
+    /**
+     *
+     */
+    decorator.Cookie = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'cookie',
+                    type: arg1,
+                }
+                : { ...arg1, name, location: 'cookie' };
+            meta.parameters = 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' };
+            meta.parameters = 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' };
+            meta.parameters = 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' };
+            meta.parameters = meta.parameters || [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.KeyParam = (name, arg1) => {
+        decoratorChain.push((meta) => {
+            if (!meta.path?.includes(':' + name))
+                meta.path = (meta.path || '') + '@:' + name;
+            const paramMeta = typeof arg1 === 'string' || typeof arg1 === 'function'
+                ? {
+                    name,
+                    location: 'path',
+                    type: arg1,
+                    keyParam: true,
+                }
+                : {
+                    ...arg1,
+                    name,
+                    location: 'path',
+                    keyParam: true,
+                };
+            meta.parameters = meta.parameters || [];
+            meta.parameters.push(paramMeta);
+        });
+        return decorator;
+    };
+    /**
+     *
+     */
+    decorator.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    return decorator;
+}
+exports.HttpControllerDecoratorFactory = HttpControllerDecoratorFactory;