Forem: Akkarapon Phikulsri

✨ Take a look at it on Akkarapon Foliokub

After dropping the files, I just iterate the prompt like
base on csv files give me mockup base on those data

The agent looked at the headers and quickly built a working dashboard without having to do any manual mapping or coding. It's very satisfying to see a static file turn into an interactive app component right in front of your eyes.

Publish

We can make our spark public (need to sign in with GitHub to view) and also change the visibility setting.

Is GitHub Spark the Future of Rapid Prototyping?

In summary, GitHub Spark is a game changer for bridging the gap between a raw idea and a functional reality; it empowers creators to take the concepts in their heads and manifest them into tangible "Sparks" using nothing more than natural language and some simple prompts.

Why it stands out

Speed to market Whether you're a developer or a visionary, you can build a working product or mockup prototype at an incredible pace.
Intuitive Customization The ability to tweak themes, typography, and data mockups with a few clicks makes it accessible without sacrificing control.
The GitHub Advantage The killer feature is the native ecosystem. Being able to reference your existing private repositories for context is a superpower that other tools simply can't match

If you are already a fan of tools like Lovable but prefer staying within the GitHub ecosystem, Spark is a fantastic alternative. At the current price point of $39 USD (GitHub Copilot Pro+), the value you get—combining AI-assisted coding with this rapid prototyping environment—is exceptionally comprehensive.

GitHub Spark isn't just a toy; It's a high-velocity engine for the next generation of builders :)

DeltaView - AI-Driven JSON Diff Viewer Built with GitHub Copilot

Akkarapon Phikulsri — Sat, 14 Feb 2026 11:40:32 +0000

This is a submission for the GitHub Copilot CLI Challenge

DeltaView - AI-Driven Diff Viewer Built with GitHub Copilot

What I Built

DeltaView is a powerful web-based JSON diff viewer that showcases AI-driven development using GitHub Copilot. The application parses JSON inputs, generates structural diffs, and displays them with beautiful syntax highlighting and side-by-side comparison views.

Key Features:

Intelligent JSON Diff Engine - Recursively compares JSON structures and categorizes changes (added, removed, modified)
Real-time Diff Visualization - Side-by-side comparison with color-coded changes
Syntax Highlighting - Professional code display with proper formatting
Error Handling - Graceful handling of invalid JSON and edge cases
Type-Safe Implementation - Built with TypeScript for reliability
Responsive UI - Modern, clean interface built with React, TailwindCSS, and shadcn/ui

Technology Stack:

Frontend: React + TypeScript
Styling: TailwindCSS + shadcn/ui components
Build Tool: Bun (ultra-fast JavaScript runtime)
Development Methodology: AI-driven architecture with markdown specifications

🎬 Features & Demo

Live demo available at: deltaview.refactorroom.com

DeltaView - All-in-One Developer Toolkit | JSON Converters, Generators, Editor & Schema Converters

All-in-one developer toolkit: JSON converters, generators, online editor, and schema converters. Compare JSON with visual diffs, format & validate, visualize as graphs or tables. Privacy-first, free forever.

deltaview.refactorroom.com

1. 📝 JSON Compare Input Panel

Easily input two JSON objects to compare. The interface features:

Side-by-side JSON input panels
Format buttons to validate and beautify JSON
Load example data for quick testing
Real-time error validation
Support for large JSON structures

2. 🔍 JSON Comparison Results

Get detailed, line-by-line diff visualization:

Orange highlights - Removed or old values
Purple highlights - Added or new values
Character-level precision - See exactly what changed within each line
Copy buttons - Easily copy individual sides
Expandable view - Toggle between split and fullscreen modes
Line numbers for easy reference

Key Comparison Features:

Recursive diff of nested objects
Array element tracking
Property addition/removal detection
Value modification detection
Type change detection

3. 📊 JSON Graph Visualization

Visualize JSON structure as an interactive graph:

Node-based representation of objects and arrays
Visual relationship mapping
Interactive node exploration
Zoom and pan controls
Perfect for understanding complex JSON hierarchies

Graph Features:

Auto-layout for clarity
Color-coded node types
Expandable/collapsible nodes
Connection visualization
Ideal for API responses and config files

4. 📋 Table View

Convert JSON data into structured table format:

Automatic table generation from JSON objects
Column headers from object keys
Clean, organized data presentation
Sortable columns
Perfect for data-driven JSON

Table Features:

Auto-detect and format columns
Handle nested objects gracefully
Array data visualization
Easy copy and export functionality
Responsive column sizing

5. ✨ JSON Formatter

Format, validate, and beautify JSON with professional formatting:

One-click JSON formatting
Automatic indentation (2 spaces)
Syntax highlighting
Error detection with line numbers
Copy formatted output

Formatter Capabilities:

Validate JSON syntax
Detect and report errors
Pretty-print with proper indentation
Remove unnecessary whitespace
Support for large files

🌐 Technology & Performance

Instant Validation - Real-time error checking
Responsive Design - Works perfectly on desktop, tablet, and mobile
Dark/Light Mode - Comfortable viewing in any lighting
Fast Processing - Handles large JSON files efficiently
Type-Safe - Built with TypeScript for reliability

My Experience with GitHub Copilot CLI

How I Used GitHub Copilot CLI

Architecture Definition - Used natural language in docs/architecture.md to define the diff engine specifications, component structure, and data contracts. GitHub Copilot CLI helped generate detailed TypeScript interfaces.
Component Generation - Leveraged gh copilot in the terminal to:
- Generate React component scaffolds with proper TypeScript types
- Create utility functions following project conventions
- Generate UI component wrappers for shadcn/ui integration
Complex Logic Implementation - Used Copilot Chat for:
- Implementing the recursive JSON diff algorithm
- Handling edge cases and data type comparisons
- Creating proper error handling patterns
Code Quality & Consistency - Copilot CLI suggested:
- Linting fixes and TypeScript improvements
- Best practice patterns for React hooks and state management
- Proper accessibility attributes for UI components

Impact on Development

Productivity Gains:

⚡ 60-80% faster development - Boilerplate and repetitive code generation done by AI
🎯 Consistency - All components follow the same patterns defined in agent markdown files
📚 Better Documentation - Architecture markdown files serve as both specs and living documentation
🐛 Fewer Bugs - Type-safe implementations and consistent error handling patterns

Developer Experience:

Natural language to code conversion eliminated context switching
AI understood project conventions and applied them automatically
Focus shifted from syntax to architecture and user experience
Iterative refinement became faster with AI assistance

Key Learnings

Markdown-First Development - Well-structured architecture docs enable AI to maintain consistency across large codebases
Context is King - Providing clear specifications in agent files dramatically improves code quality
Collaboration Model - Human architects design system, AI implements details, humans review and refine
Scalability - This methodology scales better than traditional development for complex projects

This project demonstrates that modern web applications can be built faster, with higher quality, and better maintainability when humans and AI work together with clear architectural specifications.

🚀 Get Started with GitHub Copilot - Easy, Fun & Productive!

Why GitHub Copilot?

GitHub Copilot transforms your coding experience into a productive conversation with AI! Whether you're building new features, debugging code, or learning new frameworks, Copilot is your 24/7 coding companion that makes development easier, faster, and more enjoyable.

✨ Key Benefits

🎯 Easy to Use - Just install and start coding! Copilot understands natural language and suggests code as you type
⚡ Boost Productivity - Cut development time in half by letting AI handle boilerplate, repetitive tasks, and scaffolding
💡 Learn While You Code - Discover best practices, new APIs, and coding patterns through intelligent suggestions
🎨 Focus on Creativity - Spend less time on syntax, more time on solving problems and building amazing features
🤖 CLI Power - Use gh copilot in your terminal for instant help, command suggestions, and code generation

📦 Super Simple Installation

Getting started with GitHub Copilot is as easy as 1-2-3:

Install the Extension - One click in VS Code or your favorite IDE
Sign In - Connect with your GitHub account
Start Coding - That's it! Copilot is ready to assist you

🎉 Why Developers Love It

"Instead of manually writing everything from scratch, I just describe what I want and Copilot generates it. This cuts out boilerplate and lets me focus on the actual logic and user experience."

Key Features That Make Coding Fun:

Natural Language → Code: Describe what you want in comments, get working code instantly
Context-Aware: Understands your project structure and adapts to your coding style
Multi-Language: Works seamlessly with dozens of programming languages
Terminal Integration: GitHub Copilot CLI for command suggestions and explanations right in your terminal
Real-Time Assistance: Get suggestions as you type, no interruptions to your flow

💪 Productivity Boosters

Generate entire functions from a single comment
Convert ideas into working code in seconds
Automate repetitive coding tasks
Get instant code explanations and documentation
Fix bugs faster with AI-powered suggestions

Ready to supercharge your coding? Get GitHub Copilot today!

🤖 AI-Driven Development with Agent Markdown Files

This project demonstrates a powerful AI-first development methodology using structured markdown documentation to guide AI coding agents. Instead of traditional specification documents, we use agent-optimized markdown files that serve as both documentation and instruction sets for AI assistants like GitHub Copilot.

📋 The Agent MD File Pattern

Our docs/ folder contains markdown files specifically designed for AI agents:

docs/
  ├── agent.md              # Core agent instructions & principles
  ├── architecture.md       # System architecture & structure
  ├── coding-standards.md   # Code quality rules
  ├── prompt.md             # Initial project prompt
  ├── ui-guidelines.md      # UI/UX specifications
  ├── vision.md             # Project scope & constraints
  └── tasks/                # Task breakdown

🎯 Why This Approach Works

Traditional Development:

Write specs → Translate to code → Review → Refactor
High cognitive load on developers
Specs often become outdated
Inconsistent implementation

AI-Driven Development:

Write clear markdown requirements → AI generates code → Human reviews
AI maintains consistency across codebase
Documentation stays synchronized with code
Faster iteration cycles

🔧 How We Use Agent Files

1. Architecture as Code (architecture.md)

Defines the entire system structure, component responsibilities, and technical constraints:

Tech stack decisions (React, TypeScript, shadcn/ui)
File organization and structure
Data contracts and interfaces
Performance constraints
Non-goals and boundaries

AI Agent Benefit: Understands the full context and makes consistent architectural decisions.

2. Agent Instructions (agent.md)

Core principles and rules for the AI coding agent:

Code style preferences
Component patterns to follow
JSON handling rules
UI tone and approach
Error handling standards

AI Agent Benefit: Maintains code quality and follows project conventions automatically.

3. Project Prompt (prompt.md)

The initial project specification in natural language:

Feature requirements
Component structure
UX guidelines
API contracts

AI Agent Benefit: Can regenerate or extend features while staying aligned with original vision.

4. Vision Document (vision.md)

Clear boundaries and constraints:

What the project IS
What the project IS NOT
Scope limitations

AI Agent Benefit: Prevents scope creep and keeps AI focused on core functionality.

✨ Benefits of AI-Driven Development

🚀 Speed

Generate entire components from markdown specifications
Boilerplate elimination – AI handles repetitive code
Parallel development – AI works on multiple files simultaneously

🎯 Consistency

Architectural alignment – AI follows defined patterns
Code style uniformity – Automatic adherence to standards
No drift – Documentation and code stay in sync

📚 Living Documentation

Markdown files are human-readable project docs
AI references them for every code generation
Easy to update and maintain

🧠 Knowledge Transfer

New team members read markdown files
AI onboards instantly with same context
Reduces tribal knowledge problems

🛠️ Practical Workflow Example

Step 1: Manual Project Initialization

Before leveraging GitHub Copilot, we start with a basic project setup. This project was initialized using Bun:

bun init

After running bun init, your project structure is ready:

This creates the initial project structure with:

Basic package.json
TypeScript configuration
Entry point files

Why manual first? This establishes the foundation and project structure that Copilot will then enhance and build upon. You control the tech stack decisions, and AI handles the implementation details.

Step 2: Trust Your Workspace

When you open your project folder in VS Code, you'll need to trust the workspace to enable all features:

Click "Yes, I trust the authors" to allow VS Code and GitHub Copilot to:

Access your project files
Provide context-aware suggestions
Run scripts and tools
Enable full extension functionality

This is a one-time security step that ensures you're comfortable with the code in your workspace.

Step 3: Start Prompting with Copilot

Now you're ready to start working with GitHub Copilot! Open the Copilot chat and start describing what you want to build:

Simply describe your requirements in natural language:

"Create a JSON formatter component following docs/architecture.md"
"Build a diff viewer with syntax highlighting"
"Add error handling for invalid JSON input"

Copilot understands your project context and generates code that fits your architecture!

Step 4: AI Takes Over Development

Once the foundation is set, GitHub Copilot accelerates development:

Scenario: Add a new "Export to CSV" feature

Traditional Approach:

Write feature spec
Manually code the export logic
Create UI components
Write tests
Update documentation
Code review
Refactor

AI-Driven Approach:

Update docs/architecture.md with CSV export requirements
Ask Copilot: "Implement CSV export feature following docs/architecture.md"
AI generates:
- Export logic in lib/export/csv.ts
- UI button component
- Integration with existing panels
- Error handling
- TypeScript types
Human reviews and refines
Documentation already updated (step 1)

Time saved: 60-80% reduction in implementation time

📖 Example: JSON Diff Implementation

Our architecture.md specifies:

## Diff Engine
Must be:
- Structural (parse JSON first)
- Recursive
- Deterministic
- Library-free

type DiffEntry = {
  path: string
  type: "added" | "removed" | "modified"
  oldValue?: unknown
  newValue?: unknown
}

AI Agent reads this and generates:

Complete recursive diff algorithm
Type-safe implementation
Proper error handling
Exact data contract adherence

Developer role: Review logic, test edge cases, refine algorithm

💡 Best Practices for Agent Markdown Files

Be Specific, Not Vague
- ❌ "Make it look nice"
- ✅ "Use monospace font, 2-space indentation, subtle colors (green for added, red for removed)"
Define Data Contracts
- Include TypeScript types in markdown
- Specify exact field names and types
- Show example inputs/outputs
Set Boundaries
- Explicitly state what NOT to do
- Define scope limitations
- Prevent feature creep
Keep It Organized
- One concern per file
- Cross-reference related files
- Use clear headings
Write for Both AI and Humans
- Natural language that humans can read
- Structured format AI can parse
- Examples and counterexamples

🎓 Getting Started with Agent-Driven Development

Create a docs/ folder in your project
Write an architecture.md – Define your system structure
Add agent.md – Specify coding principles and patterns
Create vision.md – Set clear boundaries
Reference these files when working with GitHub Copilot
Iterate – Update markdown files as requirements evolve

🔮 The Future of Development

AI-driven development with agent markdown files represents a paradigm shift:

Documentation-first development
AI as implementation partner
Human as architect and reviewer
Faster, more consistent codebases

This project (deltaview.refactorroom.com) was built almost entirely using this methodology, demonstrating that complex applications can be developed with AI assistance while maintaining high code quality and clear architecture.

🚀 Deploying to Cloudflare Pages

DeltaView is deployed to Cloudflare Pages for fast, global distribution. Here's how to deploy:

Prerequisites

Cloudflare Account - Sign up at cloudflare.com
Wrangler CLI - Install with:

   npm install -g wrangler

Authentication - Run wrangler login to connect your account

Your Current Setup

Your project is configured for Cloudflare Pages with:

Project name: deltaview
Build output: dist/
Build command: bun run build.ts

Deployment Steps

1. Authenticate with Cloudflare

wrangler login

2. Build Your Project

bun run build.ts

This generates the dist/ folder with your static assets.

3. Deploy to Pages

wrangler pages deploy dist

Or deploy to a specific environment:

wrangler pages deploy dist --branch=production
wrangler pages deploy dist --branch=preview

4. Add Custom Domain (via Dashboard)

Go to Cloudflare Dashboard
Select deltaview project
Navigate to Settings → Custom domains
Add your domain (e.g., deltaview.refactorroom.com)

Using Package Scripts

We've provided convenient npm scripts in package.json:

bun run pages:build      # Build the project
bun run pages:deploy     # Deploy to Pages
bun run pages:dev        # Local Pages preview

CI/CD Automatic Deployment

For automatic deployments on every push:

Go to Cloudflare Dashboard
Select deltaview project → Settings → Build and deployment
Connect your GitHub repository
Configure:
- Build command: bun run build.ts
- Build output directory: dist
Push to main branch - deployment happens automatically!

Live Site

Your site is live at:

Pages domain: https://deltaview-ap7.pages.dev
Custom domain: https://deltaview.refactorroom.com (once configured)

Project Setup

To install dependencies:

bun install

To start a development server:

bun dev

To run for production:

bun start

This project was created using bun init in bun v1.2.19. Bun is a fast all-in-one JavaScript runtime.

Comprehensive Research: Audit Log Paradigms & Go/PostgreSQL/GORM Design Patterns

Akkarapon Phikulsri — Sat, 07 Feb 2026 16:16:36 +0000

Audit Log Paradigms
Event Sourcing vs Audit Logging
Real-World Use Cases
Database Design Patterns for Audit Trails
State Transition Tracking
API Audit Logging Best Practices
Go/PostgreSQL/GORM Implementation Patterns
Complete Code Examples

1. Audit Log Paradigms

Core Concepts

Audit logging is the practice of recording changes to data in a system to provide:

Traceability: Who did what, when, and why
Compliance: Meeting regulatory requirements (GDPR, HIPAA, SOC 2, PCI DSS)
Security: Detecting suspicious activities and unauthorized access
Debugging: Understanding system behavior and data evolution
Recovery: Ability to rollback or replay changes

Key Principles

1. Append-Only Structure

Audit logs should NEVER be modified or deleted
All entries are immutable after creation
Use separate tables/storage from operational data

2. Essential Audit Fields

Every audit log entry should capture:

Timestamp: When the action occurred (with timezone)
Actor: Who performed the action (user ID, service account)
Action: What was done (CREATE, UPDATE, DELETE, READ)
Resource: What entity was affected (table name, record ID)
Before/After State: Previous and new values
Context: Additional metadata (IP address, session ID, request ID)

3. Performance Considerations

Audit logging should not significantly impact main operations
Use async/background processing for logging when possible
Implement log rotation and archival strategies
Index strategically for query performance

2. Event Sourcing vs Audit Logging

Comparison Matrix

Feature	Event Sourcing	Audit Log
Purpose	Maintain complete history of state changes as source of truth	Track user actions for security/compliance
Granularity	Very granular, every state change	High-level, significant actions
Structure	Append-only log of immutable events	Append-only log of action records
Events Recorded	Facts that occurred (irrefutable)	Account of actions performed
Reconstruction	Can reconstruct system state by replaying events	Not designed for reconstructing state
Querying	Often requires event replay	Direct querying for audit purposes
System Recovery	Facilitates rollback/recovery by replaying	Primarily for investigation/compliance
Complexity	Higher complexity, careful design needed	Generally simpler, auxiliary feature
Use Case	Core business logic and state management	Compliance, security, debugging

When to Use What?

Use Event Sourcing when:

Business logic depends on complete history
Need to replay events to rebuild state
Domain complexity requires detailed tracking
Audit trail is a critical business requirement

Use Audit Logging when:

Need compliance/security tracking only
Don't need state reconstruction
Want simpler implementation
Audit is secondary concern

Hybrid Approach:
Many systems use event sourcing for critical domains and traditional audit logging for other areas.

3. Real-World Use Cases

1. Financial Services

Scenario: Banking transaction processing

Use Case: Track every transaction, balance change, and access attempt
Requirements:
- Immutable records of all transactions
- 7-10 year retention for compliance
- Millisecond-precision timestamps
- Ability to prove no tampering

Implementation:
- Separate audit database with write-only access
- Cryptographic signatures on audit entries
- Regular backup to immutable storage (S3 Glacier)

2. Healthcare (HIPAA Compliance)

Scenario: Patient record access tracking

Use Case: Track who viewed/modified patient records
Requirements:
- Log every access to protected health information (PHI)
- Capture: user, timestamp, patient ID, action, reason
- Alert on suspicious access patterns
- Retain for 6+ years

Implementation:
- Real-time audit logging on every PHI access
- Automated alerting for unusual patterns
- Encrypted audit logs
- Regular compliance reports

3. E-Commerce Order Management

Scenario: Order lifecycle tracking

Use Case: Track order state transitions from creation to delivery
Requirements:
- Capture state changes: created → paid → shipped → delivered
- Record who authorized changes
- Support dispute resolution
- Enable order reconstruction

Implementation:
- State machine with audit trail
- Transition validation rules
- Rollback capability for specific states

4. API Access Control

Scenario: RESTful API request tracking

Use Case: Monitor API usage, detect abuse, support debugging
Requirements:
- Log API requests: endpoint, method, user, parameters
- Track rate limiting violations
- Capture response status and errors
- Enable analytics and billing

Implementation:
- Middleware-based request/response logging
- Async logging to not block requests
- Log aggregation (ELK stack, Splunk)
- Real-time alerting on anomalies

5. Multi-Tenant SaaS

Scenario: User action tracking across tenants

Use Case: Provide audit trails to enterprise customers
Requirements:
- Per-tenant audit logs
- Customer-accessible audit UI
- GDPR right-to-erasure support
- Role-based audit log access

Implementation:
- Tenant-isolated audit tables or schemas
- Audit API endpoints for customers
- Export functionality (CSV, JSON)
- Data retention policies per tenant

6. Incident Management System

Scenario: Tracking incident status and updates

Use Case: Track incident lifecycle and all updates
Requirements:
- Every status change logged
- Update history with timestamps
- Severity changes tracked
- Automated timeline generation

Implementation:
- Event-sourced incident aggregate
- Rich timeline reconstruction
- Audit log as secondary index
- Real-time status board

4. Database Design Patterns for Audit Trails

Pattern 1: Row Versioning (In-Place Audit)

Concept: Add versioning fields directly to the main table

CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    order_number VARCHAR(50) NOT NULL,
    customer_id BIGINT NOT NULL,
    total_amount DECIMAL(10,2),
    status VARCHAR(20),

    -- Audit fields
    version INT NOT NULL DEFAULT 1,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    created_by VARCHAR(100) NOT NULL,
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_by VARCHAR(100) NOT NULL,
    deleted_at TIMESTAMPTZ,
    deleted_by VARCHAR(100)
);

Pros:

Simple to implement
No extra tables
Easy to query current state

Cons:

Loses history of changes
No details on what changed
Can't rollback to previous versions

Pattern 2: Shadow/History Tables

Concept: Separate table mirrors main table with full history

-- Main table (current state)
CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    order_number VARCHAR(50) NOT NULL,
    customer_id BIGINT NOT NULL,
    total_amount DECIMAL(10,2),
    status VARCHAR(20),
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

-- History table (all versions)
CREATE TABLE orders_history (
    history_id BIGSERIAL PRIMARY KEY,
    id BIGINT NOT NULL,
    order_number VARCHAR(50),
    customer_id BIGINT,
    total_amount DECIMAL(10,2),
    status VARCHAR(20),

    -- Audit metadata
    operation VARCHAR(10) NOT NULL, -- INSERT, UPDATE, DELETE
    changed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    changed_by VARCHAR(100) NOT NULL,

    -- Track what changed
    change_reason TEXT
);

-- Trigger to populate history
CREATE OR REPLACE FUNCTION orders_audit_trigger()
RETURNS TRIGGER AS $$
BEGIN
    IF (TG_OP = 'DELETE') THEN
        INSERT INTO orders_history (id, order_number, customer_id, total_amount, 
                                    status, operation, changed_by)
        VALUES (OLD.id, OLD.order_number, OLD.customer_id, OLD.total_amount,
                OLD.status, 'DELETE', current_user);
        RETURN OLD;
    ELSIF (TG_OP = 'UPDATE') THEN
        INSERT INTO orders_history (id, order_number, customer_id, total_amount,
                                    status, operation, changed_by)
        VALUES (NEW.id, NEW.order_number, NEW.customer_id, NEW.total_amount,
                NEW.status, 'UPDATE', current_user);
        RETURN NEW;
    ELSIF (TG_OP = 'INSERT') THEN
        INSERT INTO orders_history (id, order_number, customer_id, total_amount,
                                    status, operation, changed_by)
        VALUES (NEW.id, NEW.order_number, NEW.customer_id, NEW.total_amount,
                NEW.status, 'INSERT', current_user);
        RETURN NEW;
    END IF;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER orders_audit
AFTER INSERT OR UPDATE OR DELETE ON orders
FOR EACH ROW EXECUTE FUNCTION orders_audit_trigger();

Pros:

Complete history preserved
Main table stays clean
Easy to query historical data

Cons:

Doubles storage requirements
Schema changes need updating both tables
Trigger overhead on every operation

Pattern 3: Generic Audit Log Table

Concept: Single table logs changes to any entity

CREATE TABLE audit_logs (
    id BIGSERIAL PRIMARY KEY,

    -- What was changed
    table_name VARCHAR(100) NOT NULL,
    record_id VARCHAR(100) NOT NULL,

    -- What changed
    field_name VARCHAR(100),
    old_value TEXT,
    new_value TEXT,

    -- Who and when
    operation VARCHAR(10) NOT NULL, -- CREATE, UPDATE, DELETE, READ
    changed_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    changed_by VARCHAR(100) NOT NULL,

    -- Context
    ip_address INET,
    user_agent TEXT,
    session_id VARCHAR(100),
    request_id VARCHAR(100),

    -- Additional metadata
    metadata JSONB
);

-- Indexes for common queries
CREATE INDEX idx_audit_logs_table_record ON audit_logs(table_name, record_id);
CREATE INDEX idx_audit_logs_changed_at ON audit_logs(changed_at DESC);
CREATE INDEX idx_audit_logs_changed_by ON audit_logs(changed_by);
CREATE INDEX idx_audit_logs_operation ON audit_logs(operation);

Pros:

Works for any table
Flexible schema
Single place for all audits

Cons:

Less type safety
Complex queries for reconstruction
Can grow very large

Pattern 4: Event Store (Event Sourcing)

Concept: Store all changes as discrete events

CREATE TABLE events (
    id BIGSERIAL PRIMARY KEY,

    -- Event identification
    aggregate_type VARCHAR(100) NOT NULL, -- e.g., "Order"
    aggregate_id VARCHAR(100) NOT NULL,
    event_type VARCHAR(100) NOT NULL, -- e.g., "OrderCreated", "OrderPaid"
    event_version INT NOT NULL,

    -- Event data
    event_data JSONB NOT NULL,

    -- Metadata
    occurred_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    caused_by VARCHAR(100) NOT NULL,
    correlation_id VARCHAR(100),

    -- Ensure ordered sequence per aggregate
    CONSTRAINT unique_aggregate_version UNIQUE (aggregate_type, aggregate_id, event_version)
);

CREATE INDEX idx_events_aggregate ON events(aggregate_type, aggregate_id, event_version);
CREATE INDEX idx_events_occurred_at ON events(occurred_at);

Example events:

{
  "event_type": "OrderCreated",
  "aggregate_type": "Order",
  "aggregate_id": "ORD-12345",
  "event_version": 1,
  "event_data": {
    "order_number": "ORD-12345",
    "customer_id": 567,
    "items": [...],
    "total": 99.99
  }
}

{
  "event_type": "OrderPaid",
  "aggregate_type": "Order",
  "aggregate_id": "ORD-12345",
  "event_version": 2,
  "event_data": {
    "payment_method": "credit_card",
    "transaction_id": "TXN-98765"
  }
}

Pros:

Complete history with business context
Can rebuild state by replaying events
Natural fit for CQRS
Excellent for complex domains

Cons:

High complexity
Schema evolution challenges
Event versioning required
Querying current state requires rebuilding

5. State Transition Tracking

Finite State Machine Pattern

Concept: Track valid state transitions and maintain history

-- Define valid state transitions
CREATE TABLE state_transitions (
    from_state VARCHAR(50) NOT NULL,
    to_state VARCHAR(50) NOT NULL,
    PRIMARY KEY (from_state, to_state)
);

-- Seed valid transitions for orders
INSERT INTO state_transitions (from_state, to_state) VALUES
    ('INITIAL', 'created'),
    ('created', 'payment_pending'),
    ('payment_pending', 'paid'),
    ('payment_pending', 'cancelled'),
    ('paid', 'processing'),
    ('processing', 'shipped'),
    ('shipped', 'delivered'),
    ('delivered', 'completed'),
    ('paid', 'refunded'),
    ('processing', 'cancelled');

-- Main entity table
CREATE TABLE orders (
    id BIGSERIAL PRIMARY KEY,
    order_number VARCHAR(50) UNIQUE NOT NULL,
    customer_id BIGINT NOT NULL,
    current_state VARCHAR(50) NOT NULL DEFAULT 'created',
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

-- State history table
CREATE TABLE order_state_history (
    id BIGSERIAL PRIMARY KEY,
    order_id BIGINT NOT NULL REFERENCES orders(id),
    from_state VARCHAR(50) NOT NULL,
    to_state VARCHAR(50) NOT NULL,

    -- Enforce valid transitions
    FOREIGN KEY (from_state, to_state) 
        REFERENCES state_transitions(from_state, to_state),

    transitioned_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    transitioned_by VARCHAR(100) NOT NULL,
    reason TEXT,
    metadata JSONB,

    -- Ensure transitions are sequential
    sort_key INT NOT NULL,
    is_current BOOLEAN NOT NULL DEFAULT true,

    CONSTRAINT unique_current_per_order 
        UNIQUE (order_id, is_current) WHERE is_current = true
);

-- Index for querying current state
CREATE INDEX idx_order_state_history_current 
    ON order_state_history(order_id, is_current) 
    WHERE is_current = true;

-- Index for timeline queries
CREATE INDEX idx_order_state_history_timeline 
    ON order_state_history(order_id, sort_key);

State Transition Function

CREATE OR REPLACE FUNCTION transition_order_state(
    p_order_id BIGINT,
    p_to_state VARCHAR(50),
    p_user VARCHAR(100),
    p_reason TEXT DEFAULT NULL
) RETURNS BOOLEAN AS $$
DECLARE
    v_current_state VARCHAR(50);
    v_next_sort_key INT;
    v_is_valid BOOLEAN;
BEGIN
    -- Get current state
    SELECT current_state INTO v_current_state
    FROM orders
    WHERE id = p_order_id
    FOR UPDATE; -- Lock row

    IF NOT FOUND THEN
        RAISE EXCEPTION 'Order not found: %', p_order_id;
    END IF;

    -- Check if transition is valid
    SELECT EXISTS(
        SELECT 1 FROM state_transitions
        WHERE from_state = v_current_state
        AND to_state = p_to_state
    ) INTO v_is_valid;

    IF NOT v_is_valid THEN
        RAISE EXCEPTION 'Invalid state transition: % -> %', 
            v_current_state, p_to_state;
    END IF;

    -- Get next sort key
    SELECT COALESCE(MAX(sort_key), 0) + 1
    INTO v_next_sort_key
    FROM order_state_history
    WHERE order_id = p_order_id;

    -- Mark current state as no longer current
    UPDATE order_state_history
    SET is_current = false
    WHERE order_id = p_order_id
    AND is_current = true;

    -- Insert new state
    INSERT INTO order_state_history (
        order_id, from_state, to_state, transitioned_by, 
        reason, sort_key, is_current
    ) VALUES (
        p_order_id, v_current_state, p_to_state, p_user,
        p_reason, v_next_sort_key, true
    );

    -- Update current state on main table
    UPDATE orders
    SET current_state = p_to_state
    WHERE id = p_order_id;

    RETURN true;
END;
$$ LANGUAGE plpgsql;

Querying State History

-- Get complete timeline for an order
SELECT 
    from_state,
    to_state,
    transitioned_at,
    transitioned_by,
    reason,
    sort_key
FROM order_state_history
WHERE order_id = 123
ORDER BY sort_key;

-- Find all orders in a specific state
SELECT o.id, o.order_number, o.current_state
FROM orders o
WHERE o.current_state = 'shipped';

-- Find orders that transitioned through a specific state
SELECT DISTINCT o.id, o.order_number
FROM orders o
JOIN order_state_history h ON o.id = h.order_id
WHERE h.to_state = 'processing';

-- Get duration in each state
SELECT 
    order_id,
    to_state,
    transitioned_at,
    LEAD(transitioned_at) OVER (PARTITION BY order_id ORDER BY sort_key) 
        - transitioned_at AS duration_in_state
FROM order_state_history
WHERE order_id = 123
ORDER BY sort_key;

6. API Audit Logging Best Practices

Essential Elements for API Audit Logs

Request Identification
- Request ID (unique identifier)
- Correlation ID (for distributed tracing)
- Session ID
Authentication/Authorization
- User ID or service account
- Authentication method (JWT, OAuth, API key)
- Scopes/permissions used
Request Details
- HTTP method (GET, POST, PUT, DELETE)
- Endpoint/route
- Request parameters
- Request body (sanitized of sensitive data)
Response Details
- Status code
- Response time
- Error messages (if applicable)
Context
- IP address
- User agent
- Geolocation
- Timestamp (with timezone)

API Audit Log Schema

CREATE TABLE api_audit_logs (
    id BIGSERIAL PRIMARY KEY,

    -- Request identification
    request_id UUID NOT NULL UNIQUE,
    correlation_id UUID,
    session_id VARCHAR(100),

    -- Authentication
    user_id VARCHAR(100),
    service_account VARCHAR(100),
    auth_method VARCHAR(50),

    -- Request details
    http_method VARCHAR(10) NOT NULL,
    endpoint TEXT NOT NULL,
    route_pattern VARCHAR(200), -- e.g., "/api/v1/orders/:id"
    query_params JSONB,
    request_body JSONB,
    request_headers JSONB,

    -- Response details
    status_code INT NOT NULL,
    response_time_ms INT,
    response_body JSONB,
    error_message TEXT,

    -- Context
    ip_address INET,
    user_agent TEXT,
    geo_location JSONB,

    -- Timing
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),

    -- Additional metadata
    metadata JSONB
);

-- Indexes for common query patterns
CREATE INDEX idx_api_audit_user ON api_audit_logs(user_id, created_at DESC);
CREATE INDEX idx_api_audit_endpoint ON api_audit_logs(route_pattern, created_at DESC);
CREATE INDEX idx_api_audit_status ON api_audit_logs(status_code, created_at DESC);
CREATE INDEX idx_api_audit_created ON api_audit_logs(created_at DESC);
CREATE INDEX idx_api_audit_correlation ON api_audit_logs(correlation_id);

-- GIN index for JSONB queries
CREATE INDEX idx_api_audit_metadata ON api_audit_logs USING GIN(metadata);

API Audit Logging Best Practices

Log Asynchronously
- Don't block API responses
- Use queues (RabbitMQ, Kafka)
- Buffer and batch writes
Sanitize Sensitive Data
- Never log passwords, tokens, credit cards
- Mask or redact PII
- Use allowlist for safe fields
Structured Logging
- Use JSON format
- Consistent field names
- Enable easy parsing/analysis
Implement Log Rotation
- Archive old logs
- Partition tables by date
- Set retention policies
Monitor and Alert
- Set up alerts for anomalies
- Track error rates
- Monitor unusual access patterns
Compliance Considerations
- GDPR: Support right to erasure
- HIPAA: Encrypt at rest and in transit
- SOC 2: Tamper-proof logs

7. Go/PostgreSQL/GORM Implementation Patterns

Architecture Overview

┌─────────────────────────────────────────┐
│         HTTP Handler Layer              │
│  (Middleware: Context, Auth, Logging)   │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│         Service Layer                   │
│  (Business Logic, Validation)           │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│       Repository Layer                  │
│  (Data Access, GORM Operations)         │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│         Database Layer                  │
│  (PostgreSQL + Audit Tables)            │
└─────────────────────────────────────────┘

Pattern 1: GORM Callbacks for Automatic Audit Logging

Concept: Use GORM's hook system to automatically log changes

package models

import (
    "context"
    "encoding/json"
    "time"

    "gorm.io/gorm"
)

// AuditLog represents the audit log table
type AuditLog struct {
    ID          uint           `gorm:"primaryKey"`
    TableName   string         `gorm:"index;not null"`
    RecordID    string         `gorm:"index;not null"`
    Operation   string         `gorm:"index;not null"` // CREATE, UPDATE, DELETE, READ
    OldValue    json.RawMessage `gorm:"type:jsonb"`
    NewValue    json.RawMessage `gorm:"type:jsonb"`
    ChangedBy   string         `gorm:"index"`
    ChangedAt   time.Time      `gorm:"index;not null"`
    IPAddress   string
    UserAgent   string
    SessionID   string         `gorm:"index"`
    RequestID   string         `gorm:"index"`
    Metadata    json.RawMessage `gorm:"type:jsonb"`
}

// Auditable interface for models that support audit logging
type Auditable interface {
    TableName() string
    GetID() string
}

// Order model with audit support
type Order struct {
    ID           uint      `gorm:"primaryKey"`
    OrderNumber  string    `gorm:"uniqueIndex;not null"`
    CustomerID   uint      `gorm:"not null"`
    TotalAmount  float64
    Status       string
    CreatedAt    time.Time
    UpdatedAt    time.Time
}

func (Order) TableName() string {
    return "orders"
}

func (o Order) GetID() string {
    return fmt.Sprintf("%d", o.ID)
}

// RegisterAuditCallbacks registers GORM callbacks for audit logging
func RegisterAuditCallbacks(db *gorm.DB) {
    // After Create
    db.Callback().Create().After("gorm:after_create").Register("audit:after_create", func(db *gorm.DB) {
        if db.Statement.Schema == nil {
            return
        }

        // Check if model implements Auditable
        if auditable, ok := db.Statement.Dest.(Auditable); ok {
            createAuditLog(db, auditable, "CREATE", nil, db.Statement.Dest)
        }
    })

    // After Update
    db.Callback().Update().After("gorm:after_update").Register("audit:after_update", func(db *gorm.DB) {
        if db.Statement.Schema == nil {
            return
        }

        // Get old values before update (stored in context)
        oldValue := db.Statement.Context.Value("audit:old_value")

        if auditable, ok := db.Statement.Dest.(Auditable); ok {
            createAuditLog(db, auditable, "UPDATE", oldValue, db.Statement.Dest)
        }
    })

    // Before Update - capture old values
    db.Callback().Update().Before("gorm:before_update").Register("audit:before_update", func(db *gorm.DB) {
        if db.Statement.Schema == nil {
            return
        }

        // Fetch current values
        if auditable, ok := db.Statement.Dest.(Auditable); ok {
            var oldModel interface{}
            // Clone the model
            db.Session(&gorm.Session{}).
                Where(db.Statement.Schema.PrioritizedPrimaryField.Name+" = ?", auditable.GetID()).
                First(&oldModel)

            // Store in context for after_update
            ctx := context.WithValue(db.Statement.Context, "audit:old_value", oldModel)
            db.Statement.Context = ctx
        }
    })

    // After Delete
    db.Callback().Delete().After("gorm:after_delete").Register("audit:after_delete", func(db *gorm.DB) {
        if db.Statement.Schema == nil {
            return
        }

        if auditable, ok := db.Statement.Dest.(Auditable); ok {
            createAuditLog(db, auditable, "DELETE", db.Statement.Dest, nil)
        }
    })
}

func createAuditLog(db *gorm.DB, auditable Auditable, operation string, oldValue, newValue interface{}) {
    // Get audit context from request context
    ctx := db.Statement.Context

    var oldJSON, newJSON json.RawMessage

    if oldValue != nil {
        oldJSON, _ = json.Marshal(oldValue)
    }
    if newValue != nil {
        newJSON, _ = json.Marshal(newValue)
    }

    auditLog := AuditLog{
        TableName:  auditable.TableName(),
        RecordID:   auditable.GetID(),
        Operation:  operation,
        OldValue:   oldJSON,
        NewValue:   newJSON,
        ChangedBy:  getFromContext(ctx, "user_id"),
        ChangedAt:  time.Now(),
        IPAddress:  getFromContext(ctx, "ip_address"),
        UserAgent:  getFromContext(ctx, "user_agent"),
        SessionID:  getFromContext(ctx, "session_id"),
        RequestID:  getFromContext(ctx, "request_id"),
    }

    // Use a new session to avoid triggering callbacks recursively
    db.Session(&gorm.Session{SkipHooks: true}).Create(&auditLog)
}

func getFromContext(ctx context.Context, key string) string {
    if val := ctx.Value(key); val != nil {
        if str, ok := val.(string); ok {
            return str
        }
    }
    return ""
}

Pattern 2: Repository Pattern with Explicit Audit Logging

Concept: Repository layer explicitly logs changes

package repository

import (
    "context"
    "encoding/json"
    "fmt"
    "time"

    "gorm.io/gorm"
)

// OrderRepository handles order data access
type OrderRepository interface {
    Create(ctx context.Context, order *Order) error
    Update(ctx context.Context, order *Order) error
    Delete(ctx context.Context, id uint) error
    FindByID(ctx context.Context, id uint) (*Order, error)
}

type orderRepository struct {
    db *gorm.DB
    auditRepo AuditRepository
}

func NewOrderRepository(db *gorm.DB, auditRepo AuditRepository) OrderRepository {
    return &orderRepository{
        db: db,
        auditRepo: auditRepo,
    }
}

func (r *orderRepository) Create(ctx context.Context, order *Order) error {
    return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // Create order
        if err := tx.Create(order).Error; err != nil {
            return err
        }

        // Log audit
        newValue, _ := json.Marshal(order)
        return r.auditRepo.Log(ctx, AuditEntry{
            TableName: "orders",
            RecordID:  fmt.Sprintf("%d", order.ID),
            Operation: "CREATE",
            NewValue:  newValue,
        })
    })
}

func (r *orderRepository) Update(ctx context.Context, order *Order) error {
    return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // Get old values
        var oldOrder Order
        if err := tx.First(&oldOrder, order.ID).Error; err != nil {
            return err
        }

        // Update order
        if err := tx.Save(order).Error; err != nil {
            return err
        }

        // Log audit
        oldValue, _ := json.Marshal(oldOrder)
        newValue, _ := json.Marshal(order)
        return r.auditRepo.Log(ctx, AuditEntry{
            TableName: "orders",
            RecordID:  fmt.Sprintf("%d", order.ID),
            Operation: "UPDATE",
            OldValue:  oldValue,
            NewValue:  newValue,
        })
    })
}

func (r *orderRepository) Delete(ctx context.Context, id uint) error {
    return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // Get current values before delete
        var order Order
        if err := tx.First(&order, id).Error; err != nil {
            return err
        }

        // Soft delete
        if err := tx.Delete(&order, id).Error; err != nil {
            return err
        }

        // Log audit
        oldValue, _ := json.Marshal(order)
        return r.auditRepo.Log(ctx, AuditEntry{
            TableName: "orders",
            RecordID:  fmt.Sprintf("%d", id),
            Operation: "DELETE",
            OldValue:  oldValue,
        })
    })
}

Pattern 3: State Machine with Audit Trail

Concept: Explicit state transitions with validation and audit

package statemachine

import (
    "context"
    "fmt"
    "time"

    "gorm.io/gorm"
    "gorm.io/gorm/clause"
)

// OrderState represents valid order states
type OrderState string

const (
    StateCreated         OrderState = "created"
    StatePaymentPending  OrderState = "payment_pending"
    StatePaid            OrderState = "paid"
    StateProcessing      OrderState = "processing"
    StateShipped         OrderState = "shipped"
    StateDelivered       OrderState = "delivered"
    StateCompleted       OrderState = "completed"
    StateCancelled       OrderState = "cancelled"
    StateRefunded        OrderState = "refunded"
)

// StateTransition defines valid transitions
type StateTransition struct {
    FromState OrderState `gorm:"primaryKey"`
    ToState   OrderState `gorm:"primaryKey"`
}

// OrderStateHistory tracks state changes
type OrderStateHistory struct {
    ID              uint       `gorm:"primaryKey"`
    OrderID         uint       `gorm:"index;not null"`
    FromState       OrderState `gorm:"not null"`
    ToState         OrderState `gorm:"not null"`
    TransitionedAt  time.Time  `gorm:"index;not null"`
    TransitionedBy  string     `gorm:"index;not null"`
    Reason          string
    SortKey         int        `gorm:"not null"`
    IsCurrent       bool       `gorm:"not null;default:true"`
    Metadata        string     `gorm:"type:jsonb"`
}

// OrderStateMachine manages order state transitions
type OrderStateMachine struct {
    db *gorm.DB
}

func NewOrderStateMachine(db *gorm.DB) *OrderStateMachine {
    return &OrderStateMachine{db: db}
}

// TransitionTo attempts to transition order to new state
func (sm *OrderStateMachine) TransitionTo(
    ctx context.Context,
    orderID uint,
    toState OrderState,
    user string,
    reason string,
) error {
    return sm.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
        // Lock order row
        var order Order
        if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
            First(&order, orderID).Error; err != nil {
            return fmt.Errorf("order not found: %w", err)
        }

        currentState := OrderState(order.Status)

        // Validate transition
        if err := sm.validateTransition(tx, currentState, toState); err != nil {
            return err
        }

        // Get next sort key
        var maxSortKey int
        tx.Model(&OrderStateHistory{}).
            Where("order_id = ?", orderID).
            Select("COALESCE(MAX(sort_key), 0)").
            Scan(&maxSortKey)
        nextSortKey := maxSortKey + 1

        // Mark current state as not current
        tx.Model(&OrderStateHistory{}).
            Where("order_id = ? AND is_current = ?", orderID, true).
            Update("is_current", false)

        // Create new state history entry
        history := OrderStateHistory{
            OrderID:        orderID,
            FromState:      currentState,
            ToState:        toState,
            TransitionedAt: time.Now(),
            TransitionedBy: user,
            Reason:         reason,
            SortKey:        nextSortKey,
            IsCurrent:      true,
        }

        if err := tx.Create(&history).Error; err != nil {
            return fmt.Errorf("failed to create state history: %w", err)
        }

        // Update order status
        if err := tx.Model(&order).Update("status", string(toState)).Error; err != nil {
            return fmt.Errorf("failed to update order status: %w", err)
        }

        return nil
    })
}

func (sm *OrderStateMachine) validateTransition(tx *gorm.DB, from, to OrderState) error {
    var count int64
    tx.Model(&StateTransition{}).
        Where("from_state = ? AND to_state = ?", from, to).
        Count(&count)

    if count == 0 {
        return fmt.Errorf("invalid state transition: %s -> %s", from, to)
    }
    return nil
}

// GetStateHistory returns the complete state history for an order
func (sm *OrderStateMachine) GetStateHistory(ctx context.Context, orderID uint) ([]OrderStateHistory, error) {
    var history []OrderStateHistory
    err := sm.db.WithContext(ctx).
        Where("order_id = ?", orderID).
        Order("sort_key ASC").
        Find(&history).Error
    return history, err
}

// GetCurrentState returns the current state of an order
func (sm *OrderStateMachine) GetCurrentState(ctx context.Context, orderID uint) (*OrderStateHistory, error) {
    var history OrderStateHistory
    err := sm.db.WithContext(ctx).
        Where("order_id = ? AND is_current = ?", orderID, true).
        First(&history).Error
    return &history, err
}

Pattern 4: Middleware for API Audit Logging

Concept: HTTP middleware captures API request/response details

package middleware

import (
    "bytes"
    "context"
    "encoding/json"
    "io"
    "log"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
    "gorm.io/gorm"
)

// APIAuditLog represents API audit log entries
type APIAuditLog struct {
    ID             uint            `gorm:"primaryKey"`
    RequestID      string          `gorm:"uniqueIndex;not null"`
    CorrelationID  string          `gorm:"index"`
    SessionID      string          `gorm:"index"`
    UserID         string          `gorm:"index"`
    HTTPMethod     string          `gorm:"not null"`
    Endpoint       string          `gorm:"not null"`
    RoutePattern   string          `gorm:"index"`
    QueryParams    json.RawMessage `gorm:"type:jsonb"`
    RequestBody    json.RawMessage `gorm:"type:jsonb"`
    RequestHeaders json.RawMessage `gorm:"type:jsonb"`
    StatusCode     int             `gorm:"index"`
    ResponseTimeMs int
    ResponseBody   json.RawMessage `gorm:"type:jsonb"`
    ErrorMessage   string
    IPAddress      string
    UserAgent      string
    CreatedAt      time.Time       `gorm:"index"`
    Metadata       json.RawMessage `gorm:"type:jsonb"`
}

// APIAuditMiddleware logs all API requests and responses
func APIAuditMiddleware(db *gorm.DB) gin.HandlerFunc {
    return func(c *gin.Context) {
        startTime := time.Now()

        // Generate request ID if not present
        requestID := c.GetHeader("X-Request-ID")
        if requestID == "" {
            requestID = uuid.New().String()
            c.Header("X-Request-ID", requestID)
        }

        // Store request ID in context
        ctx := context.WithValue(c.Request.Context(), "request_id", requestID)
        c.Request = c.Request.WithContext(ctx)

        // Capture request body
        var requestBody []byte
        if c.Request.Body != nil {
            requestBody, _ = io.ReadAll(c.Request.Body)
            // Restore body for handler
            c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
        }

        // Create custom response writer to capture response
        blw := &bodyLogWriter{body: bytes.NewBufferString(""), ResponseWriter: c.Writer}
        c.Writer = blw

        // Process request
        c.Next()

        // Calculate response time
        responseTime := time.Since(startTime).Milliseconds()

        // Prepare audit log (async to not block response)
        go func() {
            auditLog := APIAuditLog{
                RequestID:      requestID,
                CorrelationID:  c.GetHeader("X-Correlation-ID"),
                SessionID:      c.GetString("session_id"), // From auth middleware
                UserID:         c.GetString("user_id"),    // From auth middleware
                HTTPMethod:     c.Request.Method,
                Endpoint:       c.Request.URL.Path,
                RoutePattern:   c.FullPath(),
                QueryParams:    toJSON(c.Request.URL.Query()),
                RequestBody:    sanitizeRequestBody(requestBody),
                RequestHeaders: toJSON(sanitizeHeaders(c.Request.Header)),
                StatusCode:     c.Writer.Status(),
                ResponseTimeMs: int(responseTime),
                ResponseBody:   sanitizeResponseBody(blw.body.Bytes()),
                IPAddress:      c.ClientIP(),
                UserAgent:      c.Request.UserAgent(),
                CreatedAt:      startTime,
            }

            // Save to database
            if err := db.Create(&auditLog).Error; err != nil {
                // Log error but don't fail the request
                log.Printf("Failed to create audit log: %v", err)
            }
        }()
    }
}

type bodyLogWriter struct {
    gin.ResponseWriter
    body *bytes.Buffer
}

func (w bodyLogWriter) Write(b []byte) (int, error) {
    w.body.Write(b)
    return w.ResponseWriter.Write(b)
}

func toJSON(v interface{}) json.RawMessage {
    b, _ := json.Marshal(v)
    return b
}

func sanitizeRequestBody(body []byte) json.RawMessage {
    if len(body) == 0 {
        return nil
    }

    var data map[string]interface{}
    if err := json.Unmarshal(body, &data); err != nil {
        return nil
    }

    // Remove sensitive fields
    sensitiveFields := []string{"password", "token", "api_key", "secret", "credit_card"}
    for _, field := range sensitiveFields {
        if _, exists := data[field]; exists {
            data[field] = "[REDACTED]"
        }
    }

    return toJSON(data)
}

func sanitizeResponseBody(body []byte) json.RawMessage {
    // Similar to request sanitization
    return sanitizeRequestBody(body)
}

func sanitizeHeaders(headers http.Header) http.Header {
    sanitized := make(http.Header)
    for k, v := range headers {
        // Skip authorization headers
        if k == "Authorization" || k == "Cookie" {
            sanitized[k] = []string{"[REDACTED]"}
        } else {
            sanitized[k] = v
        }
    }
    return sanitized
}

8. Complete Code Examples

Example 1: Complete Order Management System with Audit

// main.go
package main

import (
    "log"

    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

func main() {
    // Database connection
    dsn := "host=localhost user=postgres password=postgres dbname=orders port=5432"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }

    // Auto-migrate tables
    db.AutoMigrate(
        &Order{},
        &OrderStateHistory{},
        &StateTransition{},
        &AuditLog{},
        &APIAuditLog{},
    )

    // Seed valid state transitions
    seedStateTransitions(db)

    // Register audit callbacks
    RegisterAuditCallbacks(db)

    // Initialize repositories
    auditRepo := NewAuditRepository(db)
    orderRepo := NewOrderRepository(db, auditRepo)

    // Initialize state machine
    stateMachine := NewOrderStateMachine(db)

    // Initialize services
    orderService := NewOrderService(orderRepo, stateMachine)

    // Setup router
    router := gin.Default()

    // Global middleware
    router.Use(APIAuditMiddleware(db))
    router.Use(AuthMiddleware()) // Your auth middleware

    // Routes
    v1 := router.Group("/api/v1")
    {
        orders := v1.Group("/orders")
        {
            orders.POST("", orderService.CreateOrder)
            orders.GET("/:id", orderService.GetOrder)
            orders.PUT("/:id", orderService.UpdateOrder)
            orders.DELETE("/:id", orderService.DeleteOrder)
            orders.POST("/:id/transition", orderService.TransitionState)
            orders.GET("/:id/history", orderService.GetStateHistory)
        }
    }

    log.Fatal(router.Run(":8080"))
}

func seedStateTransitions(db *gorm.DB) {
    transitions := []StateTransition{
        {FromState: "created", ToState: "payment_pending"},
        {FromState: "payment_pending", ToState: "paid"},
        {FromState: "payment_pending", ToState: "cancelled"},
        {FromState: "paid", ToState: "processing"},
        {FromState: "processing", ToState: "shipped"},
        {FromState: "shipped", ToState: "delivered"},
        {FromState: "delivered", ToState: "completed"},
        {FromState: "paid", ToState: "refunded"},
        {FromState: "processing", ToState: "cancelled"},
    }

    for _, t := range transitions {
        db.FirstOrCreate(&t, t)
    }
}

Example 2: Service Layer with Context Propagation

// service/order_service.go
package service

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "strconv"
    "time"

    "github.com/gin-gonic/gin"
)

type OrderService struct {
    orderRepo    OrderRepository
    stateMachine *OrderStateMachine
}

func NewOrderService(orderRepo OrderRepository, stateMachine *OrderStateMachine) *OrderService {
    return &OrderService{
        orderRepo:    orderRepo,
        stateMachine: stateMachine,
    }
}

type CreateOrderRequest struct {
    CustomerID  uint    `json:"customer_id" binding:"required"`
    TotalAmount float64 `json:"total_amount" binding:"required"`
}

func (s *OrderService) CreateOrder(c *gin.Context) {
    var req CreateOrderRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // Build context with audit information
    ctx := buildAuditContext(c)

    // Generate order number
    orderNumber := fmt.Sprintf("ORD-%d", time.Now().Unix())

    order := &Order{
        OrderNumber: orderNumber,
        CustomerID:  req.CustomerID,
        TotalAmount: req.TotalAmount,
        Status:      string(StateCreated),
    }

    if err := s.orderRepo.Create(ctx, order); err != nil {
        log.Printf("Failed to create order: %v", err)
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create order"})
        return
    }

    c.JSON(http.StatusCreated, order)
}

func (s *OrderService) TransitionState(c *gin.Context) {
    orderID := c.Param("id")

    var req struct {
        ToState string `json:"to_state" binding:"required"`
        Reason  string `json:"reason"`
    }

    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    ctx := buildAuditContext(c)
    userID := c.GetString("user_id")

    id, _ := strconv.ParseUint(orderID, 10, 64)

    err := s.stateMachine.TransitionTo(
        ctx,
        uint(id),
        OrderState(req.ToState),
        userID,
        req.Reason,
    )

    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "State transitioned successfully"})
}

func (s *OrderService) GetStateHistory(c *gin.Context) {
    orderID := c.Param("id")
    id, _ := strconv.ParseUint(orderID, 10, 64)

    ctx := buildAuditContext(c)

    history, err := s.stateMachine.GetStateHistory(ctx, uint(id))
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get history"})
        return
    }

    c.JSON(http.StatusOK, history)
}

// buildAuditContext extracts audit info from request and builds context
func buildAuditContext(c *gin.Context) context.Context {
    ctx := c.Request.Context()

    // Add audit fields to context
    ctx = context.WithValue(ctx, "user_id", c.GetString("user_id"))
    ctx = context.WithValue(ctx, "session_id", c.GetString("session_id"))
    ctx = context.WithValue(ctx, "ip_address", c.ClientIP())
    ctx = context.WithValue(ctx, "user_agent", c.Request.UserAgent())
    ctx = context.WithValue(ctx, "request_id", c.GetHeader("X-Request-ID"))

    return ctx
}

Example 3: Querying Audit Logs

// repository/audit_repository.go
package repository

import (
    "context"
    "encoding/json"
    "time"

    "gorm.io/gorm"
)

type AuditRepository interface {
    Log(ctx context.Context, entry AuditEntry) error
    GetByRecordID(ctx context.Context, tableName, recordID string) ([]AuditLog, error)
    GetByUser(ctx context.Context, userID string, limit int) ([]AuditLog, error)
    GetByDateRange(ctx context.Context, start, end time.Time) ([]AuditLog, error)
    GetByOperation(ctx context.Context, operation string, limit int) ([]AuditLog, error)
}

type auditRepository struct {
    db *gorm.DB
}

func NewAuditRepository(db *gorm.DB) AuditRepository {
    return &auditRepository{db: db}
}

type AuditEntry struct {
    TableName string
    RecordID  string
    Operation string
    OldValue  json.RawMessage
    NewValue  json.RawMessage
}

func (r *auditRepository) Log(ctx context.Context, entry AuditEntry) error {
    auditLog := AuditLog{
        TableName:  entry.TableName,
        RecordID:   entry.RecordID,
        Operation:  entry.Operation,
        OldValue:   entry.OldValue,
        NewValue:   entry.NewValue,
        ChangedBy:  getFromContext(ctx, "user_id"),
        ChangedAt:  time.Now(),
        IPAddress:  getFromContext(ctx, "ip_address"),
        UserAgent:  getFromContext(ctx, "user_agent"),
        SessionID:  getFromContext(ctx, "session_id"),
        RequestID:  getFromContext(ctx, "request_id"),
    }

    return r.db.WithContext(ctx).Create(&auditLog).Error
}

func (r *auditRepository) GetByRecordID(ctx context.Context, tableName, recordID string) ([]AuditLog, error) {
    var logs []AuditLog
    err := r.db.WithContext(ctx).
        Where("table_name = ? AND record_id = ?", tableName, recordID).
        Order("changed_at DESC").
        Find(&logs).Error
    return logs, err
}

func (r *auditRepository) GetByUser(ctx context.Context, userID string, limit int) ([]AuditLog, error) {
    var logs []AuditLog
    err := r.db.WithContext(ctx).
        Where("changed_by = ?", userID).
        Order("changed_at DESC").
        Limit(limit).
        Find(&logs).Error
    return logs, err
}

func (r *auditRepository) GetByDateRange(ctx context.Context, start, end time.Time) ([]AuditLog, error) {
    var logs []AuditLog
    err := r.db.WithContext(ctx).
        Where("changed_at BETWEEN ? AND ?", start, end).
        Order("changed_at DESC").
        Find(&logs).Error
    return logs, err
}

func (r *auditRepository) GetByOperation(ctx context.Context, operation string, limit int) ([]AuditLog, error) {
    var logs []AuditLog
    err := r.db.WithContext(ctx).
        Where("operation = ?", operation).
        Order("changed_at DESC").
        Limit(limit).
        Find(&logs).Error
    return logs, err
}

9. Summary & Best Practices

Key Takeaways

Choose the Right Pattern
- Simple audit: Row versioning or shadow tables
- Complex domains: Event sourcing
- API tracking: Middleware-based logging
GORM Integration
- Use callbacks for automatic logging
- Leverage context for audit metadata
- Implement repository pattern for clean separation
State Management
- Use state machines for complex workflows
- Enforce valid transitions at database level
- Maintain complete history with sort keys
API Audit Logging
- Log asynchronously to avoid blocking
- Sanitize sensitive data
- Use correlation IDs for distributed tracing
Performance
- Index strategically (user_id, timestamp, table_name)
- Partition large tables by date
- Archive old logs to cold storage
- Use JSONB for flexible metadata
Compliance
- Encrypt sensitive audit data
- Implement log retention policies
- Support right-to-erasure (GDPR)
- Make logs tamper-proof (write-once)
Testing
- Unit test state transitions
- Integration test audit log creation
- Verify sensitive data is sanitized
- Test concurrent state changes

New Year, New You Portfolio Challenge - Building & Deploying My Portfolio with Google Cloud Run

Akkarapon Phikulsri — Fri, 09 Jan 2026 15:22:58 +0000

New Year New You Portfolio Challenge

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Akkarapon Phikulsri — Software Engineer specializing in Go, Python, C#, and TypeScript. I build scalable systems with modern web frameworks and microservices.

Portfolio

portfolio.refactorroom.com

How I Built It

I used Google AI Studio to ideate and implement my portfolio for the New Year, New You challenge. I then refined the project locally using Antigravity Editor, enhancing each section with relevant images and showcasing my certificates.

The portfolio is built using React, TypeScript, and Tailwind CSS, focusing on a clean, responsive design and maintainable component structure.

Antigravity I leverage Antigravity to bring my concepts to life, allowing for rapid prototyping and superior design quality.

What I'm Most Proud Of

Custom Animation System Built five reusable animation components (Aurora, ClickSpark, GlitchText, Bounce, FadeContent) that bring the portfolio to life without compromising performance.

Performance-First Custom useInViewOnce hook optimizes animations using Intersection Observer, triggering only when elements enter the viewport.

Project Showcase Two distinct sections (grid + timeline) highlight 14+ projects across backend APIs, mobile apps, and full-stack applications.

Production Deployment Dockerized with Nginx, deployed to Google Cloud Run with automatic scaling—ready for real-world use.

Interactive Portfolio Experience & Leveling System
The portfolio uses an experience (XP) and leveling system that rewards visitors and unlocks sections.
Features

Five XP categories Scroll, Game, Chat, Activity, and Other
Level progression Total level combines all categories (up to 1000)
Section unlocking New sections unlock as level increases
Persistent progress XP saved in localStorage across sessions
Expandable XP bar Shows total XP and detailed category breakdown with progress bars
Level-up celebration Confetti animation on level up with notifications
Visual feedback Gradient progress bars and real-time XP tracking

3D Interactive Skills Sphere
I built an interactive 3D sphere to showcase my technical skills using React Three Fiber. Skills are distributed evenly using the Fibonacci sphere algorithm, and users can rotate and explore the sphere with smooth hover interactions.

Dark Theme Switcher
A custom Dark theme toggle button that smoothly switches between light and dark modes. It remembers user preferences, respects system settings, and includes smooth animations. The entire site, including the 3D sphere, adapts dynamically to theme changes.
Both features improve the user experience and demonstrate modern web development techniques with 3D graphics and smooth state management.

White

Dark

"Take a Break" Game

To add interactivity and a fun easter egg, I built a full-screen canvas-based game that visitors can play directly on the portfolio.

Key Features

Canvas-based gameplay Built with HTML5 Canvas and requestAnimationFrame for smooth 60fps animations
Mouse-controlled ship Players move their cursor to collect colorful orbs floating across the screen
Multiple themes Three visual themes (Space, Neon, Retro) that can be switched on the fly
XP integration Scores earn XP points that integrate with the portfolio's gamification system Animated background Procedurally generated stars that create a dynamic space environment
Collision detection Real-time collision detection using distance calculations
Full-screen immersion Full-screen overlay with hidden cursor for an immersive experience

🐍 Snake Game (Arcade Zone)

Overview
Classic Snake implemented as a responsive web game. Earn XP while playing.

Features

Responsive board 20x20 grid that adapts to screen size (12–25px cells)
Speed settings Slow, Normal, Fast, Very Fast
Controls
- Keyboard Arrow keys or WASD
- Mobile Touch direction buttons
- Spacebar to pause
Scoring 10 XP per food eaten
Game mechanics
- Grow by eating food (red pulsing dots)
- Game over on wall or self collision
- Pause/Resume
- Reset

🎯 Career Simulator Games

Example

Playgroud

Stats

Interactive role-playing scenarios based on real tech work. Earn XP through problem-solving, design decisions, and code challenges.

All simulators use a chat/log interface where you

Receive scenario briefings
Input solutions, code, or decisions
Get AI feedback from role-played colleagues (Junior/Senior Dev, Tech Lead, etc.)
Earn XP based on solution quality
Track progress with saved stats and achievements

Game List

Senior Engineer Simulator
Backend Developer Simulator
Frontend Developer Simulator
System Analysis Simulator
Project Manager Simulator
Database Admin Simulator

The Local Site-Based Simple Chatbot
Instead of relying on external AI APIs, I built a locally-powered chatbot that runs entirely client-side using a curated knowledge base.
Key Features

Zero API dependencies No external API keys or calls—everything runs locally in the browser Curated knowledge base Pre-built responses covering tech stack, projects, career, and engineering philosophy
Smart keyword matching Fuzzy matching and category-based routing to find relevant answers
Suggested questions Category-based question suggestions to guide conversations XP integration Each interaction rewards XP points, encouraging engagement
Typing indicators Realistic typing delays to simulate natural conversation flow
Privacy-first All conversations stay in the browser—no data is sent to external servers

Crafting software requires artistry, guided by imagination, grounded in logic, endlessly enduring. - Akkarapon Phikulsri

Deploy to Google Cloud Run

I will guide you through deploying a static React portfolio website to Google Cloud Run, a fully managed serverless platform.

What is Google Cloud Run?

Google Cloud Run is a fully managed compute platform that automatically scales your stateless containers. It's perfect for deploying static websites and web applications with minimal configuration. Cloud Run automatically handles

HTTPS/TLS certificates
Load balancing
Auto-scaling (including scaling to zero when not in use)
Pay-per-use pricing

Prerequisites

Before starting, ensure you have:

Google Cloud Account (already registered)
Google Cloud SDK - Will be installed in Step 1 below
Docker (optional, for local testing) Install from docker.com

Step 1 Install Google Cloud SDK

Since your internet connection may be unreliable, this step is broken into parts with checkpoints after each section. Each part can be completed independently and verified before proceeding.

Part A Choose Installation Method

First, choose your operating system and preferred installation method:

macOS

Option 1 Homebrew (Recommended - Better for Interruptions)

Homebrew handles retries and resume automatically
Easier to manage updates
Preferred if you already have Homebrew installed

Option 2 Manual Installation

Direct download from Google Cloud
Works without package managers
Requires manual updates

Linux

Option 1 Package Manager (Recommended - Better for Interruptions)

apt for Debian/Ubuntu
yum for Red Hat/CentOS/Fedora
Package managers handle retries better than manual downloads

Option 2 Manual Installation

Direct download script
Works on any Linux distribution

Windows

Option 1 Installer (Recommended)

Windows installer (.msi file)
Handles installation automatically
Can be resumed if interrupted

Option 2 Package Manager (Chocolatey/Winget)

Requires Chocolatey or Windows Package Manager
Easier updates

Part B Installation by Platform

macOS Installation

Using Homebrew (Recommended)

# Check if Homebrew is installed (if not, install from https://brew.sh)
brew --version

# Install Google Cloud SDK
brew install --cask google-cloud-sdk

# Checkpoint Verify installation started
which gcloud

If installation is interrupted

Homebrew automatically resumes from where it left off
Simply re-run brew install --cask google-cloud-sdk
Homebrew will continue from the last checkpoint

Using Manual Installation

# Step 1 Download the SDK (can be resumed if interrupted)
curl https://sdk.cloud.google.com | bash

# If download is interrupted, remove partial download and retry:
# rm -rf ~/google-cloud-sdk
# Then re-run the curl command above

# Step 2 Restart your shell or source the path
exec -l $SHELL

# Or manually add to PATH in your ~/.zshrc or ~/.bash_profile:
# echo 'source "$HOME/google-cloud-sdk/path.bash.inc"' >> ~/.zshrc
# source ~/.zshrc

Checkpoint Verify Part B Complete

# Check if gcloud is accessible
gcloud version

# If successful, you should see version information
# If command not found, restart your terminal or source your shell config

Linux Installation

Using apt (Debian/Ubuntu)

# Part 1 Add Google Cloud SDK repository
echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] https://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list

# If interrupted here, you can skip if the repository was already added (check with):
# cat /etc/apt/sources.list.d/google-cloud-sdk.list

# Part 2 Import Google Cloud public key
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key --keyring /usr/share/keyrings/cloud.google.gpg add -

# If interrupted here, check if key exists:
# sudo apt-key list | grep Google

# Part 3 Update package list
sudo apt-get update

# Part 4 Install Google Cloud SDK
sudo apt-get install google-cloud-sdk

# If installation is interrupted, apt-get will resume automatically:
# sudo apt-get install -f google-cloud-sdk

Checkpoint Verify Part B Complete

gcloud version
# Should display version information if successful

Using yum (Red Hat/CentOS/Fedora)

# Part 1 Add Google Cloud SDK repository
sudo tee -a /etc/yum.repos.d/google-cloud-sdk.repo << EOM
[google-cloud-sdk]
name=Google Cloud SDK
baseurl=https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg
       https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOM

# If interrupted here, check if repo file exists:
# cat /etc/yum.repos.d/google-cloud-sdk.repo

# Part 2 Install Google Cloud SDK
sudo yum install google-cloud-sdk

# If interrupted, yum will handle resume automatically

Checkpoint Verify Part B Complete

gcloud version
# Should display version information if successful

Using Manual Installation (Any Linux)

# Step 1 Download the SDK (can be resumed if interrupted)
curl https://sdk.cloud.google.com | bash

# If download is interrupted:
# rm -rf ~/google-cloud-sdk
# Then re-run the curl command

# Step 2 Restart shell or source the path
exec -l $SHELL

# Or add to PATH manually:
# echo 'source "$HOME/google-cloud-sdk/path.bash.inc"' >> ~/.bashrc
# source ~/.bashrc

Checkpoint Verify Part B Complete

gcloud version
# Should display version information if successful

Windows Installation

Using Installer

Download the Google Cloud SDK installer:
- Visit https://cloud.google.com/sdk/docs/install-sdk
- Download the Windows installer (.msi file)
- If download is interrupted, resume or re-download
Run the installer:
- Double-click the downloaded .msi file
- Follow the installation wizard
- If interrupted, re-run the installer (it will resume)
Checkpoint Verify Part B Complete
- Open a new Command Prompt or PowerShell window
- Run gcloud version
- Should display version information if successful

Using Chocolatey (if installed)

# Install Google Cloud SDK
choco install gcloudsdk

# Checkpoint Verify installation
gcloud version

Using Winget (Windows Package Manager)

# Install Google Cloud SDK
winget install Google.CloudSDK

# Checkpoint Verify installation
gcloud version

Part C Initialize and Authenticate

Now that gcloud is installed, initialize and authenticate:

# Step 1 Initialize gcloud
gcloud init

# This will prompt you to
# - Log in with your Google account
# - Choose or create a project
# - Set default region/zone

# If interrupted during initialization:
# Simply re-run gcloud init
# It will resume from where it left off

Alternative Manual Authentication

If gcloud init is interrupted, you can authenticate separately:

# Step 1 Authenticate
gcloud auth login

# This will open a browser for authentication
# If browser doesn't open, use gcloud auth login --no-browser

# Step 2 Set project (after authentication)
gcloud config set project YOUR_PROJECT_ID

# Step 3 Set region (optional, recommended)
gcloud config set run/region asia-southeast1
# or us-central1, europe-west1, etc.

Checkpoint Verify Part C Complete

# Verify authentication
gcloud auth list

# Should show your authenticated account with an asterisk (*)

# Verify current configuration
gcloud config list

# Should show your project, region, etc.

Part D Enable Required APIs

After authentication, enable the APIs needed for Cloud Run

# Enable Cloud Build API
gcloud services enable cloudbuild.googleapis.com

# If interrupted, check which APIs are enabled:
# gcloud services list --enabled

# Enable Cloud Run API
gcloud services enable run.googleapis.com

# Verify both APIs are enabled
gcloud services list --enabled | grep -E "cloudbuild|run"

Checkpoint Verify Part D Complete

# Should show both cloudbuild and run APIs as enabled
gcloud services list --enabled | grep -E "cloudbuild|run"

Installation Complete!

If all checkpoints passed, your Google Cloud SDK is ready. You can verify everything works:

# Full verification
gcloud version
gcloud components list
gcloud config list
gcloud auth list

Step 2 Prepare Your Application

This application uses a multi-stage Docker build:

Build stage Compiles the React application using Node.js
Production stage Serves the static files using Nginx

The Dockerfile is already configured for Cloud Run with:

Port 8080 (Cloud Run default)
Nginx configuration for SPA routing
Optimized multi-stage build

No additional configuration needed. The application is ready to deploy.

Step 3 Deploy to Cloud Run

Method 1 Direct Deployment from Source (Recommended)

This is the easiest method - Cloud Run will build and deploy your application automatically

But it also can do that if you want to build Dockerfile on your locally first before run this command

gcloud run deploy portfolio \
  --source . \
  --platform managed \
  --region asia-southeast1 \
  --allow-unauthenticated \
  --labels dev-tutorial=devnewyear2026 \
  --port 8080

if success it will show like this

Notes

Replace portfolio with your preferred service name
Choose a region closest to your users (e.g., us-central1, asia-southeast1, europe-west1)
The --labels dev-tutorial=devnewyear2026 flag is required if submitting to the Dev.to challenge
--allow-unauthenticated makes your service publicly accessible
--port 8080 matches the port exposed in your Dockerfile

Method 2 Build Docker Image First

If you prefer to build the Docker image locally or using Cloud Build:

# Build the Docker image using Cloud Build
gcloud builds submit --tag gcr.io/$(gcloud config get-value project)/portfolio

# Deploy to Cloud Run
gcloud run deploy portfolio \
  --image gcr.io/$(gcloud config get-value project)/portfolio \
  --platform managed \
  --region asia-southeast1 \
  --allow-unauthenticated \
  --labels dev-tutorial=devnewyear2026 \
  --port 8080

Method 3 Using Cloud Build Config

You can also use the provided cloudbuild.yaml:

gcloud builds submit --config cloudbuild.yaml

Then deploy the built image:

gcloud run deploy portfolio \
  --image gcr.io/$(gcloud config get-value project)/portfolio \
  --platform managed \
  --region asia-southeast1 \
  --allow-unauthenticated \
  --labels dev-tutorial=devnewyear2026 \
  --port 8080

Step 4 Verify Deployment

After deployment, Cloud Run will provide you with a URL

https://portfolio-xxxxx-uc.a.run.app

Visit the URL to verify your portfolio is live! Cloud Run automatically provides:

HTTPS encryption
A custom domain (or you can configure your own)
Global CDN distribution

Step 5 Update and Redeploy

To update your application after making changes

# Simply redeploy (Cloud Run will rebuild if needed)
gcloud run deploy portfolio \
  --source . \
  --platform managed \
  --region asia-southeast1 \
  --allow-unauthenticated \
  --labels dev-tutorial=devnewyear2026 \
  --port 8080

Cost Considerations

Google Cloud Run offers a generous free tier

CPU First 240,000 vCPU-seconds free per month
Memory First 450,000 GiB-seconds free per month
Requests First 2 million requests free per month

For a portfolio website with moderate traffic, you should stay well within the free tier. Cloud Run only charges when requests are being processed (scales to zero).

Useful Commands

# List all Cloud Run services
gcloud run services list

# View service details
gcloud run services describe portfolio --region asia-southeast1

# View logs
gcloud run services logs read portfolio --region asia-southeast1

# Delete service
gcloud run services delete portfolio --region asia-southeast1

# View service URL
gcloud run services describe portfolio --region asia-southeast1 --format='value(status.url)'

Good luck with your deployment! 🚀

Node.js + Fastify + Sequelize + MySQL

Akkarapon Phikulsri — Fri, 09 Jan 2026 03:09:05 +0000

This course is based on this template

akkaraponph / nodejs-ts-fastify-mvc-starter-template

This repo node api crud template - folder-by-type

Node.js TypeScript Fastify MVC Starter Template

A production-ready starter template for building RESTful APIs with Node.js, TypeScript, and Fastify. This template follows the MVC (Model-Routes-Controllers-Services) architecture pattern, providing a clean and scalable foundation for your backend projects.

🚀 Features

Fastify - Fast and low overhead web framework
TypeScript - Type-safe development
Sequelize ORM - Database abstraction with PostgreSQL/MySQL support
JWT Authentication - Secure token-based authentication
Swagger Documentation - Auto-generated API documentation
CORS Support - Cross-origin resource sharing configured
Error Handling - Custom error handling middleware
MVC Architecture - Clean separation of concerns
Environment Configuration - Multi-environment support (dev, test, production)

📁 Project Structure

├── src/
│   ├── app.ts                 # Fastify app configuration
│   ├── config/                # Configuration files
│   │   ├── config.ts          # Environment variables
│   │   ├── db.config.ts       # Database configuration
│   │   └── swagger/           # Swagger documentation setup
│   ├── controllers/           # Request handlers (business logic)
│   ├──

…

Flag

This YouTube tutorial is in Thai. I’m keeping this post in English so everyone can quickly understand the main concepts alongside the video. For deeper understanding, feel free to ask ChatGPT or your favorite AI.

What you will learn

This course teaches you how to build an API using:

Node.js
Fastify (a web framework)
Sequelize (for working with databases)
MySQL (database)

About MRCS

MRCS means Model-Routes-Controllers-Services. This is a way to organize your code. It helps you keep your code clean and easy to understand.

BillowDev Youtube

Setup Videos

Watch these videos first to install the tools you need:

How to Install Git and using GitHub

How to Install Node.js and VS code

How to Install Laragon

Node js TypeScript Fastify EP 01 Intro

In this episode, you will learn how to start your project and create your first API.

Step 1: Start a new project

First, create a new Node.js project. Open your terminal and type:

npm init -y

This command creates a file called package.json. This file stores information about your project.

Step 2: Using Yarn (Optional)

You can use npm or yarn. Both are package managers. They help you install libraries for your project.

If you want to use yarn, install it first:

npm install -g yarn

Here are the yarn commands you need to know:

npm install is the same as yarn add
npm install -D is the same as yarn add -D
npm run is the same as yarn

Step 3: Install TypeScript tools

You need to install TypeScript and some tools. TypeScript is a language that adds types to JavaScript.

Type this command in your terminal:

npm install --save-dev ts-node @types/node typescript

Or if you use yarn:

yarn add -D ts-node @types/node typescript

Step 4: Create TypeScript config file

Now create a TypeScript configuration file. This file tells TypeScript how to work with your code.

Type this command:

npx tsc --init

This creates a file called tsconfig.json. Copy this code into that file:

tsconfig.json

{
  "compilerOptions": {
    /* Visit https://aka.ms/tsconfig to read more about this file */
    /* Language and Environment */
    "target": "ESNext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */

    /* Modules */
    "module": "commonjs",                                /* Specify what module code is generated. */
    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
    "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
    "baseUrl": "./src",                                  /* Specify the base directory to resolve non-relative module names. */
    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */

    /* Type Checking */
    "strict": true,                                      /* Enable all strict type-checking options. */
    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
  },
  "include": [
    "**/*.ts"
, "src/config/db.config.ts"  ],
  "exclude": [
    "node_modules",
    "**/*.d.ts",
    "**/*.spec.ts"
  ]
}

Step 5: Install Fastify

Fastify is a web framework. It helps you build APIs quickly.

Install it with this command:

npm install fastify

Or if you use yarn:

yarn add fastify

Step 6: Create your first file

Create a new file called index.ts in your project root folder.

Step 7: Write your first API

Now you will write code to create your first API. Follow these steps:

Step 7.1: Import Fastify

import fastify from "fastify";

This line imports the Fastify library.

Step 7.2: Create the app

Next, create your app:

const app = fastify()

Step 7.3: Create your first route

A route is a URL that your API can respond to. Create your first route:

app.get("/", async () => "SERVER");

This creates a route at "/". When someone visits this URL, they will see "SERVER".

Step 7.4: Start your server

Now you need to start your server. Add this code:

    const PORT = 5000
    app.listen({port:Number(PORT)}, (err) => {
        if (err) {
            console.error(err)
            process.exit(1)
        }
        console.log(`SERVE ON ${PORT}`)
    })

This code starts your server on port 5000.

Step 7.5: Run your API

Save your file. Then open your terminal and type:

ts-node index.ts

You should see the message "SERVE ON 5000" in your terminal. This means your API is running!

Step 8: Make your logs look better

The logs help you see what your API is doing. Let's make them look better.

Step 8.1: Add logging options

Change your app code to this:

const app = fastify({
    logger: true
})

This turns on logging.

Step 8.2: Update your listen code

Replace the code from step 7.4 with this:

    const PORT = 5000
    app.listen({port:Number(PORT)}, (err) => {
        if (err) {
            app.log.error(err);
            process.exit(1)
        }
        app.log.info(`SERVE ON ${PORT}`)
    })

This uses the logger instead of console.log.

Step 8.3: See your logs

When you run your API now, you will see logs like this:

{"level":30,"time":1676779096246,"pid":25344,"hostname":"billo","msg":"Server listening at http://[::1]:5000"}
{"level":30,"time":1676779096248,"pid":25344,"hostname":"billo","msg":"Server listening at http://127.0.0.1:5000"}
{"level":30,"time":1676779096248,"pid":25344,"hostname":"billo","msg":"SERVE ON 5000"}

Step 9: Test your API

You can test your API with Thunder Client. It is a tool for testing APIs. You can find it in the Visual Studio Code extensions.

You can also use other tools like Postman or Insomnia. These tools let you test different HTTP methods like GET, POST, PUT, PATCH, and DELETE. If your API uses GET method, you can also test it in your browser.

Node js TypeScript Fastify EP 02 Thunder client

In this episode, you will learn how to test your API using Thunder Client.

What is Thunder Client?

Thunder Client is a tool for testing APIs. It works inside Visual Studio Code. You can use it to send requests to your API and see the responses.

Step 1: Install Thunder Client

Open Visual Studio Code. Go to the Extensions section. Search for "Thunder Client" and install it.

Step 2: How to use Thunder Client

After installing Thunder Client, you will see a new icon in your sidebar. Click on it to open Thunder Client. You can create requests and test your API there.

Your complete index.ts file

After following all the steps in EP 01, your index.ts file should look like this:

import fastify from "fastify";

const app = fastify({
    logger: true
})

app.get("/", async () => "SERVER");

const PORT = 5000
app.listen({port:Number(PORT)}, (err) => {
    if (err) {
        app.log.error(err);
        process.exit(1)
    }
    app.log.info(`SERVE ON ${PORT}`)
})

Node js TypeScript Fastify EP 03 App

In this episode, you will learn how to organize your code better. We will move the app logic to a separate file.

Why organize code?

When your code grows, it is better to organize it. This makes your code easier to read and maintain. We will create a src folder and put our code there.

Step 1: Create the src folder

First, create a new folder called src in your project root.

Step 2: Move app logic to src/app.ts

Create a new file called app.ts inside the src folder. Move the app creation code there.

Code for src/app.ts

import fastify, { FastifyServerOptions } from "fastify";

const App = (options: FastifyServerOptions) => {
    const app = fastify(options)

    app.get("/", async () => "SERVER");
    return app
}
export default App

This code creates a function called App. This function takes options and creates a Fastify app. It returns the app so you can use it later.

Code for index.ts

Now update your index.ts file. Import the App function and use it to create your app:

import App from "./src/app";

const app = App({
    logger: true
})
const PORT = 5000
app.listen({port:Number(PORT)}, (err) => {
    if (err) {
        app.log.error(err);
        process.exit(1)
    }
    app.log.info(`SERVE ON ${PORT}`)
})

What changed?

Before: All your code was in index.ts
After: The app logic is in src/app.ts, and index.ts only starts the server

This makes your code more organized. When you add more features, you will add them to the src folder.

Node js TypeScript Fastify EP 04 Routes

In this episode, you will learn how to create routes. Routes are URLs that your API responds to.

What is a route?

A route is a URL path. When someone visits that URL, your API responds. For example, /api/v1/articles is a route.

Step 1: Create the routes folder

Create a new folder called routes inside the src folder.

Step 2: Create article route file

Create a new file called article.route.ts inside the src/routes folder.

Step 3: Write the route code

import { FastifyInstance } from "fastify";

const articleRouter = async (app: FastifyInstance) => {
    // This is sample data for testing
    const article = {
        id: "1",
        name: "node.js fastify",
        desc: "Fast and easy course for building APIs"
    }

    // Create a GET route at "/"
    app.get(
        "/",
        () => {
            return {
                articles: [
                    article
                ]
            }
        }
    );
};

export default articleRouter;

This code creates a router for articles. It has one route that returns sample data.

Step 4: Create routes index file

Create a new file called index.ts inside the src/routes folder. This file exports all your routes.

import articleRouter from "./article.route";

export { articleRouter };

Step 5: Register the route in app.ts

Now you need to tell your app to use this route. Update your src/app.ts file.

import fastify, { FastifyServerOptions } from "fastify";
import { articleRouter } from "./routes";

const App = (options: FastifyServerOptions) => {
    const app = fastify(options)

    app.get("/", async () => "SERVER");
    // Register the article router with a prefix
    app.register(articleRouter, { prefix: "/api/v1/articles" });
    return app
}
export default App

The prefix means all article routes will start with /api/v1/articles.

Step 6: Test your route

Stop your server by pressing CTRL + C in your terminal
Start it again with: ts-node index.ts
Open Thunder Client and test the route: http://localhost:5000/api/v1/articles

Result

You should see the article data when you visit the route:

Node js TypeScript Fastify EP 05 Controllers

In this episode, you will learn about controllers. Controllers handle the logic for your routes.

What is a controller?

A controller is a function that handles requests. When someone visits a route, the controller decides what to do and what to return.

Step 1: Create controllers folder

Create a new folder called controllers inside the src folder.

Step 2: Create article controller

Create a new file called article.controller.ts inside the src/controllers folder.

export const handleGetArticle = () => {
    // This is sample data for testing
    const article = {
        id: "1",
        name: "node.js fastify",
        desc: "Fast and easy course for building APIs"
    }
    return {
        articles: [
            article
        ]
    }
}

export default {
    handleGetArticle
}

This controller function returns article data. Later, it will get data from a service.

Step 3: Create controllers index file

Create a new file called index.ts inside the src/controllers folder.

import articlesController from "./article.controller";
export { articlesController };

Step 4: Update the route to use the controller

Now update your src/routes/article.route.ts file to use the controller.

import { FastifyInstance } from "fastify";
import articleController from './../controllers/article.controller';

const articleRouter = async (app: FastifyInstance) => {
    // Use the controller function as the handler
    app.get(
        "/",
        articleController.handleGetArticle
    );
};

export default articleRouter;

Now your route uses the controller. This separates the route logic from the business logic.

Node js TypeScript Fastify EP 06 Services

In this episode, you will learn about services. Services contain the business logic of your application.

What is a service?

A service is where you put your business logic. It handles things like getting data or processing information. Controllers call services.

Step 1: Create services folder

Create a new folder called services inside the src folder.

Step 2: Create article service

Create a new file called article.service.ts inside the src/services folder.

export const getArticles = () => {
    const data = {
        id: "1",
        name: "node.js fastify",
        desc: "Fast and easy course for building APIs"
    }

    return { response: data }
}

export default {
    getArticles
}

This service function returns article data. Later, it will get data from a database.

Step 3: Create services index file

Create a new file called index.ts inside the src/services folder.

import articleService from "./article.service";
export { articleService };

Step 4: Update the controller to use the service

Now update your src/controllers/article.controller.ts file to use the service.

import { articleService } from "../services";

export const handleGetArticle = () => {
    return articleService.getArticles()
}

export default {
    handleGetArticle
}

Now your controller calls the service. This separates the request handling from the business logic.

Node js TypeScript Fastify EP 07 MySQL Database

In this episode, you will learn how to set up MySQL database using Laragon.

What is MySQL?

MySQL is a database. It stores your data in tables. You will use it to store articles and other information.

What is Laragon?

Laragon is a tool that helps you run MySQL on your computer. It makes it easy to start and manage MySQL.

Step 1: Install Laragon

First, install Laragon. Follow this video: How to Install Laragon

Step 2: Start Laragon server

Open Laragon and click the "Start All" button to start the MySQL server.

Step 3: Open MySQL

Click on the "Database" button in Laragon to open the database manager.

Step 4: Create a new database

Click on "Database" in the left sidebar
Right-click and select "Create Database"

Step 5: Name your database

Name your database node_fastify_db and click "OK".

Great! Your database is ready. In the next episode, you will learn how to connect your API to this database.

Node js TypeScript Fastify EP 08 Sequelize

In this episode, you will learn how to connect your API to the database using Sequelize.

What is Sequelize?

Sequelize is an ORM (Object-Relational Mapping). It helps you talk to your database. You use models to work with database tables.

What is dotenv?

Dotenv is a package that helps you use environment variables. Environment variables store secret information like database passwords. You put them in a .env file.

What is mysql2?

mysql2 is a driver for MySQL. It allows your code to connect to MySQL database. If you use PostgreSQL, you would use pg instead.

Step 1: Install packages

Install Sequelize, dotenv, and mysql2:

npm install sequelize dotenv mysql2

Or if you use yarn:

yarn add sequelize dotenv mysql2

Step 2: Create .env file

Create a new file called .env in your project root. This file stores your database settings.

Important: The default MySQL username in Laragon is root and the password is empty "".

We separate the settings for different environments: development, production, and test.

NODE_ENV=development

DB_USERNAME_DEV=root
DB_PASSWORD_DEV=""
DB_DATABASE_DEV=node_fastify_db
DB_HOST_DEV=localhost

DB_USERNAME_PROD=root
DB_PASSWORD_PROD=""
DB_DATABASE_PROD=node_fastify_db_production
DB_HOST_PROD=localhost

DB_USERNAME_TEST=root
DB_PASSWORD_TEST=""
DB_DATABASE_TEST=node_fastify_db_test
DB_HOST_TEST=localhost

DB_DIALECT=mysql

Step 3: Create config files

We need to create config files to use the .env file. First, we import dotenv. Then we create a config that reads values from the .env file.

Step 3.1: Create config.ts

Create a new folder called config inside the src folder. Then create a file called config.ts inside src/config.

import dotenv from "dotenv";
dotenv.config();

const config = {
  env: process.env.NODE_ENV || "development",
  port: process.env.PORT || 5000,
  database: {
    dev: {
      username: process.env.DB_USERNAME_DEV,
      password: process.env.DB_PASSWORD_DEV,
      name: process.env.DB_DATABASE_DEV,
      host: process.env.DB_HOST_DEV,
    },
    production:{
      username: process.env.DB_USERNAME_PROD,
      password: process.env.DB_PASSWORD_PROD,
      name: process.env.DB_DATABASE_PROD,
      host: process.env.DB_HOST_PROD,
    },
    test: {
      username: process.env.DB_USERNAME_TEST,
      password: process.env.DB_PASSWORD_TEST,
      name: process.env.DB_DATABASE_TEST,
      host: process.env.DB_HOST_TEST,
    },
    dialect: process.env.DB_DIALECT,
  },
};

export default config;

Step 3.2: Create db.config.ts

Create a new file called db.config.ts inside the src/config folder.

import config from "./config"; // this is important!

module.exports = {
  development: {
    username: config.database.dev.username,
    password: config.database.dev.password,
    database: config.database.dev.name,
    host: config.database.dev.host,
    dialect: config.database.dialect,
  },
  test: {
    username: config.database.test.username,
    password: config.database.test.password,
    database: config.database.test.name,
    host: config.database.test.host,
    dialect: config.database.dialect,
  },
  production: {
    username: config.database.production.username,
    password: config.database.production.password,
    database: config.database.production.name,
    host: config.database.production.host,
    dialect: config.database.dialect,
  },
};

Step 4: Create models

Models represent your database tables. They define what data you can store.

Step 4.1: Create types folder

Create a new folder called types inside the src folder.

Step 4.2: Create article model types

Create a new folder called articles inside the src/types folder. Then create a file called article.model.types.ts inside src/types/articles.

export interface ArticleAttributes {
  id?: string;
  title?: string;
  text?: string;
  type?: string;
  UserId?: string;
  createdAt?: Date;
  updatedAt?: Date;
}

Step 4.3: Create models folder

Create a new folder called models inside the src folder.

Step 4.4: Create models/index.ts

Create a new file called index.ts inside the src/models folder.

Note: The code below is usually generated by sequelize-cli. But for TypeScript, we modified it to read config from ../config/db.config.ts.

"use strict";

const fs = require("fs");
const path = require("path");
const basename = path.basename(__filename);
const Sequelize = require("sequelize");
const env = process.env.NODE_ENV || "development";
const config = require(__dirname + "/../config/db.config.ts")[env];
const db: any = {};

let sequelize: any;
if (config.use_env_variable) {
  sequelize = new Sequelize(process.env[config.use_env_variable], config);
} else {
  sequelize = new Sequelize(
    config.database,
    config.username,
    config.password,
    config
  );
}

fs.readdirSync(__dirname)
  .filter((file: string) => {
    return (
      file.indexOf(".") !== 0 && file !== basename && file.slice(-3) === ".ts"
    );
  })
  .forEach((file: any) => {
    const model = require(path.join(__dirname, file))(
      sequelize,
      Sequelize.DataTypes
    );
    db[model.name] = model;
  });

Object.keys(db).forEach((modelName) => {
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

db.sequelize = sequelize;
db.Sequelize = Sequelize;

export default db;

Step 4.5: Create article model

Create a new file called article.model.ts inside the src/models folder.

This file defines the Article model. The models/index.ts file will automatically read this file and create the model based on what you declare.

"use strict";
import * as Sequelize from "sequelize";
import { Model, UUIDV4 } from "sequelize";
import { ArticleAttributes } from "types/articles/article.model.types";

module.exports = (sequelize: any, DataTypes: any) => {
  class Article
    extends Model<ArticleAttributes>
    implements ArticleAttributes
  {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    id!: string;
    title!: string;
    text!: string;
    type!: string;
    static associate(models: any) {
      // define association here

    }
  }
  Article.init(
    {
      id: {
        type: DataTypes.UUID,
        defaultValue: UUIDV4,
        allowNull: false,
        primaryKey: true,
      },
      title: {
        type: DataTypes.STRING,
        allowNull: false,
      },
      text: {
        type: DataTypes.STRING(500),
      },
    },
    {
      sequelize,
      modelName: "Article",
    }
  );
  return Article;
};

Step 4.6: Update index.ts

Now update your index.ts file to:

Import the database and config files
Get the PORT from the config file
Sync the database with Sequelize (this creates the tables)

import App from "./src/app";
import db from "./src/models"
import config from "./src/config/config"

const app = App({
    logger: true
})
const PORT: string | number = config.port

db.sequelize.sync().then(() => {
app.listen({port:Number(PORT)}, (err) => {
    if (err) {
        app.log.error(err);
        process.exit(1)
    }
    app.log.info(`SERVE ON ${PORT}`)
})
})

Step 5: Use nodemon for development

Nodemon automatically restarts your app when you change the code. This is very helpful during development.

Important: Only use nodemon in development. It will restart your app every time you save a file.

Step 5.1: Install nodemon

npm install -D nodemon

Or if you use yarn:

yarn add -D nodemon

Step 5.2: Add script to package.json

Open your package.json file. Find the "scripts" section and add this line:

"dev": "nodemon index.ts"

Step 5.3: Run your app

Now you can run your app with:

npm run dev

Or if you use yarn:

yarn dev

Your app will automatically restart when you change your code!

Bonus: Complete CRUD API Example

This is a bonus section. You will learn how to create a complete CRUD API. CRUD means Create, Read, Update, and Delete.

Note: This section does not have a video tutorial. Follow the steps below to build a complete Articles API.

What you will build

You will create an Articles API with these operations:

GET - Get all articles
GET - Get one article by ID
POST - Create a new article
PUT - Update an article
DELETE - Delete an article

How it works

The flow is: routes → controllers → services → models (Sequelize) → MySQL database

Step 1: Update routes

We will create 5 routes in the article router. Each route calls a controller function.

import { FastifyInstance } from "fastify";
import articleController from './../controllers/article.controller';

const articleRouter = async (app: FastifyInstance) => {
    // GET all articles
    app.get(
        "/",
        articleController.handleGetArticle
    );

    // GET one article by ID
    app.get(
        "/get/:id",
        articleController.handleGetArticleById
    );

    // POST create a new article
    app.post(
        "/create",
        articleController.handleCreateArticle
    );

    // PUT update an article
    app.put(
        "/update/:id",
        articleController.handleUpdateArticle
    );

    // DELETE delete an article
    app.delete(
        "/delete/:id",
        articleController.handleDeleteArticle
    );
};

export default articleRouter;

Step 2: Create request types

We need to define types for the request data. This helps TypeScript understand what data to expect.

Create a new file called article.controller.types.ts inside src/types/articles.

import { FastifyRequest } from "fastify";
export type RequestWithIdArticle = FastifyRequest<{
    Params: { id: string };
}>;


export type UpdateArticleRequest = FastifyRequest<{
    Params: { id: string };
    Body: {
        title?: string | undefined;
        text?: string | undefined;
        type?: string | undefined;
    };
}>;

export type ArticleCreateRequest = FastifyRequest<{
    Body: {
        title?: string | undefined;
        text?: string | undefined;
        type?: string | undefined;
    };
}>;

Step 3: Update controllers

In the article controller, we will create handler functions. Each function calls a service function.

import { ArticleCreateRequest, RequestWithIdArticle, UpdateArticleRequest } from "types/articles/article.controller.types";
import { ArticleAttributes } from "types/articles/article.model.types";
import { articleService } from "../services";


export const handleGetArticle = async () => {
    return articleService.getArticles()
}

export const handleGetArticleById = async (req: RequestWithIdArticle) => {
    const id = req.params.id;
    return articleService.getOneArticle(id)
}

export const handleCreateArticle = async (req: ArticleCreateRequest) => {
    const { title, text, type } = req.body
    return articleService.createArticle({ title, text, type })
}

export const handleUpdateArticle = async (req: UpdateArticleRequest) => {
    const { title, text, type } = req.body
    return articleService.updateArticle(req.params.id, { title, text, type })
}

export const handleDeleteArticle = async (req: RequestWithIdArticle) => {
    return articleService.deleteArticle(req.params.id)
}

export default {
    handleGetArticle,
    handleGetArticleById,
    handleCreateArticle,
    handleUpdateArticle,
    handleDeleteArticle
}

Step 4: Update services

In the article service, we create functions that use Sequelize to interact with the database.

import { ArticleAttributes } from "types/articles/article.model.types";
import db from "../models";
const ArticleModel = db.Article

export const getArticles = async (): Promise<ArticleAttributes[]> => {
    const response = await ArticleModel.findAll();
    return response
}

export const getOneArticle = async (id: string): Promise<ArticleAttributes> => {
    const response: ArticleAttributes = await ArticleModel.findByPk(id)
    return response
}

export const createArticle = async (body: ArticleAttributes): Promise<ArticleAttributes> => {
    const response: ArticleAttributes = await ArticleModel.create(body)
    return response
}

export const updateArticle = async (id: string, body: ArticleAttributes) => {
    const response = await ArticleModel.update({ ...body }, { where: { id } })
    return response
}

export const deleteArticle = async (id: string) => {
    const response = await ArticleModel.destroy({ where: { id } });
    return response
}

export default {
    getArticles,
    getOneArticle,
    createArticle,
    updateArticle,
    deleteArticle
}

Step 5: Test your API

Now you can test all the routes using Thunder Client. Here are examples of the results:

GET all articles

Visit GET http://localhost:5000/api/v1/articles to get all articles:

GET one article

Visit GET http://localhost:5000/api/v1/articles/get/:id to get one article (replace :id with an article ID):

CREATE article

Send a POST request to http://localhost:5000/api/v1/articles/create with article data in the body:

UPDATE article

Send a PUT request to http://localhost:5000/api/v1/articles/update/:id with updated data in the body:

DELETE article

Send a DELETE request to http://localhost:5000/api/v1/articles/delete/:id to delete an article:

Congratulations! You now have a complete CRUD API working with a database!

Atomic Transaction Patterns C#

Akkarapon Phikulsri — Thu, 08 Jan 2026 05:51:39 +0000

Pattern	Consistency	Scale	Complexity	Suitable For
Pessimistic Locking	Strong	Low	Low	Monoliths, legacy systems
Saga Pattern	Eventual	High	High	Microservices
CQRS	Eventual	High	High	Read-heavy systems, DDD
Mediator	Depends	Med	Medium	Coordinated command handling
Event Sourcing	Eventual	High	High	Auditable systems
Two-Phase Commit	Strong	Low	High	Cross-DB transactional ops
Outbox Pattern	Eventual	High	Medium	DB + messaging consistency

Two powerful transaction patterns for modern applications: AtomicService for ACID transactions and SagaPatternService for distributed transactions with eventual consistency.

🎯 Overview

This library offers two complementary approaches to handle transactions in both monolithic and distributed architectures:

Pattern	Use Case	Consistency	Scope	Recovery
AtomicService	Single service/database	Immediate (ACID)	Local operations	Transaction rollback
SagaPatternService	Multiple services	Eventual	Distributed operations	Compensating actions

✨ Features

🛡️ AtomicService (ACID Transactions)

Hierarchical Transactions - Parent-child transaction support
Enhanced Retry Logic - Configurable retry with exponential backoff
Performance Monitoring - Built-in metrics and correlation tracking
Multiple Isolation Levels - ReadCommitted, RepeatableRead, Serializable
Deadlock Detection - Smart handling of transient database errors
Flexible Configuration - Per-operation timeouts and retry policies

🌐 SagaPatternService (Distributed Transactions)

Compensating Actions - Automatic rollback through compensation
State Persistence - Durable saga state with resume capability
Step Orchestration - Sequential, conditional, and parallel execution
Error Recovery - Comprehensive error handling and retry strategies
Monitoring & Observability - Full saga lifecycle tracking
Integration Ready - Works seamlessly with AtomicService

🚀 Quick Start

Basic Setup

// Program.cs
using Persistence.Database;

var builder = WebApplication.CreateBuilder(args);

// Configure AtomicService
builder.Services.Configure<AtomicServiceOptions>(options =>
{
    options.MaxRetryAttempts = 3;
    options.TransactionTimeout = TimeSpan.FromMinutes(5);
    options.DefaultIsolationLevel = IsolationLevel.ReadCommitted;
});

// Configure SagaPatternService
builder.Services.Configure<SagaPatternOptions>(options =>
{
    options.StepTimeout = TimeSpan.FromMinutes(5);
    options.MaxRetryAttempts = 3;
    options.EnableStateLogging = true;
});

// Register services
builder.Services.AddScoped<IAtomicService, AtomicService>();
builder.Services.AddScoped<ISagaStateStore, InMemorySagaStateStore>();
builder.Services.AddScoped<ISagaPatternService, SagaPatternService>();

var app = builder.Build();

📖 Usage Examples

AtomicService - Local ACID Transactions

public class OrderService
{
    private readonly IAtomicService _atomicService;

    // Simple atomic operation
    public async Task CreateOrderAsync(Order order)
    {
        await _atomicService.ExecuteAtomicallyAsync(async () =>
        {
            await _orderRepository.CreateAsync(order);
            await _auditRepository.LogAsync(order.Id, "OrderCreated");
            await _notificationService.SendConfirmationAsync(order.CustomerId);
        });
    }

    // Parent-child hierarchical transaction
    public async Task ProcessComplexOrderAsync(Order order)
    {
        await _atomicService.ExecuteAsParentAsync(async () =>
        {
            await CreateOrderAsync(order); // Child transaction
            await _paymentService.ProcessPaymentAsync(order.Payment); // Child transaction
            await _inventoryService.ReserveItemsAsync(order.Items); // Child transaction
        });
    }

    // With custom options
    public async Task ProcessCriticalOrderAsync(Order order)
    {
        var options = new AtomicOperationOptions
        {
            OperationName = "CriticalOrderProcessing",
            IsolationLevel = IsolationLevel.Serializable,
            Timeout = TimeSpan.FromMinutes(10),
            MaxRetryAttempts = 5
        };

        await _atomicService.ExecuteAtomicallyAsync(async () =>
        {
            // Critical business logic here
        }, options);
    }
}

SagaPatternService - Distributed Transactions

public class DistributedOrderService
{
    private readonly ISagaPatternService _sagaService;

    public async Task<SagaExecutionResult> ProcessDistributedOrderAsync(OrderRequest request)
    {
        var context = new OrderSagaContext(request);

        var steps = new List<ISagaStep<OrderSagaContext>>
        {
            // Step 1: Process Payment
            SagaStepBuilder.Create<OrderSagaContext>(
                "ProcessPayment", 1,
                executeAction: async (ctx, ct) =>
                {
                    var payment = await _paymentService.ChargeAsync(ctx.OrderRequest.Payment);
                    ctx.PaymentId = payment.Id;
                    return StepResult.Success;
                },
                compensateAction: async (ctx, ct) =>
                {
                    if (!string.IsNullOrEmpty(ctx.PaymentId))
                    {
                        await _paymentService.RefundAsync(ctx.PaymentId);
                    }
                    return StepResult.Success;
                }
            ),

            // Step 2: Reserve Inventory
            SagaStepBuilder.Create<OrderSagaContext>(
                "ReserveInventory", 2,
                executeAction: async (ctx, ct) =>
                {
                    var reservation = await _inventoryService.ReserveAsync(ctx.OrderRequest.Items);
                    ctx.ReservationId = reservation.Id;
                    return StepResult.Success;
                },
                compensateAction: async (ctx, ct) =>
                {
                    if (!string.IsNullOrEmpty(ctx.ReservationId))
                    {
                        await _inventoryService.ReleaseAsync(ctx.ReservationId);
                    }
                    return StepResult.Success;
                }
            ),

            // Step 3: Schedule Shipping
            SagaStepBuilder.Create<OrderSagaContext>(
                "ScheduleShipping", 3,
                executeAction: async (ctx, ct) =>
                {
                    var shipping = await _shippingService.ScheduleAsync(ctx.OrderRequest);
                    ctx.Data["ShippingId"] = shipping.Id;
                    return StepResult.Success;
                },
                compensateAction: async (ctx, ct) =>
                {
                    if (ctx.Data.TryGetValue("ShippingId", out var shippingId))
                    {
                        await _shippingService.CancelAsync(shippingId.ToString()!);
                    }
                    return StepResult.Success;
                }
            )
        };

        return await _sagaService.ExecuteSagaAsync(context, steps);
    }
}

Hybrid Approach - Best of Both Worlds

public class HybridOrderService
{
    public async Task<StepResult> ProcessOrderDataAsync(OrderContext context, CancellationToken ct)
    {
        // Use AtomicService for local consistency within saga steps
        await _atomicService.ExecuteAtomicallyAsync(async () =>
        {
            // Local ACID operations within the distributed saga step
            await _orderRepository.CreateAsync(context.Order);
            await _auditRepository.LogAsync(context.Order.Id, "OrderCreated");
            await _customerRepository.UpdateOrderCountAsync(context.Order.CustomerId);
        }, new AtomicOperationOptions
        {
            OperationName = "SagaStep.LocalOrderData",
            CorrelationData = new Dictionary<string, object>
            {
                ["SagaId"] = context.SagaId,
                ["OrderId"] = context.Order.Id
            }
        });

        return StepResult.Success;
    }
}

🎯 When to Use Which Pattern

Use AtomicService When:

✅ Single service operations - All operations within one service/database
✅ Need immediate consistency - ACID properties required
✅ Traditional database transactions - Relational database operations
✅ Parent-child service relationships - Hierarchical transaction coordination
✅ Short-lived operations - Transactions that complete quickly

Use Saga Pattern When:

✅ Multiple microservices involved - Cross-service coordination needed
✅ External API integrations - Third-party services in the flow
✅ Long-running business processes - Operations that take significant time
✅ Need eventual consistency - Can tolerate temporary inconsistency
✅ Distributed architecture - Services across different databases/systems

Use Both Together When:

🚀 Each saga step needs local ACID guarantees - Best of both worlds
🚀 Distributed coordination with local consistency - Hybrid approach
🚀 Complex business processes - Spanning multiple services with local data integrity

🏗️ Architecture Overview

graph TB
    A[Client Request] --> B{Transaction Type?}

    B -->|Local Operations| C[AtomicService]
    B -->|Distributed Operations| D[SagaPatternService]
    B -->|Hybrid| E[Both Services]

    C --> C1[Transaction Scope]
    C --> C2[Retry Logic]
    C --> C3[Performance Monitoring]

    D --> D1[Saga Steps]
    D --> D2[Compensation Actions]
    D --> D3[State Persistence]

    E --> E1[Saga Orchestration]
    E1 --> E2[Step 1: AtomicService]
    E1 --> E3[Step 2: AtomicService]
    E1 --> E4[Step N: AtomicService]

    C1 --> F[Database]
    D3 --> G[Saga State Store]
    E2 --> F
    E3 --> F
    E4 --> F

📊 Performance Characteristics

Pattern	Latency	Throughput	Consistency	Complexity	Scalability
AtomicService	Low	High	Strong	Low	Vertical
SagaPattern	Medium	Medium	Eventual	Medium	Horizontal
Hybrid	Medium	High	Mixed	High	Both

📚 Documentation

Core Documentation

AtomicService Usage Guide - Comprehensive guide for ACID transactions
Saga Pattern Usage Guide - Complete saga implementation guide
API Reference - Full API documentation
Configuration Guide - Setup and configuration options

Examples & Tutorials

E-commerce Order Processing - Real-world e-commerce example
Banking Transfers - Financial transaction examples
Microservices Integration - Cross-service coordination
Performance Optimization - High-throughput scenarios

Advanced Topics

Error Handling Strategies - Comprehensive error management
Monitoring & Observability - Metrics and logging
Testing Strategies - Unit and integration testing
Production Deployment - Production considerations

🛠️ Configuration Options

AtomicService Configuration

public class AtomicServiceOptions
{
    public int MaxRetryAttempts { get; set; } = 3;
    public TimeSpan BaseRetryDelay { get; set; } = TimeSpan.FromMilliseconds(100);
    public TimeSpan TransactionTimeout { get; set; } = TimeSpan.FromMinutes(5);
    public IsolationLevel DefaultIsolationLevel { get; set; } = IsolationLevel.ReadCommitted;
    public bool EnablePerformanceLogging { get; set; } = true;
    public bool EnableDistributedTransactions { get; set; } = false;
}

SagaPatternService Configuration

public class SagaPatternOptions
{
    public TimeSpan StepTimeout { get; set; } = TimeSpan.FromMinutes(5);
    public TimeSpan CompensationTimeout { get; set; } = TimeSpan.FromMinutes(10);
    public int MaxRetryAttempts { get; set; } = 3;
    public TimeSpan RetryDelay { get; set; } = TimeSpan.FromSeconds(1);
    public bool EnableStateLogging { get; set; } = true;
    public bool EnableCompensationLogging { get; set; } = true;
}

🔍 Monitoring & Observability

Both services provide comprehensive monitoring capabilities:

Built-in Metrics

Transaction success/failure rates
Operation duration and performance
Retry attempt tracking
Compensation execution monitoring
Resource usage statistics

Logging Integration

Structured logging with correlation IDs
Performance logging for optimization
Error tracking with context
Saga state change events

Health Checks

// Built-in health checks
services.AddHealthChecks()
    .AddCheck<AtomicServiceHealthCheck>("atomic-service")
    .AddCheck<SagaPatternHealthCheck>("saga-pattern");

🧪 Testing

Unit Testing

[Test]
public async Task AtomicService_Should_Rollback_On_Exception()
{
    // Arrange
    var mockRepository = new Mock<IRepository>();
    mockRepository.Setup(x => x.SaveAsync(It.IsAny<Entity>()))
              .ThrowsAsync(new InvalidOperationException());

    // Act & Assert
    await Assert.ThrowsAsync<InvalidOperationException>(() =>
        _atomicService.ExecuteAtomicallyAsync(async () =>
        {
            await mockRepository.Object.SaveAsync(new Entity());
        }));

    // Verify rollback occurred
    mockRepository.Verify(x => x.SaveAsync(It.IsAny<Entity>()), Times.Once);
}

Integration Testing

[Test]
public async Task SagaPattern_Should_Compensate_On_Step_Failure()
{
    // Arrange
    var context = new TestSagaContext();
    var steps = CreateTestStepsWithFailure();

    // Act
    var result = await _sagaService.ExecuteSagaAsync(context, steps);

    // Assert
    Assert.That(result.FinalStatus, Is.EqualTo(SagaStatus.Compensated));
    Assert.That(context.CompensatedSteps.Count, Is.GreaterThan(0));
}

Reference

akkaraponph / iamatomic

Atomic Hanlding C# | Consistency within a single transaction scope

🔚 Summary Table Of Data Consistency Handling

Pattern	Consistency	Scale	Complexity	Suitable For
Pessimistic Locking	Strong	Low	Low	Monoliths, legacy systems
Saga Pattern	Eventual	High	High	Microservices
CQRS	Eventual	High	High	Read-heavy systems, DDD
Mediator	Depends	Med	Medium	Coordinated command handling
Event Sourcing	Eventual	High	High	Auditable systems
Two-Phase Commit	Strong	Low	High	Cross-DB transactional ops
Outbox Pattern	Eventual	High	Medium	DB + messaging consistency

🔄 I Am Atomic Transaction Patterns

Two powerful transaction patterns for modern applications: AtomicService for ACID transactions and SagaPatternService for distributed transactions with eventual consistency.

🎯 Overview

This library offers two complementary approaches to handle transactions in both monolithic and distributed architectures:

Pattern	Use Case	Consistency	Scope	Recovery
AtomicService	Single service/database	Immediate (ACID)	Local operations	Transaction rollback
SagaPatternService	Multiple services	Eventual	Distributed operations	Compensating actions

✨ Features

🛡️ AtomicService (ACID Transactions)

Hierarchical Transactions - Parent-child transaction support
Enhanced Retry Logic - Configurable retry with exponential…

NodeJS 101 — Part 4 🔐 Authorization with JWT

Akkarapon Phikulsri — Thu, 08 Jan 2026 04:13:59 +0000

เนื้อหาดังต่อไปนี้เป็นเนื้อหาเมื่อปี 2023 ถูกปรับปรุงเรียบเรียงใหม่ 2026 ขอให้สนุกกับการเริ่มต้นกับโลก Programming อย่างภาษาง่าย ๆ ด้วย JavaScript กันเน่อ :)

Akkarapon Phikulsri

Jan 8

NodeJS 101 — Part 3 🗄️MySQL + Sequelize

#javascript #mysql #node #tutorial

9 min read

📖 คำนำ

เอกสารฉบับนี้เป็นการพัฒนา web service หรือ RESTful API โดยใช้ภาษา JavaScript Node.js ร่วมกับเฟรมเวิร์กและไลบรารี่ต่าง ๆ ได้แก่:

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

Section 4-1 - 🔑 JWT Authentication

📚 JWT คืออะไร?

JWT (JSON Web Token) เป็นมาตรฐานสำหรับสร้าง access token ที่ใช้ในการยืนยันตัวตน (Authentication) และกำหนดสิทธิ์ (Authorization)

🔍 องค์ประกอบของ JWT:

Header - ระบุประเภท token และ algorithm
Payload - ข้อมูลที่ต้องการส่ง (เช่น user ID)
Signature - ใช้สำหรับตรวจสอบความถูกต้องของ token

📦 ติดตั้ง jsonwebtoken

npm install jsonwebtoken

📥 Import jsonwebtoken

const jwt = require('jsonwebtoken');

🔐 สร้าง Login Controller

เพิ่มในไฟล์: controllers/student.controller.js

const jwt = require('jsonwebtoken');

exports.login = async (req, res) => {
    try {
        const id = req.body.stdId;
        const pass = req.body.stdPass;

        // ค้นหานักศึกษาจากฐานข้อมูล
        const response = await studentModel.findOne({
            where: {
                std_id: id,
                std_pass: pass
            },
            raw: true
        })

        if (response) {
            // ⚠️ ในทางปฏิบัติ ควรเก็บ SECRETKEY ไว้ใน .env
            const SECRETKEY = process.env.JWT_SECRET || "secret1234";

            // สร้าง JWT token
            const token = jwt.sign({
                std_id: response.stdId,
            }, SECRETKEY, {
                expiresIn: "1h", // Token หมดอายุใน 1 ชั่วโมง
            });

            // ลบ password ออกจาก response
            delete response.stdPass;

            res.status(200).json({
                message: "login was successfully",
                payload: { ...response, token }
            })
        } else {
            res.status(401).json({
                message: "Invalid credentials"
            })
        }

    } catch (error) {
        res.status(500).json({
            message: error.message || "login student was failed"
        })
    }
}

🔍 อธิบายโค้ด:

jwt.sign() - สร้าง JWT token
expiresIn: "1h" - กำหนดอายุ token (1 ชั่วโมง)
delete response.stdPass - ลบ password ก่อนส่ง response
status(401) - HTTP status code สำหรับ Unauthorized

⚠️ คำเตือน: ในทางปฏิบัติ ควรเก็บ SECRETKEY ไว้ในไฟล์ .env หรือ environment variables เพื่อความปลอดภัยนะครับ

🛣️ เพิ่ม Login Route

เพิ่มในไฟล์: routes/student.route.js

router.post("/login", studentController.login);

🧪 ทดสอบ Login API

POST http://localhost:5000/api/student/login
Content-Type: application/json

{
  "stdId": "12345",
  "stdPass": "password123"
}

✅ Response ที่คาดหวัง:

{
  "message": "login was successfully",
  "payload": {
    "stdId": "12345",
    "stdName": "John Doe",
    "facId": 1,
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
  }
}

Section 4-2 - 🛡️ สร้าง Middleware สำหรับ Verify Token

📁 สร้างโฟลเดอร์ Middlewares

mkdir middlewares

🔒 สร้าง Verify Token Middleware

ไฟล์: middlewares/verify-token.js

const jwt = require('jsonwebtoken');

module.exports = {
    verifyToken(req, res, next) {
        let token;

        // ตรวจสอบ token จากหลายแหล่ง
        if (req.headers.authorization && req.headers.authorization.split(' ')[0] === 'Bearer') {
            // Token จาก Authorization header: Bearer <token>
            token = req.headers.authorization.split(' ')[1];
        } else if (req.query && req.query.token) {
            // Token จาก query parameter: ?token=<token>
            token = req.query.token;
        } else if (req.cookies && req.cookies.token) {
            // Token จาก cookie
            token = req.cookies.token;
        }

        // ⚠️ ในทางปฏิบัติ ควรเก็บ SECRETKEY ไว้ใน .env
        const SECRETKEY = process.env.JWT_SECRET || "secret1234";

        if (!token) {
            return res.status(401).json({ 
                auth: false, 
                message: 'No token provided.' 
            });
        }

        jwt.verify(token, SECRETKEY, function (err, decoded) {
            if (err) {
                return res.status(401).json({ 
                    auth: false, 
                    message: 'Failed to authenticate token.' 
                });
            }

            // เก็บข้อมูล decoded token ใน req.user สำหรับใช้ใน routes อื่น
            req.user = decoded;
            next();
        });
    }
}

🔍 อธิบายโค้ด:

verifyToken() - Middleware function สำหรับตรวจสอบ token
jwt.verify() - ตรวจสอบความถูกต้องของ token
req.user - เก็บข้อมูลจาก decoded token
next() - เรียกใช้ middleware หรือ route ถัดไป

⚠️ คำเตือน: ในทางปฏิบัติ ควรเก็บ SECRETKEY ไว้ในไฟล์ .env หรือ environment variables เพื่อความปลอดภัยนะครับ

Section 4-3 - 🔐 การใช้งาน Middleware เพื่อป้องกัน Routes

🛡️ ป้องกัน Faculty Routes

แก้ไขไฟล์: routes/faculty.route.js

const express = require("express");
const router = express.Router();
const facultyController = require("../controllers/faculty.controller");
const VerifyToken = require('../middlewares/verify-token');

// Protected routes - ต้องมี token ถึงจะเข้าถึงได้
router.get("/", VerifyToken.verifyToken, facultyController.findAll);
router.get("/:id", VerifyToken.verifyToken, facultyController.findOne);
router.post("/", VerifyToken.verifyToken, facultyController.createOne);
router.put("/:id", VerifyToken.verifyToken, facultyController.update);
router.delete("/:id", VerifyToken.verifyToken, facultyController.delete);

module.exports = router;

🛡️ ป้องกัน Student Routes

แก้ไขไฟล์: routes/student.route.js

const express = require("express");
const router = express.Router();
const studentController = require("../controllers/student.controller");
const VerifyToken = require('../middlewares/verify-token');

// Public route - ไม่ต้องมี token
router.post("/login", studentController.login);

// Protected routes - ต้องมี token ถึงจะเข้าถึงได้
router.get("/", VerifyToken.verifyToken, studentController.findAll);
router.get("/:id", VerifyToken.verifyToken, studentController.findOne);

module.exports = router;

🧪 ทดสอบ Protected Routes

✅ ทดสอบด้วย Token (สำเร็จ)

GET http://localhost:5000/api/faculty
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

❌ ทดสอบโดยไม่มี Token (ล้มเหลว)

GET http://localhost:5000/api/faculty

Response:

{
  "auth": false,
  "message": "No token provided."
}

Section 4-4 - 📝 ตัวอย่างโค้ดเต็ม

📄 ตัวอย่าง Student Controller (สมบูรณ์)

ไฟล์: controllers/student.controller.js

const db = require('../models')
const studentModel = db.students;
const jwt = require('jsonwebtoken');

// Get all students (Protected)
exports.findAll = async (req, res) => {
    try {
        const response = await studentModel.findAll()
        res.status(200).json({
            message: "get all student was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "get all student was failed"
        })
    }
}

// Get student by id (Protected)
exports.findOne = async (req, res) => {
    try {
        const id = req.params.id
        const response = await studentModel.findOne({
            where: { std_id: id }
        })

        if (response) {
            res.status(200).json({
                message: "get one student was successfully",
                payload: response
            })
        } else {
            res.status(404).json({
                message: "Student not found"
            })
        }
    } catch (error) {
        res.status(500).json({
            message: error.message || "get one student was failed"
        })
    }
}

// Login (Public)
exports.login = async (req, res) => {
    try {
        const id = req.body.stdId;
        const pass = req.body.stdPass;

        const response = await studentModel.findOne({
            where: {
                std_id: id,
                std_pass: pass
            },
            raw: true
        })

        if (response) {
            const SECRETKEY = process.env.JWT_SECRET || "secret1234";

            const token = jwt.sign({
                std_id: response.stdId,
            }, SECRETKEY, {
                expiresIn: "1h",
            });

            delete response.stdPass;

            res.status(200).json({
                message: "login was successfully",
                payload: { ...response, token }
            })
        } else {
            res.status(401).json({
                message: "Invalid credentials"
            })
        }

    } catch (error) {
        res.status(500).json({
            message: error.message || "login student was failed"
        })
    }
}

📄 ตัวอย่าง Student Routes (สมบูรณ์)

ไฟล์: routes/student.route.js

const express = require("express");
const router = express.Router();
const studentController = require("../controllers/student.controller");
const VerifyToken = require('../middlewares/verify-token');

// Public routes
router.post("/login", studentController.login);

// Protected routes
router.get("/", VerifyToken.verifyToken, studentController.findAll);
router.get("/:id", VerifyToken.verifyToken, studentController.findOne);

module.exports = router;

Section 4-5 - 🔧 การใช้ Environment Variables

📦 ติดตั้ง dotenv

npm install dotenv

📄 สร้างไฟล์ `.env`

ไฟล์: .env

JWT_SECRET=your_super_secret_key_here_change_this_in_production
DB_HOST=localhost
DB_USERNAME=root
DB_PASSWORD=
DB_DATABASE=db_std
PORT=5000

⚠️ สำคัญ: อย่าลืมเพิ่ม .env ใน .gitignore เพื่อไม่ให้ commit ไฟล์นี้ขึ้น GitHub นะครับ

🔧 แก้ไข `server.js` เพื่อใช้ dotenv

ไฟล์: server.js

require('dotenv').config(); // เพิ่มบรรทัดนี้ไว้ด้านบนสุด

const express = require('express')
const app = express();
const db = require("./models");

app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

// ... routes และโค้ดอื่นๆ

🔧 แก้ไข Middleware และ Controller

ไฟล์: middlewares/verify-token.js

const jwt = require('jsonwebtoken');

module.exports = {
    verifyToken(req, res, next) {
        // ... โค้ดเดิม
        const SECRETKEY = process.env.JWT_SECRET; // ใช้จาก .env
        // ... โค้ดเดิม
    }
}

ไฟล์: controllers/student.controller.js

// ... โค้ดเดิม
const SECRETKEY = process.env.JWT_SECRET; // ใช้จาก .env
// ... โค้ดเดิม

🎉 สรุป Module 4

เราได้เรียนรู้การสร้างระบบ Authentication และ Authorization ด้วย JWT ครบทั้ง:

ฟีเจอร์	คำอธิบาย
🔑 JWT Authentication	สร้าง token สำหรับยืนยันตัวตน
🛡️ Middleware Protection	ป้องกัน routes ด้วย middleware
🔒 Token Verification	ตรวจสอบความถูกต้องของ token
🔐 Secure Routes	แยก public และ protected routes
🌍 Environment Variables	เก็บ secret keys อย่างปลอดภัย

📋 สรุป API Endpoints

Public Endpoints (ไม่ต้องมี Token)

Method	Endpoint	Description
`POST`	`/api/student/login`	Login และรับ token

Protected Endpoints (ต้องมี Token)

Method	Endpoint	Description
`GET`	`/api/faculty`	ดึงข้อมูล faculty ทั้งหมด
`GET`	`/api/faculty/:id`	ดึงข้อมูล faculty ตาม id
`POST`	`/api/faculty`	สร้าง faculty ใหม่
`PUT`	`/api/faculty/:id`	อัปเดตข้อมูล faculty
`DELETE`	`/api/faculty/:id`	ลบ faculty
`GET`	`/api/student`	ดึงข้อมูล student ทั้งหมด
`GET`	`/api/student/:id`	ดึงข้อมูล student ตาม id

🧪 ตัวอย่างการใช้งาน

1. Login เพื่อรับ Token

POST http://localhost:5000/api/student/login
Content-Type: application/json

{
  "stdId": "12345",
  "stdPass": "password123"
}

2. ใช้ Token เพื่อเข้าถึง Protected Routes

GET http://localhost:5000/api/faculty
Authorization: Bearer <your_token_here>

Reference

akkaraponph / basic-nodejs-express-sequelize-mysql

สร้าง API โดยใช้ JavaScript Node.js Express

หมายเหตุ Tutorial นี้ได้จัดทำขึ้นเมื่อ (April 4th, 2023) และได้รับการปรับปรุงเมื่อ (January 8th, 2026)

🚀 การสร้าง API โดยใช้ JavaScript Node.js Express

คู่มือการพัฒนา RESTful API แบบครบวงจรด้วย Node.js, Express, Sequelize และ MySQL

📖 คำนำ

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

📚 สารบัญ

Module 1: 📡 Basic API

Module 2: 💾 Basic API MySQL

Section 2-1 - 🚀 Create New App Express and…

NodeJS 101 — Part 3 🗄️MySQL + Sequelize

Akkarapon Phikulsri — Thu, 08 Jan 2026 04:12:05 +0000

Akkarapon Phikulsri

Jan 8

NodeJS 101 — Part 2 💾MySQL

#node #express #javascript #tutorial

4 min read

📖 คำนำ

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

Module 3: 🗄️ Sequelize

เรียนรู้การใช้ Sequelize ORM สำหรับจัดการฐานข้อมูล

Section 3-1 - 📦 การติดตั้ง Sequelize

📥 ติดตั้ง Sequelize

Sequelize เป็น ORM (Object-Relational Mapping) ที่ช่วยให้เราจัดการฐานข้อมูลได้ง่ายขึ้น

npm install --save sequelize

📚 เอกสารเพิ่มเติม: ดูข้อมูลเพิ่มเติมได้ที่ Sequelize Documentation

🔌 ติดตั้ง Database Driver

เราต้องติดตั้ง driver สำหรับฐานข้อมูลที่เราจะใช้ด้วยนะครับ

Database	Driver Package	คำสั่งติดตั้ง
PostgreSQL	`pg`, `pg-hstore`	`npm install --save pg pg-hstore`
MySQL	`mysql2`	`npm install --save mysql2`
MariaDB	`mariadb`	`npm install --save mariadb`
SQLite	`sqlite3`	`npm install --save sqlite3`
Microsoft SQL Server	`tedious`	`npm install --save tedious`
Oracle Database	`oracledb`	`npm install --save oracledb`

💡 ตัวอย่างสำหรับ MySQL (ที่เราจะใช้ในบทเรียนนี้):

npm install --save sequelize mysql2

Section 3-2 - 🚀 New Project for Sequelize Demo

📁 สร้างโปรเจกต์ใหม่

1. สร้างโปรเจกต์ Node.js

npm init -y

2. ติดตั้ง Packages ที่จำเป็น

npm install express mysql2 cors sequelize
npm install -D nodemon

📋 Packages ที่ติดตั้ง:

Package	Description
`express`	Web framework
`mysql2`	MySQL driver สำหรับ Sequelize
`cors`	Cross-Origin Resource Sharing middleware
`sequelize`	ORM สำหรับจัดการฐานข้อมูล
`nodemon`	Auto-restart server (dev dependency)

📄 สร้างไฟล์ `server.js`

ไฟล์: server.js

const express = require('express')
const app = express();

app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

app.get('/', (req, res) => {
    res.json({ message: "Welcome to my app" })
})

app.listen(PORT, () => {
    console.log(`SERVER ON PORT ${PORT}`)
})

▶️ รันแอปพลิเคชัน

nodemon server.js

หรือเพิ่ม script ใน package.json:

{
  "scripts": {
    "dev": "nodemon server.js"
  }
}

แล้วรันด้วย:

npm run dev

Section 3-3 - ⚙️ Config Sequelize

📁 สร้างโฟลเดอร์และไฟล์ Config

1. สร้างโฟลเดอร์ `config`

mkdir config

2. สร้างไฟล์ `db.config.js`

ไฟล์: config/db.config.js

module.exports = {
    DB_HOST: "localhost",
    DB_USERNAME: "root",
    DB_PASSWORD: "",
    DB_DATABASE: "db_std",
    dialect: "mysql",
    pool: {
        max: 5,
        min: 0,
        acquire: 30000,
        idle: 10000
    }
};

🔍 อธิบาย Config:

DB_HOST - ที่อยู่ของ MySQL server
DB_USERNAME - ชื่อผู้ใช้ MySQL
DB_PASSWORD - รหัสผ่าน MySQL
DB_DATABASE - ชื่อฐานข้อมูล
dialect - ประเภทฐานข้อมูล (mysql, postgres, sqlite, etc.)
pool - การตั้งค่า connection pool

📄 สร้างไฟล์ `models/index.js`

ไฟล์นี้จะใช้สำหรับเชื่อมต่อ Sequelize กับฐานข้อมูลและ register models

ไฟล์: models/index.js

const dbConfig = require("../config/db.config.js");

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
    dbConfig.DB_DATABASE, 
    dbConfig.DB_USERNAME, 
    dbConfig.DB_PASSWORD, 
    {
        host: dbConfig.DB_HOST,
        dialect: dbConfig.dialect,
        operatorsAliases: false,
        pool: {
            max: dbConfig.pool.max,
            min: dbConfig.pool.min,
            acquire: dbConfig.pool.acquire,
            idle: dbConfig.pool.idle
        }
    }
);

const db = {};

db.Sequelize = Sequelize;
db.sequelize = sequelize;

// Register models here
// db.students = require("./student.model.js")(sequelize, Sequelize);
// db.faculty = require("./faculty.model.js")(sequelize, Sequelize);

module.exports = db;

💡 หมายเหตุ: เราจะ register models ในขั้นตอนถัดไปนะครับ

🔄 Sync Database ใน `server.js`

ไฟล์: server.js

const express = require('express')
const app = express();
const db = require("./models");

app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

app.get('/', (req, res) => {
    res.json({ message: "Welcome to my app" })
})

// Sync database
db.sequelize.sync({ force: false })
    .then(() => {
        console.log("Database was synchronized successfully.");
        app.listen(PORT, () => {
            console.log(`SERVER ON PORT ${PORT}`)
        })
    })
    .catch((err) => {
        console.log("Failed to synchronize database: " + err.message);
    });

🔍 อธิบาย `sync()`:

force: false - ไม่ลบตารางที่มีอยู่แล้ว (ใช้ true เพื่อลบและสร้างใหม่)
sync() - สร้างตารางตาม models ที่เรากำหนด

Section 3-4 - 📋 สร้างโมเดล Student และ Faculty

🏛️ สร้างโมเดล Faculty

ไฟล์: models/faculty.model.js

module.exports = (sequelize, Sequelize) => {
    const Faculty = sequelize.define("faculty", {
        facultyId: {
            type: Sequelize.INTEGER,
            primaryKey: true,
            autoIncrement: true,
            field: "fac_id"
        },
        facultyName: {
            type: Sequelize.STRING,
            field: "fac_name",
        },
    }, {
        sequelize,
        tableName: 'faculty',
        freezeTableName: true,
        timestamps: false
    });

    Faculty.associate = (models) => {
        Faculty.hasMany(models.student, {
            foreignKey: 'fac_id',
            sourceKey: 'fac_id',
            onDelete: "cascade",
        });
    }

    return Faculty;
}

🔍 อธิบายโค้ด:

sequelize.define() - สร้างโมเดลใหม่
primaryKey: true - กำหนดเป็น primary key
autoIncrement: true - เพิ่มค่า id อัตโนมัติ
field: "fac_id" - กำหนดชื่อคอลัมน์ในฐานข้อมูล
freezeTableName: true - ใช้ชื่อตารางตามที่กำหนด (ไม่เติม 's')
timestamps: false - ไม่ใช้ created_at และ updated_at
hasMany() - กำหนดความสัมพันธ์ one-to-many (1 คณะมีหลายนักศึกษา)

👨‍🎓 สร้างโมเดล Student

ไฟล์: models/student.model.js

module.exports = (sequelize, Sequelize) => {
    const Student = sequelize.define("student", {
        stdId: {
            primaryKey: true,
            type: Sequelize.STRING,
            field: "std_id",
        },
        stdPass: {
            type: Sequelize.STRING,
            field: "std_pass",
        },
        stdName: {
            type: Sequelize.STRING,
            field: "std_name",
        },
        facId: {
            type: Sequelize.INTEGER,
            field: "fac_id",
            unique: false
        },
    }, {
        sequelize,
        tableName: 'student',
        freezeTableName: true,
        timestamps: false
    });

    Student.associate = (models) => {
        Student.belongsTo(models.faculty, {
            foreignKey: 'fac_id',
            sourceKey: 'fac_id',
            onDelete: "cascade",
        });
    }

    return Student;
};

🔍 อธิบายโค้ด:

belongsTo() - กำหนดความสัมพันธ์ many-to-one (หลายนักศึกษาอยู่ใน 1 คณะ)
onDelete: "cascade" - เมื่อลบ faculty จะลบ student ที่เกี่ยวข้องด้วย

📝 Register Models ใน `models/index.js`

หลังจากสร้างโมเดลแล้ว เราต้อง register ใน models/index.js นะครับ

ไฟล์: models/index.js

const dbConfig = require("../config/db.config.js");

const Sequelize = require("sequelize");
const sequelize = new Sequelize(
    dbConfig.DB_DATABASE, 
    dbConfig.DB_USERNAME, 
    dbConfig.DB_PASSWORD, 
    {
        host: dbConfig.DB_HOST,
        dialect: dbConfig.dialect,
        operatorsAliases: false,
        pool: {
            max: dbConfig.pool.max,
            min: dbConfig.pool.min,
            acquire: dbConfig.pool.acquire,
            idle: dbConfig.pool.idle
        }
    }
);

const db = {};

db.Sequelize = Sequelize;
db.sequelize = sequelize;

// Register models
db.students = require("./student.model.js")(sequelize, Sequelize);
db.faculty = require("./faculty.model.js")(sequelize, Sequelize);

// Initialize associations
Object.keys(db).forEach(modelName => {
    if (db[modelName].associate) {
        db[modelName].associate(db);
    }
});

module.exports = db;

🔍 จุดสำคัญ:

Register models ก่อนใช้
เรียก associate() เพื่อกำหนดความสัมพันธ์ระหว่างโมเดล

Section 3-5 - 🎮 การสร้าง Controllers

📁 สร้างโฟลเดอร์ Controllers

mkdir controllers

🏛️ สร้าง Faculty Controller

ไฟล์: controllers/faculty.controller.js

const db = require('../models')
const facultyModel = db.faculty;
const Op = db.Sequelize.Op;

// Get all faculty
exports.findAll = async (req, res) => {
    try {
        const response = await facultyModel.findAll()
        res.status(200).json({
            message: "get all faculty was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "get all faculty was failed"
        })
    }
}

🔍 อธิบายโค้ด:

facultyModel.findAll() - ดึงข้อมูล faculty ทั้งหมด
async/await - ใช้ async function เพื่อจัดการ Promise
try/catch - จัดการ error

👨‍🎓 สร้าง Student Controller

ไฟล์: controllers/student.controller.js

const db = require('../models')
const studentModel = db.students;

// Get all student
exports.findAll = async (req, res) => {
    try {
        const response = await studentModel.findAll()
        res.status(200).json({
            message: "get all student was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "get all student was failed"
        })
    }
}

💡 หมายเหตุ: ใช้ db.students (มี s) ตามที่ register ใน models/index.js นะครับ

Section 3-6 - 🛣️ การสร้าง Faculty Routes

📁 สร้างโฟลเดอร์ Routes

mkdir routes

🏛️ สร้าง Faculty Route

ไฟล์: routes/faculty.route.js

const express = require("express");
const router = express.Router();
const facultyController = require("../controllers/faculty.controller");

router.get("/", facultyController.findAll);

module.exports = router;

🔍 อธิบายโค้ด:

express.Router() - สร้าง router instance
router.get("/", ...) - สร้าง GET route ที่ path /
facultyController.findAll - เรียกใช้ controller function

🔗 เพิ่ม Route ใน `server.js`

ไฟล์: server.js

const express = require('express')
const app = express();
const db = require("./models");

app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

app.get('/', (req, res) => {
    res.json({ message: "Welcome to my app" })
})

// Faculty routes
const facultyRoute = require("./routes/faculty.route");
app.use("/api/faculty", facultyRoute);

// Sync database
db.sequelize.sync({ force: false })
    .then(() => {
        console.log("Database was synchronized successfully.");
        app.listen(PORT, () => {
            console.log(`SERVER ON PORT ${PORT}`)
        })
    })
    .catch((err) => {
        console.log("Failed to synchronize database: " + err.message);
    });

🧪 ทดสอบ API

GET http://localhost:5000/api/faculty

Section 3-7 - 🛣️ การสร้าง Student Routes

👨‍🎓 สร้าง Student Route

ไฟล์: routes/student.route.js

const express = require("express");
const router = express.Router();
const studentController = require("../controllers/student.controller");

router.get("/", studentController.findAll);

module.exports = router;

🔗 เพิ่ม Route ใน `server.js`

ไฟล์: server.js

const express = require('express')
const app = express();
const db = require("./models");

app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

app.get('/', (req, res) => {
    res.json({ message: "Welcome to my app" })
})

// Faculty routes
const facultyRoute = require("./routes/faculty.route");
app.use("/api/faculty", facultyRoute);

// Student routes
const studentRoute = require("./routes/student.route");
app.use("/api/student", studentRoute);

// Sync database
db.sequelize.sync({ force: false })
    .then(() => {
        console.log("Database was synchronized successfully.");
        app.listen(PORT, () => {
            console.log(`SERVER ON PORT ${PORT}`)
        })
    })
    .catch((err) => {
        console.log("Failed to synchronize database: " + err.message);
    });

🧪 ทดสอบ API

GET http://localhost:5000/api/student

Section 3-8 - ➕ การสร้าง Routes เพิ่มเติมใน Faculty (CRUD Complete)

➕ สร้าง Function `createOne` ใน Controller

เพิ่มในไฟล์: controllers/faculty.controller.js

exports.createOne = async (req, res) => {
    try {
        const response = await facultyModel.create(req.body)
        res.status(201).json({
            message: "create one faculty was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "create one faculty was failed"
        })
    }
}

🔍 อธิบายโค้ด:

facultyModel.create() - สร้าง record ใหม่ในฐานข้อมูล
req.body - ข้อมูลที่ส่งมาจาก client
status(201) - HTTP status code สำหรับการสร้างข้อมูลสำเร็จ

🔗 เพิ่ม Route สำหรับ Create

เพิ่มในไฟล์: routes/faculty.route.js

router.post("/", facultyController.createOne);

📝 ตัวอย่างโค้ดเต็ม `faculty.route.js` (หลังจากเพิ่ม POST)

const express = require("express");
const router = express.Router();
const facultyController = require("../controllers/faculty.controller");

router.get("/", facultyController.findAll);
router.post("/", facultyController.createOne);

module.exports = router;

🧪 ทดสอบ API

POST http://localhost:5000/api/faculty
Content-Type: application/json

{
  "facultyName": "คณะวิศวกรรมศาสตร์"
}

✏️ สร้าง Function `update` ใน Controller

เพิ่มในไฟล์: controllers/faculty.controller.js

exports.update = async (req, res) => {
    try {
        const id = req.params.id
        const body = req.body

        const response = await facultyModel.update(body, {
            where: { fac_id: id },
        })

        if (response[0] == 1) {
            res.status(200).json({
                message: "update one faculty was successfully",
                payload: response
            })
        } else {
            res.status(400).json({
                message: `update one faculty was failed faculty with fac_id=${id}. Maybe fac was not found or req.body is empty!`
            });
        }
    } catch (error) {
        res.status(500).json({
            message: error.message || "update one faculty was failed"
        })
    }
}

🔍 อธิบายโค้ด:

facultyModel.update() - อัปเดตข้อมูลในฐานข้อมูล
where: { fac_id: id } - เงื่อนไขการค้นหา

- `response[0]` - จำนวนแถวที่ถูกอัปเดต (1 = สำเร็จ, 0 = ไม่พบข้อมูล)

🔗 เพิ่ม Route สำหรับ Update

เพิ่มในไฟล์: routes/faculty.route.js

router.put("/:id", facultyController.update);

🧪 ทดสอบ API

PUT http://localhost:5000/api/faculty/1
Content-Type: application/json

{
  "facultyName": "คณะวิศวกรรมศาสตร์ (แก้ไข)"
}

🗑️ สร้าง Function `delete` ใน Controller

เพิ่มในไฟล์: controllers/faculty.controller.js

exports.delete = async (req, res) => {
    try {
        const id = req.params.id;
        const response = await facultyModel.destroy({
            where: {
                fac_id: id
            }
        })

        if (response == 1) {
            res.status(200).json({
                message: "delete faculty was successfully",
                payload: response
            })
        } else {
            res.status(400).json({
                message: `delete faculty was failed faculty with fac_id=${id}. Maybe faculty was not found!`
            });
        }
    } catch (error) {
        res.status(500).json({
            message: error.message || "delete faculty was failed"
        })
    }
}

🔍 อธิบายโค้ด:

facultyModel.destroy() - ลบข้อมูลจากฐานข้อมูล
response == 1 - จำนวนแถวที่ถูกลบ (1 = สำเร็จ, 0 = ไม่พบข้อมูล)

🔗 เพิ่ม Route สำหรับ Delete

เพิ่มในไฟล์: routes/faculty.route.js

router.delete("/:id", facultyController.delete);

📝 ตัวอย่างโค้ดเต็ม `faculty.controller.js` (CRUD Complete)

ไฟล์: controllers/faculty.controller.js

const db = require('../models')
const facultyModel = db.faculty;
const Op = db.Sequelize.Op;

// Get all faculty
exports.findAll = async (req, res) => {
    try {
        const response = await facultyModel.findAll()
        res.status(200).json({
            message: "get all faculty was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "get all faculty was failed"
        })
    }
}

// Create faculty
exports.createOne = async (req, res) => {
    try {
        const response = await facultyModel.create(req.body)
        res.status(201).json({
            message: "create one faculty was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "create one faculty was failed"
        })
    }
}

// Update faculty
exports.update = async (req, res) => {
    try {
        const id = req.params.id
        const body = req.body

        const response = await facultyModel.update(body, {
            where: { fac_id: id },
        })

        if (response[0] == 1) {
            res.status(200).json({
                message: "update one faculty was successfully",
                payload: response
            })
        } else {
            res.status(400).json({
                message: `update one faculty was failed faculty with fac_id=${id}. Maybe fac was not found or req.body is empty!`
            });
        }
    } catch (error) {
        res.status(500).json({
            message: error.message || "update one faculty was failed"
        })
    }
}

// Delete faculty
exports.delete = async (req, res) => {
    try {
        const id = req.params.id;
        const response = await facultyModel.destroy({
            where: {
                fac_id: id
            }
        })

        if (response == 1) {
            res.status(200).json({
                message: "delete faculty was successfully",
                payload: response
            })
        } else {
            res.status(400).json({
                message: `delete faculty was failed faculty with fac_id=${id}. Maybe faculty was not found!`
            });
        }
    } catch (error) {
        res.status(500).json({
            message: error.message || "delete faculty was failed"
        })
    }
}

📝 ตัวอย่างโค้ดเต็ม `faculty.route.js` (CRUD Complete)

ไฟล์: routes/faculty.route.js

const express = require("express");
const router = express.Router();
const facultyController = require("../controllers/faculty.controller");

router.get("/", facultyController.findAll);
router.post("/", facultyController.createOne);
router.put("/:id", facultyController.update);
router.delete("/:id", facultyController.delete);

module.exports = router;

🧪 ทดสอบ API

DELETE http://localhost:5000/api/faculty/1

🎉 สรุป Module 3

เราได้เรียนรู้การใช้งาน Sequelize ORM ครบทั้ง:

ฟีเจอร์	คำอธิบาย
📦 ติดตั้ง Sequelize	ติดตั้ง ORM และ database driver
⚙️ Config Database	ตั้งค่าการเชื่อมต่อฐานข้อมูล
📋 สร้าง Models	สร้างโมเดลและความสัมพันธ์
🎮 Controllers	สร้าง business logic
🛣️ Routes	สร้าง API endpoints
🔄 CRUD Operations	Create, Read, Update, Delete

**🎊 ยินดีด้วยครับ! เราได้เรียนรู้การใช้งาน Sequelize ORM แล้ว** • [➡️ ไปยัง Module 4: Authorization with JWT](#module-4--authorization-with-jwt)

สร้าง controller สำหรับ findOne ใน `faculty.controller.js`

exports.findOne = async (req, res) => {
    try {
        const id = req.params.id
        const response = await facultyModel.findOne({
            where: { fac_id: id }
        })
        console.log(facultyModel)
        res.status(200).json({
            message: "get one faculty was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "get one faculty was failed"
        })
    }
}

สร้าง route สำหรับ findOne ใน `faculty.route.js`

router.get("/:id", facultyController.findOne)

Section 3-9 - 👨‍🎓 การสร้าง Controller & Route สำหรับ CRUD Student

📝 สร้าง Function `findOne` ใน Student Controller

เพิ่มในไฟล์: controllers/student.controller.js

// Get student by id
exports.findOne = async (req, res) => {
    try {
        const id = req.params.id
        const response = await studentModel.findOne({
            where: { std_id: id }
        })

        if (response) {
            res.status(200).json({
                message: "get one student was successfully",
                payload: response
            })
        } else {
            res.status(404).json({
                message: "Student not found"
            })
        }
    } catch (error) {
        res.status(500).json({
            message: error.message || "get one student was failed"
        })
    }
}

🔗 เพิ่ม Route สำหรับ findOne

เพิ่มในไฟล์: routes/student.route.js

router.get("/:id", studentController.findOne);

📝 ตัวอย่างโค้ดเต็ม `student.controller.js` (CRUD Complete)

ไฟล์: controllers/student.controller.js

const db = require('../models')
const studentModel = db.students;

// Get all students
exports.findAll = async (req, res) => {
    try {
        const response = await studentModel.findAll()
        res.status(200).json({
            message: "get all student was successfully",
            payload: response
        })
    } catch (error) {
        res.status(500).json({
            message: error.message || "get all student was failed"
        })
    }
}

// Get student by id
exports.findOne = async (req, res) => {
    try {
        const id = req.params.id
        const response = await studentModel.findOne({
            where: { std_id: id }
        })

        if (response) {
            res.status(200).json({
                message: "get one student was successfully",
                payload: response
            })
        } else {
            res.status(404).json({
                message: "Student not found"
            })
        }
    } catch (error) {
        res.status(500).json({
            message: error.message || "get one student was failed"
        })
    }
}

📝 ตัวอย่างโค้ดเต็ม `student.route.js` (CRUD Complete)

ไฟล์: routes/student.route.js

const express = require("express");
const router = express.Router();
const studentController = require("../controllers/student.controller");

router.get("/", studentController.findAll);
router.get("/:id", studentController.findOne);

module.exports = router;

🧪 ทดสอบ API

GET http://localhost:5000/api/student
GET http://localhost:5000/api/student/12345

Akkarapon Phikulsri

Jan 8

NodeJS 101 — Part 4 🔐 Authorization with JWT

#beginners #node #security #tutorial

4 min read

Reference

akkaraponph / basic-nodejs-express-sequelize-mysql

สร้าง API โดยใช้ JavaScript Node.js Express

🚀 การสร้าง API โดยใช้ JavaScript Node.js Express

คู่มือการพัฒนา RESTful API แบบครบวงจรด้วย Node.js, Express, Sequelize และ MySQL

📖 คำนำ

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

📚 สารบัญ

Module 1: 📡 Basic API

Module 2: 💾 Basic API MySQL

Section 2-1 - 🚀 Create New App Express and…

NodeJS 101 — Part 2 💾MySQL

Akkarapon Phikulsri — Thu, 08 Jan 2026 04:04:49 +0000

Akkarapon Phikulsri

Jan 8

NodeJS 101 — Part 1 📡 JavaScript Node.js Express

#beginners #javascript #node #tutorial

6 min read

🚀 การสร้าง API โดยใช้ JavaScript Node.js Express

คู่มือการพัฒนา RESTful API แบบครบวงจรด้วย Node.js, Express, Sequelize และ MySQL

📖 คำนำ

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

Module 2: 💾 Basic API MySQL

เรียนรู้การเชื่อมต่อและใช้งาน MySQL Database กับ Express

Section 2-1 - 🚀 Create New App Express and MySQL

📁 สร้างโปรเจกต์ใหม่

1. สร้างโฟลเดอร์ `demo-mysql`

mkdir demo-mysql

2. เข้าไปในโฟลเดอร์ `demo-mysql`

cd demo-mysql

⚠️ หมายเหตุ: คำสั่ง cd mkdir demo-mysql ในเอกสารเดิมไม่ถูกต้องนะครับ ควรใช้ cd demo-mysql หลังจากสร้างโฟลเดอร์แล้ว

3. สร้าง Node.js Application

npm init -y

คำสั่งนี้จะสร้างไฟล์ package.json อัตโนมัติ

📄 สร้างไฟล์ `index.js`

ไฟล์: index.js

const express = require('express')
const cors = require('cors')  // ⚠️ แก้ไข: ควรเป็น 'cors' ไม่ใช่ 'express'
const PORT = process.env.PORT || 5000
const app = express()

app.use(express.json())
app.use(express.urlencoded({ extended: true }))
app.use(cors())

app.listen(PORT, () => {
    console.log(`CORS enabled server listening on ${PORT}`)
})

⚠️ หมายเหตุ: ในโค้ดเดิมมีการ require('express') สำหรับ cors ซึ่งไม่ถูกต้องนะครับ ควรเป็น require('cors')

📦 ติดตั้ง Packages ที่จำเป็น

ติดตั้ง Packages หลัก

npm install express mysql2 cors --save

ติดตั้ง Nodemon สำหรับ Development

Development Dependencies:

npm install -D nodemon

Global Installation (Optional):

npm install -g nodemon

📋 Packages ที่ติดตั้ง:

Package	Description
`express`	Web framework สำหรับ Node.js
`mysql2`	MySQL client สำหรับ Node.js
`cors`	Middleware สำหรับจัดการ Cross-Origin Resource Sharing
`nodemon`	Auto-restart server เมื่อมีการแก้ไขไฟล์

Section 2-2 - 🔌 Connect MySQL Database

📦 Import MySQL2

เพิ่มในไฟล์: index.js

const mysql = require('mysql2');

🔌 เชื่อมต่อฐานข้อมูล MySQL

วิธีที่ 1: ใช้ค่าคงที่

const connection = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: '',
    database: 'basic_api_express_db'
});

วิธีที่ 2: ใช้ Environment Variables (แนะนำ) ⭐

const connection = mysql.createConnection({
    host: process.env.DB_HOSTNAME || 'localhost',
    user: process.env.DB_USERNAME || 'root',
    password: process.env.DB_PASSWORD || '',
    database: process.env.DB_DATABASE || 'basic_api_express_db'
});

💡 แนะนำ: ใช้วิธีที่ 2 เพื่อความปลอดภัยและยืดหยุ่นในการ deploy

📥 ทดสอบดึงข้อมูลจากฐานข้อมูล

เพิ่มในไฟล์: index.js

// Get all users
app.get('/users', (req, res, next) => {
    try {
        connection.query(
            'SELECT * FROM `users`',
            (err, results, fields) => {
                if (err) {
                    return res.status(500).json({ message: "Database error", error: err });
                }
                res.status(200).json(results);
            }
        );
    } catch (error) {
        res.status(400).json({ message: "get user was failed", error: error.message });
    }
})

// Get user by id
app.get('/users/:id', (req, res, next) => {
    try {
        const id = req.params.id;
        connection.query(
            'SELECT * FROM `users` WHERE `id` = ?',
            [id],
            (err, results) => {
                if (err) {
                    return res.status(500).json({ message: "Database error", error: err });
                }
                if (results.length === 0) {
                    return res.status(404).json({ message: "User not found" });
                }
                res.status(200).json({ payload: results });
            }
        );
    } catch (error) {
        res.status(400).json({ message: "get user by id was failed", error: error.message });
    }
})

🧪 ทดสอบ API

GET http://localhost:5000/users
GET http://localhost:5000/users/1

Section 2-3 - ➕ CREATE USER

➕ สร้าง User ใหม่

เพิ่มในไฟล์: index.js

app.post('/users', (req, res, next) => {
    try {
        const { fname, lname, username, password, avatar } = req.body;

        connection.query(
            'INSERT INTO `users`(`fname`, `lname`, `username`, `password`, `avatar`) VALUES (?, ?, ?, ?, ?)',
            [fname, lname, username, password, avatar],
            (err, results) => {
                if (err) {
                    return res.status(500).json({ 
                        message: "create user was failed", 
                        error: err.message 
                    });
                }
                res.status(201).json({ 
                    message: "create user was successfully", 
                    payload: results 
                });
            }
        );
    } catch (error) {
        res.status(400).json({ 
            message: "create user was failed", 
            error: error.message 
        });
    }
})

🔍 อธิบายโค้ด:

INSERT INTO - คำสั่ง SQL สำหรับเพิ่มข้อมูล
? - Placeholder สำหรับป้องกัน SQL injection
status(201) - HTTP status code สำหรับการสร้างข้อมูลสำเร็จ

🧪 ทดสอบ API

POST http://localhost:5000/users
Content-Type: application/json

{
  "fname": "John",
  "lname": "Doe",
  "username": "johndoe",
  "password": "password123",
  "avatar": "https://example.com/avatar.jpg"
}

Section 2-4 - ✏️ UPDATE USER

✏️ อัปเดตข้อมูล User

เพิ่มในไฟล์: index.js

app.put('/users/:id', (req, res, next) => {
    try {
        const id = req.params.id;
        const { fname, lname, username, password, avatar } = req.body;

        connection.query(
            'UPDATE `users` SET `fname`= ?, `lname`= ?, `username`= ?, `password`= ?, `avatar`= ? WHERE id = ?',
            [fname, lname, username, password, avatar, id],
            (err, results) => {
                if (err) {
                    return res.status(500).json({ 
                        message: "update user was failed", 
                        error: err.message 
                    });
                }
                if (results.affectedRows === 0) {
                    return res.status(404).json({ 
                        message: "User not found" 
                    });
                }
                res.status(200).json({ 
                    message: "update user was successfully", 
                    payload: results 
                });
            }
        );
    } catch (error) {
        res.status(400).json({ 
            message: "update user was failed", 
            error: error.message 
        });
    }
})

🔍 อธิบายโค้ด:

UPDATE - คำสั่ง SQL สำหรับอัปเดตข้อมูล
affectedRows - จำนวนแถวที่ถูกอัปเดต (0 = ไม่พบข้อมูล)

🧪 ทดสอบ API

PUT http://localhost:5000/users/1
Content-Type: application/json

{
  "fname": "Jane",
  "lname": "Doe",
  "username": "janedoe",
  "password": "newpassword123",
  "avatar": "https://example.com/new-avatar.jpg"
}

Section 2-5 - 🗑️ DELETE USER

🗑️ ลบข้อมูล User

เพิ่มในไฟล์: index.js

app.delete('/users/:id', (req, res, next) => {
    try {
        const id = req.params.id;

        connection.query(
            'DELETE FROM `users` WHERE id = ?',
            [id],
            (err, results) => {
                if (err) {
                    return res.status(500).json({ 
                        message: "delete user was failed", 
                        error: err.message 
                    });
                }
                if (results.affectedRows === 0) {
                    return res.status(404).json({ 
                        message: "User not found" 
                    });
                }
                res.status(200).json({ 
                    message: "delete user was successfully", 
                    payload: results 
                });
            }
        );
    } catch (error) {
        res.status(400).json({ 
            message: "delete user was failed", 
            error: error.message 
        });
    }
})

🔍 อธิบายโค้ด:

DELETE FROM - คำสั่ง SQL สำหรับลบข้อมูล
affectedRows - จำนวนแถวที่ถูกลบ (0 = ไม่พบข้อมูล)

🧪 ทดสอบ API

DELETE http://localhost:5000/users/1

🎉 สรุป Module 2

เราได้เรียนรู้การเชื่อมต่อและใช้งาน MySQL Database กับ Express ครบทั้ง CRUD Operations:

Method	Endpoint	Description
`GET`	`/users`	ดึงข้อมูล users ทั้งหมด
`GET`	`/users/:id`	ดึงข้อมูล user ตาม id
`POST`	`/users`	สร้าง user ใหม่
`PUT`	`/users/:id`	อัปเดตข้อมูล user
`DELETE`	`/users/:id`	ลบ user

Akkarapon Phikulsri

Jan 8

NodeJS 101 — Part 3 🗄️MySQL + Sequelize

#javascript #mysql #node #tutorial

9 min read

Reference

akkaraponph / basic-nodejs-express-sequelize-mysql

สร้าง API โดยใช้ JavaScript Node.js Express

🚀 การสร้าง API โดยใช้ JavaScript Node.js Express

คู่มือการพัฒนา RESTful API แบบครบวงจรด้วย Node.js, Express, Sequelize และ MySQL

📖 คำนำ

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

📚 สารบัญ

Module 1: 📡 Basic API

Module 2: 💾 Basic API MySQL

Section 2-1 - 🚀 Create New App Express and…

NodeJS 101 — Part 1 📡 JavaScript Node.js Express

Akkarapon Phikulsri — Thu, 08 Jan 2026 04:01:59 +0000

🚀 การสร้าง API โดยใช้ JavaScript Node.js Express

คู่มือการพัฒนา RESTful API แบบครบวงจรด้วย Node.js, Express, Sequelize และ MySQL

📖 คำนำ

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

Module 1: 📡 Basic API

เรียนรู้พื้นฐานการสร้าง API ด้วย Node.js และ Express

Section 1-1 - 🎯 Intro

📝 เริ่มต้นสร้าง Server ด้วย HTTP Library

สร้างไฟล์ server.js สำหรับสร้าง server พื้นฐานโดยใช้ HTTP library ของ Node.js

ไฟล์: server.js

const http = require('http')
const HOSTNAME = '127.0.0.1';
const PORT = 3000;

const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Hello World \n')
})

server.listen(PORT, HOSTNAME, () => {
    console.log(`Server running at http://${HOSTNAME}:${PORT}`)
})

⚠️ หมายเหตุ: ในโค้ดตัวอย่างมีการใช้ตัวแปร hostname และ port แบบตัวพิมพ์เล็ก ซึ่งควรเป็น HOSTNAME และ PORT ตามที่ประกาศไว้

🔧 ติดตั้ง Nodemon

Nodemon เป็นเครื่องมือที่ช่วยให้ server รีสตาร์ทอัตโนมัติเมื่อมีการแก้ไขไฟล์

📦 ติดตั้งสำหรับ Development Dependencies

npm install -D nodemon

หรือ

npm install --save-dev nodemon

🌐 ติดตั้งแบบ Global

npm install -g nodemon

▶️ วิธีใช้งาน

nodemon index.js

💡 เคล็ดลับ: แทนที่ index.js ด้วยชื่อไฟล์แอปพลิเคชันของเราดูครับ

Section 1-2 - 🛣️ สร้าง Route ด้วย Express

📦 ติดตั้ง Express Framework

npm install express --save

📄 สร้างไฟล์ `app.js`

สร้างไฟล์ app.js และเพิ่มโค้ดสำหรับ import Express และสร้าง route พื้นฐาน

ไฟล์: app.js

const express = require('express');
const app = express();
app.use(express.json())
const PORT = 3000;

app.get('/', (req, res) => {
    res.send('Hello Express!');
});

app.listen(PORT, () => {
    console.log(`Listening at http://localhost:${PORT}`);
});

🔍 อธิบายโค้ด:

express() - สร้าง Express application instance
app.use(express.json()) - เปิดใช้งาน JSON parser middleware
app.get('/') - สร้าง GET route ที่ path /
app.listen() - เริ่มต้น server ที่ port ที่กำหนด

▶️ รันแอปเพื่อทดสอบ

nodemon app.js

เปิดเบราว์เซอร์ไปที่ http://localhost:3000 เพื่อดูผลลัพธ์

Section 1-3 - 💡 ตัวอย่างการสร้าง API

📄 สร้างไฟล์ `app-demo.js`

ตัวอย่างการสร้าง API แบบง่าย ๆ พร้อมการกำหนด PORT จาก environment variable

ไฟล์: app-demo.js

const express = require('express')
const app = express();
const PORT = process.env.PORT || 5000

app.get('/', (req, res) => {
    res.send("Hello! Node.js")
})

app.listen(PORT, () => {
    console.log(`SERVER ON PORT ${PORT}`)
})

🔍 จุดเด่นของโค้ด:

✅ ใช้ process.env.PORT เพื่อรองรับการ deploy บน cloud platforms
✅ มีค่า default เป็น 5000 หากไม่มีการกำหนด PORT
✅ โครงสร้างโค้ดเรียบง่ายและเข้าใจง่าย

▶️ รันแอปเพื่อทดสอบ

nodemon app-demo.js

หรือกำหนด PORT ก่อนรัน:

PORT=3000 nodemon app-demo.js

Section 1-4 - ⚙️ การสร้าง Scripts

📝 สร้าง Scripts ใน package.json

สร้าง script เพื่อรันแอปพลิเคชันได้ง่ายขึ้น โดยเราสามารถแก้ไขได้ที่ package.json ในส่วน scripts

ตัวอย่างการตั้งค่า:

"scripts": {
  "dev": "nodemon ./server.js"
}

📸 ตัวอย่าง package.json

ไฟล์: package.json

{
  "name": "server",
  "version": "1.0.0",
  "description": "example javascript or node.js application that use express http framework",
  "main": "server.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "dev": "nodemon ./server.js"
  },
  "keywords": [],
  "author": "billowdev",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2",
    "mysql2": "^3.2.0",
    "sequelize": "^6.30.0"
  },
  "devDependencies": {
    "nodemon": "^2.0.22"
  }
}

▶️ วิธีใช้งาน Script

หลังจากเพิ่ม script แล้ว ลองรันแอปด้วยคำสั่งนี้ดูครับ

npm run dev

💡 ประโยชน์: ไม่ต้องพิมพ์ nodemon ./server.js ทุกครั้ง แค่พิมพ์ npm run dev ก็พอ

Section 1-5 - 🔄 RESTful API

📄 สร้างไฟล์ `db.json` สำหรับจำลองข้อมูล

สร้างไฟล์ db.json เพื่อใช้เป็นฐานข้อมูลจำลองสำหรับทดสอบ API

ไฟล์: db.json

[
    {
        "id": 1,
        "username": "user1",
        "name": "Alice"
    },
    {
        "id": 2,
        "username": "user2",
        "name": "Lac"
    },
    {
        "id": 3,
        "username": "user3",
        "name": "Billo"
    }
]

📥 Import ข้อมูลจาก db.json

const users = require('./db.json')

🛣️ สร้าง Route สำหรับดึงข้อมูล Users

app.get('/users', (req, res) => {
    res.json(users)
})

📝 ตัวอย่างโค้ดเต็มใน `app-demo.js`

ไฟล์: app-demo.js

const express = require('express')
const app = express();
const PORT = process.env.PORT || 5000

const users = require('./db.json')

app.get('/', (req, res) => {
    res.send("Hello! Node.js")
})

app.get('/users', (req, res) => {
    res.json(users)
})

app.listen(PORT, () => {
    console.log(`SERVER ON PORT ${PORT}`)
})

🧪 ทดสอบ API

รันแอปพลิเคชัน:

   nodemon app-demo.js

ทดสอบด้วย Browser หรือ Postman:
- GET http://localhost:5000/ - ดูข้อความต้อนรับ
- GET http://localhost:5000/users - ดูรายการ users ทั้งหมด

Section 1-6 - 📥 Method GET and API Params

🎯 สร้าง Route สำหรับดึงข้อมูล User ตาม ID

สร้าง API route ที่มี endpoint เป็น /users/:id เพื่อดึงข้อมูล user เฉพาะคนจาก users array

📌 Route Parameters

app.get('/users/:id', (req, res) => {
    res.json(users.find(el => el.id === Number(req.params.id)))
})

🔍 อธิบายโค้ด:

:id - Route parameter ที่จะรับค่า id จาก URL
req.params.id - ดึงค่า id จาก URL parameter
Number() - แปลง string เป็น number
find() - ค้นหา user ที่มี id ตรงกับที่ระบุ

📝 ตัวอย่างโค้ดเต็มใน `api-demo.js`

ไฟล์: api-demo.js

const express = require('express')
const app = express();
const PORT = process.env.PORT || 5000

const users = require('./db.json')

app.get('/', (req, res) => {
    res.send("Hello! Node.js")
})

app.get('/users', (req, res) => {
    res.status(200).json(users)
})

app.get('/users/:id', (req, res) => {
    res.json(users.find(el => el.id === Number(req.params.id)))
})

app.listen(PORT, () => {
    console.log(`SERVER ON PORT ${PORT}`)
})

🧪 ทดสอบ API

GET http://localhost:5000/users/1 - ดึงข้อมูล user ที่มี id = 1
GET http://localhost:5000/users/2 - ดึงข้อมูล user ที่มี id = 2
GET http://localhost:5000/users/3 - ดึงข้อมูล user ที่มี id = 3

⚠️ หมายเหตุ: หากไม่พบ user ที่ระบุ จะได้ค่า undefined แนะนำให้เพิ่มการตรวจสอบและส่ง error response กันนะครับ

Section 1-7 - 📤 Using JSON and Method POST

📦 ติดตั้ง body-parser (Optional)

💡 หมายเหตุ: ใน Express 4.16+ เราสามารถใช้ express.json() แทน body-parser ได้โดยไม่ต้องติดตั้งเพิ่มนะครับ

npm install body-parser --save

🔧 วิธีใช้งาน JSON Parser

วิธีที่ 1: ใช้ body-parser

const bodyParser = require('body-parser')
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))

วิธีที่ 2: ใช้ Express (แนะนำ) ⭐

app.use(express.json())
app.use(express.urlencoded({ extended: true }))

✅ แนะนำ: ใช้วิธีที่ 2 กันนะครับ เพราะไม่ต้องติดตั้ง package เพิ่ม และ Express รองรับอยู่แล้ว

➕ สร้าง User โดยใช้ Method POST

app.post('/users', (req, res) => {
    // push ข้อมูลจาก body ไปใน users array
    users.push(req.body)
    // ดึงเฉพาะข้อมูล username เก็บไว้ในตัวแปร username
    let username = req.body.username
    // ส่ง response กลับไปให้ผู้ใช้ API
    res.json(`Add user: '${username}' was successfully.`)
})

🔍 อธิบายโค้ด:

app.post() - สร้าง POST route
req.body - ข้อมูลที่ส่งมาจาก client (JSON)
users.push() - เพิ่มข้อมูลใหม่เข้าไปใน array
res.json() - ส่ง response กลับเป็น JSON

📝 ตัวอย่างโค้ดเต็มใน `api-demo.js`

ไฟล์: api-demo.js

const express = require('express')
const app = express();
app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

const users = require('./db.json')

app.get('/', (req, res) => {
    res.send("Hello! Node.js")
})

app.get('/users', (req, res) => {
    res.status(200).json(users)
})

app.get('/users/:id', (req, res) => {
    res.json(users.find(el => el.id === Number(req.params.id)))
})

// สร้าง users
app.post('/users', (req, res) => {
    // push ข้อมูลจาก body ไปใน users array
    users.push(req.body)
    // ดึงเฉพาะข้อมูล username เก็บไว้ในตัวแปร username
    let username = req.body.username
    // ส่ง response กลับไปให้ผู้ใช้ API
    res.json(`Add user: '${username}' was successfully.`)
})

app.listen(PORT, () => {
    console.log(`SERVER ON PORT ${PORT}`)
})

🧪 ทดสอบ API ด้วย Postman

Method: POST
URL: http://localhost:5000/users
Headers:

   Content-Type: application/json

Body (raw JSON):

   {
     "id": 4,
     "username": "user4",
     "name": "John"
   }

✅ Response ที่คาดหวัง:

"Add user: 'user4' was successfully."

Section 1-8 - ✏️ Method PUT

🔄 อัปเดตข้อมูล User โดยใช้ Method PUT

Method PUT ใช้สำหรับอัปเดตข้อมูลที่มีอยู่แล้ว

📌 Route สำหรับอัปเดต User

app.put('/users/:id', (req, res) => {
    // ค้นหา index ของ user ด้วย id ที่รับมาจาก params
    const userIndex = users.findIndex(user => user.id === Number(req.params.id))

    // ตรวจสอบว่าพบ user หรือไม่
    if (userIndex !== -1) {
        // อัปเดตข้อมูล user
        users[userIndex] = { ...users[userIndex], ...req.body }
        res.json(`Update user id: '${users[userIndex].id}' was successfully.`)
    } else {
        res.status(404).json({ message: 'User not found' })
    }
})

🔍 อธิบายโค้ด:

findIndex() - ค้นหา index ของ user ใน array
...users[userIndex] - spread operator เพื่อคงข้อมูลเดิม
...req.body - spread operator เพื่ออัปเดตข้อมูลใหม่
ตรวจสอบ userIndex !== -1 เพื่อยืนยันว่าพบ user

📝 ตัวอย่างโค้ดเต็มใน `api-demo.js`

ไฟล์: api-demo.js

const express = require('express')
const app = express();
app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

const users = require('./db.json')

app.get('/', (req, res) => {
    res.send("Hello! Node.js")
})

app.get('/users', (req, res) => {
    res.status(200).json(users)
})

app.get('/users/:id', (req, res) => {
    res.json(users.find(el => el.id === Number(req.params.id)))
})

// สร้าง users
app.post('/users', (req, res) => {
    users.push(req.body)
    let username = req.body.username
    res.json(`Add user: '${username}' was successfully.`)
})

// อัปเดต user
app.put('/users/:id', (req, res) => {
    // ค้นหา user ด้วย id ที่รับมาจาก params
    const userIndex = users.findIndex(user => user.id === Number(req.params.id))

    if (userIndex !== -1) {
        // อัปเดตข้อมูล
        users[userIndex] = { ...users[userIndex], ...req.body }
        res.json(`Update user id: '${users[userIndex].id}' was successfully.`)
    } else {
        res.status(404).json({ message: 'User not found' })
    }
})

app.listen(PORT, () => {
    console.log(`SERVER ON PORT ${PORT}`)
})

🧪 ทดสอบ API ด้วย Postman

Method: PUT
URL: http://localhost:5000/users/1
Headers:

   Content-Type: application/json

Body (raw JSON):

   {
     "username": "user1_updated",
     "name": "Alice Updated"
   }

✅ Response ที่คาดหวัง:

"Update user id: '1' was successfully."

Section 1-9 - 🗑️ Method DELETE

🗑️ ลบข้อมูล User โดยใช้ Method DELETE

Method DELETE ใช้สำหรับลบข้อมูลที่มีอยู่แล้ว

📌 Route สำหรับลบ User

app.delete('/users/:id', (req, res) => {
    const userIndex = users.findIndex(user => user.id === Number(req.params.id))

    if (userIndex !== -1) {
        const deletedUser = users[userIndex]
        // ลบ user ออกจาก array
        users.splice(userIndex, 1)
        res.json(`Delete user '${deletedUser.username}' was successfully.`)
    } else {
        res.status(404).json({ message: 'User not found' })
    }
})

🔍 อธิบายโค้ด:

findIndex() - ค้นหา index ของ user ใน array
splice(userIndex, 1) - ลบ element 1 ตัวที่ตำแหน่ง userIndex
ตรวจสอบ userIndex !== -1 เพื่อยืนยันว่าพบ user

📝 ตัวอย่างโค้ดเต็มใน `api-demo.js` (CRUD Complete)

ไฟล์: api-demo.js

const express = require('express')
const app = express();
app.use(express.json())
app.use(express.urlencoded({ extended: true }))
const PORT = process.env.PORT || 5000

const users = require('./db.json')

// Home route
app.get('/', (req, res) => {
    res.send("Hello! Node.js")
})

// Get all users
app.get('/users', (req, res) => {
    res.status(200).json(users)
})

// Get user by id
app.get('/users/:id', (req, res) => {
    const user = users.find(el => el.id === Number(req.params.id))
    if (user) {
        res.json(user)
    } else {
        res.status(404).json({ message: 'User not found' })
    }
})

// Create user
app.post('/users', (req, res) => {
    users.push(req.body)
    let username = req.body.username
    res.status(201).json(`Add user: '${username}' was successfully.`)
})

// Update user
app.put('/users/:id', (req, res) => {
    const userIndex = users.findIndex(user => user.id === Number(req.params.id))

    if (userIndex !== -1) {
        users[userIndex] = { ...users[userIndex], ...req.body }
        res.json(`Update user id: '${users[userIndex].id}' was successfully.`)
    } else {
        res.status(404).json({ message: 'User not found' })
    }
})

// Delete user
app.delete('/users/:id', (req, res) => {
    const userIndex = users.findIndex(user => user.id === Number(req.params.id))

    if (userIndex !== -1) {
        const deletedUser = users[userIndex]
        users.splice(userIndex, 1)
        res.json(`Delete user '${deletedUser.username}' was successfully.`)
    } else {
        res.status(404).json({ message: 'User not found' })
    }
})

app.listen(PORT, () => {
    console.log(`SERVER ON PORT ${PORT}`)
})

🧪 ทดสอบ API ด้วย Postman

Method: DELETE
URL: http://localhost:5000/users/1

✅ Response ที่คาดหวัง:

"Delete user 'user1' was successfully."

🎉 สรุป Module 1

เราได้เรียนรู้การสร้าง RESTful API แบบพื้นฐานครบทั้ง CRUD Operations กันแล้ว:

Method	Endpoint	Description
`GET`	`/users`	ดึงข้อมูล users ทั้งหมด
`GET`	`/users/:id`	ดึงข้อมูล user ตาม id
`POST`	`/users`	สร้าง user ใหม่
`PUT`	`/users/:id`	อัปเดตข้อมูล user
`DELETE`	`/users/:id`	ลบ user

Akkarapon Phikulsri

Jan 8

NodeJS 101 — Part 2 💾MySQL

#node #express #javascript #tutorial

4 min read

Reference

akkaraponph / basic-nodejs-express-sequelize-mysql

สร้าง API โดยใช้ JavaScript Node.js Express

🚀 การสร้าง API โดยใช้ JavaScript Node.js Express

คู่มือการพัฒนา RESTful API แบบครบวงจรด้วย Node.js, Express, Sequelize และ MySQL

📖 คำนำ

🌐 Express HTTP Framework - สำหรับสร้าง web server
🗄️ Sequelize - ORM สำหรับจัดการฐานข้อมูล
💾 MySQL - ฐานข้อมูลเชิงสัมพันธ์
🔧 POSTMAN - สำหรับทดสอบ API

📚 สารบัญ

Module 1: 📡 Basic API

Module 2: 💾 Basic API MySQL

Section 2-1 - 🚀 Create New App Express and…

📂 ดูรายละเอียดเพิ่มเติม Week 02 →

🌐 Cisco Packet Tracer Lab Collection

Akkarapon Phikulsri — Thu, 08 Jan 2026 03:56:39 +0000

หมายเหตุ Tutorial นี้จัดทำขึ้นเมื่อปี 2020 และปรับปรุงเมื่อ 2026

คอลเลกชันแล็บ Cisco Packet Tracer สำหรับวิชา Data Communication and Computer Network

เรียนรู้การตั้งค่าเครือข่ายตั้งแต่พื้นฐานจนถึงขั้นสูง พร้อมคำสั่งและตัวอย่างที่ใช้งานได้จริง

📖 เกี่ยวกับโปรเจกต์นี้

โปรเจกต์นี้รวบรวมแล็บ Cisco Packet Tracer ที่ครอบคลุมเนื้อหาตั้งแต่พื้นฐานไปจนถึงขั้นสูง เหมาะสำหรับผู้ที่กำลังศึกษาเรื่องเครือข่ายคอมพิวเตอร์และต้องการฝึกปฏิบัติจริง

ในแต่ละ Week คุณจะได้เรียนรู้:

✅ การตั้งค่าอุปกรณ์เครือข่าย (Router, Switch, PC)
✅ การจัดการ IP Address และ Subnet
✅ การสร้างและจัดการ VLAN
✅ การตั้งค่า Routing Protocol (RIP)
✅ Network Address Translation (NAT)
✅ และอีกมากมาย...

🗂️ โครงสร้างโปรเจกต์

lab-cisco-packet-tracer/
│
├── 📁 labs/                    # ไฟล์แล็บทั้งหมด
│   ├── Week01/                 # Introduction to Cisco Packet Tracer
│   ├── Week02/                 # การทดสอบการตั้งค่า
│   ├── Week03/                 # Static IP และ Share IP
│   ├── Week04/                 # แล็บเพิ่มเติม
│   ├── Week06/                 # แล็บพื้นฐาน
│   ├── Week07/                 # VLAN Configuration
│   ├── Week08/                 # แล็บเพิ่มเติม
│   ├── Week09/                 # แล็บพื้นฐาน
│   └── Week10/                 # RIP Routing Protocol
│
├── 📁 docs/                    # เอกสารและคำสั่ง
│   ├── introduction.txt        # คำสั่ง Week 1
│   ├── vlan.txt                # คำสั่ง VLAN
│   └── text.txt                # คำสั่ง RIP
│
├── 📁 images/                  # รูปภาพและ screenshots
│   └── ...
│
└── 📁 examples/                # ไฟล์ตัวอย่างเพิ่มเติม
    └── ...

🎯 เนื้อหาการเรียนรู้

Week 01: Introduction to Cisco Packet Tracer 🚀

เริ่มต้นการเดินทางของคุณที่นี่!

เรียนรู้พื้นฐานการใช้งาน Cisco Packet Tracer ตั้งแต่การเพิ่มอุปกรณ์ การเชื่อมต่อ และการตั้งค่า IP Address พื้นฐาน เหมาะสำหรับผู้เริ่มต้น

วัตถุประสงค์

ทำความคุ้นเคยกับ Cisco Packet Tracer Interface
เรียนรู้การเพิ่มและเชื่อมต่ออุปกรณ์พื้นฐาน
เรียนรู้การตั้งค่า IP Address
เรียนรู้คำสั่งพื้นฐานของ Router
เรียนรู้การตรวจสอบการเชื่อมต่อ

เนื้อหาการเรียนรู้

1. การใช้งาน Cisco Packet Tracer

Interface และ Tools พื้นฐาน
การเพิ่มอุปกรณ์ (Devices)
การเชื่อมต่อด้วยสาย (Connections)

2. การตั้งค่า IP Address

การตั้งค่า IP บน PC
การตั้งค่า IP บน Router Interface
Subnet Mask และ Default Gateway

3. คำสั่ง Router พื้นฐาน

Privileged Mode และ Configuration Mode
การตั้งค่า Interface
การเปิด/ปิด Interface

4. การตรวจสอบการเชื่อมต่อ

คำสั่ง ping
คำสั่ง show ต่างๆ
การดูสถานะ Interface

แล็บที่แนะนำ

Lab 1: Basic Network Setup
สร้าง network พื้นฐานที่มี:

2 PCs
1 Switch
1 Router

ขั้นตอน:

เพิ่มอุปกรณ์: 2 PCs, 1 Switch, 1 Router
เชื่อมต่อ PCs กับ Switch ด้วยสาย Straight-through
เชื่อมต่อ Switch กับ Router ด้วยสาย Straight-through
ตั้งค่า IP:
- PC0: 192.168.1.10/24, Gateway: 192.168.1.1
- PC1: 192.168.1.20/24, Gateway: 192.168.1.1
- Router Fa0/0: 192.168.1.1/24
เปิด Router Interface: no shutdown
ทดสอบ ping ระหว่าง PC0 และ PC1

Lab 2: Router Configuration Practice
ฝึกการตั้งค่า Router:

เข้าสู่ Privileged Mode: enable
เข้าสู่ Configuration Mode: configure terminal
ตั้งค่า Interface: interface FastEthernet 0/0
ตั้งค่า IP: ip address 192.168.1.1 255.255.255.0
เปิด Interface: no shutdown
ตรวจสอบ: show ip interface brief

คำสั่งที่ควรจำ

enable                          # เข้าสู่ privileged mode
configure terminal              # เข้าสู่ configuration mode
interface FastEthernet 0/0      # เลือก interface
ip address [IP] [Subnet]         # ตั้งค่า IP
no shutdown                     # เปิดใช้งาน interface
exit                            # ออกจาก mode ปัจจุบัน
show ip interface brief         # ดูสถานะ interface
ping [IP]                       # ทดสอบการเชื่อมต่อ

📂 ดูรายละเอียดเพิ่มเติม Week 01 → | 📄 เอกสารคำสั่ง →

Week 02: การทดสอบการตั้งค่า 🔍

ตรวจสอบและแก้ไขปัญหาเครือข่าย

ฝึกทักษะการตรวจสอบการตั้งค่าและการแก้ไขปัญหาเบื้องต้น เรียนรู้การใช้คำสั่ง diagnostic ต่างๆ

วัตถุประสงค์

ทดสอบการตั้งค่าพื้นฐานของอุปกรณ์เครือข่าย
ฝึกการตรวจสอบการทำงานของ network
ทำความเข้าใจการตั้งค่า IP และการเชื่อมต่อ

เนื้อหาการเรียนรู้

1. การทดสอบการตั้งค่า

การตรวจสอบการตั้งค่า IP Address
การทดสอบการเชื่อมต่อระหว่างอุปกรณ์
การใช้คำสั่งตรวจสอบสถานะ

2. การแก้ไขปัญหาเบื้องต้น

การตรวจสอบการเชื่อมต่อสาย
การตรวจสอบการตั้งค่า Interface
การใช้คำสั่ง diagnostic

ไฟล์แล็บ

week2_test_config.pkt - แล็บทดสอบการตั้งค่าพื้นฐาน

ขั้นตอนการทำแล็บ

เปิดไฟล์ week2_test_config.pkt
ตรวจสอบการตั้งค่า IP Address ของอุปกรณ์ทั้งหมด
ทดสอบการเชื่อมต่อด้วยคำสั่ง ping
ตรวจสอบสถานะ Interface ด้วย show ip interface brief
ตรวจสอบ routing table ด้วย show ip route (ถ้ามี Router)

คำสั่งที่ใช้

show ip interface brief         # ดูสถานะ interface ทั้งหมด
show running-config             # ดูการตั้งค่าปัจจุบัน
ping [IP Address]               # ทดสอบการเชื่อมต่อ
traceroute [IP Address]         # ติดตามเส้นทางของ packet
show ip route                   # ดู routing table

การตรวจสอบ

✅ ทุกอุปกรณ์สามารถ ping ถึงกันได้
✅ Interface ทั้งหมดมีสถานะ UP
✅ IP Address ถูกตั้งค่าถูกต้อง
✅ Default Gateway ถูกตั้งค่าถูกต้อง

Week 03: Static IP และ Share IP 🌐

จัดการ IP Address อย่างมืออาชีพ

เรียนรู้การตั้งค่า Static IP Address และการแชร์ IP Address ด้วย NAT/PAT เพื่อให้เครือข่ายภายในสามารถเข้าถึงอินเทอร์เน็ตได้

วัตถุประสงค์

เรียนรู้การตั้งค่า Static IP Address
เรียนรู้การแชร์ IP Address (NAT/PAT)
ทำความเข้าใจความแตกต่างระหว่าง Static IP และ Dynamic IP
เรียนรู้การตั้งค่า Network Address Translation (NAT)

เนื้อหาการเรียนรู้

1. Static IP Configuration

การตั้งค่า IP Address แบบ Static
การตั้งค่า Subnet Mask และ Default Gateway
การตั้งค่า DNS Server

2. IP Sharing (NAT/PAT)

Network Address Translation (NAT)
Port Address Translation (PAT)
การแชร์ IP Address ระหว่างเครือข่าย

ไฟล์แล็บ

week03_ex01_StaticIP.pkt - แล็บการตั้งค่า Static IP
week03_ex02_ShareIP.pkt - แล็บการแชร์ IP Address

ขั้นตอนการทำแล็บ

Lab 1: Static IP Configuration

เปิดไฟล์ week03_ex01_StaticIP.pkt
ตั้งค่า Static IP Address ให้กับทุกอุปกรณ์
ตั้งค่า Default Gateway ให้ถูกต้อง
ทดสอบการเชื่อมต่อด้วย ping

Lab 2: IP Sharing (NAT)

เปิดไฟล์ week03_ex02_ShareIP.pkt
ตั้งค่า NAT บน Router
ตรวจสอบการทำงานของ NAT
ทดสอบการเชื่อมต่อจากภายในไปภายนอก

คำสั่งที่ใช้

Static IP Configuration

interface FastEthernet 0/0
ip address [IP] [Subnet Mask]
no shutdown

NAT Configuration

# กำหนด inside interface
interface FastEthernet 0/0
ip nat inside
exit

# กำหนด outside interface
interface Serial 0/0/0
ip nat outside
exit

# สร้าง NAT pool (ถ้าต้องการ)
ip nat pool [pool-name] [start-ip] [end-ip] netmask [subnet]
ip nat inside source list [ACL-number] pool [pool-name]

# หรือใช้ PAT (overload)
ip nat inside source list [ACL-number] interface [interface] overload

การตรวจสอบ NAT

show ip nat translations        # ดู NAT translation table
show ip nat statistics          # ดูสถิติ NAT
debug ip nat                    # debug NAT (ใช้ใน privileged mode)

การตรวจสอบ

✅ ทุกอุปกรณ์มี Static IP Address ที่ถูกต้อง
✅ NAT ทำงานถูกต้อง (ถ้ามี)
✅ อุปกรณ์ภายในสามารถเชื่อมต่อภายนอกได้
✅ การ translate IP Address ทำงานถูกต้อง

📂 ดูรายละเอียดเพิ่มเติม Week 03 →

Week 04: แล็บเพิ่มเติม 💡

ทบทวนและฝึกฝน

แล็บเพิ่มเติมสำหรับทบทวนความรู้ที่เรียนมาและฝึกทักษะการแก้ไขปัญหาที่ซับซ้อนขึ้น

วัตถุประสงค์

ฝึกทักษะการตั้งค่าเครือข่ายเพิ่มเติม
ทบทวนความรู้ที่เรียนมา
เรียนรู้การแก้ไขปัญหาที่ซับซ้อนขึ้น

เนื้อหาการเรียนรู้

1. การตั้งค่าเครือข่ายที่ซับซ้อน

การเชื่อมต่อหลายเครือข่าย
การตั้งค่า Router หลายตัว
การจัดการ Subnet หลายตัว

2. การแก้ไขปัญหา

การวินิจฉัยปัญหาการเชื่อมต่อ
การตรวจสอบการตั้งค่า
การแก้ไขข้อผิดพลาด

ไฟล์แล็บ

LAB_28122021.pkt - แล็บวันที่ 28 ธันวาคม 2021
LAB28112021.pkt - แล็บวันที่ 28 พฤศจิกายน 2021
test.pkt - แล็บทดสอบ

ขั้นตอนการทำแล็บ

เปิดไฟล์แล็บที่ต้องการทำ
ศึกษาโครงสร้างเครือข่าย
ตรวจสอบการตั้งค่าปัจจุบัน
ตั้งค่าตามที่กำหนด (ถ้ามี)
ทดสอบการเชื่อมต่อ
แก้ไขปัญหาที่พบ

คำสั่งที่ใช้

# การตรวจสอบ
show ip interface brief
show running-config
show ip route
show cdp neighbors

# การตั้งค่า
configure terminal
interface [interface]
ip address [IP] [Subnet]
no shutdown

# การทดสอบ
ping [IP]
traceroute [IP]

📂 ดูรายละเอียดเพิ่มเติม Week 04 →

Week 06: แล็บพื้นฐาน 📚

ทบทวนพื้นฐานเครือข่าย

ทบทวนความรู้พื้นฐานเกี่ยวกับเครือข่าย การตั้งค่าอุปกรณ์ และการทำงานของเครือข่าย

วัตถุประสงค์

ทบทวนความรู้พื้นฐานเกี่ยวกับเครือข่าย
ฝึกทักษะการตั้งค่าอุปกรณ์เครือข่าย
ทำความเข้าใจการทำงานของเครือข่ายพื้นฐาน

เนื้อหาการเรียนรู้

1. Network Fundamentals

การเชื่อมต่ออุปกรณ์เครือข่าย
การตั้งค่า IP Address
การทดสอบการเชื่อมต่อ

2. Device Configuration

การตั้งค่า Router
การตั้งค่า Switch
การตั้งค่า End Devices

ไฟล์แล็บ

W6LAB01.pkt - แล็บพื้นฐาน Week 6

ขั้นตอนการทำแล็บ

เปิดไฟล์ W6LAB01.pkt
ศึกษาโครงสร้างเครือข่าย
ตรวจสอบการตั้งค่าปัจจุบัน
ตั้งค่าตามที่กำหนด
ทดสอบการเชื่อมต่อระหว่างอุปกรณ์
ตรวจสอบการทำงานของเครือข่าย

คำสั่งที่ใช้

# Router Configuration
enable
configure terminal
interface FastEthernet 0/0
ip address [IP] [Subnet Mask]
no shutdown
exit

# การตรวจสอบ
show ip interface brief
show running-config
show ip route

# การทดสอบ
ping [IP Address]

📂 ดูรายละเอียดเพิ่มเติม Week 06 →

Week 07: VLAN Configuration 🏢

แยกเครือข่ายแบบลอจิก

เรียนรู้การสร้างและจัดการ VLAN (Virtual LAN) เพื่อแยกเครือข่ายแบบลอจิกโดยไม่ต้องแยกทางกายภาพ และการเชื่อมต่อระหว่าง VLAN ด้วย Router-on-a-Stick

วัตถุประสงค์

เรียนรู้การสร้างและจัดการ VLAN (Virtual LAN)
เรียนรู้การตั้งค่า VLAN บน Switch
เรียนรู้การเชื่อมต่อระหว่าง VLAN (Inter-VLAN Routing)
ทำความเข้าใจประโยชน์ของ VLAN

เนื้อหาการเรียนรู้

1. VLAN Basics

ความหมายและประโยชน์ของ VLAN
การแยกเครือข่ายแบบลอจิก
VLAN ID และ VLAN Name

2. VLAN Configuration

การสร้าง VLAN
การกำหนด Port ให้กับ VLAN
การตั้งค่า Trunk Port
การตั้งค่า Access Port

3. Inter-VLAN Routing

การเชื่อมต่อระหว่าง VLAN ด้วย Router
Router-on-a-Stick Configuration
การตั้งค่า Sub-interface

ไฟล์แล็บ

W7LAB01.pkt - แล็บ VLAN พื้นฐาน
W7LAB02.pkt - แล็บ VLAN ขั้นสูง
W7LAB03.pkt - แล็บ Inter-VLAN Routing
ExtraClass_VLAN.pkt - แล็บเพิ่มเติม VLAN

ขั้นตอนการทำแล็บ

Lab 1: Basic VLAN Configuration

เปิดไฟล์ W7LAB01.pkt
สร้าง VLAN ใหม่
กำหนด Port ให้กับ VLAN
ทดสอบการเชื่อมต่อภายใน VLAN เดียวกัน

Lab 2: Multiple VLANs

เปิดไฟล์ W7LAB02.pkt
สร้าง VLAN หลายตัว
กำหนด Port ให้กับ VLAN ที่เหมาะสม
ทดสอบการแยกเครือข่าย

Lab 3: Inter-VLAN Routing

เปิดไฟล์ W7LAB03.pkt
ตั้งค่า Router-on-a-Stick
สร้าง Sub-interface สำหรับแต่ละ VLAN
ทดสอบการเชื่อมต่อระหว่าง VLAN

คำสั่งที่ใช้

สร้าง VLAN

configure terminal
vlan [VLAN-ID]
name [VLAN-NAME]
exit

กำหนด Port ให้กับ VLAN

configure terminal
interface FastEthernet 0/[port-number]
switchport mode access
switchport access vlan [VLAN-ID]
no shutdown
exit

ตั้งค่า Trunk Port

configure terminal
interface FastEthernet 0/[port-number]
switchport mode trunk
switchport trunk allowed vlan [VLAN-IDs]
no shutdown
exit

Router-on-a-Stick (Inter-VLAN Routing)

configure terminal
interface FastEthernet 0/0.[VLAN-ID]
encapsulation dot1Q [VLAN-ID]
ip address [IP] [Subnet Mask]
no shutdown
exit

การตรวจสอบ VLAN

show vlan                    # ดู VLAN ทั้งหมด
show vlan brief              # ดู VLAN แบบย่อ
show interfaces switchport    # ดูการตั้งค่า switchport
show interfaces trunk        # ดู trunk port

การตรวจสอบ

✅ VLAN ถูกสร้างและตั้งค่าถูกต้อง
✅ Port ถูกกำหนดให้กับ VLAN ที่ถูกต้อง
✅ อุปกรณ์ใน VLAN เดียวกันสามารถสื่อสารกันได้
✅ อุปกรณ์ใน VLAN ต่างกันไม่สามารถสื่อสารกันได้ (ถ้าไม่มี Router)
✅ Inter-VLAN Routing ทำงานถูกต้อง (ถ้ามี Router)

📂 ดูรายละเอียดเพิ่มเติม Week 07 → | 📄 คำสั่ง VLAN →

Week 08: แล็บเพิ่มเติม 🎓

ฝึกฝนขั้นสูง

แล็บเพิ่มเติมสำหรับฝึกทักษะการตั้งค่าเครือข่ายที่ซับซ้อนและการแก้ไขปัญหาขั้นสูง

วัตถุประสงค์

ฝึกทักษะการตั้งค่าเครือข่ายเพิ่มเติม
ทบทวนความรู้ที่เรียนมา
เรียนรู้การแก้ไขปัญหาที่ซับซ้อนขึ้น

เนื้อหาการเรียนรู้

1. Advanced Network Configuration

การตั้งค่าเครือข่ายที่ซับซ้อน
การจัดการหลายเครือข่าย
การแก้ไขปัญหาขั้นสูง

2. Network Troubleshooting

การวินิจฉัยปัญหาการเชื่อมต่อ
การใช้คำสั่ง diagnostic
การแก้ไขข้อผิดพลาด

ไฟล์แล็บ

EXTRA_W8LAB01.pkt - แล็บเพิ่มเติม Week 8

ขั้นตอนการทำแล็บ

เปิดไฟล์ EXTRA_W8LAB01.pkt
ศึกษาโครงสร้างเครือข่าย
ตรวจสอบการตั้งค่าปัจจุบัน
ตั้งค่าตามที่กำหนด
ทดสอบการเชื่อมต่อ
แก้ไขปัญหาที่พบ

คำสั่งที่ใช้

# การตรวจสอบ
show ip interface brief
show running-config
show ip route
show cdp neighbors
show vlan

# การตั้งค่า
configure terminal
interface [interface]
ip address [IP] [Subnet]
no shutdown

# การทดสอบ
ping [IP]
traceroute [IP]

📂 ดูรายละเอียดเพิ่มเติม Week 08 →

Week 09: แล็บพื้นฐาน 🔧

ทบทวนและเสริมสร้าง

ทบทวนความรู้พื้นฐานและเสริมสร้างทักษะการตั้งค่าเครือข่ายและการแก้ไขปัญหา

วัตถุประสงค์

ทบทวนความรู้พื้นฐานเกี่ยวกับเครือข่าย
ฝึกทักษะการตั้งค่าอุปกรณ์เครือข่าย
ทำความเข้าใจการทำงานของเครือข่าย

เนื้อหาการเรียนรู้

1. Network Configuration Review

การตั้งค่า IP Address
การตั้งค่า Router
การตั้งค่า Switch
การทดสอบการเชื่อมต่อ

2. Network Troubleshooting

การตรวจสอบการตั้งค่า
การแก้ไขปัญหาเบื้องต้น
การใช้คำสั่ง diagnostic

ไฟล์แล็บ

W09LAB1.pkt - แล็บพื้นฐาน Week 9

ขั้นตอนการทำแล็บ

เปิดไฟล์ W09LAB1.pkt
ศึกษาโครงสร้างเครือข่าย
ตรวจสอบการตั้งค่าปัจจุบัน
ตั้งค่าตามที่กำหนด
ทดสอบการเชื่อมต่อระหว่างอุปกรณ์
ตรวจสอบการทำงานของเครือข่าย
แก้ไขปัญหาที่พบ

คำสั่งที่ใช้

# Router Configuration
enable
configure terminal
interface FastEthernet 0/0
ip address [IP] [Subnet Mask]
no shutdown
exit

# การตรวจสอบ
show ip interface brief
show running-config
show ip route
show cdp neighbors

# การทดสอบ
ping [IP Address]
traceroute [IP Address]

📂 ดูรายละเอียดเพิ่มเติม Week 09 →

Week 10: RIP Routing Protocol 🛣️

เรียนรู้ Dynamic Routing

เรียนรู้การตั้งค่า RIP (Routing Information Protocol) ซึ่งเป็น Dynamic Routing Protocol ที่ Router ใช้แชร์ routing information กันอัตโนมัติ

วัตถุประสงค์

เรียนรู้การตั้งค่า RIP (Routing Information Protocol)
ทำความเข้าใจการทำงานของ Distance Vector Routing Protocol
เรียนรู้การแชร์ routing information ระหว่าง Router
เรียนรู้การตรวจสอบและแก้ไขปัญหา RIP

เนื้อหาการเรียนรู้

1. RIP Basics

ความหมายและหลักการทำงานของ RIP
Distance Vector Routing Protocol
RIP Version 1 และ Version 2
Administrative Distance และ Metric

2. RIP Configuration

การเปิดใช้งาน RIP
การประกาศ Network
การตั้งค่า RIP Version
การตรวจสอบ RIP

3. RIP Troubleshooting

การตรวจสอบ RIP Routes
การแก้ไขปัญหา RIP
การใช้คำสั่ง debug

ไฟล์แล็บ

W10LAB01.pkt - แล็บการตั้งค่า RIP

ขั้นตอนการทำแล็บ

เปิดไฟล์ W10LAB01.pkt
ศึกษาโครงสร้างเครือข่ายและ Router ทั้งหมด
ตั้งค่า IP Address ให้กับทุก Interface
เปิดใช้งาน RIP บน Router ทุกตัว
ประกาศ Network ที่เชื่อมต่ออยู่
ตรวจสอบ Routing Table
ทดสอบการเชื่อมต่อระหว่างเครือข่าย

คำสั่งที่ใช้

การตั้งค่า RIP

configure terminal
router rip
version 2                    # ใช้ RIP version 2 (ถ้าต้องการ)
network [network-address]    # ประกาศ network ที่เชื่อมต่ออยู่
no auto-summary             # ปิดการสรุปอัตโนมัติ (RIP v2)
exit

การตรวจสอบ RIP

show ip route                # ดู routing table
show ip protocols           # ดู routing protocol ที่ใช้งาน
show ip rip database        # ดู RIP database
debug ip rip                # debug RIP (ใช้ใน privileged mode)

การตั้งค่า Interface

configure terminal
interface FastEthernet 0/0
ip address [IP] [Subnet Mask]
no shutdown
exit

ตัวอย่างการตั้งค่า

Router(config)# router rip
Router(config-router)# version 2
Router(config-router)# network 192.168.1.0
Router(config-router)# network 192.168.2.0
Router(config-router)# no auto-summary
Router(config-router)# exit

การตรวจสอบ

✅ RIP ทำงานบน Router ทุกตัว
✅ Network ถูกประกาศถูกต้อง
✅ Routing Table มี RIP routes
✅ อุปกรณ์ในเครือข่ายต่างกันสามารถสื่อสารกันได้
✅ Router แชร์ routing information กันได้

เปรียบเทียบ RIP กับ Static Routing

Static Routing: ต้องตั้งค่าเองทุกเส้นทาง, ไม่มีการอัปเดตอัตโนมัติ
RIP: เรียนรู้ routes อัตโนมัติ, มีการอัปเดตเป็นระยะ, เหมาะกับเครือข่ายขนาดเล็ก-กลาง

📂 ดูรายละเอียดเพิ่มเติม Week 10 → | 📄 คำสั่ง RIP →

📚 เอกสารอ้างอิง

ในโฟลเดอร์ docs/ คุณจะพบเอกสารคำสั่งที่สำคัญ:

📄 introduction.txt - คำสั่งและขั้นตอนสำหรับ Week 1
📄 vlan.txt - คำสั่งการตั้งค่า VLAN
📄 text.txt - คำสั่งการตั้งค่า RIP

🚀 เริ่มต้นใช้งาน

ข้อกำหนดเบื้องต้น

Cisco Packet Tracer - ดาวน์โหลดได้จาก Cisco Networking Academy
ความรู้พื้นฐานเกี่ยวกับเครือข่ายคอมพิวเตอร์ (แนะนำ)

ขั้นตอนการใช้งาน

ดาวน์โหลดหรือ Clone โปรเจกต์

   git clone [repository-url]
   cd lab-cisco-packet-tracer

เปิดไฟล์แล็บ
- เปิด Cisco Packet Tracer
- เปิดไฟล์ .pkt จากโฟลเดอร์ labs/WeekXX/
ศึกษาและทำตาม
- อ่าน README.md ในแต่ละ Week เพื่อเข้าใจวัตถุประสงค์
- ทำตามขั้นตอนใน README.md
- ดูเอกสารใน docs/ สำหรับคำสั่งที่เกี่ยวข้อง
ทดสอบและตรวจสอบ
- ใช้คำสั่ง ping เพื่อทดสอบการเชื่อมต่อ
- ใช้คำสั่ง show เพื่อตรวจสอบการตั้งค่า
- ใช้ Simulation Mode เพื่อดูการทำงานของ packets

💡 Tips & Tricks

สำหรับผู้เริ่มต้น

เริ่มจาก Week 01 เพื่อทำความคุ้นเคยกับ Cisco Packet Tracer
อ่าน README.md ในแต่ละ Week ก่อนเริ่มทำแล็บ
ใช้ Help (?) ใน Cisco Packet Tracer เพื่อดูคำสั่งที่ใช้ได้

สำหรับผู้มีประสบการณ์

ดูไฟล์ในโฟลเดอร์ examples/ สำหรับแล็บเพิ่มเติม
ทดลองแก้ไขและปรับแต่งแล็บเพื่อเรียนรู้เพิ่มเติม
ใช้ Simulation Mode เพื่อเข้าใจการทำงานของ protocols

คำสั่งที่ควรจำ

# การตรวจสอบ
show ip interface brief      # ดูสถานะ interface
show running-config          # ดูการตั้งค่าปัจจุบัน
show ip route                # ดู routing table

# การทดสอบ
ping [IP Address]            # ทดสอบการเชื่อมต่อ
traceroute [IP Address]      # ติดตามเส้นทาง

# การบันทึก
write memory                 # บันทึกการตั้งค่า

📸 Screenshots

ดูรูปภาพและ screenshots จากแล็บต่างๆ ในโฟลเดอร์ images/

🎓 ตัวอย่างเพิ่มเติม

ในโฟลเดอร์ examples/ คุณจะพบแล็บเพิ่มเติมสำหรับฝึกฝน:

การเปรียบเทียบ RIP กับ Static Routing
แล็บ NAT และ DHCP
และอีกมากมาย...

⚠️ หมายเหตุสำคัญ

ไฟล์ทั้งหมดเป็นไฟล์ Cisco Packet Tracer (.pkt)
ใช้ Cisco Packet Tracer เวอร์ชันที่รองรับเพื่อเปิดไฟล์
เอกสารใน docs/ เป็นคำสั่งพื้นฐานสำหรับการตั้งค่า
แนะนำให้บันทึกการตั้งค่าทุกครั้งด้วย write memory หรือ copy running-config startup-config

ขอบคุณที่สนใจโปรเจกต์นี้! คับผ๋ม หวังว่าแล็บเหล่านี้จะช่วยให้คุณเข้าใจการทำงานของเครือข่ายคอมพิวเตอร์มากขึ้น :)

Happy Learning! 🎉

อัปเดตล่าสุด: 2026

Reference

akkaraponph / lab-cisco-packet-tracer

Data Communitaion and Computer Network

หมายเหตุ Tutorial นี้จัดทำขึ้นเมื่อปี 2020 และปรับปรุงเมื่อ 2026

🌐 Cisco Packet Tracer Lab Collection

คอลเลกชันแล็บ Cisco Packet Tracer สำหรับวิชา Data Communication and Computer Network
เรียนรู้การตั้งค่าเครือข่ายตั้งแต่พื้นฐานจนถึงขั้นสูง พร้อมคำสั่งและตัวอย่างที่ใช้งานได้จริง

📖 เกี่ยวกับโปรเจกต์นี้

ในแต่ละ Week คุณจะได้เรียนรู้:

✅ การตั้งค่าอุปกรณ์เครือข่าย (Router, Switch, PC)
✅ การจัดการ IP Address และ Subnet
✅ การสร้างและจัดการ VLAN
✅ การตั้งค่า Routing Protocol (RIP)
✅ Network Address Translation (NAT)
✅ และอีกมากมาย...

🗂️ โครงสร้างโปรเจกต์

lab-cisco-packet-tracer/
│
├── 📁 labs/                    # ไฟล์แล็บทั้งหมด
│   ├── Week01/                 # Introduction to Cisco Packet Tracer
│   ├── Week02/                 # การทดสอบการตั้งค่า
│   ├── Week03/                 # Static IP และ Share IP
│   ├── Week04/                 # แล็บเพิ่มเติม
│   ├── Week06/                 # แล็บพื้นฐาน
│   ├── Week07/                 # VLAN Configuration
│   ├── Week08/                 # แล็บเพิ่มเติม
│   ├── Week09/                 # แล็บพื้นฐาน
│   └── Week10/                 # RIP Routing Protocol
│
├── 📁 docs/                    # เอกสารและคำสั่ง
│   ├── introduction.txt        # คำสั่ง Week 1
│   ├── vlan.txt                # คำสั่ง VLAN
│   └── text.txt                # คำสั่ง

…

Commit Message Format

Akkarapon Phikulsri — Thu, 08 Jan 2026 03:16:52 +0000

Each commit message consists of a header, a body, and a footer. The header has a special format that includes a type, a scope, and a subject:

<type>(<scope>): <subject>
<BLANK LINE>

<body>
<BLANK LINE>
<footer>

The header is mandatory and the scope of the header is optional.

Example — fix: remove unused dependency lodash.camelcase

Any line of the commit message cannot be longer than 100 characters. This allows the message to be easier to read on GitHub as well as in various git tools.

Type

Must be one of the following:

feat: A new feature.
fix: A bug fix.
docs: Documentation only changes. style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc).
refactor: A code change that neither fixes a bug nor adds a feature.
perf: A code change that improves performance.
test: Adding missing tests.
chore: Changes to the build process or auxiliary tools and libraries such as documentation generation.
ci: Changes to our CI configuration files and scripts.
build: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm).
revert: Reverts a previous commit.
wip: Work in progress. Commit that may be removed later.

Scope

The scope is optional and could be anything specifying the place of the commit change. For example nsis, mac, linux, etc.

Subject

The subject contains a succinct description of the change:

Use the imperative, present tense: change not changed nor changes.
Don't capitalize the first letter.
No dot (.) at the end.

Body

Just as in the subject, use the imperative, present tense: "change" not "changed" nor "changes".
The body should include the motivation for the change and contrast this with the previous behavior.

Footer

The footer should contain any information about Breaking Changes and is also the place to reference GitHub issues that this commit Closes.

Breaking Changes should start with the word BREAKING CHANGE: with a space or two newlines. The rest of the commit message is then used for this.

Best Practices

Write Meaningful Commit Messages: Ensure that each commit message clearly conveys what the change is and why it was made. This is crucial for maintaining a clear project history.
Keep Commits Small: Each commit should represent a single logical change. This makes it easier to review changes and revert them if necessary.
Use Branches: For each new feature or bug fix, create a new branch. This helps in keeping the main branch stable and allows for easier collaboration.
Squash Commits: Before merging a feature branch into the main branch, consider squashing commits to ensure a clean and concise project history.
Review Before Commit: Review your changes before committing. Ensure that your code adheres to the project's coding standards and passes all tests.
Automate Testing: Set up automated tests to run on each commit to ensure that changes do not introduce new bugs.
Follow a Consistent Style: Adhere to the established style guide for the project to maintain consistency across the codebase.

Reference

FreeCodeCamp. (2022, March 2). How to write better Git commit messages. FreeCodeCamp. https://www.freecodecamp.org/news/how-to-write-better-git-commit-messages/
Beams, C. (n.d.). How to write a Git commit message. Retrieved July 16, 2024, from https://cbea.ms/git-commit/
2my. (2021, October 30). Git conventional commits. 2my Blog. https://blog.2my.xyz/2021/10/30/git-conventional-commits/

akkaraponph / commit-messages

Commit Message Format

Each commit message consists of a header, a body, and a footer. The header has a special format that includes a type, a scope, and a subject:

<type>(<scope>): <subject>
<BLANK LINE>

<body>
<BLANK LINE>
<footer>

The header is mandatory and the scope of the header is optional.

Example — fix: remove unused dependency lodash.camelcase

Any line of the commit message cannot be longer than 100 characters. This allows the message to be easier to read on GitHub as well as in various git tools.

Type

Must be one of the following:

feat: A new feature.
fix: A bug fix.
docs: Documentation only changes style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc).
refactor: A code change that neither fixes a bug nor adds a feature.
perf: A code change that improves performance.
test: Adding…