@sundaysf/cli-v2 1.0.1 → 1.0.3

package/dist/templates/db-sql/.claude/agents/sundays-backend-builder.md

@@ -1,70 +1,70 @@
----
-name: sundays-backend-builder
-description: Use this agent when you need to create or modify backend components in a Sundays Framework project. This includes creating new controllers, routers, services, implementing CRUD operations, or ensuring existing code follows the framework's strict architectural patterns. <example>Context: User needs to create a new API endpoint for managing products. user: 'I need to create a products API with full CRUD operations' assistant: 'I'll use the sundays-backend-builder agent to create the products API following the Sundays Framework standards' <commentary>Since the user needs to create backend components following Sundays Framework patterns, use the sundays-backend-builder agent to ensure proper structure and implementation.</commentary></example> <example>Context: User wants to add pagination to an existing controller. user: 'Add pagination to the orders controller getAll method' assistant: 'Let me use the sundays-backend-builder agent to implement proper pagination using IBasePaginator' <commentary>The user needs to modify a controller to follow Sundays Framework pagination patterns, so the sundays-backend-builder agent should be used.</commentary></example> <example>Context: User needs to fix a controller that doesn't follow standards. user: 'The customer controller isn't following our standards, can you fix it?' assistant: 'I'll use the sundays-backend-builder agent to refactor the customer controller to match our Sundays Framework standards' <commentary>Since the controller needs to be refactored to follow framework standards, the sundays-backend-builder agent is appropriate.</commentary></example>
-model: sonnet
-color: blue
----
-
-You are an expert backend developer specializing in the Sundays Framework architecture. Your mission is to build and maintain backend components that strictly adhere to the framework's established patterns and conventions.
-
-**Core Responsibilities:**
-
-1. **Component Creation**: When creating new backend components, ALWAYS use `npm run create:controller` to scaffold the initial structure. This ensures consistency across the codebase.
-
-2. **Strict Structure Adherence**: You must follow these exact directory structures without deviation:
-   - Routes: `routes/<name>/<name>.router.ts`
-   - Controllers: `controllers/<name>/<name>.controller.ts`
-   - Services: `services/<name>/<name>.service.ts`
-   - DTOs: `dto/input/<entity>/<entity>.create.dto.ts` and `dto/input/<entity>/<entity>.update.dto.ts`
-
-3. **Interface Implementation**:
-   - ALL controllers MUST implement `IBaseController`
-   - ALL paginated getAll methods MUST use `IDataPaginator` (not IBasePaginator)
-   - ALWAYS use `paginationHelper` from `@sundaysf/utils` to extract page and limit from request
-
-4. **DAO/Service Pattern**:
-   - Initialize DAOs as private class members: `private _<entity>DAO: <Entity>DAO = new <Entity>DAO()`
-   - Follow the same pattern for services when applicable
-   - Use underscore prefix for private members
-
-5. **Method Implementation Standards**:
-   - **getAll**: Return paginated results using `IDataPaginator`, extract pagination with `paginationHelper(req)`
-   - **getByUuid**: Use UUID in params, convert to ID for DAO operations
-   - **create**: Validate with DTOs, generate UUID with `uuidv4()` in controller
-   - **update**: Get entity by UUID first to find ID, then update using DAO
-   - **delete**: Get entity by UUID first to find ID, then delete using DAO
-
-6. **Response Format**: ALL responses must follow:
-   ```json
-   {
-     "success": boolean,
-     "data": {...} // or "message": string
-   }
-   ```
-   Note: `IDataPaginator` already includes these fields, so don't double-wrap paginated responses.
-
-7. **Router Binding**: ALWAYS use `.bind(this._<entity>Controller)` when assigning controller methods to routes to maintain proper context.
-
-8. **Quality Checks**:
-   - Verify all imports are correct and from the right packages
-   - Ensure TypeScript types are properly defined
-   - Check that error handling uses `next(err)` pattern
-   - Validate that DTOs properly sanitize input data
-   - Confirm UUID generation happens in controller, not DTO or client-side
-
-**Working Process**:
-
-1. When creating new components, first run `npm run create:controller` command
-2. Analyze existing similar components in the project for pattern reference
-3. Implement following the exact structure found in existing code
-4. Ensure all naming conventions match (camelCase for variables, PascalCase for classes)
-5. Test that all CRUD operations follow the established patterns
-
-**Critical Rules**:
-- NEVER deviate from the established folder structure
-- NEVER create custom patterns - follow existing examples exactly
-- ALWAYS check existing implementations before creating new ones
-- ALWAYS maintain consistency with the project's CLAUDE.md guidelines
-- Be extremely meticulous about structure - it must be perfect
-
-Your code must be production-ready, following all Sundays Framework conventions to the letter. Every component you create or modify should seamlessly integrate with the existing architecture without requiring any adjustments to other parts of the system.
+---
+name: sundays-backend-builder
+description: Use this agent when you need to create or modify backend components in a Sundays Framework project. This includes creating new controllers, routers, services, implementing CRUD operations, or ensuring existing code follows the framework's strict architectural patterns. <example>Context: User needs to create a new API endpoint for managing products. user: 'I need to create a products API with full CRUD operations' assistant: 'I'll use the sundays-backend-builder agent to create the products API following the Sundays Framework standards' <commentary>Since the user needs to create backend components following Sundays Framework patterns, use the sundays-backend-builder agent to ensure proper structure and implementation.</commentary></example> <example>Context: User wants to add pagination to an existing controller. user: 'Add pagination to the orders controller getAll method' assistant: 'Let me use the sundays-backend-builder agent to implement proper pagination using IBasePaginator' <commentary>The user needs to modify a controller to follow Sundays Framework pagination patterns, so the sundays-backend-builder agent should be used.</commentary></example> <example>Context: User needs to fix a controller that doesn't follow standards. user: 'The customer controller isn't following our standards, can you fix it?' assistant: 'I'll use the sundays-backend-builder agent to refactor the customer controller to match our Sundays Framework standards' <commentary>Since the controller needs to be refactored to follow framework standards, the sundays-backend-builder agent is appropriate.</commentary></example>
+model: sonnet
+color: blue
+---
+
+You are an expert backend developer specializing in the Sundays Framework architecture. Your mission is to build and maintain backend components that strictly adhere to the framework's established patterns and conventions.
+
+**Core Responsibilities:**
+
+1. **Component Creation**: When creating new backend components, ALWAYS use `npm run create:controller` to scaffold the initial structure. This ensures consistency across the codebase.
+
+2. **Strict Structure Adherence**: You must follow these exact directory structures without deviation:
+   - Routes: `routes/<name>/<name>.router.ts`
+   - Controllers: `controllers/<name>/<name>.controller.ts`
+   - Services: `services/<name>/<name>.service.ts`
+   - DTOs: `dto/input/<entity>/<entity>.create.dto.ts` and `dto/input/<entity>/<entity>.update.dto.ts`
+
+3. **Interface Implementation**:
+   - ALL controllers MUST implement `IBaseController`
+   - ALL paginated getAll methods MUST use `IDataPaginator` (not IBasePaginator)
+   - ALWAYS use `paginationHelper` from `@sundaysf/utils` to extract page and limit from request
+
+4. **DAO/Service Pattern**:
+   - Initialize DAOs as private class members: `private _<entity>DAO: <Entity>DAO = new <Entity>DAO()`
+   - Follow the same pattern for services when applicable
+   - Use underscore prefix for private members
+
+5. **Method Implementation Standards**:
+   - **getAll**: Return paginated results using `IDataPaginator`, extract pagination with `paginationHelper(req)`
+   - **getByUuid**: Use UUID in params, convert to ID for DAO operations
+   - **create**: Validate with DTOs, generate UUID with `uuidv4()` in controller
+   - **update**: Get entity by UUID first to find ID, then update using DAO
+   - **delete**: Get entity by UUID first to find ID, then delete using DAO
+
+6. **Response Format**: ALL responses must follow:
+   ```json
+   {
+     "success": boolean,
+     "data": {...} // or "message": string
+   }
+   ```
+   Note: `IDataPaginator` already includes these fields, so don't double-wrap paginated responses.
+
+7. **Router Binding**: ALWAYS use `.bind(this._<entity>Controller)` when assigning controller methods to routes to maintain proper context.
+
+8. **Quality Checks**:
+   - Verify all imports are correct and from the right packages
+   - Ensure TypeScript types are properly defined
+   - Check that error handling uses `next(err)` pattern
+   - Validate that DTOs properly sanitize input data
+   - Confirm UUID generation happens in controller, not DTO or client-side
+
+**Working Process**:
+
+1. When creating new components, first run `npm run create:controller` command
+2. Analyze existing similar components in the project for pattern reference
+3. Implement following the exact structure found in existing code
+4. Ensure all naming conventions match (camelCase for variables, PascalCase for classes)
+5. Test that all CRUD operations follow the established patterns
+
+**Critical Rules**:
+- NEVER deviate from the established folder structure
+- NEVER create custom patterns - follow existing examples exactly
+- ALWAYS check existing implementations before creating new ones
+- ALWAYS maintain consistency with the project's CLAUDE.md guidelines
+- Be extremely meticulous about structure - it must be perfect
+
+Your code must be production-ready, following all Sundays Framework conventions to the letter. Every component you create or modify should seamlessly integrate with the existing architecture without requiring any adjustments to other parts of the system.

package/dist/templates/db-sql/.claude/settings.local.json

@@ -1,11 +1,11 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm run migrate:create:*)",
-      "Bash(npm run migrate:deploy:*)",
-      "Bash(npm run build:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run migrate:create:*)",
+      "Bash(npm run migrate:deploy:*)",
+      "Bash(npm run build:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
 }

package/dist/templates/db-sql/.env.example

@@ -1,8 +1,8 @@
-SQL_HOST=localhost
-SQL_PORT=5432
-SQL_USER=postgres
-SQL_PASSWORD=
-SQL_DB_NAME=mydb
-
-# Set to 'false' to disable SSL certificate verification (not recommended for production)
-# SQL_REJECT_UNAUTHORIZED=false
+SQL_HOST=localhost
+SQL_PORT=5432
+SQL_USER=postgres
+SQL_PASSWORD=
+SQL_DB_NAME=mydb
+
+# Set to 'false' to disable SSL certificate verification (not recommended for production)
+# SQL_REJECT_UNAUTHORIZED=false

package/dist/templates/db-sql/CLAUDE.md

@@ -1,106 +1,106 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## File Structure Conventions
-
-**Interfaces**: All interfaces should be placed in `src/interfaces/{entity}/{entity}.interfaces.ts`
-- Example: `src/interfaces/company/company.interfaces.ts`
-
-**DAOs**: All DAO classes should be placed in `src/dao/{entity}/{entity}.dao.ts`
-- Example: `src/dao/company/company.dao.ts`
-
-This convention maintains consistency with the existing structure (e.g., sundays-package-version).
-
-## Common Development Commands
-
-**Build**: `npm run build` - Compiles TypeScript to JavaScript in the `dist` directory
-
-**Format**: `npm run format` - Formats code using Prettier
-
-**Test**: `npm test` - Runs Jest tests
-
-**Clean Build**: `npm run clean` - Removes dist, formats code, and rebuilds
-
-**Database Migrations**:
-- Create migration: `npm run migrate:create` - Creates a new migration file in TypeScript
-- Run migrations: `npm run migrate:deploy` - Applies pending migrations
-
-**Database Seeds**:
-- Create seed: `npm run seed:create` - Creates a new seed file in TypeScript
-- Run seeds: `npm run seed:run` - Executes seed files
-
-## Architecture Overview
-
-This is a Knex.js database module (`@dupin/knex-v2`) that provides a PostgreSQL connection manager and data access layer.
-
-**Key Components**:
-
-1. **KnexManager** (`src/KnexConnection.ts`): Singleton pattern for managing database connections
-   - Handles connection pooling with configurable min/max connections
-   - Uses environment variables for database configuration (SQL_HOST, SQL_USER, SQL_PASSWORD, SQL_DB_NAME, SQL_PORT)
-   - Supports SSL connections with `rejectUnauthorized: false`
-
-2. **DAO Pattern**: Data Access Objects implement the `IBaseDAO<T>` interface
-   - Example: `SundaysPackageVersionDAO` provides CRUD operations
-   - All DAOs use the shared KnexManager connection
-   - Includes pagination support via `IDataPaginator`
-
-3. **Database Configuration** (`knexfile.ts`): Supports development, staging, and production environments
-   - All environments use PostgreSQL client
-   - Configuration reads from environment variables
-   - Migration table: `knex_migrations`
-
-4. **Type System**: 
-   - Interfaces in `src/interfaces/` define data models
-   - Common types in `src/d.types.ts` (IBaseDAO, IDataPaginator)
-   - All exports centralized in `src/index.ts`
-
-**Environment Requirements**:
-- SQL_HOST: PostgreSQL host
-- SQL_USER: Database user
-- SQL_PASSWORD: Database password
-- SQL_DB_NAME: Database name
-- SQL_PORT: Database port (defaults to 5432)
-
-## DAO Implementation Patterns
-
-### Join Pattern for Related Entities
-
-When implementing DAOs that need to include related entities, use PostgreSQL's `to_jsonb()` function for clean and efficient joins:
-
-```typescript
-async getById(id: number): Promise<IEntity | null> {
-  const result = await this._knex("entity as e")
-    .leftJoin("related as r", "e.relatedId", "r.id")
-    .select("e.*", this._knex.raw("to_jsonb(r.*) as related"))
-    .where("e.id", id)
-    .first();
-  return result || null;
-}
-```
-
-**Key Points:**
-- Use table aliases for clarity (`as e`, `as r`)
-- `to_jsonb(r.*)` automatically converts the joined row to JSON
-- Returns `null` if no related entity is found (with leftJoin)
-- No manual mapping required - PostgreSQL handles the conversion
-
-**For paginated results:**
-```typescript
-const query = this._knex("entity as e")
-  .leftJoin("related as r", "e.relatedId", "r.id")
-  .select("e.*", this._knex.raw("to_jsonb(r.*) as related"));
-
-const data = await query
-  .clone()
-  .limit(limit)
-  .offset(offset)
-  .orderBy("e.id", "desc");
-```
-
-## Known Issues and Solutions
-
-**Migration Error "require is not defined"**: The knexfile.ts uses ES module syntax. If you encounter this error, ensure the file uses:
-- `import dotenv from "dotenv"` instead of `require("dotenv")`
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## File Structure Conventions
+
+**Interfaces**: All interfaces should be placed in `src/interfaces/{entity}/{entity}.interfaces.ts`
+- Example: `src/interfaces/company/company.interfaces.ts`
+
+**DAOs**: All DAO classes should be placed in `src/dao/{entity}/{entity}.dao.ts`
+- Example: `src/dao/company/company.dao.ts`
+
+This convention maintains consistency with the existing structure (e.g., sundays-package-version).
+
+## Common Development Commands
+
+**Build**: `npm run build` - Compiles TypeScript to JavaScript in the `dist` directory
+
+**Format**: `npm run format` - Formats code using Prettier
+
+**Test**: `npm test` - Runs Jest tests
+
+**Clean Build**: `npm run clean` - Removes dist, formats code, and rebuilds
+
+**Database Migrations**:
+- Create migration: `npm run migrate:create` - Creates a new migration file in TypeScript
+- Run migrations: `npm run migrate:deploy` - Applies pending migrations
+
+**Database Seeds**:
+- Create seed: `npm run seed:create` - Creates a new seed file in TypeScript
+- Run seeds: `npm run seed:run` - Executes seed files
+
+## Architecture Overview
+
+This is a Knex.js database module (`@dupin/knex-v2`) that provides a PostgreSQL connection manager and data access layer.
+
+**Key Components**:
+
+1. **KnexManager** (`src/KnexConnection.ts`): Singleton pattern for managing database connections
+   - Handles connection pooling with configurable min/max connections
+   - Uses environment variables for database configuration (SQL_HOST, SQL_USER, SQL_PASSWORD, SQL_DB_NAME, SQL_PORT)
+   - Supports SSL connections with `rejectUnauthorized: false`
+
+2. **DAO Pattern**: Data Access Objects implement the `IBaseDAO<T>` interface
+   - Example: `SundaysPackageVersionDAO` provides CRUD operations
+   - All DAOs use the shared KnexManager connection
+   - Includes pagination support via `IDataPaginator`
+
+3. **Database Configuration** (`knexfile.ts`): Supports development, staging, and production environments
+   - All environments use PostgreSQL client
+   - Configuration reads from environment variables
+   - Migration table: `knex_migrations`
+
+4. **Type System**: 
+   - Interfaces in `src/interfaces/` define data models
+   - Common types in `src/d.types.ts` (IBaseDAO, IDataPaginator)
+   - All exports centralized in `src/index.ts`
+
+**Environment Requirements**:
+- SQL_HOST: PostgreSQL host
+- SQL_USER: Database user
+- SQL_PASSWORD: Database password
+- SQL_DB_NAME: Database name
+- SQL_PORT: Database port (defaults to 5432)
+
+## DAO Implementation Patterns
+
+### Join Pattern for Related Entities
+
+When implementing DAOs that need to include related entities, use PostgreSQL's `to_jsonb()` function for clean and efficient joins:
+
+```typescript
+async getById(id: number): Promise<IEntity | null> {
+  const result = await this._knex("entity as e")
+    .leftJoin("related as r", "e.relatedId", "r.id")
+    .select("e.*", this._knex.raw("to_jsonb(r.*) as related"))
+    .where("e.id", id)
+    .first();
+  return result || null;
+}
+```
+
+**Key Points:**
+- Use table aliases for clarity (`as e`, `as r`)
+- `to_jsonb(r.*)` automatically converts the joined row to JSON
+- Returns `null` if no related entity is found (with leftJoin)
+- No manual mapping required - PostgreSQL handles the conversion
+
+**For paginated results:**
+```typescript
+const query = this._knex("entity as e")
+  .leftJoin("related as r", "e.relatedId", "r.id")
+  .select("e.*", this._knex.raw("to_jsonb(r.*) as related"));
+
+const data = await query
+  .clone()
+  .limit(limit)
+  .offset(offset)
+  .orderBy("e.id", "desc");
+```
+
+## Known Issues and Solutions
+
+**Migration Error "require is not defined"**: The knexfile.ts uses ES module syntax. If you encounter this error, ensure the file uses:
+- `import dotenv from "dotenv"` instead of `require("dotenv")`
 - `export default config` instead of `module.exports = config`

package/dist/templates/db-sql/knexfile.ts

@@ -1,33 +1,33 @@
-import type { Knex } from "knex";
-import dotenv from "dotenv";
-dotenv.config();
-
-const isLocalhost = process.env.SQL_HOST === 'localhost' || process.env.SQL_HOST === '127.0.0.1';
-const rejectUnauthorized = process.env.SQL_REJECT_UNAUTHORIZED !== 'false';
-
-const sharedConfig: Knex.Config = {
-  client: "postgresql",
-  connection: {
-    database: process.env.SQL_DB_NAME,
-    user: process.env.SQL_USER,
-    password: process.env.SQL_PASSWORD,
-    host: process.env.SQL_HOST,
-    port: process.env.SQL_PORT ? +process.env.SQL_PORT : 5432,
-    ssl: isLocalhost ? false : { rejectUnauthorized },
-  },
-  pool: {
-    min: 2,
-    max: 10,
-  },
-  migrations: {
-    tableName: "knex_migrations",
-  },
-};
-
-const config: { [key: string]: Knex.Config } = {
-  development: sharedConfig,
-  staging: sharedConfig,
-  production: sharedConfig,
-};
-
-export default config;
+import type { Knex } from "knex";
+import dotenv from "dotenv";
+dotenv.config();
+
+const isLocalhost = process.env.SQL_HOST === 'localhost' || process.env.SQL_HOST === '127.0.0.1';
+const rejectUnauthorized = process.env.SQL_REJECT_UNAUTHORIZED !== 'false';
+
+const sharedConfig: Knex.Config = {
+  client: "postgresql",
+  connection: {
+    database: process.env.SQL_DB_NAME,
+    user: process.env.SQL_USER,
+    password: process.env.SQL_PASSWORD,
+    host: process.env.SQL_HOST,
+    port: process.env.SQL_PORT ? +process.env.SQL_PORT : 5432,
+    ssl: isLocalhost ? false : { rejectUnauthorized },
+  },
+  pool: {
+    min: 2,
+    max: 10,
+  },
+  migrations: {
+    tableName: "knex_migrations",
+  },
+};
+
+const config: { [key: string]: Knex.Config } = {
+  development: sharedConfig,
+  staging: sharedConfig,
+  production: sharedConfig,
+};
+
+export default config;

package/dist/templates/db-sql/migrations/001_create_sundays_package_version.ts

@@ -1,13 +1,13 @@
-import type { Knex } from "knex";
-
-export async function up(knex: Knex): Promise<void> {
-  await knex.schema.createTable("sundays_package_version", (table) => {
-    table.increments("id").primary();
-    table.string("versionName").notNullable();
-    table.timestamps(true, true); // created_at, updated_at
-  });
-}
-
-export async function down(knex: Knex): Promise<void> {
-  await knex.schema.dropTableIfExists("sundays_package_version");
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable("sundays_package_version", (table) => {
+    table.increments("id").primary();
+    table.string("versionName").notNullable();
+    table.timestamps(true, true); // created_at, updated_at
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists("sundays_package_version");
 }

package/dist/templates/db-sql/seeds/001_sundays_package_version_seed.ts

@@ -1,11 +1,11 @@
-import { Knex } from "knex";
-
-export async function seed(knex: Knex): Promise<void> {
-    // Deletes ALL existing entries
-    await knex("sundays_package_version").del();
-
-    // Inserts seed entries
-    await knex("sundays_package_version").insert([
-        { versionName: "1.0.0" }
-    ]);
+import { Knex } from "knex";
+
+export async function seed(knex: Knex): Promise<void> {
+    // Deletes ALL existing entries
+    await knex("sundays_package_version").del();
+
+    // Inserts seed entries
+    await knex("sundays_package_version").insert([
+        { versionName: "1.0.0" }
+    ]);
 }