@pori15/logixlysia 0.0.1

package/src/Error/errors.ts

@@ -0,0 +1,258 @@
+// src/libs/elysia-http-problem-json/errors.ts
+
+export interface ProblemDocument {
+  type: string;
+  title: string;
+  status?: number;
+  detail?: string;
+  instance?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * RFC 9457 Problem Details Error Base Class
+ *
+ * Core members as per RFC 9457:
+ * - type: A URI reference [RFC3986] that identifies the problem type.
+ *         Defaults to "about:blank" when omitted.
+ * - title: A short, human-readable summary of the problem type.
+ * - status: The HTTP status code ([RFC7231], Section 6).
+ * - detail: A human-readable explanation specific to this occurrence of the problem.
+ * - instance: A URI reference that identifies the specific occurrence of the problem.
+ *
+ * Extension members: Additional properties can be added to provide more context.
+ * These are serialized as-is in the JSON response.
+ */
+/**
+ * RFC 9457 Error Base Class
+ * * 修改思路：直接使用 public readonly 属性，拒绝嵌套，拒绝 Getter。
+ */
+export class ProblemError extends Error {
+  // 1. 直接声明公开属性
+  public readonly status: number;
+  public readonly title: string;
+  public readonly type: string;
+  public readonly detail?: string;
+  public readonly instance?: string;
+  public readonly extensions?: Record<string, unknown>;
+
+  constructor(
+    type = "about:blank",
+    title: string,
+    status: number,
+    detail?: string,
+    instance?: string,
+    extensions: Record<string, unknown> = {}
+  ) {
+    super(detail || title);
+    Object.setPrototypeOf(this, ProblemError.prototype);
+
+    // 2. 直接赋值给 this
+    this.status = status;
+    this.title = title;
+    this.type = type;
+    this.detail = detail;
+    this.instance = instance;
+    this.extensions = extensions;
+  }
+
+  // 3. toJSON 的时候动态组装一下即可
+  toJSON(): ProblemDocument {
+    return {
+      type: this.type,
+      title: this.title,
+      status: this.status,
+      ...(this.detail ? { detail: this.detail } : {}),
+      ...(this.instance ? { instance: this.instance } : {}),
+      // 把扩展字段展开 (extensions)
+      ...this.extensions,
+    };
+  }
+}
+
+// --- 40X Errors ---
+class BadRequest extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/400",
+      "Bad Request",
+      400,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class Unauthorized extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/401",
+      "Unauthorized",
+      401,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class Forbidden extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/403",
+      "Forbidden",
+      403,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class NotFound extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/404",
+      "Not Found",
+      404,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class Conflict extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/409",
+      "Conflict",
+      409,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class PaymentRequired extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/402",
+      "Payment Required",
+      402,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class MethodNotAllowed extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/405",
+      "Method Not Allowed",
+      405,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class NotAcceptable extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/406",
+      "Not Acceptable",
+      406,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+// 50X Errors
+class InternalServerError extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/500",
+      "Internal Server Error",
+      500,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class NotImplemented extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/501",
+      "Not Implemented",
+      501,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class BadGateway extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/502",
+      "Bad Gateway",
+      502,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class ServiceUnavailable extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/503",
+      "Service Unavailable",
+      503,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+class GatewayTimeout extends ProblemError {
+  constructor(detail?: string, extensions?: Record<string, any>) {
+    super(
+      "https://httpstatuses.com/504",
+      "Gateway Timeout",
+      504,
+      detail,
+      undefined,
+      extensions
+    );
+  }
+}
+
+export const HttpError = {
+  BadRequest,
+  Unauthorized,
+  PaymentRequired,
+  Forbidden,
+  NotFound,
+  MethodNotAllowed,
+  NotAcceptable,
+  Conflict,
+  InternalServerError,
+  NotImplemented,
+  BadGateway,
+  ServiceUnavailable,
+  GatewayTimeout,
+} as const;

package/src/Error/type.ts

@@ -0,0 +1,51 @@
+// src/libs/elysia-http-problem-json/types.ts
+
+import { HttpError, ProblemError } from "./errors";
+
+export type Code =
+  | number
+  | "PROBLEM_ERROR"
+  | "UNKNOWN"
+  | "VALIDATION"
+  | "NOT_FOUND"
+  | "PARSE"
+  | "INTERNAL_SERVER_ERROR"
+  | "INVALID_COOKIE_SIGNATURE"
+  | "INVALID_FILE_TYPE";
+
+// 获取 HttpError 对象的所有 Key (例如 "BadRequest" | "NotFound")
+export type HttpErrorType = keyof typeof HttpError;
+
+export interface ErrorContext {
+  request: Request;
+  path: string;
+  code: string | number;
+  error: unknown;
+}
+
+export interface HttpProblemJsonOptions {
+  /**
+   * 自定义错误类型的 Base URL
+   * @example "https://api.mysite.com/errors"
+   */
+  typeBaseUrl?: string;
+
+  /**
+   * 🪝 Transform Hook
+   * 将未知错误转换为 HttpError。
+   * 返回 undefined/null 表示不处理（走默认逻辑）。
+   */
+  transform?: (
+    error: unknown,
+    context: ErrorContext
+  ) => ProblemError | undefined | null; // 这里直接返回 ProblemError 实例更好，或者用 HttpErrorType 也可以，看你喜好
+
+  /**
+   * 📢 Listen Hook
+   * 在响应发送前触发（用于日志）。
+   */
+  onBeforeRespond?: (
+    problem: ProblemError,
+    context: ErrorContext
+  ) => void | Promise<void>;
+}

package/src/extensions/banner.ts

@@ -0,0 +1,26 @@
+import elysiaPkg from 'elysia/package.json'
+
+const centerText = (text: string, width: number): string => {
+  if (text.length >= width) {
+    return text.slice(0, width)
+  }
+
+  const left = Math.floor((width - text.length) / 2)
+  const right = width - text.length - left
+  return `${' '.repeat(left)}${text}${' '.repeat(right)}`
+}
+
+export const renderBanner = (message: string): string => {
+  const versionLine = `Elysia v${elysiaPkg.version}`
+  const contentWidth = Math.max(message.length, versionLine.length)
+  const innerWidth = contentWidth + 4 // 2 spaces padding on both sides
+
+  const top = `┌${'─'.repeat(innerWidth)}┐`
+  const bot = `└${'─'.repeat(innerWidth)}┘`
+  const empty = `│${' '.repeat(innerWidth)}│`
+
+  const versionRow = `│${centerText(versionLine, innerWidth)}│`
+  const messageRow = `│  ${message}${' '.repeat(Math.max(0, innerWidth - message.length - 4))}  │`
+
+  return [top, empty, versionRow, empty, messageRow, empty, bot].join('\n')
+}

package/src/extensions/index.ts

@@ -0,0 +1,28 @@
+import type { Options } from '../interfaces'
+import { renderBanner } from './banner'
+
+export const startServer = (
+  server: { port?: number; hostname?: string; protocol?: string | null },
+  options: Options
+): void => {
+  const showStartupMessage = options.config?.showStartupMessage ?? true
+  if (!showStartupMessage) {
+    return
+  }
+
+  const { port, hostname, protocol } = server
+  if (port === undefined || !hostname || !protocol) {
+    return
+  }
+
+  const url = `${protocol}://${hostname}:${port}`
+  const message = `🦊 Elysia is running at ${url}`
+
+  const format = options.config?.startupMessageFormat ?? 'banner'
+  if (format === 'simple') {
+    console.log(message)
+    return
+  }
+
+  console.log(renderBanner(message))
+}

package/src/helpers/status.ts

@@ -0,0 +1,58 @@
+import { StatusMap } from 'elysia'
+
+const DIGITS_ONLY = /^\d+$/
+const DELIMITERS = /[_-]+/g
+const CAMEL_BOUNDARY_1 = /([a-z0-9])([A-Z])/g
+const CAMEL_BOUNDARY_2 = /([A-Z])([A-Z][a-z])/g
+const APOSTROPHES = /['’]/g
+const NON_ALPHANUMERIC = /[^a-z0-9\s]+/g
+const WHITESPACE = /\s+/g
+
+const normalizeStatusName = (value: string): string => {
+  // Handles common variants:
+  // - case differences: "not found" vs "Not Found"
+  // - spacing/punctuation: "Not-Found", "not_found"
+  // - camelCase/PascalCase: "InternalServerError"
+  const trimmed = value.trim()
+  if (!trimmed) {
+    return ''
+  }
+
+  return trimmed
+    .replace(DELIMITERS, ' ')
+    .replace(CAMEL_BOUNDARY_1, '$1 $2')
+    .replace(CAMEL_BOUNDARY_2, '$1 $2')
+    .replace(APOSTROPHES, '')
+    .toLowerCase()
+    .replace(NON_ALPHANUMERIC, ' ')
+    .replace(WHITESPACE, ' ')
+    .trim()
+}
+
+const STATUS_BY_NORMALIZED_NAME = (() => {
+  const map = new Map<string, number>()
+
+  for (const [name, code] of Object.entries(StatusMap)) {
+    map.set(normalizeStatusName(name), code)
+  }
+
+  return map
+})()
+
+export const getStatusCode = (value: unknown): number => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value
+  }
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (DIGITS_ONLY.test(trimmed)) {
+      return Number(trimmed)
+    }
+
+    const known = STATUS_BY_NORMALIZED_NAME.get(normalizeStatusName(trimmed))
+    return known ?? 500
+  }
+
+  return 500
+}

package/src/index.ts

@@ -0,0 +1,141 @@
+import { Elysia, type SingletonBase } from 'elysia'
+import { startServer } from './extensions'
+import type { LogixlysiaStore, Options } from './interfaces'
+import { createLogger } from './logger'
+import { normalizeToProblem } from './utils/handle-error'
+
+export type Logixlysia = Elysia<
+  'Logixlysia',
+  SingletonBase & { store: LogixlysiaStore }
+>
+
+export const logixlysia = (options: Options = {}): Logixlysia => {
+  const didCustomLog = new WeakSet<Request>()
+  const baseLogger = createLogger(options)
+  const logger = {
+    ...baseLogger,
+    debug: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.debug(request, message, context)
+    },
+    info: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.info(request, message, context)
+    },
+    warn: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.warn(request, message, context)
+    },
+    error: (
+      request: Request,
+      message: string,
+      context?: Record<string, unknown>
+    ) => {
+      didCustomLog.add(request)
+      baseLogger.error(request, message, context)
+    }
+  }
+
+  const app = new Elysia({
+    name: 'Logixlysia',
+    detail: {
+      description:
+        'Logixlysia is a plugin for Elysia that provides a logger and pino logger.',
+      tags: ['logging', 'pino']
+    }
+  })
+
+  return (
+    app
+      .state('logger', logger)
+      .state('pino', logger.pino)
+      .state('beforeTime', BigInt(0))
+      .onStart(({ server }) => {
+        if (server) {
+          startServer(server, options)
+        }
+      })
+      .onRequest(({ store }) => {
+        store.beforeTime = process.hrtime.bigint()
+      })
+      .onAfterHandle(({ request, set, store }) => {
+        if (didCustomLog.has(request)) {
+          return
+        }
+
+        const status = typeof set.status === 'number' ? set.status : 200
+        let level: 'INFO' | 'WARNING' | 'ERROR' = 'INFO'
+        if (status >= 500) {
+          level = 'ERROR'
+        } else if (status >= 400) {
+          level = 'WARNING'
+        }
+
+        logger.log(level, request, { status }, store)
+      })
+      .onError(({ request, error,code, path,store,set }) => {
+        // logger.handleHttpError(request, error, store)
+
+        // ==========================================
+  // Phase 1: Transform (转换)
+  // ==========================================
+  let result = options.transform ? options.transform(error, { request, code }) : error
+
+  // ==========================================
+  // Phase 2: Normalization (规范化)
+  // ==========================================
+  // 统一转为 ProblemError 实例
+  const problem = normalizeToProblem(result, code, path, options.config?.error?.problemJson?.typeBaseUrl)
+
+  // ==========================================
+  // Phase 3: Logging (日志)
+  // ==========================================
+  // 调用上面改造后的函数，它现在只负责记录，不负责逻辑判断
+  logger.handleHttpError(request, problem, store, options)
+
+  // ==========================================
+  // Phase 4: Response (响应)
+  // ==========================================
+  // 统一设置 Header 和 Status
+  set.status = problem.status
+  set.headers['content-type'] = 'application/problem+json'
+
+  // 返回符合 RFC 标准的 JSON
+  return problem.toJSON()
+
+
+      })
+      // Ensure plugin lifecycle hooks (onRequest/onAfterHandle/onError) apply to the parent app.
+      .as('scoped') as unknown as Logixlysia
+  )
+}
+
+export type {
+  Logger,
+  LogixlysiaContext,
+  LogixlysiaStore,
+  LogLevel,
+  Options,
+  Pino,
+  StoreData,
+  Transport,
+} from './interfaces'
+
+export { HttpError } from './interfaces'
+export { toProblemJson, formatProblemJsonLog } from './utils/handle-error'
+export type { ProblemJson } from './utils/handle-error'
+
+export default logixlysia
+

package/src/interfaces.ts

@@ -0,0 +1,136 @@
+import type {
+  Logger as PinoLogger,
+  LoggerOptions as PinoLoggerOptions
+} from 'pino'
+import { ProblemError } from './Error/errors'
+import { Code } from './Error/type'
+
+export type Pino = PinoLogger<never, boolean>
+export type Request = Request
+
+export type LogLevel = 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR'
+
+export interface StoreData {
+  beforeTime: bigint
+}
+
+export interface LogixlysiaStore {
+  logger: Logger
+  pino: Pino
+  beforeTime?: bigint
+  [key: string]: unknown
+}
+
+export interface Transport {
+  log: (
+    level: LogLevel,
+    message: string,
+    meta?: Record<string, unknown>
+  ) => void | Promise<void>
+}
+
+export interface LogRotationConfig {
+  /**
+   * Max log file size before rotation, e.g. '10m', '5k', or a byte count.
+   */
+  maxSize?: string | number
+  /**
+   * Keep at most N files or keep files for a duration like '7d'.
+   */
+  maxFiles?: number | string
+  /**
+   * Rotate at a fixed interval, e.g. '1d', '12h'.
+   */
+  interval?: string
+  compress?: boolean
+  compression?: 'gzip'
+}
+
+
+
+
+
+export interface Options {
+  config?: {
+    showStartupMessage?: boolean
+    startupMessageFormat?: 'simple' | 'banner'
+    useColors?: boolean
+    ip?: boolean
+    timestamp?: {
+      translateTime?: string
+    }
+    customLogFormat?: string
+
+    // Outputs
+    transports?: Transport[]
+    useTransportsOnly?: boolean
+    disableInternalLogger?: boolean
+    disableFileLogging?: boolean
+    logFilePath?: string
+    logRotation?: LogRotationConfig
+
+    // Pino
+    pino?: (PinoLoggerOptions & { prettyPrint?: boolean }) | undefined
+  
+    error?:{ 
+     problemJson?:{ 
+      typeBaseUrl?: string
+    }
+    }
+
+  }
+
+ transform?: (error: unknown, context: { request: Request; code: Code }) => ProblemError | unknown
+
+ 
+}
+
+export class HttpError extends Error {
+  readonly status: number
+
+  constructor(status: number, message: string) {
+    super(message)
+    this.status = status
+  }
+}
+
+export interface Logger {
+  pino: Pino
+  log: (
+    level: LogLevel,
+    request: Request,
+    data: Record<string, unknown>,
+    store: StoreData
+  ) => void
+  handleHttpError: (
+    request: Request,
+    error: ProblemError,
+    store: StoreData,
+    options: Options
+  ) => void
+  debug: (
+    request: Request,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+  info: (
+    request: Request,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+  warn: (
+    request: Request,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+  error: (
+    request: Request,
+    message: string,
+    context?: Record<string, unknown>
+  ) => void
+}
+
+export interface LogixlysiaContext {
+  request: Request
+  store: LogixlysiaStore
+}