service.proto

syntax = "proto3";

package berty.node;

import "api/protobuf/graphql/graphql.proto";
import "api/p2p/event.proto";
import "api/node/kind.proto";
import "network/metrics.proto";
import "network/peer.proto";
import "entity/contact.proto";
import "entity/conversation.proto";
import "entity/message.proto";
import "pkg/deviceinfo/deviceinfo.proto";

import "gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto";


option go_package = "berty.tech/core/api/node";

service Service {
  // return node current ID
  rpc ID (Void) returns (berty.network.Peer) {
    option (gql.graphql_type) = "Query";
  };

  //
  // Events
  //

  // yield new events in real-time
  rpc EventStream (EventStreamInput) returns (stream berty.p2p.Event) {
    option (gql.graphql_type) = "Subscription";
  };
  // list old events
  rpc EventList (EventListInput) returns (stream berty.p2p.Event) {
    option (gql.graphql_output) = ".berty.node.EventListConnection";
    option (gql.graphql_type) = "Query";
  };
  rpc GetEvent (gql.Node) returns (berty.p2p.Event) {
    option (gql.graphql_type) = "Query";
  };
  rpc EventSeen (EventIDInput) returns (berty.p2p.Event) {
    option (gql.graphql_type) = "Mutation";
  }

  //
  // Contacts
  //

  rpc ContactRequest (ContactRequestInput) returns (berty.entity.Contact) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc ContactAcceptRequest (berty.entity.Contact) returns (berty.entity.Contact) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc ContactRemove (berty.entity.Contact) returns (berty.entity.Contact) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc ContactUpdate (berty.entity.Contact) returns (berty.entity.Contact) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc ContactList (ContactListInput) returns (stream berty.entity.Contact) {
    option (gql.graphql_output) = ".berty.node.ContactListConnection";
    option (gql.graphql_type) = "Query";
  };
  rpc Contact (ContactInput) returns (berty.entity.Contact) {
    option (gql.graphql_type) = "Query";
  };

  //
  // Conversations
  //

  rpc ConversationCreate (ConversationCreateInput) returns (berty.entity.Conversation) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc ConversationList (ConversationListInput) returns (stream berty.entity.Conversation) {
    option (gql.graphql_output) = ".berty.node.ConversationListConnection";
    option (gql.graphql_type) = "Query";
  };
  rpc ConversationInvite (ConversationManageMembersInput) returns (berty.entity.Conversation) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc ConversationExclude (ConversationManageMembersInput) returns (berty.entity.Conversation) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc ConversationAddMessage (ConversationAddMessageInput) returns (berty.p2p.Event) {
    option (gql.graphql_type) = "Mutation";
  };
  rpc GetConversation (gql.Node) returns (berty.entity.Conversation) {
    option (gql.graphql_type) = "Query";
  };
  rpc GetConversationMember (gql.Node) returns (berty.entity.ConversationMember) {
    option (gql.graphql_type) = "Query";
  };
  rpc ConversationRead (gql.Node) returns (berty.entity.Conversation) {
    option (gql.graphql_type) = "Mutation";
  }

  //rpc ConversationLeave(berty.entity.Conversation) returns (berty.entity.Conversation);
  //rpc ConversationJoinRequest(berty.entity.Conversation) returns (berty.entity.Conversation);
  //rpc ConverstionAcceptJoinRequest(berty.entity.Conversation) returns (berty.entity.Conversation);

  //
  // Devtools
  //

  // HandleEvent is the unencrypted (and unsafe) version of HandleEnvelope.
  // it's only exposed over the node API, it should be completely deactivated in public releases
  rpc HandleEvent (berty.p2p.Event) returns (Void) {
  };

  rpc GenerateFakeData (Void) returns (Void) {
    option (gql.graphql_type) = "Mutation";
  };

  rpc RunIntegrationTests (IntegrationTestInput) returns (IntegrationTestOutput) {
    option (gql.graphql_type) = "Mutation";
  };

  rpc DebugPing (PingDestination) returns (Void) {
  };

  rpc DebugRequeueEvent (EventIDInput) returns (berty.p2p.Event) {
    option (gql.graphql_type) = "Mutation";
  };

  rpc DebugRequeueAll (Void) returns (Void) {
    option (gql.graphql_type) = "Mutation";
  };

  rpc DeviceInfos (Void) returns (berty.pkg.deviceinfo.DeviceInfos) {
    option (gql.graphql_type) = "Query";
  };

  rpc AppVersion (Void) returns (AppVersionOutput) {
    option (gql.graphql_type) = "Query";
  };

  rpc Peers (Void) returns (berty.network.Peers) {
    option (gql.graphql_type) = "Query";
  };

  rpc Protocols (berty.network.Peer) returns (ProtocolsOutput) {
    option (gql.graphql_type) = "Query";
  };

  rpc LogStream (LogStreamInput) returns (stream LogEntry) {
    option (gql.graphql_type) = "Subscription";
  };

  rpc LogfileList (Void) returns (stream LogfileEntry) {
    option (gql.graphql_type) = "Query";
  }

  rpc LogfileRead (LogfileReadInput) returns (stream LogEntry) {
    option (gql.graphql_type) = "Subscription";
  }

  //
  // Metrics
  //

  // Yield bandwidth in real-time
  rpc MonitorBandwidth (berty.network.BandwidthStats) returns (stream berty.network.BandwidthStats) {
    option (gql.graphql_type) = "Subscription";
  };

  // Yield new peers in real-time
  rpc MonitorPeers (Void) returns (stream berty.network.Peer) {
    option (gql.graphql_type) = "Subscription";
  };

  rpc Panic (Void) returns (Void) {
    option (gql.graphql_type) = "Query";
  };
}

message ProtocolsOutput {
  repeated string protocols = 1;
};

message AppVersionOutput {
  string version = 1;
}

message PingDestination {
  string destination = 1;
}

message ContactRequestInput {
  berty.entity.Contact contact = 1;
  string intro_text = 2;
}

message ConversationAddMessageInput {
  berty.entity.Conversation conversation = 1;
  berty.entity.Message message = 2;
}

message EventStreamInput {
  berty.p2p.Event filter = 1;
}


// Node


//
// EventList
//
message EventListInput {
  berty.p2p.Event filter = 1;
  NullableTrueFalse only_without_acked_at = 2;
  Pagination paginate = 99 [(gql.graphql_spread) = true];
}
message EventEdge {
  berty.p2p.Event node = 1;
  string cursor = 2;
}
message EventListConnection {
  repeated EventEdge edges = 1;
  PageInfo page_info = 99 [(gql.graphql_non_nullable) = true];
}


//
// ContactList
//

message ContactListInput {
  berty.entity.Contact filter = 1;
  Pagination paginate = 99 [(gql.graphql_spread) = true];
}
message ContactEdge {
  berty.entity.Contact node = 1;
  string cursor = 2;
}
message ContactListConnection {
  repeated ContactEdge edges = 1;
  PageInfo page_info = 99 [(gql.graphql_non_nullable) = true];
}
message ContactInput {
  berty.entity.Contact filter = 1;
}


//
// ConversationList
//

message ConversationListInput {
  berty.entity.Conversation filter = 1;
  Pagination paginate = 99 [(gql.graphql_spread) = true];
}
message ConversationEdge {
  berty.entity.Conversation node = 1;
  string cursor = 2;
}
message ConversationListConnection{
  repeated ConversationEdge edges = 1;
  PageInfo page_info = 99 [(gql.graphql_non_nullable) = true];
}

message ConversationCreateInput {
  repeated berty.entity.Contact contacts = 1;
  string title = 2;
  string topic = 3;
}

message ConversationManageMembersInput {
  berty.entity.Conversation conversation = 1;
  repeated berty.entity.ConversationMember members = 2;
}

//
// common
//

message Pagination {
  // argument definition
  string order_by = 1;
  bool order_desc = 2;

  // feed definition
  int32 first = 11 [(gql.graphql_nullable) = true];
  string after = 12 [(gql.graphql_nullable) = true];
  int32 last = 13 [(gql.graphql_nullable) = true];
  string before = 14 [(gql.graphql_nullable) = true];
}

message PageInfo {
  string start_cursor = 1;
  string end_cursor = 2;
  bool has_next_page = 3;
  bool has_previous_page = 4;

  // non-standard
  uint32 count = 5;
}

message IntegrationTestInput {
  string name = 1;
}

message IntegrationTestOutput {
  string name = 1;
  bool success = 2;
  string verbose = 3;
  google.protobuf.Timestamp started_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
  google.protobuf.Timestamp finished_at = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
}

message Void {
  bool T = 1;
}

enum NullableTrueFalse {
  Null = 0;
  True = 1;
  False = 2;
}

message EventIDInput {
  string event_id = 1 [(gql.graphql_id) = true, (gogoproto.customname) = "EventID"];
}

//
// Logs
//

message LogStreamInput {
  bool continues = 1;     // stay connected and wait for new lines
  string log_level = 2;   // "debug", "info", "warn", "error"
  string namespaces = 3;  // "core.*", "*", ...
  int32 last = 4;         // number of previous lines to return, capped by the rotating buffer size
}

message LogEntry {
  string line = 1;        // line
  // string log_level = 2;
  // namespace
  // ...
}

message LogfileEntry {
  string path = 1;
  int32 filesize = 2;
  google.protobuf.Timestamp created_at = 3 [(gogoproto.stdtime) = true, (gogoproto.nullable) = true];
  google.protobuf.Timestamp updated_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = true];
}

message LogfileReadInput {
  string path = 1;
  // position
}

//
// Node Event (see kind.proto)
//

// NodeEvent is embedded in a classical p2p.Event with p2p.Event.Kind = p2p.Kind_Node
// we don't need to add base information as the created_at field, as we can already
// read them from the parent p2p.Event.
message NodeEvent {
  // Kind is an enum defining the event type.
  Kind kind = 1;

  // Attributes is a nested protobuf message containing per-event-type additional attributes.
  bytes attributes = 2;
}