@neo4j-labs/experimental-query-api-wrapper 0.0.1-alpha05 → 0.0.1-alpha06

package/lib/http-connection/codec.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [https://neo4j.com]
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export const NEO4J_QUERY_CONTENT_TYPE = 'application/vnd.neo4j.query';
+export function encodeAuthToken(auth) {
+    switch (auth.scheme) {
+        case 'bearer':
+            return `Bearer ${btoa(auth.credentials)}`;
+        case 'basic':
+            return `Basic ${btoa(`${auth.principal}:${auth.credentials}`)}`;
+        default:
+            throw new Error(`Authorization scheme "${auth.scheme}" is not supported.`);
+    }
+}
+export function encodeTransactionBody(config) {
+    const body = {};
+    if (config?.bookmarks != null && !config.bookmarks.isEmpty()) {
+        body.bookmarks = config?.bookmarks?.values();
+    }
+    if (config?.txConfig.timeout != null) {
+        body.maxExecutionTime = config?.txConfig.timeout.toInt();
+    }
+    if (config?.impersonatedUser != null) {
+        body.impersonatedUser = config?.impersonatedUser;
+    }
+    if (config?.mode) {
+        body.accessMode = config.mode.toUpperCase();
+    }
+    return body;
+}

package/lib/http-connection/connection.http.js

@@ -17,6 +17,8 @@
 import { Connection, newError } from "neo4j-driver-core";
 import { ResultStreamObserver } from "./stream-observers";
 import { QueryRequestCodec, QueryResponseCodec } from "./query.codec";
+import { BeginTransactionRequestCodec, BeginTransactionResponseCodec, CommitTransactionRequestCodec, CommitTransactionResponseCodec, RollbackTransactionRequestCodec, RollbackTransactionResponseCodec } from "./transaction.codec";
+import Pipe from "./lang/pipe";
 let currentId = 0;
 export default class HttpConnection extends Connection {
     constructor(config) {
@@ -29,43 +31,36 @@ export default class HttpConnection extends Connection {
         this._log = config.logger;
         this._errorHandler = config.errorHandler;
         this._open = true;
+        this._currentTx = undefined;
+        this._workPipe = new Pipe(config.logger);
+        this._abortControllers = [];
+        this._sessionAffinityHeader = config.config.httpSessionAffinityHeader ?? 'neo4j-cluster-affinity';
     }
     run(query, parameters, config) {
         const observer = new ResultStreamObserver({
             highRecordWatermark: config?.highRecordWatermark ?? Number.MAX_SAFE_INTEGER,
             lowRecordWatermark: config?.lowRecordWatermark ?? Number.MIN_SAFE_INTEGER,
             afterComplete: config?.afterComplete,
+            beforeError: config?.beforeError,
             server: this._address,
         });
         const requestCodec = QueryRequestCodec.of(this._auth, query, parameters, config);
-        this._abortController = new AbortController();
-        const request = {
-            url: this._getTransactionApi(config?.database),
-            method: 'POST',
-            mode: 'cors',
-            headers: {
-                'Content-Type': requestCodec.contentType,
-                Accept: requestCodec.accept,
-                Authorization: requestCodec.authorization,
-            },
-            signal: this._abortController.signal,
-            body: JSON.stringify(requestCodec.body)
-        };
-        this._log?.debug(`${this} REQUEST: ${JSON.stringify(request)} `);
-        fetch(request.url, request).
-            then(async (res) => {
-            return [res.headers.get('content-type'), (await res.json())];
-        })
-            .catch((error) => this._handleAndReThrown(newError(`Failure accessing "${request.url}"`, 'SERVICE_UNAVAILABLE', error)))
-            .catch((error) => observer.onError(error))
-            .then(async ([contentType, rawQueryResponse]) => {
-            if (rawQueryResponse == null) {
-                // is already dead
-                return;
-            }
+        const abortController = this._newAbortController();
+        this._workPipe.attach(async () => {
+            const request = {
+                url: this._getTransactionApi(config?.database),
+                method: 'POST',
+                mode: 'cors',
+                headers: this._headers(requestCodec),
+                signal: abortController.signal,
+                body: JSON.stringify(requestCodec.body)
+            };
+            this._log?.debug(`${this} REQUEST: ${JSON.stringify(request)}`);
+            const res = await fetch(request.url, request);
+            const { body: rawQueryResponse, headers: [contentType] } = await readBodyAndReaders(request.url, res, 'content-type');
             this._log?.debug(`${this} ${JSON.stringify(rawQueryResponse)}`);
             const batchSize = config?.fetchSize ?? Number.MAX_SAFE_INTEGER;
-            const codec = QueryResponseCodec.of(this._config, contentType, rawQueryResponse);
+            const codec = QueryResponseCodec.of(this._config, contentType ?? '', rawQueryResponse);
             if (codec.error) {
                 throw codec.error;
             }
@@ -88,18 +83,145 @@ export default class HttpConnection extends Connection {
             }
             observer.onCompleted(codec.meta);
         })
-            .catch(this._handleAndReThrown.bind(this))
-            .catch(error => observer.onError(error))
-            .finally(() => {
-            this._abortController = undefined;
+            .catch(this._catch(observer))
+            .finally(this._finally(abortController));
+        return observer;
+    }
+    _headers(requestCodec) {
+        const headers = {
+            'Content-Type': requestCodec.contentType,
+            Accept: requestCodec.accept,
+            Authorization: requestCodec.authorization,
+        };
+        if (this._currentTx?.affinity != null) {
+            headers[this._sessionAffinityHeader] = this._currentTx.affinity;
+        }
+        return headers;
+    }
+    beginTransaction(config) {
+        const observer = new ResultStreamObserver({
+            server: this._address,
+            afterComplete: config?.afterComplete,
+            beforeError: config.beforeError,
+            highRecordWatermark: Number.MAX_SAFE_INTEGER,
+            lowRecordWatermark: Number.MIN_SAFE_INTEGER,
         });
+        observer.prepareToHandleSingleResponse();
+        const requestCodec = BeginTransactionRequestCodec.of(this._auth, config);
+        const abortController = this._newAbortController();
+        this._workPipe.attach(async () => {
+            const request = {
+                url: this._getExplicityTransactionApi(config?.database),
+                method: 'POST',
+                mode: 'cors',
+                headers: this._headers(requestCodec),
+                signal: abortController.signal,
+                body: JSON.stringify(requestCodec.body)
+            };
+            this._log?.debug(`${this} REQUEST: ${JSON.stringify(request)} `);
+            const res = await fetch(request.url, request);
+            const { body: rawBeginTransactionResponse, headers: [contentType, affinity] } = await readBodyAndReaders(request.url, res, 'content-type', this._sessionAffinityHeader);
+            this._log?.debug(`${this} ${JSON.stringify(rawBeginTransactionResponse)}`);
+            const codec = BeginTransactionResponseCodec.of(this._config, contentType ?? '', rawBeginTransactionResponse);
+            if (codec.error != null) {
+                throw codec.error;
+            }
+            this._currentTx = {
+                id: codec.id,
+                host: codec.host,
+                expires: codec.expires,
+                database: config?.database,
+            };
+            if (affinity != null) {
+                this._currentTx.affinity = affinity;
+            }
+            observer.onCompleted({});
+        })
+            .catch(this._catch(observer))
+            .finally(this._finally(abortController));
+        return observer;
+    }
+    commitTransaction(config) {
+        const observer = new ResultStreamObserver({
+            server: this._address,
+            afterComplete: config?.afterComplete,
+            beforeError: config.beforeError,
+            highRecordWatermark: Number.MAX_SAFE_INTEGER,
+            lowRecordWatermark: Number.MIN_SAFE_INTEGER,
+        });
+        observer.prepareToHandleSingleResponse();
+        const requestCodec = CommitTransactionRequestCodec.of(this._auth, config);
+        const abortController = this._newAbortController();
+        this._workPipe.attach(async () => {
+            const request = {
+                url: this._getTransactionCommitApi(),
+                method: 'POST',
+                mode: 'cors',
+                headers: this._headers(requestCodec),
+                signal: abortController.signal,
+                body: JSON.stringify(requestCodec.body)
+            };
+            this._log?.debug(`${this} REQUEST: ${JSON.stringify(request)} `);
+            const res = await fetch(request.url, request);
+            const { body: rawCommitTransactionResponse, headers: [contentType] } = await readBodyAndReaders(request.url, res, 'contentType');
+            this._log?.debug(`${this} ${JSON.stringify(rawCommitTransactionResponse)}`);
+            const codec = CommitTransactionResponseCodec.of(this._config, contentType ?? '', rawCommitTransactionResponse);
+            if (codec.error) {
+                throw codec.error;
+            }
+            this._currentTx = undefined;
+            observer.onCompleted(codec.meta);
+        })
+            .catch(this._catch(observer))
+            .finally(this._finally(abortController));
         return observer;
     }
-    _handleAndReThrown(error) {
-        throw this._errorHandler(error);
+    rollbackTransaction(config) {
+        const observer = new ResultStreamObserver({
+            server: this._address,
+            afterComplete: config?.afterComplete,
+            beforeError: config.beforeError,
+            highRecordWatermark: Number.MAX_SAFE_INTEGER,
+            lowRecordWatermark: Number.MIN_SAFE_INTEGER,
+        });
+        observer.prepareToHandleSingleResponse();
+        const requestCodec = RollbackTransactionRequestCodec.of(this._auth, config);
+        const abortController = this._newAbortController();
+        this._workPipe.attach(async () => {
+            const request = {
+                url: this._getTransactionApi(this._currentTx?.database),
+                method: 'DELETE',
+                mode: 'cors',
+                headers: this._headers(requestCodec),
+                signal: abortController.signal,
+                body: JSON.stringify(requestCodec.body)
+            };
+            this._log?.debug(`${this} REQUEST: ${JSON.stringify(request)} `);
+            const res = await fetch(request.url, request);
+            const { body: rawRollbackTransactionResponse, headers: [contentType] } = await readBodyAndReaders(request.url, res, 'content-type');
+            this._log?.debug(`${this} ${JSON.stringify(rawRollbackTransactionResponse)}`);
+            const codec = RollbackTransactionResponseCodec.of(this._config, contentType ?? '', rawRollbackTransactionResponse);
+            if (codec.error) {
+                throw codec.error;
+            }
+            this._currentTx = undefined;
+            observer.onCompleted(codec.meta);
+        })
+            .catch(this._catch(observer))
+            .finally(this._finally(abortController));
+        return observer;
     }
     _getTransactionApi(database) {
-        return this._queryEndpoint.replace('{databaseName}', database);
+        if (this._currentTx === undefined) {
+            return this._queryEndpoint.replace('{databaseName}', database);
+        }
+        return this._queryEndpoint.replace('{databaseName}', this._currentTx.database) + `/tx/${this._currentTx.id}`;
+    }
+    _getTransactionCommitApi() {
+        return this._queryEndpoint.replace('{databaseName}', this._currentTx?.database) + `/tx/${this._currentTx?.id}/commit`;
+    }
+    _getExplicityTransactionApi(database) {
+        return this._queryEndpoint.replace('{databaseName}', database) + '/tx';
     }
     static async discover({ scheme, address }) {
         return await fetch(`${scheme}://${address.asHostPort()}`, {
@@ -112,7 +234,8 @@ export default class HttpConnection extends Connection {
             if (typeof json.query !== 'string') {
                 throw new Error('Query API is not available');
             }
-            return { query: json.query, version: json.neo4j_version, edition: json.neo4j_edition };
+            const query = json.query.endsWith('/') ? json.query.substring(0, json.query.length - 1) : json.query;
+            return { query, version: json.neo4j_version, edition: json.neo4j_edition };
         })
             .catch(e => {
             throw newError(`Failure discovering endpoints. Caused by: ${e.message}`, 'SERVICE_UNAVAILABLE', e);
@@ -140,19 +263,52 @@ export default class HttpConnection extends Connection {
         return this._open;
     }
     hasOngoingObservableRequests() {
-        return this._abortController != null;
+        return this._abortControllers.length > 0;
     }
     async resetAndFlush() {
-        this._abortController?.abort(newError('User aborted operation.'));
+        this._abortControllers.forEach((controller) => controller.abort(newError('User aborted operation.')));
+        this._abortControllers = [];
+        this._currentTx = undefined;
+        this._workPipe.recover();
     }
     release() {
+        this._workPipe.recover();
         return this._release();
     }
     async close() {
-        this._abortController?.abort(newError('Aborted since connection is being closed.'));
+        this._abortControllers.forEach((controller) => controller.abort(newError('Aborted since connection is being closed.')));
+        this._abortControllers = [];
         this._open = false;
     }
     toString() {
         return `HttpConnection [${this._id}]`;
     }
+    _catch(observer) {
+        return error => {
+            this._currentTx = undefined;
+            const newError = this._errorHandler(error);
+            observer.onError(newError);
+        };
+    }
+    _finally(abortController) {
+        this._abortControllers = this._abortControllers.filter(ac => ac !== abortController);
+        return undefined;
+    }
+    _newAbortController() {
+        const abortController = new AbortController();
+        this._abortControllers.push(abortController);
+        return abortController;
+    }
+}
+async function readBodyAndReaders(url, response, ...headers) {
+    try {
+        const text = await response.text();
+        return {
+            body: text !== '' ? JSON.parse(text) : {},
+            headers: headers.map(header => response.headers.get(header))
+        };
+    }
+    catch (error) {
+        throw newError(`Failure accessing "${url}"`, 'SERVICE_UNAVAILABLE', error);
+    }
 }

package/lib/http-connection/lang/pipe.js

@@ -0,0 +1,17 @@
+export default class Pipe {
+    constructor(logger) {
+        this.logger = logger;
+        this.promise = Promise.resolve();
+    }
+    attach(work) {
+        this.promise = this.promise.then(work);
+        return this.promise;
+    }
+    recover() {
+        this.promise = this.promise.catch(error => {
+            if (this.logger?.isDebugEnabled() === true) {
+                this.logger?.debug(`Recovering from ${error}`);
+            }
+        });
+    }
+}

package/lib/http-connection/query.codec.js

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 import { newError, Node, Relationship, int, error, Time, Date, LocalTime, Point, DateTime, LocalDateTime, Duration, isInt, isPoint, isDuration, isLocalTime, isTime, isDate, isLocalDateTime, isDateTime, isRelationship, isPath, isNode, isPathSegment, Path, PathSegment, internal, isUnboundRelationship } from "neo4j-driver-core";
-const NEO4J_QUERY_CONTENT_TYPE = 'application/vnd.neo4j.query';
+import { NEO4J_QUERY_CONTENT_TYPE, encodeAuthToken, encodeTransactionBody } from "./codec";
 export class QueryResponseCodec {
     static of(config, contentType, response) {
         if (isSuccess(response)) {
@@ -415,14 +415,7 @@ export class QueryRequestCodec {
         return `${NEO4J_QUERY_CONTENT_TYPE}, application/json`;
     }
     get authorization() {
-        switch (this._auth.scheme) {
-            case 'bearer':
-                return `Bearer ${btoa(this._auth.credentials)}`;
-            case 'basic':
-                return `Basic ${btoa(`${this._auth.principal}:${this._auth.credentials}`)}`;
-            default:
-                throw new Error(`Authorization scheme "${this._auth.scheme}" is not supported.`);
-        }
+        return encodeAuthToken(this._auth);
     }
     get body() {
         if (this._body != null) {
@@ -430,23 +423,12 @@ export class QueryRequestCodec {
         }
         this._body = {
             statement: this._query,
-            includeCounters: true
+            includeCounters: true,
+            ...encodeTransactionBody(this._config)
         };
         if (this._parameters != null && Object.getOwnPropertyNames(this._parameters).length !== 0) {
             this._body.parameters = this._encodeParameters(this._parameters);
         }
-        if (this._config?.bookmarks != null && !this._config.bookmarks.isEmpty()) {
-            this._body.bookmarks = this._config?.bookmarks?.values();
-        }
-        if (this._config?.txConfig.timeout != null) {
-            this._body.maxExecutionTime = this._config?.txConfig.timeout.toInt();
-        }
-        if (this._config?.impersonatedUser != null) {
-            this._body.impersonatedUser = this._config?.impersonatedUser;
-        }
-        if (this._config?.mode) {
-            this._body.accessMode = this._config.mode.toUpperCase();
-        }
         return this._body;
     }
     _encodeParameters(parameters) {

package/lib/http-connection/transaction.codec.js

@@ -0,0 +1,255 @@
+/**
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [https://neo4j.com]
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { error, newError } from "neo4j-driver-core";
+import { NEO4J_QUERY_CONTENT_TYPE, encodeAuthToken, encodeTransactionBody } from "./codec";
+export class BeginTransactionRequestCodec {
+    static of(auth, config) {
+        return new BeginTransactionRequestCodec(auth, config);
+    }
+    constructor(_auth, _config) {
+        this._auth = _auth;
+        this._config = _config;
+    }
+    get contentType() {
+        return 'application/json';
+    }
+    get accept() {
+        return `${NEO4J_QUERY_CONTENT_TYPE}, application/json`;
+    }
+    get authorization() {
+        return encodeAuthToken(this._auth);
+    }
+    get body() {
+        if (this._body != null) {
+            return this._body;
+        }
+        this._body = encodeTransactionBody(this._config);
+        return this._body;
+    }
+}
+export class BeginTransactionResponseCodec {
+    static of(config, contentType, response) {
+        if (isSuccess(response)) {
+            return new BeginTransactionSuccessResponseCodec(config, response);
+        }
+        return new BeginTransactionFailureResponseCodec(response.errors?.length > 0 ?
+            newError(response.errors[0].message, 
+            // TODO: REMOVE THE ?? AND .ERROR WHEN SERVER IS FIXED
+            response.errors[0].code ?? response.errors[0].error) :
+            newError('Server replied an empty error response', error.PROTOCOL_ERROR));
+    }
+    get error() {
+        throw new Error('Not implemented');
+    }
+    get id() {
+        throw new Error('Not implemented');
+    }
+    get expires() {
+        throw new Error('Not implemented');
+    }
+    get host() {
+        throw new Error('Not implemented');
+    }
+}
+class BeginTransactionSuccessResponseCodec extends BeginTransactionResponseCodec {
+    constructor(_config, _response) {
+        super();
+        this._config = _config;
+        this._response = _response;
+    }
+    get error() {
+        return undefined;
+    }
+    get id() {
+        return this._response.transaction.id;
+    }
+    get expires() {
+        return new Date(this._response.transaction.expires);
+    }
+    get host() {
+        return this._response.transaction.tx_host;
+    }
+}
+class BeginTransactionFailureResponseCodec extends BeginTransactionResponseCodec {
+    constructor(_error) {
+        super();
+        this._error = _error;
+    }
+    get error() {
+        return this._error;
+    }
+    get id() {
+        throw this._error;
+    }
+    get expires() {
+        throw this._error;
+    }
+    get host() {
+        throw this._error;
+    }
+}
+export class CommitTransactionRequestCodec {
+    static of(auth, config) {
+        return new CommitTransactionRequestCodec(auth, config);
+    }
+    constructor(_auth, _config) {
+        this._auth = _auth;
+        this._config = _config;
+    }
+    get contentType() {
+        return 'application/json';
+    }
+    get accept() {
+        return `${NEO4J_QUERY_CONTENT_TYPE}, application/json`;
+    }
+    get body() {
+        return {};
+    }
+    get authorization() {
+        return encodeAuthToken(this._auth);
+    }
+}
+export class CommitTransactionResponseCodec {
+    static of(config, contentType, response) {
+        if (isCommitSuccess(response)) {
+            return new CommitTransactionSuccessResponseCodec(config, response);
+        }
+        return new CommitTransactionFailureResponseCodec(response.errors?.length > 0 ?
+            newError(response.errors[0].message, 
+            // TODO: REMOVE THE ?? AND .ERROR WHEN SERVER IS FIXED
+            response.errors[0].code ?? response.errors[0].error) :
+            newError('Server replied an empty error response', error.PROTOCOL_ERROR));
+    }
+    get error() {
+        throw new Error('Not implemented');
+    }
+    get meta() {
+        throw new Error('Not implemented');
+    }
+}
+class CommitTransactionSuccessResponseCodec extends CommitTransactionResponseCodec {
+    constructor(_config, _response) {
+        super();
+        this._config = _config;
+        this._response = _response;
+    }
+    get error() {
+        return undefined;
+    }
+    get meta() {
+        return {
+            bookmark: this._response.bookmarks
+        };
+    }
+}
+class CommitTransactionFailureResponseCodec extends CommitTransactionResponseCodec {
+    constructor(_error) {
+        super();
+        this._error = _error;
+    }
+    get error() {
+        return this._error;
+    }
+    get meta() {
+        throw this._error;
+    }
+}
+export class RollbackTransactionRequestCodec {
+    static of(auth, config) {
+        return new RollbackTransactionRequestCodec(auth, config);
+    }
+    constructor(_auth, _config) {
+        this._auth = _auth;
+        this._config = _config;
+    }
+    get body() {
+        return {};
+    }
+    get contentType() {
+        return 'application/json';
+    }
+    get accept() {
+        return `${NEO4J_QUERY_CONTENT_TYPE}, application/json`;
+    }
+    get authorization() {
+        return encodeAuthToken(this._auth);
+    }
+}
+export class RollbackTransactionResponseCodec {
+    static of(config, contentType, response) {
+        if (isRollbackSuccess(response)) {
+            return new RollbackTransactionSuccessResponseCodec(config, response);
+        }
+        return new RollbackTransactionFailureResponseCodec(response.errors?.length > 0 ?
+            newError(response.errors[0].message, 
+            // TODO: REMOVE THE ?? AND .ERROR WHEN SERVER IS FIXED
+            response.errors[0].code ?? response.errors[0].error) :
+            newError('Server replied an empty error response', error.PROTOCOL_ERROR));
+    }
+    get error() {
+        throw new Error('Not implemented');
+    }
+    get meta() {
+        throw new Error('Not implemented');
+    }
+}
+class RollbackTransactionSuccessResponseCodec extends RollbackTransactionResponseCodec {
+    constructor(_config, _response) {
+        super();
+        this._config = _config;
+        this._response = _response;
+    }
+    get error() {
+        return undefined;
+    }
+    get meta() {
+        return {};
+    }
+}
+class RollbackTransactionFailureResponseCodec extends RollbackTransactionResponseCodec {
+    constructor(_error) {
+        super();
+        this._error = _error;
+    }
+    get error() {
+        return this._error;
+    }
+    get meta() {
+        throw this._error;
+    }
+}
+function isSuccess(obj) {
+    // @ts-expect-error
+    if (obj.errors != null) {
+        return false;
+    }
+    return true;
+}
+function isCommitSuccess(obj) {
+    // @ts-expect-error
+    if (obj.errors != null) {
+        return false;
+    }
+    return true;
+}
+function isRollbackSuccess(obj) {
+    // @ts-expect-error
+    if (obj.errors != null) {
+        return false;
+    }
+    return true;
+}

package/lib/index.js

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { auth, bookmarkManager, authTokenManagers, staticAuthTokenManager, Connection, ConnectionProvider, Date, DateTime, Driver, Duration, error, inSafeRange, int, Integer, internal, isDate, isDateTime, isDuration, isInt, isLocalDateTime, isLocalTime, isNode, isPath, isPathSegment, isPoint, isRelationship, isRetriableError, isTime, isUnboundRelationship, LocalDateTime, LocalTime, Neo4jError, Node, Notification, notificationCategory, notificationSeverityLevel, Path, PathSegment, Plan, Point, ProfiledPlan, QueryStatistics, Record, Relationship, Result, ResultSummary, resultTransformers, ServerInfo, Session, Time, toNumber, toString, UnboundRelationship, driver as coreDriver, } from 'neo4j-driver-core';
+import { auth, bookmarkManager, authTokenManagers, staticAuthTokenManager, Connection, ConnectionProvider, Date, DateTime, Driver, Duration, error, inSafeRange, int, Integer, internal, isDate, isDateTime, isDuration, isInt, isLocalDateTime, isLocalTime, isNode, isPath, isPathSegment, isPoint, isRelationship, isRetriableError, isTime, isUnboundRelationship, LocalDateTime, LocalTime, Neo4jError, Node, Notification, notificationCategory, notificationSeverityLevel, Path, PathSegment, Plan, Point, ProfiledPlan, QueryStatistics, Record, Relationship, Result, ResultSummary, resultTransformers, ServerInfo, Session, Time, toNumber, toString, UnboundRelationship, driver as coreDriver, Transaction, TransactionPromise, ManagedTransaction } from 'neo4j-driver-core';
 import { logging } from './logging';
 import { WrapperImpl } from './wrapper.impl';
 import { HttpConnectionProvider } from './http-connection';
@@ -186,6 +186,9 @@ const forExport = {
     Result,
     Record,
     ResultSummary,
+    Transaction,
+    TransactionPromise,
+    ManagedTransaction,
     Node,
     Relationship,
     UnboundRelationship,
@@ -213,5 +216,5 @@ const forExport = {
     notificationSeverityLevel,
     wrapper
 };
-export { authTokenManagers, int, isInt, isPoint, isDuration, isLocalTime, isTime, isDate, isLocalDateTime, isDateTime, isNode, isPath, isPathSegment, isRelationship, isUnboundRelationship, integer, Neo4jError, isRetriableError, auth, logging, types, session, error, graph, spatial, temporal, Driver, Result, Record, ResultSummary, Node, Relationship, UnboundRelationship, PathSegment, Path, Integer, Plan, ProfiledPlan, QueryStatistics, Notification, ServerInfo, Session, Point, Duration, LocalTime, Time, Date, LocalDateTime, DateTime, ConnectionProvider, Connection, bookmarkManager, resultTransformers, notificationCategory, notificationSeverityLevel, wrapper };
+export { authTokenManagers, int, isInt, isPoint, isDuration, isLocalTime, isTime, isDate, isLocalDateTime, isDateTime, isNode, isPath, isPathSegment, isRelationship, isUnboundRelationship, integer, Neo4jError, isRetriableError, auth, logging, types, session, error, graph, spatial, temporal, Driver, Result, Record, ResultSummary, Node, Relationship, UnboundRelationship, PathSegment, Path, Integer, Plan, ProfiledPlan, QueryStatistics, Notification, ServerInfo, Session, Transaction, TransactionPromise, ManagedTransaction, Point, Duration, LocalTime, Time, Date, LocalDateTime, DateTime, ConnectionProvider, Connection, bookmarkManager, resultTransformers, notificationCategory, notificationSeverityLevel, wrapper };
 export default forExport;

package/lib/wrapper-session.impl.js

@@ -8,6 +8,15 @@ export default class WrapperSessionImpl {
     run(query, parameters, transactionConfig) {
         return this.session.run(query, parameters, transactionConfig);
     }
+    beginTransaction(transactionConfig) {
+        return this.session.beginTransaction(transactionConfig);
+    }
+    executeRead(transactionWork, transactionConfig) {
+        return this.session.executeRead(transactionWork, transactionConfig);
+    }
+    executeWrite(transactionWork, transactionConfig) {
+        return this.session.executeWrite(transactionWork, transactionConfig);
+    }
     lastBookmarks() {
         return this.session.lastBookmarks();
     }

package/lib/wrapper.impl.js

@@ -6,6 +6,13 @@ export class WrapperImpl {
     close() {
         return this.driver.close();
     }
+    executeQuery(query, parameters, config) {
+        validateDatabase(config);
+        return this.driver.executeQuery(query, parameters, config);
+    }
+    get executeQueryBookmarkManager() {
+        return this.driver.executeQueryBookmarkManager;
+    }
     verifyConnectivity(config) {
         validateDatabase(config);
         return this.driver.verifyConnectivity(config);
@@ -33,7 +40,7 @@ export class WrapperImpl {
     }
 }
 function validateDatabase(config) {
-    if (config.database == null || config.database === '') {
-        throw new TypeError(`database must be a non-empty string, but got ${config.database}`);
+    if (config == null || config.database == null || config.database === '') {
+        throw new TypeError(`database must be a non-empty string, but got ${config?.database}`);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neo4j-labs/experimental-query-api-wrapper",
-  "version": "0.0.1-alpha05",
+  "version": "0.0.1-alpha06",
   "description": "Experimental wrapper library to access Neo4j Database using Query API with a neo4j-driver-like interface.",
   "main": "lib/index.js",
   "types": "types/index.d.ts",
@@ -42,7 +42,7 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "neo4j-driver-core": "^5.24.1"
+    "neo4j-driver-core": "^5.26.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/types/http-connection/codec.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [https://neo4j.com]
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { types } from "neo4j-driver-core";
+import { BeginTransactionConfig } from "neo4j-driver-core/types/connection";
+export declare const NEO4J_QUERY_CONTENT_TYPE = "application/vnd.neo4j.query";
+export declare function encodeAuthToken(auth: types.AuthToken): string;
+export declare function encodeTransactionBody(config?: Pick<BeginTransactionConfig, 'bookmarks' | 'txConfig' | 'mode' | 'impersonatedUser'>): Record<string, unknown>;

package/types/http-connection/connection.http.d.ts

@@ -15,14 +15,15 @@
  * limitations under the License.
  */
 import { Connection, types, internal } from "neo4j-driver-core";
-import { RunQueryConfig } from "neo4j-driver-core/types/connection";
+import { BeginTransactionConfig, CommitTransactionConfig, RunQueryConfig } from "neo4j-driver-core/types/connection";
+import { WrapperConfig } from "../types";
 export type HttpScheme = 'http' | 'https';
 export interface HttpConnectionConfig {
     release: () => Promise<void>;
     auth: types.AuthToken;
     queryEndpoint: string;
     address: internal.serverAddress.ServerAddress;
-    config: types.InternalConfig;
+    config: WrapperConfig;
     logger: internal.logger.Logger;
     errorHandler: (error: Error & {
         code: string;
@@ -35,15 +36,23 @@ export default class HttpConnection extends Connection {
     private _queryEndpoint;
     private _address;
     private _config;
-    private _abortController?;
+    private _abortControllers;
     private _log?;
+    private _sessionAffinityHeader;
     private _id;
     private _errorHandler;
     private _open;
+    private _currentTx;
+    private _workPipe;
     constructor(config: HttpConnectionConfig);
     run(query: string, parameters?: Record<string, unknown> | undefined, config?: RunQueryConfig | undefined): internal.observer.ResultStreamObserver;
-    private _handleAndReThrown;
+    private _headers;
+    beginTransaction(config: BeginTransactionConfig): internal.observer.ResultStreamObserver;
+    commitTransaction(config: CommitTransactionConfig): internal.observer.ResultStreamObserver;
+    rollbackTransaction(config: CommitTransactionConfig): internal.observer.ResultStreamObserver;
     private _getTransactionApi;
+    private _getTransactionCommitApi;
+    private _getExplicityTransactionApi;
     static discover({ scheme, address }: {
         scheme: HttpScheme;
         address: internal.serverAddress.ServerAddress;
@@ -64,4 +73,7 @@ export default class HttpConnection extends Connection {
     release(): Promise<void>;
     close(): Promise<void>;
     toString(): string;
+    private _catch;
+    private _finally;
+    private _newAbortController;
 }

package/types/http-connection/lang/pipe.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [https://neo4j.com]
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { internal } from "neo4j-driver-core";
+export default class Pipe {
+    private logger?;
+    private promise;
+    constructor(logger?: internal.logger.Logger | undefined);
+    attach(work: () => Promise<void> | void): Promise<void>;
+    recover(): void;
+}

package/types/http-connection/transaction.codec.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [https://neo4j.com]
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { types } from "neo4j-driver-core";
+import { BeginTransactionConfig } from "neo4j-driver-core/types/connection";
+export type BeginTransactionRequestCodecConfig = Pick<BeginTransactionConfig, 'bookmarks' | 'txConfig' | 'mode' | 'impersonatedUser'>;
+export type CommitTransactionRequestCodecConfig = {};
+export type RollbackTransactionRequestCodecConfig = {};
+export type RawTransaction = {
+    id: string;
+    expires: string;
+    tx_host?: string;
+};
+export type RawBeginTransactionSuccessResponse = {
+    transaction: RawTransaction;
+};
+export type RawTransactionError = {
+    code: string;
+    message: string;
+    error?: string;
+};
+export type RawTransactionFailuresResponse = {
+    errors: RawTransactionError[];
+};
+export type RawBeginTransactionResponse = RawBeginTransactionSuccessResponse | RawTransactionFailuresResponse;
+export declare class BeginTransactionRequestCodec {
+    private _auth;
+    private _config?;
+    private _body?;
+    static of(auth: types.AuthToken, config?: BeginTransactionRequestCodecConfig | undefined): BeginTransactionRequestCodec;
+    private constructor();
+    get contentType(): string;
+    get accept(): string;
+    get authorization(): string;
+    get body(): Record<string, unknown>;
+}
+export declare class BeginTransactionResponseCodec {
+    static of(config: types.InternalConfig, contentType: string, response: RawBeginTransactionResponse): BeginTransactionResponseCodec;
+    get error(): Error | undefined;
+    get id(): string;
+    get expires(): Date;
+    get host(): string | undefined;
+}
+export type RawCommitTransactionSuccessResponse = {
+    bookmarks: string[] | undefined;
+};
+export type RawCommitTransactionResponse = RawCommitTransactionSuccessResponse | RawTransactionFailuresResponse;
+export declare class CommitTransactionRequestCodec {
+    private _auth;
+    private _config?;
+    static of(auth: types.AuthToken, config?: CommitTransactionRequestCodecConfig | undefined): CommitTransactionRequestCodec;
+    private constructor();
+    get contentType(): string;
+    get accept(): string;
+    get body(): Record<string, unknown>;
+    get authorization(): string;
+}
+export declare class CommitTransactionResponseCodec {
+    static of(config: types.InternalConfig, contentType: string, response: RawCommitTransactionResponse): CommitTransactionResponseCodec;
+    get error(): Error | undefined;
+    get meta(): Record<string, unknown>;
+}
+export type RawRollbackTransactionSuccessResponse = {
+    e?: any;
+};
+export type RawRollbackTransactionResponse = RawRollbackTransactionSuccessResponse | RawTransactionFailuresResponse;
+export declare class RollbackTransactionRequestCodec {
+    private _auth;
+    private _config?;
+    static of(auth: types.AuthToken, config?: RollbackTransactionRequestCodecConfig | undefined): RollbackTransactionRequestCodec;
+    private constructor();
+    get body(): Record<string, unknown>;
+    get contentType(): string;
+    get accept(): string;
+    get authorization(): string;
+}
+export declare class RollbackTransactionResponseCodec {
+    static of(config: types.InternalConfig, contentType: string, response: RawRollbackTransactionResponse): RollbackTransactionResponseCodec;
+    get error(): Error | undefined;
+    get meta(): Record<string, unknown>;
+}

package/types/index.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { auth, BookmarkManager, bookmarkManager, BookmarkManagerConfig, authTokenManagers, AuthTokenManager, AuthTokenManagers, AuthTokenAndExpiration, Connection, ConnectionProvider, Date, DateTime, Driver, Duration, error, int, Integer, internal, isDate, isDateTime, isDuration, isInt, isLocalDateTime, isLocalTime, isNode, isPath, isPathSegment, isPoint, isRelationship, isRetriableError, isTime, isUnboundRelationship, LocalDateTime, LocalTime, Neo4jError, Node, Notification, notificationCategory, NotificationCategory, NotificationPosition, notificationSeverityLevel, NotificationSeverityLevel, Path, PathSegment, Plan, Point, ProfiledPlan, QueryConfig, QueryResult, QueryStatistics, Record, RecordShape, Relationship, Result, ResultObserver, ResultSummary, ResultTransformer, resultTransformers, ServerInfo, Session, SessionConfig, Time, types as coreTypes, UnboundRelationship } from 'neo4j-driver-core';
+import { auth, BookmarkManager, bookmarkManager, BookmarkManagerConfig, authTokenManagers, AuthTokenManager, AuthTokenManagers, AuthTokenAndExpiration, Connection, ConnectionProvider, Date, DateTime, Driver, Duration, error, int, Integer, internal, isDate, isDateTime, isDuration, isInt, isLocalDateTime, isLocalTime, isNode, isPath, isPathSegment, isPoint, isRelationship, isRetriableError, isTime, isUnboundRelationship, LocalDateTime, LocalTime, Neo4jError, Node, Notification, notificationCategory, NotificationCategory, NotificationPosition, notificationSeverityLevel, NotificationSeverityLevel, Path, PathSegment, Plan, Point, ProfiledPlan, QueryConfig, QueryResult, QueryStatistics, Record, RecordShape, Relationship, Result, ResultObserver, ResultSummary, ResultTransformer, resultTransformers, ServerInfo, Session, SessionConfig, Time, types as coreTypes, UnboundRelationship, Transaction, TransactionConfig, TransactionPromise, ManagedTransaction } from 'neo4j-driver-core';
 import { logging } from './logging';
 import { HttpUrl, Wrapper, WrapperSession, WrapperConfig, WrapperSessionConfig } from './types';
 type AuthToken = coreTypes.AuthToken;
@@ -191,6 +191,9 @@ declare const forExport: {
     Result: typeof Result;
     Record: typeof Record;
     ResultSummary: typeof ResultSummary;
+    Transaction: typeof Transaction;
+    TransactionPromise: typeof TransactionPromise;
+    ManagedTransaction: typeof ManagedTransaction;
     Node: typeof Node;
     Relationship: typeof Relationship;
     UnboundRelationship: typeof UnboundRelationship;
@@ -248,12 +251,12 @@ declare const forExport: {
         SCHEMA: "SCHEMA";
     };
     notificationSeverityLevel: {
+        UNKNOWN: "UNKNOWN";
         WARNING: "WARNING";
         INFORMATION: "INFORMATION";
-        UNKNOWN: "UNKNOWN";
     };
     wrapper: typeof wrapper;
 };
-export { authTokenManagers, int, isInt, isPoint, isDuration, isLocalTime, isTime, isDate, isLocalDateTime, isDateTime, isNode, isPath, isPathSegment, isRelationship, isUnboundRelationship, integer, Neo4jError, isRetriableError, auth, logging, types, session, error, graph, spatial, temporal, Driver, Result, Record, ResultSummary, Node, Relationship, UnboundRelationship, PathSegment, Path, Integer, Plan, ProfiledPlan, QueryStatistics, Notification, ServerInfo, Session, Point, Duration, LocalTime, Time, Date, LocalDateTime, DateTime, ConnectionProvider, Connection, bookmarkManager, resultTransformers, notificationCategory, notificationSeverityLevel, wrapper };
-export type { QueryResult, AuthToken, AuthTokenManager, AuthTokenManagers, AuthTokenAndExpiration, Config, EncryptionLevel, TrustStrategy, SessionMode, ResultObserver, NotificationPosition, BookmarkManager, BookmarkManagerConfig, SessionConfig, QueryConfig, RecordShape, ResultTransformer, NotificationCategory, NotificationSeverityLevel, Logger, HttpUrl, Wrapper, WrapperConfig, WrapperSession, WrapperSessionConfig };
+export { authTokenManagers, int, isInt, isPoint, isDuration, isLocalTime, isTime, isDate, isLocalDateTime, isDateTime, isNode, isPath, isPathSegment, isRelationship, isUnboundRelationship, integer, Neo4jError, isRetriableError, auth, logging, types, session, error, graph, spatial, temporal, Driver, Result, Record, ResultSummary, Node, Relationship, UnboundRelationship, PathSegment, Path, Integer, Plan, ProfiledPlan, QueryStatistics, Notification, ServerInfo, Session, Transaction, TransactionPromise, ManagedTransaction, Point, Duration, LocalTime, Time, Date, LocalDateTime, DateTime, ConnectionProvider, Connection, bookmarkManager, resultTransformers, notificationCategory, notificationSeverityLevel, wrapper };
+export type { QueryResult, AuthToken, AuthTokenManager, AuthTokenManagers, AuthTokenAndExpiration, Config, EncryptionLevel, TrustStrategy, SessionMode, ResultObserver, NotificationPosition, BookmarkManager, BookmarkManagerConfig, SessionConfig, QueryConfig, RecordShape, ResultTransformer, TransactionConfig, NotificationCategory, NotificationSeverityLevel, Logger, HttpUrl, Wrapper, WrapperConfig, WrapperSession, WrapperSessionConfig };
 export default forExport;

package/types/types.d.ts

@@ -30,12 +30,14 @@ type VerifyAuthentication = {
     }): Promise<boolean>;
 };
 type HttpUrl = `http://${string}` | `https://${string}`;
-type WrapperSession = Pick<Session, 'run' | 'lastBookmarks' | 'close'> & Disposable;
+type WrapperSession = Pick<Session, 'run' | 'beginTransaction' | 'executeRead' | 'executeWrite' | 'lastBookmarks' | 'close'> & Disposable;
 type WrapperSessionConfig = Pick<SessionConfig, 'bookmarks' | 'impersonatedUser' | 'bookmarkManager' | 'defaultAccessMode' | 'auth'> & {
     database: string;
 };
-type Wrapper = Pick<Driver, 'close' | 'supportsMultiDb' | 'supportsSessionAuth' | 'supportsUserImpersonation'> & Disposable & VerifyConnectivity & VerifyAuthentication & {
+type Wrapper = Pick<Driver, 'close' | 'executeQuery' | 'executeQueryBookmarkManager' | 'supportsMultiDb' | 'supportsSessionAuth' | 'supportsUserImpersonation'> & Disposable & VerifyConnectivity & VerifyAuthentication & {
     session(config: WrapperSessionConfig): WrapperSession;
 };
-type WrapperConfig = Pick<Config, 'encrypted' | 'useBigInt' | 'disableLosslessIntegers' | 'maxConnectionPoolSize' | 'connectionAcquisitionTimeout'>;
+type WrapperConfig = Pick<Config, 'encrypted' | 'useBigInt' | 'disableLosslessIntegers' | 'maxConnectionPoolSize' | 'connectionAcquisitionTimeout'> & {
+    httpSessionAffinityHeader?: string;
+};
 export type { HttpUrl, WrapperSession, WrapperSessionConfig, Wrapper, WrapperConfig };

package/types/wrapper-session.impl.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { RecordShape, TransactionConfig, Result, Session } from "neo4j-driver-core";
+import { RecordShape, TransactionConfig, Result, Session, TransactionPromise, ManagedTransaction } from "neo4j-driver-core";
 import { Query } from "neo4j-driver-core/types/types";
 import { WrapperSession } from "./types";
 export default class WrapperSessionImpl implements WrapperSession {
@@ -22,6 +22,9 @@ export default class WrapperSessionImpl implements WrapperSession {
     constructor(session: Session);
     [Symbol.asyncDispose](): Promise<void>;
     run<R extends RecordShape = RecordShape>(query: Query, parameters?: any, transactionConfig?: TransactionConfig | undefined): Result<R>;
+    beginTransaction(transactionConfig?: TransactionConfig | undefined): TransactionPromise;
+    executeRead<T>(transactionWork: (tx: ManagedTransaction) => T | Promise<T>, transactionConfig?: TransactionConfig | undefined): Promise<T>;
+    executeWrite<T>(transactionWork: (tx: ManagedTransaction) => T | Promise<T>, transactionConfig?: TransactionConfig | undefined): Promise<T>;
     lastBookmarks(): string[];
     close(): Promise<void>;
 }

package/types/wrapper.impl.d.ts

@@ -14,12 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Driver, ServerInfo, types } from "neo4j-driver-core";
+import { BookmarkManager, Driver, EagerResult, QueryConfig, RecordShape, ServerInfo, types } from "neo4j-driver-core";
 import { Wrapper, WrapperSession, WrapperSessionConfig } from "./types";
 export declare class WrapperImpl implements Wrapper {
     private readonly driver;
     constructor(driver: Driver);
     close(): Promise<void>;
+    executeQuery<T = EagerResult<RecordShape>>(query: types.Query, parameters?: any, config?: QueryConfig<T> | undefined): Promise<T>;
+    get executeQueryBookmarkManager(): BookmarkManager;
     verifyConnectivity(config: {
         database: string;
     }): Promise<ServerInfo>;