@idealyst/cli 1.2.32 → 1.2.34

package/dist/templates/core/api/src-graphql/schema.ts

@@ -0,0 +1,217 @@
+/**
+ * GraphQL Schema Definition
+ *
+ * Uses Prisma database for data persistence.
+ */
+
+import { builder } from './builder.js';
+import { prisma } from '../lib/database.js';
+
+// =============================================================================
+// Object Types
+// =============================================================================
+
+const ItemType = builder.objectRef<{
+  id: string;
+  title: string;
+  description: string | null;
+  completed: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}>('Item');
+
+builder.objectType(ItemType, {
+  description: 'A simple item for demonstrating CRUD operations',
+  fields: (t) => ({
+    id: t.exposeString('id'),
+    title: t.exposeString('title'),
+    description: t.exposeString('description', { nullable: true }),
+    completed: t.exposeBoolean('completed'),
+    createdAt: t.expose('createdAt', { type: 'DateTime' }),
+    updatedAt: t.expose('updatedAt', { type: 'DateTime' }),
+  }),
+});
+
+const ItemStatsType = builder.objectRef<{
+  total: number;
+  completed: number;
+  pending: number;
+}>('ItemStats');
+
+builder.objectType(ItemStatsType, {
+  description: 'Aggregate item statistics',
+  fields: (t) => ({
+    total: t.exposeInt('total'),
+    completed: t.exposeInt('completed'),
+    pending: t.exposeInt('pending'),
+  }),
+});
+
+// =============================================================================
+// Queries
+// =============================================================================
+
+builder.queryFields((t) => ({
+  // Get single item by ID
+  item: t.field({
+    type: ItemType,
+    nullable: true,
+    args: {
+      id: t.arg.string({ required: true }),
+    },
+    resolve: async (_, args) => {
+      return await prisma.item.findUnique({
+        where: { id: args.id },
+      });
+    },
+  }),
+
+  // List all items with optional filtering
+  items: t.field({
+    type: [ItemType],
+    args: {
+      completed: t.arg.boolean(),
+      search: t.arg.string(),
+    },
+    resolve: async (_, args) => {
+      const where: any = {};
+
+      if (args.completed !== null && args.completed !== undefined) {
+        where.completed = args.completed;
+      }
+
+      if (args.search) {
+        where.OR = [
+          { title: { contains: args.search } },
+          { description: { contains: args.search } },
+        ];
+      }
+
+      return await prisma.item.findMany({
+        where,
+        orderBy: { createdAt: 'desc' },
+      });
+    },
+  }),
+
+  // Get item stats
+  itemStats: t.field({
+    type: ItemStatsType,
+    resolve: async () => {
+      const items = await prisma.item.findMany();
+
+      return {
+        total: items.length,
+        completed: items.filter((i) => i.completed).length,
+        pending: items.filter((i) => !i.completed).length,
+      };
+    },
+  }),
+}));
+
+// =============================================================================
+// Mutations
+// =============================================================================
+
+const CreateItemInput = builder.inputType('CreateItemInput', {
+  fields: (t) => ({
+    title: t.string({ required: true }),
+    description: t.string(),
+    completed: t.boolean({ defaultValue: false }),
+  }),
+});
+
+const UpdateItemInput = builder.inputType('UpdateItemInput', {
+  fields: (t) => ({
+    title: t.string(),
+    description: t.string(),
+    completed: t.boolean(),
+  }),
+});
+
+builder.mutationFields((t) => ({
+  // Create a new item
+  createItem: t.field({
+    type: ItemType,
+    args: {
+      input: t.arg({ type: CreateItemInput, required: true }),
+    },
+    resolve: async (_, args) => {
+      return await prisma.item.create({
+        data: {
+          title: args.input.title,
+          description: args.input.description,
+          completed: args.input.completed ?? false,
+        },
+      });
+    },
+  }),
+
+  // Update an existing item
+  updateItem: t.field({
+    type: ItemType,
+    nullable: true,
+    args: {
+      id: t.arg.string({ required: true }),
+      input: t.arg({ type: UpdateItemInput, required: true }),
+    },
+    resolve: async (_, args) => {
+      const data: any = {};
+
+      if (args.input.title !== null && args.input.title !== undefined) {
+        data.title = args.input.title;
+      }
+      if (args.input.description !== undefined) {
+        data.description = args.input.description;
+      }
+      if (args.input.completed !== null && args.input.completed !== undefined) {
+        data.completed = args.input.completed;
+      }
+
+      return await prisma.item.update({
+        where: { id: args.id },
+        data,
+      });
+    },
+  }),
+
+  // Delete an item
+  deleteItem: t.field({
+    type: ItemType,
+    nullable: true,
+    args: {
+      id: t.arg.string({ required: true }),
+    },
+    resolve: async (_, args) => {
+      return await prisma.item.delete({
+        where: { id: args.id },
+      });
+    },
+  }),
+
+  // Toggle item completed status
+  toggleItem: t.field({
+    type: ItemType,
+    nullable: true,
+    args: {
+      id: t.arg.string({ required: true }),
+    },
+    resolve: async (_, args) => {
+      const item = await prisma.item.findUnique({
+        where: { id: args.id },
+      });
+
+      if (!item) {
+        return null;
+      }
+
+      return await prisma.item.update({
+        where: { id: args.id },
+        data: { completed: !item.completed },
+      });
+    },
+  }),
+}));
+
+// Build and export the schema
+export const schema = builder.toSchema();

package/dist/templates/core/api/src-trpc/context.ts

@@ -0,0 +1,15 @@
+import type { CreateExpressContextOptions } from '@trpc/server/adapters/express';
+
+export interface Context {
+  req: CreateExpressContextOptions['req'];
+  res: CreateExpressContextOptions['res'];
+}
+
+export const createContext = ({ req, res }: CreateExpressContextOptions): Context => {
+  return {
+    req,
+    res,
+  };
+};
+
+export type { CreateExpressContextOptions };

package/dist/templates/core/api/src-trpc/index.ts

@@ -0,0 +1,6 @@
+// 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';

package/dist/templates/core/api/src-trpc/lib/database.ts

@@ -0,0 +1,4 @@
+import { prisma } from '@{{workspaceScope}}/database';
+
+export { prisma };
+export default prisma;

package/dist/templates/core/api/src-trpc/router/index.ts

@@ -0,0 +1,187 @@
+import { z } from 'zod';
+import { router, publicProcedure } from '../trpc.js';
+import { prisma } from '../lib/database.js';
+import { ItemCreateSchema, ItemUpdateSchema } from '@{{workspaceScope}}/database';
+
+// ==========================================================================
+// Base Routes (no database required)
+// ==========================================================================
+
+const baseRoutes = {
+  // 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',
+    };
+  }),
+
+  // Echo procedure - returns what you send
+  echo: publicProcedure
+    .input(z.object({ message: z.string() }))
+    .query(({ input }) => {
+      return {
+        original: input.message,
+        reversed: input.message.split('').reverse().join(''),
+        length: input.message.length,
+        timestamp: new Date().toISOString(),
+      };
+    }),
+
+  // Counter - in-memory state demo
+  counter: router({
+    // Get current counter value
+    get: publicProcedure.query(() => {
+      return { value: counterState.value };
+    }),
+
+    // Increment counter
+    increment: publicProcedure.mutation(() => {
+      counterState.value += 1;
+      return { value: counterState.value };
+    }),
+
+    // Decrement counter
+    decrement: publicProcedure.mutation(() => {
+      counterState.value -= 1;
+      return { value: counterState.value };
+    }),
+
+    // Reset counter
+    reset: publicProcedure.mutation(() => {
+      counterState.value = 0;
+      return { value: counterState.value };
+    }),
+  }),
+};
+
+// In-memory counter state
+const counterState = { value: 0 };
+
+// ==========================================================================
+// Database Routes (requires Prisma)
+// ==========================================================================
+
+const itemsRouter = router({
+  // List all items
+  list: publicProcedure
+    .input(
+      z.object({
+        completed: z.boolean().optional(),
+        search: z.string().optional(),
+      }).optional()
+    )
+    .query(async ({ input }) => {
+      const where: any = {};
+
+      if (input?.completed !== undefined) {
+        where.completed = input.completed;
+      }
+
+      if (input?.search) {
+        where.OR = [
+          { title: { contains: input.search } },
+          { description: { contains: input.search } },
+        ];
+      }
+
+      return await prisma.item.findMany({
+        where,
+        orderBy: { createdAt: 'desc' },
+      });
+    }),
+
+  // Get single item by ID
+  byId: publicProcedure
+    .input(z.object({ id: z.string() }))
+    .query(async ({ input }) => {
+      return await prisma.item.findUnique({
+        where: { id: input.id },
+      });
+    }),
+
+  // Create item
+  create: publicProcedure
+    .input(ItemCreateSchema)
+    .mutation(async ({ input }) => {
+      return await prisma.item.create({
+        data: input,
+      });
+    }),
+
+  // Update item
+  update: publicProcedure
+    .input(
+      z.object({
+        id: z.string(),
+        data: ItemUpdateSchema,
+      })
+    )
+    .mutation(async ({ input }) => {
+      return await prisma.item.update({
+        where: { id: input.id },
+        data: input.data,
+      });
+    }),
+
+  // Delete item
+  delete: publicProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input }) => {
+      return await prisma.item.delete({
+        where: { id: input.id },
+      });
+    }),
+
+  // Toggle completed status
+  toggle: publicProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ input }) => {
+      const item = await prisma.item.findUnique({
+        where: { id: input.id },
+      });
+
+      if (!item) {
+        throw new Error('Item not found');
+      }
+
+      return await prisma.item.update({
+        where: { id: input.id },
+        data: { completed: !item.completed },
+      });
+    }),
+
+  // Get stats
+  stats: publicProcedure.query(async () => {
+    const items = await prisma.item.findMany();
+
+    return {
+      total: items.length,
+      completed: items.filter((i: { completed: boolean }) => i.completed).length,
+      pending: items.filter((i: { completed: boolean }) => !i.completed).length,
+    };
+  }),
+});
+
+// ==========================================================================
+// Combined Router
+// ==========================================================================
+
+export const appRouter = router({
+  ...baseRoutes,
+  items: itemsRouter,
+});
+
+// Export type definition of API
+export type AppRouter = typeof appRouter;

package/dist/templates/core/api/src-trpc/server.ts

@@ -0,0 +1,63 @@
+import express from 'express';
+import cors from 'cors';
+import { createExpressMiddleware } from '@trpc/server/adapters/express';
+import { createYoga } from 'graphql-yoga';
+import { appRouter } from './router/index.js';
+import { createContext } from './context.js';
+import { schema } from './graphql/schema.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,
+  })
+);
+
+// GraphQL Yoga middleware
+const yoga = createYoga({
+  schema,
+  graphqlEndpoint: '/graphql',
+  // Enable GraphiQL playground in development
+  graphiql: process.env.NODE_ENV !== 'production',
+});
+
+app.use('/graphql', yoga);
+
+// Default route
+app.get('/', (req, res) => {
+  res.json({
+    message: 'Welcome to {{appDisplayName}} API',
+    endpoints: {
+      health: '/health',
+      trpc: '/trpc',
+      graphql: '/graphql',
+    }
+  });
+});
+
+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`);
+  console.log(`Health check at http://localhost:${PORT}/health`);
+});

package/dist/templates/core/api/src-trpc/trpc.ts

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

package/dist/templates/core/database/schema.prisma

@@ -0,0 +1,22 @@
+// Prisma schema for {{appDisplayName}}
+// Learn more: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+  output   = "./generated/client"
+}
+
+datasource db {
+  provider = "sqlite"
+  url      = env("DATABASE_URL")
+}
+
+// Simple Item model for demonstrating CRUD operations
+model Item {
+  id          String   @id @default(cuid())
+  title       String
+  description String?
+  completed   Boolean  @default(false)
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+}

package/dist/templates/core/shared/src-components/App.tsx

@@ -0,0 +1,51 @@
+import React, { useState } from 'react';
+import { NavigatorProvider } from '@idealyst/navigation';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { AppRouter } from '../navigation/AppRouter';
+import { trpc, createTRPCClient } from '../trpc/client';
+import { ApolloProvider, createApolloClient } from '../graphql/client';
+
+// API configuration
+const API_URL = 'http://localhost:3002';
+
+/**
+ * Main App component for the {{appDisplayName}}
+ * Sets up navigation with tRPC and Apollo providers
+ */
+export const App: React.FC = () => {
+  // Create React Query client
+  const [queryClient] = useState(() => new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: 1,
+        staleTime: 5000,
+      },
+    },
+  }));
+
+  // Create tRPC client
+  const [trpcClient] = useState(() =>
+    createTRPCClient({
+      apiUrl: `${API_URL}/trpc`,
+    })
+  );
+
+  // Create Apollo client
+  const [apolloClient] = useState(() =>
+    createApolloClient({
+      graphqlUrl: `${API_URL}/graphql`,
+    })
+  );
+
+  return (
+    <trpc.Provider client={trpcClient} queryClient={queryClient}>
+      <QueryClientProvider client={queryClient}>
+        <ApolloProvider client={apolloClient}>
+          <NavigatorProvider route={AppRouter} />
+        </ApolloProvider>
+      </QueryClientProvider>
+    </trpc.Provider>
+  );
+};
+
+export default App;

package/dist/templates/core/shared/src-graphql/client.ts

@@ -0,0 +1,70 @@
+/**
+ * Apollo Client Configuration
+ *
+ * Provides a configured Apollo Client for GraphQL queries and mutations.
+ */
+
+import { ApolloClient, InMemoryCache, HttpLink, from } from '@apollo/client';
+import { onError } from '@apollo/client/link/error';
+
+export interface ApolloClientConfig {
+  graphqlUrl?: string;
+  headers?: () => Record<string, string>;
+}
+
+// Error handling link
+const createErrorLink = () =>
+  onError(({ graphQLErrors, networkError }) => {
+    if (graphQLErrors) {
+      graphQLErrors.forEach(({ message, locations, path }) => {
+        console.error(
+          `[GraphQL error]: Message: ${message}, Location: ${JSON.stringify(locations)}, Path: ${path}`
+        );
+      });
+    }
+    if (networkError) {
+      console.error(`[Network error]: ${networkError}`);
+    }
+  });
+
+/**
+ * Creates a configured Apollo Client
+ */
+export function createApolloClient(config: ApolloClientConfig = {}) {
+  const { graphqlUrl = 'http://localhost:3000/graphql', headers } = config;
+
+  // HTTP link to GraphQL endpoint
+  const httpLink = new HttpLink({
+    uri: graphqlUrl,
+    credentials: 'include',
+    headers: headers?.(),
+  });
+
+  // Create the Apollo Client
+  return new ApolloClient({
+    link: from([createErrorLink(), httpLink]),
+    cache: new InMemoryCache({
+      typePolicies: {
+        Item: {
+          keyFields: ['id'],
+        },
+      },
+    }),
+    defaultOptions: {
+      watchQuery: {
+        fetchPolicy: 'cache-and-network',
+      },
+    },
+  });
+}
+
+// Re-export Apollo hooks and types for convenience
+export {
+  ApolloProvider,
+  useQuery,
+  useMutation,
+  useLazyQuery,
+  gql,
+} from '@apollo/client';
+
+export type { ApolloError, QueryResult, MutationResult } from '@apollo/client';