@safercity/sdk-react 0.1.2 → 0.2.0

package/README.md

@@ -2,6 +2,18 @@
 
 React hooks and components for SaferCity SDK with TanStack Query integration.
 
+## What's New in v0.2.0
+
+- **Panic Information Hooks** - New hooks for managing user panic profiles and emergency contacts.
+- **User Scoping** - `SaferCityProvider` now supports `userId` for automatic request scoping.
+- **Enhanced Crime Hooks** - Added `useBanner` and `useCrimeCategoriesWithTypes`.
+- **Security Hardening** - Removed admin-only hooks (`useUsers`, `useDeleteUser`, `useSubscriptionStats`).
+- **Path Alignment** - Hooks now use the latest singular API paths.
+
+## What's New in v0.1.3
+
+- **Security hardening** - Removed `usePanics` and `useSubscriptionStats` hooks (client-side listing/stats are now restricted)
+
 ## Installation
 
 ```bash
@@ -45,6 +57,7 @@ function App() {
       mode="direct"
       baseUrl="https://api.safercity.com"
       tenantId="tenant-123"
+      userId="user-123" // optional, for auto-scoping
       getAccessToken={() => session?.accessToken}
     >
       <YourApp />
@@ -53,6 +66,27 @@ function App() {
 }
 ```
 
+### Cookie Mode
+
+Browser with `credentials: include`. For first-party web apps using session cookies.
+
+```tsx
+import { SaferCityProvider } from '@safercity/sdk-react';
+
+function App() {
+  return (
+    <SaferCityProvider 
+      mode="cookie" 
+      baseUrl="https://api.safercity.com"
+      userId="user-123" // optional
+    >
+      <YourApp />
+    </SaferCityProvider>
+  );
+}
+```
+
+
 The provider automatically refreshes the token every 30 seconds by calling `getAccessToken`.
 
 ### Cookie Mode
@@ -133,18 +167,16 @@ interface SessionState {
 ## Using Hooks
 
 ```tsx
-import { useUsers, usePanics, useCreatePanic } from '@safercity/sdk-react';
+import { useUser, useCreatePanic } from '@safercity/sdk-react';
 
-function Dashboard() {
-  const { data: users, isLoading } = useUsers();
-  const { data: panics } = usePanics({ status: 'active' });
+function Dashboard({ userId }: { userId: string }) {
+  const { data: user, isLoading } = useUser(userId);
   
   if (isLoading) return <div>Loading...</div>;
   
   return (
     <div>
-      <h1>Users: {users?.data.users.length}</h1>
-      <h1>Active Panics: {panics?.data.panics.length}</h1>
+      <h1>Welcome, {user?.data.firstName}</h1>
     </div>
   );
 }
@@ -182,33 +214,46 @@ function PanicButton({ userId }: { userId: string }) {
 - `useWhoAmI()` - Current auth context
 
 ### Users
-- `useUsers(filters?)` - List users
-- `useUser(userId)` - Get user by ID
+- `useUser(userId?)` - Get user by ID (defaults to client's `userId`)
 - `useCreateUser()` - Create user mutation
 - `useUpdateUser()` - Update user mutation
-- `useDeleteUser()` - Delete user mutation
 
 ### Panics
-- `usePanics(filters?)` - List panics
 - `usePanic(panicId, query?)` - Get panic by ID
 - `useCreatePanic()` - Create panic mutation
 - `useUpdatePanicLocation()` - Update location mutation
 - `useCancelPanic()` - Cancel panic mutation
+- `usePanicTypes(userId?)` - Get available panic types for a user
 - `usePanicStream(panicId, options?)` - Stream panic updates
 
+### Panic Information
+- `usePanicInformation(id)` - Get profile by ID
+- `usePanicInformationByUser(userId?)` - Get profile by user ID
+- `usePanicEligibility(userId?)` - Check user eligibility
+- `useCreatePanicInformation()` - Create profile mutation
+- `useUpdatePanicInformation()` - Update profile mutation
+- `useDeletePanicInformation()` - Delete profile mutation
+
 ### Subscriptions
 - `useSubscriptionTypes()` - List subscription types
-- `useSubscriptions(filters?)` - List subscriptions
-- `useSubscriptionStats()` - Get statistics
+- `useSubscriptions(filters?)` - List subscriptions for a user
 - `useCreateSubscription()` - Create subscription mutation
+- `useSubscribeUser()` - Subscribe user mutation
+
+### Notifications
+- `useBulkTriggerNotifications()` - Bulk trigger notifications mutation
 
 ### Location Safety
 - `useLocationSafety(lat, lng, radius?)` - Check location safety
 
+### Banner
+- `useBanner(body)` - Get crime banner data for a location
+
 ### Crimes
 - `useCrimes(filters?)` - List crimes
 - `useCrimeCategories()` - Get crime categories
 - `useCrimeTypes()` - Get crime types
+- `useCrimeCategoriesWithTypes()` - Get categories with nested types
 
 ## Streaming Hook
 

package/dist/index.cjs

@@ -49,13 +49,15 @@ function SaferCityProvider(props) {
     if (isDirectMode(props)) {
       return sdk.createSaferCityClient({
         baseUrl: props.baseUrl,
-        tenantId: props.tenantId
+        tenantId: props.tenantId,
+        userId: props.userId
       });
     }
     if (isCookieMode(props)) {
       return sdk.createSaferCityClient({
         baseUrl: props.baseUrl,
         tenantId: props.tenantId,
+        userId: props.userId,
         headers: {
           // Note: cookies are sent automatically with fetch credentials: 'include'
         }
@@ -92,6 +94,7 @@ function SaferCityProvider(props) {
         if (!isMounted) return;
         if (response.ok) {
           const data = await response.json();
+          client.setUserId(data.userId);
           setSession({
             isAuthenticated: data.authenticated,
             isLoading: false,
@@ -118,7 +121,7 @@ function SaferCityProvider(props) {
     return () => {
       isMounted = false;
     };
-  }, [mode, props]);
+  }, [mode, props, client]);
   const createSession = react.useCallback(async (token, tenantId) => {
     if (mode !== "cookie" || !isCookieMode(props)) {
       throw new Error("createSession is only available in cookie mode");
@@ -253,12 +256,17 @@ var saferCityKeys = {
   authWhoami: () => [...saferCityKeys.auth(), "whoami"],
   // Users
   users: () => [...saferCityKeys.all, "users"],
-  usersList: (filters) => [...saferCityKeys.users(), "list", filters],
   usersDetail: (userId) => [...saferCityKeys.users(), "detail", userId],
   // Panics
   panics: () => [...saferCityKeys.all, "panics"],
   panicsList: (filters) => [...saferCityKeys.panics(), "list", filters],
   panicsDetail: (panicId) => [...saferCityKeys.panics(), "detail", panicId],
+  panicTypes: (userId) => [...saferCityKeys.panics(), "types", userId],
+  // Panic Information
+  panicInformation: () => [...saferCityKeys.all, "panicInformation"],
+  panicInformationDetail: (id) => [...saferCityKeys.panicInformation(), "detail", id],
+  panicInformationByUser: (userId) => [...saferCityKeys.panicInformation(), "byUser", userId],
+  panicEligibility: (userId) => [...saferCityKeys.panicInformation(), "eligibility", userId],
   // Subscriptions
   subscriptions: () => [...saferCityKeys.all, "subscriptions"],
   subscriptionsList: (filters) => [...saferCityKeys.subscriptions(), "list", filters],
@@ -266,11 +274,14 @@ var saferCityKeys = {
   subscriptionsStats: () => [...saferCityKeys.subscriptions(), "stats"],
   // Location Safety
   locationSafety: (lat, lng) => [...saferCityKeys.all, "location-safety", lat, lng],
+  // Banner
+  banner: (body) => [...saferCityKeys.all, "banner", body],
   // Crimes
   crimes: () => [...saferCityKeys.all, "crimes"],
   crimesList: (filters) => [...saferCityKeys.crimes(), "list", filters],
   crimesCategories: () => [...saferCityKeys.crimes(), "categories"],
-  crimesTypes: () => [...saferCityKeys.crimes(), "types"]
+  crimesTypes: () => [...saferCityKeys.crimes(), "types"],
+  crimeCategoriesWithTypes: () => [...saferCityKeys.crimes(), "categoriesWithTypes"]
 };
 function useHealthCheck(options) {
   const client = useSaferCityClient();
@@ -288,14 +299,6 @@ function useWhoAmI(options) {
     ...options
   });
 }
-function useUsers(filters, options) {
-  const client = useSaferCityClient();
-  return reactQuery.useQuery({
-    queryKey: saferCityKeys.usersList(filters),
-    queryFn: () => client.users.list(filters),
-    ...options
-  });
-}
 function useUser(userId, options) {
   const client = useSaferCityClient();
   return reactQuery.useQuery({
@@ -323,30 +326,10 @@ function useUpdateUser(options) {
     mutationFn: ({ userId, data }) => client.users.update(userId, data),
     onSuccess: (_, { userId }) => {
       queryClient.invalidateQueries({ queryKey: saferCityKeys.usersDetail(userId) });
-      queryClient.invalidateQueries({ queryKey: saferCityKeys.usersList() });
     },
     ...options
   });
 }
-function useDeleteUser(options) {
-  const client = useSaferCityClient();
-  const queryClient = reactQuery.useQueryClient();
-  return reactQuery.useMutation({
-    mutationFn: (userId) => client.users.delete(userId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: saferCityKeys.users() });
-    },
-    ...options
-  });
-}
-function usePanics(filters, options) {
-  const client = useSaferCityClient();
-  return reactQuery.useQuery({
-    queryKey: saferCityKeys.panicsList(filters),
-    queryFn: () => client.panics.list(filters),
-    ...options
-  });
-}
 function usePanic(panicId, query, options) {
   const client = useSaferCityClient();
   return reactQuery.useQuery({
@@ -390,6 +373,77 @@ function useCancelPanic(options) {
     ...options
   });
 }
+function usePanicTypes(userId, options) {
+  const client = useSaferCityClient();
+  return reactQuery.useQuery({
+    queryKey: saferCityKeys.panicTypes(userId),
+    queryFn: () => client.panics.types(userId),
+    enabled: !!userId,
+    staleTime: 1e3 * 60 * 10,
+    // 10 minutes - types don't change often
+    ...options
+  });
+}
+function usePanicInformation(id, options) {
+  const client = useSaferCityClient();
+  return reactQuery.useQuery({
+    queryKey: saferCityKeys.panicInformationDetail(id),
+    queryFn: () => client.panicInformation.get(id),
+    enabled: !!id,
+    ...options
+  });
+}
+function usePanicInformationByUser(userId, options) {
+  const client = useSaferCityClient();
+  return reactQuery.useQuery({
+    queryKey: saferCityKeys.panicInformationByUser(userId),
+    queryFn: () => client.panicInformation.getByUser(userId),
+    enabled: !!userId,
+    ...options
+  });
+}
+function usePanicEligibility(userId, options) {
+  const client = useSaferCityClient();
+  return reactQuery.useQuery({
+    queryKey: saferCityKeys.panicEligibility(userId),
+    queryFn: () => client.panicInformation.validateEligibility(userId),
+    enabled: !!userId,
+    ...options
+  });
+}
+function useCreatePanicInformation(options) {
+  const client = useSaferCityClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => client.panicInformation.create(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.panicInformation() });
+    },
+    ...options
+  });
+}
+function useUpdatePanicInformation(options) {
+  const client = useSaferCityClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ id, data }) => client.panicInformation.update(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.panicInformation() });
+    },
+    ...options
+  });
+}
+function useDeletePanicInformation(options) {
+  const client = useSaferCityClient();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (id) => client.panicInformation.delete(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.panicInformation() });
+    },
+    ...options
+  });
+}
 function useSubscriptionTypes(options) {
   const client = useSaferCityClient();
   return reactQuery.useQuery({
@@ -408,25 +462,35 @@ function useSubscriptions(filters, options) {
     ...options
   });
 }
-function useSubscriptionStats(options) {
+function useCreateSubscription(options) {
   const client = useSaferCityClient();
-  return reactQuery.useQuery({
-    queryKey: saferCityKeys.subscriptionsStats(),
-    queryFn: () => client.subscriptions.stats(),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => client.subscriptions.create(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.subscriptions() });
+    },
     ...options
   });
 }
-function useCreateSubscription(options) {
+function useSubscribeUser(options) {
   const client = useSaferCityClient();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
-    mutationFn: (data) => client.subscriptions.create(data),
+    mutationFn: (body) => client.subscriptions.subscribeUser(body),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: saferCityKeys.subscriptions() });
     },
     ...options
   });
 }
+function useBulkTriggerNotifications(options) {
+  const client = useSaferCityClient();
+  return reactQuery.useMutation({
+    mutationFn: (body) => client.notifications.bulkTrigger(body),
+    ...options
+  });
+}
 function useLocationSafety(latitude, longitude, radius, options) {
   const client = useSaferCityClient();
   return reactQuery.useQuery({
@@ -438,6 +502,17 @@ function useLocationSafety(latitude, longitude, radius, options) {
     ...options
   });
 }
+function useBanner(body, options) {
+  const client = useSaferCityClient();
+  return reactQuery.useQuery({
+    queryKey: saferCityKeys.banner(body),
+    queryFn: () => client.banner.get(body),
+    enabled: body.latitude !== void 0 && body.longitude !== void 0,
+    staleTime: 1e3 * 60 * 5,
+    // 5 minutes - location-based, changes moderately
+    ...options
+  });
+}
 function useCrimes(filters, options) {
   const client = useSaferCityClient();
   return reactQuery.useQuery({
@@ -466,6 +541,16 @@ function useCrimeTypes(options) {
     ...options
   });
 }
+function useCrimeCategoriesWithTypes(options) {
+  const client = useSaferCityClient();
+  return reactQuery.useQuery({
+    queryKey: saferCityKeys.crimeCategoriesWithTypes(),
+    queryFn: () => client.crimes.categoriesWithTypes(),
+    staleTime: 1e3 * 60 * 30,
+    // 30 minutes - categories rarely change
+    ...options
+  });
+}
 function usePanicStream(panicId, options = {}) {
   const client = useSaferCityClient();
   const {
@@ -663,31 +748,38 @@ function useStream(createStream, options = {}) {
 exports.SaferCityProvider = SaferCityProvider;
 exports.saferCityKeys = saferCityKeys;
 exports.useAuthMode = useAuthMode;
+exports.useBanner = useBanner;
+exports.useBulkTriggerNotifications = useBulkTriggerNotifications;
 exports.useCancelPanic = useCancelPanic;
 exports.useCreatePanic = useCreatePanic;
+exports.useCreatePanicInformation = useCreatePanicInformation;
 exports.useCreateSubscription = useCreateSubscription;
 exports.useCreateUser = useCreateUser;
 exports.useCrimeCategories = useCrimeCategories;
+exports.useCrimeCategoriesWithTypes = useCrimeCategoriesWithTypes;
 exports.useCrimeTypes = useCrimeTypes;
 exports.useCrimes = useCrimes;
-exports.useDeleteUser = useDeleteUser;
+exports.useDeletePanicInformation = useDeletePanicInformation;
 exports.useHealthCheck = useHealthCheck;
 exports.useLocationSafety = useLocationSafety;
 exports.usePanic = usePanic;
+exports.usePanicEligibility = usePanicEligibility;
+exports.usePanicInformation = usePanicInformation;
+exports.usePanicInformationByUser = usePanicInformationByUser;
 exports.usePanicStream = usePanicStream;
-exports.usePanics = usePanics;
+exports.usePanicTypes = usePanicTypes;
 exports.useSaferCity = useSaferCity;
 exports.useSaferCityClient = useSaferCityClient;
 exports.useSession = useSession;
 exports.useSessionManager = useSessionManager;
 exports.useStream = useStream;
-exports.useSubscriptionStats = useSubscriptionStats;
+exports.useSubscribeUser = useSubscribeUser;
 exports.useSubscriptionTypes = useSubscriptionTypes;
 exports.useSubscriptions = useSubscriptions;
+exports.useUpdatePanicInformation = useUpdatePanicInformation;
 exports.useUpdatePanicLocation = useUpdatePanicLocation;
 exports.useUpdateUser = useUpdateUser;
 exports.useUser = useUser;
-exports.useUsers = useUsers;
 exports.useWhoAmI = useWhoAmI;
 Object.keys(sdk).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {