@wrelik/errors 0.2.1 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrelik/errors",
-  "version": "0.2.1",
+  "version": "2.0.0",
   "publishConfig": {
     "access": "public"
   },
@@ -9,21 +9,28 @@
     "url": "https://github.com/lwhite702/wrelik-kit.git",
     "directory": "packages/errors"
   },
-  "main": "./dist/node.js",
-  "types": "./dist/node.d.ts",
+  "sideEffects": false,
   "exports": {
-    ".": {
-      "react-native": "./dist/react-native.js",
-      "browser": "./dist/browser.js",
-      "import": "./dist/node.js",
-      "require": "./dist/node.js"
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.js"
     },
-    "./react-native": "./dist/react-native.js"
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.mjs",
+      "require": "./dist/client/index.js"
+    },
+    "./shared": {
+      "types": "./dist/shared/index.d.ts",
+      "import": "./dist/shared/index.mjs",
+      "require": "./dist/shared/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "dependencies": {
     "@sentry/browser": "^10.38.0",
-    "@sentry/node": "^7.101.1",
-    "@sentry/react-native": "^5.19.0"
+    "@sentry/node": "^7.101.1"
   },
   "devDependencies": {
     "@types/node": "^25.2.0",
@@ -32,9 +39,17 @@
     "@wrelik/eslint-config": "0.1.1",
     "@wrelik/tsconfig": "0.1.1"
   },
+  "wrelik": {
+    "runtimes": [
+      "server",
+      "client",
+      "shared"
+    ]
+  },
   "scripts": {
-    "build": "tsup src/node.ts src/browser.ts src/react-native.ts --format cjs,esm --dts --clean",
+    "build": "tsup src/server/index.ts src/client/index.ts src/shared/index.ts --format cjs,esm --dts --clean",
     "lint": "eslint src/",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run --passWithNoTests"
   }
 }

package/src/client/index.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeError } from './index';
+
+describe('@wrelik/errors/client', () => {
+  it('exposes error normalization but not server capture helpers', async () => {
+    const mod = await import('./index.js');
+
+    expect(typeof mod.normalizeError).toBe('function');
+    expect('captureError' in mod).toBe(false);
+    expect('initErrors' in mod).toBe(false);
+  });
+
+  it('normalizes errors with a client-safe entrypoint', () => {
+    const normalized = normalizeError(new Error('client-boom'));
+    expect(normalized.code).toBe('INTERNAL_ERROR');
+    expect(normalized.message).toBe('client-boom');
+  });
+});

package/src/client/index.ts

@@ -0,0 +1,2 @@
+export { normalizeError } from '../shared';
+export type { ErrorContext, NormalizedError } from '../shared';

package/src/server/index.test.ts

@@ -0,0 +1,40 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+afterEach(() => {
+  vi.resetModules();
+  vi.clearAllMocks();
+});
+
+describe('@wrelik/errors/server', () => {
+  it('captures unexpected errors through the server Sentry SDK', async () => {
+    const captureException = vi.fn();
+    vi.doMock('@sentry/node', () => ({
+      default: {},
+      captureException,
+      init: vi.fn(),
+      setUser: vi.fn(),
+    }));
+
+    const mod = await import('./index.js');
+    mod.captureError(new Error('boom'), { requestId: 'r1' });
+
+    expect(captureException).toHaveBeenCalledTimes(1);
+    expect(captureException.mock.calls[0][1]).toEqual({ extra: { requestId: 'r1' } });
+  });
+
+  it('does not capture handled 4xx AppError instances', async () => {
+    const captureException = vi.fn();
+    vi.doMock('@sentry/node', () => ({
+      default: {},
+      captureException,
+      init: vi.fn(),
+      setUser: vi.fn(),
+    }));
+
+    const mod = await import('./index.js');
+    const { ValidationError } = await import('../shared/index.js');
+    mod.captureError(new ValidationError('bad input'));
+
+    expect(captureException).not.toHaveBeenCalled();
+  });
+});

package/src/server/index.ts

@@ -0,0 +1,26 @@
+import * as Sentry from '@sentry/node';
+import { AppError, normalizeError, type ErrorContext } from '../shared';
+
+export function initErrors(config: { dsn: string; tracesSampleRate?: number }): void {
+  Sentry.init({
+    dsn: config.dsn,
+    tracesSampleRate: config.tracesSampleRate ?? 1,
+  });
+}
+
+export function setUserContext(user: { id: string; email?: string } | null): void {
+  Sentry.setUser(user);
+}
+
+export function captureError(err: unknown, context?: ErrorContext): void {
+  const normalized = normalizeError(err, context);
+
+  if (err instanceof AppError) {
+    if (normalized.statusCode >= 500) {
+      Sentry.captureException(err, { extra: normalized.context });
+    }
+    return;
+  }
+
+  Sentry.captureException(err, { extra: normalized.context });
+}

package/src/shared/index.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeError, ValidationError } from './index';
+
+describe('@wrelik/errors/shared', () => {
+  it('normalizes AppError shapes and merges context', () => {
+    const err = new ValidationError('Bad input', { field: 'email' });
+    const normalized = normalizeError(err, { requestId: 'r1' });
+
+    expect(normalized).toEqual({
+      name: 'AppError',
+      message: 'Bad input',
+      code: 'VALIDATION_ERROR',
+      statusCode: 400,
+      context: { field: 'email', requestId: 'r1' },
+    });
+  });
+
+  it('normalizes unknown errors to an internal error shape', () => {
+    const normalized = normalizeError(new Error('boom'));
+
+    expect(normalized).toEqual({
+      name: 'Error',
+      message: 'boom',
+      code: 'INTERNAL_ERROR',
+      statusCode: 500,
+      context: undefined,
+    });
+  });
+
+  it('normalizes non-error throwables with original payload', () => {
+    const normalized = normalizeError('boom', { requestId: 'r2' });
+
+    expect(normalized.code).toBe('INTERNAL_ERROR');
+    expect(normalized.statusCode).toBe(500);
+    expect(normalized.context).toEqual({ requestId: 'r2', originalError: 'boom' });
+  });
+});

package/src/shared/index.ts

@@ -0,0 +1,9 @@
+export {
+  AppError,
+  AuthRequiredError,
+  normalizeError,
+  PermissionDeniedError,
+  TenantRequiredError,
+  ValidationError,
+} from './types';
+export type { ErrorContext, NormalizedError } from './types';

package/src/shared/types.ts

@@ -0,0 +1,78 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ErrorContext = Record<string, any>;
+
+export interface NormalizedError {
+  name: string;
+  message: string;
+  code: string;
+  statusCode: number;
+  context?: ErrorContext;
+}
+
+export class AppError extends Error {
+  public readonly code: string;
+  public readonly statusCode: number;
+  public readonly context?: ErrorContext;
+
+  constructor(message: string, code: string, statusCode = 500, context?: ErrorContext) {
+    super(message);
+    this.name = 'AppError';
+    this.code = code;
+    this.statusCode = statusCode;
+    this.context = context;
+  }
+}
+
+export class AuthRequiredError extends AppError {
+  constructor(message = 'Authentication required', context?: ErrorContext) {
+    super(message, 'AUTH_REQUIRED', 401, context);
+  }
+}
+
+export class TenantRequiredError extends AppError {
+  constructor(message = 'Tenant context required', context?: ErrorContext) {
+    super(message, 'TENANT_REQUIRED', 400, context);
+  }
+}
+
+export class PermissionDeniedError extends AppError {
+  constructor(message = 'Permission denied', context?: ErrorContext) {
+    super(message, 'PERMISSION_DENIED', 403, context);
+  }
+}
+
+export class ValidationError extends AppError {
+  constructor(message: string, context?: ErrorContext) {
+    super(message, 'VALIDATION_ERROR', 400, context);
+  }
+}
+
+export function normalizeError(err: unknown, context?: ErrorContext): NormalizedError {
+  if (err instanceof AppError) {
+    return {
+      name: err.name,
+      message: err.message,
+      code: err.code,
+      statusCode: err.statusCode,
+      context: context ? { ...err.context, ...context } : err.context,
+    };
+  }
+
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      code: 'INTERNAL_ERROR',
+      statusCode: 500,
+      context,
+    };
+  }
+
+  return {
+    name: 'Error',
+    message: 'Unknown error',
+    code: 'INTERNAL_ERROR',
+    statusCode: 500,
+    context: context ? { ...context, originalError: err } : { originalError: err },
+  };
+}

package/tsconfig.json

@@ -2,7 +2,8 @@
   "extends": "@wrelik/tsconfig/node.json",
   "compilerOptions": {
     "outDir": "dist",
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "lib": ["DOM", "DOM.Iterable", "ES2022"]
   },
   "include": ["src"]
 }

package/dist/browser.d.mts

@@ -1,10 +0,0 @@
-export { A as AppError, a as AuthRequiredError, P as PermissionDeniedError, T as TenantRequiredError, V as ValidationError } from './shared-DXFP3J32.mjs';
-
-declare function captureError(err: unknown, context?: Record<string, any>): void;
-declare function setUserContext(user: {
-    id: string;
-    email?: string;
-} | null): void;
-declare function initErrors(dsn: string): void;
-
-export { captureError, initErrors, setUserContext };

package/dist/browser.d.ts

@@ -1,10 +0,0 @@
-export { A as AppError, a as AuthRequiredError, P as PermissionDeniedError, T as TenantRequiredError, V as ValidationError } from './shared-DXFP3J32.js';
-
-declare function captureError(err: unknown, context?: Record<string, any>): void;
-declare function setUserContext(user: {
-    id: string;
-    email?: string;
-} | null): void;
-declare function initErrors(dsn: string): void;
-
-export { captureError, initErrors, setUserContext };

package/dist/browser.js

@@ -1,115 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/browser.ts
-var browser_exports = {};
-__export(browser_exports, {
-  AppError: () => AppError,
-  AuthRequiredError: () => AuthRequiredError,
-  PermissionDeniedError: () => PermissionDeniedError,
-  TenantRequiredError: () => TenantRequiredError,
-  ValidationError: () => ValidationError,
-  captureError: () => captureError,
-  initErrors: () => initErrors,
-  setUserContext: () => setUserContext
-});
-module.exports = __toCommonJS(browser_exports);
-var Sentry = __toESM(require("@sentry/browser"));
-
-// src/shared.ts
-var AppError = class extends Error {
-  code;
-  statusCode;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  context;
-  constructor(message, code, statusCode = 500, context) {
-    super(message);
-    this.name = "AppError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.context = context;
-  }
-};
-var AuthRequiredError = class extends AppError {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(message = "Authentication required", context) {
-    super(message, "AUTH_REQUIRED", 401, context);
-  }
-};
-var TenantRequiredError = class extends AppError {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(message = "Tenant context required", context) {
-    super(message, "TENANT_REQUIRED", 400, context);
-  }
-};
-var PermissionDeniedError = class extends AppError {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(message = "Permission denied", context) {
-    super(message, "PERMISSION_DENIED", 403, context);
-  }
-};
-var ValidationError = class extends AppError {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  constructor(message, context) {
-    super(message, "VALIDATION_ERROR", 400, context);
-  }
-};
-
-// src/browser.ts
-function captureError(err, context) {
-  if (err instanceof AppError) {
-    console.warn(`[${err.code}] ${err.message}`, { context: err.context, ...context });
-    if (err.statusCode >= 500) {
-      Sentry.captureException(err, { extra: { ...err.context, ...context } });
-    }
-  } else {
-    console.error("Unexpected error:", err);
-    Sentry.captureException(err, { extra: context });
-  }
-}
-function setUserContext(user) {
-  Sentry.setUser(user);
-}
-function initErrors(dsn) {
-  Sentry.init({
-    dsn,
-    tracesSampleRate: 1
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AppError,
-  AuthRequiredError,
-  PermissionDeniedError,
-  TenantRequiredError,
-  ValidationError,
-  captureError,
-  initErrors,
-  setUserContext
-});

package/dist/browser.mjs

@@ -1,40 +0,0 @@
-import {
-  AppError,
-  AuthRequiredError,
-  PermissionDeniedError,
-  TenantRequiredError,
-  ValidationError
-} from "./chunk-EARDCOC4.mjs";
-
-// src/browser.ts
-import * as Sentry from "@sentry/browser";
-function captureError(err, context) {
-  if (err instanceof AppError) {
-    console.warn(`[${err.code}] ${err.message}`, { context: err.context, ...context });
-    if (err.statusCode >= 500) {
-      Sentry.captureException(err, { extra: { ...err.context, ...context } });
-    }
-  } else {
-    console.error("Unexpected error:", err);
-    Sentry.captureException(err, { extra: context });
-  }
-}
-function setUserContext(user) {
-  Sentry.setUser(user);
-}
-function initErrors(dsn) {
-  Sentry.init({
-    dsn,
-    tracesSampleRate: 1
-  });
-}
-export {
-  AppError,
-  AuthRequiredError,
-  PermissionDeniedError,
-  TenantRequiredError,
-  ValidationError,
-  captureError,
-  initErrors,
-  setUserContext
-};

package/dist/node.d.mts

@@ -1,10 +0,0 @@
-export { A as AppError, a as AuthRequiredError, P as PermissionDeniedError, T as TenantRequiredError, V as ValidationError } from './shared-DXFP3J32.mjs';
-
-declare function captureError(err: unknown, context?: Record<string, any>): void;
-declare function setUserContext(user: {
-    id: string;
-    email?: string;
-} | null): void;
-declare function initErrors(dsn: string): void;
-
-export { captureError, initErrors, setUserContext };

package/dist/node.d.ts

@@ -1,10 +0,0 @@
-export { A as AppError, a as AuthRequiredError, P as PermissionDeniedError, T as TenantRequiredError, V as ValidationError } from './shared-DXFP3J32.js';
-
-declare function captureError(err: unknown, context?: Record<string, any>): void;
-declare function setUserContext(user: {
-    id: string;
-    email?: string;
-} | null): void;
-declare function initErrors(dsn: string): void;
-
-export { captureError, initErrors, setUserContext };

package/dist/node.mjs

@@ -1,40 +0,0 @@
-import {
-  AppError,
-  AuthRequiredError,
-  PermissionDeniedError,
-  TenantRequiredError,
-  ValidationError
-} from "./chunk-EARDCOC4.mjs";
-
-// src/node.ts
-import * as Sentry from "@sentry/node";
-function captureError(err, context) {
-  if (err instanceof AppError) {
-    console.warn(`[${err.code}] ${err.message}`, { context: err.context, ...context });
-    if (err.statusCode >= 500) {
-      Sentry.captureException(err, { extra: { ...err.context, ...context } });
-    }
-  } else {
-    console.error("Unexpected error:", err);
-    Sentry.captureException(err, { extra: context });
-  }
-}
-function setUserContext(user) {
-  Sentry.setUser(user);
-}
-function initErrors(dsn) {
-  Sentry.init({
-    dsn,
-    tracesSampleRate: 1
-  });
-}
-export {
-  AppError,
-  AuthRequiredError,
-  PermissionDeniedError,
-  TenantRequiredError,
-  ValidationError,
-  captureError,
-  initErrors,
-  setUserContext
-};

package/dist/react-native.d.mts

@@ -1,13 +0,0 @@
-export { A as AppError, a as AuthRequiredError, P as PermissionDeniedError, T as TenantRequiredError, V as ValidationError } from './shared-DXFP3J32.mjs';
-
-declare function initErrors(config: {
-    dsn: string;
-    environment?: string;
-}): void;
-declare function setUserContext(user: {
-    id: string;
-    email?: string;
-} | null): void;
-declare function captureError(err: unknown, context?: Record<string, any>): void;
-
-export { captureError, initErrors, setUserContext };

package/dist/react-native.d.ts

@@ -1,13 +0,0 @@
-export { A as AppError, a as AuthRequiredError, P as PermissionDeniedError, T as TenantRequiredError, V as ValidationError } from './shared-DXFP3J32.js';
-
-declare function initErrors(config: {
-    dsn: string;
-    environment?: string;
-}): void;
-declare function setUserContext(user: {
-    id: string;
-    email?: string;
-} | null): void;
-declare function captureError(err: unknown, context?: Record<string, any>): void;
-
-export { captureError, initErrors, setUserContext };

package/dist/react-native.mjs

@@ -1,40 +0,0 @@
-import {
-  AppError,
-  AuthRequiredError,
-  PermissionDeniedError,
-  TenantRequiredError,
-  ValidationError
-} from "./chunk-EARDCOC4.mjs";
-
-// src/react-native.ts
-import * as Sentry from "@sentry/react-native";
-function initErrors(config) {
-  Sentry.init({
-    dsn: config.dsn,
-    environment: config.environment || "production"
-  });
-}
-function setUserContext(user) {
-  Sentry.setUser(user);
-}
-function captureError(err, context) {
-  if (err instanceof AppError) {
-    if (err.statusCode >= 500) {
-      Sentry.captureException(err, { extra: { ...err.context, ...context } });
-    } else {
-      console.warn(`[${err.code}] ${err.message}`, { context: err.context, ...context });
-    }
-  } else {
-    Sentry.captureException(err, { extra: context });
-  }
-}
-export {
-  AppError,
-  AuthRequiredError,
-  PermissionDeniedError,
-  TenantRequiredError,
-  ValidationError,
-  captureError,
-  initErrors,
-  setUserContext
-};

package/dist/shared-DXFP3J32.d.mts

@@ -1,20 +0,0 @@
-declare class AppError extends Error {
-    readonly code: string;
-    readonly statusCode: number;
-    readonly context?: Record<string, any>;
-    constructor(message: string, code: string, statusCode?: number, context?: Record<string, any>);
-}
-declare class AuthRequiredError extends AppError {
-    constructor(message?: string, context?: Record<string, any>);
-}
-declare class TenantRequiredError extends AppError {
-    constructor(message?: string, context?: Record<string, any>);
-}
-declare class PermissionDeniedError extends AppError {
-    constructor(message?: string, context?: Record<string, any>);
-}
-declare class ValidationError extends AppError {
-    constructor(message: string, context?: Record<string, any>);
-}
-
-export { AppError as A, PermissionDeniedError as P, TenantRequiredError as T, ValidationError as V, AuthRequiredError as a };

package/dist/shared-DXFP3J32.d.ts

@@ -1,20 +0,0 @@
-declare class AppError extends Error {
-    readonly code: string;
-    readonly statusCode: number;
-    readonly context?: Record<string, any>;
-    constructor(message: string, code: string, statusCode?: number, context?: Record<string, any>);
-}
-declare class AuthRequiredError extends AppError {
-    constructor(message?: string, context?: Record<string, any>);
-}
-declare class TenantRequiredError extends AppError {
-    constructor(message?: string, context?: Record<string, any>);
-}
-declare class PermissionDeniedError extends AppError {
-    constructor(message?: string, context?: Record<string, any>);
-}
-declare class ValidationError extends AppError {
-    constructor(message: string, context?: Record<string, any>);
-}
-
-export { AppError as A, PermissionDeniedError as P, TenantRequiredError as T, ValidationError as V, AuthRequiredError as a };