@graphprotocol/graph-cli 0.37.2 → 0.37.3-alpha-20230110163550-d64bef6

package/dist/validation/schema.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("./schema");
+describe('Schema validation', () => {
+    test('Type suggestions', () => {
+        expect((0, schema_1.typeSuggestion)('Address')).toEqual('Bytes');
+        expect((0, schema_1.typeSuggestion)('address')).toEqual('Bytes');
+        expect((0, schema_1.typeSuggestion)('bytes')).toEqual('Bytes');
+        expect((0, schema_1.typeSuggestion)('string')).toEqual('String');
+        expect((0, schema_1.typeSuggestion)('bool')).toEqual('Boolean');
+        expect((0, schema_1.typeSuggestion)('boolean')).toEqual('Boolean');
+        expect((0, schema_1.typeSuggestion)('float')).toEqual('BigDecimal');
+        expect((0, schema_1.typeSuggestion)('Float')).toEqual('BigDecimal');
+        expect((0, schema_1.typeSuggestion)(`int`)).toBe('Int');
+        expect((0, schema_1.typeSuggestion)(`uint`)).toBe('BigInt');
+        expect((0, schema_1.typeSuggestion)(`uint32`)).toBe('BigInt');
+        // Test i8..i32, int8..int32
+        for (let i = 8; i <= 32; i += 8) {
+            expect((0, schema_1.typeSuggestion)(`i${i}`)).toBe('Int');
+            expect((0, schema_1.typeSuggestion)(`int${i}`)).toBe('Int');
+        }
+        // Test u8..u24, uint8..uint24
+        for (let i = 8; i <= 24; i += 8) {
+            expect((0, schema_1.typeSuggestion)(`u${i}`)).toBe('Int');
+            expect((0, schema_1.typeSuggestion)(`uint${i}`)).toBe('Int');
+        }
+        // Test i40..i256, int40..int256, u40..u256, uint40..uint256
+        for (let i = 40; i <= 256; i += 8) {
+            expect((0, schema_1.typeSuggestion)(`i${i}`)).toBe('BigInt');
+            expect((0, schema_1.typeSuggestion)(`int${i}`)).toBe('BigInt');
+            expect((0, schema_1.typeSuggestion)(`u${i}`)).toBe('BigInt');
+            expect((0, schema_1.typeSuggestion)(`uint${i}`)).toBe('BigInt');
+        }
+    });
+});

package/dist/watcher.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chokidar_1 = __importDefault(require("chokidar"));
+const path_1 = __importDefault(require("path"));
+class Watcher {
+    onReady;
+    onTrigger;
+    onCollectFiles;
+    onError;
+    watcher;
+    constructor(options) {
+        const { onReady, onTrigger, onCollectFiles, onError } = options;
+        this.onReady = onReady;
+        this.onTrigger = onTrigger;
+        this.onCollectFiles = onCollectFiles;
+        this.onError = onError;
+    }
+    async watch() {
+        // Collect files to watch
+        let files = await this.onCollectFiles();
+        // Initialize watcher
+        this.watcher = chokidar_1.default.watch(files, {
+            persistent: true,
+            ignoreInitial: true,
+            atomic: 500,
+        });
+        // Bind variables locally
+        let watcher = this.watcher;
+        let onTrigger = this.onTrigger;
+        let onCollectFiles = this.onCollectFiles;
+        let onError = this.onError;
+        let onReady = this.onReady;
+        watcher.on('ready', async () => {
+            // Notify listeners that we're watching
+            onReady();
+            // Trigger once when ready
+            await onTrigger(undefined);
+        });
+        watcher.on('error', (error) => {
+            onError(error);
+        });
+        watcher.on('all', async (_, file) => {
+            try {
+                // Collect watch all new files to watch
+                let newFiles = await onCollectFiles();
+                // Collect watched files, if there are any
+                let watchedFiles = [];
+                let watched = watcher.getWatched();
+                watchedFiles = Object.keys(watched).reduce((files, dirname) => watched[dirname].reduce((files, filename) => {
+                    files.push(path_1.default.resolve(path_1.default.join(dirname, filename)));
+                    return files;
+                }, files), []);
+                let diff = (xs, ys) => ({
+                    added: ys.filter((y) => xs.indexOf(y) < 0),
+                    removed: xs.filter((x) => ys.indexOf(x) < 0),
+                });
+                // Diff previously watched files and new files; then remove and
+                // add files from/to the watcher accordingly
+                let filesDiff = diff(watchedFiles, newFiles);
+                watcher.unwatch(filesDiff.removed);
+                watcher.add(filesDiff.added);
+                // Run the trigger callback
+                await onTrigger(file);
+            }
+            catch (e) {
+                onError(e);
+            }
+        });
+    }
+    close() {
+        if (this.watcher !== undefined) {
+            this.watcher.close();
+        }
+    }
+}
+exports.default = Watcher;

package/jest.config.js

@@ -136,7 +136,7 @@ module.exports = {
   testMatch: ['**/?(*.)+(spec|test).js?(x)'],
 
   // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
-  testPathIgnorePatterns: ['/src/commands/test.js', '/node_modules/'],
+  testPathIgnorePatterns: ['/src/commands/test.js', '/node_modules/', '/dist/'],
 
   // The regexp pattern Jest uses to detect test files
   // testRegex: "",

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "@graphprotocol/graph-cli",
-  "version": "0.37.2",
+  "version": "0.37.3-alpha-20230110163550-d64bef6",
   "license": "(Apache-2.0 OR MIT)",
   "description": "CLI for building for and deploying to The Graph",
+  "main": "dist/cli.js",
+  "bin": {
+    "graph": "dist/bin.js"
+  },
   "dependencies": {
+    "@float-capital/float-subgraph-uncrashable": "^0.0.0-alpha.4",
     "assemblyscript": "0.19.23",
     "binary-install-raw": "0.0.13",
     "chalk": "3.0.0",
@@ -11,12 +16,11 @@
     "debug": "4.3.1",
     "docker-compose": "0.23.4",
     "dockerode": "2.5.8",
-    "@float-capital/float-subgraph-uncrashable": "^0.0.0-alpha.4",
     "fs-extra": "9.0.0",
     "glob": "7.1.6",
     "gluegun": "https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep",
     "graphql": "15.5.0",
-    "immutable": "3.8.2",
+    "immutable": "4.2.1",
     "ipfs-http-client": "34.0.0",
     "jayson": "3.6.6",
     "js-yaml": "3.13.1",
@@ -31,15 +35,16 @@
     "which": "2.0.2",
     "yaml": "1.9.2"
   },
-  "bin": {
-    "graph": "bin/graph"
-  },
   "devDependencies": {
-    "eslint": "6.8.0",
+    "@types/debug": "^4.1.7",
+    "@types/fs-extra": "^9.0.13",
+    "@types/which": "^2.0.1",
+    "copyfiles": "^2.4.1",
     "jest": "26.0.0",
     "spawn-command": "0.0.2-1",
     "strip-ansi": "6.0.0",
-    "tern": "0.24.3"
+    "tern": "0.24.3",
+    "typescript": "^4.9.4"
   },
   "publishConfig": {
     "access": "public"
@@ -47,6 +52,8 @@
   "scripts": {
     "test": "jest --verbose",
     "test:init": "jest tests/cli/init.test.js --verbose",
-    "test:validation": "jest tests/cli/validation.test.js --verbose"
+    "test:validation": "jest tests/cli/validation.test.js --verbose",
+    "type-check": "tsc --noEmit",
+    "build": "tsc --build && copyfiles -u 1 src/**/*.graphql dist/ && chmod +x ./dist/bin.js"
   }
 }

package/{bin/graph → src/bin.ts}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
 
 // run the CLI with the current process arguments
-require('../src/cli').run(process.argv)
+import { run } from './cli'
+run(process.argv)

package/src/cli.ts

@@ -0,0 +1,36 @@
+import path from 'path'
+import { build, system } from 'gluegun'
+
+const run = async (argv: string[]) => {
+  let builder = build()
+    .brand('graph')
+    .src(__dirname)
+
+  const pluginDirs: string[] = []
+  await Promise.all(
+    ['npm root -g', 'npm root', 'yarn global dir'].map(async cmd => {
+      try {
+        const dir = await system.run(cmd, { trim: true })
+        pluginDirs.push(dir)
+      } catch (_) {
+        // noop
+      }
+    }),
+  )
+
+  // Inject potential plugin directories
+  builder = pluginDirs.reduce(
+    (cli, dir) => cli.plugin(path.join(dir, '@graphprotocol', 'indexer-cli', 'dist')),
+    builder,
+  )
+
+  const cli = builder
+    .help()
+    .version()
+    .defaultCommand()
+    .create()
+
+  return await cli.run(argv)
+}
+
+export { run }

package/src/codegen/schema.js

@@ -1,25 +1,25 @@
-const immutable = require('immutable')
+import immutable from 'immutable'
 
-const tsCodegen = require('./typescript')
-const typesCodegen = require('./types')
+import * as tsCodegen from './typescript'
+import * as typesCodegen from './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
+    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,19 +27,19 @@ 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) {
@@ -48,11 +48,11 @@ class IdField {
   }
 
   static fromTypeDef(def) {
-    return IdField.fromFields(def.get("fields"))
+    return IdField.fromFields(def.get('fields'))
   }
 }
 
-module.exports = class SchemaCodeGenerator {
+export default class SchemaCodeGenerator {
   constructor(schema) {
     this.schema = schema
   }
@@ -206,17 +206,13 @@ module.exports = class SchemaCodeGenerator {
     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 = `
@@ -246,8 +242,13 @@ Suggestion: add an '!' to the member type of the List, change from '[${baseType}
 
     // 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
+      .get('definitions')
+      .find(
+        def =>
+          (this._isEntityTypeDefinition(def) || this._isInterfaceDefinition(def)) &&
+          def.getIn(['name', 'value']) === typeName,
+      )
     if (typeDef) {
       return IdField.fromTypeDef(typeDef).typeName()
     } else {

package/src/codegen/schema.test.js

@@ -1,7 +1,7 @@
-const prettier = require('prettier')
-const graphql = require('graphql/language')
-const immutable = require('immutable')
-const SchemaCodeGenerator = require('./schema')
+import prettier from 'prettier'
+import * as graphql from 'graphql/language'
+import immutable from 'immutable'
+import SchemaCodeGenerator from './schema'
 const {
   Class,
   Method,
@@ -12,11 +12,7 @@ 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({
@@ -248,7 +244,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 +378,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 +400,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 → template.ts}

@@ -1,16 +1,18 @@
-const immutable = require('immutable')
-const IpfsFileTemplateCodeGen = require('../protocols/ipfs/codegen/file_template')
+import immutable from 'immutable'
+import IpfsFileTemplateCodeGen from '../protocols/ipfs/codegen/file_template'
 
-const tsCodegen = require('./typescript')
+import * as tsCodegen from './typescript'
 
-module.exports = class DataSourceTemplateCodeGenerator {
-  constructor(template, protocol) {
+export default class DataSourceTemplateCodeGenerator {
+  template: any
+  protocolTemplateCodeGen: any
+  constructor(template: any, protocol: any) {
     this.template = template
     let kind = template.get('kind')
 
     if (kind.split('/')[0] == protocol.name) {
       this.protocolTemplateCodeGen = protocol.getTemplateCodeGen(template)
-    } else if (kind == "file/ipfs") {
+    } else if (kind == 'file/ipfs') {
       this.protocolTemplateCodeGen = new IpfsFileTemplateCodeGen(template)
     }
   }