@acteo/api 0.0.0-stage → 0.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +34 -0
- package/LICENSE +21 -0
- package/README.md +492 -2
- package/dist/index.cjs +1249 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +1058 -0
- package/dist/index.d.ts +1058 -0
- package/dist/index.js +1211 -0
- package/dist/index.js.map +1 -0
- package/package.json +105 -5
package/dist/index.cjs
ADDED
|
@@ -0,0 +1,1249 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
var effect = require('effect');
|
|
4
|
+
|
|
5
|
+
// src/client.ts
|
|
6
|
+
var VerificRcaError = class extends effect.Data.Error {
|
|
7
|
+
/** Discriminantul erorii. Fiecare subclasa are propria valoare, ex: `"EroareLimita"`. */
|
|
8
|
+
_tag = "VerificRcaError";
|
|
9
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
10
|
+
name = "VerificRcaError";
|
|
11
|
+
};
|
|
12
|
+
var EroareConfigurare = class extends VerificRcaError {
|
|
13
|
+
/** Discriminantul erorii: `"EroareConfigurare"`. Util in `switch (err._tag)`. */
|
|
14
|
+
_tag = "EroareConfigurare";
|
|
15
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
16
|
+
name = "EroareConfigurare";
|
|
17
|
+
};
|
|
18
|
+
var EroareValidare = class extends VerificRcaError {
|
|
19
|
+
/** Discriminantul erorii: `"EroareValidare"`. Util in `switch (err._tag)`. */
|
|
20
|
+
_tag = "EroareValidare";
|
|
21
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
22
|
+
name = "EroareValidare";
|
|
23
|
+
/**
|
|
24
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
25
|
+
*
|
|
26
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
27
|
+
*/
|
|
28
|
+
constructor(args) {
|
|
29
|
+
super(args);
|
|
30
|
+
}
|
|
31
|
+
};
|
|
32
|
+
var EroareAutentificare = class extends VerificRcaError {
|
|
33
|
+
/** Discriminantul erorii: `"EroareAutentificare"`. Util in `switch (err._tag)`. */
|
|
34
|
+
_tag = "EroareAutentificare";
|
|
35
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
36
|
+
name = "EroareAutentificare";
|
|
37
|
+
};
|
|
38
|
+
var EroarePlanInactiv = class extends VerificRcaError {
|
|
39
|
+
/** Discriminantul erorii: `"EroarePlanInactiv"`. Util in `switch (err._tag)`. */
|
|
40
|
+
_tag = "EroarePlanInactiv";
|
|
41
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
42
|
+
name = "EroarePlanInactiv";
|
|
43
|
+
};
|
|
44
|
+
var EroareInterzis = class extends VerificRcaError {
|
|
45
|
+
/** Discriminantul erorii: `"EroareInterzis"`. Util in `switch (err._tag)`. */
|
|
46
|
+
_tag = "EroareInterzis";
|
|
47
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
48
|
+
name = "EroareInterzis";
|
|
49
|
+
/**
|
|
50
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
51
|
+
*
|
|
52
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
53
|
+
*/
|
|
54
|
+
constructor(args) {
|
|
55
|
+
super(args);
|
|
56
|
+
}
|
|
57
|
+
};
|
|
58
|
+
var EroareNegasit = class extends VerificRcaError {
|
|
59
|
+
/** Discriminantul erorii: `"EroareNegasit"`. Util in `switch (err._tag)`. */
|
|
60
|
+
_tag = "EroareNegasit";
|
|
61
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
62
|
+
name = "EroareNegasit";
|
|
63
|
+
};
|
|
64
|
+
var EroareConflict = class extends VerificRcaError {
|
|
65
|
+
/** Discriminantul erorii: `"EroareConflict"`. Util in `switch (err._tag)`. */
|
|
66
|
+
_tag = "EroareConflict";
|
|
67
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
68
|
+
name = "EroareConflict";
|
|
69
|
+
};
|
|
70
|
+
var EroareLimita = class extends VerificRcaError {
|
|
71
|
+
/** Discriminantul erorii: `"EroareLimita"`. Util in `switch (err._tag)`. */
|
|
72
|
+
_tag = "EroareLimita";
|
|
73
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
74
|
+
name = "EroareLimita";
|
|
75
|
+
/**
|
|
76
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
77
|
+
*
|
|
78
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
79
|
+
*/
|
|
80
|
+
constructor(args) {
|
|
81
|
+
super(args);
|
|
82
|
+
}
|
|
83
|
+
};
|
|
84
|
+
var EroareServer = class extends VerificRcaError {
|
|
85
|
+
/** Discriminantul erorii: `"EroareServer"`. Util in `switch (err._tag)`. */
|
|
86
|
+
_tag = "EroareServer";
|
|
87
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
88
|
+
name = "EroareServer";
|
|
89
|
+
};
|
|
90
|
+
var EroareHttp = class extends VerificRcaError {
|
|
91
|
+
/** Discriminantul erorii: `"EroareHttp"`. Util in `switch (err._tag)`. */
|
|
92
|
+
_tag = "EroareHttp";
|
|
93
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
94
|
+
name = "EroareHttp";
|
|
95
|
+
};
|
|
96
|
+
var EroareRetea = class extends VerificRcaError {
|
|
97
|
+
/** Discriminantul erorii: `"EroareRetea"`. Util in `switch (err._tag)`. */
|
|
98
|
+
_tag = "EroareRetea";
|
|
99
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
100
|
+
name = "EroareRetea";
|
|
101
|
+
/**
|
|
102
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
103
|
+
*
|
|
104
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
105
|
+
*/
|
|
106
|
+
constructor(args) {
|
|
107
|
+
super(args);
|
|
108
|
+
}
|
|
109
|
+
};
|
|
110
|
+
var EroareRaspunsInvalid = class extends VerificRcaError {
|
|
111
|
+
/** Discriminantul erorii: `"EroareRaspunsInvalid"`. Util in `switch (err._tag)`. */
|
|
112
|
+
_tag = "EroareRaspunsInvalid";
|
|
113
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
114
|
+
name = "EroareRaspunsInvalid";
|
|
115
|
+
};
|
|
116
|
+
var EroareVerificare = class extends VerificRcaError {
|
|
117
|
+
/** Discriminantul erorii: `"EroareVerificare"`. Util in `switch (err._tag)`. */
|
|
118
|
+
_tag = "EroareVerificare";
|
|
119
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
120
|
+
name = "EroareVerificare";
|
|
121
|
+
/**
|
|
122
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
123
|
+
*
|
|
124
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si `codSursa`.
|
|
125
|
+
*/
|
|
126
|
+
constructor(args) {
|
|
127
|
+
super(args);
|
|
128
|
+
}
|
|
129
|
+
};
|
|
130
|
+
var EroareTimeoutVerificare = class extends VerificRcaError {
|
|
131
|
+
/** Discriminantul erorii: `"EroareTimeoutVerificare"`. Util in `switch (err._tag)`. */
|
|
132
|
+
_tag = "EroareTimeoutVerificare";
|
|
133
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
134
|
+
name = "EroareTimeoutVerificare";
|
|
135
|
+
};
|
|
136
|
+
var EroareWebhook = class extends VerificRcaError {
|
|
137
|
+
/** Discriminantul erorii: `"EroareWebhook"`. Util in `switch (err._tag)`. */
|
|
138
|
+
_tag = "EroareWebhook";
|
|
139
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
140
|
+
name = "EroareWebhook";
|
|
141
|
+
};
|
|
142
|
+
var TipVerificare = effect.Schema.Literal("rca", "itp", "rovinieta", "arr");
|
|
143
|
+
var StatusDocument = effect.Schema.Literal("valid", "warning", "expired", "not_found");
|
|
144
|
+
var DataNullabila = effect.Schema.NullOr(effect.Schema.Date);
|
|
145
|
+
var RezultatVerificareSchema = effect.Schema.Struct({
|
|
146
|
+
/** Tipul verificarii. */
|
|
147
|
+
tip: TipVerificare,
|
|
148
|
+
/** Identificatorul dupa care s-a cautat (la RCA cu VIN, acesta e VIN-ul). */
|
|
149
|
+
query: effect.Schema.String,
|
|
150
|
+
/** Numarul de inmatriculare verificat, `null` cand cautarea s-a facut doar dupa VIN. */
|
|
151
|
+
numarInmatriculare: effect.Schema.NullOr(effect.Schema.String),
|
|
152
|
+
/** Seria de sasiu (VIN) verificata, `null` cand cautarea s-a facut doar dupa numar. */
|
|
153
|
+
serieSasiu: effect.Schema.NullOr(effect.Schema.String),
|
|
154
|
+
/** Cand a fost interogata sursa oficiala. */
|
|
155
|
+
checkedAt: effect.Schema.Date,
|
|
156
|
+
/** Starea documentului. Vezi {@link StatusDocument}. */
|
|
157
|
+
status: StatusDocument,
|
|
158
|
+
/** Data expirarii documentului, `null` daca nu exista document valabil. */
|
|
159
|
+
expiresAt: DataNullabila,
|
|
160
|
+
/** ID-ul cererii, prezent doar cand ai trimis `callbackUrl`. Apare si in webhook. */
|
|
161
|
+
requestId: effect.Schema.optional(effect.Schema.String),
|
|
162
|
+
/** Recomandarea API-ului, ex: la RCA cerut doar dupa numar, sa trimiti si VIN-ul. */
|
|
163
|
+
hint: effect.Schema.optional(effect.Schema.String)
|
|
164
|
+
});
|
|
165
|
+
var InCursSchema = effect.Schema.Struct({
|
|
166
|
+
tip: TipVerificare,
|
|
167
|
+
query: effect.Schema.String,
|
|
168
|
+
status: effect.Schema.Literal("processing"),
|
|
169
|
+
requestId: effect.Schema.optional(effect.Schema.String),
|
|
170
|
+
queuedAt: effect.Schema.optional(effect.Schema.Date),
|
|
171
|
+
pollUrl: effect.Schema.optional(effect.Schema.String),
|
|
172
|
+
hint: effect.Schema.optional(effect.Schema.String)
|
|
173
|
+
});
|
|
174
|
+
var EsuataSchema = effect.Schema.Struct({
|
|
175
|
+
tip: TipVerificare,
|
|
176
|
+
query: effect.Schema.String,
|
|
177
|
+
status: effect.Schema.Literal("error"),
|
|
178
|
+
error: effect.Schema.String,
|
|
179
|
+
/** Doar cand sursa a refuzat datele trimise. Vezi {@link CodRefuzSursa}. */
|
|
180
|
+
cod: effect.Schema.optional(effect.Schema.String),
|
|
181
|
+
hint: effect.Schema.optional(effect.Schema.String)
|
|
182
|
+
});
|
|
183
|
+
var RaspunsVerificareSchema = effect.Schema.Union(RezultatVerificareSchema, InCursSchema, EsuataSchema);
|
|
184
|
+
var CorpEroareSchema = effect.Schema.Struct({
|
|
185
|
+
error: effect.Schema.String,
|
|
186
|
+
hint: effect.Schema.optional(effect.Schema.String),
|
|
187
|
+
accepted: effect.Schema.optional(effect.Schema.Array(effect.Schema.String)),
|
|
188
|
+
code: effect.Schema.optional(effect.Schema.String),
|
|
189
|
+
limita: effect.Schema.optional(effect.Schema.Number),
|
|
190
|
+
dailyUsage: effect.Schema.optional(effect.Schema.String),
|
|
191
|
+
monthlyUsage: effect.Schema.optional(effect.Schema.String)
|
|
192
|
+
});
|
|
193
|
+
var VehiculSchema = effect.Schema.Struct({
|
|
194
|
+
/** ID-ul vehiculului in cont, folosit la stergere. */
|
|
195
|
+
id: effect.Schema.String,
|
|
196
|
+
/** Numarul de inmatriculare, `null` daca vehiculul a fost adaugat doar cu VIN. */
|
|
197
|
+
numarInmatriculare: effect.Schema.NullOr(effect.Schema.String),
|
|
198
|
+
/** Seria de sasiu (VIN), `null` daca vehiculul a fost adaugat doar cu numarul. */
|
|
199
|
+
serieSasiu: effect.Schema.NullOr(effect.Schema.String),
|
|
200
|
+
/** Numarul certificatului de inmatriculare (talon). Fara el rovinieta nu se verifica. */
|
|
201
|
+
serieTalon: effect.Schema.optionalWith(effect.Schema.NullOr(effect.Schema.String), { default: () => null }),
|
|
202
|
+
/** Sursa oficiala a respins numarul talonului; rovinieta nu se mai verifica pana la corectarea lui. */
|
|
203
|
+
serieTalonRespinsa: effect.Schema.optionalWith(effect.Schema.Boolean, { default: () => false }),
|
|
204
|
+
/** Data expirarii RCA, `null` daca nu e cunoscuta inca. */
|
|
205
|
+
rcaExpiraLa: DataNullabila,
|
|
206
|
+
/** Data expirarii ITP, `null` daca nu e cunoscuta inca (ITP-ul cere VIN). */
|
|
207
|
+
itpExpiraLa: DataNullabila,
|
|
208
|
+
/** Data expirarii rovinietei, `null` daca nu e cunoscuta inca (rovinieta cere numar, VIN si numarul talonului). */
|
|
209
|
+
rovinietaExpiraLa: DataNullabila,
|
|
210
|
+
/** Data expirarii copiei conforme ARR. Completata doar cand `arrMonitorizat` e `true`. */
|
|
211
|
+
arrExpiraLa: DataNullabila,
|
|
212
|
+
/** Vehiculul e monitorizat si pentru copia conforma ARR (cere un plan activ). */
|
|
213
|
+
arrMonitorizat: effect.Schema.Boolean,
|
|
214
|
+
/** Cand a fost adaugat vehiculul in cont. */
|
|
215
|
+
createdAt: effect.Schema.Date,
|
|
216
|
+
/** Vehiculul e verificat automat si primeste notificari de expirare. */
|
|
217
|
+
activ: effect.Schema.Boolean
|
|
218
|
+
});
|
|
219
|
+
var ListaVehiculeSchema = effect.Schema.Struct({ vehicule: effect.Schema.Array(VehiculSchema) });
|
|
220
|
+
var VehiculCreatSchema = effect.Schema.Struct({ vehicul: VehiculSchema });
|
|
221
|
+
var StergereSchema = effect.Schema.Struct({ success: effect.Schema.Literal(true) });
|
|
222
|
+
var WebhookRezultatSchema = effect.Schema.Struct({
|
|
223
|
+
/** ID-ul cererii, acelasi cu `requestId` primit de la `porneste()`. */
|
|
224
|
+
requestId: effect.Schema.String,
|
|
225
|
+
/** Tipul verificarii. */
|
|
226
|
+
tip: TipVerificare,
|
|
227
|
+
/** Identificatorul dupa care s-a cautat. */
|
|
228
|
+
query: effect.Schema.String,
|
|
229
|
+
/** Seria de sasiu trimisa in cerere, daca exista. */
|
|
230
|
+
serieSasiu: effect.Schema.NullOr(effect.Schema.String),
|
|
231
|
+
/** Starea documentului sau `"error"` cand sursa oficiala nu a raspuns. */
|
|
232
|
+
status: effect.Schema.Union(StatusDocument, effect.Schema.Literal("error")),
|
|
233
|
+
/** Rezultatul complet, `null` la `status: "error"`. */
|
|
234
|
+
result: effect.Schema.NullOr(RezultatVerificareSchema),
|
|
235
|
+
/** Cand a fost interogata sursa, `null` la eroare. */
|
|
236
|
+
checkedAt: DataNullabila,
|
|
237
|
+
/** Mesajul de eroare, doar la `status: "error"`. */
|
|
238
|
+
error: effect.Schema.optional(effect.Schema.String)
|
|
239
|
+
});
|
|
240
|
+
var WebhookDocumentExpiraSchema = effect.Schema.Struct({
|
|
241
|
+
/** Numele evenimentului. */
|
|
242
|
+
event: effect.Schema.Literal("document.expira"),
|
|
243
|
+
/** ID unic al livrarii. Foloseste-l pentru deduplicare. */
|
|
244
|
+
id: effect.Schema.String,
|
|
245
|
+
/** Vehiculul la care expira documentul. */
|
|
246
|
+
vehicul: effect.Schema.Struct({
|
|
247
|
+
/** ID-ul vehiculului in cont, acelasi ca in `vehicule.lista()`. */
|
|
248
|
+
id: effect.Schema.String,
|
|
249
|
+
/** Numarul de inmatriculare, daca e cunoscut. */
|
|
250
|
+
numarInmatriculare: effect.Schema.NullOr(effect.Schema.String),
|
|
251
|
+
/** Seria de sasiu (VIN), daca e cunoscuta. */
|
|
252
|
+
serieSasiu: effect.Schema.NullOr(effect.Schema.String)
|
|
253
|
+
}),
|
|
254
|
+
/** Documentul care expira. */
|
|
255
|
+
document: TipVerificare,
|
|
256
|
+
/** Data expirarii documentului. */
|
|
257
|
+
expiraLa: effect.Schema.Date,
|
|
258
|
+
/** Zile intregi ramase pana la expirare (minim 0). */
|
|
259
|
+
zileRamase: effect.Schema.Number,
|
|
260
|
+
/** Pragul de notificare atins, in zile (RCA/ITP/rovinieta: 30, 14, 3; ARR: 60, 50, 45). */
|
|
261
|
+
prag: effect.Schema.Number,
|
|
262
|
+
/** Cand a fost trimisa notificarea. */
|
|
263
|
+
trimisLa: effect.Schema.Date
|
|
264
|
+
});
|
|
265
|
+
var WebhookTestSchema = effect.Schema.Struct({
|
|
266
|
+
/** Numele evenimentului. */
|
|
267
|
+
event: effect.Schema.Literal("webhook.test"),
|
|
268
|
+
/** ID unic al testului. */
|
|
269
|
+
id: effect.Schema.String,
|
|
270
|
+
/** Mesajul de confirmare. */
|
|
271
|
+
mesaj: effect.Schema.String,
|
|
272
|
+
/** Cand a fost trimis testul. */
|
|
273
|
+
trimisLa: effect.Schema.Date
|
|
274
|
+
});
|
|
275
|
+
var WebhookNotificareSchema = effect.Schema.Union(WebhookDocumentExpiraSchema, WebhookTestSchema);
|
|
276
|
+
|
|
277
|
+
// src/internal/http.ts
|
|
278
|
+
var Setari = class extends effect.Context.Tag("@verificrca/sdk/Setari")() {
|
|
279
|
+
};
|
|
280
|
+
var CODURI_NEAJUNSE = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN"]);
|
|
281
|
+
function codSistem(err) {
|
|
282
|
+
let curent = err;
|
|
283
|
+
for (let i = 0; i < 4 && curent && typeof curent === "object"; i++) {
|
|
284
|
+
const cod = curent.code;
|
|
285
|
+
if (typeof cod === "string") return cod;
|
|
286
|
+
curent = curent.cause;
|
|
287
|
+
}
|
|
288
|
+
return void 0;
|
|
289
|
+
}
|
|
290
|
+
function mesaj(err) {
|
|
291
|
+
return err instanceof Error ? err.message : String(err);
|
|
292
|
+
}
|
|
293
|
+
function citesteRetryAfter(headers) {
|
|
294
|
+
const valoare = headers.get("retry-after");
|
|
295
|
+
if (!valoare) return void 0;
|
|
296
|
+
const secunde = Number(valoare);
|
|
297
|
+
if (Number.isFinite(secunde)) return Math.max(0, secunde * 1e3);
|
|
298
|
+
const data = Date.parse(valoare);
|
|
299
|
+
return Number.isNaN(data) ? void 0 : Math.max(0, data - Date.now());
|
|
300
|
+
}
|
|
301
|
+
var decodeazaCorpEroare = effect.Schema.decodeUnknownOption(CorpEroareSchema);
|
|
302
|
+
function eroareDinRaspuns(status, headers, body) {
|
|
303
|
+
const corp = decodeazaCorpEroare(body);
|
|
304
|
+
const c = corp._tag === "Some" ? corp.value : void 0;
|
|
305
|
+
const comun = {
|
|
306
|
+
message: c?.error ?? `Cererea a esuat cu HTTP ${status}.`,
|
|
307
|
+
status,
|
|
308
|
+
raspuns: body,
|
|
309
|
+
...c?.hint !== void 0 && { hint: c.hint },
|
|
310
|
+
...c?.code !== void 0 && { cod: c.code }
|
|
311
|
+
};
|
|
312
|
+
switch (status) {
|
|
313
|
+
case 400:
|
|
314
|
+
return new EroareValidare({ ...comun, ...c?.accepted && { acceptate: c.accepted } });
|
|
315
|
+
case 401:
|
|
316
|
+
return new EroareAutentificare(comun);
|
|
317
|
+
case 402:
|
|
318
|
+
return new EroarePlanInactiv(comun);
|
|
319
|
+
case 403:
|
|
320
|
+
return new EroareInterzis({ ...comun, ...c?.limita !== void 0 && { limita: c.limita } });
|
|
321
|
+
case 404:
|
|
322
|
+
return new EroareNegasit(comun);
|
|
323
|
+
case 409:
|
|
324
|
+
return new EroareConflict(comun);
|
|
325
|
+
case 429: {
|
|
326
|
+
const retryAfterMs = citesteRetryAfter(headers);
|
|
327
|
+
const cod = c?.code ?? (c?.dailyUsage || c?.monthlyUsage ? "COTA_ATINSA" : "PREA_MULTE_CERERI");
|
|
328
|
+
return new EroareLimita({
|
|
329
|
+
...comun,
|
|
330
|
+
cod,
|
|
331
|
+
...retryAfterMs !== void 0 && { retryAfterMs },
|
|
332
|
+
...c?.dailyUsage !== void 0 && { utilizareZi: c.dailyUsage },
|
|
333
|
+
...c?.monthlyUsage !== void 0 && { utilizareLuna: c.monthlyUsage }
|
|
334
|
+
});
|
|
335
|
+
}
|
|
336
|
+
default:
|
|
337
|
+
return status >= 500 ? new EroareServer(comun) : new EroareHttp(comun);
|
|
338
|
+
}
|
|
339
|
+
}
|
|
340
|
+
function construiesteUrl(baseUrl, cerere) {
|
|
341
|
+
const url = new URL(baseUrl.replace(/\/+$/, "") + cerere.cale);
|
|
342
|
+
for (const [cheie, valoare] of Object.entries(cerere.query ?? {})) {
|
|
343
|
+
if (valoare !== void 0) url.searchParams.set(cheie, valoare);
|
|
344
|
+
}
|
|
345
|
+
return url.toString();
|
|
346
|
+
}
|
|
347
|
+
var trimiteOData = (cerere) => effect.Effect.gen(function* () {
|
|
348
|
+
const s = yield* Setari;
|
|
349
|
+
const url = construiesteUrl(s.baseUrl, cerere);
|
|
350
|
+
const headers = {
|
|
351
|
+
Authorization: `Bearer ${s.apiKey}`,
|
|
352
|
+
Accept: "application/json",
|
|
353
|
+
"User-Agent": s.userAgent
|
|
354
|
+
};
|
|
355
|
+
if (cerere.body !== void 0) headers["Content-Type"] = "application/json";
|
|
356
|
+
const res = yield* effect.Effect.tryPromise({
|
|
357
|
+
try: (signal) => s.fetch(url, {
|
|
358
|
+
method: cerere.metoda,
|
|
359
|
+
headers,
|
|
360
|
+
signal,
|
|
361
|
+
...cerere.body !== void 0 && { body: JSON.stringify(cerere.body) }
|
|
362
|
+
}),
|
|
363
|
+
catch: (err) => new EroareRetea({
|
|
364
|
+
message: `Cererea ${cerere.metoda} ${cerere.cale} nu a primit raspuns: ${mesaj(err)}`,
|
|
365
|
+
cause: err,
|
|
366
|
+
neajunsa: CODURI_NEAJUNSE.has(codSistem(err) ?? "")
|
|
367
|
+
})
|
|
368
|
+
}).pipe(
|
|
369
|
+
effect.Effect.timeoutFail({
|
|
370
|
+
duration: effect.Duration.millis(s.timeoutMs),
|
|
371
|
+
onTimeout: () => new EroareRetea({
|
|
372
|
+
message: `Cererea ${cerere.metoda} ${cerere.cale} a depasit ${s.timeoutMs} ms.`,
|
|
373
|
+
timeout: true
|
|
374
|
+
})
|
|
375
|
+
})
|
|
376
|
+
);
|
|
377
|
+
const text = yield* effect.Effect.tryPromise({
|
|
378
|
+
try: () => res.text(),
|
|
379
|
+
catch: (err) => new EroareRetea({ message: `Raspunsul la ${cerere.metoda} ${cerere.cale} s-a intrerupt: ${mesaj(err)}`, cause: err })
|
|
380
|
+
});
|
|
381
|
+
let body = null;
|
|
382
|
+
if (text) {
|
|
383
|
+
try {
|
|
384
|
+
body = JSON.parse(text);
|
|
385
|
+
} catch {
|
|
386
|
+
if (res.ok) {
|
|
387
|
+
return yield* effect.Effect.fail(
|
|
388
|
+
new EroareRaspunsInvalid({ message: "API-ul a raspuns cu un corp care nu e JSON.", status: res.status, raspuns: text })
|
|
389
|
+
);
|
|
390
|
+
}
|
|
391
|
+
body = text;
|
|
392
|
+
}
|
|
393
|
+
}
|
|
394
|
+
if (!res.ok) return yield* effect.Effect.fail(eroareDinRaspuns(res.status, res.headers, body));
|
|
395
|
+
return { status: res.status, headers: res.headers, body };
|
|
396
|
+
});
|
|
397
|
+
function sePoateReincerca(cerere, eroare2, retry) {
|
|
398
|
+
switch (eroare2._tag) {
|
|
399
|
+
case "EroareRetea":
|
|
400
|
+
return cerere.idempotenta || eroare2.neajunsa === true;
|
|
401
|
+
case "EroareServer":
|
|
402
|
+
return cerere.idempotenta || eroare2.status === 502 || eroare2.status === 503 || eroare2.status === 504;
|
|
403
|
+
case "EroareLimita":
|
|
404
|
+
return cerere.idempotenta && eroare2.cod === "PREA_MULTE_CERERI" && (eroare2.retryAfterMs ?? 0) <= retry.intarziereMaximaMs;
|
|
405
|
+
default:
|
|
406
|
+
return false;
|
|
407
|
+
}
|
|
408
|
+
}
|
|
409
|
+
function politicaRetry(retry) {
|
|
410
|
+
const backoff = effect.Schedule.exponential(effect.Duration.millis(retry.intarziereInitialaMs), 2).pipe(
|
|
411
|
+
effect.Schedule.jittered,
|
|
412
|
+
effect.Schedule.modifyDelay((_, d) => effect.Duration.min(d, effect.Duration.millis(retry.intarziereMaximaMs))),
|
|
413
|
+
effect.Schedule.intersect(effect.Schedule.recurs(retry.incercari))
|
|
414
|
+
);
|
|
415
|
+
return effect.Schedule.intersect(effect.Schedule.identity(), backoff).pipe(
|
|
416
|
+
effect.Schedule.modifyDelay(
|
|
417
|
+
([eroare2], d) => eroare2._tag === "EroareLimita" && eroare2.retryAfterMs !== void 0 ? effect.Duration.max(d, effect.Duration.millis(eroare2.retryAfterMs)) : d
|
|
418
|
+
)
|
|
419
|
+
);
|
|
420
|
+
}
|
|
421
|
+
var trimite = (cerere) => effect.Effect.gen(function* () {
|
|
422
|
+
const s = yield* Setari;
|
|
423
|
+
if (!s.retry) return yield* trimiteOData(cerere);
|
|
424
|
+
const retry = s.retry;
|
|
425
|
+
return yield* trimiteOData(cerere).pipe(
|
|
426
|
+
effect.Effect.retry({ schedule: politicaRetry(retry), while: (e) => sePoateReincerca(cerere, e, retry) })
|
|
427
|
+
);
|
|
428
|
+
});
|
|
429
|
+
var decodeaza = (schema) => (raspuns) => effect.Schema.decodeUnknown(schema)(raspuns.body).pipe(
|
|
430
|
+
effect.Effect.mapError(
|
|
431
|
+
(err) => new EroareRaspunsInvalid({
|
|
432
|
+
message: `Raspunsul API-ului nu are forma asteptata: ${effect.ParseResult.TreeFormatter.formatErrorSync(err)}`,
|
|
433
|
+
status: raspuns.status,
|
|
434
|
+
raspuns: raspuns.body,
|
|
435
|
+
cause: err
|
|
436
|
+
})
|
|
437
|
+
)
|
|
438
|
+
);
|
|
439
|
+
var JUDETE = "AB|AR|AG|BC|BH|BN|BT|BV|BR|BZ|CS|CL|CJ|CT|CV|DB|DJ|GL|GR|GJ|HD|HR|IL|IS|IF|MM|MH|MS|NT|OT|PH|SM|SJ|SB|SV|TR|TM|TL|VS|VL|VN";
|
|
440
|
+
var NUMAR_REGEX = new RegExp(
|
|
441
|
+
`^(B\\d{2,3}[A-Z]{2,3}|(${JUDETE})\\d{2}[A-Z]{2,3}|CD\\d{3}[A-Z]{1,3}|TC\\d{4}[A-Z]{2})$`,
|
|
442
|
+
"i"
|
|
443
|
+
);
|
|
444
|
+
var VIN_REGEX = /^[A-HJ-NPR-Z0-9]{17}$/i;
|
|
445
|
+
var LUNGIME_VIN = 17;
|
|
446
|
+
var SERIE_TALON_REGEX = /^(?=.*\d)[A-Z0-9]{6,20}$/;
|
|
447
|
+
var TIPURI_VERIFICARE = ["rca", "itp", "rovinieta", "arr"];
|
|
448
|
+
function normalizeaza(valoare) {
|
|
449
|
+
return valoare.trim().toUpperCase().replace(/[\s\-_]/g, "");
|
|
450
|
+
}
|
|
451
|
+
function esteNumarInmatriculareValid(valoare) {
|
|
452
|
+
return NUMAR_REGEX.test(normalizeaza(valoare));
|
|
453
|
+
}
|
|
454
|
+
function esteVinValid(valoare) {
|
|
455
|
+
return VIN_REGEX.test(normalizeaza(valoare));
|
|
456
|
+
}
|
|
457
|
+
function normalizeazaSerieTalon(valoare) {
|
|
458
|
+
return valoare.toUpperCase().replace(/[^A-Z0-9]/g, "");
|
|
459
|
+
}
|
|
460
|
+
function esteSerieTalonValida(valoare) {
|
|
461
|
+
return SERIE_TALON_REGEX.test(normalizeazaSerieTalon(valoare));
|
|
462
|
+
}
|
|
463
|
+
var MESAJ_SERIE_TALON = 'numarul certificatului de inmatriculare, tiparit jos pe talon la "Numarul certificatului" (ex: I00639603F).';
|
|
464
|
+
function explicaVin(valoare) {
|
|
465
|
+
if (!valoare) return "Lipseste seria de sasiu (VIN).";
|
|
466
|
+
if (valoare.length !== LUNGIME_VIN) {
|
|
467
|
+
return `Seria de sasiu are ${valoare.length} caractere, sunt necesare exact ${LUNGIME_VIN}.`;
|
|
468
|
+
}
|
|
469
|
+
return "Seria de sasiu contine caractere neacceptate. Standardul ISO 3779 exclude literele I, O si Q.";
|
|
470
|
+
}
|
|
471
|
+
var eroare = (message, camp, acceptate) => new EroareValidare({ message, camp, cod: "VALIDARE_LOCALA", ...acceptate && { acceptate } });
|
|
472
|
+
function valideazaCallbackUrl(raw) {
|
|
473
|
+
if (raw === void 0 || raw.trim() === "") return effect.Effect.succeed(null);
|
|
474
|
+
const trimis = raw.trim();
|
|
475
|
+
if (trimis.length > 2e3) {
|
|
476
|
+
return effect.Effect.fail(eroare("`callbackUrl` e prea lung (maxim 2000 de caractere).", "callbackUrl"));
|
|
477
|
+
}
|
|
478
|
+
try {
|
|
479
|
+
const url = new URL(trimis);
|
|
480
|
+
if (url.protocol !== "http:" && url.protocol !== "https:") {
|
|
481
|
+
return effect.Effect.fail(eroare("`callbackUrl` trebuie sa foloseasca http sau https.", "callbackUrl"));
|
|
482
|
+
}
|
|
483
|
+
return effect.Effect.succeed(trimis);
|
|
484
|
+
} catch {
|
|
485
|
+
return effect.Effect.fail(eroare("`callbackUrl` trebuie sa fie un URL absolut http(s).", "callbackUrl"));
|
|
486
|
+
}
|
|
487
|
+
}
|
|
488
|
+
function valideazaIdentificatori(tip, query, serieSasiu, serieTalon) {
|
|
489
|
+
if (!query) {
|
|
490
|
+
return effect.Effect.fail(eroare("Lipseste `query` (numar de inmatriculare sau serie de sasiu).", "query"));
|
|
491
|
+
}
|
|
492
|
+
switch (tip) {
|
|
493
|
+
case "rca": {
|
|
494
|
+
if (NUMAR_REGEX.test(query)) {
|
|
495
|
+
if (!serieSasiu) return effect.Effect.succeed({ tip, query, serieSasiu: null, queryPolling: query, serieTalon: null });
|
|
496
|
+
if (!VIN_REGEX.test(serieSasiu)) {
|
|
497
|
+
return effect.Effect.fail(eroare(`\`serieSasiu\` invalid. ${explicaVin(serieSasiu)}`, "serieSasiu"));
|
|
498
|
+
}
|
|
499
|
+
return effect.Effect.succeed({ tip, query, serieSasiu, queryPolling: serieSasiu, serieTalon: null });
|
|
500
|
+
}
|
|
501
|
+
if (VIN_REGEX.test(query)) return effect.Effect.succeed({ tip, query, serieSasiu: null, queryPolling: query, serieTalon: null });
|
|
502
|
+
return effect.Effect.fail(
|
|
503
|
+
eroare(
|
|
504
|
+
`\`query\` invalid: se accepta un numar de inmatriculare romanesc (ex: B123ABC) sau o serie de sasiu de ${LUNGIME_VIN} caractere. ${explicaVin(query)}`,
|
|
505
|
+
"query"
|
|
506
|
+
)
|
|
507
|
+
);
|
|
508
|
+
}
|
|
509
|
+
case "itp": {
|
|
510
|
+
const vin = VIN_REGEX.test(query) ? query : VIN_REGEX.test(serieSasiu) ? serieSasiu : null;
|
|
511
|
+
if (!vin) {
|
|
512
|
+
return effect.Effect.fail(
|
|
513
|
+
eroare(
|
|
514
|
+
`Verificarea ITP cere seria de sasiu (VIN, ${LUNGIME_VIN} caractere). RAR nu cauta dupa numarul de inmatriculare. ${explicaVin(serieSasiu || query)}`,
|
|
515
|
+
"query"
|
|
516
|
+
)
|
|
517
|
+
);
|
|
518
|
+
}
|
|
519
|
+
return effect.Effect.succeed({ tip, query, serieSasiu: serieSasiu || null, queryPolling: vin, serieTalon: null });
|
|
520
|
+
}
|
|
521
|
+
case "arr": {
|
|
522
|
+
if (!NUMAR_REGEX.test(query)) {
|
|
523
|
+
return effect.Effect.fail(
|
|
524
|
+
eroare("Verificarea ARR cere numarul de inmatriculare in `query` (ex: B123ABC). ARR nu cauta dupa VIN.", "query")
|
|
525
|
+
);
|
|
526
|
+
}
|
|
527
|
+
return effect.Effect.succeed({ tip, query, serieSasiu: null, queryPolling: query, serieTalon: null });
|
|
528
|
+
}
|
|
529
|
+
case "rovinieta": {
|
|
530
|
+
if (!NUMAR_REGEX.test(query)) {
|
|
531
|
+
return effect.Effect.fail(
|
|
532
|
+
eroare("Verificarea rovinietei cere numarul de inmatriculare in `query` (ex: B123ABC).", "query")
|
|
533
|
+
);
|
|
534
|
+
}
|
|
535
|
+
if (!VIN_REGEX.test(serieSasiu)) {
|
|
536
|
+
return effect.Effect.fail(
|
|
537
|
+
eroare(`Verificarea rovinietei cere si seria de sasiu in \`serieSasiu\`. ${explicaVin(serieSasiu)}`, "serieSasiu")
|
|
538
|
+
);
|
|
539
|
+
}
|
|
540
|
+
if (!serieTalon) {
|
|
541
|
+
return effect.Effect.fail(
|
|
542
|
+
eroare(`Verificarea rovinietei cere si \`serieTalon\`: ${MESAJ_SERIE_TALON}`, "serieTalon")
|
|
543
|
+
);
|
|
544
|
+
}
|
|
545
|
+
if (!SERIE_TALON_REGEX.test(serieTalon)) {
|
|
546
|
+
return effect.Effect.fail(eroare(`\`serieTalon\` invalid: se asteapta ${MESAJ_SERIE_TALON}`, "serieTalon"));
|
|
547
|
+
}
|
|
548
|
+
return effect.Effect.succeed({ tip, query, serieSasiu, queryPolling: query, serieTalon });
|
|
549
|
+
}
|
|
550
|
+
}
|
|
551
|
+
}
|
|
552
|
+
function valideazaCerereVerificare(cerere) {
|
|
553
|
+
const tip = typeof cerere.tip === "string" ? cerere.tip.toLowerCase() : cerere.tip;
|
|
554
|
+
if (!TIPURI_VERIFICARE.includes(tip)) {
|
|
555
|
+
return effect.Effect.fail(eroare("`tip` invalid.", "tip", TIPURI_VERIFICARE));
|
|
556
|
+
}
|
|
557
|
+
const query = typeof cerere.query === "string" ? normalizeaza(cerere.query) : "";
|
|
558
|
+
const serieSasiu = typeof cerere.serieSasiu === "string" ? normalizeaza(cerere.serieSasiu) : "";
|
|
559
|
+
const serieTalon = typeof cerere.serieTalon === "string" ? normalizeazaSerieTalon(cerere.serieTalon) : "";
|
|
560
|
+
return effect.Effect.all({
|
|
561
|
+
tinta: valideazaIdentificatori(tip, query, serieSasiu, serieTalon),
|
|
562
|
+
callbackUrl: valideazaCallbackUrl(cerere.callbackUrl)
|
|
563
|
+
}).pipe(effect.Effect.map(({ tinta, callbackUrl }) => ({ ...tinta, callbackUrl })));
|
|
564
|
+
}
|
|
565
|
+
function valideazaVehiculNou(vehicul) {
|
|
566
|
+
const numar = vehicul.numarInmatriculare?.trim() ?? "";
|
|
567
|
+
const serie = vehicul.serieSasiu?.trim() ?? "";
|
|
568
|
+
if (numar && (numar.length > 20 || !/^[A-Z0-9\s-]*$/i.test(numar))) {
|
|
569
|
+
return effect.Effect.fail(eroare("`numarInmatriculare` poate contine doar litere, cifre, spatii si cratime (maxim 20).", "numarInmatriculare"));
|
|
570
|
+
}
|
|
571
|
+
if (serie && (serie.length > 50 || !/^[A-Z0-9]*$/i.test(serie))) {
|
|
572
|
+
return effect.Effect.fail(eroare("`serieSasiu` poate contine doar litere si cifre (maxim 50).", "serieSasiu"));
|
|
573
|
+
}
|
|
574
|
+
const serieTalon = vehicul.serieTalon === void 0 ? "" : normalizeazaSerieTalon(vehicul.serieTalon);
|
|
575
|
+
if (serieTalon && !SERIE_TALON_REGEX.test(serieTalon)) {
|
|
576
|
+
return effect.Effect.fail(eroare(`\`serieTalon\` invalid: se asteapta ${MESAJ_SERIE_TALON}`, "serieTalon"));
|
|
577
|
+
}
|
|
578
|
+
const numarNormalizat = numar.toUpperCase().replace(/[\s-]+/g, "");
|
|
579
|
+
const serieNormalizata = serie.toUpperCase();
|
|
580
|
+
if (!numarNormalizat && !serieNormalizata) {
|
|
581
|
+
return effect.Effect.fail(eroare("Trimite numarul de inmatriculare sau seria de sasiu.", "numarInmatriculare"));
|
|
582
|
+
}
|
|
583
|
+
return effect.Effect.succeed({
|
|
584
|
+
...numarNormalizat && { numarInmatriculare: numarNormalizat },
|
|
585
|
+
...serieNormalizata && { serieSasiu: serieNormalizata },
|
|
586
|
+
...serieTalon && { serieTalon },
|
|
587
|
+
...vehicul.arrMonitorizat !== void 0 && { arrMonitorizat: vehicul.arrMonitorizat }
|
|
588
|
+
});
|
|
589
|
+
}
|
|
590
|
+
|
|
591
|
+
// src/internal/verificari.ts
|
|
592
|
+
var CALE = "/api/public/v1/verificare";
|
|
593
|
+
var INTERVAL_IMPLICIT_MS = 3e3;
|
|
594
|
+
var INTERVAL_MINIM_MS = 2e3;
|
|
595
|
+
var TIMEOUT_IMPLICIT_MS = 5 * 6e4;
|
|
596
|
+
function limiteDin(raspuns) {
|
|
597
|
+
const h = raspuns.headers;
|
|
598
|
+
const numar = (nume) => {
|
|
599
|
+
const v = h.get(nume);
|
|
600
|
+
return v === null ? NaN : Number(v);
|
|
601
|
+
};
|
|
602
|
+
const valori = [
|
|
603
|
+
numar("x-ratelimit-limit-day"),
|
|
604
|
+
numar("x-ratelimit-remaining-day"),
|
|
605
|
+
numar("x-ratelimit-limit-month"),
|
|
606
|
+
numar("x-ratelimit-remaining-month")
|
|
607
|
+
];
|
|
608
|
+
if (!valori.every(Number.isFinite)) return void 0;
|
|
609
|
+
return {
|
|
610
|
+
zi: { limita: valori[0], ramase: valori[1] },
|
|
611
|
+
luna: { limita: valori[2], ramase: valori[3] }
|
|
612
|
+
};
|
|
613
|
+
}
|
|
614
|
+
function sinceDinPollUrl(pollUrl) {
|
|
615
|
+
if (!pollUrl) return void 0;
|
|
616
|
+
const intrebare = pollUrl.indexOf("?");
|
|
617
|
+
if (intrebare === -1) return void 0;
|
|
618
|
+
const since = Number(new URLSearchParams(pollUrl.slice(intrebare + 1)).get("since"));
|
|
619
|
+
return Number.isFinite(since) && since > 0 ? since : void 0;
|
|
620
|
+
}
|
|
621
|
+
var interpreteaza = (raspuns, serieSasiu, sinceImplicit) => decodeaza(RaspunsVerificareSchema)(raspuns).pipe(
|
|
622
|
+
effect.Effect.flatMap((corp) => {
|
|
623
|
+
const limite = limiteDin(raspuns);
|
|
624
|
+
if (corp.status === "error") {
|
|
625
|
+
return effect.Effect.fail(
|
|
626
|
+
new EroareVerificare({
|
|
627
|
+
message: corp.error,
|
|
628
|
+
cod: "VERIFICARE_ESUATA",
|
|
629
|
+
raspuns: corp,
|
|
630
|
+
...corp.cod && { codSursa: corp.cod },
|
|
631
|
+
...corp.hint && { hint: corp.hint }
|
|
632
|
+
})
|
|
633
|
+
);
|
|
634
|
+
}
|
|
635
|
+
if (corp.status === "processing") {
|
|
636
|
+
const since = sinceDinPollUrl(corp.pollUrl) ?? sinceImplicit ?? Date.now();
|
|
637
|
+
return effect.Effect.succeed({
|
|
638
|
+
status: "processing",
|
|
639
|
+
tip: corp.tip,
|
|
640
|
+
query: corp.query,
|
|
641
|
+
serieSasiu: corp.tip === "rovinieta" ? serieSasiu : null,
|
|
642
|
+
since,
|
|
643
|
+
...corp.requestId !== void 0 && { requestId: corp.requestId },
|
|
644
|
+
...corp.queuedAt !== void 0 && { queuedAt: corp.queuedAt },
|
|
645
|
+
...corp.hint !== void 0 && { hint: corp.hint },
|
|
646
|
+
...limite && { limite }
|
|
647
|
+
});
|
|
648
|
+
}
|
|
649
|
+
return effect.Effect.succeed({ ...corp, ...limite && { limite } });
|
|
650
|
+
})
|
|
651
|
+
);
|
|
652
|
+
var porneste = (cerere) => effect.Effect.gen(function* () {
|
|
653
|
+
const tinta = yield* valideazaCerereVerificare(cerere);
|
|
654
|
+
const inainte = Date.now();
|
|
655
|
+
const raspuns = yield* trimite({
|
|
656
|
+
metoda: "POST",
|
|
657
|
+
cale: CALE,
|
|
658
|
+
idempotenta: false,
|
|
659
|
+
body: {
|
|
660
|
+
tip: tinta.tip,
|
|
661
|
+
query: tinta.query,
|
|
662
|
+
...tinta.serieSasiu && { serieSasiu: tinta.serieSasiu },
|
|
663
|
+
...tinta.serieTalon && { serieTalon: tinta.serieTalon },
|
|
664
|
+
...tinta.callbackUrl && { callbackUrl: tinta.callbackUrl }
|
|
665
|
+
}
|
|
666
|
+
});
|
|
667
|
+
return yield* interpreteaza(raspuns, tinta.serieSasiu, inainte);
|
|
668
|
+
});
|
|
669
|
+
var rezultat = (ref) => effect.Effect.gen(function* () {
|
|
670
|
+
const raspuns = yield* trimite({
|
|
671
|
+
metoda: "GET",
|
|
672
|
+
cale: CALE,
|
|
673
|
+
idempotenta: true,
|
|
674
|
+
query: {
|
|
675
|
+
tip: ref.tip,
|
|
676
|
+
query: ref.query,
|
|
677
|
+
serieSasiu: ref.tip === "rovinieta" && ref.serieSasiu ? ref.serieSasiu : void 0,
|
|
678
|
+
since: ref.since !== void 0 ? String(ref.since) : void 0
|
|
679
|
+
}
|
|
680
|
+
});
|
|
681
|
+
return yield* interpreteaza(raspuns, ref.serieSasiu ?? null, ref.since);
|
|
682
|
+
});
|
|
683
|
+
var asteapta = (ref, optiuni = {}) => {
|
|
684
|
+
const intervalMs = Math.max(INTERVAL_MINIM_MS, optiuni.intervalMs ?? INTERVAL_IMPLICIT_MS);
|
|
685
|
+
const timeoutMs = optiuni.timeoutMs ?? TIMEOUT_IMPLICIT_MS;
|
|
686
|
+
return rezultat(ref).pipe(
|
|
687
|
+
effect.Effect.delay(effect.Duration.millis(intervalMs)),
|
|
688
|
+
// recurWhile intoarce ultimul raspuns, deci repeat-ul iese cu rezultatul final.
|
|
689
|
+
effect.Effect.repeat(
|
|
690
|
+
effect.Schedule.recurWhile((r) => r.status === "processing").pipe(
|
|
691
|
+
effect.Schedule.addDelay(() => effect.Duration.millis(intervalMs))
|
|
692
|
+
)
|
|
693
|
+
),
|
|
694
|
+
effect.Effect.flatMap(
|
|
695
|
+
(r) => r.status === "processing" ? effect.Effect.fail(new EroareTimeoutVerificare({ message: "Verificarea nu s-a finalizat." })) : effect.Effect.succeed(r)
|
|
696
|
+
),
|
|
697
|
+
effect.Effect.timeoutFail({
|
|
698
|
+
duration: effect.Duration.millis(timeoutMs),
|
|
699
|
+
onTimeout: () => new EroareTimeoutVerificare({
|
|
700
|
+
message: `Verificarea ${ref.tip} pentru ${ref.query} nu s-a finalizat in ${Math.round(timeoutMs / 1e3)} secunde.`,
|
|
701
|
+
cod: "TIMEOUT_VERIFICARE"
|
|
702
|
+
})
|
|
703
|
+
})
|
|
704
|
+
);
|
|
705
|
+
};
|
|
706
|
+
var verificaSiAsteapta = (cerere, optiuni = {}) => porneste(cerere).pipe(
|
|
707
|
+
effect.Effect.flatMap((r) => r.status === "processing" ? asteapta(r, optiuni) : effect.Effect.succeed(r))
|
|
708
|
+
);
|
|
709
|
+
var CALE2 = "/api/public/v1/vehicule";
|
|
710
|
+
var lista = () => trimite({ metoda: "GET", cale: CALE2, idempotenta: true }).pipe(
|
|
711
|
+
effect.Effect.flatMap(decodeaza(ListaVehiculeSchema)),
|
|
712
|
+
effect.Effect.map((r) => r.vehicule)
|
|
713
|
+
);
|
|
714
|
+
var adauga = (vehicul) => valideazaVehiculNou(vehicul).pipe(
|
|
715
|
+
effect.Effect.flatMap((body) => trimite({ metoda: "POST", cale: CALE2, idempotenta: false, body })),
|
|
716
|
+
effect.Effect.flatMap(decodeaza(VehiculCreatSchema)),
|
|
717
|
+
effect.Effect.map((r) => r.vehicul)
|
|
718
|
+
);
|
|
719
|
+
var sterge = (id) => id.trim() ? trimite({ metoda: "DELETE", cale: `${CALE2}/${encodeURIComponent(id.trim())}`, idempotenta: true }).pipe(
|
|
720
|
+
effect.Effect.flatMap(decodeaza(StergereSchema)),
|
|
721
|
+
effect.Effect.asVoid
|
|
722
|
+
) : effect.Effect.fail(new EroareValidare({ message: "Lipseste ID-ul vehiculului.", camp: "id", cod: "VALIDARE_LOCALA" }));
|
|
723
|
+
|
|
724
|
+
// src/client.ts
|
|
725
|
+
var VERSIUNE_SDK = "0.3.0";
|
|
726
|
+
var URL_IMPLICIT = "https://api.acteo.ro";
|
|
727
|
+
var URL_IMPLICIT_LEGACY = "https://www.verificrca.ro";
|
|
728
|
+
var RETRY_IMPLICIT = { incercari: 3, intarziereInitialaMs: 500, intarziereMaximaMs: 1e4 };
|
|
729
|
+
function citesteEnv(nume) {
|
|
730
|
+
const proces = globalThis.process;
|
|
731
|
+
return proces?.env?.[nume];
|
|
732
|
+
}
|
|
733
|
+
var PROFIL_ACTEO = {
|
|
734
|
+
urlImplicit: URL_IMPLICIT,
|
|
735
|
+
variabileCheie: ["ACTEO_API_KEY", "VERIFICRCA_API_KEY"],
|
|
736
|
+
agent: "acteo-sdk-js",
|
|
737
|
+
undeCheie: "https://app.acteo.ro/api/chei"
|
|
738
|
+
};
|
|
739
|
+
var PROFIL_LEGACY = {
|
|
740
|
+
urlImplicit: URL_IMPLICIT_LEGACY,
|
|
741
|
+
variabileCheie: ["VERIFICRCA_API_KEY"],
|
|
742
|
+
agent: "verificrca-sdk-js",
|
|
743
|
+
undeCheie: "https://www.verificrca.ro/dashboard/api"
|
|
744
|
+
};
|
|
745
|
+
function construiesteSetari(optiuni, profil) {
|
|
746
|
+
const dinEnv = profil.variabileCheie.map(citesteEnv).find((v) => v?.trim());
|
|
747
|
+
const apiKey = (optiuni.apiKey ?? dinEnv ?? "").trim();
|
|
748
|
+
if (!apiKey) {
|
|
749
|
+
throw new EroareConfigurare({
|
|
750
|
+
message: `Lipseste cheia API. Trimite \`apiKey\` sau seteaza variabila de mediu ${profil.variabileCheie[0]}.`,
|
|
751
|
+
hint: `Cheia se genereaza din ${profil.undeCheie}`
|
|
752
|
+
});
|
|
753
|
+
}
|
|
754
|
+
if (apiKey.length < 16 || apiKey.length > 128) {
|
|
755
|
+
throw new EroareConfigurare({ message: "Cheia API are un format invalid (intre 16 si 128 de caractere)." });
|
|
756
|
+
}
|
|
757
|
+
const baseUrl = optiuni.baseUrl ?? profil.urlImplicit;
|
|
758
|
+
try {
|
|
759
|
+
new URL(baseUrl);
|
|
760
|
+
} catch {
|
|
761
|
+
throw new EroareConfigurare({ message: `\`baseUrl\` invalid: ${baseUrl}` });
|
|
762
|
+
}
|
|
763
|
+
const fetchImpl = optiuni.fetch ?? globalThis.fetch;
|
|
764
|
+
if (typeof fetchImpl !== "function") {
|
|
765
|
+
throw new EroareConfigurare({ message: "`fetch` nu exista in acest mediu. Foloseste Node.js 18+ sau trimite optiunea `fetch`." });
|
|
766
|
+
}
|
|
767
|
+
const timeoutMs = optiuni.timeoutMs ?? 3e4;
|
|
768
|
+
if (!(timeoutMs > 0)) throw new EroareConfigurare({ message: "`timeoutMs` trebuie sa fie pozitiv." });
|
|
769
|
+
return {
|
|
770
|
+
apiKey,
|
|
771
|
+
baseUrl,
|
|
772
|
+
timeoutMs,
|
|
773
|
+
retry: optiuni.retry === false ? null : { ...RETRY_IMPLICIT, ...optiuni.retry },
|
|
774
|
+
fetch: fetchImpl,
|
|
775
|
+
userAgent: `${profil.agent}/${VERSIUNE_SDK}${optiuni.userAgent ? ` ${optiuni.userAgent}` : ""}`
|
|
776
|
+
};
|
|
777
|
+
}
|
|
778
|
+
function creeazaRulare(optiuni, profil) {
|
|
779
|
+
const setari = construiesteSetari(optiuni, profil);
|
|
780
|
+
return (efect, opt) => effect.Effect.runPromiseExit(
|
|
781
|
+
effect.Effect.provideService(efect, Setari, setari),
|
|
782
|
+
opt?.signal ? { signal: opt.signal } : void 0
|
|
783
|
+
).then((exit) => {
|
|
784
|
+
if (effect.Exit.isSuccess(exit)) return exit.value;
|
|
785
|
+
if (effect.Cause.isInterruptedOnly(exit.cause)) {
|
|
786
|
+
throw new VerificRcaError({ message: "Cererea a fost anulata.", cod: "ANULATA" });
|
|
787
|
+
}
|
|
788
|
+
throw effect.Cause.squash(exit.cause);
|
|
789
|
+
});
|
|
790
|
+
}
|
|
791
|
+
var ClientVerificari = class {
|
|
792
|
+
#ruleaza;
|
|
793
|
+
/** @internal */
|
|
794
|
+
constructor(ruleaza2) {
|
|
795
|
+
this.#ruleaza = ruleaza2;
|
|
796
|
+
}
|
|
797
|
+
/**
|
|
798
|
+
* Porneste o verificare si consuma o unitate din cota planului.
|
|
799
|
+
*
|
|
800
|
+
* Daca vehiculul a fost verificat de curand, primesti imediat rezultatul
|
|
801
|
+
* existent. Altfel verificarea intra in
|
|
802
|
+
* coada si primesti `status: "processing"`; rezultatul il afli cu
|
|
803
|
+
* {@link ClientVerificari.rezultat}, {@link ClientVerificari.asteapta} sau
|
|
804
|
+
* prin webhook, daca ai trimis `callbackUrl`.
|
|
805
|
+
*
|
|
806
|
+
* Datele sunt validate local inainte de cerere: o greseala de tastare nu
|
|
807
|
+
* pleaca pe retea si nu consuma din cota.
|
|
808
|
+
*
|
|
809
|
+
* @param cerere tipul verificarii, identificatorul, VIN-ul (obligatoriu la rovinieta,
|
|
810
|
+
* impreuna cu `serieTalon`) si, optional, `callbackUrl`.
|
|
811
|
+
* @param optiuni `signal` pentru anulare.
|
|
812
|
+
* @returns rezultatul final sau o {@link VerificareInCurs}.
|
|
813
|
+
* @throws {@link EroareValidare} date invalide, local sau HTTP 400.
|
|
814
|
+
* @throws {@link EroareAutentificare} cheie API invalida (401).
|
|
815
|
+
* @throws {@link EroarePlanInactiv} contul nu are abonament API activ (402).
|
|
816
|
+
* @throws {@link EroareLimita} cota zilnica sau lunara atinsa (429, `cod: "COTA_ATINSA"`).
|
|
817
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a
|
|
818
|
+
* refuzat datele trimise (`codSursa`, ex: `"serie_talon_invalida"`).
|
|
819
|
+
* @throws {@link EroareRetea} fara raspuns sau timeout.
|
|
820
|
+
* @throws {@link EroareServer} eroare 5xx.
|
|
821
|
+
* @example
|
|
822
|
+
* const r = await vrca.verificari.porneste({ tip: "itp", query: "WVWZZZ1JZXW000001" })
|
|
823
|
+
* if (r.status === "processing") {
|
|
824
|
+
* const final = await vrca.verificari.asteapta(r)
|
|
825
|
+
* }
|
|
826
|
+
*/
|
|
827
|
+
porneste(cerere, optiuni) {
|
|
828
|
+
return this.#ruleaza(porneste(cerere), optiuni);
|
|
829
|
+
}
|
|
830
|
+
/**
|
|
831
|
+
* Interogheaza o singura data rezultatul unei verificari. Nu consuma din cota.
|
|
832
|
+
*
|
|
833
|
+
* Serverul accepta cel mult o interogare la 2 secunde pentru aceeasi
|
|
834
|
+
* verificare; la depasire, SDK-ul asteapta cat cere `Retry-After` si reincearca.
|
|
835
|
+
*
|
|
836
|
+
* @param referinta obiectul primit de la `porneste()` sau `{ tip, query, serieSasiu?, since? }`.
|
|
837
|
+
* @param optiuni `signal` pentru anulare.
|
|
838
|
+
* @returns rezultatul final sau, daca sursa nu a raspuns inca, o {@link VerificareInCurs}.
|
|
839
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata; reia cu `porneste()`.
|
|
840
|
+
* @throws {@link EroareValidare} referinta invalida (400).
|
|
841
|
+
* @throws {@link EroareAutentificare} cheie API invalida (401).
|
|
842
|
+
* @throws {@link EroareRetea} fara raspuns sau timeout, dupa reincercari.
|
|
843
|
+
* @example
|
|
844
|
+
* const r = await vrca.verificari.rezultat({ tip: "rca", query: "B123ABC" })
|
|
845
|
+
* if (r.status !== "processing") console.log(r.status, r.expiresAt)
|
|
846
|
+
*/
|
|
847
|
+
rezultat(referinta, optiuni) {
|
|
848
|
+
return this.#ruleaza(rezultat(referinta), optiuni);
|
|
849
|
+
}
|
|
850
|
+
/**
|
|
851
|
+
* Interogheaza periodic pana la rezultatul final. Nu consuma din cota.
|
|
852
|
+
*
|
|
853
|
+
* @param referinta obiectul primit de la `porneste()` sau `{ tip, query, serieSasiu?, since? }`.
|
|
854
|
+
* @param optiuni `intervalMs` (implicit 3000, minim 2000), `timeoutMs` (implicit 5 minute) si `signal`.
|
|
855
|
+
* @returns rezultatul final al verificarii.
|
|
856
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
857
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata; reia cu `porneste()`.
|
|
858
|
+
* @throws {@link EroareRetea} fara raspuns, dupa reincercari.
|
|
859
|
+
* @example
|
|
860
|
+
* const r = await vrca.verificari.porneste({ tip: "arr", query: "CJ45XYZ" })
|
|
861
|
+
* const final = r.status === "processing" ? await vrca.verificari.asteapta(r, { intervalMs: 5000 }) : r
|
|
862
|
+
*/
|
|
863
|
+
asteapta(referinta, optiuni) {
|
|
864
|
+
return this.#ruleaza(asteapta(referinta, optiuni), optiuni);
|
|
865
|
+
}
|
|
866
|
+
/**
|
|
867
|
+
* Porneste verificarea si asteapta rezultatul final, intr-un singur apel.
|
|
868
|
+
* Consuma o unitate din cota (doar pornirea; pollingul e gratuit).
|
|
869
|
+
*
|
|
870
|
+
* @param cerere tipul verificarii, identificatorul, VIN-ul (obligatoriu la rovinieta,
|
|
871
|
+
* impreuna cu `serieTalon`) si, optional, `callbackUrl`.
|
|
872
|
+
* @param optiuni `intervalMs`, `timeoutMs` si `signal`, ca la {@link ClientVerificari.asteapta}.
|
|
873
|
+
* @returns rezultatul final al verificarii.
|
|
874
|
+
* @throws {@link EroareValidare} date invalide, local sau HTTP 400.
|
|
875
|
+
* @throws {@link EroareLimita} cota atinsa (`cod: "COTA_ATINSA"`).
|
|
876
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
877
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a
|
|
878
|
+
* refuzat datele trimise (`codSursa`, ex: `"serie_talon_invalida"`).
|
|
879
|
+
* @throws {@link VerificRcaError} orice alta eroare de la API sau de retea.
|
|
880
|
+
* @example
|
|
881
|
+
* const rovinieta = await vrca.verificari.verificaSiAsteapta({
|
|
882
|
+
* tip: "rovinieta",
|
|
883
|
+
* query: "B123ABC",
|
|
884
|
+
* serieSasiu: "WVWZZZ1JZXW000001",
|
|
885
|
+
* serieTalon: "I00639603F",
|
|
886
|
+
* })
|
|
887
|
+
* console.log(rovinieta.status, rovinieta.expiresAt)
|
|
888
|
+
*/
|
|
889
|
+
verificaSiAsteapta(cerere, optiuni) {
|
|
890
|
+
return this.#ruleaza(verificaSiAsteapta(cerere, optiuni), optiuni);
|
|
891
|
+
}
|
|
892
|
+
};
|
|
893
|
+
var ClientVehicule = class {
|
|
894
|
+
#ruleaza;
|
|
895
|
+
/** @internal */
|
|
896
|
+
constructor(ruleaza2) {
|
|
897
|
+
this.#ruleaza = ruleaza2;
|
|
898
|
+
}
|
|
899
|
+
/**
|
|
900
|
+
* Listeaza toate vehiculele din cont, cu datele de expirare RCA, ITP,
|
|
901
|
+
* rovinieta si ARR.
|
|
902
|
+
*
|
|
903
|
+
* @param optiuni `signal` pentru anulare.
|
|
904
|
+
* @returns vehiculele contului; lista goala daca nu ai niciunul.
|
|
905
|
+
* @throws {@link EroareAutentificare} cheie API invalida (401).
|
|
906
|
+
* @throws {@link EroarePlanInactiv} contul nu are un plan activ (402).
|
|
907
|
+
* @throws {@link EroareRetea} fara raspuns, dupa reincercari.
|
|
908
|
+
* @example
|
|
909
|
+
* for (const v of await acteo.auto.flota.lista()) {
|
|
910
|
+
* console.log(v.numarInmatriculare, v.rcaExpiraLa, v.itpExpiraLa)
|
|
911
|
+
* }
|
|
912
|
+
*/
|
|
913
|
+
lista(optiuni) {
|
|
914
|
+
return this.#ruleaza(lista(), optiuni);
|
|
915
|
+
}
|
|
916
|
+
/**
|
|
917
|
+
* Adauga un vehicul in monitorizare. Trimite cel putin numarul de
|
|
918
|
+
* inmatriculare sau seria de sasiu. ITP-ul cere VIN, iar rovinieta cere
|
|
919
|
+
* numarul, VIN-ul si `serieTalon` (numarul certificatului de inmatriculare);
|
|
920
|
+
* fara `serieTalon`, rovinieta nu se verifica.
|
|
921
|
+
*
|
|
922
|
+
* @param vehicul numarul, VIN-ul si, optional, `serieTalon` si `arrMonitorizat`.
|
|
923
|
+
* @param optiuni `signal` pentru anulare.
|
|
924
|
+
* @returns vehiculul creat, cu `id`-ul folosit la stergere.
|
|
925
|
+
* @throws {@link EroareValidare} lipseste identificatorul, are caractere nepermise sau `serieTalon` e invalida.
|
|
926
|
+
* @throws {@link EroareInterzis} `LIMIT_ATINS` (ai atins numarul de masini din plan, vezi `limita`) sau `ARR_NECESITA_PLAN`.
|
|
927
|
+
* @throws {@link EroareConflict} vehiculul exista deja in cont (`VEHICUL_EXISTENT`).
|
|
928
|
+
* @throws {@link EroareLimita} plafonul zilnic de adaugari prin API (`LIMITA_FLOTA_ATINSA`).
|
|
929
|
+
* @throws {@link EroarePlanInactiv} contul nu are un plan activ (402).
|
|
930
|
+
* @example
|
|
931
|
+
* const v = await acteo.auto.flota.adauga({
|
|
932
|
+
* numarInmatriculare: "B123ABC",
|
|
933
|
+
* serieSasiu: "WVWZZZ1JZXW000001",
|
|
934
|
+
* serieTalon: "I00639603F",
|
|
935
|
+
* })
|
|
936
|
+
* console.log(v.id)
|
|
937
|
+
*/
|
|
938
|
+
adauga(vehicul, optiuni) {
|
|
939
|
+
return this.#ruleaza(adauga(vehicul), optiuni);
|
|
940
|
+
}
|
|
941
|
+
/**
|
|
942
|
+
* Scoate un vehicul din cont. Monitorizarea si notificarile lui se opresc.
|
|
943
|
+
*
|
|
944
|
+
* @param id `id`-ul vehiculului, din {@link ClientVehicule.lista} sau {@link ClientVehicule.adauga}.
|
|
945
|
+
* @param optiuni `signal` pentru anulare.
|
|
946
|
+
* @returns se rezolva fara valoare cand vehiculul a fost sters.
|
|
947
|
+
* @throws {@link EroareNegasit} vehiculul nu exista in contul cheii (404).
|
|
948
|
+
* @throws {@link EroareLimita} plafonul zilnic de stergeri prin API (`LIMITA_FLOTA_ATINSA`).
|
|
949
|
+
* @throws {@link EroareValidare} `id` gol.
|
|
950
|
+
* @example
|
|
951
|
+
* await acteo.auto.flota.sterge("6f2c1b9e-0000-4000-8000-000000000001")
|
|
952
|
+
*/
|
|
953
|
+
sterge(id, optiuni) {
|
|
954
|
+
return this.#ruleaza(sterge(id), optiuni);
|
|
955
|
+
}
|
|
956
|
+
};
|
|
957
|
+
var VerificRca = class {
|
|
958
|
+
/** Verificari la cerere RCA, ITP, rovinieta si ARR. */
|
|
959
|
+
verificari;
|
|
960
|
+
/** Vehiculele monitorizate din cont. */
|
|
961
|
+
vehicule;
|
|
962
|
+
/**
|
|
963
|
+
* Creeaza un client. Nu face nicio cerere pe retea.
|
|
964
|
+
*
|
|
965
|
+
* @param optiuni cheia API si setarile de retea; toate sunt optionale daca
|
|
966
|
+
* `VERIFICRCA_API_KEY` e setata.
|
|
967
|
+
* @throws {@link EroareConfigurare} lipseste cheia API sau o optiune e invalida.
|
|
968
|
+
* @example
|
|
969
|
+
* const vrca = new VerificRca({
|
|
970
|
+
* apiKey: process.env.VERIFICRCA_API_KEY,
|
|
971
|
+
* timeoutMs: 15_000,
|
|
972
|
+
* retry: { incercari: 5 },
|
|
973
|
+
* })
|
|
974
|
+
*/
|
|
975
|
+
constructor(optiuni = {}) {
|
|
976
|
+
const ruleaza2 = creeazaRulare(optiuni, PROFIL_LEGACY);
|
|
977
|
+
this.verificari = new ClientVerificari(ruleaza2);
|
|
978
|
+
this.vehicule = new ClientVehicule(ruleaza2);
|
|
979
|
+
}
|
|
980
|
+
};
|
|
981
|
+
var HEADER_CHEIE_WEBHOOK = "x-verificrca-key";
|
|
982
|
+
var HEADER_EVENIMENT_WEBHOOK = "x-verificrca-event";
|
|
983
|
+
function citesteHeader(headers, nume) {
|
|
984
|
+
if (typeof headers.get === "function") return headers.get(nume) ?? void 0;
|
|
985
|
+
const obiect = headers;
|
|
986
|
+
for (const [cheie, valoare] of Object.entries(obiect)) {
|
|
987
|
+
if (cheie.toLowerCase() !== nume) continue;
|
|
988
|
+
return typeof valoare === "string" ? valoare : valoare?.[0];
|
|
989
|
+
}
|
|
990
|
+
return void 0;
|
|
991
|
+
}
|
|
992
|
+
function egaleConstant(a, b) {
|
|
993
|
+
const ea = new TextEncoder().encode(a);
|
|
994
|
+
const eb = new TextEncoder().encode(b);
|
|
995
|
+
let diferenta = ea.length ^ eb.length;
|
|
996
|
+
const lungime = Math.max(ea.length, eb.length);
|
|
997
|
+
for (let i = 0; i < lungime; i++) diferenta |= (ea[i] ?? 0) ^ (eb[i] ?? 0);
|
|
998
|
+
return diferenta === 0;
|
|
999
|
+
}
|
|
1000
|
+
var parseazaCorp = (corp) => {
|
|
1001
|
+
if (typeof corp !== "string" && !(corp instanceof Uint8Array)) return effect.Effect.succeed(corp);
|
|
1002
|
+
const text = typeof corp === "string" ? corp : new TextDecoder().decode(corp);
|
|
1003
|
+
return effect.Effect.try({
|
|
1004
|
+
try: () => JSON.parse(text),
|
|
1005
|
+
catch: (err) => new EroareWebhook({ message: "Corpul webhook-ului nu e JSON valid.", cod: "JSON_INVALID", cause: err })
|
|
1006
|
+
});
|
|
1007
|
+
};
|
|
1008
|
+
var decodeazaWebhook = (schema) => (corp) => effect.Schema.decodeUnknown(schema)(corp).pipe(
|
|
1009
|
+
effect.Effect.mapError(
|
|
1010
|
+
(err) => new EroareWebhook({
|
|
1011
|
+
message: `Payload webhook invalid: ${effect.ParseResult.TreeFormatter.formatErrorSync(err)}`,
|
|
1012
|
+
cod: "PAYLOAD_INVALID",
|
|
1013
|
+
raspuns: corp,
|
|
1014
|
+
cause: err
|
|
1015
|
+
})
|
|
1016
|
+
)
|
|
1017
|
+
);
|
|
1018
|
+
function ruleaza(efect) {
|
|
1019
|
+
const rezultat2 = effect.Effect.runSync(effect.Effect.either(efect));
|
|
1020
|
+
if (effect.Either.isLeft(rezultat2)) throw rezultat2.left;
|
|
1021
|
+
return rezultat2.right;
|
|
1022
|
+
}
|
|
1023
|
+
function parseazaWebhookRezultat(corp) {
|
|
1024
|
+
return ruleaza(parseazaCorp(corp).pipe(effect.Effect.flatMap(decodeazaWebhook(WebhookRezultatSchema))));
|
|
1025
|
+
}
|
|
1026
|
+
function verificaWebhookNotificare(corp, headers, optiuni) {
|
|
1027
|
+
return ruleaza(
|
|
1028
|
+
effect.Effect.gen(function* () {
|
|
1029
|
+
if (!optiuni.cheie) {
|
|
1030
|
+
return yield* effect.Effect.fail(new EroareWebhook({ message: "Lipseste cheia de webhook din optiuni.", cod: "CHEIE_NECONFIGURATA" }));
|
|
1031
|
+
}
|
|
1032
|
+
const primita = citesteHeader(headers, HEADER_CHEIE_WEBHOOK);
|
|
1033
|
+
if (!primita || !egaleConstant(primita, optiuni.cheie)) {
|
|
1034
|
+
return yield* effect.Effect.fail(
|
|
1035
|
+
new EroareWebhook({ message: "Cheia din headerul X-Verificrca-Key lipseste sau nu se potriveste.", cod: "CHEIE_INVALIDA" })
|
|
1036
|
+
);
|
|
1037
|
+
}
|
|
1038
|
+
const json = yield* parseazaCorp(corp);
|
|
1039
|
+
return yield* decodeazaWebhook(WebhookNotificareSchema)(json);
|
|
1040
|
+
})
|
|
1041
|
+
);
|
|
1042
|
+
}
|
|
1043
|
+
|
|
1044
|
+
// src/acteo.ts
|
|
1045
|
+
var VIN_REGEX2 = /^[A-HJ-NPR-Z0-9]{17}$/;
|
|
1046
|
+
function esteInCurs(x) {
|
|
1047
|
+
return typeof x === "object" && x !== null && x.status === "processing";
|
|
1048
|
+
}
|
|
1049
|
+
var ClientDocument = class {
|
|
1050
|
+
#ruleaza;
|
|
1051
|
+
#mapare;
|
|
1052
|
+
/** @internal */
|
|
1053
|
+
constructor(ruleaza2, mapare) {
|
|
1054
|
+
this.#ruleaza = ruleaza2;
|
|
1055
|
+
this.#mapare = mapare;
|
|
1056
|
+
}
|
|
1057
|
+
/**
|
|
1058
|
+
* Verifica documentul si asteapta rezultatul final de la sursa oficiala.
|
|
1059
|
+
* Daca vehiculul a fost verificat de curand, rezultatul vine imediat.
|
|
1060
|
+
*
|
|
1061
|
+
* @param identificator ce cere sursa oficiala pentru acest document.
|
|
1062
|
+
* @param optiuni `timeoutMs`, `intervalMs` pentru asteptare si `signal`.
|
|
1063
|
+
* @returns rezultatul final.
|
|
1064
|
+
* @throws {@link EroareValidare} identificator invalid, local sau HTTP 400.
|
|
1065
|
+
* @throws {@link EroareLimita} cota zilnica sau lunara atinsa.
|
|
1066
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a refuzat datele.
|
|
1067
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
1068
|
+
*/
|
|
1069
|
+
verifica(identificator, optiuni) {
|
|
1070
|
+
return this.#ruleaza(
|
|
1071
|
+
verificaSiAsteapta(this.#mapare.cerere(identificator), optiuni),
|
|
1072
|
+
optiuni
|
|
1073
|
+
);
|
|
1074
|
+
}
|
|
1075
|
+
/**
|
|
1076
|
+
* Porneste verificarea fara sa astepte. Primesti rezultatul imediat, daca
|
|
1077
|
+
* vehiculul a fost verificat de curand, sau `status: "processing"`; atunci
|
|
1078
|
+
* afli raspunsul cu {@link ClientDocument.asteapta}, {@link ClientDocument.rezultat}
|
|
1079
|
+
* sau prin webhook la `callbackUrl`.
|
|
1080
|
+
*
|
|
1081
|
+
* @param identificator ce cere sursa oficiala pentru acest document.
|
|
1082
|
+
* @param optiuni `callbackUrl` si `signal`.
|
|
1083
|
+
* @returns rezultatul final sau verificarea in curs.
|
|
1084
|
+
*/
|
|
1085
|
+
porneste(identificator, optiuni) {
|
|
1086
|
+
const cerere = {
|
|
1087
|
+
...this.#mapare.cerere(identificator),
|
|
1088
|
+
...optiuni?.callbackUrl !== void 0 && { callbackUrl: optiuni.callbackUrl }
|
|
1089
|
+
};
|
|
1090
|
+
return this.#ruleaza(porneste(cerere), optiuni);
|
|
1091
|
+
}
|
|
1092
|
+
/**
|
|
1093
|
+
* Interogheaza o singura data rezultatul. Nu consuma din cota.
|
|
1094
|
+
*
|
|
1095
|
+
* @param referinta verificarea in curs primita de la `porneste()` sau identificatorul documentului.
|
|
1096
|
+
* @param optiuni `signal` pentru anulare.
|
|
1097
|
+
* @returns rezultatul final sau verificarea inca in curs.
|
|
1098
|
+
*/
|
|
1099
|
+
rezultat(referinta, optiuni) {
|
|
1100
|
+
return this.#ruleaza(rezultat(this.#referinta(referinta)), optiuni);
|
|
1101
|
+
}
|
|
1102
|
+
/**
|
|
1103
|
+
* Interogheaza periodic pana la rezultatul final. Nu consuma din cota.
|
|
1104
|
+
*
|
|
1105
|
+
* @param referinta verificarea in curs primita de la `porneste()` sau identificatorul documentului.
|
|
1106
|
+
* @param optiuni `timeoutMs`, `intervalMs` si `signal`.
|
|
1107
|
+
* @returns rezultatul final.
|
|
1108
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
1109
|
+
*/
|
|
1110
|
+
asteapta(referinta, optiuni) {
|
|
1111
|
+
return this.#ruleaza(
|
|
1112
|
+
asteapta(this.#referinta(referinta), optiuni),
|
|
1113
|
+
optiuni
|
|
1114
|
+
);
|
|
1115
|
+
}
|
|
1116
|
+
#referinta(x) {
|
|
1117
|
+
return esteInCurs(x) ? x : this.#mapare.referinta(x);
|
|
1118
|
+
}
|
|
1119
|
+
};
|
|
1120
|
+
function rcaPe(id) {
|
|
1121
|
+
if (typeof id !== "string") return id;
|
|
1122
|
+
const n = normalizeaza(id);
|
|
1123
|
+
return VIN_REGEX2.test(n) ? { vin: n } : { numar: n };
|
|
1124
|
+
}
|
|
1125
|
+
var MAPARE_RCA = {
|
|
1126
|
+
cerere: (id) => {
|
|
1127
|
+
const { numar, vin } = rcaPe(id);
|
|
1128
|
+
return numar ? { tip: "rca", query: numar, ...vin && { serieSasiu: vin } } : { tip: "rca", query: vin ?? "" };
|
|
1129
|
+
},
|
|
1130
|
+
// Cu VIN, API-ul cauta doar dupa VIN, deci pollingul merge pe VIN.
|
|
1131
|
+
referinta: (id) => {
|
|
1132
|
+
const { numar, vin } = rcaPe(id);
|
|
1133
|
+
return { tip: "rca", query: normalizeaza(vin ?? numar ?? "") };
|
|
1134
|
+
}
|
|
1135
|
+
};
|
|
1136
|
+
var MAPARE_ITP = {
|
|
1137
|
+
cerere: (vin) => ({ tip: "itp", query: vin }),
|
|
1138
|
+
referinta: (vin) => ({ tip: "itp", query: normalizeaza(vin) })
|
|
1139
|
+
};
|
|
1140
|
+
var MAPARE_ARR = {
|
|
1141
|
+
cerere: (numar) => ({ tip: "arr", query: numar }),
|
|
1142
|
+
referinta: (numar) => ({ tip: "arr", query: normalizeaza(numar) })
|
|
1143
|
+
};
|
|
1144
|
+
var MAPARE_ROVINIETA = {
|
|
1145
|
+
cerere: (id) => ({ tip: "rovinieta", query: id.numar, serieSasiu: id.vin, serieTalon: id.serieTalon }),
|
|
1146
|
+
referinta: (id) => ({ tip: "rovinieta", query: normalizeaza(id.numar), serieSasiu: normalizeaza(id.vin) })
|
|
1147
|
+
};
|
|
1148
|
+
var ClientAuto = class {
|
|
1149
|
+
/** Asigurarea RCA: `acteo.auto.rca.verifica("B123ABC")`. */
|
|
1150
|
+
rca;
|
|
1151
|
+
/** ITP: `acteo.auto.itp.verifica("WVWZZZ1JZXW000001")`. */
|
|
1152
|
+
itp;
|
|
1153
|
+
/** Rovinieta: `acteo.auto.rovinieta.verifica({ numar, vin, serieTalon })`. */
|
|
1154
|
+
rovinieta;
|
|
1155
|
+
/** Copia conforma ARR: `acteo.auto.arr.verifica("B123ABC")`. */
|
|
1156
|
+
arr;
|
|
1157
|
+
/** Vehiculele monitorizate din cont: `lista()`, `adauga()`, `sterge()`. */
|
|
1158
|
+
flota;
|
|
1159
|
+
/** @internal */
|
|
1160
|
+
constructor(ruleaza2) {
|
|
1161
|
+
this.rca = new ClientDocument(ruleaza2, MAPARE_RCA);
|
|
1162
|
+
this.itp = new ClientDocument(ruleaza2, MAPARE_ITP);
|
|
1163
|
+
this.rovinieta = new ClientDocument(ruleaza2, MAPARE_ROVINIETA);
|
|
1164
|
+
this.arr = new ClientDocument(ruleaza2, MAPARE_ARR);
|
|
1165
|
+
this.flota = new ClientVehicule(ruleaza2);
|
|
1166
|
+
}
|
|
1167
|
+
};
|
|
1168
|
+
var ClientWebhooks = class {
|
|
1169
|
+
/**
|
|
1170
|
+
* Valideaza corpul unui webhook de rezultat (trimis la `callbackUrl`).
|
|
1171
|
+
*
|
|
1172
|
+
* @param corp corpul cererii, ca string sau obiect deja parsat.
|
|
1173
|
+
* @returns rezultatul verificarii.
|
|
1174
|
+
* @throws {@link EroareWebhook} corp invalid.
|
|
1175
|
+
*/
|
|
1176
|
+
parseazaRezultat(corp) {
|
|
1177
|
+
return parseazaWebhookRezultat(corp);
|
|
1178
|
+
}
|
|
1179
|
+
/**
|
|
1180
|
+
* Verifica cheia si corpul unui webhook de notificare (ex: `document.expira`).
|
|
1181
|
+
*
|
|
1182
|
+
* @param corp corpul cererii.
|
|
1183
|
+
* @param headers headerele cererii.
|
|
1184
|
+
* @param optiuni `cheie`, cheia de webhook din dashboard.
|
|
1185
|
+
* @returns notificarea validata.
|
|
1186
|
+
* @throws {@link EroareWebhook} cheie lipsa, gresita sau corp invalid.
|
|
1187
|
+
*/
|
|
1188
|
+
verificaNotificare(corp, headers, optiuni) {
|
|
1189
|
+
return verificaWebhookNotificare(corp, headers, optiuni);
|
|
1190
|
+
}
|
|
1191
|
+
};
|
|
1192
|
+
var Acteo = class {
|
|
1193
|
+
/** Documentele unei masini (RCA, ITP, rovinieta, ARR) si flota. */
|
|
1194
|
+
auto;
|
|
1195
|
+
/** Citirea webhook-urilor. */
|
|
1196
|
+
webhooks;
|
|
1197
|
+
/**
|
|
1198
|
+
* Creeaza un client. Nu face nicio cerere pe retea.
|
|
1199
|
+
*
|
|
1200
|
+
* @param optiuni cheia API si setarile de retea; toate sunt optionale daca
|
|
1201
|
+
* `ACTEO_API_KEY` e setata.
|
|
1202
|
+
* @throws {@link EroareConfigurare} lipseste cheia API sau o optiune e invalida.
|
|
1203
|
+
*/
|
|
1204
|
+
constructor(optiuni = {}) {
|
|
1205
|
+
const ruleaza2 = creeazaRulare(optiuni, PROFIL_ACTEO);
|
|
1206
|
+
this.auto = new ClientAuto(ruleaza2);
|
|
1207
|
+
this.webhooks = new ClientWebhooks();
|
|
1208
|
+
}
|
|
1209
|
+
};
|
|
1210
|
+
|
|
1211
|
+
exports.Acteo = Acteo;
|
|
1212
|
+
exports.ActeoError = VerificRcaError;
|
|
1213
|
+
exports.ClientAuto = ClientAuto;
|
|
1214
|
+
exports.ClientDocument = ClientDocument;
|
|
1215
|
+
exports.ClientVehicule = ClientVehicule;
|
|
1216
|
+
exports.ClientVerificari = ClientVerificari;
|
|
1217
|
+
exports.ClientWebhooks = ClientWebhooks;
|
|
1218
|
+
exports.EroareAutentificare = EroareAutentificare;
|
|
1219
|
+
exports.EroareConfigurare = EroareConfigurare;
|
|
1220
|
+
exports.EroareConflict = EroareConflict;
|
|
1221
|
+
exports.EroareHttp = EroareHttp;
|
|
1222
|
+
exports.EroareInterzis = EroareInterzis;
|
|
1223
|
+
exports.EroareLimita = EroareLimita;
|
|
1224
|
+
exports.EroareNegasit = EroareNegasit;
|
|
1225
|
+
exports.EroarePlanInactiv = EroarePlanInactiv;
|
|
1226
|
+
exports.EroareRaspunsInvalid = EroareRaspunsInvalid;
|
|
1227
|
+
exports.EroareRetea = EroareRetea;
|
|
1228
|
+
exports.EroareServer = EroareServer;
|
|
1229
|
+
exports.EroareTimeoutVerificare = EroareTimeoutVerificare;
|
|
1230
|
+
exports.EroareValidare = EroareValidare;
|
|
1231
|
+
exports.EroareVerificare = EroareVerificare;
|
|
1232
|
+
exports.EroareWebhook = EroareWebhook;
|
|
1233
|
+
exports.HEADER_CHEIE_WEBHOOK = HEADER_CHEIE_WEBHOOK;
|
|
1234
|
+
exports.HEADER_EVENIMENT_WEBHOOK = HEADER_EVENIMENT_WEBHOOK;
|
|
1235
|
+
exports.TIPURI_VERIFICARE = TIPURI_VERIFICARE;
|
|
1236
|
+
exports.URL_IMPLICIT = URL_IMPLICIT;
|
|
1237
|
+
exports.URL_IMPLICIT_LEGACY = URL_IMPLICIT_LEGACY;
|
|
1238
|
+
exports.VERSIUNE_SDK = VERSIUNE_SDK;
|
|
1239
|
+
exports.VerificRca = VerificRca;
|
|
1240
|
+
exports.VerificRcaError = VerificRcaError;
|
|
1241
|
+
exports.esteNumarInmatriculareValid = esteNumarInmatriculareValid;
|
|
1242
|
+
exports.esteSerieTalonValida = esteSerieTalonValida;
|
|
1243
|
+
exports.esteVinValid = esteVinValid;
|
|
1244
|
+
exports.normalizeaza = normalizeaza;
|
|
1245
|
+
exports.normalizeazaSerieTalon = normalizeazaSerieTalon;
|
|
1246
|
+
exports.parseazaWebhookRezultat = parseazaWebhookRezultat;
|
|
1247
|
+
exports.verificaWebhookNotificare = verificaWebhookNotificare;
|
|
1248
|
+
//# sourceMappingURL=index.cjs.map
|
|
1249
|
+
//# sourceMappingURL=index.cjs.map
|