// 例外ベース: 何が throw されるかわからない
function parseJSON(input: string): unknown {
  return JSON.parse(input); // SyntaxError を throw する可能性
}
 
// Result 型ベース: エラーが型シグネチャに現れる
function parseJSON(input: string): Result<unknown, SyntaxError> {
  try {
    return Ok(JSON.parse(input));
  } catch (e) {
    return Err(e instanceof SyntaxError ? e : new SyntaxError(String(e)));
  }
}

// Result 型の定義
type Result<T, E> = Ok<T> | Err<E>;
 
interface Ok<T> {
  readonly _tag: "Ok";
  readonly value: T;
}
 
interface Err<E> {
  readonly _tag: "Err";
  readonly error: E;
}
 
// コンストラクタ関数
function Ok<T>(value: T): Ok<T> {
  return { _tag: "Ok", value };
}
 
function Err<E>(error: E): Err<E> {
  return { _tag: "Err", error };
}
 
// 型ガード
function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
  return result._tag === "Ok";
}
 
function isErr<T, E>(result: Result<T, E>): result is Err<E> {
  return result._tag === "Err";
}

// map: 成功値を変換
function map<T, U, E>(
  result: Result<T, E>,
  fn: (value: T) => U
): Result<U, E> {
  return isOk(result) ? Ok(fn(result.value)) : result;
}
 
// flatMap (chain): 成功値から新しい Result を返す
function flatMap<T, U, E>(
  result: Result<T, E>,
  fn: (value: T) => Result<U, E>
): Result<U, E> {
  return isOk(result) ? fn(result.value) : result;
}
 
// unwrapOr: エラー時にデフォルト値を返す
function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {
  return isOk(result) ? result.value : defaultValue;
}
 
// 使用例
const parsed = parseAge("25");           // Result<number, ParseError>
const doubled = map(parsed, (n) => n * 2); // Result<number, ParseError>
const age = unwrapOr(doubled, 0);        // number

// mapErr: エラーを変換する
function mapErr<T, E, F>(
  result: Result<T, E>,
  fn: (error: E) => F
): Result<T, F> {
  return isErr(result) ? Err(fn(result.error)) : result;
}
 
// tap: 副作用を実行しつつ Result をそのまま返す
function tap<T, E>(
  result: Result<T, E>,
  fn: (value: T) => void
): Result<T, E> {
  if (isOk(result)) {
    fn(result.value);
  }
  return result;
}
 
// tapErr: エラー時に副作用を実行
function tapErr<T, E>(
  result: Result<T, E>,
  fn: (error: E) => void
): Result<T, E> {
  if (isErr(result)) {
    fn(result.error);
  }
  return result;
}
 
// match: パターンマッチ
function match<T, E, U>(
  result: Result<T, E>,
  handlers: {
    ok: (value: T) => U;
    err: (error: E) => U;
  }
): U {
  return isOk(result) ? handlers.ok(result.value) : handlers.err(result.error);
}
 
// fromPromise: Promise を Result に変換
async function fromPromise<T, E = Error>(
  promise: Promise<T>,
  errorFn?: (error: unknown) => E
): Promise<Result<T, E>> {
  try {
    const value = await promise;
    return Ok(value);
  } catch (error) {
    if (errorFn) {
      return Err(errorFn(error));
    }
    return Err(error as E);
  }
}
 
// fromThrowable: throw する関数を Result に変換
function fromThrowable<T, E = Error>(
  fn: () => T,
  errorFn?: (error: unknown) => E
): Result<T, E> {
  try {
    return Ok(fn());
  } catch (error) {
    if (errorFn) {
      return Err(errorFn(error));
    }
    return Err(error as E);
  }
}
 
// combine: 複数の Result をまとめる
function combine<T, E>(results: Result<T, E>[]): Result<T[], E> {
  const values: T[] = [];
  for (const result of results) {
    if (isErr(result)) {
      return result;
    }
    values.push(result.value);
  }
  return Ok(values);
}
 
// combineAll: 全エラーを収集する
function combineAll<T, E>(results: Result<T, E>[]): Result<T[], E[]> {
  const values: T[] = [];
  const errors: E[] = [];
 
  for (const result of results) {
    if (isErr(result)) {
      errors.push(result.error);
    } else {
      values.push(result.value);
    }
  }
 
  return errors.length > 0 ? Err(errors) : Ok(values);
}
 
// 使用例: combine
const validations = [
  validateName("John"),   // Result<string, ValidationError>
  validateEmail("a@b.c"), // Result<string, ValidationError>
  validateAge("25"),      // Result<number, ValidationError>
];
 
const combined = combine(validations);
// Result<(string | number)[], ValidationError>

class ResultClass<T, E> {
  private constructor(
    private readonly _tag: "Ok" | "Err",
    private readonly _value?: T,
    private readonly _error?: E
  ) {}
 
  static ok<T, E = never>(value: T): ResultClass<T, E> {
    return new ResultClass<T, E>("Ok", value);
  }
 
  static err<T = never, E = unknown>(error: E): ResultClass<T, E> {
    return new ResultClass<T, E>("Err", undefined, error);
  }
 
  isOk(): this is ResultClass<T, never> {
    return this._tag === "Ok";
  }
 
  isErr(): this is ResultClass<never, E> {
    return this._tag === "Err";
  }
 
  map<U>(fn: (value: T) => U): ResultClass<U, E> {
    if (this._tag === "Ok") {
      return ResultClass.ok(fn(this._value as T));
    }
    return ResultClass.err(this._error as E);
  }
 
  mapErr<F>(fn: (error: E) => F): ResultClass<T, F> {
    if (this._tag === "Err") {
      return ResultClass.err(fn(this._error as E));
    }
    return ResultClass.ok(this._value as T);
  }
 
  flatMap<U>(fn: (value: T) => ResultClass<U, E>): ResultClass<U, E> {
    if (this._tag === "Ok") {
      return fn(this._value as T);
    }
    return ResultClass.err(this._error as E);
  }
 
  unwrap(): T {
    if (this._tag === "Ok") {
      return this._value as T;
    }
    throw new Error(`Attempted to unwrap an Err: ${this._error}`);
  }
 
  unwrapOr(defaultValue: T): T {
    return this._tag === "Ok" ? (this._value as T) : defaultValue;
  }
 
  unwrapOrElse(fn: (error: E) => T): T {
    return this._tag === "Ok" ? (this._value as T) : fn(this._error as E);
  }
 
  match<U>(handlers: { ok: (value: T) => U; err: (error: E) => U }): U {
    if (this._tag === "Ok") {
      return handlers.ok(this._value as T);
    }
    return handlers.err(this._error as E);
  }
 
  tap(fn: (value: T) => void): ResultClass<T, E> {
    if (this._tag === "Ok") {
      fn(this._value as T);
    }
    return this;
  }
 
  tapErr(fn: (error: E) => void): ResultClass<T, E> {
    if (this._tag === "Err") {
      fn(this._error as E);
    }
    return this;
  }
 
  toPromise(): Promise<T> {
    if (this._tag === "Ok") {
      return Promise.resolve(this._value as T);
    }
    return Promise.reject(this._error);
  }
}
 
// 使用例: メソッドチェーン
const result = ResultClass.ok<string, Error>("42")
  .map((s) => parseInt(s, 10))
  .flatMap((n) =>
    n > 0
      ? ResultClass.ok(n)
      : ResultClass.err(new Error("Must be positive"))
  )
  .map((n) => n * 2)
  .tapErr((e) => console.error("Error:", e.message))
  .match({
    ok: (value) => `Success: ${value}`,
    err: (error) => `Failed: ${error.message}`,
  });

import { ok, err, Result, ResultAsync } from "neverthrow";
 
// 基本的な使い方
function divide(a: number, b: number): Result<number, Error> {
  if (b === 0) {
    return err(new Error("Division by zero"));
  }
  return ok(a / b);
}
 
// ResultAsync: 非同期版 Result
function fetchUser(id: string): ResultAsync<User, ApiError> {
  return ResultAsync.fromPromise(
    fetch(`/api/users/${id}`).then((r) => r.json()),
    (error) => new ApiError("FETCH_FAILED", String(error))
  );
}
 
// メソッドチェーンで処理を組み合わせ
const result = await fetchUser("123")
  .andThen((user) =>
    user.isActive
      ? ok(user)
      : err(new ApiError("INACTIVE_USER", "User is inactive"))
  )
  .map((user) => ({
    id: user.id,
    name: user.name,
    email: user.email,
  }))
  .mapErr((error) => ({
    code: error.code,
    message: error.message,
  }));
 
// match でパターンマッチ
result.match(
  (user) => console.log("User:", user),
  (error) => console.error("Error:", error)
);
 
// combine: 複数の Result を合成
const combinedResult = Result.combine([
  validateName(input.name),
  validateEmail(input.email),
  validateAge(input.age),
]);
// Result<[string, string, number], ValidationError>
 
// combineWithAllErrors: 全てのエラーを収集
const allErrors = Result.combineWithAllErrors([
  validateName(input.name),
  validateEmail(input.email),
  validateAge(input.age),
]);
// Result<[string, string, number], ValidationError[]>

// pipe 関数の定義
function pipe<A>(value: A): A;
function pipe<A, B>(value: A, fn1: (a: A) => B): B;
function pipe<A, B, C>(value: A, fn1: (a: A) => B, fn2: (b: B) => C): C;
function pipe<A, B, C, D>(
  value: A,
  fn1: (a: A) => B,
  fn2: (b: B) => C,
  fn3: (c: C) => D
): D;
function pipe(value: unknown, ...fns: Function[]): unknown {
  return fns.reduce((acc, fn) => fn(acc), value);
}
 
// Result 用の pipe 対応関数
const R = {
  map:
    <T, U, E>(fn: (value: T) => U) =>
    (result: Result<T, E>): Result<U, E> =>
      isOk(result) ? Ok(fn(result.value)) : result,
 
  flatMap:
    <T, U, E>(fn: (value: T) => Result<U, E>) =>
    (result: Result<T, E>): Result<U, E> =>
      isOk(result) ? fn(result.value) : result,
 
  mapErr:
    <T, E, F>(fn: (error: E) => F) =>
    (result: Result<T, E>): Result<T, F> =>
      isErr(result) ? Err(fn(result.error)) : result,
 
  unwrapOr:
    <T, E>(defaultValue: T) =>
    (result: Result<T, E>): T =>
      isOk(result) ? result.value : defaultValue,
 
  tap:
    <T, E>(fn: (value: T) => void) =>
    (result: Result<T, E>): Result<T, E> => {
      if (isOk(result)) fn(result.value);
      return result;
    },
};
 
// 使用例
const processedAge = pipe(
  parseAge("25"),
  R.map((n: number) => n + 1),
  R.flatMap((n: number) =>
    n > 0 && n < 150 ? Ok(n) : Err(new Error("Invalid age"))
  ),
  R.tap((n: number) => console.log("Valid age:", n)),
  R.unwrapOr(0)
);

// 基底エラークラス
abstract class AppError extends Error {
  abstract readonly code: string;
  abstract readonly statusCode: number;
  readonly timestamp: Date;
 
  constructor(message: string, public readonly cause?: unknown) {
    super(message);
    this.name = this.constructor.name;
    this.timestamp = new Date();
    // プロトタイプチェーンの修正
    Object.setPrototypeOf(this, new.target.prototype);
  }
 
  toJSON() {
    return {
      code: this.code,
      message: this.message,
      timestamp: this.timestamp.toISOString(),
    };
  }
}
 
// 具体的なエラークラス
class ValidationError extends AppError {
  readonly code = "VALIDATION_ERROR";
  readonly statusCode = 400;
 
  constructor(
    message: string,
    public readonly fields: Record<string, string[]>
  ) {
    super(message);
  }
}
 
class NotFoundError extends AppError {
  readonly code = "NOT_FOUND";
  readonly statusCode = 404;
 
  constructor(public readonly resource: string, public readonly id: string) {
    super(`${resource} with id ${id} not found`);
  }
}
 
class PermissionError extends AppError {
  readonly code = "PERMISSION_DENIED";
  readonly statusCode = 403;
 
  constructor(
    public readonly action: string,
    public readonly resource: string
  ) {
    super(`Permission denied: cannot ${action} on ${resource}`);
  }
}

// ─── インフラストラクチャエラー ───
class InfraError extends AppError {
  readonly code = "INFRA_ERROR";
  readonly statusCode = 500;
 
  constructor(
    message: string,
    public readonly service: string,
    cause?: unknown
  ) {
    super(message, cause);
  }
}
 
class DatabaseError extends InfraError {
  readonly code = "DATABASE_ERROR" as const;
 
  constructor(
    message: string,
    public readonly query?: string,
    cause?: unknown
  ) {
    super(message, "database", cause);
  }
}
 
class ExternalApiError extends InfraError {
  readonly code = "EXTERNAL_API_ERROR" as const;
 
  constructor(
    message: string,
    public readonly endpoint: string,
    public readonly responseStatus?: number,
    cause?: unknown
  ) {
    super(message, "external_api", cause);
  }
}
 
class CacheError extends InfraError {
  readonly code = "CACHE_ERROR" as const;
 
  constructor(
    message: string,
    public readonly key?: string,
    cause?: unknown
  ) {
    super(message, "cache", cause);
  }
}
 
// ─── ビジネスロジックエラー ───
class BusinessError extends AppError {
  abstract readonly statusCode: number;
 
  constructor(message: string, cause?: unknown) {
    super(message, cause);
  }
}
 
class ConflictError extends BusinessError {
  readonly code = "CONFLICT";
  readonly statusCode = 409;
 
  constructor(
    public readonly resource: string,
    public readonly conflictField: string,
    public readonly conflictValue: string
  ) {
    super(
      `${resource} with ${conflictField}=${conflictValue} already exists`
    );
  }
}
 
class RateLimitError extends BusinessError {
  readonly code = "RATE_LIMIT_EXCEEDED";
  readonly statusCode = 429;
 
  constructor(
    public readonly limit: number,
    public readonly windowMs: number,
    public readonly retryAfterMs: number
  ) {
    super(`Rate limit exceeded: ${limit} requests per ${windowMs}ms`);
  }
}
 
class InsufficientBalanceError extends BusinessError {
  readonly code = "INSUFFICIENT_BALANCE";
  readonly statusCode = 422;
 
  constructor(
    public readonly required: number,
    public readonly available: number,
    public readonly currency: string
  ) {
    super(
      `Insufficient balance: required ${required} ${currency}, available ${available} ${currency}`
    );
  }
}
 
class ExpiredError extends BusinessError {
  readonly code = "EXPIRED";
  readonly statusCode = 410;
 
  constructor(
    public readonly resource: string,
    public readonly expiredAt: Date
  ) {
    super(`${resource} expired at ${expiredAt.toISOString()}`);
  }
}

// すべてのエラーコードをリテラル型のユニオンで定義
type ErrorCode =
  | "VALIDATION_ERROR"
  | "NOT_FOUND"
  | "PERMISSION_DENIED"
  | "CONFLICT"
  | "RATE_LIMIT_EXCEEDED"
  | "INSUFFICIENT_BALANCE"
  | "EXPIRED"
  | "DATABASE_ERROR"
  | "EXTERNAL_API_ERROR"
  | "CACHE_ERROR";
 
// ドメインエラーの判別共用体
type DomainError =
  | ValidationError
  | NotFoundError
  | PermissionError
  | ConflictError
  | RateLimitError
  | InsufficientBalanceError
  | ExpiredError;
 
// 網羅性チェック用のヘルパー
function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`);
}
 
// エラーコードでの分岐（網羅性チェック付き）
function handleDomainError(error: DomainError): HttpResponse {
  switch (error.code) {
    case "VALIDATION_ERROR":
      return {
        status: 400,
        body: {
          code: error.code,
          message: error.message,
          fields: error.fields,
        },
      };
    case "NOT_FOUND":
      return {
        status: 404,
        body: {
          code: error.code,
          message: error.message,
          resource: error.resource,
        },
      };
    case "PERMISSION_DENIED":
      return {
        status: 403,
        body: { code: error.code, message: error.message },
      };
    case "CONFLICT":
      return {
        status: 409,
        body: { code: error.code, message: error.message },
      };
    case "RATE_LIMIT_EXCEEDED":
      return {
        status: 429,
        body: {
          code: error.code,
          message: error.message,
          retryAfter: error.retryAfterMs,
        },
      };
    case "INSUFFICIENT_BALANCE":
      return {
        status: 422,
        body: { code: error.code, message: error.message },
      };
    case "EXPIRED":
      return {
        status: 410,
        body: { code: error.code, message: error.message },
      };
    default:
      // ここに到達する場合、DomainError に新しいケースが追加されている
      return assertNever(error);
  }
}

type DomainError = ValidationError | NotFoundError | PermissionError;
 
type DomainResult<T> = Result<T, DomainError>;
 
async function getUser(id: string): Promise<DomainResult<User>> {
  const user = await db.users.findById(id);
  if (!user) {
    return Err(new NotFoundError("User", id));
  }
  return Ok(user);
}
 
async function updateUser(
  requesterId: string,
  targetId: string,
  data: unknown
): Promise<DomainResult<User>> {
  // 権限チェック
  if (requesterId !== targetId) {
    return Err(new PermissionError("update", "User"));
  }
 
  // バリデーション
  const validation = userSchema.safeParse(data);
  if (!validation.success) {
    return Err(
      new ValidationError("Invalid user data", formatZodErrors(validation.error))
    );
  }
 
  // 更新
  const result = await getUser(targetId);
  if (isErr(result)) return result;
 
  const updated = await db.users.update(targetId, validation.data);
  return Ok(updated);
}

// エラーファクトリ
class AppErrors {
  // ─── バリデーションエラー ───
  static validation(fields: Record<string, string[]>): ValidationError {
    return new ValidationError("Validation failed", fields);
  }
 
  static requiredField(field: string): ValidationError {
    return new ValidationError(`${field} is required`, {
      [field]: [`${field}は必須です`],
    });
  }
 
  static invalidFormat(field: string, expected: string): ValidationError {
    return new ValidationError(`${field} has invalid format`, {
      [field]: [`${field}は${expected}の形式である必要があります`],
    });
  }
 
  // ─── 404 エラー ───
  static notFound(resource: string, id: string): NotFoundError {
    return new NotFoundError(resource, id);
  }
 
  static userNotFound(id: string): NotFoundError {
    return new NotFoundError("User", id);
  }
 
  static orderNotFound(id: string): NotFoundError {
    return new NotFoundError("Order", id);
  }
 
  // ─── 権限エラー ───
  static forbidden(action: string, resource: string): PermissionError {
    return new PermissionError(action, resource);
  }
 
  // ─── コンフリクトエラー ───
  static duplicate(
    resource: string,
    field: string,
    value: string
  ): ConflictError {
    return new ConflictError(resource, field, value);
  }
 
  static emailAlreadyExists(email: string): ConflictError {
    return new ConflictError("User", "email", email);
  }
 
  // ─── インフラエラー ───
  static database(message: string, cause?: unknown): DatabaseError {
    return new DatabaseError(message, undefined, cause);
  }
 
  static externalApi(
    endpoint: string,
    status?: number,
    cause?: unknown
  ): ExternalApiError {
    return new ExternalApiError(
      `External API error: ${endpoint}`,
      endpoint,
      status,
      cause
    );
  }
}
 
// 使用例
function createUser(data: CreateUserInput): Promise<DomainResult<User>> {
  const existing = await db.users.findByEmail(data.email);
  if (existing) {
    return Err(AppErrors.emailAlreadyExists(data.email));
  }
  // ...
}

// エラーレスポンスの型
interface ErrorResponse {
  code: string;
  message: string;
  timestamp: string;
  requestId?: string;
  details?: Record<string, unknown>;
}
 
// エラーシリアライザ
class ErrorSerializer {
  static toResponse(error: AppError, requestId?: string): ErrorResponse {
    const base: ErrorResponse = {
      code: error.code,
      message: error.message,
      timestamp: error.timestamp.toISOString(),
      requestId,
    };
 
    // エラータイプに応じた詳細情報の追加
    if (error instanceof ValidationError) {
      base.details = { fields: error.fields };
    } else if (error instanceof NotFoundError) {
      base.details = { resource: error.resource, id: error.id };
    } else if (error instanceof RateLimitError) {
      base.details = {
        limit: error.limit,
        windowMs: error.windowMs,
        retryAfterMs: error.retryAfterMs,
      };
    }
 
    return base;
  }
 
  // ログ出力用（スタックトレース付き）
  static toLogEntry(error: AppError, context?: Record<string, unknown>) {
    return {
      level: error.statusCode >= 500 ? "error" : "warn",
      code: error.code,
      message: error.message,
      statusCode: error.statusCode,
      timestamp: error.timestamp.toISOString(),
      stack: error.stack,
      cause: error.cause,
      ...context,
    };
  }
}
 
// 構造化ログとの統合
import { Logger } from "pino";
 
function logError(logger: Logger, error: AppError, context?: Record<string, unknown>) {
  const entry = ErrorSerializer.toLogEntry(error, context);
  if (entry.level === "error") {
    logger.error(entry, error.message);
  } else {
    logger.warn(entry, error.message);
  }
}

import { z } from "zod";
 
// スキーマ定義
const UserCreateSchema = z.object({
  name: z
    .string()
    .min(1, "名前は必須です")
    .max(100, "名前は100文字以内です"),
  email: z
    .string()
    .email("有効なメールアドレスを入力してください"),
  age: z
    .number()
    .int("年齢は整数を指定してください")
    .min(0, "年齢は0以上です")
    .max(150, "年齢は150以下です"),
});
 
// 型を自動推論
type UserCreate = z.infer<typeof UserCreateSchema>;
// => { name: string; email: string; age: number }
 
// zod → Result 型への変換
function validate<T>(
  schema: z.ZodSchema<T>,
  data: unknown
): Result<T, ValidationError> {
  const result = schema.safeParse(data);
  if (result.success) {
    return Ok(result.data);
  }
 
  const fields: Record<string, string[]> = {};
  for (const issue of result.error.issues) {
    const path = issue.path.join(".");
    if (!fields[path]) fields[path] = [];
    fields[path].push(issue.message);
  }
 
  return Err(new ValidationError("Validation failed", fields));
}

// discriminatedUnion でリクエスト種別を判別
const PaymentSchema = z.discriminatedUnion("method", [
  z.object({
    method: z.literal("credit_card"),
    cardNumber: z.string().regex(/^\d{16}$/),
    expiry: z.string().regex(/^\d{2}\/\d{2}$/),
    cvv: z.string().regex(/^\d{3,4}$/),
  }),
  z.object({
    method: z.literal("bank_transfer"),
    bankCode: z.string().length(4),
    accountNumber: z.string().min(7).max(8),
  }),
  z.object({
    method: z.literal("wallet"),
    walletId: z.string().uuid(),
  }),
]);
 
type Payment = z.infer<typeof PaymentSchema>;
 
// transform でデータ整形
const DateRangeSchema = z
  .object({
    start: z.coerce.date(),
    end: z.coerce.date(),
  })
  .refine((data) => data.start < data.end, {
    message: "開始日は終了日より前でなければなりません",
    path: ["start"],
  });

// ─── カスタムバリデータの定義 ───
 
// 日本の電話番号
const JapanesePhoneNumber = z
  .string()
  .regex(
    /^0[0-9]{1,4}-?[0-9]{1,4}-?[0-9]{4}$/,
    "有効な日本の電話番号を入力してください"
  )
  .transform((val) => val.replace(/-/g, ""));
 
// 郵便番号
const JapanesePostalCode = z
  .string()
  .regex(/^\d{3}-?\d{4}$/, "有効な郵便番号を入力してください（例: 123-4567）")
  .transform((val) => val.replace(/-/, ""));
 
// パスワード強度
const StrongPassword = z
  .string()
  .min(8, "パスワードは8文字以上である必要があります")
  .max(128, "パスワードは128文字以下である必要があります")
  .refine(
    (val) => /[A-Z]/.test(val),
    "パスワードには大文字を1文字以上含める必要があります"
  )
  .refine(
    (val) => /[a-z]/.test(val),
    "パスワードには小文字を1文字以上含める必要があります"
  )
  .refine(
    (val) => /[0-9]/.test(val),
    "パスワードには数字を1文字以上含める必要があります"
  )
  .refine(
    (val) => /[!@#$%^&*(),.?":{}|<>]/.test(val),
    "パスワードには記号を1文字以上含める必要があります"
  );
 
// URL バリデータ（特定のドメインのみ許可）
function urlWithDomain(...domains: string[]) {
  return z
    .string()
    .url("有効なURLを入力してください")
    .refine(
      (val) => {
        try {
          const url = new URL(val);
          return domains.some(
            (d) => url.hostname === d || url.hostname.endsWith(`.${d}`)
          );
        } catch {
          return false;
        }
      },
      `許可されたドメイン: ${domains.join(", ")}`
    );
}
 
// ISO 8601 日付文字列
const ISODateString = z
  .string()
  .datetime({ message: "ISO 8601形式の日付文字列を入力してください" })
  .transform((val) => new Date(val));
 
// 非負整数（ページネーション用）
const PositiveInt = z.coerce
  .number()
  .int("整数を指定してください")
  .min(1, "1以上の値を指定してください");
 
const NonNegativeInt = z.coerce
  .number()
  .int("整数を指定してください")
  .min(0, "0以上の値を指定してください");
 
// ─── スキーマの組み合わせ例 ───
 
const AddressSchema = z.object({
  postalCode: JapanesePostalCode,
  prefecture: z.string().min(1, "都道府県は必須です"),
  city: z.string().min(1, "市区町村は必須です"),
  street: z.string().min(1, "番地は必須です"),
  building: z.string().optional(),
  phone: JapanesePhoneNumber.optional(),
});
 
const UserRegistrationSchema = z
  .object({
    name: z.string().min(1).max(100),
    email: z.string().email(),
    password: StrongPassword,
    passwordConfirmation: z.string(),
    address: AddressSchema,
    profileUrl: urlWithDomain("github.com", "twitter.com").optional(),
  })
  .refine((data) => data.password === data.passwordConfirmation, {
    message: "パスワードが一致しません",
    path: ["passwordConfirmation"],
  });
 
type UserRegistration = z.infer<typeof UserRegistrationSchema>;

// エラーマップによるグローバルなメッセージカスタマイズ
const japaneseErrorMap: z.ZodErrorMap = (issue, ctx) => {
  switch (issue.code) {
    case z.ZodIssueCode.invalid_type:
      if (issue.expected === "string") {
        return { message: "文字列を入力してください" };
      }
      if (issue.expected === "number") {
        return { message: "数値を入力してください" };
      }
      return { message: `${issue.expected}型の値を入力してください` };
 
    case z.ZodIssueCode.too_small:
      if (issue.type === "string") {
        return { message: `${issue.minimum}文字以上入力してください` };
      }
      if (issue.type === "number") {
        return { message: `${issue.minimum}以上の値を入力してください` };
      }
      if (issue.type === "array") {
        return { message: `${issue.minimum}個以上の要素が必要です` };
      }
      return { message: ctx.defaultError };
 
    case z.ZodIssueCode.too_big:
      if (issue.type === "string") {
        return { message: `${issue.maximum}文字以内で入力してください` };
      }
      if (issue.type === "number") {
        return { message: `${issue.maximum}以下の値を入力してください` };
      }
      return { message: ctx.defaultError };
 
    case z.ZodIssueCode.invalid_string:
      if (issue.validation === "email") {
        return { message: "有効なメールアドレスを入力してください" };
      }
      if (issue.validation === "url") {
        return { message: "有効なURLを入力してください" };
      }
      if (issue.validation === "uuid") {
        return { message: "有効なUUIDを入力してください" };
      }
      return { message: ctx.defaultError };
 
    default:
      return { message: ctx.defaultError };
  }
};
 
// グローバルに設定
z.setErrorMap(japaneseErrorMap);
 
// フォーム向けのエラーフォーマッタ
function formatZodErrorForForm(
  error: z.ZodError
): Record<string, string[]> {
  const formatted: Record<string, string[]> = {};
 
  for (const issue of error.issues) {
    const path = issue.path.length > 0 ? issue.path.join(".") : "_root";
    if (!formatted[path]) {
      formatted[path] = [];
    }
    formatted[path].push(issue.message);
  }
 
  return formatted;
}
 
// フラットなエラーメッセージリスト
function flattenZodErrors(error: z.ZodError): string[] {
  return error.issues.map((issue) => {
    const path = issue.path.join(".");
    return path ? `${path}: ${issue.message}` : issue.message;
  });
}

// Express ミドルウェアとしての zod バリデーション
import { Request, Response, NextFunction } from "express";
 
function validateBody<T>(schema: z.ZodSchema<T>) {
  return (req: Request, res: Response, next: NextFunction) => {
    const result = schema.safeParse(req.body);
    if (!result.success) {
      const errors = formatZodErrorForForm(result.error);
      return res.status(400).json({
        code: "VALIDATION_ERROR",
        message: "入力データが不正です",
        errors,
      });
    }
    req.body = result.data;
    next();
  };
}
 
function validateQuery<T>(schema: z.ZodSchema<T>) {
  return (req: Request, res: Response, next: NextFunction) => {
    const result = schema.safeParse(req.query);
    if (!result.success) {
      const errors = formatZodErrorForForm(result.error);
      return res.status(400).json({
        code: "VALIDATION_ERROR",
        message: "クエリパラメータが不正です",
        errors,
      });
    }
    // 型安全なクエリパラメータ
    (req as any).validatedQuery = result.data;
    next();
  };
}
 
function validateParams<T>(schema: z.ZodSchema<T>) {
  return (req: Request, res: Response, next: NextFunction) => {
    const result = schema.safeParse(req.params);
    if (!result.success) {
      const errors = formatZodErrorForForm(result.error);
      return res.status(400).json({
        code: "VALIDATION_ERROR",
        message: "パスパラメータが不正です",
        errors,
      });
    }
    (req as any).validatedParams = result.data;
    next();
  };
}
 
// 使用例
const PaginationSchema = z.object({
  page: z.coerce.number().int().min(1).default(1),
  limit: z.coerce.number().int().min(1).max(100).default(20),
  sort: z.enum(["created_at", "updated_at", "name"]).default("created_at"),
  order: z.enum(["asc", "desc"]).default("desc"),
});
 
const UserIdSchema = z.object({
  id: z.string().uuid("有効なユーザーIDを指定してください"),
});
 
app.get(
  "/api/users",
  validateQuery(PaginationSchema),
  async (req, res) => {
    const query = (req as any).validatedQuery;
    // query は { page: number; limit: number; sort: string; order: string } 型
    const users = await userService.list(query);
    res.json(users);
  }
);
 
app.get(
  "/api/users/:id",
  validateParams(UserIdSchema),
  async (req, res) => {
    const { id } = (req as any).validatedParams;
    const result = await userService.getById(id);
    if (isErr(result)) {
      return res.status(result.error.statusCode).json(result.error.toJSON());
    }
    res.json(result.value);
  }
);

// 環境変数スキーマ
const EnvSchema = z.object({
  // 必須
  NODE_ENV: z.enum(["development", "staging", "production"]),
  PORT: z.coerce.number().int().min(1).max(65535).default(3000),
  DATABASE_URL: z.string().url(),
 
  // Redis
  REDIS_HOST: z.string().default("localhost"),
  REDIS_PORT: z.coerce.number().int().default(6379),
  REDIS_PASSWORD: z.string().optional(),
 
  // JWT
  JWT_SECRET: z.string().min(32, "JWT_SECRETは32文字以上必要です"),
  JWT_EXPIRES_IN: z
    .string()
    .regex(/^\d+[smhd]$/, "例: 1h, 30m, 7d")
    .default("1h"),
 
  // 外部API
  STRIPE_SECRET_KEY: z.string().startsWith("sk_"),
  STRIPE_WEBHOOK_SECRET: z.string().startsWith("whsec_"),
 
  // S3
  AWS_ACCESS_KEY_ID: z.string().min(1),
  AWS_SECRET_ACCESS_KEY: z.string().min(1),
  S3_BUCKET_NAME: z.string().min(1),
  S3_REGION: z.string().default("ap-northeast-1"),
 
  // メール
  SMTP_HOST: z.string().optional(),
  SMTP_PORT: z.coerce.number().int().optional(),
  SMTP_USER: z.string().optional(),
  SMTP_PASSWORD: z.string().optional(),
  FROM_EMAIL: z.string().email().optional(),
 
  // ロギング
  LOG_LEVEL: z
    .enum(["trace", "debug", "info", "warn", "error", "fatal"])
    .default("info"),
});
 
type Env = z.infer<typeof EnvSchema>;
 
// 起動時にバリデーション
function loadEnv(): Env {
  const result = EnvSchema.safeParse(process.env);
 
  if (!result.success) {
    const errors = result.error.issues.map(
      (issue) => `  ${issue.path.join(".")}: ${issue.message}`
    );
    console.error("❌ 環境変数の設定エラー:");
    console.error(errors.join("\n"));
    process.exit(1);
  }
 
  return result.data;
}
 
// シングルトンとしてエクスポート
export const env = loadEnv();

// AsyncResult 型の定義
type AsyncResult<T, E> = Promise<Result<T, E>>;
 
// 非同期 Result ユーティリティ
const AsyncR = {
  // Promise<Result> の map
  map: async <T, U, E>(
    asyncResult: AsyncResult<T, E>,
    fn: (value: T) => U
  ): AsyncResult<U, E> => {
    const result = await asyncResult;
    return isOk(result) ? Ok(fn(result.value)) : result;
  },
 
  // Promise<Result> の flatMap
  flatMap: async <T, U, E>(
    asyncResult: AsyncResult<T, E>,
    fn: (value: T) => AsyncResult<U, E>
  ): AsyncResult<U, E> => {
    const result = await asyncResult;
    return isOk(result) ? fn(result.value) : result;
  },
 
  // Promise を Result に変換
  fromPromise: async <T, E>(
    promise: Promise<T>,
    errorMapper: (error: unknown) => E
  ): AsyncResult<T, E> => {
    try {
      const value = await promise;
      return Ok(value);
    } catch (error) {
      return Err(errorMapper(error));
    }
  },
 
  // 並列実行
  all: async <T, E>(
    results: AsyncResult<T, E>[]
  ): AsyncResult<T[], E> => {
    const resolved = await Promise.all(results);
    return combine(resolved);
  },
 
  // settled: すべての結果を返す（エラーも含む）
  allSettled: async <T, E>(
    results: AsyncResult<T, E>[]
  ): Promise<Result<T, E>[]> => {
    return Promise.all(results);
  },
};
 
// 使用例: 非同期処理のチェーン
async function processOrder(
  orderId: string,
  userId: string
): AsyncResult<OrderConfirmation, DomainError> {
  // 1. ユーザー取得
  const userResult = await getUser(userId);
  if (isErr(userResult)) return userResult;
  const user = userResult.value;
 
  // 2. 注文取得
  const orderResult = await getOrder(orderId);
  if (isErr(orderResult)) return orderResult;
  const order = orderResult.value;
 
  // 3. 権限チェック
  if (order.userId !== user.id) {
    return Err(new PermissionError("process", "Order"));
  }
 
  // 4. 支払い処理
  const paymentResult = await processPayment(order, user);
  if (isErr(paymentResult)) return paymentResult;
 
  // 5. 確認メール送信
  const emailResult = await sendConfirmation(user.email, order);
  if (isErr(emailResult)) {
    // メール送信失敗は致命的ではないのでログのみ
    console.warn("Failed to send confirmation email:", emailResult.error);
  }
 
  return Ok({
    orderId: order.id,
    status: "confirmed",
    paymentId: paymentResult.value.id,
    processedAt: new Date(),
  });
}

// ResultBuilder: do記法風のチェーン
class ResultBuilder<E> {
  private steps: Map<string, unknown> = new Map();
 
  async bind<K extends string, T>(
    key: K,
    fn: () => AsyncResult<T, E>
  ): Promise<
    | { success: true; value: T }
    | { success: false; error: Err<E> }
  > {
    const result = await fn();
    if (isErr(result)) {
      return { success: false, error: result };
    }
    this.steps.set(key, result.value);
    return { success: true, value: result.value };
  }
 
  get<K extends string>(key: K): unknown {
    return this.steps.get(key);
  }
}
 
// Do記法ヘルパー
async function Do<T, E>(
  fn: (ctx: {
    bind: <V>(result: AsyncResult<V, E>) => Promise<V>;
  }) => AsyncResult<T, E>
): AsyncResult<T, E> {
  try {
    const ctx = {
      bind: async <V>(result: AsyncResult<V, E>): Promise<V> => {
        const r = await result;
        if (isErr(r)) {
          throw { _tag: "ResultError" as const, error: r };
        }
        return r.value;
      },
    };
    return await fn(ctx);
  } catch (e: unknown) {
    if (
      typeof e === "object" &&
      e !== null &&
      "_tag" in e &&
      (e as any)._tag === "ResultError"
    ) {
      return (e as any).error;
    }
    throw e;
  }
}
 
// 使用例: Do記法で平坦化
async function processOrder(
  orderId: string,
  userId: string
): AsyncResult<OrderConfirmation, DomainError> {
  return Do(async ({ bind }) => {
    const user = await bind(getUser(userId));
    const order = await bind(getOrder(orderId));
 
    if (order.userId !== user.id) {
      return Err(new PermissionError("process", "Order"));
    }
 
    const payment = await bind(processPayment(order, user));
 
    // メール送信は失敗しても続行
    await sendConfirmation(user.email, order).catch(() => {});
 
    return Ok({
      orderId: order.id,
      status: "confirmed" as const,
      paymentId: payment.id,
      processedAt: new Date(),
    });
  });
}

interface RetryOptions {
  maxRetries: number;
  initialDelayMs: number;
  maxDelayMs: number;
  backoffMultiplier: number;
  retryableErrors?: (error: unknown) => boolean;
}
 
const DEFAULT_RETRY_OPTIONS: RetryOptions = {
  maxRetries: 3,
  initialDelayMs: 100,
  maxDelayMs: 5000,
  backoffMultiplier: 2,
};
 
async function withRetry<T, E>(
  fn: () => AsyncResult<T, E>,
  options: Partial<RetryOptions> = {}
): AsyncResult<T, E> {
  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
  let lastResult: Result<T, E> | undefined;
  let delay = opts.initialDelayMs;
 
  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
    lastResult = await fn();
 
    if (isOk(lastResult)) {
      return lastResult;
    }
 
    // リトライ可能なエラーかチェック
    if (
      opts.retryableErrors &&
      !opts.retryableErrors(lastResult.error)
    ) {
      return lastResult;
    }
 
    // 最後の試行ではリトライしない
    if (attempt < opts.maxRetries) {
      // ジッター付きの指数バックオフ
      const jitter = Math.random() * delay * 0.1;
      await new Promise((resolve) =>
        setTimeout(resolve, Math.min(delay + jitter, opts.maxDelayMs))
      );
      delay *= opts.backoffMultiplier;
    }
  }
 
  return lastResult!;
}
 
// サーキットブレーカーパターン
class CircuitBreaker<T, E> {
  private failures = 0;
  private lastFailure: Date | null = null;
  private state: "closed" | "open" | "half-open" = "closed";
 
  constructor(
    private readonly fn: () => AsyncResult<T, E>,
    private readonly options: {
      failureThreshold: number;
      resetTimeoutMs: number;
      fallback?: () => AsyncResult<T, E>;
    }
  ) {}
 
  async execute(): AsyncResult<T, E> {
    if (this.state === "open") {
      // リセットタイムアウトが経過したかチェック
      const now = new Date();
      if (
        this.lastFailure &&
        now.getTime() - this.lastFailure.getTime() > this.options.resetTimeoutMs
      ) {
        this.state = "half-open";
      } else {
        // フォールバックを返すか、エラーを返す
        if (this.options.fallback) {
          return this.options.fallback();
        }
        return Err({
          code: "CIRCUIT_OPEN",
          message: "Circuit breaker is open",
        } as any);
      }
    }
 
    const result = await this.fn();
 
    if (isErr(result)) {
      this.failures++;
      this.lastFailure = new Date();
 
      if (this.failures >= this.options.failureThreshold) {
        this.state = "open";
      }
    } else {
      this.failures = 0;
      this.state = "closed";
    }
 
    return result;
  }
}
 
// 使用例
const fetchUserWithRetry = (id: string) =>
  withRetry(() => fetchUser(id), {
    maxRetries: 3,
    retryableErrors: (error) => {
      // ネットワークエラーのみリトライ
      return error instanceof ExternalApiError;
    },
  });
 
const userCircuitBreaker = new CircuitBreaker(
  () => fetchUser("123"),
  {
    failureThreshold: 5,
    resetTimeoutMs: 30000,
    fallback: () => Promise.resolve(Ok(getCachedUser("123"))),
  }
);

class TimeoutError extends AppError {
  readonly code = "TIMEOUT";
  readonly statusCode = 408;
 
  constructor(
    public readonly operationName: string,
    public readonly timeoutMs: number
  ) {
    super(`Operation "${operationName}" timed out after ${timeoutMs}ms`);
  }
}
 
async function withTimeout<T, E>(
  fn: () => AsyncResult<T, E>,
  timeoutMs: number,
  operationName: string = "unknown"
): AsyncResult<T, E | TimeoutError> {
  const timeoutPromise = new Promise<Result<never, TimeoutError>>((resolve) =>
    setTimeout(
      () => resolve(Err(new TimeoutError(operationName, timeoutMs))),
      timeoutMs
    )
  );
 
  return Promise.race([fn(), timeoutPromise]);
}
 
// AbortController を使ったキャンセル可能な処理
async function fetchWithAbort<T>(
  url: string,
  options: { timeoutMs: number }
): AsyncResult<T, ExternalApiError | TimeoutError> {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs);
 
  try {
    const response = await fetch(url, { signal: controller.signal });
    clearTimeout(timeoutId);
 
    if (!response.ok) {
      return Err(
        new ExternalApiError(
          `HTTP ${response.status}: ${response.statusText}`,
          url,
          response.status
        )
      );
    }
 
    const data = await response.json();
    return Ok(data as T);
  } catch (error) {
    clearTimeout(timeoutId);
    if (error instanceof DOMException && error.name === "AbortError") {
      return Err(new TimeoutError("fetch", options.timeoutMs));
    }
    return Err(new ExternalApiError(String(error), url));
  }
}