@neo4j-cypher/query-tools 2.0.0-next.36 → 2.0.0-next.38

package/dist/cjs/index.cjs

@@ -0,0 +1,1848 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ESCAPE_CHAR: () => ESCAPE_CHAR,
+  FRIENDLY_ERROR_MESSAGES: () => FRIENDLY_ERROR_MESSAGES,
+  Neo4jSchemaPoller: () => Neo4jSchemaPoller,
+  RESERVED_TYPE_PROPERTY_NAME: () => RESERVED_TYPE_PROPERTY_NAME,
+  addAnnotationProp: () => addAnnotationProp,
+  cypherDataToCypherCSVString: () => cypherDataToCypherCSVString,
+  cypherDataToString: () => cypherDataToString,
+  deleteAnnotationProp: () => deleteAnnotationProp,
+  deserializeTypeAnnotations: () => deserializeTypeAnnotations,
+  extractUniqueNodesAndRels: () => extractUniqueNodesAndRels,
+  getCypherTypeName: () => getCypherTypeName,
+  getPropertyTypeDisplayName: () => getPropertyTypeDisplayName,
+  getVersion: () => getVersion,
+  graphResultTransformer: () => graphResultTransformer,
+  isCypherBasicPropertyType: () => isCypherBasicPropertyType,
+  isCypherPropertyType: () => isCypherPropertyType,
+  isCypherTemporalType: () => isCypherTemporalType,
+  isInt8Array: () => isInt8Array,
+  propertyToString: () => propertyToString,
+  serializeTypeAnnotations: () => serializeTypeAnnotations,
+  spacialFormat: () => spacialFormat
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/connectionErrorHandler.ts
+var FRIENDLY_ERROR_MESSAGES = {
+  "Neo.ClientError.Security.AuthenticationRateLimit": "Double check your username and password",
+  "Neo.ClientError.Security.CredentialsExpired": "Double check your username and password",
+  "Neo.ClientError.Security.Unauthorized": "Double check your username and password",
+  "Neo.ClientError.Security.TokenExpired": "Double check your username and password",
+  "Neo.ClientError.Database.DatabaseNotFound": "Double check that the database exists",
+  ServiceUnavailable: "Double check the scheme, host and port are correct, make sure Neo4j is running and that you have a network connection if needed",
+  Default: "An error occurred while connecting to Neo4j"
+};
+function isRetriableNeo4jError(error) {
+  return isNeo4jError(error) ? error.retriable : true;
+}
+function isNeo4jError(error) {
+  return error instanceof Error && error.code !== void 0 && error.message !== void 0;
+}
+function getConnectionError(error) {
+  if (isNeo4jError(error)) {
+    return {
+      message: stripTrailingPeriod(error.message),
+      code: error.code,
+      friendlyMessage: FRIENDLY_ERROR_MESSAGES[error.code] ?? FRIENDLY_ERROR_MESSAGES.Default
+    };
+  }
+  return {
+    message: "",
+    code: "",
+    friendlyMessage: FRIENDLY_ERROR_MESSAGES.Default
+  };
+}
+function stripTrailingPeriod(message) {
+  return message.endsWith(".") ? message.slice(0, -1) : message;
+}
+
+// src/cypher-execution/extract-unique-nodes-and-relationships.ts
+var import_neo4j_driver = require("neo4j-driver");
+var extractUniqueNodesAndRels = (records, {
+  nodeLimit,
+  keepDanglingRels = false
+} = {}) => {
+  let limitHit = false;
+  const items = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    for (const key of record.keys) {
+      items.add(record.get(key));
+    }
+  }
+  const paths = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  function addNode(n) {
+    if (!limitHit) {
+      const id = n.elementId.toString();
+      if (!nodeMap.has(id)) {
+        nodeMap.set(id, n);
+      }
+      if (typeof nodeLimit === "number" && nodeMap.size === nodeLimit) {
+        limitHit = true;
+      }
+    }
+  }
+  const relMap = /* @__PURE__ */ new Map();
+  function addRel(r) {
+    const id = r.elementId.toString();
+    if (!relMap.has(id)) {
+      relMap.set(id, r);
+    }
+  }
+  const findAllEntities = (item) => {
+    if (typeof item !== "object" || !item) {
+      return;
+    }
+    if ((0, import_neo4j_driver.isRelationship)(item)) {
+      addRel(item);
+    } else if ((0, import_neo4j_driver.isNode)(item)) {
+      addNode(item);
+    } else if ((0, import_neo4j_driver.isPath)(item)) {
+      paths.push(item);
+    } else if (Array.isArray(item)) {
+      item.forEach(findAllEntities);
+    } else {
+      Object.values(item).forEach(findAllEntities);
+    }
+  };
+  findAllEntities(Array.from(items));
+  for (const path of paths) {
+    addNode(path.start);
+    addNode(path.end);
+    for (const segment of path.segments) {
+      addNode(segment.start);
+      addNode(segment.end);
+      addRel(segment.relationship);
+    }
+  }
+  const nodes = Array.from(nodeMap.values());
+  const relationships = Array.from(relMap.values()).filter((item) => {
+    if (keepDanglingRels) {
+      return true;
+    }
+    const start = item.startNodeElementId.toString();
+    const end = item.endNodeElementId.toString();
+    return nodeMap.has(start) && nodeMap.has(end);
+  });
+  return { nodes, relationships, limitHit };
+};
+
+// src/cypher-execution/query-result.ts
+var import_neo4j_driver2 = require("neo4j-driver");
+var RESERVED_TYPE_PROPERTY_NAME = "transport-class";
+var ESCAPE_CHAR = "_";
+function addAnnotationProp(obj, type, prop = RESERVED_TYPE_PROPERTY_NAME) {
+  let objShallowCopy = Object.entries(obj).reduce(
+    (newObj, [key, value]) => {
+      newObj[key] = value;
+      return newObj;
+    },
+    {}
+  );
+  if (Object.prototype.hasOwnProperty.call(objShallowCopy, prop)) {
+    objShallowCopy = addAnnotationProp(
+      objShallowCopy,
+      objShallowCopy[prop],
+      ESCAPE_CHAR + prop
+    );
+    delete objShallowCopy[prop];
+  }
+  objShallowCopy[prop] = type;
+  return objShallowCopy;
+}
+function deleteAnnotationProp(obj) {
+  let escapedProp = RESERVED_TYPE_PROPERTY_NAME;
+  while (Object.prototype.hasOwnProperty.call(obj, escapedProp)) {
+    obj[escapedProp.replace(ESCAPE_CHAR, "")] = obj[escapedProp];
+    delete obj[escapedProp];
+    escapedProp = ESCAPE_CHAR + escapedProp;
+  }
+}
+function copyAndAnnotate(obj) {
+  return Object.keys(obj).reduce((newObj, key) => {
+    const value = obj[key];
+    newObj[key] = serializeTypeAnnotations(value);
+    return newObj;
+  }, {});
+}
+function serializeTypeAnnotations(item) {
+  if (Array.isArray(item)) {
+    return item.map((i) => serializeTypeAnnotations(i));
+  }
+  if (item === null || item === void 0) {
+    return item;
+  }
+  if (item instanceof import_neo4j_driver2.types.Record) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Record");
+  }
+  if (item instanceof import_neo4j_driver2.types.ResultSummary) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "ResultSummary");
+  }
+  if (item instanceof import_neo4j_driver2.types.Node) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Node");
+  }
+  if (item instanceof import_neo4j_driver2.types.PathSegment) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "PathSegment");
+  }
+  if (item instanceof import_neo4j_driver2.types.Path) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Path");
+  }
+  if (item instanceof import_neo4j_driver2.types.Relationship) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Relationship");
+  }
+  if (item instanceof import_neo4j_driver2.types.Point) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Point");
+  }
+  if (item instanceof import_neo4j_driver2.types.Date) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Date");
+  }
+  if (item instanceof import_neo4j_driver2.types.DateTime) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "DateTime");
+  }
+  if (item instanceof import_neo4j_driver2.types.Duration) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Duration");
+  }
+  if (item instanceof import_neo4j_driver2.types.LocalDateTime) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "LocalDateTime");
+  }
+  if (item instanceof import_neo4j_driver2.types.LocalTime) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "LocalTime");
+  }
+  if (item instanceof import_neo4j_driver2.types.Time) {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Time");
+  }
+  if ((0, import_neo4j_driver2.isInt)(item)) {
+    const tmp = { ...item };
+    return addAnnotationProp(tmp, "Integer");
+  }
+  if ((0, import_neo4j_driver2.isVector)(item)) {
+    const typedArray = item.asTypedArray();
+    const values = typedArray instanceof BigInt64Array ? Array.from(typedArray, (v) => v.toString()) : Array.from(typedArray);
+    return addAnnotationProp(
+      {
+        _type: item.getType(),
+        _values: values
+      },
+      "Vector"
+    );
+  }
+  if (typeof item === "object") {
+    const tmp = copyAndAnnotate(item);
+    return addAnnotationProp(tmp, "Object");
+  }
+  return item;
+}
+function deserializeTypeAnnotations(rawItem) {
+  if (Array.isArray(rawItem)) {
+    const mapped = rawItem.map((i) => deserializeTypeAnnotations(i));
+    return mapped;
+  }
+  if (rawItem === null || rawItem === void 0 || typeof rawItem === "boolean" || typeof rawItem === "string" || !Object.prototype.hasOwnProperty.call(rawItem, RESERVED_TYPE_PROPERTY_NAME)) {
+    return rawItem;
+  }
+  const item = { ...rawItem };
+  const className = item[RESERVED_TYPE_PROPERTY_NAME];
+  deleteAnnotationProp(item);
+  switch (className) {
+    case "Record":
+      return new import_neo4j_driver2.types.Record(
+        deserializeTypeAnnotations(item.keys),
+        deserializeTypeAnnotations(item._fields),
+        deserializeTypeAnnotations(item._fieldLookup)
+      );
+    case "ResultSummary": {
+      const metadata = {
+        ...item,
+        type: item.queryType,
+        db: item.database.name,
+        result_available_after: deserializeTypeAnnotations(
+          item.resultAvailableAfter
+        ),
+        result_consumed_after: deserializeTypeAnnotations(
+          item.resultConsumedAfter
+        ),
+        profile: item.profile === false ? null : item.profile,
+        plan: item.plan === false ? null : item.plan,
+        stream_summary: { have_records_streamed: true },
+        server: {
+          ...item.server,
+          version: item.server.agent
+        }
+      };
+      return new import_neo4j_driver2.types.ResultSummary(
+        deserializeTypeAnnotations(item.query.text),
+        deserializeTypeAnnotations(item.query.parameters),
+        deserializeTypeAnnotations(metadata),
+        deserializeTypeAnnotations(item.server.protocolVersion)
+      );
+    }
+    case "Node":
+      return new import_neo4j_driver2.types.Node(
+        deserializeTypeAnnotations(item.identity),
+        item.labels,
+        deserializeTypeAnnotations(item.properties),
+        item.elementId
+      );
+    case "Relationship":
+      return new import_neo4j_driver2.types.Relationship(
+        deserializeTypeAnnotations(item.identity),
+        deserializeTypeAnnotations(item.start),
+        deserializeTypeAnnotations(item.end),
+        item.type,
+        deserializeTypeAnnotations(item.properties),
+        item.elementId,
+        item.startNodeElementId,
+        item.endNodeElementId
+      );
+    case "PathSegment":
+      return new import_neo4j_driver2.types.PathSegment(
+        deserializeTypeAnnotations(item.start),
+        deserializeTypeAnnotations(item.relationship),
+        deserializeTypeAnnotations(item.end)
+      );
+    case "Path": {
+      const { segments } = item;
+      return new import_neo4j_driver2.types.Path(
+        deserializeTypeAnnotations(item.start),
+        deserializeTypeAnnotations(item.end),
+        (Array.isArray(segments) ? segments : []).map(
+          (x) => deserializeTypeAnnotations(x)
+        )
+      );
+    }
+    case "Point":
+      return new import_neo4j_driver2.types.Point(
+        deserializeTypeAnnotations(item.srid),
+        deserializeTypeAnnotations(item.x),
+        deserializeTypeAnnotations(item.y),
+        deserializeTypeAnnotations(item.z)
+      );
+    case "Date":
+      return new import_neo4j_driver2.types.Date(
+        deserializeTypeAnnotations(item.year),
+        deserializeTypeAnnotations(item.month),
+        deserializeTypeAnnotations(item.day)
+      );
+    case "DateTime":
+      return new import_neo4j_driver2.types.DateTime(
+        deserializeTypeAnnotations(item.year),
+        deserializeTypeAnnotations(item.month),
+        deserializeTypeAnnotations(item.day),
+        deserializeTypeAnnotations(item.hour),
+        deserializeTypeAnnotations(item.minute),
+        deserializeTypeAnnotations(item.second),
+        deserializeTypeAnnotations(item.nanosecond),
+        deserializeTypeAnnotations(item.timeZoneOffsetSeconds),
+        deserializeTypeAnnotations(item.timeZoneId)
+      );
+    case "Duration":
+      return new import_neo4j_driver2.types.Duration(
+        deserializeTypeAnnotations(item.months),
+        deserializeTypeAnnotations(item.days),
+        deserializeTypeAnnotations(item.seconds),
+        deserializeTypeAnnotations(item.nanoseconds)
+      );
+    case "LocalDateTime":
+      return new import_neo4j_driver2.types.LocalDateTime(
+        deserializeTypeAnnotations(item.year),
+        deserializeTypeAnnotations(item.month),
+        deserializeTypeAnnotations(item.day),
+        deserializeTypeAnnotations(item.hour),
+        deserializeTypeAnnotations(item.minute),
+        deserializeTypeAnnotations(item.second),
+        deserializeTypeAnnotations(item.nanosecond)
+      );
+    case "LocalTime":
+      return new import_neo4j_driver2.types.LocalTime(
+        deserializeTypeAnnotations(item.hour),
+        deserializeTypeAnnotations(item.minute),
+        deserializeTypeAnnotations(item.second),
+        deserializeTypeAnnotations(item.nanosecond)
+      );
+    case "Time":
+      return new import_neo4j_driver2.types.Time(
+        deserializeTypeAnnotations(item.hour),
+        deserializeTypeAnnotations(item.minute),
+        deserializeTypeAnnotations(item.second),
+        deserializeTypeAnnotations(item.nanosecond),
+        deserializeTypeAnnotations(item.timeZoneOffsetSeconds)
+      );
+    case "Integer":
+      return (0, import_neo4j_driver2.int)(item);
+    case "Vector": {
+      const type = item._type;
+      const values = item._values;
+      let typedArray;
+      switch (type) {
+        case "INT8":
+          typedArray = new Int8Array(values);
+          break;
+        case "INT16":
+          typedArray = new Int16Array(values);
+          break;
+        case "INT32":
+          typedArray = new Int32Array(values);
+          break;
+        case "INT64":
+          typedArray = new BigInt64Array(values.map((v) => BigInt(v)));
+          break;
+        case "FLOAT32":
+          typedArray = new Float32Array(values);
+          break;
+        case "FLOAT64":
+          typedArray = new Float64Array(values);
+          break;
+        default:
+          return item;
+      }
+      return new import_neo4j_driver2.Vector(typedArray);
+    }
+    case "Object":
+      return Object.keys(item).reduce(
+        (newObj, key) => {
+          newObj[key] = deserializeTypeAnnotations(item[key]);
+          return newObj;
+        },
+        {}
+      );
+    default:
+      return item;
+  }
+}
+
+// src/data-transforms/cypher-type-names.ts
+var import_neo4j_driver4 = require("neo4j-driver");
+
+// src/types/cypher-data-types.ts
+var import_neo4j_driver3 = require("neo4j-driver");
+var isCypherTemporalType = (anything) => {
+  if (typeof anything === "object" && anything !== null) {
+    return [
+      import_neo4j_driver3.isDate,
+      import_neo4j_driver3.isTime,
+      import_neo4j_driver3.isDateTime,
+      import_neo4j_driver3.isLocalTime,
+      import_neo4j_driver3.isLocalDateTime,
+      import_neo4j_driver3.isDuration
+    ].some((tester) => tester(anything));
+  }
+  return false;
+};
+var isCypherBasicPropertyType = (value) => {
+  const valType = typeof value;
+  return value === null || valType === "boolean" || valType === "string" || valType === "number" || valType === "bigint" || value?.constructor === Int8Array || (0, import_neo4j_driver3.isInt)(value) || isCypherTemporalType(value) || (0, import_neo4j_driver3.isPoint)(value) || (0, import_neo4j_driver3.isVector)(value);
+};
+var isCypherPropertyType = (value) => {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return true;
+    }
+    return isCypherBasicPropertyType(value[0]);
+  }
+  return isCypherBasicPropertyType(value);
+};
+function isInt8Array(val) {
+  return typeof val === "object" && val !== null && val.constructor === Int8Array;
+}
+
+// src/data-transforms/cypher-type-names.ts
+var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var getPropertyTypeDisplayName = (val) => {
+  const jsType = typeof val;
+  if (jsType === "number") {
+    return "Float";
+  }
+  if (val === null || val === void 0) {
+    return "null";
+  }
+  if (typeof val !== "object") {
+    const capitalized = capitalize(jsType);
+    switch (capitalized) {
+      case "String":
+      case "Bigint":
+      case "Boolean":
+        return capitalized;
+      default:
+        return "Unknown";
+    }
+  }
+  if (val instanceof Array) {
+    const [firstVal] = val;
+    if (firstVal !== void 0) {
+      return `List<${getPropertyTypeDisplayName(firstVal)}>(${val.length})`;
+    }
+    return `List(${val.length})`;
+  }
+  if ((0, import_neo4j_driver4.isLocalTime)(val)) {
+    return "LocalTime";
+  }
+  if ((0, import_neo4j_driver4.isTime)(val)) {
+    return "Time";
+  }
+  if ((0, import_neo4j_driver4.isDate)(val)) {
+    return "Date";
+  }
+  if ((0, import_neo4j_driver4.isLocalDateTime)(val)) {
+    return "LocalDateTime";
+  }
+  if ((0, import_neo4j_driver4.isDateTime)(val)) {
+    return "DateTime";
+  }
+  if ((0, import_neo4j_driver4.isInt)(val)) {
+    return "Integer";
+  }
+  if ((0, import_neo4j_driver4.isDuration)(val)) {
+    return "Duration";
+  }
+  if ((0, import_neo4j_driver4.isPoint)(val)) {
+    return "Point";
+  }
+  if (isInt8Array(val)) {
+    return "ByteArray";
+  }
+  if ((0, import_neo4j_driver4.isVector)(val)) {
+    return "Vector";
+  }
+  return "Unknown";
+};
+function getCypherTypeName(val) {
+  if (Array.isArray(val)) {
+    return "List";
+  }
+  if (isCypherBasicPropertyType(val)) {
+    return getPropertyTypeDisplayName(val);
+  }
+  if ((0, import_neo4j_driver4.isNode)(val)) {
+    return "Node";
+  }
+  if ((0, import_neo4j_driver4.isRelationship)(val)) {
+    return "Relationship";
+  }
+  if ((0, import_neo4j_driver4.isPath)(val)) {
+    return "Path";
+  }
+  if ((0, import_neo4j_driver4.isVector)(val)) {
+    return "Vector";
+  }
+  return "Map";
+}
+
+// src/data-transforms/record-to-string.ts
+var import_neo4j_driver5 = require("neo4j-driver");
+
+// src/data-transforms/format-float.ts
+var formatFloat = (anything) => {
+  if ([Infinity, -Infinity, NaN].includes(anything)) {
+    return `${anything}`;
+  }
+  if (Math.floor(anything) === anything) {
+    return `${anything}.0`;
+  }
+  return anything.toString();
+};
+
+// src/data-transforms/record-to-string.ts
+var spacialFormat = (p) => {
+  const zString = p.z !== void 0 ? `, z:${formatFloat(p.z)}` : "";
+  return `point({srid:${p.srid.toString()}, x:${formatFloat(
+    p.x
+  )}, y:${formatFloat(p.y)}${zString}})`;
+};
+function propertyToString(property, quoteStrings = true, localeFormattedDates = false) {
+  if (Array.isArray(property)) {
+    return `[${property.map((p) => propertyToString(p, quoteStrings)).join(", ")}]`;
+  }
+  if (property === null) {
+    return "null";
+  }
+  if (isCypherTemporalType(property)) {
+    if ((0, import_neo4j_driver5.isDate)(property) && localeFormattedDates) {
+      return property.toStandardDate().toLocaleDateString();
+    }
+    if ((0, import_neo4j_driver5.isLocalDateTime)(property) && localeFormattedDates) {
+      return property.toStandardDate().toLocaleString();
+    }
+    return property.toString();
+  }
+  if (typeof property === "boolean" || (0, import_neo4j_driver5.isInt)(property) || typeof property === "bigint" || (0, import_neo4j_driver5.isVector)(property)) {
+    return property.toString();
+  }
+  if ((0, import_neo4j_driver5.isPoint)(property)) {
+    return spacialFormat(property);
+  }
+  if (typeof property === "number") {
+    return formatFloat(property);
+  }
+  if (typeof property === "string") {
+    if (quoteStrings) {
+      return `"${property}"`;
+    }
+    return property;
+  }
+  if (isInt8Array(property)) {
+    return "ByteArray";
+  }
+  return String(property);
+}
+var cypherShellStyleStringify = (value, {
+  stringStyle,
+  quoteStrings
+}) => {
+  const includeIds = stringStyle === "cypher-with-ids";
+  if ((0, import_neo4j_driver5.isNode)(value)) {
+    const labels = value.labels.length > 0 ? `:${value.labels.join(":")}` : "";
+    const properties = Object.entries(value.properties).map(([key, val]) => {
+      return `${key}: ${propertyToString(val, quoteStrings)}`;
+    }).concat(
+      includeIds ? [
+        `<elementId>: "${value.elementId.toString()}", <id>: ${value.identity.toString()}`
+      ] : []
+    ).join(", ");
+    const propertiesString = properties.length > 0 ? `{${properties}}` : "";
+    const space = labels.length > 0 && propertiesString.length > 0 ? " " : "";
+    return `(${labels}${space}${propertiesString})`;
+  } else if ((0, import_neo4j_driver5.isRelationship)(value)) {
+    const type = value.type ? `:${value.type}` : "";
+    const properties = Object.entries(value.properties).map(([key, val]) => {
+      return `${key}: ${propertyToString(val, quoteStrings)}`;
+    }).concat(
+      includeIds ? [
+        `<elementId>: ${quoteStrings ? `"${value.elementId.toString()}"` : value.elementId.toString()}, <id>: ${value.identity.toString()}`
+      ] : []
+    ).join(", ");
+    const propertiesString = properties.length > 0 ? ` {${properties}}` : "";
+    return `[${type}${propertiesString}]`;
+  } else if ((0, import_neo4j_driver5.isPath)(value)) {
+    if (value.segments.length === 0) {
+      return cypherShellStyleStringify(value.start, {
+        stringStyle,
+        quoteStrings
+      });
+    }
+    return value.segments.map((segment, index) => {
+      const result = [];
+      if (index === 0) {
+        result.push(
+          cypherShellStyleStringify(segment.start, {
+            stringStyle,
+            quoteStrings
+          })
+        );
+      }
+      if (segment.start.elementId === segment.relationship.startNodeElementId) {
+        result.push("-");
+        result.push(
+          cypherShellStyleStringify(segment.relationship, {
+            stringStyle,
+            quoteStrings
+          })
+        );
+        result.push("->");
+        result.push(
+          cypherShellStyleStringify(segment.end, {
+            stringStyle,
+            quoteStrings
+          })
+        );
+      } else {
+        result.push("<-");
+        result.push(
+          cypherShellStyleStringify(segment.relationship, {
+            stringStyle,
+            quoteStrings
+          })
+        );
+        result.push("-");
+        result.push(
+          cypherShellStyleStringify(segment.end, {
+            stringStyle,
+            quoteStrings
+          })
+        );
+      }
+      return result.join("");
+    }).join("");
+  }
+  return "";
+};
+var recursiveStringify = (value, {
+  indentationLevel = 0,
+  quoteStrings = true,
+  stringStyle = "json"
+} = {}) => {
+  if (value === void 0) {
+    return "";
+  }
+  const indentation = "  ".repeat(indentationLevel);
+  const nextIndentationLevel = indentationLevel + 1;
+  const nextIdentation = "  ".repeat(nextIndentationLevel);
+  if (isCypherPropertyType(value)) {
+    return propertyToString(value, quoteStrings);
+  }
+  if (Array.isArray(value)) {
+    return `[
+${value.map(
+      (v) => `${nextIdentation}${recursiveStringify(v, {
+        indentationLevel: nextIndentationLevel,
+        quoteStrings
+      })}`
+    ).join(",\n")}
+${indentation}]`;
+  }
+  if (stringStyle !== "json" && ((0, import_neo4j_driver5.isNode)(value) || (0, import_neo4j_driver5.isRelationship)(value) || (0, import_neo4j_driver5.isPath)(value))) {
+    return cypherShellStyleStringify(value, { stringStyle, quoteStrings });
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  return `{
+${entries.map(([key, val]) => {
+    return `${nextIdentation}${key}: ${recursiveStringify(val, {
+      indentationLevel: nextIndentationLevel,
+      quoteStrings
+    })}`;
+  }).join(",\n")}
+${indentation}}`;
+};
+var cypherDataToString = (map, stringStyle = "json", quoteStrings = true) => {
+  return recursiveStringify(map, { quoteStrings, stringStyle });
+};
+var cypherDataToCypherCSVString = (map, stringStyle) => {
+  return recursiveStringify(map, { quoteStrings: false, stringStyle });
+};
+
+// src/result-transformers/graph-result-transformer.ts
+var import_neo4j_driver6 = require("neo4j-driver");
+var graphResultTransformer = import_neo4j_driver6.resultTransformers.mapped({
+  map(record) {
+    return record;
+  },
+  collect(records, summary) {
+    const { nodes, relationships, limitHit } = extractUniqueNodesAndRels(records);
+    return { nodes, relationships, limitHit, records, summary };
+  }
+});
+
+// src/schemaPoller.ts
+var import_events = require("events");
+var import_neo4j_driver15 = __toESM(require("neo4j-driver"), 1);
+
+// src/metadataPoller.ts
+var import_language_support = require("@neo4j-cypher/language-support");
+
+// src/queries/databases.ts
+var import_neo4j_driver7 = require("neo4j-driver");
+
+// src/types/sdkTypes.ts
+var DbType = {
+  SYSTEM: "system",
+  STANDARD: "standard",
+  COMPOSITE: "composite",
+  GRAPH_SHARD: "graph shard",
+  PROPERTY_SHARD: "property shard"
+};
+
+// src/queries/databases.ts
+var findComposite = (databases, alias) => {
+  const compositeDatabases = databases.filter((db) => db.type === "composite");
+  return compositeDatabases.find((db) => db.constituents?.includes(alias));
+};
+var isCompositeAlias = (databases, alias) => findComposite(databases, alias) !== void 0;
+var removeCompositeAliases = (databases) => {
+  return databases.map(({ aliases, ...db }) => ({
+    ...db,
+    aliases: aliases?.filter((alias) => !isCompositeAlias(databases, alias))
+  }));
+};
+var removeSPDShards = (databases) => {
+  return databases.filter((db) => {
+    return !(db.type !== void 0 && (db.type === DbType.GRAPH_SHARD || db.type === DbType.PROPERTY_SHARD));
+  });
+};
+function listDatabases() {
+  const query = "SHOW DATABASES YIELD *";
+  const resultTransformer = import_neo4j_driver7.resultTransformers.mapped({
+    map(record) {
+      const obj = record.toObject();
+      if (obj.defaultLanguage) {
+        obj.defaultLanguage = obj.defaultLanguage.toUpperCase();
+      }
+      return obj;
+    },
+    collect(databases, summary) {
+      const instancesRecord = databases.reduce((acc, db) => {
+        const instanceId = `${db.name}@${db.address}`;
+        acc[instanceId] = db;
+        return acc;
+      }, {});
+      const logicalDatabases = getLogicalDatabases(instancesRecord);
+      const uiDatabases = removeSPDShards(
+        removeCompositeAliases(Object.values(logicalDatabases))
+      );
+      return {
+        databases: sortDatabases(uiDatabases),
+        summary
+      };
+    }
+  });
+  return {
+    query,
+    queryConfig: { resultTransformer, routing: "READ", database: "system" }
+  };
+}
+function getLogicalDatabases(instances) {
+  const mergeDatabases = (db1, db2) => {
+    let mergedDatabase = { ...db1 };
+    if (db2.role === "leader" || db2.writer === true) {
+      mergedDatabase = { ...db2 };
+    }
+    return mergedDatabase;
+  };
+  return Object.values(instances).reduce(
+    (databases, instance) => {
+      const key = instance.name;
+      const existingDatabase = databases[key];
+      const mergedDatabase = existingDatabase ? mergeDatabases(existingDatabase, instance) : instance;
+      return {
+        ...databases,
+        [key]: mergedDatabase
+      };
+    },
+    {}
+  );
+}
+function sortDatabases(databases) {
+  function databaseComparator(a, b) {
+    if (a.default && b.home) return 1;
+    if (a.default) return -1;
+    if (b.default) return 1;
+    if (a.name === "system") return 1;
+    if (b.name === "system") return -1;
+    return a.name.localeCompare(b.name);
+  }
+  return databases.sort(databaseComparator);
+}
+
+// src/queries/dataSummary.ts
+var import_neo4j_driver8 = require("neo4j-driver");
+var ITEM_LIMIT = 1e3;
+function getDataSummary(database) {
+  const query = `CALL db.labels() YIELD label
+RETURN COLLECT(label)[..${ITEM_LIMIT}] AS result
+UNION ALL
+CALL db.relationshipTypes() YIELD relationshipType
+RETURN COLLECT(relationshipType)[..${ITEM_LIMIT}] AS result
+UNION ALL
+CALL db.propertyKeys() YIELD propertyKey
+RETURN COLLECT(propertyKey)[..${ITEM_LIMIT}] AS result`;
+  const resultTransformer = import_neo4j_driver8.resultTransformers.mapped({
+    map(record) {
+      return record.toObject().result;
+    },
+    collect(results, summary) {
+      return {
+        labels: results[0],
+        relationshipTypes: results[1],
+        propertyKeys: results[2],
+        summary
+      };
+    }
+  });
+  return {
+    query,
+    queryConfig: { resultTransformer, routing: "READ", database }
+  };
+}
+
+// src/queries/functions.ts
+var import_ajv = require("ajv");
+var import_neo4j_driver9 = require("neo4j-driver");
+
+// src/data-transforms/clean-type.ts
+function cleanType(type) {
+  let resultType = type;
+  if (resultType.startsWith("LIST? OF ")) {
+    resultType = resultType.replace("LIST? OF ", "LIST<");
+    resultType += ">";
+  }
+  return resultType.replace(/\?/g, "");
+}
+function cleanTypeDescription(arg) {
+  return { ...arg, type: cleanType(arg.type) };
+}
+
+// src/queries/functions.ts
+function cleanTypes(result) {
+  return {
+    ...result,
+    argumentDescription: result.argumentDescription.map(cleanTypeDescription),
+    returnDescription: cleanType(result.returnDescription)
+  };
+}
+var functionSchema = {
+  type: "object",
+  properties: {
+    aggregating: { type: "boolean" },
+    argumentDescription: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          type: { type: "string" },
+          default: { type: "string", nullable: true },
+          isDeprecated: { type: "boolean", default: false }
+        },
+        required: ["name", "description", "type", "isDeprecated"]
+      }
+    },
+    category: { type: "string" },
+    description: { type: "string" },
+    isBuiltIn: { type: "boolean" },
+    name: { type: "string" },
+    returnDescription: { type: "string" },
+    signature: { type: "string" },
+    isDeprecated: { type: "boolean", default: false },
+    deprecatedBy: { type: "string", nullable: true }
+  },
+  required: [
+    "aggregating",
+    "argumentDescription",
+    "category",
+    "description",
+    "isBuiltIn",
+    "isDeprecated",
+    "name",
+    "returnDescription",
+    "signature"
+  ],
+  additionalProperties: true
+};
+var validateFunction = new import_ajv.Ajv({ useDefaults: true }).compile(functionSchema);
+function listFunctions({ executableByMe, cypherVersion } = {
+  executableByMe: false,
+  cypherVersion: void 0
+}) {
+  const query = `${cypherVersion ? cypherVersion + " " : ""}
+    SHOW FUNCTIONS 
+    ${executableByMe ? "EXECUTABLE BY CURRENT USER" : ""}
+    YIELD *`;
+  const resultTransformer = import_neo4j_driver9.resultTransformers.mapped({
+    map(record) {
+      const objResult = record.toObject();
+      validateFunction(objResult);
+      const result = cleanTypes(objResult);
+      return result;
+    },
+    collect(functions, summary) {
+      return { functions, summary };
+    }
+  });
+  return {
+    query,
+    queryConfig: { resultTransformer, routing: "READ", database: "system" }
+  };
+}
+
+// src/queries/procedures.ts
+var import_ajv2 = require("ajv");
+var import_neo4j_driver10 = require("neo4j-driver");
+var procedureSchema = {
+  type: "object",
+  properties: {
+    admin: { type: "boolean" },
+    argumentDescription: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          type: { type: "string" },
+          default: { type: "string", nullable: true },
+          isDeprecated: { type: "boolean", default: false }
+        },
+        required: ["name", "description", "type", "isDeprecated"]
+      }
+    },
+    description: { type: "string" },
+    mode: { type: "string" },
+    name: { type: "string" },
+    option: { type: "object" },
+    returnDescription: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          description: { type: "string" },
+          type: { type: "string" },
+          isDeprecated: { type: "boolean", default: false }
+        },
+        required: ["name", "description", "type", "isDeprecated"]
+      }
+    },
+    signature: { type: "string" },
+    worksOnSystem: { type: "boolean" },
+    deprecatedBy: { type: "string", nullable: true }
+  },
+  required: [
+    "admin",
+    "argumentDescription",
+    "description",
+    "mode",
+    "name",
+    "option",
+    "returnDescription",
+    "signature",
+    "worksOnSystem"
+  ],
+  additionalProperties: true
+};
+var validateProcedure = new import_ajv2.Ajv({ useDefaults: true }).compile(
+  procedureSchema
+);
+function cleanTypes2(result) {
+  return {
+    ...result,
+    argumentDescription: result.argumentDescription.map(cleanTypeDescription),
+    returnDescription: result.returnDescription.map(cleanTypeDescription)
+  };
+}
+function listProcedures({ executableByMe, cypherVersion } = {
+  executableByMe: false,
+  cypherVersion: void 0
+}) {
+  const query = `${cypherVersion ? cypherVersion + " " : ""}
+    SHOW PROCEDURES 
+    ${executableByMe ? "EXECUTABLE BY CURRENT USER" : ""}
+    YIELD *`;
+  const resultTransformer = import_neo4j_driver10.resultTransformers.mapped({
+    map(record) {
+      const objResult = record.toObject();
+      validateProcedure(objResult);
+      const result = cleanTypes2(objResult);
+      return result;
+    },
+    collect(procedures, summary) {
+      return { procedures, summary };
+    }
+  });
+  return {
+    query,
+    queryConfig: {
+      routing: "READ",
+      database: "system",
+      resultTransformer
+    }
+  };
+}
+
+// src/queries/roles.ts
+var import_neo4j_driver11 = require("neo4j-driver");
+function listRoles() {
+  const query = `SHOW ROLES`;
+  const resultTransformer = import_neo4j_driver11.resultTransformers.mapped({
+    map(record) {
+      return record.toObject();
+    },
+    collect(roles, summary) {
+      return { roles, summary };
+    }
+  });
+  return {
+    query,
+    queryConfig: { resultTransformer, routing: "READ", database: "system" }
+  };
+}
+
+// src/queries/users.ts
+var import_neo4j_driver12 = require("neo4j-driver");
+function listUsers() {
+  const query = `SHOW USERS`;
+  const resultTransformer = import_neo4j_driver12.resultTransformers.mapped({
+    map(record) {
+      return record.toObject();
+    },
+    collect(users, summary) {
+      return { users, summary };
+    }
+  });
+  return {
+    query,
+    queryConfig: { resultTransformer, routing: "READ", database: "system" }
+  };
+}
+
+// src/queries/graphSchema.ts
+var import_neo4j_driver13 = require("neo4j-driver");
+var import_ajv3 = require("ajv");
+var graphSchemaSchema = {
+  type: "object",
+  properties: {
+    nodes: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          labels: {
+            type: "array",
+            items: { type: "string" }
+          },
+          elementId: { type: "string" }
+        },
+        required: ["labels", "elementId"],
+        additionalProperties: true
+      }
+    },
+    relationships: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          type: { type: "string" },
+          endNodeElementId: { type: "string" },
+          startNodeElementId: { type: "string" }
+        },
+        required: ["type", "endNodeElementId", "startNodeElementId"],
+        additionalProperties: true
+      }
+    }
+  },
+  required: ["nodes", "relationships"],
+  additionalProperties: true
+};
+var validateGraphSchema = new import_ajv3.Ajv({ useDefaults: true }).compile(
+  graphSchemaSchema
+);
+function listGraphSchema(database) {
+  const query = `CALL db.schema.visualization() YIELD *`;
+  const resultTransformer = import_neo4j_driver13.resultTransformers.mapped({
+    map(record) {
+      const objResult = record.toObject();
+      validateGraphSchema(objResult);
+      return objResult;
+    },
+    collect(records, summary) {
+      return {
+        summary,
+        graphSchema: extractRelationshipsWithNamedNodes(records)
+      };
+    }
+  });
+  return {
+    query,
+    queryConfig: { resultTransformer, routing: "READ", database }
+  };
+}
+function extractRelationshipsWithNamedNodes(graphSchemas) {
+  const items = [];
+  if (graphSchemas.length !== 1) {
+    return items;
+  }
+  const graphSchema = graphSchemas[0];
+  const nodes = {};
+  for (const node of graphSchema.nodes) {
+    nodes[node.elementId] = node.labels[0];
+  }
+  for (const rel of graphSchema.relationships) {
+    const from = nodes[rel.startNodeElementId];
+    const to = nodes[rel.endNodeElementId];
+    const relType = rel.type;
+    items.push({ from, to, relType });
+  }
+  return items;
+}
+
+// src/metadataPoller.ts
+var QueryPoller = class {
+  status = "not-started";
+  data;
+  lastFetchStart;
+  errorMessage;
+  connection;
+  onRefetchDone;
+  queryArgs;
+  constructor({
+    prefetchedData,
+    queryArgs,
+    connection,
+    onRefetchDone
+  }) {
+    this.connection = connection;
+    this.queryArgs = queryArgs;
+    this.onRefetchDone = onRefetchDone;
+    if (prefetchedData) {
+      this.data = prefetchedData;
+      this.lastFetchStart = Date.now();
+      this.status = "fetched";
+    }
+  }
+  async refetch() {
+    if (this.status === "fetching") return;
+    this.status = "fetching";
+    this.lastFetchStart = Date.now();
+    delete this.errorMessage;
+    try {
+      const data = await this.connection.runSdkQuery(this.queryArgs, {
+        queryType: "system"
+      });
+      this.data = data;
+      this.status = "fetched";
+      this.onRefetchDone?.({ success: true, data });
+    } catch (e) {
+      const errorMessage = String(e);
+      this.errorMessage = errorMessage;
+      this.status = "error";
+      console.error(e);
+      this.onRefetchDone?.({ success: false, errorMessage });
+    }
+  }
+};
+var MetadataPoller = class {
+  dbSchema = {};
+};
+var DisconnectedMetadataPoller = class extends MetadataPoller {
+  dbSchema = {};
+  constructor(parameters) {
+    super();
+    this.dbSchema.parameters = parameters;
+  }
+  stopBackgroundPolling() {
+  }
+  startBackgroundPolling() {
+  }
+  fetchDbSchema() {
+  }
+};
+var ConnectedMetadataPoller = class extends MetadataPoller {
+  constructor(databases, parameters, serverCypherVersions, connection, events) {
+    super();
+    this.connection = connection;
+    this.events = events;
+    this.dbSchema.parameters = parameters;
+    this.databases = new QueryPoller({
+      connection,
+      queryArgs: listDatabases(),
+      prefetchedData: { databases },
+      onRefetchDone: (result) => {
+        if (result.success) {
+          this.dbSchema.databaseNames = result.data.databases.flatMap(
+            (db) => db.name
+          );
+          this.dbSchema.aliasNames = result.data.databases.flatMap(
+            (db) => db.aliases ?? []
+          );
+          const dbs = result.data.databases;
+          const currentDb = dbs.find(
+            (db) => db.name === this.connection.currentDb
+          );
+          if (currentDb) {
+            this.dbSchema.defaultLanguage = currentDb.defaultLanguage;
+          }
+        }
+      }
+    });
+    this.users = new QueryPoller({
+      connection,
+      queryArgs: listUsers(),
+      onRefetchDone: (result) => {
+        if (result.success) {
+          this.dbSchema.userNames = result.data.users.map((user) => user.user);
+        }
+      }
+    });
+    this.roles = new QueryPoller({
+      connection,
+      queryArgs: listRoles(),
+      onRefetchDone: (result) => {
+        if (result.success) {
+          this.dbSchema.roleNames = result.data.roles.map((role) => role.role);
+        }
+      }
+    });
+    this.graphSchema = new QueryPoller({
+      connection,
+      queryArgs: listGraphSchema(connection.currentDb),
+      onRefetchDone: (result) => {
+        if (result.success) {
+          const { graphSchema } = result.data;
+          this.dbSchema.graphSchema = graphSchema;
+        }
+      }
+    });
+    this.dataSummary = new QueryPoller({
+      connection,
+      queryArgs: getDataSummary(connection.currentDb),
+      onRefetchDone: (result) => {
+        if (result.success) {
+          const { labels, propertyKeys, relationshipTypes } = result.data;
+          this.dbSchema.labels = labels;
+          this.dbSchema.propertyKeys = propertyKeys;
+          this.dbSchema.relationshipTypes = relationshipTypes;
+        }
+      }
+    });
+    const versions = serverCypherVersions?.includes("25") ? import_language_support.allCypherVersions : [void 0];
+    versions.forEach((cypherVersion) => {
+      const effectiveCypherVersion = cypherVersion ?? "CYPHER 5";
+      this.procedures[effectiveCypherVersion] = new QueryPoller({
+        connection,
+        queryArgs: listProcedures({
+          executableByMe: true,
+          cypherVersion
+        }),
+        onRefetchDone: (result) => {
+          if (result.success) {
+            const procedures = result.data.procedures.reduce((acc, curr) => {
+              const { name } = curr;
+              acc[name] = curr;
+              return acc;
+            }, {});
+            if (!this.dbSchema.procedures) {
+              this.dbSchema.procedures = {};
+            }
+            this.dbSchema.procedures[effectiveCypherVersion] = procedures;
+          }
+        }
+      });
+      this.functions[effectiveCypherVersion] = new QueryPoller({
+        connection,
+        queryArgs: listFunctions({
+          executableByMe: true,
+          cypherVersion
+        }),
+        onRefetchDone: (result) => {
+          if (result.success) {
+            const functions = result.data.functions.reduce((acc, curr) => {
+              const { name } = curr;
+              acc[name] = curr;
+              return acc;
+            }, {});
+            if (!this.dbSchema.functions) {
+              this.dbSchema.functions = {};
+            }
+            this.dbSchema.functions[effectiveCypherVersion] = functions;
+          }
+        }
+      });
+    });
+  }
+  databases;
+  dataSummary;
+  functions = {};
+  procedures = {};
+  users;
+  roles;
+  graphSchema;
+  dbPollingInterval;
+  dbSchema = {};
+  async fetchDbSchema() {
+    await Promise.allSettled([
+      this.databases.refetch(),
+      this.dataSummary.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 = void 0;
+    }
+    this.events.emit("schemaFetched");
+  }
+  stopBackgroundPolling() {
+    clearInterval(this.dbPollingInterval);
+    this.dbPollingInterval = void 0;
+  }
+  startBackgroundPolling(intervalSeconds = 30) {
+    this.stopBackgroundPolling();
+    void this.fetchDbSchema();
+    this.dbPollingInterval = setInterval(
+      () => void this.fetchDbSchema(),
+      intervalSeconds * 1e3
+    );
+  }
+};
+
+// package.json
+var package_default = {
+  name: "@neo4j-cypher/query-tools",
+  version: "2.0.0-next.38",
+  description: "",
+  bugs: {
+    url: "https://github.com/neo4j/cypher-language-support/issues"
+  },
+  license: "Apache-2.0",
+  author: "Neo4j Inc.",
+  repository: {
+    type: "git",
+    url: "git://github.com/neo4j/cypher-language-support.git"
+  },
+  type: "module",
+  main: "./dist/cjs/index.cjs",
+  module: "./dist/esm/src/index.js",
+  types: "./dist/types/src/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/types/src/index.d.ts",
+      require: "./dist/cjs/index.cjs",
+      import: "./dist/esm/src/index.js",
+      default: "./dist/cjs/index.cjs"
+    }
+  },
+  scripts: {
+    build: "concurrently 'npm:build-esm' 'npm:build-commonjs' 'npm:build-types'",
+    "build-esm": "tsc --outDir dist/esm",
+    "build-commonjs": "esbuild ./src/index.ts --bundle --format=cjs --sourcemap --packages=external --outfile=dist/cjs/index.cjs",
+    "build-types": "tsc --emitDeclarationOnly --outDir dist/types",
+    dev: "concurrently 'npm:build-esm -- --watch' 'npm:build-commonjs -- --watch'",
+    clean: "rm -rf dist tsconfig*.tsbuildinfo",
+    test: "vitest run extract-unique-nodes-and-relationships",
+    "test:polling": "vitest run pollingIntegrationTests"
+  },
+  dependencies: {
+    "@neo4j-cypher/language-support": "workspace:*",
+    ajv: "^8.12.0",
+    "neo4j-driver": "catalog:"
+  },
+  devDependencies: {
+    "@testcontainers/neo4j": "^11.5.1"
+  },
+  engines: {
+    node: ">=24.11.1"
+  }
+};
+
+// src/neo4jConnection.ts
+var METADATA_BASE = {
+  app: "neo4j-sdk",
+  version: package_default.version
+};
+var RECORD_LIMIT = 5e3;
+function resolveInitialDatabase(databases, database) {
+  if (database) {
+    return databases.find(
+      (d) => d.name === database || d?.aliases?.includes(database)
+    )?.name;
+  }
+  const home = databases.find((d) => d.home);
+  const def = databases.find((d) => d.default);
+  const system = databases.find((d) => d.name === "system");
+  return home?.name ?? def?.name ?? system?.name ?? databases[0]?.name;
+}
+var Neo4jConnection = class {
+  constructor(connectedUser, protocolVersion, databases, driver, database) {
+    this.connectedUser = connectedUser;
+    this.protocolVersion = protocolVersion;
+    this.databases = databases;
+    this.driver = driver;
+    this.currentDb = resolveInitialDatabase(databases, database);
+    this.serverVersion = void 0;
+  }
+  currentDb;
+  serverVersion;
+  async evalQuery(session, query, parameters, metadata, tx) {
+    let result;
+    if (!tx) {
+      result = session.run(query, parameters, {
+        metadata
+      });
+    } else {
+      result = tx.run(query, parameters);
+    }
+    const records = [];
+    let recordLimitHit = false;
+    for await (const record of result) {
+      if (records.length < RECORD_LIMIT) {
+        records.push(record);
+      } else {
+        recordLimitHit = true;
+        break;
+      }
+    }
+    const summary = await result.summary();
+    return { records, summary, recordLimitHit };
+  }
+  async runCypherQuery({
+    query,
+    parameters,
+    database,
+    abortSignal,
+    implicitTransaction = false
+  }) {
+    const session = this.driver.session({
+      database: database ?? this.currentDb
+    });
+    if (abortSignal !== void 0) {
+      abortSignal.addEventListener("abort", () => {
+        void session.close();
+      });
+    }
+    const metadata = {
+      ...METADATA_BASE,
+      type: "user-direct"
+    };
+    try {
+      let result;
+      if (implicitTransaction) {
+        result = this.evalQuery(session, query, parameters, metadata);
+      } else {
+        result = session.executeWrite(
+          async (tx) => {
+            const result2 = this.evalQuery(
+              session,
+              query,
+              parameters,
+              metadata,
+              tx
+            );
+            return result2;
+          },
+          {
+            metadata
+          }
+        );
+      }
+      return await result;
+    } finally {
+      await session.close();
+    }
+  }
+  async runSdkQuery({ query, queryConfig }, { queryType, abortSignal }) {
+    const session = this.driver.session({
+      database: queryConfig?.database ?? this.currentDb
+    });
+    if (abortSignal !== void 0) {
+      abortSignal.addEventListener("abort", () => {
+        void session.close();
+      });
+    }
+    try {
+      const executeInTransaction = queryConfig.routing === "READ" ? session.executeRead.bind(session) : session.executeWrite.bind(session);
+      return await executeInTransaction(
+        async (tx) => {
+          const result = tx.run(query, {});
+          return await queryConfig.resultTransformer(result);
+        },
+        { timeout: 500, metadata: { ...METADATA_BASE, type: queryType } }
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async healthcheck() {
+    try {
+      await this.driver.verifyConnectivity({ database: this.currentDb });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  dispose() {
+    void this.driver?.close();
+  }
+};
+
+// src/queries/version.ts
+var import_neo4j_driver14 = require("neo4j-driver");
+function getVersion() {
+  const query = "CALL dbms.components() YIELD name, versions";
+  const resultTransformer = import_neo4j_driver14.resultTransformers.mapped({
+    map(record) {
+      const obj = record.toObject();
+      const name = obj.name;
+      const versions = obj.versions;
+      return { name, versions };
+    },
+    collect(rows, summary) {
+      for (const row of rows) {
+        if (row.name === "Neo4j Kernel") {
+          return { serverVersion: row.versions[0], summary };
+        }
+      }
+      return { serverVersion: void 0, summary };
+    }
+  });
+  return {
+    query,
+    queryConfig: { resultTransformer, routing: "READ", database: "system" }
+  };
+}
+
+// src/schemaPoller.ts
+var MAX_RETRY_ATTEMPTS = 5;
+var RETRY_INTERVAL_MS = 3e4;
+var Neo4jSchemaPoller = class {
+  connection;
+  metadata;
+  events = new import_events.EventEmitter();
+  driver;
+  reconnectionTimeout;
+  retries = MAX_RETRY_ATTEMPTS;
+  lastError;
+  parameters = {};
+  setParameters(parameters) {
+    this.parameters = parameters;
+    if (this.metadata) {
+      this.metadata.dbSchema.parameters = parameters;
+    } else {
+      this.metadata = new DisconnectedMetadataPoller(parameters);
+    }
+  }
+  async connect(url, credentials, config, database) {
+    try {
+      this.driver = await this.initializeDriver(
+        url,
+        credentials,
+        config,
+        database
+      );
+    } catch (error) {
+      console.error("Error connecting to Neo4j.", error);
+      return {
+        success: false,
+        retriable: isRetriableNeo4jError(error),
+        error: getConnectionError(error)
+      };
+    }
+    return { success: true };
+  }
+  async persistentConnect(url, credentials, config, database) {
+    const shouldHaveConnection = this.connection !== void 0;
+    const connectionAlive = await this.connection?.healthcheck();
+    const shouldUpdateConnection = this.connection && database && this.connection?.currentDb !== database;
+    if (!connectionAlive || shouldUpdateConnection) {
+      if (shouldHaveConnection && !shouldUpdateConnection) {
+        console.error("Connection to Neo4j dropped");
+        this.disconnect();
+      } else if (shouldUpdateConnection) {
+        this.disconnect();
+      }
+      try {
+        await this.connectAndStartMetadataPoller(
+          url,
+          credentials,
+          config,
+          database
+        );
+        this.reconnectionTimeout = this.setReconnectionTimeout(
+          url,
+          credentials,
+          config,
+          database
+        );
+        return this.handleSuccessfulConnection();
+      } catch (error) {
+        console.error("Error connecting to Neo4j.", error);
+        this.retries -= 1;
+        this.lastError = getConnectionError(error);
+        if (!isRetriableNeo4jError(error)) {
+          return this.handlePermanentlyFailingConnection();
+        }
+        if (this.retries > 0) {
+          this.reconnectionTimeout = this.setReconnectionTimeout(
+            url,
+            credentials,
+            config,
+            database
+          );
+          return this.handleNonSuccessfulConnection();
+        }
+        return this.handlePermanentlyFailingConnection();
+      }
+    }
+    this.reconnectionTimeout = this.setReconnectionTimeout(
+      url,
+      credentials,
+      config,
+      database
+    );
+    return { success: true };
+  }
+  disconnect() {
+    if (this.connection) {
+      console.log("Disconnected from Neo4j");
+    }
+    this.connection?.dispose();
+    this.metadata?.stopBackgroundPolling();
+    this.connection = void 0;
+    const parameters = this.metadata?.dbSchema?.parameters ?? {};
+    this.metadata = new DisconnectedMetadataPoller(parameters);
+    this.driver = void 0;
+    clearTimeout(this.reconnectionTimeout);
+  }
+  async getAvailableCypherVersions() {
+    const { query: cypherVersionQuery, queryConfig: cypherVersionQueryConfig } = getVersion();
+    try {
+      if (this.driver) {
+        await this.driver.executeQuery(
+          "CYPHER 25 " + cypherVersionQuery,
+          {},
+          cypherVersionQueryConfig
+        );
+        return ["5", "25"];
+      }
+    } catch {
+      return ["5"];
+    }
+    return ["5"];
+  }
+  async connectAndStartMetadataPoller(url, credentials, config, database) {
+    this.driver = this.driver ?? await this.initializeDriver(url, credentials, config, database);
+    const { query: dbQuery, queryConfig: dbQueryConfig } = listDatabases();
+    const { databases, summary } = await this.driver.executeQuery(
+      dbQuery,
+      {},
+      dbQueryConfig
+    );
+    const protocolVersion = summary.server.protocolVersion?.toString() ?? "unknown";
+    this.connection = new Neo4jConnection(
+      credentials.username,
+      protocolVersion,
+      databases,
+      this.driver,
+      database
+    );
+    const serverCypherVersions = await this.getAvailableCypherVersions();
+    const { query: serverVersionQuery, queryConfig: serverVersionQueryConfig } = getVersion();
+    let { serverVersion } = await this.driver.executeQuery(
+      serverVersionQuery,
+      {},
+      serverVersionQueryConfig
+    );
+    if (serverVersion?.startsWith("5.27.0")) {
+      const agent = summary.server.agent;
+      if (agent) {
+        const matchedVersion = agent.match(/\d+\.\d+\.\d+/);
+        if (matchedVersion) {
+          serverVersion = matchedVersion[0];
+        }
+      }
+    }
+    this.connection.serverVersion = serverVersion;
+    this.metadata = new ConnectedMetadataPoller(
+      databases,
+      this.parameters,
+      serverCypherVersions,
+      this.connection,
+      this.events
+    );
+    this.metadata.startBackgroundPolling();
+  }
+  async initializeDriver(url, credentials, config, database) {
+    const driver = import_neo4j_driver15.default.driver(
+      url,
+      import_neo4j_driver15.default.auth.basic(credentials.username, credentials.password),
+      {
+        userAgent: config.appName,
+        ...config.driverConfig
+      }
+    );
+    await driver.verifyConnectivity({ database });
+    if (await driver.supportsSessionAuth()) {
+      if (!await driver.verifyAuthentication()) {
+        throw new Error("Invalid credentials");
+      }
+    }
+    return driver;
+  }
+  setReconnectionTimeout(url, credentials, config, database) {
+    return setTimeout(() => {
+      void this.persistentConnect(url, credentials, config, database);
+    }, RETRY_INTERVAL_MS);
+  }
+  handleSuccessfulConnection() {
+    this.resetRetries();
+    console.log("Established connection to Neo4j");
+    this.events.emit("connectionConnected");
+    return { success: true };
+  }
+  handleNonSuccessfulConnection() {
+    const connectionError = this.formatConnectionErrorFriendlyMessage(
+      this.lastError,
+      true
+    );
+    this.events.emit("connectionErrored", connectionError);
+    return {
+      success: false,
+      retriable: true,
+      error: connectionError
+    };
+  }
+  handlePermanentlyFailingConnection() {
+    this.resetRetries();
+    const connectionError = this.formatConnectionErrorFriendlyMessage(
+      this.lastError,
+      false
+    );
+    this.events.emit("connectionFailed", connectionError);
+    return {
+      success: false,
+      retriable: false,
+      error: connectionError
+    };
+  }
+  formatConnectionErrorFriendlyMessage(connectionError = {
+    message: "",
+    friendlyMessage: FRIENDLY_ERROR_MESSAGES.Default,
+    code: ""
+  }, retriable) {
+    const friendlyMessage = retriable ? `${connectionError.friendlyMessage}. Retrying in ${RETRY_INTERVAL_MS / 1e3} seconds` : connectionError.friendlyMessage;
+    return {
+      ...connectionError,
+      friendlyMessage
+    };
+  }
+  resetRetries() {
+    this.retries = MAX_RETRY_ATTEMPTS;
+  }
+};
+//# sourceMappingURL=index.cjs.map