Define streaming APIs(Server side events, log stream, etc.) about cadl HOT 7 OPEN

// Helper model
model Stream<T> {
  @stream stream: T[]; // or not an array?
}

// Stream response string
op foo(): {@stream foo: string[]}
op foo(): {...Stream<string>}
// Stream input string
op foo(@stream foo: string[]): void
op foo(...Stream<string>): void

// Stream custom message
model MyMessage {id: string, value: string}
op foo(): {@stream foo: MyMessage[]}
op foo(): {...Stream<MyMessage>}
// Stream custom message
op foo(@stream foo: MyMessage[]): void
op foo(...Stream<MyMessage>): void

// Helper model
@intrinsic
model Stream<T> {
  stream: T;
}

// Stream response string
op foo(): Stream<string>

// Stream custom message
model MyMessage {id: string, value: string}
op foo(): Stream<MyMessage>
op foo(@body stream Stream<MyMessage>): void;

op foo(@body stream Stream<MyMessage>): Stream<MyMessage>;

model Message {
  id: string;
  from: string;
  group: string;
  content: string;
}
// Option 1
op messages(@stream messages: Message[]):  {@stream messages: Message[]}
// Option 2
op messages(@body messages: Stream<Message>):  {@body messages: Stream<Message>}

alias WebPubSubRequest = JoinGroupRequest | LeaveGroupRequest | SentToGroupRequest

model JoinGroupRequest {
  type: "joinGroup";
  group: string;
  ackId: int32;
}

model LeaveGroupRequest {
  type: "leaveGroup";
  group: string;
  ackId: int32;
}

model SentToGroupRequest {
    type: "sendToGroup";
    group: string;
    ackId : number;
    noEcho: boolean;
    dataType : "json" |"text"|"binary";
    data: string | {};
}

model WebPubSubResponse = AckResponse | MessageResponse;

model AckResponse {
  type:  "ack";
  ackId: number;
  success: boolean;
  error?: {
    name: "Forbidden"|"InternalServerError"|"Duplicate";
    message: string;
  }
}
model MessageResponse {
  type: "message";
  from: "group";
  group: string;
  dataType : "json" |"text"|"binary";
  data: string | {};
  fromUserId: string;
}

model ConnectedSystemResponse {
  type: "system";
  event: "connected";
  userId: string;
  connectionId: string;
}

model DisconnectedSystemResponse {
  type: "system";
  event: "disconnected";
  message: string;
}
// Option 1
op webpubsub(@stream messages: WebPubSubRequest[]):  {@stream messages: WebPubSubResponse[]}
// Option 2
op webpubsub(@body messages: Stream<WebPubSubRequest>): Stream<WebPubSubResponse>

model ServerSideEvent {
  id: string;
  event: string;
  data: {};
}

// Option 1
op messages(): {
  @header("Cache-Control") cacheControl: "no-store";
  @header("Content-Type")  contentType: "text/event-stream";
  @stream events: ServerSideEvent[];
}

// Option 2
op messages(): {
  @header("Cache-Control") cacheControl: "no-store";
  @header("Content-Type")  contentType: "text/event-stream";
  @body events: Stream<ServerSideEvent>;
}
// Option 2 alt with named model
model MyType is Stream<ServerSideEvent>{
  @header("Cache-Control") cacheControl: "no-store";
  @header("Content-Type")  contentType: "text/event-stream";
}
op messages(): MyType 

op readLogs(@query fromBytes: int64): string;
// ------------ convert to stream -------------


op readLogs(@query fromBytes: int64): Stream<string>;

op readLogs(@query fromBytes: int64): {@body body: string, @header contentType: "text/plain"};
// ------------ convert to stream -------------

op readLogs(@query fromBytes: int64): {@body stream: Stream<String>, @header contentType: "text/event-stream"};

op readLogs(@query fromBytes: int64): {data: string, lineCount: number, @header contentType: "application/json"};
// ------------ convert to stream -------------

// Option 1 wrap everything in stream type and have everything that should belong in the body be there.
op readLogs(@query fromBytes: int64): Stream<{data: string, lineCount: number, @header contentType: "application/json"}>;

// Option 2: Extract body manually
op readLogs(@query fromBytes: int64): {@body stream: Stream<{data: string, lineCount: number}>, @header contentType: "application/stream+json"};

// Option 3: @stream
op readLogs(@query fromBytes: int64): {@stream stream: {data: string, lineCount: number}, @header contentType: "application/stream+json"};

op readItems(@query skipCount: number): Foo[];
// ------------ convert to stream -------------

// Now stream the foo items.
op readItems(@query skipCount: number): Stream<Foo>;

op postItems(@body items: Foo[]): void;
// ------------ convert to stream -------------

// Now stream the foo items into the server.
op readItems(@body items: Stream<Foo>): void;

{"foo":"bar","baz":1}
{"foo":"qux","baz":2}