@idealyst/cli 1.0.46 → 1.0.48

package/templates/api/src/router/index.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { router, publicProcedure } from '../trpc.js';
+import { testRouter } from '../routers/test.js';
 
 export const appRouter = router({
   // Simple hello world procedure
@@ -21,110 +22,142 @@ export const appRouter = router({
     };
   }),
 
-  // Add your procedures here
+  // Test CRUD endpoints - generated automatically from Prisma model
+  test: testRouter,
+
+  // Add your model routers here
   // Example:
   // users: userRouter,
   // posts: postRouter,
-
-  // Example controller integration:
-  // Uncomment the lines below and create the corresponding controllers
-  
-  // 1. Import your controllers at the top:
-  // import { userRouter } from '../controllers/UserController.js';
-  
-  // 2. Add them to the router:
-  // users: userRouter,
 });
 
 // Export type definition of API
 export type AppRouter = typeof appRouter;
 
 /*
-CONTROLLER & MIDDLEWARE SYSTEM USAGE:
+SIMPLIFIED CRUD API SYSTEM:
 
-This API template includes a controller and middleware system that works seamlessly with tRPC.
+This API template uses a simplified approach with automatic CRUD generation for Prisma models.
 
-## Quick Start with Controllers:
+## Quick Start:
 
-1. Create a controller (see src/controllers/UserController.ts for example):
+1. **Define your Prisma model** in packages/database/schema.prisma
+2. **Create Zod schemas** for validation
+3. **Generate CRUD router** using createCrudRouter()
+4. **Add to main router** 
+
+## Example - Adding a User model:
+
+### 1. Define Prisma model:
+```prisma
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
 
+### 2. Create router file (src/routers/user.ts):
 ```typescript
 import { z } from 'zod';
-import { BaseController, controllerToRouter } from '../lib/controller.js';
-import { requireAuth } from '../middleware/auth.js';
-
-export class UserController extends BaseController {
-  getAll = this.createQueryWithMiddleware(
-    z.object({}),
-    [requireAuth],
-    async (input, ctx) => {
-      return await ctx.prisma.user.findMany();
-    }
-  );
-}
+import { createCrudRouter } from '../lib/crud.js';
 
-export const userRouter = controllerToRouter({
-  getAll: new UserController({} as any).getAll,
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1),
 });
-```
 
-2. Add to main router:
+const updateUserSchema = z.object({
+  email: z.string().email().optional(),
+  name: z.string().min(1).optional(),
+});
 
+export const userRouter = createCrudRouter(
+  'user',
+  createUserSchema,
+  updateUserSchema
+);
+```
+
+### 3. Add to main router:
 ```typescript
-import { userRouter } from '../controllers/UserController.js';
+import { userRouter } from '../routers/user.js';
 
 export const appRouter = router({
-  users: userRouter,
   // ... other routes
+  users: userRouter,
+});
+```
+
+### 4. Use in frontend:
+```typescript
+// Get all users
+const { data: users } = trpc.users.getAll.useQuery();
+
+// Create user
+const createUser = trpc.users.create.useMutation();
+await createUser.mutateAsync({ 
+  email: 'user@example.com', 
+  name: 'John Doe' 
+});
+
+// Update user
+const updateUser = trpc.users.update.useMutation();
+await updateUser.mutateAsync({ 
+  id: 'user-id', 
+  data: { name: 'Jane Doe' } 
 });
 ```
 
-## Available Middleware:
+## Available CRUD Operations:
 
-### Authentication:
-- `requireAuth` - Requires Bearer token
-- `requireRole(role)` - Requires specific role
-- `requireAdmin` - Requires admin role
+Each generated router includes:
+- `getAll({ skip?, take?, orderBy? })` - List with pagination
+- `getById({ id })` - Get single record
+- `create(data)` - Create new record
+- `update({ id, data })` - Update existing record
+- `delete({ id })` - Delete record
+- `count({ where? })` - Count records
 
-### Utility:
-- `logger` - Request/response logging
-- `rateLimit(max, window)` - Rate limiting
-- `responseTime` - Adds response time header
-- `requestId` - Adds unique request ID
-- `errorHandler` - Centralized error handling
+## Advanced Usage:
 
-## Usage Examples:
+### Custom procedures:
+You can extend generated routers with custom procedures:
 
 ```typescript
-// Public endpoint
-getPublicData = this.createQuery(schema, handler);
-
-// Protected endpoint
-getPrivateData = this.createQueryWithMiddleware(
-  schema,
-  [requireAuth],
-  handler
-);
+import { z } from 'zod';
+import { router, publicProcedure } from '../trpc.js';
+import { createCrudRouter } from '../lib/crud.js';
+import { prisma } from '../lib/database.js';
 
-// Admin-only endpoint
-adminAction = this.createMutationWithMiddleware(
-  schema,
-  [requireAuth, requireAdmin],
-  handler
-);
+const baseCrudRouter = createCrudRouter('user', createUserSchema);
 
-// Multiple middleware
-complexEndpoint = this.createQueryWithMiddleware(
-  schema,
-  [logger, rateLimit(10, 60000), requireAuth],
-  handler
-);
+export const userRouter = router({
+  ...baseCrudRouter,
+  
+  // Add custom procedures
+  getByEmail: publicProcedure
+    .input(z.object({ email: z.string().email() }))
+    .query(async ({ input }) => {
+      return await prisma.user.findUnique({
+        where: { email: input.email }
+      });
+    }),
+});
+```
+
+### Authentication & Authorization:
+Use middleware for protected procedures:
+
+```typescript
+import { protectedProcedure } from '../trpc.js';
+
+// Replace publicProcedure with protectedProcedure in createCrudRouter
+// or create a custom version for authenticated routes
 ```
 
-This system provides:
-✅ Type safety with tRPC
-✅ Reusable middleware
-✅ Clean controller organization
-✅ Easy testing
-✅ Consistent error handling
+This simplified system removes the controller layer complexity while providing
+type-safe, validated CRUD operations for all your Prisma models.
 */ 

package/templates/api/src/routers/test.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { createCrudRouter } from "../lib/crud.js";
+
+// Define Zod schemas for the Test model based on the Prisma schema
+const createTestSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  message: z.string().min(1, "Message is required"),
+  status: z.string().optional().default("active"),
+});
+
+const updateTestSchema = z.object({
+  name: z.string().min(1, "Name is required").optional(),
+  message: z.string().min(1, "Message is required").optional(),
+  status: z.string().optional(),
+});
+
+// Create the CRUD router for the Test model
+export const testRouter = createCrudRouter(
+  "Test",
+  createTestSchema,
+  updateTestSchema
+);
+
+/**
+ * This generates the following endpoints:
+ * 
+ * - test.getAll({ skip?, take?, orderBy? }) - Get all test records with pagination
+ * - test.getById({ id }) - Get test record by ID
+ * - test.create({ name, message, status? }) - Create new test record
+ * - test.update({ id, data: { name?, message?, status? } }) - Update test record
+ * - test.delete({ id }) - Delete test record
+ * - test.count({ where? }) - Get test record count
+ * 
+ * Example usage in frontend:
+ * 
+ * ```typescript
+ * // Get all tests
+ * const { data: tests } = trpc.test.getAll.useQuery({ take: 10 });
+ * 
+ * // Create a new test
+ * const createTest = trpc.test.create.useMutation();
+ * await createTest.mutateAsync({ 
+ *   name: 'My Test', 
+ *   message: 'This is a test message',
+ *   status: 'active'
+ * });
+ * 
+ * // Update a test
+ * const updateTest = trpc.test.update.useMutation();
+ * await updateTest.mutateAsync({ 
+ *   id: 'test-id', 
+ *   data: { name: 'Updated Test' } 
+ * });
+ * 
+ * // Delete a test
+ * const deleteTest = trpc.test.delete.useMutation();
+ * await deleteTest.mutateAsync({ id: 'test-id' });
+ * ```
+ */

package/templates/api/src/routers/user.example.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { createCrudRouter } from '../lib/crud.js';
+
+// Define Zod schemas for the User model
+const createUserSchema = z.object({
+  email: z.string().email('Invalid email format'),
+  name: z.string().min(1, 'Name is required'),
+});
+
+const updateUserSchema = z.object({
+  email: z.string().email('Invalid email format').optional(),
+  name: z.string().min(1, 'Name is required').optional(),
+});
+
+// Create the CRUD router for the User model
+export const userRouter = createCrudRouter(
+  'user',
+  createUserSchema,
+  updateUserSchema
+);
+
+/**
+ * This generates the following endpoints:
+ * 
+ * - users.getAll({ skip?, take?, orderBy? }) - Get all users with pagination
+ * - users.getById({ id }) - Get user by ID
+ * - users.create({ name, email }) - Create new user
+ * - users.update({ id, data: { name?, email? } }) - Update user
+ * - users.delete({ id }) - Delete user
+ * - users.count({ where? }) - Get user count
+ * 
+ * To use this router:
+ * 
+ * 1. First add a User model to your Prisma schema:
+ * 
+ * ```prisma
+ * model User {
+ *   id        String   @id @default(cuid())
+ *   email     String   @unique
+ *   name      String
+ *   createdAt DateTime @default(now())
+ *   updatedAt DateTime @updatedAt
+ * }
+ * ```
+ * 
+ * 2. Run `yarn db:migrate` to apply the schema changes
+ * 
+ * 3. Uncomment the users router in src/router/index.ts:
+ * 
+ * ```typescript
+ * import { userRouter } from '../routers/user.js';
+ * 
+ * export const appRouter = router({
+ *   // ... other routes
+ *   users: userRouter,
+ * });
+ * ```
+ * 
+ * 4. Use in your frontend:
+ * 
+ * ```typescript
+ * // Get all users
+ * const { data: users } = trpc.users.getAll.useQuery({ take: 10 });
+ * 
+ * // Create a new user
+ * const createUser = trpc.users.create.useMutation();
+ * await createUser.mutateAsync({ 
+ *   name: 'John Doe', 
+ *   email: 'john@example.com' 
+ * });
+ * 
+ * // Update a user
+ * const updateUser = trpc.users.update.useMutation();
+ * await updateUser.mutateAsync({ 
+ *   id: 'user-id', 
+ *   data: { name: 'Jane Doe' } 
+ * });
+ * 
+ * // Delete a user
+ * const deleteUser = trpc.users.delete.useMutation();
+ * await deleteUser.mutateAsync({ id: 'user-id' });
+ * ```
+ */

package/templates/api/src/server.ts

@@ -13,7 +13,7 @@ const PORT = process.env.PORT || 3000;
 
 // CORS configuration
 app.use(cors({
-  origin: process.env.CORS_ORIGIN || 'http://localhost:3000',
+  origin: process.env.CORS_ORIGIN || 'http://localhost:5173',
   credentials: true,
 }));
 

package/templates/api/tsconfig.json

@@ -2,7 +2,6 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "ESNext",
-    "moduleResolution": "node",
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
     "allowJs": true,

package/templates/database/README.md

@@ -1,6 +1,6 @@
 # Database Package
 
-This package provides database access and validation schemas for the workspace.
+This package provides database access and validation schemas for the workspace using Prisma ORM.
 
 ## Setup
 
@@ -25,6 +25,120 @@ yarn db:generate
 yarn db:push
 ```
 
+5. Seed the database with test data:
+```bash
+yarn db:seed
+```
+
+## Database Schema
+
+### Test Model
+
+The Test model is included for quick testing and API demonstration:
+
+```prisma
+model Test {
+  id        String   @id @default(cuid())
+  name      String
+  message   String
+  status    String   @default("active")
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+#### Fields:
+- `id`: Unique identifier (CUID)
+- `name`: Test name/title
+- `message`: Test message content
+- `status`: Test status (defaults to "active")
+- `createdAt`: Record creation timestamp
+- `updatedAt`: Record last update timestamp
+
+### Sample Models
+
+The schema also includes comprehensive example models for reference:
+
+#### User Model
+- Complete user management with authentication fields
+- Email validation and profile information
+- Timestamps for tracking
+
+#### Post Model
+- Blog post or content management
+- User relationship for authorship
+- Publishing status and timestamps
+
+#### Comment Model
+- Comment system for posts
+- User and post relationships
+- Moderation support
+
+## Usage
+
+### In API Code
+
+```typescript
+import { db } from '@{{workspaceScope}}/database';
+
+// Create a test record
+const test = await db.test.create({
+  data: {
+    name: 'My Test',
+    message: 'This is a test message',
+    status: 'active'
+  }
+});
+
+// Get all tests
+const tests = await db.test.findMany();
+
+// Update a test
+const updatedTest = await db.test.update({
+  where: { id: 'test-id' },
+  data: { status: 'completed' }
+});
+```
+
+### Prisma Commands
+
+```bash
+# Generate client
+yarn prisma:generate
+
+# Run migrations
+yarn prisma:migrate
+
+# Reset database
+yarn prisma:reset
+
+# Seed database
+yarn prisma:seed
+
+# Open Prisma Studio
+yarn prisma:studio
+```
+
+## Quick Test
+
+The database includes a simple `Test` model for immediate testing:
+
+```typescript
+import { prisma } from '@{{workspaceScope}}/{{name}}';
+
+// Get all test entries
+const tests = await prisma.test.findMany();
+
+// Create a new test entry
+const newTest = await prisma.test.create({
+  data: {
+    name: 'My Test',
+    message: 'Testing the database connection',
+    status: 'active',
+  },
+});
+```
+
 ## Usage
 
 ```typescript

package/templates/database/package.json

@@ -28,6 +28,7 @@
     "db:push": "prisma db push",
     "db:migrate": "prisma migrate dev",
     "db:studio": "prisma studio",
+    "db:seed": "tsx prisma/seed.ts",
     "db:reset": "prisma migrate reset"
   },
   "dependencies": {
@@ -37,6 +38,7 @@
   "devDependencies": {
     "@types/node": "^20.10.0",
     "prisma": "^5.19.1",
+    "tsx": "^4.7.0",
     "typescript": "^5.3.3"
   },
   "files": [

package/templates/database/prisma/seed.ts

@@ -6,7 +6,43 @@ async function main() {
   // Add your seed data here
   console.log('🌱 Seeding database...');
   
-  // Example seed data
+  // Create some test data for the Test model
+  console.log('📝 Creating test entries...');
+  
+  const testEntries = await Promise.all([
+    prisma.test.create({
+      data: {
+        name: 'API Connection Test',
+        message: 'This test verifies that the API can connect to the database successfully.',
+        status: 'active',
+      },
+    }),
+    prisma.test.create({
+      data: {
+        name: 'Data Validation Test',
+        message: 'This test ensures that data validation is working correctly across the stack.',
+        status: 'active',
+      },
+    }),
+    prisma.test.create({
+      data: {
+        name: 'tRPC Integration Test',
+        message: 'This test confirms that tRPC endpoints are properly configured and accessible.',
+        status: 'active',
+      },
+    }),
+    prisma.test.create({
+      data: {
+        name: 'Sample Inactive Test',
+        message: 'This is an example of an inactive test entry.',
+        status: 'inactive',
+      },
+    }),
+  ]);
+
+  console.log(`✅ Created ${testEntries.length} test entries`);
+  
+  // Example seed data for other models (uncommented for reference)
   // const user = await prisma.user.create({
   //   data: {
   //     email: 'admin@example.com',

package/templates/database/schema.prisma

@@ -7,10 +7,20 @@ generator client {
 }
 
 datasource db {
-  provider = "sqlite"
+  provider = "postgres"
   url      = env("DATABASE_URL")
 }
 
+// Simple Test model for quick API testing
+model Test {
+  id        String   @id @default(cuid())
+  name      String
+  message   String
+  status    String   @default("active") // "active", "inactive"
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
 // Demo User model with profile information
 model User {
   id        String   @id @default(cuid())

package/templates/native/index.js

@@ -1,6 +1,6 @@
 import '@idealyst/theme/unistyles';
 
 import { AppRegistry } from 'react-native';
-import App from './App';
+import App from './src/App';
 
 AppRegistry.registerComponent('{{projectName}}', () => App); 

package/templates/native/metro.config.js

@@ -16,7 +16,7 @@ const config = {
       path.resolve(__dirname, '..', 'node_modules'),
     ],
     // Important for Idealyst to use .native extensions for React Native (eg: @idealyst/components/src/Button/Button.native.tsx)
-    sourceExts: ['native.tsx', 'native.ts', 'tsx', 'ts', 'native.jsx', 'native.js', 'jsx', 'js', 'json'],
+    sourceExts: ['native.tsx', 'native.ts', 'tsx', 'ts', 'native.jsx', 'native.js', 'jsx', 'js', 'json', 'cjs'],
   },
   watcher: {
     // When configuring custom components with .native extensions, make sure the watcher looks for them

package/templates/native/package.json

@@ -16,6 +16,10 @@
     "@idealyst/components": "^1.0.21",
     "@idealyst/navigation": "^1.0.21",
     "@idealyst/theme": "^1.0.21",
+    "@tanstack/react-query": "^5.83.0",
+    "@trpc/client": "^11.5.1",
+    "@trpc/react-query": "^11.5.1",
+    "@trpc/server": "^11.5.1",
     "react": "^18.2.0",
     "react-native": "^0.73.0"
   },

package/templates/native/src/App.tsx

@@ -0,0 +1,16 @@
+import React from 'react';
+import { App } from '@{{workspaceScope}}/shared';
+
+// Main App component using shared App wrapper
+function AppWithShared() {
+  return (
+    <App 
+      apiUrl="http://localhost:3000/trpc"
+      name="{{projectName}} Developer"
+      platform="mobile"
+      projectName="{{projectName}}"
+    />
+  );
+}
+
+export default AppWithShared;