@graphprotocol/graph-cli 0.37.3-alpha-20230113140856-3e7bd95 → 0.37.3

package/dist/codegen/types/conversions.js

@@ -1,335 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const immutable_1 = __importDefault(require("immutable"));
-/**
- * ethereum.Value -> AssemblyScript conversions
- */
-const ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT = [
-    // Scalar values
-    ['address', 'Address', (code) => `${code}.toAddress()`],
-    ['bool', 'boolean', (code) => `${code}.toBoolean()`],
-    ['byte', 'Bytes', (code) => `${code}.toBytes()`],
-    [
-        /^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)?$/,
-        'Bytes',
-        (code) => `${code}.toBytes()`,
-    ],
-    [/^int(8|16|24|32)$/, 'i32', (code) => `${code}.toI32()`],
-    [/^uint(8|16|24)$/, 'i32', (code) => `${code}.toI32()`],
-    ['uint32', 'BigInt', (code) => `${code}.toBigInt()`],
-    [
-        /^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)$/,
-        'BigInt',
-        (code) => `${code}.toBigInt()`,
-    ],
-    ['string', 'string', (code) => `${code}.toString()`],
-    // Arrays
-    [/^address\[([0-9]+)?\]$/, 'Array<Address>', (code) => `${code}.toAddressArray()`],
-    [/^bool\[([0-9]+)?\]$/, 'Array<boolean>', (code) => `${code}.toBooleanArray()`],
-    [/^byte\[([0-9]+)?\]$/, 'Array<Bytes>', (code) => `${code}.toBytesArray()`],
-    [
-        /^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]+)?\]$/,
-        'Array<Bytes>',
-        (code) => `${code}.toBytesArray()`,
-    ],
-    [/^int(8|16|24|32)\[([0-9]+)?\]$/, 'Array<i32>', (code) => `${code}.toI32Array()`],
-    [/^uint(8|16|24)\[([0-9]+)?\]$/, 'Array<i32>', (code) => `${code}.toI32Array()`],
-    [/^uint32\[([0-9]+)?\]$/, 'Array<BigInt>', (code) => `${code}.toBigIntArray()`],
-    [
-        /^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]+)?\]$/,
-        'Array<BigInt>',
-        (code) => `${code}.toBigIntArray()`,
-    ],
-    [/^string\[([0-9]+)?\]$/, 'Array<string>', (code) => `${code}.toStringArray()`],
-    // Tuples
-    ['tuple', 'ethereum.Tuple', (code) => `${code}.toTuple()`],
-    [
-        /^tuple\[([0-9]+)?\]$/,
-        'Array<ethereum.Tuple>',
-        (code, type) => `${code}.toTupleArray<${type}>()`,
-    ],
-    // 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()`,
-    ],
-    [
-        /^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()`,
-    ],
-    [
-        /^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()`,
-    ],
-    [
-        /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        'Array<Array<ethereum.Tuple>>',
-        (code, type) => `${code}.toTupleMatrix<${type}>()`,
-    ],
-];
-/**
- * AssemblyScript -> ethereum.Value conversions
- *
- * Note: The order and patterns for conversions in this direction differ slightly
- * from ethereum.Value -> AssemblyScript, which is why there is a separate table
- * for them.
- */
-const ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE = [
-    // Scalar values
-    ['Address', 'address', (code) => `ethereum.Value.fromAddress(${code})`],
-    ['boolean', 'bool', (code) => `ethereum.Value.fromBoolean(${code})`],
-    ['Bytes', 'byte', (code) => `ethereum.Value.fromFixedBytes(${code})`],
-    ['Bytes', 'bytes', (code) => `ethereum.Value.fromBytes(${code})`],
-    [
-        'Bytes',
-        /^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)$/,
-        (code) => `ethereum.Value.fromFixedBytes(${code})`,
-    ],
-    ['i32', /^int(8|16|24|32)$/, (code) => `ethereum.Value.fromI32(${code})`],
-    [
-        'i32',
-        /^uint(8|16|24)$/,
-        (code) => `ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(${code}))`,
-    ],
-    [
-        'BigInt',
-        /^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)$/,
-        (code) => `ethereum.Value.fromSignedBigInt(${code})`,
-    ],
-    [
-        'BigInt',
-        /^uint(32|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)$/,
-        (code) => `ethereum.Value.fromUnsignedBigInt(${code})`,
-    ],
-    ['string', 'string', (code) => `ethereum.Value.fromString(${code})`],
-    // Arrays
-    [
-        'Array<Address>',
-        /^address\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromAddressArray(${code})`,
-    ],
-    [
-        'Array<boolean>',
-        /^bool\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromBooleanArray(${code})`,
-    ],
-    [
-        'Array<Bytes>',
-        /^byte\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromFixedBytesArray(${code})`,
-    ],
-    ['Array<Bytes>', /bytes\[([0-9]+)?\]$/, (code) => `ethereum.Value.fromBytesArray(${code})`],
-    [
-        'Array<Bytes>',
-        /^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]+)?\]$/,
-        (code) => `ethereum.Value.fromFixedBytesArray(${code})`,
-    ],
-    [
-        'Array<i32>',
-        /^int(8|16|24|32)\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromI32Array(${code})`,
-    ],
-    [
-        'Array<i32>',
-        /^uint(8|16|24)\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromI32Array(${code})`,
-    ],
-    [
-        'Array<BigInt>',
-        /^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]+)?\]$/,
-        (code) => `ethereum.Value.fromSignedBigIntArray(${code})`,
-    ],
-    [
-        'Array<BigInt>',
-        /^uint(32|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]+)?\]$/,
-        (code) => `ethereum.Value.fromUnsignedBigIntArray(${code})`,
-    ],
-    [
-        'Array<string>',
-        /^string\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromStringArray(${code})`,
-    ],
-    // Tuples
-    ['ethereum.Tuple', 'tuple', (code) => `ethereum.Value.fromTuple(${code})`],
-    [
-        'Array<ethereum.Tuple>',
-        /^tuple\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromTupleArray(${code})`,
-    ],
-    // Multi dimentional arrays
-    [
-        'Array<Array<Address>>',
-        /^address\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromAddressMatrix(${code})`,
-    ],
-    [
-        'Array<Array<boolean>>',
-        /^bool\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromBooleanMatrix(${code})`,
-    ],
-    [
-        'Array<Array<Bytes>>',
-        /^byte\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromFixedBytesMatrix(${code})`,
-    ],
-    [
-        'Array<Array<Bytes>>',
-        /bytes\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromBytesMatrix(${code})`,
-    ],
-    [
-        'Array<Array<Bytes>>',
-        /^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]+)?\]$/,
-        (code) => `ethereum.Value.fromFixedBytesMatrix(${code})`,
-    ],
-    [
-        'Array<Array<i32>>',
-        /^int(8|16|24|32)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromI32Matrix(${code})`,
-    ],
-    [
-        'Array<Array<i32>>',
-        /^uint(8|16|24)\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromI32Matrix(${code})`,
-    ],
-    [
-        'Array<Array<BigInt>>',
-        /^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]+)?\]$/,
-        (code) => `ethereum.Value.fromSignedBigIntMatrix(${code})`,
-    ],
-    [
-        'Array<Array<BigInt>>',
-        /^uint(32|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]+)?\]$/,
-        (code) => `ethereum.Value.fromUnsignedBigIntMatrix(${code})`,
-    ],
-    [
-        'Array<Array<string>>',
-        /^string\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromStringMatrix(${code})`,
-    ],
-    [
-        'Array<Array<ethereum.Tuple>>',
-        /^tuple\[([0-9]+)?\]\[([0-9]+)?\]$/,
-        (code) => `ethereum.Value.fromTupleMatrix(${code})`,
-    ],
-];
-/**
- * Value -> AssemblyScript conversions
- */
-const VALUE_TO_ASSEMBLYSCRIPT = [
-    // Arrays
-    ['[Bytes]', 'Array<Bytes>', (code) => `${code}.toBytesArray()`],
-    ['[Boolean]', 'Array<boolean>', (code) => `${code}.toBooleanArray()`],
-    ['[Int]', 'Array<i32>', (code) => `${code}.toI32Array()`],
-    ['[BigInt]', 'Array<BigInt>', (code) => `${code}.toBigIntArray()`],
-    ['[ID]', 'Array<string>', (code) => `${code}.toStringArray()`],
-    ['[String]', 'Array<string>', (code) => `${code}.toStringArray()`],
-    ['[BigDecimal]', 'Array<BigDecimal>', (code) => `${code}.toBigDecimalArray()`],
-    [/\[.*\]/, 'Array<string>', (code) => `${code}.toStringArray()`],
-    // Scalar values
-    ['Bytes', 'Bytes', (code) => `${code}.toBytes()`],
-    ['Boolean', 'boolean', (code) => `${code}.toBoolean()`],
-    ['Int', 'i32', (code) => `${code}.toI32()`],
-    ['BigInt', 'BigInt', (code) => `${code}.toBigInt()`],
-    ['ID', 'string', (code) => `${code}.toString()`],
-    ['String', 'string', (code) => `${code}.toString()`],
-    ['BigDecimal', 'BigDecimal', (code) => `${code}.toBigDecimal()`],
-    [/.*/, 'string', (code) => `${code}.toString()`],
-];
-/**
- * AssemblyScript -> Value conversions
- *
- * Note: The order and patterns for conversions in this direction differ slightly
- * from Value -> AssemblyScript, which is why there is a separate table
- * for them.
- */
-const ASSEMBLYSCRIPT_TO_VALUE = [
-    // Matrices
-    ['Array<Array<Address>>', '[[Bytes]]', (code) => `Value.fromBytesMatrix(${code})`],
-    ['Array<Array<Bytes>>', '[[Bytes]]', (code) => `Value.fromBytesMatrix(${code})`],
-    ['Array<Array<boolean>>', '[[Boolean]]', (code) => `Value.fromBooleanMatrix(${code})`],
-    ['Array<Array<i32>>', '[[Int]]', (code) => `Value.fromI32Matrix(${code})`],
-    ['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<string>>', /\[\[.*\]\]/, (code) => `Value.fromStringMatrix(${code})`],
-    ['Array<Array<string | null>>', null, (code) => `Value.fromStringMatrix(${code})`],
-    // Arrays
-    ['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})`],
-    ['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})`],
-];
-const CONVERSIONS = {
-    ethereum: {
-        AssemblyScript: ETHEREUM_VALUE_TO_ASSEMBLYSCRIPT,
-    },
-    AssemblyScript: {
-        ethereum: ASSEMBLYSCRIPT_TO_ETHEREUM_VALUE,
-        Value: ASSEMBLYSCRIPT_TO_VALUE,
-    },
-    Value: {
-        AssemblyScript: VALUE_TO_ASSEMBLYSCRIPT,
-    },
-};
-/**
- * Type conversions
- */
-exports.default = immutable_1.default.fromJS(CONVERSIONS);

package/dist/codegen/types/index.js

@@ -1,71 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.valueFromAsc = exports.valueToAsc = exports.valueTypeForAsc = exports.ascTypeForValue = exports.ethereumFromAsc = exports.ethereumToAsc = exports.ethereumTypeForAsc = exports.ascTypeForEthereum = exports.ascTypeForProtocol = void 0;
-const immutable_1 = __importDefault(require("immutable"));
-const conversions_1 = __importDefault(require("./conversions"));
-// Conversion utilities
-const conversionsForTypeSystems = (fromTypeSystem, toTypeSystem) => {
-    const conversions = conversions_1.default.getIn([fromTypeSystem, toTypeSystem]);
-    if (conversions === undefined) {
-        throw new Error(`Conversions from '${fromTypeSystem}' to '${toTypeSystem}' are not supported`);
-    }
-    return conversions;
-};
-const objectifyConversion = (fromTypeSystem, toTypeSystem, conversion) => {
-    return immutable_1.default.fromJS({
-        from: {
-            typeSystem: fromTypeSystem,
-            type: conversion.get(0),
-        },
-        to: {
-            typeSystem: toTypeSystem,
-            type: conversion.get(1),
-        },
-        convert: conversion.get(2),
-    });
-};
-const findConversionFromType = (fromTypeSystem, toTypeSystem, fromType) => {
-    const conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
-    const conversion = conversions.find(conversion => typeof conversion.get(0) === 'string'
-        ? conversion.get(0) === fromType
-        : !!fromType.match(conversion.get(0)));
-    if (conversion === undefined) {
-        throw new Error(`Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
-            `source type '${fromType}' is not supported`);
-    }
-    return objectifyConversion(fromTypeSystem, toTypeSystem, conversion);
-};
-const findConversionToType = (fromTypeSystem, toTypeSystem, toType) => {
-    const conversions = conversionsForTypeSystems(fromTypeSystem, toTypeSystem);
-    const conversion = conversions.find(conversion => typeof conversion.get(1) === 'string'
-        ? conversion.get(1) === toType
-        : !!toType.match(conversion.get(1)));
-    if (conversion === undefined) {
-        throw new Error(`Conversion from '${fromTypeSystem}' to '${toTypeSystem}' for ` +
-            `target type '${toType}' is not supported`);
-    }
-    return objectifyConversion(fromTypeSystem, toTypeSystem, conversion);
-};
-// High-level type system API
-const ascTypeForProtocol = (protocol, protocolType) => findConversionFromType(protocol, 'AssemblyScript', protocolType).getIn(['to', 'type']);
-exports.ascTypeForProtocol = ascTypeForProtocol;
-// TODO: this can be removed/replaced by the function above
-const ascTypeForEthereum = (ethereumType) => (0, exports.ascTypeForProtocol)('ethereum', ethereumType);
-exports.ascTypeForEthereum = ascTypeForEthereum;
-const ethereumTypeForAsc = (ascType) => findConversionFromType('AssemblyScript', 'ethereum', ascType).getIn(['to', 'type']);
-exports.ethereumTypeForAsc = ethereumTypeForAsc;
-const ethereumToAsc = (code, ethereumType, internalType) => findConversionFromType('ethereum', 'AssemblyScript', ethereumType).get('convert')(code, internalType);
-exports.ethereumToAsc = ethereumToAsc;
-const ethereumFromAsc = (code, ethereumType) => findConversionToType('AssemblyScript', 'ethereum', ethereumType).get('convert')(code);
-exports.ethereumFromAsc = ethereumFromAsc;
-const ascTypeForValue = (valueType) => findConversionFromType('Value', 'AssemblyScript', valueType).getIn(['to', 'type']);
-exports.ascTypeForValue = ascTypeForValue;
-const valueTypeForAsc = (ascType) => findConversionFromType('AssemblyScript', 'Value', ascType).getIn(['to', 'type']);
-exports.valueTypeForAsc = valueTypeForAsc;
-const valueToAsc = (code, valueType) => findConversionFromType('Value', 'AssemblyScript', valueType).get('convert')(code);
-exports.valueToAsc = valueToAsc;
-const valueFromAsc = (code, valueType) => findConversionToType('AssemblyScript', 'Value', valueType).get('convert')(code);
-exports.valueFromAsc = valueFromAsc;