@nu-art/firebase-frontend 0.400.5

package/ModuleFE_Firebase.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Created by tacb0ss on 25/08/2018.
+ */
+import { Module } from '@nu-art/ts-common';
+import { FirebaseSessionFE } from './auth/FirebaseSessionFE.js';
+import { SwFirebaseSessionFE } from './auth/SwFirebaseSessionFE.js';
+import { FirebaseConfig } from '@nu-art/firebase-shared';
+type ConfigType = {
+    [s: string]: FirebaseConfig;
+};
+export declare class ModuleFE_Firebase_Class extends Module<ConfigType> {
+    private sessions;
+    private swSession?;
+    createSwSession(): Promise<SwFirebaseSessionFE>;
+    private createLocalSession;
+    private fetchLocalConfig;
+    createSession(projectId?: string | FirebaseConfig, token?: string): Promise<FirebaseSessionFE>;
+    private createSessionWithConfigs;
+    private getProjectAuth;
+    private initiateSession;
+    private checkConfig;
+}
+export declare const ModuleFE_Firebase: ModuleFE_Firebase_Class;
+export {};

package/ModuleFE_Firebase.js

@@ -0,0 +1,100 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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.
+ */
+/**
+ * Created by tacb0ss on 25/08/2018.
+ */
+import { __stringify, BadImplementationException, ImplementationMissingException, Module } from '@nu-art/ts-common';
+import { FirebaseSessionFE } from './auth/FirebaseSessionFE.js';
+import { SwFirebaseSessionFE } from './auth/SwFirebaseSessionFE.js';
+const localSessionId = 'local';
+export class ModuleFE_Firebase_Class extends Module {
+    sessions = {};
+    swSession;
+    async createSwSession() {
+        const swSession = this.swSession;
+        if (swSession)
+            return swSession;
+        const localSession = await this.createLocalSession();
+        return this.swSession = new SwFirebaseSessionFE(localSessionId, localSession.app);
+    }
+    async createLocalSession(token) {
+        let session = this.sessions[localSessionId];
+        if (session)
+            return session;
+        let localConfig = this.getProjectAuth(localSessionId);
+        if (!localConfig)
+            localConfig = await this.fetchLocalConfig();
+        this.checkConfig(localConfig, localSessionId);
+        // I need to recheck because since it is an async op there might be race conditions
+        session = this.sessions[localSessionId];
+        if (session)
+            return session;
+        return this.initiateSession(localSessionId, localConfig, token);
+    }
+    fetchLocalConfig = async () => {
+        try {
+            const resp = await fetch('/__/firebase/init.json');
+            const config = await resp.json();
+            // @ts-ignore
+            this.setConfig({ [localSessionId]: config });
+            return config;
+        }
+        catch (e) {
+            throw new ImplementationMissingException(`Either specify configs for the 'ModuleBE_Firebase' or use SDK auto-configuration with firebase hosting`, e);
+        }
+    };
+    async createSession(projectId, token) {
+        if (!projectId)
+            return this.createLocalSession(token);
+        if (typeof projectId === 'object')
+            return this.createSessionWithConfigs(projectId, token);
+        const session = this.sessions[projectId];
+        if (session)
+            return session;
+        this.logInfo(`Creating session for config: ${projectId}`);
+        const config = this.getProjectAuth(projectId);
+        this.checkConfig(config, projectId);
+        return this.initiateSession(projectId, config, token);
+    }
+    async createSessionWithConfigs(config, token) {
+        if (!config || !config.projectId || !config.databaseURL || !config.authDomain || !config.apiKey)
+            throw new BadImplementationException(`Config: ${__stringify(config)} is not a credentials pattern`);
+        const projectId = config.projectId + (token || '');
+        // @ts-ignore
+        this.setConfig({ [projectId]: config });
+        return this.createSession(projectId, token);
+    }
+    getProjectAuth(projectId) {
+        return this.config?.[projectId];
+    }
+    async initiateSession(projectId, config, token) {
+        const session = new FirebaseSessionFE(projectId, config);
+        this.sessions[projectId] = session;
+        session.connect();
+        if (token)
+            await session.signInWithToken(token);
+        return session;
+    }
+    checkConfig(config, projectId) {
+        if (!config)
+            throw new BadImplementationException('Did you forget to add ModuleBE_Firebase to the main.ts in the modules array?');
+        if (!config || !config.projectId || !config.apiKey || !config.authDomain)
+            throw new BadImplementationException(`Config for key ${projectId} is not an Admin credentials pattern`);
+    }
+}
+export const ModuleFE_Firebase = new ModuleFE_Firebase_Class();

package/ModuleFE_FirebaseListener/ModuleFE_FirebaseListener.d.ts

@@ -0,0 +1,52 @@
+import { FirebaseApp } from 'firebase/app';
+import { Database, DataSnapshot } from 'firebase/database';
+import { Logger, Module } from '@nu-art/ts-common';
+import 'firebase/database';
+type FirebaseConfig = {
+    apiKey: string;
+    authDomain: string;
+    databaseURL: string;
+    projectId: string;
+    appId: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    measurementId?: string;
+};
+type EmulatorConfig = {
+    hostname: string;
+    port: number;
+    ssl?: boolean;
+    httpsPort?: number;
+};
+type FirebaseListenerConfig = {
+    emulatorConfig?: EmulatorConfig;
+    firebaseConfig: FirebaseConfig;
+};
+export declare class ModuleFE_FirebaseListener_Class extends Module<FirebaseListenerConfig> {
+    app: FirebaseApp;
+    database: Database;
+    protected init(): void;
+    getDatabase(): Database;
+    createListener(nodePath: string): RefListenerFE;
+}
+/**
+ * Firebase Realtime Database rules need to allow reading the nodes that are being queried.
+ * <p>"<b>Permission Denied</b>" errors in dev console imply permission is not allowed in the db's rules.
+ */
+export declare class RefListenerFE<Value = any> extends Logger {
+    private readonly nodePath;
+    private toUnsubscribeFunction?;
+    constructor(nodePath: string);
+    private getQuery;
+    /**
+     * Receives initial value and listens henceforth.
+     */
+    startListening(onValueChangedListener: (snapshot: DataSnapshot) => void): this;
+    /**
+     * One time get the value.
+     */
+    get(): Promise<Value>;
+    stopListening(): void;
+}
+export declare const ModuleFE_FirebaseListener: ModuleFE_FirebaseListener_Class;
+export {};

package/ModuleFE_FirebaseListener/ModuleFE_FirebaseListener.js

@@ -0,0 +1,95 @@
+import { initializeApp } from 'firebase/app';
+import { connectDatabaseEmulator, get, getDatabase, onValue, query, ref } from 'firebase/database';
+import { __stringify, _keys, exists, filterInstances, ImplementationMissingException, Logger, Module } from '@nu-art/ts-common';
+import 'firebase/database';
+const MandatoryFirebaseConfigKeys = ['apiKey', 'authDomain', 'databaseURL', 'projectId', 'appId'];
+export class ModuleFE_FirebaseListener_Class extends Module {
+    app;
+    database;
+    init() {
+        if (!this.config.firebaseConfig)
+            throw new ImplementationMissingException('Could not initialize firebase listener, did not provide FE firebase config!');
+        const configObjectKeys = _keys(this.config.firebaseConfig);
+        const missingKeys = filterInstances(MandatoryFirebaseConfigKeys.map(key => configObjectKeys.includes(key) ? undefined : key));
+        if (missingKeys.length > 0)
+            throw new ImplementationMissingException(`Could not initialize firebase listener, FE firebase config is missing props: ${__stringify(missingKeys)}`);
+        this.app = initializeApp(this.config.firebaseConfig);
+    }
+    getDatabase() {
+        if (this.database)
+            return this.database;
+        const _database = getDatabase(this.app);
+        const emulatorConfig = this.config.emulatorConfig;
+        if (exists(emulatorConfig)) {
+            connectDatabaseEmulator(_database, emulatorConfig.hostname, emulatorConfig.port);
+        }
+        return this.database = _database;
+    }
+    createListener(nodePath) {
+        this.logDebug(`Creating listener for firebase rtdb node ${nodePath}`);
+        return new RefListenerFE(nodePath);
+    }
+}
+/**
+ * Firebase Realtime Database rules need to allow reading the nodes that are being queried.
+ * <p>"<b>Permission Denied</b>" errors in dev console imply permission is not allowed in the db's rules.
+ */
+export class RefListenerFE extends Logger {
+    nodePath;
+    toUnsubscribeFunction;
+    constructor(nodePath) {
+        super(`RefListenerFE('${nodePath}')`);
+        this.nodePath = nodePath;
+    }
+    getQuery() {
+        const db = ModuleFE_FirebaseListener.getDatabase();
+        return query(ref(db, this.nodePath));
+    }
+    /**
+     * Receives initial value and listens henceforth.
+     */
+    startListening(onValueChangedListener) {
+        if (this.toUnsubscribeFunction) {
+            this.logWarning('RefListener asked to listen mid-listening. Stopping to listen prior to re-listening');
+            this.stopListening();
+        }
+        this.logDebug('Starting to listen...');
+        const refQuery = this.getQuery();
+        try {
+            this.toUnsubscribeFunction = onValue(refQuery, (snapshot) => {
+                onValueChangedListener(snapshot);
+            }, error => {
+                this.logError('Failed receiving value with error', error);
+            });
+        }
+        catch (e) {
+            this.logWarning(`Failed listening on node data, check if your rtdb rules permit reading this node '${this.nodePath}'`);
+            throw e;
+        }
+        this.logDebug(`Listening.`);
+        return this;
+    }
+    /**
+     * One time get the value.
+     */
+    async get() {
+        try {
+            const dataSnapshot = await get(this.getQuery());
+            return dataSnapshot.val();
+        }
+        catch (e) {
+            this.logWarning(`Failed getting node data, check if your rtdb rules permit reading this node '${this.nodePath}'`);
+            throw e;
+        }
+    }
+    stopListening() {
+        if (!this.toUnsubscribeFunction) {
+            this.logWarning('RefListener asked to stop listening but unsubscribeFunction does not exist.');
+            return;
+        }
+        this.logInfo('RefListener asked to stop listening');
+        this.toUnsubscribeFunction();
+        this.toUnsubscribeFunction = undefined;
+    }
+}
+export const ModuleFE_FirebaseListener = new ModuleFE_FirebaseListener_Class();

package/analytics/AnalyticsWrapperFE.d.ts

@@ -0,0 +1,34 @@
+import { Logger } from '@nu-art/ts-common';
+import { FirebaseType_CallOptions, FirebaseType_EventNameString } from './types.js';
+import { CustomParams } from 'firebase/analytics';
+import { FirebaseApp } from 'firebase/app';
+/**
+ AnalyticsWrapperFE provides a wrapper around the Firebase Analytics library for frontend (FE) use.
+ It provides methods for setting user IDs, setting the current screen, enabling or disabling analytics collection,
+ setting custom user properties, and logging events.
+ */
+export declare class AnalyticsWrapperFE extends Logger {
+    private readonly analytics;
+    constructor(app: FirebaseApp);
+    setUserId(userId: string, options?: FirebaseType_CallOptions): void;
+    /**
+     * Set the current screen for the user
+     * @param screenName
+     * @param options
+     */
+    setCurrentScreen(screenName: string, options?: FirebaseType_CallOptions): void;
+    /**
+     * Enable or disable analytics collection
+     * @param enabled
+     */
+    setAnalyticsCollectionEnabled(enabled: boolean): void;
+    /**
+     * Set custom user properties for analytics
+     * @param properties
+     * @param options
+     */
+    setUserProperties(properties: CustomParams, options?: FirebaseType_CallOptions): void;
+    logEvent(eventName: FirebaseType_EventNameString | string, eventParams?: {
+        [key: string]: any;
+    }, options?: FirebaseType_CallOptions): void;
+}

package/analytics/AnalyticsWrapperFE.js

@@ -0,0 +1,61 @@
+/*
+ * 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 { Logger } from '@nu-art/ts-common';
+import { getAnalytics, logEvent, setAnalyticsCollectionEnabled, setCurrentScreen, setUserId, setUserProperties, } from 'firebase/analytics';
+/**
+ AnalyticsWrapperFE provides a wrapper around the Firebase Analytics library for frontend (FE) use.
+ It provides methods for setting user IDs, setting the current screen, enabling or disabling analytics collection,
+ setting custom user properties, and logging events.
+ */
+export class AnalyticsWrapperFE extends Logger {
+    analytics;
+    constructor(app) {
+        super();
+        this.analytics = getAnalytics(app);
+    }
+    setUserId(userId, options) {
+        setUserId(this.analytics, userId, options);
+    }
+    /**
+     * Set the current screen for the user
+     * @param screenName
+     * @param options
+     */
+    setCurrentScreen(screenName, options) {
+        setCurrentScreen(this.analytics, screenName, options);
+    }
+    /**
+     * Enable or disable analytics collection
+     * @param enabled
+     */
+    setAnalyticsCollectionEnabled(enabled) {
+        setAnalyticsCollectionEnabled(this.analytics, enabled);
+    }
+    /**
+     * Set custom user properties for analytics
+     * @param properties
+     * @param options
+     */
+    setUserProperties(properties, options) {
+        setUserProperties(this.analytics, properties);
+    }
+    logEvent(eventName, eventParams, options) {
+        return logEvent(this.analytics, eventName, eventParams, options);
+    }
+}

package/analytics/ModuleFE_Analytics.d.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nu-art/ts-common';
+declare class FirebaseAnalyticsModule_Class extends Module {
+    private analytics?;
+    protected init(): void;
+    private _init;
+    logEvent(eventName: string, eventParams?: {
+        [key: string]: any;
+    }): void;
+    setCurrentScreen(screenName: string): void;
+}
+export declare const FirebaseAnalyticsModule: FirebaseAnalyticsModule_Class;
+export {};

package/analytics/ModuleFE_Analytics.js

@@ -0,0 +1,41 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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 { ImplementationMissingException, Module } from '@nu-art/ts-common';
+import { ModuleFE_Firebase } from '../ModuleFE_Firebase.js';
+class FirebaseAnalyticsModule_Class extends Module {
+    analytics;
+    init() {
+        this.runAsync('Init Analytics', this._init);
+    }
+    _init = async () => {
+        const session = await ModuleFE_Firebase.createSession();
+        this.analytics = session.getAnalytics();
+        this.analytics.setAnalyticsCollectionEnabled(true);
+    };
+    logEvent(eventName, eventParams) {
+        if (!this.analytics)
+            throw new ImplementationMissingException('Missing analytics wrapper');
+        return this.analytics.logEvent(eventName, eventParams);
+    }
+    setCurrentScreen(screenName) {
+        if (!this.analytics)
+            throw new ImplementationMissingException('Missing analytics wrapper');
+        return this.analytics.setCurrentScreen(screenName);
+    }
+}
+export const FirebaseAnalyticsModule = new FirebaseAnalyticsModule_Class();

package/analytics/types.d.ts

@@ -0,0 +1,4 @@
+import { Analytics, AnalyticsCallOptions, EventNameString } from 'firebase/analytics';
+export type FirebaseType_Analytics = Analytics;
+export type FirebaseType_CallOptions = AnalyticsCallOptions;
+export type FirebaseType_EventNameString = EventNameString;

package/analytics/types.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/auth/FirebaseSessionFE.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Created by tacb0ss on 19/09/2018.
+ */
+import { Logger } from '@nu-art/ts-common';
+import { MessagingWrapperFE } from '../messaging/MessagingWrapperFE.js';
+import { AnalyticsWrapperFE } from '../analytics/AnalyticsWrapperFE.js';
+import { DatabaseWrapperFE } from '../database/DatabaseWrapperFE.js';
+import { FirebaseApp } from 'firebase/app';
+import { FirebaseConfig } from '@nu-art/firebase-shared';
+export declare class FirebaseSessionFE extends Logger {
+    app: FirebaseApp;
+    protected config: FirebaseConfig;
+    protected sessionName: string;
+    protected messaging?: MessagingWrapperFE;
+    protected analytics?: AnalyticsWrapperFE;
+    protected database?: DatabaseWrapperFE;
+    constructor(sessionName: string, config: FirebaseConfig);
+    connect(): void;
+    /**
+     * Returns an instance of the MessagingWrapperFE class if it exists, or creates and returns a new instance if it does not
+     */
+    getMessaging(): MessagingWrapperFE;
+    /**
+     * Returns an instance of the AnalyticsWrapperFE class if it exists, or creates and returns a new instance if it does not
+     */
+    getAnalytics(): AnalyticsWrapperFE;
+    /**
+     * Returns an instance of the DatabaseWrapperFE class if it exists, or creates and returns a new instance if it does not
+     */
+    getDatabase(): DatabaseWrapperFE;
+    /**
+     * Authenticates the user with the given token
+     * @param token
+     */
+    signInWithToken(token: string): Promise<import("firebase/auth").UserCredential>;
+    /**
+     * Signs out the currently authenticated user
+     */
+    signOut(): Promise<void>;
+    getProjectId(): string;
+}

package/auth/FirebaseSessionFE.js

@@ -0,0 +1,88 @@
+/*
+ * 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.
+ */
+/**
+ * Created by tacb0ss on 19/09/2018.
+ */
+import { Logger, ThisShouldNotHappenException } from '@nu-art/ts-common';
+import { MessagingWrapperFE } from '../messaging/MessagingWrapperFE.js';
+import { AnalyticsWrapperFE } from '../analytics/AnalyticsWrapperFE.js';
+import { DatabaseWrapperFE } from '../database/DatabaseWrapperFE.js';
+import { getAuth, signInWithCustomToken, signOut } from 'firebase/auth';
+import { initializeApp } from 'firebase/app';
+// import auth = firebase.auth;
+export class FirebaseSessionFE extends Logger {
+    app;
+    config;
+    sessionName;
+    messaging;
+    analytics;
+    database;
+    constructor(sessionName, config) {
+        super(`firebase: ${sessionName}`);
+        this.sessionName = sessionName;
+        this.config = config;
+    }
+    connect() {
+        this.app = initializeApp(this.config, this.sessionName);
+    }
+    /**
+     * Returns an instance of the MessagingWrapperFE class if it exists, or creates and returns a new instance if it does not
+     */
+    getMessaging() {
+        if (this.messaging)
+            return this.messaging;
+        return this.messaging = new MessagingWrapperFE(this.app);
+    }
+    /**
+     * Returns an instance of the AnalyticsWrapperFE class if it exists, or creates and returns a new instance if it does not
+     */
+    getAnalytics() {
+        if (this.analytics)
+            return this.analytics;
+        return this.analytics = new AnalyticsWrapperFE(this.app);
+    }
+    /**
+     * Returns an instance of the DatabaseWrapperFE class if it exists, or creates and returns a new instance if it does not
+     */
+    getDatabase() {
+        if (this.database)
+            return this.database;
+        return this.database = new DatabaseWrapperFE(this.app);
+    }
+    /**
+     * Authenticates the user with the given token
+     * @param token
+     */
+    async signInWithToken(token) {
+        return signInWithCustomToken(getAuth(this.app), token);
+    }
+    /**
+     * Signs out the currently authenticated user
+     */
+    async signOut() {
+        return signOut(getAuth(this.app));
+    }
+    getProjectId() {
+        if (!this.config)
+            throw new ThisShouldNotHappenException('Missing config. Probably init not resolved yet!');
+        if (!this.config.projectId)
+            throw new ThisShouldNotHappenException('Could not deduce project id from session config.. if you need the functionality.. add it to the config!!');
+        return this.config.projectId;
+    }
+}

package/auth/SwFirebaseSessionFE.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Created by tacb0ss on 19/09/2018.
+ */
+import { FirebaseApp } from 'firebase/app';
+import 'firebase/auth';
+import { Logger } from '@nu-art/ts-common';
+import { SwMessagingWrapperFE } from '../messaging/SwMessagingWrapperFE.js';
+export declare class SwFirebaseSessionFE extends Logger {
+    app: FirebaseApp;
+    protected sessionName: string;
+    protected messaging?: SwMessagingWrapperFE;
+    constructor(sessionName: string, app: FirebaseApp);
+    getMessaging(): SwMessagingWrapperFE;
+}

package/auth/SwFirebaseSessionFE.js

@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+// tslint:disable:no-import-side-effect
+import 'firebase/auth';
+import { Logger } from '@nu-art/ts-common';
+// noinspection TypeScriptPreferShortImport
+import { SwMessagingWrapperFE } from '../messaging/SwMessagingWrapperFE.js';
+import { getMessaging } from 'firebase/messaging';
+export class SwFirebaseSessionFE extends Logger {
+    app;
+    sessionName;
+    messaging;
+    constructor(sessionName, app) {
+        super(`service worker firebase: ${sessionName}`);
+        this.sessionName = sessionName;
+        this.app = app;
+    }
+    getMessaging() {
+        if (this.messaging)
+            return this.messaging;
+        return this.messaging = new SwMessagingWrapperFE(getMessaging(this.app));
+    }
+}

package/database/DatabaseWrapperFE.d.ts

@@ -0,0 +1,16 @@
+import { Logger, TS_Object } from '@nu-art/ts-common';
+import { FirebaseApp } from 'firebase/app';
+export declare class DatabaseWrapperFE extends Logger {
+    private readonly database;
+    constructor(app: FirebaseApp);
+    get<T>(path: string): Promise<T | null>;
+    listen<T>(path: string, callback: (value: T) => void): import("firebase/database").Unsubscribe;
+    private getRef;
+    set<T>(path: string, value: T): Promise<void>;
+    /** @deprecated */
+    update<T extends TS_Object>(path: string, value: T): Promise<void>;
+    patch<T extends TS_Object>(path: string, value: T): Promise<void>;
+    /** @deprecated */
+    remove(path: string, assertionRegexp?: string): Promise<void>;
+    delete(path: string, assertionRegexp?: string): Promise<void>;
+}

package/database/DatabaseWrapperFE.js

@@ -0,0 +1,81 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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 { BadImplementationException, Logger } from '@nu-art/ts-common';
+import { getDatabase, onValue, ref, remove, set, update } from 'firebase/database';
+export class DatabaseWrapperFE extends Logger {
+    database;
+    constructor(app) {
+        super();
+        this.database = getDatabase(app);
+    }
+    async get(path) {
+        return new Promise((resolve, reject) => {
+            onValue(this.getRef(path), snapshot => {
+                resolve(snapshot.val());
+            }, (error) => {
+                reject(error);
+            }, { onlyOnce: true });
+        });
+    }
+    listen(path, callback) {
+        return onValue(this.getRef(path), snapshot => {
+            callback(!snapshot || snapshot.val());
+        }, (error) => {
+            throw new BadImplementationException(`Error while getting value from path: ${path}`, error);
+        }, { onlyOnce: false });
+    }
+    getRef = (path) => ref(this.database, path);
+    async set(path, value) {
+        try {
+            await set(this.getRef(path), value);
+        }
+        catch (e) {
+            throw new BadImplementationException(`Error while setting value to path: ${path}`);
+        }
+    }
+    /** @deprecated */
+    async update(path, value) {
+        this.logWarning('update will be deprecated!! please use patch');
+        return this.patch(path, value);
+    }
+    async patch(path, value) {
+        try {
+            await update(this.getRef(path), value);
+        }
+        catch (e) {
+            throw new BadImplementationException(`Error while updating value to path: ${path}`);
+        }
+    }
+    /** @deprecated */
+    async remove(path, assertionRegexp = '^/.*?/.*') {
+        this.logWarning('remove will be deprecated!! please use delete');
+        return this.delete(path, assertionRegexp);
+    }
+    async delete(path, assertionRegexp = '^/.*?/.*') {
+        if (!path)
+            throw new BadImplementationException(`Falsy value, path: '${path}'`);
+        if (!path.match(new RegExp(assertionRegexp)))
+            throw new BadImplementationException(`path: '${path}'  does not match assertion: '${assertionRegexp}'`);
+        try {
+            await remove(this.getRef(path));
+        }
+        catch (e) {
+            throw new BadImplementationException(`Error while removing path: ${path}`);
+        }
+    }
+}

package/database/types.d.ts

@@ -0,0 +1,2 @@
+import { Database } from 'firebase/database';
+export type FirebaseType_DB = Database;

package/database/types.js

@@ -0,0 +1,18 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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,4 @@
+export * from './auth/FirebaseSessionFE.js';
+export * from './ModuleFE_Firebase.js';
+export * from './analytics/ModuleFE_Analytics.js';
+export * from './messaging/MessagingWrapperFE.js';

package/index.js

@@ -0,0 +1,22 @@
+/*
+ * 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 * from './auth/FirebaseSessionFE.js';
+export * from './ModuleFE_Firebase.js';
+export * from './analytics/ModuleFE_Analytics.js';
+export * from './messaging/MessagingWrapperFE.js';

package/messaging/MessagingWrapperFE.d.ts

@@ -0,0 +1,23 @@
+import { Logger } from '@nu-art/ts-common';
+import { FirebaseType_Unsubscribe } from './types.js';
+import { GetTokenOptions, MessagePayload, NextFn, Observer } from 'firebase/messaging';
+import { FirebaseApp } from 'firebase/app';
+/**
+ Firebase Messaging wrapper
+ */
+export declare class MessagingWrapperFE extends Logger {
+    private readonly messaging;
+    private callback?;
+    private token?;
+    /**
+     * Constructor for the MessagingWrapperFE class
+     * @param app
+     */
+    constructor(app: FirebaseApp);
+    getToken(options?: GetTokenOptions): Promise<string>;
+    /**
+     Deletes the current Firebase Messaging token for the client
+     */
+    deleteToken(): Promise<void>;
+    onMessage(callback: NextFn<MessagePayload> | Observer<MessagePayload>): FirebaseType_Unsubscribe | void;
+}

package/messaging/MessagingWrapperFE.js

@@ -0,0 +1,55 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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 { Logger } from '@nu-art/ts-common';
+import { deleteToken, getMessaging, getToken, onMessage } from 'firebase/messaging';
+/**
+ Firebase Messaging wrapper
+ */
+export class MessagingWrapperFE extends Logger {
+    messaging;
+    callback;
+    token;
+    /**
+     * Constructor for the MessagingWrapperFE class
+     * @param app
+     */
+    constructor(app) {
+        super();
+        this.messaging = getMessaging(app);
+    }
+    async getToken(options) {
+        this.token = await getToken(this.messaging, options);
+        if (this.callback)
+            this.onMessage(this.callback);
+        return this.token;
+    }
+    /**
+     Deletes the current Firebase Messaging token for the client
+     */
+    async deleteToken() {
+        this.logVerbose('Deleting firebase messaging token');
+        await deleteToken(this.messaging);
+        delete this.token;
+    }
+    onMessage(callback) {
+        this.callback = callback;
+        if (!this.token)
+            return;
+        return onMessage(this.messaging, callback);
+    }
+}

package/messaging/SwMessagingWrapperFE.d.ts

@@ -0,0 +1,7 @@
+import { Logger } from '@nu-art/ts-common';
+import { FirebaseType_Messaging } from './types.js';
+export declare class SwMessagingWrapperFE extends Logger {
+    private readonly messaging;
+    constructor(messaging: FirebaseType_Messaging);
+    onBackgroundMessage(callback: (payload: any) => void): void | import("firebase/messaging/sw").Unsubscribe;
+}

package/messaging/SwMessagingWrapperFE.js

@@ -0,0 +1,39 @@
+/*
+ * 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 { Logger } from '@nu-art/ts-common';
+import { onBackgroundMessage } from 'firebase/messaging/sw';
+export class SwMessagingWrapperFE extends Logger {
+    messaging;
+    constructor(messaging) {
+        super();
+        this.messaging = messaging;
+    }
+    onBackgroundMessage(callback) {
+        // This means that the bundle is being evaluated in the main thread to register the service worker so there is no need to run the rest
+        // Also because it would fail since firebase would initialize the messaging controller as the main thread one instead of the sw one...
+        if (!self || !('ServiceWorkerGlobalScope' in self))
+            return this.logWarning('Not a service worker context');
+        this.logInfo('This is a service worker context');
+        return onBackgroundMessage(this.messaging, {
+            next: callback,
+            error: error => this.logWarning(error),
+            complete: () => this.logInfo('Successfully set on background messaging')
+        });
+    }
+}

package/messaging/types.d.ts

@@ -0,0 +1,3 @@
+import { Messaging, Unsubscribe } from 'firebase/messaging';
+export type FirebaseType_Messaging = Messaging;
+export type FirebaseType_Unsubscribe = Unsubscribe;

package/messaging/types.js

@@ -0,0 +1,18 @@
+/*
+ * Firebase is a simpler Typescript wrapper to all of firebase services.
+ *
+ * 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/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@nu-art/firebase-frontend",
+  "version": "0.400.5",
+  "description": "Storm - Express & Typescript based backend framework Frontend",
+  "keywords": [
+    "TacB0sS",
+    "infra",
+    "nu-art",
+    "storm",
+    "thunderstorm",
+    "typescript"
+  ],
+  "homepage": "https://github.com/nu-art-js/firebase",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/firebase/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/firebase.git"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "files": [
+    "**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "run-tests": "firebase emulators:exec \"npm run test\"",
+    "test": "ts-mocha -w -p src/test/tsconfig.json --timeout 0 --inspect=8107 --watch-files '**/*.ts' src/test/firestore-v2/__test.ts",
+    "rtv2": "firebase emulators:exec \"npm run test-v2\"",
+    "test-v2": "ts-mocha -w -p src/test/tsconfig.json --timeout 0 --inspect=8107 --watch-files '**/*.ts' src/test/firestore-v2/__test.ts"
+  },
+  "dependencies": {
+    "@nu-art/firebase-shared": "0.400.5",
+    "@google-cloud/common": "^5.0.2",
+    "@google-cloud/firestore": "^7.11.0",
+    "@google-cloud/storage": "^7.15.0",
+    "@nu-art/ts-common": "0.400.5",
+    "express": "^4.18.2",
+    "firebase": "^11.9.0",
+    "firebase-admin": "13.4.0",
+    "firebase-functions": "6.3.2",
+    "google-auth-library": "^10.0.0",
+    "http-proxy": "1.18.1",
+    "url": "0.11.3",
+    "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "@types/compression": "^1.0.1",
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^10.0.1",
+    "@types/http-proxy": "1.17.14",
+    "teeny-request": "~7.2.0",
+    "@types/ws": "^8.5.5"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    }
+  }
+}