@progressive-development/pd-spa-helper 0.1.159 → 0.1.161

package/package.json

@@ -3,7 +3,7 @@
   "description": "Webcomponent pd-spa-helper following open-wc recommendations",
   "license": "MIT",
   "author": "pd-spa-helper",
-  "version": "0.1.159",
+  "version": "0.1.161",
   "main": "dist/src/index.js",
   "module": "dist/src/index.js",
   "exports": {

package/src/index.ts

@@ -31,7 +31,8 @@ export {
   loginImpl,
   logoutImpl,
   isAuthenticatedImpl,
-  callFunctionImpl
+  callFunctionImpl,
+  uploadFile
 } from './service-provider/service-provider-impl.js'
 
 export { pdStore } from './store/mini-rx.store.js';

package/src/service-provider/firebase/firestorage-client.ts

@@ -0,0 +1,82 @@
+import { FirebaseApp } from 'firebase/app';
+import { FirebaseStorage, StorageReference, UploadResult, getStorage, ref, uploadString } from "firebase/storage";
+
+import { FileStorageConfig, UploadFile } from '../service-provider-model.js';
+
+const DEFAULT_STORAGE = "default_storage";
+
+const storageMap:Map<string, {  
+  storage: FirebaseStorage,
+  references?: {
+    key: string,
+    storageRef:  StorageReference
+  }[],
+}> = new Map();
+
+/**
+ * During start/load application, initialize functions.
+ *
+ * @param {*} app - initialized app.
+ */
+export const initFirestorage = (app: FirebaseApp, defaultStorage?: string, storageConfig?: FileStorageConfig) => {
+  try {
+
+    // add default storage
+    if (defaultStorage) {
+      storageMap.set(DEFAULT_STORAGE, {
+        storage: getStorage(app)
+      });
+    }    
+    
+    // add specific storages
+    storageConfig?.storage.forEach(storeConfig => {
+
+      const storage = getStorage(app, storeConfig.name);
+      const storageRootRef = ref(storage);
+
+      storageMap.set(storeConfig.name, {
+        storage,
+        references: [
+          {
+            key: "ROOT",
+            storageRef: storageRootRef
+          },
+          ...storeConfig.references.map(refConfigString => ({
+            key: refConfigString,
+            storageRef: ref(storageRootRef, refConfigString)
+          }))
+        ]
+      });
+    });            
+
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+export const uploadFirestorageFile = (file: UploadFile):Promise<UploadResult> => {  
+
+  if (!storageMap || storageMap.size === 0) {
+    throw new Error("No storage is configured");
+  }  
+
+  // get storage
+  const {storageName, referenceKey, subFolderName, fileName} = file;
+  const storageConf = storageMap.get(storageName || DEFAULT_STORAGE);
+  if (!storageConf ) {
+    throw new Error(`Invalid storage name: ${storageName || DEFAULT_STORAGE}`);
+  }  
+  if (!storageConf.references || storageConf.references.length === 0) {
+    throw new Error(`No references configured for storage: ${storageName || DEFAULT_STORAGE}`);
+  }
+
+  // get reference to path
+  const uploadRefConf = referenceKey ? (storageConf.references.filter(filterRef => filterRef.key === referenceKey)[0]) : storageConf.references[0];
+  if (!uploadRefConf || !uploadRefConf.storageRef) {
+    throw new Error(`No valid reference for key: ${referenceKey}`);
+  }
+
+  // create file reference and upload
+  const fileRef = ref(uploadRefConf.storageRef, subFolderName ? `${subFolderName}/${fileName}` : fileName);
+  return uploadString(fileRef, file.base64DataURL, 'data_url');
+};

package/src/service-provider/mock/storage-client.ts

@@ -0,0 +1,124 @@
+import { FileStorageConfig, UploadFile } from '../service-provider-model.js';
+
+
+const DEFAULT_STORAGE = "default_storage";
+
+
+// Download file in mock implementation
+const downloadFile = (buffer: ArrayBuffer) => {
+  const data: Blob = new Blob([buffer], {
+      type: 'image/png'
+  });
+  const url= window.URL.createObjectURL(data);
+  window.open(url);
+}
+
+const base64ToArrayBuffer = (base64:string) => {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i+=1) {
+      bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+
+
+class MockStorage {
+
+  private _name: string;
+
+  constructor(storageName: string) {
+    this._name = storageName;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  uploadFile(filePath: string, file: UploadFile): Promise<any> {
+    downloadFile(
+      base64ToArrayBuffer(file.base64DataURL)
+    );
+    return Promise.resolve({
+      fullPath: filePath
+    });
+  }
+
+}
+
+const storageMap:Map<string, {  
+  storage: MockStorage,
+  references?: {
+    key: string,
+    storageRef:  string
+  }[],
+}> = new Map();
+
+/**
+ * During start/load application, initialize functions.
+ *
+ * @param {*} app - initialized app.
+ */
+export const initStorageMock = (defaultStorage?: string, storageConfig?: FileStorageConfig) => {
+  console.log("Init mock Storage");
+  try {
+
+    // add default storage
+    if (defaultStorage) {
+      storageMap.set(DEFAULT_STORAGE, {
+        storage: new MockStorage(DEFAULT_STORAGE)
+      });
+    }    
+    
+    // add specific storages
+    storageConfig?.storage.forEach(storeConfig => {
+
+      const storage = new MockStorage(storeConfig.name);
+      const storageRootRef = "/";
+
+      storageMap.set(storeConfig.name, {
+        storage,
+        references: [
+          {
+            key: "ROOT",
+            storageRef: storageRootRef
+          },
+          ...storeConfig.references.map(refConfigString => ({
+            key: refConfigString,
+            storageRef: `${storageRootRef}/${refConfigString}`
+          }))
+        ]
+      });
+    });            
+
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+
+export const uploadStorageFileMock = (file: UploadFile):Promise<any> => {  
+
+  if (!storageMap || storageMap.size === 0) {
+    throw new Error("No storage is configured");
+  }  
+
+  // get storage
+  const {storageName, referenceKey, subFolderName, fileName} = file;
+  const storageConf = storageMap.get(storageName || DEFAULT_STORAGE);
+  if (!storageConf ) {
+    throw new Error(`Invalid storage name: ${storageName || DEFAULT_STORAGE}`);
+  }  
+  if (!storageConf.references || storageConf.references.length === 0) {
+    throw new Error(`No references configured for storage: ${storageName || DEFAULT_STORAGE}`);
+  }
+
+  // get reference to path
+  const uploadRefConf = referenceKey ? (storageConf.references.filter(filterRef => filterRef.key === referenceKey)[0]) : storageConf.references[0];
+  if (!uploadRefConf || !uploadRefConf.storageRef) {
+    throw new Error(`No valid reference for key: ${referenceKey}`);
+  }
+
+  // create file reference and upload
+  const fileRef = `${uploadRefConf.storageRef}/${subFolderName ? `${subFolderName}/${fileName}` : fileName}`;  
+  return storageConf.storage.uploadFile(fileRef, file);
+};
+
+

package/src/service-provider/service-provider-impl.ts

@@ -1,12 +1,14 @@
-import { FirebaseApp, initializeApp } from "firebase/app";
+import { FirebaseApp, FirebaseOptions, initializeApp } from "firebase/app";
 
 import { authStateChanged, isAuthenticated, login, logout } from "./firebase/auth.js";
 import { authStateChangedMock, isAuthenticatedMock, loginMock, logoutMock } from "./mock/auth.js";
-import { AppConfiguration, FunctionDefinition, FunctionResult, FunctionsConfig, ServiceProviderConfiguration } from "./service-provider-model.js";
+import { AppConfiguration, FileStorageConfig, FunctionDefinition, FunctionResult, FunctionsConfig, ServiceProviderConfiguration, UploadFile } from "./service-provider-model.js";
 import { callFunction, initFunctions } from "./firebase/functions-client.js";
 import { initFirestore } from "./firebase/firestore-client.js";
 import { callFunctionMock, initMockResponse } from "./mock/function-client.js";
 import { ServiceCallController } from "../service-call-controller2.js";
+import { initFirestorage, uploadFirestorageFile } from "./firebase/firestorage-client.js";
+import { initStorageMock, uploadStorageFileMock } from "./mock/storage-client.js";
 
 let provider: ServiceProviderConfiguration | undefined;
 let controller: ServiceCallController;
@@ -27,22 +29,30 @@ export const initController = (controllerParam: ServiceCallController) => {
   controller = controllerParam
 }
 
-const initFirebaseApplicationServices = (firebaseApp: FirebaseApp, functionsConfig: FunctionsConfig) => {
+const initFirebaseApplicationServices = (
+  firebaseApp: FirebaseApp, 
+  functionsConfig: FunctionsConfig,   
+  firebaseConfig: FirebaseOptions,
+  storageConfig?: FileStorageConfig, 
+) => {
   // do something with the app, init db, firestore and functions    
   initFunctions(firebaseApp, functionsConfig);
-  initFirestore(firebaseApp);
+  initFirestore(firebaseApp);  
+  initFirestorage(firebaseApp, firebaseConfig.storageBucket, storageConfig);
+  
 }
 
 export const initAppImpl = (config: AppConfiguration) => {
 
   if (provider === "firebase" && config.firebaseConfig) {
     const app:FirebaseApp = initializeApp(config.firebaseConfig);
-    if (config.functionsConfig) {
+    if (config.functionsConfig) { // TODO: invalid if only storage config exists
       // init application services (functions, store)    
-      initFirebaseApplicationServices(app, config.functionsConfig);
+      initFirebaseApplicationServices(app, config.functionsConfig, config.firebaseConfig, config.storageConfig);
     }
   } else if (provider === "mock") {
     initMockResponse(config.mock);
+    initStorageMock("default", config.storageConfig);
   } else {
     throwUndefinedProviderError();
   }
@@ -131,3 +141,16 @@ export const logoutImpl = () => {
   }     
   return throwUndefinedProviderError();  
 }
+
+/* #####################
+ * Storage Implementation
+ * ##################### */
+export const uploadFile = (file: UploadFile): Promise<unknown> => {  
+  if (provider === "firebase") {
+    return uploadFirestorageFile(file);        
+  } 
+  if (provider === "mock") {
+    return uploadStorageFileMock(file)
+  }
+  return throwUndefinedProviderError();  
+}

package/src/service-provider/service-provider-model.ts

@@ -96,6 +96,15 @@ export interface StoreConfig {
   effects: Array<any>
 }
 
+export interface FileStorage {
+  name: string,
+  references: string[]  
+}
+
+export interface FileStorageConfig {
+  storage: FileStorage[],
+}
+
 export interface AppConfiguration {  
   serviceProvider?: ServiceProviderConfiguration,
   mock?: {
@@ -105,7 +114,16 @@ export interface AppConfiguration {
   navigationConfigParam: NavigationConfig;
   storeConfigParam?: StoreConfig;
   firebaseConfig?: FirebaseOptions;
+  storageConfig?: FileStorageConfig;
   functionsConfig?: FunctionsConfig;
 }
 
+export interface UploadFile {  
+  fileName: string,
+  base64DataURL:string,
+  storageName?: string
+  referenceKey?: string
+  subFolderName?: string,
+}
+