@growsober/sdk 1.0.0

package/dist/api/mutations/grow90.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEnrollGrow90 = useEnrollGrow90;
+exports.useUpdateGrow90Progress = useUpdateGrow90Progress;
+exports.useUpdateGrow90Settings = useUpdateGrow90Settings;
+exports.usePauseGrow90 = usePauseGrow90;
+exports.useResumeGrow90 = useResumeGrow90;
+exports.useAbandonGrow90 = useAbandonGrow90;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const grow90_1 = require("../queries/grow90");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Enroll in GROW90 program
+ */
+function useEnrollGrow90(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/grow90/enroll', data);
+            // API returns { data: {...}, meta: {...} }, extract the data
+            const enrollment = 'data' in response.data ? response.data.data : response.data;
+            return enrollment;
+        },
+        onSuccess: (enrollment) => {
+            queryClient.setQueryData(grow90_1.grow90Keys.enrollment(), enrollment);
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.today() });
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.progress() });
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.stats() });
+        },
+        ...options,
+    });
+}
+/**
+ * Update progress for a specific day
+ */
+function useUpdateGrow90Progress(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ day, data }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/grow90/progress/${day}`, data);
+            // API returns { data: {...}, meta: {...} }, extract the data
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.today() });
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.progress() });
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.stats() });
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.enrollment() });
+        },
+        ...options,
+    });
+}
+/**
+ * Update GROW90 settings
+ */
+function useUpdateGrow90Settings(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put('/api/v1/grow90/settings', data);
+            // API returns { data: {...}, meta: {...} }, extract the data
+            return response.data?.data || response.data;
+        },
+        onSuccess: (enrollment) => {
+            queryClient.setQueryData(grow90_1.grow90Keys.enrollment(), enrollment);
+        },
+        ...options,
+    });
+}
+/**
+ * Pause GROW90 program
+ */
+function usePauseGrow90(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/grow90/pause');
+            // API returns { data: {...}, meta: {...} }, extract the data
+            return response.data?.data || response.data;
+        },
+        onSuccess: (enrollment) => {
+            queryClient.setQueryData(grow90_1.grow90Keys.enrollment(), enrollment);
+        },
+        ...options,
+    });
+}
+/**
+ * Resume GROW90 program
+ */
+function useResumeGrow90(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/grow90/resume');
+            // API returns { data: {...}, meta: {...} }, extract the data
+            return response.data?.data || response.data;
+        },
+        onSuccess: (enrollment) => {
+            queryClient.setQueryData(grow90_1.grow90Keys.enrollment(), enrollment);
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.today() });
+        },
+        ...options,
+    });
+}
+/**
+ * Abandon GROW90 program
+ */
+function useAbandonGrow90(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/grow90/abandon');
+            // API returns { data: {...}, meta: {...} }, extract the data
+            return response.data?.data || response.data;
+        },
+        onSuccess: () => {
+            queryClient.setQueryData(grow90_1.grow90Keys.enrollment(), null);
+            queryClient.invalidateQueries({ queryKey: grow90_1.grow90Keys.all });
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grow90.js","sourceRoot":"","sources":["../../../src/api/mutations/grow90.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  useMutation,\n  useQueryClient,\n  UseMutationOptions,\n  UseMutationResult,\n} from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport type {\n  Grow90EnrollmentResponse,\n  Grow90ProgressResponse,\n  EnrollGrow90Request,\n  UpdateGrow90ProgressRequest,\n  UpdateGrow90SettingsRequest,\n} from '../types';\nimport { grow90Keys } from '../queries/grow90';\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Enroll in GROW90 program\n */\nexport function useEnrollGrow90(\n  options?: Omit<\n    UseMutationOptions<Grow90EnrollmentResponse, Error, EnrollGrow90Request>,\n    'mutationFn'\n  >\n): UseMutationResult<Grow90EnrollmentResponse, Error, EnrollGrow90Request> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: EnrollGrow90Request): Promise<Grow90EnrollmentResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/grow90/enroll', data);\n      // API returns { data: {...}, meta: {...} }, extract the data\n      const enrollment = 'data' in response.data ? response.data.data : response.data;\n      return enrollment;\n    },\n    onSuccess: (enrollment) => {\n      queryClient.setQueryData(grow90Keys.enrollment(), enrollment);\n      queryClient.invalidateQueries({ queryKey: grow90Keys.today() });\n      queryClient.invalidateQueries({ queryKey: grow90Keys.progress() });\n      queryClient.invalidateQueries({ queryKey: grow90Keys.stats() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update progress for a specific day\n */\nexport function useUpdateGrow90Progress(\n  options?: Omit<\n    UseMutationOptions<Grow90ProgressResponse, Error, { day: number; data: UpdateGrow90ProgressRequest }>,\n    'mutationFn'\n  >\n): UseMutationResult<Grow90ProgressResponse, Error, { day: number; data: UpdateGrow90ProgressRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({ day, data }): Promise<Grow90ProgressResponse> => {\n      const client = getApiClient();\n      const response = await client.put(`/api/v1/grow90/progress/${day}`, data);\n      // API returns { data: {...}, meta: {...} }, extract the data\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.invalidateQueries({ queryKey: grow90Keys.today() });\n      queryClient.invalidateQueries({ queryKey: grow90Keys.progress() });\n      queryClient.invalidateQueries({ queryKey: grow90Keys.stats() });\n      queryClient.invalidateQueries({ queryKey: grow90Keys.enrollment() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Update GROW90 settings\n */\nexport function useUpdateGrow90Settings(\n  options?: Omit<\n    UseMutationOptions<Grow90EnrollmentResponse, Error, UpdateGrow90SettingsRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<Grow90EnrollmentResponse, Error, UpdateGrow90SettingsRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: UpdateGrow90SettingsRequest): Promise<Grow90EnrollmentResponse> => {\n      const client = getApiClient();\n      const response = await client.put('/api/v1/grow90/settings', data);\n      // API returns { data: {...}, meta: {...} }, extract the data\n      return response.data?.data || response.data;\n    },\n    onSuccess: (enrollment) => {\n      queryClient.setQueryData(grow90Keys.enrollment(), enrollment);\n    },\n    ...options,\n  });\n}\n\n/**\n * Pause GROW90 program\n */\nexport function usePauseGrow90(\n  options?: Omit<UseMutationOptions<Grow90EnrollmentResponse, Error, void>, 'mutationFn'>\n): UseMutationResult<Grow90EnrollmentResponse, Error, void> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (): Promise<Grow90EnrollmentResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/grow90/pause');\n      // API returns { data: {...}, meta: {...} }, extract the data\n      return response.data?.data || response.data;\n    },\n    onSuccess: (enrollment) => {\n      queryClient.setQueryData(grow90Keys.enrollment(), enrollment);\n    },\n    ...options,\n  });\n}\n\n/**\n * Resume GROW90 program\n */\nexport function useResumeGrow90(\n  options?: Omit<UseMutationOptions<Grow90EnrollmentResponse, Error, void>, 'mutationFn'>\n): UseMutationResult<Grow90EnrollmentResponse, Error, void> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (): Promise<Grow90EnrollmentResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/grow90/resume');\n      // API returns { data: {...}, meta: {...} }, extract the data\n      return response.data?.data || response.data;\n    },\n    onSuccess: (enrollment) => {\n      queryClient.setQueryData(grow90Keys.enrollment(), enrollment);\n      queryClient.invalidateQueries({ queryKey: grow90Keys.today() });\n    },\n    ...options,\n  });\n}\n\n/**\n * Abandon GROW90 program\n */\nexport function useAbandonGrow90(\n  options?: Omit<UseMutationOptions<{ success: boolean }, Error, void>, 'mutationFn'>\n): UseMutationResult<{ success: boolean }, Error, void> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (): Promise<{ success: boolean }> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/grow90/abandon');\n      // API returns { data: {...}, meta: {...} }, extract the data\n      return response.data?.data || response.data;\n    },\n    onSuccess: () => {\n      queryClient.setQueryData(grow90Keys.enrollment(), null);\n      queryClient.invalidateQueries({ queryKey: grow90Keys.all });\n    },\n    ...options,\n  });\n}\n"]}

package/dist/api/mutations/hubs.d.ts

@@ -0,0 +1,111 @@
+import { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import type { HubResponse, CreateHubRequest, UpdateHubRequest } from '../types';
+export interface UpdateMemberRoleRequest {
+    role: 'OWNER' | 'ADMIN' | 'MEMBER';
+}
+export interface JoinHubResponse {
+    message: string;
+    membership: {
+        id: string;
+        hubId: string;
+        userId: string;
+        role: 'MEMBER';
+        status: 'ACTIVE' | 'PENDING';
+        joinedAt: string;
+    };
+}
+export interface LeaveHubResponse {
+    message: string;
+}
+export interface ApproveMemberResponse {
+    message: string;
+}
+export interface UpdateMemberRoleResponse {
+    message: string;
+    role: 'OWNER' | 'ADMIN' | 'MEMBER';
+}
+export interface RemoveMemberResponse {
+    message: string;
+}
+/**
+ * Create a new hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useCreateHub(options?: Omit<UseMutationOptions<HubResponse, Error, CreateHubRequest>, 'mutationFn'>): UseMutationResult<HubResponse, Error, CreateHubRequest>;
+/**
+ * Update an existing hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useUpdateHub(options?: Omit<UseMutationOptions<HubResponse, Error, {
+    id: string;
+    data: UpdateHubRequest;
+}>, 'mutationFn'>): UseMutationResult<HubResponse, Error, {
+    id: string;
+    data: UpdateHubRequest;
+}>;
+/**
+ * Delete a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useDeleteHub(options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>): UseMutationResult<void, Error, string>;
+/**
+ * Join a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useJoinHub(options?: Omit<UseMutationOptions<JoinHubResponse, Error, string>, 'mutationFn'>): UseMutationResult<JoinHubResponse, Error, string>;
+/**
+ * Leave a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useLeaveHub(options?: Omit<UseMutationOptions<LeaveHubResponse, Error, string>, 'mutationFn'>): UseMutationResult<LeaveHubResponse, Error, string>;
+/**
+ * Approve a pending member
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useApproveMember(options?: Omit<UseMutationOptions<ApproveMemberResponse, Error, {
+    hubId: string;
+    memberId: string;
+}>, 'mutationFn'>): UseMutationResult<ApproveMemberResponse, Error, {
+    hubId: string;
+    memberId: string;
+}>;
+/**
+ * Update a member's role
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useUpdateMemberRole(options?: Omit<UseMutationOptions<UpdateMemberRoleResponse, Error, {
+    hubId: string;
+    memberId: string;
+    data: UpdateMemberRoleRequest;
+}>, 'mutationFn'>): UseMutationResult<UpdateMemberRoleResponse, Error, {
+    hubId: string;
+    memberId: string;
+    data: UpdateMemberRoleRequest;
+}>;
+/**
+ * Remove a member from a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+export declare function useRemoveMember(options?: Omit<UseMutationOptions<RemoveMemberResponse, Error, {
+    hubId: string;
+    memberId: string;
+}>, 'mutationFn'>): UseMutationResult<RemoveMemberResponse, Error, {
+    hubId: string;
+    memberId: string;
+}>;

package/dist/api/mutations/hubs.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateHub = useCreateHub;
+exports.useUpdateHub = useUpdateHub;
+exports.useDeleteHub = useDeleteHub;
+exports.useJoinHub = useJoinHub;
+exports.useLeaveHub = useLeaveHub;
+exports.useApproveMember = useApproveMember;
+exports.useUpdateMemberRole = useUpdateMemberRole;
+exports.useRemoveMember = useRemoveMember;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../client");
+const hubs_1 = require("../queries/hubs");
+// ============================================================================
+// MUTATION HOOKS
+// ============================================================================
+/**
+ * Create a new hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useCreateHub(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/api/v1/hubs', data);
+            return response.data;
+        },
+        onSuccess: (newHub, variables, context) => {
+            // Invalidate all hub lists to refetch with the new hub
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.lists() });
+            // Invalidate my hubs list
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.myHubs() });
+            // Set the new hub in the cache
+            queryClient.setQueryData(hubs_1.hubKeys.detail(newHub.id), newHub);
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Update an existing hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useUpdateHub(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ id, data, }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/hubs/${id}`, data);
+            return response.data;
+        },
+        onSuccess: (updatedHub, variables, context) => {
+            // Update the hub in the cache
+            queryClient.setQueryData(hubs_1.hubKeys.detail(updatedHub.id), updatedHub);
+            // Invalidate hub lists to refetch with updated data
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.lists() });
+            // Invalidate my hubs list
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.myHubs() });
+            // Invalidate slug-based query since slug might have changed
+            queryClient.invalidateQueries({
+                queryKey: hubs_1.hubKeys.bySlug(updatedHub.slug)
+            });
+            // Call user's onSuccess if provided
+        },
+        ...options,
+    });
+}
+/**
+ * Delete a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useDeleteHub(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (id) => {
+            const client = (0, client_1.getApiClient)();
+            await client.delete(`/api/v1/hubs/${id}`);
+        },
+        onSuccess: (data, id, context) => {
+            // Remove the hub from the cache
+            queryClient.removeQueries({ queryKey: hubs_1.hubKeys.detail(id) });
+            // Invalidate all hub lists to refetch without the deleted hub
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.lists() });
+            // Invalidate my hubs list
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.myHubs() });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Join a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useJoinHub(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (id) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/hubs/${id}/join`);
+            return response.data;
+        },
+        onSuccess: (data, id, context) => {
+            // Invalidate membership status for this hub
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.membership(id) });
+            // Invalidate my hubs list
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.myHubs() });
+            // Invalidate hub members list
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.members(id) });
+            // Refetch hub details to update member count
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.detail(id) });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Leave a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useLeaveHub(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (id) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/hubs/${id}/leave`);
+            return response.data;
+        },
+        onSuccess: (data, id, context) => {
+            // Invalidate membership status for this hub
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.membership(id) });
+            // Invalidate my hubs list
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.myHubs() });
+            // Invalidate hub members list
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.members(id) });
+            // Refetch hub details to update member count
+            queryClient.invalidateQueries({ queryKey: hubs_1.hubKeys.detail(id) });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Approve a pending member
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useApproveMember(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ hubId, memberId, }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post(`/api/v1/hubs/${hubId}/members/${memberId}/approve`);
+            return response.data;
+        },
+        onSuccess: (data, variables, context) => {
+            // Invalidate hub members list to refetch with updated status
+            queryClient.invalidateQueries({
+                queryKey: hubs_1.hubKeys.members(variables.hubId)
+            });
+            // Refetch hub details to update member count
+            queryClient.invalidateQueries({
+                queryKey: hubs_1.hubKeys.detail(variables.hubId)
+            });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Update a member's role
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useUpdateMemberRole(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ hubId, memberId, data, }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put(`/api/v1/hubs/${hubId}/members/${memberId}/role`, data);
+            return response.data;
+        },
+        onSuccess: (data, variables, context) => {
+            // Invalidate hub members list to refetch with updated role
+            queryClient.invalidateQueries({
+                queryKey: hubs_1.hubKeys.members(variables.hubId)
+            });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+/**
+ * Remove a member from a hub
+ *
+ * @param options - React Query mutation options
+ * @returns Mutation result
+ */
+function useRemoveMember(options) {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async ({ hubId, memberId, }) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.delete(`/api/v1/hubs/${hubId}/members/${memberId}`);
+            return response.data;
+        },
+        onSuccess: (data, variables, context) => {
+            // Invalidate hub members list to refetch without removed member
+            queryClient.invalidateQueries({
+                queryKey: hubs_1.hubKeys.members(variables.hubId)
+            });
+            // Refetch hub details to update member count
+            queryClient.invalidateQueries({
+                queryKey: hubs_1.hubKeys.detail(variables.hubId)
+            });
+            // Call user's onSuccess if provided
+            // User's onSuccess is handled by spreading options
+        },
+        ...options,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hubs.js","sourceRoot":"","sources":["../../../src/api/mutations/hubs.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  useMutation,\n  useQueryClient,\n  UseMutationOptions,\n  UseMutationResult,\n} from '@tanstack/react-query';\nimport { getApiClient } from '../client';\nimport type { HubResponse, CreateHubRequest, UpdateHubRequest } from '../types';\nimport { hubKeys } from '../queries/hubs';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport interface UpdateMemberRoleRequest {\n  role: 'OWNER' | 'ADMIN' | 'MEMBER';\n}\n\nexport interface JoinHubResponse {\n  message: string;\n  membership: {\n    id: string;\n    hubId: string;\n    userId: string;\n    role: 'MEMBER';\n    status: 'ACTIVE' | 'PENDING';\n    joinedAt: string;\n  };\n}\n\nexport interface LeaveHubResponse {\n  message: string;\n}\n\nexport interface ApproveMemberResponse {\n  message: string;\n}\n\nexport interface UpdateMemberRoleResponse {\n  message: string;\n  role: 'OWNER' | 'ADMIN' | 'MEMBER';\n}\n\nexport interface RemoveMemberResponse {\n  message: string;\n}\n\n// ============================================================================\n// MUTATION HOOKS\n// ============================================================================\n\n/**\n * Create a new hub\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useCreateHub(\n  options?: Omit<\n    UseMutationOptions<HubResponse, Error, CreateHubRequest>,\n    'mutationFn'\n  >\n): UseMutationResult<HubResponse, Error, CreateHubRequest> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (data: CreateHubRequest): Promise<HubResponse> => {\n      const client = getApiClient();\n      const response = await client.post('/api/v1/hubs', data);\n      return response.data;\n    },\n    onSuccess: (newHub, variables, context) => {\n      // Invalidate all hub lists to refetch with the new hub\n      queryClient.invalidateQueries({ queryKey: hubKeys.lists() });\n      // Invalidate my hubs list\n      queryClient.invalidateQueries({ queryKey: hubKeys.myHubs() });\n      // Set the new hub in the cache\n      queryClient.setQueryData(hubKeys.detail(newHub.id), newHub);\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Update an existing hub\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useUpdateHub(\n  options?: Omit<\n    UseMutationOptions<HubResponse, Error, { id: string; data: UpdateHubRequest }>,\n    'mutationFn'\n  >\n): UseMutationResult<HubResponse, Error, { id: string; data: UpdateHubRequest }> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      id,\n      data,\n    }: {\n      id: string;\n      data: UpdateHubRequest;\n    }): Promise<HubResponse> => {\n      const client = getApiClient();\n      const response = await client.put(`/api/v1/hubs/${id}`, data);\n      return response.data;\n    },\n    onSuccess: (updatedHub, variables, context) => {\n      // Update the hub in the cache\n      queryClient.setQueryData(hubKeys.detail(updatedHub.id), updatedHub);\n      // Invalidate hub lists to refetch with updated data\n      queryClient.invalidateQueries({ queryKey: hubKeys.lists() });\n      // Invalidate my hubs list\n      queryClient.invalidateQueries({ queryKey: hubKeys.myHubs() });\n      // Invalidate slug-based query since slug might have changed\n      queryClient.invalidateQueries({\n        queryKey: hubKeys.bySlug(updatedHub.slug)\n      });\n\n      // Call user's onSuccess if provided\n    },\n    ...options,\n  });\n}\n\n/**\n * Delete a hub\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useDeleteHub(\n  options?: Omit<UseMutationOptions<void, Error, string>, 'mutationFn'>\n): UseMutationResult<void, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<void> => {\n      const client = getApiClient();\n      await client.delete(`/api/v1/hubs/${id}`);\n    },\n    onSuccess: (data, id, context) => {\n      // Remove the hub from the cache\n      queryClient.removeQueries({ queryKey: hubKeys.detail(id) });\n      // Invalidate all hub lists to refetch without the deleted hub\n      queryClient.invalidateQueries({ queryKey: hubKeys.lists() });\n      // Invalidate my hubs list\n      queryClient.invalidateQueries({ queryKey: hubKeys.myHubs() });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Join a hub\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useJoinHub(\n  options?: Omit<UseMutationOptions<JoinHubResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<JoinHubResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<JoinHubResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/hubs/${id}/join`);\n      return response.data;\n    },\n    onSuccess: (data, id, context) => {\n      // Invalidate membership status for this hub\n      queryClient.invalidateQueries({ queryKey: hubKeys.membership(id) });\n      // Invalidate my hubs list\n      queryClient.invalidateQueries({ queryKey: hubKeys.myHubs() });\n      // Invalidate hub members list\n      queryClient.invalidateQueries({ queryKey: hubKeys.members(id) });\n      // Refetch hub details to update member count\n      queryClient.invalidateQueries({ queryKey: hubKeys.detail(id) });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Leave a hub\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useLeaveHub(\n  options?: Omit<UseMutationOptions<LeaveHubResponse, Error, string>, 'mutationFn'>\n): UseMutationResult<LeaveHubResponse, Error, string> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async (id: string): Promise<LeaveHubResponse> => {\n      const client = getApiClient();\n      const response = await client.post(`/api/v1/hubs/${id}/leave`);\n      return response.data;\n    },\n    onSuccess: (data, id, context) => {\n      // Invalidate membership status for this hub\n      queryClient.invalidateQueries({ queryKey: hubKeys.membership(id) });\n      // Invalidate my hubs list\n      queryClient.invalidateQueries({ queryKey: hubKeys.myHubs() });\n      // Invalidate hub members list\n      queryClient.invalidateQueries({ queryKey: hubKeys.members(id) });\n      // Refetch hub details to update member count\n      queryClient.invalidateQueries({ queryKey: hubKeys.detail(id) });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Approve a pending member\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useApproveMember(\n  options?: Omit<\n    UseMutationOptions<\n      ApproveMemberResponse,\n      Error,\n      { hubId: string; memberId: string }\n    >,\n    'mutationFn'\n  >\n): UseMutationResult<\n  ApproveMemberResponse,\n  Error,\n  { hubId: string; memberId: string }\n> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      hubId,\n      memberId,\n    }: {\n      hubId: string;\n      memberId: string;\n    }): Promise<ApproveMemberResponse> => {\n      const client = getApiClient();\n      const response = await client.post(\n        `/api/v1/hubs/${hubId}/members/${memberId}/approve`\n      );\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate hub members list to refetch with updated status\n      queryClient.invalidateQueries({\n        queryKey: hubKeys.members(variables.hubId)\n      });\n      // Refetch hub details to update member count\n      queryClient.invalidateQueries({\n        queryKey: hubKeys.detail(variables.hubId)\n      });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Update a member's role\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useUpdateMemberRole(\n  options?: Omit<\n    UseMutationOptions<\n      UpdateMemberRoleResponse,\n      Error,\n      { hubId: string; memberId: string; data: UpdateMemberRoleRequest }\n    >,\n    'mutationFn'\n  >\n): UseMutationResult<\n  UpdateMemberRoleResponse,\n  Error,\n  { hubId: string; memberId: string; data: UpdateMemberRoleRequest }\n> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      hubId,\n      memberId,\n      data,\n    }: {\n      hubId: string;\n      memberId: string;\n      data: UpdateMemberRoleRequest;\n    }): Promise<UpdateMemberRoleResponse> => {\n      const client = getApiClient();\n      const response = await client.put(\n        `/api/v1/hubs/${hubId}/members/${memberId}/role`,\n        data\n      );\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate hub members list to refetch with updated role\n      queryClient.invalidateQueries({\n        queryKey: hubKeys.members(variables.hubId)\n      });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n\n/**\n * Remove a member from a hub\n *\n * @param options - React Query mutation options\n * @returns Mutation result\n */\nexport function useRemoveMember(\n  options?: Omit<\n    UseMutationOptions<\n      RemoveMemberResponse,\n      Error,\n      { hubId: string; memberId: string }\n    >,\n    'mutationFn'\n  >\n): UseMutationResult<\n  RemoveMemberResponse,\n  Error,\n  { hubId: string; memberId: string }\n> {\n  const queryClient = useQueryClient();\n\n  return useMutation({\n    mutationFn: async ({\n      hubId,\n      memberId,\n    }: {\n      hubId: string;\n      memberId: string;\n    }): Promise<RemoveMemberResponse> => {\n      const client = getApiClient();\n      const response = await client.delete(\n        `/api/v1/hubs/${hubId}/members/${memberId}`\n      );\n      return response.data;\n    },\n    onSuccess: (data, variables, context) => {\n      // Invalidate hub members list to refetch without removed member\n      queryClient.invalidateQueries({\n        queryKey: hubKeys.members(variables.hubId)\n      });\n      // Refetch hub details to update member count\n      queryClient.invalidateQueries({\n        queryKey: hubKeys.detail(variables.hubId)\n      });\n\n      // Call user's onSuccess if provided\n      // User's onSuccess is handled by spreading options\n    },\n    ...options,\n  });\n}\n"]}

package/dist/api/mutations/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Mutation Hooks
+ *
+ * Re-exports all mutation hooks for API endpoints.
+ */
+export * from './admin';
+export * from './auth';
+export * from './bookings';
+export * from './events';
+export * from './hubs';
+export * from './library';
+export * from './map';
+export * from './notifications';
+export * from './offers';
+export * from './subscriptions';
+export * from './support';
+export * from './users';
+export * from './jack';
+export * from './ambassadors';
+export * from './grow90';
+export * from './matching';
+export * from './event-chat';

package/dist/api/mutations/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Mutation Hooks
+ *
+ * Re-exports all mutation hooks for API endpoints.
+ */
+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("./admin"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./bookings"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./hubs"), exports);
+__exportStar(require("./library"), exports);
+__exportStar(require("./map"), exports);
+__exportStar(require("./notifications"), exports);
+__exportStar(require("./offers"), exports);
+__exportStar(require("./subscriptions"), exports);
+__exportStar(require("./support"), exports);
+__exportStar(require("./users"), exports);
+__exportStar(require("./jack"), exports);
+__exportStar(require("./ambassadors"), exports);
+__exportStar(require("./grow90"), exports);
+__exportStar(require("./matching"), exports);
+__exportStar(require("./event-chat"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBpL211dGF0aW9ucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7R0FJRzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILDBDQUF3QjtBQUN4Qix5Q0FBdUI7QUFDdkIsNkNBQTJCO0FBQzNCLDJDQUF5QjtBQUN6Qix5Q0FBdUI7QUFDdkIsNENBQTBCO0FBQzFCLHdDQUFzQjtBQUN0QixrREFBZ0M7QUFDaEMsMkNBQXlCO0FBQ3pCLGtEQUFnQztBQUNoQyw0Q0FBMEI7QUFDMUIsMENBQXdCO0FBQ3hCLHlDQUF1QjtBQUN2QixnREFBOEI7QUFDOUIsMkNBQXlCO0FBQ3pCLDZDQUEyQjtBQUMzQiwrQ0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE11dGF0aW9uIEhvb2tzXG4gKlxuICogUmUtZXhwb3J0cyBhbGwgbXV0YXRpb24gaG9va3MgZm9yIEFQSSBlbmRwb2ludHMuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9hZG1pbic7XG5leHBvcnQgKiBmcm9tICcuL2F1dGgnO1xuZXhwb3J0ICogZnJvbSAnLi9ib29raW5ncyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2h1YnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWJyYXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vbWFwJztcbmV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL29mZmVycyc7XG5leHBvcnQgKiBmcm9tICcuL3N1YnNjcmlwdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdXBwb3J0JztcbmV4cG9ydCAqIGZyb20gJy4vdXNlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9qYWNrJztcbmV4cG9ydCAqIGZyb20gJy4vYW1iYXNzYWRvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9ncm93OTAnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXRjaGluZyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50LWNoYXQnO1xuIl19