Getters for nested fields in temporal types

So that it's, for example, possible to obtain year from `LocalDateTime`
which is modeled as a combination of `Date` and `LocalTime`.

Author: lutovich

src/v1/temporal-types.js

@@ -124,6 +124,22 @@ export class Time {
     Object.freeze(this);
   }
 
+  get hour() {
+    return this.localTime.hour;
+  }
+
+  get minute() {
+    return this.localTime.minute;
+  }
+
+  get second() {
+    return this.localTime.second;
+  }
+
+  get nanosecond() {
+    return this.localTime.nanosecond;
+  }
+
   toString() {
     return this.localTime.toString() + timeZoneOffsetToIsoString(this.offsetSeconds);
   }
@@ -192,6 +208,34 @@ export class LocalDateTime {
     Object.freeze(this);
   }
 
+  get year() {
+    return this.localDate.year;
+  }
+
+  get month() {
+    return this.localDate.month;
+  }
+
+  get day() {
+    return this.localDate.day;
+  }
+
+  get hour() {
+    return this.localTime.hour;
+  }
+
+  get minute() {
+    return this.localTime.minute;
+  }
+
+  get second() {
+    return this.localTime.second;
+  }
+
+  get nanosecond() {
+    return this.localTime.nanosecond;
+  }
+
   toString() {
     return `${this.localDate.toString()}T${this.localTime.toString()}`;
   }
@@ -225,6 +269,34 @@ export class DateTimeWithZoneOffset {
     Object.freeze(this);
   }
 
+  get year() {
+    return this.localDateTime.year;
+  }
+
+  get month() {
+    return this.localDateTime.month;
+  }
+
+  get day() {
+    return this.localDateTime.day;
+  }
+
+  get hour() {
+    return this.localDateTime.hour;
+  }
+
+  get minute() {
+    return this.localDateTime.minute;
+  }
+
+  get second() {
+    return this.localDateTime.second;
+  }
+
+  get nanosecond() {
+    return this.localDateTime.nanosecond;
+  }
+
   toString() {
     return this.localDateTime.toString() + timeZoneOffsetToIsoString(this.offsetSeconds);
   }
@@ -258,6 +330,34 @@ export class DateTimeWithZoneId {
     Object.freeze(this);
   }
 
+  get year() {
+    return this.localDateTime.year;
+  }
+
+  get month() {
+    return this.localDateTime.month;
+  }
+
+  get day() {
+    return this.localDateTime.day;
+  }
+
+  get hour() {
+    return this.localDateTime.hour;
+  }
+
+  get minute() {
+    return this.localDateTime.minute;
+  }
+
+  get second() {
+    return this.localDateTime.second;
+  }
+
+  get nanosecond() {
+    return this.localDateTime.nanosecond;
+  }
+
   toString() {
     return `${this.localDateTime.toString()}[${this.zoneId}]`;
   }

test/types/v1/temporal-types.test.ts

@@ -61,10 +61,18 @@ const localTime2Nanosecond1: number = localTime2.nanosecond;
 const time1: Time = new Time(localTime1, int(1));
 const localTime3: LocalTime = time1.localTime;
 const offset1: Integer = time1.offsetSeconds;
+const hour1: Integer = time1.hour;
+const minute1: Integer = time1.minute;
+const second1: Integer = time1.second;
+const nanosecond1: Integer = time1.nanosecond;
 
 const time2: Time<number> = new Time(localTime2, 1);
 const localTime4: LocalTime<number> = time2.localTime;
 const offset2: number = time2.offsetSeconds;
+const hour2: number = time2.hour;
+const minute2: number = time2.minute;
+const second2: number = time2.second;
+const nanosecond2: number = time2.nanosecond;
 
 const date1: Date = new Date(int(1), int(1), int(1));
 const date1Year1: Integer = date1.year;
@@ -79,18 +87,46 @@ const date2Day1: number = date2.day;
 const localDateTime1: LocalDateTime = new LocalDateTime(date1, localTime1);
 const date3: Date = localDateTime1.localDate;
 const localTime5: LocalTime = localDateTime1.localTime;
+const year1: Integer = localDateTime1.year;
+const month1: Integer = localDateTime1.month;
+const day1: Integer = localDateTime1.day;
+const hour3: Integer = localDateTime1.hour;
+const minute3: Integer = localDateTime1.minute;
+const second3: Integer = localDateTime1.second;
+const nanosecond3: Integer = localDateTime1.nanosecond;
 
 const localDateTime2: LocalDateTime<number> = new LocalDateTime(date2, localTime2);
 const date4: Date<number> = localDateTime2.localDate;
 const localTime6: LocalTime<number> = localDateTime2.localTime;
+const year2: number = localDateTime2.year;
+const month2: number = localDateTime2.month;
+const day2: number = localDateTime2.day;
+const hour4: number = localDateTime2.hour;
+const minute4: number = localDateTime2.minute;
+const second4: number = localDateTime2.second;
+const nanosecond4: number = localDateTime2.nanosecond;
 
 const dateTime1: DateTimeWithZoneOffset = new DateTimeWithZoneOffset(localDateTime1, int(1));
 const localDateTime3: LocalDateTime = dateTime1.localDateTime;
 const offset3: Integer = dateTime1.offsetSeconds;
+const year3: Integer = dateTime1.year;
+const month3: Integer = dateTime1.month;
+const day3: Integer = dateTime1.day;
+const hour5: Integer = dateTime1.hour;
+const minute5: Integer = dateTime1.minute;
+const second5: Integer = dateTime1.second;
+const nanosecond5: Integer = dateTime1.nanosecond;
 
 const dateTime2: DateTimeWithZoneOffset<number> = new DateTimeWithZoneOffset(localDateTime2, 1);
 const localDateTime4: LocalDateTime<number> = dateTime2.localDateTime;
 const offset4: number = dateTime2.offsetSeconds;
+const year4: number = dateTime2.year;
+const month4: number = dateTime2.month;
+const day4: number = dateTime2.day;
+const hour6: number = dateTime2.hour;
+const minute6: number = dateTime2.minute;
+const second6: number = dateTime2.second;
+const nanosecond6: number = dateTime2.nanosecond;
 
 const isDurationValue: boolean = isDuration(duration1);
 const isLocalTimeValue: boolean = isLocalTime(localTime1);

test/v1/temporal-types.test.js

@@ -376,6 +376,54 @@ describe('temporal-types', () => {
     expect(dateTimeWithZoneId(248, 12, 30, 23, 59, 59, 3, 'CET').toString()).toEqual('0248-12-30T23:59:59.000000003[CET]');
   });
 
+  it('should expose local time components in time', () => {
+    const offsetTime = time(22, 12, 58, 999111222, 42);
+
+    expect(offsetTime.hour).toEqual(neo4j.int(22));
+    expect(offsetTime.minute).toEqual(neo4j.int(12));
+    expect(offsetTime.second).toEqual(neo4j.int(58));
+    expect(offsetTime.nanosecond).toEqual(neo4j.int(999111222));
+  });
+
+  it('should expose local date and time components in local date-time', () => {
+    const dateTime = localDateTime(2025, 9, 18, 23, 22, 21, 2020);
+
+    expect(dateTime.year).toEqual(neo4j.int(2025));
+    expect(dateTime.month).toEqual(neo4j.int(9));
+    expect(dateTime.day).toEqual(neo4j.int(18));
+
+    expect(dateTime.hour).toEqual(neo4j.int(23));
+    expect(dateTime.minute).toEqual(neo4j.int(22));
+    expect(dateTime.second).toEqual(neo4j.int(21));
+    expect(dateTime.nanosecond).toEqual(neo4j.int(2020));
+  });
+
+  it('should expose local date-time components in date-time with zone offset', () => {
+    const zonedDateTime = dateTimeWithZoneOffset(1799, 5, 19, 18, 37, 59, 875387, 3600);
+
+    expect(zonedDateTime.year).toEqual(neo4j.int(1799));
+    expect(zonedDateTime.month).toEqual(neo4j.int(5));
+    expect(zonedDateTime.day).toEqual(neo4j.int(19));
+
+    expect(zonedDateTime.hour).toEqual(neo4j.int(18));
+    expect(zonedDateTime.minute).toEqual(neo4j.int(37));
+    expect(zonedDateTime.second).toEqual(neo4j.int(59));
+    expect(zonedDateTime.nanosecond).toEqual(neo4j.int(875387));
+  });
+
+  it('should expose local date-time components in date-time with zone ID', () => {
+    const zonedDateTime = dateTimeWithZoneId(2356, 7, 29, 23, 32, 11, 9346458, 3600, randomZoneId());
+
+    expect(zonedDateTime.year).toEqual(neo4j.int(2356));
+    expect(zonedDateTime.month).toEqual(neo4j.int(7));
+    expect(zonedDateTime.day).toEqual(neo4j.int(29));
+
+    expect(zonedDateTime.hour).toEqual(neo4j.int(23));
+    expect(zonedDateTime.minute).toEqual(neo4j.int(32));
+    expect(zonedDateTime.second).toEqual(neo4j.int(11));
+    expect(zonedDateTime.nanosecond).toEqual(neo4j.int(9346458));
+  });
+
   function testSendAndReceiveRandomTemporalValues(valueGenerator, done) {
     const asyncFunction = (index, callback) => {
       const next = () => callback();

types/v1/temporal-types.d.ts

@@ -42,6 +42,10 @@ declare class Time<T extends NumberOrInteger = Integer> {
 
   localTime: LocalTime<T>;
   offsetSeconds: T;
+  hour: T;
+  minute: T;
+  second: T;
+  nanosecond: T;
 
   constructor(localTime: LocalTime<T>, offsetSeconds: T);
 }
@@ -59,6 +63,13 @@ declare class LocalDateTime<T extends NumberOrInteger = Integer> {
 
   localDate: Date<T>;
   localTime: LocalTime<T>;
+  year: T;
+  month: T;
+  day: T;
+  hour: T;
+  minute: T;
+  second: T;
+  nanosecond: T;
 
   constructor(localDate: Date<T>, localTime: LocalTime<T>);
 }
@@ -67,6 +78,13 @@ declare class DateTimeWithZoneOffset<T extends NumberOrInteger = Integer> {
 
   localDateTime: LocalDateTime<T>;
   offsetSeconds: T;
+  year: T;
+  month: T;
+  day: T;
+  hour: T;
+  minute: T;
+  second: T;
+  nanosecond: T;
 
   constructor(localDateTime: LocalDateTime<T>, offsetSeconds: T);
 }
@@ -75,6 +93,13 @@ declare class DateTimeWithZoneId<T extends NumberOrInteger = Integer> {
 
   localDateTime: LocalDateTime<T>;
   zoneId: string;
+  year: T;
+  month: T;
+  day: T;
+  hour: T;
+  minute: T;
+  second: T;
+  nanosecond: T;
 
   constructor(localDateTime: LocalDateTime<T>, zoneId: string);
 }