@idealyst/cli 1.1.9 → 1.2.1

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

@@ -1,163 +0,0 @@
-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

@@ -1,161 +0,0 @@
-import { z } from 'zod';
-import { prisma } from '../lib/database.js';
-import { publicProcedure, router } from '../trpc.js';
-
-/**
- * Test Router - tRPC CRUD operations for the Test model
- *
- * This router provides standard CRUD operations via tRPC.
- * For the GraphQL equivalent, see src/graphql/types/test.ts
- *
- * Endpoints:
- * - test.getById({ id })           - Get test by ID
- * - test.getAll({ skip, take })    - Get all tests with pagination
- * - test.count({ status })         - Get count of tests
- * - test.create({ name, message }) - Create new test
- * - test.update({ id, data })      - Update existing test
- * - test.delete({ id })            - Delete test
- */
-export const testRouter = router({
-  // Get a single test by ID
-  getById: publicProcedure
-    .input(z.object({ id: z.string() }))
-    .query(async ({ input }) => {
-      const test = await prisma.test.findUnique({
-        where: { id: input.id },
-      });
-
-      if (!test) {
-        throw new Error('Test not found');
-      }
-
-      return test;
-    }),
-
-  // Get all tests with pagination
-  getAll: publicProcedure
-    .input(z.object({
-      skip: z.number().min(0).optional(),
-      take: z.number().min(1).max(100).optional(),
-      orderBy: z.enum(['createdAt', 'updatedAt', 'name']).optional(),
-      orderDir: z.enum(['asc', 'desc']).optional(),
-    }))
-    .query(async ({ input }) => {
-      const take = input.take ?? 10;
-      const orderField = input.orderBy ?? 'createdAt';
-      const orderDir = input.orderDir ?? 'desc';
-
-      return prisma.test.findMany({
-        ...(input.skip != null ? { skip: input.skip } : {}),
-        take,
-        orderBy: { [orderField]: orderDir },
-      });
-    }),
-
-  // Get count of tests
-  count: publicProcedure
-    .input(z.object({
-      status: z.string().optional(),
-    }))
-    .query(async ({ input }) => {
-      return prisma.test.count({
-        ...(input.status != null ? { where: { status: input.status } } : {}),
-      });
-    }),
-
-  // Create a new test
-  create: publicProcedure
-    .input(z.object({
-      name: z.string().min(1, 'Name is required'),
-      message: z.string().min(1, 'Message is required'),
-      status: z.string().optional().default('active'),
-    }))
-    .mutation(async ({ input }) => {
-      return prisma.test.create({
-        data: {
-          name: input.name,
-          message: input.message,
-          status: input.status,
-        },
-      });
-    }),
-
-  // Update an existing test
-  update: publicProcedure
-    .input(z.object({
-      id: z.string(),
-      data: z.object({
-        name: z.string().min(1).optional(),
-        message: z.string().min(1).optional(),
-        status: z.string().optional(),
-      }),
-    }))
-    .mutation(async ({ input }) => {
-      const existing = await prisma.test.findUnique({
-        where: { id: input.id },
-      });
-
-      if (!existing) {
-        throw new Error('Test not found');
-      }
-
-      // Build update data only with defined values
-      const updateData: { name?: string; message?: string; status?: string } = {};
-      if (input.data.name != null) updateData.name = input.data.name;
-      if (input.data.message != null) updateData.message = input.data.message;
-      if (input.data.status != null) updateData.status = input.data.status;
-
-      return prisma.test.update({
-        where: { id: input.id },
-        data: updateData,
-      });
-    }),
-
-  // Delete a test
-  delete: publicProcedure
-    .input(z.object({ id: z.string() }))
-    .mutation(async ({ input }) => {
-      const existing = await prisma.test.findUnique({
-        where: { id: input.id },
-      });
-
-      if (!existing) {
-        throw new Error('Test not found');
-      }
-
-      return prisma.test.delete({
-        where: { id: input.id },
-      });
-    }),
-});
-
-/**
- * Example usage in frontend:
- *
- * ```typescript
- * // Get all tests
- * const { data: tests } = trpc.test.getAll.useQuery({ take: 10 });
- *
- * // Get test by ID
- * const { data: test } = trpc.test.getById.useQuery({ id: 'test-id' });
- *
- * // 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/server.ts

@@ -1,68 +0,0 @@
-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 { yoga } from './graphql/index.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,
-}));
-
-// Parse JSON bodies (needed for some GraphQL clients)
-app.use(express.json());
-
-// Health check endpoint
-app.get('/health', (_req, res) => {
-  res.json({ status: 'OK', timestamp: new Date().toISOString() });
-});
-
-// tRPC middleware - for internal TypeScript clients
-app.use(
-  '/trpc',
-  createExpressMiddleware({
-    router: appRouter,
-    createContext,
-  })
-);
-
-// GraphQL middleware - for public API, mobile clients, etc.
-// GraphQL Yoga handles the /graphql endpoint
-// Using all() to handle both GET (GraphiQL) and POST (queries)
-app.all('/graphql', yoga as unknown as express.RequestHandler);
-
-// Default route
-app.get('/', (_req, res) => {
-  res.json({
-    message: 'Welcome to {{projectName}} API',
-    endpoints: {
-      health: '/health',
-      trpc: '/trpc',
-      graphql: '/graphql',
-      graphiql: process.env.NODE_ENV !== 'production' ? '/graphql' : undefined,
-    },
-    documentation: {
-      trpc: 'Use tRPC for internal TypeScript clients with full type safety',
-      graphql: 'Use GraphQL for public APIs, mobile apps, and third-party integrations',
-    },
-  });
-});
-
-app.listen(PORT, () => {
-  console.log(`🚀 Server running on http://localhost:${PORT}`);
-  console.log(`📡 tRPC API available at http://localhost:${PORT}/trpc`);
-  console.log(`📊 GraphQL API available at http://localhost:${PORT}/graphql`);
-  if (process.env.NODE_ENV !== 'production') {
-    console.log(`🎮 GraphiQL Playground at http://localhost:${PORT}/graphql`);
-  }
-  console.log(`🏥 Health check at http://localhost:${PORT}/health`);
-}); 

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

@@ -1,28 +0,0 @@
-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

@@ -1,44 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "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
-  }
-} 

package/template/packages/database/README.md

@@ -1,162 +0,0 @@
-# Database Package
-
-This package provides database access and validation schemas for the workspace using Prisma ORM.
-
-## Setup
-
-1. Install dependencies:
-```bash
-yarn install
-```
-
-2. Set up your environment:
-```bash
-cp .env.example .env
-# Edit .env with your database URL
-```
-
-3. Generate the Prisma client:
-```bash
-yarn db:generate
-```
-
-4. Push the schema to your database:
-```bash
-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
-import { prisma, User, TestValidator } from '@{{workspaceScope}}/{{name}}';
-
-// Use the database client
-const users = await prisma.user.findMany();
-
-// Use validators
-const validatedData = TestValidator.parse(userData);
-```
-
-## Scripts
-
-- `yarn db:generate` - Generate Prisma client
-- `yarn db:push` - Push schema to database
-- `yarn db:migrate` - Create and run migrations
-- `yarn db:studio` - Open Prisma Studio
-- `yarn db:reset` - Reset the database
-- `yarn build` - Build the package
-- `yarn dev` - Build in watch mode

package/template/packages/database/package.json

@@ -1,49 +0,0 @@
-{
-  "name": "@{{workspaceScope}}/database",
-  "version": "1.0.0",
-  "description": "Database layer with Prisma",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    },
-    "./client": {
-      "types": "./generated/client/index.d.ts",
-      "import": "./generated/client/index.js",
-      "require": "./generated/client/index.js"
-    },
-    "./schemas": {
-      "types": "./dist/validators.d.ts",
-      "import": "./dist/validators.js",
-      "require": "./dist/validators.js"
-    }
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "db:generate": "prisma generate",
-    "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": {
-    "@prisma/client": "^5.19.1",
-    "zod": "^3.22.4"
-  },
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "prisma": "^5.19.1",
-    "tsx": "^4.7.0",
-    "typescript": "^5.3.3"
-  },
-  "files": [
-    "dist/**/*",
-    "prisma/**/*",
-    "generated/**/*"
-  ]
-}