@blyp/core 0.1.2

package/dist/frameworks/client/index.d.ts

@@ -0,0 +1,3 @@
+export { createClientLogger, logger } from './logger';
+export { HTTP_CODES, BlypError, getHttpCode, parseError, } from '../../shared/errors';
+export type { ClientLogger, ClientLoggerConfig, ClientLogBrowserContext, ClientConnectorRequest, ClientLogDeviceContext, ClientLogEvent, ClientLogLevel, ClientLogPageContext, RemoteDeliveryConfig, RemoteDeliveryDropContext, RemoteDeliveryFailureContext, RemoteDeliveryFailureReason, RemoteDeliveryRetryContext, RemoteDeliverySuccessContext, ErrorLogLevel, ErrorLoggerLike, ParseErrorOptions, ParseableErrorPayload, BlypErrorCode, BlypErrorCodeDefinition, BlypErrorLike, } from '../../types/frameworks/client';

package/dist/frameworks/client/logger.d.ts

@@ -0,0 +1,4 @@
+import type { ClientLogger, ClientLoggerConfig } from '../../types/frameworks/client';
+export declare function createClientLogger(config?: ClientLoggerConfig): ClientLogger;
+export declare const logger: ClientLogger;
+export declare function resetClientWarningsForTests(): void;

package/dist/frameworks/elysia/index.d.ts

@@ -0,0 +1,2 @@
+export { createElysiaLogger, createElysiaLogger as createLogger } from './logger';
+export type { ClientLogIngestionConfig, ElysiaClientLogIngestionConfig, ElysiaLoggerConfig, LoggerConfig, ElysiaContext, ResolveCtx, HttpRequestLog, } from '../../types/frameworks/elysia';

package/dist/frameworks/elysia/logger.d.ts

@@ -0,0 +1,35 @@
+import { Elysia } from 'elysia';
+import type { ElysiaLoggerConfig } from '../../types/frameworks/elysia';
+export declare function createElysiaLogger(config?: ElysiaLoggerConfig): Elysia<"", {
+    decorator: {
+        log: import("../..").BlypLogger;
+    };
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {
+        readonly startTime: number;
+        readonly log: import("../..").BlypLogger;
+    };
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/frameworks/expo/index.d.ts

@@ -0,0 +1,2 @@
+export { createExpoLogger } from './logger';
+export type { ExpoLogger, ExpoLoggerConfig, ClientLogBrowserContext, ClientConnectorRequest, ClientLogDeviceContext, ClientLogEvent, ClientLogLevel, ClientLogPageContext, RemoteDeliveryConfig, RemoteDeliveryDropContext, RemoteDeliveryFailureContext, RemoteDeliveryFailureReason, RemoteDeliveryRetryContext, RemoteDeliverySuccessContext, } from '../../types/frameworks/expo';

package/dist/frameworks/expo/logger.d.ts

@@ -0,0 +1,3 @@
+import type { ExpoLogger, ExpoLoggerConfig } from '../../types/frameworks/expo';
+export declare function createExpoLogger(config: ExpoLoggerConfig): ExpoLogger;
+export declare function resetExpoWarningsForTests(): void;

package/dist/frameworks/expo/network.d.ts

@@ -0,0 +1,7 @@
+import type { ClientLogDeviceContext } from '../../shared/client-log';
+import type { ExpoNetworkLoader, ExpoNetworkModule } from '../../types/frameworks/expo';
+export declare function loadExpoNetworkModule(): Promise<ExpoNetworkModule | null>;
+export declare function getExpoNetworkSnapshot(): Promise<ClientLogDeviceContext['network'] | undefined>;
+export declare function subscribeToExpoNetworkState(listener: (state: ClientLogDeviceContext['network'] | undefined) => void): () => void;
+export declare function setExpoNetworkLoaderForTests(loader: ExpoNetworkLoader): void;
+export declare function resetExpoNetworkStateForTests(): void;

package/dist/frameworks/express/index.d.ts

@@ -0,0 +1,2 @@
+export { createExpressErrorLogger, createExpressLogger, createLogger, } from './logger';
+export type { ExpressClientLogIngestionConfig, ExpressErrorLoggerMiddleware, ExpressLoggerConfig, ExpressLoggerContext, ExpressLoggerMiddleware, HttpRequestLog, } from '../../types/frameworks/express';

package/dist/frameworks/express/logger.d.ts

@@ -0,0 +1,5 @@
+import type { ErrorRequestHandler, RequestHandler } from 'express';
+import type { ExpressLoggerConfig } from '../../types/frameworks/express';
+export declare function createExpressLogger(config?: ExpressLoggerConfig): RequestHandler;
+export declare function createExpressErrorLogger(_config?: ExpressLoggerConfig): ErrorRequestHandler;
+export declare const createLogger: typeof createExpressLogger;

package/dist/frameworks/fastify/index.d.ts

@@ -0,0 +1,2 @@
+export { createFastifyLogger, createLogger } from './logger';
+export type { FastifyClientLogIngestionConfig, FastifyLoggerConfig, FastifyLoggerContext, FastifyLoggerPlugin, HttpRequestLog, } from '../../types/frameworks/fastify';

package/dist/frameworks/fastify/logger.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { FastifyLoggerConfig } from '../../types/frameworks/fastify';
+export declare function createFastifyLogger(config?: FastifyLoggerConfig): FastifyPluginAsync;
+export declare const createLogger: typeof createFastifyLogger;

package/dist/frameworks/hono/index.d.ts

@@ -0,0 +1,2 @@
+export { createHonoLogger, createLogger } from './logger';
+export type { HonoClientLogIngestionConfig, HonoLoggerConfig, HonoLoggerMiddleware, HonoLoggerVariables, HttpRequestLog, } from '../../types/frameworks/hono';

package/dist/frameworks/hono/logger.d.ts

@@ -0,0 +1,4 @@
+import type { MiddlewareHandler } from 'hono';
+import type { HonoLoggerConfig } from '../../types/frameworks/hono';
+export declare function createHonoLogger(config?: HonoLoggerConfig): MiddlewareHandler;
+export declare const createLogger: typeof createHonoLogger;

package/dist/frameworks/nestjs/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const BLYP_NEST_LOGGER: unique symbol;
+export declare const BLYP_NEST_LOGGER_INIT_ERROR = "BlypModule.forRoot() requires createLogger(...) to run before NestFactory.create(AppModule).";

package/dist/frameworks/nestjs/filter.d.ts

@@ -0,0 +1,8 @@
+import type { ArgumentsHost } from '@nestjs/common';
+import { BaseExceptionFilter, HttpAdapterHost } from '@nestjs/core';
+import type { NestLoggerState } from '../../types/frameworks/nestjs';
+export declare class BlypNestExceptionFilter extends BaseExceptionFilter {
+    private readonly state;
+    constructor(state: NestLoggerState, httpAdapterHost: HttpAdapterHost);
+    catch(exception: unknown, host: ArgumentsHost): void;
+}

package/dist/frameworks/nestjs/helpers.d.ts

@@ -0,0 +1,25 @@
+import type { ExecutionContext } from '@nestjs/common';
+import type { NestAdapterType, NestHeaderRecord, NestLoggerContext } from '../../types/frameworks/nestjs';
+export declare function resolveNestAdapterType(request: unknown, response: unknown): NestAdapterType;
+export declare function getNestRequestMethod(request: unknown): string;
+export declare function getNestRequestHeaders(request: unknown): NestHeaderRecord | undefined;
+export declare function getNestRequestUrl(request: unknown): string;
+export declare function getNestRequestPath(request: unknown): string;
+export declare function readNestRequestBody(request: unknown): Promise<unknown>;
+export declare function setNestRequestStartTime(request: unknown, startTime: number): void;
+export declare function getNestRequestStartTime(request: unknown): number | undefined;
+export declare function setNestStructuredLogEmitted(request: unknown, emitted: boolean): void;
+export declare function getNestStructuredLogEmitted(request: unknown): boolean;
+export declare function attachNestRequestLogger(request: unknown, logger: unknown): void;
+export declare function buildNestRequestLike(request: unknown): import("../shared").RequestLike;
+export declare function getNestResponseStatus(response: unknown): number;
+export declare function setNestResponseHeaders(response: unknown, headers: Record<string, string>): void;
+export declare function sendNestStatusResponse(response: unknown, statusCode: number): void;
+export declare function getControllerName(context: ExecutionContext): string | undefined;
+export declare function getHandlerName(context: ExecutionContext): string | undefined;
+export declare function createNestLoggerContext(options: {
+    request: unknown;
+    response: unknown;
+    executionContext?: ExecutionContext;
+    error?: unknown;
+}): NestLoggerContext;

package/dist/frameworks/nestjs/index.d.ts

@@ -0,0 +1,3 @@
+export { createLogger, createNestLogger } from './logger';
+export { BlypModule } from './module';
+export type { HttpRequestLog, NestAdapterType, NestClientLogIngestionConfig, NestLoggerConfig, NestLoggerContext, } from '../../types/frameworks/nestjs';

package/dist/frameworks/nestjs/interceptor.d.ts

@@ -0,0 +1,8 @@
+import { type CallHandler, type ExecutionContext, type NestInterceptor } from '@nestjs/common';
+import type { Observable } from 'rxjs';
+import type { NestLoggerState } from '../../types/frameworks/nestjs';
+export declare class BlypNestInterceptor implements NestInterceptor {
+    private readonly state;
+    constructor(state: NestLoggerState);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+}

package/dist/frameworks/nestjs/logger.d.ts

@@ -0,0 +1,6 @@
+import { type StandaloneLogger } from '../standalone/logger';
+import type { NestLoggerConfig, NestLoggerState } from '../../types/frameworks/nestjs';
+export declare function createNestLogger(config?: NestLoggerConfig): StandaloneLogger;
+export declare const createLogger: typeof createNestLogger;
+export declare function getNestLoggerStateOrThrow(): NestLoggerState;
+export declare function resetNestLoggerState(): void;

package/dist/frameworks/nestjs/middleware.d.ts

@@ -0,0 +1,8 @@
+import { type NestMiddleware } from '@nestjs/common';
+import type { NestLoggerState } from '../../types/frameworks/nestjs';
+export declare class BlypNestMiddleware implements NestMiddleware {
+    private readonly state;
+    constructor(state: NestLoggerState);
+    use(request: unknown, response: unknown, next: (error?: unknown) => void): void;
+    private handleClientLogRequest;
+}

package/dist/frameworks/nestjs/module.d.ts

@@ -0,0 +1,5 @@
+import type { MiddlewareConsumer, DynamicModule, NestModule } from '@nestjs/common';
+export declare class BlypModule implements NestModule {
+    static forRoot(): DynamicModule;
+    configure(consumer: MiddlewareConsumer): void;
+}

package/dist/frameworks/nextjs/index.d.ts

@@ -0,0 +1,2 @@
+export { createLogger, createNextJsLogger } from './logger';
+export type { HttpRequestLog, NextJsClientLogIngestionConfig, NextJsHandlerWithLogger, NextJsLoggerConfig, NextJsLoggerContext, NextJsLoggerFactory, NextJsLoggerHelpers, NextJsRouteContext, NextJsWrappedHandler, } from '../../types/frameworks/nextjs';

package/dist/frameworks/nextjs/logger.d.ts

@@ -0,0 +1,3 @@
+import type { NextJsLoggerConfig, NextJsLoggerFactory } from '../../types/frameworks/nextjs';
+export declare function createNextJsLogger(config?: NextJsLoggerConfig): NextJsLoggerFactory;
+export declare const createLogger: typeof createNextJsLogger;

package/dist/frameworks/shared/http.d.ts

@@ -0,0 +1,10 @@
+import type { ErrorLike, HttpRequestLog, RequestLike } from '../../types/frameworks/http';
+export type { ErrorLike, HeaderRecord, HttpRequestLog, RequestLike, ResolveLike } from '../../types/frameworks/http';
+export declare function getHeaderValue(headers: RequestLike['headers'], name: string): string | undefined;
+export declare function extractPathname(requestUrl: string, fallbackPath?: string): string;
+export declare function createRequestLike(method: string, url: string, headers?: RequestLike['headers']): RequestLike;
+export declare function buildClientDetails(request: RequestLike, fallbackPath?: string): Omit<HttpRequestLog, 'type' | 'method' | 'url' | 'statusCode' | 'responseTime' | 'error' | 'stack'>;
+export declare function buildRequestLogData(request: RequestLike, type: 'http_request' | 'http_error', path: string, statusCode: number, responseTime: number, extra?: Record<string, unknown>): HttpRequestLog;
+export declare function buildInfoLogMessage(method: string, statusCode: number, url: string, responseTime: number): string;
+export declare function toErrorLike(error: unknown, fallbackStatusCode?: number): ErrorLike | undefined;
+export declare function isErrorStatus(statusCode: number): boolean;

package/dist/frameworks/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from './http';
+export * from './logger';
+export * from './request-context';
+export * from './request-logger';
+export * from '../../types/frameworks/shared';

package/dist/frameworks/shared/logger.d.ts

@@ -0,0 +1,35 @@
+import { createBaseLogger } from '../../core/logger';
+import type { ErrorLike, HttpRequestLog, RequestLike, ResolveLike } from '../../types/frameworks/http';
+import type { ClientLogIngestionConfig, ResolvedServerLogger, ServerLoggerConfig } from '../../types/frameworks/shared';
+import type { HttpErrorCaptureContext } from '../../types/frameworks/request-logger';
+export declare function resolveClientLoggingConfig<Ctx>(clientLogging: ServerLoggerConfig<Ctx>['clientLogging'], defaultClientLogging: {
+    enabled?: boolean;
+    path?: string;
+} | undefined): ClientLogIngestionConfig<Ctx> | null;
+export declare function resolveServerLogger<Ctx>(config?: ServerLoggerConfig<Ctx>, loggerOverride?: ReturnType<typeof createBaseLogger>): ResolvedServerLogger<Ctx>;
+export declare function shouldSkipAutoLogging<Ctx>(config: ResolvedServerLogger<Ctx>, ctx: Ctx, path: string): boolean;
+export declare function shouldSkipErrorLogging<Ctx>(config: ResolvedServerLogger<Ctx>, path: string): boolean;
+export declare function resolveAdditionalProps<Ctx>(config: ResolvedServerLogger<Ctx>, ctx: Ctx): Record<string, unknown>;
+export declare function emitHttpRequestLog(logger: ResolvedServerLogger<unknown>['logger'], level: string, request: RequestLike, path: string, statusCode: number, responseTime: number, additionalProps?: Record<string, unknown>): HttpRequestLog;
+export declare function emitHttpErrorLog(logger: ResolvedServerLogger<unknown>['logger'], level: string, request: RequestLike, path: string, statusCode: number, responseTime: number, error: ErrorLike | undefined, additionalProps?: Record<string, unknown>, captureContext?: HttpErrorCaptureContext): HttpRequestLog;
+export declare function parseClientLogPayload(request: RequestLike & {
+    json?: () => Promise<unknown>;
+}, body?: unknown): Promise<unknown>;
+export declare function handleClientLogIngestion<Ctx>(options: {
+    config: ResolvedServerLogger<Ctx>;
+    ctx: Ctx;
+    request: RequestLike & {
+        json?: () => Promise<unknown>;
+    };
+    body?: unknown;
+    deliveryPath?: string;
+}): Promise<{
+    status: number;
+    headers?: Record<string, string>;
+}>;
+export declare function readNodeRequestBody(stream: AsyncIterable<Uint8Array | string>): Promise<string>;
+export declare function buildAbsoluteUrl(path: string, headers?: RequestLike['headers']): string;
+export declare function resolveRequestStatus(ctx: ResolveLike, successCode?: number, errorCode?: number, isError?: boolean): number;
+export declare function shouldAutoFlushServerLogger<Ctx>(config: ResolvedServerLogger<Ctx>): boolean;
+export declare function flushServerLoggerSafely<Ctx>(config: ResolvedServerLogger<Ctx>): Promise<void>;
+export { buildInfoLogMessage, buildRequestLogData, createRequestLike, extractPathname, isErrorStatus, toErrorLike, } from './http';

package/dist/frameworks/shared/request-context.d.ts

@@ -0,0 +1,12 @@
+import type { BlypLogger } from '../../core/logger';
+import type { BlypRequestContextStore } from '../../types/frameworks/request-context';
+export type { BlypRequestContextStore } from '../../types/frameworks/request-context';
+export declare function runWithRequestContext<T>(callback: () => T): T;
+export declare function enterRequestContext(): BlypRequestContextStore;
+export declare function getRequestContextStore(): BlypRequestContextStore | undefined;
+export declare function setActiveRequestLogger(logger: BlypLogger): void;
+export declare function getActiveRequestLogger(): BlypLogger | undefined;
+export declare function markStructuredCollectorActive(): void;
+export declare function markStructuredLogEmitted(): void;
+export declare function hasStructuredLogBeenEmitted(): boolean;
+export declare function shouldDropRootLogWrite(): boolean;

package/dist/frameworks/shared/request-logger.d.ts

@@ -0,0 +1,4 @@
+import { type BlypLogger } from '../../core/logger';
+import type { RequestScopedLoggerOptions } from '../../types/frameworks/request-logger';
+export type { RequestScopedLoggerOptions } from '../../types/frameworks/request-logger';
+export declare function createRequestScopedLogger(logger: BlypLogger, options?: RequestScopedLoggerOptions): BlypLogger;

package/dist/frameworks/standalone/index.d.ts

@@ -0,0 +1,3 @@
+export { configureDefaultStandaloneLogger, createStandaloneLogger, logger, } from './logger';
+export type { StandaloneLogger } from './logger';
+export * from '../../types/frameworks/standalone';

package/dist/frameworks/standalone/logger.d.ts

@@ -0,0 +1,5 @@
+import type { StandaloneLogger, StandaloneLoggerConfig } from '../../types/frameworks/standalone';
+export type { StandaloneLogger } from '../../types/frameworks/standalone';
+export declare function createStandaloneLogger(config?: StandaloneLoggerConfig): StandaloneLogger;
+export declare function configureDefaultStandaloneLogger(config?: StandaloneLoggerConfig): StandaloneLogger;
+export declare const logger: StandaloneLogger;

package/dist/frameworks/sveltekit/index.d.ts

@@ -0,0 +1,2 @@
+export { createLogger, createSvelteKitLogger } from './logger';
+export type { HttpRequestLog, SvelteKitClientLogIngestionConfig, SvelteKitHandle, SvelteKitLoggerConfig, SvelteKitLoggerContext, SvelteKitLoggerFactory, SvelteKitLocals, SvelteKitRequestEvent, SvelteKitRequestHandler, SvelteKitResolve, } from '../../types/frameworks/sveltekit';

package/dist/frameworks/sveltekit/logger.d.ts

@@ -0,0 +1,3 @@
+import type { SvelteKitLoggerConfig, SvelteKitLoggerFactory } from '../../types/frameworks/sveltekit';
+export declare function createSvelteKitLogger(config?: SvelteKitLoggerConfig): SvelteKitLoggerFactory;
+export declare const createLogger: typeof createSvelteKitLogger;

package/dist/frameworks/tanstack-start/index.d.ts

@@ -0,0 +1,2 @@
+export { createLogger, createTanStackStartLogger } from './logger';
+export type { HttpRequestLog, TanStackStartClientLogHandlers, TanStackStartClientLogIngestionConfig, TanStackStartLoggerConfig, TanStackStartLoggerContext, TanStackStartLoggerFactory, TanStackStartMiddlewareContext, } from '../../types/frameworks/tanstack-start';

package/dist/frameworks/tanstack-start/logger.d.ts

@@ -0,0 +1,3 @@
+import type { TanStackStartLoggerConfig, TanStackStartLoggerFactory } from '../../types/frameworks/tanstack-start';
+export declare function createTanStackStartLogger(config?: TanStackStartLoggerConfig): TanStackStartLoggerFactory;
+export declare const createLogger: typeof createTanStackStartLogger;

package/dist/frameworks/workers/index.d.ts

@@ -0,0 +1,2 @@
+export { createWorkersLogger, initWorkersLogger } from './logger';
+export type { HttpRequestLog, StructuredLog, WorkersEmitOptions, WorkersLoggerConfig, WorkersRequestLogger, } from '../../types/frameworks/workers';

package/dist/frameworks/workers/logger.d.ts

@@ -0,0 +1,3 @@
+import type { WorkersLoggerConfig, WorkersRequestLogger } from '../../types/frameworks/workers';
+export declare function initWorkersLogger(config?: WorkersLoggerConfig): void;
+export declare function createWorkersLogger(request: Request): WorkersRequestLogger;