Client

Pre-requisites

• installed
• Initialized Dapr environment

1. Install the SDK with :

1. Import the libraries:

import { DaprClient, DaprServer, HttpMethod, CommunicationProtocolEnum } from "dapr-client";
const daprHost = "127.0.0.1"; // Dapr Sidecar Host
const daprPort = "3500"; // Dapr Sidecar Port of this Example Server
const serverHost = "127.0.0.1"; // App Host of this Example Server
const serverPort = "50051"; // App Port of this Example Server 
// HTTP Example
const client = new DaprClient(daprHost, daprPort);
// GRPC Example
const client = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.GRPC);

Running

To run the examples, you can use two different protocols to interact with the Dapr sidecar: HTTP (default) or gRPC.

import { DaprClient } from "dapr-client";
const client = new DaprClient(daprHost, daprPort);

# Using dapr run
dapr run --app-id example-sdk --app-protocol http -- npm run start
# or, using npm script
npm run start:dapr-http

Using gRPC

Since HTTP is the default, you will have to adapt the communication protocol to use gRPC. You can do this by passing an extra argument to the client or server constructor.

# Using dapr run
dapr run --app-id example-sdk --app-protocol grpc -- npm run start
# or, using npm script
npm run start:dapr-grpc

Invoke a Service

import { DaprClient, HttpMethod } from "dapr-client"; 
const daprHost = "127.0.0.1"; 
const daprPort = "3500"; 
async function start() {
  const client = new DaprClient(daprHost, daprPort); 
  const serviceAppId = "my-app-id";
  const serviceMethod = "say-hello";
  // POST Request
  const response = await client.invoker.invoke(serviceAppId , serviceMethod , HttpMethod.POST, { hello: "world" });
  // GET Request
  const response = await client.invoker.invoke(serviceAppId , serviceMethod , HttpMethod.GET);
start().catch((e) => {
  console.error(e);
  process.exit(1);
});

State Management API

Save, Get and Delete application state

import { DaprClient } from "dapr-client"; 
const daprHost = "127.0.0.1"; 
const daprPort = "3500"; 
async function start() {
  const client = new DaprClient(daprHost, daprPort); 
  const serviceStoreName = "my-state-store-name";
  // Save State
  const response = await client.state.save(serviceStoreName, [
      key: "first-key-name",
      value: "hello"
    },
    {
      key: "second-key-name",
      value: "world"
    }
  ]);
  // Get State
  const response = await client.state.get(serviceStoreName, "first-key-name");
  // Get Bulk State
  const response = await client.state.getBulk(serviceStoreName, ["first-key-name", "second-key-name"]);
  // State Transactions
  await client.state.transaction(serviceStoreName, [
    {
      operation: "upsert",
      request: {
        key: "first-key-name",
        value: "new-data"
      }
    },
    {
      operation: "delete",
      request: {
        key: "second-key-name"
      }
    }
  ]);
  // Delete State
  const response = await client.state.delete(serviceStoreName, "first-key-name");
}
start().catch((e) => {
  console.error(e);
  process.exit(1);
});

Query State API

Publish messages

import { DaprClient } from "dapr-client"; 
const daprHost = "127.0.0.1"; 
const daprPort = "3500"; 
async function start() {
  const client = new DaprClient(daprHost, daprPort); 
  const pubSubName = "my-pubsub-name";
  const message = { hello: "world" }
  // Publish Message to Topic
  const response = await client.pubsub.publish(pubSubName, topic, message);
}
start().catch((e) => {
  console.error(e);
});

Subscribe to messages

import { DaprServer } from "dapr-client";
const daprHost = "127.0.0.1"; // Dapr Sidecar Host
const daprPort = "3500"; // Dapr Sidecar Port of this Example Server
const serverHost = "127.0.0.1"; // App Host of this Example Server
const serverPort = "50051"; // App Port of this Example Server "
async function start() {
  const server = new DaprServer(serverHost, serverPort, daprHost, daprPort);
  const pubSubName = "my-pubsub-name";
  const topic = "topic-a";
  // Configure Subscriber for a Topic
  await server.pubsub.subscribe(pubSubName, topic, async (data: any) => console.log(`Got Data: ${JSON.stringify(data)}`));
  await server.start();
}

Bindings API

Invoke Output Binding

Output Bindings

import { DaprClient } from "dapr-client"; 
const daprHost = "127.0.0.1"; 
const daprPort = "3500"; 
async function start() {
  const client = new DaprClient(daprHost, daprPort); 
  const bindingName = "my-binding-name";
  const bindingOperation = "create";
  const message = { hello: "world" };
  const response = await client.binding.send(bindingName, bindingOperation, message);
}
start().catch((e) => {
  console.error(e);
  process.exit(1);
});

Retrieve secrets

Configuration API

Get Configuration Keys

import { DaprClient } from "dapr-client";
const daprHost = "127.0.0.1";
const daprAppId = "example-config";
async function start() {
  const client = new DaprClient(
    daprHost,
    process.env.DAPR_HTTP_PORT
  );
  const config = await client.configuration.get('config-store', ['key1', 'key2']);
  console.log(config);
}
start().catch((e) => {
  console.error(e);
  process.exit(1);
});

Related links