@alphauspkgs/blue-sdk-ts 1.0.2 → 1.0.4

package/conn/conn.js

@@ -1,23 +1,25 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WithAccessToken = exports.BlueAPIService = void 0;
+exports.BlueCredentials = exports.WithNewBlueCredentials = exports.WithAccessToken = exports.WithDefaultCredentials = exports.BlueAPIService = void 0;
 const connect_1 = require("@connectrpc/connect");
 const connect_web_1 = require("@connectrpc/connect-web");
 const connect_devtools_1 = require("connect-devtools");
+const axios_1 = __importDefault(require("axios"));
+const DEFAULT_BLUE_RPC_HOST = "https://bluerpc.alphaus.cloud:8443";
+const DEFAULT_AUTH_URL = "https://login.alphaus.cloud/ripple/access_token";
 class BlueAPIService {
     get clientInstance() {
         return this.client;
     }
-    constructor(service, serviceName, connectOptions = []) {
+    constructor(service, serviceName, connectOption = new WithDefaultCredentials()) {
         this.serviceName = serviceName;
-        this.host = "https://bluerpc.alphaus.cloud:8443";
-        if (!connectOptions.length) {
-            throw new Error("At least one ConnectOption is required");
-        }
         const interceptors = [
             (next) => async (req) => {
                 req.header.set("service-name", this.serviceName);
-                connectOptions.forEach((option) => option.apply(req.header));
+                await connectOption.apply(req.header);
                 return await next(req);
             },
         ];
@@ -26,19 +28,96 @@ class BlueAPIService {
             interceptors.push(connect_devtools_1.devtoolsInterceptor);
         }
         const transport = (0, connect_web_1.createGrpcWebTransport)({
-            baseUrl: this.host,
+            baseUrl: connectOption.getHost(),
             interceptors: interceptors,
         });
         this.client = (0, connect_1.createClient)(service, transport);
     }
 }
 exports.BlueAPIService = BlueAPIService;
+class WithDefaultCredentials {
+    constructor() {
+        this.env = process.env;
+        this.clientId =
+            this.env["ALPHAUS_CLIENT_ID"] ||
+                this.env["ALPHAUS_RIPPLE_CLIENT_ID"] ||
+                this.env["ALPHAUS_WAVE_CLIENT_ID"];
+        this.clientSecret =
+            this.env["ALPHAUS_CLIENT_SECRET"] ||
+                this.env["ALPHAUS_RIPPLE_CLIENT_SECRET"] ||
+                this.env["ALPHAUS_WAVE_CLIENT_SECRET"];
+        if (!this.clientId && !this.clientSecret) {
+            throw new Error("Missing client ID and client secret");
+        }
+    }
+    getHost() {
+        return DEFAULT_BLUE_RPC_HOST;
+    }
+    async apply(req) {
+        // get access token
+        const creds = new BlueCredentials({
+            clientId: this.clientId,
+            clientSecret: this.clientSecret,
+            authUrl: this.env["ALPHAUS_AUTH_URL"],
+            userName: this.env["ALPHAUS_USERNAME"],
+            password: this.env["ALPHAUS_PASSWORD"],
+        });
+        req.set("Authorization", `Bearer ${await creds.getAccessToken()}`);
+    }
+}
+exports.WithDefaultCredentials = WithDefaultCredentials;
 class WithAccessToken {
-    constructor(accessToken) {
+    constructor(accessToken, host) {
         this.accessToken = accessToken;
+        this.host = host;
+    }
+    getHost() {
+        return this.host || DEFAULT_BLUE_RPC_HOST;
     }
     apply(req) {
         req.set("Authorization", `Bearer ${this.accessToken}`);
+        return Promise.resolve();
     }
 }
 exports.WithAccessToken = WithAccessToken;
+class WithNewBlueCredentials {
+    constructor(creds) {
+        this.creds = creds;
+    }
+    getHost() {
+        return this.creds.input.host || DEFAULT_BLUE_RPC_HOST;
+    }
+    async apply(req) {
+        req.set("Authorization", `Bearer ${await this.creds.getAccessToken()}`);
+    }
+}
+exports.WithNewBlueCredentials = WithNewBlueCredentials;
+class BlueCredentials {
+    constructor(input) {
+        this.input = input;
+    }
+    isUserPassAuth() {
+        return !!(this.input.userName && this.input.password);
+    }
+    async getAccessToken() {
+        const gt = this.isUserPassAuth() ? "password" : "client_credentials";
+        const url = this.input.authUrl || DEFAULT_AUTH_URL;
+        try {
+            const formData = new FormData();
+            formData.append("client_id", this.input.clientId);
+            formData.append("client_secret", this.input.clientSecret);
+            formData.append("grant_type", gt);
+            formData.append("scope", "openid");
+            if (this.isUserPassAuth()) {
+                formData.append("username", this.input.userName);
+                formData.append("password", this.input.password);
+            }
+            const response = await axios_1.default.post(url, formData);
+            return response.data.access_token;
+        }
+        catch (error) {
+            throw new Error(`Failed to get access token: ${error}`);
+        }
+    }
+}
+exports.BlueCredentials = BlueCredentials;

package/conn/conn.ts

@@ -2,10 +2,12 @@ import { createClient, Interceptor, type Client } from "@connectrpc/connect";
 import { createGrpcWebTransport } from "@connectrpc/connect-web";
 import type { DescService } from "@bufbuild/protobuf";
 import { devtoolsInterceptor } from "connect-devtools";
+import axios from "axios";
 
+const DEFAULT_BLUE_RPC_HOST = "https://bluerpc.alphaus.cloud:8443";
+const DEFAULT_AUTH_URL = "https://login.alphaus.cloud/ripple/access_token";
 export class BlueAPIService<Service extends DescService> {
   private client: Client<Service>;
-  private host: string = "https://bluerpc.alphaus.cloud:8443";
 
   get clientInstance(): Client<Service> {
     return this.client;
@@ -14,16 +16,12 @@ export class BlueAPIService<Service extends DescService> {
   constructor(
     service: Service,
     private serviceName: string,
-    connectOptions: ConnectOption[] = []
+    connectOption: ConnectOption = new WithDefaultCredentials()
   ) {
-    if (!connectOptions.length) {
-      throw new Error("At least one ConnectOption is required");
-    }
-
     const interceptors: Interceptor[] = [
       (next) => async (req) => {
         req.header.set("service-name", this.serviceName);
-        connectOptions.forEach((option) => option.apply(req.header));
+        await connectOption.apply(req.header);
         return await next(req);
       },
     ];
@@ -36,22 +34,117 @@ export class BlueAPIService<Service extends DescService> {
     }
 
     const transport = createGrpcWebTransport({
-      baseUrl: this.host,
+      baseUrl: connectOption.getHost(),
       interceptors: interceptors,
     });
 
     this.client = createClient(service, transport);
   }
 }
-
 export interface ConnectOption {
-  apply(req: Headers): void;
+  apply(req: Headers): Promise<void>;
+  getHost(): string;
 }
 
+export class WithDefaultCredentials implements ConnectOption {
+  private readonly clientId?: string;
+  private readonly clientSecret?: string;
+  private readonly env = process.env;
+
+  constructor() {
+    this.clientId =
+      this.env["ALPHAUS_CLIENT_ID"] ||
+      this.env["ALPHAUS_RIPPLE_CLIENT_ID"] ||
+      this.env["ALPHAUS_WAVE_CLIENT_ID"];
+    this.clientSecret =
+      this.env["ALPHAUS_CLIENT_SECRET"] ||
+      this.env["ALPHAUS_RIPPLE_CLIENT_SECRET"] ||
+      this.env["ALPHAUS_WAVE_CLIENT_SECRET"];
+
+    if (!this.clientId && !this.clientSecret) {
+      throw new Error("Missing client ID and client secret");
+    }
+  }
+
+  getHost(): string {
+    return DEFAULT_BLUE_RPC_HOST;
+  }
+
+  async apply(req: Headers): Promise<void> {
+    // get access token
+    const creds = new BlueCredentials({
+      clientId: this.clientId!,
+      clientSecret: this.clientSecret!,
+      authUrl: this.env["ALPHAUS_AUTH_URL"],
+      userName: this.env["ALPHAUS_USERNAME"],
+      password: this.env["ALPHAUS_PASSWORD"],
+    });
+    req.set("Authorization", `Bearer ${await creds.getAccessToken()}`);
+  }
+}
 export class WithAccessToken implements ConnectOption {
-  constructor(private accessToken: string) {}
+  constructor(
+    private readonly accessToken: string,
+    private readonly host?: string
+  ) {}
+
+  getHost(): string {
+    return this.host || DEFAULT_BLUE_RPC_HOST;
+  }
 
-  apply(req: Headers): void {
+  apply(req: Headers): Promise<void> {
     req.set("Authorization", `Bearer ${this.accessToken}`);
+    return Promise.resolve();
   }
 }
+
+export class WithNewBlueCredentials implements ConnectOption {
+  constructor(private creds: BlueCredentials) {}
+
+  getHost(): string {
+    return this.creds.input.host || DEFAULT_BLUE_RPC_HOST;
+  }
+
+  async apply(req: Headers): Promise<void> {
+    req.set("Authorization", `Bearer ${await this.creds.getAccessToken()}`);
+  }
+}
+
+export class BlueCredentials {
+  constructor(public readonly input: BlueCredentials.Input) {}
+
+  private isUserPassAuth(): boolean {
+    return !!(this.input.userName && this.input.password);
+  }
+
+  async getAccessToken() {
+    const gt = this.isUserPassAuth() ? "password" : "client_credentials";
+    const url = this.input.authUrl || DEFAULT_AUTH_URL;
+    try {
+      const formData = new FormData();
+      formData.append("client_id", this.input.clientId);
+      formData.append("client_secret", this.input.clientSecret);
+      formData.append("grant_type", gt);
+      formData.append("scope", "openid");
+      if (this.isUserPassAuth()) {
+        formData.append("username", this.input.userName!);
+        formData.append("password", this.input.password!);
+      }
+      const response = await axios.post(url, formData);
+      return response.data.access_token;
+    } catch (error) {
+      throw new Error(`Failed to get access token: ${error}`);
+    }
+  }
+}
+
+namespace BlueCredentials {
+  export type Input = {
+    clientId: string;
+    clientSecret: string;
+    authUrl?: string;
+    userName?: string;
+    password?: string;
+    host?: string;
+  };
+}

package/cost/v1/client.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NewCostClient = NewCostClient;
 const cost_pb_1 = require("./cost_pb");
 const conn_1 = require("../../conn/conn");
-function NewCostClient(...opts) {
-    const blueapi = new conn_1.BlueAPIService(cost_pb_1.Cost, "cost", opts);
+function NewCostClient(opt) {
+    const blueapi = new conn_1.BlueAPIService(cost_pb_1.Cost, "cost", opt);
     return blueapi.clientInstance;
 }

package/cost/v1/client.ts

@@ -1,7 +1,7 @@
 import { Cost } from "./cost_pb";
 import { BlueAPIService, ConnectOption } from "../../conn/conn";
 
-export function NewCostClient(...opts: ConnectOption[]) {
-  const blueapi = new BlueAPIService(Cost, "cost", opts);
+export function NewCostClient(opt?: ConnectOption) {
+  const blueapi = new BlueAPIService(Cost, "cost", opt);
   return blueapi.clientInstance;
 }