phos 1.0.0 → 1.0.2

package/dist/generators/monorepo.js

@@ -1,27 +1,25 @@
-import { createDirectory, writeFile, getProjectPath, logStep, logSuccess, logInfo, installDependencies, initializeGit, } from '@/utils/helpers.js';
-import { generateElysiaBackend } from "@/generators/backends/elysia.js";
-import { generateFastAPIBackend } from "@/generators/backends/fastapi.js";
-import { generateAstroFrontend } from "@/generators/frontends/astro.js";
-import { generateSvelteFrontend } from "@/generators/frontends/svelte.js";
-import { generateNextJSFrontend } from "@/generators/frontends/nextjs.js";
+import { createDirectory, writeFile, getProjectPath, logStep, logSuccess, logInfo, initializeGit, capitalize, getPackageManagerRunCmd, getPackageManagerInstallCmd, } from "../utils/helpers.js";
+import { generateElysiaBackend } from "../generators/backends/elysia.js";
+import { generateFastAPIBackend } from "../generators/backends/fastapi.js";
+import { generateAstroFrontend } from "../generators/frontends/astro.js";
+import { generateSvelteFrontend } from "../generators/frontends/svelte.js";
+import { generateNextJSFrontend } from "../generators/frontends/nextjs.js";
 export async function generateMonorepo(config) {
     const projectPath = getProjectPath(config.projectName);
     logStep(`Creating monorepo at ${projectPath}`);
     await createDirectory(projectPath);
-    const appsPath = `${projectPath}/apps`;
-    const packagesPath = `${projectPath}/packages`;
-    await createDirectory(appsPath);
-    await createDirectory(packagesPath);
-    await generateRootPackageJson(projectPath, config);
-    await generateWorkspaceConfig(projectPath, config);
-    await generateSharedTsConfig(projectPath);
-    await generateSharedEslintConfig(projectPath, config);
-    await generateSharedPrettierConfig(projectPath, config);
+    const backendPath = `${projectPath}/${capitalize(config.projectName)}_Backend`;
+    const frontendPath = `${projectPath}/${capitalize(config.projectName)}_Frontend`;
+    const docsPath = `${projectPath}/Docs`;
+    await createDirectory(backendPath);
+    await createDirectory(frontendPath);
+    await createDirectory(docsPath);
     await generateGitIgnore(projectPath);
     await generateReadme(projectPath, config);
-    const backendPath = `${appsPath}/backend`;
-    await createDirectory(backendPath);
-    switch (config.backend.framework) {
+    await generateAgentsMd(projectPath, config);
+    await generateLicense(projectPath, config);
+    await generateEnvExample(projectPath);
+    switch (config.backend?.framework) {
         case "elysia":
             await generateElysiaBackend(backendPath, config);
             break;
@@ -29,9 +27,7 @@ export async function generateMonorepo(config) {
             await generateFastAPIBackend(backendPath, config);
             break;
     }
-    const frontendPath = `${appsPath}/frontend`;
-    await createDirectory(frontendPath);
-    switch (config.frontend.framework) {
+    switch (config.frontend?.framework) {
         case "astro":
             await generateAstroFrontend(frontendPath, config);
             break;
@@ -42,130 +38,27 @@ export async function generateMonorepo(config) {
             await generateNextJSFrontend(frontendPath, config);
             break;
     }
-    await createDirectory(`${packagesPath}/shared`);
-    await generateSharedPackage(`${packagesPath}/shared`, config);
-    logSuccess("Backend created at apps/backend");
-    logSuccess("Frontend created at apps/frontend");
-    logSuccess("Shared packages configured");
-    logSuccess("Workspace configured");
+    await createDirectory(`${docsPath}/Feature`);
+    await createDirectory(`${docsPath}/DatabaseSetup`);
+    await generateSchemaDocs(docsPath, config);
+    const backendName = `${capitalize(config.projectName)}_Backend`;
+    const frontendName = `${capitalize(config.projectName)}_Frontend`;
+    logSuccess(`Backend created at ${backendName}`);
+    logSuccess(`Frontend created at ${frontendName}`);
+    logSuccess("Docs folder created");
     if (config.git) {
         await initializeGit(projectPath);
     }
-    if (config.install) {
-        await installDependencies(projectPath, config.frontend.packageManager);
-    }
+    const backendInstallCmd = getPackageManagerInstallCmd(config.backend?.packageManager || "npm");
+    const backendRunCmd = getPackageManagerRunCmd(config.backend?.packageManager || "npm", "dev");
+    const frontendInstallCmd = getPackageManagerInstallCmd(config.frontend?.packageManager || "npm");
+    const frontendRunCmd = getPackageManagerRunCmd(config.frontend?.packageManager || "npm", "dev");
     logInfo("\n📦 Next steps:");
     logInfo(`  cd ${config.projectName}`);
     logInfo(`  # Backend`);
-    logInfo(`  cd apps/backend && ${config.backend.packageManager} install && ${config.backend.packageManager} run dev`);
+    logInfo(`  cd ${backendName} && ${backendInstallCmd} && ${backendRunCmd}`);
     logInfo(`  # Frontend`);
-    logInfo(`  cd apps/frontend && ${config.frontend.packageManager} install && ${config.frontend.packageManager} run dev`);
-}
-async function generateRootPackageJson(projectPath, config) {
-    const packageManager = config.frontend.packageManager;
-    const content = JSON.stringify({
-        name: config.projectName,
-        version: "0.1.0",
-        private: true,
-        type: "module",
-        scripts: {
-            dev: `${packageManager} run --filter "apps/*" dev`,
-            build: `${packageManager} run --filter "apps/*" build`,
-            lint: `${packageManager} run --filter "*" lint`,
-            format: 'prettier --write "**/*.{js,jsx,ts,tsx,json,css,md}"',
-        },
-        workspaces: ["apps/*", "packages/*"],
-        devDependencies: {
-            ...(config.backend.eslint || config.frontend.eslint
-                ? {
-                    eslint: "^8.57.0",
-                    "@typescript-eslint/parser": "^7.0.0",
-                    "@typescript-eslint/eslint-plugin": "^7.0.0",
-                }
-                : {}),
-            ...(config.backend.prettier || config.frontend.prettier ? { prettier: "^3.2.0" } : {}),
-            ...(config.backend.typescript || config.frontend.typescript
-                ? { typescript: "^5.3.0" }
-                : {}),
-        },
-    }, null, 2);
-    await writeFile(`${projectPath}/package.json`, content);
-    logSuccess("Root package.json created");
-}
-async function generateWorkspaceConfig(projectPath, config) {
-    let content = "";
-    switch (config.frontend.packageManager) {
-        case "pnpm":
-            content = `packages:\n  - 'apps/*'\n  - 'packages/*'\n`;
-            await writeFile(`${projectPath}/pnpm-workspace.yaml`, content);
-            break;
-        case "yarn":
-            content = JSON.stringify({ workspaces: ["apps/*", "packages/*"] }, null, 2);
-            await writeFile(`${projectPath}/package.json`, content);
-            break;
-        case "npm":
-        case "bun":
-            await writeFile(`${projectPath}/.npmrc`, "workspaces=apps/* packages/*");
-            break;
-    }
-    logSuccess("Workspace configuration created");
-}
-async function generateSharedTsConfig(projectPath) {
-    const content = JSON.stringify({
-        compilerOptions: {
-            target: "ES2022",
-            module: "ES2022",
-            lib: ["ES2022"],
-            moduleResolution: "bundler",
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            forceConsistentCasingInFileNames: true,
-            resolveJsonModule: true,
-            declaration: true,
-            declarationMap: true,
-            sourceMap: true,
-            composite: true,
-        },
-        references: [
-            { path: "./apps/backend" },
-            { path: "./apps/frontend" },
-            { path: "./packages/shared" },
-        ],
-    }, null, 2);
-    await writeFile(`${projectPath}/tsconfig.json`, content);
-    logSuccess("Shared TypeScript configuration created");
-}
-async function generateSharedEslintConfig(projectPath, config) {
-    if (!config.backend.eslint && !config.frontend.eslint)
-        return;
-    const content = `module.exports = {
-  root: true,
-  extends: ['eslint:recommended'],
-  env: {
-    node: true,
-    es2022: true,
-  },
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-  },
-};`;
-    await writeFile(`${projectPath}/.eslintrc.js`, content);
-    logSuccess("Shared ESLint configuration created");
-}
-async function generateSharedPrettierConfig(projectPath, config) {
-    if (!config.backend.prettier && !config.frontend.prettier)
-        return;
-    const content = JSON.stringify({
-        semi: false,
-        singleQuote: true,
-        tabWidth: 2,
-        trailingComma: "es5",
-        printWidth: 80,
-    }, null, 2);
-    await writeFile(`${projectPath}/.prettierrc`, content);
-    logSuccess("Shared Prettier configuration created");
+    logInfo(`  cd ${frontendName} && ${frontendInstallCmd} && ${frontendRunCmd}`);
 }
 async function generateGitIgnore(projectPath) {
     const content = `# Dependencies
@@ -218,6 +111,8 @@ yarn-error.log*
     logSuccess(".gitignore created");
 }
 async function generateReadme(projectPath, config) {
+    const backendName = `${capitalize(config.projectName)}_Backend`;
+    const frontendName = `${capitalize(config.projectName)}_Frontend`;
     const content = `# ${config.projectName}
 
 This project was generated by [Phos](https://github.com/yourusername/phos).
@@ -226,12 +121,12 @@ This project was generated by [Phos](https://github.com/yourusername/phos).
 
 \`\`\`
 .
-├── apps/
-│   ├── backend/     # ${config.backend.framework} backend
-│   └── frontend/    # ${config.frontend.framework} frontend
-├── packages/
-│   └── shared/      # Shared utilities and types
-└── package.json     # Root package.json with workspace config
+├── ${backendName}/     # ${config.backend?.framework} backend
+├── ${frontendName}/    # ${config.frontend?.framework} frontend
+├── Docs/               # Documentation
+├── AGENTS.md           # Agent guidelines
+├── LICENSE             # License file
+└── env.example         # Environment variables template
 \`\`\`
 
 ## Getting Started
@@ -239,82 +134,354 @@ This project was generated by [Phos](https://github.com/yourusername/phos).
 ### Backend
 
 \`\`\`bash
-cd apps/backend
-${config.backend.packageManager} install
-${config.backend.packageManager} run dev
+cd ${backendName}
+${config.backend?.packageManager} install
+${config.backend?.packageManager} run dev
 \`\`\`
 
 ### Frontend
 
 \`\`\`bash
-cd apps/frontend
-${config.frontend.packageManager} install
-${config.frontend.packageManager} run dev
+cd ${frontendName}
+${config.frontend?.packageManager} install
+${config.frontend?.packageManager} run dev
 \`\`\`
 
 ## Available Scripts
 
-- \`${config.frontend.packageManager} run dev\` - Start development servers
-- \`${config.frontend.packageManager} run build\` - Build for production
-- \`${config.frontend.packageManager} run lint\` - Run ESLint
-- \`${config.frontend.packageManager} run format\` - Format code with Prettier
+- \`${config.frontend?.packageManager} run dev\` - Start development servers
+- \`${config.frontend?.packageManager} run build\` - Build for production
+- \`${config.frontend?.packageManager} run lint\` - Run ESLint
+- \`${config.frontend?.packageManager} run format\` - Format code with Prettier
 
 ## Tech Stack
 
 ### Backend
-- Framework: ${config.backend.framework}
-- Package Manager: ${config.backend.packageManager}
-- TypeScript: ${config.backend.typescript ? "Yes" : "No"}
-- ESLint: ${config.backend.eslint ? "Yes" : "No"}
-- Prettier: ${config.backend.prettier ? "Yes" : "No"}
+- Framework: ${config.backend?.framework}
+- Package Manager: ${config.backend?.packageManager}
+- TypeScript: ${config.backend?.typescript ? "Yes" : "No"}
+- ESLint: ${config.backend?.eslint ? "Yes" : "No"}
+- Prettier: ${config.backend?.prettier ? "Yes" : "No"}
 
 ### Frontend
-- Framework: ${config.frontend.framework}
-- Package Manager: ${config.frontend.packageManager}
-- TypeScript: ${config.frontend.typescript ? "Yes" : "No"}
-- ESLint: ${config.frontend.eslint ? "Yes" : "No"}
-- Prettier: ${config.frontend.prettier ? "Yes" : "No"}
-- CSS Framework: ${config.frontend.cssFramework}
-- UI Components: ${config.frontend.uiComponents}
-- Testing: ${config.frontend.testing}
+- Framework: ${config.frontend?.framework}
+- Package Manager: ${config.frontend?.packageManager}
+- TypeScript: ${config.frontend?.typescript ? "Yes" : "No"}
+- ESLint: ${config.frontend?.eslint ? "Yes" : "No"}
+- Prettier: ${config.frontend?.prettier ? "Yes" : "No"}
+- CSS Framework: ${config.frontend?.cssFramework}
+- UI Components: ${config.frontend?.uiComponents}
+- Testing: ${config.frontend?.testing}
 `;
     await writeFile(`${projectPath}/README.md`, content);
     logSuccess("README.md created");
 }
-async function generateSharedPackage(packagePath, config) {
-    const content = JSON.stringify({
-        name: "@phos/shared",
-        version: "0.1.0",
-        type: "module",
-        main: "./dist/index.js",
-        types: "./dist/index.d.ts",
-        exports: {
-            ".": {
-                types: "./dist/index.d.ts",
-                import: "./dist/index.js",
-            },
-        },
-        scripts: {
-            build: "tsc",
-            dev: "tsc --watch",
-        },
-        devDependencies: {
-            typescript: "^5.3.0",
-        },
-    }, null, 2);
-    await writeFile(`${packagePath}/package.json`, content);
-    const tsConfigContent = JSON.stringify({
-        extends: "../../tsconfig.json",
-        compilerOptions: {
-            composite: true,
-            outDir: "./dist",
-            rootDir: "./src",
-        },
-        include: ["src/**/*"],
-    }, null, 2);
-    await writeFile(`${packagePath}/tsconfig.json`, tsConfigContent);
-    await createDirectory(`${packagePath}/src`);
-    await writeFile(`${packagePath}/src/index.ts`, `export function hello(name: string): string {\n  return \`Hello, \${name}!\`;\n}\n`);
-    logSuccess("Shared package created");
+async function generateAgentsMd(projectPath, config) {
+    const projectName = config.projectName;
+    const capitalizedProjectName = capitalize(config.projectName);
+    const backendName = `${capitalizedProjectName}_Backend`;
+    const frontendName = `${capitalizedProjectName}_Frontend`;
+    const content = `# AGENTS Guidelines for This Repository
+
+## Project Name: ${projectName}
+
+This project was generated by [Phos](https://github.com/yourusername/phos).
+
+### Core Features:
+
+1. **${config.frontend?.framework || "Next.js"} Frontend** - Modern web framework
+2. **${config.backend?.framework || "Elysia"} Backend** - Server-side application
+3. **Monorepo Structure** - Organized workspace with separate backend and frontend
+
+### Technology Stack:
+
+- **Frontend**: ${config.frontend?.framework || "Next.js"}
+- **Backend**: ${config.backend?.framework || "Elysia"}
+- **Package Manager**: ${config.frontend?.packageManager || "npm"}
+- **TypeScript**: ${config.frontend?.typescript ? "Enabled" : "Disabled"}
+- **ESLint**: ${config.frontend?.eslint ? "Enabled" : "Disabled"}
+- **Prettier**: ${config.frontend?.prettier ? "Enabled" : "Disabled"}
+- **CSS Framework**: ${config.frontend?.cssFramework || "Tailwind CSS"}
+
+## 1. Development Workflow
+
+### Project Structure
+
+\`\`\`
+${projectName}/
+├── ${backendName}/    # Backend application
+├── ${frontendName}/   # Frontend application
+├── Docs/                             # Documentation
+├── AGENTS.md                         # This file
+├── LICENSE                           # License
+├── README.md                         # Project README
+└── env.example                       # Environment variables template
+\`\`\`
+
+### Running the Project
+
+#### Backend
+\`\`\`bash
+cd ${backendName}
+${config.backend?.packageManager || "npm"} install
+${config.backend?.packageManager || "npm"} run dev
+\`\`\`
+
+#### Frontend
+\`\`\`bash
+cd ${frontendName}
+${config.frontend?.packageManager || "npm"} install
+${config.frontend?.packageManager || "npm"} run dev
+\`\`\`
+
+## 2. Architecture
+
+### Backend
+- Framework: ${config.backend?.framework || "Elysia"}
+- Language: ${config.backend?.framework === "fastapi" ? "Python" : "TypeScript"}
+- Package Manager: ${config.backend?.packageManager || "npm"}
+
+### Frontend
+- Framework: ${config.frontend?.framework || "Next.js"}
+- Language: JavaScript/TypeScript
+- Package Manager: ${config.frontend?.packageManager || "npm"}
+- CSS Framework: ${config.frontend?.cssFramework || "Tailwind CSS"}
+- UI Components: ${config.frontend?.uiComponents || "None"}
+
+## 3. Coding Conventions
+
+### ${config.frontend?.framework || "Next.js"}
+
+${config.frontend?.framework === "astro"
+        ? `
+- Use Astro component syntax
+- Follow Astro best practices
+- Use TypeScript if enabled
+`
+        : config.frontend?.framework === "svelte"
+            ? `
+- Use Svelte component syntax
+- Follow Svelte best practices
+- Use TypeScript if enabled
+`
+            : `
+- Use Next.js conventions
+- Use App Router for new features
+- Use TypeScript if enabled
+`}
+
+### ${config.backend?.framework || "Elysia"}
+
+${config.backend?.framework === "elysia"
+        ? `
+- Use Elysia patterns
+- Follow Bun conventions
+- Use TypeScript if enabled
+`
+        : `
+- Use FastAPI patterns
+- Follow Python PEP 8 guidelines
+- Use type hints
+`}
+
+## 4. Available Scripts
+
+### Root Level
+- \`${config.frontend?.packageManager || "npm"} run dev\` - Start both dev servers
+- \`${config.frontend?.packageManager || "npm"} run build\` - Build both apps
+- \`${config.frontend?.packageManager || "npm"} run lint\` - Run ESLint
+- \`${config.frontend?.packageManager || "npm"} run format\` - Format code
+
+## 5. Documentation
+
+Check the \`Docs/\` folder for:
+- Feature documentation
+- Database setup scripts
+- Schema documentation
+- SQL queries
+`;
+    await writeFile(`${projectPath}/AGENTS.md`, content);
+    logSuccess("AGENTS.md created");
+}
+async function generateLicense(projectPath, config) {
+    const content = `MIT License
+
+Copyright (c) ${new Date().getFullYear()} ${config.projectName}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+    await writeFile(`${projectPath}/LICENSE`, content);
+    logSuccess("LICENSE created");
+}
+async function generateEnvExample(projectPath) {
+    const content = `# Database
+DB_HOST=localhost
+DB_NAME=your_db_name
+DB_USER=postgres
+DB_PASSWORD=postgres
+DB_PORT=5433
+
+# URLs
+FRONTEND_BASE_URL=http://localhost:4200
+BACKEND_BASE_URL=http://localhost:4100
+
+# JWT Configuration for rest API
+JWT_SECRET=your-super-secret-jwt-key-change-in-production
+JWT_EXPIRES_IN=60m
+
+# Encryption
+ENCRYPTION_SALT=your-super-secret-salt-change-in-production
+
+# API Keys
+X_API_KEY=1234
+`;
+    await writeFile(`${projectPath}/env.example`, content);
+    logSuccess("env.example created");
+}
+async function generateSchemaDocs(docsPath, config) {
+    const projectName = config.projectName;
+    const content = `# ${projectName} Database Schema
+
+## Table of Contents
+
+- [${projectName} Database Schema](#${projectName.toLowerCase()}-database-schema)
+  - [Table of Contents](#table-of-contents)
+  - [Overview](#overview)
+  - [Core Entities](#core-entities)
+    - [Entity Name](#entity-name)
+  - [Entity Relationships](#entity-relationships)
+  - [SQL Schema](#sql-schema)
+    - [Create Tables](#create-tables)
+  - [Sample Data](#sample-data)
+  - [Data Types Notes](#data-types-notes)
+  - [Migration Notes](#migration-notes)
+
+---
+
+## Overview
+
+This document describes the complete database schema for ${projectName}, including all entities, relationships, and sample data.
+
+---
+
+## Core Entities
+
+### Entity Name
+
+| Column      | Type     | Nullable | Description                        |
+| ----------- | -------- | -------- | ---------------------------------- |
+| id          | int      | No       | Primary key, auto-incremented ID   |
+| uuid        | string   | No       | Unique identifier                  |
+| column_name | str      | Yes/No   | Description of column              |
+| created_at  | datetime | No       | Record creation timestamp (UTC)    |
+| updated_at  | datetime | Yes      | Record last update timestamp (UTC) |
+
+---
+
+## Entity Relationships
+
+\`\`\`
+table1 (1) ──── (many) table2
+table3 (many) ──── (1) table4
+\`\`\`
+
+---
+
+## SQL Schema
+
+### Create Tables
+
+For PostgreSQL deployment, use the following schema:
+
+\`\`\`sql
+-- Drop tables if they exist (for clean setup)
+DROP TABLE IF EXISTS child_table;
+DROP TABLE IF EXISTS parent_table;
+
+-- Parent table
+CREATE TABLE parent_table (
+    id SERIAL PRIMARY KEY,
+    uuid TEXT NOT NULL UNIQUE,
+    name TEXT NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP
+);
+
+-- Child table
+CREATE TABLE child_table (
+    id TEXT PRIMARY KEY,
+    parent_id TEXT NOT NULL,
+    content TEXT NOT NULL,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (parent_id) REFERENCES parent_table(uuid)
+);
+
+-- Add foreign key constraints if needed
+ALTER TABLE child_table ADD CONSTRAINT fk_child_parent FOREIGN KEY (parent_id) REFERENCES parent_table(uuid);
+
+-- Performance indexes
+CREATE INDEX idx_parent_table_uuid ON parent_table(uuid);
+CREATE INDEX idx_child_table_parent_id ON child_table(parent_id);
+CREATE INDEX idx_child_table_created_at ON child_table(created_at);
+\`\`\`
+
+---
+
+## Sample Data
+
+\`\`\`sql
+-- Insert sample data for parent table
+INSERT INTO parent_table (uuid, name, description, created_at)
+VALUES ('550e8400-e29b-41d4-a716-446655440000', 'Sample Name', 'Sample description', CURRENT_TIMESTAMP);
+
+-- Insert sample data for child table
+INSERT INTO child_table (id, parent_id, content, created_at, updated_at)
+VALUES ('6ba7b810-9dad-11d1-80b4-00c04fd430c8', '550e8400-e29b-41d4-a716-446655440000', 'Sample content', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
+\`\`\`
+
+---
+
+## Data Types Notes
+
+- **UUID**: Stored as TEXT for simplicity
+- **Arrays**: Stored as native PostgreSQL arrays (e.g., text[])
+- **JSON**: Stored as JSONB for PostgreSQL (or TEXT for SQLite)
+- **Boolean**: Stored as BOOLEAN for PostgreSQL (or INTEGER 0/1 for SQLite)
+- **Decimal**: Stored as DECIMAL for precision calculations
+- **Datetime**: Stored as TIMESTAMP with CURRENT_TIMESTAMP defaults
+
+---
+
+## Migration Notes
+
+When deploying to production:
+
+1. Consider using PostgreSQL for better JSON support and performance
+2. Add proper UUID generation in application code
+3. Implement database migrations for schema changes
+4. Add database constraints and triggers as needed
+5. Run \`ALTER TABLE\` statements for schema additions
+6. Test migrations on staging environment before production
+`;
+    await writeFile(`${docsPath}/Schema.md`, content);
+    logSuccess("Schema.md created");
 }
 //# sourceMappingURL=monorepo.js.map