@neo4j-labs/experimental-query-api-wrapper 0.0.1-alpha02 → 0.0.1-alpha04

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

@@ -14,10 +14,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ConnectionProvider, ServerInfo } from "neo4j-driver-core";
+import { ConnectionProvider, internal, ServerInfo } from "neo4j-driver-core";
 import HttpConnection from "./connection.http";
+const { pool: { Pool, PoolConfig, }, bookmarks: { Bookmarks }, txConfig: { TxConfig }, constants: { ACCESS_MODE_READ, ACCESS_MODE_WRITE } } = internal;
+const AUTHENTICATION_ERRORS = [
+    'Neo.ClientError.Security.CredentialsExpired',
+    'Neo.ClientError.Security.Forbidden',
+    'Neo.ClientError.Security.TokenExpired',
+    'Neo.ClientError.Security.Unauthorized'
+];
 export default class HttpConnectionProvider extends ConnectionProvider {
-    constructor(config) {
+    constructor(config, { newPool, newHttpConnection } = {
+        newPool: (...params) => new Pool(...params),
+        newHttpConnection: (...params) => new HttpConnection(...params)
+    }) {
         super();
         this._id = config.id;
         this._log = config.log;
@@ -25,6 +35,15 @@ export default class HttpConnectionProvider extends ConnectionProvider {
         this._scheme = config.scheme;
         this._authTokenManager = config.authTokenManager;
         this._config = config.config;
+        this._openConnections = {};
+        this._newHttpConnection = newHttpConnection;
+        this._pool = newPool({
+            create: this._createConnection.bind(this),
+            destroy: this._destroyConnection.bind(this),
+            validateOnAcquire: this._validateConnectionOnAcquire.bind(this),
+            config: PoolConfig.fromDriverConfig(config.config),
+            log: this._log
+        });
     }
     async acquireConnection(param) {
         if (this._queryEndpoint == null) {
@@ -34,16 +53,66 @@ export default class HttpConnectionProvider extends ConnectionProvider {
             const discoveryResult = await this._discoveryPromise;
             this._queryEndpoint = discoveryResult.query;
         }
-        const auth = param?.auth ?? await this._authTokenManager.getToken();
-        return new HttpConnection({
-            release: async () => { },
+        return await this._pool.acquire({ auth: param?.auth, queryEndpoint: this._queryEndpoint }, this._address);
+    }
+    async verifyConnectivityAndGetServerInfo(param) {
+        const discoveryInfo = await HttpConnection.discover({ scheme: this._scheme, address: this._address });
+        this._queryEndpoint = discoveryInfo.query;
+        const connection = await this._pool.acquire({ queryEndpoint: this._queryEndpoint }, this._address);
+        try {
+            await run(connection, param);
+            return new ServerInfo({
+                address: this._address.asHostPort(),
+                version: discoveryInfo.version
+            }, parseFloat(discoveryInfo.version));
+        }
+        finally {
+            await connection.release();
+        }
+    }
+    async verifyAuthentication(param) {
+        const connection = await this.acquireConnection({ ...param, bookmarks: Bookmarks.empty() });
+        try {
+            await run(connection, param);
+            return true;
+        }
+        catch (error) {
+            if (AUTHENTICATION_ERRORS.includes(error.code)) {
+                return false;
+            }
+            throw error;
+        }
+        finally {
+            await connection.release();
+        }
+    }
+    async supportsMultiDb() {
+        return true;
+    }
+    async supportsSessionAuth() {
+        return true;
+    }
+    async supportsUserImpersonation() {
+        return true;
+    }
+    async close() {
+        await this._pool.close();
+        await Promise.all(Object.values(this._openConnections).map(c => c.close()));
+    }
+    async _createConnection(context, address, release) {
+        const auth = context.auth ?? await this._authTokenManager.getToken();
+        const connection = this._newHttpConnection({
+            release: async () => await release(address, connection),
             auth,
-            address: this._address,
-            queryEndpoint: this._queryEndpoint,
+            address,
+            queryEndpoint: context.queryEndpoint,
             config: this._config,
             logger: this._log,
             errorHandler: (error) => {
-                if (error == null || typeof error.code !== 'string' || !error.code.startsWith('Neo.ClientError.Security.') || param?.auth != null) {
+                if (error == null || typeof error.code !== 'string' || !error.code.startsWith('Neo.ClientError.Security.') || context?.auth != null) {
+                    if (error != null && error.code === 'SERVICE_UNAVAILABLE') {
+                        this._queryEndpoint = undefined;
+                    }
                     return error;
                 }
                 const handled = this._authTokenManager.handleSecurityException(auth, error.code);
@@ -53,14 +122,43 @@ export default class HttpConnectionProvider extends ConnectionProvider {
                 return error;
             }
         });
+        this._openConnections[connection.id] = connection;
+        return connection;
     }
-    async verifyConnectivityAndGetServerInfo(param) {
-        const discoveryInfo = await HttpConnection.discover({ scheme: this._scheme, address: this._address });
-        return new ServerInfo({
-            address: this._address,
-            version: discoveryInfo.version
-        }, parseFloat(discoveryInfo.version));
+    async _validateConnectionOnAcquire(context, conn) {
+        try {
+            conn.queryEndpoint = context.queryEndpoint;
+            conn.auth = context.auth ?? await this._authTokenManager.getToken();
+            return true;
+        }
+        catch (error) {
+            this._log.debug(`The connection ${conn.id} is not valid because of an error ${error.code} '${error.message}'`);
+            return false;
+        }
     }
-    async close() {
+    async _destroyConnection(conn) {
+        delete this._openConnections[conn.id];
+        return await conn.close();
     }
 }
+/**
+ * Execute a query and reports possible errors
+ * @param connection
+ * @param config
+ * @returns Promise of correct execution
+ */
+function run(connection, config) {
+    return new Promise((resolve, reject) => {
+        connection.run('CALL db.ping()', {}, {
+            database: config?.database, mode: config?.accessMode, fetchSize: 200, reactive: false, bookmarks: Bookmarks.empty(), highRecordWatermark: 10, lowRecordWatermark: 0, txConfig: TxConfig.empty()
+        })
+            .subscribe({
+            onCompleted() {
+                resolve();
+            },
+            onError(error) {
+                reject(error);
+            }
+        });
+    });
+}

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

@@ -28,6 +28,7 @@ export default class HttpConnection extends Connection {
         this._config = config.config;
         this._log = config.logger;
         this._errorHandler = config.errorHandler;
+        this._open = true;
     }
     run(query, parameters, config) {
         const observer = new ResultStreamObserver({
@@ -55,7 +56,7 @@ export default class HttpConnection extends Connection {
             then(async (res) => {
             return [res.headers.get('content-type'), (await res.json())];
         })
-            .catch(this._handleAndReThrown.bind(this))
+            .catch((error) => this._handleAndReThrown(newError(`Failure accessing "${request.url}"`, 'SERVICE_UNAVAILABLE', error)))
             .catch((error) => observer.onError(error))
             .then(async ([contentType, rawQueryResponse]) => {
             if (rawQueryResponse == null) {
@@ -117,11 +118,26 @@ export default class HttpConnection extends Connection {
             throw newError(`Failure discovering endpoints. Caused by: ${e.message}`, 'SERVICE_UNAVAILABLE', e);
         });
     }
+    get id() {
+        return this._id;
+    }
+    set auth(auth) {
+        this._auth = auth;
+    }
+    get auth() {
+        return this._auth;
+    }
+    set queryEndpoint(queryEndpoint) {
+        this._queryEndpoint = queryEndpoint;
+    }
+    get queryEndpoint() {
+        return this._queryEndpoint;
+    }
     getProtocolVersion() {
         return 0;
     }
     isOpen() {
-        return true;
+        return this._open;
     }
     hasOngoingObservableRequests() {
         return this._abortController != null;
@@ -132,6 +148,10 @@ export default class HttpConnection extends Connection {
     release() {
         return this._release();
     }
+    async close() {
+        this._abortController?.abort(newError('Aborted since connection is being closed.'));
+        this._open = false;
+    }
     toString() {
         return `HttpConnection [${this._id}]`;
     }

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

@@ -56,8 +56,11 @@ class QuerySuccessResponseCodec extends QueryResponseCodec {
         return this._response.data.fields;
     }
     *stream() {
-        for (const value of this._response.data.values) {
-            yield value.map(this._decodeValue.bind(this));
+        while (this._response.data.values.length > 0) {
+            const value = this._response.data.values.shift();
+            if (value != null) {
+                yield value.map(this._decodeValue.bind(this));
+            }
         }
         return;
     }

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

@@ -61,9 +61,12 @@ export class ResultStreamObserver {
             observer.onKeys(this._keys);
         }
         if (this._queuedRecords.length > 0 && observer.onNext) {
-            for (let i = 0; i < this._queuedRecords.length; i++) {
-                observer.onNext(this._queuedRecords[i]);
-                if (this._queuedRecords.length - i - 1 <= this._lowRecordWatermark) {
+            while (this._queuedRecords.length > 0) {
+                const record = this._queuedRecords.shift();
+                if (record != null) {
+                    observer.onNext(record);
+                }
+                if (this._queuedRecords.length - 1 <= this._lowRecordWatermark) {
                     this.resume();
                 }
             }

package/lib/wrapper.impl.js

@@ -10,14 +10,27 @@ export class WrapperImpl {
         validateDatabase(config);
         return this.driver.verifyConnectivity(config);
     }
-    [Symbol.asyncDispose]() {
-        return this.driver.close();
+    supportsMultiDb() {
+        return this.driver.supportsMultiDb();
+    }
+    verifyAuthentication(config) {
+        validateDatabase(config);
+        return this.driver.verifyAuthentication(config);
+    }
+    supportsSessionAuth() {
+        return this.driver.supportsSessionAuth();
+    }
+    supportsUserImpersonation() {
+        return this.driver.supportsUserImpersonation();
     }
     session(config) {
         validateDatabase(config);
         const session = this.driver.session(config);
         return new WrapperSessionImpl(session);
     }
+    [Symbol.asyncDispose]() {
+        return this.driver.close();
+    }
 }
 function validateDatabase(config) {
     if (config.database == null || config.database === '') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neo4j-labs/experimental-query-api-wrapper",
-  "version": "0.0.1-alpha02",
+  "version": "0.0.1-alpha04",
   "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.23.0"
+    "neo4j-driver-core": "^5.24.1"
   },
   "engines": {
     "node": ">=18.0.0"

package/tsconfig.json

@@ -16,5 +16,5 @@
   "include": [
     "src/**/*.ts",
     "test/**/*.ts"
-  ],
+  ]
 }

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

@@ -15,8 +15,8 @@
  * limitations under the License.
  */
 import { ConnectionProvider, internal, AuthTokenManager, Connection, Releasable, types, ServerInfo } from "neo4j-driver-core";
-import { HttpScheme } from "./connection.http";
-export interface HttpConnectionProviderConfig {
+import HttpConnection, { HttpScheme } from "./connection.http";
+export type HttpConnectionProviderConfig = {
     id: number;
     log: internal.logger.Logger;
     address: internal.serverAddress.ServerAddress;
@@ -24,7 +24,13 @@ export interface HttpConnectionProviderConfig {
     authTokenManager: AuthTokenManager;
     config: types.InternalConfig;
     [rec: string]: any;
-}
+};
+export type NewPool = (...params: ConstructorParameters<typeof internal.pool.Pool<HttpConnection>>) => internal.pool.Pool<HttpConnection>;
+export type NewHttpConnection = (...params: ConstructorParameters<typeof HttpConnection>) => HttpConnection;
+export type HttpConnectionProviderInjectable = {
+    newPool: NewPool;
+    newHttpConnection: NewHttpConnection;
+};
 export default class HttpConnectionProvider extends ConnectionProvider {
     private _id;
     private _log;
@@ -34,7 +40,10 @@ export default class HttpConnectionProvider extends ConnectionProvider {
     private _config;
     private _queryEndpoint?;
     private _discoveryPromise?;
-    constructor(config: HttpConnectionProviderConfig);
+    private _openConnections;
+    private _pool;
+    private _newHttpConnection;
+    constructor(config: HttpConnectionProviderConfig, { newPool, newHttpConnection }?: HttpConnectionProviderInjectable);
     acquireConnection(param?: {
         accessMode?: string | undefined;
         database?: string | undefined;
@@ -43,9 +52,20 @@ export default class HttpConnectionProvider extends ConnectionProvider {
         onDatabaseNameResolved?: ((databaseName?: string | undefined) => void) | undefined;
         auth?: types.AuthToken | undefined;
     } | undefined): Promise<Connection & Releasable>;
-    verifyConnectivityAndGetServerInfo(param?: {
-        database?: string | undefined;
+    verifyConnectivityAndGetServerInfo(param: {
+        database: string;
         accessMode?: string | undefined;
     } | undefined): Promise<ServerInfo>;
+    verifyAuthentication(param: {
+        auth?: types.AuthToken | undefined;
+        database: string;
+        accessMode: string;
+    }): Promise<boolean>;
+    supportsMultiDb(): Promise<boolean>;
+    supportsSessionAuth(): Promise<boolean>;
+    supportsUserImpersonation(): Promise<boolean>;
     close(): Promise<void>;
+    private _createConnection;
+    private _validateConnectionOnAcquire;
+    private _destroyConnection;
 }

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

@@ -39,6 +39,7 @@ export default class HttpConnection extends Connection {
     private _log?;
     private _id;
     private _errorHandler;
+    private _open;
     constructor(config: HttpConnectionConfig);
     run(query: string, parameters?: Record<string, unknown> | undefined, config?: RunQueryConfig | undefined): internal.observer.ResultStreamObserver;
     private _handleAndReThrown;
@@ -51,10 +52,16 @@ export default class HttpConnection extends Connection {
         version: string;
         edition: string;
     }>;
+    get id(): number;
+    set auth(auth: types.AuthToken);
+    get auth(): types.AuthToken;
+    set queryEndpoint(queryEndpoint: string);
+    get queryEndpoint(): string;
     getProtocolVersion(): number;
     isOpen(): boolean;
     hasOngoingObservableRequests(): boolean;
     resetAndFlush(): Promise<void>;
     release(): Promise<void>;
+    close(): Promise<void>;
     toString(): string;
 }

package/types/index.d.ts

@@ -245,6 +245,7 @@ declare const forExport: {
         SECURITY: "SECURITY";
         DEPRECATION: "DEPRECATION";
         GENERIC: "GENERIC";
+        SCHEMA: "SCHEMA";
     };
     notificationSeverityLevel: {
         WARNING: "WARNING";

package/types/types.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Driver, Session, SessionConfig, Config, ServerInfo } from "neo4j-driver-core";
+import { Driver, Session, SessionConfig, Config, ServerInfo, types } from "neo4j-driver-core";
 type Disposable = {
     [Symbol.asyncDispose](): Promise<void>;
 };
@@ -23,13 +23,19 @@ type VerifyConnectivity = {
         database: string | undefined;
     } | undefined): Promise<ServerInfo>;
 };
+type VerifyAuthentication = {
+    verifyAuthentication(config: {
+        auth?: types.AuthToken | undefined;
+        database: string;
+    }): Promise<boolean>;
+};
 type HttpUrl = `http://${string}` | `https://${string}`;
 type WrapperSession = Pick<Session, 'run' | 'lastBookmarks' | 'close'> & Disposable;
-type WrapperSessionConfig = Pick<SessionConfig, 'bookmarks' | 'impersonatedUser' | 'bookmarkManager' | 'defaultAccessMode'> & {
+type WrapperSessionConfig = Pick<SessionConfig, 'bookmarks' | 'impersonatedUser' | 'bookmarkManager' | 'defaultAccessMode' | 'auth'> & {
     database: string;
 };
-type Wrapper = Pick<Driver, 'close'> & Disposable & VerifyConnectivity & {
+type Wrapper = Pick<Driver, 'close' | 'supportsMultiDb' | 'supportsSessionAuth' | 'supportsUserImpersonation'> & Disposable & VerifyConnectivity & VerifyAuthentication & {
     session(config: WrapperSessionConfig): WrapperSession;
 };
-type WrapperConfig = Pick<Config, 'encrypted' | 'useBigInt' | 'disableLosslessIntegers'>;
+type WrapperConfig = Pick<Config, 'encrypted' | 'useBigInt' | 'disableLosslessIntegers' | 'maxConnectionPoolSize' | 'connectionAcquisitionTimeout'>;
 export type { HttpUrl, WrapperSession, WrapperSessionConfig, Wrapper, WrapperConfig };

package/types/wrapper.impl.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Driver, ServerInfo } from "neo4j-driver-core";
+import { Driver, ServerInfo, types } from "neo4j-driver-core";
 import { Wrapper, WrapperSession, WrapperSessionConfig } from "./types";
 export declare class WrapperImpl implements Wrapper {
     private readonly driver;
@@ -23,6 +23,13 @@ export declare class WrapperImpl implements Wrapper {
     verifyConnectivity(config: {
         database: string;
     }): Promise<ServerInfo>;
-    [Symbol.asyncDispose](): Promise<void>;
+    supportsMultiDb(): Promise<boolean>;
+    verifyAuthentication(config: {
+        auth?: types.AuthToken | undefined;
+        database: string;
+    }): Promise<boolean>;
+    supportsSessionAuth(): Promise<boolean>;
+    supportsUserImpersonation(): Promise<boolean>;
     session(config: WrapperSessionConfig): WrapperSession;
+    [Symbol.asyncDispose](): Promise<void>;
 }