#!/bin/bash
# Inspect the target file to understand context
cat backend/plugins/sales_api/src/modules/pos/graphql/resolvers/mutations/pos.ts

#!/bin/bash
# Search for onServer usage throughout the codebase
rg -nP --type=ts --type=tsx 'onServer' -B2 -A2

#!/bin/bash
# Search specifically for onServer being set to false
rg -nP --type=ts --type=tsx 'onServer\s*[=:]\s*false' -B3 -A3

#!/bin/bash
# Search for POS model and posAdd method to understand the flow
rg -nP 'posAdd' -B3 -A5

#!/bin/bash
# Retry search for onServer usage with correct rg syntax (no tsx type)
rg -nP 'onServer' -B2 -A2 --type ts

#!/bin/bash
# Search for any usage of onServer: false or onServer false across entire codebase
rg -nP 'onServer.*false|false.*onServer' -B2 -A2

#!/bin/bash
# Check if there are any type definitions for IPos that document onServer
fd -e ts -e js | xargs grep -l 'interface IPos\|type IPos' | head -5

#!/bin/bash
# Find the formSchema.ts file and examine schema definitions
fd -type f -name "formSchema.ts" | head -5

#!/bin/bash
# Search for productDetailSchema definition
rg -n "productDetailSchema\s*=" --type ts

#!/bin/bash
# Search for productGroups usage in the codebase
rg -n "productGroups" --type ts -C 3

#!/bin/bash
# Search for productGroupSchema if it already exists
rg -n "productGroupSchema\s*=" --type ts

#!/bin/bash
# Search for productSchema usage to understand consumers
rg -n "productSchema" --type ts -C 2 | head -50

#!/bin/bash
# Look for any group-related schemas or types
rg -n "group.*Schema|GroupSchema" --type ts -i

#!/bin/bash
# Check for name and description fields being used with productGroups
rg -n "\.name|\.description" --type ts | grep -i group | head -20

#!/bin/bash
# Examine the specific file and surrounding context
cat frontend/plugins/sales_ui/src/modules/pos/create-pos/components/formSchema.ts 2>/dev/null || echo "File not found in expected location"

#!/bin/bash
# Search more broadly for formSchema files
fd -type f -name "*formSchema*" --type f

#!/bin/bash
# Search for product group related code patterns
rg -n "productGroup|product.*group" --type ts -i | head -30

#!/bin/bash
# Check for any imports or references that might indicate schema structure
rg -n "import.*productDetailSchema|import.*productSchema" --type ts -C 1

#!/bin/bash
# Search for object patterns with name and description to understand group expectations
rg -nP "name\s*:\s*z\.string.*description\s*:\s*z\.string" --type ts -A 2 -B 2

#!/bin/bash
# Look for any UI components using productGroups to understand expectations
rg -n "productGroups\?" --type tsx -C 5

#!/bin/bash
# Find all schema definitions in the formSchema file if it exists
fd -type f -name "formSchema.ts" -x cat {}

#!/bin/bash
# Search for type or interface definitions related to product groups
rg -n "interface.*[Gg]roup|type.*[Gg]roup" --type ts | grep -i product | head -20

#!/bin/bash
# Check API response or backend schema references
rg -n "Group.*name.*description|group.*metadata" --type ts -i -C 2 | head -30

#!/bin/bash
# Look at all z.object definitions to understand schema patterns
rg -n "const.*Schema\s*=" --type ts | grep -E "(product|group)" | head -20

#!/bin/bash
# Search in TypeScript files more broadly for schema files
find . -name "*.ts" -o -name "*.tsx" | xargs grep -l "productSchema\|productDetailSchema" 2>/dev/null | head -10

#!/bin/bash
# Get complete view of schemas in the directory
rg -n "export const.*Schema" frontend/plugins/sales_ui/src/modules/pos/create-pos/components/ --type ts -A 5 2>/dev/null | head -100

#!/bin/bash
# Search for the actual file more carefully with broader path search
find . -path "*sales_ui*" -name "*formSchema*" -type f 2>/dev/null

#!/bin/bash
# Try alternative approach - search all TypeScript files for productSchema definition
rg -l "export const productSchema" --type ts

#!/bin/bash
# Get content of the specific file from any location
rg -A 30 "export const productSchema" --type ts -B 5

#!/bin/bash
# List files in the likely directory
ls -la frontend/plugins/sales_ui/src/modules/pos/create-pos/components/ 2>/dev/null || echo "Path not found - searching alternatives"

#!/bin/bash
# Search for any POS-related formSchema files
find . -type d -name "create-pos" 2>/dev/null -exec find {} -name "*Schema*" \;

#!/bin/bash
# Broad search for all schema files that mention products
find . -type f \( -name "*.ts" -o -name "*.tsx" \) -exec grep -l "productSchema\|productDetailSchema" {} \; 2>/dev/null | head -15

#!/bin/bash
# Look for complete schema by searching more lines
rg -A 15 "export const productSchema = z.object" --type ts

#!/bin/bash
# Find where productGroups is actually used
rg "productGroups" --type ts --type tsx -B 5 -A 5 | head -100

#!/bin/bash
# Check what fields are expected in group items
rg -n "\._id|\['_id'\]|\.name|\['name'\]" --type ts | grep -i group -A 2 -B 2 | head -40

#!/bin/bash
# Directory structure investigation
find . -type d -name "pos" -o -type d -name "create-pos" 2>/dev/null

#!/bin/bash
# Final comprehensive search for schema file content
rg "productDetailSchema\|productGroupSchema" --type ts -B 10 -A 10 | head -150

#!/bin/bash
# Search for group object creation or typing patterns
rg "name.*description.*category|category.*name" --type ts -i -C 3 | grep -i group -A 3 -B 3 | head -50

#!/bin/bash
# Find ProductGroup interface definition in frontend
rg -n "export interface ProductGroup" --type ts -A 10

#!/bin/bash
# Find IProductGroup interface definition in backend
rg -n "export interface IProductGroup" --type ts -A 15

#!/bin/bash
# Check the backend productGroupSchema definition
rg -n "export const productGroupSchema" --type ts -A 20

#!/bin/bash
# Check GraphQL ProductGroups type definition
rg -n "type ProductGroups|type ProductGroups {" --type ts -A 15

#!/bin/bash
# See what GroupInput expects in the mutation
rg -n "GroupInput" --type ts -A 10 -B 2

#!/bin/bash
# Check backend mutation resolver for productGroupsBulkInsert
rg -n "productGroupsBulkInsert" --type ts -A 20 | head -80

#!/bin/bash
# Look for group creation/editing in backend models
rg -n "groupsAdd|groupsEdit" --type ts -A 10 -B 2

#!/bin/bash
# Check how groups are persisted in backend
rg -n "ProductGroups.create|ProductGroup.create" --type ts -A 5 -B 2

#!/bin/bash
# Verify what posDetail stores for productGroups
rg -n "posDetail.*productGroups\|productGroups.*posDetail" --type ts -C 3 | head -50

#!/bin/bash
# Check if there's form validation or TypeScript type for productGroups
rg -n "type ProductFormValues" --type ts -A 20

#!/bin/bash
# Look at the GraphQL schema query return type for productGroups
rg -n "query productGroups" --type ts -A 15

#!/bin/bash
# Check if there's any group name/description field being used in the UI
rg -n "productGroups\[.*\]\.name|productGroups.*\.description" --type ts -C 2

#!/bin/bash
# Inspect usages of productDetails
rg -nP -C3 --type=ts --type=tsx '\bproductDetails\b'

#!/bin/bash
# Search for productDetails usages - simplified rg syntax
rg -nC3 'productDetails' --type=ts

#!/bin/bash
# Broader search for productDetails across all file types
rg -nC3 'productDetails'

#!/bin/bash
# Double-check for any existing declarations of isRequired on ProductGroup
rg -n -C2 -P 'ProductGroup.*isRequired' frontend

#!/bin/bash
# Find where ProductGroup is used in the UI
rg -n -C3 'ProductGroup' frontend/plugins/sales_ui/src --type=ts --type=tsx | head -50

#!/bin/bash
# Search for isRequired in the sales_ui plugin
rg -n 'isRequired' frontend/plugins/sales_ui/src --type=ts --type=tsx

#!/bin/bash
# Find the component/file that uses productGroups and check for binding
rg -n -C4 'productGroups\s*\[' frontend/plugins/sales_ui/src --type=ts --type=tsx

#!/bin/bash
# Find where ProductGroup is used in the UI (without type flags)
rg -n -C3 'ProductGroup' frontend/plugins/sales_ui/src

#!/bin/bash
# Search for isRequired in the sales_ui plugin (without type flags)
rg -n 'isRequired' frontend/plugins/sales_ui/src

#!/bin/bash
# Find the component/file that uses productGroups and check for binding
rg -n -C4 'productGroups\s*\[' frontend/plugins/sales_ui/src

#!/bin/bash
# Get context around formSchema.ts line 22 to see if it's ProductGroup schema
rg -n -B5 -A5 'isRequired.*z\.boolean' frontend/plugins/sales_ui/src/modules/pos/create-pos/components/formSchema.ts

#!/bin/bash
# Get context around the productGroups.${index}.isRequired binding in product.tsx
rg -n -B3 -A3 'productGroups.*isRequired' frontend/plugins/sales_ui/src/modules/pos/create-pos/components/product/product.tsx

#!/bin/bash
# Find mutation and return type for product group save
rg -n -C3 -P '(mutation\s+saveProductGroups|productGroupsBulkInsert)' --type=ts --type=tsx --type=graphql
# Look for GraphQL type with key fields (__typename/id/_id) that identify productGroupsBulkInsert
rg -n -C2 -P '(type|interface)\s+.*ProductGroup|productGroupsBulkInsert|@key' --type=graphql --type=ts --type=tsx

#!/bin/bash
# Search without file type restrictions for the mutation and related types
rg -n -C3 'saveProductGroups|productGroupsBulkInsert' --multiline

#!/bin/bash
# Check the target hook file directly
cat "frontend/plugins/sales_ui/src/modules/pos/hooks/usePosEditProductGroup.tsx"

#!/bin/bash
# Search for GraphQL files with different extensions
fd -e 'gql' -e 'graphql' -e 'ts' -e 'tsx' | head -20

#!/bin/bash
# Look for GraphQL schema or mutation definitions in common locations
find . -type f \( -name "*.graphql" -o -name "*.gql" -o -name "*schema*" -o -name "*mutation*" \) 2>/dev/null | grep -i "product\|group" | head -20

#!/bin/bash
# Search for fieldsToUpdate definition and usage
rg -n 'fieldsToUpdate' --multiline -C5

#!/bin/bash
# Check Apollo cache usage patterns in the codebase
rg -n 'cache\.modify' --multiline -C3 | head -40

#!/bin/bash
# Find cache.identify usage patterns
rg -n 'cache\.identify' --multiline -C2 | head -30

#!/bin/bash
# Verify whether _id is optional in mapping schema
rg -n -C2 -P 'catProdMappingSchema|catProdMappings' frontend
rg -n -C2 -P 'z\.object\(\{[^}]*_id' frontend