busroot-sdk 0.0.0 → 0.0.2

package/build/client.d.ts

@@ -0,0 +1,62 @@
+import { PlantSchema, PlantViewModel, ScheduleViewModel, BusrootSignals, SkuViewModel, StationSchema, StationViewModel, AccountViewModel, ApiKeyViewModel } from "./common";
+import mqtt from "mqtt/dist/mqtt.esm";
+export declare const MqttEventType: {
+    StationMetricNew: string;
+    StationChanged: string;
+    ScheduleChanged: string;
+    ScheduleStarted: string;
+    ScheduleEnded: string;
+    ProductionNew: string;
+};
+export type MqttEventType = keyof typeof MqttEventType;
+export type Listener = (msg: any) => void;
+declare class Client {
+    config: {
+        accountId: string;
+        apiKey: string;
+        host: string;
+    };
+    mqttClient: mqtt.MqttClient;
+    listenersByEventType: Map<"StationMetricNew" | "StationChanged" | "ScheduleChanged" | "ScheduleStarted" | "ScheduleEnded" | "ProductionNew", Set<Listener>>;
+    apiUrl: string;
+    constructor(config: {
+        accountId: string;
+        apiKey: string;
+        host: string;
+    });
+    destroy(): void;
+    private get;
+    private post;
+    get profile(): {
+        get: () => Promise<any>;
+    };
+    get account(): {
+        create: (domain: string, plantName: string) => Promise<{
+            account: AccountViewModel;
+            apiKey: string;
+        }>;
+    };
+    get apiKey(): {
+        create: () => Promise<ApiKeyViewModel>;
+    };
+    get plant(): {
+        get: (plantCode: string) => Promise<PlantViewModel>;
+        createUpdate: (station: Partial<PlantSchema>) => Promise<PlantViewModel>;
+    };
+    get station(): {
+        get: (stationCode: string) => Promise<StationViewModel[]>;
+        createUpdate: (station: Partial<StationSchema>) => Promise<StationViewModel>;
+        signal: (stationCode: string, payload: BusrootSignals) => void;
+    };
+    sku: {
+        get: (skuCode: string) => Promise<SkuViewModel>;
+        createUpdate: (sku: Partial<SkuViewModel>) => Promise<SkuViewModel>;
+    };
+    schedule: {
+        get: (scheduleId: number) => Promise<ScheduleViewModel[]>;
+        createUpdate: (schedule: Partial<ScheduleViewModel>) => Promise<ScheduleViewModel>;
+    };
+    on(event: MqttEventType, listener: Listener): void;
+    off(event: MqttEventType, listener: Listener): void;
+}
+export { Client };

package/build/client.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = exports.MqttEventType = void 0;
+const mqtt_esm_1 = __importDefault(require("mqtt/dist/mqtt.esm"));
+exports.MqttEventType = {
+    StationMetricNew: "STATION_METRIC_NEW", // When a new station window is created and saved to DB.
+    StationChanged: "STATION_CHANGED", // When a station is added or edited. NOT IMPLEMENTED.
+    ScheduleChanged: "SCHEDULE_CHANGED", // When a schedule is added or edited. NOT IMPLEMENTED.
+    ScheduleStarted: "SCHEDULE_STARTED", // When a schedule starts (actualStartAt). NOT IMPLEMENTED.
+    ScheduleEnded: "SCHEDULE_ENDED", // When a schedule ends (actualEndAt). NOT IMPLEMENTED.
+    ProductionNew: "PRODUCTION_NEW", // When new production is added. NOT IMPLEMENTED FOR MANUAL PRODUCTION YET.
+};
+class Client {
+    constructor(config) {
+        this.config = config;
+        this.listenersByEventType = new Map();
+        this.sku = {
+            get: async (skuCode) => {
+                const res = await this.get("/sku", { skucodes: skuCode });
+                return res.result;
+            },
+            createUpdate: async (sku) => {
+                const res = await this.post("/sku", sku);
+                return res.result;
+            },
+        };
+        this.schedule = {
+            get: async (scheduleId) => {
+                const res = await this.get("/schedule", { ids: String(scheduleId) });
+                return res.results;
+            },
+            createUpdate: async (schedule) => {
+                const res = await this.post("/schedule", schedule);
+                return res.result;
+            },
+        };
+        this.apiUrl = "http://" + config.host + ":3000/api";
+        this.mqttClient = mqtt_esm_1.default.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 (exports.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();
+    }
+    async get(path, query) {
+        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 = await res.json();
+        return resJson;
+    }
+    async post(path, body) {
+        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 = 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, plantName) => {
+                const res = await this.post("/account/new", { domain, plantName });
+                return res.result;
+            },
+        };
+    }
+    get apiKey() {
+        return {
+            create: async () => {
+                const res = await this.post("/api-key", {});
+                return res.result;
+            },
+        };
+    }
+    get plant() {
+        return {
+            get: async (plantCode) => {
+                const res = await this.get("/plant", { plantCode });
+                return res.result;
+            },
+            createUpdate: async (station) => {
+                const res = await this.post("/station", station);
+                return res.result;
+            },
+        };
+    }
+    get station() {
+        return {
+            get: async (stationCode) => {
+                const res = await this.get("/station", { stationcodes: stationCode });
+                return res.results;
+            },
+            createUpdate: async (station) => {
+                const res = await this.post("/station", station);
+                return res.result;
+            },
+            signal: (stationCode, payload) => {
+                throw new Error("noop");
+            },
+        };
+    }
+    on(event, listener) {
+        let set = this.listenersByEventType.get(event);
+        if (!set) {
+            set = new Set();
+            this.listenersByEventType.set(event, set);
+        }
+        set.add(listener);
+    }
+    off(event, listener) {
+        const set = this.listenersByEventType.get(event);
+        if (!set) {
+            return;
+        }
+        set.delete(listener);
+        if (set.size === 0) {
+            this.listenersByEventType.delete(event);
+        }
+    }
+}
+exports.Client = Client;

package/build/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/client.test.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+(0, globals_1.describe)("test", () => {
+    (0, globals_1.test)("test", () => { });
+});

package/build/common.d.ts

@@ -0,0 +1,276 @@
+import { z } from 'zod';
+
+interface BusrootSignals {
+  timestamp?: number;
+  production_complete?: number;
+  bad_production_complete?: number;
+  production_count?: number;
+  production_count_good?: number;
+  bad_production_count?: number;
+  production_count_bad?: number;
+  sku_code?: string;
+  productive?: number;
+  line_speed?: number;
+  speed?: number;
+  status_code?: string;
+  electrical_kwh?: number;
+  electrical_kwh_interval?: number;
+  electrical_v?: number;
+  electrical_a?: number;
+  electrical_kw?: number;
+  electrical_hz?: number;
+  electrical_pf?: number;
+  rssi?: number;
+}
+
+interface PlantSchema {
+  code: string;
+  name: string;
+  timezone: string;
+  accountId: string;
+  dayStartHour: number;
+  createdAt?: string;
+  updatedAt?: string;
+  archivedAt?: string;
+}
+
+declare const StationSchema = z.object({
+  // Basics
+  accountId: z.string(),
+  code: z.string(),
+  name: z.string().trim().min(1).max(32),
+  groupCode: z.string(),
+  shiftPatternId: z.number().int().positive().nullish(),
+  moduleVisibility: z.array(z.nativeEnum(STATION_MODULE_VISIBILITY)).nullish(),
+  minimumCycleTime: z.number().int().gte(0).lte(TimeIntervals["12h"].ms).nullish(),
+  speedScale: z.number().gte(-9999).lte(9999).nullish(),
+  speedOffset: z.number().gte(-9999).lte(9999).nullish(),
+  speedToProductionRatio: z.number().gte(0).lte(99999).nullish(),
+  electricalPowerNominalKw: z.number().gte(0).nullish(),
+
+  // Defaults
+  idleCostPerMinute: z.number().gte(0).lte(99999).nullish(),
+
+  // Downtime Settings
+  downtimeDetectionMode: z.nativeEnum(DOWNTIME_DETECTION_MODE).default(DOWNTIME_DETECTION_MODE.UTILISATION).optional(),
+  utilisationDowntimeThreshold: z.preprocess((val) => (val === null ? TimeIntervals["1h"].ms : val), z.number().int().gte(0).optional()),
+
+  slowDurationThreshold: z.number().int().gte(0).nullish(),
+  forceAllShiftTimeAsPlannedProduction: z.boolean().default(true),
+
+  // Productive Settings
+  productiveStatusMode: z.nativeEnum(PRODUCTIVE_STATUS_MODE).default(PRODUCTIVE_STATUS_MODE.PRODUCTIVE_SIGNAL).optional(),
+  electricalUsageStoppedThresholdKw: z.number().gte(0).nullish(),
+  lineSpeedStoppedThreshold: z.number().gte(0).nullish(),
+  productiveHoldOnTime: z.number().int().gte(0).lte(TimeIntervals["1d"].ms).nullish(),
+
+  // Flags
+  allowInterruptionMode: z.boolean().default(false).optional(),
+  allowManualProduction: z.boolean().default(false).optional(),
+  allowQuickScheduleStart: z.boolean().default(false).optional(),
+  allowScheduleCutShort: z.boolean().default(false).optional(),
+
+  // Current State
+  currentOperatorInitials: z.string().min(3).max(3).nullish(),
+  statusCode: z.string().nullish(),
+  statusCodeUpdatedAt: z.string().nullish(),
+
+  // Performance Mode
+  cycleTime: z.number().int().gt(0).lte(TimeIntervals["12h"].ms).nullish(),
+  unitsPerMinute: z.number().int().gt(0).nullish(),
+  unitsPerHour: z.number().int().gt(0).nullish(),
+  lineSpeedTarget: z.number().gt(0).lte(99999).nullish(),
+
+  // System info
+  createdAt: z.string().nullish(),
+  updatedAt: z.string().nullish(),
+  archivedAt: z.string().nullish(),
+});
+
+type StationSchema = z.infer<typeof StationSchema>;
+
+declare const ApiKeySchema = z.object({
+  accountId: z.string(),
+  key: z.string(),
+  createdByUserId: z.number(),
+  expiresAt: z.string(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+type ApiKeySchema = z.infer<typeof ApiKeySchema>;
+
+declare const PlantViewModel = z.object({
+  code: z.string(),
+  name: z.string(),
+  timezone: z.string(),
+  now: z.string(),
+  stationGroups: z.array(StationGroupSchema.omit({ accountId: true })),
+  dayStartHour: z.number(),
+});
+
+type PlantViewModel = z.infer<typeof PlantViewModel>;
+
+declare const SkuViewModel = z.object({
+  code: z.string(),
+  name: z.string(),
+  cycleTime: z.number().nullish(),
+  specifications: z.object({ name: z.string(), value: z.string() }).array().nullish(),
+  instructionsUrl: z.string().nullish(),
+  lineSpeedTarget: z.number().nullish(),
+  downtimeDurationThresholdMultiplier: z.number().nullish(),
+  allowUseInQuickSchedule: z.boolean().nullish(),
+  unitsPerMinute: z.number().nullish(),
+  unitsPerHour: z.number().nullish(),
+  batchSize: z.number().nullish(),
+  value: z.number().nullish(),
+  minimumCycleTime: z.number().nullish(),
+});
+type SkuViewModel = z.infer<typeof SkuViewModel>;
+
+type ApiKeyViewModel = ApiKeySchema;
+
+declare const ScheduleViewModel = z.object({
+  id: z.number(),
+  stationCode: z.string(),
+  stationName: z.string().optional(),
+  accountId: z.string(),
+  plannedStartAt: z.string(),
+  plannedStartAtTimestamp: z.number(),
+  plannedEndAt: z.string().optional(),
+  plannedEndAtTimestamp: z.number().optional(),
+  workOrderReference: z.string().optional(),
+  plannedDuration: z.number().optional(),
+  plannedQuantity: z.number().optional(),
+  nonProductionReasonCode: z.string().optional(),
+  nonProductionReasonDescription: z.string().optional(),
+  skuCode: z.string().optional(),
+  skuName: z.string().optional(),
+  skuValue: z.number().optional(),
+  batchSize: z.number().optional(),
+  autoEndOnQuantityComplete: z.boolean().optional(),
+
+  cycleTime: z.number().optional(),
+  unitsPerMinute: z.number().optional(),
+  unitsPerHour: z.number().optional(),
+  lineSpeedTarget: z.number().optional(),
+
+  effectiveCycleTime: z.number().optional(),
+  effectiveUnitsPerMinute: z.number().optional(),
+  effectiveUnitsPerHour: z.number().optional(),
+  effectiveLineSpeedTarget: z.number().optional(),
+  effectiveBatchSize: z.number().optional(),
+  effectiveMinimumCycleTime: z.number().optional(),
+
+  deletedAt: z.string().optional(),
+  actualStartAt: z.string().optional(),
+  actualStartAtTimestamp: z.number().optional(),
+  actualEndAt: z.string().optional(),
+  actualEndAtTimestamp: z.number().optional(),
+  idealEndAt: z.string().optional(),
+  idealEndAtTimestamp: z.number().optional(),
+  quantityGood: z.number().optional(),
+  quantityBad: z.number().optional(),
+  skuGroupCode: z.string().optional(),
+  skuGroupName: z.string().optional(),
+  extendShift: z.boolean().optional(),
+  downtimeDurationThresholdMultiplier: z.number().optional(),
+  isStarted: z.boolean(),
+  isEnded: z.boolean(),
+  status: z.enum(["running", "planned", "deleted", "completed"]),
+  allowScheduleCutShort: z.boolean().optional(),
+  idealQuantity: z.number().optional(),
+  performanceModeFrom: z.enum(["schedule", "sku", "station", "none"]).optional(),
+  logs: z.array(z.string()).optional(),
+  priorityAt: z.string().optional(),
+});
+
+type ScheduleViewModel = z.infer<typeof ScheduleViewModel>;
+
+declare const StationViewModel = z.object({
+  code: z.string(), // from station table
+  name: z.string(), // from station table
+  groupCode: z.string().nullish(), // from station table
+  groupName: z.string().nullish(), // from join with group table
+  allowScheduleStationFlexibility: z.boolean().nullish(), // from join with group table
+  plantCode: z.string(), // from station table
+  timezone: z.string(), // from join with plant table
+  accountId: z.string(), // from station table
+  currentOperatorInitials: z.string().nullish(), // from station table
+
+  cycleTime: z.number().nullish(), // from station table
+  unitsPerMinute: z.number().nullish(),
+  unitsPerHour: z.number().nullish(),
+  lineSpeedTarget: z.number().nullish(), // from station table
+
+  allowInterruptionMode: z.boolean().nullish(),
+  allowManualProduction: z.boolean().nullish(),
+  downtimeDetectionMode: z.nativeEnum(DOWNTIME_DETECTION_MODE), // from station table
+  utilisationDowntimeThreshold: z.number().nullish(), // from station table
+  slowDurationThreshold: z.number().nullish(), // from station table
+  electricalUsageStoppedThresholdKw: z.number().nullish(), // from station table
+  allowScheduleCutShort: z.boolean().nullish(), // from station table
+  productiveStatusMode: z.nativeEnum(PRODUCTIVE_STATUS_MODE), // from station table
+  lineSpeedStoppedThreshold: z.number().nullish(), // from station table
+  shiftPatternId: z.number().nullish(), // from station table
+  productiveHoldOnTime: z.number(), // from station table
+  minimumCycleTime: z.number().nullish(), // from station table
+  statusCode: z.string().nullish(), // from station table
+  statusCodeUpdatedAt: z.string().nullish(), // from station table
+  electricalPowerNominalKw: z.number().nullish(), // from station table
+
+  shiftPattern: ShiftPatternViewModel.optional(),
+  shifts: z.array(ShiftSchema), // from join with shift table. station.shiftPatternId or if null, stationGroup.shiftPatternId
+
+  currentShift: ShiftSchema.optional(), // the shift calculated to be in now. Null if not in any shift.
+
+  currentProductionSchedule: ProductionScheduleViewModel.nullish(), //The production schedule we are in for this station. null if no active production schedule.
+  nextProductionSchedule: ProductionScheduleViewModel.nullish(), //The production schedule that is next. null if no active production schedule.
+
+  currentNonProductionSchedule: NonProductionScheduleViewModel.nullish(), // The maintenance schedule we are in for this station. null if no active maintenance schedule.
+
+  currentStopReasonCode: z.string().nullish(), // The reason code for the 'stop' type issue that is ongoing for this station. unknown if no reason given. null if no ongoing 'stop' type issue.
+  stoppedSince: z.number().nullish(), // The startAt of the ongoing 'stop' type issue. null if no ongoing issue.
+
+  // TODO: Change this to stateCode. It doesn't match our API style to return the entire state object.
+  state: StationState,
+  idleCostPerMinute: z.number().nullish(),
+  moduleVisibility: z.array(z.nativeEnum(STATION_MODULE_VISIBILITY)).nullish(),
+  cachedAt: z.number().nullish(),
+  allowQuickScheduleStart: z.boolean().nullish(),
+  speedScale: z.number().nullish(),
+  speedOffset: z.number().nullish(),
+  speedToProductionRatio: z.number().nullish(),
+
+  forceAllShiftTimeAsPlannedProduction: z.boolean(), // This will cause any in shift time to be treated as planned production time for the sake of downtime detection and OEE.
+
+  lastStationWindow: StationWindowViewModel.nullish(),
+});
+
+type StationViewModel = z.infer<typeof StationViewModel>;
+
+declare const AccountViewModel = AccountSchema.merge(
+  z.object({
+    cursors: z
+      .array(
+        z.object({
+          type: z.string(),
+          timestamp: z.number(),
+          value: z.string(),
+          valueAgo: z.string(),
+        }),
+      )
+      .optional(),
+    redshiftConfig: z
+      .object({
+        host: z.string(),
+        port: z.number(),
+        username: z.string(),
+      })
+      .optional(),
+  }),
+);
+
+type AccountViewModel = z.infer<typeof AccountViewModel>;
+
+export { AccountViewModel, PlantViewModel, ScheduleViewModel, SkuViewModel, StationSchema, StationViewModel };
+export type { ApiKeyViewModel, BusrootSignals, PlantSchema };

package/build/example.d.ts

@@ -0,0 +1 @@
+export {};

package/build/example.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const moment_1 = __importDefault(require("moment"));
+const client_1 = require("./client");
+async function main() {
+    const busrootOiClient = new client_1.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_1.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: (0, moment_1.default)().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/build/hooks.d.ts

@@ -0,0 +1,19 @@
+import { Client } from "./client";
+import z from "zod";
+export declare const ConfigPayloadSchema: z.ZodObject<{
+    accountId: z.ZodString;
+    apiKey: z.ZodString;
+    host: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    accountId: string;
+    host: string;
+    apiKey: string;
+}, {
+    accountId: string;
+    host: string;
+    apiKey: string;
+}>;
+export declare function useBusroot(): {
+    client: Client | undefined;
+    logout: () => void;
+};

package/build/hooks.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigPayloadSchema = void 0;
+exports.useBusroot = useBusroot;
+const react_1 = require("react");
+const client_1 = require("./client");
+const zod_1 = __importDefault(require("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.
+exports.ConfigPayloadSchema = zod_1.default.object({
+    accountId: zod_1.default.string().max(255),
+    apiKey: zod_1.default.string().max(255),
+    host: zod_1.default.string().max(255),
+});
+function useBusroot() {
+    const [client, setClient] = (0, react_1.useState)();
+    (0, react_1.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 = exports.ConfigPayloadSchema.parse(JSON.parse(atob(tokenParam)));
+                setClient(new client_1.Client({ accountId: config.accountId, apiKey: config.apiKey, host: config.host }));
+            }
+            catch (e) {
+                console.log(e.message);
+            }
+        }
+        return;
+    }, []);
+    const logout = () => {
+        console.log("not implemented");
+    };
+    return { client, logout };
+}

package/build/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./hooks"), exports);

package/package.json

@@ -1,30 +1,42 @@
 {
   "name": "busroot-sdk",
-  "version": "0.0.0",
+  "version": "0.0.2",
+  "description": "An SDK for accessing Busroot from output.industries",
+  "homepage": "https://www.output.industries",
   "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",
+    "build": "pnpm run lint && tsc --build --clean && tsc --build && pnpm run rollup",
     "lint": "eslint 'src/**/*.ts'",
-    "test": "jest"
+    "test": "jest",
+    "rollup": "rollup -c"
   },
+  "files": [
+    "build"
+  ],
   "devDependencies": {
     "@jest/globals": "^29.7.0",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.4",
     "@types/react": "^18.0.26",
     "eslint-config-custom": "workspace:*",
+    "rollup": "^4.49.0",
     "ts-jest": "^29.4.0",
     "tsconfig": "workspace:*",
-    "typescript-eslint": "^8.38.0"
+    "typescript-eslint": "^8.38.0",
+    "busroot-common": "workspace:*"
   },
   "dependencies": {
-    "busroot-common": "workspace:*",
     "jest": "^30.0.4",
     "moment": "^2.30.1",
     "mqtt": "^5.14.0",
     "react": "^18.3.1",
+    "rollup-plugin-dts": "^6.2.3",
     "ts-node": "^10.9.1",
     "typescript": "^5.8.3",
     "zod": "^3.25.1"

package/eslint.config.mjs

@@ -1,8 +0,0 @@
-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

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

package/src/client.test.ts

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

package/src/client.ts

@@ -1,226 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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/tsconfig.json

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

package/tsconfig.tsbuildinfo

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