@albatrossai/albatross-sdk 0.1.0 → 0.1.2

package/dist/client.d.ts

@@ -1,70 +1,38 @@
-export interface Event {
-  units: Record<string, string>;
-  value?: string;
-  eventType: string;
-  payload?: Record<string, any>;
-  timestamp?: string;
-}
-export interface DataPoint {
-  context_features: [];
-  actions: string[];
-  action_features: any;
-  rewards: {};
-  ordering: {
-    [k: string]: number;
-  };
-  scores: {
-    [k: string]: number;
-  };
-  is_randomized: boolean;
-  propensities: {
-    [k: string]: number;
-  };
-}
+import * as Request from "./request";
+import { DataPoint, PredictionPayload } from "./type";
 declare class Client {
-  token: string;
-  instanceUuid: string;
-  baseUrl: string;
-  headers: Record<string, string>;
-  constructor(token: string, instanceUuid: string, baseUrl?: string);
-  getVersion(): Promise<any>;
-  private handleNotOk;
-  catalogAdd: ({
-    entity,
-    data,
-    mainUnit,
-  }: {
-    entity: string;
-    data: {
-      [k: string]: any;
-    }[];
-    mainUnit?: string;
-  }) => Promise<any>;
-  putEvent(payload: Event): Promise<any>;
-  prediction: (payload: {
-    useCase: {
-      uuid: string;
-    };
-    context: {
-      [k: string]: string;
-    };
-    actions: {
-      [k: string]: string;
-    }[];
-  }) => Promise<{
-    ordering: {
-      [key: string]: number;
-    };
-    datapoint: DataPoint;
-    id: string;
-  }>;
-  feedback: (payload: {
-    useCaseUuid?: string;
-    modelUuid?: string;
-    predictionUuid: string;
-    value: {
-      [k: string]: any;
-    };
-  }) => Promise<any>;
+    token: string;
+    instanceUuid: string;
+    baseUrl: string;
+    headers: Record<string, string>;
+    makeRequest: <A, B extends Record<string, any>>(inputs: Request.MakeRequestInputs<B>) => Promise<A>;
+    predictionPreProcessing: (data: PredictionPayload) => PredictionPayload;
+    constructor(token: string, instanceUuid: string, baseUrl?: string, options?: Partial<{
+        makeRequest: <A, B extends Record<string, any>>(inputs: Request.MakeRequestInputs<B>) => Promise<A>;
+        predictionPreProcessing: (data: PredictionPayload) => PredictionPayload;
+    }>);
+    getVersion(): Promise<unknown>;
+    catalogAdd: ({ entity, data, mainUnit, }: {
+        entity: string;
+        data: {
+            [k: string]: any;
+        }[];
+        mainUnit?: string;
+    }) => Promise<unknown>;
+    putEvent(payload: Event): Promise<any>;
+    prediction: (payload: PredictionPayload) => Promise<{
+        ordering: {
+            [key: string]: number;
+        };
+        datapoint: DataPoint;
+        id: string;
+    }>;
+    feedback: (payload: {
+        modelUuid?: string;
+        predictionUuid: string;
+        value: {
+            [k: string]: any;
+        };
+    }) => Promise<unknown>;
 }
 export default Client;

package/dist/client.js

@@ -1,66 +1,95 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const Request = __importStar(require("./request"));
 const utils_1 = require("./utils");
 const hostDefault = "https://app.usealbatross.ai/api";
 class Client {
-    constructor(token, instanceUuid, baseUrl = hostDefault) {
+    constructor(token, instanceUuid, baseUrl = hostDefault, options = {}) {
         this.token = token;
         this.instanceUuid = instanceUuid;
         this.baseUrl = baseUrl;
         this.catalogAdd = async ({ entity, data, mainUnit, }) => {
             const formattedData = data.map(utils_1.flattenNested);
-            const response = await fetch(this.baseUrl + "/catalog", {
+            return this.makeRequest({
+                url: this.baseUrl + "/catalog",
                 method: "PUT",
-                body: JSON.stringify({ data: formattedData, entity, mainUnit }),
+                data: { data: formattedData, entity, mainUnit },
                 headers: this.headers,
             });
-            await this.handleNotOk(response);
-            return response.json();
         };
         this.prediction = async (payload) => {
             const url = `${this.baseUrl}/use-case/prediction`;
-            const response = await fetch(url, {
+            const data = this.predictionPreProcessing(payload);
+            return this.makeRequest({
                 method: "POST",
+                url,
+                data,
                 headers: this.headers,
-                body: JSON.stringify(payload),
             });
-            await this.handleNotOk(response);
-            return response.json();
         };
         this.feedback = async (payload) => {
             const url = `${this.baseUrl}/feedback`;
-            const response = await fetch(url, {
+            return this.makeRequest({
                 method: "POST",
+                url: url,
+                data: payload,
                 headers: this.headers,
-                body: JSON.stringify(payload),
             });
-            await this.handleNotOk(response);
-            return response.json();
         };
         this.headers = {
             "content-type": "application/json",
             Authorization: "Bearer " + this.token,
             "x-instance-id": this.instanceUuid,
         };
+        this.makeRequest = options.makeRequest || Request.makeRequest;
+        this.predictionPreProcessing =
+            options.predictionPreProcessing || ((data) => data);
     }
     async getVersion() {
-        const response = await fetch(this.baseUrl + "/version");
-        return response.json();
-    }
-    async handleNotOk(response) {
-        if (!response.ok) {
-            throw new Error(`Request failed: ${response.status} ${response.statusText} ${await response.text()}`);
-        }
+        const url = this.baseUrl + "/version";
+        return this.makeRequest({ url, headers: this.headers });
     }
     async putEvent(payload) {
         const url = `${this.baseUrl}/event`;
-        const response = await fetch(url, {
+        return this.makeRequest({
             method: "PUT",
+            url: url,
+            data: payload,
             headers: this.headers,
-            body: JSON.stringify(payload),
         });
-        await this.handleNotOk(response);
-        return response.json();
     }
 }
 exports.default = Client;

package/dist/request.d.ts

@@ -0,0 +1,7 @@
+export declare const makeRequest: <A, B extends Record<string, any>>({ url, method, data, headers, }: MakeRequestInputs<B>) => Promise<A>;
+export interface MakeRequestInputs<B extends Record<string, any>> {
+    url: string;
+    method?: string;
+    data?: B;
+    headers: Record<string, string>;
+}

package/dist/request.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRequest = void 0;
+const makeRequest = async ({ url, method = "GET", data, headers, }) => {
+    const body = data ? JSON.stringify(data) : undefined;
+    const response = await fetch(url, {
+        method,
+        body,
+        headers,
+    });
+    if (!response.ok) {
+        throw new Error(`Request failed: ${response.status} ${response.statusText} ${await response.text()}`);
+    }
+    return response.json();
+};
+exports.makeRequest = makeRequest;

package/dist/type.d.ts

@@ -0,0 +1,33 @@
+export interface Event {
+    eventType: string;
+    payload?: Record<string, any>;
+    timestamp?: string;
+    units?: Record<string, string>;
+    value?: string;
+}
+export type PredictionUnit = {
+    [k: string]: string;
+};
+export interface DataPoint {
+    actions: string[];
+    context_features: any;
+    action_features: any;
+    rewards: any;
+    ordering: {
+        [k: string]: number;
+    };
+    scores: {
+        [k: string]: number;
+    };
+    is_randomized: boolean;
+    propensities: {
+        [k: string]: number;
+    };
+}
+export interface PredictionPayload {
+    useCase: {
+        uuid: string;
+    };
+    context: PredictionUnit;
+    actions: PredictionUnit[];
+}

package/dist/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@albatrossai/albatross-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "main": "dist/client.js",
   "types": "dist/client.d.ts",
   "files": [
@@ -14,9 +14,8 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "typescript": "^5.7.2"
-  },
-  "dependencies": {
+    "typescript": "^5.7.2",
     "@types/bun": "^1.2.2"
-  }
+  },
+  "dependencies": {}
 }