@progressive-development/pd-spa-helper 0.3.102 → 0.3.104

package/src/service-provider/mock/auth.ts

@@ -1,86 +0,0 @@
-import { pdStore } from "../../store/mini-rx.store";
-
-/*
- * Only for temporary development:
- * Set to true/false if the user should hold only in session (login after each reload)
- * or in the localstore (login until the local store entry is invalid or not available).
- */
-const LOCALSTORE_ACTIV = true;
-const LOCALSTORE_ITEM_KEY = 'pdUserLogin';
-const HARDCODED_USER = 'mock@pd-spa-helper.com';
-const HARDCODED_PWD = 'mock';
-
-
-
-let loginAvailable: boolean | undefined;
-
-
-const checkLocalStore = () => {
-  const userItem =  localStorage.getItem(LOCALSTORE_ITEM_KEY);
-  return userItem === 'true';
-}
-
-
-export const logoutMock = async (): Promise<boolean> => {
-  console.log("Do MOCK logout");
-  loginAvailable = undefined;
-  if (LOCALSTORE_ACTIV) {
-      localStorage.removeItem(LOCALSTORE_ITEM_KEY);
-  }
-  return Promise.resolve(true);
-};
-
-export const isAuthenticatedMock = (): boolean => {
-  if (loginAvailable === undefined) {
-    console.log('MOCK: check authentication');
-    loginAvailable = LOCALSTORE_ACTIV ? checkLocalStore() : false;
-  }
-  return loginAvailable;
-} 
-
-export const getAuthUserMock = (): unknown => 
-  isAuthenticatedMock() ? {
-    uid: "34234234",
-    displayName: "userMockName"
-  } : undefined;
-
-
-let callbackLogin: Function;
-export const authStateChangedMock = (callback: Function) => {
-  callbackLogin = callback;
-  console.log("Not implemented for MOCK, do call once if authenticated");
-  if (isAuthenticatedMock()) {
-    callbackLogin(getAuthUserMock())
-  }
-}
-
-export const loginMock = async (user:string, sec:string): Promise<unknown> => {    
-
-  console.log('MOCK: do authentication for user: ', user);
-  let valid = false;
-  if (user === HARDCODED_USER && sec === HARDCODED_PWD) {
-      if (LOCALSTORE_ACTIV) {
-          localStorage.setItem(LOCALSTORE_ITEM_KEY, 'true');
-      }
-      valid = true;
-      loginAvailable = true;      
-  }
-
-  if (valid) {
-
-    const userMock = getAuthUserMock();
-    if (callbackLogin) {
-      callbackLogin(userMock)
-    }
-    return Promise.resolve(user);   
-  }
-
-  const err =  new Error("Invalid login");
-  const error: any = err;
-  error.code = "auth/wrong-password";
-  throw error;
-}
-
-
-
-

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

@@ -1,42 +0,0 @@
-import { FunctionDefinition, FunctionResult } from "../service-provider-model.js";
-
-const DEFAULT_TIMEOUT = 2000;
-
-let mockResponse: Map<string, Function>;
-let mockTimeout = DEFAULT_TIMEOUT;
-
-
-
-export const callFunctionMock = async (def: FunctionDefinition, functionInput: any): Promise<FunctionResult> => {
-  
-  let key;
-  if (functionInput?.detailsId) {
-    key = `${def.name}_${functionInput?.object}_detailsId`;
-  } else if (functionInput?.type) {
-      key = `${def.name}_${functionInput.object}_${functionInput.type}`;
-  } else {
-    key = `${def.name}_${functionInput?.object}`;
-  }
-  console.log("Mock function call", def, functionInput, key);
-
-  const timeout = () => new Promise((resolve) => {
-      window.setTimeout(() => {
-        resolve("Done");
-      }, mockTimeout);
-    });
-  await timeout();
-
-  if (mockResponse && mockResponse.has(key)) {        
-    return Promise.resolve(mockResponse.get(key)!(functionInput));
-  }
-
-  throw new Error("No data with right state available");
-}
-
-export const initMockResponse = (mock?: {
-  mockResponse?:  Map<string, Function>, 
-  mockWaitTime?: number
-  }) => {
-  mockResponse = mock?.mockResponse || new Map();
-  mockTimeout = mock?.mockWaitTime || DEFAULT_TIMEOUT;
-}

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

@@ -1,149 +0,0 @@
-import { FileStorageConfig, StorageDocument, 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 test = base64.replace("data:image/png;base64,", "");
-  const binaryString = atob(test);
-  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);
-};
-
-export const downloadFileMock = (file: StorageDocument) => {
-  alert("Not implemented for mock");
-  return Promise.resolve("");
-}
-
-export const getMockFileList = (
-  storageName: string, 
-  refKey: string,
-  subFolder?: string,
-  includeMetadata?: boolean
-):Promise<StorageDocument[]> => {
-  console.log("Searching for Documents in ", storageName, refKey, subFolder, includeMetadata);
-  return Promise.resolve([{
-    fileName: "workReport.png",
-    filePath: "workReports/1234234f2fswf/workReport.png",
-    documentType: "ToDo",
-    storageName, refKey
-  }]);
-};
-
-
-
-

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

@@ -1,286 +0,0 @@
-import { FirebaseApp, initializeApp } from "firebase/app";
-
-import { authStateChanged, getAuthUser, initAuth, isAuthenticated, login, logout } from "./firebase/auth.js";
-import { authStateChangedMock, getAuthUserMock, isAuthenticatedMock, loginMock, logoutMock } from "./mock/auth.js";
-import { 
-  AppConfiguration, CollectionContraint, FunctionDefinition, FunctionResult, 
-  ServiceProviderConfiguration, StorageDocument, UploadFile 
-} from "./service-provider-model.js";
-import { callFunction, initFunctions } from "./firebase/functions-client.js";
-import { getFirebaseCollectionListener, initFirestore } from "./firebase/firestore-client.js";
-import { callFunctionMock, initMockResponse } from "./mock/function-client.js";
-import { ServiceCallController } from "../service-call-controller2.js";
-import { deleteFirestorageDocument, downloadFileFirestorage, getFirestorageFile, getFirestorageFileList, initFirestorage, uploadFirestorageFile } from "./firebase/firestorage-client.js";
-import { downloadFileMock, getMockFileList, initStorageMock, uploadStorageFileMock } from "./mock/storage-client.js";
-import { activateTokenChangeHandler, getFirebaseMessaging, prepareMessaging, registerDevice } from "./firebase/messagingFirebaseClient.js";
-
-let provider: ServiceProviderConfiguration | undefined;
-let controller: ServiceCallController;
-let app:FirebaseApp;
-
-const throwUndefinedProviderError = () => {
-  throw new Error("Undefined service provider, please check configuration. 'firebase' or 'mock' allowed here.");
-}
-
-/* #####################
- * Init Implementation
- * ##################### */
-
-export const setServiceProvider = (providerParam?: ServiceProviderConfiguration) => {
-  provider = providerParam;
-}
-
-export const initController = (controllerParam: ServiceCallController) => {
-  controller = controllerParam
-}
-
-const initFirebaseApplicationServices = (
-  firebaseApp: FirebaseApp,
-  config: AppConfiguration
-) => {
-  
-  // ToDo: Init only of needed
-  initAuth(firebaseApp);
-  initFirestore(firebaseApp);
-
-  if (config.functionsConfig) {
-    initFunctions(firebaseApp, config.functionsConfig);
-    console.debug("Init provider functions");
-  }
-
-  if (config.firebaseConfig?.storageBucket && config.storageConfig) {
-    initFirestorage(
-      firebaseApp, 
-      config.firebaseConfig?.storageBucket, 
-      config.storageConfig
-    );
-    console.debug("Init provider storage");
-  }
-
-  if (config.messagingConfig) {
-    prepareMessaging(firebaseApp, config.messagingConfig);
-    console.debug("Set firebase app and config for messaging");
-
-    activateTokenChangeHandler(firebaseApp.name);
-    console.debug(`idTokenChangeHandler for messaging and app ${firebaseApp.name} activated`);
-  }
-
-  console.debug("Firebase initialized");  
-}
-
-export const initAppImpl = (config: AppConfiguration) => {
-
-  if (provider === "firebase" && config.firebaseConfig) {
-    app = initializeApp(config.firebaseConfig);    
-    // init application services (functions, store)    
-    initFirebaseApplicationServices(
-      app, 
-      config
-    );
-  } else if (provider === "mock") {
-    initMockResponse(config.mock);
-    initStorageMock("default", config.storageConfig);
-  } else {
-    throwUndefinedProviderError();
-  }
-}
-
-/* #####################
- * Functions Implementation
- * ##################### */
-export const callFunctionImpl = async (def: FunctionDefinition, functionInput: any): Promise<FunctionResult> => {
-  
-  const callController = (promise: Promise<any>) => {
-    if (controller) {
-      controller.callDataPromise = {func: def, promise};
-    }
-  }
-  
-  if (provider === "firebase") {
-    const promise = callFunction(def, functionInput)
-    callController(promise);
-    return promise;
-  } 
-  if (provider === "mock") {
-    const promise = callFunctionMock(def, functionInput)
-    callController(promise);
-    return promise;
-  }
-
-  return throwUndefinedProviderError();  
-}
-
-
-
-/* #####################
- * Auth Implementation
- * ##################### */
-
-
-export const authStateChangedImpl = (
-  callback: Function
-) => {
-  if (provider === "firebase") {
-    authStateChanged(callback);
-  } else if (provider === "mock") {
-    authStateChangedMock(callback);
-  } else {
-    throwUndefinedProviderError();
-  }
-}
-
-export const isAuthenticatedImpl = () => {
-  if (provider === "firebase") {
-    return isAuthenticated();
-  }   
-  if (provider === "mock") {
-    return isAuthenticatedMock();
-  }     
-  return throwUndefinedProviderError();  
-}
-
-export const loginImpl = (user: string, sec: string) => {
-
-  if (!user) {   
-    const returnError = new Error("empty user");
-    return Promise.reject(returnError);
-  }
-  if (!sec) {
-    const returnError = new Error("empty password");
-    return Promise.reject(returnError);
-  }
-
-  if (provider === "firebase") {
-    return login(user, sec);
-  }   
-  if (provider === "mock") {
-    return loginMock(user, sec);
-  }     
-  return throwUndefinedProviderError();  
-}
-
-export const logoutImpl = () => {
-  if (provider === "firebase") {
-    return logout();
-  }   
-  if (provider === "mock") {
-    return logoutMock();
-  }     
-  return throwUndefinedProviderError();  
-};
-
-// Refactor: Return defined USer Object
-export const getUser = () => {
-  if (provider === "firebase") {
-    return getAuthUser();
-  }   
-  if (provider === "mock") {
-    return getAuthUserMock();
-  }     
-  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();  
-}
-
-export const getStorageFileList = (
-  storageName: string, 
-  keyRef: string, 
-  subFolder?: string, 
-  includeMetadata?:boolean
-): Promise<StorageDocument[]> => {  
-  if (provider === "firebase") {
-    return getFirestorageFileList(storageName, keyRef, subFolder, includeMetadata);
-  }
-  if (provider === "mock") {
-    return getMockFileList(storageName, keyRef, subFolder, includeMetadata);
-  }
-  return throwUndefinedProviderError();  
-}
-
-export const getStorageFile = ( 
-  storageName: string, 
-  refKey:string,
-  storageURI: string,
-  includeMetaData: boolean,
-): Promise<StorageDocument> => {  
-  if (provider === "firebase") {
-    return getFirestorageFile(
-      storageName, refKey, storageURI, includeMetaData 
-    );
-  }
-  return throwUndefinedProviderError();  
-}
-
-export const downloadFile = (file: StorageDocument): Promise<unknown> => {  
-  if (provider === "firebase") {
-    return downloadFileFirestorage(file);
-  } 
-  if (provider === "mock") {
-    return downloadFileMock(file)
-  }
-  return throwUndefinedProviderError();  
-}
-
-export const deleteFile = (file: StorageDocument): Promise<unknown> => {  
-  if (provider === "firebase") {
-    return deleteFirestorageDocument(file);
-  }
-  return throwUndefinedProviderError();  
-}
-
-/* #########################################
- * Remote Database Implementation
- * ######################################### */
-export const activateCollectionListener = (
-  callback: Function, col: string, constraints?:CollectionContraint[]
-) => { 
-  if (provider === "firebase") {
-    return getFirebaseCollectionListener(callback, col, constraints);
-  } 
-  if (provider === "mock") {
-    console.log("getCollectionListener not implemented for MOCK, do noting");
-    return "";
-  }
-  return throwUndefinedProviderError();
-};
-
-
-/* #########################################
- * Messaging Implementation
- * ######################################### */
-export const registerAppDeviceForNotification = async (
-  registration: ServiceWorkerRegistration
-) => { 
-  if (provider === "firebase") {
-    return registerDevice(registration);
-  }
-  if (provider === "mock") {
-    console.log("registerAppDeviceForNotification not implemented for MOCK, do noting");
-    return Promise.resolve();
-  }
-  return throwUndefinedProviderError();
-};
-
-export const getMessagingImpl = () => {
-  if (provider === "firebase") {
-    return getFirebaseMessaging();
-  }
-  if (provider === "mock") {
-    console.log("getMessagingImpl not implemented for MOCK, do noting");
-    return undefined;
-  }
-  return throwUndefinedProviderError();
-};
-
-export const getApp = () => app;