create-turbo-mono 1.0.0

package/src/templates/shared.ts

@@ -0,0 +1,820 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function createSharedPackages(targetDir: string): Promise<void> {
+  await createTsConfigPackage(targetDir);
+  await createDatabasePackage(targetDir);
+  await createSharedBackendPackage(targetDir);
+  await createSharedFrontendPackage(targetDir);
+  await createSharedCommonPackage(targetDir);
+}
+
+async function createTsConfigPackage(targetDir: string): Promise<void> {
+  const packageDir = path.join(targetDir, 'packages', 'tsconfig');
+  await fs.ensureDir(packageDir);
+
+  // package.json
+  const packageJson = {
+    name: '@repo/tsconfig',
+    version: '1.0.0',
+    private: true,
+  };
+
+  await fs.writeJson(path.join(packageDir, 'package.json'), packageJson, {
+    spaces: 2,
+  });
+
+  // base.json
+  const baseConfig = {
+    compilerOptions: {
+      target: 'ES2020',
+      lib: ['ES2020'],
+      module: 'commonjs',
+      moduleResolution: 'node',
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      strict: true,
+      resolveJsonModule: true,
+      declaration: true,
+      declarationMap: true,
+      sourceMap: true,
+      incremental: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noImplicitReturns: true,
+      noFallthroughCasesInSwitch: true,
+    },
+  };
+
+  await fs.writeJson(path.join(packageDir, 'base.json'), baseConfig, {
+    spaces: 2,
+  });
+
+  // nestjs.json
+  const nestjsConfig = {
+    extends: './base.json',
+    compilerOptions: {
+      module: 'commonjs',
+      declaration: true,
+      removeComments: true,
+      emitDecoratorMetadata: true,
+      experimentalDecorators: true,
+      allowSyntheticDefaultImports: true,
+      target: 'ES2021',
+      sourceMap: true,
+      outDir: './dist',
+      baseUrl: './',
+      incremental: true,
+      skipLibCheck: true,
+    },
+  };
+
+  await fs.writeJson(path.join(packageDir, 'nestjs.json'), nestjsConfig, {
+    spaces: 2,
+  });
+
+  // nextjs.json
+  const nextjsConfig = {
+    extends: './base.json',
+    compilerOptions: {
+      target: 'ES2020',
+      lib: ['dom', 'dom.iterable', 'esnext'],
+      allowJs: true,
+      skipLibCheck: true,
+      strict: true,
+      forceConsistentCasingInFileNames: true,
+      noEmit: true,
+      esModuleInterop: true,
+      module: 'esnext',
+      moduleResolution: 'bundler',
+      resolveJsonModule: true,
+      isolatedModules: true,
+      jsx: 'preserve',
+      incremental: true,
+      plugins: [
+        {
+          name: 'next',
+        },
+      ],
+    },
+  };
+
+  await fs.writeJson(path.join(packageDir, 'nextjs.json'), nextjsConfig, {
+    spaces: 2,
+  });
+
+  // react-library.json
+  const reactLibConfig = {
+    extends: './base.json',
+    compilerOptions: {
+      target: 'ES2020',
+      lib: ['dom', 'dom.iterable', 'esnext'],
+      jsx: 'react-jsx',
+      module: 'esnext',
+      moduleResolution: 'bundler',
+      noEmit: false,
+      outDir: './dist',
+    },
+  };
+
+  await fs.writeJson(
+    path.join(packageDir, 'react-library.json'),
+    reactLibConfig,
+    { spaces: 2 }
+  );
+}
+
+async function createDatabasePackage(targetDir: string): Promise<void> {
+  const packageDir = path.join(targetDir, 'packages', 'database');
+  await fs.ensureDir(path.join(packageDir, 'prisma'));
+  await fs.ensureDir(path.join(packageDir, 'src'));
+
+  // package.json
+  const packageJson = {
+    name: '@repo/database',
+    version: '1.0.0',
+    private: true,
+    main: './src/index.ts',
+    types: './src/index.ts',
+    scripts: {
+      'db:generate': 'prisma generate',
+      'db:push': 'prisma db push',
+      'db:migrate': 'prisma migrate dev',
+      'db:studio': 'prisma studio',
+      build: 'tsc',
+      clean: 'rm -rf dist',
+      'type-check': 'tsc --noEmit',
+    },
+    dependencies: {
+      '@prisma/client': '^5.7.1',
+    },
+    devDependencies: {
+      '@repo/tsconfig': 'workspace:*',
+      prisma: '^5.7.1',
+      typescript: '^5.3.3',
+    },
+  };
+
+  await fs.writeJson(path.join(packageDir, 'package.json'), packageJson, {
+    spaces: 2,
+  });
+
+  // tsconfig.json
+  const tsConfig = {
+    extends: '@repo/tsconfig/base.json',
+    compilerOptions: {
+      outDir: './dist',
+      rootDir: './src',
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'dist'],
+  };
+
+  await fs.writeJson(path.join(packageDir, 'tsconfig.json'), tsConfig, {
+    spaces: 2,
+  });
+
+  // prisma/schema.prisma
+  const prismaSchema = `// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+  output   = "../node_modules/.prisma/client"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("users")
+}
+
+model Post {
+  id        String   @id @default(cuid())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+  authorId  String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("posts")
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'prisma', 'schema.prisma'),
+    prismaSchema
+  );
+
+  // src/index.ts
+  const indexTs = `import { PrismaClient } from '@prisma/client';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var prisma: PrismaClient | undefined;
+}
+
+export const prisma =
+  global.prisma ||
+  new PrismaClient({
+    log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+  });
+
+if (process.env.NODE_ENV !== 'production') {
+  global.prisma = prisma;
+}
+
+export * from '@prisma/client';
+`;
+
+  await fs.writeFile(path.join(packageDir, 'src', 'index.ts'), indexTs);
+
+  // .env.example
+  const envExample = `DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"
+`;
+
+  await fs.writeFile(path.join(packageDir, '.env.example'), envExample);
+
+  // README.md
+  const readme = `# @repo/database
+
+Shared Prisma database client and schema.
+
+## Usage
+
+\`\`\`typescript
+import { prisma } from '@repo/database';
+
+// Use prisma client
+const users = await prisma.user.findMany();
+\`\`\`
+
+## Commands
+
+\`\`\`bash
+# Generate Prisma Client
+pnpm db:generate
+
+# Create and apply migrations
+pnpm db:migrate
+
+# Push schema changes without migration
+pnpm db:push
+
+# Open Prisma Studio
+pnpm db:studio
+\`\`\`
+`;
+
+  await fs.writeFile(path.join(packageDir, 'README.md'), readme);
+}
+
+async function createSharedBackendPackage(targetDir: string): Promise<void> {
+  const packageDir = path.join(targetDir, 'packages', 'shared-backend');
+  await fs.ensureDir(path.join(packageDir, 'src'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'utils'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'middleware'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'types'));
+
+  // package.json
+  const packageJson = {
+    name: '@repo/shared-backend',
+    version: '1.0.0',
+    private: true,
+    main: './src/index.ts',
+    types: './src/index.ts',
+    scripts: {
+      build: 'tsc',
+      clean: 'rm -rf dist',
+      'type-check': 'tsc --noEmit',
+    },
+    dependencies: {
+      '@repo/shared-common': 'workspace:*',
+    },
+    devDependencies: {
+      '@repo/tsconfig': 'workspace:*',
+      '@types/node': '^20.10.6',
+      typescript: '^5.3.3',
+    },
+  };
+
+  await fs.writeJson(path.join(packageDir, 'package.json'), packageJson, {
+    spaces: 2,
+  });
+
+  // tsconfig.json
+  const tsConfig = {
+    extends: '@repo/tsconfig/base.json',
+    compilerOptions: {
+      outDir: './dist',
+      rootDir: './src',
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'dist'],
+  };
+
+  await fs.writeJson(path.join(packageDir, 'tsconfig.json'), tsConfig, {
+    spaces: 2,
+  });
+
+  // src/index.ts
+  const indexTs = `export * from './utils';
+export * from './types';
+`;
+
+  await fs.writeFile(path.join(packageDir, 'src', 'index.ts'), indexTs);
+
+  // src/utils/index.ts
+  const utilsIndexTs = `export * from './logger';
+export * from './response';
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'utils', 'index.ts'),
+    utilsIndexTs
+  );
+
+  // src/utils/logger.ts
+  const loggerTs = `export class Logger {
+  private context: string;
+
+  constructor(context: string) {
+    this.context = context;
+  }
+
+  log(message: string, ...args: any[]) {
+    console.log(\`[\${this.context}] \${message}\`, ...args);
+  }
+
+  error(message: string, ...args: any[]) {
+    console.error(\`[\${this.context}] ERROR: \${message}\`, ...args);
+  }
+
+  warn(message: string, ...args: any[]) {
+    console.warn(\`[\${this.context}] WARN: \${message}\`, ...args);
+  }
+
+  debug(message: string, ...args: any[]) {
+    if (process.env.NODE_ENV === 'development') {
+      console.debug(\`[\${this.context}] DEBUG: \${message}\`, ...args);
+    }
+  }
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'utils', 'logger.ts'),
+    loggerTs
+  );
+
+  // src/utils/response.ts
+  const responseTs = `export interface ApiResponse<T = any> {
+  success: boolean;
+  data?: T;
+  message?: string;
+  error?: string;
+}
+
+export function successResponse<T>(data: T, message?: string): ApiResponse<T> {
+  return {
+    success: true,
+    data,
+    message,
+  };
+}
+
+export function errorResponse(error: string, message?: string): ApiResponse {
+  return {
+    success: false,
+    error,
+    message,
+  };
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'utils', 'response.ts'),
+    responseTs
+  );
+
+  // src/types/index.ts
+  const typesIndexTs = `export interface PaginationParams {
+  page?: number;
+  limit?: number;
+}
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  total: number;
+  page: number;
+  limit: number;
+  totalPages: number;
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'types', 'index.ts'),
+    typesIndexTs
+  );
+
+  // README.md
+  const readme = `# @repo/shared-backend
+
+Shared backend utilities, types, and middleware.
+
+## Usage
+
+\`\`\`typescript
+import { Logger, successResponse } from '@repo/shared-backend';
+
+const logger = new Logger('MyService');
+logger.log('Hello from shared backend');
+
+const response = successResponse({ id: 1 }, 'User created');
+\`\`\`
+`;
+
+  await fs.writeFile(path.join(packageDir, 'README.md'), readme);
+}
+
+async function createSharedFrontendPackage(targetDir: string): Promise<void> {
+  const packageDir = path.join(targetDir, 'packages', 'shared-frontend');
+  await fs.ensureDir(path.join(packageDir, 'src'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'components'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'hooks'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'utils'));
+
+  // package.json
+  const packageJson = {
+    name: '@repo/shared-frontend',
+    version: '1.0.0',
+    private: true,
+    main: './src/index.ts',
+    types: './src/index.ts',
+    scripts: {
+      build: 'tsc',
+      clean: 'rm -rf dist',
+      'type-check': 'tsc --noEmit',
+      lint: 'eslint "src/**/*.{ts,tsx}"',
+    },
+    dependencies: {
+      '@repo/shared-common': 'workspace:*',
+      react: '^18.2.0',
+      'react-dom': '^18.2.0',
+    },
+    devDependencies: {
+      '@repo/tsconfig': 'workspace:*',
+      '@types/react': '^18.2.46',
+      '@types/react-dom': '^18.2.18',
+      typescript: '^5.3.3',
+    },
+    peerDependencies: {
+      react: '^18.2.0',
+      'react-dom': '^18.2.0',
+    },
+  };
+
+  await fs.writeJson(path.join(packageDir, 'package.json'), packageJson, {
+    spaces: 2,
+  });
+
+  // tsconfig.json
+  const tsConfig = {
+    extends: '@repo/tsconfig/react-library.json',
+    compilerOptions: {
+      outDir: './dist',
+      rootDir: './src',
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'dist'],
+  };
+
+  await fs.writeJson(path.join(packageDir, 'tsconfig.json'), tsConfig, {
+    spaces: 2,
+  });
+
+  // src/index.ts
+  const indexTs = `export * from './components';
+export * from './hooks';
+export * from './utils';
+`;
+
+  await fs.writeFile(path.join(packageDir, 'src', 'index.ts'), indexTs);
+
+  // src/components/index.ts
+  const componentsIndexTs = `export * from './Button';
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'components', 'index.ts'),
+    componentsIndexTs
+  );
+
+  // src/components/Button.tsx
+  const buttonTsx = `import React from 'react';
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+  variant?: 'primary' | 'secondary' | 'danger';
+  size?: 'sm' | 'md' | 'lg';
+}
+
+export function Button({
+  children,
+  variant = 'primary',
+  size = 'md',
+  className = '',
+  ...props
+}: ButtonProps) {
+  const baseStyles = 'font-semibold rounded focus:outline-none focus:ring-2';
+
+  const variantStyles = {
+    primary: 'bg-blue-600 text-white hover:bg-blue-700 focus:ring-blue-500',
+    secondary: 'bg-gray-600 text-white hover:bg-gray-700 focus:ring-gray-500',
+    danger: 'bg-red-600 text-white hover:bg-red-700 focus:ring-red-500',
+  };
+
+  const sizeStyles = {
+    sm: 'px-3 py-1.5 text-sm',
+    md: 'px-4 py-2 text-base',
+    lg: 'px-6 py-3 text-lg',
+  };
+
+  const combinedClassName = \`\${baseStyles} \${variantStyles[variant]} \${sizeStyles[size]} \${className}\`;
+
+  return (
+    <button className={combinedClassName} {...props}>
+      {children}
+    </button>
+  );
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'components', 'Button.tsx'),
+    buttonTsx
+  );
+
+  // src/hooks/index.ts
+  const hooksIndexTs = `export * from './useLocalStorage';
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'hooks', 'index.ts'),
+    hooksIndexTs
+  );
+
+  // src/hooks/useLocalStorage.ts
+  const useLocalStorageTs = `import { useState, useEffect } from 'react';
+
+export function useLocalStorage<T>(
+  key: string,
+  initialValue: T
+): [T, (value: T) => void] {
+  const [storedValue, setStoredValue] = useState<T>(() => {
+    if (typeof window === 'undefined') {
+      return initialValue;
+    }
+
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      console.error(error);
+      return initialValue;
+    }
+  });
+
+  const setValue = (value: T) => {
+    try {
+      setStoredValue(value);
+      if (typeof window !== 'undefined') {
+        window.localStorage.setItem(key, JSON.stringify(value));
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  };
+
+  return [storedValue, setValue];
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'hooks', 'useLocalStorage.ts'),
+    useLocalStorageTs
+  );
+
+  // src/utils/index.ts
+  const utilsIndexTs = `export * from './cn';
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'utils', 'index.ts'),
+    utilsIndexTs
+  );
+
+  // src/utils/cn.ts
+  const cnTs = `export function cn(...classes: (string | undefined | null | false)[]): string {
+  return classes.filter(Boolean).join(' ');
+}
+`;
+
+  await fs.writeFile(path.join(packageDir, 'src', 'utils', 'cn.ts'), cnTs);
+
+  // README.md
+  const readme = `# @repo/shared-frontend
+
+Shared frontend components, hooks, and utilities.
+
+## Usage
+
+\`\`\`typescript
+import { Button, useLocalStorage } from '@repo/shared-frontend';
+
+function MyComponent() {
+  const [value, setValue] = useLocalStorage('myKey', 'default');
+
+  return <Button onClick={() => setValue('new value')}>Click me</Button>;
+}
+\`\`\`
+`;
+
+  await fs.writeFile(path.join(packageDir, 'README.md'), readme);
+}
+
+async function createSharedCommonPackage(targetDir: string): Promise<void> {
+  const packageDir = path.join(targetDir, 'packages', 'shared-common');
+  await fs.ensureDir(path.join(packageDir, 'src'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'utils'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'constants'));
+  await fs.ensureDir(path.join(packageDir, 'src', 'types'));
+
+  // package.json
+  const packageJson = {
+    name: '@repo/shared-common',
+    version: '1.0.0',
+    private: true,
+    main: './src/index.ts',
+    types: './src/index.ts',
+    scripts: {
+      build: 'tsc',
+      clean: 'rm -rf dist',
+      'type-check': 'tsc --noEmit',
+    },
+    devDependencies: {
+      '@repo/tsconfig': 'workspace:*',
+      typescript: '^5.3.3',
+    },
+  };
+
+  await fs.writeJson(path.join(packageDir, 'package.json'), packageJson, {
+    spaces: 2,
+  });
+
+  // tsconfig.json
+  const tsConfig = {
+    extends: '@repo/tsconfig/base.json',
+    compilerOptions: {
+      outDir: './dist',
+      rootDir: './src',
+    },
+    include: ['src/**/*'],
+    exclude: ['node_modules', 'dist'],
+  };
+
+  await fs.writeJson(path.join(packageDir, 'tsconfig.json'), tsConfig, {
+    spaces: 2,
+  });
+
+  // src/index.ts
+  const indexTs = `export * from './utils';
+export * from './constants';
+export * from './types';
+`;
+
+  await fs.writeFile(path.join(packageDir, 'src', 'index.ts'), indexTs);
+
+  // src/utils/index.ts
+  const utilsIndexTs = `export * from './validation';
+export * from './formatting';
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'utils', 'index.ts'),
+    utilsIndexTs
+  );
+
+  // src/utils/validation.ts
+  const validationTs = `export function isEmail(email: string): boolean {
+  const emailRegex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;
+  return emailRegex.test(email);
+}
+
+export function isValidUrl(url: string): boolean {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isEmpty(value: any): boolean {
+  if (value == null) return true;
+  if (typeof value === 'string') return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === 'object') return Object.keys(value).length === 0;
+  return false;
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'utils', 'validation.ts'),
+    validationTs
+  );
+
+  // src/utils/formatting.ts
+  const formattingTs = `export function formatDate(date: Date | string): string {
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return d.toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric',
+  });
+}
+
+export function capitalize(str: string): string {
+  if (!str) return '';
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+export function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + '...';
+}
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'utils', 'formatting.ts'),
+    formattingTs
+  );
+
+  // src/constants/index.ts
+  const constantsIndexTs = `export const APP_NAME = 'My App';
+export const API_VERSION = 'v1';
+export const DEFAULT_PAGE_SIZE = 20;
+export const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'constants', 'index.ts'),
+    constantsIndexTs
+  );
+
+  // src/types/index.ts
+  const typesIndexTs = `export interface BaseEntity {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type Nullable<T> = T | null;
+
+export type Optional<T> = T | undefined;
+`;
+
+  await fs.writeFile(
+    path.join(packageDir, 'src', 'types', 'index.ts'),
+    typesIndexTs
+  );
+
+  // README.md
+  const readme = `# @repo/shared-common
+
+Universal utilities and types shared across all packages.
+
+## Usage
+
+\`\`\`typescript
+import { isEmail, formatDate, APP_NAME } from '@repo/shared-common';
+
+console.log(isEmail('test@example.com')); // true
+console.log(formatDate(new Date())); // "January 1, 2024"
+console.log(APP_NAME); // "My App"
+\`\`\`
+`;
+
+  await fs.writeFile(path.join(packageDir, 'README.md'), readme);
+}