@my-devkit/core 1.0.40 → 1.0.44

package/src/event.ts

@@ -1,32 +0,0 @@
-import { Document } from './document';
-import { guid } from './guid';
-import { autoserializeAs } from './serialize';
-
-export abstract class Event implements Document {
-    public static counter = 0;
-    @autoserializeAs(String) public id: string = null;
-    @autoserializeAs(String) public _type: string = null;
-    @autoserializeAs(String) public _correlationId: string = null;
-    @autoserializeAs(String) public _aggregateType: string = null;
-    @autoserializeAs(String) public _aggregateId: string = null;
-    @autoserializeAs(String) public _publishedBy: string = null;
-    @autoserializeAs(String) private _publishedAt: string = null;
-
-    constructor() {
-        this.id = guid();
-        this._type = this.constructor.name;
-    }
-
-    public get _path(): string {
-        return `/events/${this.id}`;
-    }
-
-    public get publishedAt(): Date {
-        return new Date(this._publishedAt.substr(0, 23) + 'Z');
-    }
-
-    public set publishedAt(date: Date) {
-        Event.counter++;
-        this._publishedAt = date.toISOString().replace('Z', '.' + (('0'.repeat(9) + Event.counter).slice(-9))) + 'Z';
-    }
-}

package/src/guid/index.ts

@@ -1,3 +0,0 @@
-import { v4 } from 'uuid';
-
-export const guid = v4;

package/src/index.ts

@@ -1,20 +0,0 @@
-import * as validators from './validators';
-
-export * from './decorators';
-export * from './document';
-export * from './command';
-export * from './event';
-export * from './date-helper';
-export * from './enum-helper';
-export * from './errors';
-export * from './guid';
-export * from './logger';
-export * from './model';
-export * from './maintenance-model';
-export * from './release-model';
-export * from './serialize';
-export * from './retry';
-export * from './sleep';
-export * from './vendors';
-export const Validators = validators;
-export { ValidationError } from './validators/validation-error';

package/src/logger.ts

@@ -1,71 +0,0 @@
-import { DateHelper } from './date-helper';
-
-export class Logger {
-    private static implementations: Logger.Implementation[] = [];
-
-    public static registerLogger(logger: Logger.Implementation): void {
-        this.implementations.push(logger);
-    }
-
-    public static debug(message: string, meta?: Logger.LogMetaData): void {
-        for (const implementation of this.implementations) {
-            implementation.debug(message, meta);
-        }
-    }
-
-    public static info(message: string, meta?: Logger.LogMetaData): void {
-        for (const implementation of this.implementations) {
-            implementation.info(message, meta);
-        }
-    }
-
-    public static infoWithElapesedTime(message: string, startDate: Date, meta?: Logger.LogMetaData): void {
-        this.info(message, {
-            ...meta,
-            elpasedTime: { ms: DateHelper.getElapsedTime(startDate), readable: DateHelper.getReadableElapsedTime(startDate) }
-        });
-    }
-
-    public static warn(message: string, meta?: Logger.LogMetaData): void {
-        for (const implementation of this.implementations) {
-            implementation.warn(message, meta);
-        }
-    }
-
-    public static error(message: string, meta?: Logger.LogMetaData): void {
-        for (const implementation of this.implementations) {
-            implementation.error(message, meta);
-        }
-    }
-}
-
-export namespace Logger {
-    export interface LogMetaData {
-        [key: string]: any;
-    }
-
-    export interface Implementation {
-        debug(message: string, data: LogMetaData): void;
-        info(message: string, data: LogMetaData): void;
-        warn(message: string, data: LogMetaData): void;
-        error(message: string, data: LogMetaData): void;
-    }
-
-    export class ConsoleImplementation implements Implementation {
-        public debug(message: string): void {
-            console.debug(`debug: ${message}`);
-        }
-
-        public info(message: string): void {
-            console.info(`info: ${message}`);
-        }
-
-        public warn(message: string): void {
-            console.warn(`warn: ${message}`);
-        }
-
-        public error(message: string): void {
-            console.error(`error: ${message}`);
-        }
-    }
-}

package/src/maintenance-model.ts

@@ -1,12 +0,0 @@
-import { Model } from './model';
-import { autoserializeAs, inheritSerialization, serializable } from './serialize';
-
-@serializable
-@inheritSerialization(Model)
-export class MaintenanceModel extends Model {
-    @autoserializeAs(Boolean) public status: boolean = null;
-
-    constructor() {
-        super('MaintenanceModel', () => `/continuous-integration/maintenance`);
-    }
-}

package/src/model.ts

@@ -1,15 +0,0 @@
-import { autoserializeAs } from 'cerialize';
-
-import { Document } from './document';
-
-export abstract class Model implements Document {
-    @autoserializeAs(String) public _type: string = null;
-
-    constructor(modelType: string, private pathCallback: () => string) {
-        this._type = modelType;
-    }
-
-    public get _path(): string {
-        return this.pathCallback();
-    }
-}

package/src/release-model.ts

@@ -1,12 +0,0 @@
-import { Model } from './model';
-import { autoserializeAs, inheritSerialization, serializable } from './serialize';
-
-@serializable
-@inheritSerialization(Model)
-export class ReleaseModel extends Model {
-    @autoserializeAs(String) public version: string = null;
-
-    constructor() {
-        super('ReleaseModel', () => `/continuous-integration/release`);
-    }
-}

package/src/retry.ts

@@ -1,41 +0,0 @@
-import { Logger } from './logger';
-import { sleep } from './sleep';
-
-/**
- * Retry operation
- * @param operation
- * @param options
- */
-export async function retry<T>(operation: () => Promise<T>, options?: retry.Options): Promise<T> {
-    options = { maxAttempts: 6, exponential: false, condition: () => true, ...options };
-
-    let continueTrying = true;
-    let retryCount = 0;
-    do {
-        try {
-            return await operation();
-        } catch (e) {
-            continueTrying = retryCount < options.maxAttempts && options.condition(e);
-            if (!continueTrying) {
-                throw e;
-            }
-            if (options.exponential) {
-                await sleep(Math.pow(2, retryCount) * 1000 + Math.round(Math.random() * 1000));
-            }
-
-            retryCount++;
-            Logger.info(`Retry: retrying... ${retryCount}/${options.maxAttempts}`);
-        }
-    } while (continueTrying)
-}
-
-export namespace retry {
-    export interface Options {
-        /**
-         * Condition callback
-         */
-        condition?: (error: any) => boolean;
-        maxAttempts?: number;
-        exponential?: boolean;
-    }
-}

package/src/serialize/deserialize.ts

@@ -1,11 +0,0 @@
-import { Deserialize } from 'cerialize';
-
-import { serializable } from './serializable';
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function deserialize<T>(object: any, type?: new () => T): T {
-    if (type) {
-        return Deserialize(object, type);
-    }
-    return Deserialize(object, serializable.getConstructor(object));
-}

package/src/serialize/index.ts

@@ -1,6 +0,0 @@
-export * from './deserialize';
-export * from './serialize';
-export * from './serializable';
-export * from './type-helper';
-
-export { autoserializeAs, inheritSerialization } from 'cerialize';

package/src/serialize/serializable.ts

@@ -1,30 +0,0 @@
-export function serializable<T>(type: new (...args: any[]) => T): void {
-    serializable.register(type as any);
-}
-
-export namespace serializable {
-
-    const types = new Map<string, new () => any>();
-
-    export function register<T extends SerializableObject>(type: new (...args: any[]) => T): void {
-        types.set(new type()._type, type);
-    }
-
-    export function getConstructor<T extends SerializableObject>(object: T): new () => T {
-        if (!object) {
-            return null;
-        }
-        if (!object._type) {
-            throw new Error(`SerializeHelper: property _type is missing in ${JSON.stringify(object)}`);
-        }
-        const type = types.get(object._type);
-        if (!type) {
-            throw new Error(`SerializeHelper: no type registered for ${object._type}`);
-        }
-        return type;
-    }
-
-    export interface SerializableObject {
-        _type: string;
-    }
-}

package/src/serialize/serialize.ts

@@ -1,7 +0,0 @@
-import { Serialize } from 'cerialize';
-
-import { serializable } from './serializable';
-
-export function serialize<T>(object: T): serializable.SerializableObject {
-    return Serialize(object);
-}

package/src/serialize/type-helper.ts

@@ -1,167 +0,0 @@
-import { __TypeMap, Deserialize } from 'cerialize';
-
-import { _trimEnd } from '../vendors/lodash';
-
-export class TypeHelper {
-    public static getProperties<T>(type: new () => T): TypeHelper.Property[] {
-        const metaData = this.getMetaData(type);
-        const result: TypeHelper.Property[] = [];
-
-        const remaining = metaData.map(m => ({ parent: null, m }));
-        while (remaining.length > 0) {
-            const property = remaining.shift();
-            const path = property.parent ? `${property.parent}.${property.m.name}` : property.m.name;
-            result.push({
-                parent: property.parent ? _trimEnd(property.parent, '[]') : null,
-                path,
-                name: property.m.name,
-                isArray: property.m.isArray,
-                type: property.m.type,
-                enumName: property.m.enumName
-            });
-
-            if (property.m.type === TypeHelper.Type.Object) {
-                const parent = property.m.isArray ? `${path}[]` : path;
-                remaining.push(...property.m.objectMetadata.map(m => ({ parent, m })))
-            }
-        }
-        return result;
-    }
-
-    public static getMetaData<T>(type: new () => T): TypeHelper.MetaData[] {
-        const metaDataList = __TypeMap.get(type);
-        if (!metaDataList) {
-            return [];
-        }
-        const instance = Deserialize({}, type);
-        return metaDataList.map(m => {
-            const metaDataType = TypeHelper.getMetaDataType(m.deserializedType);
-            const metadata: TypeHelper.MetaData = {
-                name: m.keyName,
-                serializedKey: (m.serializedKey ? m.serializedKey : m.keyName),
-                deserializedKey: (m.deserializedKey ? m.deserializedKey : m.keyName),
-                type: metaDataType,
-                enumName: metaDataType === TypeHelper.Type.Enum ? this.getEnumName(m.deserializedType) : null,
-                isArray: Array.isArray(instance[m.keyName]),
-                arrayLength: Array.isArray(instance[m.keyName]) ? instance[m.keyName].length : null,
-                objectName: metaDataType === TypeHelper.Type.Object ? m.deserializedType.name : [],
-                objectMetadata: metaDataType === TypeHelper.Type.Object ? this.getMetaData(m.deserializedType) : [],
-                enumValues: metaDataType === TypeHelper.Type.Enum ? this.getEnumValues(m.deserializedType) : []
-            };
-            return metadata;
-        });
-    }
-
-    private static getMetaDataType(propType: any): TypeHelper.Type {
-        if (this.isString(propType)) {
-            return TypeHelper.Type.String;
-        }
-        if (this.isNumber(propType)) {
-            return TypeHelper.Type.Number;
-        }
-        if (this.isBoolean(propType)) {
-            return TypeHelper.Type.Boolean;
-        }
-        if (this.isDate(propType)) {
-            return TypeHelper.Type.Date;
-        }
-        if (this.isEnum(propType)) {
-            return TypeHelper.Type.Enum;
-        }
-        if (this.isAny(propType)) {
-            return TypeHelper.Type.Any;
-        }
-        return TypeHelper.Type.Object;
-    }
-
-    private static getEnumValues(type: any): any[] {
-        return type.helper ? type.helper.members : [];
-    }
-
-    private static getEnumName(type: any): string {
-        return type.helper ? type.helper.name : 'UnkownEnum';
-    }
-
-    private static isEnum(propType: any) {
-        if (!propType) {
-            return false;
-        } else if (propType.Deserialize) {
-            return false;
-        } else if (!propType.prototype) {
-            return true;
-        }
-    }
-
-    private static isDate(propType: any): boolean {
-        if (propType === Date) {
-            return true;
-        } else if (propType === Date.prototype.constructor) {
-            return true;
-        } else if (propType && propType.Deserialize && propType.Deserialize.name === 'Date') {
-            return true;
-        }
-        return false;
-    }
-
-    private static isString(propType: any) {
-        if (propType && propType.Deserialize && propType.Deserialize.name.replace('deserialize', '') === 'String') {
-            return true;
-        }
-        return false;
-    }
-
-    private static isBoolean(propType: any) {
-        if (propType && propType.Deserialize && propType.Deserialize.name.replace('deserialize', '') === 'Boolean') {
-            return true;
-        }
-        return false;
-    }
-
-    private static isNumber(propType: any) {
-        if (propType && propType.Deserialize && propType.Deserialize.name.replace('deserialize', '') === 'Number') {
-            return true;
-        }
-        return false;
-    }
-
-    private static isAny(propType: any) {
-        if (!propType) {
-            return true;
-        }
-        return false;
-    }
-}
-
-export namespace TypeHelper {
-    export class Property {
-        public path: string;
-        public parent: string;
-        public name: string;
-        public type: Type;
-        public enumName: string = null;
-        public isArray: boolean = null;
-    }
-
-    export class MetaData {
-        public name: string = null;
-        public serializedKey: string = null;
-        public deserializedKey: string = null;
-        public type: Type = null;
-        public enumName: string = null;
-        public isArray: boolean = null;
-        public arrayLength: number = null;
-        public objectName: string = null;
-        public objectMetadata: MetaData[] = null;
-        public enumValues: string[] = null;
-    }
-
-    export enum Type {
-        String = <any>'String',
-        Number = <any>'Number',
-        Date = <any>'Date',
-        Boolean = <any>'Boolean',
-        Enum = <any>'Enum',
-        Object = <any>'Object',
-        Any = <any>'Any'
-    }
-}

package/src/sleep.ts

@@ -1,10 +0,0 @@
-import { Logger } from './logger';
-
-/**
- * Wait specified miliseconds
- * @param miliseconds
- */
-export const sleep = async (miliseconds: number): Promise<void> => {
-    Logger.info(`Sleeping ${miliseconds} ms`);
-    return new Promise<void>(resolve => setTimeout(() => resolve(), miliseconds));
-}

package/src/validators/custom-validators/camel-case.ts

@@ -1,18 +0,0 @@
-import { registerDecorator, ValidationOptions } from 'class-validator';
-
-export function CamelCase(validationOptions?: ValidationOptions) {
-    return function (object: Record<string, any>, propertyName: string): void {
-        registerDecorator({
-            name: 'camelCase',
-            target: object.constructor,
-            propertyName: propertyName,
-            constraints: [{ name: 'camelCase' }],
-            options: validationOptions,
-            validator: {
-                validate(value: any) {
-                    return /^[a-z]+((\d)|([A-Z0-9]{1,3}[a-z0-9]+))*([A-Z])?$/.test(value);
-                }
-            }
-        });
-    };
-}

package/src/validators/custom-validators/equals-to.ts

@@ -1,20 +0,0 @@
-import { registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';
-
-export function EqualsTo(property: string, validationOptions?: ValidationOptions) {
-    return function (object: Record<string, any>, propertyName: string): void {
-        registerDecorator({
-            name: 'equalsTo',
-            target: object.constructor,
-            propertyName: propertyName,
-            constraints: [{ name: 'equalsTo', property }],
-            options: validationOptions,
-            validator: {
-                validate(value: any, args: ValidationArguments) {
-                    const relatedPropertyName = args.constraints[0].property;
-                    const relatedValue = (args.object as any)[relatedPropertyName];
-                    return value === relatedValue;
-                }
-            }
-        });
-    };
-}

package/src/validators/custom-validators/greater-or-equal-than.ts

@@ -1,23 +0,0 @@
-import { registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';
-
-export function GreaterOrEqualThan(property: string, validationOptions?: ValidationOptions) {
-    return function (object: Record<string, any>, propertyName: string): void {
-        registerDecorator({
-            name: 'greaterOrEqualThan',
-            target: object.constructor,
-            propertyName: propertyName,
-            constraints: [{ name: 'greaterOrEqualThan', property }],
-            options: validationOptions,
-            validator: {
-                validate(value: any, args: ValidationArguments) {
-                    const relatedPropertyName = args.constraints[0].property;
-                    const relatedValue = (args.object as any)[relatedPropertyName];
-                    if (typeof value === 'number' && typeof relatedValue === 'number') {
-                        return value >= relatedValue;
-                    }
-                    return false;
-                }
-            }
-        });
-    };
-}

package/src/validators/custom-validators/greater-than-date.ts

@@ -1,28 +0,0 @@
-import { registerDecorator, ValidationArguments, ValidationOptions } from 'class-validator';
-
-export function GreaterThanDate(property: string, milliSecondsOffset?: number, validationOptions?: ValidationOptions) {
-    return function (object: Record<string, any>, propertyName: string): void {
-        registerDecorator({
-            name: 'greaterThanDate',
-            target: object.constructor,
-            propertyName: propertyName,
-            constraints: [{ name: 'greaterThanDate', property }],
-            options: validationOptions,
-            validator: {
-                validate(value: any, args: ValidationArguments) {
-                    const relatedPropertyName = args.constraints[0].property;
-                    let relatedValue = (args.object as any)[relatedPropertyName];
-                    if (value instanceof Date && relatedValue instanceof Date) {
-                        if (milliSecondsOffset) {
-                            const date = new Date();
-                            date.setTime(relatedValue.getTime() + milliSecondsOffset);
-                            relatedValue = date;
-                        }
-                        return value > relatedValue;
-                    }
-                    return false;
-                }
-            }
-        });
-    };
-}

package/src/validators/custom-validators/index.ts

@@ -1,7 +0,0 @@
-export * from './camel-case';
-export * from './equals-to';
-export * from './greater-or-equal-than';
-export * from './greater-than-date';
-export * from './is-not-in-relative-to';
-export * from './is-optional-if';
-export * from './pascal-case';

package/src/validators/custom-validators/is-not-in-relative-to.ts

@@ -1,25 +0,0 @@
-import { registerDecorator, ValidationArguments, ValidationOptions, Validator } from 'class-validator';
-
-const globalValidator = new Validator();
-
-export function IsNotInRelativeTo<T, S>(excludedValuesCallback: (object: T) => S[], validationOptions?: ValidationOptions) {
-    return function (object: Record<string, any>, propertyName: string): void {
-        registerDecorator({
-            name: 'isNotInRelativeTo',
-            target: object.constructor,
-            propertyName: propertyName,
-            constraints: [{ name: 'isNotInRelativeTo', relativeValueCallback: excludedValuesCallback }],
-            options: validationOptions,
-            validator: {
-                validate(value: any, args: ValidationArguments) {
-                    const excludedValues = args.constraints[0].relativeValueCallback(args.object);
-                    if (Array.isArray(value) && validationOptions && validationOptions.each) {
-                        return value.every(v => globalValidator.isNotIn(v, excludedValues));
-                    } else {
-                        return globalValidator.isNotIn(value, excludedValues);
-                    }
-                }
-            }
-        });
-    };
-}

package/src/validators/custom-validators/is-optional-if.ts

@@ -1,21 +0,0 @@
-import { getFromContainer, MetadataStorage, ValidationOptions, ValidationTypes } from 'class-validator';
-import { ValidationMetadata } from 'class-validator/metadata/ValidationMetadata';
-import { ValidationMetadataArgs } from 'class-validator/metadata/ValidationMetadataArgs';
-
-export function IsOptionalIf(condition: (object: any, value: any) => boolean, validationOptions?: ValidationOptions) {
-    return function (object: Record<string, any>, propertyName: string): void {
-        const args: ValidationMetadataArgs = {
-            type: ValidationTypes.CONDITIONAL_VALIDATION,
-            target: object.constructor,
-            propertyName: propertyName,
-            constraints: [(cobject: any, value: any) => {
-                if (condition(cobject, value)) {
-                    return cobject[propertyName] !== '' && cobject[propertyName] !== null && cobject[propertyName] !== undefined;
-                }
-                return true;
-            }],
-            validationOptions: validationOptions
-        };
-        getFromContainer(MetadataStorage).addValidationMetadata(new ValidationMetadata(args));
-    };
-}

package/src/validators/custom-validators/pascal-case.ts

@@ -1,18 +0,0 @@
-import { registerDecorator, ValidationOptions } from 'class-validator';
-
-export function PascalCase(validationOptions?: ValidationOptions) {
-    return function (object: Record<string, any>, propertyName: string): void {
-        registerDecorator({
-            name: 'pascalCase',
-            target: object.constructor,
-            propertyName: propertyName,
-            constraints: [{ name: 'pascalCase' }],
-            options: validationOptions,
-            validator: {
-                validate(value: any) {
-                    return /^([A-Z]{1,3}[a-z0-9]*)+$/.test(value);
-                }
-            }
-        });
-    };
-}

package/src/validators/index.ts

@@ -1,24 +0,0 @@
-export * from './custom-validators';
-
-export {
-    IsOptional,
-    IsDefined, Equals, NotEquals, IsEmpty, IsNotEmpty, IsIn, IsNotIn,
-    // type validation methods
-    IsArray, IsBoolean, IsDate, IsString, IsNumber, IsInt, IsEnum,
-    // number validation methods
-    IsDivisibleBy, IsPositive, IsNegative, Max, Min,
-    // date validation methods
-    MinDate, MaxDate,
-    // string-type validation methods
-    IsBooleanString, IsNumberString,
-    // string validation methods
-    Contains, NotContains, IsAlpha, IsAlphanumeric, IsAscii, IsBase64, IsByteLength,
-    IsCreditCard, IsCurrency, IsEmail, IsFQDN, IsFullWidth, IsHalfWidth, IsVariableWidth,
-    IsHexColor, IsHexadecimal, IsIP, IsISBN, IsISIN, IsISO8601, IsJSON, IsLowercase, IsMobilePhone,
-    IsMongoId, IsMultibyte, IsSurrogatePair, IsUrl, IsUUID, IsUppercase, Length, MinLength,
-    MaxLength, Matches, IsMilitaryTime,
-    // array validation methods
-    ArrayContains, ArrayNotContains, ArrayNotEmpty, ArrayMinSize, ArrayMaxSize, ArrayUnique
-} from 'class-validator';
-
-export { validate } from './validate';