@graphprotocol/graph-cli 0.25.2 → 0.26.1

package/src/codegen/schema.test.js

@@ -0,0 +1,362 @@
+const prettier = require('prettier')
+const graphql = require('graphql/language')
+const immutable = require('immutable')
+const SchemaCodeGenerator = require('./schema')
+const {
+  Class,
+  Method,
+  StaticMethod,
+  Param,
+  NamedType,
+  NullableType,
+  ArrayType,
+} = require('./typescript')
+
+const formatTS = code =>
+  prettier.format(
+    code,
+    { parser: 'typescript', semi: false }
+  )
+
+const createSchemaCodeGen = schema =>
+  new SchemaCodeGenerator({
+    ast: immutable.fromJS(graphql.parse(schema)),
+  })
+
+const testEntity = (generatedTypes, expectedEntity) => {
+  const entity = generatedTypes.find(type => type.name === expectedEntity.name)
+
+  expect(entity instanceof Class).toBe(true)
+  expect(entity.extends).toBe('Entity')
+  expect(entity.export).toBe(true)
+
+  const { members, methods } = entity
+
+  expect(members).toStrictEqual(expectedEntity.members)
+
+  for (const expectedMethod of expectedEntity.methods) {
+    const method = methods.find(method => method.name === expectedMethod.name)
+
+    expectedMethod.static
+      ? expect(method instanceof StaticMethod).toBe(true)
+      : expect(method instanceof Method).toBe(true)
+
+    expect(method.params).toStrictEqual(expectedMethod.params)
+    expect(method.returnType).toStrictEqual(expectedMethod.returnType)
+    expect(formatTS(method.body)).toBe(formatTS(expectedMethod.body))
+  }
+
+  expect(methods.length).toBe(expectedEntity.methods.length)
+}
+
+describe('Schema code generator', () => {
+  test('Should generate nothing for non entity types', () => {
+    const codegen = createSchemaCodeGen(`
+      type Foo {
+        foobar: Int
+      }
+
+      type Bar {
+        barfoo: Int
+      }
+    `)
+
+    expect(codegen.generateTypes().size).toBe(0)
+  })
+
+  describe('Should generate correct classes for each entity', () => {
+    const codegen = createSchemaCodeGen(`
+      # just to be sure nothing will be generated from non-entity types alongside regular ones
+      type Foo {
+        foobar: Int
+      }
+
+      type Account @entity {
+        id: ID!
+
+        # two non primitive types
+        description: String
+        name: String!
+
+        # two primitive types (i32)
+        age: Int
+        count: Int!
+
+        # derivedFrom
+        wallets: [Wallet!] @derivedFrom(field: "account")
+      }
+
+      type Wallet @entity {
+        id: ID!
+        amount: BigInt!
+        account: Account!
+      }
+    `)
+
+    const generatedTypes = codegen.generateTypes()
+
+    test('Foo is NOT an entity', () => {
+      const foo = generatedTypes.find(type => type.name === 'Foo')
+      expect(foo).toBe(undefined)
+      // Account and Wallet
+      expect(generatedTypes.size).toBe(2)
+    })
+
+    test('Account is an entity with the correct methods', () => {
+      testEntity(generatedTypes, {
+        name: 'Account',
+        members: [],
+        methods: [
+          {
+            name: 'constructor',
+            params: [new Param('id', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              super()
+              this.set('id', Value.fromString(id))
+            `,
+          },
+          {
+            name: 'save',
+            params: [],
+            returnType: new NamedType('void'),
+            body: `
+              let id = this.get('id')
+              assert(id != null, 'Cannot save Account entity without an ID')
+              if (id) {
+                assert(
+                  id.kind == ValueKind.STRING,
+                  'Cannot save Account entity with non-string ID. ' +
+                  'Considering using .toHex() to convert the "id" to a string.'
+                )
+                store.set('Account', id.toString(), this)
+              }
+            `,
+          },
+          {
+            name: 'load',
+            static: true,
+            params: [new Param('id', new NamedType('string'))],
+            returnType: new NullableType(new NamedType('Account')),
+            body: `
+              return changetype<Account | null>(store.get('Account', id))
+            `,
+          },
+          {
+            name: 'get id',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('id')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set id',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('id', Value.fromString(value))
+            `,
+          },
+          {
+            name: 'get description',
+            params: [],
+            returnType: new NullableType(new NamedType('string')),
+            body: `
+              let value = this.get('description')
+              if (!value || value.kind == ValueKind.NULL) {
+                return null
+              } else {
+                return value.toString()
+              }
+            `,
+          },
+          {
+            name: 'set description',
+            params: [new Param('value', new NullableType(new NamedType('string')))],
+            returnType: undefined,
+            body: `
+              if (!value) {
+                this.unset('description')
+              } else {
+                this.set('description', Value.fromString(<string>value))
+              }
+            `,
+          },
+          {
+            name: 'get name',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('name')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set name',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('name', Value.fromString(value))
+            `,
+          },
+          {
+            name: 'get age',
+            params: [],
+            returnType: new NamedType('i32'),
+            body: `
+              let value = this.get('age')
+              return value!.toI32()
+            `,
+          },
+          {
+            name: 'set age',
+            params: [new Param('value', new NamedType('i32'))],
+            returnType: undefined,
+            body: `
+              this.set('age', Value.fromI32(value))
+            `,
+          },
+          {
+            name: 'get count',
+            params: [],
+            returnType: new NamedType('i32'),
+            body: `
+              let value = this.get('count')
+              return value!.toI32()
+            `,
+          },
+          {
+            name: 'set count',
+            params: [new Param('value', new NamedType('i32'))],
+            returnType: undefined,
+            body: `
+              this.set('count', Value.fromI32(value))
+            `,
+          },
+          {
+            name: 'get wallets',
+            params: [],
+            returnType: new NullableType(new ArrayType(new NamedType('string'))),
+            body: `
+              let value = this.get('wallets')
+              if (!value || value.kind == ValueKind.NULL) {
+                return null
+              } else {
+                return value.toStringArray()
+              }
+            `,
+          },
+          {
+            name: 'set wallets',
+            params: [new Param('value', new NullableType(new ArrayType(new NamedType('string'))))],
+            returnType: undefined,
+            body: `
+              if (!value) {
+                this.unset('wallets')
+              } else {
+                this.set('wallets', Value.fromStringArray(<Array<string>>value))
+              }
+            `,
+          },
+        ],
+      })
+    })
+
+    test('Wallet is an entity with the correct methods', () => {
+      testEntity(generatedTypes, {
+        name: 'Wallet',
+        members: [],
+        methods: [
+          {
+            name: 'constructor',
+            params: [new Param('id', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              super()
+              this.set('id', Value.fromString(id))
+            `,
+          },
+          {
+            name: 'save',
+            params: [],
+            returnType: new NamedType('void'),
+            body: `
+              let id = this.get('id')
+              assert(id != null, 'Cannot save Wallet entity without an ID')
+              if (id) {
+                assert(
+                  id.kind == ValueKind.STRING,
+                  'Cannot save Wallet entity with non-string ID. ' +
+                  'Considering using .toHex() to convert the "id" to a string.'
+                )
+                store.set('Wallet', id.toString(), this)
+              }
+            `,
+          },
+          {
+            name: 'load',
+            static: true,
+            params: [new Param('id', new NamedType('string'))],
+            returnType: new NullableType(new NamedType('Wallet')),
+            body: `
+              return changetype<Wallet | null>(store.get('Wallet', id))
+            `,
+          },
+          {
+            name: 'get id',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('id')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set id',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('id', Value.fromString(value))
+            `,
+          },
+          {
+            name: 'get amount',
+            params: [],
+            returnType: new NamedType('BigInt'),
+            body: `
+              let value = this.get('amount')
+              return value!.toBigInt()
+            `,
+          },
+          {
+            name: 'set amount',
+            params: [new Param('value', new NamedType('BigInt'))],
+            returnType: undefined,
+            body: `
+              this.set('amount', Value.fromBigInt(value))
+            `,
+          },
+          {
+            name: 'get account',
+            params: [],
+            returnType: new NamedType('string'),
+            body: `
+              let value = this.get('account')
+              return value!.toString()
+            `,
+          },
+          {
+            name: 'set account',
+            params: [new Param('value', new NamedType('string'))],
+            returnType: undefined,
+            body: `
+              this.set('account', Value.fromString(value))
+            `,
+          },
+        ],
+      })
+    })
+  })
+})

package/src/codegen/types/conversions.js

@@ -188,28 +188,28 @@ const VALUE_TO_ASSEMBLYSCRIPT = [
 const ASSEMBLYSCRIPT_TO_VALUE = [
   // Arrays
 
-  ['Array<Address>', '[Bytes]', code => `Value.fromBytesArray(${code})`, 'new Array(0)'],
-  ['Array<Bytes>', '[Bytes]', code => `Value.fromBytesArray(${code})`, 'new Array(0)'],
-  ['Array<boolean>', '[Boolean]', code => `Value.fromBooleanArray(${code})`, 'new Array(0)'],
-  ['Array<i32>', '[Int]', code => `Value.fromI32Array(${code})`, 'new Array(0)'],
-  ['Array<BigInt>', '[BigInt]', code => `Value.fromBigIntArray(${code})`, 'new Array(0)'],
-  ['Array<string>', '[String]', code => `Value.fromStringArray(${code})`, 'new Array(0)'],
-  ['Array<string>', '[ID]', code => `Value.fromStringArray(${code})`, 'new Array(0)'],
-  ['Array<BigDecimal>', '[BigDecimal]', code => `Value.fromBigDecimalArray(${code})`, 'new Array(0)'],
-  ['Array<string>', /\[.*\]/, code => `Value.fromStringArray(${code})`, 'new Array(0)'],
-  ['Array<string | null>', null, code => `Value.fromStringArray(${code})`, 'new Array(0)'],
+  ['Array<Address>', '[Bytes]', code => `Value.fromBytesArray(${code})`],
+  ['Array<Bytes>', '[Bytes]', code => `Value.fromBytesArray(${code})`],
+  ['Array<boolean>', '[Boolean]', code => `Value.fromBooleanArray(${code})`],
+  ['Array<i32>', '[Int]', code => `Value.fromI32Array(${code})`],
+  ['Array<BigInt>', '[BigInt]', code => `Value.fromBigIntArray(${code})`],
+  ['Array<string>', '[String]', code => `Value.fromStringArray(${code})`],
+  ['Array<string>', '[ID]', code => `Value.fromStringArray(${code})`],
+  ['Array<BigDecimal>', '[BigDecimal]', code => `Value.fromBigDecimalArray(${code})`],
+  ['Array<string>', /\[.*\]/, code => `Value.fromStringArray(${code})`],
+  ['Array<string | null>', null, code => `Value.fromStringArray(${code})`],
 
   // Scalar values
 
-  ['Address', 'Bytes', code => `Value.fromBytes(${code})`, 'Address.zero()'],
-  ['Bytes', 'Bytes', code => `Value.fromBytes(${code})`, 'Bytes.empty()'],
-  ['boolean', 'Boolean', code => `Value.fromBoolean(${code})`, 'false'],
-  ['i32', 'Int', code => `Value.fromI32(${code})`, '0'],
-  ['BigInt', 'BigInt', code => `Value.fromBigInt(${code})`, 'BigInt.zero()'],
-  ['string', 'String', code => `Value.fromString(${code})`, "''"],
-  ['string', 'ID', code => `Value.fromString(${code})`, "''"],
-  ['BigDecimal', 'BigDecimal', code => `Value.fromBigDecimal(${code})`, 'BigDecimal.zero()'],
-  ['string', /.*/, code => `Value.fromString(${code})`, "''"],
+  ['Address', 'Bytes', code => `Value.fromBytes(${code})`],
+  ['Bytes', 'Bytes', code => `Value.fromBytes(${code})`],
+  ['boolean', 'Boolean', code => `Value.fromBoolean(${code})`],
+  ['i32', 'Int', code => `Value.fromI32(${code})`],
+  ['BigInt', 'BigInt', code => `Value.fromBigInt(${code})`],
+  ['string', 'String', code => `Value.fromString(${code})`],
+  ['string', 'ID', code => `Value.fromString(${code})`],
+  ['BigDecimal', 'BigDecimal', code => `Value.fromBigDecimal(${code})`],
+  ['string', /.*/, code => `Value.fromString(${code})`],
 ]
 
 /**

package/src/codegen/types/index.js

@@ -66,27 +66,6 @@ const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
   return objectifyConversion(fromTypeSystem, toTypeSystem, conversion)
 }
 
-const findInitializationForType = (fromTypeSystem, toTypeSystem, ascType) => {
-  const conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem)
-
-  const conversion = conversions.find(conversion =>
-    typeof conversion.get(0) === 'string'
-      ? conversion.get(0) === ascType
-      : ascType.match(conversion.get(0)),
-  )
-
-  if (conversion === undefined) {
-    throw new Error(
-      `Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
-        `target type '${ascType}' is not supported`,
-    )
-  }
-
-  const conversionObj = objectifyConversion(fromTypeSystem, toTypeSystem, conversion)
-
-  return conversionObj.get('convert')(conversion.get(3))
-}
-
 // High-level type system API
 
 const ascTypeForProtocol = (protocol, protocolType) =>
@@ -120,9 +99,6 @@ const valueToAsc = (code, valueType) =>
 const valueFromAsc = (code, valueType) =>
   findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code)
 
-const initializedValueFromAsc = ascType =>
-  findInitializationForType('AssemblyScript', 'Value', ascType)
-
 module.exports = {
   // protocol <-> AssemblyScript
   ascTypeForProtocol,
@@ -138,5 +114,4 @@ module.exports = {
   valueTypeForAsc,
   valueToAsc,
   valueFromAsc,
-  initializedValueFromAsc,
 }

package/src/codegen/types/index.test.js

@@ -449,26 +449,4 @@ describe('AssemblyScript -> Value', () => {
     expect(codegen.valueFromAsc('x', '[String]')).toBe('Value.fromStringArray(x)')
     expect(codegen.valueTypeForAsc('Array<string>')).toBe('[String]')
   })
-
-  describe('Initialization for zero/empty values', () => {
-    test('Array<string>', () => {
-      expect(codegen.initializedValueFromAsc('Array<string>')).toBe('Value.fromStringArray(new Array(0))')
-    })
-
-    test('Array<string | null>', () => {
-      expect(codegen.initializedValueFromAsc('Array<string | null>')).toBe('Value.fromStringArray(new Array(0))')
-    })
-
-    test('i32', () => {
-      expect(codegen.initializedValueFromAsc('i32')).toBe('Value.fromI32(0)')
-    })
-
-    test('string', () => {
-      expect(codegen.initializedValueFromAsc('string')).toBe("Value.fromString('')")
-    })
-
-    test('BigInt', () => {
-      expect(codegen.initializedValueFromAsc('BigInt')).toBe('Value.fromBigInt(BigInt.zero())')
-    })
-  })
 })

package/src/codegen/typescript.js

@@ -12,17 +12,6 @@ class Param {
   }
 }
 
-class ReturnType {
-  constructor(name, type) {
-    this.name = name
-    this.type = type
-  }
-
-  toString() {
-    return `${this.type.toString()}`
-  }
-}
-
 class Method {
   constructor(name, params, returnType, body) {
     this.name = name
@@ -185,8 +174,15 @@ const GENERATED_FILE_NOTE = `
 
 module.exports = {
   // Types
+  Param,
+  Method,
+  StaticMethod,
+  Class,
+  ClassMember,
+  NamedType,
   NullableType,
   ArrayType,
+  ModuleImports,
 
   // Code generators
   namedType,