datalevin-node 0.10.17 → 1.0.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/README.md +408 -13
- package/jars/{datalevin-runtime-0.10.17.jar → datalevin-runtime-1.0.0.jar} +0 -0
- package/package.json +2 -2
- package/src/client.js +12 -0
- package/src/connection.js +306 -8
- package/src/database.js +85 -0
- package/src/entity.js +171 -0
- package/src/index.js +68 -2
- package/src/interop.js +1824 -43
- package/src/jvm.js +1 -0
- package/src/kv.js +1102 -4
- package/src/llm.js +114 -0
- package/src/raw.js +385 -3
- package/src/search.js +173 -0
- package/src/udf.js +181 -0
- package/src/vector.js +87 -0
package/src/connection.js
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
|
-
import { toEdnForm, toJava, toQueryInput } from "./convert.js";
|
|
1
|
+
import { toEdnForm, toJava, toJs, toQueryInput } from "./convert.js";
|
|
2
|
+
import { txReportToJs } from "./database.js";
|
|
2
3
|
import { _BINDINGS } from "./interop.js";
|
|
3
|
-
import { callJavaMethod } from "./jvm.js";
|
|
4
|
+
import { callJavaMethod, javaBridgeModule } from "./jvm.js";
|
|
4
5
|
import { ResourceWrapper } from "./resource.js";
|
|
5
6
|
import { toJsResult } from "./result.js";
|
|
6
7
|
|
|
@@ -18,14 +19,99 @@ async function queryForm(query) {
|
|
|
18
19
|
return query;
|
|
19
20
|
}
|
|
20
21
|
|
|
22
|
+
function hasValue(value) {
|
|
23
|
+
return value !== null && value !== undefined;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
function sliceRows(rows, { limit = null, offset = 0 } = {}) {
|
|
27
|
+
const start = Math.max(offset ?? 0, 0);
|
|
28
|
+
if (!hasValue(limit)) {
|
|
29
|
+
return start === 0 ? rows : rows.slice(start);
|
|
30
|
+
}
|
|
31
|
+
return rows.slice(start, start + Math.max(limit, 0));
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
function fetchLimit(limit, offset = 0) {
|
|
35
|
+
if (!hasValue(limit)) {
|
|
36
|
+
return null;
|
|
37
|
+
}
|
|
38
|
+
return Math.max(limit, 0) + Math.max(offset ?? 0, 0);
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
function fulltextOpts(opts = null, { limit = null, offset = 0, pagingCachePages = null } = {}) {
|
|
42
|
+
const mapOpts = opts instanceof Map;
|
|
43
|
+
const merged = mapOpts ? new Map(opts) : (hasValue(opts) ? { ...opts } : {});
|
|
44
|
+
const put = (key, value) => {
|
|
45
|
+
if (mapOpts) {
|
|
46
|
+
merged.set(key, value);
|
|
47
|
+
} else {
|
|
48
|
+
merged[key] = value;
|
|
49
|
+
}
|
|
50
|
+
};
|
|
51
|
+
if (hasValue(limit)) {
|
|
52
|
+
put(":limit", Math.max(limit, 0));
|
|
53
|
+
}
|
|
54
|
+
if (offset) {
|
|
55
|
+
put(":offset", Math.max(offset, 0));
|
|
56
|
+
}
|
|
57
|
+
if (hasValue(pagingCachePages)) {
|
|
58
|
+
put(":paging-cache-pages", pagingCachePages);
|
|
59
|
+
}
|
|
60
|
+
return (mapOpts ? merged.size === 0 : Object.keys(merged).length === 0) ? null : merged;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
let listenerProxyEventLoopDepth = 0;
|
|
64
|
+
let listenerProxyEventLoopPrevious = false;
|
|
65
|
+
|
|
66
|
+
async function retainListenerProxyEventLoop() {
|
|
67
|
+
const bridge = await javaBridgeModule();
|
|
68
|
+
if (listenerProxyEventLoopDepth === 0) {
|
|
69
|
+
listenerProxyEventLoopPrevious = bridge.config.runEventLoopWhenInterfaceProxyIsActive;
|
|
70
|
+
bridge.config.runEventLoopWhenInterfaceProxyIsActive = true;
|
|
71
|
+
}
|
|
72
|
+
listenerProxyEventLoopDepth += 1;
|
|
73
|
+
return () => {
|
|
74
|
+
listenerProxyEventLoopDepth -= 1;
|
|
75
|
+
if (listenerProxyEventLoopDepth === 0) {
|
|
76
|
+
bridge.config.runEventLoopWhenInterfaceProxyIsActive = listenerProxyEventLoopPrevious;
|
|
77
|
+
}
|
|
78
|
+
};
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
async function createConsumerProxy(fn) {
|
|
82
|
+
if (typeof fn !== "function") {
|
|
83
|
+
throw new TypeError("callback must be a function.");
|
|
84
|
+
}
|
|
85
|
+
const { newProxy } = await javaBridgeModule();
|
|
86
|
+
return newProxy("java.util.function.Consumer", {
|
|
87
|
+
accept: async (value) => {
|
|
88
|
+
await fn(await toJs(value));
|
|
89
|
+
}
|
|
90
|
+
});
|
|
91
|
+
}
|
|
92
|
+
|
|
21
93
|
export class Connection extends ResourceWrapper {
|
|
22
|
-
constructor(handle) {
|
|
94
|
+
constructor(handle, { owned = true } = {}) {
|
|
23
95
|
super(
|
|
24
96
|
handle,
|
|
25
|
-
(rawHandle) => _BINDINGS.closeConnection(rawHandle),
|
|
97
|
+
owned ? (rawHandle) => _BINDINGS.closeConnection(rawHandle) : async () => {},
|
|
26
98
|
(rawHandle) => _BINDINGS.connectionClosed(rawHandle),
|
|
27
99
|
"connection"
|
|
28
100
|
);
|
|
101
|
+
this._listenerProxies = new Map();
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
async close() {
|
|
105
|
+
this._resetListenerProxies();
|
|
106
|
+
await super.close();
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
_resetListenerProxies() {
|
|
110
|
+
for (const { proxy, release } of this._listenerProxies.values()) {
|
|
111
|
+
proxy.reset?.();
|
|
112
|
+
release?.();
|
|
113
|
+
}
|
|
114
|
+
this._listenerProxies.clear();
|
|
29
115
|
}
|
|
30
116
|
|
|
31
117
|
async schema() {
|
|
@@ -36,6 +122,30 @@ export class Connection extends ResourceWrapper {
|
|
|
36
122
|
return toJsResult(await _BINDINGS.coreInvoke("opts", [this.rawHandle()]));
|
|
37
123
|
}
|
|
38
124
|
|
|
125
|
+
async datalogIndexCacheLimit(limit = null) {
|
|
126
|
+
if (hasValue(limit)) {
|
|
127
|
+
return toJsResult(
|
|
128
|
+
await callJavaMethod(this.rawHandle(), "datalogIndexCacheLimit", await toJava(limit))
|
|
129
|
+
);
|
|
130
|
+
}
|
|
131
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "datalogIndexCacheLimit"));
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
async maxEid() {
|
|
135
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "maxEid"));
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
async cardinality(attr) {
|
|
139
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "cardinality", await toJava(attr)));
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
async analyze(attr = null) {
|
|
143
|
+
if (hasValue(attr)) {
|
|
144
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "analyze", await toJava(attr)));
|
|
145
|
+
}
|
|
146
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "analyze"));
|
|
147
|
+
}
|
|
148
|
+
|
|
39
149
|
async updateSchema(schemaUpdate, { delAttrs = null, renameMap = null } = {}) {
|
|
40
150
|
const args = [
|
|
41
151
|
this.rawHandle(),
|
|
@@ -61,6 +171,12 @@ export class Connection extends ResourceWrapper {
|
|
|
61
171
|
}
|
|
62
172
|
|
|
63
173
|
async entity(eid) {
|
|
174
|
+
const { Entity } = await import("./entity.js");
|
|
175
|
+
const entity = await _BINDINGS.connectionEntity(this.rawHandle(), eid);
|
|
176
|
+
return entity === null || entity === undefined ? null : new Entity(entity);
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
async entityMap(eid) {
|
|
64
180
|
return toJsResult(await callJavaMethod(this.rawHandle(), "entityMap", await toJava(eid)));
|
|
65
181
|
}
|
|
66
182
|
|
|
@@ -138,10 +254,192 @@ export class Connection extends ResourceWrapper {
|
|
|
138
254
|
}
|
|
139
255
|
|
|
140
256
|
async transact(txData, txMeta = null) {
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
257
|
+
return toJsResult(
|
|
258
|
+
await _BINDINGS.connectionTransact(this.rawHandle(), txData, txMeta)
|
|
259
|
+
);
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
async transactAsync(txData, txMeta = null) {
|
|
263
|
+
const future = await _BINDINGS.connectionTransactAsync(this.rawHandle(), txData, txMeta);
|
|
264
|
+
return toJsResult(await callJavaMethod(future, "get"), { bridge: true });
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
async abortTransact() {
|
|
268
|
+
return toJsResult(await _BINDINGS.connectionAbortTransact(this.rawHandle()));
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
async txDataToSimulatedReport(txData) {
|
|
272
|
+
return txReportToJs(await _BINDINGS.connectionTxDataToSimulatedReport(this.rawHandle(), txData));
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
async listen(callback, key = null) {
|
|
276
|
+
const proxy = await createConsumerProxy(callback);
|
|
277
|
+
let registeredKey;
|
|
278
|
+
try {
|
|
279
|
+
registeredKey = hasValue(key)
|
|
280
|
+
? await toJsResult(await _BINDINGS.connectionListen(this.rawHandle(), key, proxy), { bridge: true })
|
|
281
|
+
: await toJsResult(await _BINDINGS.connectionListen(this.rawHandle(), proxy), { bridge: true });
|
|
282
|
+
} catch (error) {
|
|
283
|
+
proxy.reset?.();
|
|
284
|
+
throw error;
|
|
285
|
+
}
|
|
286
|
+
const previous = this._listenerProxies.get(registeredKey);
|
|
287
|
+
previous?.proxy.reset?.();
|
|
288
|
+
previous?.release?.();
|
|
289
|
+
this._listenerProxies.set(registeredKey, {
|
|
290
|
+
proxy,
|
|
291
|
+
release: await retainListenerProxyEventLoop()
|
|
292
|
+
});
|
|
293
|
+
return registeredKey;
|
|
294
|
+
}
|
|
295
|
+
|
|
296
|
+
async unlisten(key) {
|
|
297
|
+
await _BINDINGS.connectionUnlisten(this.rawHandle(), key);
|
|
298
|
+
const existing = this._listenerProxies.get(key);
|
|
299
|
+
existing?.proxy.reset?.();
|
|
300
|
+
existing?.release?.();
|
|
301
|
+
this._listenerProxies.delete(key);
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
async fillDb(datoms) {
|
|
305
|
+
await callJavaMethod(this.rawHandle(), "fillDb", await toJava(datoms));
|
|
306
|
+
return this;
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
async datalogKv() {
|
|
310
|
+
const { KV } = await import("./kv.js");
|
|
311
|
+
return new KV(await callJavaMethod(this.rawHandle(), "datalogKV"), { owned: false });
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
async reIndex(opts = null, { schema = null } = {}) {
|
|
315
|
+
this._handle = await _BINDINGS.connectionReIndex(this.rawHandle(), schema, opts);
|
|
316
|
+
return this;
|
|
317
|
+
}
|
|
318
|
+
|
|
319
|
+
async datoms(index, { c1 = null, c2 = null, c3 = null, limit = null, offset = 0 } = {}) {
|
|
320
|
+
const capped = fetchLimit(limit, offset);
|
|
321
|
+
const args = [this.rawHandle(), "datoms", await toJava(index), await toJava(c1), await toJava(c2), await toJava(c3)];
|
|
322
|
+
if (hasValue(capped)) {
|
|
323
|
+
args.push(await toJava(capped));
|
|
324
|
+
}
|
|
325
|
+
const rows = await toJsResult(
|
|
326
|
+
await callJavaMethod(...args),
|
|
327
|
+
{ bridge: true }
|
|
328
|
+
);
|
|
329
|
+
return sliceRows(rows, { limit, offset });
|
|
330
|
+
}
|
|
331
|
+
|
|
332
|
+
async searchDatoms({ e = null, attr = null, value = null, limit = null, offset = 0 } = {}) {
|
|
333
|
+
const rows = await toJsResult(
|
|
334
|
+
await callJavaMethod(this.rawHandle(), "searchDatoms", await toJava(e), await toJava(attr), await toJava(value)),
|
|
335
|
+
{ bridge: true }
|
|
336
|
+
);
|
|
337
|
+
return sliceRows(rows, { limit, offset });
|
|
338
|
+
}
|
|
339
|
+
|
|
340
|
+
async countDatoms({ e = null, attr = null, value = null } = {}) {
|
|
341
|
+
return toJsResult(
|
|
342
|
+
await callJavaMethod(this.rawHandle(), "countDatoms", await toJava(e), await toJava(attr), await toJava(value))
|
|
343
|
+
);
|
|
344
|
+
}
|
|
345
|
+
|
|
346
|
+
async seekDatoms(index, { c1 = null, c2 = null, c3 = null, limit = null, offset = 0 } = {}) {
|
|
347
|
+
const capped = fetchLimit(limit, offset);
|
|
348
|
+
const args = [
|
|
349
|
+
this.rawHandle(),
|
|
350
|
+
"seekDatoms",
|
|
351
|
+
await toJava(index),
|
|
352
|
+
await toJava(c1),
|
|
353
|
+
await toJava(c2),
|
|
354
|
+
await toJava(c3)
|
|
355
|
+
];
|
|
356
|
+
if (hasValue(capped)) {
|
|
357
|
+
args.push(await toJava(capped));
|
|
358
|
+
}
|
|
359
|
+
const rows = await toJsResult(
|
|
360
|
+
await callJavaMethod(...args),
|
|
361
|
+
{ bridge: true }
|
|
362
|
+
);
|
|
363
|
+
return sliceRows(rows, { limit, offset });
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
async rseekDatoms(index, { c1 = null, c2 = null, c3 = null, limit = null, offset = 0 } = {}) {
|
|
367
|
+
const capped = fetchLimit(limit, offset);
|
|
368
|
+
const args = [
|
|
369
|
+
this.rawHandle(),
|
|
370
|
+
"rseekDatoms",
|
|
371
|
+
await toJava(index),
|
|
372
|
+
await toJava(c1),
|
|
373
|
+
await toJava(c2),
|
|
374
|
+
await toJava(c3)
|
|
375
|
+
];
|
|
376
|
+
if (hasValue(capped)) {
|
|
377
|
+
args.push(await toJava(capped));
|
|
378
|
+
}
|
|
379
|
+
const rows = await toJsResult(
|
|
380
|
+
await callJavaMethod(...args),
|
|
381
|
+
{ bridge: true }
|
|
382
|
+
);
|
|
383
|
+
return sliceRows(rows, { limit, offset });
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
async indexRange(attr, start, end, { limit = null, offset = 0 } = {}) {
|
|
387
|
+
const rows = await toJsResult(
|
|
388
|
+
await callJavaMethod(this.rawHandle(), "indexRange", await toJava(attr), await toJava(start), await toJava(end)),
|
|
389
|
+
{ bridge: true }
|
|
390
|
+
);
|
|
391
|
+
return sliceRows(rows, { limit, offset });
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
async fulltextDatoms(query, { opts = null, limit = null, offset = 0, pagingCachePages = null } = {}) {
|
|
395
|
+
const searchOpts = fulltextOpts(opts, { limit, offset, pagingCachePages });
|
|
396
|
+
const result = hasValue(searchOpts)
|
|
397
|
+
? await callJavaMethod(this.rawHandle(), "fulltextDatoms", query, await toJava(searchOpts))
|
|
398
|
+
: await callJavaMethod(this.rawHandle(), "fulltextDatoms", query);
|
|
399
|
+
return toJsResult(
|
|
400
|
+
result,
|
|
401
|
+
{ bridge: true }
|
|
402
|
+
);
|
|
403
|
+
}
|
|
404
|
+
|
|
405
|
+
async copy(dest, { compact = null } = {}) {
|
|
406
|
+
if (hasValue(compact)) {
|
|
407
|
+
await callJavaMethod(this.rawHandle(), "copy", dest, Boolean(compact));
|
|
408
|
+
return;
|
|
409
|
+
}
|
|
410
|
+
await callJavaMethod(this.rawHandle(), "copy", dest);
|
|
411
|
+
}
|
|
412
|
+
|
|
413
|
+
async txLogWatermarks() {
|
|
414
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "txLogWatermarks"), { bridge: true });
|
|
415
|
+
}
|
|
416
|
+
|
|
417
|
+
async openTxLog(fromLsn, { uptoLsn = null, limit = null } = {}) {
|
|
418
|
+
const result = hasValue(uptoLsn)
|
|
419
|
+
? await callJavaMethod(this.rawHandle(), "openTxLog", await toJava(fromLsn), await toJava(uptoLsn))
|
|
420
|
+
: await callJavaMethod(this.rawHandle(), "openTxLog", await toJava(fromLsn));
|
|
421
|
+
const rows = await toJsResult(result, { bridge: true });
|
|
422
|
+
if (limit === null || limit === undefined) {
|
|
423
|
+
return rows;
|
|
424
|
+
}
|
|
425
|
+
return rows.slice(0, Math.max(limit, 0));
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
async createSnapshot() {
|
|
429
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "createSnapshot"), { bridge: true });
|
|
430
|
+
}
|
|
431
|
+
|
|
432
|
+
async listSnapshots() {
|
|
433
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "listSnapshots"), { bridge: true });
|
|
434
|
+
}
|
|
435
|
+
|
|
436
|
+
async gcTxLogSegments({ retainFloorLsn = null } = {}) {
|
|
437
|
+
if (hasValue(retainFloorLsn)) {
|
|
438
|
+
return toJsResult(
|
|
439
|
+
await callJavaMethod(this.rawHandle(), "gcTxLogSegments", await toJava(retainFloorLsn)),
|
|
440
|
+
{ bridge: true }
|
|
441
|
+
);
|
|
144
442
|
}
|
|
145
|
-
return toJsResult(await
|
|
443
|
+
return toJsResult(await callJavaMethod(this.rawHandle(), "gcTxLogSegments"), { bridge: true });
|
|
146
444
|
}
|
|
147
445
|
}
|
package/src/database.js
ADDED
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
import { toEdnForm, toJava } from "./convert.js";
|
|
2
|
+
import { _BINDINGS } from "./interop.js";
|
|
3
|
+
import { callJavaMethod } from "./jvm.js";
|
|
4
|
+
import { toJsResult } from "./result.js";
|
|
5
|
+
|
|
6
|
+
async function pullSelector(value) {
|
|
7
|
+
if (typeof value === "string") {
|
|
8
|
+
return value;
|
|
9
|
+
}
|
|
10
|
+
return toEdnForm(value);
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
function hasValue(value) {
|
|
14
|
+
return value !== null && value !== undefined;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
async function mapGet(map, key) {
|
|
18
|
+
return callJavaMethod(map, "get", await _BINDINGS.keyword(key));
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
export class Database {
|
|
22
|
+
constructor(handle) {
|
|
23
|
+
this._handle = handle;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
rawHandle() {
|
|
27
|
+
return this._handle;
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
toString() {
|
|
31
|
+
return "<Database>";
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
async entid(eid) {
|
|
35
|
+
return toJsResult(await _BINDINGS.databaseEntid(this.rawHandle(), eid), { bridge: true });
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
async entity(eid) {
|
|
39
|
+
const { Entity } = await import("./entity.js");
|
|
40
|
+
const entity = await _BINDINGS.databaseEntity(this.rawHandle(), eid);
|
|
41
|
+
return hasValue(entity) ? new Entity(entity) : null;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
async entityMap(eid) {
|
|
45
|
+
return toJsResult(await _BINDINGS.databaseEntityMap(this.rawHandle(), eid), { bridge: true });
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
async pull(selector, eid) {
|
|
49
|
+
return toJsResult(
|
|
50
|
+
await _BINDINGS.databasePull(this.rawHandle(), await pullSelector(selector), await toJava(eid)),
|
|
51
|
+
{ bridge: true }
|
|
52
|
+
);
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
async pullMany(selector, eids) {
|
|
56
|
+
return toJsResult(
|
|
57
|
+
await _BINDINGS.databasePullMany(this.rawHandle(), await pullSelector(selector), await toJava(eids)),
|
|
58
|
+
{ bridge: true }
|
|
59
|
+
);
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
async cardinality(attr) {
|
|
63
|
+
return toJsResult(await _BINDINGS.databaseCardinality(this.rawHandle(), await toJava(attr)), { bridge: true });
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
async analyze(attr = null) {
|
|
67
|
+
return toJsResult(await _BINDINGS.databaseAnalyze(this.rawHandle(), attr), { bridge: true });
|
|
68
|
+
}
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
export async function txReportToJs(report) {
|
|
72
|
+
const result = {};
|
|
73
|
+
const dbBefore = await mapGet(report, ":db-before");
|
|
74
|
+
const dbAfter = await mapGet(report, ":db-after");
|
|
75
|
+
if (hasValue(dbBefore)) {
|
|
76
|
+
result[":db-before"] = new Database(dbBefore);
|
|
77
|
+
}
|
|
78
|
+
if (hasValue(dbAfter)) {
|
|
79
|
+
result[":db-after"] = new Database(dbAfter);
|
|
80
|
+
}
|
|
81
|
+
for (const key of [":tx-data", ":tempids", ":tx-id", ":tx-meta"]) {
|
|
82
|
+
result[key] = await toJsResult(await mapGet(report, key), { bridge: true });
|
|
83
|
+
}
|
|
84
|
+
return result;
|
|
85
|
+
}
|
package/src/entity.js
ADDED
|
@@ -0,0 +1,171 @@
|
|
|
1
|
+
import { isJavaObject, toJs } from "./convert.js";
|
|
2
|
+
import { _BINDINGS } from "./interop.js";
|
|
3
|
+
import { classes } from "./jvm.js";
|
|
4
|
+
|
|
5
|
+
function materializeJavaCollection(collection) {
|
|
6
|
+
if (typeof collection?.toArraySync === "function") {
|
|
7
|
+
try {
|
|
8
|
+
const items = collection.toArraySync();
|
|
9
|
+
return Array.isArray(items) ? items : Array.from(items);
|
|
10
|
+
} catch {
|
|
11
|
+
// Fall back to iterator-based traversal when array materialization is unsupported.
|
|
12
|
+
}
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
const items = [];
|
|
16
|
+
const iterator = collection.iteratorSync();
|
|
17
|
+
while (iterator.hasNextSync()) {
|
|
18
|
+
items.push(iterator.nextSync());
|
|
19
|
+
}
|
|
20
|
+
return items;
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
function instanceOf(value, type) {
|
|
24
|
+
if (value === null || typeof value !== "object" || typeof value.instanceOf !== "function") {
|
|
25
|
+
return false;
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
try {
|
|
29
|
+
return value.instanceOf(type);
|
|
30
|
+
} catch {
|
|
31
|
+
return false;
|
|
32
|
+
}
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
function isPlainObject(value) {
|
|
36
|
+
if (value === null || typeof value !== "object") {
|
|
37
|
+
return false;
|
|
38
|
+
}
|
|
39
|
+
const prototype = Object.getPrototypeOf(value);
|
|
40
|
+
return prototype === Object.prototype || prototype === null;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
async function entityValue(value) {
|
|
44
|
+
if (
|
|
45
|
+
value === null
|
|
46
|
+
|| typeof value === "boolean"
|
|
47
|
+
|| typeof value === "number"
|
|
48
|
+
|| typeof value === "string"
|
|
49
|
+
|| typeof value === "bigint"
|
|
50
|
+
) {
|
|
51
|
+
return value;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
if (Array.isArray(value)) {
|
|
55
|
+
return Promise.all(value.map((item) => entityValue(item)));
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
if (!isJavaObject(value)) {
|
|
59
|
+
if (value instanceof Set) {
|
|
60
|
+
const items = [];
|
|
61
|
+
for (const item of value) {
|
|
62
|
+
items.push(await entityValue(item));
|
|
63
|
+
}
|
|
64
|
+
return new Set(items);
|
|
65
|
+
}
|
|
66
|
+
if (value instanceof Map) {
|
|
67
|
+
const entries = [];
|
|
68
|
+
for (const [key, item] of value) {
|
|
69
|
+
entries.push([await entityValue(key), await entityValue(item)]);
|
|
70
|
+
}
|
|
71
|
+
return new Map(entries);
|
|
72
|
+
}
|
|
73
|
+
if (isPlainObject(value)) {
|
|
74
|
+
const result = {};
|
|
75
|
+
for (const [key, item] of Object.entries(value)) {
|
|
76
|
+
result[key] = await entityValue(item);
|
|
77
|
+
}
|
|
78
|
+
return result;
|
|
79
|
+
}
|
|
80
|
+
return value;
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
if (await _BINDINGS.entityIs(value)) {
|
|
84
|
+
return new Entity(value);
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
const cls = await classes();
|
|
88
|
+
|
|
89
|
+
if (instanceOf(value, cls.mapType) || typeof value.entrySetSync === "function") {
|
|
90
|
+
const entries = [];
|
|
91
|
+
for (const entry of materializeJavaCollection(value.entrySetSync())) {
|
|
92
|
+
entries.push([await toJs(entry.getKeySync()), await entityValue(entry.getValueSync())]);
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
if (entries.every(([key]) => typeof key === "string")) {
|
|
96
|
+
return Object.fromEntries(entries);
|
|
97
|
+
}
|
|
98
|
+
return new Map(entries);
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
if (instanceOf(value, cls.setType)) {
|
|
102
|
+
const items = [];
|
|
103
|
+
for (const item of materializeJavaCollection(value)) {
|
|
104
|
+
items.push(await entityValue(item));
|
|
105
|
+
}
|
|
106
|
+
return new Set(items);
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
if (
|
|
110
|
+
instanceOf(value, cls.listType)
|
|
111
|
+
|| instanceOf(value, cls.collectionType)
|
|
112
|
+
|| typeof value.iteratorSync === "function"
|
|
113
|
+
) {
|
|
114
|
+
const items = [];
|
|
115
|
+
for (const item of materializeJavaCollection(value)) {
|
|
116
|
+
items.push(await entityValue(item));
|
|
117
|
+
}
|
|
118
|
+
return items;
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
return toJs(value);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
export class Entity {
|
|
125
|
+
constructor(handle) {
|
|
126
|
+
this.handle = handle;
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
rawHandle() {
|
|
130
|
+
return this.handle;
|
|
131
|
+
}
|
|
132
|
+
|
|
133
|
+
async id() {
|
|
134
|
+
return toJs(await _BINDINGS.entityId(this.rawHandle()));
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
async has(attr) {
|
|
138
|
+
return _BINDINGS.entityContains(this.rawHandle(), attr);
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
async get(attr, defaultValue = undefined) {
|
|
142
|
+
if (!(await this.has(attr))) {
|
|
143
|
+
return defaultValue;
|
|
144
|
+
}
|
|
145
|
+
return entityValue(await _BINDINGS.entityGet(this.rawHandle(), attr));
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
async touch() {
|
|
149
|
+
return toJs(await _BINDINGS.entityTouch(this.rawHandle()));
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
async entries() {
|
|
153
|
+
const value = await this.touch();
|
|
154
|
+
if (value instanceof Map) {
|
|
155
|
+
return Array.from(value.entries());
|
|
156
|
+
}
|
|
157
|
+
return Object.entries(value ?? {});
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
async keys() {
|
|
161
|
+
return (await this.entries()).map(([key]) => key);
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
async values() {
|
|
165
|
+
return (await this.entries()).map(([, value]) => value);
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
toString() {
|
|
169
|
+
return "<Entity lazy>";
|
|
170
|
+
}
|
|
171
|
+
}
|
package/src/index.js
CHANGED
|
@@ -1,5 +1,7 @@
|
|
|
1
1
|
export { Client } from "./client.js";
|
|
2
2
|
export { Connection } from "./connection.js";
|
|
3
|
+
export { Database } from "./database.js";
|
|
4
|
+
export { Entity } from "./entity.js";
|
|
3
5
|
export {
|
|
4
6
|
DatalevinConfigurationError,
|
|
5
7
|
DatalevinError,
|
|
@@ -7,13 +9,77 @@ export {
|
|
|
7
9
|
DatalevinJvmError
|
|
8
10
|
} from "./errors.js";
|
|
9
11
|
export {
|
|
12
|
+
abortTransact,
|
|
13
|
+
analyze,
|
|
10
14
|
apiInfo,
|
|
15
|
+
cardinality,
|
|
11
16
|
connect,
|
|
17
|
+
datom,
|
|
18
|
+
datomA,
|
|
19
|
+
datomAdded,
|
|
20
|
+
datomE,
|
|
21
|
+
datomIs,
|
|
22
|
+
datomTx,
|
|
23
|
+
datomV,
|
|
24
|
+
datalogKv,
|
|
25
|
+
embeddingAttr,
|
|
26
|
+
embeddingOptions,
|
|
12
27
|
execJson,
|
|
28
|
+
explicitTransactionTimeout,
|
|
29
|
+
fillDb,
|
|
30
|
+
fulltextAttr,
|
|
31
|
+
idocAttr,
|
|
32
|
+
idocDomain,
|
|
33
|
+
idocOptions,
|
|
34
|
+
initDb,
|
|
13
35
|
jvmStarted,
|
|
36
|
+
keyword,
|
|
37
|
+
maxEid,
|
|
14
38
|
newClient,
|
|
39
|
+
newLlamaEmbedder,
|
|
40
|
+
newLlamaGenerator,
|
|
41
|
+
newSearchEngine,
|
|
42
|
+
newVectorIndex,
|
|
15
43
|
openKv,
|
|
16
|
-
|
|
44
|
+
readEdn,
|
|
45
|
+
reIndex,
|
|
46
|
+
schemaAttr,
|
|
47
|
+
searchIndexWriter,
|
|
48
|
+
searchDomain,
|
|
49
|
+
searchOptions,
|
|
50
|
+
setExplicitTransactionTimeout,
|
|
51
|
+
startJvm,
|
|
52
|
+
symbol,
|
|
53
|
+
transact,
|
|
54
|
+
transactAsync,
|
|
55
|
+
txDataToSimulatedReport,
|
|
56
|
+
txAdd,
|
|
57
|
+
txEntity,
|
|
58
|
+
txEnsure,
|
|
59
|
+
txRetract,
|
|
60
|
+
txRetractEntity,
|
|
61
|
+
vectorAttr,
|
|
62
|
+
vectorOptions,
|
|
63
|
+
withTransaction,
|
|
64
|
+
writeEdn
|
|
17
65
|
} from "./interop.js";
|
|
18
66
|
export { interop } from "./raw.js";
|
|
19
|
-
export { KV } from "./kv.js";
|
|
67
|
+
export { KV, KVTransaction, RawBuffer, RawKV } from "./kv.js";
|
|
68
|
+
export { LlamaEmbedder, LlamaGenerator } from "./llm.js";
|
|
69
|
+
export {
|
|
70
|
+
SearchEngine,
|
|
71
|
+
SearchIndexWriter,
|
|
72
|
+
createAnalyzer,
|
|
73
|
+
createMaxLengthTokenFilter,
|
|
74
|
+
createMinLengthTokenFilter,
|
|
75
|
+
createNgramTokenFilter,
|
|
76
|
+
createRegexpTokenizer,
|
|
77
|
+
createStemmingTokenFilter,
|
|
78
|
+
createStopWordsTokenFilter,
|
|
79
|
+
enStopWordsTokenFilter,
|
|
80
|
+
lowerCaseTokenFilter,
|
|
81
|
+
prefixTokenFilter,
|
|
82
|
+
unaccentTokenFilter
|
|
83
|
+
} from "./search.js";
|
|
84
|
+
export { UdfRegistry, createUdfRegistry, udfDescriptor } from "./udf.js";
|
|
85
|
+
export { VectorIndex } from "./vector.js";
|