Advanced Guides
Cara Tingkatkan Kode Cloud dengan Parse Server 3.1

24min
Lebih banyak kekuatan untuk Aplikasi Anda dengan Parse Server 3.1
Pendahuluan
Komunitas Parse baru-baru ini merilis versi 3.1 dari Parse Server. Pembaruan ini telah membersihkan sintaks Cloud Code: jauh lebih mudah untuk memanfaatkan konstruk es6 async dan await.
Selain itu, beberapa keanehan yang terkait dengan penggunaan Parse telah dihapus, misalnya, fungsi Cloud cukup mengembalikan Promise daripada menggunakan error atau success pesan pada objek Response.
Anda dapat memperbarui aplikasi Anda di Back4App dengan mudah di Dasbor Anda. Panduan ini akan menunjukkan cara memperbarui kode Anda untuk memanfaatkan fitur baru dari 3.1.
Untuk mengikuti panduan ini, Anda dipersilakan untuk melihat proyek contoh yang disediakan.
Ini adalah tutorial tamu yang ditulis oleh John Considine, pengembang utama di K-Optional.
Tujuan
Untuk memperbarui Parse Server Back4App Anda ke 3.1 dan memigrasikan Cloud Code Anda sesuai.
Prasyarat
Untuk menyelesaikan tutorial ini, Anda perlu:

° Aplikasi Back4App yang sudah ada yang menggunakan Parse Server 2.x
         °    Ikuti tutorial Membuat Aplikasi Baru untuk belajar cara membuat aplikasi di Back4App.
Ringkasan perubahan
Perubahan yang paling mencolok adalah sebagai berikut:
Cloud Code berjalan dengan Parse-SDK 2.x. 
Sebelumnya, Cloud Code berjalan dengan Parse-SDK 1.x. Dengan Parse Server 3.1, ia berjalan dengan Parse-SDK 2.x.
Lihat di rilis Parse SDK untuk memahami lebih baik apa yang dimaksud. Peningkatan versi utama ini sebagian besar melibatkan perbaikan bug. Ini juga menambahkan containedBy dan includeAll metode query, serta kemampuan untuk mengambil objek dengan includes.
Pembaruan agregat
Sejak Parse 2.7.1, Anda dapat menggunakan agregat metode pada query. Ini memungkinkan Anda untuk memanfaatkan database yang mendasarinya sedikit lebih banyak. Sekarang, sintaks untuk metode agregat pada Parse.Query telah diperbarui.
Anda dapat mengeksekusi query menggunakan dua tahap: cocok dan grup tahap.
  // mencocokkan pengguna yang namanya Foo, dan mengelompokkan berdasarkan objectId mereka
  const pipeline = [{ group: { objectId: {} } }, { match: { name: 'Foo' } }];
3
  var query = new Parse.Query("Person");
  query.aggregate(pipeline)
Sebelumnya, Anda tidak perlu kunci pipeline dalam objek pipeline. Karena API yang mendasarinya, Anda sekarang harus secara eksplisit menyertakan kunci pipeline. Nilainya harus berupa array dari satu atau dua tahap, yang menampilkan group dan match.
Lihat di Dokumentasi Resmi Parse untuk contoh yang lebih spesifik.
Optimisasi di balik layar
Beberapa optimisasi di balik layar telah dilakukan. Misalnya, sebuah Parse LiveQuery akan mengambil Izin Tingkat Kelas (CLP) bersama dengan data untuk mencegah akses database ganda.
Email Reset Parse
Saat meminta email reset kata sandi, server akan mengembalikan keberhasilan meskipun email tersebut tidak disimpan. Selain itu, token reset kata sandi akan kedaluwarsa ketika email pengguna direset.
Pembaruan pemicu cloud
Dengan rilis ini, Anda dapat berbagi data antara beforeSave dan afterSave pemicu pada objek yang sama. Misalnya:
JS
  Parse.Cloud.beforeSave('Comment', async request => {
    request.context = {
      foo: 'bar'
    };
  });
6
  Parse.Cloud.afterSave('Comment', async request => {
    console.log(request.context.foo); //Bar
  });
  Parse.Cloud.beforeSave('Comment', async request => {
    request.context = {
      foo: 'bar'
    };
  });
6
  Parse.Cloud.afterSave('Comment', async request => {
    console.log(request.context.foo); //Bar
  });
﻿
Anda dapat melihat lebih banyak tentang perubahan di Parse Server dalam Changelog resmi Parse 3.1 dengan mengklik di sini.
Peningkatan LiveQuery
Klien Parse LiveQuery memungkinkan Anda untuk berlangganan pada kueri, dan menerima pembaruan dari server saat mereka datang. Kueri Tradisional dieksekusi sekali oleh klien, jadi ini sangat membantu untuk kasus seperti pengiriman pesan, dll.
Dengan Back4App Anda juga bisa memanfaatkan teknologi ini.
Dengan rilis 3.x, komunitas Parse telah meningkatkan sistem untuk LiveQuery ACLs.
Anda sekarang dapat melewatkan token sesi ke metode subscribe dari query langsung, dan Parse Server akan mengelola hanya mengembalikan hasil yang dapat diakses oleh pengguna ini. Misalnya, seorang pengguna mungkin memiliki akses baca/tulis ke ‘Pesan’ tertentu, tetapi tidak semua.
JS
 let query = new Parse.Query('Message');
 // you can get session token with
 // Parse.User.current().getSessionToken() when logged in
 let subscription = client.subscribe(query, sessionToken); 
 let query = new Parse.Query('Message');
 // you can get session token with
 // Parse.User.current().getSessionToken() when logged in
 let subscription = client.subscribe(query, sessionToken); 
﻿
Kode di atas akan secara otomatis berlangganan ke semua pesan yang dapat diakses oleh pengguna, membebaskan Anda dari tanggung jawab untuk men-query pesan tertentu.
Bagian utama dari perubahan berkaitan dengan bagaimana Cloud Code ditangani. Untuk ini, lihat panduan migrasi di bawah.
- Menyelaraskan dasar teknis
Kami akan memulai dengan contoh proyek cloud menggunakan rilis 2.x. Dengan cara itu kami dapat menavigasi melalui perubahan sintaks yang sesuai. Anda dapat melihat repositori untuk proyek contoh ini.
Jika Anda sudah familiar dengan async dan await, Anda dapat melewati bagian ini.
Evolusi kode asinkron dalam Javascript terlihat seperti ini:
﻿Fungsi Callback﻿
﻿Janji﻿
﻿Async / Await﻿
Setiap aplikasi Javascript modern kemungkinan besar akan menggunakan ketiga hal ini. Fungsi callback melibatkan pengiriman sebuah fungsi sebagai argumen ke fungsi lain. Fungsi kedua ini dapat mengeksekusi yang pertama pada suatu titik.
JS
 // Callbacks:
 // executes callback function after waiting 100 milliseconds
 setTimeout(function() {
   alert('My callback function');
 }, 100);
 // Callbacks:
 // executes callback function after waiting 100 milliseconds
 setTimeout(function() {
   alert('My callback function');
 }, 100);
﻿
Callback sangat penting tetapi bisa menjadi rumit ketika harus menghubungkan banyak di antaranya. Secara khusus, menumpuk beberapa lapisan bisa sulit dibaca, dan penanganan kesalahan terbukti sulit. Oleh karena itu, di ES2015 Promise diperkenalkan.
JS
 // promises
 // executes several promises in a row with no significant nesting
 const myPromise = new Promise(function(resolve, reject) {
   setTimeout(function() {
      if (Math.random() < 0.2) reject(new Error('Random failure!'));
      resolve('Finished');
   }, 100);
 });
9
// Executes this promise 4 times and catches errors involved
myPromise
  .then(() => myPromise)
  .then(() => myPromise)
  .then(() => myPromise)
  .then(() => myPromise)
  .catch(e => console.log(e));
 // promises
 // executes several promises in a row with no significant nesting
 const myPromise = new Promise(function(resolve, reject) {
   setTimeout(function() {
      if (Math.random() < 0.2) reject(new Error('Random failure!'));
      resolve('Finished');
   }, 100);
 });
9
// Executes this promise 4 times and catches errors involved
myPromise
  .then(() => myPromise)
  .then(() => myPromise)
  .then(() => myPromise)
  .then(() => myPromise)
  .catch(e => console.log(e));
﻿
Janji meningkatkan keterbacaan pemrograman asinkron. Mereka juga membuat alur kerja lebih eksplisit. Tetapi langkah yang lebih besar diambil di ES2017 dengan konstruksi async / await. Kode Anda sekarang dapat menunggu hasil dari sebuah Janji tanpa bergantung pada blok then / catch (yang juga bisa menjadi sulit dibaca). 
JS
 // Using the definition of myPromise from the above code:
 async function foo() {
   try {
     let result = await myPromise;
     result = await myPromise;
     result = await myPromise;
   } catch (e) {
     console.log(e);
   }
}
 // Using the definition of myPromise from the above code:
 async function foo() {
   try {
     let result = await myPromise;
     result = await myPromise;
     result = await myPromise;
   } catch (e) {
     console.log(e);
   }
}
﻿
Mungkin untuk contoh yang sangat sederhana, ini mungkin tidak terlihat lebih elegan daripada janji biasa. Tetapi menunggu hasil dari fungsi asinkron sering kali adalah apa yang ingin kita lakukan. Oleh karena itu, ini benar-benar mengoptimalkan keterbacaan kode kita.
Dukungan untuk async/await
Seperti yang telah disebutkan, async/await dimasukkan dalam spesifikasi ECMAScript 2017 (es8). Untuk kode server, versi tidak menjadi masalah karena Anda dapat memperbarui ke versi Node.js yang mendukung fitur ini. Yakinlah, lingkungan Back4App mendukung versi stabil terbaru. Untuk kode browser, transpiler seperti Babel akan menghasilkan es2016 yang kompatibel dengan kode yang menggunakan async / await dan berfungsi di browser modern.
- Memikirkan tentang kode Anda dengan cara yang berbeda
Perubahan utama dengan Cloud Code melibatkan apa yang dilakukan pengembang versus apa yang dilakukan pustaka. Sebelumnya, Anda akan secara eksplisit mengelola respons. Karena sebagian besar Cloud Code akan dieksekusi secara asinkron - melakukan kueri dan penulisan database - lebih masuk akal untuk mengembalikan Promise, mengurangi kode boilerplate.
Intuisi di balik fungsi Cloud adalah bahwa ada pengaturan dan konfigurasi minimal yang terlibat dalam menulis kode sisi server. Rilis ini mewujudkan ide itu; ingatlah ini saat Anda melakukan refactoring dan membuat fungsi baru.
Untuk menunjukkan bagaimana fungsi Cloud Code bekerja di Parse Server 3.1, kami menulis ulang contoh Cloud Code fungsional dari versi Parse Server sebelum migrasi. Anda dapat menemukan kode ini dengan mengklik di sini. Fungsi Cloud Code yang sama ditulis di Parse 3.1 seperti yang ditunjukkan di bawah.
JS
 // Cloud Code BEFORE migration
 // Full code found in link above
 const POST = 'Post';
 Parse.Cloud.define('posts:get', function(request, response) {
   // needs a post ID
   return new Parse.Query(POST)
     .get(request.params.id, { useMasterKey: true })
     .then(post => {
       response.success(post);
    })
    .catch(e => {
      response.error({ message: e.message });
    });
});
 // Cloud Code BEFORE migration
 // Full code found in link above
 const POST = 'Post';
 Parse.Cloud.define('posts:get', function(request, response) {
   // needs a post ID
   return new Parse.Query(POST)
     .get(request.params.id, { useMasterKey: true })
     .then(post => {
       response.success(post);
    })
    .catch(e => {
      response.error({ message: e.message });
    });
});
﻿
- Menambahkan semua penanda async
Setiap fungsi yang menggunakan await harus dideklarasikan dengan modifier async. Refactoring sederhana ini akan melampirkan async ke semua Cloud Functions. Ini juga akan menggantinya dengan fungsi panah karena mereka lebih ringkas dalam kasus ini (dan apa yang digunakan oleh panduan resmi Parse yang diperbarui).
JS
 // Snippet of step 2 code refactoring. See full code
 //  here in the link at the top of this step
 const POST = 'Post';
 const COMMENT = 'Comment';
5
 Parse.Cloud.define('posts:get', async (request) => {
   // Needs a post ID
   return new Parse.Query(POST)
     .get(request.params.id, { useMasterKey: true });
}    
 // Snippet of step 2 code refactoring. See full code
 //  here in the link at the top of this step
 const POST = 'Post';
 const COMMENT = 'Comment';
5
 Parse.Cloud.define('posts:get', async (request) => {
   // Needs a post ID
   return new Parse.Query(POST)
     .get(request.params.id, { useMasterKey: true });
}    
﻿
Kode Anda akan terlihat seperti ini setelah refactoring ini
Tidak ada yang gila sejauh ini. Di langkah berikutnya, kita akan mendapatkan nilai uang kita untuk perubahan ini.
- Menghapus referensi ke respons, menggunakan await
Kode Anda akan terlihat seperti ini setelah refactoring ini
Langkah ini sedikit lebih rumit. Kita perlu:
Hapus semua referensi ke variabel ‘response’, kembalikan sebuah promise sebagai gantinya
Dalam kasus beberapa fungsi query/simpan, tunggu responsenya
Periksa metode pembuatan komentar untuk melihat bagaimana ini dilakukan
JS
 // Snippet of step 3 code refactoring. See full code
 //  here in the link at the top of this step
 Parse.Cloud.define('comment:create', async request => {
   // Post should have text and should have a user and a post id
   if (!request.user) {
     throw new Error('unauthenticated!');
   }
8
   if (!request.params.text) {
    throw new Error('A comment needs text!');
  }
  if (!request.params.post_id) {
    throw new Error('A comment needs a post!');
  }
15
  //   Get the post
17
  const post = await new Parse.Query(POST).get(request.params.post_id, {
    useMasterKey: true
  });
  return new Parse.Object(COMMENT, {
    text: request.params.text,
    user: request.user,
    post: post
  }).save(null, { useMasterKey: true });
});
 // Snippet of step 3 code refactoring. See full code
 //  here in the link at the top of this step
 Parse.Cloud.define('comment:create', async request => {
   // Post should have text and should have a user and a post id
   if (!request.user) {
     throw new Error('unauthenticated!');
   }
8
   if (!request.params.text) {
    throw new Error('A comment needs text!');
  }
  if (!request.params.post_id) {
    throw new Error('A comment needs a post!');
  }
15
  //   Get the post
17
  const post = await new Parse.Query(POST).get(request.params.post_id, {
    useMasterKey: true
  });
  return new Parse.Object(COMMENT, {
    text: request.params.text,
    user: request.user,
    post: post
  }).save(null, { useMasterKey: true });
});
﻿
Perhatikan bahwa:

Sekarang sebuah Kesalahan JavaScript dilemparkan alih-alih memanggil response.error. Parse akan menangani mengubah ini menjadi respons untuk kita.
Menghapus ‘Post’ atau ‘Komentar’ melibatkan mengambil objek terlebih dahulu, kemudian menghancurkannya. Dengan menggunakan ‘await’, metode hancurkan dapat mengakses objek yang disimpan di luar blok.
Itu menyelesaikan semua refactoring yang diperlukan untuk migrasi. Artinya, jika Anda melakukan hingga Langkah ini, selamat! Kode Anda akan berjalan di Back4App Parse 3.1!
- Trik Lanjutan (opsional)
Perubahan berikut bersifat opsional tetapi dapat memperpendek kode Anda secara signifikan. Saya menemukan bahwa mereka mengurangi boilerplate.
Anda mungkin telah memperhatikan banyak pemeriksaan manual untuk parameter atau pengguna yang terautentikasi. Ini memastikan bahwa perilaku aneh tidak terjadi. Misalnya, kami telah memutuskan bahwa objek ‘Post’ kami membutuhkan teks, jadi jika tidak ada parameter ‘teks’ yang diteruskan, objek akan disimpan tanpa itu. Salah satu cara untuk mencegah ini adalah dengan memeriksa bahwa teks telah diteruskan.
Tetapi pemeriksaan manual bisa memakan waktu dan tidak elegan. Di bagian ini, kami memanfaatkan destructuring objek untuk menyelesaikan pemeriksaan ini secara implisit.
Anda harus melihat dokumentasi di atas jika Anda tidak tahu apa itu destructuring. Tetapi secara singkat, ini memungkinkan Anda mengubah properti objek menjadi variabel dengan sintaks yang sangat ringkas.
JS
 // This
 var obj = {
   hi: true,
   bye: false
 };
 var hi = obj.hi;
 var bye = obj.bye;
8
 // Is equivalent to this:
var obj = {
  hi: true,
  bye: false
};
var { hi, bye } = obj;
15
console.log(hi);
// true
console.log(bye);
// false
 // This
 var obj = {
   hi: true,
   bye: false
 };
 var hi = obj.hi;
 var bye = obj.bye;
8
 // Is equivalent to this:
var obj = {
  hi: true,
  bye: false
};
var { hi, bye } = obj;
15
console.log(hi);
// true
console.log(bye);
// false
﻿
Destructuring lebih ringkas daripada penugasan manual. Ini juga memungkinkan Anda untuk mendeklarasikan variabel parameter secara langsung, yang sangat baik:
JS
 Parse.Cloud.define('posts:get', async ({ params: { id } }) => {
   // id is declared
 });
 Parse.Cloud.define('posts:get', async ({ params: { id } }) => {
   // id is declared
 });
﻿
Ketika digabungkan dengan notasi es2015 untuk inisialisasi objek kita dapat mengoptimalkan pemeriksaan parameter kita.
Kita bisa melakukan ini:
JS
 // Iterates through object's keys. Makes sure, for each key, the value is set
 const AssertParams = parameter_obj => {
   for (var key of Object.keys(parameter_obj)) {
     if (typeof parameter_obj[key] === 'undefined')
       throw new Error(`Missing parameter ${key}`);
   }
 };
8
 var obj = {
  hi: true,
  bye: false
};
var { hi, undef, bye } = obj; // undef will be undefined
var check_1 = { hi, bye };
var check_2 = { hi, undef };
16
// check = { hi : true, no : undefined }
AssertParams(check_1); // passes
AssertParams(check_2); // throws error
 // Iterates through object's keys. Makes sure, for each key, the value is set
 const AssertParams = parameter_obj => {
   for (var key of Object.keys(parameter_obj)) {
     if (typeof parameter_obj[key] === 'undefined')
       throw new Error(`Missing parameter ${key}`);
   }
 };
8
 var obj = {
  hi: true,
  bye: false
};
var { hi, undef, bye } = obj; // undef will be undefined
var check_1 = { hi, bye };
var check_2 = { hi, undef };
16
// check = { hi : true, no : undefined }
AssertParams(check_1); // passes
AssertParams(check_2); // throws error
﻿
Jadi untuk kode Parse kami, kami bisa melakukan ini:
JS
 // Snippet of advanced code refactoring. See full code
 //  here in the link at the top of this step
 Parse.Cloud.define('posts:delete', async ({ user, params: { id } }) => {
   // Makes sure user is authenticated, and id parameter is passed
   AssertParams({ user, id });
   const post = await new Parse.Query(POST).get(id, {
     useMasterKey: true
   });
   return post.destroy({ useMasterKey: true });
});
 // Snippet of advanced code refactoring. See full code
 //  here in the link at the top of this step
 Parse.Cloud.define('posts:delete', async ({ user, params: { id } }) => {
   // Makes sure user is authenticated, and id parameter is passed
   AssertParams({ user, id });
   const post = await new Parse.Query(POST).get(id, {
     useMasterKey: true
   });
   return post.destroy({ useMasterKey: true });
});
﻿
Jika ini terasa menakutkan, jangan khawatir. kode lengkap contoh ini mungkin membantu.
Singkatnya, ‘AssertParams’ adalah fungsi utilitas untuk melempar kesalahan jika sebuah nilai tidak terdefinisi. Kami dapat memeriksa parameter dalam satu gerakan dengan menggabungkan destrukturisasi objek dan inisialisasi objek es2015.
Ini menghilangkan delapan atau sembilan pemeriksaan manual yang mulai menjadi tidak sedap dipandang setelah beberapa saat.
- Meningkatkan di Back4App
Setelah Anda memigrasikan kode Anda, Anda harus melakukan dua hal lagi agar dapat berjalan di Back4App.
Tingkatkan versi server Back4App Anda
Unggah kode cloud baru Anda.
Saya telah menyebutkan langkah pertama secara singkat sebelumnya. Yang perlu Anda lakukan adalah masuk ke Back4App dan pergi ke dasbor aplikasi Anda. Dari sana, cukup pilih “Pengaturan Server” di sebelah kiri, diikuti dengan tombol “Pengaturan” pada kartu “Kelola Parse Server”. Anda kemudian dapat memilih tombol radio Parse Server 3.1.1 dan tekan “Simpan”.
Terakhir tetapi tidak kalah penting, Anda dapat mengunggah kode Anda melalui Back4App CLI, atau dasbor Anda menggunakan unggahan manual. Lihat panduan ini jika Anda memerlukan informasi lebih lanjut tentang langkah ini.
Catatan tentang peluncuran versi baru
Jika kode Anda kompleks, mungkin ide yang baik untuk menjalankan beberapa tes sebelum melakukan dua langkah ini. Back4App memiliki beberapa panduan tentang cara melakukannya di sini dan di sini.
Akhirnya, penting untuk dicatat bahwa perubahan ini adalah breaking. Menggunakan kode yang kami tulis di Parse Server 2.x akan gagal, dan menggunakan kode 2.x di server 3.1 juga akan gagal. Oleh karena itu, Anda harus memastikan untuk memperbarui versi Parse Back4App Anda segera setelah Anda mengunggah Cloud Code yang telah diperbarui. Jika Anda memiliki banyak pengguna dan khawatir tentang pengunggahan kode dan peningkatan versi yang sedikit tidak sinkron, Anda dapat melakukan sesuatu seperti ini.
JS
 const serverVersion =
   Parse.CoreManager.get('VERSION') === 'js1.11.1' ? 'OLD' : 'NEW';
3
 if (serverVersion === 'NEW') {
   Parse.Cloud.define('posts:get', async ({ params: { id } }) => {
     AssertParams({ id });
     // Needs a post ID
     return new Parse.Query(POST).get(id, {
       useMasterKey: true
    });
  });
} else if (serverVersion === 'OLD') {
  // Old definition here
}
 const serverVersion =
   Parse.CoreManager.get('VERSION') === 'js1.11.1' ? 'OLD' : 'NEW';
3
 if (serverVersion === 'NEW') {
   Parse.Cloud.define('posts:get', async ({ params: { id } }) => {
     AssertParams({ id });
     // Needs a post ID
     return new Parse.Query(POST).get(id, {
       useMasterKey: true
    });
  });
} else if (serverVersion === 'OLD') {
  // Old definition here
}
﻿
Kode ini secara dinamis menentukan versi dan mendefinisikan Cloud Functions berdasarkan itu. Setelah mengunggah ini, Anda akan beralih ke 3.1, dan kemudian Anda dapat mengunggah ulang kode dengan bagian lama dihapus. Termasuk pemeriksaan di awal memastikan tidak ada titik di mana kode Anda akan crash. Karena Anda dapat memperbarui dan mengunggah dalam beberapa detik, biasanya tidak perlu.
Kesimpulan
Dalam panduan ini, kami menunjukkan dengan sederhana bagaimana cara memigrasikan Cloud Code Anda ke rilis Parse 3.1. Ingat untuk meningkatkan versi Back4App Anda ke 3.1 setelah Anda melakukan perubahan ini.
Juga penting, panduan ini menunjukkan sintaks yang ditingkatkan yang dimanfaatkan oleh Parse 3.1. Refactoring kami mengurangi basis kode dari ~160 baris menjadi ~90 dan membuatnya jauh lebih mudah dibaca. Untuk aplikasi nyata, ini akan memberikan keuntungan.