@stemy/backend 6.0.3 → 6.1.0

package/commands/clear.command.d.ts

@@ -0,0 +1,6 @@
+import { ITerminal, ITerminalCommand } from "../common-types";
+import { ICommandArgs } from "@stemy/terminal-commands-addon";
+export declare class ClearCommand implements ITerminalCommand {
+    readonly name = "clear";
+    execute(args: ICommandArgs, terminal: ITerminal): Promise<any>;
+}

package/commands/fixtures.command.d.ts

@@ -0,0 +1,9 @@
+import { ICommandArgs } from "@stemy/terminal-commands-addon";
+import { ITerminal, ITerminalCommand } from "../common-types";
+import { Fixtures } from "../services/fixtures";
+export declare class FixturesCommand implements ITerminalCommand {
+    protected fixtures: Fixtures;
+    readonly name = "fixtures";
+    constructor(fixtures: Fixtures);
+    execute(args: ICommandArgs, terminal: ITerminal): Promise<any>;
+}

package/commands/move-assets.command.d.ts

@@ -0,0 +1,10 @@
+import { ICommandArgs, IProgressBar, ISuggestion } from "@stemy/terminal-commands-addon";
+import { ITerminal, ITerminalCommand } from "../common-types";
+import { Assets } from "../services/assets";
+export declare class MoveAssetsCommand implements ITerminalCommand {
+    protected assets: Assets;
+    readonly name = "move-assets";
+    constructor(assets: Assets);
+    execute(args: ICommandArgs, terminal: ITerminal, progress: IProgressBar): Promise<any>;
+    suggest?(args: ICommandArgs): Promise<Array<string | ISuggestion>>;
+}

package/common-types.d.ts

@@ -8,7 +8,7 @@ import { SchemaObject } from "openapi3-ts";
 import { Readable, Writable } from "stream";
 import { Moment } from "moment";
 import { AnyExpression, Expression } from "mongoose";
-import { ICommandArgs, ISuggestion, ITerminal as ITerminalBase } from "@stemy/terminal-commands-addon";
+import { ICommandArgs, IProgressBar, ISuggestion, ITerminal as ITerminalBase } from "@stemy/terminal-commands-addon";
 import { ObjectId } from "bson";
 export declare const Type: FunctionConstructor;
 export interface Type<T = object> extends Function {
@@ -75,8 +75,8 @@ export declare const SOCKET_CONTROLLERS: InjectionToken<SocketControllers>;
 export declare const PARAMETER: InjectionToken<Parameter>;
 export declare const DI_CONTAINER: InjectionToken<IDependencyContainer>;
 export declare const OPENAPI_VALIDATION: InjectionToken<OpenApiValidation>;
-export declare const LOCAL_DIR: InjectionToken<string>;
-export declare const ASSET_DRIVER: InjectionToken<IAssetDriver>;
+export declare const ASSET_LOCAL_DIR: InjectionToken<string>;
+export declare const ASSET_DRIVER_FACTORIES: InjectionToken<AssetDriverFactoryMap>;
 export interface IMatchField {
     field: string;
     filter: any;
@@ -134,12 +134,12 @@ export interface ITerminalFile extends ISuggestion {
     accept?: string;
 }
 export interface ITerminal extends ITerminalBase {
-    suggestFiles(accept: string): Promise<ITerminalFile[]>;
-    downloadFile(filename: string, buffer: Buffer): Promise<void>;
+    suggestFiles?(accept: string): Promise<ITerminalFile[]>;
+    downloadFile?(filename: string, buffer: Buffer): Promise<void>;
 }
 export interface ITerminalCommand {
     name?: string;
-    execute(args: ICommandArgs, terminal: ITerminal): Promise<any>;
+    execute(args: ICommandArgs, terminal: ITerminal, progress: IProgressBar): Promise<any>;
     suggest?(args: ICommandArgs, terminal: ITerminal): Promise<Array<string | ISuggestion>>;
 }
 export interface IProgress {
@@ -201,12 +201,15 @@ export interface IAssetImageParams {
 export interface IAsset {
     readonly id: string;
     readonly filename: string;
+    readonly streamId: ObjectId;
+    readonly driverId: string;
     readonly contentType: string;
     readonly metadata: IAssetMeta;
     readonly stream: Readable;
     unlink(): Promise<string>;
     setMeta(meta: Partial<IAssetMeta>): Promise<any>;
     getBuffer(): Promise<Buffer>;
+    move(driverId: string): Promise<IAsset>;
     download(metadata?: IAssetMeta): Promise<Readable>;
     downloadImage(params?: IAssetImageParams, metadata?: IAssetMeta): Promise<Readable>;
     getImage(params?: IAssetImageParams): Promise<Readable>;
@@ -221,13 +224,17 @@ export interface IAssetUploadStream extends Writable {
 export interface IAssetUploadOpts {
     chunkSizeBytes?: number;
     metadata?: IAssetMeta;
-    contentType?: string;
+    contentType: string;
+    extension: string;
 }
 export interface IAssetDriver {
-    readonly metaCollection: string;
-    openUploadStream(filename: string, opts?: IAssetUploadOpts): IAssetUploadStream;
-    openDownloadStream(id: ObjectId): Readable;
-    delete(id: ObjectId): Promise<void>;
+    openUploadStream(filename: string, opts: IAssetUploadOpts): IAssetUploadStream;
+    openDownloadStream(asset: IAsset): Readable;
+    delete(asset: IAsset): Promise<void>;
+}
+export interface IAssetDrivers {
+    readonly missingDriver: string;
+    getDriver(id: string): IAssetDriver;
 }
 export interface ILazyAsset {
     id: string;
@@ -246,6 +253,9 @@ export interface ILazyAsset {
     load(): Promise<this>;
     toJSON(): any;
 }
+export interface AssetDriverFactoryMap {
+    [name: string]: (di: IDependencyContainer) => IAssetDriver;
+}
 export interface IUser {
     _id?: string;
     id?: string;
@@ -321,5 +331,5 @@ export interface IBackendConfig {
     socketOptions?: SocketOptions;
     customValidation?: SchemaConverter | SchemaObject;
     assetLocalDir?: string;
-    assetDriver?: Type<IAssetDriver>;
+    assetDrivers?: AssetDriverFactoryMap;
 }

package/esm2022/commands/clear.command.mjs

@@ -0,0 +1,15 @@
+import { __decorate } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { AnsiCodes } from "@stemy/terminal-commands-addon";
+let ClearCommand = class ClearCommand {
+    name = "clear";
+    async execute(args, terminal) {
+        terminal.write(AnsiCodes.clear);
+    }
+};
+ClearCommand = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped)
+], ClearCommand);
+export { ClearCommand };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xlYXIuY29tbWFuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jb21tYW5kcy9jbGVhci5jb21tYW5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUMsTUFBTSxVQUFVLENBQUM7QUFFdkQsT0FBTyxFQUFDLFNBQVMsRUFBZSxNQUFNLGdDQUFnQyxDQUFDO0FBSWhFLElBQU0sWUFBWSxHQUFsQixNQUFNLFlBQVk7SUFFWixJQUFJLEdBQUcsT0FBTyxDQUFDO0lBRXhCLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBa0IsRUFBRSxRQUFtQjtRQUNqRCxRQUFRLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNwQyxDQUFDO0NBQ0osQ0FBQTtBQVBZLFlBQVk7SUFGeEIsVUFBVSxFQUFFO0lBQ1osTUFBTSxDQUFDLFNBQVMsQ0FBQyxlQUFlLENBQUM7R0FDckIsWUFBWSxDQU94QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7aW5qZWN0YWJsZSwgTGlmZWN5Y2xlLCBzY29wZWR9IGZyb20gXCJ0c3lyaW5nZVwiO1xyXG5pbXBvcnQge0lUZXJtaW5hbCwgSVRlcm1pbmFsQ29tbWFuZH0gZnJvbSBcIi4uL2NvbW1vbi10eXBlc1wiO1xyXG5pbXBvcnQge0Fuc2lDb2RlcywgSUNvbW1hbmRBcmdzfSBmcm9tIFwiQHN0ZW15L3Rlcm1pbmFsLWNvbW1hbmRzLWFkZG9uXCI7XHJcblxyXG5AaW5qZWN0YWJsZSgpXHJcbkBzY29wZWQoTGlmZWN5Y2xlLkNvbnRhaW5lclNjb3BlZClcclxuZXhwb3J0IGNsYXNzIENsZWFyQ29tbWFuZCBpbXBsZW1lbnRzIElUZXJtaW5hbENvbW1hbmQge1xyXG5cclxuICAgIHJlYWRvbmx5IG5hbWUgPSBcImNsZWFyXCI7XHJcblxyXG4gICAgYXN5bmMgZXhlY3V0ZShhcmdzOiBJQ29tbWFuZEFyZ3MsIHRlcm1pbmFsOiBJVGVybWluYWwpOiBQcm9taXNlPGFueT4ge1xyXG4gICAgICAgIHRlcm1pbmFsLndyaXRlKEFuc2lDb2Rlcy5jbGVhcik7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2022/commands/fixtures.command.mjs

@@ -0,0 +1,26 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { Fixtures } from "../services/fixtures";
+import { colorize, ConsoleColor } from "../utils";
+let FixturesCommand = class FixturesCommand {
+    fixtures;
+    name = "fixtures";
+    constructor(fixtures) {
+        this.fixtures = fixtures;
+    }
+    async execute(args, terminal) {
+        const output = {
+            write: text => terminal.writeln(text),
+            writeln: text => terminal.writeln(text)
+        };
+        await this.fixtures.load(output);
+        terminal.writeln(colorize(`Fixtures loaded`, ConsoleColor.FgGreen));
+    }
+};
+FixturesCommand = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Fixtures])
+], FixturesCommand);
+export { FixturesCommand };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/commands/index.mjs

@@ -1,7 +1,9 @@
-import { ClearCommand } from "./clear-command";
-import { FixturesCommand } from "./fixtures-command";
+import { ClearCommand } from "./clear.command";
+import { FixturesCommand } from "./fixtures.command";
+import { MoveAssetsCommand } from "./move-assets.command";
 export const commands = [
     ClearCommand,
-    FixturesCommand
+    FixturesCommand,
+    MoveAssetsCommand
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29tbWFuZHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBRTdDLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUVuRCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQTZCO0lBQzlDLFlBQVk7SUFDWixlQUFlO0NBQ2xCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NsZWFyQ29tbWFuZH0gZnJvbSBcIi4vY2xlYXItY29tbWFuZFwiO1xyXG5pbXBvcnQge0lUZXJtaW5hbENvbW1hbmQsIFR5cGV9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuaW1wb3J0IHtGaXh0dXJlc0NvbW1hbmR9IGZyb20gXCIuL2ZpeHR1cmVzLWNvbW1hbmRcIjtcclxuXHJcbmV4cG9ydCBjb25zdCBjb21tYW5kczogVHlwZTxJVGVybWluYWxDb21tYW5kPltdID0gW1xyXG4gICAgQ2xlYXJDb21tYW5kLFxyXG4gICAgRml4dHVyZXNDb21tYW5kXHJcbl07XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29tbWFuZHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBRTdDLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUNuRCxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQztBQUV4RCxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQTZCO0lBQzlDLFlBQVk7SUFDWixlQUFlO0lBQ2YsaUJBQWlCO0NBQ3BCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NsZWFyQ29tbWFuZH0gZnJvbSBcIi4vY2xlYXIuY29tbWFuZFwiO1xyXG5pbXBvcnQge0lUZXJtaW5hbENvbW1hbmQsIFR5cGV9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuaW1wb3J0IHtGaXh0dXJlc0NvbW1hbmR9IGZyb20gXCIuL2ZpeHR1cmVzLmNvbW1hbmRcIjtcclxuaW1wb3J0IHtNb3ZlQXNzZXRzQ29tbWFuZH0gZnJvbSBcIi4vbW92ZS1hc3NldHMuY29tbWFuZFwiO1xyXG5cclxuZXhwb3J0IGNvbnN0IGNvbW1hbmRzOiBUeXBlPElUZXJtaW5hbENvbW1hbmQ+W10gPSBbXHJcbiAgICBDbGVhckNvbW1hbmQsXHJcbiAgICBGaXh0dXJlc0NvbW1hbmQsXHJcbiAgICBNb3ZlQXNzZXRzQ29tbWFuZFxyXG5dO1xyXG4iXX0=

package/esm2022/commands/move-assets.command.mjs

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from "tslib";
+import { injectable, Lifecycle, scoped } from "tsyringe";
+import { Assets } from "../services/assets";
+import { colorize, ConsoleColor, promiseTimeout, regexEscape } from "../utils";
+let MoveAssetsCommand = class MoveAssetsCommand {
+    assets;
+    name = "move-assets";
+    constructor(assets) {
+        this.assets = assets;
+    }
+    async execute(args, terminal, progress) {
+        await promiseTimeout(1000);
+        const from = `${args.at(1).id}`;
+        const to = `${args.at(2).id}`;
+        const assets = await this.assets.findMany(from === this.assets.missingDriver ? {
+            $or: [
+                { driverId: from },
+                { driverId: { "$exists": false } }
+            ]
+        } : { driverId: from });
+        progress.setMax(assets.length);
+        for (const asset of assets) {
+            await asset.move(to);
+            progress.advance();
+        }
+        terminal.writeln(colorize(`Assets successfully moved to: ${to}`, ConsoleColor.FgGreen));
+    }
+    async suggest(args) {
+        if (args.length > 3) {
+            return null;
+        }
+        // Replace regex special characters
+        const prev = args.length === 3 ? args.at(1) : null;
+        const id = regexEscape(args.search);
+        const regex = new RegExp(id, "g");
+        return this.assets.drivers.filter(d => d.match(regex) && (!prev || d !== prev.id));
+    }
+};
+MoveAssetsCommand = __decorate([
+    injectable(),
+    scoped(Lifecycle.ContainerScoped),
+    __metadata("design:paramtypes", [Assets])
+], MoveAssetsCommand);
+export { MoveAssetsCommand };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common-types.mjs

@@ -11,8 +11,8 @@ export const SOCKET_CONTROLLERS = Symbol.for("socket-controllers-token");
 export const PARAMETER = Symbol.for("parameter-token");
 export const DI_CONTAINER = Symbol.for("di-container-token");
 export const OPENAPI_VALIDATION = Symbol.for("openapi-validation-token");
-export const LOCAL_DIR = Symbol.for('asset-local-dir');
-export const ASSET_DRIVER = Symbol.for('assets-driver');
+export const ASSET_LOCAL_DIR = Symbol.for('asset-local-dir');
+export const ASSET_DRIVER_FACTORIES = Symbol.for('assets-driver-factories');
 export class Parameter {
     name;
     defaultValue;
@@ -23,4 +23,4 @@ export class Parameter {
         this.resolver = resolver;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../../src/common-types.ts"],"names":[],"mappings":"AAoBA,uBAAuB;AAEvB,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAC;AA0E7B,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,gBAAgB,GAAqC,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;AAEvG,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,kBAAkB,GAAsC,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAE5G,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,CAAC,MAAM,kBAAkB,GAAsC,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAE5G,MAAM,CAAC,MAAM,SAAS,GAA2B,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;AAE/E,MAAM,CAAC,MAAM,YAAY,GAAiC,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;AAiCtF,MAAM,OAAO,SAAS;IAEG;IAAqB;IAA0B;IAApE,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 {SocketControllers, 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 {Readable, Writable} from \"stream\";\r\nimport {Moment} from \"moment\";\r\nimport {AnyExpression, Expression} from \"mongoose\";\r\nimport {ICommandArgs, ISuggestion, ITerminal as ITerminalBase} from \"@stemy/terminal-commands-addon\";\r\nimport {ObjectId} from \"bson\";\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 {\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    resolve<T>(token: InjectionToken<T>): T;\r\n    resolveAll<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// --- Useful generic types ---\r\n\r\nexport type Constructor<T = object> = new (...args: any[]) => T\r\n\r\nexport type InferGeneric<T> = T extends Type<infer B> ? B : never;\r\n\r\nexport type PickMatching<T, V> = { [K in keyof T as T[K] extends V ? K : never]: T[K] }\r\n\r\nexport type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;\r\n\r\n// --- OpenApi ---\r\n\r\nexport type SchemaConverter = (meta: any, options: any) => SchemaObject;\r\n\r\nexport type OpenApiValidation = SchemaConverter | SchemaObject;\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 TERMINAL_COMMAND: InjectionToken<ITerminalCommand> = Symbol.for(\"terminal-command-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 SOCKET_CONTROLLERS: InjectionToken<SocketControllers> = Symbol.for(\"socket-controllers-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\nexport const OPENAPI_VALIDATION: InjectionToken<OpenApiValidation> = Symbol.for(\"openapi-validation-token\");\r\n\r\nexport const LOCAL_DIR: InjectionToken<string> = Symbol.for('asset-local-dir');\r\n\r\nexport const ASSET_DRIVER: InjectionToken<IAssetDriver> = Symbol.for('assets-driver');\r\n\r\n// --- Mongo interfaces and types\r\n\r\nexport interface IMatchField {\r\n    field: string;\r\n    filter: any;\r\n    when: boolean;\r\n}\r\n\r\nexport interface IProjectOptions {\r\n    [field: string]: AnyExpression | Expression | IProjectOptions;\r\n}\r\n\r\nexport interface IUnwindOptions {\r\n    path: string;\r\n    includeArrayIndex?: string;\r\n    preserveNullAndEmptyArrays?: boolean;\r\n}\r\n\r\n// --- Interfaces and utility classes ---\r\n\r\nexport interface IFixture {\r\n    load(output?: IFixtureOutput): Promise<any>;\r\n}\r\n\r\nexport interface IFixtureOutput {\r\n    write(message: string): void;\r\n    writeln(message: string): void;\r\n}\r\n\r\nexport type ParamResolver = (value: string, helper?: (param: string) => any) => 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 type SocketParam = string | number | boolean | SocketParams;\r\n\r\nexport type SocketParams = {\r\n    [name: string]: SocketParam | Array<SocketParam>;\r\n};\r\n\r\nexport type JobParams = SocketParams;\r\n\r\nexport interface ISocketMessage {\r\n    message: string;\r\n    params: SocketParams;\r\n}\r\n\r\nexport interface IMessageBridge {\r\n    sendMessage(message: string, params?: SocketParams): void;\r\n}\r\n\r\n// --- JOBS ---\r\n\r\nexport interface IJob {\r\n    process(messaging?: IMessageBridge): Promise<any>;\r\n}\r\n\r\nexport interface IJobTask {\r\n    start: () => void;\r\n    stop: () => void;\r\n}\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\n// --- COMMANDS & TERMINAL ---\r\n\r\nexport interface ITerminalFile extends ISuggestion {\r\n    content?: string;\r\n    buffer?: Buffer;\r\n    accept?: string;\r\n}\r\n\r\nexport interface ITerminal extends ITerminalBase {\r\n    suggestFiles(accept: string): Promise<ITerminalFile[]>;\r\n    downloadFile(filename: string, buffer: Buffer): Promise<void>;\r\n}\r\n\r\nexport interface ITerminalCommand {\r\n    name?: string;\r\n    execute(args: ICommandArgs, terminal: ITerminal): Promise<any>;\r\n    suggest?(args: ICommandArgs, terminal: ITerminal): Promise<Array<string | ISuggestion>>;\r\n}\r\n\r\n// --- ASSETS ---\r\n\r\nexport interface IProgress {\r\n    id: string;\r\n    current: number;\r\n    max: number;\r\n    message: string;\r\n    error: string;\r\n    canceled: boolean;\r\n    percent: number;\r\n    remaining: number;\r\n    setMessageBridge(messageBridge: IMessageBridge): this;\r\n    createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress>;\r\n    setMax(max: number): Promise<any>;\r\n    setMessage(message: string): Promise<any>;\r\n    setError(error: string): Promise<any>;\r\n    advance(value?: number): Promise<any>;\r\n    cancel(): Promise<any>;\r\n    save(): Promise<any>;\r\n    load(): Promise<this>;\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 IImageMeta {\r\n    crop?: IAssetCropInfo;\r\n    cropBefore?: IAssetCropInfo;\r\n    cropAfter?: IAssetCropInfo;\r\n    canvasScaleX?: number;\r\n    canvasScaleY?: number;\r\n}\r\n\r\nexport interface IAssetMeta extends IImageMeta {\r\n    filename?: string;\r\n    extension?: string;\r\n    classified?: boolean;\r\n    downloadCount?: number;\r\n    firstDownload?: Date;\r\n    lastDownload?: Date;\r\n    preview?: ObjectId | string;\r\n    publicUrl?: string;\r\n\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 | boolean | IAssetCropInfo;\r\n    cropAfter?: string | boolean | IAssetCropInfo;\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IAsset {\r\n    readonly id: string;\r\n    readonly filename: string;\r\n    readonly contentType: string;\r\n    readonly metadata: IAssetMeta;\r\n    readonly stream: Readable;\r\n    unlink(): Promise<string>;\r\n    setMeta(meta: Partial<IAssetMeta>): Promise<any>;\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    save(): Promise<any>;\r\n    load(): Promise<this>;\r\n    toJSON(): any;\r\n}\r\n\r\nexport interface IAssetUploadStream extends Writable {\r\n    id?: ObjectId;\r\n    done?: boolean;\r\n}\r\n\r\nexport interface IAssetUploadOpts {\r\n    chunkSizeBytes?: number;\r\n    metadata?: IAssetMeta;\r\n    contentType?: string;\r\n}\r\n\r\nexport interface IAssetDriver {\r\n    readonly metaCollection: string;\r\n    openUploadStream(filename: string, opts?: IAssetUploadOpts): IAssetUploadStream;\r\n    openDownloadStream(id: ObjectId): Readable;\r\n    delete(id: ObjectId): Promise<void>;\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    createdAt: Date;\r\n    updatedAt: Date;\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    save(): Promise<any>;\r\n    load(): Promise<this>;\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<void>;\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 IFileType {\r\n    ext: string;\r\n    mime: string;\r\n}\r\n\r\nexport type RoutingOptions = RoutingControllersOptions;\r\n\r\nexport type SocketOptions = Omit<SocketControllersOptions, \"container\">;\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    commands?: Type<ITerminalCommand>[];\r\n    restOptions?: RoutingOptions;\r\n    socketOptions?: SocketOptions;\r\n    customValidation?: SchemaConverter | SchemaObject;\r\n    assetLocalDir?: string;\r\n    assetDriver?: Type<IAssetDriver>;\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../../src/common-types.ts"],"names":[],"mappings":"AAoBA,uBAAuB;AAEvB,MAAM,CAAC,MAAM,IAAI,GAAG,QAAQ,CAAC;AA0E7B,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,gBAAgB,GAAqC,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;AAEvG,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,kBAAkB,GAAsC,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAE5G,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,CAAC,MAAM,kBAAkB,GAAsC,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAE5G,MAAM,CAAC,MAAM,eAAe,GAA2B,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;AAErF,MAAM,CAAC,MAAM,sBAAsB,GAA0C,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;AAiCnH,MAAM,OAAO,SAAS;IAEG;IAAqB;IAA0B;IAApE,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 {SocketControllers, 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 {Readable, Writable} from \"stream\";\r\nimport {Moment} from \"moment\";\r\nimport {AnyExpression, Expression} from \"mongoose\";\r\nimport {ICommandArgs, IProgressBar, ISuggestion, ITerminal as ITerminalBase} from \"@stemy/terminal-commands-addon\";\r\nimport {ObjectId} from \"bson\";\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 {\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    resolve<T>(token: InjectionToken<T>): T;\r\n    resolveAll<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// --- Useful generic types ---\r\n\r\nexport type Constructor<T = object> = new (...args: any[]) => T\r\n\r\nexport type InferGeneric<T> = T extends Type<infer B> ? B : never;\r\n\r\nexport type PickMatching<T, V> = { [K in keyof T as T[K] extends V ? K : never]: T[K] }\r\n\r\nexport type OmitFirstArg<F> = F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never;\r\n\r\n// --- OpenApi ---\r\n\r\nexport type SchemaConverter = (meta: any, options: any) => SchemaObject;\r\n\r\nexport type OpenApiValidation = SchemaConverter | SchemaObject;\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 TERMINAL_COMMAND: InjectionToken<ITerminalCommand> = Symbol.for(\"terminal-command-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 SOCKET_CONTROLLERS: InjectionToken<SocketControllers> = Symbol.for(\"socket-controllers-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\nexport const OPENAPI_VALIDATION: InjectionToken<OpenApiValidation> = Symbol.for(\"openapi-validation-token\");\r\n\r\nexport const ASSET_LOCAL_DIR: InjectionToken<string> = Symbol.for('asset-local-dir');\r\n\r\nexport const ASSET_DRIVER_FACTORIES: InjectionToken<AssetDriverFactoryMap> = Symbol.for('assets-driver-factories');\r\n\r\n// --- Mongo interfaces and types\r\n\r\nexport interface IMatchField {\r\n    field: string;\r\n    filter: any;\r\n    when: boolean;\r\n}\r\n\r\nexport interface IProjectOptions {\r\n    [field: string]: AnyExpression | Expression | IProjectOptions;\r\n}\r\n\r\nexport interface IUnwindOptions {\r\n    path: string;\r\n    includeArrayIndex?: string;\r\n    preserveNullAndEmptyArrays?: boolean;\r\n}\r\n\r\n// --- Interfaces and utility classes ---\r\n\r\nexport interface IFixture {\r\n    load(output?: IFixtureOutput): Promise<any>;\r\n}\r\n\r\nexport interface IFixtureOutput {\r\n    write(message: string): void;\r\n    writeln(message: string): void;\r\n}\r\n\r\nexport type ParamResolver = (value: string, helper?: (param: string) => any) => 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 type SocketParam = string | number | boolean | SocketParams;\r\n\r\nexport type SocketParams = {\r\n    [name: string]: SocketParam | Array<SocketParam>;\r\n};\r\n\r\nexport type JobParams = SocketParams;\r\n\r\nexport interface ISocketMessage {\r\n    message: string;\r\n    params: SocketParams;\r\n}\r\n\r\nexport interface IMessageBridge {\r\n    sendMessage(message: string, params?: SocketParams): void;\r\n}\r\n\r\n// --- JOBS ---\r\n\r\nexport interface IJob {\r\n    process(messaging?: IMessageBridge): Promise<any>;\r\n}\r\n\r\nexport interface IJobTask {\r\n    start: () => void;\r\n    stop: () => void;\r\n}\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\n// --- COMMANDS & TERMINAL ---\r\n\r\nexport interface ITerminalFile extends ISuggestion {\r\n    content?: string;\r\n    buffer?: Buffer;\r\n    accept?: string;\r\n}\r\n\r\nexport interface ITerminal extends ITerminalBase {\r\n    suggestFiles?(accept: string): Promise<ITerminalFile[]>;\r\n    downloadFile?(filename: string, buffer: Buffer): Promise<void>;\r\n}\r\n\r\nexport interface ITerminalCommand {\r\n    name?: string;\r\n    execute(args: ICommandArgs, terminal: ITerminal, progress: IProgressBar): Promise<any>;\r\n    suggest?(args: ICommandArgs, terminal: ITerminal): Promise<Array<string | ISuggestion>>;\r\n}\r\n\r\n// --- ASSETS ---\r\n\r\nexport interface IProgress {\r\n    id: string;\r\n    current: number;\r\n    max: number;\r\n    message: string;\r\n    error: string;\r\n    canceled: boolean;\r\n    percent: number;\r\n    remaining: number;\r\n    setMessageBridge(messageBridge: IMessageBridge): this;\r\n    createSubProgress(progressValue: number, max?: number, message?: string): Promise<IProgress>;\r\n    setMax(max: number): Promise<any>;\r\n    setMessage(message: string): Promise<any>;\r\n    setError(error: string): Promise<any>;\r\n    advance(value?: number): Promise<any>;\r\n    cancel(): Promise<any>;\r\n    save(): Promise<any>;\r\n    load(): Promise<this>;\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 IImageMeta {\r\n    crop?: IAssetCropInfo;\r\n    cropBefore?: IAssetCropInfo;\r\n    cropAfter?: IAssetCropInfo;\r\n    canvasScaleX?: number;\r\n    canvasScaleY?: number;\r\n}\r\n\r\nexport interface IAssetMeta extends IImageMeta {\r\n    filename?: string;\r\n    extension?: string;\r\n    classified?: boolean;\r\n    downloadCount?: number;\r\n    firstDownload?: Date;\r\n    lastDownload?: Date;\r\n    preview?: ObjectId | string;\r\n    publicUrl?: string;\r\n\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 | boolean | IAssetCropInfo;\r\n    cropAfter?: string | boolean | IAssetCropInfo;\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IAsset {\r\n    readonly id: string;\r\n    readonly filename: string;\r\n    readonly streamId: ObjectId;\r\n    readonly driverId: string;\r\n    readonly contentType: string;\r\n    readonly metadata: IAssetMeta;\r\n    readonly stream: Readable;\r\n    unlink(): Promise<string>;\r\n    setMeta(meta: Partial<IAssetMeta>): Promise<any>;\r\n    getBuffer(): Promise<Buffer>;\r\n    move(driverId: string): Promise<IAsset>;\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    save(): Promise<any>;\r\n    load(): Promise<this>;\r\n    toJSON(): any;\r\n}\r\n\r\nexport interface IAssetUploadStream extends Writable {\r\n    id?: ObjectId;\r\n    done?: boolean;\r\n}\r\n\r\nexport interface IAssetUploadOpts {\r\n    chunkSizeBytes?: number;\r\n    metadata?: IAssetMeta;\r\n    contentType: string;\r\n    extension: string;\r\n}\r\n\r\nexport interface IAssetDriver {\r\n    openUploadStream(filename: string, opts: IAssetUploadOpts): IAssetUploadStream;\r\n    openDownloadStream(asset: IAsset): Readable;\r\n    delete(asset: IAsset): Promise<void>;\r\n}\r\n\r\nexport interface IAssetDrivers {\r\n    readonly missingDriver: string;\r\n    getDriver(id: string): IAssetDriver;\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    createdAt: Date;\r\n    updatedAt: Date;\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    save(): Promise<any>;\r\n    load(): Promise<this>;\r\n    toJSON(): any;\r\n}\r\n\r\nexport interface AssetDriverFactoryMap {\r\n    [name: string]: (di: IDependencyContainer) => IAssetDriver;\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<void>;\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 IFileType {\r\n    ext: string;\r\n    mime: string;\r\n}\r\n\r\nexport type RoutingOptions = RoutingControllersOptions;\r\n\r\nexport type SocketOptions = Omit<SocketControllersOptions, \"container\">;\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    commands?: Type<ITerminalCommand>[];\r\n    restOptions?: RoutingOptions;\r\n    socketOptions?: SocketOptions;\r\n    customValidation?: SchemaConverter | SchemaObject;\r\n    assetLocalDir?: string;\r\n    assetDrivers?: AssetDriverFactoryMap;\r\n}\r\n"]}