@graphprotocol/graph-cli 0.37.1 → 0.37.2-alpha-20221219142030-0cf2a37

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @graphprotocol/graph-cli
 
+## 0.37.2-alpha-20221219142030-0cf2a37
+
+### Patch Changes
+
+- [#1021](https://github.com/graphprotocol/graph-cli/pull/1021) [`bb2a64f`](https://github.com/graphprotocol/graph-cli/commit/bb2a64f89ca704c2f6bc46bb9f3d53a9581bf765) Thanks [@saihaj](https://github.com/saihaj)! - dependencies updates:
+  - Removed dependency [`immutable@3.8.2` ↗︎](https://www.npmjs.com/package/immutable/v/3.8.2) (from `dependencies`)
+
 ## 0.37.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.37.1",
+  "version": "0.37.2-alpha-20221219142030-0cf2a37",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {
@@ -16,7 +16,6 @@
     "glob": "7.1.6",
     "gluegun": "https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep",
     "graphql": "15.5.0",
-    "immutable": "3.8.2",
     "ipfs-http-client": "34.0.0",
     "jayson": "3.6.6",
     "js-yaml": "3.13.1",

package/src/codegen/schema.js

@@ -1,25 +1,21 @@
-const immutable = require('immutable')
-
 const tsCodegen = require('./typescript')
 const typesCodegen = require('./types')
 
-const List = immutable.List
-
 class IdField {
-  static BYTES = Symbol("Bytes")
-  static STRING = Symbol("String")
+  static BYTES = Symbol('Bytes')
+  static STRING = Symbol('String')
 
   constructor(idField) {
-    const typeName = idField.getIn(['type', 'type', 'name', 'value'])
-    this.kind = typeName === "Bytes" ? IdField.BYTES : IdField.STRING
+    const typeName = idField.type?.type?.name?.value
+    this.kind = typeName === 'Bytes' ? IdField.BYTES : IdField.STRING
   }
 
   typeName() {
-    return this.kind === IdField.BYTES ? "Bytes" : "string"
+    return this.kind === IdField.BYTES ? 'Bytes' : 'string'
   }
 
   gqlTypeName() {
-    return this.kind === IdField.BYTES ? "Bytes" : "String"
+    return this.kind === IdField.BYTES ? 'Bytes' : 'String'
   }
 
   tsNamedType() {
@@ -27,28 +23,28 @@ class IdField {
   }
 
   tsValueFrom() {
-    return this.kind === IdField.BYTES ? "Value.fromBytes(id)" : "Value.fromString(id)"
+    return this.kind === IdField.BYTES ? 'Value.fromBytes(id)' : 'Value.fromString(id)'
   }
 
   tsValueKind() {
-    return this.kind === IdField.BYTES ? "ValueKind.BYTES" : "ValueKind.STRING"
+    return this.kind === IdField.BYTES ? 'ValueKind.BYTES' : 'ValueKind.STRING'
   }
 
   tsValueToString() {
-    return this.kind == IdField.BYTES ? "id.toBytes().toHexString()" : "id.toString()"
+    return this.kind == IdField.BYTES ? 'id.toBytes().toHexString()' : 'id.toString()'
   }
 
   tsToString() {
-    return this.kind == IdField.BYTES ? "id.toHexString()" : "id"
+    return this.kind == IdField.BYTES ? 'id.toHexString()' : 'id'
   }
 
   static fromFields(fields) {
-    const idField = fields.find(field => field.getIn(['name', 'value']) === 'id')
+    const idField = fields.find(field => field.name?.value === 'id')
     return new IdField(idField)
   }
 
   static fromTypeDef(def) {
-    return IdField.fromFields(def.get("fields"))
+    return IdField.fromFields(def.fields)
   }
 }
 
@@ -81,29 +77,26 @@ module.exports = class SchemaCodeGenerator {
   }
 
   generateTypes() {
-    return this.schema.ast
-      .get('definitions')
+    return this.schema.ast.definitions
       .filter(def => this._isEntityTypeDefinition(def))
       .map(def => this._generateEntityType(def))
   }
 
   _isEntityTypeDefinition(def) {
     return (
-      def.get('kind') === 'ObjectTypeDefinition' &&
-      def
-        .get('directives')
-        .find(directive => directive.getIn(['name', 'value']) === 'entity') !== undefined
+      def.kind === 'ObjectTypeDefinition' &&
+      def.directives.find(directive => directive.name?.value === 'entity') !== undefined
     )
   }
 
   _isInterfaceDefinition(def) {
-    return def.get('kind') === 'InterfaceTypeDefinition'
+    return def.kind === 'InterfaceTypeDefinition'
   }
 
   _generateEntityType(def) {
-    let name = def.getIn(['name', 'value'])
+    let name = def.name?.value
     let klass = tsCodegen.klass(name, { export: true, extends: 'Entity' })
-    const fields = def.get('fields')
+    const fields = def.fields
     const idField = IdField.fromFields(fields)
 
     // Generate and add a constructor
@@ -113,11 +106,10 @@ module.exports = class SchemaCodeGenerator {
     this._generateStoreMethods(name, idField).forEach(method => klass.addMethod(method))
 
     // Generate and add entity field getters and setters
-    def
-      .get('fields')
+    def.fields
       .reduce(
         (methods, field) => methods.concat(this._generateEntityFieldMethods(def, field)),
-        List(),
+        [],
       )
       .forEach(method => klass.addMethod(method))
 
@@ -138,7 +130,7 @@ module.exports = class SchemaCodeGenerator {
   }
 
   _generateStoreMethods(entityName, idField) {
-    return List.of(
+    return [
       tsCodegen.method(
         'save',
         [],
@@ -162,19 +154,19 @@ module.exports = class SchemaCodeGenerator {
         return changetype<${entityName} | null>(store.get('${entityName}', ${idField.tsToString()}))
         `,
       ),
-    )
+    ]
   }
 
   _generateEntityFieldMethods(entityDef, fieldDef) {
-    return List([
+    return [
       this._generateEntityFieldGetter(entityDef, fieldDef),
       this._generateEntityFieldSetter(entityDef, fieldDef),
-    ])
+    ]
   }
 
   _generateEntityFieldGetter(entityDef, fieldDef) {
-    let name = fieldDef.getIn(['name', 'value'])
-    let gqlType = fieldDef.get('type')
+    let name = fieldDef.name?.value
+    let gqlType = fieldDef.type
     let fieldValueType = this._valueTypeFromGraphQl(gqlType)
     let returnType = this._typeFromGraphQl(gqlType)
     let isNullable = returnType instanceof tsCodegen.NullableType
@@ -198,25 +190,21 @@ module.exports = class SchemaCodeGenerator {
   }
 
   _generateEntityFieldSetter(entityDef, fieldDef) {
-    let name = fieldDef.getIn(['name', 'value'])
-    let gqlType = fieldDef.get('type')
+    let name = fieldDef.name?.value
+    let gqlType = fieldDef.type
     let fieldValueType = this._valueTypeFromGraphQl(gqlType)
     let paramType = this._typeFromGraphQl(gqlType)
     let isNullable = paramType instanceof tsCodegen.NullableType
     let paramTypeString = isNullable ? paramType.inner.toString() : paramType.toString()
     let isArray = paramType instanceof tsCodegen.ArrayType
 
-    if (
-      isArray &&
-      paramType.inner instanceof tsCodegen.NullableType
-    ) {
+    if (isArray && paramType.inner instanceof tsCodegen.NullableType) {
       let baseType = this._baseType(gqlType)
 
       throw new Error(`
 GraphQL schema can't have List's with Nullable members.
 Error in '${name}' field of type '[${baseType}]'.
-Suggestion: add an '!' to the member type of the List, change from '[${baseType}]' to '[${baseType}!]'`
-      )
+Suggestion: add an '!' to the member type of the List, change from '[${baseType}]' to '[${baseType}!]'`)
     }
 
     let setNonNullable = `
@@ -242,12 +230,15 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
   }
 
   _resolveFieldType(gqlType) {
-    let typeName = gqlType.getIn(['name', 'value'])
+    let typeName = gqlType.name?.value
 
     // If this is a reference to another type, the field has the type of
     // the referred type's id field
-    const typeDef = this.schema.ast.get("definitions").
-      find(def => (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) && def.getIn(["name", "value"]) === typeName)
+    const typeDef = this.schema.ast.definitions.find(
+      def =>
+        (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
+        def.name?.value === typeName,
+    )
     if (typeDef) {
       return IdField.fromTypeDef(typeDef).typeName()
     } else {
@@ -260,10 +251,10 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
    * other entity types, this is the same as the type of the id of the
    * referred type, i.e., `string` or `Bytes`*/
   _valueTypeFromGraphQl(gqlType) {
-    if (gqlType.get('kind') === 'NonNullType') {
-      return this._valueTypeFromGraphQl(gqlType.get('type'), false)
-    } else if (gqlType.get('kind') === 'ListType') {
-      return '[' + this._valueTypeFromGraphQl(gqlType.get('type')) + ']'
+    if (gqlType.kind === 'NonNullType') {
+      return this._valueTypeFromGraphQl(gqlType.type, false)
+    } else if (gqlType.kind === 'ListType') {
+      return '[' + this._valueTypeFromGraphQl(gqlType.type) + ']'
     } else {
       return this._resolveFieldType(gqlType)
     }
@@ -272,20 +263,20 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
   /** Determine the base type of `gqlType` by removing any non-null
    * constraints and using the type of elements of lists */
   _baseType(gqlType) {
-    if (gqlType.get('kind') === 'NonNullType') {
-      return this._baseType(gqlType.get('type'))
-    } else if (gqlType.get('kind') === 'ListType') {
-      return this._baseType(gqlType.get('type'))
+    if (gqlType.kind === 'NonNullType') {
+      return this._baseType(gqlType.type)
+    } else if (gqlType.kind === 'ListType') {
+      return this._baseType(gqlType.type)
     } else {
-      return gqlType.getIn(['name', 'value'])
+      return gqlType.name?.value
     }
   }
 
   _typeFromGraphQl(gqlType, nullable = true) {
-    if (gqlType.get('kind') === 'NonNullType') {
-      return this._typeFromGraphQl(gqlType.get('type'), false)
-    } else if (gqlType.get('kind') === 'ListType') {
-      let type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.get('type')))
+    if (gqlType.kind === 'NonNullType') {
+      return this._typeFromGraphQl(gqlType.type, false)
+    } else if (gqlType.kind === 'ListType') {
+      let type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.type))
       return nullable ? tsCodegen.nullableType(type) : type
     } else {
       // NamedType

package/src/codegen/schema.test.js

@@ -1,6 +1,5 @@
 const prettier = require('prettier')
 const graphql = require('graphql/language')
-const immutable = require('immutable')
 const SchemaCodeGenerator = require('./schema')
 const {
   Class,
@@ -12,15 +11,11 @@ const {
   ArrayType,
 } = require('./typescript')
 
-const formatTS = code =>
-  prettier.format(
-    code,
-    { parser: 'typescript', semi: false }
-  )
+const formatTS = code => prettier.format(code, { parser: 'typescript', semi: false })
 
 const createSchemaCodeGen = schema =>
   new SchemaCodeGenerator({
-    ast: immutable.fromJS(graphql.parse(schema)),
+    ast: graphql.parse(schema),
   })
 
 const testEntity = (generatedTypes, expectedEntity) => {
@@ -61,7 +56,7 @@ describe('Schema code generator', () => {
       }
     `)
 
-    expect(codegen.generateTypes().size).toBe(0)
+    expect(codegen.generateTypes().length).toBe(0)
   })
 
   describe('Should generate correct classes for each entity', () => {
@@ -99,7 +94,7 @@ describe('Schema code generator', () => {
       const foo = generatedTypes.find(type => type.name === 'Foo')
       expect(foo).toBe(undefined)
       // Account and Wallet
-      expect(generatedTypes.size).toBe(2)
+      expect(generatedTypes.length).toBe(2)
     })
 
     test('Account is an entity with the correct methods', () => {
@@ -248,7 +243,12 @@ describe('Schema code generator', () => {
           },
           {
             name: 'set wallets',
-            params: [new Param('value', new NullableType(new ArrayType(new NamedType('string'))))],
+            params: [
+              new Param(
+                'value',
+                new NullableType(new ArrayType(new NamedType('string'))),
+              ),
+            ],
             returnType: undefined,
             body: `
               if (!value) {
@@ -377,20 +377,21 @@ describe('Schema code generator', () => {
 
     const generatedTypes = codegen.generateTypes()
     testEntity(generatedTypes, {
-      name: "Task",
+      name: 'Task',
       members: [],
       methods: [
         {
           name: 'constructor',
           params: [new Param('id', new NamedType('Bytes'))],
           returnType: undefined,
-          body: "\n      super()\n      this.set('id', Value.fromBytes(id))\n      "
+          body: "\n      super()\n      this.set('id', Value.fromBytes(id))\n      ",
         },
         {
           name: 'save',
           params: [],
           returnType: new NamedType('void'),
-          body: '\n' +
+          body:
+            '\n' +
             "        let id = this.get('id')\n" +
             '        assert(id != null,\n' +
             "               'Cannot save Task entity without an ID')\n" +
@@ -398,63 +399,67 @@ describe('Schema code generator', () => {
             '          assert(id.kind == ValueKind.BYTES,\n' +
             "                 `Entities of type Task must have an ID of type Bytes but the id '${id.displayData()}' is of type ${id.displayKind()}`)\n" +
             "          store.set('Task', id.toBytes().toHexString(), this)\n" +
-            '        }'
+            '        }',
         },
         {
           name: 'load',
           static: true,
           params: [new Param('id', new NamedType('Bytes'))],
           returnType: new NullableType(new NamedType('Task')),
-          body: '\n' +
+          body:
+            '\n' +
             "        return changetype<Task | null>(store.get('Task', id.toHexString()))\n" +
-            '        '
+            '        ',
         },
         {
           name: 'get id',
           params: [],
           returnType: new NamedType('Bytes'),
-          body: '\n' +
+          body:
+            '\n' +
             "       let value = this.get('id')\n" +
             '       return value!.toBytes()\n' +
-            '      '
+            '      ',
         },
         {
           name: 'set id',
           params: [new Param('value', new NamedType('Bytes'))],
           returnType: undefined,
-          body: "\n      this.set('id', Value.fromBytes(value))\n    "
+          body: "\n      this.set('id', Value.fromBytes(value))\n    ",
         },
         {
           name: 'get employee',
           params: [],
           returnType: new NamedType('Bytes'),
-          body: '\n' +
+          body:
+            '\n' +
             "       let value = this.get('employee')\n" +
             '       return value!.toBytes()\n' +
-            '      '
+            '      ',
         },
         {
           name: 'set employee',
           params: [new Param('value', new NamedType('Bytes'))],
           returnType: undefined,
-          body: "\n      this.set('employee', Value.fromBytes(value))\n    "
+          body: "\n      this.set('employee', Value.fromBytes(value))\n    ",
         },
         {
           name: 'get worker',
           params: [],
           returnType: new NamedType('Bytes'),
-          body: '\n' +
+          body:
+            '\n' +
             "       let value = this.get('worker')\n" +
             '       return value!.toBytes()\n' +
-            '      '
+            '      ',
         },
         {
           name: 'set worker',
           params: [new Param('value', new NamedType('Bytes'))],
           returnType: undefined,
-          body: "\n      this.set('worker', Value.fromBytes(value))\n    "
-        }
-      ]
+          body: "\n      this.set('worker', Value.fromBytes(value))\n    ",
+        },
+      ],
     })
   })
 })

package/src/codegen/template.js

@@ -1,4 +1,3 @@
-const immutable = require('immutable')
 const IpfsFileTemplateCodeGen = require('../protocols/ipfs/codegen/file_template')
 
 const tsCodegen = require('./typescript')
@@ -29,7 +28,7 @@ module.exports = class DataSourceTemplateCodeGenerator {
   }
 
   generateTypes() {
-    return immutable.List([this._generateTemplateType()])
+    return [this._generateTemplateType()]
   }
 
   _generateTemplateType() {

package/src/codegen/types/conversions.js

@@ -1,5 +1,3 @@
-const immutable = require('immutable')
-
 /**
  * ethereum.Value -> AssemblyScript conversions
  */
@@ -55,29 +53,56 @@ const ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT = [
 
   // Multi dimensional arrays
 
-  [/^address\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<Address>>', code => `${code}.toAddressMatrix()`],
-  [/^bool\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<boolean>>', code => `${code}.toBooleanMatrix()`],
-  [/^byte\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<Bytes>>', code => `${code}.toBytesMatrix()`],
+  [
+    /^address\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<Address>>',
+    code => `${code}.toAddressMatrix()`,
+  ],
+  [
+    /^bool\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<boolean>>',
+    code => `${code}.toBooleanMatrix()`,
+  ],
+  [
+    /^byte\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<Bytes>>',
+    code => `${code}.toBytesMatrix()`,
+  ],
   [
     /^bytes(1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32)?\[([0-9]+)?\]\[([0-9]+)?\]$/,
     'Array<Array<Bytes>>',
     code => `${code}.toBytesMatrix()`,
   ],
-  [/^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<i32>>', code => `${code}.toI32Matrix()`],
-  [/^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<i32>>', code => `${code}.toI32Matrix()`],
-  [/^uint32\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<BigInt>>', code => `${code}.toBigIntMatrix()`],
+  [
+    /^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<i32>>',
+    code => `${code}.toI32Matrix()`,
+  ],
+  [
+    /^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<i32>>',
+    code => `${code}.toI32Matrix()`,
+  ],
+  [
+    /^uint32\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<BigInt>>',
+    code => `${code}.toBigIntMatrix()`,
+  ],
   [
     /^u?int(40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)\[([0-9]+)?\]\[([0-9]+)?\]$/,
     'Array<Array<BigInt>>',
     code => `${code}.toBigIntMatrix()`,
   ],
-  [/^string\[([0-9]+)?\]\[([0-9]+)?\]$/, 'Array<Array<string>>', code => `${code}.toStringMatrix()`],
+  [
+    /^string\[([0-9]+)?\]\[([0-9]+)?\]$/,
+    'Array<Array<string>>',
+    code => `${code}.toStringMatrix()`,
+  ],
   [
     /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
     'Array<Array<ethereum.Tuple>>',
     (code, type) => `${code}.toTupleMatrix<${type}>()`,
   ],
-
 ]
 
 /**
@@ -178,7 +203,7 @@ const ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE = [
     /^tuple\[([0-9]+)?\]$/,
     code => `ethereum.Value.fromTupleArray(${code})`,
   ],
-  
+
   // Multi dimentional arrays
 
   [
@@ -282,9 +307,13 @@ const ASSEMBLYSCRIPT_TO_VALUE = [
   ['Array<Array<BigInt>>', '[[BigInt]]', code => `Value.fromBigIntMatrix(${code})`],
   ['Array<Array<string>>', '[[String]]', code => `Value.fromStringMatrix(${code})`],
   ['Array<Array<string>>', '[[ID]]', code => `Value.fromStringMatrix(${code})`],
-  ['Array<Array<BigDecimal>>', '[[BigDecimal]]', code => `Value.fromBigDecimalMatrix(${code})`],
+  [
+    'Array<Array<BigDecimal>>',
+    '[[BigDecimal]]',
+    code => `Value.fromBigDecimalMatrix(${code})`,
+  ],
   ['Array<Array<string>>', /\[\[.*\]\]/, code => `Value.fromStringMatrix(${code})`],
-  ['Array<Array<string | null>>', null, code => `Value.fromStringMatrix(${code})`],// is this overwriting the Array null below?
+  ['Array<Array<string | null>>', null, code => `Value.fromStringMatrix(${code})`], // is this overwriting the Array null below?
 
   // Arrays
 
@@ -315,7 +344,7 @@ const ASSEMBLYSCRIPT_TO_VALUE = [
 /**
  * Type conversions
  */
-module.exports = immutable.fromJS({
+module.exports = Object.freeze({
   ethereum: {
     AssemblyScript: ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT,
   },

package/src/codegen/types/index.js

@@ -1,11 +1,9 @@
-const immutable = require('immutable')
-
 const TYPE_CONVERSIONS = require('./conversions')
 
 // Conversion utilities
 
 const conversionsForTypeSystems = (fromTypeSystem, toTypeSystem) => {
-  let conversions = TYPE_CONVERSIONS.getIn([fromTypeSystem, toTypeSystem])
+  let conversions = TYPE_CONVERSIONS[fromTypeSystem]?.[toTypeSystem]
   if (conversions === undefined) {
     throw new Error(
       `Conversions from '${fromTypeSystem}' to '${toTypeSystem}' are not supported`,
@@ -15,16 +13,16 @@ const conversionsForTypeSystems = (fromTypeSystem, toTypeSystem) => {
 }
 
 const objectifyConversion = (fromTypeSystem, toTypeSystem, conversion) => {
-  return immutable.fromJS({
+  return Object.freeze({
     from: {
       typeSystem: fromTypeSystem,
-      type: conversion.get(0),
+      type: conversion[0],
     },
     to: {
       typeSystem: toTypeSystem,
-      type: conversion.get(1),
+      type: conversion[1],
     },
-    convert: conversion.get(2),
+    convert: conversion[2],
   })
 }
 
@@ -32,9 +30,9 @@ const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
   let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
 
   let conversion = conversions.find(conversion =>
-    typeof conversion.get(0) === 'string'
-      ? conversion.get(0) === fromType
-      : fromType.match(conversion.get(0)),
+    typeof conversion[0] === 'string'
+      ? conversion[0] === fromType
+      : fromType.match(conversion[0]),
   )
 
   if (conversion === undefined) {
@@ -51,9 +49,9 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
   let conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
 
   let conversion = conversions.find(conversion =>
-    typeof conversion.get(1) === 'string'
-      ? conversion.get(1) === toType
-      : toType.match(conversion.get(1)),
+    typeof conversion[1] === 'string'
+      ? conversion[1] === toType
+      : toType.match(conversion[1]),
   )
 
   if (conversion === undefined) {
@@ -69,35 +67,34 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
 // High-level type system API
 
 const ascTypeForProtocol = (protocol, protocolType) =>
-  findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type'])
+  findConversionFromType(protocol, 'AssemblyScript', protocolType).to?.type
 
 // TODO: this can be removed/replaced by the function above
-const ascTypeForEthereum = ethereumType =>
-  ascTypeForProtocol('ethereum', ethereumType)
+const ascTypeForEthereum = ethereumType => ascTypeForProtocol('ethereum', ethereumType)
 
 const ethereumTypeForAsc = ascType =>
-  findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type'])
+  findConversionFromType('AssemblyScript', 'ethereum', ascType).to?.type
 
 const ethereumToAsc = (code, ethereumType, internalType) =>
-  findConversionFromType('ethereum', 'AssemblyScript', ethereumType).get('convert')(
+  findConversionFromType('ethereum', 'AssemblyScript', ethereumType).convert(
     code,
     internalType,
   )
 
 const ethereumFromAsc = (code, ethereumType) =>
-  findConversionToType('AssemblyScript', 'ethereum', ethereumType).get('convert')(code)
+  findConversionToType('AssemblyScript', 'ethereum', ethereumType).convert(code)
 
 const ascTypeForValue = valueType =>
-  findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type'])
+  findConversionFromType('Value', 'AssemblyScript', valueType).to?.type
 
 const valueTypeForAsc = ascType =>
-  findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type'])
+  findConversionFromType('AssemblyScript', 'Value', ascType).to?.type
 
 const valueToAsc = (code, valueType) =>
-  findConversionFromType('Value', 'AssemblyScript', valueType).get('convert')(code)
+  findConversionFromType('Value', 'AssemblyScript', valueType).convert(code)
 
 const valueFromAsc = (code, valueType) =>
-  findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code)
+  findConversionToType('AssemblyScript', 'Value', valueType).convert(code)
 
 module.exports = {
   // protocol <-> AssemblyScript

package/src/codegen/typescript.js

@@ -1,6 +1,3 @@
-let immutable = require('immutable')
-let Map = immutable.Map
-
 class Param {
   constructor(name, type) {
     this.name = name