@bob-kit/client 0.0.18 → 0.0.19

package/dist/error.d.ts

@@ -0,0 +1,5 @@
+import { BobErrors } from "@bob-kit/types/errors";
+export declare class BobError extends Error {
+    readonly name: (typeof BobErrors)[keyof typeof BobErrors];
+    constructor(name: (typeof BobErrors)[keyof typeof BobErrors], message: string);
+}

package/dist/error.js

@@ -0,0 +1,10 @@
+export class BobError extends Error {
+    name;
+    constructor(name, message) {
+        super(message);
+        this.name = name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, BobError);
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { BobQueryResult, BobResult, Driver } from "@bob-kit/types";
+import type { BobQueryResult, Driver } from "@bob-kit/types";
 type BobQueryParams = {
     id?: string;
     driver: Driver;
-    input: TemplateStringsArray | string;
+    input: string;
 };
 export declare const bobQuery: ({ id, driver: { cache }, input, }: BobQueryParams) => Promise<BobQueryResult>;
 export default function bob(driver: Driver): {
-    query: <A, B = any>(input: TemplateStringsArray | string, ...parameters: B[]) => Promise<BobResult<A>>;
-    cache: (id: string) => <A, B = any>(input: TemplateStringsArray | string, ...parameters: B[]) => Promise<BobResult<A>>;
+    query: <A, B = any>(input: TemplateStringsArray | string, ...parameters: B[]) => Promise<A[]>;
+    cache: (id: string) => <A, B = any>(input: TemplateStringsArray | string, ...parameters: B[]) => Promise<A[]>;
     factory: any;
 };
 export {};

package/dist/index.js

@@ -1,14 +1,15 @@
+import { BobError } from "./error";
 import { WASM } from "./wasm.js";
+import { BobErrors } from "@bob-kit/types/errors";
 let bobInstance;
 export const bobQuery = async ({ id, driver: { cache }, input, }) => {
-    const query = typeof input === "string" ? input : input.join("?");
-    const cacheKey = id ?? query;
+    const cacheKey = id ?? input;
     if (cache) {
         const cached = cache.get(cacheKey);
         if (cached)
             return cache.get(cacheKey);
     }
-    const result = bobInstance.query(query);
+    const result = bobInstance.query(input);
     if (cache) {
         cache.set(cacheKey, result);
     }
@@ -16,31 +17,33 @@ export const bobQuery = async ({ id, driver: { cache }, input, }) => {
 };
 export default function bob(driver) {
     bobInstance = new WASM(driver.driver);
-    const execute = async (input, parameters = [], id) => {
-        const { error, value } = await bobQuery({ input, driver, id });
+    const execute = async ({ input, parameters = [], id, }) => {
+        const query = typeof input === "string" ? input : input.join("?");
+        const { error, value } = await bobQuery({ input: query, driver, id });
         if (error)
-            return { error };
+            throw new BobError(error.name, error.message);
         if (value?.tables) {
             for (const table of value.tables) {
                 await driver.querier(table.trim());
             }
         }
         if (value?.actions) {
-            const result = await Promise.all(value.actions.map((action) => driver.querier(action, ...parameters)));
-            if (result.length === 1) {
-                return { value: (result[0].length ? result[0] : undefined) };
+            if (value.actions.length > 1) {
+                throw new BobError(BobErrors.MultipleActions, "Multiple actions are not allowed");
+            }
+            if (value.actions.length === 1) {
+                return (await driver.querier(value.actions[0], ...parameters));
             }
-            return { value: result };
         }
-        return { value: undefined };
+        return [];
     };
     return {
-        query: (input, ...parameters) => execute(input, parameters),
-        cache: (id) => (input, ...parameters) => execute(input, parameters, id),
+        query: (input, ...parameters) => execute({ input, parameters }),
+        cache: (id) => (input, ...parameters) => execute({ input, parameters, id }),
         factory: new Proxy({}, {
             get(_, id) {
                 return (input, ...parameters) => {
-                    return execute(input, parameters, id);
+                    return execute({ input, parameters, id });
                 };
             },
         }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bob-kit/client",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "",
@@ -28,7 +28,7 @@
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "@bob-kit/types": "^0.0.5"
+    "@bob-kit/types": "^0.0.6"
   },
   "scripts": {
     "build": "tsc && tsc-alias",

package/dist/install.d.ts

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

package/dist/install.js

@@ -1,36 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { pipeline } from "stream";
-import { promisify } from "util";
-const streamPipeline = promisify(pipeline);
-async function downloadFile(url, folder, filename) {
-    const res = await fetch(url);
-    if (!res.ok)
-        throw new Error(`Failed to fetch ${url}: ${res.statusText}`);
-    fs.mkdirSync(folder, { recursive: true });
-    const filePath = path.join(folder, filename);
-    const nodeStream = res.body;
-    await streamPipeline(nodeStream, fs.createWriteStream(filePath));
-    console.log(`Downloaded ${filename} to ${filePath}`);
-}
-async function getLatestRelease() {
-    const apiUrl = "https://api.github.com/repos/bob-object-builder/bob/releases/latest";
-    const res = await fetch(apiUrl);
-    if (!res.ok)
-        throw new Error(`Failed to fetch latest release: ${res.statusText}`);
-    return res.json();
-}
-(async () => {
-    try {
-        const fileName = "bob.wasm";
-        const downloadFolder = "dist";
-        const release = await getLatestRelease();
-        const asset = release.assets.find((a) => a.name === fileName);
-        if (!asset)
-            throw new Error(`${fileName} not found in latest release`);
-        await downloadFile(asset.browser_download_url, downloadFolder, fileName);
-    }
-    catch (err) {
-        console.error("Error:", err);
-    }
-})();