feat: Duplicate pack from All Packs to My Packs (#1605)

apps/expo/features/packs/components/PackCard.tsx

@@ -7,7 +7,7 @@ import { router } from 'expo-router';
 import { isArray } from 'radash';
 import { useRef } from 'react';
 import { Image, Pressable, View } from 'react-native';
-import { useDeletePack, usePackDetailsFromStore } from '../hooks';
+import { useDeletePack, useDuplicatePack, usePackDetailsFromStore } from '../hooks';
 import { usePackOwnershipCheck } from '../hooks/usePackOwnershipCheck';
 import type { Pack, PackInStore } from '../types';
 
@@ -19,6 +19,7 @@ type PackCardProps = {
 
 export function PackCard({ pack: packArg, onPress, isGenUI = false }: PackCardProps) {
   const deletePack = useDeletePack();
+  const duplicatePack = useDuplicatePack();
   const { colors } = useColorScheme();
   const { showActionSheetWithOptions } = useActionSheet();
   const alertRef = useRef<AlertRef>(null);
@@ -27,15 +28,15 @@ export function PackCard({ pack: packArg, onPress, isGenUI = false }: PackCardPr
   const pack = (isOwnedByUser ? packFromStore : packArg) as Pack; // Use passed pack for non user owned pack.
 
   const handleActionsPress = () => {
-    const options =
-      isOwnedByUser && !isGenUI
-        ? ['View Details', 'Edit', 'Delete', 'Cancel']
-        : ['View Details', 'Cancel'];
+    const options = isOwnedByUser
+      ? ['View Details', 'Edit', 'Delete', 'Cancel']
+      : ['View Details', 'Duplicate', 'Cancel'];
 
     const cancelButtonIndex = options.length - 1;
     const destructiveButtonIndex = options.indexOf('Delete');
     const viewDetailsIndex = 0;
     const editIndex = options.indexOf('Edit');
+    const duplicateIndex = options.indexOf('Duplicate');
 
     showActionSheetWithOptions(
       {
@@ -66,6 +67,9 @@ export function PackCard({ pack: packArg, onPress, isGenUI = false }: PackCardPr
           case editIndex:
             router.push({ pathname: '/pack/[id]/edit', params: { id: pack.id } });
             break;
+          case duplicateIndex:
+            duplicatePack.mutate({ packId: pack.id });
+            break;
           case destructiveButtonIndex:
             alertRef.current?.alert({
               title: 'Delete pack?',

apps/expo/features/packs/hooks/index.ts

@@ -7,6 +7,7 @@ export * from './useCreatePackWithItems';
 export * from './useCurrentPack';
 export * from './useDeletePack';
 export * from './useDeletePackItem';
+export * from './useDuplicatePack';
 export * from './useDetailedPacks';
 export * from './useHasMinimumInventory';
 export * from './useImagePicker';

apps/expo/features/packs/hooks/useDuplicatePack.ts

@@ -0,0 +1,51 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useAuth } from 'expo-app/features/auth/hooks/useAuth';
+import { useRouter } from 'expo-router';
+
+export function useDuplicatePack() {
+  const { token } = useAuth();
+  const queryClient = useQueryClient();
+  const router = useRouter();
+
+  return useMutation({
+    mutationFn: async ({
+      packId,
+      name,
+    }: {
+      packId: string;
+      name?: string;
+    }): Promise<{
+      id: string;
+      name: string;
+      description: string | null;
+      category: string;
+      totalWeight: number;
+      baseWeight: number;
+    }> => {
+      const response = await fetch(
+        `${process.env.EXPO_PUBLIC_API_URL}/api/packs/${packId}/duplicate`,
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${token}`,
+          },
+          body: JSON.stringify({ name }),
+        },
+      );
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error || 'Failed to duplicate pack');
+      }
+
+      return response.json();
+    },
+    onSuccess: (data) => {
+      // Invalidate packs query to refresh the list
+      queryClient.invalidateQueries({ queryKey: ['packs'] });
+      // Navigate to the new pack
+      router.push({ pathname: '/pack/[id]', params: { id: data.id } });
+    },
+  });
+}

packages/api/src/routes/packs/pack.ts

@@ -245,6 +245,154 @@ packRoutes.openapi(deletePackRoute, async (c) => {
   return c.json({ success: true }, 200);
 });
 
+// Duplicate a pack
+const duplicatePackRoute = createRoute({
+  method: 'post',
+  path: '/{packId}/duplicate',
+  tags: ['Packs'],
+  summary: 'Duplicate pack',
+  description: 'Create a copy of a pack with all its items. The new pack will belong to the current user.',
+  security: [{ bearerAuth: [] }],
+  request: {
+    params: z.object({
+      packId: z.string().openapi({ example: 'p_123456' }),
+    }),
+    body: {
+      content: {
+        'application/json': {
+          schema: z.object({
+            name: z.string().optional().openapi({
+              example: 'My Copied Pack',
+              description: 'Optional name for the new pack. Defaults to "{original_name} (Copy)"',
+            }),
+          }),
+        },
+      },
+    },
+  },
+  responses: {
+    200: {
+      description: 'Pack duplicated successfully',
+      content: {
+        'application/json': {
+          schema: PackWithWeightsSchema,
+        },
+      },
+    },
+    404: {
+      description: 'Pack not found',
+      content: {
+        'application/json': {
+          schema: ErrorResponseSchema,
+        },
+      },
+    },
+    500: {
+      description: 'Internal server error',
+      content: {
+        'application/json': {
+          schema: ErrorResponseSchema,
+        },
+      },
+    },
+  },
+});
+
+packRoutes.openapi(duplicatePackRoute, async (c) => {
+  const db = createDb(c);
+  const auth = c.get('user');
+  const packId = c.req.param('packId');
+  const { name: customName } = await c.req.json().catch(() => ({}));
+
+  try {
+    // Get the source pack with items
+    const sourcePack = await db.query.packs.findFirst({
+      where: eq(packs.id, packId),
+      with: {
+        items: {
+          where: eq(packItems.deleted, false),
+        },
+      },
+    });
+
+    if (!sourcePack) {
+      return c.json({ error: 'Pack not found' }, 404);
+    }
+
+    // Generate new pack ID
+    const newPackId = `p_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const now = new Date();
+
+    // Create the new pack
+    const [newPack] = await db
+      .insert(packs)
+      .values({
+        id: newPackId,
+        name: customName || `${sourcePack.name} (Copy)`,
+        description: sourcePack.description,
+        category: sourcePack.category,
+        userId: auth.userId,
+        isPublic: false, // Duplicated packs are private by default
+        image: sourcePack.image,
+        tags: sourcePack.tags,
+        deleted: false,
+        isAIGenerated: false,
+        localCreatedAt: now,
+        localUpdatedAt: now,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .returning();
+
+    // Copy all items from source pack to new pack
+    if (sourcePack.items && sourcePack.items.length > 0) {
+      const newItems = sourcePack.items.map((item) => ({
+        id: `pi_${Date.now()}_${Math.random().toString(36).substring(2, 9)}_${Math.random().toString(36).substring(2, 5)}`,
+        name: item.name,
+        description: item.description,
+        weight: item.weight,
+        weightUnit: item.weightUnit,
+        quantity: item.quantity,
+        category: item.category,
+        consumable: item.consumable,
+        worn: item.worn,
+        image: item.image,
+        notes: item.notes,
+        packId: newPackId,
+        catalogItemId: item.catalogItemId,
+        userId: auth.userId,
+        deleted: false,
+        isAIGenerated: item.isAIGenerated,
+        templateItemId: item.templateItemId,
+        embedding: item.embedding,
+        createdAt: now,
+        updatedAt: now,
+      }));
+
+      await db.insert(packItems).values(newItems);
+    }
+
+    // Fetch the complete new pack with items
+    const packWithItems = await db.query.packs.findFirst({
+      where: eq(packs.id, newPackId),
+      with: {
+        items: {
+          where: eq(packItems.deleted, false),
+        },
+      },
+    });
+
+    if (!packWithItems) {
+      return c.json({ error: 'Failed to retrieve duplicated pack' }, 500);
+    }
+
+    return c.json(computePackWeights(packWithItems), 200);
+  } catch (error) {
+    console.error('Error duplicating pack:', error);
+    return c.json({ error: 'Failed to duplicate pack' }, 500);
+  }
+});
+
 const itemSuggestionsRoute = createRoute({
   method: 'post',
   path: '/{packId}/item-suggestions',