@auersperg/flare 0.0.0-stage → 0.3.2

package/dist/sdk/backup.js

@@ -0,0 +1,83 @@
+import { boundedJson, FlareError, stableJson } from "./protocol.js";
+import {
+  documentValue,
+  quote,
+  schemaContract
+} from "./schema.js";
+export const SNAPSHOT_BYTES = 4 * 1048576;
+export const SNAPSHOT_ROWS = 1e4;
+const reject = (code) => {
+  throw new FlareError(code, code);
+};
+export function emptyData(storage, schema) {
+  for (const name of Object.keys(schema))
+    if (storage.sql.exec(`SELECT 1 FROM ${quote(name)} LIMIT 1`).toArray().length)
+      return false;
+  return !storage.sql.exec("SELECT 1 FROM _flared_outbox LIMIT 1").toArray().length;
+}
+export function exportData(storage, schema) {
+  if (storage.sql.exec("SELECT 1 FROM _flared_outbox LIMIT 1").toArray().length)
+    reject("BACKUP_BUSY");
+  const snapshot = {
+    format: 1,
+    schema: schemaContract(schema),
+    revision: Number(storage.sql.exec("SELECT value FROM _flared_revision WHERE id=1").one().value),
+    tables: Object.create(null)
+  };
+  let count = 0, bytes = 0;
+  for (const name of Object.keys(schema)) {
+    const docs = [];
+    snapshot.tables[name] = docs;
+    let cursor = "";
+    for (;; ) {
+      const page = storage.sql.exec(`SELECT * FROM ${quote(name)} WHERE _id>? ORDER BY _id LIMIT 100`, cursor).toArray();
+      for (const row of page) {
+        const doc = {
+          _id: String(row._id),
+          _creationTime: Number(row._creationTime),
+          value: JSON.parse(String(row._data))
+        };
+        bytes += new TextEncoder().encode(stableJson(doc)).length;
+        if (++count > SNAPSHOT_ROWS || bytes > SNAPSHOT_BYTES)
+          reject("BACKUP_TOO_LARGE");
+        docs.push(doc);
+      }
+      if (page.length < 100)
+        break;
+      cursor = String(page.at(-1)._id);
+    }
+  }
+  return JSON.parse(boundedJson(snapshot, SNAPSHOT_BYTES));
+}
+export async function restoreData(storage, schema, id, snapshot) {
+  boundedJson(snapshot, SNAPSHOT_BYTES);
+  if (!/^[0-9a-f-]{36}$/.test(id) || snapshot?.format !== 1 || !Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0 || stableJson(snapshot.schema) !== stableJson(schemaContract(schema)) || !snapshot.tables || Array.isArray(snapshot.tables) || Object.keys(snapshot.tables).sort().join() !== Object.keys(schema).sort().join())
+    reject("INVALID_BACKUP");
+  await storage.transaction(async () => {
+    storage.sql.exec("CREATE TABLE IF NOT EXISTS _flared_restore (id TEXT PRIMARY KEY)");
+    if (storage.sql.exec("SELECT id FROM _flared_restore WHERE id=?", id).toArray().length)
+      return;
+    if (!emptyData(storage, schema))
+      reject("RESTORE_NOT_EMPTY");
+    let count = 0;
+    for (const [name, docs] of Object.entries(snapshot.tables)) {
+      if (!Array.isArray(docs))
+        reject("INVALID_BACKUP");
+      for (const doc of docs) {
+        if (++count > SNAPSHOT_ROWS || !doc || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(doc._id) || !Number.isFinite(doc._creationTime) || doc._creationTime < 0)
+          reject("INVALID_BACKUP");
+        const value = await documentValue(schema[name], doc.value);
+        if (stableJson(value) !== stableJson(doc.value))
+          reject("INVALID_BACKUP");
+        storage.sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, doc._id, doc._creationTime, stableJson(value));
+      }
+    }
+    storage.sql.exec("UPDATE _flared_revision SET value=? WHERE id=1", snapshot.revision);
+    storage.sql.exec("DELETE FROM _flared_changes");
+    for (const name of Object.keys(schema))
+      storage.sql.exec("INSERT INTO _flared_changes VALUES (?,?)", name, snapshot.revision);
+    storage.sql.exec("INSERT INTO _flared_restore VALUES (?)", id);
+  });
+  await storage.sync();
+  return { restored: true, revision: snapshot.revision };
+}

package/dist/sdk/client.d.ts

@@ -0,0 +1,80 @@
+import { FlareError, type FunctionRef } from "./protocol.js";
+export { reference, FlareError } from "./protocol.js";
+export type { FunctionRef, Json } from "./protocol.js";
+/** Unknown formats are stored as binary and always downloaded as attachments. */
+export declare function fileMetadata(file: Blob & {
+    name: string;
+}): {
+    name: string;
+    size: number;
+    type: string;
+};
+/** A grant is single-use. Never retry automatically after an ambiguous failure. */
+export declare function uploadFile(grant: {
+    url: string;
+}, file: Blob, options?: {
+    fetch?: (input: string, init: RequestInit) => Promise<Response>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<{
+    id: string;
+}>;
+export interface Socket {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: (event: any) => void): void;
+    removeEventListener(type: string, listener: (event: any) => void): void;
+}
+export interface ClientOptions {
+    url: string;
+    getToken?: () => string | null | Promise<string | null>;
+    fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+    createWebSocket?: (url: string) => Socket;
+    requestTimeoutMs?: number;
+}
+export interface Observer<O> {
+    next(value: O): void;
+    error?(error: FlareError): void;
+}
+export declare function createClient(options: ClientOptions): {
+    query: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
+    mutation: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
+    action: <I, O>(ref: FunctionRef<I, O>, args: I) => Promise<O>;
+    /** One subscription delivers the initial snapshot and subsequent updates. */
+    onUpdate<I, O>(ref: FunctionRef<I, O>, args: I, next: (value: O) => void, error?: (error: FlareError) => void): () => void;
+    /** Call on login/logout/account switch; never reuse cached values across identities. */
+    refreshAuth(): void;
+    dispose(): void;
+};
+export type FlareClient = ReturnType<typeof createClient>;
+export type PasswordUser = {
+    id: string;
+    login: string;
+    disabled: boolean;
+    createdAt: number;
+};
+export type PasswordSession = {
+    token: string;
+    expiresAt: number;
+    user: PasswordUser;
+};
+/** Browser persistence is scoped to the full deployment URL. Passwords are never stored.
+ * Server/mobile callers can provide storage explicitly, or use null for memory-only auth.
+ * Connect onChange to client.refreshAuth() and call restore() before rendering protected UI. */
+export type PasswordAuthStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+export declare function createPasswordAuth(options: {
+    url: string;
+    storage?: PasswordAuthStorage | null;
+}): {
+    getToken: () => string | null;
+    getUser: () => PasswordUser | null;
+    restore: () => Promise<PasswordUser | null>;
+    onChange(listener: () => void): () => boolean;
+    register: (login: string, password: string) => Promise<PasswordUser>;
+    login: (login: string, password: string) => Promise<PasswordUser>;
+    me(): Promise<PasswordUser>;
+    logout(): Promise<void>;
+    changePassword(currentPassword: string, password: string): Promise<void>;
+    dispose(): void;
+};