Release/v.0.1.0

.env.example

@@ -2,6 +2,12 @@
 NODE_ENV=
 APP_PORT=
 
+
+FRONTEND_URL=
+BACKEND_URL=
+SERVICE_NAME=
+COOKIE_DOMAIN=
+
 # Database variables
 DATABASE_URL=
 

.gitignore

@@ -131,4 +131,6 @@ dist
 node_modules
 .env*
 build
-dist
+dist
+keys
+*pem

Dockerfile

@@ -1,23 +1,39 @@
-# Use an official Node.js runtime as the base image
-FROM node:22
+# Stage 1: Build Stage
+FROM node:20-alpine3.17 AS build
 
-# Set the working directory inside the container
+# Set the working directory
 WORKDIR /app
 
-# Copy package.json and package-lock.json to the working directory
-COPY package*.json ./
+# Copy only package files for dependency installation
+COPY package*.json tsconfig.json ./
 
-# Install dependencies
-RUN npm install
+# Install all dependencies (including devDependencies)
+RUN npm ci
 
-# Copy the rest of the application code to the working directory
+# Copy the rest of the application code
 COPY . .
 
-# Prisma Client generates a Node.js client for the Prisma API. It is used to access the database in the application code.
-RUN npm run prisma:generate
-
 # Build the TypeScript code
 RUN npm run build
 
+# Stage 2: Production Runtime Stage
+FROM node:20-alpine3.17
+
+# Set the working directory
+WORKDIR /app
+
+# Copy only production dependencies from the build stage
+COPY package*.json ./
+RUN npm ci --only=production
+
+# Copy the built application from the build stage
+COPY --from=build /app/dist ./dist
+
+# Copy Prisma schema and other necessary files (if needed)
+COPY --from=build /app/prisma ./prisma
+
+# Generate Prisma client (if Prisma is used)
+RUN npx prisma generate
+
 # Start the application
 CMD ["npm", "start"]

Dockerfile.release

@@ -1,5 +1,5 @@
 # Use an official Node.js runtime as the base image
-FROM node:22
+FROM node:20-alpine3.17 AS build
 
 # Set the working directory inside the container
 WORKDIR /app

Jenkinsfile

@@ -1,151 +1,140 @@
 pipeline {
     agent any
 
+    environment {
+        REPO_URL = 'https://github.com/BSO-Space/attendify-back.git'
+        WORKSPACE_DIR = "${env.WORKSPACE}"
+    }
+
     stages {
-        stage("Pull") {
+        stage('Determine Environment') {
             steps {
                 script {
-                    checkout([
-                        $class: 'GitSCM',
-                        branches: [[name: "*/${env.BRANCH_NAME}"]],
-                        userRemoteConfigs: [[
-                            url: 'https://github.com/BSO-Space/attendify-back.git',
-                            credentialsId: '3c91d658-54b4-4606-b119-5fd58aa85b28'
-                        ]]
-                    ])
+                    if (env.BRANCH_NAME ==~ /release\/.*/) {
+                        env.ENVIRONMENT = 'staging'
+                        env.ENV_FILE_CREDENTIAL = 'attendify-staging-env-file'
+                    } else if (env.BRANCH_NAME == 'main') {
+                        env.ENVIRONMENT = 'production'
+                        env.ENV_FILE_CREDENTIAL = 'attendify-prod-env-file'
+                    } else {
+                        env.ENVIRONMENT = 'other'
+                        env.ENV_FILE_CREDENTIAL = 'attendify-feature-env-file'
+                    }
                 }
             }
+        }
+
+        stage('Checkout Code') {
+            steps {
+                checkout scm
+            }
             post {
                 always {
-                    echo "Pulling from ${env.BRANCH_NAME}"
+                    echo "Code checkout completed."
                 }
                 success {
-                    echo "Pulled Successfully"
+                    echo "Code checkout successful."
                 }
                 failure {
-                    echo "Pulled Failed"
+                    echo "Code checkout failed."
                 }
             }
         }
 
-        stage('Load Environment') {
-            when {
-                anyOf {
-                    branch 'main'
-                    branch pattern: 'release/.*'
-                }
-            }
+        stage('Setup .env') {
             steps {
                 script {
-                    // กำหนดตัวแปร sourceFile และ destinationFile ให้อยู่ในพื้นที่เดียวกัน
-                    def sourceFile
-                    def destinationFile
-
-                    if (env.BRANCH_NAME == 'main') {
-                        sourceFile = '/var/jenkins_home/credential/attendify-back/.env'
-                        destinationFile = "${WORKSPACE}/.env"
-                    } else {
-                        sourceFile = '/var/jenkins_home/credential/attendify-back/.env.release'
-                        destinationFile = "${WORKSPACE}/.env.release"
-                    }
-
-                    // ตรวจสอบว่าต้นทางมีอยู่ก่อนคัดลอก
-                    if (fileExists(sourceFile)) {
-                        sh "cp ${sourceFile} ${destinationFile}"
-                        echo "Environment file copied successfully to ${destinationFile}"
-                    } else {
-                        error "Source file does not exist: ${sourceFile}"
+                    // Load the Secret File and save it as .env
+                    withCredentials([file(credentialsId: "${ENV_FILE_CREDENTIAL}", variable: 'SECRET_ENV_FILE')]) {
+                        def envFile = env.BRANCH_NAME ==~ /release\/.*/ ? '.env.release' : '.env'
+                        sh "cp $SECRET_ENV_FILE ${envFile}"
+                        sh "ls -la ${envFile}"
+                        sh "cat ${envFile}"
+                        echo "Loaded environment file for ${env.ENVIRONMENT} using ${envFile}."
                     }
                 }
             }
-            post {
-                always {
-                    echo "Loading Environment"
-                }
-                success {
-                    echo "Loaded Successfully"
-                }
-                failure {
-                    echo "Loaded Failed"
-                }
-            }
         }
 
-        stage("Install Dependencies") {
+        stage('Install Dependencies') {
             steps {
                 script {
-                    sh "npm install && npx prisma generate --schema=./src/prisma/schema.prisma"
+                    sh 'npm ci && npx prisma generate'
                 }
             }
             post {
                 always {
-                    echo "Installing Dependencies"
+                    echo "Dependencies installation completed."
                 }
                 success {
-                    echo "Installed Successfully"
+                    echo "Dependencies installed successfully."
                 }
                 failure {
-                    echo "Installed Failed"
+                    echo "Dependencies installation failed."
                 }
             }
         }
 
-        stage("Build") {
+        stage('Build Application') {
             steps {
                 script {
-                    sh "npm run build"
+                    sh 'npm run build'
                 }
             }
             post {
                 always {
-                    echo "Building"
+                    echo "Build process completed."
                 }
                 success {
-                    echo "Built Successfully"
+                    echo "Build successful."
                 }
                 failure {
-                    echo "Build Failed"
+                    echo "Build failed."
                 }
             }
         }
 
-        stage("Deploy") {
+        stage('Deploy Application') {
             when {
-                anyOf {
-                    branch 'main'
-                    branch pattern: 'release/.*'
+                not {
+                    expression {
+                        env.ENVIRONMENT == 'other'
+                    }
                 }
             }
             steps {
                 script {
-                    if (env.BRANCH_NAME == 'main') {
-                        echo "Deploying using docker-compose.yml"
-                        sh "docker compose up -d"
-                    } else {
-                        echo "Deploying using docker-compose.release.yml"
-                        sh "docker compose -f docker-compose.release.yml up -d"
-                    }
+                    def composeFile = env.BRANCH_NAME == 'main' 
+                        ? 'docker-compose.yml' 
+                        : 'docker-compose.release.yml'
+
+                    echo "Deploying using ${composeFile}"
+                    sh "docker compose -f ${composeFile} up -d --build"
                 }
             }
             post {
                 always {
-                    echo "Deploying"
+                    echo "Deployment process completed."
                 }
                 success {
-                    echo "Deployment Successful"
+                    echo "Application deployed successfully."
                 }
                 failure {
-                    echo "Deployment Failed"
+                    echo "Deployment failed."
                 }
             }
         }
     }
+
     post {
+        always {
+            echo "Pipeline execution completed."
+        }
         success {
-            echo "Pipeline execution successful"
+            echo "Pipeline executed successfully."
         }
         failure {
-            echo "Pipeline execution failed"
+            echo "Pipeline execution failed."
         }
     }
 }

docker-compose.release.yml

@@ -10,10 +10,6 @@ services:
       - "${APP_PORT}:3000"
     env_file:
       - .env.release
-    volumes:
-      - .:/app
-      - /app/node_modules
-      - /app/dist
     depends_on:
       - db
       - redis

docker-compose.yml

@@ -9,10 +9,6 @@ services:
       - "${APP_PORT}:3000"
     env_file:
       - .env
-    volumes:
-      - .:/app
-      - /app/node_modules
-      - /app/dist
     depends_on:
       - db
       - redis