@estra/client 0.0.0-stage → 0.1.1

package/dist/store.js

@@ -0,0 +1,44 @@
+export function memoryStore() {
+    const m = new Map();
+    const copy = (v) => (v === undefined ? undefined : structuredClone(v));
+    return {
+        get: async (k) => copy(m.get(k)),
+        set: async (k, v) => void m.set(k, structuredClone(v)),
+        delete: async (k) => void m.delete(k),
+        list: async (p) => [...m].filter(([k]) => k.startsWith(p)).map(([k, v]) => [k, copy(v)]),
+        clear: async () => m.clear(),
+    };
+}
+const g = globalThis;
+/** One IndexedDB database with one object store; values are structured-cloned. */
+export function indexedDbStore(name, idb = g.indexedDB) {
+    if (!idb || !g.IDBKeyRange)
+        throw new Error("IndexedDB isn't available here");
+    const keyRange = g.IDBKeyRange;
+    let dbp = null;
+    const db = () => (dbp ??= new Promise((resolve, reject) => {
+        const r = idb.open(name, 1);
+        r.onupgradeneeded = () => r.result.createObjectStore("kv");
+        r.onsuccess = () => resolve(r.result);
+        r.onerror = () => reject(r.error);
+    }));
+    const tx = async (mode, fn) => {
+        const d = await db();
+        return new Promise((resolve, reject) => {
+            const req = fn(d.transaction("kv", mode).objectStore("kv"));
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        });
+    };
+    return {
+        get: (k) => tx("readonly", (s) => s.get(k)),
+        set: async (k, v) => void (await tx("readwrite", (s) => s.put(v, k))),
+        delete: async (k) => void (await tx("readwrite", (s) => s.delete(k))),
+        list: async (p) => {
+            const range = keyRange.bound(p, p + "\uffff");
+            const [keys, vals] = await Promise.all([tx("readonly", (s) => s.getAllKeys(range)), tx("readonly", (s) => s.getAll(range))]);
+            return keys.map((k, i) => [String(k), vals[i]]);
+        },
+        clear: async () => void (await tx("readwrite", (s) => s.clear())),
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,46 @@
+import type { CommitRequest, DocOut, Query } from "./_schema/index.js";
+import { type Listen } from "./realtime.js";
+export interface CommitOut {
+    writes: {
+        path: string;
+        v: number | null;
+        seq: number;
+    }[];
+    seq: number;
+    duplicate?: boolean;
+}
+export interface QueryOut {
+    docs: DocOut[];
+    hasMore: boolean;
+    truncated?: boolean;
+    fromCache?: boolean;
+}
+export interface Transport {
+    /** Live listeners (onSnapshot); absent = not supported by this transport. */
+    listen?: Listen;
+    getAll(paths: string[]): Promise<(DocOut | null)[]>;
+    query(query: Query): Promise<QueryOut>;
+    aggregate(query: Query): Promise<Record<string, number | null>>;
+    commit(req: CommitRequest): Promise<CommitOut>;
+    /** Hot counters (POST /v1/counters/inc): buffered server-side, flushed about once a second. */
+    counterInc?(path: string, field: string, by: number): Promise<{
+        value: number | null;
+    }>;
+    /** Re-send the auth token on the live connection now (after sign-in / sign-out). */
+    refreshAuth?(): void;
+}
+/** Errors carry Firestore's code names ("permission-denied", "not-found" …). */
+export declare class EstraClientError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface HttpOptions {
+    /** Base URL of the app's Estra Worker, e.g. https://api.example.com */
+    url: string;
+    /** Current access token, or null when signed out. */
+    getToken?: () => Promise<string | null> | string | null;
+    fetch?: typeof fetch;
+    /** WebSocket implementation for onSnapshot (defaults to the global one; false = no listeners). */
+    WebSocket?: typeof WebSocket | false;
+}
+export declare function httpTransport(o: HttpOptions): Transport;

package/dist/transport.js

@@ -0,0 +1,45 @@
+import { realtimeConnection } from "./realtime.js";
+/** Errors carry Firestore's code names ("permission-denied", "not-found" …). */
+export class EstraClientError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "EstraError";
+    }
+}
+export function httpTransport(o) {
+    const f = o.fetch ?? fetch;
+    const call = async (route, body) => {
+        const token = o.getToken ? await o.getToken() : null;
+        const headers = { "content-type": "application/json" };
+        if (token)
+            headers.authorization = `Bearer ${token}`;
+        let r;
+        try {
+            r = await f(`${o.url.replace(/\/$/, "")}/v1/${route}`, { method: "POST", headers, body: JSON.stringify(body) });
+        }
+        catch {
+            throw new EstraClientError("unavailable", "network request failed");
+        }
+        if (r.status === 502 || r.status === 503 || r.status === 504)
+            throw new EstraClientError("unavailable", `HTTP ${r.status}`);
+        const j = (await r.json().catch(() => ({})));
+        if (!r.ok)
+            throw new EstraClientError(j.error?.code ?? "unavailable", j.error?.message ?? `HTTP ${r.status}`);
+        return j;
+    };
+    let rt = null;
+    const listen = o.WebSocket === false
+        ? undefined
+        : (target, h) => (rt ??= realtimeConnection({ url: o.url, ...(o.getToken ? { getToken: o.getToken } : {}), ...(o.WebSocket ? { WebSocket: o.WebSocket } : {}) })).listen(target, h);
+    return {
+        ...(listen ? { listen } : {}),
+        refreshAuth: () => rt?.refreshAuth(),
+        getAll: async (paths) => (await call("get", { paths })).docs,
+        query: (query) => call("query", { query }),
+        aggregate: async (query) => (await call("query", { query })).aggregate,
+        commit: (req) => call("commit", req),
+        counterInc: (path, field, by) => call("counters/inc", { path, field, by }),
+    };
+}

package/package.json

@@ -1,6 +1,81 @@
 {
   "name": "@estra/client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Web and server client for Estra: documents, queries, realtime listeners, auth and callable functions, with a Firebase-compatible API.",
+  "license": "MIT",
+  "homepage": "https://estra.cloud",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Realm-8/estra.git",
+    "directory": "packages/client"
+  },
+  "bugs": "https://github.com/Realm-8/estra/issues",
+  "keywords": [
+    "estra",
+    "database",
+    "realtime",
+    "auth",
+    "firebase",
+    "firestore"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./firestore": {
+      "types": "./dist/firestore.d.ts",
+      "default": "./dist/firestore.js"
+    },
+    "./auth": {
+      "types": "./dist/auth.d.ts",
+      "default": "./dist/auth.js"
+    },
+    "./storage": {
+      "types": "./dist/storage.d.ts",
+      "default": "./dist/storage.js"
+    },
+    "./functions": {
+      "types": "./dist/functions.d.ts",
+      "default": "./dist/functions.js"
+    },
+    "./channels": {
+      "types": "./dist/channels.d.ts",
+      "default": "./dist/channels.js"
+    },
+    "./compat/app": {
+      "types": "./dist/compat/app.d.ts",
+      "default": "./dist/compat/app.js"
+    },
+    "./compat/auth": {
+      "types": "./dist/compat/auth.d.ts",
+      "default": "./dist/compat/auth.js"
+    },
+    "./compat/firestore": {
+      "types": "./dist/compat/firestore.d.ts",
+      "default": "./dist/compat/firestore.js"
+    },
+    "./compat/storage": {
+      "types": "./dist/compat/storage.d.ts",
+      "default": "./dist/compat/storage.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2",
+    "@estra/schema": "0.1.1"
+  },
+  "scripts": {
+    "typecheck": "tsc -p .",
+    "build": "node ../../scripts/build-package.ts client",
+    "test": "echo 'client is tested through @estra/testing'"
+  },
+  "types": "./dist/index.d.ts"
 }