@phygitallabs/tapquest-core 2.0.0

package/src/modules/reward/types/reward.ts

@@ -0,0 +1,90 @@
+// Re-export from @phygitallabs/reward package
+export type {
+  CmentityUserReward,
+  EntityRewardModel,
+  UserReward
+} from "@phygitallabs/reward";
+
+// Import EntityRewardModel for local use
+import type { EntityRewardModel } from "@phygitallabs/reward";
+
+// Define other types locally since they're not exported from reward package
+export interface RewardRule {
+  id: string;
+  name: string;
+  description?: string;
+  type: string;
+  conditions: Record<string, any>;
+  is_active: boolean;
+  priority?: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface RewardGroup {
+  id: string;
+  name: string;
+  description?: string;
+  is_active: boolean;
+  reward_ids: string[];
+  rewards?: EntityRewardModel[];
+  project_id?: string;
+  campaign_id?: string;
+  achievement_id?: string;
+  labels?: Record<string, any>;
+  custom_info?: Record<string, any>;
+  metadata?: Record<string, any>;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface RewardNotifyTheme {
+  backgroundImage: string;
+  giftImage: string;
+}
+
+export interface RewardFilter {
+  user_id?: string;
+  device_uid?: string;
+  reward_model_id?: string;
+  group_reward_id?: string;
+  project_id?: string;
+  campaign_id?: string;
+  achievement_id?: string;
+  status?: string;
+  claim_status?: string;
+  is_claimable?: boolean;
+  is_expired?: boolean;
+  type?: string;
+  labels?: Record<string, any>;
+  created_from?: string;
+  created_to?: string;
+  claimed_from?: string;
+  claimed_to?: string;
+}
+
+export interface RewardModelFilter {
+  name?: string;
+  type?: string;
+  is_active?: boolean;
+  is_claimable?: boolean;
+  project_id?: string;
+  campaign_id?: string;
+  achievement_id?: string;
+  group_reward_id?: string;
+  labels?: Record<string, any>;
+  created_from?: string;
+  created_to?: string;
+  valid_from?: string;
+  valid_until?: string;
+}
+
+export interface ClaimUserRewardPayload {
+  certificate?: {
+    thumbnail_url?: string;
+    type?: string;
+    url?: string;
+  };
+  user_info: Record<string, any>;
+}
+

package/src/modules/scan-chip/hooks/index.tsx

@@ -0,0 +1,67 @@
+import { useEffect } from "react";
+import { useChipScanStory } from "@phygitallabs/api-core";
+import { usePGLCoreService } from "@phygitallabs/api-core";
+import { setChipAuthToken } from "../../auth/helpers";
+
+import { ScanChipResponse } from "../types";
+
+interface UseScanChipProps {
+    token?: string;
+    id?: string;
+    onScanChipError?: () => void;
+}
+export { useChipScanStory, usePGLCoreService };
+export function useScanChip({ token, id, onScanChipError }: UseScanChipProps): ScanChipResponse {
+    const { updateHeaders } = usePGLCoreService();
+
+    useEffect(() => {
+        if (!!token) {
+
+            const header = {
+                "Chip-Authorization": token,
+            };
+
+            setChipAuthToken(token);
+            updateHeaders(header);
+
+        }
+    }, [token, updateHeaders]);
+
+    const { data, isLoading, isError, isSuccess } = useChipScanStory({
+        token,
+        id,
+    });
+
+    useEffect(() => {
+        if (isError) {
+            onScanChipError?.();
+        }
+    }, [isError, onScanChipError]);
+
+
+    if (!data)
+        return {
+            data: null,
+            isLoading,
+            isError,
+            isSuccess
+        };
+
+    return {
+        data: {
+            externalUrl: data?.external_url,
+            campaignDetail: data?.project,
+            locationDetail: data?.location,
+            scanCounter: data?.scan_counter,
+            campaignId: data?.campaign_id,
+            chipModelId: data?.chip_model_id,
+            organizationId: data?.organization_id,
+            projectId: data?.project_id,
+            locationId: data?.location_id,
+            chipUid: data?.uid,
+        },
+        isLoading,
+        isError,
+        isSuccess
+    }
+}

package/src/modules/scan-chip/index.ts

@@ -0,0 +1,2 @@
+export * from "./hooks";
+export * from "./types";

package/src/modules/scan-chip/types/index.ts

@@ -0,0 +1,25 @@
+import { ChipScanModel, ProjectModel, LocationModel } from "@phygitallabs/api-core";
+
+export type ScanChipData = {
+    externalUrl?: string;
+    campaignDetail?: ProjectModel;
+    locationDetail?: LocationModel;
+    scanCounter?: number;
+    campaignId?: string;
+    chipModelId?: string;
+    organizationId?: string;
+    projectId?: string;
+    locationId?: string;
+    chipUid?: string;
+}
+
+
+export interface ScanChipResponse {
+    data: ScanChipData | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+}
+
+
+export type { ChipScanModel, LocationModel, ProjectModel };

package/src/modules/send-email/hooks/index.ts

@@ -0,0 +1,2 @@
+import { useSendEmail } from "@phygitallabs/api-core";
+export {useSendEmail}

package/src/modules/send-email/index.ts

@@ -0,0 +1 @@
+export * from "./hooks";

package/src/modules/user-profile/hooks/index.ts

@@ -0,0 +1,3 @@
+import { useMyProfile, useUpdateMyProfile, useSyncCheckin, useCancelUserRewardsRequest } from "@phygitallabs/api-core";
+
+export { useMyProfile, useUpdateMyProfile, useSyncCheckin, useCancelUserRewardsRequest };

package/src/modules/user-profile/index.ts

@@ -0,0 +1,3 @@
+export * from "./hooks";
+
+export * from "./types";

package/src/modules/user-profile/types/index.ts

@@ -0,0 +1,3 @@
+import { UserSourceType } from "@phygitallabs/api-core";
+
+export { UserSourceType };

package/src/providers/ServicesProvider.tsx

@@ -0,0 +1,173 @@
+import React, { useEffect, useState, useMemo } from "react";
+import { QueryClient } from "@tanstack/react-query";
+import { PGLCoreServiceProvider } from "@phygitallabs/api-core";
+import { RewardServiceProvider } from "@phygitallabs/reward";
+import { AchievementServiceProvider } from "@phygitallabs/achievement";
+import { GenerateCertificateServiceProvider } from "@phygitallabs/generate-certificate";
+
+import serviceApiUrl from "../constants/service";
+import { APIConfig, ServiceConfig } from "../types/service";
+
+import { checkDeviceUid, getAccessToken, getRetryAttemptsRefreshToken, setRetryAttemptsRefreshToken, createRefreshTokenFunction } from "../modules/auth/helpers";
+
+import { httpMaxRetries } from "../modules/auth";
+
+import { useAuth } from "../modules/auth";
+
+import axios from "axios";
+
+interface ServicesProviderProps {
+    children: React.ReactNode;
+    queryClient: QueryClient;
+    apiConfig: APIConfig;
+    firebaseConfig?: any;
+}
+
+export const ServicesProvider: React.FC<ServicesProviderProps> = ({
+    children,
+    queryClient,
+    apiConfig = {
+        environment: "dev",
+        version: "v1"
+    },
+    firebaseConfig
+}) => {
+    const { refreshUser, signOut } = useAuth();
+    const { environment, version } = apiConfig;
+    const [commonServiceConfig, setCommonServiceConfig] = useState<ServiceConfig | null>(null);
+
+    // Create memoized refresh token function
+    const memoizedRefreshToken = useMemo(() => {
+        if (!firebaseConfig?.apiKey) {
+            console.warn("Firebase API key not provided, refresh token functionality will not work");
+            return null;
+        }
+        return createRefreshTokenFunction({
+            firebaseApiKey: firebaseConfig.apiKey
+        });
+    }, [firebaseConfig?.apiKey]);
+
+    // Init client
+    useEffect(() => {
+        const initClient = async () => {
+            try {
+                const deviceUid = await checkDeviceUid();
+
+                const responseInterceptors = ({
+                    onFulfilled: (response: any) => response,
+                    onRejected: async (error: any) => {
+
+                        // TODO: Remove
+                        // Feature: use refresh token to get new access token when token expired, have maximum `retry attempts`
+                        const originalRequest = error.config;
+
+                        if (error.response?.status === 401 && !originalRequest._retry) {
+                            const retryAttempts = parseInt(
+                                getRetryAttemptsRefreshToken() || "0",
+                                10
+                            );
+
+                            if (retryAttempts >= httpMaxRetries) {
+                                await signOut();
+                                return Promise.reject(error);
+                            }
+
+                            setRetryAttemptsRefreshToken(`${retryAttempts + 1}`);
+                            originalRequest._retry = true;
+
+                            try {
+                                if (!memoizedRefreshToken) {
+                                    await signOut();
+                                    return Promise.reject(error);
+                                }
+
+                                const result = await memoizedRefreshToken();
+
+                                if (result?.accessToken) {
+                                    originalRequest.headers[
+                                        "Authorization"
+                                    ] = `Bearer ${result.accessToken}`;
+
+                                    setRetryAttemptsRefreshToken("0");
+                                    
+                                    refreshUser(result);
+
+                                    return axios(originalRequest);
+                                }
+                            } catch (refreshError) {
+                                console.log("Failed to refresh token:", refreshError);
+                            }
+                        }
+
+                        return Promise.reject(error);
+                    },
+                })
+
+                const requestInterceptors = ({
+                    onFulfilled: (config: any) => {
+                        // Feature: set access token to request header
+                        const currentToken = getAccessToken();
+
+                        if (currentToken && !config.headers.Authorization) {
+                            config.headers.Authorization = `Bearer ${currentToken}`;
+                        }
+                        return config;
+                    },
+                    onRejected: (error: any) => Promise.reject(error),
+                })
+
+                const axiosConfig = {
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Device-UID": deviceUid,
+                    }
+                }
+
+                const config: ServiceConfig = {
+                    queryClient,
+                    axiosConfig,
+                    responseInterceptors,
+                    requestInterceptors,
+                    useDevTool: true,
+                };
+
+                setCommonServiceConfig(config);
+
+            } catch (error) {
+                console.error(error);
+            }
+        }
+
+        initClient();
+    }, [queryClient]);
+
+    if (!commonServiceConfig) {
+        return <></>
+    }
+
+    return (
+        <PGLCoreServiceProvider
+            {...commonServiceConfig}
+            baseURL={`${serviceApiUrl[environment].API_BASE_URL}/${version}`}
+            baseCoreURL={`${serviceApiUrl[environment].API_BASE_CORE_URL}/${version}`}
+        >
+            <RewardServiceProvider
+                {...commonServiceConfig}
+                // baseURL={`${serviceApiUrl[environment].API_REWARD_URL}/${version}`}
+                baseURL={`${serviceApiUrl[environment].API_REWARD_URL}/v1`} // todo: using v1 until backend fully migrate
+            >
+                <AchievementServiceProvider
+                    {...commonServiceConfig}
+                    baseURL={`${serviceApiUrl[environment].API_ACHIEVEMENT_URL}/${version}`}
+                >
+                    <GenerateCertificateServiceProvider
+                        {...commonServiceConfig}
+                        baseURL={`${serviceApiUrl[environment].API_GENERATE_CERTIFICATE_URL}/v1`}
+                    >
+                        {children}
+                    </GenerateCertificateServiceProvider>
+                </AchievementServiceProvider>
+            </RewardServiceProvider>
+        </PGLCoreServiceProvider>
+    );
+};

package/src/providers/TapquestCoreProvider.tsx

@@ -0,0 +1,64 @@
+import React, { useMemo } from "react";
+import { Provider } from "react-redux";
+import { PersistGate } from "redux-persist/integration/react";
+
+import { ServicesProvider } from "./ServicesProvider";
+import { APIConfig } from "../types/service";
+import { QueryClient } from "@tanstack/react-query";
+
+import { store, persistor } from "../store";
+import { AuthCallbacks } from "../modules/auth/types";
+import { AuthProvider } from "../modules/auth/providers";
+import { FirebaseConfig } from "../modules/auth/types";
+
+interface TapquestCoreProviderProps {
+  children: React.ReactNode;
+  queryClient: QueryClient;
+  apiConfig: APIConfig;
+  firebaseConfig?: FirebaseConfig;
+  authCallbacks?: AuthCallbacks;
+}
+
+export const TapquestCoreProvider: React.FC<TapquestCoreProviderProps> = ({
+  children,
+  queryClient,
+  apiConfig,
+  firebaseConfig,
+  authCallbacks
+}) => {
+
+  const internalAuthService = useMemo(() => {
+    if (firebaseConfig && typeof window !== "undefined") {
+      try {
+        // Dynamic import to avoid loading Firebase modules during build
+        const { createAuthService } = require("../modules/auth/services");
+        return createAuthService({ firebaseConfig });
+      } catch (error) {
+        console.warn("Failed to create auth service from firebase config:", error);
+        return null;
+      }
+    }
+
+    return null;
+  }, [firebaseConfig]);
+
+  return (
+    <Provider store={store}>
+      <PersistGate loading={null} persistor={persistor}>
+        <AuthProvider
+          authService={internalAuthService}
+          authCallbacks={authCallbacks}
+        >
+          <ServicesProvider
+            queryClient={queryClient}
+            apiConfig={apiConfig}
+            firebaseConfig={firebaseConfig}
+          >
+            {children}
+          </ServicesProvider>
+        </AuthProvider>
+
+      </PersistGate>
+    </Provider>
+  );
+};

package/src/providers/index.ts

@@ -0,0 +1 @@
+export * from './TapquestCoreProvider';

package/src/store/hooks.ts

@@ -0,0 +1,6 @@
+import { TypedUseSelectorHook, useDispatch, useSelector } from 'react-redux';
+import type { TapquestCoreRootState, TapquestCoreAppDispatch } from './index';
+
+// Typed hooks for internal use within tapquest-core
+export const useAppDispatch = () => useDispatch<TapquestCoreAppDispatch>();
+export const useAppSelector: TypedUseSelectorHook<TapquestCoreRootState> = useSelector;

package/src/store/index.ts

@@ -0,0 +1,45 @@
+import { configureStore } from "@reduxjs/toolkit";
+import storage from "redux-persist/lib/storage";
+import { persistReducer, persistStore, PersistConfig } from "redux-persist";
+import { authSlice } from "../modules/auth/store/authSlice";
+
+// Auth persist config
+const authPersistConfig: PersistConfig<any> = {
+  key: "tapquest-auth",
+  storage,
+  whitelist: ["user", "isSignedIn"], // Only persist user and sign-in status
+};
+
+// Create persisted auth reducer
+const persistedAuthReducer = persistReducer(authPersistConfig, authSlice.reducer);
+
+// Configure the tapquest-core store
+export const store = configureStore({
+  reducer: {
+    auth: persistedAuthReducer,
+  },
+  middleware: (getDefaultMiddleware) =>
+    getDefaultMiddleware({
+      serializableCheck: {
+        // Ignore redux-persist actions
+        ignoredActions: [
+          'persist/FLUSH',
+          'persist/REHYDRATE',
+          'persist/PAUSE',
+          'persist/PERSIST',
+          'persist/PURGE',
+          'persist/REGISTER',
+        ],
+      },
+    }),
+});
+
+// Create persistor
+export const persistor = persistStore(store);
+
+// Export types
+export type TapquestCoreRootState = ReturnType<typeof store.getState>;
+export type TapquestCoreAppDispatch = typeof store.dispatch;
+
+// Export store instance for internal use
+export { store as tapquestCoreStore };

package/src/types/common.d.ts

@@ -0,0 +1,8 @@
+export enum Environment {
+    DEV = "dev",
+    STAGING = "staging",
+    PRODUCTION = "production",
+}
+
+export type EnvironmentType = "dev" | "staging" | "production";
+export type APIVersionType = "v1" | "v2";

package/src/types/media.ts

@@ -0,0 +1,26 @@
+export enum MediaType {
+  IMAGE = "image",
+  VIDEO = "video",
+}
+
+export type DateTimeNumber = number;
+
+export interface Media {
+  url: string;
+  type: MediaType;
+  thumbnail_url?: string;
+}
+
+export enum EntityStatus {
+  ACTIVE = "Active",
+  INACTIVE = "Inactive",
+}
+
+export interface CommonModel {
+  id: string;
+  status: EntityStatus;
+  created_at: DateTimeNumber;
+  updated_at: DateTimeNumber;
+  created_by?: string;
+  updated_by?: string;
+}

package/src/types/service.d.ts

@@ -0,0 +1,34 @@
+import { QueryClient } from "@tanstack/react-query";
+import { InternalAxiosRequestConfig } from "axios";
+
+import { EnvironmentType } from "./common";
+
+export interface RequestInterceptor {
+    onFulfilled?: (
+        config: InternalAxiosRequestConfig
+    ) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+    onRejected?: (error: any) => any;
+}
+
+export interface ResponseInterceptor {
+    onFulfilled?: (response: any) => any;
+    onRejected?: (error: any) => any;
+}
+
+export interface APIConfig {
+    environment: EnvironmentType;
+    version: APIVersionType;
+}
+
+export interface ServiceConfig {
+    queryClient: QueryClient;
+    axiosConfig: {
+        headers: {
+            "Content-Type": string;
+            "Device-UID": string;
+        };
+    };
+    responseInterceptors: any;
+    requestInterceptors: any;
+    useDevTool: boolean;
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2021", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "allowJs": false,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "baseUrl": ".",
+    "paths": {
+      "react": ["./node_modules/@types/react"]
+    },
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "exclude": ["node_modules", "dist"],
+  "include": ["."]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});