@lix-js/sdk 0.8.4 → 0.10.0

package/dist/open-lix.js

@@ -1,16 +1,7 @@
-import { localFilesystemAlreadyOpen, localFilesystemNotOpen, invalidArgument, } from "./errors.js";
-import { normalizeOptionals, wrapExecuteResult } from "./result.js";
-import { normalizeParam, toNativeValue } from "./value.js";
-import { openLixWorker } from "./worker/client.js";
-const transactionFinalizer = new FinalizationRegistry(({ client, transactionId }) => {
-    client.notify({ kind: "transaction.abandon", transactionId });
-});
-const observeFinalizer = new FinalizationRegistry(({ client, observeId }) => {
-    void observeId.then((id) => {
-        if (id !== undefined)
-            client.notify({ kind: "observe.close", observeId: id });
-    });
-});
+import { localFilesystemAlreadyOpen, localFilesystemNotOpen, } from "./errors.js";
+import { ACTIVE_ACCOUNT_CLIENT_STATE_KEY, ACTIVE_BRANCH_CLIENT_STATE_KEY, openClientState, openStoredClientState, } from "./client-state.js";
+import { Lix } from "./lix.js";
+export { Lix, LixTransaction, ObserveEvents } from "./lix.js";
 export class SQLite {
     path;
     constructor(options) {
@@ -53,16 +44,13 @@ export class LocalFilesystem {
                 throw new TypeError("importPaths() paths must contain non-empty strings");
             }
             if (path.endsWith("/")) {
-                throw new TypeError("importPaths() paths must contain file paths, not directory paths");
+                throw new TypeError("importPaths() paths must not end with a trailing slash");
             }
         }
-        await this.client("importPaths").request({
-            kind: "importFilesystemPaths",
-            paths: [...paths],
-        });
+        await this.client("importPaths").importFilesystemPaths([...paths]);
     }
     async syncDiskToLix() {
-        return this.client("syncDiskToLix").request({ kind: "syncDiskToLix" });
+        return this.client("syncDiskToLix").syncDiskToLix();
     }
     client(operation) {
         const client = openLocalFilesystems.get(this);
@@ -79,11 +67,63 @@ export async function openLix(options = {}) {
     if ("backend" in options) {
         throw new TypeError("openLix() option 'backend' was removed; use 'storage' instead");
     }
+    if (options.telemetry !== undefined &&
+        (typeof options.telemetry !== "object" ||
+            typeof options.telemetry.onSpan !== "function")) {
+        throw new TypeError("openLix() telemetry requires an onSpan callback");
+    }
+    if (options.server !== undefined) {
+        const { openRemoteLixBinding } = await import("./remote/client.js");
+        if (options.storage === undefined) {
+            return new Lix(await openRemoteLixBinding(options.server));
+        }
+        assertSnapshotStorage(options.storage);
+        const clientState = await openStoredClientState({
+            storage: options.storage,
+            namespace: remoteClientStateNamespace(options.server.url),
+        });
+        const restoredBranchId = clientState.get(ACTIVE_BRANCH_CLIENT_STATE_KEY);
+        const restoredAccountId = clientState.get(ACTIVE_ACCOUNT_CLIENT_STATE_KEY);
+        let remoteBinding;
+        try {
+            try {
+                remoteBinding = await openRemoteLixBinding(options.server, {
+                    initialActiveBranchId: restoredBranchId,
+                    initialActiveAccountId: restoredAccountId,
+                });
+            }
+            catch (error) {
+                if (!restoredBranchId || !isBranchNotFoundError(error))
+                    throw error;
+                remoteBinding = await openRemoteLixBinding(options.server, {
+                    initialActiveAccountId: restoredAccountId,
+                });
+            }
+            const activeBranchId = await remoteBinding.activeBranchId();
+            const activeAccountId = await remoteBinding.activeAccountId();
+            if (activeBranchId !== restoredBranchId) {
+                await clientState.set(ACTIVE_BRANCH_CLIENT_STATE_KEY, activeBranchId);
+            }
+            if (activeAccountId !== restoredAccountId) {
+                await clientState.set(ACTIVE_ACCOUNT_CLIENT_STATE_KEY, activeAccountId);
+            }
+            return new Lix(remoteBinding, clientState);
+        }
+        catch (error) {
+            await remoteBinding?.close().catch(() => undefined);
+            await clientState.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    const { openLixWorkerBinding } = await import("./worker/client.js");
     if (options.storage === undefined) {
-        return new Lix(await openLixWorker({ kind: "memory" }));
+        return new Lix(await openLixWorkerBinding({ kind: "memory" }, undefined, options.telemetry));
     }
     if (options.storage instanceof SQLite) {
-        return new Lix(await openLixWorker({ kind: "sqlite", path: options.storage.path }));
+        return new Lix(await openLixWorkerBinding({
+            kind: "sqlite",
+            path: options.storage.path,
+        }, undefined, options.telemetry));
     }
     if (options.storage instanceof LocalFilesystem) {
         const storage = options.storage;
@@ -92,175 +132,64 @@ export async function openLix(options = {}) {
         }
         openLocalFilesystems.set(storage, null);
         try {
-            const client = await openLixWorker({
+            const binding = await openLixWorkerBinding({
                 kind: "localFilesystem",
                 path: storage.path,
                 lixDir: storage.lixDir,
                 syncAllFiles: storage.syncAllFiles,
-            }, () => openLocalFilesystems.delete(storage));
-            openLocalFilesystems.set(storage, client);
-            return new Lix(client);
+            }, () => openLocalFilesystems.delete(storage), options.telemetry);
+            openLocalFilesystems.set(storage, binding);
+            return new Lix(binding);
         }
         catch (error) {
             openLocalFilesystems.delete(storage);
             throw error;
         }
     }
-    throw new TypeError("openLix() requires storage to be SQLite or LocalFilesystem");
-}
-export class Lix {
-    client;
-    closePromise;
-    constructor(client) {
-        this.client = client;
-    }
-    async execute(sql, params = [], options) {
-        assertExecuteArgs("lix", sql, params, options);
-        return wrapExecuteResult(await this.client.request({
-            kind: "execute",
-            sql,
-            params: params.map((param, index) => toNativeValue(normalizeParam(param, index))),
-            options,
-        }));
-    }
-    observe(sql, params = []) {
-        assertSqlArgs("observe", "lix", sql, params);
-        return new ObserveEvents(this.client, this.client.request({
-            kind: "observe",
-            sql,
-            params: params.map((param, index) => toNativeValue(normalizeParam(param, index))),
-        }));
-    }
-    async beginTransaction() {
-        const transactionId = await this.client.request({
-            kind: "beginTransaction",
+    if (isSnapshotStorage(options.storage)) {
+        const { openPersistentLixWorkerBinding } = await import("./worker/client.js");
+        const binding = await openPersistentLixWorkerBinding({
+            storage: options.storage,
+            namespace: "local",
+            telemetry: options.telemetry,
         });
-        return new LixTransaction(this.client, transactionId);
-    }
-    async activeBranchId() {
-        return this.client.request({ kind: "activeBranchId" });
-    }
-    async createBranch(options) {
-        return this.client.request({ kind: "createBranch", options });
-    }
-    async switchBranch(options) {
-        return this.client.request({ kind: "switchBranch", options });
-    }
-    async mergeBranchPreview(options) {
-        return normalizeOptionals(await this.client.request({ kind: "mergeBranchPreview", options }));
-    }
-    async mergeBranch(options) {
-        const receipt = normalizeOptionals(await this.client.request({ kind: "mergeBranch", options }));
-        receipt.createdMergeCommitId ??= null;
-        return receipt;
-    }
-    async close() {
-        this.closePromise ??= (async () => {
-            await this.client.request({ kind: "close" });
-            await this.client.terminate();
-        })();
         try {
-            await this.closePromise;
+            const clientState = await openClientState({ binding });
+            return new Lix(binding, clientState);
         }
         catch (error) {
-            this.closePromise = undefined;
+            await binding.close().catch(() => undefined);
             throw error;
         }
     }
+    throw new TypeError("openLix() requires storage to be SQLite, LocalFilesystem, or a Lix snapshot storage adapter");
 }
-export class ObserveEvents {
-    client;
-    setup = {};
-    closed = false;
-    observeId;
-    constructor(client, observeId) {
-        this.client = client;
-        const setup = this.setup;
-        this.observeId = observeId.catch((error) => {
-            setup.error = error;
-            return undefined;
-        });
-        observeFinalizer.register(this, { client, observeId: this.observeId }, this);
-    }
-    async next() {
-        if (this.closed)
-            return undefined;
-        const observeId = await this.observeId;
-        if (observeId === undefined) {
-            throw this.setup.error;
-        }
-        const event = await this.client.request({
-            kind: "observe.next",
-            observeId,
-        });
-        if (event == null) {
-            return undefined;
-        }
-        return {
-            sequence: event.sequence,
-            mutationSequence: event.mutationSequence,
-            result: wrapExecuteResult(event.rows),
-        };
-    }
-    close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        observeFinalizer.unregister(this);
-        void this.observeId.then((observeId) => {
-            if (observeId !== undefined) {
-                this.client.notify({ kind: "observe.close", observeId });
-            }
-        });
-    }
+function isSnapshotStorage(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.load === "function" &&
+        typeof value.save === "function");
 }
-export class LixTransaction {
-    client;
-    transactionId;
-    constructor(client, transactionId) {
-        this.client = client;
-        this.transactionId = transactionId;
-        transactionFinalizer.register(this, { client, transactionId }, this);
-    }
-    async execute(sql, params = [], options) {
-        assertExecuteArgs("lixTransaction", sql, params, options);
-        return wrapExecuteResult(await this.client.request({
-            kind: "transaction.execute",
-            transactionId: this.transactionId,
-            sql,
-            params: params.map((param, index) => toNativeValue(normalizeParam(param, index))),
-            options,
-        }));
-    }
-    async commit() {
-        return this.finish("transaction.commit");
-    }
-    async rollback() {
-        return this.finish("transaction.rollback");
-    }
-    async finish(kind) {
-        transactionFinalizer.unregister(this);
-        return this.client.request({ kind, transactionId: this.transactionId });
+function assertSnapshotStorage(value) {
+    if (!isSnapshotStorage(value)) {
+        throw new TypeError("openLix() remote storage must implement load() and save()");
     }
 }
-function assertExecuteArgs(receiver, sql, params, options) {
-    assertSqlArgs("execute", receiver, sql, params);
-    if (options === undefined) {
-        return;
-    }
-    if (!options || typeof options !== "object" || Array.isArray(options)) {
-        throw invalidArgument("execute", "options", "object", typeof options, receiver);
-    }
-    if (options.originKey !== undefined &&
-        typeof options.originKey !== "string") {
-        throw invalidArgument("execute", "options.originKey", "string", typeof options.originKey, receiver);
-    }
+function remoteClientStateNamespace(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TypeError("openLix() remote server url must be an absolute URL");
+    }
+    url.pathname = url.pathname.replace(/\/$/, "");
+    url.search = "";
+    url.hash = "";
+    return `remote:${url.href}`;
 }
-function assertSqlArgs(operation, receiver, sql, params) {
-    if (typeof sql !== "string") {
-        throw invalidArgument(operation, "sql", "string", typeof sql, receiver);
-    }
-    if (!Array.isArray(params)) {
-        throw invalidArgument(operation, "params", "array", typeof params, receiver);
-    }
+function isBranchNotFoundError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === "LIX_BRANCH_NOT_FOUND");
 }

package/dist/remote/client.d.ts

@@ -0,0 +1,9 @@
+import type { LixBinding } from "../binding-types.js";
+import type { RemoteLixServerOptions } from "../types.js";
+import { type RemoteHandshakeRequest } from "./protocol.js";
+type RemoteLixClientOptions = {
+    initialActiveBranchId?: RemoteHandshakeRequest["activeBranchId"];
+    initialActiveAccountId?: RemoteHandshakeRequest["activeAccountId"];
+};
+export declare function openRemoteLixBinding(options: RemoteLixServerOptions, clientOptions?: RemoteLixClientOptions): Promise<LixBinding>;
+export {};