@yoms/create-monorepo 2.0.0 → 4.0.0

package/templates/frontend-nextjs/base/services/auth/auth.types.ts

@@ -0,0 +1,38 @@
+/**
+ * Auth types — aligned with better-auth's session model.
+ */
+
+export interface AuthUser {
+  id: string;
+  name: string;
+  email: string;
+  emailVerified: boolean;
+  image?: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface AuthSession {
+  user: AuthUser;
+  session: {
+    id: string;
+    userId: string;
+    expiresAt: Date;
+    token: string;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+  };
+}
+
+export interface SignInInput {
+  email: string;
+  password: string;
+  callbackURL?: string;
+}
+
+export interface SignUpInput {
+  name: string;
+  email: string;
+  password: string;
+  callbackURL?: string;
+}

package/templates/frontend-nextjs/base/services/auth/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Auth service exports
+ *
+ * Quick start:
+ *   import { useSession, useSignIn, useSignUp, useSignOut } from '@/services/auth';
+ *
+ * For direct better-auth client access:
+ *   import { authClient } from '@/lib/auth-client';
+ */
+
+export * from './auth.types';
+export * from './auth.hook';

package/templates/frontend-nextjs/base/services/users/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Users service exports
+ */
+
+export * from './users.types';
+export * from './users.service';
+export * from './users.queries';
+export * from './users.hook';

package/templates/frontend-nextjs/base/services/users/users.hook.ts

@@ -0,0 +1,119 @@
+/**
+ * User React Query hooks
+ * Custom hooks that wrap user service calls with React Query
+ */
+
+import {
+  useQuery,
+  useMutation,
+  useQueryClient,
+  type UseQueryOptions,
+  type UseMutationOptions,
+} from '@tanstack/react-query';
+import { UserService } from './users.service';
+import { userKeys } from './users.queries';
+import type {
+  User,
+  PaginatedUsers,
+  CreateUserInput,
+  UpdateUserInput,
+  UsersListParams,
+} from './users.types';
+import type { ApiResponse } from '__PACKAGE_SCOPE__/shared';
+
+/**
+ * Hook to fetch paginated users list
+ */
+export function useUsers(
+  params?: UsersListParams,
+  options?: Omit<
+    UseQueryOptions<ApiResponse<PaginatedUsers>>,
+    'queryKey' | 'queryFn'
+  >
+) {
+  return useQuery({
+    queryKey: userKeys.list(params),
+    queryFn: () => UserService.getUsers(params),
+    ...options,
+  });
+}
+
+/**
+ * Hook to fetch a single user by ID
+ */
+export function useUser(
+  id: string,
+  options?: Omit<UseQueryOptions<ApiResponse<User>>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: userKeys.detail(id),
+    queryFn: () => UserService.getUserById(id),
+    enabled: !!id,
+    ...options,
+  });
+}
+
+/**
+ * Hook to create a new user
+ */
+export function useCreateUser(
+  options?: UseMutationOptions<
+    ApiResponse<User>,
+    Error,
+    CreateUserInput
+  >
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: CreateUserInput) => UserService.createUser(data),
+    onSuccess: () => {
+      // Invalidate users list to refetch after creation
+      queryClient.invalidateQueries({ queryKey: userKeys.lists() });
+    },
+    ...options,
+  });
+}
+
+/**
+ * Hook to update an existing user
+ */
+export function useUpdateUser(
+  options?: UseMutationOptions<
+    ApiResponse<User>,
+    Error,
+    { id: string; data: UpdateUserInput }
+  >
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ id, data }: { id: string; data: UpdateUserInput }) =>
+      UserService.updateUser(id, data),
+    onSuccess: (_, variables) => {
+      // Invalidate both the specific user and the users list
+      queryClient.invalidateQueries({ queryKey: userKeys.detail(variables.id) });
+      queryClient.invalidateQueries({ queryKey: userKeys.lists() });
+    },
+    ...options,
+  });
+}
+
+/**
+ * Hook to delete a user
+ */
+export function useDeleteUser(
+  options?: UseMutationOptions<ApiResponse<void>, Error, string>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (id: string) => UserService.deleteUser(id),
+    onSuccess: (_, id) => {
+      // Remove the deleted user from cache and invalidate lists
+      queryClient.removeQueries({ queryKey: userKeys.detail(id) });
+      queryClient.invalidateQueries({ queryKey: userKeys.lists() });
+    },
+    ...options,
+  });
+}

package/templates/frontend-nextjs/base/services/users/users.queries.ts

@@ -0,0 +1,14 @@
+/**
+ * User query key factory
+ * Provides type-safe query keys for React Query
+ */
+
+import type { UsersListParams } from './users.types';
+
+export const userKeys = {
+  all: ['users'] as const,
+  lists: () => [...userKeys.all, 'list'] as const,
+  list: (params?: UsersListParams) => [...userKeys.lists(), params] as const,
+  details: () => [...userKeys.all, 'detail'] as const,
+  detail: (id: string) => [...userKeys.details(), id] as const,
+};

package/templates/frontend-nextjs/base/services/users/users.service.ts

@@ -0,0 +1,65 @@
+/**
+ * User service
+ * Service layer for user-related API calls
+ */
+
+import { ApiClient } from '../api/client';
+import { API_ENDPOINTS } from '../api/endpoints';
+import type {
+  User,
+  PaginatedUsers,
+  CreateUserInput,
+  UpdateUserInput,
+  UsersListParams,
+} from './users.types';
+import type { ApiResponse } from '__PACKAGE_SCOPE__/shared';
+
+export class UserService {
+  /**
+   * Fetch paginated list of users
+   */
+  static async getUsers(
+    params?: UsersListParams
+  ): Promise<ApiResponse<PaginatedUsers>> {
+    const searchParams = new URLSearchParams();
+    if (params?.page) searchParams.set('page', params.page.toString());
+    if (params?.limit) searchParams.set('limit', params.limit.toString());
+    if (params?.search) searchParams.set('search', params.search);
+
+    const query = searchParams.toString();
+    const endpoint = query ? `${API_ENDPOINTS.users.list}?${query}` : API_ENDPOINTS.users.list;
+
+    return ApiClient.get<PaginatedUsers>(endpoint);
+  }
+
+  /**
+   * Fetch a single user by ID
+   */
+  static async getUserById(id: string): Promise<ApiResponse<User>> {
+    return ApiClient.get<User>(API_ENDPOINTS.users.byId(id));
+  }
+
+  /**
+   * Create a new user
+   */
+  static async createUser(data: CreateUserInput): Promise<ApiResponse<User>> {
+    return ApiClient.post<User>(API_ENDPOINTS.users.create, data);
+  }
+
+  /**
+   * Update an existing user
+   */
+  static async updateUser(
+    id: string,
+    data: UpdateUserInput
+  ): Promise<ApiResponse<User>> {
+    return ApiClient.put<User>(API_ENDPOINTS.users.update(id), data);
+  }
+
+  /**
+   * Delete a user
+   */
+  static async deleteUser(id: string): Promise<ApiResponse<void>> {
+    return ApiClient.delete<void>(API_ENDPOINTS.users.delete(id));
+  }
+}

package/templates/frontend-nextjs/base/services/users/users.types.ts

@@ -0,0 +1,37 @@
+/**
+ * User service types
+ */
+
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateUserInput {
+  name: string;
+  email: string;
+}
+
+export interface UpdateUserInput {
+  name?: string;
+  email?: string;
+}
+
+export interface UsersListParams {
+  page?: number;
+  limit?: number;
+  search?: string;
+}
+
+export interface PaginatedUsers {
+  data: User[];
+  meta: {
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+  };
+}

package/templates/shared/base/CLAUDE.md

@@ -0,0 +1,95 @@
+# CLAUDE.md — Shared Package (`__PACKAGE_SCOPE__/shared`)
+
+This file provides guidance to Claude Code when working in this package.
+
+## Overview
+
+Shared TypeScript types and Zod schemas used by both the backend API and frontend web app. This is the single source of truth for data shapes across the monorepo.
+
+## Structure
+
+```
+src/
+├── index.ts           # Barrel export — everything exported from here
+├── types.ts           # Shared TypeScript interfaces (ApiResponse, PaginatedResponse)
+└── schemas/
+    └── user.schema.ts # Zod schemas + inferred types for User domain
+```
+
+## Development Commands
+
+```bash
+pnpm build        # Build (required before other packages can consume it)
+pnpm typecheck    # Type check
+```
+
+> **Important**: Run `pnpm build` after changes so backend and frontend pick up the latest types.
+
+## Adding New Schemas
+
+Create a new file in `src/schemas/`:
+
+```typescript
+// src/schemas/post.schema.ts
+import { z } from 'zod';
+
+export const PostSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  content: z.string().nullable(),
+  authorId: z.string(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+export type Post = z.infer<typeof PostSchema>;
+
+export const CreatePostSchema = z.object({
+  title: z.string().min(1),
+  content: z.string().optional(),
+  authorId: z.string(),
+});
+export type CreatePost = z.infer<typeof CreatePostSchema>;
+
+export const UpdatePostSchema = CreatePostSchema.partial();
+export type UpdatePost = z.infer<typeof UpdatePostSchema>;
+```
+
+Then re-export from `src/index.ts`:
+
+```typescript
+export * from './schemas/post.schema.js';
+```
+
+## Consuming in Backend
+
+```typescript
+import { PostSchema, type CreatePost } from '__PACKAGE_SCOPE__/shared';
+import { zValidator } from '@hono/zod-validator';
+
+posts.post('/', zValidator('json', CreatePostSchema), async (c) => {
+  const data = c.req.valid('json'); // typed as CreatePost
+});
+```
+
+## Consuming in Frontend
+
+```typescript
+import type { Post, CreatePost } from '__PACKAGE_SCOPE__/shared';
+import { PostSchema } from '__PACKAGE_SCOPE__/shared';
+
+// In service
+export class PostService {
+  static async getAll(): Promise<ApiResponse<Post[]>> {
+    return ApiClient.get('/posts');
+  }
+}
+```
+
+## Rules
+
+- Only pure TypeScript / Zod — no framework-specific code
+- No runtime dependencies other than `zod`
+- Always export both the Zod schema AND the inferred TypeScript type
+- Schema names: `UserSchema` / Type names: `User` (no suffix)
+- Use `.nullable()` not `.optional()` for fields that can be null in the DB
+- Use `.coerce.date()` for `DateTime` fields from Prisma

package/templates/backend-hono/features/jwt-auth/env-additions.txt

@@ -1,5 +0,0 @@
-# JWT Configuration
-JWT_SECRET=your-super-secret-jwt-key-change-this-in-production
-JWT_EXPIRES_IN=15m
-JWT_REFRESH_SECRET=your-super-secret-refresh-key-change-this-in-production
-JWT_REFRESH_EXPIRES_IN=7d

package/templates/backend-hono/features/jwt-auth/package-additions.json

@@ -1,10 +0,0 @@
-{
-  "dependencies": {
-    "jsonwebtoken": "^9.0.2",
-    "bcryptjs": "^2.4.3"
-  },
-  "devDependencies": {
-    "@types/jsonwebtoken": "^9.0.7",
-    "@types/bcryptjs": "^2.4.6"
-  }
-}

package/templates/backend-hono/features/jwt-auth/src/config/env-additions.ts

@@ -1,16 +0,0 @@
-// Add these to your env schema validation
-
-import { z } from 'zod';
-
-export const jwtEnvSchema = z.object({
-  JWT_SECRET: z.string().min(32, 'JWT_SECRET must be at least 32 characters'),
-  JWT_EXPIRES_IN: z.string().default('15m'),
-  JWT_REFRESH_SECRET: z.string().min(32, 'JWT_REFRESH_SECRET must be at least 32 characters'),
-  JWT_REFRESH_EXPIRES_IN: z.string().default('7d'),
-});
-
-// Merge this with your existing env schema:
-// const envSchema = z.object({
-//   ...existingFields,
-//   ...jwtEnvSchema.shape,
-// });

package/templates/backend-hono/features/jwt-auth/src/lib/jwt.ts

@@ -1,75 +0,0 @@
-import jwt from 'jsonwebtoken';
-import { env } from '../config/env.js';
-import { UnauthorizedError } from '../lib/errors.js';
-
-export interface JwtPayload {
-  userId: string;
-  email: string;
-  type: 'access' | 'refresh';
-}
-
-export interface TokenPair {
-  accessToken: string;
-  refreshToken: string;
-}
-
-/**
- * Generate access and refresh tokens for a user
- */
-export function generateTokens(userId: string, email: string): TokenPair {
-  const accessToken = jwt.sign(
-    { userId, email, type: 'access' } as JwtPayload,
-    env.JWT_SECRET,
-    { expiresIn: env.JWT_EXPIRES_IN }
-  );
-
-  const refreshToken = jwt.sign(
-    { userId, email, type: 'refresh' } as JwtPayload,
-    env.JWT_REFRESH_SECRET,
-    { expiresIn: env.JWT_REFRESH_EXPIRES_IN }
-  );
-
-  return { accessToken, refreshToken };
-}
-
-/**
- * Verify and decode an access token
- */
-export function verifyAccessToken(token: string): JwtPayload {
-  try {
-    const decoded = jwt.verify(token, env.JWT_SECRET) as JwtPayload;
-    if (decoded.type !== 'access') {
-      throw new UnauthorizedError('Invalid token type');
-    }
-    return decoded;
-  } catch (error) {
-    if (error instanceof jwt.TokenExpiredError) {
-      throw new UnauthorizedError('Token expired');
-    }
-    if (error instanceof jwt.JsonWebTokenError) {
-      throw new UnauthorizedError('Invalid token');
-    }
-    throw error;
-  }
-}
-
-/**
- * Verify and decode a refresh token
- */
-export function verifyRefreshToken(token: string): JwtPayload {
-  try {
-    const decoded = jwt.verify(token, env.JWT_REFRESH_SECRET) as JwtPayload;
-    if (decoded.type !== 'refresh') {
-      throw new UnauthorizedError('Invalid token type');
-    }
-    return decoded;
-  } catch (error) {
-    if (error instanceof jwt.TokenExpiredError) {
-      throw new UnauthorizedError('Refresh token expired');
-    }
-    if (error instanceof jwt.JsonWebTokenError) {
-      throw new UnauthorizedError('Invalid refresh token');
-    }
-    throw error;
-  }
-}

package/templates/backend-hono/features/jwt-auth/src/middleware/auth.middleware.ts

@@ -1,50 +0,0 @@
-import type { Context, Next } from 'hono';
-import { verifyAccessToken } from '../lib/jwt.js';
-import { UnauthorizedError } from '../lib/errors.js';
-
-/**
- * Middleware to authenticate requests using JWT
- * Extracts and verifies the JWT token from the Authorization header
- * and attaches the decoded payload to c.get('jwtPayload')
- */
-export async function authMiddleware(c: Context, next: Next): Promise<void> {
-  const authHeader = c.req.header('Authorization');
-
-  if (!authHeader) {
-    throw new UnauthorizedError('No authorization header');
-  }
-
-  const [type, token] = authHeader.split(' ');
-
-  if (type !== 'Bearer' || !token) {
-    throw new UnauthorizedError('Invalid authorization header format');
-  }
-
-  const payload = verifyAccessToken(token);
-  c.set('jwtPayload', payload);
-
-  await next();
-}
-
-/**
- * Optional authentication middleware
- * Similar to authMiddleware but doesn't throw if no token is present
- * Use this for routes that work for both authenticated and unauthenticated users
- */
-export async function optionalAuthMiddleware(c: Context, next: Next): Promise<void> {
-  const authHeader = c.req.header('Authorization');
-
-  if (authHeader) {
-    try {
-      const [type, token] = authHeader.split(' ');
-      if (type === 'Bearer' && token) {
-        const payload = verifyAccessToken(token);
-        c.set('jwtPayload', payload);
-      }
-    } catch {
-      // Silently ignore invalid tokens for optional auth
-    }
-  }
-
-  await next();
-}