feat: add support for Decimal128 type

Author: nodkz

src/__mocks__/userModel.js

@@ -90,6 +90,10 @@ const UserSchema: SchemaType<any> = new Schema(
       periods: [{ from: Number, to: Number }],
     },
 
+    salary: {
+      type: Schema.Types.Decimal128,
+    },
+
     // createdAt, created via option `timastamp: true` (see bottom)
     // updatedAt, created via option `timastamp: true` (see bottom)
   },

src/__tests__/fieldConverter-test.js

@@ -16,6 +16,7 @@ import {
   referenceToGraphQL,
 } from '../fieldsConverter';
 import GraphQLMongoID from '../types/mongoid';
+import GraphQLBSONDecimal from '../types/bsonDecimal';
 
 describe('fieldConverter', () => {
   const fields: { [key: string]: any } = getFieldsFromModel(UserModel);
@@ -77,23 +78,27 @@ describe('fieldConverter', () => {
       expect(deriveComplexType(fields.subDoc)).toBe(ComplexTypes.EMBEDDED);
     });
 
-    it('schould derive ARRAY', () => {
+    it('should derive DECIMAL', () => {
+      expect(deriveComplexType(fields.salary)).toBe(ComplexTypes.DECIMAL);
+    });
+
+    it('should derive ARRAY', () => {
       expect(deriveComplexType(fields.users)).toBe(ComplexTypes.ARRAY);
       expect(deriveComplexType(fields.skills)).toBe(ComplexTypes.ARRAY);
       expect(deriveComplexType(fields.employment)).toBe(ComplexTypes.ARRAY);
     });
 
-    it('schould derive ENUM', () => {
+    it('should derive ENUM', () => {
       expect(deriveComplexType(fields.gender)).toBe(ComplexTypes.ENUM);
       expect(deriveComplexType(fields.languages.schema.paths.ln)).toBe(ComplexTypes.ENUM);
       expect(deriveComplexType(fields.languages.schema.paths.sk)).toBe(ComplexTypes.ENUM);
     });
 
-    it('schould derive REFERENCE', () => {
+    it('should derive REFERENCE', () => {
       expect(deriveComplexType(fields.user)).toBe(ComplexTypes.REFERENCE);
     });
 
-    it('schould derive SCALAR', () => {
+    it('should derive SCALAR', () => {
       expect(deriveComplexType(fields.name)).toBe(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.relocation)).toBe(ComplexTypes.SCALAR);
       expect(deriveComplexType(fields.age)).toBe(ComplexTypes.SCALAR);
@@ -103,7 +108,7 @@ describe('fieldConverter', () => {
       expect(deriveComplexType(fields.subDoc)).not.toBe(ComplexTypes.SCALAR);
     });
 
-    it('schould derive MIXED mongoose type', () => {
+    it('should derive MIXED mongoose type', () => {
       expect(deriveComplexType(fields.someDynamic)).toBe(ComplexTypes.MIXED);
     });
   });
@@ -141,6 +146,18 @@ describe('fieldConverter', () => {
       expect(schemaComposer.get('MongoID')).toBe(customType);
       schemaComposer.delete('MongoID');
     });
+
+    it('should convert any mongoose field to graphQL type', () => {
+      schemaComposer.clear();
+      expect(schemaComposer.has('BSONDecimal')).toBeFalsy();
+      const mongooseField = {
+        path: 'salary',
+        instance: 'Decimal128',
+      };
+      expect(convertFieldToGraphQL(mongooseField, '', schemaComposer)).toBe('BSONDecimal');
+      expect(schemaComposer.has('BSONDecimal')).toBeTruthy();
+      expect(schemaComposer.get('BSONDecimal').getType()).toBe(GraphQLBSONDecimal);
+    });
   });
 
   describe('scalarToGraphQL()', () => {

src/fieldsConverter.d.ts

@@ -25,6 +25,7 @@ export const ComplexTypes: {
   REFERENCE: 'REFERENCE';
   SCALAR: 'SCALAR';
   MIXED: 'MIXED';
+  DECIMAL: 'DECIMAL';
 };
 
 export function dotPathsToEmbedded(

src/fieldsConverter.js

@@ -13,6 +13,7 @@ import type {
 import { upperFirst } from 'graphql-compose';
 import type { GraphQLScalarType } from 'graphql-compose/lib/graphql';
 import GraphQLMongoID from './types/mongoid';
+import GraphQLBSONDecimal from './types/bsonDecimal';
 
 type MongooseFieldT = MongooseSchemaField<any>;
 type MongooseFieldMapT = { [fieldName: string]: MongooseFieldT };
@@ -30,6 +31,7 @@ export const ComplexTypes = {
   REFERENCE: 'REFERENCE',
   SCALAR: 'SCALAR',
   MIXED: 'MIXED',
+  DECIMAL: 'DECIMAL',
 };
 
 function _getFieldName(field: MongooseFieldT): string {
@@ -211,6 +213,11 @@ export function convertFieldToGraphQL(
       return (documentArrayToGraphQL(field, prefix, schemaComposer): any);
     case ComplexTypes.MIXED:
       return 'JSON';
+    case ComplexTypes.DECIMAL:
+      if (!schemaComposer.has('BSONDecimal')) {
+        schemaComposer.add(GraphQLBSONDecimal);
+      }
+      return 'BSONDecimal';
     default:
       return scalarToGraphQL(field);
   }
@@ -241,6 +248,8 @@ export function deriveComplexType(field: MongooseFieldT): $Keys<typeof ComplexTy
     return ComplexTypes.MIXED;
   } else if (fieldType === 'ObjectID') {
     return ComplexTypes.REFERENCE;
+  } else if (fieldType === 'Decimal128') {
+    return ComplexTypes.DECIMAL;
   }
 
   const enums = _getFieldEnums(field);

src/index.d.ts

@@ -1,10 +1,11 @@
 import { composeWithMongoose } from './composeWithMongoose';
 import GraphQLMongoID from './types/mongoid';
+import GraphQLBSONDecimal from './types/bsonDecimal';
 
 export default composeWithMongoose;
 
 export * from './composeWithMongoose';
 export * from './composeWithMongooseDiscriminators';
 export * from './fieldsConverter';
 export * from './resolvers';
-export { GraphQLMongoID };
+export { GraphQLMongoID, GraphQLBSONDecimal };

src/index.js

@@ -2,11 +2,12 @@
 
 import { composeWithMongoose } from './composeWithMongoose';
 import GraphQLMongoID from './types/mongoid';
+import GraphQLBSONDecimal from './types/bsonDecimal';
 
 export default composeWithMongoose;
 
 export * from './composeWithMongoose';
 export * from './composeWithMongooseDiscriminators';
 export * from './fieldsConverter';
 export * from './resolvers';
-export { GraphQLMongoID };
+export { GraphQLMongoID, GraphQLBSONDecimal };

src/types/__tests__/bsonDecimal-test.js

@@ -0,0 +1,65 @@
+/* @flow */
+
+import mongoose from 'mongoose';
+import { Kind } from 'graphql-compose/lib/graphql';
+import GraphQLBSONDecimal from '../bsonDecimal';
+
+const Decimal128 = mongoose.Types.Decimal128;
+
+describe('GraphQLBSONDecimal', () => {
+  describe('serialize', () => {
+    it('pass Decimal128', () => {
+      const amount = Decimal128.fromString('90000000000000000000000000000000.09');
+      expect(GraphQLBSONDecimal.serialize(amount)).toBe('90000000000000000000000000000000.09');
+    });
+
+    it('pass String', () => {
+      const amount = '90000000000000000000000000000000.09';
+      expect(GraphQLBSONDecimal.serialize(amount)).toBe('90000000000000000000000000000000.09');
+    });
+  });
+
+  describe('parseValue', () => {
+    it('pass Decimal128', () => {
+      const amount = Decimal128.fromString('90000000000000000000000000000000.09');
+      expect(GraphQLBSONDecimal.parseValue(amount)).toBeInstanceOf(Decimal128);
+    });
+
+    it('pass String', () => {
+      const amount = '90000000000000000000000000000000.09';
+      expect(GraphQLBSONDecimal.parseValue(amount)).toBeInstanceOf(Decimal128);
+    });
+
+    it('pass Integer', () => {
+      const amount = 123;
+      expect(GraphQLBSONDecimal.parseValue(amount)).toBeInstanceOf(Decimal128);
+    });
+
+    it('pass any custom string value', () => {
+      const id = 'custom_id';
+      expect(() => GraphQLBSONDecimal.parseValue(id)).toThrow('not a valid Decimal128 string');
+    });
+  });
+
+  describe('parseLiteral', () => {
+    it('parse a ast STRING literal', async () => {
+      const ast = {
+        kind: Kind.STRING,
+        value: '90000000000000000000000000000000.09',
+      };
+      const amount: any = GraphQLBSONDecimal.parseLiteral(ast);
+      expect(amount).toBeInstanceOf(Decimal128);
+      expect(amount.toString()).toEqual('90000000000000000000000000000000.09');
+    });
+
+    it('parse a ast INT literal', async () => {
+      const ast: any = {
+        kind: Kind.INT,
+        value: '123',
+      };
+      const amount: any = GraphQLBSONDecimal.parseLiteral(ast);
+      expect(amount).toBeInstanceOf(Decimal128);
+      expect(amount.toString()).toEqual('123');
+    });
+  });
+});

src/types/bsonDecimal.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLScalarType } from 'graphql-compose/lib/graphql';
+
+declare const GraphQLBSONDecimal: GraphQLScalarType;
+
+export default GraphQLBSONDecimal;

src/types/bsonDecimal.js

@@ -0,0 +1,36 @@
+/* @flow */
+
+import mongoose from 'mongoose';
+import { GraphQLScalarType, Kind } from 'graphql-compose/lib/graphql';
+
+const Decimal128 = mongoose.Types.Decimal128;
+
+const GraphQLBSONDecimal = new GraphQLScalarType({
+  name: 'BSONDecimal',
+  description:
+    'The `Decimal` scalar type uses the IEEE 754 decimal128 ' +
+    'decimal-based floating-point numbering format. ' +
+    'Supports 34 decimal digits of precision, a max value of ' +
+    'approximately 10^6145, and min value of approximately -10^6145',
+  serialize: String,
+  parseValue(value: any) {
+    if (typeof value === 'string') {
+      return Decimal128.fromString(value);
+    }
+    if (typeof value === 'number') {
+      return Decimal128.fromString(value.toString());
+    }
+    if (value instanceof Decimal128) {
+      return value;
+    }
+    throw new TypeError('Field error: value is an invalid Decimal');
+  },
+  parseLiteral(ast) {
+    if (ast.kind === Kind.STRING || ast.kind === Kind.INT) {
+      return Decimal128.fromString(ast.value);
+    }
+    return null;
+  },
+});
+
+export default GraphQLBSONDecimal;

src/types/mongoid.d.ts

@@ -1,7 +1,5 @@
 import { GraphQLScalarType } from 'graphql-compose/lib/graphql';
 
-export type MongoId = string | any;
-
 declare const GraphQLMongoID: GraphQLScalarType;
 
 export default GraphQLMongoID;