@bandeira-tech/b3nd-web 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 B3nd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+b3nd/sdk provides client/server application protocol with multiple backend support and batteries included
+
+b3nd/sdk is intended to support the design of allowing applications to manage their data schemas on their clientside frontends and use a secure and scalable backend solution that is flexible both ways both for the client app and the backend provider
+
+b3nd/sdk is used in applications that are nodes to a network that may be local and made of 1 and can run even on your browser using local storage or indexeddb or in memory even, same for a script, or can connect to an http api that runs a simple deno kv or sqlite backend, or connects with multiple other nodes via websocket and http to broadcast and distribute persistence
+
+## Target Module Components Topology
+
+b3nd/sdk
+- backends/{memory,http,websocket,localStorage,denokv,postgres,...}
+- client
+- types
+
+b3nd/sdk/backends export unified interfaces for different backends, they require initialization with shared standards like backend schema that maps program urls (protocol://toplevel) to validation functions, and also take custom configuration related to the actual backend, i.e. connection string for postgres, url for websocket and http and so on
+
+b3nd/sdk/client exports unified interface to route message for multiple backends, it's initialized with a client schema that maps programs urls (protocol://toplevel) to target backend instance programs
+
+So while backend schema defines what programs are supported and available in a backend instance, the client schema defines what programs are routed to what backends
+
+This way browser apps can communicate with multiple http and websocket backends, as well as have a local instance; also http apis and websocket servers can be setup in meshes to work together for HA or other distributed designs
+
+## Development
+
+b3nd/sdk must
+
+- ALWAYS have a test for each component to automate validation and simplify troubleshooting
+- NEVER catch/hide/garble errors
+- ALWAYS leave it to the user to decide how to best handle errors for their applications

package/dist/apps/mod.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @b3nd/sdk/apps
+ * Lightweight client for the App Backend installation.
+ */
+interface AppsClientConfig {
+    appServerUrl: string;
+    apiBasePath: string;
+    fetch?: typeof fetch;
+    authToken?: string;
+}
+interface AppActionDef {
+    action: string;
+    validation?: {
+        stringValue?: {
+            format?: "email";
+        };
+    };
+    write: {
+        encrypted?: string;
+        plain?: string;
+    };
+}
+interface AppRegistration {
+    appKey: string;
+    accountPrivateKeyPem: string;
+    encryptionPublicKeyHex?: string;
+    encryptionPrivateKeyPem?: string;
+    allowedOrigins: string[];
+    actions: AppActionDef[];
+}
+declare class AppsClient {
+    private base;
+    private api;
+    private f;
+    private authToken?;
+    constructor(cfg: AppsClientConfig);
+    setAuthToken(token?: string): void;
+    health(): Promise<unknown>;
+    registerApp(reg: AppRegistration): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    updateSchema(appKey: string, actions: AppActionDef[]): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getSchema(appKey: string): Promise<{
+        success: true;
+        config: {
+            appKey: string;
+            allowedOrigins: string[];
+            actions: AppActionDef[];
+        };
+    }>;
+    createSession(appKey: string, token: string): Promise<{
+        success: true;
+        session: string;
+        uri: string;
+    }>;
+    invokeAction(appKey: string, action: string, payload: string, origin?: string): Promise<{
+        success: true;
+        uri: string;
+        record: {
+            ts: number;
+            data: unknown;
+        };
+    }>;
+    read(appKey: string, uri: string): Promise<{
+        success: true;
+        uri: string;
+        record: {
+            ts: number;
+            data: unknown;
+        };
+        raw?: unknown;
+    }>;
+}
+
+export { type AppActionDef, type AppRegistration, AppsClient, type AppsClientConfig };

package/dist/apps/mod.js

@@ -0,0 +1,7 @@
+import {
+  AppsClient
+} from "../chunk-QHDBFVLU.js";
+import "../chunk-MLKGABMK.js";
+export {
+  AppsClient
+};

package/dist/chunk-2D2RT2DW.js

@@ -0,0 +1,277 @@
+// wallet/client.ts
+var WalletClient = class {
+  walletServerUrl;
+  apiBasePath;
+  fetchImpl;
+  currentSession = null;
+  constructor(config) {
+    this.walletServerUrl = config.walletServerUrl.replace(/\/$/, "");
+    if (!config.apiBasePath || typeof config.apiBasePath !== "string") {
+      throw new Error("apiBasePath is required (e.g., '/api/v1')");
+    }
+    const normalized = (config.apiBasePath.startsWith("/") ? config.apiBasePath : `/${config.apiBasePath}`).replace(/\/$/, "");
+    this.apiBasePath = normalized;
+    if (config.fetch) {
+      this.fetchImpl = config.fetch;
+    } else if (typeof window !== "undefined" && typeof window.fetch === "function") {
+      this.fetchImpl = window.fetch.bind(window);
+    } else {
+      this.fetchImpl = fetch;
+    }
+  }
+  /**
+   * Get the current authenticated session
+   */
+  getSession() {
+    return this.currentSession;
+  }
+  /**
+   * Set the current session (useful for restoring from storage)
+   */
+  setSession(session) {
+    this.currentSession = session;
+  }
+  /**
+   * Check if user is currently authenticated
+   */
+  isAuthenticated() {
+    return this.currentSession !== null;
+  }
+  /**
+   * Get current username (if authenticated)
+   */
+  getUsername() {
+    var _a;
+    return ((_a = this.currentSession) == null ? void 0 : _a.username) || null;
+  }
+  /**
+   * Get current JWT token (if authenticated)
+   */
+  getToken() {
+    var _a;
+    return ((_a = this.currentSession) == null ? void 0 : _a.token) || null;
+  }
+  /**
+   * Clear current session (logout)
+   */
+  logout() {
+    this.currentSession = null;
+  }
+  /**
+   * Check wallet server health
+   */
+  async health() {
+    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/health`);
+    if (!response.ok) {
+      throw new Error(`Health check failed: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  /**
+   * Sign up a new user
+   * Returns session data - call setSession() to activate it
+   */
+  // Tokenless signup is not supported. Use signup(token,...)
+  async signup(_credentials) {
+    throw new Error("Use signup(token, credentials) \u2014 app token required");
+  }
+  /**
+   * Login existing user
+   * Returns session data - call setSession() to activate it
+   */
+  // Tokenless login is not supported. Use login(token, session, credentials)
+  async login(_credentials) {
+    throw new Error("Use login(token, session, credentials) \u2014 app token + session required");
+  }
+  /**
+   * Change password for current user
+   * Requires active authentication session
+   */
+  async changePassword(oldPassword, newPassword) {
+    if (!this.currentSession) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    const response = await this.fetchImpl(
+      `${this.walletServerUrl}${this.apiBasePath}/auth/change-password`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.currentSession.token}`
+        },
+        body: JSON.stringify({
+          oldPassword,
+          newPassword
+        })
+      }
+    );
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Change password failed: ${response.statusText}`);
+    }
+  }
+  /**
+   * Request a password reset token
+   * Does not require authentication
+   */
+  async requestPasswordReset(_username) {
+    throw new Error("Use requestPasswordResetWithToken(token, username)");
+  }
+  /**
+   * Reset password using a reset token
+   * Returns session data - call setSession() to activate it
+   */
+  async resetPassword(_username, _resetToken, _newPassword) {
+    throw new Error("Use resetPasswordWithToken(token, username, resetToken, newPassword)");
+  }
+  /**
+   * Sign up with app token (scoped to an app)
+   */
+  async signupWithToken(token, credentials) {
+    if (!token) throw new Error("token is required");
+    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/signup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token, username: credentials.username, password: credentials.password })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Signup failed: ${response.statusText}`);
+    }
+    return { username: data.username, token: data.token, expiresIn: data.expiresIn };
+  }
+  /**
+   * Login with app token and session (scoped to an app)
+   */
+  async loginWithTokenSession(token, session, credentials) {
+    if (!token) throw new Error("token is required");
+    if (!session) throw new Error("session is required");
+    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/login`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token, session, username: credentials.username, password: credentials.password })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Login failed: ${response.statusText}`);
+    }
+    return { username: data.username, token: data.token, expiresIn: data.expiresIn };
+  }
+  /**
+   * Request password reset scoped to app token
+   */
+  async requestPasswordResetWithToken(token, username) {
+    if (!token) throw new Error("token is required");
+    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/request-password-reset`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token, username })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Request password reset failed: ${response.statusText}`);
+    }
+    return { resetToken: data.resetToken, expiresIn: data.expiresIn };
+  }
+  /**
+   * Reset password scoped to app token
+   */
+  async resetPasswordWithToken(token, username, resetToken, newPassword) {
+    if (!token) throw new Error("token is required");
+    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/auth/reset-password`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token, username, resetToken, newPassword })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Reset password failed: ${response.statusText}`);
+    }
+    return { username: data.username, token: data.token, expiresIn: data.expiresIn };
+  }
+  /**
+   * Get public keys for the current authenticated user.
+   * Requires an active authentication session.
+   */
+  async getPublicKeys() {
+    if (!this.currentSession) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    const response = await this.fetchImpl(
+      `${this.walletServerUrl}${this.apiBasePath}/public-keys`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.currentSession.token}`
+        }
+      }
+    );
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(data.error || `Get public keys failed: ${response.statusText}`);
+    }
+    return {
+      accountPublicKeyHex: data.accountPublicKeyHex,
+      encryptionPublicKeyHex: data.encryptionPublicKeyHex
+    };
+  }
+  /**
+   * Proxy a write request through the wallet server
+   * The server signs the write with its identity key
+   * Requires active authentication session
+   */
+  async proxyWrite(request) {
+    if (!this.currentSession) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/proxy/write`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.currentSession.token}`
+      },
+      body: JSON.stringify({
+        uri: request.uri,
+        data: request.data,
+        encrypt: request.encrypt
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success) {
+      throw new Error(
+        data.error || `Proxy write failed: ${response.statusText}`
+      );
+    }
+    return data;
+  }
+  /**
+   * Convenience method: Get current user's public keys
+   * Requires active authentication session
+   */
+  async getMyPublicKeys() {
+    return this.getPublicKeys();
+  }
+  /**
+   * Get server's public keys
+   *
+   * @returns Server's identity and encryption public keys
+   * @throws Error if request fails
+   */
+  async getServerKeys() {
+    const response = await this.fetchImpl(`${this.walletServerUrl}${this.apiBasePath}/server-keys`);
+    if (!response.ok) {
+      throw new Error(`Failed to get server keys: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.success) {
+      throw new Error(data.error || "Failed to get server keys");
+    }
+    return {
+      identityPublicKeyHex: data.identityPublicKeyHex,
+      encryptionPublicKeyHex: data.encryptionPublicKeyHex
+    };
+  }
+};
+
+export {
+  WalletClient
+};

package/dist/chunk-C2ZIFM22.js

@@ -0,0 +1,272 @@
+// clients/websocket/mod.ts
+var WebSocketClient = class {
+  config;
+  ws = null;
+  connected = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  messageHandler = this.handleMessage.bind(this);
+  closeHandler = this.handleClose.bind(this);
+  errorHandler = this.handleError.bind(this);
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      ...config,
+      reconnect: {
+        enabled: true,
+        maxAttempts: 5,
+        interval: 1e3,
+        backoff: "exponential",
+        ...config.reconnect
+      }
+    };
+  }
+  /**
+   * Ensure WebSocket connection is established
+   */
+  async ensureConnected() {
+    var _a, _b;
+    if (this.connected && ((_a = this.ws) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
+      return;
+    }
+    if (((_b = this.ws) == null ? void 0 : _b.readyState) === WebSocket.CONNECTING) {
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Connection timeout")), this.config.timeout);
+        const checkConnection = () => {
+          var _a2, _b2;
+          if (this.connected) {
+            clearTimeout(timeout);
+            resolve();
+          } else if (((_a2 = this.ws) == null ? void 0 : _a2.readyState) === WebSocket.CLOSED || ((_b2 = this.ws) == null ? void 0 : _b2.readyState) === WebSocket.CLOSING) {
+            clearTimeout(timeout);
+            reject(new Error("Connection failed"));
+          } else {
+            setTimeout(checkConnection, 100);
+          }
+        };
+        checkConnection();
+      });
+    }
+    return this.connect();
+  }
+  /**
+   * Establish WebSocket connection
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        const url = new URL(this.config.url);
+        if (this.config.auth) {
+          switch (this.config.auth.type) {
+            case "bearer":
+              url.searchParams.set("token", this.config.auth.token || "");
+              break;
+            case "basic":
+              url.username = this.config.auth.username || "";
+              url.password = this.config.auth.password || "";
+              break;
+          }
+        }
+        this.ws = new WebSocket(url.toString());
+        this.ws.addEventListener("open", () => {
+          this.connected = true;
+          this.reconnectAttempts = 0;
+          resolve();
+        });
+        this.ws.addEventListener("message", this.messageHandler);
+        this.ws.addEventListener("close", this.closeHandler);
+        this.ws.addEventListener("error", this.errorHandler);
+        const timeout = setTimeout(() => {
+          var _a;
+          (_a = this.ws) == null ? void 0 : _a.close();
+          reject(new Error("Connection timeout"));
+        }, this.config.timeout);
+        this.ws.addEventListener("open", () => clearTimeout(timeout), { once: true });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Handle WebSocket messages
+   */
+  handleMessage(event) {
+    try {
+      const response = JSON.parse(event.data);
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(response.id);
+        pending.resolve(response);
+      }
+    } catch (error) {
+      console.error("Failed to parse WebSocket message:", error);
+    }
+  }
+  /**
+   * Handle WebSocket close
+   */
+  handleClose() {
+    var _a;
+    this.connected = false;
+    this.cleanupPendingRequests(new Error("WebSocket connection closed"));
+    if (((_a = this.config.reconnect) == null ? void 0 : _a.enabled) && this.reconnectAttempts < (this.config.reconnect.maxAttempts || 5)) {
+      this.scheduleReconnect();
+    }
+  }
+  /**
+   * Handle WebSocket errors
+   */
+  handleError(_error) {
+    this.connected = false;
+    this.cleanupPendingRequests(new Error("WebSocket error"));
+  }
+  /**
+   * Schedule reconnection attempt
+   */
+  scheduleReconnect() {
+    var _a, _b;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    const delay = ((_a = this.config.reconnect) == null ? void 0 : _a.backoff) === "exponential" ? (this.config.reconnect.interval || 1e3) * Math.pow(2, this.reconnectAttempts) : ((_b = this.config.reconnect) == null ? void 0 : _b.interval) || 1e3;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectAttempts++;
+      this.connect().catch(() => {
+      });
+    }, delay);
+  }
+  /**
+   * Cleanup pending requests with error
+   */
+  cleanupPendingRequests(error) {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+  /**
+   * Send request and wait for response
+   */
+  async sendRequest(type, payload) {
+    await this.ensureConnected();
+    return new Promise((resolve, reject) => {
+      var _a;
+      const id = crypto.randomUUID();
+      const request = { id, type, payload };
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+      this.pendingRequests.set(id, {
+        resolve: (response) => {
+          if (response.success) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.error || "Request failed"));
+          }
+        },
+        reject,
+        timeout
+      });
+      try {
+        (_a = this.ws) == null ? void 0 : _a.send(JSON.stringify(request));
+      } catch (error) {
+        this.pendingRequests.delete(id);
+        clearTimeout(timeout);
+        reject(error);
+      }
+    });
+  }
+  async write(uri, value) {
+    try {
+      const result = await this.sendRequest("write", { uri, value });
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async read(uri) {
+    try {
+      const result = await this.sendRequest("read", { uri });
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async list(uri, options) {
+    try {
+      const result = await this.sendRequest("list", { uri, options });
+      return result;
+    } catch (error) {
+      return {
+        success: true,
+        data: [],
+        pagination: {
+          page: (options == null ? void 0 : options.page) || 1,
+          limit: (options == null ? void 0 : options.limit) || 50
+        }
+      };
+    }
+  }
+  async delete(uri) {
+    try {
+      const result = await this.sendRequest("delete", { uri });
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async health() {
+    try {
+      const result = await this.sendRequest("health", {});
+      return result;
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async getSchema() {
+    try {
+      const result = await this.sendRequest("getSchema", {});
+      return result;
+    } catch (error) {
+      return [];
+    }
+  }
+  async cleanup() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.cleanupPendingRequests(new Error("Client cleanup"));
+    if (this.ws) {
+      this.ws.removeEventListener("message", this.messageHandler);
+      this.ws.removeEventListener("close", this.closeHandler);
+      this.ws.removeEventListener("error", this.errorHandler);
+      if (this.ws.readyState === WebSocket.OPEN) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+    this.connected = false;
+    this.reconnectAttempts = 0;
+  }
+};
+
+export {
+  WebSocketClient
+};