@ph-cms/client-sdk 0.1.5 → 0.1.7

package/dist/hooks/useFirebaseAuthSync.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseAuthSync = exports.useFirebaseAuthSync = void 0;
+const react_1 = __importStar(require("react"));
+const context_1 = require("../context");
+/**
+ * `useFirebaseAuthSync`
+ *
+ * Subscribes to Firebase `onAuthStateChanged` and automatically synchronizes
+ * the Firebase authentication state with the PH-CMS backend:
+ *
+ * - **Firebase user signs in** and PH-CMS is not yet authenticated →
+ *   obtains a Firebase ID token and calls `loginWithFirebase({ idToken })`
+ *   which exchanges the token for PH-CMS access/refresh tokens and then
+ *   fetches the user profile via `/auth/me`.
+ *
+ * - **Firebase user signs out** and PH-CMS is still authenticated →
+ *   calls `logout()` on PH-CMS (configurable via `logoutOnFirebaseSignOut`).
+ *
+ * The hook must be rendered **inside** `<PHCMSProvider>` because it relies
+ * on context values (`isAuthenticated`, `isLoading`) and the `loginWithFirebase`
+ * / `logout` actions exposed by the auth module.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * import { useFirebaseAuthSync } from '@ph-cms/client-sdk';
+ * import { getAuth } from 'firebase/auth';
+ *
+ * const firebaseAuth = getAuth(firebaseApp);
+ *
+ * function App() {
+ *   useFirebaseAuthSync({ firebaseAuth });
+ *   return <MainContent />;
+ * }
+ * ```
+ */
+const useFirebaseAuthSync = (options) => {
+    const { firebaseAuth, logoutOnFirebaseSignOut = true, onSyncSuccess, onSyncError, } = options;
+    const { client, isAuthenticated, isLoading, refreshUser } = (0, context_1.usePHCMSContext)();
+    // Use refs for values that change frequently but should not re-trigger
+    // the effect (which would tear down and re-create the Firebase listener).
+    const isAuthenticatedRef = (0, react_1.useRef)(isAuthenticated);
+    const isLoadingRef = (0, react_1.useRef)(isLoading);
+    const syncInProgressRef = (0, react_1.useRef)(false);
+    const isSyncingStateRef = (0, react_1.useRef)(false);
+    const [isSyncing, setIsSyncing] = react_1.default.useState(false);
+    // Keep refs up to date.
+    (0, react_1.useEffect)(() => {
+        isAuthenticatedRef.current = isAuthenticated;
+    }, [isAuthenticated]);
+    (0, react_1.useEffect)(() => {
+        isLoadingRef.current = isLoading;
+    }, [isLoading]);
+    // Stable callback refs so the effect closure doesn't go stale.
+    const onSyncSuccessRef = (0, react_1.useRef)(onSyncSuccess);
+    const onSyncErrorRef = (0, react_1.useRef)(onSyncError);
+    (0, react_1.useEffect)(() => {
+        onSyncSuccessRef.current = onSyncSuccess;
+    }, [onSyncSuccess]);
+    (0, react_1.useEffect)(() => {
+        onSyncErrorRef.current = onSyncError;
+    }, [onSyncError]);
+    const handleFirebaseUser = (0, react_1.useCallback)(async (fbUser) => {
+        if (fbUser) {
+            // Firebase user is signed in.
+            // Only exchange if PH-CMS is not already authenticated and not loading.
+            if (!isAuthenticatedRef.current &&
+                !isLoadingRef.current &&
+                !syncInProgressRef.current) {
+                syncInProgressRef.current = true;
+                isSyncingStateRef.current = true;
+                setIsSyncing(true);
+                try {
+                    const idToken = await fbUser.getIdToken();
+                    await client.auth.loginWithFirebase({ idToken });
+                    // loginWithFirebase stores the tokens in the provider.
+                    // Now refresh the context so `isAuthenticated` and `user` update.
+                    await refreshUser();
+                    onSyncSuccessRef.current?.();
+                }
+                catch (error) {
+                    console.error('[useFirebaseAuthSync] Token exchange failed:', error);
+                    onSyncErrorRef.current?.(error);
+                }
+                finally {
+                    syncInProgressRef.current = false;
+                    isSyncingStateRef.current = false;
+                    setIsSyncing(false);
+                }
+            }
+        }
+        else {
+            // Firebase user signed out.
+            if (logoutOnFirebaseSignOut && isAuthenticatedRef.current) {
+                try {
+                    await client.auth.logout();
+                    await refreshUser();
+                }
+                catch (error) {
+                    console.error('[useFirebaseAuthSync] Logout failed:', error);
+                }
+            }
+        }
+    }, 
+    // `client`, `refreshUser`, and `logoutOnFirebaseSignOut` are stable
+    // across renders (client is a singleton, refreshUser is memoized,
+    // logoutOnFirebaseSignOut is typically a constant).
+    [client, refreshUser, logoutOnFirebaseSignOut]);
+    (0, react_1.useEffect)(() => {
+        // Dynamically import the listener so that this file has zero runtime
+        // dependency on firebase/auth at the module level. The `Auth` object
+        // passed in already carries the implementation; we just need the
+        // `onAuthStateChanged` function reference from it.
+        //
+        // Firebase Auth's `onAuthStateChanged` is available on the Auth object
+        // via the modular API through the standalone function, but we can also
+        // call it as `firebaseAuth.onAuthStateChanged(...)` which works on the
+        // Auth instance directly (compat style). However, the recommended
+        // modular approach is to use the standalone function.
+        //
+        // To avoid directly importing from 'firebase/auth' at the top level
+        // (since it's an optional peer dep), we use a dynamic import wrapped
+        // in a try-catch. If the import fails, we fall back to a noop.
+        let unsubscribe = null;
+        let cancelled = false;
+        const setup = async () => {
+            try {
+                // Dynamic import so builds without firebase don't break.
+                const firebaseAuthModule = await Promise.resolve().then(() => __importStar(require('firebase/auth')));
+                if (cancelled)
+                    return;
+                unsubscribe = firebaseAuthModule.onAuthStateChanged(firebaseAuth, (fbUser) => {
+                    // Fire and forget; errors are caught inside handleFirebaseUser.
+                    void handleFirebaseUser(fbUser);
+                });
+            }
+            catch {
+                // firebase/auth is not installed — this is fine, it's optional.
+                console.warn('[useFirebaseAuthSync] firebase/auth could not be imported. ' +
+                    'Make sure it is installed if you intend to use Firebase auth sync.');
+            }
+        };
+        void setup();
+        return () => {
+            cancelled = true;
+            unsubscribe?.();
+        };
+    }, [firebaseAuth, handleFirebaseUser]);
+    return { isSyncing };
+};
+exports.useFirebaseAuthSync = useFirebaseAuthSync;
+/**
+ * `<FirebaseAuthSync>`
+ *
+ * A convenience wrapper component that calls `useFirebaseAuthSync` internally.
+ * Place it **inside** `<PHCMSProvider>` and wrap the part of the tree that
+ * should wait for or react to Firebase↔PH-CMS auth synchronization.
+ *
+ * ### Example
+ *
+ * ```tsx
+ * import { PHCMSProvider, FirebaseAuthSync } from '@ph-cms/client-sdk';
+ * import { getAuth } from 'firebase/auth';
+ *
+ * const firebaseAuth = getAuth(firebaseApp);
+ *
+ * function App() {
+ *   return (
+ *     <PHCMSProvider client={client}>
+ *       <FirebaseAuthSync firebaseAuth={firebaseAuth}>
+ *         <MainContent />
+ *       </FirebaseAuthSync>
+ *     </PHCMSProvider>
+ *   );
+ * }
+ * ```
+ */
+const FirebaseAuthSync = ({ firebaseAuth, logoutOnFirebaseSignOut, onSyncSuccess, onSyncError, children, }) => {
+    (0, exports.useFirebaseAuthSync)({
+        firebaseAuth,
+        logoutOnFirebaseSignOut,
+        onSyncSuccess,
+        onSyncError,
+    });
+    return react_1.default.createElement(react_1.default.Fragment, null, children);
+};
+exports.FirebaseAuthSync = FirebaseAuthSync;

package/dist/index.d.ts

@@ -1,17 +1,20 @@
+export * from './auth/base-provider';
+export * from './auth/firebase-provider';
 export * from './auth/interfaces';
+export * from './auth/jwt-utils';
 export * from './auth/local-provider';
-export * from './auth/firebase-provider';
-export * from './errors';
 export * from './client';
+export * from './errors';
 export * from './modules/auth';
-export * from './modules/content';
 export * from './modules/channel';
-export * from './modules/terms';
+export * from './modules/content';
 export * from './modules/media';
+export * from './modules/terms';
 export * from './context';
 export * from './hooks/useAuth';
-export * from './hooks/useContent';
 export * from './hooks/useChannel';
-export * from './hooks/useTerms';
+export * from './hooks/useContent';
+export * from './hooks/useFirebaseAuthSync';
 export * from './hooks/useMedia';
+export * from './hooks/useTerms';
 export * from './types';

package/dist/index.js

@@ -14,20 +14,23 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth/base-provider"), exports);
+__exportStar(require("./auth/firebase-provider"), exports);
 __exportStar(require("./auth/interfaces"), exports);
+__exportStar(require("./auth/jwt-utils"), exports);
 __exportStar(require("./auth/local-provider"), exports);
-__exportStar(require("./auth/firebase-provider"), exports);
-__exportStar(require("./errors"), exports);
 __exportStar(require("./client"), exports);
+__exportStar(require("./errors"), exports);
 __exportStar(require("./modules/auth"), exports);
-__exportStar(require("./modules/content"), exports);
 __exportStar(require("./modules/channel"), exports);
-__exportStar(require("./modules/terms"), exports);
+__exportStar(require("./modules/content"), exports);
 __exportStar(require("./modules/media"), exports);
+__exportStar(require("./modules/terms"), exports);
 __exportStar(require("./context"), exports);
 __exportStar(require("./hooks/useAuth"), exports);
-__exportStar(require("./hooks/useContent"), exports);
 __exportStar(require("./hooks/useChannel"), exports);
-__exportStar(require("./hooks/useTerms"), exports);
+__exportStar(require("./hooks/useContent"), exports);
+__exportStar(require("./hooks/useFirebaseAuthSync"), exports);
 __exportStar(require("./hooks/useMedia"), exports);
+__exportStar(require("./hooks/useTerms"), exports);
 __exportStar(require("./types"), exports);

package/dist/modules/auth.d.ts

@@ -1,12 +1,12 @@
+import { AuthResponse, FirebaseExchangeRequest, LoginRequest, RegisterRequest, UserDto } from "@ph-cms/api-contract";
 import { AxiosInstance } from "axios";
 import { AuthProvider } from "../auth/interfaces";
-import { LoginRequest, RegisterRequest, AuthResponse, UserDto, FirebaseExchangeRequest } from "@ph-cms/api-contract";
 export declare class AuthModule {
     private client;
     private provider?;
     constructor(client: AxiosInstance, provider?: AuthProvider | undefined);
     /**
-     * Logs in the user and updates the AuthProvider if it's a LocalAuthProvider.
+     * Logs in the user and updates the AuthProvider tokens automatically.
      */
     login(data: LoginRequest): Promise<AuthResponse>;
     /**

package/dist/modules/auth.js

@@ -9,7 +9,7 @@ class AuthModule {
         this.provider = provider;
     }
     /**
-     * Logs in the user and updates the AuthProvider if it's a LocalAuthProvider.
+     * Logs in the user and updates the AuthProvider tokens automatically.
      */
     async login(data) {
         const validation = api_contract_1.LoginSchema.safeParse(data);
@@ -17,17 +17,8 @@ class AuthModule {
             throw new errors_1.ValidationError("Invalid login data", validation.error.errors);
         }
         const response = await this.client.post('/api/auth/login', data);
-        // If using Local Provider, update tokens automatically
-        if (this.provider && (this.provider.type === 'LOCAL' || this.provider.type === 'FIREBASE')) {
-            // We need to cast to LocalAuthProvider to access setTokens,
-            // but strictly speaking we shouldn't assume implementation details here.
-            // However, for this SDK, it's a practical coupling.
-            // Or we assume the user handles it.
-            // Let's assume the user handles it via the response for now,
-            // OR we can try to update it if the method exists.
-            if ('setTokens' in this.provider) {
-                this.provider.setTokens(response.accessToken, response.refreshToken);
-            }
+        if (this.provider) {
+            this.provider.setTokens(response.accessToken, response.refreshToken);
         }
         return response;
     }
@@ -40,8 +31,7 @@ class AuthModule {
             throw new errors_1.ValidationError("Invalid Firebase token data", validation.error.errors);
         }
         const response = await this.client.post('/api/auth/firebase/exchange', data);
-        // If using a Provider, update tokens automatically
-        if (this.provider && ('setTokens' in this.provider)) {
+        if (this.provider) {
             this.provider.setTokens(response.accessToken, response.refreshToken);
         }
         return response;
@@ -51,23 +41,24 @@ class AuthModule {
         if (!validation.success) {
             throw new errors_1.ValidationError("Invalid register data", validation.error.errors);
         }
-        return this.client.post('/api/auth/register', data);
+        const response = await this.client.post('/api/auth/register', data);
+        if (this.provider) {
+            this.provider.setTokens(response.accessToken, response.refreshToken);
+        }
+        return response;
     }
     async me() {
         return this.client.get('/api/auth/me');
     }
     async refresh(refreshToken) {
-        // Validate refreshToken string? It's just a string.
         return this.client.post('/api/auth/refresh', { refreshToken });
     }
     async logout() {
         if (this.provider) {
             await this.provider.logout();
         }
-        // Also call API endpoint if needed?
-        // Usually client-side logout just clears token.
-        // But if we want to invalidate on server (blacklist), we call endpoint.
-        // Routes has /api/auth/logout.
+        // Call the server endpoint to invalidate the session if applicable.
+        // JWT-based auth is stateless, but the server may implement a blacklist.
         await this.client.post('/api/auth/logout').catch(() => { }); // Ignore error on logout
     }
 }

package/dist/types.d.ts

@@ -1 +1,15 @@
-export * from '@ph-cms/api-contract';
+export type { AuthProvider } from './auth/interfaces';
+export type { JwtPayload } from './auth/jwt-utils';
+export type { PHCMSClientConfig } from './client';
+export type { AuthStatus, PHCMSContextType, PHCMSProviderProps } from './context';
+export type { FirebaseAuthSyncProps, UseFirebaseAuthSyncOptions, UseFirebaseAuthSyncReturn } from './hooks/useFirebaseAuthSync';
+export type { AuthResponse, FirebaseExchangeRequest, LoginRequest, RefreshTokenRequest, RegisterRequest } from '@ph-cms/api-contract';
+export type { UserDto } from '@ph-cms/api-contract';
+export type { ChannelDto, CheckHierarchyQuery, CreateChannelDto, ListChannelQuery, PagedChannelListResponse } from '@ph-cms/api-contract';
+export type { ContentDto, ContentMediaDto, CreateContentRequest, ListContentQuery, PagedContentListResponse, UpdateContentRequest } from '@ph-cms/api-contract';
+export type { HierarchySetDto } from '@ph-cms/api-contract';
+export type { PermissionPolicySetDto } from '@ph-cms/api-contract';
+export type { ListTermsQuery, PagedTermListResponse, TermDto } from '@ph-cms/api-contract';
+export type { BoundsQuery, GeoJSON } from '@ph-cms/api-contract';
+export type { MediaUploadTicketBatchRequest, MediaUploadTicketBatchResponse, MediaUploadTicketRequest, MediaUploadTicketResponse } from '@ph-cms/api-contract';
+export type { PagedResponse } from '@ph-cms/api-contract';

package/dist/types.js

@@ -1,17 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
+// =============================================================================
+// PH-CMS Client SDK — Centralized Type Exports
+//
+// This file re-exports all types used across the SDK so that consumers can
+// import them from a single entry point (`@ph-cms/client-sdk`) without needing
+// to dig into `@ph-cms/api-contract` (which ships as a pre-built dependency).
+// =============================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@ph-cms/api-contract"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ph-cms/client-sdk",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Unified PH-CMS Client SDK (React + Core)",
   "keywords": [],
   "license": "MIT",