@opra/common 0.33.13 → 1.0.0-alpha.1

package/esm/document/data-type/primitive-types/string.type.js

@@ -0,0 +1,55 @@
+import { __decorate } from "tslib";
+import { toString, vg } from 'valgen';
+import { DATATYPE_METADATA, DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let StringType = class StringType {
+    constructor(properties) {
+        if (properties)
+            Object.assign(this, properties);
+    }
+    [DECODER](properties) {
+        const x = [];
+        if (properties.pattern) {
+            let formatName = properties.patternName;
+            if (!formatName) {
+                const meta = Reflect.getMetadata(DATATYPE_METADATA, Object.getPrototypeOf(this).constructor);
+                formatName = meta.name;
+            }
+            x.push(vg.matches(properties.pattern, { formatName }));
+        }
+        if (properties.minLength)
+            x.push(vg.lengthMin(properties.minLength));
+        if (properties.maxLength)
+            x.push(vg.lengthMax(properties.maxLength));
+        return x.length > 0 ? vg.pipe([toString, ...x], { returnIndex: 0 }) : toString;
+    }
+    [ENCODER](properties) {
+        return this[DECODER](properties);
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Regex pattern to be used for validation',
+    })
+], StringType.prototype, "pattern", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Name of the pattern',
+    })
+], StringType.prototype, "patternName", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Minimum number of characters',
+    })
+], StringType.prototype, "minLength", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Minimum number of characters',
+    })
+], StringType.prototype, "maxLength", void 0);
+StringType = __decorate([
+    SimpleType({
+        description: 'A sequence of characters',
+    })
+], StringType);
+export { StringType };

package/esm/document/data-type/required-type.js

@@ -0,0 +1,9 @@
+import { createMappedClass } from './utils/create-mapped-class.js';
+/**
+ *
+ */
+export function RequiredType(base, ...args) {
+    const keys = Array.isArray(args[0]) ? args[0] : true;
+    const options = Array.isArray(args[0]) ? args[1] : args[0];
+    return createMappedClass(base, { required: keys }, options);
+}

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

@@ -1,21 +1,101 @@
 import 'reflect-metadata';
-import merge from 'putil-merge';
+import { asMutable } from 'ts-gems';
+import { isAny } from 'valgen';
+import { cloneObject, omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
 import { DECORATOR } from '../constants.js';
-import { SimpleTypeDecorator } from './simple-type.decorator.js';
-import { SimpleTypeClass } from './simple-type-class.js';
+import { AttributeDecoratorFactory, SimpleTypeDecoratorFactory } from '../decorators/simple-type.decorator.js';
+import { DataType } from './data-type.js';
 /**
- * @class SimpleType
+ * SimpleType constructor
  */
 export const SimpleType = function (...args) {
     // Decorator
-    if (!this) {
-        const [options] = args;
-        return SimpleType[DECORATOR](options);
-    }
+    if (!this)
+        return SimpleType[DECORATOR](...args);
     // Constructor
-    const [document, init] = args;
-    merge(this, new SimpleTypeClass(document, init), { descriptor: true });
+    const [owner, initArgs, context] = args;
+    DataType.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.SimpleType.Kind;
+    if (initArgs.base) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(initArgs.base instanceof 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.ownAttributes = cloneObject(initArgs.attributes || {});
+    _this.attributes = _this.base ? 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;
 };
+/**
+ *
+ * @class SimpleType
+ */
+class SimpleTypeClass extends DataType {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof 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 isAny;
+        }
+        else {
+            let t = this;
+            while (t) {
+                if (t._generateEncoder)
+                    return t._generateEncoder(prop, options?.documentElement || this.owner);
+                t = this.base;
+            }
+            return isAny;
+        }
+    }
+    toJSON() {
+        const attributes = 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;
+        return omitUndefined({
+            ...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,
+        });
+    }
+}
 SimpleType.prototype = SimpleTypeClass.prototype;
-Object.assign(SimpleType, SimpleTypeDecorator);
-SimpleType[DECORATOR] = SimpleTypeDecorator;
+Object.assign(SimpleType, SimpleTypeDecoratorFactory);
+SimpleType[DECORATOR] = SimpleTypeDecoratorFactory;
+SimpleType.Attribute = AttributeDecoratorFactory;

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

@@ -0,0 +1,50 @@
+import { inheritPropertyInitializers, mergePrototype } from '../../../helpers/index.js';
+import { OpraSchema } from '../../../schema/index.js';
+import { DATATYPE_METADATA } from '../../constants.js';
+import { MappedType } from '../mapped-type.js';
+import { getIsInheritedPredicateFn } from './get-is-inherited-predicate-fn.js';
+export function createMappedClass(source, config, options) {
+    const isInheritedPredicate = 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')
+                    inheritPropertyInitializers(this, source, isInheritedPredicate);
+            }
+        },
+    }[className];
+    if (typeof source === 'function')
+        mergePrototype(MappedClass.prototype, source.prototype);
+    if (typeof source === 'function') {
+        const m = Reflect.getOwnMetadata(DATATYPE_METADATA, source);
+        if (!m)
+            throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
+        if (!(m.kind === OpraSchema.ComplexType.Kind ||
+            m.kind === OpraSchema.MappedType.Kind ||
+            m.kind === OpraSchema.MixinType.Kind))
+            throw new TypeError(`Class "${source}" is not a ${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(DATATYPE_METADATA, metadata, MappedClass);
+    if (typeof source === 'function') {
+        MappedType._applyMixin(MappedClass, source, {
+            ...config,
+            isInheritedPredicate,
+        });
+    }
+    return MappedClass;
+}

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

@@ -0,0 +1,11 @@
+export 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;
+    };
+}

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

@@ -1,7 +1,7 @@
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DATATYPE_METADATA } from '../constants.js';
-export function FieldDecorator(options) {
+export function ApiFieldDecorator(options) {
     return function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
             throw new TypeError(`Symbol properties can't be used as a field`);
@@ -9,14 +9,14 @@ export function FieldDecorator(options) {
         metadata.kind = 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(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
     };
 }

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

@@ -1,9 +1,19 @@
 import omit from 'lodash.omit';
 import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA, TYPENAME_PATTERN } from '../constants.js';
+import { CLASS_NAME_PATTERN, DATATYPE_METADATA, EXTRACT_TYPENAME_PATTERN } from '../constants.js';
 export function ComplexTypeDecorator(options) {
     return function (target) {
-        const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
+        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;
+            }
+        }
         let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
         if (!metadata) {
             metadata = {};

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

@@ -0,0 +1,112 @@
+import omit from 'lodash.omit';
+import merge from 'putil-merge';
+import { OpraSchema } from '../../schema/index.js';
+import { HTTP_CONTROLLER_METADATA } from '../constants.js';
+const CLASS_NAME_PATTERN = /^(.*)(Collection|Singleton|Resource|Controller)$/;
+export 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(HTTP_CONTROLLER_METADATA, Object.getPrototypeOf(target));
+        if (baseMetadata)
+            merge(metadata, baseMetadata, { deep: true });
+        const oldMetadata = Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target);
+        if (oldMetadata)
+            merge(metadata, oldMetadata, { deep: true });
+        merge(metadata, {
+            kind: OpraSchema.HttpController.Kind,
+            name,
+            path: name,
+            ...omit(options, ['kind', 'name', 'instance', 'endpoints', 'key']),
+        }, { deep: true });
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, metadata, target);
+        for (const fn of decoratorChain)
+            fn(metadata);
+        Reflect.defineMetadata(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.UseType = (...type) => {
+        decoratorChain.push((meta) => {
+            meta.types = meta.types || [];
+            meta.types.push(...type);
+        });
+        return decorator;
+    };
+    return decorator;
+}