TS declarations support for 'disableLosslessIntegers=true'

Previously TS declaration files only allowed returned integer types to
be `neo4j.Integer`. This was not compatible with newly introduced
`disableLosslessIntegers` config, which makes driver always return
native JS numbers.

This commit allows all integer properties to either be `neo4j.Integer`
or `number`. `Integer` is default. Existing TS users will not need to
change their code. TS users who set 'disableLosslessIntegers=true'
will have to specify generic type explicitly like `Node<number>`.
Property `identity` of such node will have type `number`.

Author: lutovich

test/types/v1/graph-types.test.ts

@@ -26,6 +26,9 @@ const node1Id: Integer = node1.identity;
 const node1Labels: string[] = node1.labels;
 const node1Props: object = node1.properties;
 
+const node2: Node<number> = new Node(2, ["Person", "Employee"], {name: "Alice"});
+const node2Id: number = node2.identity;
+
 const rel1: Relationship = new Relationship(int(1), int(2), int(3), "KNOWS", {since: 12345});
 const rel1String: string = rel1.toString();
 const rel1Id: Integer = rel1.identity;
@@ -41,13 +44,35 @@ const rel2Id: Integer = rel2.identity;
 const rel2Type: string = rel2.type;
 const rel2Props: object = rel2.properties;
 
+const rel4: Relationship<number> = new Relationship(2, 3, 4, "KNOWS", {since: 12345});
+const rel4Id: number = rel4.identity;
+const rel4Start: number = rel4.start;
+const rel4End: number = rel4.end;
+
+const rel5: UnboundRelationship<number> = new UnboundRelationship(5, "KNOWS", {since: 12345});
+const rel5Id: number = rel5.identity;
+const rel6 = rel5.bind(24, 42);
+const rel6Id: number = rel6.identity;
+const rel6Start: number = rel6.start;
+const rel6End: number = rel6.end;
+
 const pathSegment1: PathSegment = new PathSegment(node1, rel1, node1);
 const pathSegment1Start: Node = pathSegment1.start;
 const pathSegment1Rel: Relationship = pathSegment1.relationship;
 const pathSegment1End: Node = pathSegment1.end;
 
+const pathSegment2: PathSegment<number> = new PathSegment(node2, rel4, node2);
+const pathSegment2Start: Node<number> = pathSegment2.start;
+const pathSegment2Rel: Relationship<number> = pathSegment2.relationship;
+const pathSegment2End: Node<number> = pathSegment2.end;
+
 const path1: Path = new Path(node1, node1, [pathSegment1]);
 const path1Start: Node = path1.start;
 const path1End: Node = path1.end;
 const path1Segments: PathSegment[] = path1.segments;
 const path1Length: number = path1.length;
+
+const path2: Path<number> = new Path(node2, node2, [pathSegment2]);
+const path2Start: Node<number> = path2.start;
+const path2End: Node<number> = path2.end;
+const path2Segments: PathSegment<number>[] = path2.segments;

test/types/v1/result-summary.test.ts

@@ -17,27 +17,20 @@
  * limitations under the License.
  */
 
-import ResultSummary, {
-  Notification,
-  NotificationPosition,
-  Plan,
-  ProfiledPlan,
-  ServerInfo,
-  StatementStatistic
-} from "../../../types/v1/result-summary";
+import ResultSummary, {Notification, NotificationPosition, Plan, ProfiledPlan, ServerInfo, StatementStatistic} from "../../../types/v1/result-summary";
 import Integer from "../../../types/v1/integer";
 
 const dummy: any = null;
 
-const sum: ResultSummary = dummy;
+const sum1: ResultSummary = dummy;
 
-const stmt = sum.statement;
+const stmt = sum1.statement;
 const stmtText: string = stmt.text;
 const stmtParams: object = stmt.parameters;
 
-const str: string = sum.statementType;
+const str: string = sum1.statementType;
 
-const counters: StatementStatistic = sum.counters;
+const counters: StatementStatistic = sum1.counters;
 
 const containsUpdates: boolean = counters.containsUpdates();
 const nodesCreated: number = counters.nodesCreated();
@@ -52,21 +45,21 @@ const indexesRemoved: number = counters.indexesRemoved();
 const constraintsAdded: number = counters.constraintsAdded();
 const constraintsRemoved: number = counters.constraintsRemoved();
 
-const plan: Plan = sum.plan;
+const plan: Plan = sum1.plan;
 const planOperatorType: string = plan.operatorType;
 const planIdentifiers: string[] = plan.identifiers;
 const planArguments: { [key: string]: string } = plan.arguments;
 const planChildren: Plan[] = plan.children;
 
-const profile: ProfiledPlan = sum.profile;
+const profile: ProfiledPlan = sum1.profile;
 const profileOperatorType: string = profile.operatorType;
 const profileIdentifiers: string[] = profile.identifiers;
 const profileArguments: { [key: string]: string } = profile.arguments;
 const profileDbHits: number = profile.dbHits;
 const profileRows: number = profile.rows;
 const profileChildren: ProfiledPlan[] = profile.children;
 
-const notifications: Notification[] = sum.notifications;
+const notifications: Notification[] = sum1.notifications;
 const notification: Notification = notifications[0];
 const code: string = notification.code;
 const title: string = notification.title;
@@ -78,12 +71,20 @@ const offset: number = position2.offset;
 const line: number = position2.line;
 const column: number = position2.column;
 
-const server: ServerInfo = sum.server;
+const server: ServerInfo = sum1.server;
 const address: string = server.address;
 const version: string = server.version;
 
-const resultConsumedAfter: Integer = sum.resultConsumedAfter;
-const resultAvailableAfter: Integer = sum.resultAvailableAfter;
+const resultConsumedAfter1: Integer = sum1.resultConsumedAfter;
+const resultAvailableAfter1: Integer = sum1.resultAvailableAfter;
 
-const hasPlan: boolean = sum.hasPlan();
-const hasProfile: boolean = sum.hasProfile();
+const hasPlan: boolean = sum1.hasPlan();
+const hasProfile: boolean = sum1.hasProfile();
+
+const sum2: ResultSummary<number> = dummy;
+const resultConsumedAfter2: number = sum2.resultConsumedAfter;
+const resultAvailableAfter2: number = sum2.resultAvailableAfter;
+
+const sum3: ResultSummary<Integer> = dummy;
+const resultConsumedAfter3: Integer = sum3.resultConsumedAfter;
+const resultAvailableAfter3: Integer = sum3.resultAvailableAfter;

types/v1/graph-types.d.ts

@@ -19,67 +19,67 @@
 
 import Integer from "./integer";
 
-declare class Node {
-  identity: Integer;
+declare class Node<T extends (Integer | number) = Integer> {
+  identity: T;
   labels: string[];
   properties: object;
 
-  constructor(identity: Integer,
+  constructor(identity: T,
               labels: string[],
               properties: object)
 
   toString(): string;
 }
 
-declare class Relationship {
-  identity: Integer;
-  start: Integer;
-  end: Integer;
+declare class Relationship<T extends (Integer | number) = Integer> {
+  identity: T;
+  start: T;
+  end: T;
   type: string;
   properties: object;
 
-  constructor(identity: Integer,
-              start: Integer,
-              end: Integer,
+  constructor(identity: T,
+              start: T,
+              end: T,
               type: string,
               properties: object);
 
   toString(): string;
 }
 
-declare class UnboundRelationship {
-  identity: Integer;
+declare class UnboundRelationship<T extends (Integer | number) = Integer> {
+  identity: T;
   type: string;
   properties: object;
 
-  constructor(identity: Integer,
+  constructor(identity: T,
               type: string,
               properties: object);
 
-  bind(start: Integer, end: Integer): Relationship;
+  bind(start: T, end: T): Relationship<T>;
 
   toString(): string;
 }
 
-declare class PathSegment {
-  start: Node;
-  relationship: Relationship;
-  end: Node;
+declare class PathSegment<T extends (Integer | number) = Integer> {
+  start: Node<T>;
+  relationship: Relationship<T>;
+  end: Node<T>;
 
-  constructor(start: Node,
-              rel: Relationship,
-              end: Node);
+  constructor(start: Node<T>,
+              rel: Relationship<T>,
+              end: Node<T>);
 }
 
-declare class Path {
-  start: Node;
-  end: Node;
-  segments: PathSegment[];
+declare class Path<T extends (Integer | number) = Integer> {
+  start: Node<T>;
+  end: Node<T>;
+  segments: PathSegment<T>[];
   length: number;
 
-  constructor(start: Node,
-              end: Node,
-              segments: PathSegment[]);
+  constructor(start: Node<T>,
+              end: Node<T>,
+              segments: PathSegment<T>[]);
 }
 
 export {

types/v1/result-summary.d.ts

@@ -19,16 +19,16 @@
 
 import Integer from "./integer";
 
-declare interface ResultSummary {
+declare interface ResultSummary<T extends (Integer | number) = Integer> {
   statement: { text: string, parameters: { [key: string]: any } };
   statementType: string;
   counters: StatementStatistic;
   plan: Plan;
   profile: ProfiledPlan;
   notifications: Notification[];
   server: ServerInfo;
-  resultConsumedAfter: Integer;
-  resultAvailableAfter: Integer;
+  resultConsumedAfter: T;
+  resultAvailableAfter: T;
 
   hasPlan(): boolean;