@idealyst/cli 1.0.90 → 1.0.91

package/template/packages/api/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@{{workspaceScope}}/api",
+  "version": "{{version}}",
+  "description": "{{description}}",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/server.ts",
+    "start": "node dist/server.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@{{workspaceScope}}/database": "workspace:*",
+    "@{{workspaceScope}}/shared": "workspace:*",
+    "@trpc/server": "^11.5.1",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.10.4",
+    "@typescript-eslint/eslint-plugin": "^6.13.1",
+    "@typescript-eslint/parser": "^6.13.1",
+    "eslint": "^8.54.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "tsx": "^4.6.2",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "api",
+    "trpc",
+    "zod",
+    "typescript",
+    "express"
+  ],
+  "author": "",
+  "license": "MIT"
+} 

package/template/packages/api/src/context.ts

@@ -0,0 +1,19 @@
+import type { CreateExpressContextOptions } from '@trpc/server/adapters/express';
+
+export interface Context {
+  req: CreateExpressContextOptions['req'];
+  res: CreateExpressContextOptions['res'];
+  // Add your dependencies here (e.g., database client, external services)
+  // Example: db: PrismaClient;
+}
+
+export const createContext = ({ req, res }: CreateExpressContextOptions): Context => {
+  return {
+    req,
+    res,
+    // Initialize your dependencies here
+    // Example: db: prisma,
+  };
+};
+
+export type { CreateExpressContextOptions }; 

package/template/packages/api/src/index.ts

@@ -0,0 +1,9 @@
+// Main exports for the API
+export { appRouter } from './router/index.js';
+export type { AppRouter } from './router/index.js';
+
+// Export context type for client usage
+export type { Context } from './context.js';
+
+// Export CRUD utilities for creating routers
+export { createCrudRouter } from './lib/crud.js'; 

package/template/packages/api/src/lib/crud.ts

@@ -0,0 +1,150 @@
+import type { Prisma } from '@{{workspaceScope}}/database/client';
+import { z } from 'zod';
+import { prisma } from '../lib/database.js';
+import { publicProcedure, router } from '../trpc.js';
+
+/**
+ * Creates a standard CRUD router for any Prisma model
+ * 
+ * @param modelName - The name of the Prisma model (e.g., 'user', 'post', 'test')
+ * @param createSchema - Zod schema for creating new records
+ * @param updateSchema - Zod schema for updating records (optional, defaults to createSchema.partial())
+ * @returns tRPC router with standard CRUD operations
+ */
+export function createCrudRouter<
+  TModelName extends Prisma.ModelName,
+  TCreateInput extends Record<string, any>,
+  TUpdateInput extends Record<string, any> = Partial<TCreateInput>
+>(
+  modelName: TModelName,
+  createSchema: z.ZodSchema<TCreateInput>,
+  updateSchema?: z.ZodSchema<TUpdateInput>
+) {
+  const model = (prisma as any)[modelName];
+  const updateSchemaToUse = updateSchema || createSchema.partial();
+
+  return router({
+    // Get all records
+    getAll: publicProcedure
+      .input(z.object({
+        skip: z.number().min(0).optional(),
+        take: z.number().min(1).max(100).optional(),
+        orderBy: z.record(z.enum(['asc', 'desc'])).optional(),
+      }))
+      .query(async ({ input }) => {
+        return await model.findMany({
+          skip: input.skip,
+          take: input.take || 10,
+          orderBy: input.orderBy,
+        });
+      }),
+
+    // Get record by ID
+    getById: publicProcedure
+      .input(z.object({ id: z.string() }))
+      .query(async ({ input }) => {
+        const record = await model.findUnique({
+          where: { id: input.id },
+        });
+        
+        if (!record) {
+          throw new Error(`${modelName} not found`);
+        }
+        
+        return record;
+      }),
+
+    // Create new record
+    create: publicProcedure
+      .input(createSchema)
+      .mutation(async ({ input }) => {
+        return await model.create({
+          data: input,
+        });
+      }),
+
+    // Update record
+    update: publicProcedure
+      .input(z.object({
+        id: z.string(),
+        data: updateSchemaToUse,
+      }))
+      .mutation(async ({ input }) => {
+        const existingRecord = await model.findUnique({
+          where: { id: input.id },
+        });
+
+        if (!existingRecord) {
+          throw new Error(`${modelName} not found`);
+        }
+
+        return await model.update({
+          where: { id: input.id },
+          data: input.data,
+        });
+      }),
+
+    // Delete record
+    delete: publicProcedure
+      .input(z.object({ id: z.string() }))
+      .mutation(async ({ input }) => {
+        const existingRecord = await model.findUnique({
+          where: { id: input.id },
+        });
+
+        if (!existingRecord) {
+          throw new Error(`${modelName} not found`);
+        }
+
+        return await model.delete({
+          where: { id: input.id },
+        });
+      }),
+
+    // Get count
+    count: publicProcedure
+      .input(z.object({
+        where: z.record(z.any()).optional(),
+      }))
+      .query(async ({ input }) => {
+        return await model.count({
+          where: input.where,
+        });
+      }),
+  });
+}
+
+/**
+ * Example usage:
+ * 
+ * ```typescript
+ * import { z } from 'zod';
+ * import { createCrudRouter } from '../lib/crud.js';
+ * 
+ * // Define schemas for your model
+ * const createUserSchema = z.object({
+ *   email: z.string().email(),
+ *   name: z.string(),
+ * });
+ * 
+ * const updateUserSchema = z.object({
+ *   email: z.string().email().optional(),
+ *   name: z.string().optional(),
+ * });
+ * 
+ * // Create the CRUD router
+ * export const userRouter = createCrudRouter(
+ *   'user',
+ *   createUserSchema,
+ *   updateUserSchema
+ * );
+ * ```
+ * 
+ * This will generate:
+ * - users.getAll() - Get all users with pagination
+ * - users.getById({ id }) - Get user by ID
+ * - users.create({ email, name }) - Create new user
+ * - users.update({ id, data: { email?, name? } }) - Update user
+ * - users.delete({ id }) - Delete user
+ * - users.count() - Get user count
+ */

package/template/packages/api/src/lib/database.ts

@@ -0,0 +1,23 @@
+import { PrismaClient } from '@{{workspaceScope}}/database/client';
+
+// Initialize Prisma Client
+declare global {
+  // eslint-disable-next-line no-var
+  var __prisma: PrismaClient | undefined;
+}
+
+// Prevent multiple instances of Prisma Client in development
+export const prisma = globalThis.__prisma || new PrismaClient({
+  log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  globalThis.__prisma = prisma;
+}
+
+// Graceful shutdown
+process.on('beforeExit', async () => {
+  await prisma.$disconnect();
+});
+
+export default prisma;

package/template/packages/api/src/router/index.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+import { router, publicProcedure } from '../trpc.js';
+import { testRouter } from '../routers/test.js';
+
+export const appRouter = router({
+  // Simple hello world procedure
+  hello: publicProcedure
+    .input(z.object({ name: z.string().optional() }))
+    .query(({ input }) => {
+      return {
+        greeting: `Hello ${input.name || 'World'}!`,
+        timestamp: new Date().toISOString(),
+      };
+    }),
+
+  // Health check procedure
+  health: publicProcedure.query(() => {
+    return {
+      status: 'OK',
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+    };
+  }),
+
+  // Test CRUD endpoints - generated automatically from Prisma model
+  test: testRouter,
+
+  // Add your model routers here
+  // Example:
+  // users: userRouter,
+  // posts: postRouter,
+});
+
+// Export type definition of API
+export type AppRouter = typeof appRouter;
+
+/*
+SIMPLIFIED CRUD API SYSTEM:
+
+This API template uses a simplified approach with automatic CRUD generation for Prisma models.
+
+## Quick Start:
+
+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 { createCrudRouter } from '../lib/crud.js';
+
+const createUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1),
+});
+
+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 '../routers/user.js';
+
+export const appRouter = router({
+  // ... 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 CRUD Operations:
+
+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
+
+## Advanced Usage:
+
+### Custom procedures:
+You can extend generated routers with custom procedures:
+
+```typescript
+import { z } from 'zod';
+import { router, publicProcedure } from '../trpc.js';
+import { createCrudRouter } from '../lib/crud.js';
+import { prisma } from '../lib/database.js';
+
+const baseCrudRouter = createCrudRouter('user', createUserSchema);
+
+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 simplified system removes the controller layer complexity while providing
+type-safe, validated CRUD operations for all your Prisma models.
+*/ 

package/template/packages/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/template/packages/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/template/packages/api/src/server.ts

@@ -0,0 +1,50 @@
+import express from 'express';
+import cors from 'cors';
+import { createExpressMiddleware } from '@trpc/server/adapters/express';
+import { appRouter } from './router/index.js';
+import { createContext } from './context.js';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// CORS configuration
+app.use(cors({
+  origin: process.env.CORS_ORIGIN || 'http://localhost:5173',
+  credentials: true,
+}));
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ status: 'OK', timestamp: new Date().toISOString() });
+});
+
+// tRPC middleware
+app.use(
+  '/trpc',
+  createExpressMiddleware({
+    router: appRouter,
+    createContext,
+  })
+);
+
+// Default route
+app.get('/', (req, res) => {
+  res.json({
+    message: 'Welcome to {{projectName}} API',
+    endpoints: {
+      health: '/health',
+      trpc: '/trpc',
+      playground: '/trpc-playground' // Available in development
+    }
+  });
+});
+
+app.listen(PORT, () => {
+  console.log(`🚀 Server running on http://localhost:${PORT}`);
+  console.log(`📡 tRPC API available at http://localhost:${PORT}/trpc`);
+  console.log(`🏥 Health check at http://localhost:${PORT}/health`);
+}); 

package/template/packages/api/src/trpc.ts

@@ -0,0 +1,28 @@
+import { initTRPC } from '@trpc/server';
+import { type Context } from './context.js';
+import { ZodError } from 'zod';
+
+const t = initTRPC.context<Context>().create({
+  errorFormatter({ shape, error }) {
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError:
+          error.cause instanceof ZodError ? error.cause.flatten() : null,
+      },
+    };
+  },
+});
+
+// Export reusable router and procedure helpers
+export const router = t.router;
+export const publicProcedure = t.procedure;
+
+// You can create additional procedures with middleware here
+// For example, a protected procedure that requires authentication:
+// export const protectedProcedure = t.procedure.use(async ({ ctx, next }) => {
+//   // Add your authentication logic here
+//   // Example: check for valid session/token
+//   return next({ ctx: { ...ctx, user: { id: 'user-id' } } });
+// }); 

package/template/packages/api/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "checkJs": false,
+    "jsx": "preserve",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "removeComments": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ],
+  "ts-node": {
+    "esm": true
+  }
+}