feat: streaming events (#309)

* feat: add stream event model

* docs: how to work with db models

* feat: put stream event

* chore: rm comments

* feat: add stream resource type

* feat: enqueue stream event

* fix: contracts

* feat: protos

* chore: set properties correctly for typing

* fix: stream example

* chore: rm old example

* fix: async on

* fix: bytea type

* fix: worker

* feat: put stream data

* feat: stream type

* fix: correct queue

* feat: streaming payloads

* fix: cleanup

* fix: validation

* feat: example file streaming

* chore: rm unused query

* fix: tenant check and read only consumer

* fix: check tenant-steprun relation

* Update prisma/schema.prisma

Co-authored-by: abelanger5 <belanger@sas.upenn.edu>

* chore: generate protos

* chore: rename migration

* release: 0.20.0

* feat(go-sdk): implement streaming in go

---------

Co-authored-by: gabriel ruttner <gabe@hatchet.run>
Co-authored-by: abelanger5 <belanger@sas.upenn.edu>

examples/stream-event/main.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/joho/godotenv"
+
+	"github.com/hatchet-dev/hatchet/pkg/client"
+	"github.com/hatchet-dev/hatchet/pkg/cmdutils"
+	"github.com/hatchet-dev/hatchet/pkg/worker"
+)
+
+type streamEventInput struct {
+	Index int `json:"index"`
+}
+
+type stepOneOutput struct {
+	Message string `json:"message"`
+}
+
+func StepOne(ctx worker.HatchetContext) (result *stepOneOutput, err error) {
+	input := &streamEventInput{}
+
+	err = ctx.WorkflowInput(input)
+
+	if err != nil {
+		return nil, err
+	}
+
+	ctx.StreamEvent([]byte(fmt.Sprintf("This is a stream event %d", input.Index)))
+
+	return &stepOneOutput{
+		Message: fmt.Sprintf("This ran at %s", time.Now().String()),
+	}, nil
+}
+
+func main() {
+	err := godotenv.Load()
+
+	if err != nil {
+		panic(err)
+	}
+
+	c, err := client.New()
+
+	if err != nil {
+		panic(err)
+	}
+
+	w, err := worker.NewWorker(
+		worker.WithClient(
+			c,
+		),
+	)
+
+	if err != nil {
+		panic(err)
+	}
+
+	err = w.On(
+		worker.NoTrigger(),
+		&worker.WorkflowJob{
+			Name:        "stream-event-workflow",
+			Description: "This sends a stream event.",
+			Steps: []*worker.WorkflowStep{
+				worker.Fn(StepOne).SetName("step-one"),
+			},
+		},
+	)
+
+	if err != nil {
+		panic(err)
+	}
+
+	interruptCtx, cancel := cmdutils.InterruptContextFromChan(cmdutils.InterruptChan())
+	defer cancel()
+
+	_, err = w.Start()
+
+	if err != nil {
+		panic(fmt.Errorf("error cleaning up: %w", err))
+	}
+
+	workflowRunId, err := c.Admin().RunWorkflow("stream-event-workflow", &streamEventInput{
+		Index: 0,
+	})
+
+	if err != nil {
+		panic(err)
+	}
+
+	err = c.Subscribe().Stream(interruptCtx, workflowRunId, func(event client.StreamEvent) error {
+		fmt.Println(string(event.Message))
+
+		return nil
+	})
+
+	if err != nil {
+		panic(err)
+	}
+}