@stemy/backend 6.0.3 → 6.0.4

package/esm2022/services/drivers/fallback-readable.mjs

@@ -0,0 +1,34 @@
+import { PassThrough } from 'stream';
+export function createFallbackReadable(primary, fallbackFactory) {
+    const proxy = new PassThrough();
+    let hasSwitched = false;
+    const switchToFallback = () => {
+        if (hasSwitched)
+            return;
+        hasSwitched = true;
+        // 1. Cleanup the failing primary
+        primary.unpipe(proxy);
+        primary.destroy();
+        // 2. Initialize and pipe the fallback
+        const fallback = fallbackFactory();
+        // On the fallback, we allow it to end the proxy naturally
+        fallback.pipe(proxy);
+        fallback.on('error', (err) => {
+            proxy.emit('error', err); // If fallback fails too, it's a hard error
+        });
+    };
+    // Pipe primary but prevent it from closing the proxy automatically
+    primary.pipe(proxy, { end: false });
+    primary.on('error', () => {
+        switchToFallback();
+    });
+    // Handle the "Early End" case (e.g., stream closed before data finished)
+    primary.on('end', () => {
+        if (!hasSwitched) {
+            // If we finished successfully without erroring, close the proxy
+            proxy.end();
+        }
+    });
+    return proxy;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/drivers/fallback-streams.mjs

@@ -0,0 +1,72 @@
+import { PassThrough } from 'stream';
+export function createFallbackReadable(primary, fallbackFactory) {
+    const proxy = new PassThrough();
+    let hasSwitched = false;
+    const switchToFallback = () => {
+        if (hasSwitched)
+            return;
+        hasSwitched = true;
+        // 1. Cleanup the failing primary
+        primary.unpipe(proxy);
+        primary.destroy();
+        // 2. Initialize and pipe the fallback
+        const fallback = fallbackFactory();
+        // On the fallback, we allow it to end the proxy naturally
+        fallback.pipe(proxy);
+        fallback.on('error', (err) => {
+            proxy.emit('error', err); // If fallback fails too, it's a hard error
+        });
+    };
+    // Pipe primary but prevent it from closing the proxy automatically
+    primary.pipe(proxy, { end: false });
+    primary.on('error', () => {
+        switchToFallback();
+    });
+    // Handle the "Early End" case (e.g., stream closed before data finished)
+    primary.on('end', () => {
+        if (!hasSwitched) {
+            // If we finished successfully without erroring, close the proxy
+            proxy.end();
+        }
+    });
+    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.
+ */
+export 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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/entities/asset.mjs

@@ -1,4 +1,4 @@
-import { isString, streamToBuffer, toImage } from "../../utils";
+import { streamToBuffer, toImage } from "../../utils";
 import { BaseEntity } from "./base-entity";
 export class Asset extends BaseEntity {
     driver;
@@ -21,17 +21,11 @@ export class Asset extends BaseEntity {
     async unlink() {
         try {
             await this.driver.delete(this.oid);
-            await this.collection.deleteOne({ _id: this.oid });
         }
         catch (error) {
-            let err = error;
-            if (error) {
-                err = error.message || error || "";
-                if (!isString(err) || !err.startsWith("FileNotFound")) {
-                    throw err;
-                }
-            }
+            console.log("Failed to unlink", error?.message);
         }
+        await this.collection.deleteOne({ _id: this.oid });
         return this.id;
     }
     async setMeta(metadata) {
@@ -58,4 +52,4 @@ export class Asset extends BaseEntity {
         return toImage(await this.download(metadata), params, this.metadata);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/stemy-backend.mjs

@@ -39,6 +39,7 @@ import { compare } from 'bcrypt';
 import moment from 'moment';
 import { GridFSBucket } from 'mongodb/lib/gridfs';
 import { writeFile as writeFile$2, rm } from 'fs/promises';
+import got from 'got';
 import { getModelForClass } from '@typegoose/typegoose';
 import { getValue as getValue$1, setValue } from 'mongoose/lib/utils';
 
@@ -57,6 +58,8 @@ 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');
 class Parameter {
     name;
     defaultValue;
@@ -1009,17 +1012,11 @@ class Asset extends BaseEntity {
     async unlink() {
         try {
             await this.driver.delete(this.oid);
-            await this.collection.deleteOne({ _id: this.oid });
         }
         catch (error) {
-            let err = error;
-            if (error) {
-                err = error.message || error || "";
-                if (!isString(err) || !err.startsWith("FileNotFound")) {
-                    throw err;
-                }
-            }
+            console.log("Failed to unlink", error?.message);
         }
+        await this.collection.deleteOne({ _id: this.oid });
         return this.id;
     }
     async setMeta(metadata) {
@@ -4018,11 +4015,9 @@ const fixtures = [
 ];
 
 let AssetGridDriver = class AssetGridDriver {
-    metaCollection;
     bucket;
     constructor(connector) {
         this.bucket = new GridFSBucket(connector.database, { bucketName: 'assets' });
-        this.metaCollection = "assets.files";
     }
     openUploadStream(filename, opts) {
         return this.bucket.openUploadStream(filename, opts);
@@ -4041,10 +4036,8 @@ AssetGridDriver = __decorate([
 
 let AssetLocalDriver = class AssetLocalDriver {
     dir;
-    metaCollection;
     constructor(dir) {
         this.dir = dir;
-        this.metaCollection = "assets.local";
     }
     openUploadStream(filename, opts) {
         const id = new Types.ObjectId();
@@ -4073,6 +4066,144 @@ AssetLocalDriver = __decorate([
     __metadata("design:paramtypes", [String])
 ], AssetLocalDriver);
 
+function createFallbackReadable(primary, fallbackFactory) {
+    const proxy = new PassThrough();
+    let hasSwitched = false;
+    const switchToFallback = () => {
+        if (hasSwitched)
+            return;
+        hasSwitched = true;
+        // 1. Cleanup the failing primary
+        primary.unpipe(proxy);
+        primary.destroy();
+        // 2. Initialize and pipe the fallback
+        const fallback = fallbackFactory();
+        // On the fallback, we allow it to end the proxy naturally
+        fallback.pipe(proxy);
+        fallback.on('error', (err) => {
+            proxy.emit('error', err); // If fallback fails too, it's a hard error
+        });
+    };
+    // Pipe primary but prevent it from closing the proxy automatically
+    primary.pipe(proxy, { end: false });
+    primary.on('error', () => {
+        switchToFallback();
+    });
+    // Handle the "Early End" case (e.g., stream closed before data finished)
+    primary.on('end', () => {
+        if (!hasSwitched) {
+            // If we finished successfully without erroring, close the proxy
+            proxy.end();
+        }
+    });
+    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;
+    baseUrl;
+    url;
+    constructor(config) {
+        this.config = config;
+        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: {
+                'Content-Type': opts?.contentType || 'application/octet-stream'
+            } });
+        stream.done = false;
+        stream.on('finish', () => {
+            stream.id = id;
+            stream.done = true;
+        });
+        return stream;
+    }
+    async delete(id) {
+        console.log("DELETE", id.toHexString());
+        await got.delete(this.getUrl(id));
+    }
+    getUrl(id) {
+        return `${this.url}/${id.toHexString()}`;
+    }
+};
+AssetStorageProxyDriver = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Configuration])
+], AssetStorageProxyDriver);
+
 class BaseDoc {
     _id;
     /**
@@ -4450,6 +4581,8 @@ function createServices() {
         new Parameter("mongoDb", "node-backend"),
         new Parameter("mongoUser", null),
         new Parameter("mongoPassword", null),
+        new Parameter("storageProxyUri", "http://localhost:4500/", prepareUrl),
+        new Parameter("storageProxyBucket", "something"),
         new Parameter("nodeEnv", "production"),
         new Parameter("appPort", 80),
         new Parameter("zmqPort", 3000),
@@ -4623,7 +4756,13 @@ async function setupBackend(config, providers, parent) {
         useValue: config.assetLocalDir || "assets_files"
     });
     diContainer.register(ASSET_DRIVER, {
-        useClass: config.assetDriver || AssetGridDriver
+        useClass: config.assetDriver || AssetFallbackDriver
+    });
+    diContainer.register(ASSET_MAIN_DRIVER, {
+        useClass: config.assetMainDriver || AssetGridDriver
+    });
+    diContainer.register(ASSET_FALLBACK_DRIVER, {
+        useClass: config.assetFallbackDriver || AssetLocalDriver
     });
     diContainers.appContainer = diContainers.appContainer || diContainer;
     // Authentication
@@ -4694,5 +4833,5 @@ async function setupBackend(config, providers, parent) {
  * Generated bundle index. Do not edit.
  */
 
-export { AssetGridDriver, AssetImageParams, AssetLocalDriver, AssetProcessor, AssetResolver, Assets, AuthController, BackendProvider, BaseDoc, Cache, CacheProcessor, Configuration, ConsoleColor, DI_CONTAINER, DocumentArray, EXPRESS, EndpointProvider, ErrorHandlerMiddleware, FIXTURE, Fixtures, Gallery, GalleryCache, GalleryController, HTTP_SERVER, IdGenerator, IsDocumented, IsFile, IsObjectId, JOB, JobManager, JsonResponse, LanguageMiddleware, LazyAssetGenerator, LazyAssets, Logger, MailSender, MemoryCache, MongoConnector, OPENAPI_VALIDATION, OpenApi, PARAMETER, Parameter, PrimitiveArray, Progresses, ResolveEntity, ResponseType, SOCKET_CONTROLLERS, SOCKET_SERVER, TERMINAL_COMMAND, TemplateRenderer, TerminalManager, TokenGenerator, TranslationProvider, Translator, Type, UserManager, assign, broadcast, bufferToStream, camelCaseToDash, colorize, convertValue, copy, copyStream, createIdString, createServices, createTransformer, deleteFile, deleteFromBucket, fileTypeFromBuffer, filter, firstItem, flatten, getConstructorName, getDirName, getExtension, getFileName, getFunctionParams, getType, getValue, groupBy, gunzipPromised, gzipPromised, hydratePopulated, idToString, injectServices, isArray, isBoolean, isBuffer, isConstructor, isDate, isDefined, isFunction, isInterface, isNullOrUndefined, isObject, isObjectId, isPrimitive, isString, isType, jsonHighlight, lastItem, lcFirst, letsLookupStage, lookupStages, matchField, matchFieldStages, matchStage, md5, mkdirRecursive, multiSubscription, observableFromFunction, padLeft, padRight, paginate, paginateAggregations, prepareUrl, prepareUrlEmpty, prepareUrlSlash, projectStage, promiseTimeout, rand, random, readAndDeleteFile, readFile, regexEscape, regroup, replaceSpecialChars, resolveUser, runCommand, service, setupBackend, streamToBuffer, toImage, ucFirst, uniqueItems, unwindStage, valueToPromise, wrapError, writeFile };
+export { AssetGridDriver, AssetImageParams, AssetLocalDriver, AssetProcessor, AssetResolver, AssetStorageProxyDriver, Assets, AuthController, BackendProvider, BaseDoc, Cache, CacheProcessor, Configuration, ConsoleColor, DI_CONTAINER, DocumentArray, EXPRESS, EndpointProvider, ErrorHandlerMiddleware, FIXTURE, Fixtures, Gallery, GalleryCache, GalleryController, HTTP_SERVER, IdGenerator, IsDocumented, IsFile, IsObjectId, JOB, JobManager, JsonResponse, LanguageMiddleware, LazyAssetGenerator, LazyAssets, Logger, MailSender, MemoryCache, MongoConnector, OPENAPI_VALIDATION, OpenApi, PARAMETER, Parameter, PrimitiveArray, Progresses, ResolveEntity, ResponseType, SOCKET_CONTROLLERS, SOCKET_SERVER, TERMINAL_COMMAND, TemplateRenderer, TerminalManager, TokenGenerator, TranslationProvider, Translator, Type, UserManager, assign, broadcast, bufferToStream, camelCaseToDash, colorize, convertValue, copy, copyStream, createIdString, createServices, createTransformer, deleteFile, deleteFromBucket, fileTypeFromBuffer, filter, firstItem, flatten, getConstructorName, getDirName, getExtension, getFileName, getFunctionParams, getType, getValue, groupBy, gunzipPromised, gzipPromised, hydratePopulated, idToString, injectServices, isArray, isBoolean, isBuffer, isConstructor, isDate, isDefined, isFunction, isInterface, isNullOrUndefined, isObject, isObjectId, isPrimitive, isString, isType, jsonHighlight, lastItem, lcFirst, letsLookupStage, lookupStages, matchField, matchFieldStages, matchStage, md5, mkdirRecursive, multiSubscription, observableFromFunction, padLeft, padRight, paginate, paginateAggregations, prepareUrl, prepareUrlEmpty, prepareUrlSlash, projectStage, promiseTimeout, rand, random, readAndDeleteFile, readFile, regexEscape, regroup, replaceSpecialChars, resolveUser, runCommand, service, setupBackend, streamToBuffer, toImage, ucFirst, uniqueItems, unwindStage, valueToPromise, wrapError, writeFile };
 //# sourceMappingURL=stemy-backend.mjs.map