gremlin 3.7.4 → 3.8.0

package/lib/process/traversal-strategy.js

@@ -102,7 +102,7 @@ class HaltedTraverserStrategy extends TraversalStrategy {
   /**
    * @param {String} haltedTraverserFactory full qualified class name in Java of a {@code HaltedTraverserFactory} implementation
    */
-  constructor(haltedTraverserFactory) {
+  constructor({ haltedTraverserFactory } = {}) {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.HaltedTraverserStrategy');
     if (haltedTraverserFactory !== undefined) {
       this.configuration['haltedTraverserFactory'] = haltedTraverserFactory;
@@ -110,9 +110,20 @@ class HaltedTraverserStrategy extends TraversalStrategy {
   }
 }
 
+class MessagePassingReductionStrategy extends TraversalStrategy {
+  constructor() {
+    super(
+      'org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.MessagePassingReductionStrategy',
+    );
+  }
+}
+
 class OptionsStrategy extends TraversalStrategy {
   constructor(options) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy', options);
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.OptionsStrategy');
+    if (options !== undefined) {
+      this.configuration = options;
+    }
   }
 }
 
@@ -129,6 +140,24 @@ class PartitionStrategy extends TraversalStrategy {
   }
 }
 
+class ProfileStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ProfileStrategy');
+  }
+}
+
+class SeedStrategy extends TraversalStrategy {
+  /**
+   * @param {Object} [options]
+   * @param {number} [options.seed] the seed to provide to the random number generator for the traversal
+   */
+  constructor(options) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategy', {
+      seed: options?.seed,
+    });
+  }
+}
+
 class SubgraphStrategy extends TraversalStrategy {
   /**
    * @param {Object} [options]
@@ -151,13 +180,9 @@ class SubgraphStrategy extends TraversalStrategy {
   }
 }
 
-class ProductiveByStrategy extends TraversalStrategy {
-  /**
-   * @param {Object} [options]
-   * @param {Array<String>} [options.productiveKeys] set of keys that will always be productive
-   */
-  constructor(options) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy', options);
+class ReferenceElementStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.ReferenceElementStrategy');
   }
 }
 
@@ -171,7 +196,7 @@ class MatchAlgorithmStrategy extends TraversalStrategy {
   /**
    * @param matchAlgorithm
    */
-  constructor(matchAlgorithm) {
+  constructor({ matchAlgorithm } = {}) {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.finalization.MatchAlgorithmStrategy');
     if (matchAlgorithm !== undefined) {
       this.configuration['matchAlgorithm'] = matchAlgorithm;
@@ -179,12 +204,24 @@ class MatchAlgorithmStrategy extends TraversalStrategy {
   }
 }
 
+class ComputerFinalizationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.finalization.ComputerFinalizationStrategy');
+  }
+}
+
 class AdjacentToIncidentStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.AdjacentToIncidentStrategy');
   }
 }
 
+class ByModulatorOptimizationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ByModulatorOptimizationStrategy');
+  }
+}
+
 class FilterRankingStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.FilterRankingStrategy');
@@ -239,6 +276,17 @@ class PathRetractionStrategy extends TraversalStrategy {
   }
 }
 
+class ProductiveByStrategy extends TraversalStrategy {
+  /**
+   * @param {Object} [options]
+   * @param {Array<String>} productiveKeys set of keys that will always be productive
+   */
+  constructor({ productiveKeys = [] } = {}) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.ProductiveByStrategy');
+    this.configuration['productiveKeys'] = productiveKeys;
+  }
+}
+
 class CountStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.CountStrategy');
@@ -253,7 +301,7 @@ class RepeatUnrollStrategy extends TraversalStrategy {
 
 class GraphFilterStrategy extends TraversalStrategy {
   constructor() {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.GraphFilterStrategy');
+    super('org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.optimization.GraphFilterStrategy');
   }
 }
 
@@ -263,6 +311,12 @@ class EarlyLimitStrategy extends TraversalStrategy {
   }
 }
 
+class ComputerVerificationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ComputerVerificationStrategy');
+  }
+}
+
 class LambdaRestrictionStrategy extends TraversalStrategy {
   constructor() {
     super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.LambdaRestrictionStrategy');
@@ -280,11 +334,10 @@ class EdgeLabelVerificationStrategy extends TraversalStrategy {
    * @param {boolean} logWarnings determines if warnings should be written to the logger when verification fails
    * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
    */
-  constructor(logWarnings = false, throwException = false) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy', {
-      logWarnings: logWarnings,
-      throwException: throwException,
-    });
+  constructor({ logWarnings = false, throwException = false } = {}) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.EdgeLabelVerificationStrategy');
+    this.configuration['logWarnings'] = logWarnings;
+    this.configuration['throwException'] = throwException;
   }
 }
 
@@ -294,24 +347,25 @@ class ReservedKeysVerificationStrategy extends TraversalStrategy {
    * @param {boolean} throwException determines if exceptions should be thrown when verifications fails
    * @param {Array<String>} keys the list of reserved keys to verify
    */
-  constructor(logWarnings = false, throwException = false, keys = ['id', 'label']) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReservedKeysVerificationStrategy', {
-      logWarnings: logWarnings,
-      throwException: throwException,
-      keys: keys,
-    });
+  constructor({ logWarnings = false, throwException = false, keys = ['id', 'label'] } = {}) {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReservedKeysVerificationStrategy');
+    this.configuration['logWarnings'] = logWarnings;
+    this.configuration['throwException'] = throwException;
+    this.configuration['keys'] = keys;
   }
 }
 
-class SeedStrategy extends TraversalStrategy {
-  /**
-   * @param {Object} [options]
-   * @param {number} [options.seed] the seed to provide to the random number generator for the traversal
-   */
-  constructor(options) {
-    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.decoration.SeedStrategy', {
-      seed: options.seed,
-    });
+class VertexProgramRestrictionStrategy extends TraversalStrategy {
+  constructor() {
+    super(
+      'org.apache.tinkerpop.gremlin.process.computer.traversal.strategy.verification.VertexProgramRestrictionStrategy',
+    );
+  }
+}
+
+class StandardVerificationStrategy extends TraversalStrategy {
+  constructor() {
+    super('org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.StandardVerificationStrategy');
   }
 }
 
@@ -319,11 +373,15 @@ module.exports = {
   TraversalStrategies: TraversalStrategies,
   TraversalStrategy: TraversalStrategy,
   // decoration
+  ComputerFinalizationStrategy: ComputerFinalizationStrategy,
   ConnectiveStrategy: ConnectiveStrategy,
   ElementIdStrategy: ElementIdStrategy,
   HaltedTraverserStrategy: HaltedTraverserStrategy,
+  MessagePassingReductionStrategy: MessagePassingReductionStrategy,
   OptionsStrategy: OptionsStrategy,
   PartitionStrategy: PartitionStrategy,
+  ProfileStrategy: ProfileStrategy,
+  ReferenceElementStrategy: ReferenceElementStrategy,
   SeedStrategy: SeedStrategy,
   SubgraphStrategy: SubgraphStrategy,
   VertexProgramStrategy: VertexProgramStrategy,
@@ -331,6 +389,7 @@ module.exports = {
   MatchAlgorithmStrategy: MatchAlgorithmStrategy,
   // optimization
   AdjacentToIncidentStrategy: AdjacentToIncidentStrategy,
+  ByModulatorOptimizationStrategy: ByModulatorOptimizationStrategy,
   FilterRankingStrategy: FilterRankingStrategy,
   IdentityRemovalStrategy: IdentityRemovalStrategy,
   IncidentToAdjacentStrategy: IncidentToAdjacentStrategy,
@@ -346,8 +405,11 @@ module.exports = {
   GraphFilterStrategy: GraphFilterStrategy,
   EarlyLimitStrategy: EarlyLimitStrategy,
   // verification
+  ComputerVerificationStrategy: ComputerVerificationStrategy,
   EdgeLabelVerificationStrategy: EdgeLabelVerificationStrategy,
   LambdaRestrictionStrategy: LambdaRestrictionStrategy,
   ReadOnlyStrategy: ReadOnlyStrategy,
   ReservedKeysVerificationStrategy: ReservedKeysVerificationStrategy,
+  StandardVerificationStrategy: StandardVerificationStrategy,
+  VertexProgramRestrictionStrategy: VertexProgramRestrictionStrategy,
 };

package/lib/process/traversal.js

@@ -84,7 +84,7 @@ class Traversal {
    * @returns {Promise}
    */
   iterate() {
-    this.bytecode.addStep('none');
+    this.bytecode.addStep('discard');
     return this._applyStrategies().then(() => {
       let it;
       while ((it = this._getNext()) && !it.done) {
@@ -345,6 +345,11 @@ class P {
     return createP('outside', args);
   }
 
+  /** @param {...Object} args */
+  static typeOf(...args) {
+    return createP('typeOf', args);
+  }
+
   /** @param {...Object} args */
   static test(...args) {
     return createP('test', args);
@@ -487,6 +492,14 @@ function toDirectionEnum(typeName, keys) {
   return result;
 }
 
+function toGTypeEnum(typeName, keys) {
+  const result = {};
+  keys.split(' ').forEach((k) => {
+    result[k] = new EnumValue(typeName, k.toUpperCase());
+  });
+  return result;
+}
+
 class EnumValue {
   constructor(typeName, elementName) {
     this.typeName = typeName;
@@ -512,12 +525,16 @@ module.exports = {
   column: toEnum('Column', 'keys values'),
   direction: toDirectionEnum('Direction', 'BOTH IN OUT from_ to'),
   dt: toEnum('DT', 'second minute hour day'),
+  gType: toGTypeEnum(
+    'GType',
+    'bigDecimal bigInt binary boolean byte char datetime double duration edge float graph int list long map null number path property set short string tree uuid vertex vproperty',
+  ),
   graphSONVersion: toEnum('GraphSONVersion', 'V1_0 V2_0 V3_0'),
   gryoVersion: toEnum('GryoVersion', 'V1_0 V3_0'),
   merge: toEnum('Merge', 'onCreate onMatch outV inV'),
   operator: toEnum('Operator', 'addAll and assign div max min minus mult or sum sumLong'),
   order: toEnum('Order', 'asc desc shuffle'),
-  pick: toEnum('Pick', 'any none'),
+  pick: toEnum('Pick', 'any none unproductive'),
   pop: toEnum('Pop', 'all first last mixed'),
   scope: toEnum('Scope', 'global local'),
   t: toEnum('T', 'id key label value'),

package/lib/structure/graph.js

@@ -46,9 +46,11 @@ class Graph {
 }
 
 class Element {
-  constructor(id, label) {
+  // properties are stored as list of property objects
+  constructor(id, label, properties = []) {
     this.id = id;
     this.label = label;
+    this.properties = properties != null ? properties : [];
   }
 
   /**
@@ -62,9 +64,8 @@ class Element {
 }
 
 class Vertex extends Element {
-  constructor(id, label, properties) {
-    super(id, label);
-    this.properties = properties;
+  constructor(id, label, properties = []) {
+    super(id, label, properties);
   }
 
   toString() {
@@ -73,18 +74,10 @@ class Vertex extends Element {
 }
 
 class Edge extends Element {
-  constructor(id, outV, label, inV, properties) {
-    super(id, label);
+  constructor(id, outV, label, inV, properties = []) {
+    super(id, label, properties);
     this.outV = outV;
     this.inV = inV;
-    this.properties = {};
-    if (properties) {
-      const keys = Object.keys(properties);
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i];
-        this.properties[k] = properties[k].value;
-      }
-    }
   }
 
   toString() {
@@ -96,11 +89,10 @@ class Edge extends Element {
 }
 
 class VertexProperty extends Element {
-  constructor(id, label, value, properties) {
-    super(id, label);
+  constructor(id, label, value, properties = []) {
+    super(id, label, properties);
     this.value = value;
     this.key = this.label;
-    this.properties = properties;
   }
 
   toString() {

package/lib/structure/io/binary/GraphBinary.js

@@ -71,14 +71,15 @@ ioc.intSerializer               = new (require('./internals/IntSerializer'))(ioc
 ioc.longSerializer              = new (require('./internals/LongSerializer'))(ioc);
 ioc.longSerializerNg            = new (require('./internals/LongSerializerNg'))(ioc);
 ioc.stringSerializer            = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.STRING);
+ioc.offsetDateTimeSerializer    = new (require('./internals/OffsetDateTimeSerializer'))(ioc, ioc.DataType.OFFSETDATETIME);
 ioc.dateSerializer              = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.DATE);
 ioc.timestampSerializer         = new (require('./internals/DateSerializer'))(ioc, ioc.DataType.TIMESTAMP);
-ioc.classSerializer             = new (require('./internals/StringSerializer'))(ioc, ioc.DataType.CLASS);
+ioc.classSerializer             = new (require('./internals/ClassSerializer'))(ioc);
 ioc.doubleSerializer            = new (require('./internals/DoubleSerializer'))(ioc);
 ioc.floatSerializer             = new (require('./internals/FloatSerializer'))(ioc);
 ioc.listSerializer              = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.LIST);
 ioc.mapSerializer               = new (require('./internals/MapSerializer'))(ioc);
-ioc.setSerializer               = new (require('./internals/ArraySerializer'))(ioc, ioc.DataType.SET);
+ioc.setSerializer               = new (require('./internals/SetSerializer'))(ioc, ioc.DataType.SET);
 ioc.uuidSerializer              = new (require('./internals/UuidSerializer'))(ioc);
 ioc.edgeSerializer              = new (require('./internals/EdgeSerializer'))(ioc);
 ioc.pathSerializer              = new (require('./internals/PathSerializer'))(ioc);

package/lib/structure/io/binary/internals/AnySerializer.js

@@ -35,11 +35,13 @@ module.exports = class AnySerializer {
       ioc.numberSerializationStrategy,
 
       ioc.booleanSerializer,
+      ioc.offsetDateTimeSerializer,
       ioc.dateSerializer,
       ioc.bytecodeSerializer,
       ioc.pSerializer,
       ioc.traverserSerializer,
       ioc.enumSerializer,
+      ioc.setSerializer,
       ioc.listSerializer,
       ioc.uuidSerializer,
       ioc.edgeSerializer,
@@ -47,6 +49,7 @@ module.exports = class AnySerializer {
       ioc.propertySerializer,
       ioc.vertexSerializer,
       ioc.vertexPropertySerializer,
+      ioc.classSerializer,
       ioc.stringSerializer,
       ioc.textPSerializer,
       ioc.traversalStrategySerializer,

package/lib/structure/io/binary/internals/ClassSerializer.js

@@ -0,0 +1,60 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+
+'use strict';
+
+const { TraversalStrategy } = require('../../../../process/traversal-strategy');
+const { Buffer } = require('buffer');
+
+module.exports = class ClassSerializer {
+  constructor(ioc) {
+    this.ioc = ioc;
+    this.ioc.serializers[ioc.DataType.CLASS] = this;
+  }
+
+  canBeUsedFor(value) {
+    return (
+      typeof value === 'function' &&
+      !!value.prototype &&
+      !!value.prototype.constructor.name &&
+      new value() instanceof TraversalStrategy
+    );
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ioc.DataType.CLASS, 0x01]);
+      }
+      return this.ioc.intSerializer.serialize(0, false);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ioc.DataType.CLASS, 0x00]));
+    }
+
+    const fqcn = new item().fqcn;
+    const v = Buffer.from(fqcn, 'utf8');
+    bufs.push(this.ioc.intSerializer.serialize(fqcn.length, false));
+    bufs.push(v);
+
+    return Buffer.concat(bufs);
+  }
+};

package/lib/structure/io/binary/internals/DataType.js

@@ -75,6 +75,7 @@ const DataType = {
   TRAVERSALMETRICS: 0x2d,
   MERGE: 0x2e,
   DT: 0x2f,
+  GTYPE: 0x30,
 
   CHAR: 0x80,
   DURATION: 0x81,

package/lib/structure/io/binary/internals/EnumSerializer.js

@@ -43,6 +43,7 @@ module.exports = class EnumSerializer {
       { name: 'Column', code: DT.COLUMN, enum: to_orig_enum(t.column) },
       { name: 'Direction', code: DT.DIRECTION, enum: to_orig_enum(t.direction) },
       { name: 'DT', code: DT.DT, enum: to_orig_enum(t.dt) },
+      { name: 'GType', code: DT.GTYPE, enum: to_orig_enum(t.gType) },
       { name: 'Merge', code: DT.MERGE, enum: to_orig_enum(t.merge) },
       { name: 'Operator', code: DT.OPERATOR, enum: to_orig_enum(t.operator) },
       { name: 'Order', code: DT.ORDER, enum: to_orig_enum(t.order) },

package/lib/structure/io/binary/internals/NumberSerializationStrategy.js

@@ -58,7 +58,12 @@ module.exports = class NumberSerializationStrategy {
         // INT32_MIN/MAX
         return this.ioc.intSerializer.serialize(item, fullyQualifiedFormat);
       }
-      return this.ioc.longSerializer.serialize(item, fullyQualifiedFormat);
+      // eslint-disable-next-line no-loss-of-precision
+      if (item >= -9223372036854775808 && item < 9223372036854775807) {
+        // INT64_MIN/MAX
+        return this.ioc.longSerializer.serialize(item, fullyQualifiedFormat);
+      }
+      return this.ioc.doubleSerializer.serialize(item, fullyQualifiedFormat);
     }
 
     if (typeof item === 'bigint') {

package/lib/structure/io/binary/internals/OffsetDateTimeSerializer.js

@@ -0,0 +1,151 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+
+'use strict';
+
+const { Buffer } = require('buffer');
+
+module.exports = class OffsetDateTimeSerializer {
+  constructor(ioc, ID) {
+    this.ioc = ioc;
+    this.ID = ID;
+    this.ioc.serializers[ID] = this;
+  }
+
+  canBeUsedFor(value) {
+    return value instanceof Date;
+  }
+
+  serialize(item, fullyQualifiedFormat = true) {
+    if (item === undefined || item === null) {
+      if (fullyQualifiedFormat) {
+        return Buffer.from([this.ID, 0x01]);
+      }
+      return Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+    }
+
+    const bufs = [];
+    if (fullyQualifiedFormat) {
+      bufs.push(Buffer.from([this.ID, 0x00]));
+    }
+
+    // NOTE: js Date will always display time in UTC, but regular date/hour getters will return in local system time.
+    // To avoid inconsistency we will always serialize the UTC representation of the Date object with offset of 0.
+
+    // {year}
+    let v = Buffer.alloc(4);
+    v.writeInt32BE(item.getUTCFullYear());
+    bufs.push(v);
+
+    // {month}
+    v = Buffer.alloc(1);
+    v.writeUInt8(item.getUTCMonth() + 1); // Java Core DateTime serializer uses 1 - 12 for months, JS uses indices
+    bufs.push(v);
+
+    // {day} - in UTC
+    v = Buffer.alloc(1);
+    v.writeUInt8(item.getUTCDate());
+    bufs.push(v);
+
+    // {nanoseconds}
+    const h = item.getUTCHours(); // in UTC
+    const m = item.getUTCMinutes();
+    const s = item.getUTCSeconds();
+    const ms = item.getUTCMilliseconds();
+    const ns = h * 60 * 60 * 1e9 + m * 60 * 1e9 + s * 1e9 + ms * 1e6;
+    v = Buffer.alloc(8);
+    v.writeBigInt64BE(BigInt(ns));
+    bufs.push(v);
+
+    // {zone offset} - UTC is always used for serialization, as such offset will be 0
+    v = Buffer.alloc(4);
+    v.writeInt32BE(0);
+    bufs.push(v);
+
+    return Buffer.concat(bufs);
+  }
+
+  deserialize(buffer, fullyQualifiedFormat = true) {
+    let len = 0;
+    let cursor = buffer;
+
+    try {
+      if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
+        throw new Error('buffer is missing');
+      }
+      if (buffer.length < 1) {
+        throw new Error('buffer is empty');
+      }
+
+      if (fullyQualifiedFormat) {
+        const type_code = cursor.readUInt8();
+        len++;
+        if (type_code !== this.ID) {
+          throw new Error('unexpected {type_code}');
+        }
+        cursor = cursor.slice(1);
+
+        if (cursor.length < 1) {
+          throw new Error('{value_flag} is missing');
+        }
+        const value_flag = cursor.readUInt8();
+        len++;
+        if (value_flag === 1) {
+          return { v: null, len };
+        }
+        if (value_flag !== 0) {
+          throw new Error('unexpected {value_flag}');
+        }
+        cursor = cursor.slice(1);
+      }
+
+      if (cursor.length < 8) {
+        throw new Error('unexpected {value} length');
+      }
+      len += 18;
+
+      const year = cursor.readInt32BE();
+      cursor = cursor.slice(4);
+      const month = cursor.readUInt8() - 1;
+      cursor = cursor.slice(1);
+      const date = cursor.readUInt8();
+      cursor = cursor.slice(1);
+      const ns = cursor.readBigInt64BE();
+      cursor = cursor.slice(8);
+      const offset = cursor.readInt32BE();
+      cursor.slice(4);
+
+      // calculate hour, minute, second, and ms from ns as JS Date doesn't have ns precision
+      const totalMS = ns / BigInt(1e6);
+      const ms = Number(totalMS) % 1e3;
+      const totalS = Math.trunc(Number(totalMS) / 1e3) - offset; // js Date doesn't have a way to set offset properly, account offset here to use UTC
+      const s = totalS % 60;
+      const totalM = Math.trunc(totalS / 60);
+      const m = totalM % 60;
+      const h = Math.trunc(totalM / 60);
+
+      // use UTC time calculated with offset above
+      const v = new Date(Date.UTC(year, month, date, h, m, s, ms));
+
+      return { v, len };
+    } catch (err) {
+      throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+    }
+  }
+};