DEV Community: Shinya Kato

How to Deploy Dart Functions to AWS Lambda

Shinya Kato — Wed, 08 May 2024 07:35:25 +0000

Introduction

While AWS Lambda, a highly popular serverless computing service, does not officially provide a Dart runtime, you can deploy functions created in Dart to AWS Lambda using the custom runtime mechanism.

Deploying Dart functions to AWS Lambda enables you to utilize them not only within AWS Lambda but also integrate them with services like Amazon API Gateway, allowing you to leverage them in Flutter applications as well. This unified codebase in Dart offers great convenience.

In this article, we will briefly introduce how to deploy Dart functions to AWS Lambda.

Preparation

In this article, we will use Serverless Framework and Docker Desktop to deploy Dart functions to AWS Lambda. If you haven't installed them yet, please complete the installation using the following commands or links.

Additionally, you'll need an AWS account and access tokens for AWS services.

AWS Account

https://aws.amazon.com

AWS Authentication Token

Once you have generated the authentication token, set it in the environment variables as follows:

export AWS_ACCESS_KEY_ID=xxxxxxxxxx
export AWS_SECRET_ACCESS_KEY=xxxxxxxxxx

Serverless Framework

brew install serverless

https://www.serverless.com/

Docker Desktop

https://www.docker.com/products/docker-desktop/

Implementation and Registration of Functions

Now let's implement the Dart function to deploy it to AWS Lambda.

Project Structure

We'll proceed with the following structure. Details about Dockerfile and serverless.yml will be explained later.

.
├── Dockerfile
├── LICENSE
├── analysis_options.yaml
├── lib
│   ├── functions.dart
│   └── main.dart
├── pubspec.lock
├── pubspec.yaml
└── serverless.yml

Installing Packages

When deploying to AWS Lambda, you'll need to use the Dart custom runtime aws_lambda_dart_runtime_ns. Please add it to your dependencies in pubspec.yaml using the following command or manually:

https://pub.dev/packages/aws_lambda_dart_runtime_ns

dart pub add aws_lambda_dart_runtime_ns

dart pub get

name: sample

environment:
  sdk: ^3.3.4

dependencies:
  aws_lambda_dart_runtime_ns: ^0.0.13

dev_dependencies:
  lints: ^3.0.0
  test: ^1.24.0

Creating a Function to Deploy to AWS Lambda

Let's create a simple function to deploy to AWS Lambda.
For now, let's make the function simply return the string Hello, World! when called.

import 'package:aws_lambda_dart_runtime_ns/aws_lambda_dart_runtime_ns.dart';

FunctionHandler get sayHelloWorld {
  return FunctionHandler(
    name: 'hello-world',
    action: (context, event) {
      // Perform various operations here such as 
      // file IO, database operations, etc.

      return InvocationResult(
        requestId: context.requestId,
        body: {
          'message': 'Hello, World!',
        },
      );
    },
  );
}

To briefly explain, the FunctionHandler object represents the function executed on AWS Lambda.

The name of FunctionHandler is the required name when the function (or command) is invoked.
Additionally, this name must be associated with the command definition in serverless.yml, which will be introduced later.

The action of FunctionHandler defines the actual behavior of the function (or command). In this example, it simply returns the message 'Hello, World!', but you can perform various operations such as file operations or DB operations within action.

The InvocationResult needed to be returned in action represents the result of the processing. You can set any JSON data in the body of InvocationResult.

Registering the Created Function to the Custom Runtime

Let's register the sayHelloWorld function we created earlier to the custom runtime. It's very simple.

import 'package:aws_lambda_dart_runtime_ns/aws_lambda_dart_runtime_ns.dart';
import 'package:sample/functions.dart' as fn;

Future<void> main(List<String> args) async {
  await invokeAwsLambdaRuntime([
    fn.sayHelloWorld, // This is what you need to do
  ]);
}

When registering the created function to the custom runtime, all you need to do is call the invokeAwsLambdaRuntime function and pass the functions you want to register as arguments.

With this, the process of creating the function you want to register with AWS Lambda and registering it with the custom runtime is complete.

Deploying to AWS Lambda

Once you've reached this point, all that's left is to deploy the program you've created to AWS Lambda.
We'll define the Dockerfile and serverless.yml as follows:

I'm not very knowledgeable about hardware, but it seems that using ARM-based AWS Graviton makes you happy, so we'll proceed with an architecture based on arm64.

Dockerfile

FROM arm64v8/dart:latest as build-image

WORKDIR /work
COPY ./ ./

RUN dart pub get
RUN dart compile exe ./lib/main.dart -o ./bootstrap
RUN chmod +x bootstrap

FROM --platform=linux/arm64 public.ecr.aws/lambda/provided:latest

COPY --from=build-image /work/bootstrap /var/runtime/

CMD ["dummyHandler"]

If the folder structure where the Dart program is located is different, please modify the ./lib/main.dart part accordingly.

serverless.yml

service: sample-app

provider:
  name: aws
  runtime: provided
  timeout: 30
  region: ap-northeast-1
  architecture: arm64
  ecr:
    images:
      appImage:
        path: ./
        platform: linux/arm64

functions:
  hello-world:
    image:
      name: appImage
      command:
        - hello-world

Since there is no specific preference for the region, let's use ap-northeast-1 (Tokyo) for now.

When defining functions, please pay attention to ensuring that the name of the command matches the name defined earlier for FunctionHandler.

Deployment

Once you have configured everything, you can deploy the function you created to AWS Lambda using the following Serverless Framework command:

Please make sure Docker Desktop is running before executing the command.

sls deploy

sls deploy
Running "serverless" from node_modules
(node:6460) [DEP0040] DeprecationWarning: The `punycode` module is deprecated. Please use a userland alternative instead.
(Use `node --trace-deprecation ...` to show where the warning was created)

Deploying sample-app to stage dev (ap-northeast-1)

✔ Service deployed to stack sample-app-dev (32s)

functions:
  hello-world: sample-app-dev-hello-world

References

The project created in this article is publicly available in the following repository. If you'd like to quickly try it out, feel free to clone or fork it and deploy it to AWS Lambda to play around with.

https://github.com/myConsciousness/sample-aws-lambda-with-dart-runtime

How to Create Bluesky BOT using Dart and Firehose

Shinya Kato — Sat, 09 Sep 2023 12:50:06 +0000

This article shows how to create a BOT with real-time data using the Dart language and Bluesky's Firehose API.

From the Firehose API, you can retrieve Bluesky events that occur on a particular server in real time, allowing you to develop very interactive BOTs. For example, a reply can be returned in real time to data that has been mentions to a specific account.

After reading this article you will surely be able to create a BOT using the Firehose API.

BOTs intended to spam will be subject to account suspension.
I will not be liable for any account suspension as a result of spamming or otherwise. Please execute with care when testing.

Using Package

To easily handle the Bluesky API in Dart/Flutter, use the following package.

bluesky

bluesky | Dart package

The most famous and powerful Dart/Flutter library for Bluesky Social.

pub.dev

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

AT Protocol and Bluesky Social Things for Dart/Flutter 🦋

Welcome to atproto.dart 🦋

This project will maximize your development productivity about AT Protocol and Bluesky things.

Give a ⭐ on GitHub repository and follow shinyakato.dev on Bluesky!

1. Motivation 💪

AT Protocol and Bluesky are awesome.

This wonderful platform needs a standard and highly integrated SDK atproto.dart provides the best development experience in such matters for Dart/Flutter devs.

2. Packages & Tools ⚒️

2.1. Dart Packages

Package	pub.dev	Docs
at_identifier: core library for the syntax in the AT Protocol standard		README
nsid:

…

View on GitHub

If you want to learn more about bluesky package, see following official website.

AT Protocol and Bluesky Social Things for Dart and Flutter | atproto.dart

Powerful suite of AT Protocol and Bluesky-related packages for Dart/Flutter

atprotodart.com

Install

Let's install bluesky with the following commands.

dart pub add bluesky

dart pub get

Import

Basically, when you use features of the bluesky package, just add the following import.

import 'package:bluesky/bluesky.dart';

Basic

Let's begin with the most basic implementation for using the Firehose API with bluesky package. You can implement it as follows.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final bluesky = bsky.Bluesky.anonymous();

  final subscription = await bluesky.sync.subscribeRepoUpdates();

  await for (final event in subscription.data.stream.handleError(print)) {
    print(event);
  }
}

To start with the most basic point, almost all events (likes and postings and etc) that occur on a particular server in Bluesky are public data. In other words, the Firehose API does not require user authentication.

With the above code, Bluesky's Firehose works perfectly, but user authentication is always required with a specific account to develop a BOT like the one we will cover in this article. This is because the BOT must be logged in with a specific account in order to respond with a reply or other action when a specific event is detected.

So, we need following implementations.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  //  This session is active for 120 minutes.
  final session = await bsky.createSession(
    identifier: 'username or email',
    password: 'password',
  );

  // Refreshed session is active for 90 days.
  final refreshedSession = await bsky.refreshSession(
    refreshJwt: session.data.refreshJwt,
  );

  // Create an instance from authenticated session.
  final bluesky = bsky.Bluesky.fromSession(refreshedSession.data);

  final subscription = await bluesky.sync.subscribeRepoUpdates();

  await for (final event in subscription.data.stream.handleError(print)) {
    print(event);
  }
}

Comparing with the previous code, you will notice that the .createSession function adds a process to authenticate the user. By passing username and password credentials to the .createSession function, a Bluesky session is created and you are logged in with a specific account.

But it's important to note, however, that sessions created with the .createSession function are only valid for 120 minutes. This is a somewhat unreliable time limit when using the Firehose API for long-time connections.

So, let's use the .refreshSession function. By passing refreshJwt in the session object created by the .createSession function as an argument, you can issue a session that is valid for 90 days.

Advanced

Move on to the main issue!

Let's create a BOT that replies with Hello! if it detects a post "Say hello @test.shinyakato.dev".

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  //  This session is active for 120 minutes.
  final session = await bsky.createSession(
    identifier: 'username or email',
    password: 'password',
  );

  // Refreshed session is active for 90 days.
  final refreshedSession = await bsky.refreshSession(
    refreshJwt: session.data.refreshJwt,
  );

  // Create an instance from authenticated session.
  final bluesky = bsky.Bluesky.fromSession(refreshedSession.data);

  final subscription = await bluesky.sync.subscribeRepoUpdates();

  // This is a very useful adaptor.
  // You can filter only specific events from Firehose.
  final adaptor = bsky.RepoCommitAdaptor(
    // Triggered only when post is created.
    onCreatePost: (data) async {
      if (data.record.text.contains('Say hello @test.shinyakato.dev')) {
        // Post a reply
        await bluesky.feeds.createPost(
          text: 'Hello!',

          // Reply setting
          reply: bsky.ReplyRef(
            root: data.toStrongRef(),
            parent: data.toStrongRef(),
          ),
        );

        print('said hello to ${data.author}!');
      }
    },
  );

  await for (final event in subscription.data.stream.handleError(print)) {
    switch (event) {
      // Firehose events are union type.
      // Use `USubscribedRepoCommit` to filter only commit events.
      case bsky.USubscribedRepoCommit():
        // Execute adaptor like this.
        await adaptor.execute(event.data);
    }
  }
}

Well done, if you run this code and post "Say hello @test.shinyakato.dev", you will instantly receive a reply saying "Hello!".

"Oh no, this seems very difficult to implement!"

Don't worry. The implementation has increased but it's very simple.

First, I describe the RepoCommitAdaptor class. The RepoCommitAdaptor class is a solution that allows troublesome commit data records to be filtered and treated as a specific type.

The commit data returned from Firehose contains almost all the record data generated by Bluesky. This means that the implementer must check as to whether the content of the record is a post or a like and so on. But, this is a fairly burdensome task for implementors using Firehose... Well, let RepoCommitAdaptor take care of all that tedious work.

When using RepoCommitAdaptor, you can define processing directly in callbacks for specific events such as onCreatePost as follows.

  // This is a very useful adaptor.
  // You can filter only specific events from Firehose.
  final adaptor = bsky.RepoCommitAdaptor(
    // Triggered only when post is created.
    onCreatePost: (data) {
      // Do something for post data.
    },
  );

In other words, this callback is executed only for events for which a post was created upon receipt of the Firehose results.

The code for Firehose is then as follows.

  await for (final event in subscription.data.stream.handleError(print)) {
    switch (event) {
      // Firehose events are union type.
      // Use `USubscribedRepoCommit` to filter only commit events.
      case bsky.USubscribedRepoCommit():
        // Execute adaptor like this.
        await adaptor.execute(event.data);
    }
  }

As noted in the comments to the above code, the data returned from Firehose is union. But, it can be easily handled using pattern matching in Dart3.

Union type names in bluesky package is always prefixed with U, so in this case we specify the USubscribedRepoCommit class in case, which represents Firehose's repo commit event.

Finally, the RepoCommitAdaptor defined earlier is executed in a case statement. This will all be easily resolved.

Conclusion

After reading this article you now understand how to use Dart and Bluesky's Firehose to create a realtime oriented BOT. Although we created a very simple BOT in this article, it's possible to create a more serviceable BOT by incorporating more complex rules. Try various things with the bluesky package!

If you are still not sure how to implement it after reading this article, please mention me on Bluesky.

@shinyakato.dev

Also, if you found this article useful, please give a star on GitHub repository. This is very helpful to activate the development community for atproto.dart.

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

AT Protocol and Bluesky Social Things for Dart/Flutter 🦋

Welcome to atproto.dart 🦋

This project will maximize your development productivity about AT Protocol and Bluesky things.

Give a ⭐ on GitHub repository and follow shinyakato.dev on Bluesky!

1. Motivation 💪

AT Protocol and Bluesky are awesome.

This wonderful platform needs a standard and highly integrated SDK atproto.dart provides the best development experience in such matters for Dart/Flutter devs.

2. Packages & Tools ⚒️

2.1. Dart Packages

Package	pub.dev	Docs
at_identifier: core library for the syntax in the AT Protocol standard		README
nsid:

…

View on GitHub

Thank you.

How to Update Your Profile from Dart/Flutter App using Bluesky API

Shinya Kato — Tue, 15 Aug 2023 07:24:15 +0000

This article will show you how to update your profile from a Dart/Flutter application using the Bluesky API.

By reading this article, you will be able to easily update your Bluesky profile in your Dart/Flutter app from the Bluesky API.

Using Package

To easily handle the Bluesky API in Dart/Flutter, use the following package.

bluesky

bluesky | Dart package

The most famous and powerful Dart/Flutter library for Bluesky Social.

pub.dev

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

AT Protocol and Bluesky Social Things for Dart/Flutter 🦋

Welcome to atproto.dart 🦋

This project will maximize your development productivity about AT Protocol and Bluesky things.

Give a ⭐ on GitHub repository and follow shinyakato.dev on Bluesky!

1. Motivation 💪

AT Protocol and Bluesky are awesome.

This wonderful platform needs a standard and highly integrated SDK atproto.dart provides the best development experience in such matters for Dart/Flutter devs.

2. Packages & Tools ⚒️

2.1. Dart Packages

Package	pub.dev	Docs
at_identifier: core library for the syntax in the AT Protocol standard		README
nsid:

…

View on GitHub

If you want to learn more about bluesky package, see following official website.

AT Protocol and Bluesky Social Things for Dart and Flutter | atproto.dart

Powerful suite of AT Protocol and Bluesky-related packages for Dart/Flutter

atprotodart.com

Install

Let's install bluesky with the following commands.

With Dart:

dart pub add bluesky

dart pub get

With Flutter:

flutter pub add bluesky

flutter pub get

Import

Basically, when you use features of the bluesky package, just add the following import.

import 'package:bluesky/bluesky.dart';

Implement

We will implement, but let's start with a very simple step. The following example shows the process for updating the displayName and description of an authenticated user.

In order to update a Bluesky profile, you must of course be authorized to update the information for the account you are updating, so be sure to authenticate using the createSession function. You can see more details about authentication on official document.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  final ref = await bluesky.actors.updateProfile(
    displayName: 'Alf',
    description: 'This is my new profile.',
  );

  print(ref.data);
}

As shown in the code above, to update the Bluesky profile of an authenticated user using the bluesky package, use the .updateProfile method of the ActorsService.

So, all you have to do to update your Bluesky profile using the bluesky package is call the .updateProfile method.

The above example only updates the displayName and description, but the following items can be updated.

Parameter	Description
displayName	A logical name for the profile.
descriotion	A description of the account that will be set up in the profile.
avatar	An image that symbolizes the account that is set in the profile.
banner	A banner image to be set in the profile.
labels	An optional tag set for the account.

Setting up a profile picture and label is a bit more difficult than setting up a displayName or description, so we will look at that in the next section.

Update Avatar and Banner

To update your avatar or banner, you must first upload the binary data of the image you wish to set to the server. To upload binary data of images to the server, implement the following.

import 'dart:io';

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  // Get image file to be uploaded.
  final image = File('./funny_photo.png');

  // Upload here.
  final uploaded = await bluesky.repositories.uploadBlob(
    image.readAsBytesSync(),
  );
}

As shown in the code above, the .uploadBlob method of the RepositoriesService is used to upload the binary data.

Bluesky Social only supports static images at the time of this writing, but the AT Protocol allows for the upload of binary data in any format.

After a successful upload, you will get a Blob object to pass to the avatar parameter when updating your profile image. All that remains is to pass a Blob object to the avatar parameter as follows.

import 'dart:io';

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  final image = File('./funny_photo.png');

  final uploaded = await bluesky.repositories.uploadBlob(
    image.readAsBytesSync(),
  );

  final ref = await bluesky.actors.updateProfile(
    displayName: 'Alf',
    description: 'This is my new profile.',

    // Pass like this.
    avatar: uploaded.data.blob,
  );

  print(ref.data);
}

The banner parameter can also be implemented in exactly the same way as above.

Set Labels

You can set any tags, called a label, to your profile in Bluesky. It is up to you to decide what kind of tags you want to set in your profile, and you can set any string of characters.

And setting up a label for your profile is easier than uploading an image. It can be implemented as follows.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  final ref = await bluesky.actors.updateProfile(
    displayName: 'Alf',
    description: 'This is my new profile.',

    // Add like this.
    labels: bsky.Labels.selfLabels(
      data: bsky.SelfLabels(
        values: [
          bsky.SelfLabel(value: 'developer'),
          bsky.SelfLabel(value: 'flutterdev'),
        ],
      ),
    ),
  );

  print(ref.data);
}

The structure of the objects passed to the labels parameter is somewhat complex, but not as laborious as the upload process. As you can see in the code above, you can set any number of strings as labels.

But well, let's make the implementation just a little more generic.

import 'package:bluesky/bluesky.dart' as bsky;

/// Labels to be set.
const _labels = <String>[
  'developer',
  'flutterdev',
];

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  final ref = await bluesky.actors.updateProfile(
    displayName: 'Alf',
    description: 'This is my new profile.',

    labels: bsky.Labels.selfLabels(
      data: bsky.SelfLabels(
        // Fix like this.
        values: _labels.map((e) => bsky.SelfLabel(value: e)).toList(),
      ),
    ),
  );

  print(ref.data);
}

Advanced

So far you have learned how to update your Bluesky profile using the bluesky package, but there is one more thing to consider in order to actually use the .updateProfile method in your Dart/ Flutter app.

Although it is not explicitly shown even in the official Lexicon, a parameter set as null using the .updateProfile method sets the authenticated user's profile data as null. In other words, if you try to update only a specific item and pass the other parameters as null, the profile data for the item associated with the parameter passed as null will be deleted.

So, you must always pass specific values to .updateProfile for parameters other than the item to be deleted, unless the user explicitly takes action to delete a specific item.

But, the problem here is that it is somewhat difficult to find a way to retrieve the uploaded avatar and banner binary data again. You can implement it as follows.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  // The AT Uri for authenticated user's profile.
  // The format can be used as is.
  final profileUri = bsky.AtUri.make(
    session.data.did,
    'app.bsky.actor.profile',
    'self',
  );

  // Get profile record.
  final record = await bluesky.repositories.findRecord(uri: profileUri);
  // And parse value to `ProfileRecord`.
  final profileRecord = bsky.ProfileRecord.fromJson(record.data.value);

  // Very safe update.
  // Replace the item you wish to update with a specific variable.
  final ref = await bluesky.actors.updateProfile(
    displayName: profileRecord.displayName,
    description: profileRecord.description,
    avatar: profileRecord.avatar,
    banner: profileRecord.banner,
    labels: profileRecord.labels,
  );

  print(ref.data);
}

Using the above code as a base, you can update your profile very safely.

Conclusion

Now that you have somewhat understood how to update your Bluesky profile from the Dart/Flutter app using the bluesky package, you can use it to update your Bluesky profile from the Dart/Flutter app. You have also learned that updating your profile using the Bluesky API may seem easy, but in reality it requires some technique.

If you are still not sure how to implement it after reading this article, please mention me at Bluesky.

@shinyakato.dev

Also, if you found this article useful, please star the following repositories where bluesky package are developed. This is very helpful to activate the development community.

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

AT Protocol and Bluesky Social Things for Dart/Flutter 🦋

Welcome to atproto.dart 🦋

This project will maximize your development productivity about AT Protocol and Bluesky things.

Give a ⭐ on GitHub repository and follow shinyakato.dev on Bluesky!

1. Motivation 💪

AT Protocol and Bluesky are awesome.

This wonderful platform needs a standard and highly integrated SDK atproto.dart provides the best development experience in such matters for Dart/Flutter devs.

2. Packages & Tools ⚒️

2.1. Dart Packages

Package	pub.dev	Docs
at_identifier: core library for the syntax in the AT Protocol standard		README
nsid:

…

View on GitHub

Thank you.

Let's Post to Bluesky Social easily with Dart and Flutter

Shinya Kato — Thu, 15 Jun 2023 00:54:00 +0000

As already noted by many media articles, Bluesky Social is a decentralized social networking service with a Twitter-like UI. Bluesky Social is built on a next-generation common infrastructure called the AT Protocol, and the road ahead is very ambitious and full of unknown possibilities.

This article mainly shows how to post to Bluesky Social from the API in Dart language. I will not actively present the implementation in Flutter, but you can apply the same procedure in Flutter by reading this article.

What Is Dart?

For those who are not familiar with the Dart language, Dart is a relatively new programming language developed by Google. Dart has a syntax similar to Java and C, but with modern language specifications such as null safety. Above all, Flutter is probably the reason Dart is getting the most attention.

Dart programming language | Dart

Dart is an approachable, portable, and productive language for high-quality apps on any platform.

dart.dev

Flutter - Build apps for any screen

Flutter transforms the entire app development process. Build, test, and deploy beautiful mobile, web, desktop, and embedded apps from a single codebase.

flutter.dev

There is already a powerful package that makes it easy to use Bluesky Social's API with Dart and Flutter, and this article will present sample code using that package.

Install Package

To easily use Bluesky Social's API in Dart or Flutter, use the package bluesky. I develop and maintain this package and it already supports almost all endpoints, is well tested and very stable.

It is already being used in several third-party apps, and I highly recommend this package for your Bluesky Social-related apps in Dart or Flutter.

bluesky | Dart package

The most famous and powerful Dart/Flutter library for Bluesky Social.

pub.dev

Or you can see more details in in following official page.

AT Protocol and Bluesky Social Things for Dart and Flutter | atproto.dart

Powerful suite of AT Protocol and Bluesky-related packages for Dart/Flutter

atprotodart.com

Well, let's install this package with following commands.

With Dart:

dart pub add bluesky

dart pub get

With Flutter:

flutter pub add bluesky

flutter pub get

And let's check your pubspec.yaml in your Dart or Flutter app. It is successful if it looks like this and this article uses bluesky v0.6.0.

name: bluesky_post
description: A sample command-line application.
version: 1.0.0
environment:
  sdk: ^3.0.0

dependencies:
  bluesky: ^0.6.0

dev_dependencies:
  lints: ^2.0.0
  test: ^1.21.0

Let's Post!

The easiest way to post to Bluesky Social using the bluesky package is as follows. The following example simply posts any text.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  //! You need to be authenticated by credentials.
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  //! Create Bluesky from session data.
  final bluesky = bsky.Bluesky.fromSession(session.data);

  final ref = await bluesky.feeds.createPost(
    text: 'Hello, Bluesky!',
  );

  //! StrongRef
  print(ref.data);
}

I previously wrote an article about using the Firehose API with the bluesky package, which did not require credentials. However, the endpoint you will be using to post to Bluesky Social will always require your credentials.

For example, the above example uses the createSession method to authenticate with the bsky.social server using your credentials. If the authentication fails, an error is returned by bsky.social.

As a side note, if you have an account on a server other than bsky.social, you can specify any server as follows:

final session = await bsky.createSession(
  service: 'stem.social',
  identifier: 'HANDLE_OR_EMAIL',
  password: 'PASSWORD_OR_APP_PASSWORD',
);

Then, an instance of the Bluesky object, which is required to use the bluesky package, is created using the .fromSession constructor. The .fromSession constructor can be used to create a Bluesky object from a Session object without over or under creating it.

final bluesky = bsky.Bluesky.fromSession(session.data);

Okay now, if you could get session and Bluesky object from session, all you need to do is post any text with the following code.

final ref = await bluesky.feeds.createPost(
  text: 'Hello, Bluesky!',
);

With just this, you can send any post to Bluesky Social! The data returned from the createPost method is a reference to the actual data generated. It is represented on the AT Protocol as StrongRef and consists of an AT URI and CID link to the generated data.

Also, although not in the above code, you can delete a generated Post or other record from the AT URI as follows.

//! Delete any records.
await bluesky.repositories.deleteRecord(uri: ref.data.uri);

Post with Images

Now that you know how to use the bluesky package to post arbitrary text to Bluesky Social, it would be useful to be able to attach images and such when actually using it.

Basically, in order to attach an image to a particular piece of content, you must first upload that image data and then POST the uploaded data in Multipart format. However, with the bluesky package, you don't have to be aware of these difficult processes at all.

Well, you can send a post with an image by doing the following:

import 'dart:io';

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  //! Upload photo!
  final uploaded = await bluesky.repositories.uploadBlob(
    File('./funny_photo.jpg').readAsBytesSync(), // File bytes
  );

  final ref = await bluesky.feeds.createPost(
    text: 'Hello, Bluesky!',

    //! Add it.
    embed: bsky.Embed.images(
      data: bsky.EmbedImages(
        images: [
          bsky.Image(
            alt: 'This is my funny photo!',
            image: uploaded.data.blob,
          ),
        ],
      ),
    ),
  );

  print(ref);
}

The above example shows that it is very easy to send a post with an image.

All you have to do is upload an arbitrary image file using the uploadBlob method, and pass the uploaded Blob data to the embed parameter of createPost.

Quote the Post

You can also quote a post that has already been submitted easily as follows.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  //! Let's use this post as quote.
  final ref = await bluesky.feeds.createPost(text: 'This will be quoted.');

  await bluesky.feeds.createPost(
    text: 'Hello, Bluesky!',

    //! Add it.
    embed: bsky.Embed.record(
      data: bsky.EmbedRecord(ref: ref.data),
    ),
  );
}

Attach a Link Card to an External Site

When using Bluesky's API to embed a post with a link card from an external site, you will need to configure that link card yourself. The bluesky package makes it easy to set up.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  await bluesky.feeds.createPost(
    text: 'Hello, Bluesky!',

    //! Add it.
    embed: bsky.Embed.external(
      data: bsky.EmbedExternal(
        external: bsky.EmbedExternalThumbnail(
          uri: 'https://shinyakato.dev',
          title: 'Shinya Kato',
          description: 'This is my site!',
        ),
      ),
    ),
  );
}

Reply to a Specific Post

Replying to a specific post is a basic feature. Using the bluesky package, you can reply as follows.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  //! Let's reply to this post.
  final root = await bluesky.feeds.createPost(
    text: 'Reply to me',
  );

  await bluesky.feeds.createPost(
    text: 'Hello, Bluesky!',

    //! Add this.
    reply: bsky.ReplyRef(
      root: root.data,
      parent: root.data,
    ),
  );
}

With the above codes, you can easily reply to a specific post!

And you may have noticed that the ReplyRef object has two arguments, root and parent. With these arguments, you can create a thread, but if you simply want to create a series of threads, the bluesky package provides an easier way.

Let's use createThread method.

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  //! Let's reply to this post.
  final root = await bluesky.feeds.createThread([
    bsky.ThreadParam(text: 'First post'),
    bsky.ThreadParam(text: 'Second post'),
    bsky.ThreadParam(text: 'Third post'),
  ]);

  //! This is the root ref from first post.
  print(root);
}

Using createThread, it is very easy to create a series of threads.

Mentions and Links

In services similar to Bluesky, such as Twitter and Mastodon, mentions and hyperlinks in the text are automatically set up without any special attention. However, this is not the case at Bluesky.

For example, how would the status of this post appear on Bluesky's UI if the previous code were modified as follows?

import 'package:bluesky/bluesky.dart' as bsky;

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  final ref = await bluesky.feeds.createPost(
    text: 'I am @shinyakato.dev! Check https://shinyakato.dev',
  );
}

The answer is, it will post the raw I am @shinyakato.dev! Check https://shinyakato.dev text with no link set in the mentions and hyperlinks.

So, if you are asking if you can't set up links in the Bluesky API, of course you can! You just need to set a special parameter called facet.

Modify the createPost method in the previous example as follows.

await bluesky.feeds.createPost(
  text: 'I am @shinyakato.dev! Check https://shinyakato.dev',

  //! Set Facets.
  facets: [
    //! Facet for mention like "@shinyakato.dev"
    bsky.Facet(
      index: bsky.ByteSlice(
        byteStart: 5,
        byteEnd: 20,
      ),
      features: [
        bsky.FacetFeature.mention(
          data: bsky.FacetMention(
            did: 'did:plc:iijrtk7ocored6zuziwmqq3c',
          ),
        )
      ],
    ),

    //! Facet for link like "https://shinyakato.dev"
    bsky.Facet(
      index: bsky.ByteSlice(
        byteStart: 28,
        byteEnd: 50,
      ),
      features: [
        bsky.FacetFeature.link(
          data: bsky.FacetLink(
            uri: 'https://shinyakato.dev',
          ),
        )
      ],
    ),
  ],
);

Setting up this facet is one of the most difficult operations to enable mentions and hyperlinks using the Bluesky API.

The mechanics are simple, but you need to define the ByteSlice as the start and end position of the specific token you want to link to, such as a mentions or hyperlinks in the text, and even how you want the link to be placed as features.

In other words, this mechanism can be used to create a link that is completely different from the mentions or hyperlinks contained in the text.

However, I feel many people simply want mentions and hyperlinks like those offered by Twitter and Mastodon. Is there an easier solution to this complicated facet? Of course there is! But use the bluesky_text package, which is different from the bluesky package.

Let's check how to use bluesky_text in the next section!

Use `bluesky_text` for Easy `facet` Resolution

As mentioned in the previous section, activating links in text using the Bluesky API requires a facet setting, which is a somewhat difficult operation. If you need simple mentions and hyperlinks like Twitter or Mastodon, use bluesky_text.

bluesky_text is another package I am developing, designed to integrate very easily with the bluesky package.

bluesky_text | Dart package

Provides the easiest and most powerful way to analyze the text for Bluesky Social.

pub.dev

And install it like bluesky package.

With Dart:

dart pub add bluesky_text

dart pub get

With Flutter:

flutter pub add bluesky_text

flutter pub get

It is successful if it looks like this in your pubspec.yaml and this article uses bluesky_text v0.2.2.

name: bluesky_post
description: A sample command-line application.
version: 1.0.0
environment:
  sdk: ^3.0.0

dependencies:
  bluesky: ^0.6.0
  bluesky_text: ^0.2.2

dev_dependencies:
  lints: ^2.0.0
  test: ^1.21.0

Okay let's modify the complex facet setup process described earlier as follows.

import 'package:bluesky/bluesky.dart' as bsky;
import 'package:bluesky_text/bluesky_text.dart';

Future<void> main() async {
  final session = await bsky.createSession(
    identifier: 'HANDLE_OR_EMAIL',
    password: 'PASSWORD_OR_APP_PASSWORD',
  );

  final bluesky = bsky.Bluesky.fromSession(session.data);

  //! Just pass text to BlueskyText.
  final text = BlueskyText('I am @shinyakato.dev! Check https://shinyakato.dev');

  //! Extract all the mentions and hyperlinks in the text
  //! and get the facet as JSON.
  final facets = await text.entities.toFacets();

  await bluesky.feeds.createPost(
    //! This is the text you passed to BlueskyText.
    text: text.value,

    //! Convert to Facet objects.
    facets: facets.map(bsky.Facet.fromJson).toList(),
  );
}

Where the heck did the difficult facet process of a few minutes ago disappear to?! This is bluesky_text magic, all you have to do is just pass the text you want to post to the constructor when you create an instance of the BlueskyText object and call .entities.toFacet().

With just this, you can retrieve facet data contained in the text. Then, to post using the bluesky package, convert the JSON retrieved from toFacet() into a Facet object with facets.map(bsky.Facet.fromJson).toList().

Conclusion

This is how to post to Bluesky Social using the bluesky package. I also introduced a simple solution for facet, which is difficult to configure when using the Bluesky API, using the bluesky_text package.

This article mainly touches on the Dart implementation and omits the Flutter implementation, but the bluesky and bluesky_text packages can also be used in Flutter apps. The implementation method is the same as described in this article and will be easily integrated into your Flutter app!

In addition to the bluesky package and bluesky_text I have presented here, I have also developed many AT Protocol related packages for Dart/Flutter in the following monorepo. If you are interested in AT Protocol related packages for Dart/Flutter, please check it out!

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

AT Protocol and Bluesky Social Things for Dart/Flutter 🦋

Welcome to atproto.dart 🦋

This project will maximize your development productivity about AT Protocol and Bluesky things.

Give a ⭐ on GitHub repository and follow shinyakato.dev on Bluesky!

1. Motivation 💪

AT Protocol and Bluesky are awesome.

This wonderful platform needs a standard and highly integrated SDK atproto.dart provides the best development experience in such matters for Dart/Flutter devs.

2. Packages & Tools ⚒️

2.1. Dart Packages

Package	pub.dev	Docs
at_identifier: core library for the syntax in the AT Protocol standard		README
nsid:

…

View on GitHub

Suggestions for improvements and pull requests are also very welcome. Or you can contact me on Bluesky :)

https://bsky.app/profile/shinyakato.dev

Thank you.

Easily use Firehose API on Bluesky Social with Dart and Flutter

Shinya Kato — Tue, 06 Jun 2023 13:25:55 +0000

Now, I will introduce the Firehose API, one of the APIs related to Bluesky Social, and how to use it easily with the Dart language. Bluesky Social's Firehose API is a very powerful Stream API that allows you to retrieve almost any event occurring on a particular server in real time.

What Is Dart?

Dart programming language | Dart

Dart is an approachable, portable, and productive language for high-quality apps on any platform.

dart.dev

Flutter - Build apps for any screen

Flutter transforms the entire app development process. Build, test, and deploy beautiful mobile, web, desktop, and embedded apps from a single codebase.

flutter.dev

Well, there is already a powerful package that makes it easy to use Bluesky Social's API with Dart and Flutter, and this article will present sample code using that package!

Install Package

It is already being used in several third-party apps, and I highly recommend this package for your Bluesky Social-related apps in Dart or Flutter.

bluesky | Dart package

The most famous and powerful Dart/Flutter library for Bluesky Social.

pub.dev

Or you can see more details in in following official page.

AT Protocol and Bluesky Social Things for Dart and Flutter | atproto.dart

Powerful suite of AT Protocol and Bluesky-related packages for Dart/Flutter

atprotodart.com

Well, let's install this package with following commands.

With Dart:

dart pub add bluesky

dart pub get

With Flutter:

flutter pub add bluesky

flutter pub get

And let's check your pubspec.yaml in your Dart or Flutter app. It is successful if it looks like this and this article uses bluesky v0.5.7.

name: bluesky_firehose
description: A sample command-line application.
version: 1.0.0
environment:
  sdk: ^3.0.0

dependencies:
  bluesky: ^0.5.7

dev_dependencies:
  lints: ^2.0.0
  test: ^1.21.0

Let's Use Firehose API

Now all that is left is to actually use the Firehose API with the bluesky package! The bluesky package makes it easy to connect to Bluesky Social's Firehose API as follows.

import 'package:bluesky/bluesky.dart';

Future<void> main() async {
  final bluesky = Bluesky.anonymous();

  final subscription = await bluesky.sync.subscribeRepoUpdates();

  await for (final event in subscription.data.stream) {
    event.when(
      commit: (data) {
        for (final op in data.ops) {
          print(op.uri);
          print(op.record);
        }
      },
      handle: print,
      migrate: print,
      tombstone: print,
      info: print,
      unknown: print,
    );
  }
}

Very simple, right?

If you dart run the above Dart program, you will see the events occurring in bsky.social streaming in real time like:

at://did:plc:cojuqgrp6syogwzytq3p5zdq/app.bsky.graph.follow/3jxsejsfjas2n
{$type: app.bsky.graph.follow, subject: did:plc:pwm3nal7z4sht4id6wniiahv, createdAt: 2023-06-10T08:53:45.050Z}
at://did:plc:vopt5zssk6uotcsgnimyuiy3/app.bsky.feed.like/3jxsejsgnev2t
{$type: app.bsky.feed.like, subject: {cid: bafyreihoge573pwtux4dgedovmtitnwdnibvekrr7nvqs3qjbnrplnsvxq, uri: at://did:plc:awnhnq23opcufc2rnqbggjnp/app.bsky.feed.post/3jxsdpbessq2s}, createdAt: 2023-06-10T08:53:44.841Z}
at://did:plc:njyxpfp2rzb7addisbq74epa/app.bsky.graph.follow/3jxsejskzz72r
{$type: app.bsky.graph.follow, subject: did:plc:uo2g6reoqnrudyoeotwveuc2, createdAt: 2023-06-10T08:53:45.453Z}
at://did:plc:b4td4mpmhj76dwdqrds72p4p/app.bsky.feed.like/3jxsejsnh5q2h
{$type: app.bsky.feed.like, subject: {cid: bafyreienlb76pav7d4gvdpy5opmllldhjongwnmmkkrjof5cg4olawe4he, uri: at://did:plc:sho65umi6t4ohqyaijutbdcr/app.bsky.feed.post/3jxs56p2ost2l}, createdAt: 2023-06-10T08:53:45.491Z}
at://did:plc:64kdoplv62s6veonqincpgod/app.bsky.feed.post/3jxsejsib5h2r
{text: How long was this in here for that this happened?, $type: app.bsky.feed.post, embed: {$type: app.bsky.embed.recordWithMedia, media: {$type: app.bsky.embed.images, images: [{alt: , image: {ref: {$link: bafkreiddranx4ph7m53cdpiwme5g4zjuo4djaapdychlc6nm46ogyod2zi}, size: 876186, $type: blob, mimeType: image/jpeg}}]}, record: {$type: app.bsky.embed.record, record: {cid: bafyreifbe7p5fozzx4ualnrspqqfsfs2xoas4r2ambxjstcdkji3i7tq4e, uri: at://did:plc:64kdoplv62s6veonqincpgod/app.bsky.feed.post/3jxsdq3tgma2h}}}, createdAt: 2023-06-10T08:53:45.372Z}
at://did:plc:xopjsprtk24yvyfyfzfifxki/app.bsky.graph.follow/3jxsejt2nz72r
{$type: app.bsky.graph.follow, subject: did:plc:cpogq3zcrybwsibq4hzjnbxa, createdAt: 2023-06-10T08:53:45.495Z}
at://did:plc:hgb7kmelvhfdhlc777diyokk/app.bsky.feed.like/3jxsejunxmh2r
{$type: app.bsky.feed.like, subject: {cid: bafyreiayanec5xmjfs3a2ey5bu3onrwbuz53i6w5sd3k55bmnh4444iuiq, uri: at://did:plc:5fwxaoha4lvtoseohazxr5uh/app.bsky.feed.post/3jxs7uqur2n2u}, createdAt: 2023-06-10T08:53:47.609Z}
at://did:plc:djarlkihrgk7uvwcf4umikno/app.bsky.graph.follow/3jxsejuudpi2h
{$type: app.bsky.graph.follow, subject: did:plc:dqvv2jev7pm4a66iozhzqehq, createdAt: 2023-06-10T08:53:48.522Z}
at://did:plc:oqbijttmayqui2xv3e2xwcdz/app.bsky.feed.post/3jxsejvcwj32l
{text: I’m just warming them up for you fam, $type: app.bsky.feed.post, reply: {root: {cid: bafyreibhc74rccmajeddna5xkps4iqwamwngf5ihlzeimaxbw7mzoj45ya, uri: at://did:plc:rlfsrnc4kvcgatjaykqvxfql/app.bsky.feed.post/3jxs3ehmevb2n}, parent: {cid: bafyreibhc74rccmajeddna5xkps4iqwamwngf5ihlzeimaxbw7mzoj45ya, uri: at://did:plc:rlfsrnc4kvcgatjaykqvxfql/app.bsky.feed.post/3jxs3ehmevb2n}}, createdAt: 2023-06-10T08:53:48.176Z}

However, for those who are not familiar with Bluesky's API or Dart, this code may seem complicated, so I will explain the main points.

First, to access Bluesky Social's API using the bluesky package, import package:bluesky/bluesky.dart and instantiate the Bluesky object as follows.

import 'package:bluesky/bluesky.dart';

Future<void> main() async {
  final bluesky = Bluesky.anonymous();
}

Since the Firehose API used this time does not require user authentication to access it, now we created an instance of the Bluesky object using the .anonymous() constructor, which does not require authentication. The .fromSession() constructor must always be used when using endpoints that require user authentication, but is not used in this article.

The next thing we have to do is to get the Firehose API Stream from an instance of the Bluesky object as follows.

final subscription = await bluesky.sync.subscribeRepoUpdates();

With just this one simple line you can get a Stream of Bluesky Social's Firehose API. This Stream is a long-lived connection and is communicated via WebSocket. But you need not be aware of these difficult communications at all, just write one line above and you will be fine.

Returned from subscribeRepoUpdates() is a subscription data representing the connection to the Firehose API. You can retrieve the data flowing from stream in the following way.

final subscription = await bluesky.sync.subscribeRepoUpdates();

await for (final event in subscription.data.stream) {
  print(event);
}

Like above, you can get events that occur in bsky.social from stream. But, the structure of event that can be obtained from this stream is not simple. This event object is of type Union, which simply means that there are multiple structures of objects flowing from the stream.

Do you have to handle those complex structures yourself? No, that is not necessary. The bluesky package provides easy handling of objects of type Union.

Not only in this example, but any object of type Union in the bluesky package can easily handle any structure that may flow as a Union using .when().

final subscription = await bluesky.sync.subscribeRepoUpdates();

await for (final event in subscription.data.stream) {
  event.when(
    commit: print,
    handle: print,
    migrate: print,
    tombstone: print,
    info: print,
    unknown: print,
  );
}

For example, using event.when() in the above example, you can safely handle objects with the different structures commit, handle, migrate, tombstone, info and unknown. The unknown is called when there is a Union structure not supported by the bluesky package, and is passed JSON (Map) that is not parsed to a specific object.

But, only the commit and handle patterns are mainly used at this time, and the other structures are not implemented or used in the official Bluesky API. So, let's focus on commit and handle now.

The commit event is fired when a post is posted on Bluesky, or when a specific post is liked and etc. A commit event consists of one or more ops, each op having an action that triggered the event to occur as follows.

create: When a specific record is created.
update: When a specific record is updated.
delete: When a specific record is deleted.

The Dart program allows you to do the following.

final subscription = await bluesky.sync.subscribeRepoUpdates();

await for (final event in subscription.data.stream) {
  event.when(
    commit: (data) {
      for (final op in data.ops) {
        switch (op.action) {
          case RepoAction.create:
            print(op.uri);
            print(op.record);
          case RepoAction.update:
          case RepoAction.delete:
        }
      }
    },
    handle: print,
    migrate: print,
    tombstone: print,
    info: print,
    unknown: print,
  );
}

For example, in the above case, from op.uri you can get the AT URI of a specific record, and from op.record you can get a specific record according to the AT URI and action.

Next, the handle event is fired when a particular user changes the handle on an account. The handle event is not as difficult as the commit event introduced earlier, you just can get the modified contents of the handle as follows.

final subscription = await bluesky.sync.subscribeRepoUpdates();

await for (final event in subscription.data.stream) {
  event.when(
    commit: print,
    handle: (data) {
      print(data.did);
      print(data.handle);
    },
    migrate: print,
    tombstone: print,
    info: print,
    unknown: print,
  );
}

Let's Handle Commit More Easily

I have shown you how to use Bluesky Social's Firehose API using the bluesky package, but there is actually an easier way to handle the commit event. It is to use RepoCommitAdaptor for the commit event as follows.

final subscription = await bluesky.sync.subscribeRepoUpdates();

// Add this
final repoCommit = RepoCommitAdaptor(
  onCreatePost: (data) {
    print(data.author);
    print(data.uri);
    print(data.record);
  },
  onUpdateProfile: (data) {
    print(data.record);
  },
  onDeleteFollow: (data) {
    print(data.uri);
  },
);

await for (final event in subscription.data.stream) {
  event.when(
    commit: repoCommit.execute, // And execute like this
    handle: print,
    migrate: print,
    tombstone: print,
    info: print,
    unknown: print,
  );
}

You can see at a glance that the RepoCommitAdaptor can be used to process each event in a very concise manner compared to handling each event individually using ops to action, etc., as in the previous example.

The above example specifies onCreatePost, onUpdateProfile, and onDeleteFollow when creating an instance of RepoCommitAdaptor, which means that only the following events can be filtered and retrieved.

onCreatePost: When the Post is created.
onUpdateProfile: When the Profile is updated.
onDeleteFollow: When the Follow is deleted.

Of course, the above examples are only some of the events supported by RepoCommitAdaptor.

The RepoCommitAdaptor provides very powerful and secure handling when using Bluesky Social's Firehose API with the bluesky package. When using subscribeRepoUpdates() to handle commit events, it would be best to use the RepoCommitAdaptor.

Conclusion

This is how to easily use Bluesky Social's Firehose API with Dart and Flutter using the bluesky package.

This article is basically an example with a Dart program, but the bluesky package also works with Flutter, so similar code can be used to make the Firehose API work in a Flutter app. You can use the StreamBuilder widget when working with Firehose API Streams in Flutter.

As mentioned earlier, the bluesky package also supports many endpoints other than the Firehose API presented here. This is a very powerful package that will surely be useful in the Dart/Flutter apps you develop!

In addition to the bluesky package I have presented here, I have also developed many AT Protocol related packages for Dart/Flutter in the following monorepo. If you are interested in AT Protocol related packages for Dart/Flutter, please check it out!

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

AT Protocol and Bluesky Social Things for Dart/Flutter 🦋

Welcome to atproto.dart 🦋

This project will maximize your development productivity about AT Protocol and Bluesky things.

Give a ⭐ on GitHub repository and follow shinyakato.dev on Bluesky!

1. Motivation 💪

AT Protocol and Bluesky are awesome.

This wonderful platform needs a standard and highly integrated SDK atproto.dart provides the best development experience in such matters for Dart/Flutter devs.

2. Packages & Tools ⚒️

2.1. Dart Packages

Package	pub.dev	Docs
at_identifier: core library for the syntax in the AT Protocol standard		README
nsid:

…

View on GitHub

Suggestions for improvements and pull requests are also very welcome. Or you can contact me on Bluesky :)

https://bsky.app/profile/shinyakato.dev

Thank you.

DEV Community: Shinya Kato

How to Deploy Dart Functions to AWS Lambda

Introduction

Preparation

AWS Account

AWS Authentication Token

Serverless Framework

Docker Desktop

Implementation and Registration of Functions

Project Structure

Installing Packages

Creating a Function to Deploy to AWS Lambda

Registering the Created Function to the Custom Runtime

Deploying to AWS Lambda

Dockerfile

serverless.yml

Deployment

References

How to Create Bluesky BOT using Dart and Firehose

Using Package

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

1. Motivation 💪

2. Packages & Tools ⚒️

2.1. Dart Packages

Install

Import

Basic

Advanced

Conclusion

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

1. Motivation 💪

2. Packages & Tools ⚒️

2.1. Dart Packages

How to Update Your Profile from Dart/Flutter App using Bluesky API

Using Package

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

1. Motivation 💪

2. Packages & Tools ⚒️

2.1. Dart Packages

Install

Import

Implement

Update Avatar and Banner

Set Labels

Advanced

Conclusion

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

1. Motivation 💪

2. Packages & Tools ⚒️

2.1. Dart Packages

Let's Post to Bluesky Social easily with Dart and Flutter

What Is Dart?

Install Package

Let's Post!

Post with Images

Quote the Post

Attach a Link Card to an External Site

Reply to a Specific Post

Mentions and Links

Use bluesky_text for Easy facet Resolution

Conclusion

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

1. Motivation 💪

2. Packages & Tools ⚒️

2.1. Dart Packages

Easily use Firehose API on Bluesky Social with Dart and Flutter

What Is Dart?

Install Package

Let's Use Firehose API

Let's Handle Commit More Easily

Conclusion

myConsciousness / atproto.dart

🦋 AT Protocol and Bluesky things for Dart and Flutter.

1. Motivation 💪

2. Packages & Tools ⚒️

Use `bluesky_text` for Easy `facet` Resolution