【API待ち解消】「モックで進めました（圧）」で進捗報告が強気に！Express.jsで始めるリアルガチ・モックサーバー実装術（HTTPS/プロキシ対応）

mkdir uncoming-api
cd uncoming-api
npm init -y

Copy

npm install express

Copy

{
    "users": [
        {
            "id": 1,
            "name": "John Doe",
            "email": "john.doe@example.com"
        },
        {
            "id": 2,
            "name": "Jane Smith",
            "email": "jane.smith@example.com"
        },
        {
            "id": 3,
            "name": "Alice Johnson",
            "email": "alice.johnson@example.com"
        }
    ]
}

Copy

uncoming-api/
├── resource/
│   └── users.json
├── routes/
│   └── users.js  // このファイルについては後ほど説明します
└── server.js     // このメインファイルも後ほど作成します

Copy

/**
 * このファイルは、Express.js を使用してAPIモックサーバーを起動するためのメインスクリプトです。
 * 以下の主な処理を行います:
 * 1. 必要なモジュールの読み込み (express, path など)
 * 2. Expressアプリケーションインスタンスの作成
 * 3. 共通ミドルウェアの設定 (例: JSONパーサー)
 * 4. 外部ファイルに定義されたAPIルートの読み込みとアプリケーションへのマウント
 * 5. 指定されたポートでのHTTPサーバーの起動とリクエストの待ち受け開始
 */

// Expressフレームワークを読み込みます。Node.jsでWebアプリケーションを構築するための主要なツールです。
const express = require('express');
// Node.js標準の 'path' モジュールを読み込みます。ファイルパスの操作や解決に便利です。
const path = require('path');

// Expressアプリケーションのインスタンスを作成します。これがサーバー全体の基本となります。
const app = express();
// サーバーがリッスンするポート番号を定義します。
const port = 3000;

// --- ミドルウェアの設定 ---
// Expressアプリケーションが受け取ったリクエストのボディがJSON形式である場合、
// それをJavaScriptオブジェクトとして解析（パース）するためのミドルウェアを適用します。
// これにより、POSTやPATCHリクエストなどで送信されたJSONデータに req.body でアクセスできるようになります。
app.use(express.json());

// --- ルーターの読み込みとマウント ---
// './routes/users.js' ファイルに定義されたユーザー関連のAPIルートを読み込みます。
// 'require' を使うことで、別のファイルに分割されたモジュール（この場合はExpressのルーター）を利用できます。
const userRoutes = require('./routes/users');

// 読み込んだユーザー関連のルート (userRoutes) を、'/users' というベースパスにマウント（割り当て）します。
// これにより、例えば userRoutes で定義された '/' へのルートは、実際には '/users' としてアクセス可能になり、
// '/:id' へのルートは '/users/:id' としてアクセス可能になります。
// このようにして、APIのエンドポイントをモジュール化し、整理することができます。
app.use('/users', userRoutes);

// (もし他のリソース、例えば '/products' に関するルートがあれば、同様に追加できます)
// const productRoutes = require('./routes/products');
// app.use('/products', productRoutes);


// --- サーバーの起動 ---
// 指定されたポート (port) でHTTPリクエストの待ち受けを開始します。
// サーバーが起動すると、第2引数に渡されたコールバック関数が実行されます。
app.listen(port, () => {
    // サーバーが正常に起動したことを示すメッセージをコンソールに出力します。
    console.log(`Mock API server is running at http://localhost:${port}`);
    // ユーザーAPIがどのベースURLで利用可能かを示します。
    console.log(`User API endpoints are available under http://localhost:${port}/users`);
    // ユーザーデータが保存されているJSONファイルの場所を示します。
    // path.joinを使って、現在のディレクトリ (__dirname) からの相対パスで安全にファイルパスを構築しています。
    console.log(`Data is stored in: ${path.join(__dirname, 'resource', 'users.json')}`);
});

Copy

// routes/users.js

/**
 * このファイルは、ユーザーリソース (/users) に関連するAPIのルーティングを定義します。
 * ExpressのRouter機能を利用して、各HTTPメソッド（GET, POST, PATCH, DELETE）に対応する
 * エンドポイントと、それぞれの処理内容を記述しています。
 * データはプロジェクト内の 'resource/users.json' ファイルにJSON形式で保存され、
 * このファイルを通じて読み書きが行われます。
 */

const express = require('express');
const router = express.Router(); // ExpressのRouterインスタンスを作成
const fs = require('fs'); // Node.js標準のファイルシステムモジュール
const path = require('path'); // Node.js標準のパス操作モジュール

// ユーザーデータが保存されているJSONファイルへの絶対パスを構築します。
// '__dirname' は現在のファイル (users.js) が存在するディレクトリ (routes/) を指すため、
// '../resource/users.json' でプロジェクトルート下の 'resource/users.json' を指定します。
const usersFilePath = path.join(__dirname, '..', 'resource', 'users.json');

// --- データアクセス用ヘルパー関数 ---
// 以下のヘルパー関数は、users.jsonファイルの読み書きやID生成といった共通処理を担います。

/**
 * 'users.json' ファイルからユーザーデータを同期的に読み込み、JavaScriptオブジェクトとして返します。
 * ファイルが存在しない場合やJSONとして不正な場合は、空のユーザーリストを持つオブジェクトを返します。
 * @returns {{ users: Array<Object> }} ユーザーデータ。例: { users: [{ id: 1, name: "John" }] }
 */
function readUsersData() {
    try {
        // ファイルの内容をUTF-8文字列として読み込みます。
        const data = fs.readFileSync(usersFilePath, 'utf8');
        // 読み込んだ文字列をJSONオブジェクトにパースします。
        return JSON.parse(data);
    } catch (error) {
        // ファイル読み込みやJSONパース中にエラーが発生した場合のフォールバック処理です。
        console.error(`[${new Date().toISOString()}] Error reading users data from ${usersFilePath}: ${error.message}`);
        // ファイルが存在しない (ENOENT) か、内容が空または不正なJSON (SyntaxError) の場合、
        // アプリケーションがエラーで停止しないよう、初期状態のデータ構造を返します。
        if (error.code === 'ENOENT' || error instanceof SyntaxError) {
            return { users: [] };
        }
        // その他の予期せぬエラーの場合は、エラーを再スローして上位の処理に任せます。
        throw error;
    }
}

/**
 * 与えられたJavaScriptオブジェクトを整形されたJSON文字列に変換し、'users.json'ファイルに同期的に書き込みます。
 * @param {Object} data 書き込むデータ。通常は { users: [...] } という形式。
 */
function writeUsersData(data) {
    try {
        // JavaScriptオブジェクトをJSON文字列に変換します。
        // 'null, 2' はJSONを人間が読みやすいように2スペースでインデントして整形するためのオプションです。
        const jsonData = JSON.stringify(data, null, 4);
        // 整形されたJSON文字列をファイルに書き込みます。
        fs.writeFileSync(usersFilePath, jsonData, 'utf8');
    } catch (error) {
        // ファイル書き込み中にエラーが発生した場合の処理です。
        console.error(`[${new Date().toISOString()}] Error writing users data to ${usersFilePath}: ${error.message}`);
        throw error;
    }
}

/**
 * 新しいユーザーのためのユニークなIDを生成します (簡易的な実装)。
 * 現在のユーザーリスト内で最も大きなIDを探し、それに1を加えた値を返します。
 * ユーザーが一人もいない場合は、1から開始します。
 * @param {{ users: Array<{id: number}> }} usersData 現在の全ユーザーデータ。
 * @returns {number} 次に使用可能な新しいユーザーID。
 */
function getNextUserId(usersData) {
    // usersプロパティが存在しない、またはユーザーリストが空の場合、最初のIDとして1を返します。
    if (!usersData.users || usersData.users.length === 0) {
        return 1;
    }
    // 既存ユーザーのIDの中から最大値を見つけます。
    // reduceメソッドを使って、各ユーザーのidと現在の最大値を比較し、より大きい方を採用します。
    // 初期値は0としています。
    const maxId = usersData.users.reduce((max, user) => (user.id > max ? user.id : max), 0);
    // 最大IDに1を加えて、新しいユニークなIDとします。
    return maxId + 1;
}

// --- APIエンドポイントの定義 ---
// ここから、各HTTPリクエスト（GET, POST, PATCH, DELETE）に対応する
//具体的なAPI処理を定義していきます。
// router.get('/', ...) の '/' は、メインファイル(server.jsなど)で
// このルーターが '/users' にマウントされているため、実質的に '/users' を意味します。

/**
 * GET /users
 * 登録されている全ユーザーのリストを取得します。
 */
router.get('/', (req, res) => {
    console.log(`[${new Date().toISOString()}] GET /users (handled by routes/users.js)`);
    try {
        // 1. ファイルから全ユーザーデータを読み込みます。
        const usersData = readUsersData();
        // 2. ユーザーの配列 (usersData.users) をJSON形式でクライアントに返します。
        //    もしusersData.usersが存在しない場合(例:ファイルが空だった直後など)は空配列を返します。
        res.json(usersData.users || []);
    } catch (error) {
        // 3. データ読み込み中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in GET /users: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ユーザーデータの取得に失敗しました。' });
    }
});

/**
 * GET /users/:id
 * 指定されたIDを持つ特定のユーザーの情報を取得します。
 * :id 部分はURLパラメータとして扱われ、リクエストされたユーザーIDが入ります。
 */
router.get('/:id', (req, res) => {
    const requestedId = req.params.id; // URLから:id部分の値を取得
    console.log(`[${new Date().toISOString()}] GET /users/${requestedId} (handled by routes/users.js)`);
    try {
        // 1. ファイルから全ユーザーデータを読み込みます。
        const usersData = readUsersData();
        // 2. URLパラメータで受け取ったIDを数値に変換します (URLパラメータは文字列として渡されるため)。
        const userId = parseInt(requestedId, 10);
        // 3. ユーザーリストから、指定されたIDに一致するユーザーを探します。
        const foundUser = usersData.users.find(user => user.id === userId);

        if (foundUser) {
            // 4a. ユーザーが見つかった場合、そのユーザーの情報をJSONで返します。
            res.json(foundUser);
        } else {
            // 4b. ユーザーが見つからなかった場合、404 Not Foundエラーを返します。
            res.status(404).json({ message: `ユーザーが見つかりません (ID: ${userId})` });
        }
    } catch (error) {
        // 5. データ読み込み中や処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in GET /users/${requestedId}: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ユーザー情報の取得に失敗しました。' });
    }
});

/**
 * POST /users
 * 新しいユーザーを作成します。ユーザー情報はリクエストボディにJSON形式で含めます。
 * 例: { "name": "Taro Yamada", "email": "taro@example.com" }
 */
router.post('/', (req, res) => {
    console.log(`[${new Date().toISOString()}] POST /users (handled by routes/users.js) with body:`, req.body);
    try {
        // 1. リクエストボディから新しいユーザーの名前とメールアドレスを取得します。
        const { name, email } = req.body;

        // 2. 入力値の簡易的なバリデーション: nameとemailが提供されているかを確認します。
        if (!name || !email) {
            return res.status(400).json({ message: '名前とメールアドレスは必須です。' }); // 400 Bad Request
        }

        // 3. 現在のユーザーデータをファイルから読み込みます。
        const usersData = readUsersData();

        // 4. (簡易バリデーション) 提供されたメールアドレスが既に存在するかチェックします。
        if (usersData.users.some(user => user.email === email)) {
            // 既に存在する場合は、409 Conflictエラーを返します。
            return res.status(409).json({ message: `メールアドレス '${email}' は既に使用されています。` });
        }

        // 5. 新しいユーザーオブジェクトを作成します。IDは自動生成します。
        const newUser = {
            id: getNextUserId(usersData),
            name: name,
            email: email
        };

        // 6. 新しいユーザーをユーザーリストに追加します。
        usersData.users.push(newUser);
        // 7. 更新されたユーザーリスト全体をファイルに書き戻し、永続化します。
        writeUsersData(usersData);

        // 8. ユーザー作成成功を示すステータスコード201 (Created) と共に、
        //    作成されたユーザーの情報をJSONでクライアントに返します。
        res.status(201).json(newUser);
    } catch (error) {
        // 9. 処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in POST /users: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ユーザーの作成に失敗しました。' });
    }
});

/**
 * PATCH /users/:id
 * 指定されたIDを持つ特定のユーザーの情報を部分的に更新します。
 * 更新する情報はリクエストボディにJSON形式で含めます (例: { "name": "New Name" })。
 * ボディに含まれるフィールドのみが更新対象となります。
 */
router.patch('/:id', (req, res) => {
    const requestedId = req.params.id;
    console.log(`[${new Date().toISOString()}] PATCH /users/${requestedId} (handled by routes/users.js) with body:`, req.body);
    try {
        // 1. 現在のユーザーデータをファイルから読み込みます。
        const usersData = readUsersData();
        // 2. URLパラメータからユーザーIDを取得し、数値に変換します。
        const userId = parseInt(requestedId, 10);
        // 3. 更新対象のユーザーがリスト内に存在するか、そのインデックスを探します。
        const userIndex = usersData.users.findIndex(user => user.id === userId);

        // 4. ユーザーが見つからない場合は404 Not Foundエラーを返します。
        if (userIndex === -1) {
            return res.status(404).json({ message: `ユーザーが見つかりません (ID: ${userId})` });
        }

        // 5. 更新対象のユーザーオブジェクトへの参照を取得します。
        const userToUpdate = usersData.users[userIndex];

        // 6. リクエストボディに含まれている情報でユーザーデータを更新します。
        //    'name' がリクエストボディにあれば、名前を更新します。
        if (req.body.name !== undefined) {
            userToUpdate.name = req.body.name;
        }
        //    'email' がリクエストボディにあれば、メールアドレスを更新します。
        if (req.body.email !== undefined) {
            // (簡易バリデーション) 更新しようとしているメールアドレスが、
            // 他のユーザー（自分自身を除く）に既に使用されていないかチェックします。
            if (usersData.users.some(user => user.email === req.body.email && user.id !== userId)) {
                return res.status(409).json({ message: `メールアドレス '${req.body.email}' は他のユーザーに既に使用されています。` });
            }
            userToUpdate.email = req.body.email;
        }
        // 他に更新可能なフィールドがあれば、同様のロジックを追加できます。

        // 7. 更新されたユーザー情報で、元の配列内の情報を置き換えます。
        usersData.users[userIndex] = userToUpdate;
        // 8. 更新されたユーザーリスト全体をファイルに書き戻し、永続化します。
        writeUsersData(usersData);

        // 9. 更新後のユーザー情報をJSONでクライアントに返します。
        res.json(userToUpdate);
    } catch (error) {
        // 10. 処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in PATCH /users/${requestedId}: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ユーザーの更新に失敗しました。' });
    }
});

/**
 * DELETE /users/:id
 * 指定されたIDを持つ特定のユーザーを削除します。
 */
router.delete('/:id', (req, res) => {
    const requestedId = req.params.id;
    console.log(`[${new Date().toISOString()}] DELETE /users/${requestedId} (handled by routes/users.js)`);
    try {
        // 1. 現在のユーザーデータをファイルから読み込みます。
        const usersData = readUsersData();
        // 2. URLパラメータからユーザーIDを取得し、数値に変換します。
        const userId = parseInt(requestedId, 10);
        // 3. 削除前のユーザー数を記録しておきます（ユーザーが見つかったかどうかの判定用）。
        const initialUserCount = usersData.users.length;
        // 4. 指定されたID以外のユーザーで新しい配列を再構築し、実質的に対象ユーザーを削除します。
        usersData.users = usersData.users.filter(user => user.id !== userId);

        // 5. ユーザーリストの長さが変わっていなければ、対象のユーザーが見つからなかった（削除されなかった）と判断します。
        if (usersData.users.length === initialUserCount) {
            return res.status(404).json({ message: `ユーザーが見つかりません (ID: ${userId})` });
        }

        // 6. 更新されたユーザーリスト全体をファイルに書き戻し、永続化します。
        writeUsersData(usersData);
        // 7. 削除成功を示すステータスコード204 (No Content) を返します。
        //    このステータスコードは、レスポンスボディがないことを意味します。
        res.status(204).send();
    } catch (error) {
        // 8. 処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in DELETE /users/${requestedId}: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ユーザーの削除に失敗しました。' });
    }
});

// このルーターモジュールをエクスポートし、メインのサーバーファイル (server.js) から利用できるようにします。
module.exports = router;

Copy

node server.js

Copy

myuser@mypc uncoming-api % node server.js
Mock API server is running at http://localhost:3000
User API endpoints are available under http://localhost:3000/users
Data is stored in: /Users/myuser/uncoming-api/resource/users.json

Copy

{
    "users": [
        {
            "id": 1,
            "name": "John Doe",
            "email": "john.doe@example.com",
            "notes": [
                {
                    "id": 1,
                    "content": "This is a note for John Doe.",
                    "created_at": "2023-10-03T12:00:00Z"
                },
                {
                    "id": 2,
                    "content": "Another note for John Doe.",
                    "created_at": "2023-10-02T11:00:00Z"
                }
            ]
        },
        {
            "id": 2,
            "name": "Jane Smith",
            "email": "jane.smith@example.com",
            "notes": [
                {
                    "id": 1,
                    "content": "This is a note for Jane Smith.",
                    "created_at": "2023-10-03T12:00:00Z"
                }
            ]
        },
        {
            "id": 3,
            "name": "Alice Johnson",
            "email": "alice.johnson@example.com",
            "notes": []
        }
    ]
}

Copy

        // routes/users.js の router.post('/', ...) 内
        // ...
        // 5. 新しいユーザーオブジェクトを作成します。IDは自動生成します。
        const newUser = {
            id: getNextUserId(usersData),
            name: name,
            email: email
        };
        // ...

Copy

        // 5. 新しいユーザーオブジェクトを作成します。IDは自動生成します。
        const newUser = {
            id: getNextUserId(usersData),
            name: name,
            email: email,
            notes: [] // ← この行で notes プロパティを空の配列として追加
        };

Copy

/**
 * POST /users/:userId/notes
 * 指定されたユーザーIDに対して新しいノートを追加します。
 * ノートの内容はリクエストボディにJSON形式で含めます。
 * 例: { "content": "This is a new note." }
 */
router.post('/:userId/notes', (req, res) => {
    console.log(`[${new Date().toISOString()}] POST /users/:userId/notes (handled by routes/users.js) with body:`, req.body);
    try {
        // 1. リクエストパラメータからユーザーIDを取得します。
        const userId = parseInt(req.params.userId, 10); // URLパラメータからユーザーIDを取得し、数値に変換します。
        
        // 2. リクエストボディからノートの内容を取得します。
        const { content } = req.body; // リクエストボディからノートの内容を取得します。

        // 3. 入力値の簡易的なバリデーション: contentが提供されているかを確認します。
        if (!content) {
            return res.status(400).json({ message: 'ノートの内容は必須です。' }); // 400 Bad Request
        }
        // 4. 現在のユーザーデータをファイルから読み込みます。
        const usersData = readUsersData();

        // 5. 指定されたユーザーIDに一致するユーザーを探します。
        const user = usersData.users.find(user => user.id === userId);

        // 6. ユーザーが見つからない場合は404 Not Foundエラーを返します。
        if (!user) {
            return res.status(404).json({ message: `ユーザーが見つかりません (ID: ${userId})` });
        }
        // 7. 新しいノートオブジェクトを作成します。IDは自動生成します。
        const newNote = {
            id: getNextNoteId(user), // ノートIDの自動生成
            content: content,
            createdAt: new Date().toISOString() // 作成日時をISO形式で保存
        };

        // 8. ユーザーのノートリストに新しいノートを追加します。
        user.notes.push(newNote);
        // 9. 更新されたユーザーデータ全体をファイルに書き戻し、永続化します。
        writeUsersData(usersData);
        // 10. ノート作成成功を示すステータスコード201 (Created) と共に、
        //     作成されたノートの情報をJSONでクライアントに返します。
        res.status(201).json(newNote);
    } catch (error) {
        // 11. 処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in POST /users/:userId/notes: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ノートの作成に失敗しました。' });
    }
});

// --- データアクセス用ヘルパー関数 ---

/**
 * 特定のユーザーの新しいノートのためのユニークなIDを生成します。
 * そのユーザーの既存のノートIDの最大値に1を加えた値を返します。
 * ノートが一つも存在しない場合は、1から開始します。
 * @param {Object} user - 対象のユーザーオブジェクト (user.notes を持つことを期待)
 * @returns {number} 次に使用可能な新しいノートID。
 */
function getNextNoteId(user) {
    // user.notes が存在し、かつ配列であることを確認します。
    if (!user || !Array.isArray(user.notes) || user.notes.length === 0) {
        return 1; // ノートがない、またはnotesプロパティがない場合、最初のIDとして1を返します。
    }
    // ノートのIDの中から最大値を見つけます。
    const maxId = user.notes.reduce((max, note) => (note.id > max ? note.id : max), 0);
    // 最大IDに1を加えて、新しいユニークなノートIDとします。
    return maxId + 1;
}

Copy

// routes/users.js (ヘルパー関数セクションに追加)
/**
  特定のユーザーの新しいノートのためのユニークなIDを生成します。
  そのユーザーの既存のノートIDの最大値に1を加えた値を返します。
  ノートが一つも存在しない場合は、1から開始します。
  @param {Object} user - 対象のユーザーオブジェクト (user.notes を持つことを期待)
  @returns {number} 次に使用可能な新しいノートID。
 /
function getNextNoteId(user) {
    // user.notes が存在し、かつ配列であることを確認します。
    if (!user || !Array.isArray(user.notes) || user.notes.length === 0) {
        console.log(`[${new Date().toISOString()}] No notes found for user, or notes array is empty. Returning ID 1.`);
        // ユーザーやノートのデータ構造を確認するために、詳細なログを出力するのはデバッグに有効です。
        // console.log(`[${new Date().toISOString()}] User data (for getNextNoteId):`, JSON.stringify(user, null, 2));
        return 1; // ノートがない、またはnotesプロパティがない場合、最初のIDとして1を返します。
    }

    // ノートのIDの中から最大値を見つけます。
    const maxId = user.notes.reduce((currentMax, note) => {
        const noteIdAsNumber = parseInt(note.id, 10); // note.id を10進数の数値に変換

        // noteIdAsNumber が有効な数値であり、かつ現在の最大値 (currentMax) より大きいかを確認
        if (!isNaN(noteIdAsNumber) && noteIdAsNumber > currentMax) {
            return noteIdAsNumber; // 新しい最大値を返す
        }
        return currentMax; // そうでなければ、現在の最大値を維持
    }, 0); // 初期値を0とする

    // 最大IDに1を加えて、新しいユニークなノートIDとします。
    return maxId + 1;
}

Copy

// routes/users.js
// ... (既存のGET, POST /users などのエンドポイント定義) ...

router.post('/:userId/notes', (req, res) => {
    console.log(`[${new Date().toISOString()}] POST /users/${req.params.userId}/notes (handled by routes/users.js) with body:`, req.body);
    try {
        // --- ここから処理を記述していく ---
        // (仮のレスポンス)
        res.send('POST /users/:userId/notes endpoint hit!');
    } catch (error) {
        console.error(`[${new Date().toISOString()}] Error in POST /users/:userId/notes: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ノートの作成に失敗しました。' });
    }
});

Copy

        // routes/users.js の POST /users/:userId/notes 内
        // 1. リクエストパラメータからユーザーIDを取得します。
        const userId = parseInt(req.params.userId, 10); // :userId を数値として取得
        // 2. リクエストボディからノートの内容を取得します。
        const { content } = req.body; // ボディから content を取得

Copy

        // routes/users.js の POST /users/:userId/notes 内
        // 3. 入力値の簡易的なバリデーション: contentが提供されているかを確認します。
        if (!content) {
            return res.status(400).json({ message: 'ノートの内容は必須です。' });
        }

Copy

        // routes/users.js の POST /users/:userId/notes 内
        // 4. 現在のユーザーデータをファイルから読み込みます。
        const usersData = readUsersData();

Copy

        // routes/users.js の POST /users/:userId/notes 内
        // 5. 指定されたユーザーIDに一致するユーザーを探します。
        const user = usersData.users.find(u => u.id === userId);
        // 6. ユーザーが見つからない場合は404 Not Foundエラーを返します。
        if (!user) {
            return res.status(404).json({ message: `ユーザーが見つかりません (ID: ${userId})` });
        }

Copy

        // 7. 新しいノートオブジェクトを作成します。IDは自動生成します。
        const newNote = {
            id: getNextNoteId(user),
            content: content,
            created_at: new Date().toISOString()
        };

Copy

        // 8. ユーザーのノートリストに新しいノートを追加します。
        user.notes.push(newNote);
        // 9. 更新されたユーザーデータ全体をファイルに書き戻し、永続化します。
        writeUsersData(usersData);

Copy

        // 10. ノート作成成功を示すステータスコード201 (Created) と共に、
        // 作成されたノートの情報をJSONでクライアントに返します。
        res.status(201).json(newNote);

Copy

    } catch (error) {
        // 11. 処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in POST /users/:userId/notes: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ノートの作成に失敗しました。' });
    }

Copy

/**
 * PATCH /users/:userId/notes/:noteId
 * 指定されたユーザーIDとノートIDに対してノートの内容を更新します。
 * 更新する内容はリクエストボディにJSON形式で含めます。
 * 例: { "content": "Updated note content." }
 */
router.patch('/:userId/notes/:noteId', (req, res) => {
    const userId = parseInt(req.params.userId, 10);
    const noteId = parseInt(req.params.noteId, 10);
    console.log(`[${new Date().toISOString()}] PATCH /users/${userId}/notes/${noteId} (handled by routes/users.js) with body:`, req.body);
    try {
        // 1. 現在のユーザーデータをファイルから読み込みます。
        const usersData = readUsersData();
        // 2. 指定されたユーザーIDに一致するユーザーを探します。
        const user = usersData.users.find(u => u.id === userId);
        // 3. ユーザーが見つからない場合は404 Not Foundエラーを返します。
        if (!user) {
            return res.status(404).json({ message: `ユーザーが見つかりません (ID: ${userId})` });
        }

        // 4. ユーザーのノートリストから、指定されたノートIDに一致するノートを探します。
        const noteIndex = user.notes.findIndex(note => note.id === noteId);
        // 5. ノートが見つからない場合は404 Not Foundエラーを返します。
        if (noteIndex === -1) {
            return res.status(404).json({ message: `ノートが見つかりません (ID: ${noteId})` });
        }

        // 6. リクエストボディから更新内容を取得します。
        const { content } = req.body;
        // 7. 入力値の簡易的なバリデーション: contentが提供されているかを確認します。
        if (!content) {
            return res.status(400).json({ message: 'ノートの内容は必須です。' });
        }

        // 8. ノートの内容を更新します。
        user.notes[noteIndex].content = content;
        // 9. 更新されたユーザーデータ全体をファイルに書き戻し、永続化します。
        writeUsersData(usersData);

        // 10. 更新後のノート情報をJSONでクライアントに返します。
        res.json(user.notes
        [noteIndex]);
    } catch (error) {
        // 11. 処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in PATCH /users/${userId}/notes/${noteId}: ${error.message}`);
        res.status(500).json({ message: 'サーバーエラー: ノートの更新に失敗しました。' });
    }
});

Copy

/**
 * DELETE /users/:userId/notes/:noteId
 * 指定されたユーザーIDとノートIDに対してノートを削除します。
 */
router.delete('/:userId/notes/:noteId', (req, res) => {
    const userId = parseInt(req.params.userId, 10);
    const noteId = parseInt(req.params.noteId, 10);
    console.log(`[${new Date().toISOString()}] DELETE /users/${userId}/notes/${noteId} (handled by routes/users.js)`);

    try {
        // 1. 現在のユーザーデータをファイルから読み込みます。
        const usersData = readUsersData();
        // 2. 指定されたユーザーIDに一致するユーザーを探します。
        const user = usersData.users.find(u => u.id === userId);
        // 3. ユーザーが見つからない場合は404 Not Foundエラーを返します。
        if (!user) {
            return res.status(404).json({ message: `ユーザーが見つかりません (ID: ${userId})` });
        }

        // 4. ユーザーのノートリストから、指定されたノートIDに一致するノートを探します。
        const noteIndex = user.notes.findIndex(note => note.id === noteId);
        // 5. ノートが見つからない場合は404 Not Foundエラーを返します。
        if (noteIndex === -1) {
            return res.status(404).json({ message: `ノートが見つかりません (ID: ${noteId})` });
        }

        // 6. ノートを削除します。配列のfilterメソッドを使って、指定されたノート以外のものを残します。
        user.notes.splice(noteIndex, 1);
        // 7. 更新されたユーザーデータ全体をファイルに書き戻し、永続化します。
        writeUsersData(usersData);

        // 8. 削除成功を示すステータスコード204 (No Content) を返します。
        res.status(204).send();
    } catch (error) {
        // 9. 処理中に予期せぬエラーが発生した場合、500 Internal Server Errorを返します。
        console.error(`[${new Date().toISOString()}] Error in DELETE /users/${userId}/notes/${noteId}: ${error
            .message}`);
        res.status(500).json({ message: 'サーバーエラー: ノートの削除に失敗しました。' });
    }
});

Copy

npm install http-proxy-middleware

Copy

/**
 * このファイルは、Express.js を使用してAPIモックサーバーを起動するためのメインスクリプトです。
 * ローカルでのモックAPI処理と、指定外のAPIリクエストを実際のバックエンドへ転送する
 * プロキシ機能を提供します。
 */

// 必要なモジュールの読み込み
const express = require('express');
const path = require('path');
const { createProxyMiddleware } = require('http-proxy-middleware'); // http-proxy-middleware を読み込み

// --- プロキシターゲット設定 (重要: ご自身の環境に合わせて実際の値に書き換えてください) ---
// ここに、実際にリクエストを転送したいバックエンドAPIサーバーの情報を直接記述します。
const TARGET_API_SERVER = 'https://jsonplaceholder.typicode.com'; // 例: 'https://api.your-backend.com'
const TARGET_API_HOSTNAME_FOR_HEADER = 'jsonplaceholder.typicode.com'; // 例: 'api.your-backend.com' (通常はTARGET_API_SERVERのホスト名部分)

// Expressアプリケーションのインスタンスを作成
const app = express();
const port = 3000;

// --- 共通ミドルウェアの設定 ---
app.use(express.json()); // JSONパーサー

// --- モックAPIルートの読み込みとマウント ---
// `/users` へのリクエストはこちらのモックAPIで処理されます。
const userRoutes = require('./routes/users');
app.use('/users', userRoutes);
// (他のモックAPIルートがあれば、同様に追加できます)

// --- プロキシ設定 ---
const proxyOptions = {
    target: TARGET_API_SERVER, // プロキシ先のターゲットサーバー
    changeOrigin: true, // ホストヘッダーをターゲットのホストに変更
    secure: false, // HTTPSを使用する場合は、ターゲットサーバーの証明書検証を無効化（開発環境向け）
    logLevel: 'debug', // ログレベルをデバッグに設定（必要に応じて 'info' や 'warn' に変更可能）
    on: {
        // プロキシイベントのハンドラを定義
        // リクエストがターゲットサーバーに転送される前の処理
        proxyReq: (proxyReq, req, res) => {
            proxyReq.setHeader('Host', TARGET_API_HOSTNAME_FOR_HEADER);
            console.log(`[${new Date().toISOString()}] [PROXY_REQ] Forwarding ${req.method} ${req.originalUrl} to: ${TARGET_API_SERVER}${proxyReq.path} (Host: ${proxyReq.getHeader('Host')})`);
        },
        // ターゲットサーバーからのレスポンスを受け取った後の処理
        proxyRes: (proxyRes, req, res) => {
            console.log(`[${new Date().toISOString()}] [PROXY_RES] Received from target for ${req.method} ${req.originalUrl} - Status: ${proxyRes.statusCode}`);
        },
        // プロキシエラーが発生した場合の処理
        error: (err, req, res) => {
            console.error(`[${new Date().toISOString()}] [PROXY_ERR] Proxy Error for ${req.method} ${req.originalUrl}:`, err);
            if (res && res.writeHead && !res.headersSent) {
                // レスポンスヘッダーがまだ送信されていない場合にエラーレスポンスを送信
                console.error(`[${new Date().toISOString()}] [PROXY_ERR] Sending error response for ${req.originalUrl}`);
                // 502 Bad Gateway エラーをクライアントに返す
                // ここでは、JSON形式でエラーメッセージを返します。
                res.writeHead(502, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ message: 'Proxy error: Could not connect to target server.', error: err.message }));
            } else if (res && res.headersSent) {
                // レスポンスヘッダーが既に送信されている場合は、エラーメッセージをログに出力
                console.error(`[${new Date().toISOString()}] [PROXY_ERR] Headers already sent for ${req.originalUrl}, cannot send custom error to client.`);
            } else {
                // レスポンスオブジェクトが利用できない場合のエラーログ
                console.error(`[${new Date().toISOString()}] [PROXY_ERR] Response object not available for ${req.originalUrl}, cannot send error to client.`);
            }
        },
        // プロキシ接続が開かれたときの処理
        open: (proxySocket) => {
            console.log(`[${new Date().toISOString()}] [PROXY_EVENT] Connection to target server opened.`);
        },
        // プロキシ接続が閉じられたときの処理
        close: (proxyRes, proxySocket, head) => {
            console.log(`[${new Date().toISOString()}] [PROXY_EVENT] Connection to target server closed.`);
        }
    }
};

// プロキシミドルウェアの作成
const defaultProxy = createProxyMiddleware(proxyOptions);

// --- プロキシミドルウェアの適用 (重要: モックAPIルート定義の後に配置) ---
// すべてのリクエストをプロキシミドルウェアに渡します。
app.use(defaultProxy);

// --- Express全体のエラーハンドラ ---
app.use((err, req, res, next) => {
    console.error(`[${new Date().toISOString()}] [APP_ERR] Unhandled application error in mock server:`, err);
    if (!res.headersSent) {
        res.status(err.status || 500).json({
            message: 'Application error in mock server',
            error: err.message,
        });
    }
});

// --- サーバーの起動 ---
app.listen(port, () => {
    console.log(`\nMock API Server with Proxy is running at http://localhost:${port}`);
    console.log(`--------------------------------------------------------------------------------`);
    console.log(`  >> Application should be configured to send API requests to: http://localhost:${port}`);
    console.log(`\n  >> Mocked API Endpoints (handled locally):`);
    console.log(`     - User API: http://localhost:${port}/users`);
    console.log(`\n  >> Requests to all other paths will be proxied to: ${TARGET_API_SERVER}`);
    console.log(`     (Using Host header: ${TARGET_API_HOSTNAME_FOR_HEADER})`);
    console.log(`\n  User data for mocks is stored in: ${path.join(__dirname, 'resource', 'users.json')}`);
    console.log(`--------------------------------------------------------------------------------\n`);
});

Copy

myuser@mypc uncoming-api % node server.js

Mock API Server with Proxy is running at http://localhost:3000
--------------------------------------------------------------------------------
  >> Application should be configured to send API requests to: http://localhost:3000

  >> Mocked API Endpoints (handled locally):
     - User API: http://localhost:3000/users

  >> Requests to all other paths will be proxied to: https://jsonplaceholder.typicode.com

  User data for mocks is stored in: /Users/myuser/uncoming-api/resource/users.json
--------------------------------------------------------------------------------

Copy

[2025-05-28T04:06:50.327Z] GET /users (handled by routes/users.js)
[2025-05-28T04:07:18.646Z] [PROXY_REQ] Forwarding GET /arcicle to: https://jsonplaceholder.typicode.com/arcicles (Host: jsonplaceholder.typicode.com)
[2025-05-28T04:07:19.430Z] [PROXY_RES] Received from target for GET /arcicles - Status: 404
[2025-05-28T04:08:30.804Z] [PROXY_REQ] Forwarding GET /todos to: https://jsonplaceholder.typicode.com/todos (Host: jsonplaceholder.typicode.com)
[2025-05-28T04:08:30.903Z] [PROXY_RES] Received from target for GET /todos - Status: 200

Copy

sudo nano /etc/hosts

Copy

127.0.0.1 jsonplaceholder.typicode.com

Copy

brew install mkcert

Copy

mkcert -install

Copy

mkcert jsonplaceholder.typicode.com

Copy

npm install dotenv

Copy

uncoming-api/
├── certs/
│   ├── jsonplaceholder.typicode.com.pem      # (mkcertで生成したサーバー証明書)
│   └── jsonplaceholder.typicode.com-key.pem  # (mkcertで生成した秘密鍵)
├── node_modules/
├── resource/
│   └── users.json
├── routes/
│   └── users.js
├── server.js
├── package.json
├── .env
├── .env.template
└── .gitignore

Copy

# SSL証明書と秘密鍵のパス
# certsディレクトリ内に配置したファイル名を指定
SSL_CERT_PATH=./certs/jsonplaceholder.typicode.com.pem
SSL_KEY_PATH=./certs/jsonplaceholder.typicode.com-key.pem

# HTTPSサーバーのポート番号
HTTPS_PORT=443

# プロキシ先APIサーバーのURL
TARGET_API_SERVER=https://jsonplaceholder.typicode.com

# プロキシ先APIサーバーのIPアドレス（https://dns.google/）
TARGET_API_IP=104.21.64.1

Copy

# SSL証明書と秘密鍵のパス
# certsディレクトリ内に配置したファイル名を指定
SSL_CERT_PATH=./certs/target-domain.com.pem
SSL_KEY_PATH=./certs/v.com-key.pem

# HTTPSサーバーのポート番号
HTTPS_PORT=443

# プロキシサーバーのホスト名（hostsファイルで127.0.0.1に向ける対象ドメイン名）
TARGET_DOMAIN_FOR_HOSTS=target-domain.com

# プロキシサーバーのFQDN（フルクオリファイドドメイン名）
TARGET_API_SERVER_FQDN=https://target-domain.com

# プロキシ先APIサーバーのIPアドレス（https://dns.google/）
TARGET_API_IP=000.00.00.0

Copy

# 環境変数ファイル
.env

# mkcertでローカル生成したSSL証明書ファイル
certs/*.pem

Copy

/**
 * このファイルは、Express.js を使用してAPIモックサーバーを起動するためのメインスクリプトです。
 * ローカルでのモックAPI処理、指定外のAPIリクエストを実際のバックエンドへ転送するプロキシ機能、
 * および mkcert で生成された証明書を使用したローカルHTTPS機能を提供します。
 */

// .envファイルから環境変数を読み込む (ファイルの先頭で実行)
require('dotenv').config();

// 必要なモジュールの読み込み
const express = require('express');
const path = require('path');
const { createProxyMiddleware } = require('http-proxy-middleware');
const https = require('https'); // HTTPSモジュールを追加
const fs = require('fs'); // ファイルシステムモジュールを追加
const { URL } = require('url'); // URLモジュールを追加して URL パーシングを安全に

// --- 環境変数からの設定読み込み ---
const sslCertPath = process.env.SSL_CERT_PATH;
const sslKeyPath = process.env.SSL_KEY_PATH;

// HTTPSポートを環境変数から取得、なければデフォルトで443を使用
const httpsPort = parseInt(process.env.HTTPS_PORT, 10) || 443;

// --- プロキシターゲット設定 ---
// クライアントがアクセスするドメイン名（hostsで127.0.0.1に向ける対象）
const TARGET_DOMAIN_FOR_HOSTS = process.env.TARGET_DOMAIN_FOR_HOSTS || 'jsonplaceholder.typicode.com';
// 実際にリクエストを転送したいバックエンドAPIサーバーのFQDN (例: https://jsonplaceholder.typicode.com)
const TARGET_API_SERVER_FQDN = process.env.TARGET_API_SERVER_FQDN || 'https://jsonplaceholder.typicode.com';
// プロキシ先APIサーバーの実際のIPアドレス (hostsファイルが介入しないように直接指定)
const TARGET_API_IP = process.env.TARGET_API_IP || '104.21.64.1';

// Expressアプリケーションのインスタンスを作成
const app = express();

// --- 共通ミドルウェアの設定 ---
app.use(express.json()); // JSONパーサー

// --- モックAPIルートの読み込みとマウント ---
// `/users` へのリクエストはこちらのモックAPIで処理されます。
const userRoutes = require('./routes/users');
app.use('/users', userRoutes);
// (他のモックAPIルートがあれば、同様に追加できます)

// --- プロキシ設定 ---
// プロキシのターゲットは実際のIPアドレス（hostsの影響を受けない）
const proxyOptions = {
    target: `https://${TARGET_API_IP}`, // <<<< 無限ループ回避のため、IPアドレスを直接ターゲットにする
    changeOrigin: true, // ホストヘッダーをターゲットのホストに変更 (ただし proxyReq で上書きします)
    secure: false, // HTTPSを使用する場合は、ターゲットサーバーの証明書検証を無効化（開発環境向け）
    logLevel: 'debug',  // ログレベルをデバッグに設定
    agent: new https.Agent({
        rejectUnauthorized: false, // ターゲットサーバーの証明書検証を無効化（開発環境向け）
        servername: new URL(TARGET_API_SERVER_FQDN).hostname, // SNI対応のため、サーバーネームを設定
    }),
    on: {
        proxyReq: (proxyReq, req, res) => {
            // リクエストヘッダーの 'Host' を実際のドメイン名に設定
            // ターゲットがIPアドレスでも、相手サーバーはこのHostヘッダーを見てルーティングします。
            proxyReq.setHeader('Host', new URL(TARGET_API_SERVER_FQDN).hostname);
            console.log(`[${new Date().toISOString()}] [PROXY_REQ] Forwarding ${req.method} ${req.originalUrl} to: ${proxyOptions.target}${proxyReq.path} (Host: ${proxyReq.getHeader('Host')})`);
        },
        proxyRes: (proxyRes, req, res) => {
            // ターゲットサーバーからのレスポンスを受け取った後の処理
            console.log(`[${new Date().toISOString()}] [PROXY_RES] Received from target for ${req.method} ${req.originalUrl} - Status: ${proxyRes.statusCode}`);
        },
        // プロキシエラーが発生した場合の処理
        error: (err, req, res) => {
            console.error(`[${new Date().toISOString()}] [PROXY_ERR] Proxy Error for ${req.method} ${req.originalUrl}:`, err);
            if (res && res.writeHead && !res.headersSent) {
                // レスポンスヘッダーがまだ送信されていない場合にエラーレスポンスを送信
                console.error(`[${new Date().toISOString()}] [PROXY_ERR] Sending error response for ${req.originalUrl}`);
                // 502 Bad Gateway エラーをクライアントに返す
                res.writeHead(502, { 'Content-Type': 'application/json' });
                res.end(JSON.stringify({ message: 'Proxy error: Could not connect to target server.', error: err.message }));
            } else if (res && res.headersSent) {
                // レスポンスヘッダーが既に送信されている場合は、エラーメッセージをログに出力
                console.error(`[${new Date().toISOString()}] [PROXY_ERR] Headers already sent for ${req.originalUrl}, cannot send custom error to client.`);
            } else {
                // レスポンスオブジェクトが利用できない場合のエラーログ
                console.error(`[${new Date().toISOString()}] [PROXY_ERR] Response object not available for ${req.originalUrl}, cannot send error to client.`);
            }
        },
        // プロキシ接続が開かれたときの処理
        open: (proxySocket) => {
            console.log(`[${new Date().toISOString()}] [PROXY_EVENT] Connection to target server opened.`);
        },
        // プロキシ接続が閉じられたときの処理
        close: (proxyRes, proxySocket, head) => {
            console.log(`[${new Date().toISOString()}] [PROXY_EVENT] Connection to target server closed.`);
        }
    }
};

// プロキシミドルウェアの作成
const defaultProxy = createProxyMiddleware(proxyOptions);

// --- プロキシミドルウェアの適用 (モックAPIルート定義の後に配置) ---
app.use(defaultProxy);

// --- Express全体のエラーハンドラ ---
app.use((err, req, res, next) => {
    console.error(`[${new Date().toISOString()}] [APP_ERR] Unhandled application error in mock server:`, err);
    if (!res.headersSent) {
        // レスポンスヘッダーがまだ送信されていない場合にエラーレスポンスを送信
        console.error(`[${new Date().toISOString()}] [APP_ERR] Sending error response for ${req.originalUrl}`);
        // 500 Internal Server Error エラーをクライアントに返す
        res.status(err.status || 500).json({
            message: 'Application error in mock server',
            error: err.message,
        });
    }
});

// --- HTTPSサーバーの起動準備 ---
let httpsOptions;
try {
    // SSL証明書と秘密鍵のパスを環境変数から取得
    if (!sslCertPath || !sslKeyPath) {
        throw new Error('SSL_CERT_PATH and SSL_KEY_PATH must be defined in your .env file.');
    }
    // SSL証明書と秘密鍵をファイルから読み込む
    httpsOptions = {
        key: fs.readFileSync(sslKeyPath),
        cert: fs.readFileSync(sslCertPath),
    };
} catch (error) {
    // 設定ファイルが読み込めない場合はエラーメッセージを表示して終了
    console.error('[ERROR] Failed to read SSL certificate/key files.');
    console.error('Please ensure that SSL_CERT_PATH and SSL_KEY_PATH in your .env file point to valid files generated by mkcert.');
    console.error('Error details:', error.message);
    process.exit(1); // エラーが発生した場合はプロセスを終了
}

// --- HTTPSサーバーの作成と起動 ---
const httpsServer = https.createServer(httpsOptions, app);

httpsServer.listen(httpsPort, () => {
    // サーバーが正常に起動したことを示すメッセージをコンソールに出力
    console.log(`\nHTTPS Mock API Server with Proxy is running.`);
    console.log(`--------------------------------------------------------------------------------`);
    console.log(`  >> Listening on: https://localhost:${httpsPort}`);
    console.log(`  >> Your 'hosts' file should point '${TARGET_DOMAIN_FOR_HOSTS}' to 127.0.0.1.`);
    console.log(`  >> Application should send API requests to its original target domain`);
    console.log(`     (e.g., https://${TARGET_DOMAIN_FOR_HOSTS}/some-api-path)`);
    console.log(`\n  >> Mocked API Endpoints (handled locally):`);
    console.log(`     - User API: /users (accessed via https://${TARGET_DOMAIN_FOR_HOSTS}/users)`);
    console.log(`\n  >> Requests to all other paths will be proxied to: ${TARGET_API_SERVER_FQDN} (via IP: ${TARGET_API_IP})`);
    console.log(`\n  User data for mocks is stored in: ${path.join(__dirname, 'resource', 'users.json')}`);
    console.log(`--------------------------------------------------------------------------------\n`);

    // ポート443など特権ポートでsudoなしで起動しようとした場合の警告 (Linux/macOS向け)
    if (httpsPort < 1024 && process.getuid && process.getuid() !== 0) {
        console.warn(`[WARNING] Server started on a privileged port (${httpsPort}) without root privileges.`);
        console.warn(`          This might not work on all systems. If it fails, try running with 'sudo'.`);
    }
});

Copy

// --- HTTPSサーバーの起動準備 ---
let httpsOptions;
try {
    // SSL証明書と秘密鍵のパスを環境変数から取得
    if (!sslCertPath || !sslKeyPath) {
        throw new Error('SSL_CERT_PATH and SSL_KEY_PATH must be defined in your .env file.');
    }
    // SSL証明書と秘密鍵をファイルから読み込む
    httpsOptions = {
        key: fs.readFileSync(sslKeyPath),
        cert: fs.readFileSync(sslCertPath),
    };
} catch (error) {
    // 設定ファイルが読み込めない場合はエラーメッセージを表示して終了
    console.error('[ERROR] Failed to read SSL certificate/key files.');
    console.error('Please ensure that SSL_CERT_PATH and SSL_KEY_PATH in your .env file point to valid files generated by mkcert.');
    console.error('Error details:', error.message);
    process.exit(1); // エラーが発生した場合はプロセスを終了
}

// --- HTTPSサーバーの作成と起動 ---
const httpsServer = https.createServer(httpsOptions, app);

Copy

// --- プロキシ設定 ---
// プロキシのターゲットは実際のIPアドレス（hostsの影響を受けない）
const proxyOptions = {
    target: `https://${TARGET_API_IP}`, // <<<< 無限ループ回避のため、IPアドレスを直接ターゲットにする
    changeOrigin: true, // ホストヘッダーをターゲットのホストに変更 (ただし proxyReq で上書きします)
    secure: false, // HTTPSを使用する場合は、ターゲットサーバーの証明書検証を無効化（開発環境向け）
    logLevel: 'debug',  // ログレベルをデバッグに設定
    agent: new https.Agent({
        rejectUnauthorized: false, // ターゲットサーバーの証明書検証を無効化（開発環境向け）
        servername: new URL(TARGET_API_SERVER_FQDN).hostname, // SNI対応のため、サーバーネームを設定
    }),
    on: {
        proxyReq: (proxyReq, req, res) => {
            // リクエストヘッダーの 'Host' を実際のドメイン名に設定
            proxyReq.setHeader('Host', new URL(TARGET_API_SERVER_FQDN).hostname);
            console.log(`[${new Date().toISOString()}] [PROXY_REQ] Forwarding ${req.method} ${req.originalUrl} to: ${proxyOptions.target}${proxyReq.path} (Host: ${proxyReq.getHeader('Host')})`);
        },
            // ...
        },
        // ...
    }
};

Copy

sudo node server.js 

Copy

myuser@mypc uncoming-api % sudo node server.js
Password:

HTTPS Mock API Server with Proxy is running.
--------------------------------------------------------------------------------
  >> Listening on: https://localhost:443
  >> Your 'hosts' file should point 'jsonplaceholder.typicode.com' to 127.0.0.1.
  >> Application should send API requests to its original target domain
     (e.g., https://jsonplaceholder.typicode.com/some-api-path)

  >> Mocked API Endpoints (handled locally):
     - User API: /users (accessed via https://jsonplaceholder.typicode.com/users)

  >> Requests to all other paths will be proxied to: https://jsonplaceholder.typicode.com (via IP: 104.21.64.1)

  User data for mocks is stored in: /Users/myuser/uncoming-api/resource/users.json
--------------------------------------------------------------------------------

Copy

[2025-05-29T00:13:17.609Z] GET /users (handled by routes/users.js)
[2025-05-29T00:14:00.957Z] [PROXY_REQ] Forwarding GET /articles to: https://172.64.32.182/articles (Host: jsonplaceholder.typicode.com)
[2025-05-29T00:14:01.587Z] [PROXY_RES] Received from target for GET /articles - Status: 404
[2025-05-29T00:14:59.890Z] [PROXY_REQ] Forwarding GET /todos to: https://172.64.32.182/todos (Host: jsonplaceholder.typicode.com)
[2025-05-29T00:15:00.522Z] [PROXY_RES] Received from target for GET /todos - Status: 304

Copy

error [-1200] Error Domain=NSURLErrorDomain Code=-1200 "SSLエラーが起きたため、サーバへのセキュリティ保護された接続を確立できません。

Copy

mkcert -CAROOT

Copy

open "$(mkcert -CAROOT)"

Copy