create-ern-boilerplate 0.0.48 → 0.0.50

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(cat:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-ern-boilerplate",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "description": "Expo React Native boilerplate generator",
   "bin": {
     "create-ern-boilerplate": "./create.js",

package/templates/agent-generator/AI_GUIDE.md

@@ -32,6 +32,24 @@ Each file has a specific purpose:
 
 **Full details in respective files. This is just a quick reference.**
 
+### 🔴 MOST IMPORTANT: Mock API Default (See SERVER_GUIDE.md)
+
+**ALWAYS use Mock API unless user EXPLICITLY requests otherwise!**
+
+- ✅ **DEFAULT BEHAVIOR: Use Mock API** - Always create mock API for any feature
+- ✅ Use `service-with-mock.example.ts` pattern for services
+- ✅ Add 2-4 sample items to `server/db.json`
+- ✅ Create mock API file in `src/services/mockApi/`
+- ❌ **NEVER connect to real API** unless user explicitly says:
+  - "use real API"
+  - "connect to actual backend"
+  - "no mock, use production API"
+- ❌ **NEVER skip mock API** for online features
+
+**Exception: Only skip Mock API if user requests:**
+1. **Offline-only app** (use AsyncStorage - see `offline-service.example.ts`)
+2. **Explicit real API request** ("connect to real API", "use production backend")
+
 ### Tech Stack (See PATTERNS.md)
 - ⚠️ **NEVER add new dependencies** without permission
 - ✅ Use only packages in package.json
@@ -43,11 +61,6 @@ Each file has a specific purpose:
 - ✅ Support light/dark theme always
 - ✅ Handle loading and error states
 
-### Mock API (See SERVER_GUIDE.md)
-- ✅ Add 2-4 sample items to `server/db.json`
-- ✅ Match TypeScript interfaces exactly
-- ✅ Create mock API file for new models
-
 ## 🎯 Quick Decision Guide
 
 ### Choose Your Template Variant
@@ -58,12 +71,20 @@ Each file has a specific purpose:
 Does your app need user accounts?
 ├─ NO
 │   ├─ Need API? → NO  → Variant: Offline (examples/apps/todo-offline/)
+│   │                    ✅ Use: offline-service.example.ts
+│   │
 │   └─ Need API? → YES → Variant: Public Content (examples/apps/news-no-auth/)
+│                         ✅ DEFAULT: Use Mock API with service-with-mock.example.ts
+│                         ❌ NEVER use real API unless user explicitly requests it
 │
 └─ YES
     └─ Need API? → YES → Variant: Protected (examples/apps/dashboard-with-auth/)
+                          ✅ DEFAULT: Use Mock API with service-with-mock.example.ts
+                          ❌ NEVER use real API unless user explicitly requests it
 ```
 
+**🔴 IMPORTANT:** When user says "Need API", it means **Mock API by default**!
+
 ### Choose Your Examples
 
 **See `examples/` folder. Quick reference:**
@@ -75,9 +96,9 @@ Does your app need user accounts?
 - **Detail pages** → `detail-screen.example.tsx`
 
 #### Service Patterns (`examples/services/`)
-- **API with mock** → `service-with-mock.example.ts`
-- **Direct API only** → `service-without-mock.example.ts`
-- **Offline storage** → `offline-service.example.ts`
+- **✅ DEFAULT: API with mock** → `service-with-mock.example.ts` (Use this for any online feature)
+- **❌ Direct API only** → `service-without-mock.example.ts` (Only if user explicitly requests real API)
+- **Offline storage** → `offline-service.example.ts` (Only for offline-only apps)
 
 #### Complete Apps (`examples/apps/`)
 - **Offline app** → `todo-offline/README.md`
@@ -90,15 +111,19 @@ Does your app need user accounts?
 
 ### Quick Steps:
 1. ✅ Understand user request
-2. ✅ Check `examples/` for similar pattern
-3. ✅ Check `CUSTOMIZATION.md` for variant
-4. ✅ Create types in `src/types/`
-5. ✅ Add sample data to `server/db.json` (if using API)
-6. ✅ Create mock API in `src/services/mockApi/` (if using API)
-7. ✅ Create service in `src/services/`
-8. ✅ Create components in `src/components/`
-9. ✅ Create screens in `app/(tabs)/`
-10. ✅ Update navigation
+2. ✅ **Determine API strategy:**
+   - **DEFAULT: Use Mock API** (unless explicitly told otherwise)
+   - Only use offline storage if user says "offline-only app"
+   - Only skip mock if user says "use real API" or "connect to actual backend"
+3. ✅ Check `examples/` for similar pattern
+4. ✅ Check `CUSTOMIZATION.md` for variant
+5. ✅ Create types in `src/types/`
+6. ✅ **Add sample data to `server/db.json`** (if using Mock API - which is DEFAULT)
+7. ✅ **Create mock API in `src/services/mockApi/`** (if using Mock API - which is DEFAULT)
+8. ✅ Create service in `src/services/` (use `service-with-mock.example.ts` pattern by DEFAULT)
+9. ✅ Create components in `src/components/`
+10. ✅ Create screens in `app/(tabs)/`
+11. ✅ Update navigation
 
 ## 📁 File Locations
 
@@ -106,26 +131,30 @@ Does your app need user accounts?
 
 Quick reference:
 ```
-app/(tabs)/              → Screens
-src/components/          → Components
-src/hooks/               → Custom hooks
-src/services/            → API services
-src/services/mockApi/    → Mock API implementations
-src/store/               → Zustand stores
-src/types/               → TypeScript types
-server/db.json           → Mock data
-examples/                → Code examples
+app/(tabs)/                    → Screens
+src/components/                → Components
+src/hooks/                     → Custom hooks
+src/services/                  → API services
+src/services/mockApi/          → Mock API implementations (auth, users only)
+src/store/                     → Zustand stores
+src/types/                     → TypeScript types
+server/db.json                 → Mock data (users only by default)
+examples/                      → Code examples
+examples/services/mockApi/     → Mock API pattern examples (basic & advanced CRUD)
+examples/types/                → Type definition examples (generic resource types)
 ```
 
 ## ⚠️ Common Mistakes to Avoid
 
 **Full list in `CONVENTIONS.md`. Quick reference:**
 
-1. ❌ Don't add new dependencies
-2. ❌ Don't use relative imports (`../../`)
-3. ❌ Don't skip theme support
-4. ❌ Don't skip loading/error states
-5. ❌ Don't ignore examples - always check first!
+1. ❌ **Don't skip Mock API** - Always use mock API by default for online features
+2. ❌ **Don't connect to real API** - Unless user explicitly requests it
+3. ❌ Don't add new dependencies
+4. ❌ Don't use relative imports (`../../`)
+5. ❌ Don't skip theme support
+6. ❌ Don't skip loading/error states
+7. ❌ Don't ignore examples - always check first!
 
 ## 💡 Pro Tips
 
@@ -150,18 +179,24 @@ cat SERVER_GUIDE.md          # Mock API guide
 # Check examples
 ls examples/screens/         # Screen patterns
 ls examples/services/        # Service patterns
+ls examples/services/mockApi/  # Mock API pattern examples
+ls examples/types/           # Type definition examples
 ls examples/apps/            # Complete app examples
 
 # Check current structure
-cat server/db.json           # Mock data
-ls src/types/                # Type definitions
-ls src/services/mockApi/     # Mock API files
+cat server/db.json           # Mock data (users only)
+ls src/types/                # Type definitions (auth, user types)
+ls src/services/mockApi/     # Active mock API files (auth, users)
 ```
 
 ## ✅ Success Checklist
 
 Your generated code is good if:
 
+- [ ] **Uses Mock API by default** (unless explicitly told to use real API or offline-only)
+- [ ] Uses `service-with-mock.example.ts` pattern for services (DEFAULT)
+- [ ] Dummy data (2-4 items) added to `server/db.json`
+- [ ] Mock API file created in `src/services/mockApi/`
 - [ ] Uses ONLY existing packages from package.json
 - [ ] Follows examples/ patterns
 - [ ] Uses TypeScript with proper types
@@ -170,8 +205,6 @@ Your generated code is good if:
 - [ ] Handles loading/error states
 - [ ] Uses NativeWind classes
 - [ ] Follows naming conventions
-- [ ] Dummy data matches TypeScript types (if using API)
-- [ ] Mock API implemented for new models (if using API)
 
 ## 🎓 Learning Path
 

package/templates/agent-generator/CUSTOMIZATION.md

@@ -2,31 +2,55 @@
 
 How to customize this template for different app types and requirements.
 
+## 🔴 IMPORTANT: Mock API is DEFAULT
+
+**This guide is for REMOVING features, not adding them!**
+
+The template comes with Mock API **enabled by default**. This guide shows how to:
+- Remove Mock API (only if connecting to real API)
+- Remove API entirely (only for offline apps)
+- Remove authentication (for public content apps)
+
+**⚠️ For AI Agents: Unless user explicitly requests removal, KEEP and USE the Mock API!**
+
+---
+
 ## 📋 Overview
 
-This template is **intentionally general** and includes both auth and mock API infrastructure. Depending on your app needs, you may want to:
+This template is **intentionally general** and includes both auth and mock API infrastructure. The mock API is the **default and recommended approach** for development.
+
+Depending on your app needs, you may want to:
 
-1. **Remove authentication** - For apps with public content
-2. **Remove mock API** - For apps connecting directly to real API
-3. **Remove API entirely** - For offline-only apps
-4. **Keep everything** - For full-featured apps with auth and API
+1. **Keep Mock API (DEFAULT)** - Recommended for most apps
+2. **Remove authentication** - For apps with public content only
+3. **Remove mock API** - Only if user explicitly wants to connect directly to real API
+4. **Remove API entirely** - Only for offline-only apps (AsyncStorage only)
 
 ## 🎯 Quick Decision Tree
 
+**🔴 DEFAULT: Keep Mock API unless explicitly told otherwise!**
+
 ```
 Does your app need user accounts?
 ├─ YES → Keep authentication
 │   ├─ Does it need API?
-│   │   ├─ YES → Keep mock API for development
-│   │   └─ NO → Remove API, use local storage
+│   │   ├─ YES → ✅ DEFAULT: Keep Mock API (service-with-mock.example.ts)
+│   │   │         ❌ Only remove if user says "use real API"
+│   │   └─ NO → Remove API, use AsyncStorage (offline-service.example.ts)
 │   └─ Continue to final setup
 └─ NO → Remove authentication
     ├─ Does it need API?
-    │   ├─ YES → Remove auth, keep API
-    │   └─ NO → Remove both auth and API
+    │   ├─ YES → ✅ DEFAULT: Keep Mock API (service-with-mock.example.ts)
+    │   │         ❌ Only remove if user says "use real API"
+    │   └─ NO → Remove API, use AsyncStorage (offline-service.example.ts)
     └─ Continue to final setup
 ```
 
+**⚠️ IMPORTANT FOR AI AGENTS:**
+- When user says "I need a news app" → Use Mock API (don't remove it!)
+- When user says "create product management" → Use Mock API (don't remove it!)
+- Only remove Mock API if user explicitly says: "connect to real API" or "use production backend"
+
 ## 📁 Template Variants
 
 ### Variant 1: Offline-Only App (No Auth, No API)

package/templates/agent-generator/PATTERNS.md

@@ -4,6 +4,51 @@ Guidelines for AI agents generating code for this project.
 
 > **Note:** For coding standards, see `CONVENTIONS.md`. For navigation, see `AI_GUIDE.md`.
 
+## 🔴 CRITICAL RULE #1: Mock API by Default
+
+**ALWAYS use Mock API unless user EXPLICITLY requests otherwise!**
+
+### The Rule:
+```
+DEFAULT BEHAVIOR = Mock API
+  ↓
+When user requests ANY feature with API/backend:
+  ✅ Create Mock API (service-with-mock.example.ts pattern)
+  ✅ Add 2-4 sample items to server/db.json
+  ✅ Create mock API file in src/services/mockApi/
+
+EXCEPTIONS (Only 2 cases to skip Mock API):
+  1. User explicitly says: "use real API" / "connect to actual backend" / "no mock"
+  2. User explicitly says: "offline-only app" (use AsyncStorage instead)
+```
+
+### Why This Matters:
+- Mock API allows development without backend setup
+- User can test features immediately with realistic data
+- Easy to switch to real API later (just change API_CONFIG.MOCK_API flag)
+- **If in doubt, USE MOCK API!**
+
+### Examples of What User Might Say:
+
+**✅ Use Mock API (DEFAULT for these requests):**
+- "Create a news app" → Use Mock API
+- "Add product management" → Use Mock API
+- "Build a social feed" → Use Mock API
+- "I need user profile feature" → Use Mock API
+- "Create dashboard with charts" → Use Mock API
+
+**❌ Only Skip Mock if User Says:**
+- "Connect to my real API at https://api.example.com"
+- "Use production backend, no mock"
+- "I want offline-only app with AsyncStorage"
+
+### When User is Silent About API:
+If user doesn't mention API at all, but the feature needs data:
+- **DEFAULT = Use Mock API**
+- Never ask "do you want mock or real?" - just use mock!
+
+---
+
 ## ⚠️ CRITICAL: Package Management & Tech Stack
 
 ### STRICT RULES - Dependencies
@@ -263,38 +308,64 @@ export function useData(): UseDataReturn {
 
 **Location**: `src/services/`
 
-**Pattern**:
+**🔴 DEFAULT Pattern (With Mock API - Use This!):**
 ```typescript
-import { apiClient } from './api';
+import { api } from '@/services/api';
+import { mockApi } from '@/services/mockApi';
+import { API_CONFIG } from '@/utils/constants';
 
 interface Item {
   id: string;
   name: string;
 }
 
-export const itemService = {
-  getItems: async (): Promise<Item[]> => {
-    const response = await apiClient.get('/items');
-    return response.data;
-  },
+class ItemService {
+  /**
+   * Get all items
+   * Switches between mock and real API automatically
+   */
+  async getItems(): Promise<Item[]> {
+    if (API_CONFIG.MOCK_API) {
+      return await mockApi.get<Item[]>('/items');
+    }
+    return await api.get<Item[]>('/items');
+  }
 
-  getItemById: async (id: string): Promise<Item> => {
-    const response = await apiClient.get(`/items/${id}`);
-    return response.data;
-  },
+  async getItemById(id: string): Promise<Item> {
+    if (API_CONFIG.MOCK_API) {
+      return await mockApi.get<Item>(`/items/${id}`);
+    }
+    return await api.get<Item>(`/items/${id}`);
+  }
 
-  createItem: async (data: Partial<Item>): Promise<Item> => {
-    const response = await apiClient.post('/items', data);
-    return response.data;
-  },
+  async createItem(data: Partial<Item>): Promise<Item> {
+    if (API_CONFIG.MOCK_API) {
+      return await mockApi.post<Item>('/items', data);
+    }
+    return await api.post<Item>('/items', data);
+  }
+}
+
+export const itemService = new ItemService();
+```
+
+**❌ Only Use This Pattern If User Explicitly Requests Real API:**
+```typescript
+// Direct API only (no mock) - RARELY USED!
+import { api } from '@/services/api';
+
+export const itemService = {
+  getItems: async () => await api.get('/items'),
 };
 ```
 
 **Requirements**:
-- Export as const object
-- Use apiClient from `./api`
-- Async/await
-- TypeScript types for all params and returns
+- ✅ **DEFAULT: Use Mock API switching pattern** (first example)
+- ✅ Check API_CONFIG.MOCK_API before every API call
+- ✅ Export as singleton instance
+- ✅ Async/await
+- ✅ TypeScript types for all params and returns
+- ✅ Follow `examples/services/service-with-mock.example.ts`
 
 ### Types (`src/types/`)
 
@@ -374,10 +445,14 @@ export const useMyStore = create<MyState>((set) => ({
 
 Before generating code:
 
+- [ ] 🔴 **MOST IMPORTANT: Use Mock API by default** (unless explicitly told otherwise)
+- [ ] 🔴 Create service with Mock API switching (use `service-with-mock.example.ts`)
+- [ ] 🔴 Add 2-4 sample items to `server/db.json`
+- [ ] 🔴 Create mock API file in `src/services/mockApi/`
 - [ ] Check `CUSTOMIZATION.md` - Choose template variant
 - [ ] Check `examples/apps/` - See complete app example
 - [ ] Check `examples/screens/` - Use appropriate screen pattern
-- [ ] Check `examples/services/` - Use appropriate service pattern
+- [ ] Check `examples/services/` - Confirm using mock API pattern
 - [ ] Use ONLY existing packages from package.json
 - [ ] Use TypeScript with proper types
 - [ ] Use path aliases (`@/`)