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

package/CHANGELOG.md

@@ -1,11 +1,10 @@
 # @graphprotocol/graph-cli
 
-## 0.37.2-alpha-20221219142030-0cf2a37
+## 0.37.2
 
 ### 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`)
+- [#1023](https://github.com/graphprotocol/graph-cli/pull/1023) [`bf5ab6d`](https://github.com/graphprotocol/graph-cli/commit/bf5ab6dc0f19fcb5b8e599b7d9b1c2b6efcbe005) Thanks [@evaporei](https://github.com/evaporei)! - update graph-ts to 0.29.1
 
 ## 0.37.1
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.37.2-alpha-20221219142030-0cf2a37",
+  "version": "0.37.2",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
   "dependencies": {
@@ -16,6 +16,7 @@
     "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,21 +1,25 @@
+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.type?.type?.name?.value
-    this.kind = typeName === 'Bytes' ? IdField.BYTES : IdField.STRING
+    const typeName = idField.getIn(['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() {
@@ -23,28 +27,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.name?.value === 'id')
+    const idField = fields.find(field => field.getIn(['name', 'value']) === 'id')
     return new IdField(idField)
   }
 
   static fromTypeDef(def) {
-    return IdField.fromFields(def.fields)
+    return IdField.fromFields(def.get("fields"))
   }
 }
 
@@ -77,26 +81,29 @@ module.exports = class SchemaCodeGenerator {
   }
 
   generateTypes() {
-    return this.schema.ast.definitions
+    return this.schema.ast
+      .get('definitions')
       .filter(def => this._isEntityTypeDefinition(def))
       .map(def => this._generateEntityType(def))
   }
 
   _isEntityTypeDefinition(def) {
     return (
-      def.kind === 'ObjectTypeDefinition' &&
-      def.directives.find(directive => directive.name?.value === 'entity') !== undefined
+      def.get('kind') === 'ObjectTypeDefinition' &&
+      def
+        .get('directives')
+        .find(directive => directive.getIn(['name', 'value']) === 'entity') !== undefined
     )
   }
 
   _isInterfaceDefinition(def) {
-    return def.kind === 'InterfaceTypeDefinition'
+    return def.get('kind') === 'InterfaceTypeDefinition'
   }
 
   _generateEntityType(def) {
-    let name = def.name?.value
+    let name = def.getIn(['name', 'value'])
     let klass = tsCodegen.klass(name, { export: true, extends: 'Entity' })
-    const fields = def.fields
+    const fields = def.get('fields')
     const idField = IdField.fromFields(fields)
 
     // Generate and add a constructor
@@ -106,10 +113,11 @@ module.exports = class SchemaCodeGenerator {
     this._generateStoreMethods(name, idField).forEach(method => klass.addMethod(method))
 
     // Generate and add entity field getters and setters
-    def.fields
+    def
+      .get('fields')
       .reduce(
         (methods, field) => methods.concat(this._generateEntityFieldMethods(def, field)),
-        [],
+        List(),
       )
       .forEach(method => klass.addMethod(method))
 
@@ -130,7 +138,7 @@ module.exports = class SchemaCodeGenerator {
   }
 
   _generateStoreMethods(entityName, idField) {
-    return [
+    return List.of(
       tsCodegen.method(
         'save',
         [],
@@ -154,19 +162,19 @@ module.exports = class SchemaCodeGenerator {
         return changetype<${entityName} | null>(store.get('${entityName}', ${idField.tsToString()}))
         `,
       ),
-    ]
+    )
   }
 
   _generateEntityFieldMethods(entityDef, fieldDef) {
-    return [
+    return List([
       this._generateEntityFieldGetter(entityDef, fieldDef),
       this._generateEntityFieldSetter(entityDef, fieldDef),
-    ]
+    ])
   }
 
   _generateEntityFieldGetter(entityDef, fieldDef) {
-    let name = fieldDef.name?.value
-    let gqlType = fieldDef.type
+    let name = fieldDef.getIn(['name', 'value'])
+    let gqlType = fieldDef.get('type')
     let fieldValueType = this._valueTypeFromGraphQl(gqlType)
     let returnType = this._typeFromGraphQl(gqlType)
     let isNullable = returnType instanceof tsCodegen.NullableType
@@ -190,21 +198,25 @@ module.exports = class SchemaCodeGenerator {
   }
 
   _generateEntityFieldSetter(entityDef, fieldDef) {
-    let name = fieldDef.name?.value
-    let gqlType = fieldDef.type
+    let name = fieldDef.getIn(['name', 'value'])
+    let gqlType = fieldDef.get('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 = `
@@ -230,15 +242,12 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
   }
 
   _resolveFieldType(gqlType) {
-    let typeName = gqlType.name?.value
+    let typeName = gqlType.getIn(['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.definitions.find(
-      def =>
-        (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
-        def.name?.value === typeName,
-    )
+    const typeDef = this.schema.ast.get("definitions").
+      find(def => (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) && def.getIn(["name", "value"]) === typeName)
     if (typeDef) {
       return IdField.fromTypeDef(typeDef).typeName()
     } else {
@@ -251,10 +260,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.kind === 'NonNullType') {
-      return this._valueTypeFromGraphQl(gqlType.type, false)
-    } else if (gqlType.kind === 'ListType') {
-      return '[' + this._valueTypeFromGraphQl(gqlType.type) + ']'
+    if (gqlType.get('kind') === 'NonNullType') {
+      return this._valueTypeFromGraphQl(gqlType.get('type'), false)
+    } else if (gqlType.get('kind') === 'ListType') {
+      return '[' + this._valueTypeFromGraphQl(gqlType.get('type')) + ']'
     } else {
       return this._resolveFieldType(gqlType)
     }
@@ -263,20 +272,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.kind === 'NonNullType') {
-      return this._baseType(gqlType.type)
-    } else if (gqlType.kind === 'ListType') {
-      return this._baseType(gqlType.type)
+    if (gqlType.get('kind') === 'NonNullType') {
+      return this._baseType(gqlType.get('type'))
+    } else if (gqlType.get('kind') === 'ListType') {
+      return this._baseType(gqlType.get('type'))
     } else {
-      return gqlType.name?.value
+      return gqlType.getIn(['name', 'value'])
     }
   }
 
   _typeFromGraphQl(gqlType, nullable = true) {
-    if (gqlType.kind === 'NonNullType') {
-      return this._typeFromGraphQl(gqlType.type, false)
-    } else if (gqlType.kind === 'ListType') {
-      let type = tsCodegen.arrayType(this._typeFromGraphQl(gqlType.type))
+    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')))
       return nullable ? tsCodegen.nullableType(type) : type
     } else {
       // NamedType

package/src/codegen/schema.test.js

@@ -1,5 +1,6 @@
 const prettier = require('prettier')
 const graphql = require('graphql/language')
+const immutable = require('immutable')
 const SchemaCodeGenerator = require('./schema')
 const {
   Class,
@@ -11,11 +12,15 @@ 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: graphql.parse(schema),
+    ast: immutable.fromJS(graphql.parse(schema)),
   })
 
 const testEntity = (generatedTypes, expectedEntity) => {
@@ -56,7 +61,7 @@ describe('Schema code generator', () => {
       }
     `)
 
-    expect(codegen.generateTypes().length).toBe(0)
+    expect(codegen.generateTypes().size).toBe(0)
   })
 
   describe('Should generate correct classes for each entity', () => {
@@ -94,7 +99,7 @@ describe('Schema code generator', () => {
       const foo = generatedTypes.find(type => type.name === 'Foo')
       expect(foo).toBe(undefined)
       // Account and Wallet
-      expect(generatedTypes.length).toBe(2)
+      expect(generatedTypes.size).toBe(2)
     })
 
     test('Account is an entity with the correct methods', () => {
@@ -243,12 +248,7 @@ 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,21 +377,20 @@ 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" +
@@ -399,67 +398,63 @@ 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,3 +1,4 @@
+const immutable = require('immutable')
 const IpfsFileTemplateCodeGen = require('../protocols/ipfs/codegen/file_template')
 
 const tsCodegen = require('./typescript')
@@ -28,7 +29,7 @@ module.exports = class DataSourceTemplateCodeGenerator {
   }
 
   generateTypes() {
-    return [this._generateTemplateType()]
+    return immutable.List([this._generateTemplateType()])
   }
 
   _generateTemplateType() {

package/src/codegen/types/conversions.js

@@ -1,3 +1,5 @@
+const immutable = require('immutable')
+
 /**
  * ethereum.Value -> AssemblyScript conversions
  */
@@ -53,56 +55,29 @@ 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}>()`,
   ],
+
 ]
 
 /**
@@ -203,7 +178,7 @@ const ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE = [
     /^tuple\[([0-9]+)?\]$/,
     code => `ethereum.Value.fromTupleArray(${code})`,
   ],
-
+  
   // Multi dimentional arrays
 
   [
@@ -307,13 +282,9 @@ 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
 
@@ -344,7 +315,7 @@ const ASSEMBLYSCRIPT_TO_VALUE = [
 /**
  * Type conversions
  */
-module.exports = Object.freeze({
+module.exports = immutable.fromJS({
   ethereum: {
     AssemblyScript: ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT,
   },

package/src/codegen/types/index.js

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

package/src/codegen/typescript.js

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