Develop

.github/copilot-instructions.md

@@ -148,16 +148,16 @@ constructor(@Inject(DATABASE_TOKEN) private db: DatabaseService) {}
 
 ```typescript
 // ✅ Use specific NestJS exceptions
-throw new NotFoundException("User not found");
-throw new BadRequestException("Invalid input");
-throw new ConflictException("Email already exists");
-throw new InternalServerErrorException("Database error");
+throw new NotFoundException('User not found');
+throw new BadRequestException('Invalid input');
+throw new ConflictException('Email already exists');
+throw new InternalServerErrorException('Database error');
 
 // ✅ Log errors with context
 try {
   await this.operation();
 } catch (error) {
-  this.logger.error("Operation failed", error);
+  this.logger.error('Operation failed', error);
   throw error;
 }
 
@@ -175,11 +175,11 @@ try {
 // ✅ Environment-driven configuration
 const uri = process.env.MONGO_URI;
 if (!uri) {
-  throw new Error("MONGO_URI not configured");
+  throw new Error('MONGO_URI not configured');
 }
 
 // ❌ Never hardcode values
-const uri = "mongodb://localhost:27017/mydb";
+const uri = 'mongodb://localhost:27017/mydb';
 ```
 
 ### 4. Type Safety
@@ -235,7 +235,7 @@ export class UserService {
   async getUser(id: string): Promise<User> {
     const user = await this.users.findById(id);
     if (!user) {
-      throw new NotFoundException("User not found");
+      throw new NotFoundException('User not found');
     }
     return user;
   }
@@ -253,7 +253,7 @@ export class UserService {
 class MongoAdapter {
   async createUser(data: CreateUserDto) {
     if (await this.exists({ email: data.email })) {
-      throw new ConflictException("Email exists"); // Business logic!
+      throw new ConflictException('Email exists'); // Business logic!
     }
     return this.model.create(data);
   }
@@ -275,19 +275,19 @@ const poolSize = 10;
 const timeout = 5000;
 
 // ✅ GOOD
-const poolSize = parseInt(process.env.POOL_SIZE || "10", 10);
-const timeout = parseInt(process.env.TIMEOUT || "5000", 10);
+const poolSize = parseInt(process.env.POOL_SIZE || '10', 10);
+const timeout = parseInt(process.env.TIMEOUT || '5000', 10);
 ```
 
 ### 3. Leaking Internal Types
 
 ```typescript
 // ❌ BAD - Exporting internal implementation
-export { MongoAdapter } from "./adapters/mongo.adapter";
+export { MongoAdapter } from './adapters/mongo.adapter';
 
 // ✅ GOOD - Only export public API
-export { DatabaseService } from "./services/database.service";
-export { Repository } from "./contracts/database.contracts";
+export { DatabaseService } from './services/database.service';
+export { Repository } from './contracts/database.contracts';
 ```
 
 ### 4. Direct Model Access in Services
@@ -323,7 +323,7 @@ export class UserService {
 ### Test Structure
 
 ```typescript
-describe("DatabaseService", () => {
+describe('DatabaseService', () => {
   let service: DatabaseService;
   let mockAdapter: jest.Mocked<MongoAdapter>;
 
@@ -343,8 +343,8 @@ describe("DatabaseService", () => {
     service = module.get(DatabaseService);
   });
 
-  describe("connect", () => {
-    it("should connect to database", async () => {
+  describe('connect', () => {
+    it('should connect to database', async () => {
       await service.connect();
       expect(mockAdapter.connect).toHaveBeenCalled();
     });
@@ -362,34 +362,34 @@ describe("DatabaseService", () => {
 // index.ts - Only these should be exported
 
 // Module (primary)
-export { DatabaseKitModule } from "./database-kit.module";
+export { DatabaseKitModule } from './database-kit.module';
 
 // Services (for direct injection)
-export { DatabaseService } from "./services/database.service";
+export { DatabaseService } from './services/database.service';
 
 // Decorators (for DI)
-export { InjectDatabase } from "./middleware/database.decorators";
+export { InjectDatabase } from './middleware/database.decorators';
 
 // Filters (for app-wide use)
-export { DatabaseExceptionFilter } from "./filters/database-exception.filter";
+export { DatabaseExceptionFilter } from './filters/database-exception.filter';
 
 // Types (for consumers)
 export {
   Repository,
   PageResult,
   DatabaseConfig,
-} from "./contracts/database.contracts";
+} from './contracts/database.contracts';
 
 // Utilities (for convenience)
-export { isValidMongoId } from "./utils/validation.utils";
+export { isValidMongoId } from './utils/validation.utils';
 ```
 
 ### ❌ DON'T Export
 
 ```typescript
 // These should NOT be in index.ts
-export { MongoAdapter } from "./adapters/mongo.adapter"; // Internal
-export { PostgresAdapter } from "./adapters/postgres.adapter"; // Internal
+export { MongoAdapter } from './adapters/mongo.adapter'; // Internal
+export { PostgresAdapter } from './adapters/postgres.adapter'; // Internal
 ```
 
 ---

.github/dependabot.yml

@@ -0,0 +1,34 @@
+version: 2
+updates:
+  # npm dependencies
+  - package-ecosystem: npm
+    directory: '/'
+    schedule:
+      interval: weekly
+      day: monday
+      time: '03:00'
+    open-pull-requests-limit: 5
+    assignees:
+      - CISCODE-MA/cloud-devops
+    labels:
+      - 'dependencies'
+      - 'npm'
+    commit-message:
+      prefix: 'chore(deps)'
+      include: 'scope'
+    rebase-strategy: auto
+
+  # GitHub Actions
+  - package-ecosystem: github-actions
+    directory: '/'
+    schedule:
+      interval: weekly
+      day: sunday
+      time: '03:00'
+    assignees:
+      - CISCODE-MA/cloud-devops
+    labels:
+      - 'dependencies'
+      - 'github-actions'
+    commit-message:
+      prefix: 'ci(deps)'

.github/instructions/adapters.instructions.md

@@ -100,7 +100,7 @@ const model = mongoose.model<T>(name, schema);
 } // Direct pass-through
 {
   status: {
-    $in: ["active", "pending"];
+    $in: ['active', 'pending'];
   }
 }
 ```
@@ -126,7 +126,7 @@ try {
 
 ```typescript
 // MongoDB uses ObjectId
-import { Types } from "mongoose";
+import { Types } from 'mongoose';
 const objectId = new Types.ObjectId(id);
 ```
 
@@ -156,8 +156,8 @@ const table = knex<T>(tableName);
 ```typescript
 // Use Knex transaction
 await knex.transaction(async (trx) => {
-  await trx("users").insert(data);
-  await trx("orders").insert(orderData);
+  await trx('users').insert(data);
+  await trx('orders').insert(orderData);
 });
 ```
 
@@ -166,7 +166,7 @@ await knex.transaction(async (trx) => {
 ```typescript
 // PostgreSQL uses auto-increment or UUID
 // Return inserted row to get ID
-const [inserted] = await knex("users").insert(data).returning("*");
+const [inserted] = await knex('users').insert(data).returning('*');
 ```
 
 ---

.github/instructions/bugfix.instructions.md

@@ -66,14 +66,14 @@ pool: { min: 2, max: 10 }
 // MongoDB - Is the filter format correct?
 {
   status: {
-    $eq: "active";
+    $eq: 'active';
   }
 }
 
 // PostgreSQL - Are operators translated?
 {
   status: {
-    eq: "active";
+    eq: 'active';
   }
 } // → .where('status', '=', 'active')
 
@@ -92,7 +92,7 @@ if (this.softDelete) {
 ```typescript
 // Is session/transaction passed to all operations?
 await model.create([data], { session }); // MongoDB
-await trx("table").insert(data); // PostgreSQL
+await trx('table').insert(data); // PostgreSQL
 
 // Is rollback called on error?
 try {
@@ -149,10 +149,10 @@ await this.hooks.afterCreate(result);
 ### Step 1: Create Failing Test
 
 ```typescript
-describe("Bug #123: Description", () => {
-  it("should handle the edge case correctly", async () => {
+describe('Bug #123: Description', () => {
+  it('should handle the edge case correctly', async () => {
     // This test should FAIL initially
-    const result = await repo.findById("");
+    const result = await repo.findById('');
     expect(result).toBeNull(); // Currently throws
   });
 });
@@ -270,13 +270,13 @@ async findById(id: string): Promise<T | null> {
 
 ```typescript
 // BAD
-it.skip("should handle edge case", () => {
+it.skip('should handle edge case', () => {
   // "I'll fix this later"
 });
 
 // GOOD
-it("should handle edge case", async () => {
-  expect(await repo.findById("")).toBeNull();
+it('should handle edge case', async () => {
+  expect(await repo.findById('')).toBeNull();
 });
 ```
 
@@ -307,26 +307,26 @@ async findById(id: string): Promise<T | null> {
 
 ```typescript
 // In test
-it("debug test", async () => {
+it('debug test', async () => {
   // Check actual database state
   const allRecords = await repo.findAll({});
-  console.log("Current records:", allRecords);
+  console.log('Current records:', allRecords);
 
   // Check what query returns
-  const result = await repo.findById("123");
-  console.log("Query result:", result);
+  const result = await repo.findById('123');
+  console.log('Query result:', result);
 });
 ```
 
 ### Check Mongoose/Knex Debug
 
 ```typescript
 // MongoDB - Enable Mongoose debug
-mongoose.set("debug", true);
+mongoose.set('debug', true);
 
 // PostgreSQL - Knex debug
-const knex = require("knex")({
-  client: "pg",
+const knex = require('knex')({
+  client: 'pg',
   debug: true,
   // ...
 });

.github/instructions/features.instructions.md

@@ -95,12 +95,12 @@ class PostgresRepository<T> implements Repository<T> {
 
 ```typescript
 // src/adapters/mongo.adapter.spec.ts
-describe("newMethod", () => {
-  it("should perform expected behavior", async () => {
+describe('newMethod', () => {
+  it('should perform expected behavior', async () => {
     // Test implementation
   });
 
-  it("should handle edge cases", async () => {
+  it('should handle edge cases', async () => {
     // Edge case tests
   });
 });
@@ -113,7 +113,7 @@ describe("newMethod", () => {
 export {
   // ... existing exports
   NewReturnType, // If you added new types
-} from "./contracts/database.contracts";
+} from './contracts/database.contracts';
 ```
 
 ---
@@ -273,20 +273,20 @@ export function newUtility(input: string): string {
 
 ```typescript
 // src/index.ts
-export { newUtility } from "./utils/new.utils";
+export { newUtility } from './utils/new.utils';
 ```
 
 ### Step 3: Add Tests
 
 ```typescript
 // src/utils/new.utils.spec.ts
-describe("newUtility", () => {
-  it("should transform input correctly", () => {
-    expect(newUtility("input")).toBe("expected");
+describe('newUtility', () => {
+  it('should transform input correctly', () => {
+    expect(newUtility('input')).toBe('expected');
   });
 
-  it("should handle edge cases", () => {
-    expect(newUtility("")).toBe("");
+  it('should handle edge cases', () => {
+    expect(newUtility('')).toBe('');
     expect(newUtility(null as any)).toBeNull();
   });
 });