# nodata

Nodata is a simple binary that consists of two parts:

1. Data ingest
2. Data storage
3. Data aggregation
4. Data API / egress

## Data ingest

Nodata presents a simple protobuf grpc api for ingesting either single events or batch

## Data storage

Nodata stores data locally in a parquet partitioned scheme

## Data aggregation

Nodata accepts wasm routines for running aggregations over data to be processed

## Data Egress

Nodata exposes aggregations as apis, or events to be sent as grpc streamed apis to a service.

# Architecture

## Data flow

Data enteres nodata

1. Application uses SDK to publish data
2. Data is sent over grpc using, a topic, id and data
3. Data is sent to a topic
4. A broadcast is sent that said topic was updated with a given offset
5. A client can consume from said topic, given a topic and id
// 6. We need a partition in here to separate handling between partitions and consumer groups
6. A queue is running consuming each broadcast message, assigning jobs for each consumer group to delegate messages

## Components

A component is a consumer on a set topic, it will either act as a source, sink or a tranformation between topics. It can declare topics, use topics, transform data and much more.

A topic at its most basic is a computational unit implementing a certain interface, source, sink, transformation. 

The most simple is a source and sink, where we respectively push or pull data from the topics.

A component implements either or all of 3 sdk interfaces

1. Create a new sample rust application
2. Add dependency nodata-component
3. In the main functin use: nodata_component::component
4. Implement the interfaces you want to use
5. Build the application into a dockerfile, optionally use the nodata cli to build the app
6. Register the application as a component
7. nodata client add-component --image docker.io/kjuulh/nodata-example-transform:latest --tranform `<input-topic>:<output-topic>`