@neo4j-cypher/query-tools 2.0.0-next.28 → 2.0.0-next.30

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "@neo4j-cypher/query-tools",
+  "version": "2.0.0-next.30",
   "description": "",
-  "author": "Neo4j Inc.",
+  "bugs": {
+    "url": "https://github.com/neo4j/cypher-language-support/issues"
+  },
   "license": "Apache-2.0",
-  "version": "2.0.0-next.28",
+  "author": "Neo4j Inc.",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/neo4j/cypher-language-support.git"
+  },
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
   "types": "./dist/types/src/index.d.ts",
@@ -15,25 +22,18 @@
       "default": "./dist/cjs/src/index.js"
     }
   },
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/neo4j/cypher-language-support.git"
-  },
-  "bugs": {
-    "url": "https://github.com/neo4j/cypher-language-support/issues"
-  },
-  "engineStrict": true,
-  "engines": {
-    "node": ">=24.11.1"
-  },
   "dependencies": {
     "ajv": "^8.12.0",
     "neo4j-driver": "6.0.1",
-    "@neo4j-cypher/language-support": "2.0.0-next.28"
+    "@neo4j-cypher/language-support": "2.0.0-next.30"
   },
   "devDependencies": {
     "@testcontainers/neo4j": "^11.5.1"
   },
+  "engines": {
+    "node": ">=24.11.1"
+  },
+  "engineStrict": true,
   "scripts": {
     "build": "concurrently 'npm:build-esm' 'npm:build-commonjs' 'npm:build-types'",
     "build-esm": "tsc --module esnext --outDir dist/esm",

package/src/cypher-execution/extract-unique-nodes-and-relationships.test.ts

@@ -156,7 +156,9 @@ describe('extractNodesAndRels', () => {
 
     const { nodes, relationships, limitHit } = extractUniqueNodesAndRels(
       [boltRecord],
-      { nodeLimit: 1 },
+      {
+        nodeLimit: 1,
+      },
     );
     expect(limitHit).toBe(true);
     expect(nodes.length).toBe(1);

package/src/data-transforms/record-to-string.ts

@@ -34,9 +34,7 @@ export function propertyToString(
   localeFormattedDates = false,
 ): string {
   if (Array.isArray(property)) {
-    return `[${property
-      .map((p) => propertyToString(p, quoteStrings))
-      .join(', ')}]`;
+    return `[${property.map((p) => propertyToString(p, quoteStrings)).join(', ')}]`;
   }
 
   if (property === null) {
@@ -72,6 +70,7 @@ export function propertyToString(
 
   if (typeof property === 'string') {
     if (quoteStrings) {
+      // oxlint-disable-next-line typescript-eslint/restrict-template-expressions
       return `"${property}"`;
     }
     return property;

package/src/metadataPoller.ts

@@ -250,10 +250,18 @@ export class ConnectedMetadataPoller extends MetadataPoller {
     await Promise.allSettled([
       this.databases.refetch(),
       this.dataSummary.refetch(),
-      this.graphSchema.refetch(),
       ...Object.values(this.procedures).map((version) => version?.refetch()),
       ...Object.values(this.functions).map((version) => version?.refetch()),
     ]);
+    if (
+      this.dbSchema.labels &&
+      this.dbSchema.relationshipTypes &&
+      this.dbSchema.labels.length + this.dbSchema.relationshipTypes.length < 200
+    ) {
+      await this.graphSchema.refetch();
+    } else {
+      this.dbSchema.graphSchema = undefined;
+    }
     this.events.emit('schemaFetched');
   }
 

package/src/neo4jConnection.ts

@@ -21,7 +21,9 @@ function resolveInitialDatabase(
   database?: string,
 ): string | undefined {
   if (database) {
-    return databases.find((d) => d.name === database)?.name;
+    return databases.find(
+      (d) => d.name === database || d?.aliases?.includes(database),
+    )?.name;
   }
 
   const home = databases.find((d) => d.home);
@@ -165,7 +167,7 @@ export class Neo4jConnection {
           const result = tx.run(query, {});
           return await queryConfig.resultTransformer(result);
         },
-        { metadata: { ...METADATA_BASE, type: queryType } },
+        { timeout: 500, metadata: { ...METADATA_BASE, type: queryType } },
       );
     } finally {
       await session.close();

package/src/queries/dataSummary.ts

@@ -21,7 +21,7 @@ UNION ALL
 CALL db.propertyKeys() YIELD propertyKey
 RETURN COLLECT(propertyKey)[..${ITEM_LIMIT}] AS result`;
 
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       return record.toObject().result as string[];
     },

package/src/queries/databases.ts

@@ -1,6 +1,6 @@
 import type { CypherVersion } from '@neo4j-cypher/language-support';
 import { resultTransformers } from 'neo4j-driver';
-import { ExecuteQueryArgs } from '../types/sdkTypes';
+import { ExecuteQueryArgs, DbType } from '../types/sdkTypes';
 
 export type DatabaseStatus =
   | 'online'
@@ -26,7 +26,7 @@ export type Database = {
   default: boolean;
   home: boolean;
   aliases?: string[]; // introduced in neo4j 4.4
-  type?: 'system' | 'composite' | 'standard'; // introduced in neo4j 5
+  type?: 'system' | 'composite' | 'standard' | 'graph shard' | 'property shard'; // introduced in neo4j 5
   // "new keys", not sure which version introduced
   writer?: boolean;
   access?: string;
@@ -34,6 +34,30 @@ export type Database = {
   defaultLanguage?: CypherVersion;
 };
 
+const findComposite = (databases: Database[], alias: string) => {
+  const compositeDatabases = databases.filter((db) => db.type === 'composite');
+  return compositeDatabases.find((db) => db.constituents?.includes(alias));
+};
+
+const isCompositeAlias = (databases: Database[], alias: string) =>
+  findComposite(databases, alias) !== undefined;
+
+const removeCompositeAliases = (databases: Database[]): Database[] => {
+  return databases.map(({ aliases, ...db }) => ({
+    ...db,
+    aliases: aliases?.filter((alias) => !isCompositeAlias(databases, alias)),
+  }));
+};
+
+const removeSPDShards = (databases: Database[]): Database[] => {
+  return databases.filter((db) => {
+    return !(
+      db.type !== undefined &&
+      (db.type === DbType.GRAPH_SHARD || db.type === DbType.PROPERTY_SHARD)
+    );
+  });
+};
+
 /**
  * List available databases in your dbms
  * https://neo4j.com/docs/cypher-manual/current/administration/databases/#administration-databases-show-databases
@@ -43,7 +67,7 @@ export function listDatabases(): ExecuteQueryArgs<{
 }> {
   const query = 'SHOW DATABASES YIELD *';
 
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       const obj = record.toObject();
       if (obj.defaultLanguage) {
@@ -52,8 +76,21 @@ export function listDatabases(): ExecuteQueryArgs<{
       return obj as Database;
     },
     collect(databases, summary) {
+      const instancesRecord: Record<string, Database> = databases.reduce<
+        Record<string, Database>
+      >((acc, db) => {
+        const instanceId: string = `${db.name}@${db.address}`;
+        acc[instanceId] = db;
+        return acc;
+      }, {});
+      const logicalDatabases: Record<string, Database> =
+        getLogicalDatabases(instancesRecord);
+      const uiDatabases = removeSPDShards(
+        removeCompositeAliases(Object.values(logicalDatabases)),
+      );
+
       return {
-        databases: databases.filter((x) => x?.writer === true),
+        databases: sortDatabases(uiDatabases),
         summary,
       };
     },
@@ -64,3 +101,69 @@ export function listDatabases(): ExecuteQueryArgs<{
     queryConfig: { resultTransformer, routing: 'READ', database: 'system' },
   };
 }
+
+/**
+ * In clustered environments a single logical database can be backed by multiple physical database instances
+ * running on a different servers.
+ * This function returns a record of logical databases.
+ * A database instance is uniquely identified by its name and address.
+ * A logical database is uniquely identified by its name.
+ * @input instances - a record of database instances
+ * @output a record of logical databases
+ */
+export function getLogicalDatabases(
+  instances: Record<string, Database>,
+): Record<string, Database> {
+  // Two databases with the same name but different properties will be merged into one
+  // merging rules:
+  // - if writer (leader) is present, use it, otherwise use the first one
+
+  // Merge db2 into db1
+  const mergeDatabases = (db1: Database, db2: Database): Database => {
+    let mergedDatabase = { ...db1 };
+    if (db2.role === 'leader' || db2.writer === true) {
+      mergedDatabase = { ...db2 };
+    }
+
+    return mergedDatabase;
+  };
+
+  return Object.values(instances).reduce<Record<string, Database>>(
+    (databases, instance) => {
+      const key = instance.name;
+      const existingDatabase = databases[key];
+      const mergedDatabase = existingDatabase
+        ? mergeDatabases(existingDatabase, instance)
+        : instance;
+
+      return {
+        ...databases,
+        [key]: mergedDatabase,
+      };
+    },
+    {},
+  );
+}
+
+export function sortDatabases(databases: Database[]) {
+  function databaseComparator(a: Database, b: Database) {
+    // disable eslint to make code more readable
+    /* eslint-disable curly */
+    // home is greater than default
+    if (a.default && b.home) return 1;
+
+    // otherwiser default is greater than anything else
+    if (a.default) return -1;
+    if (b.default) return 1;
+
+    // system is less than anything else
+    if (a.name === 'system') return 1;
+    if (b.name === 'system') return -1;
+    /* eslint-enable curly */
+
+    // else sort alphabetically
+    return a.name.localeCompare(b.name);
+  }
+
+  return databases.sort(databaseComparator);
+}

package/src/queries/functions.ts

@@ -77,7 +77,7 @@ export function listFunctions(
     ${executableByMe ? 'EXECUTABLE BY CURRENT USER' : ''}
     YIELD *`;
 
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       const objResult = record.toObject();
       validateFunction(objResult);

package/src/queries/graphSchema.ts

@@ -65,7 +65,7 @@ export function listGraphSchema(
   graphSchema: { from: string; to: string; relType: string }[];
 }> {
   const query = `CALL db.schema.visualization() YIELD *`;
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       const objResult = record.toObject();
       validateGraphSchema(objResult);

package/src/queries/procedures.ts

@@ -91,7 +91,7 @@ export function listProcedures(
     ${executableByMe ? 'EXECUTABLE BY CURRENT USER' : ''}
     YIELD *`;
 
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       // Assign default values (e.g. isDeprecated) in case they are not present
       const objResult = record.toObject();

package/src/queries/roles.ts

@@ -14,7 +14,7 @@ export function listRoles(): ExecuteQueryArgs<{
 }> {
   const query = `SHOW ROLES`;
 
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       return record.toObject() as Neo4jRole;
     },

package/src/queries/users.ts

@@ -19,7 +19,7 @@ export function listUsers(): ExecuteQueryArgs<{
 }> {
   const query = `SHOW USERS`;
 
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       return record.toObject() as Neo4jUser;
     },

package/src/queries/version.ts

@@ -9,7 +9,7 @@ export function getVersion(): ExecuteQueryArgs<{
 }> {
   const query = 'CALL dbms.components() YIELD name, versions';
 
-  const resultTransformer = resultTransformers.mappedResultTransformer({
+  const resultTransformer = resultTransformers.mapped({
     map(record) {
       const obj = record.toObject();
       const name = obj.name as string;

package/src/result-transformers/graph-result-transformer.ts

@@ -44,14 +44,13 @@ export type GraphResult = DeduplicatedNodesAndRels & {
  *
  * @returns ResultTransformer producing {@link GraphResult}
  */
-export const graphResultTransformer =
-  resultTransformers.mappedResultTransformer({
-    map(record) {
-      return record;
-    },
-    collect(records, summary): GraphResult {
-      const { nodes, relationships, limitHit } =
-        extractUniqueNodesAndRels(records);
-      return { nodes, relationships, limitHit, records, summary };
-    },
-  });
+export const graphResultTransformer = resultTransformers.mapped({
+  map(record) {
+    return record;
+  },
+  collect(records, summary): GraphResult {
+    const { nodes, relationships, limitHit } =
+      extractUniqueNodesAndRels(records);
+    return { nodes, relationships, limitHit, records, summary };
+  },
+});

package/src/schemaPoller.ts

@@ -168,7 +168,7 @@ export class Neo4jSchemaPoller {
         );
         return ['5', '25'];
       }
-    } catch (e) {
+    } catch {
       return ['5'];
     }
 
@@ -247,7 +247,10 @@ export class Neo4jSchemaPoller {
     const driver = neo4j.driver(
       url,
       neo4j.auth.basic(credentials.username, credentials.password),
-      { userAgent: config.appName, ...config.driverConfig },
+      {
+        userAgent: config.appName,
+        ...config.driverConfig,
+      },
     );
 
     await driver.verifyConnectivity({ database: database });
@@ -323,9 +326,7 @@ export class Neo4jSchemaPoller {
     retriable: boolean,
   ): ConnectionError {
     const friendlyMessage = retriable
-      ? `${connectionError.friendlyMessage}. Retrying in ${
-          RETRY_INTERVAL_MS / 1000
-        } seconds`
+      ? `${connectionError.friendlyMessage}. Retrying in ${RETRY_INTERVAL_MS / 1000} seconds`
       : connectionError.friendlyMessage;
 
     return {

package/src/types/cypher-data-types.ts

@@ -25,7 +25,7 @@ import {
 } from 'neo4j-driver';
 type NumberOrInteger = number | Integer | bigint;
 
-/** 
+/**
       The neo4j driver type mapping - https://neo4j.com/docs/javascript-manual/current/cypher-workflow/#js-driver-type-mapping
       
       Star denotes custom driver class.

package/src/types/sdkTypes.ts

@@ -1,6 +1,12 @@
 import type { QueryConfig, ResultSummary } from 'neo4j-driver';
 
-export type DbType = 'system' | 'standard' | 'composite';
+export const DbType = {
+  SYSTEM: 'system',
+  STANDARD: 'standard',
+  COMPOSITE: 'composite',
+  GRAPH_SHARD: 'graph shard',
+  PROPERTY_SHARD: 'property shard',
+};
 
 export type QueryType =
   // Query automatically run by the app.

package/vitest.config.mts

@@ -3,6 +3,7 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   test: {
     globals: true,
-    hookTimeout: 90000
+    hookTimeout: 90000,
+    dir: './src',
   },
 });