const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/user/tokens?limit=20', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/user/tokens', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'GitHub Actions Deploy',
    scopeType: 'workspace',
    scopeWorkspaceId: 'workspace_id',
    expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000,
  }),
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/user/tokens/current', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/user/tokens/current', {
  method: 'DELETE',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/workspaces', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects?workspaceId=workspace_id', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const response = await fetch('https://hanamii.jp/api/v1/projects', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    workspaceId: 'workspace_id',
    name: 'my-api-test-app',
    source: {
      type: 'git',
      repoFullName: 'owner/repo',
      ref: 'main',
    },

    // 任意。不要な場合は省略できます
    envs: [
      { key: 'API_URL', value: 'https://example.com', type: 'plain' },
    ],

    // 任意。不要な場合は省略できます
    healthCheck: { enabled: true, path: '/health', port: null },
  }),
});

if (!response.ok) throw new Error(await response.text());
const result = await response.json(); // サーバー内で使用し、応答全体をログへ出さない

import { readFile } from 'node:fs/promises';

const baseUrl = 'https://hanamii.jp';
const token = process.env.HANAMII_TOKEN!;

async function uploadZipAndCreateCheckId(filePath: string) {
  const fileName = filePath.split('/').pop() ?? 'frontend.zip';

  // 1. デプロイ用ZIPの一時アップロード用URLとuploadIdを発行
  const uploadResponse = await fetch(`${baseUrl}/api/v1/uploads`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      workspaceId: 'workspace_id',
      fileName,
      contentType: 'application/zip',
    }),
  });

  if (!uploadResponse.ok) throw new Error(await uploadResponse.text());
  const { upload } = await uploadResponse.json();

  // 2. ZIP本体は hanamii API ではなく、発行された uploadUrl へ直接PUT
  const zipBuffer = await readFile(filePath);
  const putResponse = await fetch(upload.uploadUrl, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/zip' },
    body: zipBuffer,
  });

  if (!putResponse.ok) throw new Error(await putResponse.text());

  // 3. アップロード済みZIPを検証して checkId を取得
  const checkResponse = await fetch(`${baseUrl}/api/v1/uploads/${upload.id}/check`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({}),
  });

  if (!checkResponse.ok) throw new Error(await checkResponse.text());
  const check = await checkResponse.json();
  return check.result.checkId as string;
}

const checkId = await uploadZipAndCreateCheckId('./frontend.zip');

// 4. checkId を指定してプロジェクトを作成
const response = await fetch(`${baseUrl}/api/v1/projects`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    workspaceId: 'workspace_id',
    name: 'my-api-test-app',
    source: { type: 'zip', checkId },

    // 任意。不要な場合は省略できます
    envs: [
      { key: 'API_URL', value: 'https://example.com', type: 'plain' },
    ],

    // 任意。不要な場合は省略できます
    healthCheck: { enabled: true, path: "/health", port: null },
  }),
});

if (!response.ok) throw new Error(await response.text());
const result = await response.json(); // サーバー内で使用し、応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/deploy', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    source: {
      type: 'git',
    },
  }),
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/uploads', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    source: {
      type: 'git',
    },
  }),
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id', {
  method: 'DELETE',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/logs?limit=100&since=-15m', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/env', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/env', {
  method: 'PATCH',
  headers: {
    Authorization: `Bearer ${token}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    envs: [
      { key: 'API_URL', value: 'https://example.com', type: 'plain' },
      { key: 'API_KEY', value: 'secret-value', type: 'secret' },
    ],
  }),
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/health-check', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/health-check', {
  method: 'PUT',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/restart', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database', {
  method: 'DELETE',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/auth-tokens', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/auth-tokens', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/auth-tokens/$DB_TOKEN_ID', {
  method: 'DELETE',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/tables', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/tables/users/rows?limit=50&offset=0', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/exports', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/exports/$EXPORT_JOB_ID', {
  method: 'GET',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/exports/$EXPORT_JOB_ID/download', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/import-session', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/:id/database/import-session', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

const token = process.env.HANAMII_TOKEN;
if (!token) throw new Error('HANAMII_TOKEN is required');
const response = await fetch('https://hanamii.jp/api/v1/projects/project_id/database/import-start', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

if (!response.ok) {
  throw new Error('Request failed');
}

const data = await response.json();
// dataはサーバー内の必要な処理に渡す。応答全体をログへ出さない

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets', {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
name: 'assets',
visibility: 'private',
    }),
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets/bucket_id', {
    method: 'DELETE',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  if (response.status === 204) return;
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets/bucket_id/access-keys', {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint(
  storeKey: (value: { keyId: string; key: string; permission: string }) => Promise<void>,
) {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets/bucket_id/access-keys', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${token}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
permission: 'read_write',
    }),
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const data = await response.json();
  // storeKeyはサーバー内の秘密情報保管処理。consoleやブラウザへの返却には使わない
  await storeKey({ keyId: data.keyId, key: data.key, permission: data.permission });
  return { keyId: data.keyId, permission: data.permission, createdAt: data.createdAt };
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets/bucket_id/access-keys/storage_key_id', {
    method: 'DELETE',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  if (response.status === 204) return;
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets/bucket_id/files', {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/buckets/bucket_id/files/file_id/view-url', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}

// サーバー内から呼ぶ関数。公開ルートから使う場合は、先に利用者と対象の権限を確認する
export async function callEndpoint() {
  const token = process.env.HANAMII_TOKEN;
  if (!token) throw new Error('HANAMII_TOKEN is required');
  const response = await fetch('https://hanamii.jp/api/v1/workspaces/workspace_id/storage/usage', {
    method: 'GET',
    headers: {
      Authorization: `Bearer ${token}`,
    },
    cache: 'no-store',
  });
  if (!response.ok) throw new Error(`Request failed: ${response.status}`);
  const data = await response.json();
  // 閲覧URLを含む応答はログへ出さず、認可済みの表示・処理にだけ使う
  return data;
}