datalevin-node 1.0.0 → 1.1.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/src/udf.js CHANGED
@@ -1,14 +1,16 @@
1
1
  import { toJava, toJs } from "./convert.js";
2
+ import { Database } from "./database.js";
2
3
  import { _BINDINGS } from "./interop.js";
3
4
  import { javaBridgeModule } from "./jvm.js";
5
+ import { UdfDescriptor, descriptorData } from "./udf-value.js";
4
6
 
5
- function keywordString(value) {
6
- const text = String(value);
7
- return text.startsWith(":") ? text : `:${text}`;
8
- }
7
+ const DATABASE_CLASSES = new Set([
8
+ "datalevin.db.DB",
9
+ "datalevin.DatabaseValue"
10
+ ]);
9
11
 
10
12
  function descriptorKey(descriptor) {
11
- const normalized = udfDescriptor(descriptor);
13
+ const normalized = descriptorData(descriptor);
12
14
  return [
13
15
  normalized[":udf/lang"],
14
16
  normalized[":udf/kind"],
@@ -38,50 +40,56 @@ function materializeJavaArgs(args) {
38
40
  return items;
39
41
  }
40
42
 
41
- async function txUdfArgsToJs(args) {
43
+ function materializeUdfArgs(args) {
42
44
  if (Array.isArray(args)) {
43
- if (args.length === 0) {
44
- return args;
45
- }
46
- const convertedTail = await Promise.all(args.slice(1).map((value) => toJs(value)));
47
- return [args[0], ...convertedTail];
45
+ return args;
48
46
  }
49
-
50
47
  if (typeof args?.sizeSync === "function" && typeof args?.getSync === "function") {
48
+ const values = [];
51
49
  const size = Number(args.sizeSync());
52
- if (size === 0) {
53
- return [];
50
+ for (let index = 0; index < size; index += 1) {
51
+ try {
52
+ values.push(args.getSync(index));
53
+ } catch (error) {
54
+ const message = String(error?.message ?? error);
55
+ if (index === 0 && message.includes("ClassNotFoundException: datalevin.db.DB")) {
56
+ // Runtime jars before the DatabaseValue UDF bridge could not expose
57
+ // the generated Clojure DB class to Node. Preserve their historical
58
+ // null argument while newer runtimes provide an idiomatic Database.
59
+ values.push(null);
60
+ continue;
61
+ }
62
+ throw error;
63
+ }
54
64
  }
55
-
56
- const values = [null];
57
- for (let index = 1; index < size; index += 1) {
58
- values.push(await toJs(args.getSync(index)));
59
- }
60
- return values;
61
- }
62
-
63
- const values = materializeJavaArgs(args);
64
- if (values.length === 0) {
65
65
  return values;
66
66
  }
67
- const convertedTail = await Promise.all(values.slice(1).map((value) => toJs(value)));
68
- return [values[0], ...convertedTail];
67
+ return materializeJavaArgs(args);
69
68
  }
70
69
 
71
- async function udfArgsToJs(args, descriptor) {
72
- if (descriptor[":udf/kind"] !== ":tx-fn") {
73
- const jsArgs = await toJs(args);
74
- return Array.isArray(jsArgs) ? jsArgs : [jsArgs];
70
+ function javaClassName(value) {
71
+ try {
72
+ return value.getClassSync().getNameSync();
73
+ } catch {
74
+ return null;
75
75
  }
76
+ }
76
77
 
77
- return txUdfArgsToJs(args);
78
+ async function udfArgsToJs(args) {
79
+ const values = materializeUdfArgs(args);
80
+ return Promise.all(values.map(async (value) => {
81
+ if (DATABASE_CLASSES.has(javaClassName(value))) {
82
+ return new Database(value);
83
+ }
84
+ return toJs(value);
85
+ }));
78
86
  }
79
87
 
80
- async function createProxy(fn, descriptor) {
88
+ async function createProxy(fn) {
81
89
  const { newProxy } = await javaBridgeModule();
82
90
  return newProxy("datalevin.UdfFunction", {
83
91
  invoke: async (args) => {
84
- const values = await udfArgsToJs(args, descriptor);
92
+ const values = await udfArgsToJs(args);
85
93
  const result = await fn(...values);
86
94
  return toJava(result === undefined ? null : result);
87
95
  }
@@ -93,29 +101,7 @@ export function udfDescriptor(idOrDescriptor, {
93
101
  lang = ":java",
94
102
  version = null
95
103
  } = {}) {
96
- if (idOrDescriptor !== null && typeof idOrDescriptor === "object") {
97
- const descriptor = idOrDescriptor;
98
- const id = descriptor[":udf/id"] ?? descriptor.id ?? descriptor.udfId;
99
- return udfDescriptor(id, {
100
- kind: descriptor[":udf/kind"] ?? descriptor.kind ?? kind,
101
- lang: descriptor[":udf/lang"] ?? descriptor.lang ?? lang,
102
- version: descriptor[":udf/version"] ?? descriptor.version ?? version
103
- });
104
- }
105
-
106
- if (idOrDescriptor === null || idOrDescriptor === undefined) {
107
- throw new TypeError("udf id is required");
108
- }
109
-
110
- const descriptor = {
111
- ":udf/lang": keywordString(lang),
112
- ":udf/kind": keywordString(kind),
113
- ":udf/id": keywordString(idOrDescriptor)
114
- };
115
- if (version !== null && version !== undefined) {
116
- descriptor[":udf/version"] = version;
117
- }
118
- return descriptor;
104
+ return descriptorData(idOrDescriptor, { kind, lang, version });
119
105
  }
120
106
 
121
107
  export class UdfRegistry {
@@ -133,15 +119,15 @@ export class UdfRegistry {
133
119
  throw new TypeError("fn must be a function");
134
120
  }
135
121
 
136
- const normalized = udfDescriptor(descriptor);
137
- const proxy = await createProxy(fn, normalized);
122
+ const normalized = UdfDescriptor.from(descriptor, { defaultLang: "javascript" });
123
+ const proxy = await createProxy(fn);
138
124
  await _BINDINGS.registerUdf(this._handle, normalized, proxy);
139
125
  this._proxies.set(descriptorKey(normalized), proxy);
140
126
  return fn;
141
127
  }
142
128
 
143
129
  async unregister(descriptor) {
144
- const normalized = udfDescriptor(descriptor);
130
+ const normalized = UdfDescriptor.from(descriptor, { defaultLang: "javascript" });
145
131
  await _BINDINGS.unregisterUdf(this._handle, normalized);
146
132
  const key = descriptorKey(normalized);
147
133
  const proxy = this._proxies.get(key);
@@ -152,30 +138,35 @@ export class UdfRegistry {
152
138
  }
153
139
 
154
140
  async registered(descriptor) {
155
- return _BINDINGS.registeredUdf(this._handle, udfDescriptor(descriptor));
141
+ return _BINDINGS.registeredUdf(
142
+ this._handle,
143
+ UdfDescriptor.from(descriptor, { defaultLang: "javascript" })
144
+ );
156
145
  }
157
146
 
158
147
  async queryUdf(id, fn, options = {}) {
159
- return this.register(udfDescriptor(id, { ...options, kind: ":query-fn" }), fn);
148
+ return this.register(UdfDescriptor.queryFn(id, options), fn);
160
149
  }
161
150
 
162
151
  async predicateUdf(id, fn, options = {}) {
163
- return this.register(udfDescriptor(id, { ...options, kind: ":predicate" }), fn);
152
+ return this.register(UdfDescriptor.predicate(id, options), fn);
164
153
  }
165
154
 
166
155
  async txUdf(id, fn, options = {}) {
167
- return this.register(udfDescriptor(id, { ...options, kind: ":tx-fn" }), fn);
156
+ return this.register(UdfDescriptor.txFn(id, options), fn);
168
157
  }
169
158
 
170
159
  async analyzerUdf(id, fn, options = {}) {
171
- return this.register(udfDescriptor(id, { ...options, kind: ":analyzer" }), fn);
160
+ return this.register(UdfDescriptor.analyzer(id, options), fn);
172
161
  }
173
162
 
174
163
  async queryAnalyzerUdf(id, fn, options = {}) {
175
- return this.register(udfDescriptor(id, { ...options, kind: ":query-analyzer" }), fn);
164
+ return this.register(UdfDescriptor.queryAnalyzer(id, options), fn);
176
165
  }
177
166
  }
178
167
 
179
168
  export async function createUdfRegistry() {
180
169
  return new UdfRegistry(await _BINDINGS.createUdfRegistry());
181
170
  }
171
+
172
+ export { UdfDescriptor };