@nu-art/file-upload-backend 0.401.8 → 0.500.0

package/core/module-pack.d.ts

@@ -1 +1 @@
-export declare const ModulePackBE_FileUploader: (import("../modules/ModuleBE_AssetsTemp.js").ModuleBE_AssetsTemp_Class | import("../modules/ModuleBE_BucketListener.js").ModuleBE_BucketListener_Class | import("../modules/ModuleBE_AssetsStorage.js").ModuleBE_AssetsStorage_Class | import("../modules/ModuleBE_AssetsDB.js").ModuleBE_AssetsDB_Class | import("@nu-art/push-pub-sub-backend").ModuleBE_PushPubSub_Class | import("@nu-art/push-pub-sub-backend/modules/ModuleBE_PushSessionDB").ModuleBE_PushSessionDB_Class | import("@nu-art/push-pub-sub-backend/modules/ModuleBE_PushSubscriptionDB").ModuleBE_PushSubscriptionDB_Class | import("@nu-art/thunderstorm-backend").ModuleBE_BaseApi_Class<import("@nu-art/push-pub-sub-shared/push-subscription/types").DBProto_PushSubscription> | import("@nu-art/push-pub-sub-backend/modules/ModuleBE_PushMessagesHistoryDB").ModuleBE_PushMessagesHistoryDB_Class | import("../modules/ModuleBE_AssetsDeleted.js").ModuleBE_AssetsDeleted_Class | import("../modules/ModuleBE_AssetUploader.js").ModuleBE_AssetUploader_Class | import("../modules/ModuleBE_AssetsAPI.js").ModuleBE_AssetsAPI_Class | import("@nu-art/thunderstorm-backend").ModuleBE_BaseApi_Class<import("@nu-art/file-upload-shared").DBProto_AssetsTemp>)[];
+export declare const ModulePackBE_FileUploader: (import("../modules/ModuleBE_AssetsTemp.js").ModuleBE_AssetsTemp_Class | import("../modules/ModuleBE_BucketListener.js").ModuleBE_BucketListener_Class | import("../modules/ModuleBE_AssetsStorage.js").ModuleBE_AssetsStorage_Class | import("../modules/ModuleBE_AssetsDB.js").ModuleBE_AssetsDB_Class | import("@nu-art/push-pub-sub-backend").ModuleBE_PushPubSub_Class | import("@nu-art/push-pub-sub-backend/modules/ModuleBE_PushSessionDB").ModuleBE_PushSessionDB_Class | import("@nu-art/push-pub-sub-backend/modules/ModuleBE_PushSubscriptionDB").ModuleBE_PushSubscriptionDB_Class | import("@nu-art/push-pub-sub-backend/modules/ModuleBE_PushMessagesHistoryDB").ModuleBE_PushMessagesHistoryDB_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/push-pub-sub-shared/push-subscription/types").DatabaseDef_PushSubscription & import("@nu-art/db-api-shared").DB_Prototype<any, Omit<any, any>, import("@nu-art/ts-common").SubsetObjectByKeys<any, any>>> | import("../modules/ModuleBE_AssetsDeleted.js").ModuleBE_AssetsDeleted_Class | import("../modules/ModuleBE_AssetUploader.js").ModuleBE_AssetUploader_Class | import("../modules/ModuleBE_AssetsAPI.js").ModuleBE_AssetsAPI_Class | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/file-upload-shared").DatabaseDef_AssetsTemp> | import("@nu-art/db-api-backend").ModuleBE_BaseApi_Class<import("@nu-art/file-upload-shared").DatabaseDef_Assets>)[];

package/core/module-pack.js

@@ -22,15 +22,15 @@ import { ModuleBE_BucketListener } from '../modules/ModuleBE_BucketListener.js';
 import { ModulePackBE_PushPubSub } from '@nu-art/push-pub-sub-backend';
 import { ModuleBE_AssetUploader } from '../modules/ModuleBE_AssetUploader.js';
 import { ModuleBE_AssetsAPI } from '../modules/ModuleBE_AssetsAPI.js';
-import { createApisForDBModuleV3 } from '@nu-art/thunderstorm-backend';
+import { createApisForDBModule } from '@nu-art/db-api-backend';
 import { ModuleBE_AssetsStorage } from '../modules/ModuleBE_AssetsStorage.js';
 import { ModuleBE_AssetsDeleted } from '../modules/ModuleBE_AssetsDeleted.js';
 export const ModulePackBE_FileUploader = [
     ...ModulePackBE_PushPubSub,
     ModuleBE_AssetUploader,
-    ModuleBE_AssetsTemp, createApisForDBModuleV3(ModuleBE_AssetsTemp),
+    ModuleBE_AssetsTemp, createApisForDBModule(ModuleBE_AssetsTemp),
     ModuleBE_AssetsDeleted,
     ModuleBE_AssetsStorage,
-    ModuleBE_AssetsDB, ModuleBE_AssetsAPI,
+    ModuleBE_AssetsDB, createApisForDBModule(ModuleBE_AssetsDB), ModuleBE_AssetsAPI,
     ModuleBE_BucketListener
 ];

package/core/permissions.d.ts

@@ -1,5 +1,5 @@
 import { DefaultDef_Group } from '@nu-art/permissions-shared';
-import { DefaultDef_Domain, DefaultDef_Package } from '@nu-art/permissions-backend/types';
+import { DefaultDef_Domain, DefaultDef_Package } from '@nu-art/permissions-backend';
 export declare const PermissionsDomain_AssetsManager: Readonly<DefaultDef_Domain>;
 export declare const PermissionsGroup_AssetsManager: Readonly<DefaultDef_Group>;
 export declare const PermissionsGroup_AssetsViewer: Readonly<DefaultDef_Group>;

package/core/permissions.js

@@ -1,24 +1,25 @@
-import { DefaultAccessLevel_Admin, DefaultAccessLevel_Delete, DefaultAccessLevel_Read, DefaultAccessLevel_Write } from '@nu-art/permissions-shared';
-import { ApiDef_Assets, ApiDef_AssetUploader } from '@nu-art/file-upload-shared';
-import { Domain_Developer } from '@nu-art/permissions-backend/permissions';
-import { ModuleBE_AssetsAPI } from '../modules/ModuleBE_AssetsAPI.js';
+import { DefaultAccessLevel_Admin, DefaultAccessLevel_Delete, DefaultAccessLevel_Read, DefaultAccessLevel_Write, toPermissionDomainId, toPermissionGroupId } from '@nu-art/permissions-shared';
+import { CrudApiDef } from '@nu-art/db-api-shared';
+import { ApiDef_Assets, ApiDef_AssetUploader, DBDef_Assets } from '@nu-art/file-upload-shared';
+import { Domain_Developer } from '@nu-art/permissions-backend';
+const AssetsCrudApiDef = CrudApiDef(DBDef_Assets.dbKey);
 const Domain_AssetsManager_ID = '993c496c6aaad9c67723034137d26c42';
 const _PermissionsDomain_AssetsManager = {
-    _id: Domain_AssetsManager_ID,
+    _id: toPermissionDomainId(Domain_AssetsManager_ID),
     namespace: 'Assets',
     dbNames: [],
     customApis: [
-        { path: ModuleBE_AssetsAPI.apiDef.v1.deleteAll.path, accessLevel: DefaultAccessLevel_Admin.name },
-        { path: ModuleBE_AssetsAPI.apiDef.v1.patch.path, accessLevel: DefaultAccessLevel_Admin.name },
-        { path: ModuleBE_AssetsAPI.apiDef.v1.upsertAll.path, accessLevel: DefaultAccessLevel_Admin.name },
-        { path: ModuleBE_AssetsAPI.apiDef.v1.upsert.path, accessLevel: DefaultAccessLevel_Admin.name },
-        { path: ModuleBE_AssetsAPI.apiDef.v1.delete.path, accessLevel: DefaultAccessLevel_Delete.name },
-        { path: ModuleBE_AssetsAPI.apiDef.v1.queryUnique.path, accessLevel: DefaultAccessLevel_Read.name },
-        { path: ModuleBE_AssetsAPI.apiDef.v1.query.path, accessLevel: DefaultAccessLevel_Read.name },
-        { path: ApiDef_Assets.vv1.getReadSignedUrl.path, accessLevel: DefaultAccessLevel_Read.name },
-        { path: ApiDef_AssetUploader.vv1.getUploadUrl.path, accessLevel: DefaultAccessLevel_Write.name },
+        { path: AssetsCrudApiDef.deleteAll.path, accessLevel: DefaultAccessLevel_Admin.name },
+        { path: AssetsCrudApiDef.deleteQuery.path, accessLevel: DefaultAccessLevel_Admin.name },
+        { path: AssetsCrudApiDef.upsertAll.path, accessLevel: DefaultAccessLevel_Admin.name },
+        { path: AssetsCrudApiDef.upsert.path, accessLevel: DefaultAccessLevel_Admin.name },
+        { path: AssetsCrudApiDef.deleteUnique.path, accessLevel: DefaultAccessLevel_Delete.name },
+        { path: AssetsCrudApiDef.queryUnique.path, accessLevel: DefaultAccessLevel_Read.name },
+        { path: AssetsCrudApiDef.query.path, accessLevel: DefaultAccessLevel_Read.name },
+        { path: ApiDef_Assets.getReadSignedUrl.path, accessLevel: DefaultAccessLevel_Read.name },
+        { path: ApiDef_AssetUploader.getUploadUrl.path, accessLevel: DefaultAccessLevel_Write.name },
         {
-            path: ApiDef_AssetUploader.vv1.processAssetManually.path,
+            path: ApiDef_AssetUploader.processAssetManually.path,
             domainId: Domain_Developer._id,
             accessLevel: DefaultAccessLevel_Write.name
         },
@@ -28,7 +29,7 @@ export const PermissionsDomain_AssetsManager = Object.freeze(_PermissionsDomain_
 const PermissionsGroupId_AssetsViewer = '0773dcf3b9fbe5e595ef6e2a596b8939';
 const PermissionsGroupId_AssetsManager = '3f5037358fba0ae1199047f2fa8add94';
 const _PermissionsGroup_AssetsViewer = {
-    _id: PermissionsGroupId_AssetsViewer,
+    _id: toPermissionGroupId(PermissionsGroupId_AssetsViewer),
     name: 'Assets Viewer',
     uiLabel: 'Assets Viewer',
     accessLevels: {
@@ -36,7 +37,7 @@ const _PermissionsGroup_AssetsViewer = {
     }
 };
 const _PermissionsGroup_AssetsManager = {
-    _id: PermissionsGroupId_AssetsManager,
+    _id: toPermissionGroupId(PermissionsGroupId_AssetsManager),
     name: 'Assets Manager',
     uiLabel: 'Assets Manager',
     accessLevels: {

package/modules/ModuleBE_AssetUploader.d.ts

@@ -1,19 +1,16 @@
-import { ModuleBase_AssetUploader, UploaderConfig } from '@nu-art/file-upload-shared/modules/ModuleBase_AssetUploader';
-import { Axios_RequestConfig } from '@nu-art/thunderstorm-backend';
-import { TempSignedUrl, UI_Asset } from '@nu-art/file-upload-shared';
-import { ApiDef, BaseHttpRequest, TypedApi } from '@nu-art/thunderstorm-shared';
+import type { ApiDef, GeneralApi } from '@nu-art/api-types';
+import { ModuleBase_AssetUploader, TempSignedUrl, UI_Asset, type IAssetUploadRequest, type UploaderConfig } from '@nu-art/file-upload-shared';
 export type ServerFilesToUpload = UI_Asset & {
     file: Buffer;
 };
 type Config = UploaderConfig & {
-    requestConfig: Axios_RequestConfig;
+    baseUrl?: string;
 };
 export declare class ModuleBE_AssetUploader_Class extends ModuleBase_AssetUploader<Config> {
     constructor();
-    init(): void;
-    createRequest<API extends TypedApi<any, any, any, any>>(uploadFile: ApiDef<API>): BaseHttpRequest<API>;
+    createRequest<API extends GeneralApi>(uploadFile: ApiDef<API>): IAssetUploadRequest<API>;
     upload(files: ServerFilesToUpload[]): UI_Asset[];
-    protected subscribeToPush(toSubscribe: TempSignedUrl[]): Promise<void>;
+    protected subscribeToPush(_toSubscribe: TempSignedUrl[]): Promise<void>;
 }
 export declare const ModuleBE_AssetUploader: ModuleBE_AssetUploader_Class;
 export {};

package/modules/ModuleBE_AssetUploader.js

@@ -1,45 +1,118 @@
-/*
- * Permissions management system, define access level for each of
- * your server apis, and restrict users by giving them access levels
- *
- * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { ModuleBase_AssetUploader, } from '@nu-art/file-upload-shared/modules/ModuleBase_AssetUploader';
-import { apiWithBodyAxios, apiWithQueryAxios, AxiosHttpModule } from '@nu-art/thunderstorm-backend';
-import { ApiDef_AssetUploader } from '@nu-art/file-upload-shared';
+import { ApiDef_AssetUploader, ModuleBase_AssetUploader } from '@nu-art/file-upload-shared';
+function createFetchRequest(apiDef, baseUrl) {
+    let url = '';
+    const headers = {};
+    let body;
+    return {
+        setUrl(u) {
+            url = u;
+            return this;
+        },
+        setHeader(key, value) {
+            headers[key] = value;
+            return this;
+        },
+        setTimeout(_ms) {
+            return this;
+        },
+        setBody(b) {
+            body = b;
+            return this;
+        },
+        setOnProgressListener(_cb) {
+            return this;
+        },
+        executeSync: async () => {
+            const fullUrl = url || `${(baseUrl || '').replace(/\/$/, '')}/${apiDef.path}`;
+            const res = await fetch(fullUrl, {
+                method: apiDef.method ?? 'POST',
+                headers: { 'Content-Type': 'application/json', ...headers },
+                body: body !== undefined ? (typeof body === 'string' ? body : JSON.stringify(body)) : undefined
+            });
+            if (!res.ok)
+                throw new Error(`Request failed: ${res.status} ${res.statusText}`);
+            const text = await res.text();
+            return text ? JSON.parse(text) : undefined;
+        },
+        execute(cb) {
+            this.executeSync().then(cb).catch((e) => {
+                throw e;
+            });
+        }
+    };
+}
 export class ModuleBE_AssetUploader_Class extends ModuleBase_AssetUploader {
     constructor() {
         super();
+        const baseUrl = () => this.config?.baseUrl ?? '';
         this.vv1 = {
-            getUploadUrl: apiWithBodyAxios(ApiDef_AssetUploader.vv1.getUploadUrl),
-            processAssetManually: apiWithQueryAxios(ApiDef_AssetUploader.vv1.processAssetManually),
+            getUploadUrl: (body) => createFetchRequest(ApiDef_AssetUploader.getUploadUrl, baseUrl()).setBody(body),
+            processAssetManually: (params) => {
+                const query = {};
+                if (params.feId)
+                    query.feId = params.feId;
+                const req = createFetchRequest({ method: 'GET', path: ApiDef_AssetUploader.processAssetManually.path }, baseUrl());
+                const path = ApiDef_AssetUploader.processAssetManually.path;
+                return {
+                    ...req,
+                    setUrlParam(key, value) {
+                        query[key] = value;
+                        return this;
+                    },
+                    execute() {
+                        const qs = Object.keys(query).length ? '?' + Object.entries(query).map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&') : '';
+                        req.setUrl(`${(baseUrl() || '').replace(/\/$/, '')}/${path}${qs}`);
+                        void req.executeSync();
+                    }
+                };
+            }
         };
     }
-    init() {
-        super.init();
-        AxiosHttpModule.setRequestOption(this.config.requestConfig);
-    }
     createRequest(uploadFile) {
-        return AxiosHttpModule.createRequest(uploadFile);
+        let url = '';
+        const headers = {};
+        let body;
+        return {
+            setUrl(u) {
+                url = u;
+                return this;
+            },
+            setHeader(key, value) {
+                headers[key] = value;
+                return this;
+            },
+            setTimeout(_ms) {
+                return this;
+            },
+            setBody(b) {
+                body = b;
+                return this;
+            },
+            setOnProgressListener(_cb) {
+                return this;
+            },
+            executeSync: async () => {
+                const res = await fetch(url, {
+                    method: uploadFile.method ?? 'PUT',
+                    headers: { ...headers },
+                    body: body !== undefined ? JSON.stringify(body) : undefined
+                });
+                if (!res.ok)
+                    throw new Error(`Upload failed: ${res.status} ${res.statusText}`);
+                return res.json().catch(() => undefined);
+            },
+            execute(cb) {
+                this.executeSync().then(cb).catch((e) => {
+                    throw e;
+                });
+            }
+        };
     }
     upload(files) {
         return this.uploadImpl(files);
     }
-    async subscribeToPush(toSubscribe) {
-        // Not sure now
-        // We said timeout
+    async subscribeToPush(_toSubscribe) {
+        // Not used in backend flow
     }
 }
 export const ModuleBE_AssetUploader = new ModuleBE_AssetUploader_Class();

package/modules/ModuleBE_AssetsAPI.d.ts

@@ -1,8 +1,7 @@
-import { ModuleBE_BaseApi_Class } from '@nu-art/thunderstorm-backend';
-import { DBProto_Assets } from '@nu-art/file-upload-shared';
-export declare class ModuleBE_AssetsAPI_Class extends ModuleBE_BaseApi_Class<DBProto_Assets> {
+import { Module } from '@nu-art/ts-common';
+import { API_Assets } from '@nu-art/file-upload-shared';
+export declare class ModuleBE_AssetsAPI_Class extends Module {
     constructor();
-    init(): void;
-    private getReadSignedUrl;
+    getReadSignedUrl(body: API_Assets['getReadSignedUrl']['Body']): Promise<API_Assets['getReadSignedUrl']['Response']>;
 }
 export declare const ModuleBE_AssetsAPI: ModuleBE_AssetsAPI_Class;

package/modules/ModuleBE_AssetsAPI.js

@@ -1,22 +1,64 @@
-import { addRoutes, createBodyServerApi, ModuleBE_BaseApi_Class } from '@nu-art/thunderstorm-backend';
-import { ModuleBE_AssetsDB } from './ModuleBE_AssetsDB.js';
-import { ApiDef_Assets } from '@nu-art/file-upload-shared';
-import { ModuleBE_AssetsStorage } from './ModuleBE_AssetsStorage.js';
-export class ModuleBE_AssetsAPI_Class extends ModuleBE_BaseApi_Class {
-    constructor() {
-        super(ModuleBE_AssetsDB);
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
     }
-    init() {
-        super.init();
-        addRoutes([
-            createBodyServerApi(ApiDef_Assets.vv1.getReadSignedUrl, this.getReadSignedUrl)
-        ]);
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
     }
-    getReadSignedUrl = async (body) => {
-        const dbAsset = await ModuleBE_AssetsDB.query.uniqueAssert(body._id);
-        return {
-            signedUrl: (await (await ModuleBE_AssetsStorage.getFile(dbAsset)).getReadSignedUrl()).signedUrl
-        };
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Module } from '@nu-art/ts-common';
+import { ApiHandler } from '@nu-art/http-server';
+import { ModuleBE_AssetsDB } from './ModuleBE_AssetsDB.js';
+import { ModuleBE_AssetsStorage } from './ModuleBE_AssetsStorage.js';
+import { ApiDef_Assets } from '@nu-art/file-upload-shared';
+let ModuleBE_AssetsAPI_Class = (() => {
+    let _classSuper = Module;
+    let _instanceExtraInitializers = [];
+    let _getReadSignedUrl_decorators;
+    return class ModuleBE_AssetsAPI_Class extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getReadSignedUrl_decorators = [ApiHandler(ApiDef_Assets.getReadSignedUrl)];
+            __esDecorate(this, null, _getReadSignedUrl_decorators, { kind: "method", name: "getReadSignedUrl", static: false, private: false, access: { has: obj => "getReadSignedUrl" in obj, get: obj => obj.getReadSignedUrl }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        constructor() {
+            super('AssetsAPI');
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        async getReadSignedUrl(body) {
+            const dbAsset = await ModuleBE_AssetsDB.query.uniqueAssert(body._id);
+            return {
+                signedUrl: (await (await ModuleBE_AssetsStorage.getFile(dbAsset)).getReadSignedUrl()).signedUrl
+            };
+        }
     };
-}
+})();
+export { ModuleBE_AssetsAPI_Class };
 export const ModuleBE_AssetsAPI = new ModuleBE_AssetsAPI_Class();

package/modules/ModuleBE_AssetsDB.d.ts

@@ -1,13 +1,22 @@
 import { TypedMap } from '@nu-art/ts-common';
-import { CleanupDetails, DBApiConfigV3, ModuleBE_BaseDB, OnCleanupSchedulerAct } from '@nu-art/thunderstorm-backend';
+import { ModuleBE_BaseDB, PostWriteProcessingDataShape } from '@nu-art/db-api-backend';
 import { Clause_Where } from '@nu-art/firebase-shared';
 import { OnAssetUploaded } from './ModuleBE_BucketListener.js';
-import { DB_Asset, DBProto_Assets, TempSignedUrl, UI_Asset } from '@nu-art/file-upload-shared';
-import { CollectionActionType, PostWriteProcessingData } from '@nu-art/firebase-backend/firestore-v3/FirestoreCollectionV3';
+import { API_AssetUploader, DB_Asset, DatabaseDef_Assets, TempSignedUrl, UI_Asset } from '@nu-art/file-upload-shared';
+import { CollectionActionType } from '@nu-art/firebase-backend/firestore-v3/FirestoreCollectionV3';
 import { FileMetadata } from '@google-cloud/storage';
 import { FileWrapper } from '@nu-art/firebase-backend';
 import { Transaction } from 'firebase-admin/firestore';
-type MyConfig = DBApiConfigV3<DBProto_Assets> & {
+/** Local type for cleanup scheduler (replaces thunderstorm-backend). */
+export type CleanupDetails = {
+    moduleKey: string;
+    interval: number;
+    cleanup: () => Promise<void>;
+};
+export interface OnCleanupSchedulerAct {
+    __onCleanupSchedulerAct(): CleanupDetails;
+}
+type MyConfig = {
     authKey: string;
     bucketName?: string;
     storagePath: string;
@@ -30,11 +39,13 @@ export type FileTypeValidation = {
 export declare const DefaultMimetypeValidator: (file: FileWrapper, doc: DB_Asset) => Promise<import("file-type").FileTypeResult>;
 export type FileValidator = (file: FileWrapper, doc: DB_Asset) => Promise<FileTypeResult | undefined>;
 export declare const fileSizeValidator: (file: FileWrapper, metadata: FileMetadata, minSizeInBytes?: number, maxSizeInBytes?: number) => Promise<boolean>;
-export declare class ModuleBE_AssetsDB_Class extends ModuleBE_BaseDB<DBProto_Assets, MyConfig> implements OnCleanupSchedulerAct, OnAssetUploaded {
+export declare class ModuleBE_AssetsDB_Class extends ModuleBE_BaseDB<DatabaseDef_Assets, MyConfig> implements OnCleanupSchedulerAct, OnAssetUploaded {
     constructor();
     mimeTypeValidator: TypedMap<FileValidator>;
     fileValidator: TypedMap<FileTypeValidation>;
-    protected postWriteProcessing(data: PostWriteProcessingData<DBProto_Assets>, actionType: CollectionActionType, transaction?: Transaction): Promise<void>;
+    protected postWriteProcessing(data: PostWriteProcessingDataShape<DB_Asset>, actionType: CollectionActionType, transaction?: Transaction): Promise<void>;
+    getUploadUrl(body: API_AssetUploader['getUploadUrl']['Body']): Promise<API_AssetUploader['getUploadUrl']['Response']>;
+    processAssetManually(params: API_AssetUploader['processAssetManually']['Params']): Promise<API_AssetUploader['processAssetManually']['Response']>;
     init(): void;
     getAssetsContent(assetIds: string[]): Promise<AssetContent[]>;
     registerTypeValidator(mimeType: string, validator: (file: FileWrapper, doc: DB_Asset) => Promise<void>): void;
@@ -43,7 +54,7 @@ export declare class ModuleBE_AssetsDB_Class extends ModuleBE_BaseDB<DBProto_Ass
     __onCleanupSchedulerAct(): CleanupDetails;
     private cleanup;
     getUrl: (files: UI_Asset[]) => Promise<TempSignedUrl[]>;
-    processAssetManually: (feId?: string) => Promise<void[]>;
+    processAssetImpl: (feId?: string) => Promise<void[]>;
     __processAsset: (filePath?: string) => Promise<void>;
     private notifyFrontend;
 }

package/modules/ModuleBE_AssetsDB.js

@@ -1,3 +1,37 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 /*
  * Permissions management system, define access level for each of
  * your server apis, and restrict users by giving them access levels
@@ -16,9 +50,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ApiException, asArray, BadImplementationException, currentTimeMillis, Day, exists, filterInstances, generateHex, Hour, ImplementationMissingException, MB, Minute, MUSTNeverHappenException, ThisShouldNotHappenException } from '@nu-art/ts-common';
+import { ApiException, BadImplementationException, currentTimeMillis, Day, filterInstances, generateHex, Hour, ImplementationMissingException, MB, Minute, MUSTNeverHappenException, ThisShouldNotHappenException } from '@nu-art/ts-common';
 import { ModuleBE_AssetsTemp } from './ModuleBE_AssetsTemp.js';
-import { addRoutes, createBodyServerApi, ModuleBE_BaseDB } from '@nu-art/thunderstorm-backend';
+import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
+import { ApiHandler } from '@nu-art/http-server';
 import { ModuleBE_AssetsStorage } from './ModuleBE_AssetsStorage.js';
 import { ApiDef_AssetUploader, DBDef_Assets, FileStatus } from '@nu-art/file-upload-shared';
 import { PushMessageBE_FileUploadStatus } from '../core/messages.js';
@@ -39,205 +74,227 @@ export const fileSizeValidator = async (file, metadata, minSizeInBytes = 0, maxS
         throw new ThisShouldNotHappenException(`could not resolve metadata.size for file: ${file.path}`);
     return fileSize >= minSizeInBytes && fileSize <= maxSizeInBytes;
 };
-export class ModuleBE_AssetsDB_Class extends ModuleBE_BaseDB {
-    constructor() {
-        super(DBDef_Assets);
-        this.setDefaultConfig({
-            ...this.config,
-            storagePath: 'assets',
-            pathRegexp: '^assets/.*',
-            authKey: 'file-uploader'
-        });
-    }
-    mimeTypeValidator = {};
-    fileValidator = {};
-    async postWriteProcessing(data, actionType, transaction) {
-        const deletedItems = data.deleted;
-        if (exists(deletedItems))
-            await ModuleBE_AssetsDeleted.create.all(asArray(deletedItems), transaction);
-    }
-    init() {
-        super.init();
-        addRoutes([
-            createBodyServerApi(ApiDef_AssetUploader.vv1.getUploadUrl, this.getUrl)
-        ]);
-        this.registerVersionUpgradeProcessor('1.0.1', async (assets) => {
-            assets.forEach(asset => {
-                // @ts-ignore
-                delete asset._audit;
+let ModuleBE_AssetsDB_Class = (() => {
+    let _classSuper = ModuleBE_BaseDB;
+    let _instanceExtraInitializers = [];
+    let _getUploadUrl_decorators;
+    let _processAssetManually_decorators;
+    return class ModuleBE_AssetsDB_Class extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _getUploadUrl_decorators = [ApiHandler(ApiDef_AssetUploader.getUploadUrl)];
+            _processAssetManually_decorators = [ApiHandler(ApiDef_AssetUploader.processAssetManually)];
+            __esDecorate(this, null, _getUploadUrl_decorators, { kind: "method", name: "getUploadUrl", static: false, private: false, access: { has: obj => "getUploadUrl" in obj, get: obj => obj.getUploadUrl }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _processAssetManually_decorators, { kind: "method", name: "processAssetManually", static: false, private: false, access: { has: obj => "processAssetManually" in obj, get: obj => obj.processAssetManually }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        constructor() {
+            super(DBDef_Assets);
+            this.setDefaultConfig({
+                ...this.config,
+                storagePath: 'assets',
+                pathRegexp: '^assets/.*',
+                authKey: 'file-uploader'
+            });
+        }
+        mimeTypeValidator = (__runInitializers(this, _instanceExtraInitializers), {});
+        fileValidator = {};
+        async postWriteProcessing(data, actionType, transaction) {
+            const deleted = data.deleted ? (Array.isArray(data.deleted) ? data.deleted : [data.deleted]) : [];
+            if (deleted.length)
+                await ModuleBE_AssetsDeleted.set.all(deleted, transaction);
+        }
+        async getUploadUrl(body) {
+            return this.getUrl(body);
+        }
+        async processAssetManually(params) {
+            await this.processAssetImpl(params.feId);
+            return [];
+        }
+        init() {
+            super.init();
+            this.registerVersionUpgradeProcessor('1.0.1', async (assets) => {
+                assets.forEach(asset => {
+                    // @ts-ignore
+                    delete asset._audit;
+                });
             });
-        });
-        const originalQuery = this.query;
-        this.query = {
-            ...originalQuery,
-            unique: async (_id, transaction) => {
-                const dbAsset = await originalQuery.uniqueAssert(_id, transaction);
-                const signedUrl = (dbAsset.signedUrl?.validUntil || 0) > currentTimeMillis() ? dbAsset.signedUrl : undefined;
-                if (!signedUrl) {
-                    const url = await ModuleBE_AssetsStorage.getReadSignedUrl(dbAsset);
-                    dbAsset.signedUrl = {
-                        url,
-                        validUntil: currentTimeMillis() + Day - Minute
-                    };
+            const originalQuery = this.query;
+            this.query = {
+                ...originalQuery,
+                unique: async (_id, transaction) => {
+                    const dbAsset = await originalQuery.uniqueAssert(_id, transaction);
+                    const signedUrl = (dbAsset.signedUrl?.validUntil || 0) > currentTimeMillis() ? dbAsset.signedUrl : undefined;
+                    if (!signedUrl) {
+                        const url = await ModuleBE_AssetsStorage.getReadSignedUrl(dbAsset);
+                        dbAsset.signedUrl = {
+                            url,
+                            validUntil: currentTimeMillis() + Day - Minute
+                        };
+                    }
+                    return dbAsset;
                 }
-                return dbAsset;
-            }
-        };
-    }
-    async getAssetsContent(assetIds) {
-        const assetsToSync = filterInstances(await ModuleBE_AssetsDB.query.all(assetIds));
-        const assetFiles = await Promise.all(assetsToSync.map(asset => ModuleBE_AssetsStorage.getFile(asset)));
-        const assetContent = await Promise.all(assetFiles.map(asset => asset.read()));
-        return assetIds.map((id, index) => ({ asset: assetsToSync[index], content: assetContent[index] }));
-    }
-    registerTypeValidator(mimeType, validator) {
-    }
-    async queryUnique(where, transaction) {
-        const dbAsset = await this.query.uniqueCustom({ where });
-        const signedUrl = (dbAsset.signedUrl?.validUntil || 0) > currentTimeMillis() ? dbAsset.signedUrl : undefined;
-        if (!signedUrl) {
-            const url = await ModuleBE_AssetsStorage.getReadSignedUrl(dbAsset);
-            dbAsset.signedUrl = {
-                url,
-                validUntil: currentTimeMillis() + Day - Minute
             };
         }
-        return dbAsset;
-    }
-    register = (key, validationConfig) => {
-        if (this.fileValidator[key] && this.fileValidator[key] !== validationConfig)
-            throw new BadImplementationException(`File Validator already exists for key: ${key}`);
-        this.fileValidator[key] = validationConfig;
-    };
-    __onCleanupSchedulerAct() {
-        return {
-            moduleKey: this.getName(),
-            interval: Day,
-            cleanup: () => this.cleanup(),
-        };
-    }
-    cleanup = async (interval = Hour, module = ModuleBE_AssetsTemp) => {
-        const entries = await module.query.custom({ where: { timestamp: { $lt: currentTimeMillis() - interval } } });
-        await Promise.all(entries.map(async (dbAsset) => {
-            const file = await ModuleBE_AssetsStorage.getFile(dbAsset);
-            if (!(await file.exists()))
-                return;
-            await file.delete();
-        }));
-        await module.delete.query({ where: { timestamp: { $lt: currentTimeMillis() - interval } } });
-    };
-    getUrl = async (files) => {
-        const bucketName = this.config?.bucketName;
-        const bucket = await ModuleBE_AssetsStorage.storage.getOrCreateBucket(bucketName);
-        return Promise.all(files.map(async (_file) => {
-            const key = _file.key || _file.mimeType;
-            // this will fail the entire request... should it?
-            if (!this.fileValidator[key])
-                throw new ImplementationMissingException(`Missing validator for type ${key}`);
-            const _id = generateHex(32);
-            const path = `${this.config.storagePath}/${_id}`;
-            const dbAsset = {
-                timestamp: currentTimeMillis(),
-                _id,
-                feId: _file.feId,
-                name: _file.name,
-                ext: _file.name.substring(_file.name.toLowerCase().lastIndexOf('.') + 1),
-                mimeType: _file.mimeType,
-                key,
-                path,
-                bucketName: bucket.bucketName
-            };
-            if (_file.public)
-                dbAsset.public = _file.public;
-            const dbTempMeta = await ModuleBE_AssetsTemp.set.item(dbAsset);
-            const fileWrapper = await bucket.getFile(dbTempMeta.path);
-            const url = await fileWrapper.getWriteSignedUrl(_file.mimeType, Hour);
-            return {
-                signedUrl: url.signedUrl,
-                asset: dbTempMeta
-            };
-        }));
-    };
-    processAssetManually = async (feId) => {
-        let query = { limit: 1 };
-        if (feId)
-            query = { where: { feId } };
-        const unprocessedFiles = await ModuleBE_AssetsTemp.query.custom(query);
-        return Promise.all(unprocessedFiles.map(asset => this.__processAsset(asset.path)));
-    };
-    __processAsset = async (filePath) => {
-        if (!filePath)
-            throw new MUSTNeverHappenException('Missing file path');
-        if (!filePath.match(this.config.pathRegexp))
-            return this.logVerbose(`File was added to storage in path: ${filePath}, NOT via file uploader`);
-        this.logDebug(`Looking for file with path: ${filePath}`);
-        let dbTempAsset;
-        try {
-            dbTempAsset = await ModuleBE_AssetsTemp.query.uniqueWhere({ path: filePath });
+        async getAssetsContent(assetIds) {
+            const assetsToSync = filterInstances(await ModuleBE_AssetsDB.query.all(assetIds));
+            const assetFiles = await Promise.all(assetsToSync.map(asset => ModuleBE_AssetsStorage.getFile(asset)));
+            const assetContent = await Promise.all(assetFiles.map(asset => asset.read()));
+            return assetIds.map((id, index) => ({ asset: assetsToSync[index], content: assetContent[index] }));
         }
-        catch (e) {
-            return;
+        registerTypeValidator(mimeType, validator) {
         }
-        if (!dbTempAsset)
-            throw new ThisShouldNotHappenException(`Could not find meta for file with path: ${filePath}`);
-        await this.notifyFrontend(FileStatus.Processing, dbTempAsset);
-        this.logDebug(`Found temp meta with _id: ${dbTempAsset._id}`, dbTempAsset);
-        const validationConfig = this.fileValidator[dbTempAsset.key];
-        if (!validationConfig)
-            return this.notifyFrontend(FileStatus.ErrorNoConfig, dbTempAsset);
-        let mimetypeValidator = DefaultMimetypeValidator;
-        if (validationConfig.validator)
-            mimetypeValidator = validationConfig.validator;
-        if (!mimetypeValidator && validationConfig.fileType && validationConfig.fileType.includes(dbTempAsset.mimeType))
-            mimetypeValidator = this.mimeTypeValidator[dbTempAsset.mimeType];
-        if (!mimetypeValidator)
-            return this.notifyFrontend(FileStatus.ErrorNoValidator, dbTempAsset);
-        const file = await ModuleBE_AssetsStorage.getFile(dbTempAsset);
-        try {
-            const metadata = (await file.getMetadata());
-            if (!metadata)
-                return this.notifyFrontend(FileStatus.ErrorRetrievingMetadata, dbTempAsset);
-            await fileSizeValidator(file, metadata, validationConfig.minSize, validationConfig.maxSize);
-            const fileType = await mimetypeValidator(file, dbTempAsset);
-            dbTempAsset.md5Hash = metadata.md5Hash;
-            if (fileType && dbTempAsset.ext !== fileType.ext) {
-                this.logWarning(`renaming the file extension name: ${dbTempAsset.ext} => ${fileType.ext}`);
-                dbTempAsset.ext = fileType.ext;
+        async queryUnique(where, transaction) {
+            const dbAsset = await this.query.uniqueCustom({ where });
+            const signedUrl = (dbAsset.signedUrl?.validUntil || 0) > currentTimeMillis() ? dbAsset.signedUrl : undefined;
+            if (!signedUrl) {
+                const url = await ModuleBE_AssetsStorage.getReadSignedUrl(dbAsset);
+                dbAsset.signedUrl = {
+                    url,
+                    validUntil: currentTimeMillis() + Day - Minute
+                };
             }
+            return dbAsset;
         }
-        catch (e) {
-            //TODO delete the file and the temp doc
-            this.logError(`Error while processing asset: ${dbTempAsset.name}`, e);
-            return this.notifyFrontend(FileStatus.ErrorWhileProcessing, dbTempAsset);
+        register = (key, validationConfig) => {
+            if (this.fileValidator[key] && this.fileValidator[key] !== validationConfig)
+                throw new BadImplementationException(`File Validator already exists for key: ${key}`);
+            this.fileValidator[key] = validationConfig;
+        };
+        __onCleanupSchedulerAct() {
+            return {
+                moduleKey: this.getName(),
+                interval: Day,
+                cleanup: () => this.cleanup(),
+            };
         }
-        if (dbTempAsset.public) {
+        cleanup = async (interval = Hour, module = ModuleBE_AssetsTemp) => {
+            const entries = await module.query.custom({ where: { timestamp: { $lt: currentTimeMillis() - interval } } });
+            await Promise.all(entries.map(async (dbAsset) => {
+                const file = await ModuleBE_AssetsStorage.getFile(dbAsset);
+                if (!(await file.exists()))
+                    return;
+                await file.delete();
+            }));
+            await module.delete.query({ where: { timestamp: { $lt: currentTimeMillis() - interval } } });
+        };
+        getUrl = async (files) => {
+            const bucketName = this.config?.bucketName;
+            const bucket = await ModuleBE_AssetsStorage.storage.getOrCreateBucket(bucketName);
+            return Promise.all(files.map(async (_file) => {
+                const key = _file.key || _file.mimeType;
+                // this will fail the entire request... should it?
+                if (!this.fileValidator[key])
+                    throw new ImplementationMissingException(`Missing validator for type ${key}`);
+                const _id = generateHex(32);
+                const path = `${this.config.storagePath}/${_id}`;
+                const dbAsset = {
+                    timestamp: currentTimeMillis(),
+                    _id,
+                    feId: _file.feId,
+                    name: _file.name,
+                    ext: _file.name.substring(_file.name.toLowerCase().lastIndexOf('.') + 1),
+                    mimeType: _file.mimeType,
+                    key,
+                    path,
+                    bucketName: bucket.bucketName
+                };
+                if (_file.public)
+                    dbAsset.public = _file.public;
+                const dbTempMeta = await ModuleBE_AssetsTemp.set.item(dbAsset);
+                const fileWrapper = await bucket.getFile(dbTempMeta.path);
+                const url = await fileWrapper.getWriteSignedUrl(_file.mimeType, Hour);
+                return {
+                    signedUrl: url.signedUrl,
+                    asset: dbTempMeta
+                };
+            }));
+        };
+        processAssetImpl = async (feId) => {
+            let query = { limit: 1 };
+            if (feId)
+                query = { where: { feId } };
+            const unprocessedFiles = await ModuleBE_AssetsTemp.query.custom(query);
+            return Promise.all(unprocessedFiles.map(asset => this.__processAsset(asset.path)));
+        };
+        __processAsset = async (filePath) => {
+            if (!filePath)
+                throw new MUSTNeverHappenException('Missing file path');
+            if (!filePath.match(this.config.pathRegexp))
+                return this.logVerbose(`File was added to storage in path: ${filePath}, NOT via file uploader`);
+            this.logDebug(`Looking for file with path: ${filePath}`);
+            let dbTempAsset;
             try {
-                // need to handle the response status!
-                await file.makePublic();
+                dbTempAsset = await ModuleBE_AssetsTemp.query.uniqueWhere({ path: filePath });
             }
             catch (e) {
-                return this.notifyFrontend(FileStatus.ErrorMakingPublic, dbTempAsset);
+                return;
             }
-        }
-        const finalDbAsset = await this.runTransaction(async (transaction) => {
-            const duplicatedAssets = await this.query.custom({ where: { md5Hash: dbTempAsset.md5Hash } }, transaction);
-            if (duplicatedAssets.length && duplicatedAssets[0]) {
-                this.logWarning(`${dbTempAsset.feId} is a duplicated entry for ${duplicatedAssets[0]._id}`);
-                return { ...duplicatedAssets[0], feId: dbTempAsset.feId };
+            if (!dbTempAsset)
+                throw new ThisShouldNotHappenException(`Could not find meta for file with path: ${filePath}`);
+            // Temp and main asset share shape; cast for APIs that expect DB_Asset
+            const assetForApi = dbTempAsset;
+            await this.notifyFrontend(FileStatus.Processing, assetForApi);
+            this.logDebug(`Found temp meta with _id: ${dbTempAsset._id}`, dbTempAsset);
+            const validationConfig = this.fileValidator[dbTempAsset.key];
+            if (!validationConfig)
+                return this.notifyFrontend(FileStatus.ErrorNoConfig, assetForApi);
+            let mimetypeValidator = DefaultMimetypeValidator;
+            if (validationConfig.validator)
+                mimetypeValidator = validationConfig.validator;
+            if (!mimetypeValidator && validationConfig.fileType && validationConfig.fileType.includes(dbTempAsset.mimeType))
+                mimetypeValidator = this.mimeTypeValidator[dbTempAsset.mimeType];
+            if (!mimetypeValidator)
+                return this.notifyFrontend(FileStatus.ErrorNoValidator, assetForApi);
+            const file = await ModuleBE_AssetsStorage.getFile(assetForApi);
+            try {
+                const metadata = (await file.getMetadata());
+                if (!metadata)
+                    return this.notifyFrontend(FileStatus.ErrorRetrievingMetadata, assetForApi);
+                await fileSizeValidator(file, metadata, validationConfig.minSize, validationConfig.maxSize);
+                const fileType = await mimetypeValidator(file, assetForApi);
+                dbTempAsset.md5Hash = metadata.md5Hash;
+                if (fileType && dbTempAsset.ext !== fileType.ext) {
+                    this.logWarning(`renaming the file extension name: ${dbTempAsset.ext} => ${fileType.ext}`);
+                    dbTempAsset.ext = fileType.ext;
+                }
             }
-            const doc = this.collection.doc.item(dbTempAsset);
-            await ModuleBE_AssetsTemp.delete.unique(dbTempAsset._id, transaction);
-            return await doc.set(dbTempAsset, transaction);
-        });
-        return this.notifyFrontend(FileStatus.Completed, finalDbAsset);
-    };
-    notifyFrontend = async (status, asset, feId) => {
-        if (status !== FileStatus.Completed && status !== FileStatus.Processing) {
-            const message = `Error while processing asset: ${status}\n Failed on \n  Asset: ${asset.feId}\n    Key: ${asset.key}\n   Type: ${asset.mimeType}\n   File: ${asset.name}`;
-            throw new ApiException(500, message);
-        }
-        this.logDebug(`notify FE about asset ${feId}: ${status}`);
-        return PushMessageBE_FileUploadStatus.push({ status, asset }, { feId: feId || asset.feId });
+            catch (e) {
+                //TODO delete the file and the temp doc
+                this.logError(`Error while processing asset: ${dbTempAsset.name}`, e);
+                return this.notifyFrontend(FileStatus.ErrorWhileProcessing, assetForApi);
+            }
+            if (dbTempAsset.public) {
+                try {
+                    // need to handle the response status!
+                    await file.makePublic();
+                }
+                catch (e) {
+                    return this.notifyFrontend(FileStatus.ErrorMakingPublic, assetForApi);
+                }
+            }
+            const finalDbAsset = await this.runTransaction(async (transaction) => {
+                const duplicatedAssets = await this.query.custom({ where: { md5Hash: dbTempAsset.md5Hash } }, transaction);
+                if (duplicatedAssets.length && duplicatedAssets[0]) {
+                    this.logWarning(`${dbTempAsset.feId} is a duplicated entry for ${duplicatedAssets[0]._id}`);
+                    return { ...duplicatedAssets[0], feId: dbTempAsset.feId };
+                }
+                const doc = this.collection.doc.item(assetForApi);
+                await ModuleBE_AssetsTemp.delete.unique(dbTempAsset._id, transaction);
+                const assetForMain = { ...dbTempAsset, _id: dbTempAsset._id };
+                return await doc.set(assetForMain, transaction);
+            });
+            return this.notifyFrontend(FileStatus.Completed, finalDbAsset);
+        };
+        notifyFrontend = async (status, asset, feId) => {
+            if (status !== FileStatus.Completed && status !== FileStatus.Processing) {
+                const message = `Error while processing asset: ${status}\n Failed on \n  Asset: ${asset.feId}\n    Key: ${asset.key}\n   Type: ${asset.mimeType}\n   File: ${asset.name}`;
+                throw new ApiException(500, message);
+            }
+            this.logDebug(`notify FE about asset ${feId}: ${status}`);
+            return PushMessageBE_FileUploadStatus.push({ status, asset }, { feId: feId || asset.feId });
+        };
     };
-}
+})();
+export { ModuleBE_AssetsDB_Class };
 export const ModuleBE_AssetsDB = new ModuleBE_AssetsDB_Class();

package/modules/ModuleBE_AssetsDeleted.d.ts

@@ -1,6 +1,6 @@
-import { DBProto_AssetsDeleted } from '@nu-art/file-upload-shared';
-import { ModuleBE_BaseDB } from '@nu-art/thunderstorm-backend';
-export declare class ModuleBE_AssetsDeleted_Class extends ModuleBE_BaseDB<DBProto_AssetsDeleted> {
+import { DatabaseDef_AssetsDeleted } from '@nu-art/file-upload-shared';
+import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
+export declare class ModuleBE_AssetsDeleted_Class extends ModuleBE_BaseDB<DatabaseDef_AssetsDeleted> {
     constructor();
 }
 export declare const ModuleBE_AssetsDeleted: ModuleBE_AssetsDeleted_Class;

package/modules/ModuleBE_AssetsDeleted.js

@@ -1,23 +1,5 @@
-/*
- * Permissions management system, define access level for each of
- * your server apis, and restrict users by giving them access levels
- *
- * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { DBDef_TempDeleted } from '@nu-art/file-upload-shared';
-import { ModuleBE_BaseDB } from '@nu-art/thunderstorm-backend';
+import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
 export class ModuleBE_AssetsDeleted_Class extends ModuleBE_BaseDB {
     constructor() {
         super(DBDef_TempDeleted);

package/modules/ModuleBE_AssetsStorage.d.ts

@@ -1,7 +1,10 @@
-import { OnSyncEnvCompleted } from '@nu-art/thunderstorm-backend';
 import { Module, TypedMap } from '@nu-art/ts-common';
 import { StorageWrapperBE } from '@nu-art/firebase-backend';
 import { DB_Asset } from '@nu-art/file-upload-shared';
+/** Local interface (replaces thunderstorm-backend). */
+export interface OnSyncEnvCompleted {
+    __onSyncEnvCompleted(env: string, baseUrl: string, requiredHeaders: TypedMap<string>): Promise<void>;
+}
 type Config = {
     batchItemCount: number;
 };

package/modules/ModuleBE_AssetsStorage.js

@@ -1,26 +1,6 @@
-/*
- * Permissions management system, define access level for each of
- * your server apis, and restrict users by giving them access levels
- *
- * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { AxiosHttpModule } from '@nu-art/thunderstorm-backend';
 import { filterInstances, Module, NotImplementedYetException } from '@nu-art/ts-common';
 import { ModuleBE_Firebase } from '@nu-art/firebase-backend';
 import { ApiDef_Assets } from '@nu-art/file-upload-shared';
-import { HttpMethod } from '@nu-art/thunderstorm-shared';
 import { ModuleBE_AssetsDB } from './ModuleBE_AssetsDB.js';
 export class ModuleBE_AssetsStorage_Class extends Module {
     storage;
@@ -46,29 +26,32 @@ export class ModuleBE_AssetsStorage_Class extends Module {
             assetsToSync = filterInstances(await Promise.all(dbAssets.map(async (dbAsset) => {
                 const fileWrapper = await this.getFile(dbAsset);
                 if (await fileWrapper.exists())
-                    return;
+                    return undefined;
                 return dbAsset;
             })));
             if (assetsToSync.length > 0)
                 continue;
-            assetsToSync.map(async (dbAsset) => {
+            for (const dbAsset of assetsToSync) {
+                const base = baseUrl.replace(/\/$/, '');
+                const path = ApiDef_Assets.getReadSignedUrl.path;
                 let _signedUrl;
                 try {
-                    const { signedUrl } = await AxiosHttpModule
-                        .createRequest({ ...ApiDef_Assets.vv1.getReadSignedUrl, baseUrl, })
-                        .setHeaders(requiredHeaders)
-                        .setBodyAsJson({ assetId: dbAsset._id })
-                        .executeSync();
-                    _signedUrl = signedUrl;
+                    const res = await fetch(`${base}/${path}`, {
+                        method: 'POST',
+                        headers: { ...requiredHeaders, 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ _id: dbAsset._id })
+                    });
+                    const data = await res.json();
+                    _signedUrl = data.signedUrl;
                 }
                 catch (e) {
                     console.log(e);
+                    continue;
                 }
-                const fileContent = await AxiosHttpModule.createRequest({ method: HttpMethod.GET, fullUrl: _signedUrl, path: '' })
-                    .setResponseType('text')
-                    .executeSync();
+                const fileRes = await fetch(_signedUrl);
+                const fileContent = await fileRes.text();
                 await (await this.getFile(dbAsset)).write(fileContent);
-            });
+            }
         } while (dbAssets.length > 0);
     }
     getReadSignedUrl = async (dbAsset) => (await (await this.getFile(dbAsset)).getReadSignedUrl()).signedUrl;

package/modules/ModuleBE_AssetsTemp.d.ts

@@ -1,6 +1,6 @@
-import { DBProto_AssetsTemp } from '@nu-art/file-upload-shared';
-import { ModuleBE_BaseDB } from '@nu-art/thunderstorm-backend';
-export declare class ModuleBE_AssetsTemp_Class extends ModuleBE_BaseDB<DBProto_AssetsTemp> {
+import { DatabaseDef_AssetsTemp } from '@nu-art/file-upload-shared';
+import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
+export declare class ModuleBE_AssetsTemp_Class extends ModuleBE_BaseDB<DatabaseDef_AssetsTemp> {
     constructor();
 }
 export declare const ModuleBE_AssetsTemp: ModuleBE_AssetsTemp_Class;

package/modules/ModuleBE_AssetsTemp.js

@@ -1,23 +1,5 @@
-/*
- * Permissions management system, define access level for each of
- * your server apis, and restrict users by giving them access levels
- *
- * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { DBDef_TempAssets } from '@nu-art/file-upload-shared';
-import { ModuleBE_BaseDB } from '@nu-art/thunderstorm-backend';
+import { ModuleBE_BaseDB } from '@nu-art/db-api-backend';
 export class ModuleBE_AssetsTemp_Class extends ModuleBE_BaseDB {
     constructor() {
         super(DBDef_TempAssets);

package/modules/ModuleBE_BucketListener.d.ts

@@ -1,6 +1,19 @@
 import { ModuleBE_StorageListener } from '@nu-art/firebase-backend';
-import { DefaultDef_ServiceAccount, RequiresServiceAccount, ServiceAccountCredentials } from '@nu-art/thunderstorm-backend/modules/_tdb/service-accounts';
 import { StorageEvent } from 'firebase-functions/storage';
+/** Local types (replaces thunderstorm-backend service-accounts). */
+export type ServiceAccountCredentials = {
+    serviceAccount?: {
+        accountId?: string;
+    };
+};
+export interface RequiresServiceAccount {
+    __requiresServiceAccount(): DefaultDef_ServiceAccount;
+}
+export type DefaultDef_ServiceAccount = {
+    moduleName: string;
+    email: string;
+    groupIds: string[];
+};
 export interface OnAssetUploaded {
     __processAsset(filePath?: string): void;
 }

package/modules/ModuleBE_BucketListener.js

@@ -29,7 +29,7 @@ export class ModuleBE_BucketListener_Class extends ModuleBE_StorageListener {
         // need to create a dispatch that collects a list of services that requires service account and
         // service account details, the permissions  create project will create these account for the rest of the system ;
         return new MemStorage().init(async () => {
-            const accountId = this.config.serviceAccount.accountId;
+            const accountId = this.config?.serviceAccount?.accountId;
             if (!accountId)
                 throw new BadImplementationException('Need to perform project setup to setup this feature');
             MemKey_AccountId.set(accountId);

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@nu-art/file-upload-backend",
-  "version": "0.401.8",
+  "version": "0.500.0",
   "description": "File Uploader - Express & Typescript based backend framework Backend",
   "keywords": [
     "TacB0sS",
     "infra",
     "nu-art",
     "storm",
-    "thunderstorm",
     "typescript"
   ],
   "homepage": "https://github.com/nu-art-js/file-upload",
@@ -31,21 +30,23 @@
     "build": "tsc"
   },
   "dependencies": {
-    "@nu-art/file-upload-shared": "0.401.8",
+    "@nu-art/file-upload-shared": "0.500.0",
     "@google-cloud/common": "^5.0.2",
     "@google-cloud/firestore": "^7.11.0",
     "@google-cloud/storage": "^7.15.0",
-    "@nu-art/firebase-backend": "0.401.8",
-    "@nu-art/firebase-shared": "0.401.8",
-    "@nu-art/permissions-backend": "0.401.8",
-    "@nu-art/permissions-shared": "0.401.8",
-    "@nu-art/push-pub-sub-backend": "0.401.8",
-    "@nu-art/push-pub-sub-shared": "0.401.8",
-    "@nu-art/thunderstorm-backend": "0.401.8",
-    "@nu-art/thunderstorm-shared": "0.401.8",
-    "@nu-art/ts-common": "0.401.8",
-    "@nu-art/user-account-backend": "0.401.8",
-    "@nu-art/user-account-shared": "0.401.8",
+    "@nu-art/firebase-backend": "0.500.0",
+    "@nu-art/firebase-shared": "0.500.0",
+    "@nu-art/permissions-backend": "0.500.0",
+    "@nu-art/permissions-shared": "0.500.0",
+    "@nu-art/push-pub-sub-backend": "0.500.0",
+    "@nu-art/push-pub-sub-shared": "0.500.0",
+    "@nu-art/api-types": "{{THUNDERSTORM_VERSION}}",
+    "@nu-art/db-api-backend": "0.500.0",
+    "@nu-art/db-api-shared": "0.500.0",
+    "@nu-art/http-server": "{{THUNDERSTORM_VERSION}}",
+    "@nu-art/ts-common": "0.500.0",
+    "@nu-art/user-account-backend": "0.500.0",
+    "@nu-art/user-account-shared": "0.500.0",
     "express": "^4.18.2",
     "file-type": "^21.0.0",
     "firebase": "^11.9.0",