@nu-art/file-upload-shared 0.400.7

package/assets/apis.d.ts

@@ -0,0 +1,33 @@
+import { ApiDef, ApiDefResolver, BodyApi, HttpMethod, QueryApi } from '@nu-art/thunderstorm-shared';
+import { DB_Asset } from './types1.js';
+import { DB_BaseObject } from '@nu-art/ts-common';
+import { UI_Asset } from './types.js';
+import { ResponseError } from '@nu-art/ts-common/core/exceptions/types';
+import { FileStatus } from '../types.js';
+export type SignedUrl = {
+    signedUrl: string;
+};
+export type TempSignedUrl = SignedUrl & {
+    asset: DB_Asset;
+};
+export type ApiStruct_Assets = {
+    vv1: {
+        getReadSignedUrl: BodyApi<SignedUrl, DB_BaseObject>;
+    };
+};
+export declare const ApiDef_Assets: ApiDefResolver<ApiStruct_Assets>;
+export type FileUploadResult = {
+    status: FileStatus;
+    asset: DB_Asset;
+};
+export type Api_UploadFile = BodyApi<FileUploadResult, any, any, ResponseError, HttpMethod.PUT>;
+export declare const ApiDef_UploadFile: ApiDef<Api_UploadFile>;
+export type ApiStruct_AssetUploader = {
+    vv1: {
+        getUploadUrl: BodyApi<TempSignedUrl[], UI_Asset[]>;
+        processAssetManually: QueryApi<void[], {
+            feId?: string;
+        }>;
+    };
+};
+export declare const ApiDef_AssetUploader: ApiDefResolver<ApiStruct_AssetUploader>;

package/assets/apis.js

@@ -0,0 +1,13 @@
+import { HttpMethod } from '@nu-art/thunderstorm-shared';
+export const ApiDef_Assets = {
+    vv1: {
+        getReadSignedUrl: { method: HttpMethod.POST, path: 'v1/assets/get-read-signed-url' },
+    }
+};
+export const ApiDef_UploadFile = { method: HttpMethod.PUT, path: '' };
+export const ApiDef_AssetUploader = {
+    vv1: {
+        getUploadUrl: { method: HttpMethod.POST, path: 'v1/upload/get-url' },
+        processAssetManually: { method: HttpMethod.GET, path: 'v1/upload/process-asset-manually' },
+    }
+};

package/assets/db-def.d.ts

@@ -0,0 +1,5 @@
+import { DBDef_V3 } from '@nu-art/ts-common';
+import { DBProto_Assets, DBProto_AssetsDeleted, DBProto_AssetsTemp } from './types.js';
+export declare const DBDef_Assets: DBDef_V3<DBProto_Assets>;
+export declare const DBDef_TempAssets: DBDef_V3<DBProto_AssetsTemp>;
+export declare const DBDef_TempDeleted: DBDef_V3<DBProto_AssetsDeleted>;

package/assets/db-def.js

@@ -0,0 +1,59 @@
+import { convertUpperCamelCase, tsValidateBoolean, tsValidateDynamicObject, tsValidateExists, tsValidateMustExist, tsValidateNonMandatoryObject, tsValidateNumber, tsValidateRegexp, tsValidateString } from '@nu-art/ts-common';
+import { AssetDBGroup } from './types.js';
+const Validator_ModifiableProps = {
+    name: tsValidateRegexp(/^.{3,}$/),
+    ext: tsValidateExists(true),
+    feId: tsValidateExists(true),
+    mimeType: tsValidateExists(true),
+    key: tsValidateExists(true),
+};
+const Validator_GeneratedProps = {
+    md5Hash: tsValidateExists(false),
+    path: tsValidateExists(true),
+    bucketName: tsValidateExists(true),
+    public: tsValidateBoolean(false),
+    metadata: tsValidateDynamicObject(tsValidateMustExist, tsValidateString(), false),
+    timestamp: tsValidateNumber(),
+    signedUrl: tsValidateNonMandatoryObject({
+        url: tsValidateString(),
+        validUntil: tsValidateNumber()
+    })
+};
+export const DBDef_Assets = {
+    modifiablePropsValidator: Validator_ModifiableProps,
+    generatedPropsValidator: Validator_GeneratedProps,
+    versions: ['1.0.2', '1.0.1', '1.0.0'],
+    dbKey: 'assets',
+    entityName: convertUpperCamelCase('Assets', '-').toLowerCase(),
+    frontend: {
+        group: AssetDBGroup,
+        name: 'asset'
+    },
+    backend: {
+        name: 'assets',
+    }
+};
+export const DBDef_TempAssets = {
+    ...DBDef_Assets,
+    dbKey: 'assets-temp',
+    entityName: 'assets-temp',
+    frontend: {
+        group: AssetDBGroup,
+        name: 'temp'
+    },
+    backend: {
+        name: 'assets-temp',
+    }
+};
+export const DBDef_TempDeleted = {
+    ...DBDef_Assets,
+    dbKey: 'assets-deleted',
+    entityName: 'assets-deleted',
+    frontend: {
+        group: AssetDBGroup,
+        name: 'deleted'
+    },
+    backend: {
+        name: 'assets-deleted',
+    }
+};

package/assets/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './db-def.js';
+export * from './apis.js';

package/assets/index.js

@@ -0,0 +1,20 @@
+/*
+ * User secured registration and login management system..
+ *
+ * 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.
+ */
+export * from './types.js';
+export * from './db-def.js';
+export * from './apis.js';

package/assets/messages.d.ts

@@ -0,0 +1,27 @@
+import { PushMessage } from '@nu-art/push-pub-sub-shared';
+import { DB_Asset } from './types1.js';
+export declare const PushKey_FileUploaded = "file-uploaded";
+export declare enum FileStatus {
+    Idle = "Idle",
+    ObtainingUrl = "ObtainingUrl",
+    UrlObtained = "UrlObtained",
+    UploadingFile = "UploadingFile",
+    WaitingForProcessing = "WaitingForProcessing",
+    Processing = "Processing",
+    PostProcessing = "PostProcessing",
+    Completed = "Completed",
+    ErrorWhileProcessing = "ErrorWhileProcessing",
+    ErrorMakingPublic = "ErrorMakingPublic",
+    ErrorNoValidator = "ErrorNoValidator",
+    ErrorNoConfig = "ErrorNoConfig",
+    ErrorRetrievingMetadata = "ErrorRetrievingMetadata",
+    Error = "Error"
+}
+type FileUploadResult = {
+    status: FileStatus;
+    asset: DB_Asset;
+};
+export type PushMessage_FileUploaded = PushMessage<'file-uploaded', {
+    feId: string;
+}, FileUploadResult>;
+export {};

package/assets/messages.js

@@ -0,0 +1,18 @@
+export const PushKey_FileUploaded = 'file-uploaded';
+export var FileStatus;
+(function (FileStatus) {
+    FileStatus["Idle"] = "Idle";
+    FileStatus["ObtainingUrl"] = "ObtainingUrl";
+    FileStatus["UrlObtained"] = "UrlObtained";
+    FileStatus["UploadingFile"] = "UploadingFile";
+    FileStatus["WaitingForProcessing"] = "WaitingForProcessing";
+    FileStatus["Processing"] = "Processing";
+    FileStatus["PostProcessing"] = "PostProcessing";
+    FileStatus["Completed"] = "Completed";
+    FileStatus["ErrorWhileProcessing"] = "ErrorWhileProcessing";
+    FileStatus["ErrorMakingPublic"] = "ErrorMakingPublic";
+    FileStatus["ErrorNoValidator"] = "ErrorNoValidator";
+    FileStatus["ErrorNoConfig"] = "ErrorNoConfig";
+    FileStatus["ErrorRetrievingMetadata"] = "ErrorRetrievingMetadata";
+    FileStatus["Error"] = "Error";
+})(FileStatus || (FileStatus = {}));

package/assets/types.d.ts

@@ -0,0 +1,36 @@
+import { DB_Object, DBProto, Proto_DB_Object, TS_Object, VersionsDeclaration } from '@nu-art/ts-common';
+export declare const AssetDBGroup = "asset";
+type VersionTypes_Asset = {
+    '1.0.0': DB_Asset;
+    '1.0.1': DB_Asset;
+    '1.0.2': DB_Asset;
+};
+type Versions = VersionsDeclaration<['1.0.2', '1.0.1', '1.0.0'], VersionTypes_Asset>;
+type Dependencies = {};
+type UniqueKeys = '_id';
+type GeneratedKeys = 'signedUrl' | 'timestamp' | 'md5Hash' | 'path' | 'bucketName' | 'public' | 'metadata';
+type ProtoAssets = Proto_DB_Object<DB_Asset, 'assets', GeneratedKeys, Versions, UniqueKeys, Dependencies>;
+export type DBProto_Assets = DBProto<ProtoAssets>;
+type ProtoAssetsTemp = Proto_DB_Object<DB_Asset, 'assets-temp', GeneratedKeys, Versions, UniqueKeys, Dependencies>;
+export type DBProto_AssetsTemp = DBProto<ProtoAssetsTemp>;
+type ProtoAssetsDeleted = Proto_DB_Object<DB_Asset, 'assets-deleted', GeneratedKeys, Versions, UniqueKeys, Dependencies>;
+export type DBProto_AssetsDeleted = DBProto<ProtoAssetsDeleted>;
+export type UI_Asset = DBProto_Assets['uiType'];
+export type DB_Asset = DB_Object & {
+    key: string;
+    name: string;
+    feId: string;
+    ext: string;
+    mimeType: string;
+    timestamp: number;
+    md5Hash?: string;
+    path: string;
+    bucketName: string;
+    public?: boolean;
+    metadata?: TS_Object;
+    signedUrl?: {
+        url: string;
+        validUntil: number;
+    };
+};
+export {};

package/assets/types.js

@@ -0,0 +1 @@
+export const AssetDBGroup = 'asset';

package/assets/types1.d.ts

@@ -0,0 +1,33 @@
+import { BaseHttpRequest } from '@nu-art/thunderstorm-shared';
+import { Auditable, DB_Object, TS_Object } from '@nu-art/ts-common';
+import { FileStatus } from '../types.js';
+export type Request_Uploader = {
+    name: string;
+    mimeType: string;
+    key?: string;
+    public?: boolean;
+    metadata?: TS_Object;
+};
+export type BaseUploaderFile = Request_Uploader & {
+    feId: string;
+};
+export type DB_Asset = DB_Object & BaseUploaderFile & Auditable & Required<Pick<BaseUploaderFile, 'key'>> & {
+    timestamp: number;
+    ext: string;
+    md5Hash?: string;
+    path: string;
+    bucketName: string;
+    signedUrl?: {
+        url: string;
+        validUntil: number;
+    };
+};
+export type FileInfo = {
+    status: FileStatus;
+    messageStatus?: string;
+    progress?: number;
+    name: string;
+    request?: BaseHttpRequest<any>;
+    file?: any;
+    asset?: DB_Asset;
+};

package/assets/types1.js

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+export {};

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './assets/index.js';
+export * from './types.js';

package/index.js

@@ -0,0 +1,2 @@
+export * from './assets/index.js';
+export * from './types.js';

package/modules/ModuleBase_AssetUploader.d.ts

@@ -0,0 +1,45 @@
+import { Dispatcher, Module } from '@nu-art/ts-common';
+import { ApiDef, ApiDefCaller, BaseHttpRequest, TypedApi } from '@nu-art/thunderstorm-shared';
+import { OnPushMessageReceived } from '@nu-art/push-pub-sub-shared';
+import { PushMessage_Payload } from '@nu-art/push-pub-sub-shared';
+import { FileStatus, PushMessage_FileUploaded } from '../assets/messages.js';
+import { DB_Asset, UI_Asset } from '../assets/types.js';
+import { ApiStruct_AssetUploader, TempSignedUrl } from '../assets/apis.js';
+import { OnFileStatusChanged } from '../types.js';
+export type FilesToUpload = UI_Asset & {
+    file: any;
+};
+export type FileInfo = {
+    status: FileStatus;
+    messageStatus?: string;
+    progress?: number;
+    name: string;
+    request?: BaseHttpRequest<any>;
+    file?: any;
+    asset?: DB_Asset;
+};
+export type UploaderConfig = {
+    manualProcessTriggering: boolean;
+    uploadQueueParallelCount?: number;
+};
+export declare abstract class ModuleBase_AssetUploader<Config extends UploaderConfig = UploaderConfig> extends Module<Config> implements OnPushMessageReceived<PushMessage_FileUploaded> {
+    protected vv1: ApiDefCaller<ApiStruct_AssetUploader>['vv1'];
+    protected files: {
+        [id: string]: FileInfo;
+    };
+    private readonly uploadQueue;
+    protected readonly dispatch_fileStatusChange: Dispatcher<OnFileStatusChanged, "__onFileStatusChanged", [id: string], void>;
+    protected constructor();
+    __onMessageReceived(notification: PushMessage_Payload<PushMessage_FileUploaded>): void;
+    init(): void;
+    protected abstract subscribeToPush(toSubscribe: TempSignedUrl[]): Promise<void>;
+    getFileInfo<K extends keyof FileInfo>(id: string, key: K): FileInfo[K] | undefined;
+    getFullFileInfo(id?: string): FileInfo | undefined;
+    protected setFileInfo<K extends keyof FileInfo>(feId: string, values: Partial<FileInfo>): void;
+    protected dispatchFileStatusChange(id: string): void;
+    uploadImpl(files: FilesToUpload[]): UI_Asset[];
+    private uploadFiles;
+    private uploadFile;
+    processAssetManually: (feId?: string) => void;
+    protected abstract createRequest<API extends TypedApi<any, any, any, any>>(uploadFile: ApiDef<API>): BaseHttpRequest<API>;
+}

package/modules/ModuleBase_AssetUploader.js

@@ -0,0 +1,142 @@
+/*
+ * 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 { __stringify, _keys, BadImplementationException, Dispatcher, Minute, Module, Queue } from '@nu-art/ts-common';
+import { HeaderKey_ContentType } from '@nu-art/thunderstorm-shared';
+import { FileStatus, PushKey_FileUploaded } from '../assets/messages.js';
+import { ApiDef_UploadFile } from '../assets/apis.js';
+export class ModuleBase_AssetUploader extends Module {
+    vv1;
+    files = {};
+    uploadQueue = new Queue('File Uploader').setParallelCount(1);
+    dispatch_fileStatusChange = new Dispatcher('__onFileStatusChanged');
+    constructor() {
+        super();
+        this.setDefaultConfig({ manualProcessTriggering: false });
+    }
+    __onMessageReceived(notification) {
+        if (notification.topic !== PushKey_FileUploaded)
+            return;
+        const data = notification.message;
+        if (!data)
+            return this.logError('file upload push without data');
+        const feId = data.asset.feId;
+        if (!feId)
+            return this.logError('file upload push without feId');
+        this.setFileInfo(feId, data);
+    }
+    init() {
+        if (this.config.uploadQueueParallelCount)
+            this.uploadQueue.setParallelCount(this.config.uploadQueueParallelCount);
+    }
+    getFileInfo(id, key) {
+        return this.files[id] && this.files[id][key];
+    }
+    getFullFileInfo(id) {
+        if (!id)
+            return undefined;
+        return this.files[id];
+    }
+    setFileInfo(feId, values) {
+        const fileInfo = this.files[feId];
+        if (!fileInfo)
+            return this.logError(`file upload push received, but no file info exists for ${feId}`);
+        _keys(values).forEach(key => fileInfo[key] = values[key]);
+        this.dispatchFileStatusChange(feId);
+    }
+    dispatchFileStatusChange(id) {
+        this.dispatch_fileStatusChange.dispatchModule(id);
+    }
+    uploadImpl(files) {
+        const body = files.map(fileData => {
+            const { file, ...fileInfo } = fileData;
+            this.files[fileInfo.feId] = {
+                file,
+                status: FileStatus.ObtainingUrl,
+                name: fileData.name
+            };
+            return fileInfo;
+        });
+        this.vv1.getUploadUrl?.(body)
+            .execute(async (response) => {
+            body.forEach(f => this.setFileInfo(f.feId, { status: FileStatus.UrlObtained }));
+            if (!response)
+                return;
+            // Not a relevant await but still...
+            await this.uploadFiles(response);
+        });
+        return body;
+    }
+    uploadFiles = async (response) => {
+        // Subscribe
+        await this.subscribeToPush(response);
+        response.forEach(r => {
+            const feId = r.asset.feId;
+            this.uploadQueue.addItem(async () => {
+                await this.uploadFile(r);
+                delete this.files[feId].file;
+                this.setFileInfo(feId, { progress: 0 });
+                //TODO: Probably need to set a timer here in case we dont get a push back (contingency)
+            }, () => {
+                this.setFileInfo(feId, { status: FileStatus.WaitingForProcessing });
+                if (this.config.manualProcessTriggering)
+                    this.processAssetManually(feId);
+            }, error => {
+                this.setFileInfo(feId, {
+                    messageStatus: __stringify(error),
+                    status: FileStatus.Error
+                });
+            });
+        });
+    };
+    uploadFile = async (response) => {
+        const feId = response.asset.feId;
+        this.setFileInfo(feId, {
+            status: FileStatus.UploadingFile,
+            asset: response.asset
+        });
+        const fileInfo = this.files[feId];
+        if (!fileInfo)
+            throw new BadImplementationException(`Missing file with id ${feId} and name: ${response.asset.name}`);
+        const request = this.createRequest(ApiDef_UploadFile)
+            .setUrl(response.signedUrl)
+            .setHeader(HeaderKey_ContentType, response.asset.mimeType)
+            .setTimeout(20 * Minute)
+            .setBody(fileInfo.file)
+            .setOnProgressListener((ev) => {
+            this.setFileInfo(feId, { progress: ev.loaded / ev.total });
+        });
+        fileInfo.request = request;
+        await request.executeSync();
+        // const request = this.vv1.uploadFile(fileInfo.file, undefined as never)
+        // 	.setUrl(response.signedUrl);
+        // const request = this
+        // 	.httpModule
+        // 	.createRequest(HttpMethod.PUT, RequestKey_UploadFile, feId)
+    };
+    processAssetManually = (feId) => {
+        const request = this.vv1.processAssetManually({ feId });
+        // const request = this
+        // 	.httpModule
+        // 	.createRequest<Api_ProcessAssetManually>(HttpMethod.GET, RequestKey_ProcessAssetManually, feId)
+        // 	.setRelativeUrl('v1/upload/process-asset-manually');
+        if (feId)
+            request.setUrlParam('feId', feId);
+        request.execute();
+    };
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@nu-art/file-upload-shared",
+  "version": "0.400.7",
+  "description": "File Uploader - Express & Typescript based backend framework Shared",
+  "keywords": [
+    "TacB0sS",
+    "infra",
+    "nu-art",
+    "storm",
+    "thunderstorm",
+    "typescript"
+  ],
+  "homepage": "https://github.com/nu-art-js/file-upload",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/file-upload/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/file-upload.git"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "files": [
+    "**/*"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@nu-art/firebase-shared": "0.400.7",
+    "@nu-art/ts-styles": "0.400.7",
+    "@nu-art/push-pub-sub-shared": "0.400.7",
+    "@nu-art/permissions-shared": "0.400.7",
+    "@nu-art/user-account-shared": "0.400.7",
+    "@nu-art/thunderstorm-shared": "0.400.7",
+    "@nu-art/ts-common": "0.400.7",
+    "@google-cloud/common": "^5.0.2",
+    "@google-cloud/storage": "^7.15.0",
+    "@google-cloud/firestore": "^7.11.0",
+    "react": "^18.0.0",
+    "jszip": "^3.2.2",
+    "express": "^4.18.2",
+    "firebase": "^11.9.0",
+    "firebase-admin": "13.4.0",
+    "firebase-functions": "6.3.2",
+    "google-auth-library": "^10.0.0",
+    "file-type": "^21.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/compression": "^1.0.1",
+    "@types/express": "^4.17.17"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    }
+  }
+}

package/types.d.ts

@@ -0,0 +1,20 @@
+export declare const PushKey_FileUploaded = "file-uploaded";
+export declare enum FileStatus {
+    Idle = "Idle",
+    ObtainingUrl = "ObtainingUrl",
+    UrlObtained = "UrlObtained",
+    UploadingFile = "UploadingFile",
+    WaitingForProcessing = "WaitingForProcessing",
+    Processing = "Processing",
+    PostProcessing = "PostProcessing",
+    Completed = "Completed",
+    ErrorWhileProcessing = "ErrorWhileProcessing",
+    ErrorMakingPublic = "ErrorMakingPublic",
+    ErrorNoValidator = "ErrorNoValidator",
+    ErrorNoConfig = "ErrorNoConfig",
+    ErrorRetrievingMetadata = "ErrorRetrievingMetadata",
+    Error = "Error"
+}
+export interface OnFileStatusChanged {
+    __onFileStatusChanged: (id: string) => void;
+}

package/types.js

@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+export const PushKey_FileUploaded = 'file-uploaded';
+export var FileStatus;
+(function (FileStatus) {
+    FileStatus["Idle"] = "Idle";
+    FileStatus["ObtainingUrl"] = "ObtainingUrl";
+    FileStatus["UrlObtained"] = "UrlObtained";
+    FileStatus["UploadingFile"] = "UploadingFile";
+    FileStatus["WaitingForProcessing"] = "WaitingForProcessing";
+    FileStatus["Processing"] = "Processing";
+    FileStatus["PostProcessing"] = "PostProcessing";
+    FileStatus["Completed"] = "Completed";
+    FileStatus["ErrorWhileProcessing"] = "ErrorWhileProcessing";
+    FileStatus["ErrorMakingPublic"] = "ErrorMakingPublic";
+    FileStatus["ErrorNoValidator"] = "ErrorNoValidator";
+    FileStatus["ErrorNoConfig"] = "ErrorNoConfig";
+    FileStatus["ErrorRetrievingMetadata"] = "ErrorRetrievingMetadata";
+    FileStatus["Error"] = "Error";
+})(FileStatus || (FileStatus = {}));