@otonoma/paranet-client 2.11.0-rc.18

package/src/client.ts

@@ -0,0 +1,677 @@
+// Wrapper client around the paranet broker and data service.
+
+import { BrokerClient } from "./proto/broker.grpc.client";
+import { ConversationId, ConversationMembership } from "./proto/identifiers";
+import {
+  PncpRequest,
+  PncpMessage,
+  PncpCallback,
+  SkillMatchStrategy,
+  PncpMessageKind,
+} from "./proto/pncp";
+import { LoginRequest, MessageResponse, PncpCallbackRequest, RefreshTokenRequest } from "./proto/broker_api";
+import { jwtDecode } from "jwt-decode";
+import { ObservationCallback, ObservationMessageWrapper, ObservationRequest } from "./proto/observation";
+
+import { GrpcWebFetchTransport } from "@protobuf-ts/grpcweb-transport";
+import { RpcError, RpcMetadata, RpcOptions, ServerStreamingCall, UnaryCall } from "@protobuf-ts/runtime-rpc";
+import { fromJsonValue } from "./util";
+import { Value } from "./proto/otonoma/common/value";
+import { MessageRequest, PncpMessageObject, SkillRequest } from "./pncp";
+import { HealthClient } from "./proto/grpc/health/v1/health.client";
+import { HealthCheckRequest, HealthCheckResponse_ServingStatus } from "./proto/grpc/health/v1/health";
+
+export interface ParanetClientInit {
+  endpoint: string;
+  actorId: string;
+}
+
+export interface PncpClientInit {
+  endpoint: string;
+  actorId: string;
+  actorVersion?: string;
+  token?: string;
+  refreshToken?: string;
+}
+
+export class PncpClient {
+  transport: GrpcWebFetchTransport;
+  inner: BrokerClient;
+  health: HealthClient;
+  endpoint: string;
+  actorId: string;
+  actorVersion?: string;
+  token?: string;
+  refreshToken?: string;
+  tokenExp?: Date;
+  tokenCb?: (token: string, refresh: string) => void;
+
+  constructor(init: PncpClientInit) {
+    this.actorId = init.actorId;
+    this.endpoint = init.endpoint;
+    this.actorVersion = init.actorVersion;
+    // TODO: Consider passing in transport config.
+    this.transport = new GrpcWebFetchTransport({
+      baseUrl: init.endpoint,
+      format: "binary",
+      // TODO: Consider other methods here.
+    });
+    this.inner = new BrokerClient(this.transport);
+    this.health = new HealthClient(this.transport);
+  }
+
+  public async healthCheck(service: string = ""): Promise<boolean> {
+    const req: HealthCheckRequest = { service };
+    const response = this.health.check(req);
+    await response.status;
+    const data = await response.response;
+    return data.status === HealthCheckResponse_ServingStatus.SERVING;
+  }
+
+  public async pncpRequest(req: SkillRequest): Promise<MessageResponse> {
+    let version = req.actorVersion || this.actorVersion;
+    if (!version) {
+      throw new Error("Invalid request, must know the actor version");
+    }
+
+    let pncpReq: PncpRequest = {
+      body: {
+        subject: req.subject,
+        action: req.action,
+        body: Value.fromJson(req.body),
+      },
+      author: {
+        id: this.actorId,
+        version: version,
+      },
+      callback: req.callback ? fromJsonValue(req.callback) : undefined,
+      parentId: req.parentConversationId,
+      versionReq: req.versionReq,
+      targetActorId: req.targetId,
+      matchStrategy: req.matchStrategy || SkillMatchStrategy.BEST,
+      mustMatch: req.mustMatch || true,
+      useLock: req.useLock || false,
+      allowOpenMatch: req.allowOpenMatch || false,
+    };
+    return await this.directPncpRequest(pncpReq);
+  }
+
+  public async directPncpRequest(req: PncpRequest): Promise<MessageResponse> {
+    let response = await this.issue(req, BrokerClient.prototype.skillRequest);
+    return response;
+  }
+
+  public async pncpMessage(data: MessageRequest): Promise<MessageResponse> {
+    const [id, tag] = data.conversation.split("@");
+    const membership = tag === "requester" ? ConversationMembership.REQUESTER : tag === "fulfiller" ? ConversationMembership.FULFILLER : ConversationMembership.OBSERVER;
+    let pncpId: ConversationId = { id, membership };
+    return await this.pncpMessageObject({ id: pncpId, body: data.message });
+
+  }
+
+  public async pncpMessageObject(data: PncpMessageObject): Promise<MessageResponse> {
+    let extra: any;
+    switch (data.body.type) {
+      case PncpMessageKind.PNCP_QUESTION: {
+        extra = {
+          oneofKind: "question",
+          question: {
+            id: data.body.value.id,
+            callback: data.body.value.callback ? fromJsonValue(data.body.value.callback) : undefined,
+          }
+        };
+        break;
+      }
+      case PncpMessageKind.PNCP_ANSWER: {
+        extra = {
+          oneofKind: "answer",
+          answer: {
+            replyTo: data.body.value.reply_to,
+          }
+        };
+        break;
+      }
+      default: extra = { oneofKind: undefined };
+    }
+    let pncpMsg: PncpMessage = {
+      id: data.id,
+      kind: data.body.type,
+      body: fromJsonValue(data.body.value.data),
+      extra,
+    };
+
+    return await this.directPncpMessage(pncpMsg);
+
+  }
+
+  public async directPncpMessage(data: PncpMessage): Promise<MessageResponse> {
+    let response = await this.issue(data, BrokerClient.prototype.pncpMessageRequest);
+    return response;
+  }
+
+  // Creates a new pncp callback listener.
+  public pncpListener(): PncpListener {
+    return new PncpListener(this);
+  }
+
+  public observerListener(init: ObservationRequest): ParanetObserverListener {
+    return new ParanetObserverListener(this, init);
+  }
+
+  public async login(creds: LoginCredentials): Promise<TokenResponse> {
+    let secret: any;
+    switch (creds.kind) {
+      case "token":
+        secret = { oneofKind: "token", token: creds.secret }; break;
+      case "password": secret = { oneofKind: "password", password: creds.secret }; break;
+      default:
+        throw new Error("Invalid creds type");
+    }
+    let req: LoginRequest = {
+      actorId: this.actorId,
+      secret,
+    };
+
+    let response = await this.issue(req, BrokerClient.prototype.login);
+    let token = response.token;
+    let refresh_token = response.refreshToken;
+    this.setTokens(token, refresh_token);
+    return { refresh_token, access_token: token };
+  }
+
+  public async refreshAuth(): Promise<TokenResponse> {
+    if (!this.token || !this.refreshToken) {
+      throw new Error("Cannot refresh auth, no tokens set.");
+    }
+    let req: RefreshTokenRequest = {
+      token: this.token,
+      refreshToken: this.refreshToken,
+    };
+    let response = await this.issue(req, BrokerClient.prototype.refreshToken);
+    let token = response.token;
+    let refreshToken = response.refreshToken;
+    this.setTokens(token, refreshToken);
+    return { refresh_token: refreshToken, access_token: token };
+  }
+
+  public logout() {
+    this.setTokens();
+  }
+
+  public setTokens(token?: string, refresh?: string) {
+    this.token = token;
+    this.refreshToken = refresh;
+    if (token && refresh) {
+      let decoded = jwtDecode(token);
+      this.tokenExp = decoded.exp ? new Date(decoded.exp * 1000) : undefined;
+      if (this.tokenCb) {
+        this.tokenCb(token, refresh);
+      }
+    }
+  }
+
+  public setTokenCb(cb: (token: string, refresh: string) => void) {
+    this.tokenCb = cb;
+  }
+
+  public hasTokens(): boolean {
+    return this.token != undefined;
+  }
+
+  public getTokens(): { token?: string; refresh?: string } {
+    return { token: this.token, refresh: this.refreshToken };
+  }
+
+  public isTokenValid(): boolean {
+    if (!this.tokenExp) {
+      return false;
+    }
+    let now = new Date();
+    // Add one minute to now. This will make it so the token "expires" sooner than it really
+    // does, but allow a more clear indication that it is time to refresh.
+    now.setTime(now.getTime() + 1000 * 60);
+    return now < this.tokenExp;
+  }
+
+  getMetadata(): RpcMetadata {
+    return {
+      'x-actor-id': this.actorId,
+      ...(this.token && { 'authorization': `Bearer ${this.token}` })
+    };
+  }
+
+  async issue<R extends object, T extends object>(req: R, f: (this: BrokerClient, req: R, metadata: RpcOptions) => UnaryCall<R, T>): Promise<T> {
+    let md = this.getMetadata();
+    let response = f.bind(this.inner)(req, {
+      meta: md,
+    });
+    // Rejects if it failed.
+    await response.status;
+    let data = await response.response;
+    return data;
+  }
+}
+
+export abstract class ParanetListener<Treq extends object, Tres extends object, TresIn extends object = Tres> {
+  client: PncpClient;
+  start?: (client: PncpClient) => void;
+  msg?: (msg: Tres, client: PncpClient) => void;
+  error?: (msg: string, fatal: boolean) => void;
+  disconnected?: () => void;
+  reconnected?: () => void;
+  shouldAutoReconnect: boolean = true;
+
+  streamState?: {
+    stream: ServerStreamingCall<Treq, TresIn>;
+    abort: AbortController;
+  };
+
+  protected constructor(client: PncpClient) {
+    this.client = client;
+  }
+
+  protected abstract getRequest(): RpcStreamRequest<Treq, TresIn>;
+  protected abstract getRes(t: TresIn): Tres | null;
+
+  public onmessage(f: (msg: Tres, client: PncpClient) => void): this {
+    this.msg = f;
+    return this;
+  }
+
+  public onstart(f: (client: PncpClient) => void): this {
+    this.start = f;
+    return this;
+  }
+
+  public onerror(f: (msg: string, isFatal: boolean) => void): this {
+    this.error = f;
+    return this;
+  }
+
+  public ondisconnect(f: () => void): this {
+    this.disconnected = f;
+    return this;
+  }
+
+  public onreconnect(f: () => void): this {
+    this.reconnected = f;
+    return this;
+  }
+
+  public autoReconnect(v: boolean): this {
+    this.shouldAutoReconnect = v;
+    return this;
+  }
+
+
+  public connect() {
+    this.makeDecoratedStream(false);
+  }
+
+  public disconnect() {
+    if (this.streamState) {
+      this.streamState.abort.abort("disconnect called.");
+      this.streamState = undefined;
+    }
+  }
+
+  makeDecoratedStream(isReconnect: boolean, timeout = 100) {
+    if (this.streamState) {
+      this.disconnect();
+    }
+
+    // Set it up as a new one when we create a new stream.
+    let abort = new AbortController();
+
+    let { method, body } = this.getRequest();
+    let stream = method.bind(this.client.inner)(body, {
+      meta: this.client.getMetadata(),
+      abort: abort.signal
+    });
+    this.streamState = { stream, abort };
+    // Wait for the headers, indicating success.
+    // Note: This doesn't seem to work on firefox for some reason.
+    // Seems to be working fine in chrome though.
+    stream.headers.then((_headers) => {
+      this.start?.(this.client);
+      if (isReconnect) {
+        this.reconnected?.();
+      }
+    }).catch((err: RpcError) => {
+      // We need this catch here because of retry looping.
+      // We don't need to call this.error on this because it will come through on the onError still.
+    });
+
+    // Handle the message stream finally.
+    stream.responses.onMessage((msg) => {
+      let unwrapped = this.getRes(msg);
+      if (unwrapped) {
+        this.msg?.(unwrapped, this.client);
+      }
+    });
+
+    stream.responses.onError(async (err) => {
+      // Check if we aborted to know if we should retry or not.
+      this.disconnected?.();
+      if (!abort.signal.aborted) {
+        if (err.name == "RpcError") {
+          let rpcErr = err as RpcError;
+          if (rpcErr.code == "UNAUTHENTICATED") {
+            try {
+              await this.client.refreshAuth();
+            } catch (e) {
+              this.error?.(err.message, true);
+              abort.abort("Unauthenticated");
+              // Exit early in this case.
+              return;
+            }
+          }
+        }
+        this.error?.(err.message, false);
+        if (this.shouldAutoReconnect) {
+          // Increase timeout, saturated at 10000ms.
+          timeout = 2 * timeout + 1;
+          if (timeout > 10000)
+            timeout = 10000;
+          setTimeout(() => this.makeDecoratedStream(true, timeout), timeout);
+        }
+      }
+
+    });
+    // Semantically, this should never happen for a paranet connection, however, it might
+    // at some point in the future, so we should handle this case appropriately.
+    stream.responses.onComplete(() => {
+      this.disconnected?.();
+    });
+  }
+}
+
+export class PncpListener extends ParanetListener<PncpCallbackRequest, PncpCallback> {
+  constructor(client: PncpClient) {
+    super(client);
+  }
+
+  protected getRequest(): RpcStreamRequest<PncpCallbackRequest, PncpCallback> {
+    return {
+      method: BrokerClient.prototype.pncpCallbackStream,
+      body: {
+        disableSkillForwarding: false,
+      }
+    };
+  }
+
+  protected getRes(t: PncpCallback): PncpCallback | null {
+    if (t.body.oneofKind == undefined) return null;
+    return t;
+  }
+}
+
+interface RpcStreamRequest<TReq extends object, TRes extends object> {
+  method: (this: BrokerClient, body: TReq, meta: RpcOptions) => ServerStreamingCall<TReq, TRes>;
+  body: TReq;
+}
+
+export class ParanetObserverListener extends ParanetListener<ObservationRequest, ObservationCallback, ObservationMessageWrapper> {
+  init: ObservationRequest;
+  constructor(client: PncpClient, init: ObservationRequest) {
+    super(client);
+    this.init = init;
+  }
+
+  protected getRequest(): RpcStreamRequest<ObservationRequest, ObservationMessageWrapper> {
+    return {
+      method: BrokerClient.prototype.createObserverStream,
+      body: this.init,
+    };
+  }
+
+  protected getRes(t: ObservationMessageWrapper): ObservationCallback | null {
+    if (t.body) return t.body;
+    return null;
+  }
+}
+
+export abstract class BaseClient {
+  actorId: string;
+  endpoint: string;
+  // Access token, provided on login calls.
+  protected token?: string;
+  protected refreshToken?: string;
+  protected tokenExp?: Date;
+  protected tokenCb?: (token: string, refresh: string) => void;
+
+  constructor(init: ParanetClientInit) {
+    this.endpoint = cleanUrl(init.endpoint);
+    this.actorId = init.actorId;
+  }
+
+  public getEndpoint(): string {
+    return this.endpoint;
+  }
+
+  // Logs in this client and stores the token on the client.
+  public async login(secret: ActorSecret): Promise<TokenResponse> {
+    let id = this.actorId.split('@')[0];
+    console.log(secret);
+    let response: TokenResponse = await this.postJson(
+      "login",
+      {
+        id,
+        ...secret,
+      }
+    );
+
+    this.setTokens(response.access_token, response.refresh_token);
+    return response;
+  }
+
+  public async refreshAuth(): Promise<TokenResponse> {
+    let tokens: TokenResponse = await this.postJson(
+      "token/refresh",
+      {
+        token: this.token,
+        refresh_token: this.refreshToken,
+      }
+    );
+    this.setTokens(tokens.access_token, tokens.refresh_token);
+    return tokens;
+  }
+
+  public logout() {
+    this.setTokens();
+  }
+
+  public setTokens(token?: string, refresh?: string) {
+    this.token = token;
+    this.refreshToken = refresh;
+    if (token && refresh) {
+      let decoded = jwtDecode(token);
+      this.tokenExp = decoded.exp ? new Date(decoded.exp * 1000) : undefined;
+      if (this.tokenCb) {
+        this.tokenCb(token, refresh);
+      }
+    }
+  }
+
+  public setTokenCb(cb: (token: string, refresh: string) => void) {
+    this.tokenCb = cb;
+  }
+
+  public hasTokens(): boolean {
+    return this.token != undefined;
+  }
+
+  public getTokens(): { token?: string; refresh?: string } {
+    return { token: this.token, refresh: this.refreshToken };
+  }
+
+  public isTokenValid(): boolean {
+    if (!this.tokenExp) {
+      return false;
+    }
+    let now = new Date();
+    // Add one minute to now. This will make it so the token "expires" sooner than it really
+    // does, but allow a more clear indication that it is time to refresh.
+    now.setTime(now.getTime() + 1000 * 60);
+    return now < this.tokenExp;
+  }
+
+  protected async postJson<T>(path: string, body: any): Promise<T> {
+    let response = await this.post_(path, JSON.stringify(body), { "content-type": "application/json" });
+    return await response.json();
+  }
+
+  protected async post_(path: string, body: any, headers?: Record<string, string>): Promise<Response> {
+    let response = await this.fetch(path, "POST", body, headers);
+    return response;
+  }
+
+  protected async get<T>(path: string): Promise<T> {
+    let response = await this.fetch(path, "GET");
+    return await response.json();
+  }
+
+  protected async fetch(path: string, method: string, body?: any, headers?: Record<string, string>): Promise<Response> {
+    let url = `${this.endpoint}/${path}`;
+    const mkFetch = () => fetch(url, {
+      method,
+      body,
+      headers: {
+        ...(headers || {}),
+        ...this.getHeaders(),
+      },
+    });
+    let response = await mkFetch();
+    if (response.status == 401) {
+      await this.refreshAuth();
+      response = await mkFetch();
+    }
+    if (response.status != 200) {
+      let text = await response.text();
+      throw new Error(
+        `Failed to read from endpoint "${url}" (${response.status}): ${text} `
+      );
+    }
+
+    return response;
+  }
+
+  getHeaders(): any {
+    return {
+      "X-ACTOR-ID": this.actorId,
+      ...(this.token && { Authorization: `Bearer ${this.token}` }),
+    };
+  }
+}
+
+export class ParanetServiceClient extends BaseClient {
+  constructor(init: ParanetClientInit) {
+    super(init);
+  }
+
+  public serviceEndpoint(): string {
+    return this.endpoint;
+  }
+
+  // TODO fill in a specific type.
+  // TODO: At a higher level than this we need a schema manager which properly parses
+  // schemas and caches them.
+  public async schemaFetch(path: string): Promise<any> {
+    return await this.get(`schema/${path}`);
+  }
+
+  public async documentFetch({ name, id }: DocumentArgs): Promise<Response> {
+    if (name) {
+      return await this.fetch(`document/fetch/name/${name}`, "GET");
+    }
+
+    if (id) {
+      return await this.fetch(`document/fetch/id/${id}`, "GET");
+    }
+
+    throw new Error("Must provide either a name or id to fetch a document.");
+  }
+
+  public async documentUpload(data: File | any, args?: DocumentArgs): Promise<DocumentInfo> {
+    const formData = new FormData();
+    formData.append("file", data);
+    let response: Response | null = null;
+    if (args?.name) {
+      const url = `document/upload/name/${args.name}`;
+      response = await this.post_(url, formData);
+    }
+    else if (args?.id) {
+      const url = `document/upload/id/${args.id}`;
+      response = await this.post_(url, formData);
+    } else {
+      response = await this.post_("document/upload", formData);
+    }
+
+    return await response.json();
+  }
+
+  public async graphql(query: string, inputs?: Record<string, any>): Promise<any> {
+    let response: any = await this.postJson(
+      "graphql",
+      {
+        query,
+        variables: inputs,
+      }
+    );
+
+    return response;
+  }
+}
+
+export class SysClient extends BaseClient {
+  constructor(init: ParanetClientInit) {
+    super(init);
+  }
+
+  public async nodeInfo(): Promise<NodeInfo> {
+    return await this.get('node-info');
+  }
+}
+
+export interface LoginCredentials {
+  secret: string;
+  kind: "password" | "token" | "jwt";
+}
+
+export type ActorSecret = { password: string } | { token: string } | { jwt: string };
+
+export type TokenResponse = {
+  access_token: string;
+  refresh_token: string;
+};
+
+// Some util functions.
+function cleanUrl(url: string): string {
+  if (url.endsWith("/")) {
+    url = url.slice(0, url.length - 1);
+  }
+  return url;
+}
+
+export interface DocumentArgs {
+  name?: string;
+  id?: string;
+}
+
+export interface DocumentInfo {
+  id: string;
+  contentType: string;
+}
+
+export interface NodeInfo {
+  id: string;
+  name: string;
+  versions: {
+    broker: string;
+    expected_paraflow: string;
+    expected_paracord: string;
+    para_version: string;
+    platform_version: string;
+    platform_channel: string;
+  }
+}