feat(spanner): support for type UUID

Author: alkatrivedi

src/codec.ts

@@ -142,6 +142,20 @@ export class SpannerDate extends Date {
   }
 }
 
+/**
+ * @typedef UUID
+ * @see Spanner.uuid
+ */
+export class UUID {
+  value: string;
+  constructor(value: string) {
+    this.value = value;
+  }
+  valueOf(): string {
+    return String(this.value);
+  }
+}
+
 /**
  * Using an abstract class to simplify checking for wrapped numbers.
  *
@@ -529,6 +543,10 @@ function decode(
         enumObject: columnMetadata as object,
       });
       break;
+    case spannerClient.spanner.v1.TypeCode.UUID:
+    case 'UUID':
+      decoded = new UUID(decoded);
+      break;
     case spannerClient.spanner.v1.TypeCode.FLOAT32:
     case 'FLOAT32':
       decoded = new Float32(decoded);
@@ -665,6 +683,10 @@ function encodeValue(value: Value): Value {
     return value.value;
   }
 
+  if (value instanceof UUID) {
+    return value.value;
+  }
+
   if (value instanceof Struct) {
     return Array.from(value).map(field => encodeValue(field.value));
   }
@@ -697,6 +719,7 @@ const TypeCode: {
   bool: 'BOOL',
   int64: 'INT64',
   pgOid: 'INT64',
+  uuid: 'UUID',
   float32: 'FLOAT32',
   float64: 'FLOAT64',
   numeric: 'NUMERIC',
@@ -774,6 +797,10 @@ function getType(value: Value): Type {
   const isSpecialNumber =
     is.infinite(value) || (is.number(value) && isNaN(value));
 
+  if (value instanceof UUID) {
+    return {type: 'uuid'};
+  }
+
   if (value instanceof Float32) {
     return {type: 'float32'};
   }
@@ -969,6 +996,7 @@ export const codec = {
   convertProtoTimestampToDate,
   createTypeObject,
   SpannerDate,
+  UUID,
   Float32,
   Float,
   Int,

src/index.ts

@@ -26,6 +26,7 @@ import * as streamEvents from 'stream-events';
 import * as through from 'through2';
 import {
   codec,
+  UUID,
   Float32,
   Float,
   Int,
@@ -1704,6 +1705,23 @@ class Spanner extends GrpcService {
     return new PreciseDate(value as number);
   }
 
+  /**
+   * Helper function to get a Cloud Spanner UUID object.
+   *
+   * @param {string} value The uuid as a string.
+   * @returns {UUID}
+   *
+   * @example
+   * ```
+   * const {Spanner} = require('@google-cloud/spanner');
+   * const value = uuidv4();
+   * const uuid = Spanner.uuid(value);
+   * ```
+   */
+  static uuid(value): UUID {
+    return new codec.UUID(value);
+  }
+
   /**
    * Helper function to get a Cloud Spanner Float32 object.
    *
@@ -1891,6 +1909,7 @@ class Spanner extends GrpcService {
 promisifyAll(Spanner, {
   exclude: [
     'date',
+    'uuid',
     'float32',
     'float',
     'instance',
@@ -2070,5 +2089,5 @@ import * as protos from '../protos/protos';
 import IInstanceConfig = instanceAdmin.spanner.admin.instance.v1.IInstanceConfig;
 export {v1, protos};
 export default {Spanner};
-export {Float32, Float, Int, Struct, Numeric, PGNumeric, SpannerDate};
+export {UUID, Float32, Float, Int, Struct, Numeric, PGNumeric, SpannerDate};
 export {ObservabilityOptions};

test/codec.ts

@@ -24,6 +24,7 @@ import {GrpcService} from '../src/common-grpc/service';
 import {google} from '../protos/protos';
 import {GoogleError} from 'google-gax';
 import {util} from 'protobufjs';
+import {v4 as uuidv4} from 'uuid';
 import Long = util.Long;
 const singer = require('./data/singer');
 const music = singer.examples.spanner.music;
@@ -152,6 +153,22 @@ describe('codec', () => {
     });
   });
 
+  describe('UUID', () => {
+    it('should store the value', () => {
+      const value = uuidv4();
+      const uuid = new codec.UUID(value);
+
+      assert.strictEqual(uuid.value, value);
+    });
+
+    it('should return as a uuid', () => {
+      const value = uuidv4();
+      const uuid = new codec.UUID(value);
+
+      assert.strictEqual(uuid.valueOf(), String(value));
+    });
+  });
+
   describe('Float', () => {
     it('should store the value', () => {
       const value = 8;
@@ -680,6 +697,17 @@ describe('codec', () => {
       assert.deepStrictEqual(decoded, expected);
     });
 
+    it('should decode UUID', () => {
+      const value = uuidv4();
+
+      const decoded = codec.decode(value, {
+        code: google.spanner.v1.TypeCode.UUID,
+      });
+
+      assert(decoded instanceof codec.UUID);
+      assert.strictEqual(decoded.value, value);
+    });
+
     it.skip('should decode FLOAT32', () => {
       const value = 'Infinity';
 
@@ -1070,6 +1098,15 @@ describe('codec', () => {
       assert.strictEqual(encoded, '10');
     });
 
+    it('should encode UUID', () => {
+      const random = uuidv4();
+      const value = new codec.UUID(random);
+
+      const encoded = codec.encode(value);
+
+      assert.strictEqual(encoded, random);
+    });
+
     it.skip('should encode FLOAT32', () => {
       const value = new codec.Float32(10);
 
@@ -1165,6 +1202,12 @@ describe('codec', () => {
       });
     });
 
+    it('should determine if the value is a uuid', () => {
+      assert.deepStrictEqual(codec.getType(new codec.UUID(uuidv4())), {
+        type: 'uuid',
+      });
+    });
+
     it.skip('should determine if the value is a float32', () => {
       assert.deepStrictEqual(codec.getType(new codec.Float32(1.1)), {
         type: 'float32',
@@ -1317,6 +1360,9 @@ describe('codec', () => {
             google.spanner.v1.TypeCode.TYPE_CODE_UNSPECIFIED
           ],
         },
+        uuid: {
+          code: google.spanner.v1.TypeCode[google.spanner.v1.TypeCode.UUID],
+        },
         bool: {
           code: google.spanner.v1.TypeCode[google.spanner.v1.TypeCode.BOOL],
         },

test/index.ts

@@ -84,6 +84,7 @@ const fakePfy = extend({}, pfy, {
     promisified = true;
     assert.deepStrictEqual(options.exclude, [
       'date',
+      'uuid',
       'float32',
       'float',
       'instance',
@@ -517,6 +518,23 @@ describe('Spanner', () => {
     });
   });
 
+  describe('uuid', () => {
+    it('should create a UUID instance', () => {
+      const value = {};
+      const customValue = {};
+
+      fakeCodec.UUID = class {
+        constructor(value_) {
+          assert.strictEqual(value_, value);
+          return customValue;
+        }
+      };
+
+      const uuid = Spanner.uuid(value);
+      assert.strictEqual(uuid, customValue);
+    });
+  });
+
   describe.skip('float32', () => {
     it('should create a Float32 instance', () => {
       const value = {};