@doany-ai/sdk 0.1.0

package/dist/utils/axios-client.js

@@ -0,0 +1,202 @@
+import axios from "axios";
+import { isInIFrame } from "./common.js";
+import { v4 as uuidv4 } from "uuid";
+import { getAnalyticsSessionId } from "../modules/analytics.js";
+/**
+ * Custom error class for Base44 SDK errors.
+ *
+ * This error is thrown when API requests fail. It extends the standard `Error` class and includes additional information about the HTTP status, error code, and response data from the server.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.entities.Todo.get('invalid-id');
+ * } catch (error) {
+ *   if (error instanceof Base44Error) {
+ *     console.error('Status:', error.status);      // 404
+ *     console.error('Message:', error.message);    // "Not found"
+ *     console.error('Code:', error.code);          // "NOT_FOUND"
+ *     console.error('Data:', error.data);          // Full response data
+ *   }
+ * }
+ * ```
+ *
+ */
+export class Base44Error extends Error {
+    /**
+     * Creates a new Base44Error instance.
+     *
+     * @param message - Human-readable error message
+     * @param status - HTTP status code
+     * @param code - Error code from the API
+     * @param data - Full response data from the server
+     * @param originalError - Original axios error object
+     * @internal
+     */
+    constructor(message, status, code, data, originalError) {
+        super(message);
+        this.name = "Base44Error";
+        this.status = status;
+        this.code = code;
+        this.data = data;
+        this.originalError = originalError;
+    }
+    /**
+     * Serializes the error to a JSON-safe object.
+     *
+     * Useful for logging or sending error information to external services
+     * without circular reference issues.
+     *
+     * @returns JSON-safe representation of the error.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await client.entities.Todo.get('invalid-id');
+     * } catch (error) {
+     *   if (error instanceof Base44Error) {
+     *     const json = error.toJSON();
+     *     console.log(json);
+     *     // {
+     *     //   name: "Base44Error",
+     *     //   message: "Not found",
+     *     //   status: 404,
+     *     //   code: "NOT_FOUND",
+     *     //   data: { ... }
+     *     // }
+     *   }
+     * }
+     * ```
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            status: this.status,
+            code: this.code,
+            data: this.data,
+        };
+    }
+}
+/**
+ * Safely logs error information without circular references.
+ *
+ * @param prefix - Prefix for the log message
+ * @param error - The error to log
+ * @internal
+ */
+function safeErrorLog(prefix, error) {
+    if (error instanceof Base44Error) {
+        console.error(`${prefix} ${error.status}: ${error.message}`);
+        if (error.data) {
+            try {
+                console.error("Error data:", JSON.stringify(error.data, null, 2));
+            }
+            catch (e) {
+                console.error("Error data: [Cannot stringify error data]");
+            }
+        }
+    }
+    else {
+        console.error(`${prefix} ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Creates an axios client with default configuration and interceptors.
+ *
+ * Sets up an axios instance with:
+ * - Default headers
+ * - Authentication token injection
+ * - Response data unwrapping
+ * - Error transformation to Base44Error
+ * - iframe messaging support
+ *
+ * @param options - Client configuration options
+ * @returns Configured axios instance
+ * @internal
+ */
+export function createAxiosClient({ baseURL, headers = {}, token, interceptResponses = true, onError, }) {
+    const client = axios.create({
+        baseURL,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...headers,
+        },
+    });
+    // Add token to requests if available
+    if (token) {
+        client.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+    }
+    // Add origin URL in browser environment
+    client.interceptors.request.use((config) => {
+        // `window.location` is absent on React Native (where `window` still exists),
+        // so guard on it before reading `.href`.
+        if (typeof window !== "undefined" && window.location) {
+            config.headers.set("X-Origin-URL", window.location.href);
+            // On unauthenticated requests, attach a stable anonymous visitor id so the
+            // backend can support anonymous agent access (conversation grouping + ownership).
+            // Authenticated requests are identified by their Authorization header instead.
+            if (!config.headers.get("Authorization")) {
+                config.headers.set("X-Base44-Anonymous-Id", getAnalyticsSessionId());
+            }
+        }
+        const requestId = uuidv4();
+        config.requestId = requestId;
+        if (isInIFrame) {
+            try {
+                window.parent.postMessage({
+                    type: "api-request-start",
+                    requestId,
+                    data: {
+                        url: baseURL + config.url,
+                        method: config.method,
+                        body: config.data instanceof FormData
+                            ? "[FormData object]"
+                            : config.data,
+                    },
+                }, "*");
+            }
+            catch (_a) {
+                /* skip the logging */
+            }
+        }
+        return config;
+    });
+    // Handle responses
+    if (interceptResponses) {
+        client.interceptors.response.use((response) => {
+            var _a;
+            const requestId = (_a = response.config) === null || _a === void 0 ? void 0 : _a.requestId;
+            try {
+                if (isInIFrame && requestId) {
+                    window.parent.postMessage({
+                        type: "api-request-end",
+                        requestId,
+                        data: {
+                            statusCode: response.status,
+                            response: response.data,
+                        },
+                    }, "*");
+                }
+            }
+            catch (_b) {
+                /* do nothing */
+            }
+            return response.data;
+        }, (error) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const message = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) ||
+                ((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.detail) ||
+                error.message;
+            const base44Error = new Base44Error(message, (_e = error.response) === null || _e === void 0 ? void 0 : _e.status, (_g = (_f = error.response) === null || _f === void 0 ? void 0 : _f.data) === null || _g === void 0 ? void 0 : _g.code, (_h = error.response) === null || _h === void 0 ? void 0 : _h.data, error);
+            // Log errors in development
+            if (process.env.NODE_ENV !== "production") {
+                safeErrorLog("[Base44 SDK Error]", base44Error);
+            }
+            onError === null || onError === void 0 ? void 0 : onError(base44Error);
+            return Promise.reject(base44Error);
+        });
+    }
+    return client;
+}

package/dist/utils/axios-client.types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * JSON representation of a Base44Error.
+ *
+ * This is the structure returned by {@linkcode Base44Error.toJSON | Base44Error.toJSON()}.
+ * Useful for logging or sending error information to external services.
+ */
+export interface Base44ErrorJSON {
+    /**
+     * The error name, always "Base44Error".
+     */
+    name: string;
+    /**
+     * Human-readable error message.
+     */
+    message: string;
+    /**
+     * HTTP status code of the error.
+     */
+    status: number;
+    /**
+     * Error code from the API.
+     */
+    code: string;
+    /**
+     * Full response data from the server containing error details.
+     */
+    data: any;
+}

package/dist/utils/axios-client.types.js

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

package/dist/utils/common.d.ts

@@ -0,0 +1,4 @@
+export declare const isNode: boolean;
+export declare const isInIFrame: boolean;
+export declare const isReactNative: boolean;
+export declare const generateUuid: () => string;

package/dist/utils/common.js

@@ -0,0 +1,11 @@
+export const isNode = typeof window === "undefined";
+export const isInIFrame = !isNode && window.self !== window.top;
+// React Native defines `window` (so `isNode` is false there) but not `document`.
+// Browser-only code paths gated on `window`/`isNode` alone would run — and crash —
+// on React Native. Node (no `window`) is already handled by those `window` guards;
+// this flags the window-without-a-DOM case that isn't.
+export const isReactNative = !isNode && typeof document === "undefined";
+export const generateUuid = () => {
+    return (Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15));
+};

package/dist/utils/sharedInstance.d.ts

@@ -0,0 +1 @@
+export declare function getSharedInstance<T>(name: string, factory: () => T): T;

package/dist/utils/sharedInstance.js

@@ -0,0 +1,15 @@
+const windowObj = typeof window !== "undefined"
+    ? window
+    : { base44SharedInstances: {} };
+// Singleton (shared between sdk instances)//
+export function getSharedInstance(name, factory) {
+    if (!windowObj.base44SharedInstances) {
+        windowObj.base44SharedInstances = {};
+    }
+    if (!windowObj.base44SharedInstances[name]) {
+        windowObj.base44SharedInstances[name] = {
+            instance: factory(),
+        };
+    }
+    return windowObj.base44SharedInstances[name].instance;
+}

package/dist/utils/socket-utils.d.ts

@@ -0,0 +1,47 @@
+import { Socket } from "socket.io-client";
+export interface RoomsSocketConfig {
+    serverUrl: string;
+    mountPath: string;
+    transports: string[];
+    appId: string;
+    token?: string;
+}
+export type TSocketRoom = string;
+export type TJsonStr = string;
+type RoomsSocketEventsMap = {
+    listen: {
+        connect: () => Promise<void> | void;
+        update_model: (msg: {
+            room: string;
+            data: TJsonStr;
+        }) => Promise<void> | void;
+        error: (error: Error) => Promise<void> | void;
+    };
+    emit: {
+        join: (room: string) => void;
+        leave: (room: string) => void;
+    };
+};
+type TEvent = keyof RoomsSocketEventsMap["listen"];
+type THandler<E extends TEvent> = RoomsSocketEventsMap["listen"][E];
+export type RoomsSocket = ReturnType<typeof RoomsSocket>;
+export declare function RoomsSocket({ config }: {
+    config: RoomsSocketConfig;
+}): {
+    socket: Socket<{
+        connect: () => Promise<void> | void;
+        update_model: (msg: {
+            room: string;
+            data: TJsonStr;
+        }) => Promise<void> | void;
+        error: (error: Error) => Promise<void> | void;
+    }, {
+        join: (room: string) => void;
+        leave: (room: string) => void;
+    }>;
+    subscribeToRoom: (room: TSocketRoom, handlers: Partial<{ [k in TEvent]: THandler<k>; }>) => () => void;
+    updateConfig: (config: Partial<RoomsSocketConfig>) => void;
+    updateModel: (room: string, data: any) => Promise<void>;
+    disconnect: () => void;
+};
+export {};

package/dist/utils/socket-utils.js

@@ -0,0 +1,170 @@
+import { io } from "socket.io-client";
+import { getAccessToken } from "./auth-utils.js";
+import { getAnalyticsSessionId } from "../modules/analytics.js";
+const ROOM_LEAVE_GRACE_MS = 250;
+function initializeSocket(config, handlers) {
+    var _a;
+    // On unauthenticated clients, send a stable anonymous visitor id on the
+    // handshake so the backend can verify room access for anonymous agent
+    // conversations (mirrors the X-Base44-Anonymous-Id HTTP header). Authenticated
+    // clients are identified by their token instead.
+    const resolvedToken = (_a = config.token) !== null && _a !== void 0 ? _a : getAccessToken();
+    const query = {
+        app_id: config.appId,
+        token: resolvedToken,
+    };
+    if (!resolvedToken) {
+        query.anonymous_id = getAnalyticsSessionId();
+    }
+    const socket = io(config.serverUrl, {
+        path: config.mountPath,
+        transports: config.transports,
+        query,
+    });
+    socket.on("connect", async () => {
+        var _a;
+        console.log("connect", socket.id);
+        return (_a = handlers.connect) === null || _a === void 0 ? void 0 : _a.call(handlers);
+    });
+    socket.on("update_model", async (msg) => {
+        var _a;
+        return (_a = handlers.update_model) === null || _a === void 0 ? void 0 : _a.call(handlers, msg);
+    });
+    socket.on("error", async (error) => {
+        var _a;
+        return (_a = handlers.error) === null || _a === void 0 ? void 0 : _a.call(handlers, error);
+    });
+    socket.on("connect_error", async (error) => {
+        var _a;
+        console.error("connect_error", error);
+        return (_a = handlers.error) === null || _a === void 0 ? void 0 : _a.call(handlers, error);
+    });
+    return socket;
+}
+export function RoomsSocket({ config }) {
+    let currentConfig = { ...config };
+    const roomsToListeners = {};
+    const pendingRoomLeaves = {};
+    const handlers = {
+        connect: async () => {
+            const promises = [];
+            Object.keys(roomsToListeners).forEach((room) => {
+                const listeners = getListeners(room);
+                if (listeners.length === 0) {
+                    return;
+                }
+                joinRoom(room);
+                listeners.forEach(({ connect }) => {
+                    const promise = async () => connect === null || connect === void 0 ? void 0 : connect();
+                    promises.push(promise());
+                });
+            });
+            await Promise.all(promises);
+        },
+        update_model: async (msg) => {
+            const listeners = getListeners(msg.room);
+            const promises = listeners.map((listener) => { var _a; return (_a = listener.update_model) === null || _a === void 0 ? void 0 : _a.call(listener, msg); });
+            await Promise.all(promises);
+        },
+        error: async (error) => {
+            console.error("error", error);
+            const promises = Object.values(roomsToListeners)
+                .flat()
+                .map((listener) => { var _a; return (_a = listener.error) === null || _a === void 0 ? void 0 : _a.call(listener, error); });
+            await Promise.all(promises);
+        },
+    };
+    let socket = initializeSocket(config, handlers);
+    function cleanup() {
+        disconnect();
+    }
+    function disconnect() {
+        clearPendingRoomLeaves();
+        if (socket) {
+            socket.disconnect();
+        }
+    }
+    function updateConfig(config) {
+        cleanup();
+        currentConfig = {
+            ...currentConfig,
+            ...config,
+        };
+        socket = initializeSocket(currentConfig, handlers);
+    }
+    function joinRoom(room) {
+        socket.emit("join", room);
+    }
+    function leaveRoom(room) {
+        socket.emit("leave", room);
+    }
+    async function updateModel(room, data) {
+        var _a;
+        const dataStr = JSON.stringify(data);
+        return (_a = handlers.update_model) === null || _a === void 0 ? void 0 : _a.call(handlers, { room, data: dataStr });
+    }
+    function getListeners(room) {
+        var _a;
+        return (_a = roomsToListeners[room]) !== null && _a !== void 0 ? _a : [];
+    }
+    function cancelPendingRoomLeave(room) {
+        const pendingLeave = pendingRoomLeaves[room];
+        if (!pendingLeave) {
+            return;
+        }
+        clearTimeout(pendingLeave);
+        delete pendingRoomLeaves[room];
+    }
+    function clearPendingRoomLeaves() {
+        Object.keys(pendingRoomLeaves).forEach((room) => {
+            var _a, _b;
+            clearTimeout(pendingRoomLeaves[room]);
+            delete pendingRoomLeaves[room];
+            if (((_b = (_a = roomsToListeners[room]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) === 0) {
+                delete roomsToListeners[room];
+            }
+        });
+    }
+    function scheduleRoomLeave(room) {
+        cancelPendingRoomLeave(room);
+        pendingRoomLeaves[room] = setTimeout(() => {
+            var _a, _b;
+            delete pendingRoomLeaves[room];
+            if (((_b = (_a = roomsToListeners[room]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
+                return;
+            }
+            leaveRoom(room);
+            delete roomsToListeners[room];
+        }, ROOM_LEAVE_GRACE_MS);
+    }
+    const subscribeToRoom = (room, handlers) => {
+        if (roomsToListeners[room]) {
+            cancelPendingRoomLeave(room);
+        }
+        else {
+            joinRoom(room);
+            roomsToListeners[room] = [];
+        }
+        roomsToListeners[room].push(handlers);
+        let unsubscribed = false;
+        return () => {
+            var _a, _b;
+            if (unsubscribed) {
+                return;
+            }
+            unsubscribed = true;
+            roomsToListeners[room] =
+                (_b = (_a = roomsToListeners[room]) === null || _a === void 0 ? void 0 : _a.filter((listener) => listener !== handlers)) !== null && _b !== void 0 ? _b : [];
+            if (roomsToListeners[room].length === 0) {
+                scheduleRoomLeave(room);
+            }
+        };
+    };
+    return {
+        socket,
+        subscribeToRoom,
+        updateConfig,
+        updateModel,
+        disconnect,
+    };
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@doany-ai/sdk",
+  "version": "0.1.0",
+  "description": "JavaScript SDK for the doany app platform (API-compatible fork of @base44/sdk)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint src",
+    "test": "npm run test:types && vitest run",
+    "test:types": "tsc --noEmit -p tsconfig.type-tests.json",
+    "test:unit": "vitest run tests/unit",
+    "test:e2e": "vitest run tests/e2e",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "axios": "^1.18.1",
+    "socket.io-client": "^4.8.3",
+    "uuid": "^13.0.2"
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.4",
+    "@types/node": "^25.0.1",
+    "@types/unist": "^3.0.3",
+    "@typescript-eslint/parser": "^8.51.0",
+    "@vitest/coverage-istanbul": "^4.1.9",
+    "@vitest/coverage-v8": "^4.1.9",
+    "@vitest/ui": "^4.1.9",
+    "dotenv": "^16.3.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-import": "^2.32.0",
+    "nock": "^13.4.0",
+    "typescript": "^5.3.2",
+    "typescript-eslint": "^8.51.0",
+    "vitest": "^4.1.9"
+  },
+  "keywords": [
+    "base44",
+    "api",
+    "sdk"
+  ],
+  "author": "doany",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/InceptionsAI/doany-ai-app.git"
+  }
+}