@classytic/arc 2.11.4 → 2.13.1

package/dist/errorHandler-BQm8ZxTK.mjs

@@ -1,173 +0,0 @@
-import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
-import { p as isArcError } from "./errors-D5c-5BJL.mjs";
-import fp from "fastify-plugin";
-//#region src/plugins/errorHandler.ts
-var errorHandler_exports = /* @__PURE__ */ __exportAll({
-	defaultIsDuplicateKeyError: () => defaultIsDuplicateKeyError,
-	errorHandlerPlugin: () => errorHandlerPlugin
-});
-/**
-* Default duplicate-key detector covering the mainstream drivers arc sees
-* most. Detection is strictly by known driver codes — never by message
-* string matching — because false positives on dup-key silently mask real
-* errors (WriteConflict, NotWritablePrimary, etc.) as 409s. For long-tail
-* drivers (Neo4j, MSSQL, DynamoDB, custom kits), compose rather than
-* replace:
-*
-* ```ts
-* import { defaultIsDuplicateKeyError } from '@classytic/arc/plugins';
-*
-* errorHandler: {
-*   isDuplicateKeyError: (err) =>
-*     defaultIsDuplicateKeyError(err) || isNeo4jDupKey(err),
-* }
-* ```
-*
-* Drizzle apps get coverage transitively (Drizzle doesn't wrap driver
-* errors — pg/mysql2/better-sqlite3 codes propagate as-is). Neon is
-* Postgres-wire-compatible → `23505` covers `@neondatabase/serverless`.
-*/
-function defaultIsDuplicateKeyError(err) {
-	if (!err || typeof err !== "object") return false;
-	const e = err;
-	if (e.code === 11e3 || e.codeName === "DuplicateKey") return true;
-	if (e.code === "P2002") return true;
-	if (e.code === "23505") return true;
-	if (e.code === "ER_DUP_ENTRY" || e.errno === 1062) return true;
-	if (e.code === "SQLITE_CONSTRAINT_UNIQUE" || e.code === "SQLITE_CONSTRAINT_PRIMARYKEY") return true;
-	return false;
-}
-/**
-* Extract the duplicate-field names for the `details.duplicateFields`
-* response. Only called when the caller has opted into detail exposure
-* (`includeStack: true`) — shape differs per driver.
-*/
-function extractDuplicateFields(err) {
-	if (!err || typeof err !== "object") return null;
-	const e = err;
-	if (e.keyValue && typeof e.keyValue === "object") return Object.keys(e.keyValue);
-	if (e.meta?.target) {
-		if (Array.isArray(e.meta.target)) return e.meta.target.map(String);
-		if (typeof e.meta.target === "string") return [e.meta.target];
-	}
-	if (typeof e.constraint === "string") return [e.constraint];
-	return null;
-}
-async function errorHandlerPluginFn(fastify, options = {}) {
-	const isProduction = process.env.NODE_ENV === "production";
-	const { includeStack = !isProduction, onError, errorMap = {}, errorMappers = [], isDuplicateKeyError = defaultIsDuplicateKeyError } = options;
-	fastify.setErrorHandler(async (error, request, reply) => {
-		if (onError) try {
-			await onError(error, request);
-		} catch (callbackError) {
-			request.log.error({ err: callbackError }, "Error in onError callback");
-		}
-		const requestId = request.id;
-		if (errorMappers.length > 0) {
-			for (const mapper of errorMappers) if (error instanceof mapper.type) {
-				const mapped = mapper.toResponse(error);
-				const response = {
-					success: false,
-					error: mapped.message ?? error.message,
-					code: mapped.code ?? "DOMAIN_ERROR",
-					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-					...requestId && { requestId },
-					...mapped.details && { details: mapped.details },
-					...includeStack && error.stack ? { stack: error.stack } : {}
-				};
-				return reply.code(mapped.status).send(response);
-			}
-		}
-		const response = {
-			success: false,
-			error: error.message || "Internal Server Error",
-			code: "INTERNAL_ERROR",
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			...requestId && { requestId }
-		};
-		let statusCode = 500;
-		if (isArcError(error)) {
-			statusCode = error.statusCode;
-			response.code = error.code;
-			if (error.details) response.details = error.details;
-			if (error.requestId) response.requestId = error.requestId;
-			if (error.cause) request.log.error({ cause: error.cause }, "Error cause chain");
-		} else if ("validation" in error && Array.isArray(error.validation)) {
-			statusCode = 400;
-			response.code = "VALIDATION_ERROR";
-			response.error = "Validation failed";
-			response.details = { errors: error.validation?.map((v) => ({
-				field: v.instancePath?.replace(/^\//, "") || v.params?.missingProperty || "unknown",
-				message: v.message || "Invalid value",
-				keyword: v.keyword
-			})) };
-		} else if ("statusCode" in error && typeof error.statusCode === "number") {
-			statusCode = error.statusCode;
-			response.code = statusCodeToCode(statusCode);
-		} else if ("status" in error && typeof error.status === "number") {
-			statusCode = error.status;
-			response.code = statusCodeToCode(statusCode);
-		} else if (error.name && errorMap[error.name]) {
-			const mapping = errorMap[error.name];
-			statusCode = mapping.statusCode;
-			response.code = mapping.code;
-			if (mapping.message) response.error = mapping.message;
-		} else if (error.name === "ValidationError" && "errors" in error) {
-			statusCode = 400;
-			response.code = "VALIDATION_ERROR";
-			const mongooseErrors = error.errors;
-			if (includeStack) response.details = { errors: Object.entries(mongooseErrors).map(([field, err]) => ({
-				field: err.path || field,
-				message: err.message
-			})) };
-			else response.details = { errorCount: Object.keys(mongooseErrors).length };
-		} else if (error.name === "CastError") {
-			statusCode = 400;
-			response.code = "INVALID_ID";
-			response.error = "Invalid identifier format";
-		} else if (isDuplicateKeyError(error)) {
-			statusCode = 409;
-			response.code = "DUPLICATE_KEY";
-			response.error = "Resource already exists";
-			if (includeStack) {
-				const duplicateFields = extractDuplicateFields(error);
-				if (duplicateFields && duplicateFields.length > 0) response.details = { duplicateFields };
-			}
-		}
-		if (includeStack && error.stack) response.stack = error.stack;
-		if (statusCode >= 500) request.log.error({
-			err: error,
-			statusCode
-		}, "Server error");
-		else if (statusCode >= 400) request.log.warn({
-			err: error,
-			statusCode
-		}, "Client error");
-		return reply.status(statusCode).send(response);
-	});
-}
-/**
-* Map HTTP status code to error code
-*/
-function statusCodeToCode(statusCode) {
-	return {
-		400: "BAD_REQUEST",
-		401: "UNAUTHORIZED",
-		403: "FORBIDDEN",
-		404: "NOT_FOUND",
-		405: "METHOD_NOT_ALLOWED",
-		409: "CONFLICT",
-		422: "UNPROCESSABLE_ENTITY",
-		429: "RATE_LIMITED",
-		500: "INTERNAL_ERROR",
-		502: "BAD_GATEWAY",
-		503: "SERVICE_UNAVAILABLE",
-		504: "GATEWAY_TIMEOUT"
-	}[statusCode] ?? "ERROR";
-}
-const errorHandlerPlugin = fp(errorHandlerPluginFn, {
-	name: "arc-error-handler",
-	fastify: "5.x"
-});
-//#endregion
-export { errorHandlerPlugin as n, errorHandler_exports as r, defaultIsDuplicateKeyError as t };

package/dist/errorHandler-DEWmGWPz.d.mts

@@ -1,114 +0,0 @@
-import { FastifyInstance, FastifyRequest } from "fastify";
-
-//#region src/plugins/errorHandler.d.ts
-/** Class-based error mapper — maps thrown error instances to HTTP responses */
-interface ErrorMapper<T extends Error = Error> {
-  /**
-   * Error class to match. Checked at runtime via `instanceof` — the constructor
-   * arity/signature is not called by the plugin, so the signature is typed
-   * permissively to accept real-world error classes:
-   *
-   * - **Abstract classes** (e.g. base domain errors) — `abstract new` is accepted.
-   * - **Specific constructor signatures** (e.g. `new InvalidTransitionError(from, to, id?)`)
-   *   — `any[]` avoids forcing consumers to widen to `unknown[]` or cast.
-   *
-   * What matters for dispatch is the `instanceof` check, not the ctor shape.
-   */
-  type: abstract new (...args: any[]) => T;
-  /** Convert the error to an HTTP response shape */
-  toResponse: (error: T) => {
-    status: number;
-    code?: string;
-    message?: string;
-    details?: Record<string, unknown>;
-  };
-}
-interface ErrorHandlerOptions {
-  /**
-   * Include stack trace in error responses (default: false in production)
-   */
-  includeStack?: boolean;
-  /**
-   * Custom error callback for logging to external services
-   */
-  onError?: (error: Error, request: FastifyRequest) => void | Promise<void>;
-  /**
-   * Map specific error types to custom responses (by error.name string)
-   */
-  errorMap?: Record<string, {
-    statusCode: number;
-    code: string;
-    message?: string;
-  }>;
-  /**
-   * Class-based error mappers — checked via `instanceof`, highest priority.
-   *
-   * Register your domain error classes once; Arc auto-catches and maps them
-   * in every handler. Handlers just `throw` — no try/catch needed.
-   *
-   * @example
-   * ```typescript
-   * class AccountingError extends Error {
-   *   constructor(message: string, public status: number, public code: string) {
-   *     super(message);
-   *   }
-   * }
-   *
-   * const app = await createApp({
-   *   errorHandler: {
-   *     errorMappers: [
-   *       {
-   *         type: AccountingError,
-   *         toResponse: (err) => ({ status: err.status, code: err.code, message: err.message }),
-   *       },
-   *     ],
-   *   },
-   * });
-   *
-   * // Now handlers just throw:
-   * handler: async (req) => {
-   *   await ledger.post(id); // throws AccountingError → Arc maps to proper HTTP response
-   * }
-   * ```
-   */
-  errorMappers?: ErrorMapper[];
-  /**
-   * Classify an error as a duplicate-key / unique-constraint violation →
-   * mapped to `409 Conflict` with `code: "DUPLICATE_KEY"`.
-   *
-   * Mirrors `RepositoryLike.isDuplicateKeyError` for the Fastify layer: errors
-   * that escape a controller (custom routes, user hooks, raw driver calls)
-   * still land here, so the classifier is duplicated at the edge. Defaults
-   * cover MongoDB (`code 11000` / `codeName "DuplicateKey"`), Prisma
-   * (`code "P2002"`), and Postgres (`code "23505"`). Override to add other
-   * backends (DynamoDB `ConditionalCheckFailedException`, etc.) or to disable
-   * the built-in detection.
-   */
-  isDuplicateKeyError?: (err: unknown) => boolean;
-}
-/**
- * Default duplicate-key detector covering the mainstream drivers arc sees
- * most. Detection is strictly by known driver codes — never by message
- * string matching — because false positives on dup-key silently mask real
- * errors (WriteConflict, NotWritablePrimary, etc.) as 409s. For long-tail
- * drivers (Neo4j, MSSQL, DynamoDB, custom kits), compose rather than
- * replace:
- *
- * ```ts
- * import { defaultIsDuplicateKeyError } from '@classytic/arc/plugins';
- *
- * errorHandler: {
- *   isDuplicateKeyError: (err) =>
- *     defaultIsDuplicateKeyError(err) || isNeo4jDupKey(err),
- * }
- * ```
- *
- * Drizzle apps get coverage transitively (Drizzle doesn't wrap driver
- * errors — pg/mysql2/better-sqlite3 codes propagate as-is). Neon is
- * Postgres-wire-compatible → `23505` covers `@neondatabase/serverless`.
- */
-declare function defaultIsDuplicateKeyError(err: unknown): boolean;
-declare function errorHandlerPluginFn(fastify: FastifyInstance, options?: ErrorHandlerOptions): Promise<void>;
-declare const errorHandlerPlugin: typeof errorHandlerPluginFn;
-//#endregion
-export { errorHandlerPlugin as i, ErrorMapper as n, defaultIsDuplicateKeyError as r, ErrorHandlerOptions as t };

package/dist/errors-D5c-5BJL.mjs

@@ -1,232 +0,0 @@
-//#region src/utils/errors.ts
-/**
-* Base Arc Error
-*
-* All Arc errors extend this class and produce a consistent error envelope:
-* {
-*   success: false,
-*   error: "Human-readable message",
-*   code: "MACHINE_CODE",
-*   requestId: "uuid",     // For tracing
-*   timestamp: "ISO date", // When error occurred
-*   details: { ... }       // Additional context
-* }
-*/
-var ArcError = class ArcError extends Error {
-	name;
-	code;
-	statusCode;
-	details;
-	cause;
-	timestamp;
-	requestId;
-	constructor(message, options = {}) {
-		super(message, options.cause ? { cause: options.cause } : void 0);
-		this.name = "ArcError";
-		this.code = options.code ?? "ARC_ERROR";
-		this.statusCode = options.statusCode ?? 500;
-		this.details = options.details;
-		this.cause = options.cause;
-		this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		this.requestId = options.requestId;
-		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	}
-	/**
-	* Set request ID (typically from request context)
-	*/
-	withRequestId(requestId) {
-		this.requestId = requestId;
-		return this;
-	}
-	/**
-	* Convert to JSON response.
-	* Includes cause chain when present for debugging visibility.
-	*/
-	toJSON() {
-		return {
-			success: false,
-			error: this.message,
-			code: this.code,
-			timestamp: this.timestamp,
-			...this.requestId && { requestId: this.requestId },
-			...this.details && { details: this.details },
-			...this.cause && { cause: this.cause instanceof ArcError ? this.cause.toJSON() : {
-				message: this.cause.message,
-				name: this.cause.name
-			} }
-		};
-	}
-};
-/**
-* Not Found Error - 404
-*/
-var NotFoundError = class extends ArcError {
-	constructor(resource, identifier) {
-		const message = identifier ? `${resource} with identifier '${identifier}' not found` : `${resource} not found`;
-		super(message, {
-			code: "NOT_FOUND",
-			statusCode: 404,
-			details: {
-				resource,
-				identifier
-			}
-		});
-		this.name = "NotFoundError";
-	}
-};
-/**
-* Validation Error - 400
-*/
-var ValidationError = class extends ArcError {
-	errors;
-	constructor(message, errors = []) {
-		super(message, {
-			code: "VALIDATION_ERROR",
-			statusCode: 400,
-			details: { errors }
-		});
-		this.name = "ValidationError";
-		this.errors = errors;
-	}
-};
-/**
-* Unauthorized Error - 401
-*/
-var UnauthorizedError = class extends ArcError {
-	constructor(message = "Authentication required") {
-		super(message, {
-			code: "UNAUTHORIZED",
-			statusCode: 401
-		});
-		this.name = "UnauthorizedError";
-	}
-};
-/**
-* Forbidden Error - 403
-*/
-var ForbiddenError = class extends ArcError {
-	constructor(message = "Access denied") {
-		super(message, {
-			code: "FORBIDDEN",
-			statusCode: 403
-		});
-		this.name = "ForbiddenError";
-	}
-};
-/**
-* Conflict Error - 409
-*/
-var ConflictError = class extends ArcError {
-	constructor(message, field) {
-		super(message, {
-			code: "CONFLICT",
-			statusCode: 409,
-			details: field ? { field } : void 0
-		});
-		this.name = "ConflictError";
-	}
-};
-/**
-* Organization Required Error - 403
-*/
-var OrgRequiredError = class extends ArcError {
-	organizations;
-	constructor(message, organizations) {
-		super(message, {
-			code: "ORG_SELECTION_REQUIRED",
-			statusCode: 403,
-			details: organizations ? { organizations } : void 0
-		});
-		this.name = "OrgRequiredError";
-		this.organizations = organizations;
-	}
-};
-/**
-* Organization Access Denied Error - 403
-*/
-var OrgAccessDeniedError = class extends ArcError {
-	constructor(orgId) {
-		super("Organization access denied", {
-			code: "ORG_ACCESS_DENIED",
-			statusCode: 403,
-			details: orgId ? { organizationId: orgId } : void 0
-		});
-		this.name = "OrgAccessDeniedError";
-	}
-};
-/**
-* Rate Limit Error - 429
-*/
-var RateLimitError = class extends ArcError {
-	retryAfter;
-	constructor(message = "Too many requests", retryAfter) {
-		super(message, {
-			code: "RATE_LIMITED",
-			statusCode: 429,
-			details: retryAfter ? { retryAfter } : void 0
-		});
-		this.name = "RateLimitError";
-		this.retryAfter = retryAfter;
-	}
-};
-/**
-* Service Unavailable Error - 503
-*/
-var ServiceUnavailableError = class extends ArcError {
-	constructor(message = "Service temporarily unavailable") {
-		super(message, {
-			code: "SERVICE_UNAVAILABLE",
-			statusCode: 503
-		});
-		this.name = "ServiceUnavailableError";
-	}
-};
-/**
-* Create error from status code
-*/
-function createError(statusCode, message, details) {
-	return new ArcError(message, {
-		code: {
-			400: "BAD_REQUEST",
-			401: "UNAUTHORIZED",
-			403: "FORBIDDEN",
-			404: "NOT_FOUND",
-			409: "CONFLICT",
-			429: "RATE_LIMITED",
-			500: "INTERNAL_ERROR",
-			503: "SERVICE_UNAVAILABLE"
-		}[statusCode] ?? "ERROR",
-		statusCode,
-		details
-	});
-}
-/**
-* Create a domain-specific error with automatic HTTP status mapping.
-*
-* Eliminates manual `if (err.code === 'X') return status` boilerplate.
-* Arc's error handler automatically maps `statusCode` to HTTP response.
-*
-* @example
-* ```typescript
-* import { createDomainError } from '@classytic/arc';
-*
-* throw createDomainError('MEMBER_NOT_FOUND', 'Member does not exist', 404);
-* throw createDomainError('SELF_REFERRAL', 'Cannot refer yourself', 422);
-* throw createDomainError('INSUFFICIENT_BALANCE', 'Not enough credits', 402, { balance: 0 });
-* ```
-*/
-function createDomainError(code, message, statusCode = 400, details) {
-	return new ArcError(message, {
-		code,
-		statusCode,
-		details
-	});
-}
-/**
-* Check if error is an Arc error
-*/
-function isArcError(error) {
-	return error instanceof ArcError;
-}
-//#endregion
-export { OrgAccessDeniedError as a, ServiceUnavailableError as c, createDomainError as d, createError as f, NotFoundError as i, UnauthorizedError as l, ConflictError as n, OrgRequiredError as o, isArcError as p, ForbiddenError as r, RateLimitError as s, ArcError as t, ValidationError as u };