@stemy/backend 2.6.1 → 2.7.3

package/common-types.d.ts

@@ -1,214 +1,226 @@
-/// <reference types="node" />
-import { Server } from "http";
-import { Request, Express } from "express";
-import { Socket, Server as SocketServer } from "socket.io";
-import { RoutingControllersOptions } from "routing-controllers";
-import { SocketControllersOptions } from "socket-controllers";
-import { ClassProvider, DependencyContainer, InjectionToken, TokenProvider, ValueProvider, RegistrationOptions } from "tsyringe";
-import { SchemaObject } from "openapi3-ts";
-import { Readable } from "stream";
-import { Moment } from "moment";
-export declare const Type: FunctionConstructor;
-export interface Type<T = object> extends Function {
-    new (...args: any[]): T;
-}
-export interface FactoryProvider<T> {
-    useFactory: (dc: IDependencyContainer) => T;
-}
-export interface ITree {
-    readonly path: string;
-    resolveService(): any;
-    resolveLeaves(): Map<string, ITree>;
-    resolveServices(): Map<string, any>;
-    resolveAncestor(path: string): ITree;
-    resolvePath(path: string, throwError?: boolean): ITree;
-}
-export interface IDependencyContainer extends DependencyContainer {
-    readonly parent: IDependencyContainer;
-    readonly tree: ITree;
-    readonly registeredTokens: ReadonlyArray<InjectionToken>;
-    createChildContainer(): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;
-    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;
-    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
-    registerSingleton<T>(token: Type<T>): IDependencyContainer;
-    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
-    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer;
-    get<T>(token: InjectionToken<T>): T;
-}
-export interface ClassBasedProvider<T> extends ClassProvider<T> {
-    provide: InjectionToken;
-}
-export interface ValueBasedProvider<T> extends ValueProvider<T> {
-    provide: InjectionToken;
-}
-export interface FactoryBasedProvider<T> extends FactoryProvider<T> {
-    provide: InjectionToken;
-}
-export interface TokenBasedProvider<T> extends TokenProvider<T> {
-    provide: InjectionToken;
-}
-export declare type SyringeProvider<T> = Type<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | TokenProvider<T>;
-export declare type Provider<T> = Type<T> | ClassBasedProvider<T> | ValueBasedProvider<T> | FactoryBasedProvider<T> | TokenBasedProvider<T>;
-export declare const FIXTURE: InjectionToken<IFixture>;
-export declare const JOB: InjectionToken<IJob>;
-export declare const EXPRESS: InjectionToken<Express>;
-export declare const HTTP_SERVER: InjectionToken<Server>;
-export declare const SOCKET_SERVER: InjectionToken<SocketServer>;
-export declare const PARAMETER: InjectionToken<Parameter>;
-export declare const DI_CONTAINER: InjectionToken<IDependencyContainer>;
-export interface IFixture {
-    load(): Promise<any>;
-}
-export declare type SchemaConverter = (meta: any, options: any) => SchemaObject;
-export declare type ParamResolver = (value: string) => any;
-export declare class Parameter {
-    readonly name: string;
-    defaultValue: any;
-    resolver: ParamResolver;
-    constructor(name: string, defaultValue: any, resolver?: ParamResolver);
-}
-export interface IJob {
-    process(): Promise<any>;
-}
-export interface IJobTask {
-    start: () => this;
-    stop: () => this;
-    destroy: () => void;
-    getStatus: () => string;
-}
-export declare type JobParams = {
-    [name: string]: string | number | boolean;
-};
-export interface JobScheduleRange {
-    min: number;
-    max: number;
-}
-export declare type JobScheduleTime = string | number | JobScheduleRange | Array<string | number>;
-export interface IProgress {
-    id?: string;
-    message?: any;
-    error?: any;
-    percent?: number;
-    current: number;
-    remaining: number;
-    createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress>;
-    setMax(max: number): Promise<any>;
-    setError(error: string): Promise<any>;
-    advance(value?: number): Promise<any>;
-    save(): Promise<any>;
-    toJSON(): any;
-}
-export interface IAssetMeta {
-    filename?: string;
-    classified?: boolean;
-    downloadCount?: number;
-    firstDownload?: Date;
-    lastDownload?: Date;
-    [prop: string]: any;
-}
-export interface IAssetImageParams {
-    rotation?: number;
-    canvasScaleX?: number;
-    canvasScaleY?: number;
-    scaleX?: number;
-    scaleY?: number;
-    lazy?: boolean;
-}
-export interface IAsset {
-    id?: string;
-    filename?: string;
-    contentType?: string;
-    metadata?: IAssetMeta;
-    stream: Readable;
-    unlink(): Promise<string>;
-    getBuffer(): Promise<Buffer>;
-    download(metadata?: IAssetMeta): Promise<Readable>;
-    downloadImage(params?: IAssetImageParams, metadata?: IAssetMeta): Promise<Readable>;
-    getImage(params?: IAssetImageParams): Promise<Readable>;
-    toJSON(): any;
-}
-export interface ILazyAsset {
-    id: string;
-    jobName: string;
-    jobParams: any;
-    jobQue: string;
-    progressId?: string;
-    assetId?: string;
-    unlink(): Promise<string>;
-    startWorking(): void;
-    loadAsset(): Promise<IAsset>;
-    writeAsset(asset: IAsset): Promise<IAsset>;
-    toJSON(): any;
-}
-export interface IUser {
-    _id?: string;
-    id?: string;
-    email: string;
-    password: string;
-    roles: string[];
-}
-export interface IClientSocket extends Socket {
-    interestedProgresses: Set<string>;
-}
-export interface IRequestBase<T> extends Request {
-    id?: string;
-    started?: Moment;
-    ended?: Moment;
-    container?: DependencyContainer;
-    language?: string;
-    user?: T;
-}
-export interface IRequest extends IRequestBase<IUser> {
-}
-export interface IGalleryImage {
-    folder: string;
-    thumb: string;
-    big: string;
-    serve(id: string): Promise<Buffer>;
-}
-export interface IGallerySize {
-    width?: number;
-    height?: number;
-}
-export interface IGalleryImageHandler {
-    getOriginal(): Promise<Buffer>;
-    writeResult(isThumb: boolean, buffer: Buffer): Promise<any>;
-    hasResult(isThumb: boolean): Promise<boolean>;
-    serveResult(isThumb: boolean): Promise<Buffer>;
-}
-export interface ITranslations {
-    [key: string]: any;
-}
-export interface IPaginationMeta {
-    total: number;
-    [key: string]: any;
-}
-export interface IPaginationBase<T> {
-    count: number;
-    items: T[];
-    meta?: IPaginationMeta;
-}
-export interface IPagination extends IPaginationBase<any> {
-}
-export interface IPaginationParams {
-    page: number;
-    limit: number;
-    sort?: string;
-    populate?: string[];
-    [key: string]: any;
-}
-export declare type FontFormat = "opentype" | "truetype" | "woff" | "woff2" | "datafork";
-export interface IBackendConfig {
-    rootFolder?: string;
-    routePrefix?: string;
-    params?: Parameter[];
-    fixtures?: Type<IFixture>[];
-    jobs?: Type<IJob>[];
-    restOptions?: RoutingControllersOptions;
-    socketOptions?: SocketControllersOptions;
-    customValidation?: SchemaConverter | SchemaObject;
-}
+/// <reference types="node" />
+import { Server } from "http";
+import { Request, Express } from "express";
+import { Socket, Server as SocketServer } from "socket.io";
+import { RoutingControllersOptions } from "routing-controllers";
+import { SocketControllersOptions } from "socket-controllers";
+import { ClassProvider, DependencyContainer, InjectionToken, TokenProvider, ValueProvider, RegistrationOptions } from "tsyringe";
+import { SchemaObject } from "openapi3-ts";
+import { Readable } from "stream";
+import { Moment } from "moment";
+export declare const Type: FunctionConstructor;
+export interface Type<T = object> extends Function {
+    new (...args: any[]): T;
+}
+export interface FactoryProvider<T> {
+    useFactory: (dc: IDependencyContainer) => T;
+}
+export interface ITree {
+    readonly path: string;
+    resolveService(): any;
+    resolveLeaves(): Map<string, ITree>;
+    resolveServices(): Map<string, any>;
+    resolveAncestor(path: string): ITree;
+    resolvePath(path: string, throwError?: boolean): ITree;
+}
+export interface IDependencyContainer extends DependencyContainer {
+    readonly parent: IDependencyContainer;
+    readonly tree: ITree;
+    readonly registeredTokens: ReadonlyArray<InjectionToken>;
+    createChildContainer(): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;
+    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;
+    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
+    registerSingleton<T>(token: Type<T>): IDependencyContainer;
+    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;
+    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer;
+    get<T>(token: InjectionToken<T>): T;
+}
+export interface ClassBasedProvider<T> extends ClassProvider<T> {
+    provide: InjectionToken;
+}
+export interface ValueBasedProvider<T> extends ValueProvider<T> {
+    provide: InjectionToken;
+}
+export interface FactoryBasedProvider<T> extends FactoryProvider<T> {
+    provide: InjectionToken;
+}
+export interface TokenBasedProvider<T> extends TokenProvider<T> {
+    provide: InjectionToken;
+}
+export declare type SyringeProvider<T> = Type<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | TokenProvider<T>;
+export declare type Provider<T> = Type<T> | ClassBasedProvider<T> | ValueBasedProvider<T> | FactoryBasedProvider<T> | TokenBasedProvider<T>;
+export declare const FIXTURE: InjectionToken<IFixture>;
+export declare const JOB: InjectionToken<IJob>;
+export declare const EXPRESS: InjectionToken<Express>;
+export declare const HTTP_SERVER: InjectionToken<Server>;
+export declare const SOCKET_SERVER: InjectionToken<SocketServer>;
+export declare const PARAMETER: InjectionToken<Parameter>;
+export declare const DI_CONTAINER: InjectionToken<IDependencyContainer>;
+export interface IFixture {
+    load(): Promise<any>;
+}
+export declare type SchemaConverter = (meta: any, options: any) => SchemaObject;
+export declare type ParamResolver = (value: string) => any;
+export declare class Parameter {
+    readonly name: string;
+    defaultValue: any;
+    resolver: ParamResolver;
+    constructor(name: string, defaultValue: any, resolver?: ParamResolver);
+}
+export interface IJob {
+    process(): Promise<any>;
+}
+export interface IJobTask {
+    start: () => this;
+    stop: () => this;
+    destroy: () => void;
+    getStatus: () => string;
+}
+export declare type JobParams = {
+    [name: string]: string | number | boolean;
+};
+export interface JobScheduleRange {
+    min: number;
+    max: number;
+}
+export declare type JobScheduleTime = string | number | JobScheduleRange | Array<string | number>;
+export interface IProgress {
+    id?: string;
+    message?: any;
+    error?: any;
+    percent?: number;
+    current: number;
+    remaining: number;
+    createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress>;
+    setMax(max: number): Promise<any>;
+    setError(error: string): Promise<any>;
+    advance(value?: number): Promise<any>;
+    save(): Promise<any>;
+    toJSON(): any;
+}
+export interface IAssetCropInfo {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface IAssetMeta {
+    filename?: string;
+    classified?: boolean;
+    downloadCount?: number;
+    firstDownload?: Date;
+    lastDownload?: Date;
+    crop?: IAssetCropInfo;
+    cropBefore?: IAssetCropInfo;
+    cropAfter?: IAssetCropInfo;
+    [prop: string]: any;
+}
+export interface IAssetImageParams {
+    rotation?: number;
+    canvasScaleX?: number;
+    canvasScaleY?: number;
+    scaleX?: number;
+    scaleY?: number;
+    lazy?: boolean;
+    crop?: string | boolean;
+    cropBefore?: string | IAssetCropInfo;
+    cropAfter?: string | IAssetCropInfo;
+}
+export interface IAsset {
+    id?: string;
+    filename?: string;
+    contentType?: string;
+    metadata?: IAssetMeta;
+    stream: Readable;
+    unlink(): Promise<string>;
+    getBuffer(): Promise<Buffer>;
+    download(metadata?: IAssetMeta): Promise<Readable>;
+    downloadImage(params?: IAssetImageParams, metadata?: IAssetMeta): Promise<Readable>;
+    getImage(params?: IAssetImageParams): Promise<Readable>;
+    toJSON(): any;
+}
+export interface ILazyAsset {
+    id: string;
+    jobName: string;
+    jobParams: any;
+    jobQue: string;
+    progressId?: string;
+    assetId?: string;
+    unlink(): Promise<string>;
+    startWorking(): void;
+    loadAsset(): Promise<IAsset>;
+    writeAsset(asset: IAsset): Promise<IAsset>;
+    toJSON(): any;
+}
+export interface IUser {
+    _id?: string;
+    id?: string;
+    email: string;
+    password: string;
+    roles: string[];
+}
+export interface IClientSocket extends Socket {
+    interestedProgresses: Set<string>;
+}
+export interface IRequestBase<T> extends Request {
+    id?: string;
+    started?: Moment;
+    ended?: Moment;
+    container?: DependencyContainer;
+    language?: string;
+    user?: T;
+}
+export interface IRequest extends IRequestBase<IUser> {
+}
+export interface IGalleryImage {
+    folder: string;
+    thumb: string;
+    big: string;
+    serve(id: string): Promise<Buffer>;
+}
+export interface IGallerySize {
+    width?: number;
+    height?: number;
+}
+export interface IGalleryImageHandler {
+    getOriginal(): Promise<Buffer>;
+    writeResult(isThumb: boolean, buffer: Buffer): Promise<any>;
+    hasResult(isThumb: boolean): Promise<boolean>;
+    serveResult(isThumb: boolean): Promise<Buffer>;
+}
+export interface ITranslations {
+    [key: string]: any;
+}
+export interface IPaginationMeta {
+    total: number;
+    [key: string]: any;
+}
+export interface IPaginationBase<T> {
+    count: number;
+    items: T[];
+    meta?: IPaginationMeta;
+}
+export interface IPagination extends IPaginationBase<any> {
+}
+export interface IPaginationParams {
+    page: number;
+    limit: number;
+    sort?: string;
+    populate?: string[];
+    [key: string]: any;
+}
+export declare type FontFormat = "opentype" | "truetype" | "woff" | "woff2" | "datafork";
+export interface IBackendConfig {
+    rootFolder?: string;
+    routePrefix?: string;
+    params?: Parameter[];
+    fixtures?: Type<IFixture>[];
+    jobs?: Type<IJob>[];
+    restOptions?: RoutingControllersOptions;
+    socketOptions?: SocketControllersOptions;
+    customValidation?: SchemaConverter | SchemaObject;
+}

package/esm2015/common-types.js

@@ -1,18 +1,18 @@
-// --- DI functions ---
-export const Type = Function;
-// --- Injection tokens ---
-export const FIXTURE = Symbol.for("fixture-token");
-export const JOB = Symbol.for("job-token");
-export const EXPRESS = Symbol.for("express-token");
-export const HTTP_SERVER = Symbol.for("http-server-token");
-export const SOCKET_SERVER = Symbol.for("socket-server-token");
-export const PARAMETER = Symbol.for("parameter-token");
-export const DI_CONTAINER = Symbol.for("di-container-token");
-export class Parameter {
-    constructor(name, defaultValue, resolver = null) {
-        this.name = name;
-        this.defaultValue = defaultValue;
-        this.resolver = resolver;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../../src/common-types.ts"],"names":[],"mappings":"AAkBA,uBAAuB;AAEvB,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAC;AAwD7B,2BAA2B;AAE3B,MAAM,CAAC,MAAM,OAAO,GAA6B,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAE7E,MAAM,CAAC,MAAM,GAAG,GAAyB,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AAEjE,MAAM,CAAC,MAAM,OAAO,GAA4B,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAE5E,MAAM,CAAC,MAAM,WAAW,GAA2B,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAEnF,MAAM,CAAC,MAAM,aAAa,GAAiC,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAE7F,MAAM,CAAC,MAAM,SAAS,GAA8B,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;AAElF,MAAM,CAAC,MAAM,YAAY,GAAyC,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAenG,MAAM,OAAO,SAAS;IAElB,YAAqB,IAAY,EAAS,YAAiB,EAAS,WAA0B,IAAI;QAA7E,SAAI,GAAJ,IAAI,CAAQ;QAAS,iBAAY,GAAZ,YAAY,CAAK;QAAS,aAAQ,GAAR,QAAQ,CAAsB;IAElG,CAAC;CACJ","sourcesContent":["import {Server} from \"http\";\nimport {Request, Express} from \"express\";\nimport {Socket, Server as SocketServer} from \"socket.io\";\nimport {RoutingControllersOptions} from \"routing-controllers\";\nimport {SocketControllersOptions} from \"socket-controllers\";\nimport {\n    ClassProvider,\n    DependencyContainer,\n    InjectionToken,\n    TokenProvider,\n    ValueProvider,\n    RegistrationOptions\n} from \"tsyringe\";\nimport {SchemaObject} from \"openapi3-ts\";\nimport Buffer from \"buffer\";\nimport {Readable} from \"stream\";\nimport {Moment} from \"moment\";\n\n// --- DI functions ---\n\nexport const Type = Function;\n\nexport interface Type<T = object> extends Function {\n    new (...args: any[]): T;\n}\n\nexport interface FactoryProvider<T> {\n    useFactory: (dc: IDependencyContainer) => T;\n}\n\nexport interface ITree {\n    readonly path: string;\n    resolveService(): any;\n    resolveLeaves(): Map<string, ITree>;\n    resolveServices(): Map<string, any>;\n    resolveAncestor(path: string): ITree;\n    resolvePath(path: string, throwError?: boolean): ITree;\n}\n\nexport interface IDependencyContainer extends DependencyContainer {\n    readonly parent: IDependencyContainer;\n    readonly tree: ITree;\n    readonly registeredTokens: ReadonlyArray<InjectionToken>;\n    createChildContainer(): IDependencyContainer;\n    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;\n    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;\n    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;\n    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;\n    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;\n    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;\n    registerSingleton<T>(token: Type<T>): IDependencyContainer;\n    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;\n    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer;\n    get<T>(token: InjectionToken<T>): T;\n}\n\nexport interface ClassBasedProvider<T> extends ClassProvider<T> {\n    provide: InjectionToken;\n}\n\nexport interface ValueBasedProvider<T> extends ValueProvider<T> {\n    provide: InjectionToken;\n}\n\nexport interface FactoryBasedProvider<T> extends FactoryProvider<T> {\n    provide: InjectionToken;\n}\n\nexport interface TokenBasedProvider<T> extends TokenProvider<T> {\n    provide: InjectionToken;\n}\n\nexport type SyringeProvider<T> = Type<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | TokenProvider<T>;\n\nexport type Provider<T> = Type<T> | ClassBasedProvider<T> | ValueBasedProvider<T> | FactoryBasedProvider<T> | TokenBasedProvider<T>;\n\n// --- Injection tokens ---\n\nexport const FIXTURE: InjectionToken<IFixture> = Symbol.for(\"fixture-token\");\n\nexport const JOB: InjectionToken<IJob> = Symbol.for(\"job-token\");\n\nexport const EXPRESS: InjectionToken<Express> = Symbol.for(\"express-token\");\n\nexport const HTTP_SERVER: InjectionToken<Server> = Symbol.for(\"http-server-token\");\n\nexport const SOCKET_SERVER: InjectionToken<SocketServer> = Symbol.for(\"socket-server-token\");\n\nexport const PARAMETER: InjectionToken<Parameter> = Symbol.for(\"parameter-token\");\n\nexport const DI_CONTAINER: InjectionToken<IDependencyContainer> = Symbol.for(\"di-container-token\");\n\n// --- Interfaces and utility classes ---\n\nexport interface IFixture {\n    load(): Promise<any>;\n}\n\nexport type SchemaConverter = (\n    meta: any,\n    options: any\n) => SchemaObject;\n\nexport type ParamResolver = (value: string) => any;\n\nexport class Parameter {\n\n    constructor(readonly name: string, public defaultValue: any, public resolver: ParamResolver = null) {\n\n    }\n}\n\nexport interface IJob {\n    process(): Promise<any>;\n}\n\nexport interface IJobTask {\n    start: () => this;\n    stop: () => this;\n    destroy: () => void;\n    getStatus: () => string;\n}\n\nexport type JobParams = {[name: string]: string | number | boolean};\n\nexport interface JobScheduleRange {\n    min: number;\n    max: number;\n}\n\nexport type JobScheduleTime = string | number | JobScheduleRange | Array<string | number>;\n\nexport interface IProgress {\n    id?: string;\n    message?: any;\n    error?: any;\n    percent?: number;\n    current: number;\n    remaining: number;\n    createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress>;\n    setMax(max: number): Promise<any>;\n    setError(error: string): Promise<any>;\n    advance(value?: number): Promise<any>;\n    save(): Promise<any>;\n    toJSON(): any;\n}\n\nexport interface IAssetMeta {\n    filename?: string;\n    classified?: boolean;\n    downloadCount?: number;\n    firstDownload?: Date;\n    lastDownload?: Date;\n    [prop: string]: any;\n}\n\nexport interface IAssetImageParams {\n    rotation?: number;\n    canvasScaleX?: number;\n    canvasScaleY?: number;\n    scaleX?: number;\n    scaleY?: number;\n    lazy?: boolean;\n}\n\nexport interface IAsset {\n    id?: string;\n    filename?: string;\n    contentType?: string;\n    metadata?: IAssetMeta;\n    stream: Readable,\n    unlink(): Promise<string>;\n    getBuffer(): Promise<Buffer>;\n    download(metadata?: IAssetMeta): Promise<Readable>;\n    downloadImage(params?: IAssetImageParams, metadata?: IAssetMeta): Promise<Readable>;\n    getImage(params?: IAssetImageParams): Promise<Readable>;\n    toJSON(): any;\n}\n\nexport interface ILazyAsset {\n    id: string;\n    jobName: string;\n    jobParams: any;\n    jobQue: string;\n    progressId?: string;\n    assetId?: string;\n    unlink(): Promise<string>;\n    startWorking(): void;\n    loadAsset(): Promise<IAsset>;\n    writeAsset(asset: IAsset): Promise<IAsset>;\n    toJSON(): any;\n}\n\nexport interface IUser {\n    _id?: string;\n    id?: string;\n    email: string;\n    password: string;\n    roles: string[];\n}\n\nexport interface IClientSocket extends Socket {\n    interestedProgresses: Set<string>;\n}\n\nexport interface IRequestBase<T> extends Request {\n    id?: string;\n    started?: Moment;\n    ended?: Moment;\n    container?: DependencyContainer;\n    language?: string;\n    user?: T;\n}\n\nexport interface IRequest extends IRequestBase<IUser> {\n\n}\n\nexport interface IGalleryImage {\n    folder: string;\n    thumb: string;\n    big: string;\n    serve(id: string): Promise<Buffer>\n}\n\nexport interface IGallerySize {\n    width?: number;\n    height?: number;\n}\n\nexport interface IGalleryImageHandler {\n    getOriginal(): Promise<Buffer>;\n    writeResult(isThumb: boolean, buffer: Buffer): Promise<any>;\n    hasResult(isThumb: boolean): Promise<boolean>;\n    serveResult(isThumb: boolean): Promise<Buffer>;\n}\n\nexport interface ITranslations {\n    [key: string]: any;\n}\n\nexport interface IPaginationMeta {\n    total: number;\n    [key: string]: any;\n}\n\nexport interface IPaginationBase<T> {\n    count: number\n    items: T[];\n    meta?: IPaginationMeta;\n}\n\nexport interface IPagination extends IPaginationBase<any> {\n\n}\n\nexport interface IPaginationParams {\n    page: number;\n    limit: number;\n    sort?: string;\n    populate?: string[];\n    [key: string]: any;\n}\n\nexport type FontFormat = \"opentype\" | \"truetype\" | \"woff\" | \"woff2\" | \"datafork\";\n\nexport interface IBackendConfig {\n    rootFolder?: string;\n    routePrefix?: string;\n    params?: Parameter[];\n    fixtures?: Type<IFixture>[];\n    jobs?: Type<IJob>[];\n    restOptions?: RoutingControllersOptions;\n    socketOptions?: SocketControllersOptions;\n    customValidation?: SchemaConverter | SchemaObject;\n}\n"]}
+// --- DI functions ---
+export const Type = Function;
+// --- Injection tokens ---
+export const FIXTURE = Symbol.for("fixture-token");
+export const JOB = Symbol.for("job-token");
+export const EXPRESS = Symbol.for("express-token");
+export const HTTP_SERVER = Symbol.for("http-server-token");
+export const SOCKET_SERVER = Symbol.for("socket-server-token");
+export const PARAMETER = Symbol.for("parameter-token");
+export const DI_CONTAINER = Symbol.for("di-container-token");
+export class Parameter {
+    constructor(name, defaultValue, resolver = null) {
+        this.name = name;
+        this.defaultValue = defaultValue;
+        this.resolver = resolver;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../../src/common-types.ts"],"names":[],"mappings":"AAkBA,uBAAuB;AAEvB,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAC;AAwD7B,2BAA2B;AAE3B,MAAM,CAAC,MAAM,OAAO,GAA6B,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAE7E,MAAM,CAAC,MAAM,GAAG,GAAyB,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;AAEjE,MAAM,CAAC,MAAM,OAAO,GAA4B,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAE5E,MAAM,CAAC,MAAM,WAAW,GAA2B,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;AAEnF,MAAM,CAAC,MAAM,aAAa,GAAiC,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;AAE7F,MAAM,CAAC,MAAM,SAAS,GAA8B,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;AAElF,MAAM,CAAC,MAAM,YAAY,GAAyC,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAenG,MAAM,OAAO,SAAS;IAElB,YAAqB,IAAY,EAAS,YAAiB,EAAS,WAA0B,IAAI;QAA7E,SAAI,GAAJ,IAAI,CAAQ;QAAS,iBAAY,GAAZ,YAAY,CAAK;QAAS,aAAQ,GAAR,QAAQ,CAAsB;IAElG,CAAC;CACJ","sourcesContent":["import {Server} from \"http\";\r\nimport {Request, Express} from \"express\";\r\nimport {Socket, Server as SocketServer} from \"socket.io\";\r\nimport {RoutingControllersOptions} from \"routing-controllers\";\r\nimport {SocketControllersOptions} from \"socket-controllers\";\r\nimport {\r\n    ClassProvider,\r\n    DependencyContainer,\r\n    InjectionToken,\r\n    TokenProvider,\r\n    ValueProvider,\r\n    RegistrationOptions\r\n} from \"tsyringe\";\r\nimport {SchemaObject} from \"openapi3-ts\";\r\nimport Buffer from \"buffer\";\r\nimport {Readable} from \"stream\";\r\nimport {Moment} from \"moment\";\r\n\r\n// --- DI functions ---\r\n\r\nexport const Type = Function;\r\n\r\nexport interface Type<T = object> extends Function {\r\n    new (...args: any[]): T;\r\n}\r\n\r\nexport interface FactoryProvider<T> {\r\n    useFactory: (dc: IDependencyContainer) => T;\r\n}\r\n\r\nexport interface ITree {\r\n    readonly path: string;\r\n    resolveService(): any;\r\n    resolveLeaves(): Map<string, ITree>;\r\n    resolveServices(): Map<string, any>;\r\n    resolveAncestor(path: string): ITree;\r\n    resolvePath(path: string, throwError?: boolean): ITree;\r\n}\r\n\r\nexport interface IDependencyContainer extends DependencyContainer {\r\n    readonly parent: IDependencyContainer;\r\n    readonly tree: ITree;\r\n    readonly registeredTokens: ReadonlyArray<InjectionToken>;\r\n    createChildContainer(): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: ValueProvider<T>): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: FactoryProvider<T>): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: TokenProvider<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: ClassProvider<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    register<T>(token: InjectionToken<T>, provider: Type<T>, options?: RegistrationOptions): IDependencyContainer;\r\n    registerSingleton<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;\r\n    registerSingleton<T>(token: Type<T>): IDependencyContainer;\r\n    registerType<T>(from: InjectionToken<T>, to: InjectionToken<T>): IDependencyContainer;\r\n    registerInstance<T>(token: InjectionToken<T>, instance: T): IDependencyContainer;\r\n    get<T>(token: InjectionToken<T>): T;\r\n}\r\n\r\nexport interface ClassBasedProvider<T> extends ClassProvider<T> {\r\n    provide: InjectionToken;\r\n}\r\n\r\nexport interface ValueBasedProvider<T> extends ValueProvider<T> {\r\n    provide: InjectionToken;\r\n}\r\n\r\nexport interface FactoryBasedProvider<T> extends FactoryProvider<T> {\r\n    provide: InjectionToken;\r\n}\r\n\r\nexport interface TokenBasedProvider<T> extends TokenProvider<T> {\r\n    provide: InjectionToken;\r\n}\r\n\r\nexport type SyringeProvider<T> = Type<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | TokenProvider<T>;\r\n\r\nexport type Provider<T> = Type<T> | ClassBasedProvider<T> | ValueBasedProvider<T> | FactoryBasedProvider<T> | TokenBasedProvider<T>;\r\n\r\n// --- Injection tokens ---\r\n\r\nexport const FIXTURE: InjectionToken<IFixture> = Symbol.for(\"fixture-token\");\r\n\r\nexport const JOB: InjectionToken<IJob> = Symbol.for(\"job-token\");\r\n\r\nexport const EXPRESS: InjectionToken<Express> = Symbol.for(\"express-token\");\r\n\r\nexport const HTTP_SERVER: InjectionToken<Server> = Symbol.for(\"http-server-token\");\r\n\r\nexport const SOCKET_SERVER: InjectionToken<SocketServer> = Symbol.for(\"socket-server-token\");\r\n\r\nexport const PARAMETER: InjectionToken<Parameter> = Symbol.for(\"parameter-token\");\r\n\r\nexport const DI_CONTAINER: InjectionToken<IDependencyContainer> = Symbol.for(\"di-container-token\");\r\n\r\n// --- Interfaces and utility classes ---\r\n\r\nexport interface IFixture {\r\n    load(): Promise<any>;\r\n}\r\n\r\nexport type SchemaConverter = (\r\n    meta: any,\r\n    options: any\r\n) => SchemaObject;\r\n\r\nexport type ParamResolver = (value: string) => any;\r\n\r\nexport class Parameter {\r\n\r\n    constructor(readonly name: string, public defaultValue: any, public resolver: ParamResolver = null) {\r\n\r\n    }\r\n}\r\n\r\nexport interface IJob {\r\n    process(): Promise<any>;\r\n}\r\n\r\nexport interface IJobTask {\r\n    start: () => this;\r\n    stop: () => this;\r\n    destroy: () => void;\r\n    getStatus: () => string;\r\n}\r\n\r\nexport type JobParams = {[name: string]: string | number | boolean};\r\n\r\nexport interface JobScheduleRange {\r\n    min: number;\r\n    max: number;\r\n}\r\n\r\nexport type JobScheduleTime = string | number | JobScheduleRange | Array<string | number>;\r\n\r\nexport interface IProgress {\r\n    id?: string;\r\n    message?: any;\r\n    error?: any;\r\n    percent?: number;\r\n    current: number;\r\n    remaining: number;\r\n    createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress>;\r\n    setMax(max: number): Promise<any>;\r\n    setError(error: string): Promise<any>;\r\n    advance(value?: number): Promise<any>;\r\n    save(): Promise<any>;\r\n    toJSON(): any;\r\n}\r\n\r\nexport interface IAssetCropInfo {\r\n    x: number;\r\n    y: number;\r\n    w: number;\r\n    h: number;\r\n}\r\n\r\nexport interface IAssetMeta {\r\n    filename?: string;\r\n    classified?: boolean;\r\n    downloadCount?: number;\r\n    firstDownload?: Date;\r\n    lastDownload?: Date;\r\n    crop?: IAssetCropInfo;\r\n    cropBefore?: IAssetCropInfo;\r\n    cropAfter?: IAssetCropInfo;\r\n    [prop: string]: any;\r\n}\r\n\r\nexport interface IAssetImageParams {\r\n    rotation?: number;\r\n    canvasScaleX?: number;\r\n    canvasScaleY?: number;\r\n    scaleX?: number;\r\n    scaleY?: number;\r\n    lazy?: boolean;\r\n    crop?: string | boolean;\r\n    cropBefore?: string | IAssetCropInfo;\r\n    cropAfter?: string | IAssetCropInfo;\r\n}\r\n\r\nexport interface IAsset {\r\n    id?: string;\r\n    filename?: string;\r\n    contentType?: string;\r\n    metadata?: IAssetMeta;\r\n    stream: Readable,\r\n    unlink(): Promise<string>;\r\n    getBuffer(): Promise<Buffer>;\r\n    download(metadata?: IAssetMeta): Promise<Readable>;\r\n    downloadImage(params?: IAssetImageParams, metadata?: IAssetMeta): Promise<Readable>;\r\n    getImage(params?: IAssetImageParams): Promise<Readable>;\r\n    toJSON(): any;\r\n}\r\n\r\nexport interface ILazyAsset {\r\n    id: string;\r\n    jobName: string;\r\n    jobParams: any;\r\n    jobQue: string;\r\n    progressId?: string;\r\n    assetId?: string;\r\n    unlink(): Promise<string>;\r\n    startWorking(): void;\r\n    loadAsset(): Promise<IAsset>;\r\n    writeAsset(asset: IAsset): Promise<IAsset>;\r\n    toJSON(): any;\r\n}\r\n\r\nexport interface IUser {\r\n    _id?: string;\r\n    id?: string;\r\n    email: string;\r\n    password: string;\r\n    roles: string[];\r\n}\r\n\r\nexport interface IClientSocket extends Socket {\r\n    interestedProgresses: Set<string>;\r\n}\r\n\r\nexport interface IRequestBase<T> extends Request {\r\n    id?: string;\r\n    started?: Moment;\r\n    ended?: Moment;\r\n    container?: DependencyContainer;\r\n    language?: string;\r\n    user?: T;\r\n}\r\n\r\nexport interface IRequest extends IRequestBase<IUser> {\r\n\r\n}\r\n\r\nexport interface IGalleryImage {\r\n    folder: string;\r\n    thumb: string;\r\n    big: string;\r\n    serve(id: string): Promise<Buffer>\r\n}\r\n\r\nexport interface IGallerySize {\r\n    width?: number;\r\n    height?: number;\r\n}\r\n\r\nexport interface IGalleryImageHandler {\r\n    getOriginal(): Promise<Buffer>;\r\n    writeResult(isThumb: boolean, buffer: Buffer): Promise<any>;\r\n    hasResult(isThumb: boolean): Promise<boolean>;\r\n    serveResult(isThumb: boolean): Promise<Buffer>;\r\n}\r\n\r\nexport interface ITranslations {\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IPaginationMeta {\r\n    total: number;\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IPaginationBase<T> {\r\n    count: number\r\n    items: T[];\r\n    meta?: IPaginationMeta;\r\n}\r\n\r\nexport interface IPagination extends IPaginationBase<any> {\r\n\r\n}\r\n\r\nexport interface IPaginationParams {\r\n    page: number;\r\n    limit: number;\r\n    sort?: string;\r\n    populate?: string[];\r\n    [key: string]: any;\r\n}\r\n\r\nexport type FontFormat = \"opentype\" | \"truetype\" | \"woff\" | \"woff2\" | \"datafork\";\r\n\r\nexport interface IBackendConfig {\r\n    rootFolder?: string;\r\n    routePrefix?: string;\r\n    params?: Parameter[];\r\n    fixtures?: Type<IFixture>[];\r\n    jobs?: Type<IJob>[];\r\n    restOptions?: RoutingControllersOptions;\r\n    socketOptions?: SocketControllersOptions;\r\n    customValidation?: SchemaConverter | SchemaObject;\r\n}\r\n"]}