datastore

type Datastore interface {
	// WriteData is our function call that writes a single encrypted data event to
	// the underlying storage substrate. It takes a WriteRequest containing the
	// actual data to be stored along with public key of the bucket for which data
	// should be persisted and the submitting user's DECODE user id. THese
	// additional attributes allow us to request the data from the bucket by
	// public key.
	WriteData(context.Context, *WriteRequest) (*WriteResponse, error)

	// ReadData is used to request data from the data store. Data is requested
	// keyed by the public key used to encrypt it (encoded as a Base64 or hex
	// string probably). In addition a read request allows the client to specify a
	// time interval so that data is only retrieved if it was recorded within the
	// interval. Pagination is supported to allow for large intervals to be
	// requested without having to return all the data in one hit.
	ReadData(context.Context, *ReadRequest) (*ReadResponse, error)
}

type EncryptedEvent struct {
	// The time at which the event was recorded by the datastore.
	EventTime *timestamp.Timestamp `protobuf:"bytes,1,opt,name=event_time,json=eventTime,proto3" json:"event_time,omitempty"`
	// The opaque chunk of bytes comprising the encoded data from the device.
	Data                 []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type HTTPClient interface {
	Do(req *http.Request) (*http.Response, error)
}

type ReadRequest struct {
	// The start time represents the start of an interval for which we wish to
	// read data. It is an error for start_time to be in the future or to be
	// after end_time. This field is required.
	StartTime *timestamp.Timestamp `protobuf:"bytes,2,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// The end time represents the end of an interval for which we wish to read
	// data. It may be nil, in which case it defaults to "now".
	EndTime *timestamp.Timestamp `protobuf:"bytes,3,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// The page cursor is an opaque string that an implementing server can
	// understand in order to efficiently paginate through events.  The value
	// sent here cannot be calculated by the client, rather they should just
	// inspect value returned from a previous call to to `ReadData` and if this a
	// non-empty string, then this value can be sent back to the server to get
	// the "next" page of results.  This field is optional.
	PageCursor string `protobuf:"bytes,4,opt,name=page_cursor,json=pageCursor,proto3" json:"page_cursor,omitempty"`
	// The maximum number of encrypted events to return in the response. The
	// default value is 500. Returns an error if the caller requests a larger
	// page size than the maximum.
	PageSize uint32 `protobuf:"varint,5,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// A string that uniquely identifies the community for which data is being
	// requested. A recipient will not be able to decrypt the data unless they
	// are in possession of the correct credentials. This is a required field.
	CommunityId          string   `protobuf:"bytes,7,opt,name=community_id,json=communityId,proto3" json:"community_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type ReadResponse struct {
	// The list of encrypted events containing the actual data being requested.
	// This list will be returned in ascending time order, and each element
	// contains a timestamp as well as the actual chunk of encrypted data. If no
	// data is available this will be an empty list.
	Events []*EncryptedEvent `protobuf:"bytes,2,rep,name=events,proto3" json:"events,omitempty"`
	// An optional field containing a pointer to the next page of results
	// expressed as an opaque string. Clients should not expect to be able to
	// parse this string as its contents are strictly implementation specific and
	// subject to change at any time. Rather the value here should just be checked
	// to see if it is an empty string or contains a value, and if any value is
	// present, the client can pass it back in a new read request as the value of
	// the page_cursor field.
	NextPageCursor string `protobuf:"bytes,3,opt,name=next_page_cursor,json=nextPageCursor,proto3" json:"next_page_cursor,omitempty"`
	// The page size that was originally requested to create this response.
	// Supplied to make it easy for the client to construct a new request for the
	// next page.
	PageSize uint32 `protobuf:"varint,4,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// A string that uniquely identifies the community for which data is being
	// sent. A recipient will not be able to decrypt the data unless they
	// are in possession of the correct credentials.
	CommunityId          string   `protobuf:"bytes,6,opt,name=community_id,json=communityId,proto3" json:"community_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type TwirpServer interface {
	http.Handler
	// ServiceDescriptor returns gzipped bytes describing the .proto file that
	// this service was generated from. Once unzipped, the bytes can be
	// unmarshalled as a
	// github.com/golang/protobuf/protoc-gen-go/descriptor.FileDescriptorProto.
	//
	// The returned integer is the index of this particular service within that
	// FileDescriptorProto's 'Service' slice of ServiceDescriptorProtos. This is a
	// low-level field, expected to be used for reflection.
	ServiceDescriptor() ([]byte, int)
	// ProtocGenTwirpVersion is the semantic version string of the version of
	// twirp used to generate this file.
	ProtocGenTwirpVersion() string
}

type WriteRequest struct {
	// A string that uniquely identifies the community for which data is being
	// written. A recipient will not be able to decrypt the data unless they are
	// in possession of valid credentials to decrypt this data. This is a
	// required field.
	CommunityId string `protobuf:"bytes,5,opt,name=community_id,json=communityId,proto3" json:"community_id,omitempty"`
	// The data field here is the encrypted data to be stored for the specified
	// public key/entitlement policy. From the datastore's perspective this can
	// just be a slice of bytes, however zenroom does permit this data to
	// maintain some structure. From the datastores perspective however it treats
	// this data as a completely opaque bytes.
	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	// A token that uniquely identifies the device. This is a required field.
	DeviceToken          string   `protobuf:"bytes,3,opt,name=device_token,json=deviceToken,proto3" json:"device_token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type WriteResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}