@cullet/erp-core 1.0.0

package/dist/validation-error.js

@@ -0,0 +1,757 @@
+import { c as ErrorCodes, l as serializationErrorCode, o as AppError } from "./validation-code.js";
+//#region src/core/errors/authentication-error.ts
+var AuthenticationError = class AuthenticationError extends AppError {
+	constructor(params) {
+		super(params.message, params.code, {
+			cause: params.cause,
+			metadata: {
+				reason: params.reason,
+				...params.metadata ?? {}
+			},
+			type: params.type,
+			severity: params.severity,
+			correlationId: params.correlationId,
+			requestId: params.requestId,
+			commandId: params.commandId,
+			createdAtIso: params.createdAtIso,
+			publicMessage: params.publicMessage
+		});
+		this.reason = params.reason;
+		Object.freeze(this);
+	}
+	static missingToken(options) {
+		return new AuthenticationError({
+			message: "Missing credentials",
+			code: ErrorCodes.authentication.missingToken,
+			reason: "missing_token",
+			metadata: compactMetadata$1(options),
+			...extractAppErrorOptions$1(options)
+		});
+	}
+	static invalidToken(options) {
+		return new AuthenticationError({
+			message: "Invalid credentials",
+			code: ErrorCodes.authentication.invalidToken,
+			reason: "invalid_token",
+			metadata: compactMetadata$1({
+				authScheme: options?.authScheme,
+				tokenLocation: options?.tokenLocation,
+				details: options?.details,
+				correlationId: options?.correlationId,
+				requestId: options?.requestId
+			}),
+			...extractAppErrorOptions$1(options)
+		});
+	}
+	static expiredToken(options) {
+		return new AuthenticationError({
+			message: "Expired credentials",
+			code: ErrorCodes.authentication.expiredToken,
+			reason: "expired_token",
+			metadata: compactMetadata$1(options),
+			...extractAppErrorOptions$1(options)
+		});
+	}
+	static invalidCredentials(options) {
+		return new AuthenticationError({
+			message: "Invalid username or password",
+			code: ErrorCodes.authentication.invalidCredentials,
+			reason: "invalid_credentials",
+			metadata: compactMetadata$1(options),
+			...extractAppErrorOptions$1(options)
+		});
+	}
+};
+function extractAppErrorOptions$1(options) {
+	return {
+		cause: options?.cause,
+		type: options?.type,
+		severity: options?.severity,
+		correlationId: options?.correlationId,
+		requestId: options?.requestId,
+		commandId: options?.commandId,
+		createdAtIso: options?.createdAtIso,
+		publicMessage: options?.publicMessage
+	};
+}
+function compactMetadata$1(input) {
+	if (!input) return void 0;
+	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+//#endregion
+//#region src/core/errors/authorization-error.ts
+var AuthorizationError = class AuthorizationError extends AppError {
+	constructor(params) {
+		super(params.message, params.code, {
+			cause: params.cause,
+			metadata: params.metadata,
+			type: params.type,
+			severity: params.severity,
+			correlationId: params.correlationId,
+			requestId: params.requestId,
+			commandId: params.commandId,
+			createdAtIso: params.createdAtIso,
+			publicMessage: params.publicMessage
+		});
+		this.reason = params.reason;
+		Object.freeze(this);
+	}
+	static forbidden(input) {
+		return new AuthorizationError({
+			message: "Action not allowed",
+			code: ErrorCodes.authorization.forbidden,
+			reason: "forbidden",
+			metadata: {
+				reason: "forbidden",
+				...extractMetadataOnly(input)
+			},
+			...extractAppErrorOptions(input)
+		});
+	}
+	static policyDenied(input) {
+		return new AuthorizationError({
+			message: "Action denied by policy",
+			code: ErrorCodes.authorization.policyDenied,
+			reason: "policy_denied",
+			metadata: {
+				reason: "policy_denied",
+				...extractMetadataOnly(input),
+				decision: "deny"
+			},
+			...extractAppErrorOptions(input)
+		});
+	}
+	static missingCapability(input) {
+		return new AuthorizationError({
+			message: "Insufficient capability to perform the action",
+			code: ErrorCodes.authorization.missingCapability,
+			reason: "missing_capability",
+			metadata: {
+				reason: "missing_capability",
+				...extractMetadataOnly(input)
+			},
+			...extractAppErrorOptions(input)
+		});
+	}
+	static outOfScope(input) {
+		return new AuthorizationError({
+			message: "Action outside the allowed scope",
+			code: ErrorCodes.authorization.outOfScope,
+			reason: "out_of_scope",
+			metadata: {
+				reason: "out_of_scope",
+				...extractMetadataOnly(input)
+			},
+			...extractAppErrorOptions(input)
+		});
+	}
+};
+function extractAppErrorOptions(options) {
+	return {
+		cause: options?.cause,
+		type: options?.type,
+		severity: options?.severity,
+		correlationId: options?.correlationId,
+		requestId: options?.requestId,
+		commandId: options?.commandId,
+		createdAtIso: options?.createdAtIso,
+		publicMessage: options?.publicMessage
+	};
+}
+function extractMetadataOnly(input) {
+	const { cause, type, severity, correlationId, requestId, commandId, createdAtIso, publicMessage, ...metadata } = input;
+	return metadata;
+}
+//#endregion
+//#region src/core/errors/business-rule-violation-error.ts
+var BusinessRuleViolationError = class extends AppError {
+	constructor(rule, message, detail, options) {
+		const baseMetadata = detail ? {
+			rule,
+			detail
+		} : { rule };
+		const mergedMetadata = options?.metadata ? {
+			...baseMetadata,
+			...options.metadata
+		} : baseMetadata;
+		super(message, ErrorCodes.businessRuleViolation, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+//#region src/core/errors/conflict-error.ts
+var ConflictError = class extends AppError {
+	constructor(params) {
+		super(params.message, params.code, {
+			...params,
+			metadata: {
+				kind: params.kind,
+				...params.metadata
+			}
+		});
+		this.kind = params.kind;
+		Object.freeze(this);
+	}
+};
+var AlreadyExistsError = class AlreadyExistsError extends ConflictError {
+	constructor(input) {
+		super({
+			message: "A matching record already exists for the requested operation",
+			code: ErrorCodes.conflict.alreadyExists,
+			kind: "already_exists",
+			...input
+		});
+	}
+	static detected(input) {
+		return new AlreadyExistsError({
+			metadata: {
+				entity: input.entity,
+				operation: input.operation ?? "create",
+				field: input.field,
+				existingId: input.existingId,
+				valueHash: input.valueHash,
+				valuePreview: input.valuePreview,
+				detectedAtIso: input.detectedAtIso,
+				correlationId: input.correlationId,
+				requestId: input.requestId,
+				commandId: input.commandId,
+				hint: input.hint ?? "Verify existing records before retrying."
+			},
+			cause: input.cause
+		});
+	}
+};
+var DuplicateError = class DuplicateError extends ConflictError {
+	constructor(input) {
+		super({
+			message: "Conflict: an existing record violates uniqueness",
+			code: ErrorCodes.conflict.duplicate,
+			kind: "duplicate",
+			...input
+		});
+	}
+	static detected(input) {
+		return new DuplicateError({
+			metadata: {
+				entity: input.entity,
+				operation: input.operation,
+				field: input.field,
+				constraintName: input.constraintName,
+				existingId: input.existingId,
+				valueHash: input.valueHash,
+				valuePreview: input.valuePreview,
+				detectedAtIso: input.detectedAtIso,
+				correlationId: input.correlationId,
+				requestId: input.requestId,
+				commandId: input.commandId,
+				hint: input.hint ?? "Adjust the data so it does not duplicate existing records."
+			},
+			cause: input.cause
+		});
+	}
+};
+var UniqueConstraintViolationError = class UniqueConstraintViolationError extends ConflictError {
+	constructor(input) {
+		super({
+			message: "Uniqueness violation in storage",
+			code: ErrorCodes.conflict.uniqueViolation,
+			kind: "unique_violation",
+			...input
+		});
+	}
+	static detected(input) {
+		return new UniqueConstraintViolationError({
+			metadata: {
+				entity: input.entity,
+				operation: input.operation,
+				constraintName: input.constraintName,
+				detectedAtIso: input.detectedAtIso,
+				correlationId: input.correlationId,
+				requestId: input.requestId,
+				commandId: input.commandId,
+				violation: {
+					kind: "unique_violation",
+					constraintName: input.constraintName,
+					table: input.table,
+					columns: input.columns
+				},
+				hint: "Uniqueness conflict detected in the database."
+			},
+			cause: input.cause
+		});
+	}
+};
+function translateUniqueViolationToDuplicate(input) {
+	return DuplicateError.detected({
+		entity: input.entity,
+		operation: input.operation,
+		field: input.field,
+		constraintName: input.violation.constraintName,
+		detectedAtIso: input.ctx?.nowIso,
+		correlationId: input.ctx?.correlationId,
+		requestId: input.ctx?.requestId,
+		commandId: input.ctx?.commandId,
+		cause: input.cause
+	});
+}
+//#endregion
+//#region src/core/errors/idempotency-error.ts
+var IdempotencyError = class extends AppError {
+	constructor(input) {
+		super(input.message, input.code, {
+			cause: input.cause,
+			metadata: {
+				kind: input.kind,
+				...input.metadata
+			}
+		});
+		this.kind = input.kind;
+		Object.freeze(this);
+	}
+	static keyMissing(input) {
+		return IdempotencyKeyMissingError.detected(input);
+	}
+	static inProgress(input) {
+		return IdempotencyInProgressError.detected(input);
+	}
+	static payloadMismatch(input) {
+		return IdempotencyPayloadMismatchError.detected(input);
+	}
+	static replayNotSupported(input) {
+		return IdempotencyReplayNotSupportedError.detected(input);
+	}
+};
+var IdempotencyKeyMissingError = class IdempotencyKeyMissingError extends IdempotencyError {
+	constructor(input) {
+		super({
+			message: "Idempotency key/commandId missing for the requested operation",
+			code: ErrorCodes.idempotency.keyMissing,
+			kind: "key_missing",
+			metadata: input.metadata,
+			cause: input.cause
+		});
+	}
+	static detected(input) {
+		return new IdempotencyKeyMissingError({
+			cause: input.cause,
+			metadata: {
+				operation: input.operation,
+				scope: input.scope,
+				entity: input.entity,
+				correlationId: input.correlationId,
+				requestId: input.requestId,
+				commandId: input.commandId,
+				detectedAtIso: input.detectedAtIso,
+				hint: input.hint ?? "Send a commandId/idempotency key to prevent duplicate processing.",
+				details: input.details
+			}
+		});
+	}
+};
+var IdempotencyInProgressError = class IdempotencyInProgressError extends IdempotencyError {
+	constructor(input) {
+		super({
+			message: "The same business intent is already being processed",
+			code: ErrorCodes.idempotency.inProgress,
+			kind: "in_progress",
+			metadata: input.metadata,
+			cause: input.cause
+		});
+	}
+	static detected(input) {
+		const resolved = resolveKeyIdentity(input.key, input.keyHash, input.keyPreview);
+		return new IdempotencyInProgressError({
+			cause: input.cause,
+			metadata: {
+				operation: input.operation,
+				scope: input.scope,
+				entity: input.entity,
+				keyHash: resolved.keyHash,
+				keyPreview: resolved.keyPreview,
+				idempotencyRecordId: input.idempotencyRecordId,
+				correlationId: input.correlationId,
+				requestId: input.requestId,
+				commandId: input.commandId,
+				detectedAtIso: input.detectedAtIso,
+				hint: input.hint ?? "Wait for completion and retry using the same key.",
+				details: input.details
+			}
+		});
+	}
+};
+var IdempotencyPayloadMismatchError = class IdempotencyPayloadMismatchError extends IdempotencyError {
+	constructor(input) {
+		super({
+			message: "The idempotency key was reused with a different payload",
+			code: ErrorCodes.idempotency.payloadMismatch,
+			kind: "payload_mismatch",
+			metadata: input.metadata,
+			cause: input.cause
+		});
+	}
+	static detected(input) {
+		const resolved = resolveKeyIdentity(input.key, input.keyHash, input.keyPreview);
+		return new IdempotencyPayloadMismatchError({
+			cause: input.cause,
+			metadata: {
+				operation: input.operation,
+				scope: input.scope,
+				entity: input.entity,
+				keyHash: resolved.keyHash,
+				keyPreview: resolved.keyPreview,
+				incomingPayloadHash: input.incomingPayloadHash,
+				existingPayloadHash: input.existingPayloadHash,
+				idempotencyRecordId: input.idempotencyRecordId,
+				correlationId: input.correlationId,
+				requestId: input.requestId,
+				commandId: input.commandId,
+				detectedAtIso: input.detectedAtIso,
+				hint: input.hint ?? "Use a new idempotency key for a new intent. The same key should only be reused for retries of the same payload.",
+				details: input.details
+			}
+		});
+	}
+};
+var IdempotencyReplayNotSupportedError = class IdempotencyReplayNotSupportedError extends IdempotencyError {
+	constructor(input) {
+		super({
+			message: "Re-execution detected, but replay of the previous result is not implemented",
+			code: ErrorCodes.idempotency.replayNotSupported,
+			kind: "replay_not_supported",
+			metadata: input.metadata,
+			cause: input.cause
+		});
+	}
+	static detected(input) {
+		const resolved = resolveKeyIdentity(input.key, input.keyHash, input.keyPreview);
+		return new IdempotencyReplayNotSupportedError({
+			cause: input.cause,
+			metadata: {
+				operation: input.operation,
+				scope: input.scope,
+				entity: input.entity,
+				keyHash: resolved.keyHash,
+				keyPreview: resolved.keyPreview,
+				idempotencyRecordId: input.idempotencyRecordId,
+				correlationId: input.correlationId,
+				requestId: input.requestId,
+				commandId: input.commandId,
+				detectedAtIso: input.detectedAtIso,
+				hint: input.hint ?? "Try again later, or enable result replay for full idempotency.",
+				details: input.details
+			}
+		});
+	}
+};
+function resolveKeyIdentity(key, keyHash, keyPreview) {
+	return {
+		keyHash,
+		keyPreview: keyPreview ?? (key ? key.length <= 8 ? key : key.slice(0, 8) : void 0)
+	};
+}
+//#endregion
+//#region src/core/errors/integration-error.ts
+var IntegrationError = class IntegrationError extends AppError {
+	constructor(params) {
+		const { message, code, metadata, ...rest } = params;
+		super(message, code, {
+			...rest,
+			metadata
+		});
+		this.reason = params.reason;
+		Object.freeze(this);
+	}
+	static timeout(options) {
+		return new IntegrationError({
+			message: "Timeout while integrating with external provider",
+			code: ErrorCodes.integration.timeout,
+			reason: "timeout",
+			metadata: buildMetadata({
+				reason: "timeout",
+				...options
+			}),
+			...pickAppErrorFields(options)
+		});
+	}
+	static unreachable(options) {
+		return new IntegrationError({
+			message: "Provider unavailable",
+			code: ErrorCodes.integration.unreachable,
+			reason: "unreachable",
+			metadata: buildMetadata({
+				reason: "unreachable",
+				...options
+			}),
+			...pickAppErrorFields(options)
+		});
+	}
+	static badResponse(options) {
+		return new IntegrationError({
+			message: "Unexpected response from provider",
+			code: ErrorCodes.integration.badResponse,
+			reason: "bad_response",
+			metadata: buildMetadata({
+				reason: "bad_response",
+				...options
+			}),
+			...pickAppErrorFields(options)
+		});
+	}
+};
+function buildMetadata(input) {
+	return compactMetadata({
+		reason: input.reason,
+		provider: input.provider,
+		operation: input.operation,
+		startedAtIso: input.startedAtIso,
+		durationMs: input.durationMs,
+		detectedAtIso: input.detectedAtIso,
+		correlationId: input.correlationId,
+		requestId: input.requestId,
+		commandId: input.commandId,
+		details: input.details,
+		statusCode: input.statusCode,
+		responseCode: input.responseCode
+	});
+}
+function pickAppErrorFields(options) {
+	return {
+		cause: options.cause,
+		type: options.type,
+		severity: options.severity,
+		correlationId: options.correlationId,
+		requestId: options.requestId,
+		commandId: options.commandId,
+		createdAtIso: options.createdAtIso,
+		publicMessage: options.publicMessage
+	};
+}
+function compactMetadata(input) {
+	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+//#endregion
+//#region src/core/errors/legacy-incompatible-error.ts
+var LegacyIncompatibleError = class extends AppError {
+	constructor(message, context, options) {
+		const mergedMetadata = options?.metadata ? {
+			...context ?? {},
+			...options.metadata
+		} : context;
+		super(message, ErrorCodes.legacyIncompatible, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+//#region src/core/errors/not-found-error.ts
+var NotFoundError = class extends AppError {
+	constructor(resource, criteria, options) {
+		const baseMetadata = criteria ? {
+			resource,
+			criteria
+		} : { resource };
+		const mergedMetadata = options?.metadata ? {
+			...baseMetadata,
+			...options.metadata
+		} : baseMetadata;
+		super(`${resource} not found`, ErrorCodes.notFound, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+//#region src/core/errors/serialization-error.ts
+var SerializationError = class extends AppError {
+	constructor(input) {
+		super(input.message ?? "Serialization failure", input.code, {
+			cause: input.cause,
+			metadata: {
+				direction: input.direction,
+				category: input.category,
+				...input.metadata
+			},
+			type: input.type,
+			severity: input.severity,
+			correlationId: input.correlationId,
+			requestId: input.requestId,
+			commandId: input.commandId,
+			createdAtIso: input.createdAtIso,
+			publicMessage: input.publicMessage
+		});
+		this.direction = input.direction;
+		this.category = input.category;
+		this.boundary = input.metadata.boundary;
+		this.contract = input.metadata.contract;
+		Object.freeze(this);
+	}
+};
+var SerializationInError = class SerializationInError extends SerializationError {
+	constructor(input) {
+		super(input);
+	}
+	static failure(category, metadata) {
+		return new SerializationInError({
+			message: SerializationMessages.message("deserialize", category),
+			code: SerializationCodes.code("deserialize", category),
+			category,
+			direction: "deserialize",
+			metadata,
+			cause: metadata.cause
+		});
+	}
+};
+var SerializationOutError = class SerializationOutError extends SerializationError {
+	constructor(input) {
+		super(input);
+	}
+	static failure(category, metadata) {
+		return new SerializationOutError({
+			message: SerializationMessages.message("serialize", category),
+			code: SerializationCodes.code("serialize", category),
+			category,
+			direction: "serialize",
+			metadata,
+			cause: metadata.cause
+		});
+	}
+};
+var SerializationCodes = class {
+	static code(direction, category) {
+		return serializationErrorCode(direction, category);
+	}
+};
+var SerializationMessages = class {
+	static message(direction, category) {
+		if (direction === "deserialize") {
+			if (category === "invalid_json") return "Invalid payload: malformed JSON";
+			if (category === "schema_version_missing") return "Invalid payload: schemaVersion is missing";
+			if (category === "schema_version_unsupported") return "Invalid payload: schemaVersion is not supported";
+			if (category === "invalid_shape") return "Invalid payload: incompatible shape";
+			if (category === "mapping_not_implemented") return "Unsupported payload: mapping not implemented";
+			if (category === "contract_mismatch") return "Payload does not match the expected contract";
+			return "Failed to parse incoming payload";
+		}
+		if (category === "stringify_failed") return "Failed to serialize the response";
+		if (category === "contract_mismatch") return "Response does not match the expected contract";
+		return "Failed to build the response";
+	}
+};
+function safePreview(value, limit = 240) {
+	try {
+		const serialized = typeof value === "string" ? value : JSON.stringify(value);
+		return serialized.length > limit ? `${serialized.slice(0, limit)}…` : serialized;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/core/errors/temporal-error.ts
+var TemporalError = class extends AppError {
+	constructor(input) {
+		super(input.message, input.code, {
+			...input,
+			metadata: {
+				kind: input.kind,
+				...input.metadata
+			}
+		});
+		this.kind = input.kind;
+		this.resourceType = input.metadata.resourceType;
+		this.evaluatedAtIso = input.metadata.evaluatedAtIso;
+		Object.freeze(this);
+	}
+};
+var ExpiredError = class ExpiredError extends TemporalError {
+	constructor(input) {
+		super(input);
+	}
+	static detected(input) {
+		return new ExpiredError({
+			message: "The validity of the resource/action has expired",
+			code: ErrorCodes.temporal.expired,
+			kind: "expired",
+			metadata: {
+				...input,
+				hint: input.hint ?? "The window has expired. Request a new link or try again within the valid period."
+			},
+			cause: input.cause,
+			type: input.type,
+			severity: input.severity,
+			correlationId: input.correlationId,
+			requestId: input.requestId,
+			commandId: input.commandId,
+			createdAtIso: input.createdAtIso,
+			publicMessage: input.publicMessage
+		});
+	}
+};
+var NotYetValidError = class NotYetValidError extends TemporalError {
+	constructor(input) {
+		super(input);
+	}
+	static detected(input) {
+		return new NotYetValidError({
+			message: "The resource/action is not yet valid",
+			code: ErrorCodes.temporal.notYetValid,
+			kind: "not_yet_valid",
+			metadata: {
+				...input,
+				hint: input.hint ?? "Not yet within the valid period. Try again later."
+			},
+			cause: input.cause,
+			type: input.type,
+			severity: input.severity,
+			correlationId: input.correlationId,
+			requestId: input.requestId,
+			commandId: input.commandId,
+			createdAtIso: input.createdAtIso,
+			publicMessage: input.publicMessage
+		});
+	}
+};
+function evaluateTemporalWindow(input) {
+	const evaluatedMs = Date.parse(input.evaluatedAtIso);
+	if (Number.isNaN(evaluatedMs)) return null;
+	let notYetValid = false;
+	if (input.validFromIso) {
+		const fromMs = Date.parse(input.validFromIso);
+		if (!Number.isNaN(fromMs) && evaluatedMs < fromMs) notYetValid = true;
+	}
+	if (input.validUntilIso) {
+		const untilMs = Date.parse(input.validUntilIso);
+		if (!Number.isNaN(untilMs) && evaluatedMs > untilMs) return {
+			expired: true,
+			notYetValid: false
+		};
+	}
+	return {
+		expired: false,
+		notYetValid
+	};
+}
+//#endregion
+//#region src/core/errors/validation-error.ts
+var ValidationError = class extends AppError {
+	constructor(field, code, message, options) {
+		const baseMetadata = {
+			field: field.value,
+			validationCode: code.value
+		};
+		const mergedMetadata = options?.metadata ? {
+			...baseMetadata,
+			...options.metadata
+		} : baseMetadata;
+		super(message, ErrorCodes.validation, {
+			...options,
+			metadata: mergedMetadata
+		});
+	}
+};
+//#endregion
+export { UniqueConstraintViolationError as C, AuthenticationError as D, AuthorizationError as E, DuplicateError as S, BusinessRuleViolationError as T, IdempotencyKeyMissingError as _, evaluateTemporalWindow as a, AlreadyExistsError as b, SerializationInError as c, safePreview as d, NotFoundError as f, IdempotencyInProgressError as g, IdempotencyError as h, TemporalError as i, SerializationMessages as l, IntegrationError as m, ExpiredError as n, SerializationCodes as o, LegacyIncompatibleError as p, NotYetValidError as r, SerializationError as s, ValidationError as t, SerializationOutError as u, IdempotencyPayloadMismatchError as v, translateUniqueViolationToDuplicate as w, ConflictError as x, IdempotencyReplayNotSupportedError as y };
+
+//# sourceMappingURL=validation-error.js.map