fivebit-client 0.1.0

package/dist/AuthClient.d.ts

@@ -0,0 +1,22 @@
+export interface AuthSession {
+    userId: number;
+    token: string;
+    expiresAt: number;
+}
+export declare class AuthClient {
+    private baseUrl;
+    private _token;
+    constructor(baseUrl: string);
+    signUp(email: string, password: string, name?: string): Promise<{
+        userId: number;
+    } | {
+        error: string;
+    }>;
+    signIn(email: string, password: string): Promise<{
+        session: AuthSession;
+    } | {
+        error: string;
+    }>;
+    signOut(): Promise<void>;
+    get token(): string | null;
+}

package/dist/AuthClient.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthClient = void 0;
+class AuthClient {
+    constructor(baseUrl) {
+        this._token = null;
+        this.baseUrl = baseUrl;
+    }
+    async signUp(email, password, name) {
+        const r = await fetch(`${this.baseUrl}/api/auth/signup`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, password, name }),
+        });
+        return r.json();
+    }
+    async signIn(email, password) {
+        const r = await fetch(`${this.baseUrl}/api/auth/login`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, password }),
+        });
+        const data = await r.json();
+        if ('session' in data)
+            this._token = data.session.token;
+        return data;
+    }
+    async signOut() {
+        if (this._token) {
+            await fetch(`${this.baseUrl}/api/auth/logout`, {
+                method: 'POST', headers: { 'Authorization': `Bearer ${this._token}` },
+            });
+            this._token = null;
+        }
+    }
+    get token() { return this._token; }
+}
+exports.AuthClient = AuthClient;

package/dist/FivebitClient.d.ts

@@ -0,0 +1,35 @@
+import { AuthClient } from './AuthClient';
+export interface FivebitConfig {
+    url: string;
+    apiKey?: string;
+}
+export interface AuthSession {
+    userId: number;
+    token: string;
+    expiresAt: number;
+}
+export interface QueryResult<T> {
+    data: T | null;
+    error: string | null;
+    etag: string;
+}
+export declare class FivebitClient {
+    config: FivebitConfig;
+    auth: AuthClient;
+    private _query;
+    private _rt;
+    private _session;
+    constructor(config: FivebitConfig);
+    get session(): AuthSession | null;
+    setSession(s: AuthSession | null): void;
+    from<T = any>(table: string): {
+        getById(id: number): Promise<QueryResult<T>>;
+        insert(record: Omit<T, "_id" | "_hash">): Promise<QueryResult<T>>;
+        update(id: number, record: Partial<T>): Promise<QueryResult<T>>;
+        delete(id: number): Promise<boolean>;
+        query(field: string, value: string, limit?: number): Promise<T[]>;
+    };
+    onChanges(table: string, fn: (record: any) => void): void;
+    close(): void;
+}
+export declare function createClient(config: FivebitConfig): FivebitClient;

package/dist/FivebitClient.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FivebitClient = void 0;
+exports.createClient = createClient;
+const AuthClient_1 = require("./AuthClient");
+const QueryClient_1 = require("./QueryClient");
+const RealtimeClient_1 = require("./RealtimeClient");
+class FivebitClient {
+    constructor(config) {
+        this._session = null;
+        this.config = config;
+        this.auth = new AuthClient_1.AuthClient(config.url);
+        this._query = new QueryClient_1.QueryClient(config.url, () => this._session?.token || '');
+        this._rt = new RealtimeClient_1.RealtimeClient(config.url);
+    }
+    get session() { return this._session; }
+    setSession(s) { this._session = s; }
+    from(table) {
+        return this._query.table(table);
+    }
+    onChanges(table, fn) {
+        this._rt.subscribe(table, fn);
+    }
+    close() { this._rt.close(); }
+}
+exports.FivebitClient = FivebitClient;
+function createClient(config) {
+    return new FivebitClient(config);
+}

package/dist/QueryClient.d.ts

@@ -0,0 +1,15 @@
+import type { QueryResult } from './FivebitClient';
+export declare class QueryClient {
+    private baseUrl;
+    private getToken;
+    private etagCache;
+    constructor(baseUrl: string, getToken: () => string);
+    private headers;
+    table<T = any>(name: string): {
+        getById(id: number): Promise<QueryResult<T>>;
+        insert(record: Omit<T, "_id" | "_hash">): Promise<QueryResult<T>>;
+        update(id: number, record: Partial<T>): Promise<QueryResult<T>>;
+        delete(id: number): Promise<boolean>;
+        query(field: string, value: string, limit?: number): Promise<T[]>;
+    };
+}

package/dist/QueryClient.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryClient = void 0;
+class QueryClient {
+    constructor(baseUrl, getToken) {
+        this.etagCache = new Map();
+        this.baseUrl = baseUrl;
+        this.getToken = getToken;
+    }
+    headers() {
+        const h = { 'Content-Type': 'application/json' };
+        const t = this.getToken();
+        if (t)
+            h['Authorization'] = `Bearer ${t}`;
+        return h;
+    }
+    table(name) {
+        const self = this;
+        return {
+            async getById(id) {
+                const h = self.headers();
+                const etag = self.etagCache.get(id);
+                if (etag)
+                    h['If-None-Match'] = `"${etag}"`;
+                const r = await fetch(`${self.baseUrl}/records/${id}`, { headers: h });
+                if (r.status === 304)
+                    return { data: null, error: null, etag: etag || '' };
+                const data = await r.json();
+                const newEtag = r.headers.get('ETag')?.replace(/"/g, '') || '';
+                if (newEtag)
+                    self.etagCache.set(id, newEtag);
+                return { data, error: null, etag: newEtag };
+            },
+            async insert(record) {
+                const r = await fetch(`${self.baseUrl}/records`, {
+                    method: 'POST', headers: self.headers(), body: JSON.stringify(record),
+                });
+                const data = await r.json();
+                return { data, error: r.ok ? null : data.error, etag: '' };
+            },
+            async update(id, record) {
+                const h = self.headers();
+                const etag = self.etagCache.get(id);
+                if (etag)
+                    h['If-Match'] = `"${etag}"`;
+                const r = await fetch(`${self.baseUrl}/records/${id}`, {
+                    method: 'PUT', headers: h, body: JSON.stringify(record),
+                });
+                if (r.status === 412)
+                    return { data: null, error: 'Conflict — record modified', etag: '' };
+                const data = await r.json();
+                return { data, error: null, etag: '' };
+            },
+            async delete(id) {
+                const r = await fetch(`${self.baseUrl}/records/${id}`, {
+                    method: 'DELETE', headers: self.headers(),
+                });
+                self.etagCache.delete(id);
+                return r.ok;
+            },
+            async query(field, value, limit = 20) {
+                const r = await fetch(`${self.baseUrl}/records?field=${field}&value=${value}&limit=${limit}`, {
+                    headers: self.headers(),
+                });
+                const data = await r.json();
+                return data.results || [];
+            },
+        };
+    }
+}
+exports.QueryClient = QueryClient;

package/dist/RealtimeClient.d.ts

@@ -0,0 +1,12 @@
+type ChangeHandler = (record: any) => void;
+export declare class RealtimeClient {
+    private baseUrl;
+    private sources;
+    private handlers;
+    private reconnectMs;
+    constructor(baseUrl: string);
+    subscribe(table: string, fn: ChangeHandler): () => void;
+    private _connect;
+    close(): void;
+}
+export {};

package/dist/RealtimeClient.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeClient = void 0;
+class RealtimeClient {
+    constructor(baseUrl) {
+        this.sources = new Map();
+        this.handlers = new Map();
+        this.reconnectMs = 3000;
+        this.baseUrl = baseUrl;
+    }
+    subscribe(table, fn) {
+        if (!this.handlers.has(table)) {
+            this.handlers.set(table, new Set());
+            this._connect(table);
+        }
+        this.handlers.get(table).add(fn);
+        return () => this.handlers.get(table)?.delete(fn);
+    }
+    _connect(table) {
+        const url = `${this.baseUrl}/stream/${table}`;
+        const es = new EventSource(url);
+        es.onmessage = (e) => {
+            try {
+                const record = JSON.parse(e.data);
+                this.handlers.get(table)?.forEach(fn => fn(record));
+            }
+            catch { }
+        };
+        es.onerror = () => {
+            es.close();
+            setTimeout(() => this._connect(table), this.reconnectMs);
+        };
+        this.sources.set(table, es);
+    }
+    close() {
+        for (const es of this.sources.values())
+            es.close();
+        this.sources.clear();
+        this.handlers.clear();
+    }
+}
+exports.RealtimeClient = RealtimeClient;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createClient, FivebitClient } from './FivebitClient';
+export type { FivebitConfig, AuthSession, QueryResult } from './FivebitClient';

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FivebitClient = exports.createClient = void 0;
+var FivebitClient_1 = require("./FivebitClient");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return FivebitClient_1.createClient; } });
+Object.defineProperty(exports, "FivebitClient", { enumerable: true, get: function () { return FivebitClient_1.FivebitClient; } });

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "fivebit-client",
+  "version": "0.1.0",
+  "description": "5bit client SDK — deterministic, content-addressed database",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "src"],
+  "repository": { "type": "git", "url": "https://github.com/Humansales-AI/5bit" },
+  "license": "MIT",
+  "keywords": ["5bit", "database", "deterministic", "content-addressed", "realtime"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc"
+  }
+}

package/src/AuthClient.ts

@@ -0,0 +1,37 @@
+export interface AuthSession { userId: number; token: string; expiresAt: number; }
+
+export class AuthClient {
+  private baseUrl: string;
+  private _token: string | null = null;
+
+  constructor(baseUrl: string) { this.baseUrl = baseUrl; }
+
+  async signUp(email: string, password: string, name?: string): Promise<{ userId: number } | { error: string }> {
+    const r = await fetch(`${this.baseUrl}/api/auth/signup`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password, name }),
+    });
+    return r.json();
+  }
+
+  async signIn(email: string, password: string): Promise<{ session: AuthSession } | { error: string }> {
+    const r = await fetch(`${this.baseUrl}/api/auth/login`, {
+      method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+    const data = await r.json();
+    if ('session' in data) this._token = data.session.token;
+    return data;
+  }
+
+  async signOut(): Promise<void> {
+    if (this._token) {
+      await fetch(`${this.baseUrl}/api/auth/logout`, {
+        method: 'POST', headers: { 'Authorization': `Bearer ${this._token}` },
+      });
+      this._token = null;
+    }
+  }
+
+  get token(): string | null { return this._token; }
+}

package/src/FivebitClient.ts

@@ -0,0 +1,40 @@
+import { AuthClient } from './AuthClient';
+import { QueryClient } from './QueryClient';
+import { RealtimeClient } from './RealtimeClient';
+
+export interface FivebitConfig { url: string; apiKey?: string; }
+export interface AuthSession { userId: number; token: string; expiresAt: number; }
+export interface QueryResult<T> { data: T | null; error: string | null; etag: string; }
+
+export class FivebitClient {
+  config: FivebitConfig;
+  auth: AuthClient;
+  private _query: QueryClient;
+  private _rt: RealtimeClient;
+  private _session: AuthSession | null = null;
+
+  constructor(config: FivebitConfig) {
+    this.config = config;
+    this.auth = new AuthClient(config.url);
+    this._query = new QueryClient(config.url, () => this._session?.token || '');
+    this._rt = new RealtimeClient(config.url);
+  }
+
+  get session(): AuthSession | null { return this._session; }
+
+  setSession(s: AuthSession | null) { this._session = s; }
+
+  from<T = any>(table: string) {
+    return this._query.table<T>(table);
+  }
+
+  onChanges(table: string, fn: (record: any) => void) {
+    this._rt.subscribe(table, fn);
+  }
+
+  close() { this._rt.close(); }
+}
+
+export function createClient(config: FivebitConfig): FivebitClient {
+  return new FivebitClient(config);
+}

package/src/QueryClient.ts

@@ -0,0 +1,71 @@
+import type { QueryResult } from './FivebitClient';
+
+export class QueryClient {
+  private baseUrl: string;
+  private getToken: () => string;
+  private etagCache: Map<number, string> = new Map();
+
+  constructor(baseUrl: string, getToken: () => string) {
+    this.baseUrl = baseUrl; this.getToken = getToken;
+  }
+
+  private headers(): Record<string, string> {
+    const h: Record<string, string> = { 'Content-Type': 'application/json' };
+    const t = this.getToken();
+    if (t) h['Authorization'] = `Bearer ${t}`;
+    return h;
+  }
+
+  table<T = any>(name: string) {
+    const self = this;
+    return {
+      async getById(id: number): Promise<QueryResult<T>> {
+        const h = self.headers();
+        const etag = self.etagCache.get(id);
+        if (etag) h['If-None-Match'] = `"${etag}"`;
+        const r = await fetch(`${self.baseUrl}/records/${id}`, { headers: h });
+        if (r.status === 304) return { data: null, error: null, etag: etag || '' };
+        const data = await r.json();
+        const newEtag = r.headers.get('ETag')?.replace(/"/g, '') || '';
+        if (newEtag) self.etagCache.set(id, newEtag);
+        return { data, error: null, etag: newEtag };
+      },
+
+      async insert(record: Omit<T, '_id' | '_hash'>): Promise<QueryResult<T>> {
+        const r = await fetch(`${self.baseUrl}/records`, {
+          method: 'POST', headers: self.headers(), body: JSON.stringify(record),
+        });
+        const data = await r.json();
+        return { data, error: r.ok ? null : data.error, etag: '' };
+      },
+
+      async update(id: number, record: Partial<T>): Promise<QueryResult<T>> {
+        const h = self.headers();
+        const etag = self.etagCache.get(id);
+        if (etag) h['If-Match'] = `"${etag}"`;
+        const r = await fetch(`${self.baseUrl}/records/${id}`, {
+          method: 'PUT', headers: h, body: JSON.stringify(record),
+        });
+        if (r.status === 412) return { data: null, error: 'Conflict — record modified', etag: '' };
+        const data = await r.json();
+        return { data, error: null, etag: '' };
+      },
+
+      async delete(id: number): Promise<boolean> {
+        const r = await fetch(`${self.baseUrl}/records/${id}`, {
+          method: 'DELETE', headers: self.headers(),
+        });
+        self.etagCache.delete(id);
+        return r.ok;
+      },
+
+      async query(field: string, value: string, limit = 20): Promise<T[]> {
+        const r = await fetch(`${self.baseUrl}/records?field=${field}&value=${value}&limit=${limit}`, {
+          headers: self.headers(),
+        });
+        const data = await r.json();
+        return data.results || [];
+      },
+    };
+  }
+}

package/src/RealtimeClient.ts

@@ -0,0 +1,41 @@
+type ChangeHandler = (record: any) => void;
+
+export class RealtimeClient {
+  private baseUrl: string;
+  private sources: Map<string, EventSource> = new Map();
+  private handlers: Map<string, Set<ChangeHandler>> = new Map();
+  private reconnectMs = 3000;
+
+  constructor(baseUrl: string) { this.baseUrl = baseUrl; }
+
+  subscribe(table: string, fn: ChangeHandler): () => void {
+    if (!this.handlers.has(table)) {
+      this.handlers.set(table, new Set());
+      this._connect(table);
+    }
+    this.handlers.get(table)!.add(fn);
+    return () => this.handlers.get(table)?.delete(fn);
+  }
+
+  private _connect(table: string): void {
+    const url = `${this.baseUrl}/stream/${table}`;
+    const es = new EventSource(url);
+    es.onmessage = (e) => {
+      try {
+        const record = JSON.parse(e.data);
+        this.handlers.get(table)?.forEach(fn => fn(record));
+      } catch {}
+    };
+    es.onerror = () => {
+      es.close();
+      setTimeout(() => this._connect(table), this.reconnectMs);
+    };
+    this.sources.set(table, es);
+  }
+
+  close(): void {
+    for (const es of this.sources.values()) es.close();
+    this.sources.clear();
+    this.handlers.clear();
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createClient, FivebitClient } from './FivebitClient';
+export type { FivebitConfig, AuthSession, QueryResult } from './FivebitClient';