Forem: Damodar Lohani

Appwrite is now available as a one-click app on the Akamai cloud (Linode) marketplace

Damodar Lohani — Thu, 13 Jul 2023 06:44:23 +0000

We have some exciting news. Appwrite, an open-source end-to-end backend server, is now available as a One-Click app on the Akamai Marketplace!

For those who are not yet acquainted, Appwrite is an open-source back-end-as-a-service that abstracts all the complexity of building a modern application by providing you with a set of REST APIs, GraphQL APIs and Realtime APIs for your core back-end needs. Appwrite takes the heavy lifting for developers and handles user authentication and authorization, databases, file storage, cloud functions, webhooks, and more!

By making Appwrite available on the Akamai Marketplace, self-hosting a fully-featured backend for your web, mobile, or flutter app is even simpler and faster!

To help you get started, here is a step-by-step guide on creating and deploying Appwrite from the Akamai Marketplace.

Step-by-step guide

Step 1: Access the Akamai Marketplace

Log into your Linode account and navigate to the marketplace apps.

Step 2: Select appwrite

Find the Appwrite One-Click app, and select it.

Step 3: Deploy the app

Click on the deploy this app button which should take you to the Akamai cloud create, where Appwrite should already be selected.

Step 4: Configure your appwrite instance

Scroll below and update configurations. You'll need to make a few choices regarding the configuration of your Appwrite instance, such as the region where your Linode will be hosted, the Linode plan, and the root password or SSH keys.

Once you have provided all the details, click the Create Linode button.

That should create your Akamai server for Appwrite.

Once the Linode is ready and running, give it a minute or two to complete the Appwrite installation. Finally, you can access your Appwrite console using the server's IP address to create a new account to manage your Appwrite instance. You can also assign domains and update other settings. Learn more about self-hosted Appwrite in our self-hosting documentation.

That's it! You'll have your Appwrite instance running on an Akamai server in minutes. Using Appwrite on the Akamai cloud, you can rapidly prototype and deploy applications while maintaining full control over data, user privacy, and UX. Appwrite also supports many popular technologies, including Flutter, iOS, Android, and JavaScript.

We're excited to see what amazing projects you'll create with the power of Appwrite and Akamai cloud at your fingertips!

Learn More

Join our #30DaysMasterFlutter Challenge and Learn Flutter & Dart in One Month!

Damodar Lohani — Mon, 08 May 2023 02:41:54 +0000

Greetings, Aspiring App Developers! 📱

We're excited to announce that our #30DaysMasterFlutter challenge has finally begun, and it's your opportunity to master Flutter & Dart. This project-based course 📚 is completely free and provides you with the foundation to learn one of the most exciting technologies in the app development industry.

For the next 30 days, we will focus on a significant concept each day and give you the resources to comprehend and implement them. You'll not only learn these concepts but also use them to create real-world projects. 💻🌍 This course is suitable for beginners and experienced programmers alike.

Don't worry about getting stuck. Our enthusiastic community of learners 👥 is there to support you and answer your queries, share insights, and work collaboratively.

This journey is about learning, building, and growing together. So let's embark on this adventure and come out as skilled app developers. 🎉

Remember to use the hashtag #30DaysMasterFlutter on social media to share your progress each day. We can't wait to see your accomplishments! 🏅

Are you ready to join us? Let's dive in and start coding! 🤓

Happy Learning! 🎓

Originally posted on appwriters.dev

Protect Your Applications from Bad Passwords - Introducing Password History

Damodar Lohani — Thu, 13 Apr 2023 00:31:19 +0000

If you are a developer, security is definitely one of your top concerns. When we built Appwrite, we wanted to help developers build secure applications faster. And we are always looking out for features that make our open-source back-end services more secure.

However we may write the most secure APIs and applications, but if the end-user chooses a terrible password, all our work would be for nothing. Users selecting a simple, easily guessed password or repeating the same password over and over again, even when changing, are things that make even the most secure applications vulnerable. With Appwrite version 1.3.0, we introduce a password history feature to tackle the problem where users repeatedly use the same password. We also introduce a password dictionary feature to tackle weak passwords, which is talked about in another article. In this article, let’s talk about Password History and why it is a valuable tool in your security arsenal.

🔐 Password History

Password history is especially important today when online security breaches are becoming more common. By keeping track of their password history, users can ensure they are not repeating their password and also be sure they are safe if there was a data breach previously.

The newly introduced password history feature is another step in making authentication more secure for end users. With this new feature, you can save users’ last-used passwords and prevent them from reusing them. By default, Password History is disabled and can be enabled through the project’s Auth settings. You can also configure the number of passwords to remember. The maximum number of passwords allowed to save is 20. When you enable this feature, your users cannot reuse passwords they have previously used.

To configure the password history feature, you can visit Authentication in the dashboard. Under the Security tab.

Once there, you can enable password history and set the number of passwords to save. Once you are done, click the Update button to save the changes.

Conclusion

Overall, the Password History features, together with the password dictionary feature introduced in Appwrite 1.3, is a valuable tool for improving online security and preventing users from using vulnerable and repeated passwords. By enabling this feature, your users can ensure they are using strong, unique passwords that have not been previously compromised. If you have any queries or want to learn more about Appwrite, you can use the following resources.

I Built Bitly Clone with Redis, Express Svelte and Node ( RESN)

Damodar Lohani — Sat, 20 Aug 2022 01:13:31 +0000

Overview of My Submission

I always wanted to build my own URL shortener that could give metrics like how many times the URL was visited. I had always been busy to try, but redis hackathon felt like perfect opportunity for me to work on this. So I decide to use this opportunity to build myself a URL shortener. I built it using redis as primary database where it uses Redis JSON to store URL details and RedisTimeSeries to store usage metrics.

The project has two parts a server, provides REST API and is built using ExpressJS. The server is also responsible to interface with Redis. I'm using official Javascript redis package and Redis OM for Node.js to interface with redis database to save and retrieve data.

And, another is the client, that is build with Sveltekit. It provides web UI where users can create short URLs and view the metrics in beautiful looking charts.

You can view the live demo of client at https://urlui.vercel.app

Submission Category:

MEAN/MERN Maverics

Video

Language

JS/TS/Node.js

Link to Code

lohanidamodar / redis-hack-urlshortner

URL Shortener app built for redis x dev hackathon

URL Shortener with Node.JS and Redis

A URL shortener application build with ExpressJS, Redis and SvelteKit. Shorten URLs and also get link visit history.

Live Demo

Screenshots

Overview video

Here's a short video that explains the project and how it uses Redis:

How it works

How the data is stored:

The project uses redis json to store Url records. Each record has following properties

originalUrl: string
shortName: string
createdAt: date
updatedAt: date

To easily work with redis project uses Redis OM for Node.js.

Schema definition

// server/app/om/url.js
import { Entity, Schema } from 'redis-om'
import client from './client.js'
class Url extends

…

View on GitHub

Additional Resources / Info


Home Page


Create new Short URL


History


QR Code


Hourly and Daily Metrics using RedisTimeSeries

Check out Redis OM, client libraries for working with Redis as a multi-model database.
Use RedisInsight to visualize your data in Redis.
Sign up for a free Redis database.

Appwrite Loves Open Source: Why I Chose to Support Provider and Riverpod

Damodar Lohani — Mon, 01 Aug 2022 00:34:22 +0000

Open-source is at the ❤️ of everything we do at Appwrite, and we want to enable and foster the open-source community that helped us grow to more than 20,000 stars on GitHub.
Open-source projects require a great deal of effort to maintain and grow. We use open-source tools every day to build Appwrite, and we want to help our community. To give back, each Appwrite engineer gets to pick an open-source project for Appwrite to sponsor for one year.

🧠 State Management in Flutter

There are tons of choices when it comes to state management in Flutter. However, for me and my projects, none have been better than the provider, and recently the riverpod, a complete rewrite of provider from the same maintainer. Provider and riverpod both are straightforward to get started with yet pretty powerful to handle large applications and complex use cases. They are easily testable and maintainable. I like provider/riverpod because compared to most of the state management solutions for Flutter, these two have fewer boilerplate codes. The extra bit of code that I have to write for state management with provider/riverpod is minimal—giving me a maintainable code and allowing me to build excellent applications in record time. I am thankful for this package every time I write a Flutter project.

Apart from riverpod and provider, Remi maintains other excellent and helpful Flutter packages like flutter_hooks and freezed to make the Flutter application robust. I am so excited to choose to sponsor him and his projects which I have been using a lot from day one for my Flutter projects. I thank Appwrite for this great opportunity.

☢️ Open-source Software (OSS) Is Hard

Since Appwrite is open-source, we understand the challenges that OSS projects face. If you fall in love ❤️ with an open-source project (like we have), consider checking out ways to contribute. Most OSS projects happily accept contributions in their own way, whether they be in the form of commits, bug 🐛 reports, advocacy, or even monetary 💰 support. If you love Provider/Riverpod, consider joining us as a sponsor. Or, if you're interested in contributing to Appwrite, check out our contribution guide.

🔗 Learn More about Appwrite

Appwrite is an open-source Backend-as-a-Service (BaaS), packaged as a set of Docker microservices, to give developers of any background the tools necessary to build modern apps quickly and securely.

Check out Appwrite as the backend for your next web, Flutter, or server-side application. Here are some handy links for more information:

Appwrite Phone Authentication with Flutter

Damodar Lohani — Wed, 29 Jun 2022 00:18:45 +0000

Phone authentication is one of the most reliable authentication methods for mobile applications. And Appwrite has now introduced phone authentication in our recent release. In this article, we will learn how to implement Appwrite’s phone authentication in our Flutter applications.

New to Appwrite?

Appwrite is an open-source back-end-as-a-service that abstracts all the complexity of building a modern application by providing a set of REST and Realtime APIs for your core back-end needs. Appwrite minimizes the heavy lifting for developers and handles user authentication and authorization, databases, file storage, cloud functions, webhooks, and much more!

Prerequisites

Access to an Appwrite project or permission to create one. If you don’t already have an Appwrite server running, follow the official installation tutorial for setup instructions.
A Flutter-configured development machine.

Twilio Account Setup

We first need to set up a phone service provider for authentication. Twilio is a popular choice – a Twilio account can provide API access keys, allowing Appwrite to send codes to mobile phones. If you don’t have an existing Twilio account, you can visit https://www.twilio.com/try-twilio and create a free account using your email and password. Via email, you will then receive a verification link, clicking on which will verify your Twilio account. It will also ask you to verify your phone number.

Enter your phone number and click on the Verify button. You will then receive a code via SMS. Enter the received code in Twilio and click Submit to confirm your number.

On the next screen, enter your choices. It doesn’t matter which coding language you choose, as we will integrate Twilio with Appwrite, so we don’t have to interface with Twilio directly. Next, click on Get started with Twilio button.

You should then be redirected to the Twilio console. Click the Getting your Twilio number button. The initial trial account can only send texts and calls to your verified numbers, and for testing, that’s perfect. However, for production use, you must upgrade your Twilio account.

You can see the Account SID, Auth Token, and Phone number in the console. You will need these in the next session to set up Twillio as an SMS provider Appwrite can use. Your Twilio account should now be ready to integrate with Appwrite.

Appwrite Setup

Follow the official guide to set up and run Appwrite. For Appwrite to know about Appwrite, we need to open the .env file from the appwrite directory where you installed Appwrite, and update the following environment variables.



_APP_PHONE_PROVIDER=phone://<ACCOUNT SID>:<AUTH TOKEN>@twilio
_APP_PHONE_FROM=<TWILIO_PHONE_NUMBER>

Once the environment variables are updated, run the following command from the command line in the installation directory that contains the .env and docker-compose.yml files.



docker-compose up -d

This will restart the containers, providing new values for the environment variables, so Appwrite can connect to Twilio. We are now ready to implement phone authentication in our application.

Install and Configure Appwrite’s Flutter SDK

Cloning the project we created for this tutorial lets us skip the setup and UI part, and focus on the main topic. Clone https://github.com/lohanidamodar/appwrite_phone_auth.git. Once cloned, open it in your favorite IDE.

We will start by adding Appwrite’s SDK as a dependency. Open pubspec.yaml file and add Appwrite’s SDK under dependencies.



dependencies:
    appwrite: ^6.0.0

If the IDE doesn’t get dependencies automatically, run the following command from the terminal.



flutter pub get

Next, open lib/providers/app_state.dart file. This is where we will configure our Appwrite SDK. First, import the appwrite package.



import 'package:appwrite/appwrite.dart';
import 'package:appwrite/models.dart'; // Response type definitions

In the AuthState class, add new properties.



class AuthState extends ChangeNotifier {
  final _client = Client();
  late final Account  _account;
}

Then in the constructor, let’s configure the client and instantiate the account.



  AuthState() {
    _client.setEndpoint('YOUR_ENDPOINT')
       .setProject(‘YOUR_PROJECT_ID’);
    _account = Account(client);
  }

Once the SDK is installed and configured, the final step is adding the platform to our Appwrite project. Open the Appwrite console and choose the project you created for this application. You can find the Add Platform button on the project home page. Click on the Add Platformbutton and select New Flutter App. In the dialog box that appears, choose the appropriate Flutter platform, assign it a recognizable name, and add the application ID or package name based on the platform. You must complete this step for each Flutter platform you build in your application.

Flutter developers can find more detail instructions on using Appwrite in our official Getting Started for Flutter guide.

Now that our SDK is installed and configured, we are ready to implement phone authentication in our application.

Creating a Session with a Phone

Two steps are needed to create a valid session for users with phone numbers. First, to initiate the session creation process, we will use the setup provider for sending a verification code to the provided phone number. Next, the verification code will confirm and create a valid session for the user. So let’s implement those two methods in our AuthState class.

To initiate the session, we call createPhoneSession from the account service and pass the userId and phone numbers. Passing 'unique()' as userId allows Appwrite to generate a unique Id.



  Future<bool> createSession(String phone) async {
    try {
      final token =
          await _account.createPhoneSession(userId: 'unique()', number: phone);
      userId = token.userId;
      return true;
    } on AppwriteException catch (e) {
      _error = e.message ?? e.toString();
      isLoggedIn = false;
      notifyListeners();
      return false;
    }
  }

Calling createPhoneSession returns a token object with userId. We save the userId because we need it to confirm authentication and create a valid session. To do that, we need to call updatePhoneSession from the account service. Let’s follow the confirmSession method.



Future<bool> confirmSession(String secret) async {
    if (userId.isEmpty) {
      _error = 'userId not known, call `createSession` first to get userId';
      notifyListeners();
      return false;
    }
    try {
      await _account.updatePhoneSession(userId: userId, secret: secret);
      await getAccount();
      return true;
    } on AppwriteException catch (e) {
      _error = e.message ?? e.toString();
      isLoggedIn = false;
      return false;
    }
  }

Now let’s call these methods in the appropriate UI. Open lib/login.dart and find the Login button. In the onPressed action of the button, add the following code after the check.



final success = await ref
  .read(AuthState.provider.notifier)
  .createSession(_phoneController.text);
if (!mounted) return;
if (success) {
  Navigator.pushNamed(context, '/verify');
}

Open lib/verify_phone.dart and find the Verify button. In the onPressed action of the button, add the following code after the check.



final loggedIn = await ref
    .read(AuthState.provider.notifier)
    .confirmSession(currentText);
if (!mounted) return;
if (loggedIn) {
  Navigator.pushReplacementNamed(context, '/');
} else {
  ScaffoldMessenger.of(context).showSnackBar(SnackBar(
    content: Text(ref.read(AuthState.provider).error),
  ));
}

Here we are calling Appwrite with the code received in the SMS. There’s one last thing we need to do -- we need to make a call to get an account. Open lib/providers/app_state.dart and add the following function.



  Future<bool> getAccount() async {
    try {
      user = await _account.get();
      isLoggedIn = true;
      notifyListeners();
      return true;
    } on AppwriteException catch (e) {
      _error = e.message ?? e.toString();
      isLoggedIn = false;
      user = null;
      notifyListeners();
      return false;
    }
  }

Call this function in the constructor of the AuthState, so when the application starts, it checks if we already have a valid session. You can now run the application and see the phone authentication in action.

Conclusion

That’s how easy it is to set up phone authentication with Appwrite. You can choose between different providers --Twilio, Telesign, and TextMagic at the moment. You are also welcome to contribute by adding more providers. To learn more about Appwrite and to integrate it with Flutter, here are a few more resources that might help:

Stripe Payment with Flutter and Appwrite

Damodar Lohani — Wed, 22 Jun 2022 01:49:22 +0000

Stripe is one of the most popular payment providers to accept payments online. In this tutorial, we will integrate Stripe in our Appwrite Store mobile application built with Flutter and receive payments using Stripe. We will be writing the Appwrite cloud function using Dart to process the payments using Stripe.

If you don't know what Appwrite is, Appwrite is a self-hosted backend-as-a-service platform that provides developers with all the core APIs required to build any application.

Prerequisites

To continue with this tutorial and take full advantage of it, you need the following things:

Flutter setup and running - https://docs.flutter.dev/get-started/install
Access to Appwrite project or permission to create one - https://appwrite.io/docs/installation
Stripe account, you can create one for free - https://dashboard.stripe.com/register

💰 Setup Stripe

Let's start by properly setting up our Stripe account to ensure we have all secrets we need in the future. We will be using test mode for this example, but the same steps could be followed in production mode.
You start by visiting the Stripe website and signing up. Once in the dashboard, you can switch to the Developers page and enter the API keys tab. In there, copy the publishable key as well as a secret key. Click the Reveal key button to copy the secret key.

Please make sure you turn on the test mode, so we use test keys and not the real keys for testing purposes.

🔧 Setup Appwrite

Before we move on, we need to set up an Appwrite project. After following installation instructions and signing up, you can create a project with a custom project ID flutter-stripe.

Once the project is created, hop into the Settings page and copy the endpoint, we will need this next to set up our Appwrite CLI.

🧑‍💻 CLI Installation

Let's now install the Appwrite CLI, which we will use in the next section to set up the database required for our application.

Install the CLI using one of the methods from our CLI installation guide. Once the CLI is installed, you need to log in to authorize CLI and gain access to your Appwrite instance.

# Initialize the client
appwrite client --endpoint https://<API endpoint>/v1 

# Login, this command is interactive; login with your console email
# and password
appwrite login

The endpoint is the URL you get from the project settings page.

📜 Source Code

The source code required for this tutorial is available in the GitHub repository. Clone the repository using git or download the zip directly from GitHub and extract. The project comes with an appwrite.json file. Next, let‘s set up collections. The collection is already defined in the appwrite.json, and you need to deploy it. Navigate to the folder containing appwrite.json from your terminal and run the following command to deploy the collection.

appwrite deploy collection

This command will create a new collection in your project, and you can check it via the Appwrite console if you’d like. Next, let's add some products to our products collection.
Let's set up some base products using Appwrite CLI. Still, in the same folder from your terminal, use the following command to add new products.

appwrite database createDocument --collectionId 'products' --documentId 'unique()' --data '{"name":"Appwrite Backpack","price":20.0, "imageUrl": "https://cdn.shopify.com/s/files/1/0532/9397/3658/products/all-over-print-backpack-white-front-60abc9d286d19_1100x.jpg"}' --read 'role:all'

Use the same command to add a few more products with a different name, price, and image of your choice, so that we have something to buy in our shop application. Now we have our Appwrite instance ready and some products in our collection for us to buy. Next, let's set up our mobile application built with Flutter that allows us to log in and buy stuff.

🛠 Flutter Project Set up

In the project you downloaded from GitHub, you can find another folder named flutter_stripe that contains our Flutter shopping application. Let's set it up and run. First, let's set up the configurations. Open the project in your favorite Flutter IDE. Copy flutter_stripe/lib/utils/config.example.dart as flutter_stripe/lib/utils/config.dart and inside it, replace [ENDPOINT] and [PROJECT_ID] with your endpoint and project ID that you got from Appwrite project settings page. Replace [STRIPE_PUBLISHABLE_KEY] with the Stripe's publishable key that you got from the Stripe dashboard starting with sk_test_.

Now run the project in your emulator or your device, and you should see the following screen. We have already implemented registration, login, products display, and shopping cart so we can focus on the stripe integration.

You can create a new account from the registration page and log in to see the products page. There you can add products to your cart and view your cart. Tapping on the Checkout button in the cart will navigate you to an empty page. Let's implement a checkout page to allow payment with Stripe. First, add the [flutter_stripe](https://pub.dev/packages/flutter_stripe) package as a dependency in pubspec.yaml and run flutter pub get to download the dependencies.

Next, let’s initialize the stripe SDK. Open flappwrite_stripe/lib/main.dart and add the following imports.

import 'package:flutter_stripe/flutter_stripe.dart';

Inside the main function, initialize the Stripe SDK

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  Stripe.publishableKey = config.publishableKey;
  Stripe.merchantIdentifier = 'merchent.flappwrite.test';
  Stripe.urlScheme = 'appwrite-callback-${config.projectId}';
  await Stripe.instance.applySettings();
  client.setEndpoint(config.endpoint).setProject(config.projectId);
    runApp(....);
}

Now that Stripe is initialized let's set up the checkout page. Open flappwrite_stripe/lib/screens/checkout.dart and add CardField and an ElevatedButton to confirm the payment as the following.

import 'dart:convert';
import 'package:flappwrite_stripe/providers/cart.dart';
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_stripe/flutter_stripe.dart';
import 'package:appwrite_auth_kit/appwrite_auth_kit.dart';

class CheckoutScreen extends ConsumerWidget {
  CheckoutScreen({Key? key}) : super(key: key);
  final _cardEditController = CardEditController();

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Checkout'),
      ),
      body: ListView(
        padding: const EdgeInsets.all(16.0),
        children: <Widget>[
          if (context.authNotifier.user?.email != null &&
              context.authNotifier.user?.email != '')
            Text(
              context.authNotifier.user!.email,
              style: Theme.of(context).textTheme.bodyLarge?.copyWith(
                    fontWeight: FontWeight.bold,
                  ),
            ),
          const SizedBox(height: 10.0),
          CardField(
            controller: _cardEditController,
          ),
          ListTile(
            title: const Text("Total Amount"),
            trailing: Text(
              '\$${ref.watch(cartTotalProvider).toStringAsFixed(2)}',
              style: const TextStyle(
                fontWeight: FontWeight.bold,
              ),
            ),
          ),
          ElevatedButton(
            onPressed: () => __confirmPressed(context, ref),
            child: const Text("Confirm"),
          ),
        ],
      ),
    );
  }
}

When the confirm button is pressed, we need to charge the user for the total amount of products in their shopping cart. So let's begin.

Let’s define a new method in the widget _confirmPressed.

_confirmPressed(BuildContext context, WidgetRef ref) async {
    // Woops we can't do this yet 
}

The first step here is to get a payment intent by sending Stripe's amount, currency, and customer details, which can only be done from the server-side using Stripe's secret key. So before we proceed further with payment in App, we will write an Appwrite cloud function that will accept the amount to create a payment intent and return the client secret.

☁ Create Payment Cloud Function

We will be using the Appwrite CLI to initialize our function. from the project folder (the folder that contains appwrite.json), spin up a terminal and run

appwrite init function

It's an interactive command that will ask you for a name and runtime. Give it the name createPaymentIntent and choose Dart 2.16 as the runtime. If Dart 2.16 is not available in the list, it's probably not enabled in your Appwrite server. You can do that by updating the _APP_FUNCTIONS_RUNTIMES in the .env file in your Appwrite installation folder. Look at the environment docs to learn more about Appwrite’s environment variables.

Open pubspec.yaml and add dart_appwrite and stripedart under dependencies. Next, we validate the environment variables required by the function to work properly.

final client = appwrite.Client();
final account = appwrite.Account(client);

Future<void> start(final request, final response) async {
  if (request.env['STRIPE_SECRET_KEY'] == null ||
      request.env['STRIPE_PUBLISHABLE_KEY'] == null) {
    return response.send('Stripe payment keys are missing', 500);
  }

  if (request.env['APPWRITE_ENDPOINT'] == null) {
    return response.send('Appwrite endpoint is missing', 500);
  }
}

Once the environment variables are validated, we can initialize the Appwrite SDK.

  final jwt = request.env['APPWRITE_FUNCTION_JWT'];

  client
      .setEndpoint(request.env['APPWRITE_ENDPOINT'])
      .setProject(request.env['APPWRITE_FUNCTION_PROJECT_ID'])
      .setJWT(jwt);

Next, let's get the details of the user executing the function from Appwrite. Let's write a function that gets the user.

Future<User> getUser() async {
  return await account.get();
}

Let's update our start function to get the user details and check if stripe customer id already exists for the user in their preferences.

Future<void> start(final request, final response) async {
    ...
    client
      .setEndpoint(request.env['APPWRITE_ENDPOINT'])
      .setProject(request.env['APPWRITE_FUNCTION_PROJECT_ID'])
      .setJWT(jwt);

    final user = await getUser();
  final prefs = user.prefs.data;
  String? customerId = prefs['stripeCustomerId'];
}

Next, if the customerId doesn't exist, we will create a new account; we will set up Stripe SDK and create a customer.

    var stripe = Stripe(request.env['STRIPE_SECRET_KEY']);

  // create account for customer if it doesn't already exist
  dynamic customer;
  if (customerId == null) {
    customer =
        await stripe.core.customers.create(params: {"email": user.email});
    customerId = customer!['id'];
    if (customerId == null) {
      throw (customer.toString());
    } else {
      prefs['stripeCustomerId'] = customerId;
      await account.updatePrefs(prefs: prefs);
    }
  }

Notice we also save customer ID in the user's preference for next-time access.

Now that we have the customer ID, we can create a payment intent from the amount and the currency provided during function execution.

     // data provided to the function during execution
    final data = jsonDecode(request.env['APPWRITE_FUNCTION_DATA']);
  final paymentIntent = await stripe.core.paymentIntents!.create(params: {
    "amount": data['amount'],
    "currency": data['currency'],
    "customer": customerId,
  });
  response.json({
    "paymentIntent": paymentIntent,
    "client_secret": paymentIntent!['client_secret'],
  });

Our function is now ready, and the complete function looks like this.

import 'dart:convert';

import 'package:dart_appwrite/dart_appwrite.dart' as appwrite;
import 'package:dart_appwrite/models.dart';
import 'package:stripedart/stripedart.dart';

final client = appwrite.Client();
final account = appwrite.Account(client);

Future<User> getUser() async {
  return await account.get();
}

Future<void> start(final request, final response) async {
  if (request.env['STRIPE_SECRET_KEY'] == null ||
      request.env['STRIPE_PUBLISHABLE_KEY'] == null) {
    return response.send('Stripe payment keys are missing', 500);
  }

  if (request.env['APPWRITE_ENDPOINT'] == null) {
    return response.send('Appwrite endpoint is missing', 500);
  }

  // final userId = request.env['APPWRITE_FUNCTION_USER_ID'];
  final jwt = request.env['APPWRITE_FUNCTION_JWT'];

  client
      .setEndpoint(request.env['APPWRITE_ENDPOINT'])
      .setProject(request.env['APPWRITE_FUNCTION_PROJECT_ID'])
      .setJWT(jwt);

  final user = await getUser();
  final prefs = user.prefs.data;
  String? customerId = prefs['stripeCustomerId'];

  var stripe = Stripe(request.env['STRIPE_SECRET_KEY']);

  // create account for customer if it doesn't already exist
  dynamic customer;
  if (customerId == null) {
    customer =
        await stripe.core.customers.create(params: {"email": user.email});
    customerId = customer!['id'];
    if (customerId == null) {
      throw (customer.toString());
    } else {
      prefs['stripeCustomerId'] = customerId;
      await account.updatePrefs(prefs: prefs);
    }
  }
  final data = jsonDecode(request.env['APPWRITE_FUNCTION_DATA']);
  final paymentIntent = await stripe.core.paymentIntents!.create(params: {
    "amount": data['amount'],
    "currency": data['currency'],
    "customer": customerId,
  });
  response.json({
    "paymentIntent": paymentIntent,
    "client_secret": paymentIntent!['client_secret'],
  });
}

Let's deploy the function using the Appwrite CLI. Still, in the project folder containing appwrite.json, use the following command to deploy the function.

appwrite deploy function

This interactive command allows you to choose the functions to deploy. We can use space to select that function and press return to deploy as we have only one. If you now go to your Appwrite console and tap on the Functions from the sidebar, you should see your function in the list. Tap on the Settings button for the function and in the overview, make sure your function is built and ready for execution. If the build has failed, check the logs for the build to figure out what happened.

Finally, we need to set up the function's environment variable. Open your function's settings page and scroll below to find the Variables section. Please tap on the add variable button, add three variables as STRIPE_SECRET_KEY, STRIPE_PUBLISHABLE_KEY, and the APPWRITE_ENDPOINT and give them proper values obtained from Stripe and your Appwrite's endpoint, respectively.

Now let's get back to our Flutter app to set up the rest of the payment flow. Open flappwrite_stripe/lib/screens/checkout.dart and add new method in the widget _fetchClientSecret with the following details.

    Future<String> _fetchClientSecret(BuildContext context, double total) async {
    final functions = Functions(context.authNotifier.client);
    final execution = await functions.createExecution(
        functionId: '[FUNCTION_ID]',
        data: jsonEncode({
          'currency': 'usd',
          'amount': (total * 100).toInt(),
        }),
        xasync: false);
    if (execution.stdout.isNotEmpty) {
      final data = jsonDecode(execution.stdout);
      return data['client_secret'];
    }
    return '';
  }

You can get the FUNCTION_ID from your appwrite.json or the function's settings page in the Appwrite console. Finally, we will complete the _confirmPressed function like the following.

if (!_cardEditController.complete) {
  ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
      content: Text("Card details not entered completely")));
  return;
}

final clientSecret = await fetchClientSecret(
    context, ref.watch(cartTotalProvider));
if(clientSecret.isEmpty) {
    ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
      content: Text("Unable to fetch client secret")));
    return;
}

// you should get proper billing details from the user
final billingDetails = BillingDetails(
  email: context.authNotifier.user!.email,
  phone: '+48888000888',
  address: const Address(
    city: 'Kathmandu',
    country: 'NP',
    line1: 'Chabahil, Kathmandu',
    line2: '',
    state: 'Bagmati',
    postalCode: '55890',
  ),
);

try {
  final paymentIntent = await Stripe.instance.confirmPayment(
    clientSecret,
    PaymentMethodParams.card(
      billingDetails: billingDetails,
      setupFutureUsage: PaymentIntentsFutureUsage.OffSession,
    ),
  );
  if (paymentIntent.status == PaymentIntentsStatus.Succeeded) {
    ref.read(cartProvider.notifier).emptyCart();
    ScaffoldMessenger.of(context).showSnackBar(
      const SnackBar(
        content: Text(
            "Success!: The payment was confirmed successfully!"),
      ),
    );
    Navigator.pop(context);
  }
} on StripeException catch (e) {
  ScaffoldMessenger.of(context).showSnackBar(SnackBar(
      content: Text(e.error.localizedMessage ?? e.toString())));
}

Our Application is now ready. Run the application, add some products to the shopping cart, and tap checkout. On the checkout page, add a test card details 4242 4242 4242 4242, and any valid validity date from the future, and any three-digit number is CCV. Finally, when you tap submit, you should be able to confirm the payment and see that you have received payment in the Stripe dashboard. That’s it; you can now build an application that can accept payment from your users.

🔗 Conclusion

I hope you enjoyed this tutorial. You can find the complete code of this project in the GitHub repository. To learn more about Appwrite, you can visit our documentation or join us on our discord.

Appwrite Zoom OAuth Integration

Damodar Lohani — Tue, 21 Jun 2022 00:45:13 +0000

We just released Appwrite 0.14, and among other excellent features, we also added Zoom OAuth2 support. This new feature will allow you to build applications with Zoom integrations quickly. In this article, we will learn to set up Zoom authentication in our applications using Appwrite. By the end of this tutorial, you will know that setting up Zoom OAuth using Appwrite is so easy that we can do it in a few minutes.

New to Appwrite

Appwrite is an open-source back-end-as-a-service that abstracts all the complexity of building a modern application by providing a set of REST and Realtime APIs for your core back-end needs. Appwrite takes the heavy lifting for developers and handles user authentication and authorization, databases, file storage, cloud functions, webhooks, and much more!

Prerequisites

To follow along with this tutorial, you’ll need access to an Appwrite project or permissions to create one. If you don’t already have an Appwrite server running, follow the official installation tutorial to set one up.

You will also need a Zoom account, and if you don’t have one, you can easily create one for free by visiting https://zoom.us.

Create a Zoom OAuth App

Once we have our Appwrite server up and running, we need to create a Zoom OAuth App from the Zoom App Marketplace.

To create the Zoom OAuth app, log in to your Zoom account in the marketplace and head over to https://marketplace.zoom.us/develop/create and click the Create button on the OAuth app.

Provide a suitable name for your App and choose the App Type to be User-managed app, and click on the Create button.

You will be redirected to your new app’s page, where you can find the Client ID and Client Secret. Copy the production Client ID and Client Secret as we’ll need them in the next step.

Enable Zoom in Appwrite

Next, switch to your Appwrite Dashboard and head over to Users →Settings. This is where we will set up the Zoom OAuth provider. Scroll to the end of the list and enable the Zoom OAuth provider. You’ll be asked to enter the App ID and App Secret from the previous step.

Next, copy the redirect URL from Appwrite’s Zoom OAuth Setting dialog and paste it to your Zoom App’s Redirect URL field for both development and production environments, as well as in the Add allow lists field. If your web application is running in a separate domain, you need to add that to the Add allow lists as well.

Implementing Sign In With Zoom in Your Project

Once you have set up Zoom OAuth credentials in the Appwrite console, you are ready to implement Zoom Sign In in your project. Let's see how we can do it on various platforms.

You can use our client SDKs for various platforms to authenticate your users with OAuth2 providers. Before you can authenticate, you need to add our SDK as dependency and configure it with an endpoint and project ID. To learn to configure our SDKs you can follow the getting started guide for each platform. The appropriate links are provided in each section below. Once you have the SDK configured, you can instantiate and call the account service to create a session from the OAuth2 provider. Below are the examples for different platforms to initialize clients and perform OAuth2 login.

Web

First you need to add a web platform in your project from the Appwrite console. Adding a web platform allows appwrite to validate the request it receives and also prevents cross origin errors in your browser. In the project settings page, click on Add Platform button and select New Web App. In the dialog box that appears, give a recognizable name to your platform and add the host name of your application.

Follow the Getting Started for Web guide for detailed instruction on how to use Appwrite with your web application.

const appwrite = new Appwrite();

appwrite
  .setEndpoint('YOUR_END_POINT')
  .setProject('YOUR_PROJECT_ID');

try {
    await appwrite.account.createOAuth2Session(
        "zoom",
        "[YOUR_END_POINT]/auth/oauth2/success",
        "[YOUR_END_POINT]/auth/oauth2/failure",
    );
} catch (error) {
    throw error;
}

Flutter

For Flutter, in Android, to properly handle redirecting your users back to your mobile application after completion of OAuth flow, you need to set the following in your AndroidManifest.xml file.

<manifest ...>
  ...
  <application ...>
    ...
    <!-- Add this inside the `<application>` tag, along side the existing `<activity>` tags -->
    <activity android:name="com.linusu.flutter_web_auth.CallbackActivity" android:exported="true">
      <intent-filter android:label="flutter_web_auth">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="appwrite-callback-[PROJECT_ID]" />
      </intent-filter>
    </activity>
  </application>
</manifest>

You also need to add the Flutter platform in your project from the Appwrite console. Adding Flutter platforms allows appwrite to validate the request it receives and also prevents requests from unknown applications. In the project settings page, click on Add Platform button and select New Flutter App. In the dialog box that appears, select the appropriate Flutter platform, give a recognizable name to your platform and add the application ID or package name based on the platform. You need to follow this step for each Flutter platform you will build your application for.

For more detailed instructions on getting started with Appwrite for Flutter developers follow our official Getting Started for Flutter guide. Finally, you can call account.createOAuth2Session from your application as shown below.

import 'package:appwrite/appwrite.dart';

void main() async {
    final client = new Client();

    client
    .setEndpoint('YOUR_END_POINT')
    .setProject('YOUR_PROJECT_ID');

    final account = Account(client);

    try {
        await account.createOAuth2Session(
            provider: "zoom"
        );
    } catch (error) {
        throw error;
    }
}

Android

For Android, to properly handle redirecting your users back to your mobile application after completion of OAuth flow, you need to set the following in your AndroidManifest.xml file.

<manifest ...>
  ...
  <application ...>
    ...
    <!-- Add this inside the `<application>` tag, along side the existing `<activity>` tags -->
    <activity android:name="io.appwrite.views.CallbackActivity" android:exported="true">
      <intent-filter android:label="android_web_auth">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="appwrite-callback-[PROJECT_ID]" />
      </intent-filter>
    </activity>
  </application>
</manifest>

You also need to add the Android platform in your project from the Appwrite console. Adding Android platforms allows appwrite to validate the request it receives and also prevents requests from unknown applications. In the project settings page, click on Add Platform button and select New Android App. In the dialog box that appears give your platform a recognizable name and add the package name of your application.

For more detailed instructions on getting started with Appwrite for Android developers follow our official Getting Started for Android guide. Finally, you can call account.createOAuth2Session from your application as shown below.

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import io.appwrite.Client
import io.appwrite.services.Account

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val client = Client(applicationContext)
            .setEndpoint("https://[HOSTNAME_OR_IP]/v1") // Your API Endpoint
            .setProject("5df5acd0d48c2") // Your project ID

        val account = Account(client)

        GlobalScope.launch {
            account.createOAuth2Session(
                activity = this@MainActivity,
                provider = "zoom"
            )

        }
    }
}

Apple

To capture the Appwrite OAuth callback URL, the following URL scheme needs to add to your Info.plist

<key>CFBundleURLTypes</key>
<array>
<dict>
    <key>CFBundleTypeRole</key>
    <string>Editor</string>
    <key>CFBundleURLName</key>
    <string>io.appwrite</string>
    <key>CFBundleURLSchemes</key>
    <array>
        <string>appwrite-callback-[PROJECT_ID]</string>
    </array>
</dict>
</array>

You also need to add Apple platform in your project from Appwrite console. Adding Apple platforms allows appwrite to validate the request it receives and also prevents requests from unknown applications. In the project settings page, click on Add Platform button and select New Apple App. In the dialog box that appears select appropriate Apple platform tab and give your platform a recognizable name and add the package name of your application. For each supported Apple platform you need to follow this process.

For more detailed instructions on getting started with Appwrite for iOS developers follow our official Getting Started for Apple guide. Finally, you can call account.createOAuth2Session from your application as shown below.

import Appwrite

let client = Client()
    .setEndpoint("[YOUR_ENDPOINT]")
    .setProject("[YOUR_PROJECT_ID]")

let account = Account(client)

account.createOAuth2Session(
    provider: "zoom"
){ result in
    switch result {
    case .failure(let err):
        print(err.message)
    case .success:
        print("logged in")
    }
}

Conclusion

Well, that’s all that is to set up Zoom OAuth-based authentication with Appwrite. It is straightforward using Appwrite to set up Zoom OAuth-based authentication in your application. Following resources can be handy if you want to explore Appwrite further.

Implementing OAuth on Flutter with Appwrite

Damodar Lohani — Fri, 17 Jun 2022 04:18:17 +0000

Today, we will learn to set up social authentication in our Flutter applications using Appwrite. By the end of this tutorial, you will know that setting up social authentication in the Flutter app using Appwrite is so easy that it can be done in a few minutes.

Prerequisites

To take full advantage of this tutorial, you need the following:

Access to the Appwrite project or permission to create one. If you don’t already have an Appwrite server running, follow the official installation tutorial to set up one.
Flutter configured development machine.

Source Code

To begin, clone the repository I’ve prepared for this tutorial where I have already set up a basic UI so that we can focus on implementing social login with Appwrite. We will start by adding and configuring the Appwrite SDK.

Configure Appwrite’s SDK

First, open pubspec.yaml and add appwrite: 4.0.2 as a dependency, and run flutter pub get.

dependencies:
    appwrite: 4.0.2

Next open main_screen.dart and import the package.

import 'package:appwrite/appwrite.dart';

In the _MainScreenState , let’s configure the client.

First, create a client property.

class _MainScreenState extends State<MainScreen> {
    final Client client;
    ...
}

Then in initState function, we configure the client.

client = Client();
client
    .setEndpoint('https://demo.appwrite.io/v1') // your endpoint
    .setProject('flappwrite_oauth'); // Yout project id

Configure Discord OAuth

Either use an existing Appwrite project or create a new one. Go to Users →Settings. This is where we will set up the OAuth providers. Let’s first set up Discord. Click to turn on the Discord’s switch.

We need to fill in the app ID and secret in the dialog that appears. We can get that from the Discord developer portal following the official guide. Copy the callback URL provided in the dialog and paste it into Discords setup for the redirect URL. Click Update once the app ID and secrets are filled.

Configure Google Sign In

In the Appwrite console, visit the Users→Settings page. There, find Google from the list and turn the switch on. To complete this, you will need an App ID and App Secret, which you can easily set up from Google API Console. Check out their official documentation for more details.

Once you get and fill in the Google App ID and the App Secret, you need to provide the callback URL shown in the dialog to the Google OAuth2's Authorized redirect URIs.

Authorized JavaScript origins are required only for a web app. If you are also using Flutter web, you should add the URL as the Authorized JavaScript origins

Now that we have configured Google and Discord OAuth in the Appwrite console, we will implement this social auth in our Flutter application in the next section.

Implement OAuth login on Appwrite

Before we can make any request to the Appwrite server from our applications, we need to add the platform we are building for Appwrite. On the project dashboard, click Add Platform → New Flutter App.

In the dialog that appears, add the relevant platforms. I’ll be adding Android. If you want to add more than one platform, follow the same process for each platform.

Next, in Android, to handle redirection successfully after the authentication is completed, we need to add the following to the AndroidManifest.xml.

<manifest ...>
  ...
  <application ...>
    ...
    <!-- Add this inside the `<application>` tag, along side the existing `<activity>` tags -->
    <activity android:name="com.linusu.flutter_web_auth.CallbackActivity" android:exported="true">
      <intent-filter android:label="flutter_web_auth">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="appwrite-callback-[PROJECT_ID]" />
      </intent-filter>
    </activity>
  </application>
</manifest>

For iOS, version 12+ and macOS version 10.15+ are required for OAuth to work.

Finally, we can now log in with Google and Discord in our Application. It is straightforward. We instantiate Account with an instance of Client and call createOAuth2Session.

final account = Account(client);
account.createOAuth2Session(provider: 'google');

Open main_screen.dart find _MainScreenState, and there find the handleLogin function. This is called when we press Google login or Discord login buttons. We pass the respective provider, google, or discord as the param. Update the handleLogin function as the following.

handleLogin(String provider) async {
    await Account(client).createOAuth2Session(
      provider: provider,
    );
    checkedLoggedIn();
  }

The first thing to note, we only need to pass the provider and not the success and failure URL. Success and failure URLs are required only if we implement our own web application that handles completing the login process from the authorization code obtained from OAuth providers. However, this is handled by the Appwrite server internally, so we don’t need to provide the success and failure URLs.

Another thing to note, the log-in and sign-up process for OAuth-based authentication are the same, and the createOAuth2Session automatically creates a User if it doesn’t already exist in Appwrite. Also, if a user account already exists with the same email address, the OAuth session is linked to the same user account.

Conclusion

Well, that’s all that is required to set up OAuth-based authentication with Appwrite. The final code can be found in the final branch of the repository. The challenging parts are setting up the specific provider and getting the client ID and secret from them. The rest is straightforward using Appwrite. Following resources can be handy if you want to explore Appwrite further.

What's New in Appwrite's Storage

Damodar Lohani — Wed, 09 Mar 2022 19:45:41 +0000

Appwrite comes with a robust storage service to help you manage files required for your application. Appwrite’s storage service provides API for uploading and managing files, manipulating images, getting image previews, and more. It has built-in security, access control using users, teams, and roles, built-in encryption, and antivirus scanning. Also, the image preview manipulation endpoint comes with caching to keep it efficient. With the release of Appwrite 0.13, we are adding more power to Appwrite’s already powerful storage service. We have introduced buckets to group files with additional configurations. We have improved efficient handling of large files and have introduced support for external storage services to use as Appwrites storage location. Let’s look at each of these new features independently

Appwrite is an open source backend-as-a-service that abstracts all the complexity involved in building a modern application by providing you with a set of REST APIs for your core backend needs. Appwrite handles user authentication and authorization, databases, file storage, cloud functions, webhooks, and much more! If anything is missing, you can extend Appwrite using your favorite backend language.

Buckets

With version 0.13 of Appwrite, we have introduced buckets. Buckets are simply a collection of files. If you have previously worked with Appwrite’s database service, buckets are similar to collections in database service. Buckets allow you to have additional control over your files. You can group files based on domain, type, or any other logic that suits your application using buckets. Buckets make file organization better. Not only that, buckets allow you additional control by specifying what type and size of files can go into it, whether or not to encrypt the files in the bucket and whether or not to scan files going into the bucket with antivirus. To learn more about buckets, visit our storage docs.

External Storage Support

Files are important and even important is to have them in a reliable storage. Appwrite 0.13.0 introduces support for AWS S3 and DigitalOcean spaces as a storage solution for Appwrite. So, if you want to, you can set any files uploaded to Appwrite storage to directly be uploaded to AWS S3 bucket or DigitalOcean spaces. In the upcoming days we will introduce support for more storage solutions so that you will not be limited to these two services. To learn more about setting up Appwrite to use S3 or DigitalOcean spaces, check out the storage environment variables docs.

Large File

There are many applications where we would want to use and store huge files. Appwrite 0.12, and the previous versions did not handle large files efficiently. From version 0.13, Appwrite handles the uploading and downloading of large files efficiently. You can now upload gigabytes of files easily using the chunked upload process. Appwrite uploads large files by breaking them into smaller chunks so that the server can handle them efficiently and the API is more robust and stable. Check out our blog post to learn more about implementing large file support.

Conclusion

Storage is an essential service for applications, and Appwrite, a back-end service, provides a practical storage service that you can use to manage your application files. And with the 0.13 version of Appwrite, the storage service adds more powerful features that will help you organize your files, play with large files for complex applications, and more. We hope these new features of Appwrite will open up a whole new domain of possibilities for developers out there. We can’t wait to see what you will build with it.

Efficiently Handling Large Files Upload and Download

Damodar Lohani — Tue, 08 Mar 2022 16:41:54 +0000

Introduction

Uploading files to remote servers is an essential operation for many applications. While developing a tool like Appwrite, it is crucial to efficiently handle the uploading of files to use it in their application without being concerned about the efficiency and reliability. Managing files upload comes with a challenge when dealing primarily with huge files. We need to think about efficient resource usage in both the client and server and a reliable upload process. This article will discuss our learning from adding support for huge file upload in Appwrite’s 0.13 release. So let’s get started.

Appwrite is an open source backend-as-a-service that abstracts all the complexity involved in building a modern application by providing you with a set of REST APIs for your core backend needs. Appwrite handles user authentication and authorization, databases, file storage, cloud functions, webhooks, and much more! If anything is missing, you can extend Appwrite using your favorite backend language.

Overview

First, when discussing file uploads using the HTTP protocol, let us understand the basic upload process from client and server perspectives. To upload a file to the client, first, we load the file into memory and make a request over HTTP to the server. The server then receives the file and saves it in a temporary location. Then we can decide to move the file to the appropriate location. The problem with this process is that the server freezes until the file is completely uploaded. And If we want to handle huge files, say gigabytes of files, we would need as many resources, memory, and CPU to handle those files. Also, the server would take much time to respond to requests. If the upload fails in between, the client will have to re-initiate the upload process from the beginning, which wastes time and resources. Also, imagine a server where hundreds of users are trying to upload gigabytes of files simultaneously. The server would need considerable resources to handle those requests. Many requests will have to wait long before the server can respond to them if the server resources are limited, which is not recommended. So this method is suitable for reasonably small file size uploads. Now that we know the challenges of uploading files, we will discuss what options are available to upload files in the next section.

Handling File Uploads

Researching the ways to handle file uploads to web servers, we mainly found two ways. On is the basic upload process we discussed in the previous section. If we use this approach, it is recommended to set a maximum upload size limit to around 20-30 MB to keep things simple and effective. But for us, that was not an option, as a developer tool limiting our users and would be unsuitable for various applications.

The next method that we found was the chunked upload process. Which was efficient, less resource-intensive, and in case of failure, would support resumable upload. Which meant we could use this for smaller as well as huge files. And that is what we decided to implement in Appwrite 0.13 to power our developers. In the next section, we will look into how this method works and its efficiency.

Chunking and Content Range

Until a specific file size, it is okay to use the simple file upload approach. However, when the file size grows, it is recommended to use chunked upload. So how do we upload files using chunks? In this method, we don’t send the whole file in a single request; we instead send a chunk (a part of the file) and make multiple requests with each part. The benefit is that the server doesn’t have to receive the whole file at once but rather receives small chunks. This makes both the upload process and server responsive. Also, we can only upload those chunks that failed; we don’t have to upload the whole file again. This makes uploading large files efficiently, even over unstable connections. Also, this opens up another possibility to upload multiple chunks in parallel, making the upload process much faster if the network bandwidth allows. While sending each chunk, we set the associated content-range header. The server uses the content-range header to determine the total chunks uploaded and part of the file the chunk belongs to. The content-range header is defined in the HTTP specification. The syntax is defined as the following

Content-Range: <unit> <range-start>-<range-end>/<size>
Content-Range: <unit> <range-start>-<range-end>/*
Content-Range: <unit> */<size>

We need to set the unit, generally in bytes, and then the range-start is the start offset of this chunk and range-end is the end offset of this chunk, and finally, the size is the total size of the file. The value of range-start, range-end, and size must be in the unit provided. These headers in each chunk will tell the server exactly how to combine the chunks to get the original file. Now that we know how the chunked upload process works let’s see how we can make the upload process resumable in the next section.

Resumable Upload

With the implementation of chunked upload, it is relatively easy to implement resumable uploads. To make it happen, we can track each successful chunk uploaded and each that has failed during upload. Whenever the upload process stops in between, we will record all the successfully uploaded chunks. Next time, we can start the upload process only for the remaining chunks. This makes it very easy to upload large files over an unstable connection as we can upload small chunks and only upload failed and remaining chunks with as many retries as possible.

Conclusion

Handling file uploads reliably and efficiently can be challenging. We saw in this article that we have two ways of uploading files: one, we upload the whole file in a single request, and another where we upload a file in smaller chunks. We should use the first approach for smaller file sizes, maybe up to 20-30MB, and for any file larger than that, it's best to implement a chunked upload to make the upload process reliable and efficient. We hope this article will be helpful to anyone trying to build an upload service. However, if you are using Appwrite, you will not have to think about all these things. Appwrite handles everything internally to provide reliable and efficient storage service to upload and manage files.

Working with database indexes ( the right way )

Damodar Lohani — Wed, 12 Jan 2022 12:39:59 +0000

👀 Overview

The database is an integral part of any modern application. We use a database to provide pre-filled information to our users or sync information supplied by users across their devices or their shared community and a failure can cause massive damage to our application and its users. That means, all modern applications must have well structured, scalable, and maintained database to provide optimum service to our users. A database index is an essential feature of any database system, which helps make the database more performant to access data according to the needs of our application. Using database indexes effectively can make your queries much faster, hence making your application much more performant. Who doesn't love extra seconds of responsiveness in their application?

🎬 Introduction to Database Indexes

Indexes are a data structure technique used to quickly locate and access data in the database. It improves the performance of the database by minimizing the number of disk reads required to find the data.

An index is a small table with only two columns, a key, and a reference. The key is the candidate key of the table that we want to index, and the reference column contains pointers to hold the disk block address where the value for that specific key is stored. An index takes a search key as the input and returns a collection of matching records. Imagine you have to find data in a persons table with the person's name, and suppose you don't have an index. Then the database will have to look at each record to figure out whether or not it is the matching record. Going through every record in a table is called a full table scan, and it takes a long time, based on the number of records in the table. However, if you have indexed the table's name column when you search for a particular name, the database will first query the index and get the pointer to the data, then get the matching data. This way database will have to go through only the index instead of scanning the whole table. An index table might be shorter than the data table itself and is sorted to be able to search efficiently.

If it seems too complex to understand, let's take an example from something simpler. Let's assume that we have a box that contains small pieces of paper with English words written on them, one for every word in the English language, and on the back side has the definition of the word. How would we find the definition of 'simplicity'? The slowest way would be to read each piece of paper, one by one, until we find the definition. Though, we could find it much faster if we had all the words sorted ahead of time.

In other words, we need a dictionary.

Finding definitions of words is much faster with a dictionary in hand since the words are listed in alphabetical order. How would we use a dictionary to speed up our search? We would open to a page, look at the first word, and check if we need to flip ahead or back in the book. We repeat this until we find the right page, and eventually, the definition of 'simplicity'. So how would we instruct a computer to do this sort of search? We'll need ask everyone's favorite Computer Science subject for the answer: data structures and algorithms, but only in a simplified way 😉

Our dictionary search is faster because we can quickly eliminate the need to check large chunks of pages - if we flip to the middle-most page in the dictionary and check the first word on the page, we eliminate the need to check half of the pages of the entire dictionary. The data structure representation of this concept is the binary search tree, or B-tree. This data structure optimizes our search from scaling linearly (O(n)) to scaling logarithmically (O(log(n))), which results in massive performance gains for big data sets.

The downside to indexing is that indexes require additional space on the disk. Also, these indexes are kept in sorted order to access the corresponding data quickly, and one can perform a binary search on the index itself. It's important to keep the index balanced along with the constantly updating data. This means that with every write operation (insert, update and delete), the index will also have to be updated, decreasing the write performance.

Creating an index requires additional disk space and also decreases the write performance. So too many indexes can cause issues arising from file systems size limits, degraded write performances, and more. We should be careful and plan what fields we want to index. A poorly indexed database is as bad or worse than a database that is not indexed.

🧑‍💻 Types of Database Indexes

Indexing in Database is defined based on the attributes it's indexing. There are four main types of indexing methods that are:

Primary Indexes

A database table must have some way to uniquely identify each record, so it can read and write data from the correct block of storage. A primary index serves this purpose: by requiring a unique ID for each record, the database can prepare a pre-sorted list (a B-tree, usually) of IDs that point to their locations on disk, vastly improving the speed to find individual records.

Unique Indexes

Primary indexes require a unique identifier that it maps to the record's disk location (for good reason), but we can use B-trees to enforce any attribute to be unique.

Secondary Indexes

Databases can use B-trees to prepare similar pre-sorted lists for any attribute of data that's commonly queried. If we commonly check our Inventory for low-stock items (count < 5), we can increase query performance by creating a secondary index for the count field. We can do the same across multiple attributes (count < 5 && price > 100), but the order and sorted direction increasingly matters as you add more attributes.

Fulltext Indexes

If we want to search for specific text, databases support fulltext indexes to create data structures to support this. The implementation of fulltext indexes can vary between different database systems, but the principle allows us to check our Inventory for items with name LIKE apple.

It's common that where clause use indexes. However, B-tree indexes can also help the order by, group by, select and other clauses.

🔖 Introducing Indexes in the Appwrite Database

Appwrite is an open-source back-end server for all your apps, be it Flutter, Web, Android, or iOS. It helps developers innovate by taking care of modern application development's complex and repetitive parts. Appwrite provides authentication, database, storage, cloud functions, realtime APIs, webhooks, and more. With version 0.12 of Appwrite, we are pleased to announce the newest refactored database service with support for powerful queries and indexes.

Appwrite 0.12 comes with a refactored database service. We bring a database service that is much on par with the DBMS service we implement internally with this version. We get features like indexes, advanced queries, and more to our database. The basic attributes of our database are on par with the underlying database. On top of that, we have added advanced attributes like URL, email, and more that allows you to design complex data structure for your application with proper validation without much work.

Another significant feature introduced with the database in this version are indexes. We already saw above how important indexes are for performance, so we bring you the power to manage your indexes with the Appwrite database to make your queries even more performant. We also made a design decision with Appwrite's new database. With this version, we only allow querying on the fields that have indexes. If you have previously used databases like MariaDB or MySQL, they will enable you to perform queries even when you have not created any index which can lead to full table scans. This is a huge performance hit and can cause database bottlenecks. That is why with Appwrite, we prevent such queries.

🗂 Indexes Supported by Appwrite

Appwrite as of writing of this article supports unique, key and fulltext indexes. Let's look at each of these indexes, what they are and when to create these.

Unique Index

A unique index must use unique values. However, values can be null. Appwrite uses MariaDB's unique index internally, so you get all the benefits of MariaDB's unique index. Each key in the unique index identifies only one record. However, each record in the table may not be represented because of the possibility of the null value. That means you can create a unique key index for unique attributes. For example, suppose you have a user profile collection where you store users' email. In that case, you can create a unique index for email attribute both to prevent duplication and easily find records using email. You can also create a unique index for a combination of attributes. For example, if you support multiple user profiles with different names, you can create a unique index for a combination of email and name attribute.

Key Index

The key index doesn't have to be unique. You might want to add an index to attributes that you want to filter and order your records during accessing. Appwrite uses MariaDB's plain indexes internally, so you get all the benefits of MariaDB's key index. For example, if you are ordering the list of users in the decreasing order of their joining date, you can create a key index for dateJoined in descending order. This will improve performance, as we already discussed above.

Fulltext Index

Fulltext indexes allow searching a portion of text in an attribute. Appwrite uses MariaDB's Fulltext index internally, so you get all the benefits of a full-text index from MariaDB. For example, in your users table, if you have a short biography attribute where users store their short bio, and your application allows searching for users based on words mentioned in their bio, then it's a good idea to create a full-text index for the biography attribute. If you want to pre-populate large data sets in your collection, it's best to first populate the collection with data and then create the required indexes.

Now that we know what indexes are supported by Appwrite let's look at how we can manage indexes in Appwrite. There are two ways you can achieve this, first is using Appwrite's console, and the second is using Appwrite's server-side APIs and SDKs. We will look at both ways. Before moving on to managing indexes, if you have not already installed Appwrite, visit our installation docs.

🕵️‍♂️ Managing Indexes in the Appwrite Database

We have already learned the importance of the indexes above. And same implies to Appwrite's database service as well. Having proper indexes affects a lot in performance. You can use this benchmarking to reference how performance is impacted by having and not having indexes.

Create Collection and Attributes

Before we can create an index, we first need to create a collection and few attributes. So we will create a courses collection that will have the following attributes.

+--------------+--------+------+----------+-------+---------+
| Attribute Id | Type   | Size | Required | Array | Default |
+--------------+--------+------+----------+-------+---------+
| title        | string | 255  | true     | false | null    |
+--------------+--------+------+----------+-------+---------+
| slug         | string | 255  | true     | false | null    |
+--------------+--------+------+----------+-------+---------+
| description  | string | 1000 | false    | false | null    |
+--------------+--------+------+----------+-------+---------+
| authors      | string | 60   | false    | true  | null    |
+--------------+--------+------+----------+-------+---------+
| category     | string | 60   | false    | false | null    |
+--------------+--------+------+----------+-------+---------+
| credit       | float  | -    | true     | false | null    |
+--------------+--------+------+----------+-------+---------+

To create a new collection, log in to the Appwrite console, create a project, or access an existing one. Then access the database by clicking on the Database from left side menu. Once there, you can click on the Add Collection button. You will see a dialog to choose a custom id if you wish to by clicking on the edit icon next to the auto-generated field. Now enter the collection id as courses and name as Courses. Finally, click on the Create button, and you should be directed to a new page with collection details. Access the Attributes tab, and to create attributes, carry out the following steps.

Click on the Add Attribute button and select New String Attribute

In the dialog box you receive, set title as the attribute id.
Size, make it 255
Make it required and
Click on the Create button.

This should add the title attribute. Repeat steps 1 to 6 for each attribute choosing the right option to create attributes defined above.

Create Indexes

Now that we have a collection and attributes, we can plan our index. First, we would like to perform a text search on the title, so we should create a full-text index for the title. Then we want the slug to be unique, so we should create a unique index for the slug attribute. Finally, we might want to filter by author, category, and credit, so we create the key index for each attribute. Now that we have a plan for indexing, let's create those indexes. First, access the indexes tab. Once there, follow the given steps to add an index.

Click on the Add Index button to access the dialog

Now, type title_fulltext in the Index Key field
Select Fulltext as the type and
Under attributes, just select title and leave the ordering as ASC

This should add a Fulltext index for the title attribute. The newly added index should be listed in the indexes tab. Now repeat steps 1 to 4 for every index we planned above, choosing the appropriate options to create all the required indexes.

You can also use Appwrite's server-side SDKs to create these indexes. If you have never used server SDK, please go through the getting started with server docs. You can use the SDK of your choice and use createIndex function as described in docs from Appwrite's database service to add a new index. There are also methods to create collection, create attributes, indexes and update, delete them. This way, you can write and save a script that can add collection, create attributes and create indexes that you can run on any Appwrite instance to set up your collections.

Deleting Indexes

If you want to delete or remove an index that you are no longer using in your applications, you can do it easily from the indexes tab. While there, you can see the list of available indexes in a table with a delete button for each row. Click the delete button on the row of the index you want to delete, and in the confirmation dialog that appears, click ok. If you accidentally delete an index, you can easily recreate it. However, it might take much time if the database already has tons of data. You can also use deleteIndex function from the database service using the server-side SDKs.

Now that we know how to manage indexes with Appwrite database, let's look at how to choose indexes correctly.

🧭 Choosing Indexes

You should carefully plan what indexes to add based on the queries you make from your applications. Any extra indexes will waste resources as well as hamper performance. The index may not make much difference in a small collection, but as soon as your collection grows, indexes will start to speed queries dramatically. If you want to perform a search query, you should create a full-text index. With Appwrite, we also notify you when you try to query an un-indexed field, so you know what to index. If you created an index but have not used it, remove those to increase create and update queries performance.

👋 Conclusion

Database indexes are a critical aspect of database design for your application, and with Appwrite, we make it easy to manage your indexes. Properly planned indexes will improve performance by a lot and prevent database failure. We hope this article was a helpful guide to database indexing while designing a data structure for your next application and will help you build robust and performant apps. If you have any queries ( pun intended! ) or confusion, please reach us on our Discord server.

📚 Resources

To learn more about Appwrite and its services, including the Database service we discussed in this article, you can use the following resources.

Discord Server
Database Documentation
Appwrite Database Benchmarks
[Getting Started with Server Side SDKs](https://appwrite.io/docs/getting-started-for-server

Forem: Damodar Lohani

Appwrite is now available as a one-click app on the Akamai cloud (Linode) marketplace

Step-by-step guide

Learn More

Join our #30DaysMasterFlutter Challenge and Learn Flutter & Dart in One Month!

Protect Your Applications from Bad Passwords - Introducing Password History

🔐 Password History

Conclusion

I Built Bitly Clone with Redis, Express Svelte and Node ( RESN)

Overview of My Submission

Submission Category:

Video

Language

Link to Code

lohanidamodar / redis-hack-urlshortner

URL Shortener app built for redis x dev hackathon

URL Shortener with Node.JS and Redis

Table of Contents

Screenshots

Overview video

How it works

How the data is stored:

Additional Resources / Info

Appwrite Loves Open Source: Why I Chose to Support Provider and Riverpod

🧠 State Management in Flutter

☢️ Open-source Software (OSS) Is Hard

🔗 Learn More about Appwrite

Appwrite Phone Authentication with Flutter

Prerequisites

Twilio Account Setup

Appwrite Setup

Creating a Session with a Phone

Conclusion

Stripe Payment with Flutter and Appwrite

Prerequisites

💰 Setup Stripe

🔧 Setup Appwrite

🧑‍💻 CLI Installation

📜 Source Code

🛠 Flutter Project Set up

☁ Create Payment Cloud Function

🔗 Conclusion

Appwrite Zoom OAuth Integration

New to Appwrite

Prerequisites

Create a Zoom OAuth App

Enable Zoom in Appwrite

Implementing Sign In With Zoom in Your Project

Web

Flutter

Android

Apple

Conclusion

Implementing OAuth on Flutter with Appwrite

Prerequisites

Source Code

Configure Appwrite’s SDK

Configure Discord OAuth

Configure Google Sign In

Implement OAuth login on Appwrite

Conclusion

What's New in Appwrite's Storage

Buckets

External Storage Support

Large File

Conclusion

Efficiently Handling Large Files Upload and Download

Introduction

Overview

Handling File Uploads

Chunking and Content Range

Resumable Upload

Conclusion

Working with database indexes ( the right way )

👀 Overview

🎬 Introduction to Database Indexes

🧑‍💻 Types of Database Indexes

🔖 Introducing Indexes in the Appwrite Database

🗂 Indexes Supported by Appwrite

🕵️‍♂️ Managing Indexes in the Appwrite Database