Errors, Panics & Wrapping

package config

import (
    "errors"
    "fmt"
    "os"
)

var ErrMissing = errors.New("missing config")

func Load(path string) ([]byte, error) {
    b, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("load %s: %w", path, err)
    }
    if len(b) == 0 {
        return nil, ErrMissing
    }
    return b, nil
}

func Use(path string) error {
    _, err := Load(path)
    if errors.Is(err, ErrMissing) {
        return fmt.Errorf("config required: %w", err)
    }
    var pe *os.PathError
    if errors.As(err, &pe) {
        return fmt.Errorf("path %s: %w", pe.Path, err)
    }
    return err
}

export class MissingConfigError extends Error {}

export async function load(path: string): Promise<Uint8Array> {
  let buf: Uint8Array;
  try {
    buf = await Deno.readFile(path);
  } catch (err) {
    throw new Error(`load ${path}`, { cause: err });
  }
  if (buf.byteLength === 0) throw new MissingConfigError("missing");
  return buf;
}

export async function use(path: string): Promise<Uint8Array> {
  try {
    return await load(path);
  } catch (err) {
    if (err instanceof MissingConfigError) return new TextEncoder().encode("defaults");
    throw err;
  }
}

class MissingConfigError(Exception):
    pass

def load(path: str) -> bytes:
    try:
        with open(path, "rb") as handle:
            data = handle.read()
    except OSError as exc:
        raise RuntimeError(f"load {path}") from exc
    if not data:
        raise MissingConfigError("missing")
    return data

package httpx

import (
    "log"
    "net/http"
)

func RecoverMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if v := recover(); v != nil {
                log.Printf("panic: %v", v)
                http.Error(w, "internal server error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

function recoverMiddleware(err: unknown, _req: unknown, res: { status(code: number): { send(body: string): void } }) {
  console.error(err);
  res.status(500).send("internal server error"); // log err, never echo it to clients
}

async def all_exc(_request: object, exc: Exception) -> dict[str, str]:
    return {"error": str(exc)}