@blyp/core 0.1.2

package/dist/types/shared/client-log.d.ts

@@ -0,0 +1,91 @@
+export type ClientLogLevel = 'debug' | 'info' | 'warning' | 'error' | 'critical' | 'success' | 'table';
+export interface ClientLogPageContext {
+    url?: string;
+    pathname?: string;
+    search?: string;
+    hash?: string;
+    title?: string;
+    referrer?: string;
+}
+export interface ClientLogBrowserContext {
+    userAgent?: string;
+    language?: string;
+    platform?: string;
+}
+export interface ClientLogDeviceContext {
+    runtime?: 'expo' | 'browser';
+    network?: {
+        type?: string;
+        isConnected?: boolean;
+        isInternetReachable?: boolean;
+    };
+}
+export interface ClientLogSessionContext {
+    pageId: string;
+    sessionId: string;
+}
+export type ClientConnectorRequest = 'betterstack' | 'posthog' | 'sentry' | {
+    type: 'otlp';
+    name: string;
+};
+export interface ClientLogEvent {
+    type: 'client_log';
+    source: 'client';
+    id: string;
+    level: ClientLogLevel;
+    message: string;
+    connector?: ClientConnectorRequest;
+    data?: unknown;
+    bindings?: Record<string, unknown>;
+    clientTimestamp: string;
+    page: ClientLogPageContext;
+    browser: ClientLogBrowserContext;
+    device?: ClientLogDeviceContext;
+    session: ClientLogSessionContext;
+    metadata?: Record<string, unknown>;
+}
+export type RemoteDeliveryRuntime = 'browser' | 'expo';
+export type RemoteDeliveryTransport = 'fetch' | 'beacon';
+export type RemoteDeliveryFailureReason = 'offline' | 'network_error' | 'response_status' | 'invalid_endpoint' | 'missing_transport' | 'queue_overflow';
+export interface RemoteDeliverySuccessContext {
+    runtime: RemoteDeliveryRuntime;
+    event: ClientLogEvent;
+    attempt: number;
+    status?: number;
+    transport: RemoteDeliveryTransport;
+}
+export interface RemoteDeliveryRetryContext {
+    runtime: RemoteDeliveryRuntime;
+    event: ClientLogEvent;
+    attempt: number;
+    retriesRemaining: number;
+    nextRetryAt: string;
+    reason: 'offline' | 'network_error' | 'response_status';
+    status?: number;
+    error?: string;
+}
+export interface RemoteDeliveryFailureContext {
+    runtime: RemoteDeliveryRuntime;
+    event: ClientLogEvent;
+    attempt: number;
+    reason: RemoteDeliveryFailureReason;
+    status?: number;
+    error?: string;
+}
+export interface RemoteDeliveryDropContext {
+    runtime: RemoteDeliveryRuntime;
+    droppedEvent: ClientLogEvent;
+    replacementEvent: ClientLogEvent;
+    maxQueueSize: number;
+    reason: 'queue_overflow';
+}
+export interface RemoteDeliveryConfig {
+    maxRetries?: number;
+    retryDelayMs?: number;
+    maxQueueSize?: number;
+    warnOnFailure?: boolean;
+    onSuccess?: (ctx: RemoteDeliverySuccessContext) => void;
+    onRetry?: (ctx: RemoteDeliveryRetryContext) => void;
+    onFailure?: (ctx: RemoteDeliveryFailureContext) => void;
+    onDrop?: (ctx: RemoteDeliveryDropContext) => void;
+}

package/dist/types/shared/errors.d.ts

@@ -0,0 +1,75 @@
+export type ErrorLogLevel = 'debug' | 'info' | 'warning' | 'error' | 'critical';
+export interface ErrorLoggerLike {
+    debug: (message: unknown, ...args: unknown[]) => void;
+    info: (message: unknown, ...args: unknown[]) => void;
+    warning: (message: unknown, ...args: unknown[]) => void;
+    error: (message: unknown, ...args: unknown[]) => void;
+    critical: (message: unknown, ...args: unknown[]) => void;
+}
+export interface BlypErrorLike {
+    status?: number;
+    statusCode?: number;
+    code?: string | number;
+    message?: string;
+    stack?: string;
+    why?: string;
+    fix?: string;
+    link?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+    logLevel?: ErrorLogLevel;
+}
+export interface BlypErrorCodeDefinition {
+    key: string;
+    status: number;
+    message: string;
+    code?: string;
+    why?: string;
+    fix?: string;
+    link?: string;
+    details?: Record<string, unknown>;
+    logLevel?: ErrorLogLevel;
+}
+export interface BlypErrorCodeCreateOptions extends Omit<BlypErrorLike, 'statusCode'> {
+    logger?: ErrorLoggerLike;
+    skipLogging?: boolean;
+}
+export interface BlypErrorCode extends Readonly<BlypErrorCodeDefinition> {
+    readonly statusCode: number;
+    create(overrides?: BlypErrorCodeCreateOptions): BlypErrorLike;
+    extend(definition: {
+        code: string;
+        message?: string;
+        why?: string;
+        fix?: string;
+        link?: string;
+        details?: Record<string, unknown>;
+        logLevel?: ErrorLogLevel;
+    }): BlypErrorCode;
+}
+export type ParseableErrorPayload = BlypErrorLike | Error | string | Record<string, unknown> | null | undefined;
+export interface ParseErrorOptions {
+    logger?: ErrorLoggerLike;
+    logLevel?: ErrorLogLevel;
+    fallbackStatus?: number;
+}
+export interface ResolvedErrorConfig {
+    status: number;
+    statusCode: number;
+    message: string;
+    code?: string | number;
+    why?: string;
+    fix?: string;
+    link?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+    stack?: string;
+    logLevel: ErrorLogLevel;
+}
+export interface ErrorConstructionInput extends BlypErrorLike {
+    status?: number;
+    logger?: ErrorLoggerLike;
+    skipLogging?: boolean;
+}
+export type HttpCodeRegistry<TKeys extends string = string> = Readonly<Record<TKeys, BlypErrorCode>>;
+export type CreateCodeFunction = (definition: BlypErrorCodeDefinition, overrides?: BlypErrorCodeCreateOptions) => BlypErrorLike;

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

@@ -0,0 +1,4 @@
+export * from './errors';
+export * from './client-log';
+export * from './once';
+export * from './remote-delivery';

package/dist/types/shared/once.d.ts

@@ -0,0 +1,2 @@
+export type ConsoleOnceLogger = (key: string, message: string, error?: unknown) => void;
+export type ConsoleMethod = 'warn' | 'error';

package/dist/types/shared/remote-delivery.d.ts

@@ -0,0 +1,32 @@
+import type { ClientLogEvent, RemoteDeliveryConfig, RemoteDeliveryFailureReason, RemoteDeliveryRuntime, RemoteDeliveryTransport } from './client-log';
+export type RetryReason = 'offline' | 'network_error' | 'response_status';
+export interface QueueItem {
+    event: ClientLogEvent;
+    attempt: number;
+    nextAttemptAt: number;
+}
+export interface DeliveryAttemptSuccess {
+    outcome: 'success';
+    transport: RemoteDeliveryTransport;
+    status?: number;
+}
+export interface DeliveryAttemptRetry {
+    outcome: 'retry';
+    reason: RetryReason;
+    status?: number;
+    error?: string;
+}
+export interface DeliveryAttemptFailure {
+    outcome: 'failure';
+    reason: Exclude<RemoteDeliveryFailureReason, 'queue_overflow'>;
+    status?: number;
+    error?: string;
+    suppressWarning?: boolean;
+}
+export type DeliveryAttemptResult = DeliveryAttemptSuccess | DeliveryAttemptRetry | DeliveryAttemptFailure;
+export interface RemoteDeliveryManagerOptions {
+    runtime: RemoteDeliveryRuntime;
+    delivery?: RemoteDeliveryConfig;
+    send: (event: ClientLogEvent) => Promise<DeliveryAttemptResult>;
+    subscribeToResume?: (resume: () => void) => (() => void) | void;
+}