create-easy-stack 1.0.3

package/templates/nest-ddd/files/src/core/utils/hash.util.ts

@@ -0,0 +1,47 @@
+import * as argon2 from 'argon2';
+import { createHash, createHmac, randomBytes, randomInt } from 'crypto';
+
+export class HashUtil {
+  /** Deterministic hex digest for high-entropy values (tokens), where a slow password hash isn't needed. */
+  static sha256(value: string): string {
+    return createHash('sha256').update(value).digest('hex');
+  }
+
+  static async hashPassword(plainText: string): Promise<string> {
+    // Standard config: Cân bằng tốc độ và bảo mật cho web (Khoảng 200-300ms)
+    return argon2.hash(plainText, {
+      type: argon2.argon2id,
+      memoryCost: 19456, // 19 MB RAM
+      timeCost: 2, // 2 iterations
+      parallelism: 1, // 1 thread
+    });
+  }
+
+  static async comparePassword(
+    plainText: string,
+    hash: string,
+  ): Promise<boolean> {
+    try {
+      return await argon2.verify(hash, plainText);
+    } catch {
+      return false;
+    }
+  }
+
+  static generateRandomToken(length = 32): string {
+    return randomBytes(length).toString('hex');
+  }
+
+  /** Keyed hex digest: unlike a plain hash, it can't be brute-forced offline without the key. */
+  static hmacSha256(key: string | Buffer, value: string): string {
+    return createHmac('sha256', key).update(value).digest('hex');
+  }
+
+  /**
+   * A numeric one-time code of `length` digits (leading zeros allowed), drawn from
+   * the OS CSPRNG so it can't be predicted from earlier codes.
+   */
+  static generateOTP(length = 6): string {
+    return randomInt(0, Math.pow(10, length)).toString().padStart(length, '0');
+  }
+}

package/templates/nest-ddd/files/src/core/utils/snowflake.util.spec.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { SnowflakeGenerator, snowflake } from './snowflake.util.js';
+
+describe('SnowflakeGenerator', () => {
+  it('should generate a string ID', () => {
+    const id = snowflake.nextId();
+    expect(typeof id).toBe('string');
+    expect(id.length).toBeGreaterThan(0);
+  });
+
+  it('should generate unique IDs (10000 items)', () => {
+    const ids = new Set<string>();
+    const count = 10000;
+    for (let i = 0; i < count; i++) {
+      ids.add(snowflake.nextId());
+    }
+    expect(ids.size).toBe(count);
+  });
+
+  it('should construct with specific machine ID', () => {
+    const customSnowflake = new SnowflakeGenerator(5);
+    const id = customSnowflake.nextId();
+    expect(typeof id).toBe('string');
+  });
+
+  it('should throw error if machine ID is out of bounds', () => {
+    expect(() => new SnowflakeGenerator(2000)).toThrow();
+    expect(() => new SnowflakeGenerator(-1)).toThrow();
+  });
+
+  it('should derive a machine ID within valid bounds when PROCESS_ID is unset', () => {
+    const original = process.env.PROCESS_ID;
+    delete process.env.PROCESS_ID;
+    try {
+      expect(() => new SnowflakeGenerator()).not.toThrow();
+    } finally {
+      if (original !== undefined) process.env.PROCESS_ID = original;
+    }
+  });
+});

package/templates/nest-ddd/files/src/core/utils/snowflake.util.ts

@@ -0,0 +1,99 @@
+import { hostname } from 'os';
+import { createHash } from 'crypto';
+
+/**
+ * Derives a machine id from the host's hostname when PROCESS_ID isn't set
+ * explicitly, so different containers/instances don't silently collide on
+ * the same default id (each container gets a distinct hostname in
+ * Docker/Kubernetes, unlike a fixed literal default).
+ */
+function deriveMachineIdFromHostname(maxMachineId: number): number {
+  const hash = createHash('sha256').update(hostname()).digest();
+  const value = hash.readUInt32BE(0);
+  return value % (maxMachineId + 1);
+}
+
+/**
+ * Trình tạo Snowflake ID.
+ * Cấu trúc (64 bit) trả về dưới dạng string:
+ * - 41 bits: Timestamp (mili-giây) từ một epoch cố định.
+ * - 10 bits: Machine/Worker ID (0 - 1023).
+ * - 12 bits: Sequence number (0 - 4095).
+ */
+export class SnowflakeGenerator {
+  private readonly EPOCH = 1704067200000n; // 2024-01-01T00:00:00.000Z
+  private readonly MACHINE_ID_BITS = 10n;
+  private readonly SEQUENCE_BITS = 12n;
+
+  private readonly MAX_MACHINE_ID = -1n ^ (-1n << this.MACHINE_ID_BITS);
+  private readonly MAX_SEQUENCE = -1n ^ (-1n << this.SEQUENCE_BITS);
+
+  private readonly MACHINE_ID_SHIFT = this.SEQUENCE_BITS;
+  private readonly TIMESTAMP_SHIFT = this.SEQUENCE_BITS + this.MACHINE_ID_BITS;
+
+  private machineId: bigint;
+  private sequence: bigint = 0n;
+  private lastTimestamp: bigint = -1n;
+
+  constructor(machineId?: number) {
+    let id = machineId;
+    if (id === undefined) {
+      // PROCESS_ID lets an operator pin an explicit id (e.g. from a k8s
+      // pod ordinal). Without it, every instance would otherwise fall back
+      // to the same hardcoded default and risk generating colliding ids —
+      // so instead each host derives its own id from its hostname.
+      id = process.env.PROCESS_ID
+        ? parseInt(process.env.PROCESS_ID, 10)
+        : deriveMachineIdFromHostname(Number(this.MAX_MACHINE_ID));
+    }
+
+    this.machineId = BigInt(id);
+    if (this.machineId < 0n || this.machineId > this.MAX_MACHINE_ID) {
+      throw new Error(
+        `Machine ID phải nằm trong khoảng từ 0 đến ${this.MAX_MACHINE_ID}`,
+      );
+    }
+  }
+
+  private currentTimestamp(): bigint {
+    return BigInt(Date.now());
+  }
+
+  private waitNextMillis(currentTimestamp: bigint): bigint {
+    let timestamp = this.currentTimestamp();
+    while (timestamp <= currentTimestamp) {
+      timestamp = this.currentTimestamp();
+    }
+    return timestamp;
+  }
+
+  public nextId(): string {
+    let timestamp = this.currentTimestamp();
+
+    if (timestamp < this.lastTimestamp) {
+      throw new Error('Đồng hồ hệ thống bị lùi lại. Không thể sinh ID.');
+    }
+
+    if (timestamp === this.lastTimestamp) {
+      this.sequence = (this.sequence + 1n) & this.MAX_SEQUENCE;
+      if (this.sequence === 0n) {
+        // Hết sequence trong 1 mili-giây, đợi sang mili-giây tiếp theo
+        timestamp = this.waitNextMillis(this.lastTimestamp);
+      }
+    } else {
+      this.sequence = 0n;
+    }
+
+    this.lastTimestamp = timestamp;
+
+    const id =
+      ((timestamp - this.EPOCH) << this.TIMESTAMP_SHIFT) |
+      (this.machineId << this.MACHINE_ID_SHIFT) |
+      this.sequence;
+
+    return id.toString();
+  }
+}
+
+// Khởi tạo Singleton để dùng chung toàn app
+export const snowflake = new SnowflakeGenerator();

package/templates/nest-ddd/files/src/core/utils/string.util.spec.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { StringUtil } from './string.util.js';
+
+describe('StringUtil', () => {
+  it('should slugify vietnamese string correctly', () => {
+    const input = 'Áo thun Nam Đẹp 2024!@#';
+    const slug = StringUtil.slugify(input);
+
+    expect(slug).toBe('ao-thun-nam-dep-2024');
+  });
+
+  it('should generate an order code with given prefix', () => {
+    const code = StringUtil.generateOrderCode('SHOPEE');
+    expect(code.startsWith('SHOPEE-')).toBe(true);
+
+    const parts = code.split('-');
+    expect(parts.length).toBe(3);
+    expect(parts[0]).toBe('SHOPEE');
+  });
+});

package/templates/nest-ddd/files/src/core/utils/string.util.ts

@@ -0,0 +1,21 @@
+import slugify from 'slugify';
+import { randomBytes } from 'crypto';
+
+export class StringUtil {
+  static slugify(text: string): string {
+    return slugify(text, {
+      replacement: '-',
+      remove: undefined,
+      lower: true,
+      strict: true,
+      locale: 'vi',
+      trim: true,
+    });
+  }
+
+  static generateOrderCode(prefix = 'ORD'): string {
+    const timestamp = Date.now().toString(36).toUpperCase();
+    const random = randomBytes(2).toString('hex').toUpperCase();
+    return `${prefix}-${timestamp}-${random}`;
+  }
+}

package/templates/nest-ddd/files/src/core/utils/time.util.spec.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import { TimeUtil } from './time.util.js';
+import dayjs from 'dayjs';
+
+describe('TimeUtil', () => {
+  it('should get current time in UTC ISO format', () => {
+    const time = TimeUtil.getCurrentUtc();
+    expect(time.endsWith('Z')).toBe(true);
+  });
+
+  it('should add minutes correctly', () => {
+    const baseDate = '2024-01-01T12:00:00Z';
+    const newDate = TimeUtil.addMinutes(15, baseDate);
+
+    expect(newDate).toBe('2024-01-01T12:15:00.000Z');
+  });
+
+  it('should correctly identify expired time', () => {
+    const pastDate = dayjs().subtract(1, 'minute').toISOString();
+    const futureDate = dayjs().add(1, 'minute').toISOString();
+
+    expect(TimeUtil.isExpired(pastDate)).toBe(true);
+    expect(TimeUtil.isExpired(futureDate)).toBe(false);
+  });
+});

package/templates/nest-ddd/files/src/core/utils/time.util.ts

@@ -0,0 +1,25 @@
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+import timezone from 'dayjs/plugin/timezone.js';
+
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+export class TimeUtil {
+  static getCurrentUtc(): string {
+    return dayjs().utc().toISOString();
+  }
+
+  static addMinutes(minutes: number, fromDate?: string | Date): string {
+    const base = fromDate ? dayjs(fromDate) : dayjs();
+    return base.add(minutes, 'minute').utc().toISOString();
+  }
+
+  static isExpired(targetDate: string | Date): boolean {
+    return dayjs().isAfter(dayjs(targetDate));
+  }
+
+  static toUtcDate(dateString: string): Date {
+    return dayjs(dateString).utc().toDate();
+  }
+}

package/templates/nest-ddd/files/src/core/utils/ttl.util.ts

@@ -0,0 +1,22 @@
+const DAY = 24;
+const HOUR = 60;
+const MINUTE = 60;
+const SECOND = 1; // Hệ thống này lưu TTL vào Redis dưới dạng Giây (Seconds)
+
+export const buildTTL = (
+  unit: 'DAY' | 'HOUR' | 'MINUTE' | 'SECOND',
+  value: number,
+) => {
+  switch (unit) {
+    case 'DAY':
+      return value * DAY * HOUR * MINUTE * SECOND;
+    case 'HOUR':
+      return value * HOUR * MINUTE * SECOND;
+    case 'MINUTE':
+      return value * MINUTE * SECOND;
+    case 'SECOND':
+      return value * SECOND;
+    default:
+      return value * DAY * HOUR * MINUTE * SECOND;
+  }
+};

package/templates/nest-ddd/files/src/main.ts

@@ -0,0 +1,61 @@
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { ClsService } from 'nestjs-cls';
+import { json } from 'express';
+import helmet from 'helmet';
+import { AppModule } from './app.module.js';
+import { AllExceptionsFilter } from './core/http/filters/all-exceptions.filter.js';
+import { ResponseInterceptor } from './core/http/interceptors/response.interceptor.js';
+import { LoggingInterceptor } from './core/http/interceptors/logging.interceptor.js';
+import { AppLogger } from './core/http/logging/app.logger.js';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, {
+    bufferLogs: true, // Buffer logs until custom logger is attached
+  });
+  app.useLogger(new AppLogger());
+
+  // Security headers
+  app.use(helmet());
+
+  // CORS — restrict origins in production via CORS_ORIGINS (comma separated)
+  const rawOrigins = process.env.CORS_ORIGINS;
+  app.enableCors({
+    origin: rawOrigins ? rawOrigins.split(',').map((o) => o.trim()) : '*',
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization', 'Idempotency-Key'],
+    credentials: false,
+  });
+
+  app.enableShutdownHooks();
+  app.setGlobalPrefix('api/v1');
+
+  // Reject oversized payloads before they hit any handler
+  app.use(json({ limit: '1mb' }));
+
+  app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: true, // strip unknown fields silently
+      forbidNonWhitelisted: true, // AND reject the request if unknown fields are present
+      transform: true,
+    }),
+  );
+  app.useGlobalFilters(new AllExceptionsFilter(app.get(ClsService)));
+  app.useGlobalInterceptors(new LoggingInterceptor(), new ResponseInterceptor());
+
+  // Swagger documentation
+  const config = new DocumentBuilder()
+    .setTitle('{{PROJECT_NAME}} API')
+    .setVersion('1.0')
+    .addBearerAuth()
+    .build();
+  SwaggerModule.setup(
+    'api/v1/docs',
+    app,
+    SwaggerModule.createDocument(app, config),
+  );
+
+  await app.listen(process.env.PORT ?? 3000);
+}
+void bootstrap();

package/templates/nest-ddd/files/test/setup.ts

@@ -0,0 +1,6 @@
+import dotenv from 'dotenv';
+dotenv.config({ path: '.env.test' });
+
+// Background jobs run inside the request here, so e2e tests need no broker.
+// (Only read when the rabbitmq infra is installed.)
+process.env.JOB_QUEUE ??= 'inline';

package/templates/nest-ddd/files/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "rootDir": "./src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/templates/nest-ddd/files/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "ignoreDeprecations": "6.0",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "strictPropertyInitialization": false,
+    "types": ["vitest/globals", "node"],
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  }
+}

package/templates/nest-ddd/files/vitest.config.e2e.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  resolve: {
+    tsconfigPaths: true,
+  },
+  test: {
+    globals: true,
+    root: './',
+    include: ['**/*.e2e-spec.ts'],
+    exclude: ['**/node_modules/**', '**/dist/**'],
+    setupFiles: ['./test/setup.ts'],
+    fileParallelism: false,
+  },
+});

package/templates/nest-ddd/files/vitest.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  // Vite natively supports tsconfig paths
+  resolve: {
+    tsconfigPaths: true,
+  },
+  test: {
+    globals: true,
+    root: './',
+    fileParallelism: false,
+    include: ['**/*.spec.ts', '**/*.integration-spec.ts', '**/*.e2e-spec.ts'],
+    exclude: ['**/node_modules/**', '**/dist/**'],
+    setupFiles: ['./test/setup.ts'],
+  },
+});

package/templates/nest-ddd/template.json

@@ -0,0 +1,8 @@
+{
+  "id": "nest-ddd",
+  "label": "NestJS · DDD + CQRS (Clean Architecture)",
+  "group": "backend",
+  "description": "core/ + modules/<context>/{domain,application,infrastructure,presentation}",
+  "supportsInfra": true,
+  "nextSteps": ["start:dev"]
+}

package/templates/node-express/files/.env.example

@@ -0,0 +1,28 @@
+MONGO_URI=mongodb+srv://thuyphuocthinhtpt1:09122003@cluster0.j97zc.mongodb.net/ecommerce-tipsjs?retryWrites=true&w=majority&appName=Cluster0
+PORT=5000
+DEV_APP_PORT=3000
+DEV_DB_HOST=localhost
+DEV_DB_PORT=27017
+DEV_DB_NAME=dbDev
+PRO_APP_PORT=3000
+PRO_DB_HOST=localhost
+PRO_DB_PORT=27017
+PRO_DB_NAME=dbProduct
+NODE_ENV=dev
+CHANNEL_ID=1314221126024560653
+TOKEN_DISCORD=your_discord_token
+
+CLOUDINARY_CLOUD_NAME=dy0m9udjz
+CLOUDINARY_API_KEY=your_cloudinary_api_key
+CLOUDINARY_API_SECRET=your_cloudinary_api_secret
+
+AWS_REGION=ap-southeast-1
+AWS_BUCKET_NAME=shopdev-ecom-bucket-s3
+AWS_BUCKET_ACCESS_KEY=your_aws_access_key
+AWS_BUCKET_SECRET_KEY=your_aws_secret_key
+AWS_CLOUDFRONT_DOMAIN=https://d2bueawcnwe0if.cloudfront.net
+AWS_CLOUDFRONT_PUBLIC_KEY_ID=K10XVU65Z0IGBU
+AWS_CLOUDFRONT_PRIVATE_KEY=your_cloudfront_private_key"
+
+AWS_EMAIL_APP_USER=your_aws_email_app_user
+AWS_EMAIL_APP_PASSWORD=your_aws_email_app_password

package/templates/node-express/files/docker-compose.yml

@@ -0,0 +1,52 @@
+version: '3.8'
+services:
+  zookeeper:
+    image: bitnami/zookeeper:latest
+    container_name: zookeeper
+    environment:
+      - ALLOW_ANONYMOUS_LOGIN=yes
+    ports:
+      - "2181:2181"
+
+  kafka:
+    image: bitnami/kafka:latest
+    container_name: kafka
+    environment:
+      - KAFKA_BROKER_ID=1
+      - KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181
+      - KAFKA_LISTENERS=PLAINTEXT://:9092
+      - KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092
+      - KAFKA_LISTENER_SECURITY_PROTOCOL=PLAINTEXT
+    ports:
+      - "9092:9092"
+    depends_on:
+      - zookeeper
+
+  elasticsearch:
+    image: docker.elastic.co/elasticsearch/elasticsearch:7.10.0
+    container_name: shopdev_es
+    environment:
+      - node.name=shopdev_es
+      - cluster.name=docker-cluster
+      - bootstrap.memory_lock=true
+      - discovery.type=single-node
+    ulimits:
+      memlock:
+        soft: -1
+        hard: -1
+    volumes:
+      - esdata:/usr/share/elasticsearch/data
+    ports:
+      - "9200:9200"
+
+  kibana:
+    image: docker.elastic.co/kibana/kibana:7.10.0
+    container_name: shopdev_kibana
+    ports:
+      - "5601:5601"
+    depends_on:
+      - elasticsearch
+
+volumes:
+  esdata:
+    driver: local