असेंबलीस्क्रिप्ट माइग्रेशन गाइड

अब तक, सबग्राफ ने AssemblyScript के शुरुआती संस्करणों⁠ में से एक (v0.6) का उपयोग किया है। आखिरकार, हमने नवीनतम उपलब्ध संस्करण⁠(v0.19.10) के लिए समर्थन जोड़ दिया है! 🎉

यह सबग्राफ डेवलपर्स को AS भाषा और स्टैंडर्ड लाइब्रेरी की नई विशेषताओं का उपयोग करने में सक्षम बनाएगा।

यह मार्गदर्शक उन सभी लोगों के लिए लागू है जो graph-cli/graph-ts का संस्करण 0.22.0 से कम उपयोग कर रहे हैं। यदि आप पहले से ही इस संस्करण (या उससे उच्च) पर हैं, तो आप पहले से ही AssemblyScript के संस्करण 0.19.10 का उपयोग कर रहे हैं 🙂

विशेषताएँ

नई कार्यक्षमता

• TypedArray को अब ArrayBuffer से बनाया जा सकता है नए wrap static method ⁠का उपयोग करके ([v0.8.1] (https://github.com/AssemblyScript/assemblyscript/releases/tag/v0.8.1))।⁠
• नई मानक लाइब्रेरी फ़ंक्शन: String#toUpperCase, String#toLowerCase, String#localeCompare और TypedArray#set (v0.9.0⁠)
• GenericClass के लिए x instanceof समर्थन जोड़ा गया (v0.9.2⁠)
• StaticArray<T> जो एक अधिक कुशल array प्रकार है, जोड़ा गया (v0.9.3⁠)
• Array<T>#flat जोड़ा गया (v0.10.0⁠)
• Number#toString पर radix आर्गुमेंट लागू किया (v0.10.1⁠)
• फ्लोटिंग पॉइंट लिटरल्स में सेपरेटर्स के लिए समर्थन जोड़ा गया (v0.13.7⁠)
• पहली श्रेणी के फ़ंक्शन्स के लिए समर्थन जोड़ा गया (v0.14.0⁠)
• बिल्ट-इन जोड़ें: i32/i64/f32/f64.add/sub/mul (v0.14.13⁠)
• Array/TypedArray/String#at को लागू करें (v0.18.2⁠)
• टेम्पलेट लिटरल स्ट्रिंग्स के लिए सपोर्ट जोड़ा गया (v0.18.17⁠)
• encodeURI(Component) और decodeURI(Component) को जोड़ा गया (v0.18.27⁠)
• toString, toDateString और toTimeString को Date में जोड़ें (v0.18.29⁠)
• toUTCString के लिए Date में जोड़ें (v0.18.30⁠)
• nonnull/NonNullable बिल्ट-इन टाइप जोड़ा गया (v0.19.2⁠)

अनुकूलन

• Math फ़ंक्शंस जैसे कि exp, exp2, log, log2 और pow को तेज़ वेरिएंट्स से बदल दिया गया है (v0.9.0⁠)
• थोड़ा ऑप्टिमाइज़ करें Math.mod (v0.17.1⁠)
• स्टैंडर्ड मैप और सेट में अधिक फ़ील्ड एक्सेस कैश करें (v0.17.8⁠)
• ipow32/64(v0.18.2⁠) में दो के शक्तियों के लिए अनुकूलित करें

अन्य

• एक एरे लिटरल के प्रकार को अब इसकी सामग्री से अनुमानित किया जा सकता है (v0.9.0⁠)
• Updated stdlib को Unicode 13.0.0 में अपडेट किया गया (v0.10.0⁠)

कैसे करें अपग्रेड?

1. अपनी subgraph.yaml फ़ाइल में apiVersion को 0.0.9 में बदलें:

1...2dataSources:3  ...4    mapping:5      ...6      apiVersion: 0.0.97      ...

2. आप जो graph-cli उपयोग कर रहे हैं, उसे latest संस्करण में अपडेट करने के लिए यह चलाएँ:

1# if you have it globally installed2npm install --global @graphprotocol/graph-cli@latest34# or in your subgraph if you have it as a dev dependency5npm install --save-dev @graphprotocol/graph-cli@latest

3. यह वही करें graph-ts, लेकिन इसे ग्लोबली इंस्टॉल करने के बजाय, इसे अपनी मुख्य निर्भरताओं में सेव करें:

1npm install --save @graphprotocol/graph-ts@latest

4. भाषा संबंधी परिवर्तनों को ठीक करने के लिए शेष मार्गदर्शिका का पालन करें।
5. codegen और deploy को फिर से चलाएं।

ब्रेकिंग परिवर्तन

Nullability

असेंबलीस्क्रिप्ट के पुराने संस्करण पर, आप इस तरह कोड बना सकते हैं:

1function load(): Value | null { ... }23let maybeValue = load();4maybeValue.aMethod();

हालाँकि नए संस्करण पर, क्योंकि मान अशक्त है, इसके लिए आपको जाँच करने की आवश्यकता है, जैसे:

1let maybeValue = load()23if (maybeValue) {4  maybeValue.aMethod() // `maybeValue` is not null anymore5}

या इसे इस तरह मजबूर करें:

1let maybeValue = load()! // breaks in runtime if value is null23maybeValue.aMethod()

अगर आपको यकीन नहीं है कि किसे चुनना है, तो हम हमेशा सुरक्षित संस्करण का उपयोग करने की सलाह देते हैं। यदि मान मौजूद नहीं है, तो आप अपने सबग्राफ के handler में एक प्रारंभिक if स्टेटमेंट के साथ return का उपयोग कर सकते हैं।

Variable Shadowing

पहले आप variable shadowing⁠ कर सकते थे और कोड इस तरह काम करता था:

1let a = 102let b = 203let a = a + b

हालाँकि अब यह संभव नहीं है, और संकलक इस त्रुटि को लौटाता है:

1ERROR TS2451: Cannot redeclare block-scoped variable 'a'23 let a = a + b;4 ~~~~~~~~~~~~~5in assembly/index.ts(4,3)

यदि आपके पास वेरिएबल शैडोइंग है, तो आपको अपने डुप्लिकेट वेरिएबल्स का नाम बदलने की आवश्यकता होगी।

Null Comparisons

अपने सबग्राफ को अपग्रेड करने पर, कभी-कभी आपको ऐसे त्रुटियाँ मिल सकती हैं:

1ERROR TS2322: Type '~lib/@graphprotocol/graph-ts/common/numbers/BigInt | null' is not assignable to type '~lib/@graphprotocol/graph-ts/common/numbers/BigInt'.2     if (decimals == null) {3                     ~~~~4 in src/mappings/file.ts(41,21)

समस्या को हल करने के लिए आप बस if स्टेटमेंट को इस प्रकार बदल सकते हैं:

1if (!decimals) {23  // or45  if (decimals === null) {

यदि आप == के बजाय != कर रहे हैं तो वही लागू होता है।

कास्टिंग

पहले कास्टिंग करने का सामान्य तरीका as कीवर्ड का उपयोग करना था, जैसे कि इस प्रकार:

1let byteArray = new ByteArray(10)2let uint8Array = byteArray as Uint8Array // इसका समकक्ष: <Uint8Array>byteArray

However this only works in two scenarios:

• प्रिमिटिव कास्टिंग (जैसे u8, i32, bool प्रकारों के बीच; उदाहरण के लिए: let b: isize = 10; b as usize);
• क्लास इनहेरिटेंस (सबक्लास → सुपरक्लास) पर अपकास्टिंग

उदाहरण:

1// primitive casting2let a: usize = 103let b: isize = 54let c: usize = a + (b as usize)

1// क्लास इनहेरिटेंस पर उपकास्टिंग2class Bytes extends Uint8Array {}34let bytes = new Bytes(2)5// <Uint8Array>bytes // यह समान है: bytes as Uint8Array

यहां दो परिदृश्य हैं जहाँ आप कास्ट करना चाह सकते हैं, लेकिन as/<T>var का उपयोग सुरक्षित नहीं है:

• क्लास इनहेरिटेंस (सुपरक्लास → सबक्लास) पर डाउनकास्टिंग
• एक सुपरक्लास साझा करने वाले दो प्रकारों के बीच

1// क्लास इनहेरिटेंस में डाउनकास्टिंग2class Bytes extends Uint8Array {}34let uint8Array = new Uint8Array(2)5// <Bytes>uint8Array // रनटाइम में ब्रेक हो जाता है :(

1// दो प्रकारों के बीच जो एक superclass साझा करते हैं2class Bytes extends Uint8Array {}3class ByteArray extends Uint8Array {}45let bytes = new Bytes(2)6// <ByteArray>bytes // रनटाइम में टूट जाता है :(

ऐसे मामलों के लिए, आप changetype<T> फ़ंक्शन का उपयोग कर सकते हैं:

1// क्लास इनहेरिटेंस पर डाउनकास्टिंग2class Bytes extends Uint8Array {}34let uint8Array = new Uint8Array(2)5changetype<Bytes>(uint8Array) // काम करता है :)

1// दो प्रकारों के बीच जो एक सुपरक्लास साझा करते हैं2class Bytes extends Uint8Array {}3class ByteArray extends Uint8Array {}45let bytes = new Bytes(2)6changetype<ByteArray>(bytes) // काम करता है :)

यदि आप केवल nullability को हटाना चाहते हैं, तो आप as ऑपरेटर (या <T>variable) का उपयोग जारी रख सकते हैं, लेकिन यह सुनिश्चित करें कि आपको पता है कि वह मान null नहीं हो सकता है, अन्यथा यह टूट जाएगा।

1// remove nullability2let previousBalance = AccountBalance.load(balanceId) // AccountBalance | null34if (previousBalance != null) {5  return previousBalance as AccountBalance // safe remove null6}78let newBalance = new AccountBalance(balanceId)

nullability के मामले में, हम सुझाव देते हैं कि आप nullability check विशेषता⁠ पर एक नज़र डालें, यह आपकी कोड को अधिक साफ-सुथरा बना देगा 🙂

साथ ही, हमने कास्टिंग को आसान बनाने के लिए कुछ प्रकारों में कुछ और स्थैतिक विधियाँ जोड़ी हैं, वे हैं:

• Bytes.fromByteArray
• Bytes.fromUint8Array
• BigInt.fromByteArray
• ByteArray.fromBigInt

Nullability check with property access

nullability check विशेषता⁠ का उपयोग करने के लिए, आप या तो if स्टेटमेंट्स का उपयोग कर सकते हैं या टर्नरी ऑपरेटर (? और :) का उपयोग कर सकते हैं, इस प्रकार:

1let something: string | null = 'data'23let somethingOrElse = something ? something : 'else'45// or67let somethingOrElse89if (something) {10  somethingOrElse = something11} else {12  somethingOrElse = 'else'13}

हालांकि, यह केवल तब काम करता है जब आप किसी वेरिएबल पर if / टर्नरी का उपयोग कर रहे हों, न कि किसी प्रॉपर्टी एक्सेस पर, जैसे:

1class Container {2  data: string | null3}45let container = new Container()6container.data = 'data'78let somethingOrElse: string = container.data ? container.data : 'else' // doesn't compile

जो इस त्रुटि को आउटपुट करता है:

1ERROR TS2322: Type '~lib/string/String | null' is not assignable to type '~lib/string/String'.23   let somethingOrElse: string = container.data ? container.data : "else";

इस समस्या को ठीक करने के लिए, आप उस प्रॉपर्टी एक्सेस के लिए एक वेरिएबल बना सकते हैं ताकि कंपाइलर अशक्तता जांच जादू कर सके:

1class Container {2  data: string | null3}45let container = new Container()6container.data = 'data'78let data = container.data910let somethingOrElse: string = data ? data : 'else' // compiles just fine :)

प्रॉपर्टी एक्सेस के साथ ऑपरेटर ओवरलोडिंग

यदि आप एक अशक्त प्रकार के साथ एक अशक्त प्रकार (एक संपत्ति के उपयोग से) का योग करने की कोशिश करते हैं, तो असेंबलीस्क्रिप्ट कंपाइलर एक संकलन समय त्रुटि चेतावनी देने के बजाय यह चेतावनी देता है कि मानों में से एक अशक्त है, यह सिर्फ चुपचाप संकलित करता है, मौका देता है कोड रनटाइम पर टूटने के लिए।

1class BigInt extends Uint8Array {2  @operator('+')3  plus(other: BigInt): BigInt {4    // ...5  }6}78class Wrapper {9  public constructor(public n: BigInt | null) {}10}1112let x = BigInt.fromI32(2)13let y: BigInt | null = null1415x + y // give compile time error about nullability1617let wrapper = new Wrapper(y)1819wrapper.n = wrapper.n + x // doesn't give compile time errors as it should

हमने इस मुद्दे को AssemblyScript compiler पर खोला है, लेकिन अभी के लिए, यदि आप अपनी सबग्राफ mappings में इस प्रकार के संचालन कर रहे हैं, तो आपको इसके पहले एक null जांच करनी चाहिए।

1let wrapper = new Wrapper(y)23if (!wrapper.n) {4  wrapper.n = BigInt.fromI32(0)5}67wrapper.n = wrapper.n + x // now `n` is guaranteed to be a BigInt

मूल्य आरंभीकरण

यदि आपके पास ऐसा कोई कोड है:

1var value: Type // null2value.x = 103value.y = 'content'

यह संकलित हो जाएगा लेकिन रनटाइम पर टूट जाएगा, क्योंकि मान प्रारंभ नहीं किया गया है। इसलिए सुनिश्चित करें कि आपका सबग्राफ ने अपने मानों को प्रारंभ किया है, इस प्रकार:

1var value = new Type() // initialized2value.x = 103value.y = 'content'

इसके अलावा, यदि आपके पास एक ग्राफक्यूएल इकाई में अशक्त गुण हैं, जैसे:

1type Total @entity {2  id: Bytes!3  amount: BigInt4}

और आपके पास इसके समान कोड है:

1let total = Total.load('latest')23if (total === null) {4  total = new Total('latest')5}67total.amount = total.amount + BigInt.fromI32(1)

आपको यह सुनिश्चित करना होगा कि total.amount मान को प्रारंभिक रूप से सेट किया जाए, क्योंकि यदि आप इसे अंतिम पंक्ति में जोड़ने के लिए एक्सेस करने का प्रयास करेंगे, तो यह क्रैश हो जाएगा। तो आपको इसे पहले प्रारंभिक रूप से सेट करना होगा।

1let total = Total.load('latest')23if (total === null) {4  total = new Total('latest')5  total.amount = BigInt.fromI32(0)6}78total.tokens = total.tokens + BigInt.fromI32(1)

या आप अपनी GraphQL स्कीमा को इस प्रॉपर्टी के लिए nullable टाइप का उपयोग न करने के लिए बदल सकते हैं, फिर हम इसे codegen स्टेप में शून्य के रूप में इनिशियलाइज करेंगे 😉

1type Total @entity {2  id: Bytes!3  amount: BigInt!4}

1let total = Total.load('latest')23if (total === null) {4  total = new Total('latest') // already initializes non-nullable properties5}67total.amount = total.amount + BigInt.fromI32(1)

क्लास प्रॉपर्टी इनिशियलाइज़ेशन

यदि आप किसी भी वर्ग को गुणों के साथ निर्यात करते हैं जो अन्य वर्ग हैं (आपके द्वारा या मानक पुस्तकालय द्वारा घोषित) इस तरह:

1class Thing {}23export class Something {4  value: Thing5}

कंपाइलर में त्रुटि होगी क्योंकि आपको उन गुणों के लिए या तो एक प्रारंभिक मान जोड़ने की आवश्यकता है जो कक्षाएँ हैं, या ! ऑपरेटर जोड़ने की आवश्यकता है।

1export class Something {2  constructor(public value: Thing) {}3}45// or67export class Something {8  value: Thing910  constructor(value: Thing) {11    this.value = value12  }13}1415// or1617export class Something {18  value!: Thing19}

सरणी आरंभीकरण

Array क्लास अभी भी एक नंबर स्वीकार करता है जिससे सूची की लंबाई को प्रारंभिक रूप से सेट किया जा सकता है, हालांकि आपको सावधानी बरतनी चाहिए क्योंकि .push जैसी ऑपरेशन्स वास्तव में आकार बढ़ा देंगी बजाय इसके कि वे शुरुआत में जोड़ें, उदाहरण के लिए:

1let arr = new Array<string>(5) // ["", "", "", "", ""]23arr.push('something') // ["", "", "", "", "", "something"] // आकार 6 :(

आपके द्वारा उपयोग किए जा रहे प्रकारों के आधार पर, उदाहरण के लिए अशक्त वाले, और आप उन्हें कैसे एक्सेस कर रहे हैं, आपको इस तरह की रनटाइम त्रुटि का सामना करना पड़ सकता है:

1ERRO handler निष्पादन विफलता के कारण छोड़ दिया गया, त्रुटि: ~lib/array.ts, पंक्ति 110, कॉलम 40 पर मानचित्रण बंद कर दी गई, संदेश के साथ: यदि एरे में छेद हो तो तत्व प्रकार को नल होना चाहिए wasm बैकट्रेस: 0: 0x19c4 - <unknown>!~lib/@graphprotocol/graph-ts/index/format 1: 0x1e75 - <unknown>!~lib/@graphprotocol/graph-ts/common/collections/Entity#constructor 2: 0x30b9 - <unknown>!node_modules/@graphprotocol/graph-ts/global/global/id_of_type

शुरुआत में वास्तव में पुश करने के लिए, आपको Array को शून्य आकार के साथ इस प्रकार प्रारंभ करना चाहिए:

1let arr = new Array<string>(0) // []23arr.push('something') // ["something"]

या आपको इसे इंडेक्स के माध्यम से बदलना चाहिए:

1let arr = new Array<string>(5) // ["", "", "", "", ""]23arr[0] = 'something' // ["something", "", "", "", ""]

ग्राफक्यूएल स्कीमा

यह एक सीधे AssemblyScript में परिवर्तन नहीं है, लेकिन आपको अपनी schema.graphql फ़ाइल को अपडेट करना पड़ सकता है।

अब आप अपने प्रकारों में उन क्षेत्रों को परिभाषित नहीं कर सकते हैं जो गैर-शून्य सूची हैं। यदि आपके पास ऐसा स्कीमा है:

1type Something @entity {2  id: Bytes!3}45type MyEntity @entity {6  id: Bytes!7  invalidField: [Something]! # no longer valid8}

आपको List प्रकार के सदस्य में ! जोड़ना होगा, इस तरह:

1type Something @entity {2  id: Bytes!3}45type MyEntity @entity {6  id: Bytes!7  invalidField: [Something!]! # valid8}

यह AssemblyScript संस्करणों के बीच nullability अंतर के कारण बदला, और यह src/generated/schema.ts फ़ाइल से संबंधित है (डिफ़ॉल्ट पथ, आप इसे बदल सकते हैं)।

अन्य

• स्पेसिफिकेशन के साथ Map#set और Set#add को संरेखित किया गया, जो this को लौटाता है (v0.9.2⁠)
• ऐरे अब ArrayBufferView से विरासत में नहीं मिलते हैं, बल्कि अब वे अलग हैं (v0.10.0⁠)
• वस्तु साहित्य से प्रारंभ की गई कक्षाएँ अब एक निर्माता (constructor) परिभाषित नहीं कर सकतीं (v0.10.0⁠)
• ** बाइनरी ऑपरेशन का परिणाम अब सामान्य हरियाली पूर्णांक होता है यदि दोनों ऑपरेन्ड पूर्णांक होते हैं। पहले, परिणाम एक फ्लोट होता था जैसे कि Math/f.pow को कॉल करते समय (v0.11.0⁠)
• NaN को false में बदलें जब bool में कास्ट किया जाए (v0.14.9⁠)
• जब एक छोटे पूर्णांक मान को i8/u8 या i16/u16 प्रकार में शिफ्ट किया जाता है, तो केवल RHS मान के 3 या 4 सबसे कम महत्वपूर्ण बिट्स परिणाम को प्रभावित करते हैं, जैसे कि i32.shl के परिणाम को केवल RHS मान के 5 सबसे कम महत्वपूर्ण बिट्स द्वारा प्रभावित किया जाता है। उदाहरण: someI8 << 8 पहले 0 मान उत्पन्न करता था, लेकिन अब someI8 उत्पन्न करता है क्योंकि RHS को मास्क किया गया है जैसा कि 8 & 7 = 0 (3 बिट्स) (v0.17.0⁠)
• वर्शन (v0.17.8⁠) में आकारों के भिन्न होने पर संबंधी स्ट्रिंग तुलना में बग सुधार