@aicgen/aicgen 1.0.0-beta.1

package/data/architecture/solid/principles.md

@@ -0,0 +1,187 @@
+# SOLID Principles
+
+## Single Responsibility Principle (SRP)
+
+A class should have only one reason to change.
+
+**Bad:**
+```typescript
+class UserService {
+  createUser(data: UserData): User { /* ... */ }
+  sendWelcomeEmail(user: User): void { /* ... */ }
+  generateReport(users: User[]): Report { /* ... */ }
+}
+```
+
+**Good:**
+```typescript
+class UserService {
+  createUser(data: UserData): User { /* ... */ }
+}
+
+class EmailService {
+  sendWelcomeEmail(user: User): void { /* ... */ }
+}
+
+class ReportService {
+  generateUserReport(users: User[]): Report { /* ... */ }
+}
+```
+
+## Open/Closed Principle (OCP)
+
+Open for extension, closed for modification.
+
+**Bad:**
+```typescript
+class PaymentProcessor {
+  process(payment: Payment): void {
+    if (payment.type === 'credit') { /* credit logic */ }
+    else if (payment.type === 'paypal') { /* paypal logic */ }
+    // Must modify class to add new payment types
+  }
+}
+```
+
+**Good:**
+```typescript
+interface PaymentHandler {
+  process(payment: Payment): void;
+}
+
+class CreditCardHandler implements PaymentHandler {
+  process(payment: Payment): void { /* credit logic */ }
+}
+
+class PayPalHandler implements PaymentHandler {
+  process(payment: Payment): void { /* paypal logic */ }
+}
+
+class PaymentProcessor {
+  constructor(private handlers: Map<string, PaymentHandler>) {}
+
+  process(payment: Payment): void {
+    this.handlers.get(payment.type)?.process(payment);
+  }
+}
+```
+
+## Liskov Substitution Principle (LSP)
+
+Subtypes must be substitutable for their base types.
+
+**Bad:**
+```typescript
+class Bird {
+  fly(): void { /* flying logic */ }
+}
+
+class Penguin extends Bird {
+  fly(): void {
+    throw new Error("Penguins can't fly!"); // Violates LSP
+  }
+}
+```
+
+**Good:**
+```typescript
+interface Bird {
+  move(): void;
+}
+
+class FlyingBird implements Bird {
+  move(): void { this.fly(); }
+  private fly(): void { /* flying logic */ }
+}
+
+class Penguin implements Bird {
+  move(): void { this.swim(); }
+  private swim(): void { /* swimming logic */ }
+}
+```
+
+## Interface Segregation Principle (ISP)
+
+Clients shouldn't depend on interfaces they don't use.
+
+**Bad:**
+```typescript
+interface Worker {
+  work(): void;
+  eat(): void;
+  sleep(): void;
+}
+
+class Robot implements Worker {
+  work(): void { /* ... */ }
+  eat(): void { throw new Error("Robots don't eat"); }
+  sleep(): void { throw new Error("Robots don't sleep"); }
+}
+```
+
+**Good:**
+```typescript
+interface Workable {
+  work(): void;
+}
+
+interface Eatable {
+  eat(): void;
+}
+
+interface Sleepable {
+  sleep(): void;
+}
+
+class Human implements Workable, Eatable, Sleepable {
+  work(): void { /* ... */ }
+  eat(): void { /* ... */ }
+  sleep(): void { /* ... */ }
+}
+
+class Robot implements Workable {
+  work(): void { /* ... */ }
+}
+```
+
+## Dependency Inversion Principle (DIP)
+
+Depend on abstractions, not concretions.
+
+**Bad:**
+```typescript
+class UserService {
+  private database = new MySQLDatabase();
+
+  getUser(id: string): User {
+    return this.database.query(`SELECT * FROM users WHERE id = '${id}'`);
+  }
+}
+```
+
+**Good:**
+```typescript
+interface Database {
+  query(sql: string): any;
+}
+
+class UserService {
+  constructor(private database: Database) {}
+
+  getUser(id: string): User {
+    return this.database.query(`SELECT * FROM users WHERE id = '${id}'`);
+  }
+}
+
+// Can inject any database implementation
+const userService = new UserService(new MySQLDatabase());
+const testService = new UserService(new InMemoryDatabase());
+```
+
+## Best Practices
+
+- Apply SRP at class, method, and module levels
+- Use interfaces and dependency injection for flexibility
+- Prefer composition over inheritance
+- Design small, focused interfaces
+- Inject dependencies rather than creating them internally

package/data/database/basics.md

@@ -0,0 +1,365 @@
+# Database Basics
+
+## CRUD Operations
+
+CRUD = Create, Read, Update, Delete
+
+These are the four basic operations for working with data.
+
+## CREATE - Inserting Data
+
+### SQL
+
+```sql
+-- Insert single record
+INSERT INTO users (name, email)
+VALUES ('Alice', 'alice@example.com');
+
+-- Insert multiple records
+INSERT INTO users (name, email)
+VALUES
+  ('Bob', 'bob@example.com'),
+  ('Carol', 'carol@example.com');
+```
+
+### With Code
+
+```pseudocode
+// Using SQL directly
+database.execute(
+    "INSERT INTO users (name, email) VALUES (?, ?)",
+    ['Alice', 'alice@example.com']
+)
+
+// Using ORM/Model
+user = User.create({
+    name: 'Alice',
+    email: 'alice@example.com'
+})
+```
+
+## READ - Querying Data
+
+### Select All
+
+```sql
+-- Get all records
+SELECT * FROM users;
+
+-- Get specific columns
+SELECT id, name FROM users;
+```
+
+### Filter with WHERE
+
+```sql
+-- Find by ID
+SELECT * FROM users WHERE id = 123;
+
+-- Find by condition
+SELECT * FROM users WHERE age > 18;
+
+-- Multiple conditions
+SELECT * FROM users
+WHERE age > 18 AND status = 'active';
+```
+
+### With Code
+
+```pseudocode
+// Get all
+users = database.query("SELECT * FROM users")
+
+// Get by ID
+user = database.query(
+    "SELECT * FROM users WHERE id = ?",
+    [userId]
+)
+
+// Using ORM/Model
+user = User.findById(123)
+activeUsers = User.findAll({
+    where: { status: 'active' }
+})
+```
+
+## UPDATE - Modifying Data
+
+### SQL
+
+```sql
+-- Update single field
+UPDATE users
+SET email = 'newemail@example.com'
+WHERE id = 123;
+
+-- Update multiple fields
+UPDATE users
+SET name = 'Alice Smith',
+    email = 'alice.smith@example.com'
+WHERE id = 123;
+
+-- Update with condition
+UPDATE users
+SET status = 'inactive'
+WHERE last_login < '2023-01-01';
+```
+
+### With Code
+
+```pseudocode
+// Using SQL
+database.execute(
+    "UPDATE users SET email = ? WHERE id = ?",
+    ['newemail@example.com', 123]
+)
+
+// Using ORM/Model
+User.update(
+    { email: 'newemail@example.com' },
+    { where: { id: 123 } }
+)
+```
+
+## DELETE - Removing Data
+
+### SQL
+
+```sql
+-- Delete by ID
+DELETE FROM users WHERE id = 123;
+
+-- Delete with condition
+DELETE FROM users WHERE status = 'banned';
+
+-- Delete all (be careful!)
+DELETE FROM users;
+```
+
+### With Code
+
+```pseudocode
+// Using SQL
+database.execute("DELETE FROM users WHERE id = ?", [userId])
+
+// Using ORM/Model
+User.destroy({ where: { id: userId } })
+```
+
+## Sorting Results
+
+```sql
+-- Sort ascending (A-Z, 0-9)
+SELECT * FROM users ORDER BY name ASC;
+
+-- Sort descending (Z-A, 9-0)
+SELECT * FROM users ORDER BY created_at DESC;
+
+-- Sort by multiple columns
+SELECT * FROM users
+ORDER BY status ASC, name ASC;
+```
+
+## Limiting Results
+
+```sql
+-- Get first 10 records
+SELECT * FROM users LIMIT 10;
+
+-- Skip first 20, get next 10
+SELECT * FROM users LIMIT 10 OFFSET 20;
+
+-- Most recent 5 users
+SELECT * FROM users
+ORDER BY created_at DESC
+LIMIT 5;
+```
+
+## Counting Records
+
+```sql
+-- Count all users
+SELECT COUNT(*) FROM users;
+
+-- Count by condition
+SELECT COUNT(*) FROM users WHERE status = 'active';
+```
+
+## Common Patterns
+
+### Check if Record Exists
+
+```pseudocode
+user = database.query(
+    "SELECT * FROM users WHERE email = ?",
+    [email]
+)
+
+if user is empty:
+    print("User not found")
+else:
+    print("User exists")
+```
+
+### Get One or Return Default
+
+```pseudocode
+user = database.query(
+    "SELECT * FROM users WHERE id = ?",
+    [userId]
+)
+
+return user[0] or null
+```
+
+### Update if Exists, Create if Not
+
+```pseudocode
+existing = database.query(
+    "SELECT * FROM users WHERE email = ?",
+    [email]
+)
+
+if existing.length > 0:
+    // Update
+    database.execute(
+        "UPDATE users SET name = ? WHERE email = ?",
+        [name, email]
+    )
+else:
+    // Create
+    database.execute(
+        "INSERT INTO users (name, email) VALUES (?, ?)",
+        [name, email]
+    )
+```
+
+## Always Use Parameterized Queries
+
+```pseudocode
+// ❌ DANGEROUS: SQL Injection risk
+email = userInput
+database.query("SELECT * FROM users WHERE email = '" + email + "'")
+// If email = "'; DROP TABLE users; --"  😱
+
+// ✅ SAFE: Parameterized query
+database.query(
+    "SELECT * FROM users WHERE email = ?",
+    [email]
+)
+```
+
+## Basic WHERE Conditions
+
+```sql
+-- Equals
+WHERE status = 'active'
+
+-- Not equals
+WHERE status != 'banned'
+
+-- Greater than / Less than
+WHERE age > 18
+WHERE price < 100
+
+-- NULL checks
+WHERE deleted_at IS NULL
+WHERE email IS NOT NULL
+
+-- IN list
+WHERE status IN ('active', 'pending')
+
+-- Pattern matching
+WHERE email LIKE '%@gmail.com'
+
+-- Multiple conditions
+WHERE age > 18 AND status = 'active'
+WHERE role = 'admin' OR role = 'moderator'
+```
+
+## Basic Data Types
+
+```sql
+-- Text
+name VARCHAR(255)
+description TEXT
+
+-- Numbers
+age INTEGER
+price DECIMAL(10, 2)
+
+-- Dates
+created_at TIMESTAMP
+birth_date DATE
+
+-- Boolean
+is_active BOOLEAN
+```
+
+## Best Practices
+
+1. **Always use parameterized queries** - Prevents SQL injection
+2. **Add WHERE to UPDATE/DELETE** - Avoid accidentally modifying all records
+3. **Use LIMIT for testing** - Prevent fetching too much data
+4. **Check query results** - Handle empty results gracefully
+
+```pseudocode
+// ✅ Good practices
+async function getUser(id):
+    result = database.query(
+        "SELECT * FROM users WHERE id = ? LIMIT 1",
+        [id]
+    )
+
+    if result.length == 0:
+        return null  // Handle not found
+
+    return result[0]
+
+async function updateUserEmail(id, email):
+    // Validate first
+    if not email.contains('@'):
+        throw Error("Invalid email")
+
+    // Update with WHERE
+    database.execute(
+        "UPDATE users SET email = ? WHERE id = ?",
+        [email, id]
+    )
+```
+
+## Common Mistakes
+
+```pseudocode
+// ❌ String concatenation (SQL injection!)
+database.query("SELECT * FROM users WHERE id = " + userId)
+
+// ❌ No WHERE clause (updates everything!)
+database.query("UPDATE users SET status = 'banned'")
+
+// ❌ Not handling empty results
+user = result[0]  // Crashes if empty
+print(user.name)  // undefined error
+
+// ✅ Correct
+database.query("SELECT * FROM users WHERE id = ?", [userId])
+database.query("UPDATE users SET status = ? WHERE id = ?", ['banned', userId])
+user = result[0] or null
+if user is not null:
+    print(user.name)
+```
+
+## Testing Queries
+
+```pseudocode
+// Start with SELECT to verify
+usersToDelete = database.query(
+    "SELECT * FROM users WHERE status = ?",
+    ['inactive']
+)
+
+print("Would delete " + usersToDelete.length + " users")
+
+// If correct, change to DELETE
+// database.execute("DELETE FROM users WHERE status = ?", ['inactive'])
+```

package/data/database/design-patterns.md

@@ -0,0 +1,68 @@
+# Database Design Patterns
+
+## Schema Design
+
+### Normalization
+Reduce redundancy, maintain integrity.
+
+```sql
+-- Normalized
+CREATE TABLE users (id, name, email);
+CREATE TABLE orders (id, user_id REFERENCES users(id), total);
+CREATE TABLE order_items (id, order_id REFERENCES orders(id), product_id, qty);
+```
+
+### Denormalization
+Trade redundancy for read performance.
+
+```sql
+-- Denormalized for read performance
+CREATE TABLE order_summary (
+  id, user_id, user_name, user_email,
+  total, item_count, created_at
+);
+```
+
+## Common Patterns
+
+### Soft Deletes
+```sql
+ALTER TABLE users ADD COLUMN deleted_at TIMESTAMP NULL;
+
+-- Query active users
+SELECT * FROM users WHERE deleted_at IS NULL;
+```
+
+### Audit Trail
+```sql
+CREATE TABLE audit_log (
+  id SERIAL PRIMARY KEY,
+  table_name VARCHAR(100),
+  record_id VARCHAR(100),
+  action VARCHAR(20),
+  old_values JSONB,
+  new_values JSONB,
+  changed_by VARCHAR(100),
+  changed_at TIMESTAMP DEFAULT NOW()
+);
+```
+
+### Polymorphic Associations
+```sql
+CREATE TABLE comments (
+  id SERIAL PRIMARY KEY,
+  body TEXT,
+  commentable_type VARCHAR(50), -- 'post', 'image', 'video'
+  commentable_id INTEGER,
+  created_at TIMESTAMP
+);
+```
+
+## Best Practices
+
+- Use appropriate data types
+- Add indexes for frequently queried columns
+- Use foreign keys for referential integrity
+- Consider partitioning for large tables
+- Plan for schema migrations
+- Document schema decisions

package/data/database/index.md

@@ -0,0 +1,8 @@
+# Database Guidelines
+
+This directory contains database design and optimization patterns.
+
+## Available Chunks
+
+- **schema.md** - Naming conventions, data types, constraints, normalization
+- **indexing.md** - When to index, composite indexes, query optimization