corebasic 1.0.212 → 1.0.214
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/dist/index.js +10 -0
- package/dist/libs/ObjectId.js +114 -0
- package/dist/libs/auth.js +103 -0
- package/dist/libs/compression.js +11 -0
- package/dist/libs/cpp.js +154 -0
- package/dist/libs/dip/suffix/date.js +89 -0
- package/dist/libs/dip/suffix/index.js +227 -0
- package/dist/libs/dip/suffix/policy.js +113 -0
- package/dist/libs/dip/suffix/query.js +279 -0
- package/dist/libs/dip/suffix/suffix.js +99 -0
- package/dist/libs/dip/suffix/tests/date.test.js +187 -0
- package/dist/libs/dip/suffix/tests/index.test.js +441 -0
- package/dist/libs/dip/suffix/tests/policy.applySuffixPolicy.test.js +489 -0
- package/dist/libs/dip/suffix/tests/policy.test.js +329 -0
- package/dist/libs/dip/suffix/tests/suffix.test.js +316 -0
- package/dist/libs/dip.js +102 -0
- package/dist/libs/dipper.js +73 -0
- package/dist/libs/elabase.js +656 -0
- package/dist/libs/features.js +366 -0
- package/dist/libs/kafka.js +121 -0
- package/dist/libs/messaging.js +130 -0
- package/dist/libs/mobilecodes.js +562 -0
- package/dist/libs/session.js +96 -0
- package/dist/libs/utils.js +297 -0
- package/package.json +3 -2
- package/tsc-notes +14 -0
- package/tsconfig.json +48 -0
|
@@ -0,0 +1,489 @@
|
|
|
1
|
+
import { describe, test } from "node:test";
|
|
2
|
+
import assert from "node:assert/strict";
|
|
3
|
+
import { applySuffixPolicy } from "../policy.js";
|
|
4
|
+
// -----------------------------------------------------------------------------
|
|
5
|
+
// applySuffixPolicy()
|
|
6
|
+
// -----------------------------------------------------------------------------
|
|
7
|
+
describe("applySuffixPolicy()", () => {
|
|
8
|
+
test("no collection", async () => {
|
|
9
|
+
const collections = {};
|
|
10
|
+
const result = await applySuffixPolicy(collections, "missing", {});
|
|
11
|
+
assert.deepEqual(result, []);
|
|
12
|
+
});
|
|
13
|
+
test("collection without policy", async () => {
|
|
14
|
+
const collections = {
|
|
15
|
+
invoices: {}
|
|
16
|
+
};
|
|
17
|
+
const result = await applySuffixPolicy(collections, "invoices", {});
|
|
18
|
+
assert.deepEqual(result, []);
|
|
19
|
+
});
|
|
20
|
+
test("empty policy array", async () => {
|
|
21
|
+
const collections = {
|
|
22
|
+
invoices: {
|
|
23
|
+
policy: []
|
|
24
|
+
}
|
|
25
|
+
};
|
|
26
|
+
const result = await applySuffixPolicy(collections, "invoices", {});
|
|
27
|
+
assert.deepEqual(result, []);
|
|
28
|
+
});
|
|
29
|
+
test("single policy object", async () => {
|
|
30
|
+
const collections = {
|
|
31
|
+
invoices: {
|
|
32
|
+
policy: {
|
|
33
|
+
suffix: [
|
|
34
|
+
{ key: "type" }
|
|
35
|
+
]
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
};
|
|
39
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
40
|
+
type: "Sales"
|
|
41
|
+
});
|
|
42
|
+
assert.deepEqual(result, [
|
|
43
|
+
"/Sales"
|
|
44
|
+
]);
|
|
45
|
+
});
|
|
46
|
+
test("single policy array", async () => {
|
|
47
|
+
const collections = {
|
|
48
|
+
invoices: {
|
|
49
|
+
policy: [
|
|
50
|
+
{
|
|
51
|
+
suffix: [
|
|
52
|
+
{ key: "type" }
|
|
53
|
+
]
|
|
54
|
+
}
|
|
55
|
+
]
|
|
56
|
+
}
|
|
57
|
+
};
|
|
58
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
59
|
+
type: "Sales"
|
|
60
|
+
});
|
|
61
|
+
assert.deepEqual(result, [
|
|
62
|
+
"/Sales"
|
|
63
|
+
]);
|
|
64
|
+
});
|
|
65
|
+
test("unconditional policy", async () => {
|
|
66
|
+
const collections = {
|
|
67
|
+
invoices: {
|
|
68
|
+
policy: {
|
|
69
|
+
when: {},
|
|
70
|
+
suffix: [
|
|
71
|
+
{ key: "type" }
|
|
72
|
+
]
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
};
|
|
76
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
77
|
+
type: "Sales"
|
|
78
|
+
});
|
|
79
|
+
assert.deepEqual(result, [
|
|
80
|
+
"/Sales"
|
|
81
|
+
]);
|
|
82
|
+
});
|
|
83
|
+
test("policy matches equality", async () => {
|
|
84
|
+
const collections = {
|
|
85
|
+
invoices: {
|
|
86
|
+
policy: {
|
|
87
|
+
when: {
|
|
88
|
+
status: "Active"
|
|
89
|
+
},
|
|
90
|
+
suffix: [
|
|
91
|
+
{ key: "type" }
|
|
92
|
+
]
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
};
|
|
96
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
97
|
+
status: "Active",
|
|
98
|
+
type: "Sales"
|
|
99
|
+
});
|
|
100
|
+
assert.deepEqual(result, [
|
|
101
|
+
"/Sales"
|
|
102
|
+
]);
|
|
103
|
+
});
|
|
104
|
+
test("policy does not match equality", async () => {
|
|
105
|
+
const collections = {
|
|
106
|
+
invoices: {
|
|
107
|
+
policy: {
|
|
108
|
+
when: {
|
|
109
|
+
status: "Active"
|
|
110
|
+
},
|
|
111
|
+
suffix: [
|
|
112
|
+
{ key: "type" }
|
|
113
|
+
]
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
};
|
|
117
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
118
|
+
status: "Deleted",
|
|
119
|
+
type: "Sales"
|
|
120
|
+
});
|
|
121
|
+
assert.deepEqual(result, []);
|
|
122
|
+
});
|
|
123
|
+
test("$in subset", async () => {
|
|
124
|
+
const collections = {
|
|
125
|
+
invoices: {
|
|
126
|
+
policy: {
|
|
127
|
+
when: {
|
|
128
|
+
status: { $in: ["Active"] }
|
|
129
|
+
},
|
|
130
|
+
suffix: [
|
|
131
|
+
{ key: "type" }
|
|
132
|
+
]
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
};
|
|
136
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
137
|
+
status: { $in: ["Active", "Pending"] },
|
|
138
|
+
type: "Sales"
|
|
139
|
+
});
|
|
140
|
+
assert.deepEqual(result, [
|
|
141
|
+
"/Sales"
|
|
142
|
+
]);
|
|
143
|
+
});
|
|
144
|
+
test("multiple matching policies", async () => {
|
|
145
|
+
const collections = {
|
|
146
|
+
invoices: {
|
|
147
|
+
policy: [
|
|
148
|
+
{
|
|
149
|
+
when: {
|
|
150
|
+
status: "Active"
|
|
151
|
+
},
|
|
152
|
+
suffix: [
|
|
153
|
+
{ key: "type" }
|
|
154
|
+
]
|
|
155
|
+
},
|
|
156
|
+
{
|
|
157
|
+
when: {
|
|
158
|
+
status: "Active"
|
|
159
|
+
},
|
|
160
|
+
suffix: [
|
|
161
|
+
{ key: "region" }
|
|
162
|
+
]
|
|
163
|
+
}
|
|
164
|
+
]
|
|
165
|
+
}
|
|
166
|
+
};
|
|
167
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
168
|
+
status: "Active",
|
|
169
|
+
type: "Sales",
|
|
170
|
+
region: "IN"
|
|
171
|
+
});
|
|
172
|
+
assert.deepEqual(result.sort(), [
|
|
173
|
+
"/Sales",
|
|
174
|
+
"/IN"
|
|
175
|
+
].sort());
|
|
176
|
+
});
|
|
177
|
+
test("one policy matches one skipped", async () => {
|
|
178
|
+
const collections = {
|
|
179
|
+
invoices: {
|
|
180
|
+
policy: [
|
|
181
|
+
{
|
|
182
|
+
when: {
|
|
183
|
+
status: "Active"
|
|
184
|
+
},
|
|
185
|
+
suffix: [
|
|
186
|
+
{ key: "type" }
|
|
187
|
+
]
|
|
188
|
+
},
|
|
189
|
+
{
|
|
190
|
+
when: {
|
|
191
|
+
status: "Deleted"
|
|
192
|
+
},
|
|
193
|
+
suffix: [
|
|
194
|
+
{ key: "region" }
|
|
195
|
+
]
|
|
196
|
+
}
|
|
197
|
+
]
|
|
198
|
+
}
|
|
199
|
+
};
|
|
200
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
201
|
+
status: "Active",
|
|
202
|
+
type: "Sales",
|
|
203
|
+
region: "IN"
|
|
204
|
+
});
|
|
205
|
+
assert.deepEqual(result, [
|
|
206
|
+
"/Sales"
|
|
207
|
+
]);
|
|
208
|
+
});
|
|
209
|
+
test("duplicate suffix removed", async () => {
|
|
210
|
+
const collections = {
|
|
211
|
+
invoices: {
|
|
212
|
+
policy: [
|
|
213
|
+
{
|
|
214
|
+
suffix: [
|
|
215
|
+
{ key: "type" }
|
|
216
|
+
]
|
|
217
|
+
},
|
|
218
|
+
{
|
|
219
|
+
suffix: [
|
|
220
|
+
{ key: "type" }
|
|
221
|
+
]
|
|
222
|
+
}
|
|
223
|
+
]
|
|
224
|
+
}
|
|
225
|
+
};
|
|
226
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
227
|
+
type: "Sales"
|
|
228
|
+
});
|
|
229
|
+
assert.deepEqual(result, [
|
|
230
|
+
"/Sales"
|
|
231
|
+
]);
|
|
232
|
+
});
|
|
233
|
+
test("date suffix", async () => {
|
|
234
|
+
const collections = {
|
|
235
|
+
invoices: {
|
|
236
|
+
policy: {
|
|
237
|
+
suffix: [
|
|
238
|
+
{
|
|
239
|
+
key: "date",
|
|
240
|
+
type: "date:YYYY"
|
|
241
|
+
}
|
|
242
|
+
]
|
|
243
|
+
}
|
|
244
|
+
}
|
|
245
|
+
};
|
|
246
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
247
|
+
date: new Date(2026, 4, 3).getTime()
|
|
248
|
+
});
|
|
249
|
+
assert.deepEqual(result, [
|
|
250
|
+
"/2026"
|
|
251
|
+
]);
|
|
252
|
+
});
|
|
253
|
+
test("multiple suffix parts", async () => {
|
|
254
|
+
const collections = {
|
|
255
|
+
invoices: {
|
|
256
|
+
policy: {
|
|
257
|
+
suffix: [
|
|
258
|
+
{ key: "type" },
|
|
259
|
+
{
|
|
260
|
+
key: "date",
|
|
261
|
+
type: "date:YYYY"
|
|
262
|
+
}
|
|
263
|
+
]
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
};
|
|
267
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
268
|
+
type: "Sales",
|
|
269
|
+
date: new Date(2026, 4, 3).getTime()
|
|
270
|
+
});
|
|
271
|
+
assert.deepEqual(result, [
|
|
272
|
+
"/Sales/2026"
|
|
273
|
+
]);
|
|
274
|
+
});
|
|
275
|
+
test("range policy", async () => {
|
|
276
|
+
const collections = {
|
|
277
|
+
invoices: {
|
|
278
|
+
policy: {
|
|
279
|
+
when: {
|
|
280
|
+
age: {
|
|
281
|
+
$gt: 10
|
|
282
|
+
}
|
|
283
|
+
},
|
|
284
|
+
suffix: [
|
|
285
|
+
{ key: "type" }
|
|
286
|
+
]
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
};
|
|
290
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
291
|
+
age: {
|
|
292
|
+
$gt: 20
|
|
293
|
+
},
|
|
294
|
+
type: "Sales"
|
|
295
|
+
});
|
|
296
|
+
assert.deepEqual(result, [
|
|
297
|
+
"/Sales"
|
|
298
|
+
]);
|
|
299
|
+
});
|
|
300
|
+
test("range policy miss", async () => {
|
|
301
|
+
const collections = {
|
|
302
|
+
invoices: {
|
|
303
|
+
policy: {
|
|
304
|
+
when: {
|
|
305
|
+
age: {
|
|
306
|
+
$gt: 50
|
|
307
|
+
}
|
|
308
|
+
},
|
|
309
|
+
suffix: [
|
|
310
|
+
{ key: "type" }
|
|
311
|
+
]
|
|
312
|
+
}
|
|
313
|
+
}
|
|
314
|
+
};
|
|
315
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
316
|
+
age: {
|
|
317
|
+
$lt: 10
|
|
318
|
+
},
|
|
319
|
+
type: "Sales"
|
|
320
|
+
});
|
|
321
|
+
assert.deepEqual(result, []);
|
|
322
|
+
});
|
|
323
|
+
test("$ne throws", async () => {
|
|
324
|
+
const collections = {
|
|
325
|
+
invoices: {
|
|
326
|
+
policy: {
|
|
327
|
+
when: {
|
|
328
|
+
status: {
|
|
329
|
+
$ne: "Deleted"
|
|
330
|
+
}
|
|
331
|
+
},
|
|
332
|
+
suffix: [
|
|
333
|
+
{ key: "type" }
|
|
334
|
+
]
|
|
335
|
+
}
|
|
336
|
+
}
|
|
337
|
+
};
|
|
338
|
+
await assert.rejects(async () => {
|
|
339
|
+
await applySuffixPolicy(collections, "invoices", {
|
|
340
|
+
status: "Active",
|
|
341
|
+
type: "Sales"
|
|
342
|
+
});
|
|
343
|
+
});
|
|
344
|
+
});
|
|
345
|
+
test("policy value inside query range", async () => {
|
|
346
|
+
const collections = {
|
|
347
|
+
invoices: {
|
|
348
|
+
policy: {
|
|
349
|
+
when: {
|
|
350
|
+
age: { $in: [10] }
|
|
351
|
+
},
|
|
352
|
+
suffix: [
|
|
353
|
+
{ key: "type" }
|
|
354
|
+
]
|
|
355
|
+
}
|
|
356
|
+
}
|
|
357
|
+
};
|
|
358
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
359
|
+
age: {
|
|
360
|
+
$gt: 5,
|
|
361
|
+
$lt: 15
|
|
362
|
+
},
|
|
363
|
+
type: "Sales"
|
|
364
|
+
});
|
|
365
|
+
assert.deepEqual(result, [
|
|
366
|
+
"/Sales"
|
|
367
|
+
]);
|
|
368
|
+
});
|
|
369
|
+
test("policy value outside query range", async () => {
|
|
370
|
+
const collections = {
|
|
371
|
+
invoices: {
|
|
372
|
+
policy: {
|
|
373
|
+
when: {
|
|
374
|
+
age: { $in: [20] }
|
|
375
|
+
},
|
|
376
|
+
suffix: [
|
|
377
|
+
{ key: "type" }
|
|
378
|
+
]
|
|
379
|
+
}
|
|
380
|
+
}
|
|
381
|
+
};
|
|
382
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
383
|
+
age: {
|
|
384
|
+
$gt: 5,
|
|
385
|
+
$lt: 15
|
|
386
|
+
},
|
|
387
|
+
type: "Sales"
|
|
388
|
+
});
|
|
389
|
+
assert.deepEqual(result, []);
|
|
390
|
+
});
|
|
391
|
+
test("policy range intersects query value", async () => {
|
|
392
|
+
const collections = {
|
|
393
|
+
invoices: {
|
|
394
|
+
policy: {
|
|
395
|
+
when: {
|
|
396
|
+
age: {
|
|
397
|
+
$gt: 5,
|
|
398
|
+
$lt: 15
|
|
399
|
+
}
|
|
400
|
+
},
|
|
401
|
+
suffix: [
|
|
402
|
+
{ key: "type" }
|
|
403
|
+
]
|
|
404
|
+
}
|
|
405
|
+
}
|
|
406
|
+
};
|
|
407
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
408
|
+
age: { $in: [10] },
|
|
409
|
+
type: "Sales"
|
|
410
|
+
});
|
|
411
|
+
assert.deepEqual(result, [
|
|
412
|
+
"/Sales"
|
|
413
|
+
]);
|
|
414
|
+
});
|
|
415
|
+
test("policy range does not intersect query value", async () => {
|
|
416
|
+
const collections = {
|
|
417
|
+
invoices: {
|
|
418
|
+
policy: {
|
|
419
|
+
when: {
|
|
420
|
+
age: {
|
|
421
|
+
$gt: 20,
|
|
422
|
+
$lt: 30
|
|
423
|
+
}
|
|
424
|
+
},
|
|
425
|
+
suffix: [
|
|
426
|
+
{ key: "type" }
|
|
427
|
+
]
|
|
428
|
+
}
|
|
429
|
+
}
|
|
430
|
+
};
|
|
431
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
432
|
+
age: { $in: [10] },
|
|
433
|
+
type: "Sales"
|
|
434
|
+
});
|
|
435
|
+
assert.deepEqual(result, []);
|
|
436
|
+
});
|
|
437
|
+
test("policy range intersects query range", async () => {
|
|
438
|
+
const collections = {
|
|
439
|
+
invoices: {
|
|
440
|
+
policy: {
|
|
441
|
+
when: {
|
|
442
|
+
age: {
|
|
443
|
+
$gt: 10,
|
|
444
|
+
$lt: 30
|
|
445
|
+
}
|
|
446
|
+
},
|
|
447
|
+
suffix: [
|
|
448
|
+
{ key: "type" }
|
|
449
|
+
]
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
};
|
|
453
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
454
|
+
age: {
|
|
455
|
+
$gt: 20,
|
|
456
|
+
$lt: 40
|
|
457
|
+
},
|
|
458
|
+
type: "Sales"
|
|
459
|
+
});
|
|
460
|
+
assert.deepEqual(result, [
|
|
461
|
+
"/Sales"
|
|
462
|
+
]);
|
|
463
|
+
});
|
|
464
|
+
test("policy range does not intersect query range", async () => {
|
|
465
|
+
const collections = {
|
|
466
|
+
invoices: {
|
|
467
|
+
policy: {
|
|
468
|
+
when: {
|
|
469
|
+
age: {
|
|
470
|
+
$gt: 50,
|
|
471
|
+
$lt: 60
|
|
472
|
+
}
|
|
473
|
+
},
|
|
474
|
+
suffix: [
|
|
475
|
+
{ key: "type" }
|
|
476
|
+
]
|
|
477
|
+
}
|
|
478
|
+
}
|
|
479
|
+
};
|
|
480
|
+
const result = await applySuffixPolicy(collections, "invoices", {
|
|
481
|
+
age: {
|
|
482
|
+
$gt: 10,
|
|
483
|
+
$lt: 20
|
|
484
|
+
},
|
|
485
|
+
type: "Sales"
|
|
486
|
+
});
|
|
487
|
+
assert.deepEqual(result, []);
|
|
488
|
+
});
|
|
489
|
+
});
|