busroot-sdk 0.0.0

package/eslint.config.mjs

@@ -0,0 +1,8 @@
+import tseslint from "typescript-eslint";
+import custom from "eslint-config-custom";
+
+const config = tseslint.config(custom, {
+  languageOptions: { parserOptions: { tsconfigRootDir: "./" } },
+});
+
+export default config;

package/jest.config.ts

@@ -0,0 +1,10 @@
+import type { Config } from "jest";
+
+export default async (): Promise<Config> => {
+  return {
+    verbose: true,
+    preset: "ts-jest",
+    testEnvironment: "node",
+    modulePathIgnorePatterns: ["<rootDir>/build"],
+  };
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "busroot-sdk",
+  "version": "0.0.0",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "example": "ts-node -r dotenv-expand/config ./src/example.ts",
+    "dev": "pnpm run lint && tsc -b --watch",
+    "build": "pnpm run lint && tsc -b --verbose",
+    "lint": "eslint 'src/**/*.ts'",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/react": "^18.0.26",
+    "eslint-config-custom": "workspace:*",
+    "ts-jest": "^29.4.0",
+    "tsconfig": "workspace:*",
+    "typescript-eslint": "^8.38.0"
+  },
+  "dependencies": {
+    "busroot-common": "workspace:*",
+    "jest": "^30.0.4",
+    "moment": "^2.30.1",
+    "mqtt": "^5.14.0",
+    "react": "^18.3.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.8.3",
+    "zod": "^3.25.1"
+  }
+}

package/src/client.test.ts

@@ -0,0 +1,5 @@
+import { describe, expect, test, beforeEach } from "@jest/globals";
+
+describe("test", () => {
+  test("test", () => {});
+});

package/src/client.ts

@@ -0,0 +1,226 @@
+import {
+  PlantSchema,
+  PlantViewModel,
+  ScheduleViewModel,
+  BusrootSignals,
+  SkuViewModel,
+  StationSchema,
+  StationViewModel,
+  AccountViewModel,
+  ApiKeyViewModel,
+  MqttEventType,
+} from "busroot-common";
+import mqtt from "mqtt/dist/mqtt.esm";
+
+export type Listener = (msg: any) => void;
+
+interface BusrootResponse {
+  isSuccess: boolean;
+  errorCode?: string;
+  result: any;
+  results: any[];
+}
+
+class Client {
+  mqttClient: mqtt.MqttClient;
+  listenersByEventType = new Map<keyof typeof MqttEventType, Set<Listener>>();
+  apiUrl: string;
+
+  constructor(public config: { accountId: string; apiKey: string; host: string }) {
+    this.apiUrl = "http://" + config.host + ":3000/api";
+
+    this.mqttClient = mqtt.connect({
+      host: config.host,
+      port: 8883,
+      username: "api-key",
+      password: this.config.apiKey,
+      clientId: this.config.accountId + "/sdk",
+    });
+
+    this.mqttClient.on("message", (topic, payload) => {
+      const eventType = topic.toUpperCase().split("/").at(-1);
+
+      for (const [listenerEventType, listeners] of this.listenersByEventType) {
+        if (MqttEventType[listenerEventType] !== eventType) {
+          continue;
+        }
+
+        for (const listener of listeners) {
+          try {
+            listener(JSON.parse(payload.toString()));
+          } catch (e) {
+            //
+          }
+        }
+      }
+    });
+
+    this.mqttClient.on("error", (error) => {
+      console.error(error);
+    });
+
+    this.mqttClient.on("connect", () => {
+      console.log("Connected to Busroot MQTT...");
+    });
+
+    this.mqttClient.on("reconnect", () => {
+      console.log("Disconnected from Busroot MQTT...");
+    });
+
+    this.mqttClient.subscribe(`busroot/v2/${this.config.accountId}/events/#`);
+  }
+
+  destroy() {
+    this.mqttClient.end();
+  }
+
+  private async get(path: string, query?: { [query: string]: string }) {
+    let url = this.apiUrl + path;
+
+    if (query != null) {
+      url +=
+        "?" +
+        Object.entries(query)
+          .map((value) => value[0] + "=" + value[1])
+          .join("&");
+    }
+
+    const res = await fetch(url, {
+      headers: { "x-api-key": this.config.apiKey },
+      method: "GET",
+    });
+
+    if (res.status !== 200) {
+      throw new Error(`${res.status}: ${res.statusText}`);
+    }
+
+    const resJson: BusrootResponse = await res.json();
+
+    return resJson;
+  }
+
+  private async post(path: string, body: object) {
+    const res = await fetch(this.apiUrl + path, {
+      headers: { "x-api-key": this.config.apiKey, "Content-Type": "application/json" },
+      method: "POST",
+      body: JSON.stringify(body),
+    });
+
+    const resJson: BusrootResponse = await res.json();
+
+    return resJson;
+  }
+
+  get profile() {
+    return {
+      get: async () => {
+        const res = await this.get("/auth/profile");
+
+        return res.result;
+      },
+    };
+  }
+
+  get account() {
+    return {
+      create: async (domain: string, plantName: string): Promise<{ account: AccountViewModel; apiKey: string }> => {
+        const res = await this.post("/account/new", { domain, plantName });
+
+        return res.result;
+      },
+    };
+  }
+
+  get apiKey() {
+    return {
+      create: async (): Promise<ApiKeyViewModel> => {
+        const res = await this.post("/api-key", {});
+
+        return res.result;
+      },
+    };
+  }
+
+  get plant() {
+    return {
+      get: async (plantCode: string): Promise<PlantViewModel> => {
+        const res = await this.get("/plant", { plantCode });
+
+        return res.result;
+      },
+      createUpdate: async (station: Partial<PlantSchema>): Promise<PlantViewModel> => {
+        const res = await this.post("/station", station);
+
+        return res.result;
+      },
+    };
+  }
+
+  get station() {
+    return {
+      get: async (stationCode: string): Promise<StationViewModel[]> => {
+        const res = await this.get("/station", { stationcodes: stationCode });
+
+        return res.results;
+      },
+      createUpdate: async (station: Partial<StationSchema>): Promise<StationViewModel> => {
+        const res = await this.post("/station", station);
+
+        return res.result;
+      },
+      signal: (stationCode: string, payload: BusrootSignals): void => {
+        throw new Error("noop");
+      },
+    };
+  }
+
+  sku = {
+    get: async (skuCode: string): Promise<SkuViewModel> => {
+      const res = await this.get("/sku", { skucodes: skuCode });
+
+      return res.result;
+    },
+    createUpdate: async (sku: Partial<SkuViewModel>): Promise<SkuViewModel> => {
+      const res = await this.post("/sku", sku);
+
+      return res.result;
+    },
+  };
+
+  schedule = {
+    get: async (scheduleId: number): Promise<ScheduleViewModel[]> => {
+      const res = await this.get("/schedule", { ids: String(scheduleId) });
+
+      return res.results;
+    },
+    createUpdate: async (schedule: Partial<ScheduleViewModel>): Promise<ScheduleViewModel> => {
+      const res = await this.post("/schedule", schedule);
+
+      return res.result;
+    },
+  };
+
+  on(event: MqttEventType, listener: Listener) {
+    let set = this.listenersByEventType.get(event);
+
+    if (!set) {
+      set = new Set<Listener>();
+      this.listenersByEventType.set(event, set);
+    }
+    set.add(listener);
+  }
+
+  off(event: MqttEventType, listener: Listener) {
+    const set = this.listenersByEventType.get(event);
+    if (!set) {
+      return;
+    }
+
+    set.delete(listener);
+    if (set.size === 0) {
+      this.listenersByEventType.delete(event);
+    }
+  }
+}
+
+export { Client };

package/src/example.ts

@@ -0,0 +1,43 @@
+import moment from "moment";
+import { Client } from "./client";
+
+async function main() {
+  const busrootOiClient = new Client({ accountId: "account_000", apiKey: "admin_api_key", host: "localhost" });
+
+  // const profile = await busroot.profile.get();
+
+  // console.log(profile);
+
+  const account = await busrootOiClient.account.create("opind.co", "London");
+
+  // console.log(account);
+
+  const busrootClient = new Client({ accountId: account.account.id, apiKey: account.apiKey, host: "localhost" });
+
+  // const profile = await busrootClient.profile.get();
+
+  // console.log(profile);
+
+  const station1 = await busrootClient.station.createUpdate({ code: "machine1", name: "Machine 1", groupCode: "unknown" });
+
+  const sku1 = await busrootClient.sku.createUpdate({ code: "PRODUCT1", name: "Product 1" });
+
+  const { id: scheduleId } = await busrootClient.schedule.createUpdate({
+    stationCode: station1.code,
+    skuCode: sku1.code,
+    plannedStartAt: moment().toISOString(),
+  });
+
+  console.log(scheduleId);
+
+  // busrootClient.station.signal(station1.code, { production_complete: 1 });
+
+  const schedule = await busrootClient.schedule.get(scheduleId);
+
+  console.log(schedule[0]);
+
+  busrootOiClient.destroy();
+  busrootClient.destroy();
+}
+
+main();

package/src/hooks.ts

@@ -0,0 +1,43 @@
+import { useEffect, useState } from "react";
+import { Client } from "./client";
+import z from "zod";
+
+// TODO: Account ID and API key should be saved to a local cookie and removed from the query param.
+// TODO: Add logout functionality, that clears the cookies.
+
+export const ConfigPayloadSchema = z.object({
+  accountId: z.string().max(255),
+  apiKey: z.string().max(255),
+  host: z.string().max(255),
+});
+
+export function useBusroot() {
+  const [client, setClient] = useState<Client>();
+
+  useEffect(() => {
+    if (typeof window === undefined) {
+      return;
+    }
+
+    const searchParams = new URLSearchParams(window.location.search);
+    const tokenParam = searchParams.get("busroot_token");
+
+    if (tokenParam != null && client == null) {
+      try {
+        const config = ConfigPayloadSchema.parse(JSON.parse(atob(tokenParam)));
+
+        setClient(new Client({ accountId: config.accountId, apiKey: config.apiKey, host: config.host }));
+      } catch (e: any) {
+        console.log(e.message);
+      }
+    }
+
+    return;
+  }, []);
+
+  const logout = () => {
+    console.log("not implemented");
+  };
+
+  return { client, logout };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./hooks";

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "tsconfig/base.json",
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "build"],
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "build",
+    "target": "es2020",
+  }
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/client.test.ts","./src/client.ts","./src/example.ts","./src/hooks.ts","./src/index.ts"],"version":"5.8.3"}