@stemy/backend 6.0.4 → 6.1.0

package/fesm2022/stemy-backend.mjs

@@ -8,14 +8,14 @@ import { create } from 'fontkit';
 import sharp_ from 'sharp';
 import { ObjectId as ObjectId$1 } from 'bson';
 import axios from 'axios';
-import { mkdir, unlink, readFile as readFile$1, writeFile as writeFile$1, lstat, readdir, access, constants, lstatSync, readFileSync, existsSync, mkdirSync, createWriteStream, createReadStream } from 'fs';
+import { mkdir, unlink, readFile as readFile$1, writeFile as writeFile$1, lstat, readdir, access, constants, lstatSync, readFileSync, existsSync, mkdirSync, createWriteStream, writeFileSync, createReadStream } from 'fs';
 import { gzip, gunzip } from 'zlib';
 import { fileURLToPath } from 'url';
 import { exec } from 'child_process';
 import { createHash } from 'crypto';
 import { Subscription, Observable, Subject, from, BehaviorSubject } from 'rxjs';
 import { ObjectId } from 'mongodb';
-import mongoose, { Types } from 'mongoose';
+import mongoose from 'mongoose';
 import { Readable, PassThrough } from 'stream';
 import fileType from 'file-type/core';
 import dotenv from 'dotenv';
@@ -31,14 +31,15 @@ import { routingControllersToSpec, OpenAPI, getStatusCode } from 'routing-contro
 import { defaultMetadataStorage } from 'class-transformer/cjs/storage';
 import { validationMetadatasToSchemas } from 'class-validator-jsonschema';
 import { ValidatorConstraint, ValidationTypes, Min, Max, IsOptional, IsBoolean } from 'class-validator';
+import { CommandsAddon, AnsiCodes } from '@stemy/terminal-commands-addon';
+import * as readline from 'readline';
 import { v4 } from 'uuid';
 import { createTransport } from 'nodemailer';
 import * as Handlebars from 'handlebars';
-import { CommandsAddon, AnsiCodes } from '@stemy/terminal-commands-addon';
 import { compare } from 'bcrypt';
 import moment from 'moment';
 import { GridFSBucket } from 'mongodb/lib/gridfs';
-import { writeFile as writeFile$2, rm } from 'fs/promises';
+import { rm } from 'fs/promises';
 import got from 'got';
 import { getModelForClass } from '@typegoose/typegoose';
 import { getValue as getValue$1, setValue } from 'mongoose/lib/utils';
@@ -56,10 +57,8 @@ const SOCKET_CONTROLLERS = Symbol.for("socket-controllers-token");
 const PARAMETER = Symbol.for("parameter-token");
 const DI_CONTAINER = Symbol.for("di-container-token");
 const OPENAPI_VALIDATION = Symbol.for("openapi-validation-token");
-const LOCAL_DIR = Symbol.for('asset-local-dir');
-const ASSET_DRIVER = Symbol.for('assets-driver');
-const ASSET_MAIN_DRIVER = Symbol.for('assets-main-driver');
-const ASSET_FALLBACK_DRIVER = Symbol.for('assets-fallback-driver');
+const ASSET_LOCAL_DIR = Symbol.for('asset-local-dir');
+const ASSET_DRIVER_FACTORIES = Symbol.for('assets-driver-factories');
 class Parameter {
     name;
     defaultValue;
@@ -867,10 +866,12 @@ async function fileTypeFromBuffer(buffer) {
 }
 
 let Configuration = class Configuration {
+    isCli;
     paramMap;
     paramValues;
     constructor(params) {
         dotenv.config();
+        this.isCli = process.env.IS_CLI === 'true';
         this.paramMap = {};
         this.paramValues = {};
         (params || []).forEach(param => this.add(param));
@@ -891,15 +892,15 @@ let Configuration = class Configuration {
             const value = isFunction(param.resolver)
                 ? param.resolver(envValue, helper)
                 : convertValue(envValue, getType(param.defaultValue));
-            console.log(colorize(`Processing param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), colorize(envName, ConsoleColor.FgBlue), `"${envValue}"`, value);
+            this.log(colorize(`Processing param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), colorize(envName, ConsoleColor.FgBlue), `"${envValue}"`, value);
             return value;
         }
         else if (isFunction(param.resolver)) {
             const value = param.resolver(param.defaultValue, helper);
-            console.log(colorize(`Processing default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue, value);
+            this.log(colorize(`Processing default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue, value);
             return value;
         }
-        console.log(colorize(`Using default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue);
+        this.log(colorize(`Using default param value`, ConsoleColor.FgYellow), colorize(param.name, ConsoleColor.FgGreen), param.defaultValue);
         return param.defaultValue;
     }
     hasParam(name) {
@@ -921,6 +922,11 @@ let Configuration = class Configuration {
         }
         return this.paramValues[name];
     }
+    log(...args) {
+        if (this.isCli)
+            return;
+        console.log(...args);
+    }
 };
 Configuration = __decorate([
     singleton(),
@@ -992,10 +998,19 @@ class BaseEntity {
 }
 
 class Asset extends BaseEntity {
-    driver;
+    drivers;
     get filename() {
         return this.data.filename;
     }
+    get streamId() {
+        return this.data.streamId || this.oid;
+    }
+    get driverId() {
+        return this.data.driverId;
+    }
+    get driver() {
+        return this.drivers.getDriver(this.driverId || this.drivers.missingDriver);
+    }
     get contentType() {
         return this.data.contentType;
     }
@@ -1003,15 +1018,15 @@ class Asset extends BaseEntity {
         return this.data.metadata;
     }
     get stream() {
-        return this.driver.openDownloadStream(this.oid);
+        return this.driver.openDownloadStream(this);
     }
-    constructor(id, data, collection, driver) {
+    constructor(id, data, collection, drivers) {
         super(id, data, collection);
-        this.driver = driver;
+        this.drivers = drivers;
     }
     async unlink() {
         try {
-            await this.driver.delete(this.oid);
+            await this.driver.delete(this);
         }
         catch (error) {
             console.log("Failed to unlink", error?.message);
@@ -1026,6 +1041,38 @@ class Asset extends BaseEntity {
     getBuffer() {
         return streamToBuffer(this.stream);
     }
+    async move(driverId) {
+        const oldDriver = this.driver;
+        const targetDriver = this.drivers.getDriver(driverId);
+        if (targetDriver === oldDriver)
+            return this;
+        const oldAsset = new Asset(this.oid, this.data, this.collection, this.drivers);
+        const streamId = await this.uploadTo(targetDriver);
+        this.data = {
+            ...this.data,
+            streamId,
+            driverId,
+        };
+        await this.save();
+        await oldDriver.delete(oldAsset);
+    }
+    uploadTo(driver) {
+        return new Promise((resolve, reject) => {
+            const uploaderStream = driver.openUploadStream(this.filename, {
+                chunkSizeBytes: 1048576,
+                contentType: this.contentType,
+                extension: this.metadata.extension,
+                metadata: this.metadata,
+            });
+            this.stream.pipe(uploaderStream)
+                .on("error", error => {
+                reject(error.message || error);
+            })
+                .on("finish", async () => {
+                resolve(uploaderStream.id);
+            });
+        });
+    }
     async download(metadata) {
         metadata = Object.assign(this.metadata, metadata || {});
         metadata.downloadCount = isNaN(metadata.downloadCount) || !metadata.firstDownload
@@ -1049,16 +1096,25 @@ class TempAsset {
     filename;
     contentType;
     metadata;
-    id;
+    get id() {
+        return this.oid.toHexString();
+    }
+    get streamId() {
+        return this.oid;
+    }
+    get driverId() {
+        return "temp";
+    }
     get stream() {
         return bufferToStream(this.buffer);
     }
+    oid;
     constructor(buffer, filename, contentType, metadata) {
         this.buffer = buffer;
         this.filename = filename;
         this.contentType = contentType;
         this.metadata = metadata;
-        this.id = new ObjectId$1().toHexString();
+        this.oid = new ObjectId$1();
     }
     async unlink() {
         throw new Error(`Temp asset '${this.id}' can not be removed!`);
@@ -1069,6 +1125,9 @@ class TempAsset {
     async getBuffer() {
         return this.buffer;
     }
+    async move() {
+        throw new Error(`Temp asset '${this.id}' can not be moved!`);
+    }
     async download(metadata) {
         return this.stream;
     }
@@ -1098,13 +1157,38 @@ class TempAsset {
 let Assets = class Assets {
     connector;
     assetProcessor;
-    driver;
+    config;
+    container;
+    driverFactoryMap;
     collection;
-    constructor(connector, assetProcessor, driver) {
+    driverMap;
+    mainDriver;
+    missingDriver;
+    drivers;
+    constructor(connector, assetProcessor, config, container, driverFactoryMap) {
         this.connector = connector;
         this.assetProcessor = assetProcessor;
-        this.driver = driver;
+        this.config = config;
+        this.container = container;
+        this.driverFactoryMap = driverFactoryMap;
         this.collection = connector.database?.collection("assets.metadata");
+        this.driverMap = new Map();
+        this.mainDriver = this.config.resolve("assetsMainDriver");
+        this.missingDriver = this.config.resolve("assetsMissingDriver");
+        this.drivers = Object.keys(driverFactoryMap);
+    }
+    getDriver(name) {
+        if (!name) {
+            throw new Error(`No name provider for asset driver!`);
+        }
+        if (!this.driverMap.has(name)) {
+            const factory = this.driverFactoryMap[name];
+            if (!factory) {
+                throw new Error(`No asset driver factory found with name: '${name}'!`);
+            }
+            this.driverMap.set(name, factory(this.container));
+        }
+        return this.driverMap.get(name);
     }
     async write(stream, contentType = null, metadata = null) {
         const uploadStream = copyStream(stream);
@@ -1173,7 +1257,7 @@ let Assets = class Assets {
     }
     async find(where) {
         const data = await this.collection.findOne(where);
-        return !data ? null : new Asset(data._id, data, this.collection, this.driver);
+        return !data ? null : new Asset(data._id, data, this.collection, this);
     }
     async findMany(where) {
         const cursor = this.collection.find(where);
@@ -1182,7 +1266,7 @@ let Assets = class Assets {
         for (let item of items) {
             if (!item)
                 continue;
-            result.push(new Asset(item._id, item, this.collection, this.driver));
+            result.push(new Asset(item._id, item, this.collection, this));
         }
         return result;
     }
@@ -1206,10 +1290,13 @@ let Assets = class Assets {
         metadata.filename = metadata.filename || new ObjectId$1().toHexString();
         metadata.extension = (fileType.ext || "").trim();
         return new Promise(((resolve, reject) => {
-            const uploaderStream = this.driver.openUploadStream(metadata.filename, {
+            const driverId = this.mainDriver;
+            const driver = this.getDriver(driverId);
+            const uploaderStream = driver.openUploadStream(metadata.filename, {
                 chunkSizeBytes: 1048576,
+                contentType: fileType.mime,
+                extension: fileType.ext,
                 metadata,
-                contentType: fileType.mime
             });
             stream.pipe(uploaderStream)
                 .on("error", error => {
@@ -1217,10 +1304,12 @@ let Assets = class Assets {
             })
                 .on("finish", () => {
                 const asset = new Asset(uploaderStream.id, {
+                    streamId: uploaderStream.id,
                     filename: metadata.filename,
                     contentType,
-                    metadata
-                }, this.collection, this.driver);
+                    metadata,
+                    driverId
+                }, this.collection, this);
                 asset.save().then(() => {
                     resolve(asset);
                 }, error => {
@@ -1233,9 +1322,11 @@ let Assets = class Assets {
 Assets = __decorate([
     injectable(),
     scoped(Lifecycle.ContainerScoped),
-    __param(2, inject(ASSET_DRIVER)),
+    __param(3, inject(DI_CONTAINER)),
+    __param(4, inject(ASSET_DRIVER_FACTORIES)),
     __metadata("design:paramtypes", [MongoConnector,
-        AssetProcessor, Object])
+        AssetProcessor,
+        Configuration, Object, Object])
 ], Assets);
 
 class LazyAsset extends BaseEntity {
@@ -2083,6 +2174,154 @@ Fixtures = __decorate([
     __metadata("design:paramtypes", [Object])
 ], Fixtures);
 
+class CliTerminal {
+    callbacks = new Set();
+    stdin = process.stdin;
+    constructor() {
+        // Set stdin to raw mode to get character-by-character data
+        if (this.stdin.isTTY) {
+            this.stdin.setRawMode(true);
+        }
+        this.clearScreen();
+        this.stdin.setEncoding('utf8');
+        this.stdin.on('data', this.handleInput);
+    }
+    clearScreen() {
+        readline.cursorTo(process.stdout, 0, 0);
+        readline.clearScreenDown(process.stdout);
+    }
+    handleInput = (data) => {
+        const input = data.toString();
+        // Standard "Ctrl+C" exit handling
+        if (input === '\u0003') {
+            this.clearScreen();
+            this.dispose();
+        }
+        this.callbacks.forEach((cb) => cb(input));
+    };
+    /**
+     * Registers a listener for data input.
+     * Returns an IDisposable to unregister the listener.
+     */
+    onData(cb) {
+        this.callbacks.add(cb);
+        return {
+            dispose: () => this.callbacks.delete(cb),
+        };
+    }
+    write(data) {
+        process.stdout.write(data);
+    }
+    writeln(data) {
+        process.stdout.write(data + '\n');
+    }
+    loadAddon(addon) {
+        addon.activate(this);
+    }
+    dispose() {
+        if (this.stdin.isTTY) {
+            this.stdin.setRawMode(false);
+        }
+        this.stdin.removeListener('data', this.handleInput);
+        this.stdin.pause();
+        this.callbacks.clear();
+        process.exit();
+    }
+}
+
+let TerminalManager = class TerminalManager {
+    logger;
+    config;
+    cliTerminal;
+    servicePassword;
+    suggestions;
+    commands;
+    loggedOutCommands;
+    loggedInCommands;
+    constructor(logger, config, commands) {
+        this.logger = logger;
+        this.config = config;
+        this.servicePassword = config.resolve("servicePassword");
+        this.suggestions = {
+            login: async (args) => {
+                if (args.length > 2) {
+                    return null;
+                }
+                const input = `${args.at(1).label}`;
+                return (!input) ? [] : [{
+                        id: input,
+                        label: input,
+                        masked: true
+                    }];
+            },
+            ...commands.reduce((acc, command) => {
+                command.name = camelCaseToDash(command.name || command.constructor.name || "");
+                if (!command.name || !command.suggest)
+                    return acc;
+                acc[command.name] = async (a, t) => command.suggest(a, t);
+                return acc;
+            }, {})
+        };
+        this.commands = commands.reduce((acc, command) => {
+            if (!command.name)
+                return acc;
+            acc[command.name] = async (a, t, p) => command.execute(a, t, p);
+            return acc;
+        }, {});
+        this.loggedOutCommands = ["login", "clear"];
+        this.loggedInCommands = Object.keys(this.commands);
+        this.loggedInCommands.push("logout");
+        console.log(`Current service password is: ${colorize(this.servicePassword, ConsoleColor.FgGreen)}`);
+    }
+    runCli() {
+        this.cliTerminal = new CliTerminal();
+        this.loadAddons(this.cliTerminal);
+    }
+    loadAddons(terminal) {
+        const isCli = terminal === this.cliTerminal;
+        let loggedIn = isCli;
+        const commands = isCli ? {
+            logout: async () => {
+                terminal.dispose();
+            }
+        } : {
+            login: async (args, terminal) => {
+                if (args.at(1).label === this.servicePassword) {
+                    loggedIn = true;
+                    terminal.writeln("Logged in as admin");
+                }
+                else {
+                    throw new Error("Invalid login");
+                }
+            },
+            logout: async (args, terminal) => {
+                loggedIn = false;
+                terminal.writeln("Logged out");
+            }
+        };
+        const addon = new CommandsAddon({
+            commands: {
+                ...commands,
+                ...this.commands
+            },
+            suggestCommands: async () => {
+                if (loggedIn) {
+                    return this.loggedInCommands;
+                }
+                return this.loggedOutCommands;
+            },
+            suggestions: this.suggestions
+        });
+        terminal.loadAddon(addon);
+    }
+};
+TerminalManager = __decorate([
+    singleton(),
+    __param(2, injectAll(TERMINAL_COMMAND)),
+    __metadata("design:paramtypes", [Logger,
+        Configuration, Array])
+], TerminalManager);
+
 const express = express_;
 let BackendProvider = class BackendProvider {
     config;
@@ -2131,6 +2370,11 @@ let BackendProvider = class BackendProvider {
     }
     async quickStart() {
         const port = this.config.resolve("appPort");
+        const isCli = this.config.isCli;
+        if (isCli) {
+            this.container.resolve(TerminalManager).runCli();
+            return `Running CLI mode`;
+        }
         const isWorker = this.config.resolve("isWorker");
         if (isWorker || this.config.resolve("startWorker")) {
             await this.container.resolve(JobManager).startProcessing();
@@ -2714,86 +2958,6 @@ MemoryCache = __decorate([
     __metadata("design:paramtypes", [Cache])
 ], MemoryCache);
 
-let TerminalManager = class TerminalManager {
-    logger;
-    config;
-    servicePassword;
-    suggestions;
-    commands;
-    loggedOutCommands;
-    loggedInCommands;
-    constructor(logger, config, commands) {
-        this.logger = logger;
-        this.config = config;
-        this.servicePassword = config.resolve("servicePassword");
-        this.suggestions = {
-            login: async (args) => {
-                if (args.length > 2) {
-                    return null;
-                }
-                const input = `${args.at(1).label}`;
-                return (!input) ? [] : [{
-                        id: input,
-                        label: input,
-                        masked: true
-                    }];
-            },
-            ...commands.reduce((acc, command) => {
-                command.name = camelCaseToDash(command.name || command.constructor.name || "");
-                if (!command.name || !command.suggest)
-                    return acc;
-                acc[command.name] = async (a, t) => command.suggest(a, t);
-                return acc;
-            }, {})
-        };
-        this.commands = commands.reduce((acc, command) => {
-            if (!command.name)
-                return acc;
-            acc[command.name] = async (a, t) => command.execute(a, t);
-            return acc;
-        }, {});
-        this.loggedOutCommands = ["login", "clear"];
-        this.loggedInCommands = Object.keys(this.commands);
-        this.loggedInCommands.push("logout");
-        console.log(`Current service password is: ${colorize(this.servicePassword, ConsoleColor.FgGreen)}`);
-    }
-    loadAddons(terminal) {
-        let loggedIn = false;
-        const addon = new CommandsAddon({
-            commands: {
-                login: async (args, terminal) => {
-                    if (args.at(1).label === this.servicePassword) {
-                        loggedIn = true;
-                        terminal.writeln("Logged in as admin");
-                    }
-                    else {
-                        throw new Error("Invalid login");
-                    }
-                },
-                logout: async (args, terminal) => {
-                    loggedIn = false;
-                    terminal.writeln("Logged out");
-                },
-                ...this.commands
-            },
-            suggestCommands: async () => {
-                if (loggedIn) {
-                    return this.loggedInCommands;
-                }
-                return this.loggedOutCommands;
-            },
-            suggestions: this.suggestions
-        });
-        terminal.loadAddon(addon);
-    }
-};
-TerminalManager = __decorate([
-    singleton(),
-    __param(2, injectAll(TERMINAL_COMMAND)),
-    __metadata("design:paramtypes", [Logger,
-        Configuration, Array])
-], TerminalManager);
-
 let TokenGenerator = class TokenGenerator {
     chars;
     constructor() {
@@ -3573,7 +3737,7 @@ ProgressController = __decorate([
     __metadata("design:paramtypes", [Progresses, Server])
 ], ProgressController);
 
-class Terminal {
+class SocketTerminal {
     client;
     addons;
     files$;
@@ -3667,7 +3831,7 @@ let TerminalController = class TerminalController {
         this.terminals = {};
     }
     async terminalInit(client) {
-        const terminal = new Terminal(client);
+        const terminal = new SocketTerminal(client);
         this.manager.loadAddons(terminal);
         this.terminals[client.id] = terminal;
         client.on("disconnect", () => terminal.dispose());
@@ -3986,9 +4150,50 @@ FixturesCommand = __decorate([
     __metadata("design:paramtypes", [Fixtures])
 ], FixturesCommand);
 
+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);
+
 const commands = [
     ClearCommand,
-    FixturesCommand
+    FixturesCommand,
+    MoveAssetsCommand
 ];
 
 let TtlFixture = class TtlFixture {
@@ -4022,11 +4227,11 @@ let AssetGridDriver = class AssetGridDriver {
     openUploadStream(filename, opts) {
         return this.bucket.openUploadStream(filename, opts);
     }
-    openDownloadStream(id) {
-        return this.bucket.openDownloadStream(id);
+    openDownloadStream(asset) {
+        return this.bucket.openDownloadStream(asset.streamId);
     }
-    delete(id) {
-        return this.bucket.delete(id);
+    delete(asset) {
+        return this.bucket.delete(asset.streamId);
     }
 };
 AssetGridDriver = __decorate([
@@ -4040,29 +4245,31 @@ let AssetLocalDriver = class AssetLocalDriver {
         this.dir = dir;
     }
     openUploadStream(filename, opts) {
-        const id = new Types.ObjectId();
+        const id = new ObjectId$1();
         const dir = `${this.dir}/${id.toHexString()}`;
         mkdirSync(dir, { recursive: true });
-        const stream = createWriteStream(`${dir}/file.bin`);
-        stream.id = id;
+        const stream = createWriteStream(this.getPath(id, filename, opts.extension));
         stream.done = false;
         stream.on('finish', () => {
-            writeFile$2(`${dir}/filename.txt`, filename);
-            writeFile$2(`${dir}/metadata.json`, JSON.stringify(opts?.metadata || {}));
+            stream.id = id;
             stream.done = true;
+            writeFileSync(`${dir}/metadata.json`, JSON.stringify(opts?.metadata || {}));
         });
         return stream;
     }
-    openDownloadStream(id) {
-        return createReadStream(`${this.dir}/${id.toHexString()}/file.bin`, { autoClose: true, emitClose: true });
+    openDownloadStream(asset) {
+        return createReadStream(this.getPath(asset.streamId, asset.filename, asset.metadata.extension), { autoClose: true, emitClose: true });
     }
-    delete(id) {
-        return rm(`${this.dir}/${id.toHexString()}`, { recursive: true, force: true });
+    delete(asset) {
+        return rm(this.getPath(asset.streamId, asset.filename, asset.metadata.extension), { recursive: true, force: true });
+    }
+    getPath(id, name, ext) {
+        return join(this.dir, id.toHexString(), `${name}.${ext}`);
     }
 };
 AssetLocalDriver = __decorate([
     injectable(),
-    __param(0, inject(LOCAL_DIR)),
+    __param(0, inject(ASSET_LOCAL_DIR)),
     __metadata("design:paramtypes", [String])
 ], AssetLocalDriver);
 
@@ -4098,74 +4305,6 @@ function createFallbackReadable(primary, fallbackFactory) {
     });
     return proxy;
 }
-/**
- * Creates a Writable proxy that switches to a fallback destination on error.
- * @param primary The initial Writable destination.
- * @param fallbackFactory A function that returns a new Writable destination.
- */
-function createFallbackWritable(primary, fallbackFactory) {
-    // 1. The Proxy acts as the stable "entry point" for your data
-    const proxy = new PassThrough();
-    let currentDestination = primary;
-    let hasSwitched = false;
-    // Function to handle the swap
-    const handleSwitch = (err) => {
-        if (hasSwitched)
-            return; // Prevent infinite loops if fallback also fails
-        hasSwitched = true;
-        // 2. Unpipe from the failed stream and destroy it
-        proxy.unpipe(currentDestination);
-        currentDestination.destroy();
-        // 3. Create the new destination and pipe the remaining data to it
-        const fallback = fallbackFactory();
-        currentDestination = fallback;
-        // Pipe the proxy into the fallback
-        proxy.pipe(fallback);
-        // Ensure errors on the fallback are bubbled up
-        fallback.on('error', (fallbackErr) => {
-            proxy.emit('error', fallbackErr);
-        });
-    };
-    // Initial setup
-    primary.on('error', handleSwitch);
-    proxy.on('finish', () => {
-        const final = proxy;
-        final.id = currentDestination.id;
-        final.done = true;
-    });
-    proxy.pipe(primary);
-    return proxy;
-}
-
-let AssetFallbackDriver = class AssetFallbackDriver {
-    main;
-    fallback;
-    constructor(main, fallback) {
-        this.main = main;
-        this.fallback = fallback;
-    }
-    openDownloadStream(id) {
-        return createFallbackReadable(this.main.openDownloadStream(id), () => this.fallback.openDownloadStream(id));
-    }
-    openUploadStream(filename, opts) {
-        return createFallbackWritable(this.main.openUploadStream(filename, opts), () => this.fallback.openUploadStream(filename, opts));
-    }
-    async delete(id) {
-        try {
-            await this.main.delete(id);
-        }
-        catch (e) {
-            console.log("Failed to delete from primary: ", e.message);
-            await this.fallback.delete(id);
-        }
-    }
-};
-AssetFallbackDriver = __decorate([
-    injectable(),
-    __param(0, inject(ASSET_MAIN_DRIVER)),
-    __param(1, inject(ASSET_FALLBACK_DRIVER)),
-    __metadata("design:paramtypes", [Object, Object])
-], AssetFallbackDriver);
 
 let AssetStorageProxyDriver = class AssetStorageProxyDriver {
     config;
@@ -4176,12 +4315,9 @@ let AssetStorageProxyDriver = class AssetStorageProxyDriver {
         this.baseUrl = this.config.resolve("storageProxyUri");
         this.url = this.baseUrl + this.config.resolve("storageProxyBucket");
     }
-    openDownloadStream(id) {
-        return got.stream.get(this.getUrl(id));
-    }
     openUploadStream(_, opts) {
         const id = new ObjectId$1();
-        const stream = got.stream.put(this.getUrl(id), { headers: {
+        const stream = got.stream.put(this.getUrl(id, opts.extension), { headers: {
                 'Content-Type': opts?.contentType || 'application/octet-stream'
             } });
         stream.done = false;
@@ -4191,12 +4327,19 @@ let AssetStorageProxyDriver = class AssetStorageProxyDriver {
         });
         return stream;
     }
-    async delete(id) {
-        console.log("DELETE", id.toHexString());
-        await got.delete(this.getUrl(id));
+    openDownloadStream(asset) {
+        return createFallbackReadable(got.stream.get(this.getUrl(asset.streamId, asset.metadata.extension)), () => got.stream.get(this.getUrl(asset.streamId)));
     }
-    getUrl(id) {
-        return `${this.url}/${id.toHexString()}`;
+    async delete(asset) {
+        try {
+            await got.delete(this.getUrl(asset.streamId, asset.metadata.extension));
+        }
+        catch (e) {
+            await got.delete(this.getUrl(asset.streamId));
+        }
+    }
+    getUrl(id, ext) {
+        return !ext ? `${this.url}/${id.toHexString()}` : `${this.url}/${id.toHexString()}.${ext}`;
     }
 };
 AssetStorageProxyDriver = __decorate([
@@ -4581,8 +4724,10 @@ function createServices() {
         new Parameter("mongoDb", "node-backend"),
         new Parameter("mongoUser", null),
         new Parameter("mongoPassword", null),
-        new Parameter("storageProxyUri", "http://localhost:4500/", prepareUrl),
+        new Parameter("storageProxyUri", "http://localhost:4500/files", prepareUrlSlash),
         new Parameter("storageProxyBucket", "something"),
+        new Parameter("assetsMainDriver", "grid"),
+        new Parameter("assetsMissingDriver", "grid"),
         new Parameter("nodeEnv", "production"),
         new Parameter("appPort", 80),
         new Parameter("zmqPort", 3000),
@@ -4752,17 +4897,16 @@ async function setupBackend(config, providers, parent) {
     diContainer.register(OPENAPI_VALIDATION, {
         useValue: config.customValidation || (() => null)
     });
-    diContainer.register(LOCAL_DIR, {
+    diContainer.register(ASSET_LOCAL_DIR, {
         useValue: config.assetLocalDir || "assets_files"
     });
-    diContainer.register(ASSET_DRIVER, {
-        useClass: config.assetDriver || AssetFallbackDriver
-    });
-    diContainer.register(ASSET_MAIN_DRIVER, {
-        useClass: config.assetMainDriver || AssetGridDriver
-    });
-    diContainer.register(ASSET_FALLBACK_DRIVER, {
-        useClass: config.assetFallbackDriver || AssetLocalDriver
+    diContainer.register(ASSET_DRIVER_FACTORIES, {
+        useValue: {
+            grid: container => container.resolve(AssetGridDriver),
+            storageProxy: container => container.resolve(AssetStorageProxyDriver),
+            local: container => container.resolve(AssetLocalDriver),
+            ...(config.assetDrivers || {}),
+        }
     });
     diContainers.appContainer = diContainers.appContainer || diContainer;
     // Authentication