@rocicorp/zero 0.0.0-202410031711

package/out/replicache/src/replicache-impl.d.ts

@@ -0,0 +1,321 @@
+import { LogContext } from '@rocicorp/logger';
+import type { MaybePromise } from '../../shared/src/types.js';
+import { type Cookie } from './cookies.js';
+import { LazyStore } from './dag/lazy-store.js';
+import { type Store } from './dag/store.js';
+import { type Hash } from './hash.js';
+import { type PendingMutation } from './pending-mutations.js';
+import { type ClientMap } from './persist/clients.js';
+import type { Puller } from './puller.js';
+import { type Pusher } from './pusher.js';
+import type { ReplicacheOptions } from './replicache-options.js';
+import { type SubscribeOptions, type SubscriptionsManager, type WatchCallbackForOptions, type WatchNoIndexCallback, type WatchOptions } from './subscriptions.js';
+import type { ReadTransaction } from './transactions.js';
+import type { BeginPullResult, MakeMutators, MutatorDefs, PokeInternal, QueryInternal, RequestOptions, UpdateNeededReason } from './types.js';
+/** @deprecated Not used any more */
+export interface MakeSubscriptionsManager {
+    (queryInternal: QueryInternal, lc: LogContext): SubscriptionsManager;
+}
+export interface ReplicacheImplOptions {
+    /**
+     * Defaults to true.
+     */
+    enableMutationRecovery?: boolean | undefined;
+    /**
+     * Defaults to true.
+     */
+    enableScheduledPersist?: boolean | undefined;
+    /**
+     * Defaults to true.
+     */
+    enableScheduledRefresh?: boolean | undefined;
+    /**
+     * Defaults to true.
+     */
+    enablePullAndPushInOpen?: boolean | undefined;
+    /**
+     * @deprecated Not used anymore.
+     */
+    makeSubscriptionsManager?: unknown;
+    /**
+     * Default is `true`.  If `false` if an exact match client group
+     * is not found, a new client group is always made instead of forking
+     * from an existing client group.
+     */
+    enableClientGroupForking?: boolean | undefined;
+}
+export declare class ReplicacheImpl<MD extends MutatorDefs = {}> {
+    #private;
+    /** The URL to use when doing a pull request. */
+    pullURL: string;
+    /** The URL to use when doing a push request. */
+    pushURL: string;
+    /** The authorization token used when doing a push request. */
+    auth: string;
+    /** The name of the Replicache database. Populated by {@link ReplicacheOptions#name}. */
+    readonly name: string;
+    readonly subscriptions: SubscriptionsManager;
+    /**
+     * Client groups gets disabled when the server does not know about it.
+     * A disabled client group prevents the client from pushing and pulling.
+     */
+    isClientGroupDisabled: boolean;
+    lastMutationID: number;
+    /**
+     * This is the name Replicache uses for the IndexedDB database where data is
+     * stored.
+     */
+    get idbName(): string;
+    /** The schema version of the data understood by this application. */
+    readonly schemaVersion: string;
+    /**
+     * The mutators that was registered in the constructor.
+     */
+    readonly mutate: MakeMutators<MD>;
+    /**
+     * The duration between each periodic {@link pull}. Setting this to `null`
+     * disables periodic pull completely. Pull will still happen if you call
+     * {@link pull} manually.
+     */
+    pullInterval: number | null;
+    /**
+     * The delay between when a change is made to Replicache and when Replicache
+     * attempts to push that change.
+     */
+    pushDelay: number;
+    /**
+     * The function to use to pull data from the server.
+     */
+    puller: Puller;
+    /**
+     * The function to use to push data to the server.
+     */
+    pusher: Pusher;
+    readonly memdag: LazyStore;
+    readonly perdag: Store;
+    /**
+     * The options used to control the {@link pull} and push request behavior. This
+     * object is live so changes to it will affect the next pull or push call.
+     */
+    get requestOptions(): Required<RequestOptions>;
+    /**
+     * `onSync(true)` is called when Replicache transitions from no push or pull
+     * happening to at least one happening. `onSync(false)` is called in the
+     * opposite case: when Replicache transitions from at least one push or pull
+     * happening to none happening.
+     *
+     * This can be used in a React like app by doing something like the following:
+     *
+     * ```js
+     * const [syncing, setSyncing] = useState(false);
+     * useEffect(() => {
+     *   rep.onSync = setSyncing;
+     * }, [rep]);
+     * ```
+     */
+    onSync: ((syncing: boolean) => void) | null;
+    /**
+     * `onClientStateNotFound` is called when the persistent client has been
+     * garbage collected. This can happen if the client has no pending mutations
+     * and has not been used for a while.
+     *
+     * The default behavior is to reload the page (using `location.reload()`). Set
+     * this to `null` or provide your own function to prevent the page from
+     * reloading automatically.
+     */
+    onClientStateNotFound: (() => void) | null;
+    /**
+     * `onUpdateNeeded` is called when a code update is needed.
+     *
+     * A code update can be needed because:
+     * - the server no longer supports the {@link pushVersion},
+     *   {@link pullVersion} or {@link schemaVersion} of the current code.
+     * - a new Replicache client has created a new client group, because its code
+     *   has different mutators, indexes, schema version and/or format version
+     *   from this Replicache client. This is likely due to the new client having
+     *   newer code. A code update is needed to be able to locally sync with this
+     *   new Replicache client (i.e. to sync while offline, the clients can still
+     *   sync with each other via the server).
+     *
+     * The default behavior is to reload the page (using `location.reload()`). Set
+     * this to `null` or provide your own function to prevent the page from
+     * reloading automatically. You may want to provide your own function to
+     * display a toast to inform the end user there is a new version of your app
+     * available and prompting them to refresh.
+     */
+    onUpdateNeeded: ((reason: UpdateNeededReason) => void) | null;
+    /**
+     * This gets called when we get an HTTP unauthorized (401) response from the
+     * push or pull endpoint. Set this to a function that will ask your user to
+     * reauthenticate.
+     */
+    getAuth: (() => MaybePromise<string | null | undefined>) | null | undefined;
+    onPushInvoked: () => undefined;
+    onBeginPull: () => undefined;
+    onRecoverMutations: (r: Promise<boolean>) => Promise<boolean>;
+    constructor(options: ReplicacheOptions<MD>, implOptions?: ReplicacheImplOptions);
+    /**
+     * The browser profile ID for this browser profile. Every instance of Replicache
+     * browser-profile-wide shares the same profile ID.
+     */
+    get profileID(): Promise<string>;
+    /**
+     * The client ID for this instance of Replicache. Each instance of Replicache
+     * gets a unique client ID.
+     */
+    get clientID(): string;
+    /**
+     * The client group ID for this instance of Replicache. Instances of
+     * Replicache will have the same client group ID if and only if they have
+     * the same name, mutators, indexes, schema version, format version, and
+     * browser profile.
+     */
+    get clientGroupID(): Promise<string>;
+    /**
+     * `onOnlineChange` is called when the {@link online} property changes. See
+     * {@link online} for more details.
+     */
+    onOnlineChange: ((online: boolean) => void) | null;
+    /**
+     * A rough heuristic for whether the client is currently online. Note that
+     * there is no way to know for certain whether a client is online - the next
+     * request can always fail. This property returns true if the last sync attempt succeeded,
+     * and false otherwise.
+     */
+    get online(): boolean;
+    /**
+     * Whether the Replicache database has been closed. Once Replicache has been
+     * closed it no longer syncs and you can no longer read or write data out of
+     * it. After it has been closed it is pretty much useless and should not be
+     * used any more.
+     */
+    get closed(): boolean;
+    /**
+     * Closes this Replicache instance.
+     *
+     * When closed all subscriptions end and no more read or writes are allowed.
+     */
+    close(): Promise<void>;
+    maybeEndPull(syncHead: Hash, requestID: string): Promise<void>;
+    /**
+     * Push pushes pending changes to the {@link pushURL}.
+     *
+     * You do not usually need to manually call push. If {@link pushDelay} is
+     * non-zero (which it is by default) pushes happen automatically shortly after
+     * mutations.
+     *
+     * If the server endpoint fails push will be continuously retried with an
+     * exponential backoff.
+     *
+     * @param [now=false] If true, push will happen immediately and ignore
+     *   {@link pushDelay}, {@link RequestOptions.minDelayMs} as well as the
+     *   exponential backoff in case of errors.
+     * @returns A promise that resolves when the next push completes. In case of
+     * errors the first error will reject the returned promise. Subsequent errors
+     * will not be reflected in the promise.
+     */
+    push({ now }?: {
+        now?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     * Pull pulls changes from the {@link pullURL}. If there are any changes local
+     * changes will get replayed on top of the new server state.
+     *
+     * If the server endpoint fails pull will be continuously retried with an
+     * exponential backoff.
+     *
+     * @param [now=false] If true, pull will happen immediately and ignore
+     *   {@link RequestOptions.minDelayMs} as well as the exponential backoff in
+     *   case of errors.
+     * @returns A promise that resolves when the next pull completes. In case of
+     * errors the first error will reject the returned promise. Subsequent errors
+     * will not be reflected in the promise.
+     */
+    pull({ now }?: {
+        now?: boolean | undefined;
+    }): Promise<void>;
+    /**
+     * Applies an update from the server to Replicache.
+     * Throws an error if cookie does not match. In that case the server thinks
+     * this client has a different cookie than it does; the caller should disconnect
+     * from the server and re-register, which transmits the cookie the client actually
+     * has.
+     *
+     * @experimental This method is under development and its semantics will change.
+     */
+    poke(poke: PokeInternal): Promise<void>;
+    beginPull(): Promise<BeginPullResult>;
+    persist(): Promise<void>;
+    refresh(): Promise<void>;
+    disableClientGroup(): Promise<void>;
+    /**
+     * Subscribe to the result of a {@link query}. The `body` function is
+     * evaluated once and its results are returned via `onData`.
+     *
+     * Thereafter, each time the the result of `body` changes, `onData` is fired
+     * again with the new result.
+     *
+     * `subscribe()` goes to significant effort to avoid extraneous work
+     * re-evaluating subscriptions:
+     *
+     * 1. subscribe tracks the keys that `body` accesses each time it runs. `body`
+     *    is only re-evaluated when those keys change.
+     * 2. subscribe only re-fires `onData` in the case that a result changes by
+     *    way of the `isEqual` option which defaults to doing a deep JSON value
+     *    equality check.
+     *
+     * Because of (1), `body` must be a pure function of the data in Replicache.
+     * `body` must not access anything other than the `tx` parameter passed to it.
+     *
+     * Although subscribe is as efficient as it can be, it is somewhat constrained
+     * by the goal of returning an arbitrary computation of the cache. For even
+     * better performance (but worse dx), see {@link experimentalWatch}.
+     *
+     * If an error occurs in the `body` the `onError` function is called if
+     * present. Otherwise, the error is logged at log level 'error'.
+     *
+     * To cancel the subscription, call the returned function.
+     *
+     * @param body The function to evaluate to get the value to pass into
+     *    `onData`.
+     * @param options Options is either a function or an object. If it is a
+     *    function it is equivalent to passing it as the `onData` property of an
+     *    object.
+     */
+    subscribe<R>(body: (tx: ReadTransaction) => Promise<R>, options: SubscribeOptions<R> | ((result: R) => void)): () => void;
+    /**
+     * Watches Replicache for changes.
+     *
+     * The `callback` gets called whenever the underlying data changes and the
+     * `key` changes matches the `prefix` of {@link ExperimentalWatchIndexOptions} or
+     * {@link ExperimentalWatchNoIndexOptions} if present. If a change
+     * occurs to the data but the change does not impact the key space the
+     * callback is not called. In other words, the callback is never called with
+     * an empty diff.
+     *
+     * This gets called after commit (a mutation or a rebase).
+     *
+     * @experimental This method is under development and its semantics will
+     * change.
+     */
+    experimentalWatch(callback: WatchNoIndexCallback): () => void;
+    experimentalWatch<Options extends WatchOptions>(callback: WatchCallbackForOptions<Options>, options?: Options): () => void;
+    /**
+     * Query is used for read transactions. It is recommended to use transactions
+     * to ensure you get a consistent view across multiple calls to `get`, `has`
+     * and `scan`.
+     */
+    query<R>(body: (tx: ReadTransaction) => Promise<R> | R): Promise<R>;
+    get cookie(): Promise<Cookie>;
+    recoverMutations(preReadClientMap?: ClientMap): Promise<boolean>;
+    /**
+     * List of pending mutations. The order of this is from oldest to newest.
+     *
+     * Gives a list of local mutations that have `mutationID` >
+     * `syncHead.mutationID` that exists on the main client group.
+     *
+     * @experimental This method is experimental and may change in the future.
+     */
+    experimentalPendingMutations(): Promise<readonly PendingMutation[]>;
+}
+//# sourceMappingURL=replicache-impl.d.ts.map

package/out/replicache/src/replicache-impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicache-impl.d.ts","sourceRoot":"","sources":["../../../../replicache/src/replicache-impl.ts"],"names":[],"mappings":"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"}

package/out/replicache/src/replicache-options.d.ts

@@ -0,0 +1,209 @@
+import type { LogLevel, LogSink } from '@rocicorp/logger';
+import type { IndexDefinitions } from './index-defs.js';
+import type { StoreProvider } from './kv/store.js';
+import type { Puller } from './puller.js';
+import type { Pusher } from './pusher.js';
+import type { MutatorDefs, RequestOptions } from './types.js';
+/**
+ * The options passed to {@link Replicache}.
+ */
+export interface ReplicacheOptions<MD extends MutatorDefs> {
+    /**
+     * This is the URL to the server endpoint dealing with the push updates. See
+     * [Push Endpoint Reference](https://doc.replicache.dev/reference/server-push) for more
+     * details.
+     *
+     * If not provided, push requests will not be made unless a custom
+     * {@link ReplicacheOptions.pusher} is provided.
+     */
+    pushURL?: string | undefined;
+    /**
+     * This is the authorization token used when doing a
+     * [pull](https://doc.replicache.dev/reference/server-pull#authorization) and
+     * [push](https://doc.replicache.dev/reference/server-push#authorization).
+     */
+    auth?: string | undefined;
+    /**
+     * This is the URL to the server endpoint dealing with pull. See [Pull
+     * Endpoint Reference](https://doc.replicache.dev/reference/server-pull) for more
+     * details.
+     *
+     * If not provided, pull requests will not be made unless a custom
+     * {@link ReplicacheOptions.puller} is provided.
+     */
+    pullURL?: string | undefined;
+    /**
+     * The name of the Replicache database.
+     *
+     * It is important to use user specific names so that if there are multiple
+     * tabs open for different distinct users their data is kept separate.
+     *
+     * For efficiency and performance, a new {@link Replicache} instance will
+     * initialize its state from the persisted state of an existing {@link Replicache}
+     * instance with the same `name`, domain and browser profile.
+     *
+     * Mutations from one {@link Replicache} instance may be pushed using the
+     * {@link ReplicacheOptions.auth}, {@link ReplicacheOptions.pushURL},
+     * {@link ReplicacheOptions.pullURL}, {@link ReplicacheOptions.pusher}, and
+     * {@link ReplicacheOptions.puller}  of another Replicache instance with the same
+     * `name`, domain and browser profile.
+     *
+     * You can use multiple Replicache instances for the same user as long as the
+     * names are unique.  e.g. `name: `$userID:$roomID`
+     */
+    name: string;
+    /**
+     * The schema version of the data understood by this application. This enables
+     * versioning of mutators (in the push direction) and the client view (in the
+     * pull direction).
+     */
+    schemaVersion?: string | undefined;
+    /**
+     * The duration between each {@link pull} in milliseconds. Set this to `null` to
+     * prevent pulling in the background.  Defaults to 60 seconds.
+     */
+    pullInterval?: number | null | undefined;
+    /**
+     * The delay between when a change is made to Replicache and when Replicache
+     * attempts to push that change.
+     */
+    pushDelay?: number | undefined;
+    /**
+     * Determines how much logging to do. When this is set to `'debug'`,
+     * Replicache will also log `'info'` and `'error'` messages. When set to
+     * `'info'` we log `'info'` and `'error'` but not `'debug'`. When set to
+     * `'error'` we only log `'error'` messages.
+     * Default is `'info'`.
+     */
+    logLevel?: LogLevel | undefined;
+    /**
+     * Enables custom handling of logs.
+     *
+     * By default logs are logged to the console.  If you would like logs to be
+     * sent elsewhere (e.g. to a cloud logging service like DataDog) you can
+     * provide an array of {@link LogSink}s.  Logs at or above
+     * {@link ReplicacheOptions.logLevel} are sent to each of these {@link LogSink}s.
+     * If you would still like logs to go to the console, include
+     * `consoleLogSink` in the array.
+     *
+     * ```ts
+     * logSinks: [consoleLogSink, myCloudLogSink],
+     * ```
+     */
+    logSinks?: LogSink[] | undefined;
+    /**
+     * An object used as a map to define the *mutators*. These gets registered at
+     * startup of {@link Replicache}.
+     *
+     * *Mutators* are used to make changes to the data.
+     *
+     * #### Example
+     *
+     * The registered *mutations* are reflected on the
+     * {@link Replicache.mutate | mutate} property of the {@link Replicache} instance.
+     *
+     * ```ts
+     * const rep = new Replicache({
+     *   name: 'user-id',
+     *   mutators: {
+     *     async createTodo(tx: WriteTransaction, args: JSONValue) {
+     *       const key = `/todo/${args.id}`;
+     *       if (await tx.has(key)) {
+     *         throw new Error('Todo already exists');
+     *       }
+     *       await tx.set(key, args);
+     *     },
+     *     async deleteTodo(tx: WriteTransaction, id: number) {
+     *       ...
+     *     },
+     *   },
+     * });
+     * ```
+     *
+     * This will create the function to later use:
+     *
+     * ```ts
+     * await rep.mutate.createTodo({
+     *   id: 1234,
+     *   title: 'Make things work offline',
+     *   complete: true,
+     * });
+     * ```
+     *
+     * #### Replays
+     *
+     * *Mutators* run once when they are initially invoked, but they might also be
+     * *replayed* multiple times during sync. As such *mutators* should not modify
+     * application state directly. Also, it is important that the set of
+     * registered mutator names only grows over time. If Replicache syncs and
+     * needed *mutator* is not registered, it will substitute a no-op mutator, but
+     * this might be a poor user experience.
+     *
+     * #### Server application
+     *
+     * During push, a description of each mutation is sent to the server's [push
+     * endpoint](https://doc.replicache.dev/reference/server-push) where it is applied. Once
+     * the *mutation* has been applied successfully, as indicated by the client
+     * view's
+     * [`lastMutationId`](https://doc.replicache.dev/reference/server-pull#lastmutationid)
+     * field, the local version of the *mutation* is removed. See the [design
+     * doc](https://doc.replicache.dev/design#commits) for additional details on
+     * the sync protocol.
+     *
+     * #### Transactionality
+     *
+     * *Mutators* are atomic: all their changes are applied together, or none are.
+     * Throwing an exception aborts the transaction. Otherwise, it is committed.
+     * As with {@link query} and {@link subscribe} all reads will see a consistent view of
+     * the cache while they run.
+     */
+    mutators?: MD | undefined;
+    /**
+     * Options to use when doing pull and push requests.
+     */
+    requestOptions?: RequestOptions | undefined;
+    /**
+     * Allows passing in a custom implementation of a {@link Puller} function. This
+     * function is called when doing a pull and it is responsible for
+     * communicating with the server.
+     *
+     * Normally, this is just a POST to a URL with a JSON body but you can provide
+     * your own function if you need to do things differently.
+     */
+    puller?: Puller | undefined;
+    /**
+     * Allows passing in a custom implementation of a {@link Pusher} function. This
+     * function is called when doing a push and it is responsible for
+     * communicating with the server.
+     *
+     * Normally, this is just a POST to a URL with a JSON body but you can provide
+     * your own function if you need to do things differently.
+     */
+    pusher?: Pusher | undefined;
+    /**
+     * @deprecated Replicache no longer uses a license key. This option is now
+     * ignored and will be removed in a future release.
+     */
+    licenseKey?: string | undefined;
+    /**
+     * Allows providing a custom implementation of the underlying storage layer.
+     */
+    kvStore?: 'mem' | 'idb' | StoreProvider | undefined;
+    /**
+     * Defines the indexes, if any, to use on the data.
+     */
+    readonly indexes?: IndexDefinitions | undefined;
+    /**
+     * The maximum age of a client in milliseconds. If a client hasn't been seen
+     * and has no pending mutations for this long, it will be removed from the
+     * cache. Default is 24 hours.
+     *
+     * This means that this is the maximum time a tab can be in the background
+     * (frozen or in fbcache) and still be able to sync when it comes back to the
+     * foreground. If tab comes back after this time the
+     * {@linkcode onClientStateNotFound} callback is called on the Replicache
+     * instance.
+     */
+    clientMaxAgeMs?: number | undefined;
+}
+//# sourceMappingURL=replicache-options.d.ts.map

package/out/replicache/src/replicache-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicache-options.d.ts","sourceRoot":"","sources":["../../../../replicache/src/replicache-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,OAAO,EAAC,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,WAAW,EAAE,cAAc,EAAC,MAAM,YAAY,CAAC;AAE5D;;GAEG;AAEH,MAAM,WAAW,iBAAiB,CAAC,EAAE,SAAS,WAAW;IACvD;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1B;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B;;;;;;;;;;;;;;;;;;OAkBG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEnC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAEzC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE/B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAEhC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiEG;IACH,QAAQ,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;IAE1B;;OAEG;IACH,cAAc,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAE5C;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE5B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE5B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEhC;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,aAAa,GAAG,SAAS,CAAC;IAEpD;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAEhD;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC"}