@idealyst/cli 1.0.92 → 1.0.94

package/template/packages/api/src/routers/test.ts

@@ -1,57 +1,159 @@
-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"),
-});
+import { z } from 'zod';
+import { prisma } from '../lib/database.js';
+import { publicProcedure, router } from '../trpc.js';
 
-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(),
-});
+/**
+ * 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 the CRUD router for the Test model
-export const testRouter = createCrudRouter(
-  "Test",
-  createTestSchema,
-  updateTestSchema
-);
+  // 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 },
+      });
+    }),
+});
 
 /**
- * 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 });
- * 
+ *
+ * // 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', 
+ * 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' } 
+ * 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

@@ -3,6 +3,7 @@ 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
@@ -17,12 +18,15 @@ app.use(cors({
   credentials: true,
 }));
 
+// Parse JSON bodies (needed for some GraphQL clients)
+app.use(express.json());
+
 // Health check endpoint
-app.get('/health', (req, res) => {
+app.get('/health', (_req, res) => {
   res.json({ status: 'OK', timestamp: new Date().toISOString() });
 });
 
-// tRPC middleware
+// tRPC middleware - for internal TypeScript clients
 app.use(
   '/trpc',
   createExpressMiddleware({
@@ -31,20 +35,34 @@ app.use(
   })
 );
 
+// 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) => {
+app.get('/', (_req, res) => {
   res.json({
     message: 'Welcome to {{projectName}} API',
     endpoints: {
       health: '/health',
       trpc: '/trpc',
-      playground: '/trpc-playground' // Available in development
-    }
+      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/tsconfig.json

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

package/template/packages/shared/package.json

@@ -35,6 +35,12 @@
       "optional": true
     }
   },
+  "dependencies": {
+    "@mdi/js": "^7.4.47",
+    "@mdi/react": "^1.6.1",
+    "graphql": "^16.9.0",
+    "graphql-request": "^7.1.2"
+  },
   "devDependencies": {
     "@idealyst/components": "^{{idealystVersion}}",
     "@idealyst/navigation": "^{{idealystVersion}}",

package/template/packages/shared/src/components/App.tsx

@@ -1,11 +1,13 @@
 import { NavigatorProvider } from "@idealyst/navigation";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import React from "react";
+import React, { useEffect } from "react";
+import { createGraphQLClient } from "../graphql/client";
 import AppRouter from "../navigation/AppRouter";
 import { createTRPCClient, trpc } from "../trpc/client";
 
 interface AppProps {
   apiUrl?: string;
+  graphqlUrl?: string;
   queryClient?: QueryClient;
   headers?: () => Record<string, string>;
 }
@@ -20,11 +22,12 @@ const defaultQueryClient = new QueryClient({
 });
 
 /**
- * Unified App component that sets up tRPC, React Query providers, and Navigation
+ * Unified App component that sets up tRPC, GraphQL, React Query providers, and Navigation
  * This component can be used by both web and mobile platforms
  */
 export const App: React.FC<AppProps> = ({
   apiUrl = "http://localhost:3000/trpc",
+  graphqlUrl = "http://localhost:3000/graphql",
   queryClient = defaultQueryClient,
   headers,
 }) => {
@@ -34,6 +37,14 @@ export const App: React.FC<AppProps> = ({
     headers,
   });
 
+  // Initialize GraphQL client
+  useEffect(() => {
+    createGraphQLClient({
+      apiUrl: graphqlUrl,
+      headers,
+    });
+  }, [graphqlUrl, headers]);
+
   return (
     <trpc.Provider client={trpcClient} queryClient={queryClient}>
       <QueryClientProvider client={queryClient}>