After announcing the official shutdown of the hosted Parse service, an open source version was released. It can be deployed to any infrastructure that can run NodeJS, works with the Express web application framework and can be added to existing web applications, or run by itself.

Parse Server is the best open source option to explore for those who search for alternative for the Hosted MBaaS (Mobile Backend as a Service). It has the potential to be one of the largest open sourced projects in GitHub. So for those who still can’t get over the fact that Parse will be shut down – have no fear, Parse Server offers much more that you expect.

Why Parse Server offers more?

Few years ago programmers had to deal with a lot of stuff – database, servers, user accounts, front-end, network and hardware maintenance etc. Everything had to be build individually and a lot of skills and knowledge were needed to cope with the entire building process. What made Parse so awesome was that it gave freedom to the developers to focus on the actual building of the app and to not think about the backend. The frustration that Parse’s users felt after learning the bad news of closure is understandable.
The good news is that with the use of other providers, Parse’s awesomeness can be available even after January 2017. Parse Server is self-hosted, so you can choose to use Parse Server hosting provider such as SashiDo, run it on your local machine or you can use your own cloud-based server.
There are few differences between Parse.com and the Parse Server, as follows :

• You can test and develop your app locally on Parse Server, which is so useful especially when you want to check something before official update.
• Parse had east-coast data center and offers no other location, Parse Server can be hosted anywhere, which means you can choose the most convenient region for you and be closer to your users.
• Parse stored all files in their Amazon S3 bucket. Parse Server: adapters are being written to allow developers to choose which database platform and file storage system they'd like to use.
• With Parse Server you have to bring your own database, but you receive several pluses like: index management, performance tuning, backup and restore functionality, and all of the other cool features your database provides. If you decide to host the Parse Server on Third party provider you don’t have to deal with managing database, because it’s included in the service so it’s one less thing to worry about.
• Parse enforced a 1,000-object maximum on queries, a 3-second time limit on database triggers, a 15-second time limit on cloud functions, and an overall 30-second limit on all requests. This was needed because it powered a lot of apps, but now this limitation is gone since you’re running just your apps.
• With Parse Server you can use all official npm modules, not only Parse Cloud Code modules, which is great, because this means a lot more variety of packages for you to include in your application. Check out how to do it on SashiDo with our Twilio Cloud Code integration. The principle is the same with any npm package. We provide GitHub integration, which makes npm modules management even more simple.
• New features were included in the Parse Server such as Parse LiveQuery, allowing you to easily include real - time operations in your application. Check out our tutorial on how to use them on SashiDo.
• Parse Open Source community is growing huge. Mobile developers join forces in order to improve the product. There’s constant pull requests, bug-fixing and updates (almost 40 in the last couple of months).

The best thing about the Parse Server is that it’s free and open source: you can change whatever you want and need. And there’s a lot of people who are like you and wish to contribute for the community. One of the most popular products (such as Wordpress, Linux kernel, MySQL etc.) became so popular and developed so much due to the reason that they were open source. Here you can read an interview with the biggest contributor to the Parse Server: Florent Vilmart and what motivated him to do this outstanding job.

The old Parse is about to reborn because of Parse Server and this is a great option to start something new, better and make it your own. It’s up to you whether to host it by yourself or use Parse Server provider such as SashiDo, which will take care of all the time and effort - consuming server-side part. This is actually our passion and what we’re good at. We have experience with Cloud hosting and we’d love to manage the Parse Server for you so you can have the freedom to focus on your applications.

In the meantime, happy coding :-)

Choosing your Parse Server provider could be important decision, if you’ve decided to go with a third party solution. A lot of new companies and providers came on the market during the last year, which is awesome, because you have more options to choose from. This also creates competition which pushes providers to improve the quality of the service and to give better terms in order to gain more customers. On the other hand you may feel confused - everybody promises good conditions and service, but what are the “must-haves” of your new partner? We want to help you out a bit and that’s why we have prepared a list of things we believe a good Parse Server provider needs to have.

• Auto scaling - you probably know the number of users and your regular traffic each month, but let’s imagine you are launching a marketing campaign or some other event that requires escalated data transfer or more push notifications than usually. You need to be sure that your new provider is capable of handling this traffic at any time. Auto scaling is one of the essential concepts in Cloud computing, because it provides the flexibility to automatically add or cut out compute resources based on the actual usage of your applications. You benefit in every way - you pay for what you’ve used and most importantly: don’t have to worry if your apps can handle an unexpected traffic.

• Multi region - make sure your provider covers as many regions as possible or at least plans to do so. This is important in many aspects - the distance between your server location and your app’s users may affect the speed and no one wants slow loading of data. SEO (Search Engine Optimization) considers server location as a factor when trying to check if your web app or website is relevant for a certain country or language market.

• No Vendor Lock-in - our advice is to double check this, because you need to make sure you’ll be able to migrate your apps away at any time without problems. You should feel satisfied with the service and the provider and this should be the reason that you don’t leave, not because they don’t let you do it.

• Good 24/7 support - it’s crucial to be able to get expert assistance and to know your new provider can help you if you experience any troubles.

• Reasonable pricing - of course we talk about business and this is an important aspect, so feel free to compare what you’ll receive for your payment. Still have in mind that choosing the lowest price is not always the best solution, because you may miss some important features or good support etc.

• Check the provider’s background - we mean not only comments of other users, whо already used the service, but get to know the company a little better - are they on the market for some time now, what is their core business, do they have experience with Cloud hosting, who are the people behind it? Years of experience in the field sounds much more promising and reliably.

• Vision for the future - it’s good to know your provider has plans for the future beyond just hosting the Parse Server. As developers we all like to dream big and it’s the best to know you have access to the most innovating technologies. Try to find if they are contributing in some way to the improvement of the Parse Server or just ask them if they have any bigger plans. If they do - they’ll be more than excited to share with you.

We know it’s hard to pin your faith upon a new provider and to allocate your applications in their hands after Parse has shaken the trust in MBaaS as industry. But the benefits and convenience of using a third party provider definitely worth the risk. Just follow our tips and you’ll save yourself a lot of time and nerves, spent on switching from one service to another. We’d love to hear what’s important for you when you look for a new Parse Server provider. Share with us your opinion!

In the meantime: Happy coding :)

Time flies fast. It’s been 10 months since Parse announced the future retirement of their hosted service.
Many of you still feel uncertain about starting the migration process. We do understand your reasons - you need more time to see how the situation is going to develop, which new path to choose - self hosted backend or third party provider, you still wonder how stable are the fresh Parse Server providers. The actual migration also may scare you - you’ve probably have read the long official Parse documentation on the process and feel confused whether you'll manage to do it on your own.

Don't worry! We did our best by providing the easiest and fastest possible migration. It's fully automated and takes minutes (depending on your DB size). You can read more in our tutorial - Parse Migration in a Click.

In addition to this information we'd like to share with you the most appropriate order of steps to do your migration on SashiDo along with few tricky moments you need to know. If you follow them we guarantee you’ll experience troubleless migration and fully functioning features of your apps.

Here’s the short list of the recommended migration steps:

1. Migrate your database
2. Update your SDK-s
3. Set up the Cloud Code
4. Activate your Background Jobs
5. Upload your Certificates for Push Notifications and switch to FCM /for Android/
6. Check Global config, Sender Email and e-mail templates, Webhooks
7. Set up your Host Name (CNAME)
8. Migrate your files
9. Prepare your app for IPv6 networks /iOS/

So let’s get started :)

Migrate your database

There’s plenty of options to transfer your DB from Parse - manually or with supporting tools. We chose to help you in any way possible, so we offer fully automated database migration. Although it's completely safe and trustworthy, it’s always good practice to check if everything has moved successfully. You can easily do this with MongoDB’s diagnostic commands or see it in SashiDo’s Dashboard under Core > Browser and if there’s a problem - just reach us at support@sashido.io and we’d love to check what could be the problem. Keep in mind that if you don’t finalize your migration on Parse’s Dashboard in the next 24 hours, your application will be using your old database. You can read more information in our migration tutorial.

If you don’t finalize your migration in 24 hours, you can restart the database migration only manually. For this you would need to clean up the database from any collections. Then to start a manual migration you have to go to SashiDo dashboard > Application Settings > Security & Keys > Copy the Database URI.
Then go to the Parse.com dashboard > App Settings > General and click the button "migrate" (Migrate to external database) and paste the URI there. After that you have another 24 hours to finalize the process.

Upgrade to the latest SDKs

Parse Server uses the latest SDKs- so make sure you update them before you start testing your application in order for your Cloud Code to work properly. Here’s a list of what you might need:

• For iOS & OSX
• For Android
• For JavaScript
• For .NET + Xamarin
• For Unity
• Parse PHP SDK
• For Arduino
• Embedded C
• Cloud Code

Keep in mind that non revocable sessions are not supported by the open source Parse Server and may need to be migrated

If your application is using old style sessions you will need to migrate these too due to the fact that this functionality is not supported by the open source Parse Server. There is a tutorial on how to do this and it is not hard at all! You can check this link for more detailed information about session migration

Set up the Cloud Code

Mentioning Cloud Code - the popular Javascript SDK for a server-side environment, was changed in the Parse Server.

1. Parse.User.current() is not safe to use

In the open source Parse Server it is not safe to use Parse.User.current() and this needs to be changed a bit. You will have to pass the session token taken from the request variable. Here is an example code we will quickly migrate:

And this is how it should look after the changes:

Here we get the user from the request variable and we can pass the token to future query and cloud code invocations. We will save it in a variable just to make our life easier and pass it as part of the options argument to the find function. Remember you will need to pass it to other find, delete, save, etc functions as well. You will also need to pass it to other calls to your cloud code functions.

2. Parse.Cloud.useMasterKey() may lead to security issues

You should not rely on Parse.Cloud.useMasterKey() as it may lead to security issues, instead you should to the same as what we have done with the user’s session token and pass it as part of the options object. Here is an example:

And here is the result of the new migrated cloud code:

As you can see we have Parse.Cloud.useMasterKey() is now commented out and useMasterKey is passed to the count function. As previously if you need to bypass ACLs or CLPs and need master you will have to pass this to other functions and cloud code calls.

3. Parse native Cloud Code modules are not available anymore

Parse native Cloud Code modules are not available anymore, now you need to use their official npm modules. This actually is a great news, because before you were restricted to only Parse Cloud Code modules and now you can use any npm module you want to. We did a short tutorial on how to use Twilio - the principle is the same with all packages.

Here is a list of the modules and their npm counterparts:

• App Links: There is no direct replacement, but it is relatively easy to generate these tags yourself.
• Buffer: This is included natively with Node. Remove any require('buffer') calls.
• Mailgun: Use the official npm module mailgun-js
• Mandrill: Use the official npm module mandrill-api
• Moment:
  Use the official npm module moment
• SendGrid: Use the official npm module sendgrid
• Stripe: Use the official npm module stripe
• Twilio: Use the official npm module twilio
• Underscore: Use the official npm module underscore
• Parse Image: We recommend using another image manipulation library, like the imagemagick wrapper module

Note: In-app purchases are not yet supported by the open source Parse Server.

Activate your Background Jobs

Background Jobs is an useful tool, allowing you to use long-running, repeating tasks. They’re part of the Cloud Code and migrate with it, jobs are not active as they may conflict with your currently running jobs on parse.com and you need to activate them after the migration. Just go in SashiDo’s Dashboard > Core > Jobs > Scheduled Jobs > Activate. After they are activated you will be able to change the schedule and edit them. Bear in mind that jobs will be running on parse.com too and you may need to stop them from running there. If you don’t know how to create Background Jobs and haven’t used them before you can take a look at our tutorial - Getting started with Background Jobs on SashiDo.

Upload your Certificates for Push Notifications and switch to FCM /for Android/

A common mistake is to forget to upload your certificates in order to use Push Notifications. They can’t be migrated because of security issues, but push audiences will be moved with your application. You need to upload your Apple Push Certificates and Android Push Credentials in your SashiDo Dashboard manually. Important news is that if you use GCM Credentials you’ll need to upgrade to FCM (Firebase Cloud Messaging), because some of the features of GCM are already depreciated and soon the whole GCM will be depreciated. You can read more information on how to upgrade to FCM.

Another important information regarding Android apps:
Parse.com owns the API Key of all default Sender IDs for each of their users. This means that the legacy FCM tokens can only be published via the hosted Parse.com API end point. If you use your SENDER_ID, generated by Parse, it will publish to all tokens - new and old, but after January 2017 you won’t be able to use it anymore. There’s no way to migrate the tokens, generated by Parse API, the only solution is to update the client SDK and register each user specifying your own SENDER_ID.

Global Config, E-mail templates, Webhooks

Global Config allows you to set up parameters that let you control the appearance or behavior of your app. It should migrate successfully with your application, but just check if everything is ok under Core > Config.

E-mail templates also migrate with your DB, just check them and do some tests if needed.

Reply-to email address: If you want your users to receive emails like forgotten password, auto reply etc. from a custom email address you have to make a small update. Go to SashiDo’s Dashboard and add your reply-to email address in the Settings > Hosting & Emails section. You will receive an email to verify the address, so make sure you check your inbox and do the necessary to complete the verification.

If you were using webhooks you will need to add them yourself. The interface is the same as in Parse.com and thus makes it fairly straight forward to add them in the dashboard.

Set up your Host Name (CNAME)

You can use static web hosting with SashiDo, you just need to set up your custom domain and CNAME in the Dashboard. Here's an article explaining how to use hosting on SashiDo.

Take care of your files

Parse stores your files in it’s own AWS S3 Bucket and Mongo database stores only references (URLs) to them. So after migrating the DB, the files don’t move with it and will be deleted after 28th of January 2017. Few months ago, this was a huge problem, but now there are file migration tools. SashiDo was the first to provide one, you can easily find the tool in SashiDo’s Dashboard: App Settings > File Migration. It’s completely free and can be used by all AWS clients, regardless if they use SashiDo or not.

One important note before you start the migration of your files: when the files are pointing to Parse.com’s S3 bucket they are visible to both api.parse.com and Parse Servers because of the way they are kept in the database Parse.com knows how to find them and provide a correct link. But after the files are being migrated they are no longer pointing to the Parse.com S3 and won’t be visible to Parse.com API end point. Also files uploaded from the Parse Server won't be visible to Parse.com API end point.

This means that file migration should be done after you have released a new build for you application and people start updating it.

Now to start a file migration you need to go to App Settings - choose File Migration and press Start File Migration.

App Store requires support of IPv6

In June this year Apple announced that after iOS 9 apps including, submitted to the App Store, must support IPv6 Network. Starting June 1, 2016 all apps submitted to the App Store must support IPv6-only networking. Most apps will not require any changes because IPv6 is already supported by NSURLSession and CFNetwork APIs, but in case your app uses IPv4-specific APIs or hard-coded IP addresses, you will need to make some changes. In order to meet the requirements your app needs to: work over IPv6 network connections and use DNS over IPv6. When you release the new version of your application on AppStore after migration make sure you meet these requirements.

In other words this IPv6 compatibility means to ensure that your apps work with IPv6 technology, you don’t have to make the endpoints running on IPv6 as DNS64/NAT64, translation technologies will facilitate the communications.

What you actually need to do is to make sure your application is ready for IPv6. This could involve things like not hard coding IPv4 in the app, not using a [short] fixed length string to store IP Address.

If you do use a string to store IP address it’s very important to make sure it has room to store at least 40 characters to accommodate IPv6 address format.

Here is a list of steps you need to take to ensure your application is ready for IPv6:

• Use High-Level Networking Frameworks
• Don not Use IP Address Literals
• Connect Without Preflight
• Use Appropriately Sized Storage Containers
• Check Source Code for IPv6 DNS64/NAT64 Incompatibilities
• Use System APIs to Synthesize IPv6 Addresses
• Test for IPv6 DNS64/NAT64 Compatibility Regularly

We know migration can be challenging and problematic so make sure you give yourself enough time to check everything and leave enough time for live testing with the real users. In this way you’ll ensure the safe and smooth new journey of your apps. Keep in mind that in case you are not happy with your initial Parse.com alternative choice you will need time to find another provider and migrate there. In this line of thoughts our last tip is to make sure your provider doesn’t have vendor lock-in, this was one of the key strategic points in our policy as a company - users should feel free to make their decision based on the quality of the products, not because they feel trapped.

Don't be afraid of the migration, but also don't delay it too much, because there isn't a lot of time left.

If you have any questions regarding the migration - we'd love to help you with answers and we will be happy to receive feedback on your experience with the migration process.

In the meantime, happy coding :-)

We, SashiDo’s team, like to dream big, because setting up the bar high is the way to achieve awesome results. We wanted to create a service, offering every feature from Parse so you wouldn’t miss anything when coding your favourite apps, to give to you a REAL PARSE ALTERNATIVE. After launching so many of them and putting a lot of effort into improving the service, it was clear: it’s time to expand and cover more hosting location. Since most of you asked for US - it was decided to be the next in our roadmap.
We’re very excited to announce that from today you can

Create new or migrate existing apps in US region

It’s simple, in case you want to build a new app in US location choose it from the dropdown menu in SashiDo’s Dashboard. If you already have apps running on SashiDo, but US is a more convenient for you: write us at support@sashido.io and we’ll be more than happy to change your current region to US.

We will start migrating your apps from EU to US after 17.11.2016.

Why server region matters?

It’s important in many aspects. The distance that data has to travel between your server location and your app’s users may affect the speed that your application loads so if you choose a server, closer to your users, this will make your products faster. So it’s better to keep your app on a server, close to your target market. Another good reason is that SEO (Search Engine Optimization) considers server location as a factor when attempting to ascertain if your web app or website is relevant for a particular country or language market.

What’s coming next?

Here’s a sneak peek of what’s already in progress and will be available for you to enjoy very soon:

• New region Australia
• Advanced Push Notifications
• Automated MongoDB Backups
• Documentation

Don’t forget that you can write us at support@sashido.io in case you have any questions.

In the meantime: happy coding :)

One of the guideline policy that Parse created was to try to make everything convenient for their users and that was one of the main reasons developers loved the service. SashiDo’s team wants to keep this tradition by providing our customers the same experience of comfort and effortless coding. I’m sure this happened to you: you get an order for an app, but the customer also wants a website with it. So you have to use one provider for the mobile application, another for the website, deal with web hosting and sftp servers, domain name registering etc. Wouldn’t it be lovely to have everything in one place?

With SashiDo you can :)

In this tutorial we’ll show you how to publish static web sites in few simple steps.
When you deploy Cloud Code in your GitHub repo, any files in your directory ‘public’ is uploaded to Parse Server and becomes accessible online. You can choose a subdomain in their app settings.

So let’s get started.

• Go to SashiDo’s Dashboard > App Settings > Emails & Hosting . Choose a subdomain name, it should be in the following format:

  [subdomain-name].yoursite.com

• Enter the wanted subdomain + mysite.com in the input, don’t press ‘Save changes’ yet.

• By entering the subdomain’s name you’ll see host names to resolve the CNAME.

• Now you have to claim the new host name. Go to your DNS provider and set up a new CNAME record.
• Go back to SashiDo’s Dashboard and now save the changes.
• You already know about your private GitHub repo with you Cloud Code hosted in it link to tutorial. It also holds a folder named ‘public’ where you can keep your html, css, JavaScript, image files.
• Clone the repository and

git add .
git commit -am 'upload my awesome site'
git push

your website files in the ‘public’ directory. Every push triggers a deploy so you don’t have to deploy the code afterwards :)

• Now go to your new domain and see how the website just came alive for the web.

Here’s some useful documentation on how to add new CNAME record:

GoDaddy

Amazon

namecheap

networksolutions

Continue enjoying simple and straight-forward coding, leave the messy server-side stuff to us to handle :)

We can’t wait to see the amazing sites you’ll create and host on SashiDo.

Happy coding :)

How to set up Twilio for local development

In the first part of this tutorial we showed you how to make npm package integrations directly into your Advanced Cloud Code. But let’s say you want to test something on your computer before deploying it on SashiDo’s Cloud Code. This tutorial is for Mac OS X (for other OS should something similar)

First you should install nvm (Node Version Manager - Simple bash script to manage multiple active node.js versions). Here’s explanation how to do it: link. Command is

curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.32.0/install.sh | bash

You should also have Node.js installed, you can download it from here. But we’ll show how to do it with the NVM. Run in your terminal the following command:

nvm install v6.2.1

Clone the repository, if you haven’t done it yet.

git clone git@github.com:parsegroundapps/pg-app-yourapp-id.git

Install twilio, here is explained how to do it link. We suggest you to use the command:

npm install --save twilio

Command --save will automatically write it in package.json. It’s a good practice to use it, because sometimes a programmer forgets to add the dependency and to push it to the server. The code won’t work as a result.

You should add node_modules directory to the git ignore file, because they’ll be installed on the server automatically by SashiDo.

echo 'node_modules' >> .gitignore

Let’s create a new file which will keep our test code: twilio.js in the cloud directory. Don’t forget to require it in main.js, otherwise it’ll not work.

Let’s write a simple function in twilio.js, which will send a SMS to a number by your choice.

You can find 'ACCOUNT_SID' and 'AUTH_TOKEN' in Twilio’s Dashboard, here is Twilio’s documentation in case you need it.

In order to test, you’ll need some database. You can use your application’s database. Go to SashiDo’s Dashboard, App Settings -> Security & Keys -> Database URL. Copy & Paste in index.js:

Run Parse Server in Node.js with command
node index.js

Open a new tab of the terminal and write the following POST request to do the test:

curl -X POST \
	-H 'X-Parse-Application-Id: myAppId' \
	-H 'X-Parse-REST-API-Key: key' \
	http://localhost:1337/1/functions/inviteWithTwilio

Check the phone for the results, if you followed this tutorial correctly, you should get the SMS:

If you’re happy with the results, it’s time to deploy the code. Git add, git commit, git push your changes

git add .
git commit -am 'Add twillio integration'
git push

Happy coding :)

Setup of Twilio package tutorial

Building more complex apps without a lot of knowledge about back-ends and infrastructure sounds difficult, but we believe in Parse’s vision for letting developers create any app effortlessly. When we first launched early access for SashiDo, most of our lovely users asked for Advanced Cloud Code and we do understand why - it’s essential feature, because it’s flexible, allows you to write Express applications and use different packages such as Mashape, Mailgun etc. This means that Advanced Cloud Code gives you the opportunity to build more complex application with minimum of logic and no struggle. You only need to integrate a Cloud module into your SashiDo GitHub repo and you can easily use third-party services and libraries which will help you to create the dream product.
Those of you who haven’t used external packages will surely enjoy the power, given by them, and those of you who don’t know how to set them up with SashiDo, will see how easy and straight-forward it is.

This tutorial will show you how to setup Twilio ( an awesome API providing video and voice calls, send & receive SMS, MMS, authentication service for more secure apps ) into your Advanced Cloud Code. You can do the same with every Cloud module and the same technique will work with Android, iOS and any other platforms, supported by SashiDo. So let’s get started !

We’ll divide this tutorial into two parts: the first will show how to do the integration on the Cloud Code of SashiDo, and the second will describe how develop locally on your pc (in case you want to do some testing before deployment).

Setup of Twilio on SashiDo’s Cloud Code

You already know about your private GitHub repo, provided by SashiDo with your Cloud Code (if you’ve missed this important info, read more here.
Here is a helpful article about how to set up Git. Clone the repository, if you haven’t done it yet.

Find in the main directory file package.json. In package.json you can add all npm packages you want to use in your app. According to our tutorial this will be Twilio, but the same principle will apply for other npm packages.

P.S. Take a look at line 14.

We’ll create a new JavaScipt file named twilio.js and require it in the main.js file. Every Cloud Code file should be included there, otherwise it will not work.

Let’s write a simple function in twilio.js in the cloud directory, which will send a SMS to a number by your choice.

You can find 'ACCOUNT_SID' and 'AUTH_TOKEN' in Twilio’s Dashboard, here is Twilio’s documentation in case you need it.

We’re ready with the preparations, it’s time to deploy our code.

git add .
git commit -am 'Add twillio integration'
git push

Keep in mind that every trigger causes a deploy in your application, so you don’t have to do anything about it.

Go to SashiDo’s Dashboard -> Core -> Cloud Code and wait until the code is finished deploying.

Now it’s time to test if our integration is successful: go to Core -> Api Console, make a POST request with function twilio.js and press Send Query.

Let’s see the result on the phone :)

If you followed the steps correctly, you should have received the SMS. In the second of the tutorial we’ll learn how to set up npm package for local development.

GitHub integration of Advanced Cloud Code part 2

If you have any difficulties or need help - reach us at support@sashido.io .

Happy coding :)

SashiDo has been on the market for few months and during this time we had the opportunity to get to know more about our clients and what they need in order to receive fully complete experience with the service.

After launching Advanced Cloud Code the top asked question was “Are Background jobs in the roadmap?” So we did it - now you can run scheduled tasks on your app.

Why do I need Background Jobs?

Because they give you the comfort to write a function once and set it up to run as often as you want. Background Jobs allow you to build long running tasks by writing code similar to Cloud Functions.

Let’s say you have an app game with free and paid users accounts. The second group has access to more features and you want to make regular check if a user has an active paid account.

Of course it will be very hard to do this check every couple of hours and as developers we always think of a logic solution to a problem. This is a good time to use background jobs - we can write a simple function that checks twice a day all the users if they have inactive payment their plan changes to “free”.

You do it once, schedule it and update it anytime you want to change its functionality.

How to use Background Jobs on SashiDo?

First we’ll need some users that we want to check for payment status. Enter SashiDo’s dashboard and choose an app you want to work on. Create a new Class named User and add two Objects.

Add parameters “plan” and “payment”. Set payment with different values in order to check later if our function is working correctly.

Go to your private GitHub repository where your Cloud Code is stored and clone it if you haven’t done it yet. Go to the cloud directory in the cloned project: cd appfolder/cloud And make a new javascript file in it with name checkUserStatus.js. Now let’s write the function that does the check:

Function checkUserStatus(); checks all instances of Class User with a loop and if the payment status of the user. If it’s inactive the plan changes to free.

Now go to your appfolder/cloud/main.js file in the same repo and include the file we’ve just created:

It’s time to commit and push the changes. They will automatically deploy to your app so you don’t have to do it additionally. Enter SashiDo’s Dashboard and open Core > Cloud Code. You’ll see a button saying that the Cloud Code is building at the moment - wait until it says the process is finished.

Next you have to go to Scheduled Jobs (Your app > Core > Jobs). Here you can manage your Background Jobs, create, edit and delete. Click the button to create a new Cloud Job and name it, then add JSON parameters (in our case it’s the new status of the user):

You can choose if and how often the jobs will repeat. We’ll choose twice a day. After the setup is finished we can start the function immediately in order to see if it’s working. We can see the result in Jobs Status - go there and refresh the page. You can also see input and result of the function in your Logs (Your app > Core > Logs).

Looks like our function is working, let’s more importantly see if it’s do the job. Go in the Browser and check class User:

Voilà, our first Background jobs is working!

Now you can build your own jobs according to your needs, it’s easy and fun.

Background Jobs use cases

You can use Background Jobs whenever you want to run a process without user intervention like logging, user notification, monitoring etc., when you need to automate a process that needs to be running repeatedly in your app.

This is the basic setup of SashiDo’s Background Jobs.
Now you can start building Cloud functions which saves you time and efforts.

Happy coding!

SashiDo launched Advanced Cloud Code so you can have the ability to write more complex logic, add 3rd party API libraries and packages which provide you a lot of ready-to-use functionality. That’s awesome, but what happens if you want to implement your server-side logic in a language other than Javascript? Or if you want to use in your project a tool, not supported by Cloud Code? Then the perfect solution is to set up WebHooks on your application. They are an HTTP POST callback request sent to URL of a user's choice in response to some occurring event. They offer simple and effective server-to-server communication without long running connections.

WebHooks give you the freedom to use the programming language that you want and to add specialized libraries and technologies. You can write functions on your preferred language and host locally for testing before deployment.

Webhooks use cases ideas

You can use WebHooks whenever you want to add technology, not supported by Cloud Code. For example - integration with Billing, e-mail templates, PayPal, Slack etc. A webhook delivers data to other applications as it happens, meaning you get data immediately.

How to use WebHooks?

It’s quite easy on SashiDo. Let’s imagine we have an app with active paid users and free trial. We need to know which users are paid and which not so we can stop their access to the system. We’ll do this by implementing a simple function in Python and framework Flask , but the principle is the same with other languages and technologies. If you want to run the sample code locally, you’ll need a tunneling service like ngrok or ultrahook to map your local http endpoints to public URLs.

• Go to SashiDo’s Dashboard > Browser and create a new class User with two instances: jane and john so we can test.
  

• Add two properties to the class: plan and payment. Set value “try” to plan.

• Now let’s write the function: Function webhook() has POST method and requests the current user to check its payment status. We also implemented a simple help function make_payment() to fake the payment logic in order to do our test.

• Now go back to SashiDo’s Dashboard Core -> WebHooks. Press Create a WebHook and choose a type, a Class, and add the URL of the WebHook:
  We have deployed for your convenience the Python code from above here so you can try with it without any coding right now: https://webhook-sashido-examples.scalabl.cloud/webhook

• It’s time to test :) Go back to the Browser and fill property plan with value “try”. After refreshing we see the results:

Looks like our function has done its jobs. Now you can use any framework or language to build awesome apps.

If you are fans of Python and want to play with the example on your local computer, we uploaded the source here: https://github.com/SashiDo/webhook-handler-example

If you don’t want to clone and run the whole example, we uploaded it live for quick tests:
https://webhook-sashido-examples.scalabl.cloud/webhook

What about Cloud functions and triggers?

Let’s take a more detailed look to what Webhooks Cloud functions and triggers offer:

Cloud function: A webhook request for a Cloud function. It must contain the following parameters:

• master: True // if the master key was used and false otherwise.
• user: If set, this will contain the Parse User who made the request, in our REST API format. This is not set if the master key is used.
• installationId: If available, the installationId which made the request.
• params: A JSON object containing the parameters passed to the function. For example: { "foo": "bar" }
• functionName: The name of the Cloud function.

Send a JSON object with the key error or success set to respond to this request. If the result is success: send back the expected data or simply “true”. Otherwise: return the error message.

For beforeSave, afterSave, beforeDelete, afterDelete triggers , the following parameters are sent to your webhook.

• master: True // if the master key was used and false otherwise.
• user: If set, this will contain the Parse User who made the request, in our REST API format.
• installationId: If available, the installationId which made the request.
• object: For triggers, this will contain the Parse Object, in our REST API format. For example: { "className": "TestObject", "foo": "bar" }.
  triggerName: "beforeSave"

Send a JSON object for beforeSave trigger with the keyerror or success set to respond to a beforeSave request - same as Cloud function. The difference is when you return an error, you will cancel the save request and the object will not be stored.

No response is required for afterSave and afterDelete triggers.

To respond to a beforeDelete request, send a JSON object with the key error or success set. If you return an error this will cancel the delete and the object will remain unchanged in your database.

If you have any issues or questions contact us at support@sashido.io

Happy coding :)

Before the concept of Live Queries (WebSockets behind the scenes) was created, developers used comet and long polling in order to simulate real time web. The problem was that this technologies needed almost constant communication with the server, which, as you’d imagine, it’s not very fast and resource-friendly.

Then Live Queries came and the Parse Server became realtime. Imagine an app game, which needs to update in real time non-stop. As you know, games should work very fast so every resource is important.

Why use Live Queries?

One of the key concepts behind Parse Server is the Query, which allows you to tell the Parse Server which object you need. If you want to use Live Queries you have to build a Query just like you normally would and instead of find() call subscribe(); This means that every time an object matching this query is changed, the server will see this immediately and push the new object data to you realtime.

Live Queries are part of the Parse Server and now they are also included and automated in SashiDo’s Dashboard and you can access and manipulate them easier that ever.

You can do so many things with them - updates, notifications, gaming, chats - everything will update in realtime! For example: you don’t necessarily need them for signing, user registration or other standard operation, but they are crucial if we talk about multiplayer gaming or realtime messaging and stuff.

How to set up Live Queries on SashiDo?

1. Go to SashiDo’s Dashboard App settings -> Live Queries

2. Choose the Class (in our case _User) you want to use Live Queries with and Save Changes

That’s it all! The setup is easy and effortless.

Benind the scenes

We know you're curious ... so here is what happens "behind the scenes" in case you had to do it by yourself:

We add liveQuery for class _User and a function to listen for the updates:

More info here:

• https://www.nginx.com/blog/websocket-nginx/
• https://github.com/ParsePlatform/parse-server/wiki/Parse-LiveQuery

Using Live Queries

Let's provide a LiveQuery client in our main JavaScript SDK (v1.8) and a separate client package for iOS.

We'll use JavaScript for the example. You have to use subscribe() instead of calling find() on a regular Query.

After that, if someone creates a new Player object that matches this query, with data like:

{
  objectId: 'rj9f032j0k',
  name: 'Mengyan',
  favoriteAthlete: 'INnoVation',
  league: 'Platinum'
}

Then the create event on the subscription will be triggered, and it will log INnoVation to the console.

And here is a simple page for quick tests if you don’t feel like doing the whole tutorial:

And if you want to play around with the code from the example, you can find it here:

As mentioned above, we have to use subscribe() to use Live Queries, but there’s also other events like delete, update, enter, error, leave.

Here are the Protocol-Specification and complete LiveQueries documentations for more detailed info so you can decide which one to use according to your use case.

We would love to see what you’ll build with this new feature, share it with us!

Happy coding :)

As Parse developers ourselves we were wondering what is about to happen with our files after the service stops. How to transfer them over the new platform? Whether they will be stored somewhere by Parse, or they will disappear and we have to take precautions. No one provides a service for this.

The most probable scenario is that after Jan 28th, 2017 you won’t be able to access your files even if they are not completely deleted. While thinking about how to make it easier for SashiDo users to move their Parse S3 to SashiDo S3 we came up with an idea:

“What about to open a File Migration Tool to everyone?” : )

And here it is - a pretty simple tool for migrating all your Parse files in a click -- https://mv.sashido.io/ -- SashiDo File Migration. The first file transfer tool for all Parse users. Completely free and ready to utilize.

It takes minutes to move all your files from Parse S3 to your own Amazon S3. No complex tutorials, no manual transfer, no need to spend hours on such a tedious job. Also, you don't need a registration. It's easy, fast and reliable.

You can start in few simple steps. The tiny robot will assist you. : )

If you're a SashiDo user:

• Go to SashiDo’s dashboard: https://dashboard.sashido.io/

• Choose the app you want to work on.

• Go to “App Settings” - choose “File Migration” and press “Start File Migration”.

• You’ll see the migration process - it takes few minutes, depending on the size of your files.

• After finishing the process you can restart your file migration with the button “Restart File Migration.”

If you're an Amazon user:

• Go to https://mv.sashido.io/
  You have to provide the following information:

• E-mail

• Your own Mongo URI

• Application File Key

• And also your:

  • AWS Access Key ID
  • AWS Secret Access Key
  • AWS Bucket Name

Don’t worry, we don’t save your information anywhere, we only use it to locate your files.
After providing this info - press the button “RUN MIGRATION.”

• SashiDo will start to transfer your files - you’ll immediately see the running process:

• After few minutes (depending on your files’ size), the migration will be over, how cool :) If you’re happy with the result - please share your experience so other can use it too.

• Repeat the process, if you want to transfer files from another app.

WHY?

After Parse shuts down no one knows what will happen with our Parse files. Most probable is that there won’t be an access to the storage. Make sure you have a control over your files.

SashiDo Tool allows:

• Automated one-click file migration
• Migration to your own Amazon S3
• Transfer progress tracking
• Updating of your database with a new file URL
• No limits - migrate everything.

If you’re not a SashiDo account - join our family today.

We know very well what a trouble migration of your parse apps could be. There’s a lot of info on the subject, this is just a small part of the official documentation:

Official Parse docs

Parse server migration guide

AWS docs

Google Cloud Platform

Firebase iOS

Firebase Android

Heroku docs

Digital Ocean docs

You can also find a ton of tutorials by users, trying to help each other, but don’t worry - there’s fast and easy solution: our “migration in a click”.

SashiDo’s team understands the difficulties that you experience and developed the only one available fully automated migration. It takes minutes, your app is safely migrated, completely for free.

Here are the steps:

Go to SashiDo’s dashboard dashboard.sashido.io and sign up/activate your account:

When you’re inside the service - choose the button “Migrate from Parse.com”

The service will ask you to provide your username and password from Parse.com. Don’t worry, we only use this info in order to find your apps, we don’t save it anywhere - safety first ;)

In a few seconds a dropdown menu will appear with all your apps, associated with Parse.com - choose the one you want to migrate and press the button “Migrate”.

Now the real awesomeness takes place :) SashiDo migrates the whole app, database, Cloud Code, push notification, audiences, settings etc. - it only takes few minutes.

When the process is ready, a button “Continue” will show up. Press it.

We’re almost done! Your app will continue to work on Parse.com. Parse’s database is synchronized with SashiDo’s database for the next 24 hours after the start of the migration. Now you can install the latest version of the Parse SDK for Parse JavaScript, iOS, Android SDK etc., update your custom API URL (as the example below), test if your whole database has migrated successfully, set up certificates for push notification, check your Cloud Code and see if everything is working correctly.

If you like it and want to continue using your app on SashiDo - finalize your migration on Parse.com during these 24 hours, which means your app will be using the new MongoDB instance. You have to go to your Parse.com application dashboard -> Core -> Migration -> and click the button “Finalize”. Don’t worry if it’s not active in the very beginning: sometimes it takes a little bit of time. Be careful not to click stop ;)

What will happen after finalizing?

After finalizing the migration your application will continue to work on Parse.com, but with SashiDo’s database. Your app’s old database may will stay on Parse.com until January 2017 and after this any calls to the hosted Parse backend service (api.parse.com) will cease to function. In order to avoid this, you should make a new build of the app with your app’s new security keys and URLs. You can find them on Your app -> App Settings -> Security and Keys (in SashiDo's Dashboard). Then just release the new version on App Store or Google Play.

Yeap, it’s THAT EASY!

If you experience any kind of problems during migration - contact us at support@sashido.io.

We’re always ready to help :)

Cloud Code is one of the coolest features of Parse, but we take it even to the next level ;) You loved it and we love to make you happy so we decided to make the easiest possible way to set up your Cloud Code!

After you migrate your app from Parse.com (if you haven’t done this yet, click here: Parse Migration in a Click ) you have to set up your Cloud Code in order to use it.

First select the app you want to work on:

Go to Core -> Cloud Code -> press “Connect your account to GitHub”

After a few seconds the service will ask for your username and pass for GitHub (if you’re not logged in yet). A window will show up with option to connect your GitHub account to SashiDo.
Afterwards press the button “Start your Cloud Code ”:

We’ll automatically create a private GitHub repo for you, how cool is that :)

Yes, we’re the only one who give a private GitHub repo for each app :)

As developers we use GitHub all the time - to collaborate, to manage and deploy our code. We think it’s one of the most convenient tools and we’ve decided to integrate our platform with GitHub to ease your job.

Soon you’ll see your Cloud Code in the dashboard.

Now you have fast and easy access to this awesome feature!

IMPORTANT! Note that you should have a folder “cloud” with a file “main.js” inside in order to have working functionality and to see your Cloud Code in the dashboard.

You can find more useful info about your new repo’s possibilities in the file “README.md”.

If you experience any kind of troubles during setup - contact us at support@sashido.io. We’re always ready to help :)