@ph-cms/client-sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PH-CMS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# @ph-cms/client-sdk
+
+Unified PH-CMS client SDK for browser and React applications.
+
+This package is intended to be published to npm and provides:
+
+- A typed API client
+- Auth provider interfaces and implementations
+- React context and hooks for consuming the client in UI code
+
+## Installation
+
+Install the SDK itself with its runtime dependencies:
+
+```bash
+npm install @ph-cms/client-sdk @ph-cms/api-contract axios zod
+```
+
+If you use the React bindings, also install the peer dependencies:
+
+```bash
+npm install react @tanstack/react-query
+```
+
+If you use Firebase auth integration:
+
+```bash
+npm install firebase
+```
+
+## Usage
+
+```ts
+import { PHCMSClient } from '@ph-cms/client-sdk';
+
+const client = new PHCMSClient({
+  baseURL: 'https://api.example.com',
+});
+
+const contents = await client.content.list({
+  page: 1,
+  limit: 20,
+});
+```
+
+## React Usage
+
+`react` and `@tanstack/react-query` are peer dependencies, so your application must provide them.
+
+```tsx
+import { PHCMSClient, PHCMSProvider, usePHCMS } from '@ph-cms/client-sdk';
+
+const client = new PHCMSClient({ baseURL: 'https://api.example.com' });
+
+function ContentCount() {
+  const sdk = usePHCMS();
+  // Use sdk.content / sdk.auth / sdk.channel / sdk.terms here.
+  return null;
+}
+
+export function App() {
+  return (
+    <PHCMSProvider client={client}>
+      <ContentCount />
+    </PHCMSProvider>
+  );
+}
+```
+
+## License
+
+MIT

package/dist/auth/firebase-provider.d.ts

@@ -0,0 +1,17 @@
+import { AuthProvider } from "./interfaces";
+import type { Auth } from "firebase/auth";
+export declare class FirebaseAuthProvider implements AuthProvider {
+    private readonly auth;
+    private readonly storageKeyPrefix;
+    readonly type = "FIREBASE";
+    private accessToken;
+    private refreshToken;
+    private onExpiredCallback;
+    constructor(auth: Auth, storageKeyPrefix?: string);
+    setTokens(accessToken: string, refreshToken: string): void;
+    getToken(): Promise<string | null>;
+    onTokenExpired(callback: () => Promise<void>): void;
+    logout(): Promise<void>;
+    getRefreshToken(): string | null;
+    getIdToken(): Promise<string | null>;
+}

package/dist/auth/firebase-provider.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseAuthProvider = void 0;
+class FirebaseAuthProvider {
+    constructor(auth, storageKeyPrefix = 'ph_cms_fb_') {
+        this.auth = auth;
+        this.storageKeyPrefix = storageKeyPrefix;
+        this.type = 'FIREBASE';
+        this.accessToken = null;
+        this.refreshToken = null;
+        this.onExpiredCallback = null;
+        if (typeof window !== 'undefined') {
+            this.accessToken = localStorage.getItem(`${this.storageKeyPrefix}access_token`);
+            this.refreshToken = localStorage.getItem(`${this.storageKeyPrefix}refresh_token`);
+        }
+    }
+    setTokens(accessToken, refreshToken) {
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
+        if (typeof window !== 'undefined') {
+            localStorage.setItem(`${this.storageKeyPrefix}access_token`, accessToken);
+            localStorage.setItem(`${this.storageKeyPrefix}refresh_token`, refreshToken);
+        }
+    }
+    async getToken() {
+        // If we have a local access token, use it for PH-CMS API calls.
+        if (this.accessToken) {
+            return this.accessToken;
+        }
+        // Fallback to Firebase ID token if no local token is set yet.
+        // This might be useful if the server starts supporting Firebase tokens directly
+        // or for the initial exchange call if we want to automate it (though currently it's manual).
+        const user = this.auth.currentUser;
+        if (!user)
+            return null;
+        return user.getIdToken();
+    }
+    onTokenExpired(callback) {
+        this.onExpiredCallback = callback;
+    }
+    async logout() {
+        this.accessToken = null;
+        this.refreshToken = null;
+        if (typeof window !== 'undefined') {
+            localStorage.removeItem(`${this.storageKeyPrefix}access_token`);
+            localStorage.removeItem(`${this.storageKeyPrefix}refresh_token`);
+        }
+        await this.auth.signOut();
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    async getIdToken() {
+        const user = this.auth.currentUser;
+        if (!user)
+            return null;
+        return user.getIdToken();
+    }
+}
+exports.FirebaseAuthProvider = FirebaseAuthProvider;

package/dist/auth/interfaces.d.ts

@@ -0,0 +1,16 @@
+export interface AuthProvider {
+    type: 'FIREBASE' | 'LOCAL';
+    /**
+     * Returns the current valid access token.
+     * Should handle refreshing if necessary (or return null/throw if expired and can't refresh).
+     */
+    getToken(): Promise<string | null>;
+    /**
+     * Sets a callback to be called when the token is known to be expired by the external world (e.g. 401 response).
+     */
+    onTokenExpired(callback: () => Promise<void>): void;
+    /**
+     * Clears the session.
+     */
+    logout(): Promise<void>;
+}

package/dist/auth/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/auth/local-provider.d.ts

@@ -0,0 +1,18 @@
+import { AuthProvider } from "./interfaces";
+export declare class LocalAuthProvider implements AuthProvider {
+    private readonly storageKeyPrefix;
+    private readonly refreshFn?;
+    readonly type = "LOCAL";
+    private accessToken;
+    private refreshToken;
+    private onExpiredCallback;
+    constructor(storageKeyPrefix?: string, refreshFn?: ((refreshToken: string) => Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>) | undefined);
+    setTokens(accessToken: string, refreshToken: string): void;
+    getToken(): Promise<string | null>;
+    onTokenExpired(callback: () => Promise<void>): void;
+    logout(): Promise<void>;
+    getRefreshToken(): string | null;
+}

package/dist/auth/local-provider.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalAuthProvider = void 0;
+class LocalAuthProvider {
+    constructor(storageKeyPrefix = 'ph_cms_', refreshFn) {
+        this.storageKeyPrefix = storageKeyPrefix;
+        this.refreshFn = refreshFn;
+        this.type = 'LOCAL';
+        this.accessToken = null;
+        this.refreshToken = null;
+        this.onExpiredCallback = null;
+        if (typeof window !== 'undefined') {
+            this.accessToken = localStorage.getItem(`${this.storageKeyPrefix}access_token`);
+            this.refreshToken = localStorage.getItem(`${this.storageKeyPrefix}refresh_token`);
+        }
+    }
+    setTokens(accessToken, refreshToken) {
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
+        if (typeof window !== 'undefined') {
+            localStorage.setItem(`${this.storageKeyPrefix}access_token`, accessToken);
+            localStorage.setItem(`${this.storageKeyPrefix}refresh_token`, refreshToken);
+        }
+    }
+    async getToken() {
+        // Ideally check expiration here using jwt-decode, but for now return what we have.
+        // If it's expired, the API will return 401, triggering the interceptor which calls onTokenExpired.
+        return this.accessToken;
+    }
+    onTokenExpired(callback) {
+        this.onExpiredCallback = callback;
+    }
+    async logout() {
+        this.accessToken = null;
+        this.refreshToken = null;
+        if (typeof window !== 'undefined') {
+            localStorage.removeItem(`${this.storageKeyPrefix}access_token`);
+            localStorage.removeItem(`${this.storageKeyPrefix}refresh_token`);
+        }
+    }
+    // Helper for the client to trigger refresh manually if needed
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+}
+exports.LocalAuthProvider = LocalAuthProvider;

package/dist/client.d.ts

@@ -0,0 +1,21 @@
+import { AxiosInstance } from 'axios';
+import { AuthProvider } from './auth/interfaces';
+import { AuthModule } from './modules/auth';
+import { ContentModule } from './modules/content';
+import { ChannelModule } from './modules/channel';
+import { TermsModule } from './modules/terms';
+export interface PHCMSClientConfig {
+    baseURL: string;
+    apiPrefix?: string;
+    auth?: AuthProvider;
+    timeout?: number;
+}
+export declare class PHCMSClient {
+    private config;
+    readonly axiosInstance: AxiosInstance;
+    readonly auth: AuthModule;
+    readonly content: ContentModule;
+    readonly channel: ChannelModule;
+    readonly terms: TermsModule;
+    constructor(config: PHCMSClientConfig);
+}

package/dist/client.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHCMSClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("./errors");
+const auth_1 = require("./modules/auth");
+const content_1 = require("./modules/content");
+const channel_1 = require("./modules/channel");
+const terms_1 = require("./modules/terms");
+class PHCMSClient {
+    constructor(config) {
+        this.config = config;
+        const normalizedApiPrefix = `/${(config.apiPrefix || '/api').replace(/^\/+|\/+$/g, '')}`;
+        this.axiosInstance = axios_1.default.create({
+            baseURL: config.baseURL,
+            timeout: config.timeout || 10000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        // Request Interceptor: Add Auth Token
+        this.axiosInstance.interceptors.request.use(async (reqConfig) => {
+            if (typeof reqConfig.url === 'string') {
+                if (reqConfig.url === '/api') {
+                    reqConfig.url = normalizedApiPrefix;
+                }
+                else if (reqConfig.url.startsWith('/api/')) {
+                    reqConfig.url = `${normalizedApiPrefix}${reqConfig.url.slice('/api'.length)}`;
+                }
+            }
+            if (this.config.auth) {
+                const token = await this.config.auth.getToken();
+                if (token) {
+                    reqConfig.headers.Authorization = `Bearer ${token}`;
+                }
+            }
+            return reqConfig;
+        });
+        // Response Interceptor: Unwrap Data & Handle Errors
+        this.axiosInstance.interceptors.response.use((response) => {
+            // Return the data directly, stripping Axios wrapper
+            return response.data;
+        }, async (error) => {
+            if (error.response) {
+                // Server responded with a status code outside 2xx
+                const { status, data } = error.response;
+                const message = data?.message || error.message;
+                // Handle 401 Token Expiry if provider supports it
+                if (status === 401 && this.config.auth) {
+                    // Logic to handle token refresh could be here or triggered by the app.
+                    // For now just throw.
+                }
+                throw new errors_1.ApiError(message, status, data);
+            }
+            else if (error.request) {
+                // Request made but no response
+                throw new errors_1.PHCMSError('No response received from server');
+            }
+            else {
+                // Something happened in setting up the request
+                throw new errors_1.PHCMSError(error.message);
+            }
+        });
+        // Initialize Modules
+        this.auth = new auth_1.AuthModule(this.axiosInstance, config.auth);
+        this.content = new content_1.ContentModule(this.axiosInstance);
+        this.channel = new channel_1.ChannelModule(this.axiosInstance);
+        this.terms = new terms_1.TermsModule(this.axiosInstance);
+    }
+}
+exports.PHCMSClient = PHCMSClient;

package/dist/context.d.ts

@@ -0,0 +1,8 @@
+import React, { ReactNode } from 'react';
+import { PHCMSClient } from './client';
+export interface PHCMSProviderProps {
+    client: PHCMSClient;
+    children: ReactNode;
+}
+export declare const PHCMSProvider: React.FC<PHCMSProviderProps>;
+export declare const usePHCMS: () => PHCMSClient;

package/dist/context.js

@@ -0,0 +1,50 @@
+"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.usePHCMS = exports.PHCMSProvider = void 0;
+const react_1 = __importStar(require("react"));
+const PHCMSContext = (0, react_1.createContext)(null);
+const PHCMSProvider = ({ client, children }) => {
+    return (react_1.default.createElement(PHCMSContext.Provider, { value: { client } }, children));
+};
+exports.PHCMSProvider = PHCMSProvider;
+const usePHCMS = () => {
+    const context = (0, react_1.useContext)(PHCMSContext);
+    if (!context) {
+        throw new Error('usePHCMS must be used within a PHCMSProvider');
+    }
+    return context.client;
+};
+exports.usePHCMS = usePHCMS;

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class PHCMSError extends Error {
+    constructor(message: string);
+}
+export declare class ValidationError extends PHCMSError {
+    errors: any[];
+    constructor(message: string, errors: any[]);
+}
+export declare class ApiError extends PHCMSError {
+    statusCode: number;
+    originalError: any;
+    constructor(message: string, statusCode: number, originalError: any);
+}

package/dist/errors.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = exports.ValidationError = exports.PHCMSError = void 0;
+class PHCMSError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PHCMSError';
+    }
+}
+exports.PHCMSError = PHCMSError;
+class ValidationError extends PHCMSError {
+    constructor(message, errors) {
+        super(message);
+        this.name = 'ValidationError';
+        this.errors = errors;
+    }
+}
+exports.ValidationError = ValidationError;
+class ApiError extends PHCMSError {
+    constructor(message, statusCode, originalError) {
+        super(message);
+        this.name = 'ApiError';
+        this.statusCode = statusCode;
+        this.originalError = originalError;
+    }
+}
+exports.ApiError = ApiError;

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,98 @@
+export declare const useLogin: () => import("@tanstack/react-query").UseMutationResult<{
+    refreshToken: string;
+    user: {
+        uid: string;
+        email: string;
+        username: string | null;
+        display_name: string;
+        avatar_url: string | null;
+        phone_number: string | null;
+        email_verified_at: string | null;
+        phone_verified_at: string | null;
+        locale: string;
+        timezone: string;
+        status: string;
+        role: string[];
+        profile_data: Record<string, any>;
+        last_login_at: string | null;
+        created_at: string;
+        updated_at: string;
+    };
+    accessToken: string;
+}, Error, {
+    email: string;
+    password: string;
+}, unknown>;
+export declare const useLoginWithFirebase: () => import("@tanstack/react-query").UseMutationResult<{
+    refreshToken: string;
+    user: {
+        uid: string;
+        email: string;
+        username: string | null;
+        display_name: string;
+        avatar_url: string | null;
+        phone_number: string | null;
+        email_verified_at: string | null;
+        phone_verified_at: string | null;
+        locale: string;
+        timezone: string;
+        status: string;
+        role: string[];
+        profile_data: Record<string, any>;
+        last_login_at: string | null;
+        created_at: string;
+        updated_at: string;
+    };
+    accessToken: string;
+}, Error, {
+    idToken: string;
+}, unknown>;
+export declare const useRegister: () => import("@tanstack/react-query").UseMutationResult<{
+    refreshToken: string;
+    user: {
+        uid: string;
+        email: string;
+        username: string | null;
+        display_name: string;
+        avatar_url: string | null;
+        phone_number: string | null;
+        email_verified_at: string | null;
+        phone_verified_at: string | null;
+        locale: string;
+        timezone: string;
+        status: string;
+        role: string[];
+        profile_data: Record<string, any>;
+        last_login_at: string | null;
+        created_at: string;
+        updated_at: string;
+    };
+    accessToken: string;
+}, Error, {
+    email: string;
+    display_name: string;
+    username?: string | null | undefined;
+    password?: string | undefined;
+    provider?: string | undefined;
+    provider_subject?: string | undefined;
+    termCodes?: string[] | undefined;
+}, unknown>;
+export declare const useLogout: () => import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;
+export declare const useUser: () => import("@tanstack/react-query").UseQueryResult<{
+    uid: string;
+    email: string;
+    username: string | null;
+    display_name: string;
+    avatar_url: string | null;
+    phone_number: string | null;
+    email_verified_at: string | null;
+    phone_verified_at: string | null;
+    locale: string;
+    timezone: string;
+    status: string;
+    role: string[];
+    profile_data: Record<string, any>;
+    last_login_at: string | null;
+    created_at: string;
+    updated_at: string;
+}, Error>;

package/dist/hooks/useAuth.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUser = exports.useLogout = exports.useRegister = exports.useLoginWithFirebase = exports.useLogin = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const context_1 = require("../context");
+const useLogin = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (data) => client.auth.login(data),
+        onSuccess: (data) => {
+            // Invalidate user query to fetch fresh user data
+            queryClient.invalidateQueries({ queryKey: ['auth', 'me'] });
+        },
+    });
+};
+exports.useLogin = useLogin;
+const useLoginWithFirebase = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (data) => client.auth.loginWithFirebase(data),
+        onSuccess: (data) => {
+            // Invalidate user query to fetch fresh user data
+            queryClient.invalidateQueries({ queryKey: ['auth', 'me'] });
+        },
+    });
+};
+exports.useLoginWithFirebase = useLoginWithFirebase;
+const useRegister = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (data) => client.auth.register(data),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['auth', 'me'] });
+        },
+    });
+};
+exports.useRegister = useRegister;
+const useLogout = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: () => client.auth.logout(),
+        onSuccess: () => {
+            queryClient.setQueryData(['auth', 'me'], null);
+            queryClient.invalidateQueries();
+        },
+    });
+};
+exports.useLogout = useLogout;
+const useUser = () => {
+    const client = (0, context_1.usePHCMS)();
+    return (0, react_query_1.useQuery)({
+        queryKey: ['auth', 'me'],
+        queryFn: () => client.auth.me(),
+        retry: false, // Don't retry if 401
+        staleTime: 1000 * 60 * 5, // 5 minutes
+    });
+};
+exports.useUser = useUser;

package/dist/hooks/useChannel.d.ts

@@ -0,0 +1,65 @@
+import { ListChannelQuery } from '@ph-cms/api-contract';
+export declare const channelKeys: {
+    all: readonly ["channels"];
+    lists: () => readonly ["channels", "list"];
+    list: (params: ListChannelQuery) => readonly ["channels", "list", {
+        status?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        ownerUid?: string | undefined;
+    }];
+};
+export declare const useChannelList: (params: ListChannelQuery) => import("@tanstack/react-query").UseQueryResult<{
+    items: {
+        uid: string;
+        status: string;
+        created_at: string;
+        updated_at: string;
+        name: string;
+        description: string | null;
+        slug: string;
+        hierarchySet: {
+            uid: string;
+            created_at: string;
+            updated_at: string;
+            name: string;
+            description: string | null;
+        } | null;
+        permissionPolicySet: {
+            uid: string;
+            name: string;
+            description: string | null;
+        } | null;
+    }[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}, Error>;
+export declare const useCreateChannel: () => import("@tanstack/react-query").UseMutationResult<{
+    uid: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    name: string;
+    description: string | null;
+    slug: string;
+    hierarchySet: {
+        uid: string;
+        created_at: string;
+        updated_at: string;
+        name: string;
+        description: string | null;
+    } | null;
+    permissionPolicySet: {
+        uid: string;
+        name: string;
+        description: string | null;
+    } | null;
+}, Error, {
+    name: string;
+    slug: string;
+    hierarchySetUid: string;
+    description?: string | undefined;
+    permissionPolicySetUid?: string | undefined;
+}, unknown>;

package/dist/hooks/useChannel.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateChannel = exports.useChannelList = exports.channelKeys = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const context_1 = require("../context");
+exports.channelKeys = {
+    all: ['channels'],
+    lists: () => [...exports.channelKeys.all, 'list'],
+    list: (params) => [...exports.channelKeys.lists(), params],
+};
+const useChannelList = (params) => {
+    const client = (0, context_1.usePHCMS)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.channelKeys.list(params),
+        queryFn: () => client.channel.list(params),
+        staleTime: 1000 * 60 * 5, // 5 minutes
+    });
+};
+exports.useChannelList = useChannelList;
+const useCreateChannel = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (data) => client.channel.create(data),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: exports.channelKeys.lists() });
+        },
+    });
+};
+exports.useCreateChannel = useCreateChannel;

package/dist/hooks/useContent.d.ts

@@ -0,0 +1,71 @@
+import { UpdateContentRequest, ListContentQuery, ContentDto, BoundsQuery } from '@ph-cms/api-contract';
+export declare const contentKeys: {
+    all: readonly ["contents"];
+    lists: () => readonly ["contents", "list"];
+    list: (params: ListContentQuery) => readonly ["contents", "list", {
+        page: number;
+        limit: number;
+        status?: string | undefined;
+        type?: string | undefined;
+        tags?: string[] | undefined;
+        channelUid?: string | undefined;
+        channelSlug?: string | undefined;
+        parentUid?: string | undefined;
+        rootUid?: string | undefined;
+        keyword?: string | undefined;
+        orderBy?: "created_at" | "updated_at" | "published_at" | "title" | "view_count" | "like_count" | undefined;
+        orderDir?: "asc" | "desc" | undefined;
+        withDetail?: boolean | undefined;
+        includeDeleted?: boolean | undefined;
+    }];
+    geoLists: () => readonly ["contents", "geo-list"];
+    geoList: (bounds: BoundsQuery) => readonly ["contents", "geo-list", {
+        minLat: number;
+        maxLat: number;
+        minLng: number;
+        maxLng: number;
+    }];
+    details: () => readonly ["contents", "detail"];
+    detail: (uid: string) => readonly ["contents", "detail", string];
+};
+export declare const useContentList: (params: ListContentQuery, enabled?: boolean) => import("@tanstack/react-query").UseQueryResult<{
+    number: number;
+    totalPages: number;
+    size: number;
+    content: ContentDto[];
+    totalElements: number;
+    first: boolean;
+    last: boolean;
+    empty: boolean;
+}, Error>;
+export declare const useContentGeoList: (bounds: BoundsQuery) => import("@tanstack/react-query").UseQueryResult<ContentDto[], Error>;
+export declare const useContentDetail: (uid: string) => import("@tanstack/react-query").UseQueryResult<ContentDto, Error>;
+export declare const useCreateContent: () => import("@tanstack/react-query").UseMutationResult<ContentDto, Error, {
+    type: string;
+    title: string;
+    status?: string | undefined;
+    geometry?: {
+        type: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection" | "Feature" | "FeatureCollection";
+        coordinates?: any[] | undefined;
+        geometries?: any[] | undefined;
+        features?: any[] | undefined;
+        properties?: Record<string, any> | undefined;
+        geometry?: any;
+    } | undefined;
+    image?: string | null | undefined;
+    text?: string | null | undefined;
+    attributes?: Record<string, any> | undefined;
+    summary?: string | null | undefined;
+    slug?: string | null | undefined;
+    tags?: string[] | undefined;
+    channelUid?: string | undefined;
+    channelSlug?: string | undefined;
+    parentUid?: string | undefined;
+    sortOrder?: number | undefined;
+    mediaAttachments?: string[] | undefined;
+}, unknown>;
+export declare const useUpdateContent: () => import("@tanstack/react-query").UseMutationResult<ContentDto, Error, {
+    uid: string;
+    data: UpdateContentRequest;
+}, unknown>;
+export declare const useDeleteContent: () => import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;

package/dist/hooks/useContent.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeleteContent = exports.useUpdateContent = exports.useCreateContent = exports.useContentDetail = exports.useContentGeoList = exports.useContentList = exports.contentKeys = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const context_1 = require("../context");
+exports.contentKeys = {
+    all: ['contents'],
+    lists: () => [...exports.contentKeys.all, 'list'],
+    list: (params) => [...exports.contentKeys.lists(), params],
+    geoLists: () => [...exports.contentKeys.all, 'geo-list'],
+    geoList: (bounds) => [...exports.contentKeys.geoLists(), bounds],
+    details: () => [...exports.contentKeys.all, 'detail'],
+    detail: (uid) => [...exports.contentKeys.details(), uid],
+};
+const useContentList = (params, enabled = true) => {
+    const client = (0, context_1.usePHCMS)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.contentKeys.list(params),
+        queryFn: () => client.content.list(params),
+        staleTime: 1000 * 60, // 1 minute
+        enabled,
+    });
+};
+exports.useContentList = useContentList;
+const useContentGeoList = (bounds) => {
+    const client = (0, context_1.usePHCMS)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.contentKeys.geoList(bounds),
+        queryFn: () => client.content.listGeo(bounds),
+        enabled: !!(bounds.minLat && bounds.maxLat && bounds.minLng && bounds.maxLng),
+    });
+};
+exports.useContentGeoList = useContentGeoList;
+const useContentDetail = (uid) => {
+    const client = (0, context_1.usePHCMS)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.contentKeys.detail(uid),
+        queryFn: () => client.content.get(uid),
+        enabled: !!uid,
+    });
+};
+exports.useContentDetail = useContentDetail;
+const useCreateContent = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (data) => client.content.create(data),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: exports.contentKeys.lists() });
+        },
+    });
+};
+exports.useCreateContent = useCreateContent;
+const useUpdateContent = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: ({ uid, data }) => client.content.update(uid, data),
+        onSuccess: (data, variables) => {
+            queryClient.invalidateQueries({ queryKey: exports.contentKeys.detail(variables.uid) });
+            queryClient.invalidateQueries({ queryKey: exports.contentKeys.lists() });
+        },
+    });
+};
+exports.useUpdateContent = useUpdateContent;
+const useDeleteContent = () => {
+    const client = (0, context_1.usePHCMS)();
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: (uid) => client.content.delete(uid),
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: exports.contentKeys.lists() });
+        },
+    });
+};
+exports.useDeleteContent = useDeleteContent;

package/dist/hooks/useTerms.d.ts

@@ -0,0 +1,26 @@
+import { ListTermsQuery } from '@ph-cms/api-contract';
+export declare const termsKeys: {
+    all: readonly ["terms"];
+    lists: () => readonly ["terms", "list"];
+    list: (params?: ListTermsQuery) => readonly ["terms", "list", {
+        code?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        isActive?: boolean | undefined;
+    } | undefined];
+};
+export declare const useTermsList: (params?: ListTermsQuery) => import("@tanstack/react-query").UseQueryResult<{
+    items: {
+        code: string;
+        title: string;
+        content: string;
+        id: number;
+        version: string;
+        isActive: boolean;
+        createdAt: string;
+    }[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}, Error>;

package/dist/hooks/useTerms.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTermsList = exports.termsKeys = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const context_1 = require("../context");
+exports.termsKeys = {
+    all: ['terms'],
+    lists: () => [...exports.termsKeys.all, 'list'],
+    list: (params) => [...exports.termsKeys.lists(), params],
+};
+const useTermsList = (params) => {
+    const client = (0, context_1.usePHCMS)();
+    return (0, react_query_1.useQuery)({
+        queryKey: exports.termsKeys.list(params),
+        queryFn: () => client.terms.list(params),
+        staleTime: 1000 * 60 * 60, // 1 hour
+    });
+};
+exports.useTermsList = useTermsList;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './auth/interfaces';
+export * from './auth/local-provider';
+export * from './auth/firebase-provider';
+export * from './errors';
+export * from './client';
+export * from './modules/auth';
+export * from './modules/content';
+export * from './modules/channel';
+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 './types';

package/dist/index.js

@@ -0,0 +1,31 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./auth/interfaces"), exports);
+__exportStar(require("./auth/local-provider"), exports);
+__exportStar(require("./auth/firebase-provider"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./modules/auth"), exports);
+__exportStar(require("./modules/content"), exports);
+__exportStar(require("./modules/channel"), 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("./types"), exports);

package/dist/modules/auth.d.ts

@@ -0,0 +1,23 @@
+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.
+     */
+    login(data: LoginRequest): Promise<AuthResponse>;
+    /**
+     * Exchanges a Firebase ID token for application tokens.
+     */
+    loginWithFirebase(data: FirebaseExchangeRequest): Promise<AuthResponse>;
+    register(data: RegisterRequest): Promise<AuthResponse>;
+    me(): Promise<UserDto>;
+    refresh(refreshToken: string): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    logout(): Promise<void>;
+}

package/dist/modules/auth.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthModule = void 0;
+const api_contract_1 = require("@ph-cms/api-contract");
+const errors_1 = require("../errors");
+class AuthModule {
+    constructor(client, provider) {
+        this.client = client;
+        this.provider = provider;
+    }
+    /**
+     * Logs in the user and updates the AuthProvider if it's a LocalAuthProvider.
+     */
+    async login(data) {
+        const validation = api_contract_1.LoginSchema.safeParse(data);
+        if (!validation.success) {
+            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);
+            }
+        }
+        return response;
+    }
+    /**
+     * Exchanges a Firebase ID token for application tokens.
+     */
+    async loginWithFirebase(data) {
+        const validation = api_contract_1.FirebaseExchangeSchema.safeParse(data);
+        if (!validation.success) {
+            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)) {
+            this.provider.setTokens(response.accessToken, response.refreshToken);
+        }
+        return response;
+    }
+    async register(data) {
+        const validation = api_contract_1.RegisterSchema.safeParse(data);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid register data", validation.error.errors);
+        }
+        return this.client.post('/api/auth/register', data);
+    }
+    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.
+        await this.client.post('/api/auth/logout').catch(() => { }); // Ignore error on logout
+    }
+}
+exports.AuthModule = AuthModule;

package/dist/modules/channel.d.ts

@@ -0,0 +1,15 @@
+import { ChannelDto, CheckHierarchyQuery, CreateChannelDto, ListChannelQuery, PagedChannelListResponse } from "@ph-cms/api-contract";
+import { AxiosInstance } from "axios";
+export declare class ChannelModule {
+    private client;
+    constructor(client: AxiosInstance);
+    list(params: ListChannelQuery): Promise<PagedChannelListResponse>;
+    getByUid(uid: string): Promise<ChannelDto>;
+    getBySlug(slug: string): Promise<ChannelDto>;
+    create(data: CreateChannelDto): Promise<ChannelDto>;
+    update(uid: string, data: any): Promise<ChannelDto>;
+    checkHierarchy(params: CheckHierarchyQuery): Promise<{
+        allowed: boolean;
+        message?: string;
+    }>;
+}

package/dist/modules/channel.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelModule = void 0;
+const api_contract_1 = require("@ph-cms/api-contract");
+const errors_1 = require("../errors");
+class ChannelModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const validation = api_contract_1.ListChannelQuerySchema.safeParse(params);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid list channel params", validation.error.errors);
+        }
+        return this.client.get('/api/channels', { params });
+    }
+    async getByUid(uid) {
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        return this.client.get(`/api/channels/u/${uid}`);
+    }
+    async getBySlug(slug) {
+        if (!slug)
+            throw new errors_1.ValidationError("Slug is required", []);
+        return this.client.get(`/api/channels/s/${slug}`);
+    }
+    async create(data) {
+        const validation = api_contract_1.CreateChannelSchema.safeParse(data);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid create channel params", validation.error.errors);
+        }
+        return this.client.post('/api/channels', data);
+    }
+    async update(uid, data) {
+        // TODO: Add schema validation for update channel
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        return this.client.patch(`/api/channels/u/${uid}`, data);
+    }
+    async checkHierarchy(params) {
+        const validation = api_contract_1.CheckHierarchyQuerySchema.safeParse(params);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid check hierarchy params", validation.error.errors);
+        }
+        return this.client.get('/api/contents/check-hierarchy', { params });
+    }
+}
+exports.ChannelModule = ChannelModule;

package/dist/modules/content.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from "axios";
+import { CreateContentRequest, UpdateContentRequest, ListContentQuery, ContentDto, PagedContentListResponse, BoundsQuery } from "@ph-cms/api-contract";
+export declare class ContentModule {
+    private client;
+    constructor(client: AxiosInstance);
+    list(params: ListContentQuery): Promise<PagedContentListResponse>;
+    listGeo(bounds: BoundsQuery): Promise<ContentDto[]>;
+    get(uid: string): Promise<ContentDto>;
+    create(data: CreateContentRequest): Promise<ContentDto>;
+    update(uid: string, data: UpdateContentRequest): Promise<ContentDto>;
+    delete(uid: string): Promise<void>;
+}

package/dist/modules/content.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentModule = void 0;
+const api_contract_1 = require("@ph-cms/api-contract");
+const errors_1 = require("../errors");
+class ContentModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        const validation = api_contract_1.ListContentQuerySchema.safeParse(params);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid list params", validation.error.errors);
+        }
+        return this.client.get('/api/contents', { params });
+    }
+    async listGeo(bounds) {
+        const validation = api_contract_1.BoundsQuerySchema.safeParse(bounds);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid bounds params", validation.error.errors);
+        }
+        return this.client.get('/api/contents/geo', { params: bounds });
+    }
+    async get(uid) {
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        return this.client.get(`/api/contents/${uid}`);
+    }
+    async create(data) {
+        const validation = api_contract_1.CreateContentSchema.safeParse(data);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid create content data", validation.error.errors);
+        }
+        return this.client.post('/api/contents', data);
+    }
+    async update(uid, data) {
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        const validation = api_contract_1.UpdateContentSchema.safeParse(data);
+        if (!validation.success) {
+            throw new errors_1.ValidationError("Invalid update content data", validation.error.errors);
+        }
+        return this.client.put(`/api/contents/${uid}`, data);
+    }
+    async delete(uid) {
+        if (!uid)
+            throw new errors_1.ValidationError("UID is required", []);
+        return this.client.delete(`/api/contents/${uid}`);
+    }
+}
+exports.ContentModule = ContentModule;

package/dist/modules/terms.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from "axios";
+import { TermDto, ListTermsQuery, PagedTermListResponse } from "@ph-cms/api-contract";
+export declare class TermsModule {
+    private client;
+    constructor(client: AxiosInstance);
+    list(params?: ListTermsQuery): Promise<PagedTermListResponse>;
+    get(id: number): Promise<TermDto>;
+}

package/dist/modules/terms.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TermsModule = void 0;
+class TermsModule {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(params) {
+        return this.client.get('/api/terms', { params });
+    }
+    async get(id) {
+        return this.client.get(`/api/terms/${id}`);
+    }
+}
+exports.TermsModule = TermsModule;

package/dist/types.d.ts

@@ -0,0 +1 @@
+export * from '@ph-cms/api-contract';

package/dist/types.js

@@ -0,0 +1,17 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@ph-cms/api-contract"), exports);

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@ph-cms/client-sdk",
+  "version": "0.1.0",
+  "description": "Unified PH-CMS Client SDK (React + Core)",
+  "keywords": [],
+  "license": "MIT",
+  "author": "854dev",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@ph-cms/api-contract": "^0.1.0",
+    "axios": "^1.6.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.0.0",
+    "@types/react": "^18.3.1",
+    "@types/react-dom": "^18.3.1",
+    "firebase": "^10.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.0.0",
+    "react": ">=18.0.0",
+    "firebase": "^10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "firebase": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc"
+  }
+}