1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/*
This file is part of GNU Taler
(C) 2019-2020 Taler Systems SA
GNU Taler is free software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the Free Software
Foundation; either version 3, or (at your option) any later version.
GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
*/
/**
* Classes and helpers for error handling specific to wallet operations.
*
* @author Florian Dold <dold@taler.net>
*/
/**
* Imports.
*/
import { TalerErrorCode, TalerErrorDetails } from "@gnu-taler/taler-util";
/**
* This exception is there to let the caller know that an error happened,
* but the error has already been reported by writing it to the database.
*/
export class OperationFailedAndReportedError extends Error {
static fromCode(
ec: TalerErrorCode,
message: string,
details: Record<string, unknown>,
): OperationFailedAndReportedError {
return new OperationFailedAndReportedError(
makeErrorDetails(ec, message, details),
);
}
constructor(public operationError: TalerErrorDetails) {
super(operationError.message);
// Set the prototype explicitly.
Object.setPrototypeOf(this, OperationFailedAndReportedError.prototype);
}
}
/**
* This exception is thrown when an error occurred and the caller is
* responsible for recording the failure in the database.
*/
export class OperationFailedError extends Error {
static fromCode(
ec: TalerErrorCode,
message: string,
details: Record<string, unknown>,
): OperationFailedError {
return new OperationFailedError(makeErrorDetails(ec, message, details));
}
constructor(public operationError: TalerErrorDetails) {
super(operationError.message);
// Set the prototype explicitly.
Object.setPrototypeOf(this, OperationFailedError.prototype);
}
}
export function makeErrorDetails(
ec: TalerErrorCode,
message: string,
details: Record<string, unknown>,
): TalerErrorDetails {
return {
code: ec,
hint: `Error: ${TalerErrorCode[ec]}`,
details: details,
message,
};
}
/**
* Run an operation and call the onOpError callback
* when there was an exception or operation error that must be reported.
* The cause will be re-thrown to the caller.
*/
export async function guardOperationException<T>(
op: () => Promise<T>,
onOpError: (e: TalerErrorDetails) => Promise<void>,
): Promise<T> {
try {
return await op();
} catch (e) {
if (e instanceof OperationFailedAndReportedError) {
throw e;
}
if (e instanceof OperationFailedError) {
await onOpError(e.operationError);
throw new OperationFailedAndReportedError(e.operationError);
}
if (e instanceof Error) {
const opErr = makeErrorDetails(
TalerErrorCode.WALLET_UNEXPECTED_EXCEPTION,
`unexpected exception (message: ${e.message})`,
{
stack: e.stack,
},
);
await onOpError(opErr);
throw new OperationFailedAndReportedError(opErr);
}
// Something was thrown that is not even an exception!
// Try to stringify it.
let excString: string;
try {
excString = e.toString();
} catch (e) {
// Something went horribly wrong.
excString = "can't stringify exception";
}
const opErr = makeErrorDetails(
TalerErrorCode.WALLET_UNEXPECTED_EXCEPTION,
`unexpected exception (not an exception, ${excString})`,
{},
);
await onOpError(opErr);
throw new OperationFailedAndReportedError(opErr);
}
}
|
