@orbitinghail/sqlsync-solid-js/dist/index.js

SQLSync is a collaborative offline-first wrapper around SQLite. It is designed to synchronize web application state between users, devices, and the edge.

import { SQLSync, normalizeQuery, pendingPromise } from '@orbitinghail/sqlsync-worker';
import { createContext, createSignal, onCleanup, createComponent, createEffect, useContext } from 'solid-js';

const SQLSyncContext = createContext([() => null, () => {}]);
const createSqlSync = props => {
  return new SQLSync(props.workerUrl, props.wasmUrl, props.coordinatorUrl);
};
const SQLSyncProvider = props => {
  const [sqlSync, setSQLSync] = createSignal(createSqlSync(props));
  onCleanup(() => {
    const s = sqlSync();
    if (s) {
      s.close();
    }
  });
  return createComponent(SQLSyncContext.Provider, {
    value: [sqlSync, setSQLSync],
    get children() {
      return props.children;
    }
  });
};

function useSQLSync() {
  const [sqlSync] = useContext(SQLSyncContext);
  return () => {
    const value = sqlSync();
    if (!value) {
      throw new Error("could not find sqlsync context value; please ensure the component is wrapped in a <SqlSyncProvider>");
    }
    return value;
  };
}
function createDocHooks(docType) {
  const useMutate = docId => {
    const sqlsync = useSQLSync();
    return mutation => sqlsync().mutate(docId, docType(), mutation);
  };
  const useQueryWrapper = (docId, query) => {
    return useQuery(docType, docId, query);
  };
  const useSetConnectionEnabledWrapper = docId => {
    const sqlsync = useSQLSync();
    return enabled => sqlsync().setConnectionEnabled(docId, docType(), enabled);
  };
  return {
    useMutate,
    useQuery: useQueryWrapper,
    useSetConnectionEnabled: useSetConnectionEnabledWrapper
  };
}
function useQuery(docType, docId, rawQuery) {
  const sqlsync = useSQLSync();
  const [state, setState] = createSignal({
    state: "pending"
  });
  createEffect(() => {
    const query = normalizeQuery(rawQuery());
    const [unsubPromise, unsubResolve] = pendingPromise();
    const subscription = {
      handleRows: rows => setState({
        state: "success",
        rows: rows
      }),
      handleErr: err => setState(s => ({
        state: "error",
        error: new Error(err),
        rows: s.rows
      }))
    };
    sqlsync().subscribe(docId(), docType(), query, subscription).then(unsubResolve).catch(err => {
      console.error("sqlsync: error subscribing", err);
      setState({
        state: "error",
        error: err
      });
    });
    onCleanup(() => {
      unsubPromise.then(unsub => unsub()).catch(err => {
        console.error("sqlsync: error unsubscribing", err);
      });
    });
  });
  return state;
}
const useConnectionStatus = () => {
  const sqlsync = useSQLSync();
  const [status, setStatus] = createSignal(sqlsync().connectionStatus);
  createEffect(() => {
    const cleanup = sqlsync().addConnectionStatusListener(setStatus);
    onCleanup(cleanup);
  });
  return status;
};

export { SQLSyncProvider, createDocHooks, useConnectionStatus };
//# sourceMappingURL=index.js.map