@sundaysf/cli-v2 1.0.1 → 1.0.3

package/dist/templates/backend-embedded-db-sql/src/db/KnexConnection.ts

@@ -0,0 +1,74 @@
+import { knex, Knex } from 'knex';
+
+class KnexManager {
+  private static knexInstance: Knex<any, unknown[]> | null = null;
+
+  /**
+   * Open a new connection. Reuse the already existing one if there's any.
+   */
+  static async connect(
+    config?: Knex.Config,
+    connections?: number
+  ): Promise<Knex<any, unknown[]>> {
+    if (!KnexManager.knexInstance) {
+      const isLocalhost = process.env.SQL_HOST === 'localhost' || process.env.SQL_HOST === '127.0.0.1';
+      const rejectUnauthorized = process.env.SQL_REJECT_UNAUTHORIZED !== 'false';
+      const defaultConfig = {
+        client: 'pg',
+        connection: {
+          host: process.env.SQL_HOST,
+          user: process.env.SQL_USER,
+          password: process.env.SQL_PASSWORD,
+          database: process.env.SQL_DB_NAME,
+          port: Number(process.env.SQL_PORT) || 5432,
+          ssl: isLocalhost ? false : { rejectUnauthorized },
+        },
+        pool: {
+          min: 1,
+          max: connections || 15,
+          idleTimeoutMillis: 20000,
+          acquireTimeoutMillis: 30000,
+        },
+        migrations: {
+          tableName: 'knex_migrations',
+        },
+      };
+      KnexManager.knexInstance = knex(config || defaultConfig);
+      try {
+        await KnexManager.knexInstance.raw('SELECT 1');
+        console.info(`Knex connection established`);
+      } catch (error) {
+        console.error(`Failed to establish Knex connection:`, error);
+        KnexManager.knexInstance = null;
+        throw error;
+      }
+    }
+
+    return KnexManager.knexInstance;
+  }
+
+  /**
+   * Returns the active connection.
+   */
+  static getConnection(): Knex<any, unknown[]> {
+    if (!KnexManager.knexInstance) {
+      throw new Error(
+        'Knex connection has not been established. Call connect() first.'
+      );
+    }
+    return KnexManager.knexInstance;
+  }
+
+  /**
+   * Closes the connection and destroys the instance.
+   */
+  static async disconnect(): Promise<void> {
+    if (KnexManager.knexInstance) {
+      await KnexManager.knexInstance.destroy();
+      KnexManager.knexInstance = null;
+      console.info(`Knex connection closed`);
+    }
+  }
+}
+
+export default KnexManager;

package/dist/templates/backend-embedded-db-sql/src/db/d.types.ts

@@ -0,0 +1,18 @@
+export interface IBaseDAO<T> {
+    create(item: T): Promise<T>;
+    getById(id: number): Promise<T | null>;
+    getByUuid(uuid: string): Promise<T | null>;
+    update(id: number, item: Partial<T>): Promise<T | null>;
+    delete(id: number): Promise<boolean>;
+    getAll(page: number, limit: number): Promise<IDataPaginator<T>>;
+}
+
+export interface IDataPaginator<T> {
+    success: boolean;
+    data: T[];
+    page: number;
+    limit: number;
+    count: number;
+    totalCount: number;
+    totalPages: number;
+}

package/dist/templates/backend-embedded-db-sql/src/db/dao/sundays-package-version/sundays-package-version.dao.ts

@@ -0,0 +1,71 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { ISundaysPackageVersion } from "../../interfaces/sundays-package-version/sundays-package-version.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class SundaysPackageVersionDAO implements IBaseDAO<ISundaysPackageVersion> {
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    async create(item: ISundaysPackageVersion): Promise<ISundaysPackageVersion> {
+        const [created] = await this._knex("sundays_package_version").insert(item).returning("*");
+        return created;
+    }
+
+    async getById(id: number): Promise<ISundaysPackageVersion | null> {
+        const result = await this._knex("sundays_package_version")
+            .select("*")
+            .where("id", id)
+            .first();
+        return result || null;
+    }
+
+    async getByUuid(uuid: string): Promise<ISundaysPackageVersion | null> {
+        const result = await this._knex("sundays_package_version")
+            .select("*")
+            .where("uuid", uuid)
+            .first();
+        return result || null;
+    }
+
+    async update(id: number, item: Partial<ISundaysPackageVersion>): Promise<ISundaysPackageVersion | null> {
+        const [updated] = await this._knex("sundays_package_version")
+            .where({ id })
+            .update(item)
+            .returning("*");
+        return updated || null;
+    }
+
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("sundays_package_version").where({ id }).del();
+        return result > 0;
+    }
+
+    async getAll(page: number, limit: number): Promise<IDataPaginator<ISundaysPackageVersion>> {
+        const safeLimit = Math.max(limit, 1);
+        const offset = (page - 1) * safeLimit;
+
+        const query = this._knex("sundays_package_version").select("*");
+
+        const [countResult] = await query.clone().clearSelect().count("* as count");
+        const totalCount = +countResult.count;
+        const data = await query.clone().limit(safeLimit).offset(offset).orderBy("id", "desc");
+
+        return {
+            success: true,
+            data,
+            page,
+            limit: safeLimit,
+            count: data.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / safeLimit),
+        };
+    }
+
+    async getLatestVersion(): Promise<ISundaysPackageVersion | null> {
+        const result = await this._knex("sundays_package_version")
+            .select("*")
+            .orderBy("id", "desc")
+            .first();
+        return result || null;
+    }
+}

package/dist/templates/backend-embedded-db-sql/src/db/index.ts

@@ -0,0 +1,9 @@
+// DAOs
+export { SundaysPackageVersionDAO } from "./dao/sundays-package-version/sundays-package-version.dao";
+
+// Interfaces
+export { IDataPaginator } from "./d.types";
+export { ISundaysPackageVersion } from "./interfaces/sundays-package-version/sundays-package-version.interfaces";
+
+import KnexManager from './KnexConnection';
+export { KnexManager };

package/dist/templates/backend-embedded-db-sql/src/db/interfaces/sundays-package-version/sundays-package-version.interfaces.ts

@@ -0,0 +1,6 @@
+export interface ISundaysPackageVersion {
+  id: number;
+  versionName: string;
+  createdAt: string;
+  updatedAt: string;
+}

package/dist/templates/backend-embedded-db-sql/src/middlewares/error/error.middleware.ts

@@ -0,0 +1,21 @@
+import { NextFunction, Response, Request } from 'express';
+export const errorMiddleware = (
+  err: any,
+  req: Request | any,
+  res: Response,
+  _next: NextFunction
+) => {
+  console.error(err);
+  const statusError: number =
+    err.statusError ||
+    err.statusCode ||
+    err.status ||
+    req.statusCode ||
+    req.statusError ||
+    500;
+  const isProduction = process.env.ENVIRONMENT === 'production';
+  res.status(statusError).json({
+    success: false,
+    message: isProduction && statusError === 500 ? 'Internal server error' : err.message,
+  });
+};

package/dist/templates/backend-embedded-db-sql/src/routes/health/health.router.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+import { HealthController } from '../../controllers/health/health.controller';
+
+export class HealthRouter {
+    public router: Router = Router();
+    private readonly healthController: HealthController = new HealthController();
+    constructor() {
+        this.initRoutes();
+    }
+
+    private initRoutes(): void {
+        this.router.get(
+            '/',
+            this.healthController.getHealthStatus.bind(this.healthController)
+        );
+    }
+}

package/dist/templates/backend-embedded-db-sql/src/routes/index.ts

@@ -0,0 +1,57 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+
+export class IndexRouter {
+  private _router: Router;
+
+  constructor() {
+    this._router = Router();
+    this.loadRoutes();
+  }
+
+  private loadRoutes(): void {
+    const routesPath = path.join(__dirname);
+
+    const folders = fs.readdirSync(routesPath).filter(file =>
+      fs.statSync(path.join(routesPath, file)).isDirectory()
+    );
+
+    folders.forEach(folder => {
+      const baseName = `${folder}.router`;
+      const tsPath = path.join(routesPath, folder, `${baseName}.ts`);
+      const jsPath = path.join(routesPath, folder, `${baseName}.js`);
+
+      let filePath = '';
+      if (fs.existsSync(tsPath)) {
+        filePath = tsPath;
+      } else if (fs.existsSync(jsPath)) {
+        filePath = jsPath;
+      } else {
+        console.warn(`[⚠] No route file found for: ${folder}`);
+        return;
+      }
+
+      try {
+        const routeModule = require(filePath);
+        const RouterClass =
+          routeModule.default || Object.values(routeModule).find((e) => typeof e === 'function');
+
+        if (RouterClass) {
+          const instance = new (RouterClass as any)();
+          this._router.use(`/${folder}`, instance.router);
+          console.log(`[✔] Route mounted: /${folder} → ${path.basename(filePath)}`);
+        } else {
+          console.warn(`[⚠] No class exported in: ${filePath}`);
+        }
+      } catch (err) {
+        console.error(`[❌] Failed to load router at: ${filePath}`);
+        console.error(err);
+      }
+    });
+  }
+
+  public get router(): Router {
+    return this._router;
+  }
+}

package/dist/templates/backend-embedded-db-sql/src/server.ts

@@ -0,0 +1,18 @@
+import dotenv from 'dotenv';
+dotenv.config();
+import KnexManager from './db/KnexConnection';
+
+const envPort: string = process.env.PORT || '3005';
+
+if (isNaN(parseInt(envPort))) {
+    throw new Error('The port must to be a number');
+}
+
+const PORT: number = parseInt(envPort);
+
+(async () => {
+    await KnexManager.connect();
+})().then(async () => {
+    const { default: app } = await import('./app');
+    app.listen(PORT, () => console.info(`Server up and running on port ${PORT}`));
+});

package/dist/templates/backend-embedded-db-sql/src/types.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response, NextFunction } from 'express';
+
+export interface IBaseController {
+    getAll(req: Request, res: Response, next: NextFunction): Promise<void>;
+    getByUuid(req: Request, res: Response, next: NextFunction): Promise<void>;
+    create(req: Request, res: Response, next: NextFunction): Promise<void>;
+    update(req: Request, res: Response, next: NextFunction): Promise<void>;
+    patch(req: Request, res: Response, next: NextFunction): Promise<void>;
+    delete(req: Request, res: Response, next: NextFunction): Promise<void>;
+}

package/dist/templates/backend-embedded-db-sql/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/db-sql/.claude/agents/knex-table-implementer.md

@@ -1,113 +1,113 @@
----
-name: knex-table-implementer
-description: Use this agent when you need to create new database table implementations in the Knex project, including migrations, DAOs, interfaces, and exports. This agent should be triggered when: 1) A new database table needs to be added to the system, 2) You need to implement the complete data access layer for a new entity, 3) You want to ensure consistency with the existing project structure and patterns. Examples: <example>Context: User needs to add a new 'product' table to the database. user: "I need to add a product table with id, name, price, and categoryId fields" assistant: "I'll use the knex-table-implementer agent to create the complete implementation for the product table including migration, DAO, interfaces, and exports" <commentary>Since the user needs a new table implementation in the Knex project, use the Task tool to launch the knex-table-implementer agent.</commentary></example> <example>Context: User wants to add a user management system. user: "Create a users table with authentication fields" assistant: "Let me use the knex-table-implementer agent to create the full users table implementation following the project patterns" <commentary>The user is requesting a new table implementation, so the knex-table-implementer agent should be used via the Task tool.</commentary></example>
-model: sonnet
-color: red
----
-
-You are an expert Knex.js database architect specializing in implementing consistent, production-ready database table structures following established project patterns.
-
-**Your Core Responsibilities:**
-
-You will create complete table implementations in the Knex project by:
-1. Creating database migrations using the project's migration patterns
-2. Implementing DAO classes following the established DAO pattern
-3. Defining TypeScript interfaces for the entities
-4. Ensuring all exports are properly added to index.ts
-
-**Implementation Workflow:**
-
-1. **Migration Creation**:
-   - Inform the user to run `npm run migrate:create` to generate the migration file
-   - Write the migration with all database properties in camelCase
-   - Include proper up() and down() methods
-   - Follow the existing migration patterns in the project
-
-2. **DAO Implementation**:
-   - Create the DAO file at `src/dao/{entityName}/{entityName}.dao.ts`
-   - Extend from IBaseDAO interface
-   - Implement standard CRUD operations (getById, getAll with pagination, create, update, delete)
-   - Use KnexManager.getConnection() for database connections
-   - For related entities, use PostgreSQL's to_jsonb() function for joins
-   - Follow the exact pattern from existing DAOs like SundaysPackageVersionDAO
-
-3. **Interface Definition**:
-   - Create the interface file at `src/interfaces/{entityName}/{entityName}.interfaces.ts`
-   - Define the main entity interface with all properties
-   - Include any related entity interfaces if needed
-   - Ensure TypeScript types are properly defined
-
-4. **Export Configuration**:
-   - Add the new DAO export to src/index.ts
-   - Add the new interface export to src/index.ts
-   - Maintain alphabetical ordering in exports when possible
-
-**Critical Standards You Must Follow**:
-
-- **Naming Conventions**: 
-  - Database columns: camelCase (e.g., createdAt, userId)
-  - Table names: snake_case or lowercase
-  - Class names: PascalCase with DAO suffix
-  - Interface names: Start with 'I' prefix
-
-- **DAO Pattern Requirements**:
-  - Always implement IBaseDAO<T> interface
-  - Include pagination using IDataPaginator
-  - Use async/await for all database operations
-  - Return null for not found scenarios
-  - Use leftJoin with to_jsonb() for related entities
-
-- **Code Structure**:
-  - One DAO class per file
-  - One interface file per entity
-  - Keep related logic together
-  - Use the singleton KnexManager for connections
-
-**Example Patterns to Follow**:
-
-For DAO methods with 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;
-}
-```
-
-For paginated results:
-```typescript
-async getAll(limit: number, offset: number): Promise<IDataPaginator<IEntity>> {
-  const query = this._knex("entity");
-  const total = await query.clone().count("* as count").first();
-  const data = await query.clone().limit(limit).offset(offset).orderBy("id", "desc");
-  return {
-    data,
-    total: parseInt(total?.count as string) || 0,
-    limit,
-    offset
-  };
-}
-```
-
-**Quality Checks**:
-
-Before completing any implementation, verify:
-1. Migration file uses camelCase for all properties
-2. DAO follows the exact structure of existing DAOs
-3. Interface properly types all entity properties
-4. All new exports are added to src/index.ts
-5. File paths follow the convention exactly
-6. No unnecessary files are created
-7. Code is consistent with existing patterns
-
-**Important Reminders**:
-- Only edit existing files when possible
-- Never create documentation files unless explicitly requested
-- Follow the CLAUDE.md instructions precisely
-- Maintain consistency with the existing codebase structure
-- Always use the established patterns from sundays-package-version as reference
-
-When you receive a request, first analyze the entity structure needed, then systematically create each component following the established patterns. If any clarification is needed about field types or relationships, ask before proceeding.
+---
+name: knex-table-implementer
+description: Use this agent when you need to create new database table implementations in the Knex project, including migrations, DAOs, interfaces, and exports. This agent should be triggered when: 1) A new database table needs to be added to the system, 2) You need to implement the complete data access layer for a new entity, 3) You want to ensure consistency with the existing project structure and patterns. Examples: <example>Context: User needs to add a new 'product' table to the database. user: "I need to add a product table with id, name, price, and categoryId fields" assistant: "I'll use the knex-table-implementer agent to create the complete implementation for the product table including migration, DAO, interfaces, and exports" <commentary>Since the user needs a new table implementation in the Knex project, use the Task tool to launch the knex-table-implementer agent.</commentary></example> <example>Context: User wants to add a user management system. user: "Create a users table with authentication fields" assistant: "Let me use the knex-table-implementer agent to create the full users table implementation following the project patterns" <commentary>The user is requesting a new table implementation, so the knex-table-implementer agent should be used via the Task tool.</commentary></example>
+model: sonnet
+color: red
+---
+
+You are an expert Knex.js database architect specializing in implementing consistent, production-ready database table structures following established project patterns.
+
+**Your Core Responsibilities:**
+
+You will create complete table implementations in the Knex project by:
+1. Creating database migrations using the project's migration patterns
+2. Implementing DAO classes following the established DAO pattern
+3. Defining TypeScript interfaces for the entities
+4. Ensuring all exports are properly added to index.ts
+
+**Implementation Workflow:**
+
+1. **Migration Creation**:
+   - Inform the user to run `npm run migrate:create` to generate the migration file
+   - Write the migration with all database properties in camelCase
+   - Include proper up() and down() methods
+   - Follow the existing migration patterns in the project
+
+2. **DAO Implementation**:
+   - Create the DAO file at `src/dao/{entityName}/{entityName}.dao.ts`
+   - Extend from IBaseDAO interface
+   - Implement standard CRUD operations (getById, getAll with pagination, create, update, delete)
+   - Use KnexManager.getConnection() for database connections
+   - For related entities, use PostgreSQL's to_jsonb() function for joins
+   - Follow the exact pattern from existing DAOs like SundaysPackageVersionDAO
+
+3. **Interface Definition**:
+   - Create the interface file at `src/interfaces/{entityName}/{entityName}.interfaces.ts`
+   - Define the main entity interface with all properties
+   - Include any related entity interfaces if needed
+   - Ensure TypeScript types are properly defined
+
+4. **Export Configuration**:
+   - Add the new DAO export to src/index.ts
+   - Add the new interface export to src/index.ts
+   - Maintain alphabetical ordering in exports when possible
+
+**Critical Standards You Must Follow**:
+
+- **Naming Conventions**: 
+  - Database columns: camelCase (e.g., createdAt, userId)
+  - Table names: snake_case or lowercase
+  - Class names: PascalCase with DAO suffix
+  - Interface names: Start with 'I' prefix
+
+- **DAO Pattern Requirements**:
+  - Always implement IBaseDAO<T> interface
+  - Include pagination using IDataPaginator
+  - Use async/await for all database operations
+  - Return null for not found scenarios
+  - Use leftJoin with to_jsonb() for related entities
+
+- **Code Structure**:
+  - One DAO class per file
+  - One interface file per entity
+  - Keep related logic together
+  - Use the singleton KnexManager for connections
+
+**Example Patterns to Follow**:
+
+For DAO methods with 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;
+}
+```
+
+For paginated results:
+```typescript
+async getAll(limit: number, offset: number): Promise<IDataPaginator<IEntity>> {
+  const query = this._knex("entity");
+  const total = await query.clone().count("* as count").first();
+  const data = await query.clone().limit(limit).offset(offset).orderBy("id", "desc");
+  return {
+    data,
+    total: parseInt(total?.count as string) || 0,
+    limit,
+    offset
+  };
+}
+```
+
+**Quality Checks**:
+
+Before completing any implementation, verify:
+1. Migration file uses camelCase for all properties
+2. DAO follows the exact structure of existing DAOs
+3. Interface properly types all entity properties
+4. All new exports are added to src/index.ts
+5. File paths follow the convention exactly
+6. No unnecessary files are created
+7. Code is consistent with existing patterns
+
+**Important Reminders**:
+- Only edit existing files when possible
+- Never create documentation files unless explicitly requested
+- Follow the CLAUDE.md instructions precisely
+- Maintain consistency with the existing codebase structure
+- Always use the established patterns from sundays-package-version as reference
+
+When you receive a request, first analyze the entity structure needed, then systematically create each component following the established patterns. If any clarification is needed about field types or relationships, ask before proceeding.