@verdant-web/server 3.0.0-next.0 → 3.0.0

package/dist/esm/ClientConnection.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { ServerMessage } from '@verdant-web/common';
+import { IncomingMessage, ServerResponse } from 'http';
+import { WebSocket } from 'ws';
+import { TokenInfo } from './TokenVerifier.js';
+export declare class ClientConnectionManager {
+    private readonly connections;
+    private getLibraryConnections;
+    addSocket: (libraryId: string, key: string, socket: WebSocket, info: TokenInfo) => void;
+    addRequest: (libraryId: string, key: string, request: IncomingMessage, response: ServerResponse, info: TokenInfo) => () => void;
+    addFetch: (libraryId: string, key: string, req: Request, info: TokenInfo) => (() => Response);
+    remove: (libraryId: string, key: string) => void;
+    respond: (libraryId: string, key: string, message: ServerMessage) => void;
+    /**
+     * Broadcasts a message to all live-connected clients in a library.
+     * This does not reach push/pull clients.
+     */
+    broadcast: (libraryId: string, message: ServerMessage, omitKeys?: string[]) => void;
+    disconnectAll: (libraryId: string) => void;
+}

package/dist/esm/MessageSender.d.ts

@@ -0,0 +1,5 @@
+import { ServerMessage } from '@verdant-web/common';
+export interface MessageSender {
+    broadcast(libraryId: string, message: ServerMessage, omitKeys?: string[]): void;
+    send(libraryId: string, clientKey: string, message: ServerMessage): void;
+}

package/dist/esm/Presence.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import { UserInfo } from '@verdant-web/common';
+import EventEmitter from 'events';
+/**
+ * Stores client presence in-memory for connected
+ * clients
+ */
+export declare class Presence extends EventEmitter {
+    private presences;
+    private getLibrary;
+    set: (libraryId: string, userId: string, presence: UserInfo<any, any>) => void;
+    removeReplica: (libraryId: string, replicaId: string) => void;
+    all: (libraryId: string) => Record<string, UserInfo<any, any>>;
+    clear: (libraryId: string) => void;
+}

package/dist/esm/Profiles.d.ts

@@ -0,0 +1,10 @@
+export interface UserProfiles<Profile> {
+    get(userId: string): Promise<Profile>;
+}
+export declare class UserProfileLoader<Profile> {
+    private source;
+    private cache;
+    constructor(source: UserProfiles<Profile>);
+    get: (userId: string) => Promise<Profile>;
+    evict: (userId: string) => void;
+}

package/dist/esm/ReplicaKeepaliveTimers.d.ts

@@ -0,0 +1,17 @@
+import { EventSubscriber } from '@verdant-web/common';
+/**
+ * A set of timers per-replica which are
+ * refreshed whenever the replica sends
+ * a message to the server. If a timer expires,
+ * the replica is removed from presence. This
+ * is a failsafe for socket-based replicas but
+ * essential for pull-based replicas.
+ */
+export declare class ReplicaKeepaliveTimers extends EventSubscriber<{
+    lost: (libraryId: string, replicaId: string) => void;
+}> {
+    private timeout;
+    private timers;
+    constructor(timeout?: number);
+    refresh: (libraryId: string, replicaId: string) => void;
+}

package/dist/esm/Server.d.ts

@@ -0,0 +1,171 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { DocumentBaseline, Operation, ServerMessage } from '@verdant-web/common';
+import EventEmitter from 'events';
+import { Server as HttpServer, IncomingMessage, ServerResponse } from 'http';
+import internal from 'stream';
+import { FileStorage } from './files/FileStorage.js';
+import { MessageSender } from './MessageSender.js';
+import { UserProfiles } from './Profiles.js';
+import { TokenInfo } from './TokenVerifier.js';
+import { StorageFactory } from './storage/Storage.js';
+export interface ServerOptions {
+    /**
+     * Attach to a pre-existing HTTP server. Provide this if you have another server,
+     * like an Express server, that you want to add lofi to. If provided, you don't
+     * need to call .listen()
+     */
+    httpServer?: HttpServer;
+    /**
+     * The secret value used to generate tokens from your authentication endpoint.
+     * Used to verify and decode user identity and library access on connection.
+     */
+    tokenSecret: string;
+    /**
+     * Your storage implementation. See the sqlStorage export for a built-in
+     * option.
+     */
+    storage: StorageFactory;
+    /**
+     * Optionally provide an implementation of the UserProfiles interface to look up
+     * static user profile data to use in persistence. This data is considered trusted
+     * and can be used to identify users with information like name or profile image.
+     */
+    profiles?: UserProfiles<any>;
+    /**
+     * How many minutes of inactivity before a replica is considered truant and
+     * removed from the library. Defaults to 30 days.
+     */
+    replicaTruancyMinutes?: number;
+    /**
+     * Supply a logging function to log debug messages.
+     */
+    log?: (...args: any[]) => void;
+    /**
+     * Disable history compaction. Storage usage will grow indefinitely. Not recommended.
+     */
+    disableRebasing?: boolean;
+    /**
+     * Provide a FileStorage backend to accept file uploads. Without a file backend,
+     * users will not be able to synchronize files, and all files added on peer replicas
+     * will be forever unavailable.
+     *
+     * A default, filesystem-backed FileStorage implementation is provided as an export
+     * of this library.
+     */
+    fileStorage?: FileStorage;
+    fileConfig?: {
+        deleteExpirationDays?: number;
+    };
+}
+export interface ServerEvents {
+    error: (err: any) => void;
+    warning: (msg: string, ...args: any[]) => void;
+    changes: (info: Omit<TokenInfo, 'token'>, operations: Operation[], baselines: DocumentBaseline[]) => void;
+    request: (info: TokenInfo) => void;
+    'socket-close': (info: TokenInfo) => void;
+    'socket-connection': (info: TokenInfo) => void;
+}
+export declare interface Server {
+    on<Event extends keyof ServerEvents>(ev: Event, cb: ServerEvents[Event]): this;
+    off<Event extends keyof ServerEvents>(ev: Event, cb: ServerEvents[Event]): this;
+    emit<Event extends keyof ServerEvents>(ev: Event, ...args: Parameters<ServerEvents[Event]>): boolean;
+}
+export declare class Server extends EventEmitter implements MessageSender {
+    private httpServer;
+    private wss;
+    private fileStorage?;
+    private storage;
+    private library;
+    private clientConnections;
+    private keepalives;
+    private tokenVerifier;
+    private connectionToReplicaIdMap;
+    private log;
+    private __testMode;
+    constructor(options: ServerOptions);
+    /**
+     * Attaches the Verdant server to an HttpServer instance, which
+     * allows it to handle requests and websockets required for the
+     * Verdant protocol.
+     *
+     * You can pass httpPath = false if you want to handle HTTP requests
+     * yourself, and this will only attach the websocket handling.
+     */
+    attach: (server: HttpServer, options?: {
+        httpPath?: string | false;
+    }) => void;
+    /**
+     * Handles an HTTP upgrade request to a websocket connection.
+     */
+    handleUpgrade: (req: IncomingMessage, socket: internal.Duplex, head: Buffer) => Promise<void>;
+    private authorizeRequest;
+    private getRequestToken;
+    private createInternalRequestHandler;
+    /**
+     * Handles an HTTP request from a verdant client.
+     */
+    handleRequest: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    /**
+     * Handles a "fetch" style request. Complement to handleRequest, for servers
+     * that use Request/Response style handlers.
+     */
+    handleFetch: (req: Request) => Promise<Response>;
+    private handleRequestBody;
+    private writeErrorResponse;
+    private getErrorResponse;
+    /**
+     * Handles a multipart upload of a file from a verdant client. The upload
+     * will include parameters for the file's ID, name, and type. The request
+     * must be authenticated with a token to tie it to a library.
+     */
+    handleFileRequest: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    /**
+     * Handles a "fetch" style file request. Complement to handleFileRequest,
+     * for servers that use Request/Response style handlers.
+     */
+    handleFileFetch: (req: Request) => Promise<Response>;
+    private getFileStorageOrThrow;
+    private streamIncomingFile;
+    private getFileData;
+    broadcast: (libraryId: string, message: ServerMessage, omitKeys?: string[]) => void;
+    send: (libraryId: string, key: string, message: ServerMessage) => void;
+    private handleMessage;
+    private handleConnection;
+    listen: (handle: any, listeningListener?: (() => void) | undefined) => void;
+    close: () => Promise<void>;
+    /**
+     * Completely remove a library from the server.
+     * This will remove all data associated with the library.
+     * Use it very carefully! Data will still be stored on user
+     * devices, so this is not as scary as it sounds - the next time
+     * any replica connects, it will repopulate the library. But
+     * you should still be careful.
+     */
+    evictLibrary: (libraryId: string) => void;
+    /**
+     * Returns currently connected replica info for a library
+     */
+    getLibraryPresence: (libraryId: string) => Record<string, import("@verdant-web/common").UserInfo<any, any>>;
+    /**
+     * Returns helpful information about a library.
+     * This is currently only the known replicas and some
+     * more low-level metadata.
+     */
+    getLibraryInfo: (libraryId: string) => Promise<import("./types.js").LibraryInfo | null>;
+    /**
+     * Removes all replicas associated with a User ID from
+     * the server. Consistency algorithms will no longer wait on these
+     * replicas before confirming and squashing changes.
+     */
+    evictUser: (libraryId: string, userId: string) => void;
+    /**
+     * Retrieves a snapshot of the full document contents at this time.
+     * Useful for capturing the shape of data for static usage outside
+     * of the live system.
+     */
+    getDocumentSnapshot: (libraryId: string, collection: string, documentId: string) => Promise<any>;
+}

package/dist/esm/ServerLibrary.d.ts

@@ -0,0 +1,58 @@
+import { ClientMessage, DocumentBaseline, EventSubscriber, Operation } from '@verdant-web/common';
+import { MessageSender } from './MessageSender.js';
+import { UserProfileLoader } from './Profiles.js';
+import { TokenInfo } from './TokenVerifier.js';
+import { FileStorage } from './files/FileStorage.js';
+import { Storage } from './storage/Storage.js';
+import { LibraryInfo } from './types.js';
+export type ServerLibraryEvents = {
+    changes: (info: TokenInfo, operations: Operation[], baselines: DocumentBaseline[]) => void;
+};
+export declare class ServerLibrary extends EventSubscriber<ServerLibraryEvents> {
+    private storage;
+    private sender;
+    private profiles;
+    private presences;
+    private disableRebasing;
+    private fileStorage;
+    private log;
+    constructor({ storage, sender, profiles, log, disableRebasing, fileStorage, }: {
+        storage: Storage;
+        sender: MessageSender;
+        profiles: UserProfileLoader<any>;
+        log?: (...args: any[]) => void;
+        disableRebasing?: boolean;
+        fileStorage?: FileStorage;
+    });
+    /**
+     * Validates a user's access to a replica. If the replica does not
+     * exist, a user may create it. But if it does exist, its user (clientId)
+     * must match the user making the request.
+     */
+    private validateReplicaAccess;
+    private hasWriteAccess;
+    receive: (message: ClientMessage, clientKey: string, info: TokenInfo) => Promise<void>;
+    remove: (libraryId: string, replicaId: string) => void;
+    private handleOperation;
+    private rebroadcastOperations;
+    private handleSync;
+    private createAckNonce;
+    private handleAck;
+    private updateHighwater;
+    private pendingRebaseTimeout;
+    private enqueueRebase;
+    private rebase;
+    private handleHeartbeat;
+    private handlePresenceUpdate;
+    private onPresenceLost;
+    destroy: (libraryId: string) => Promise<void>;
+    getPresence: (libraryId: string) => Record<string, import("@verdant-web/common").UserInfo<any, any>>;
+    getInfo: (libraryId: string) => Promise<LibraryInfo | null>;
+    evictUser: (libraryId: string, userId: string) => Promise<void>;
+    getDocumentSnapshot: (libraryId: string, oid: string) => Promise<any>;
+    private getObjectSnapshot;
+    private hydrateObject;
+    private hydrateFile;
+    private removeBaselineExtras;
+    private removeOperationExtras;
+}

package/dist/esm/ServerLibrary.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/TokenProvider.d.ts

@@ -0,0 +1,19 @@
+import { ReplicaType } from '@verdant-web/common';
+export declare class TokenProvider {
+    private config;
+    constructor(config: {
+        secret: string;
+    });
+    getToken: ({ userId, libraryId, syncEndpoint, role, type, expiresIn, fileEndpoint, }: {
+        userId: string;
+        libraryId: string;
+        syncEndpoint: string;
+        fileEndpoint?: string | undefined;
+        role?: string | undefined;
+        type?: ReplicaType | undefined;
+        /**
+         * The time when the token will expire. A string in the format of "3d" or a number of seconds.
+         */
+        expiresIn?: string | number | undefined;
+    }) => string;
+}

package/dist/esm/TokenVerifier.d.ts

@@ -0,0 +1,16 @@
+import { ReplicaType } from '@verdant-web/common';
+export declare class TokenVerifier {
+    private config;
+    constructor(config: {
+        secret: string;
+    });
+    verifyToken: (token: string) => TokenInfo;
+}
+export interface TokenInfo {
+    userId: string;
+    libraryId: string;
+    syncEndpoint: string;
+    role?: string;
+    type: ReplicaType;
+    token: string;
+}

package/dist/esm/files/FileStorage.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Readable } from 'stream';
+export interface FileInfo {
+    fileName: string;
+    id: string;
+    libraryId: string;
+    type: string;
+}
+/**
+ * The interface for implementing a file storage backend.
+ * verdant will supply file Blobs and metadata, and the storage backend
+ * must store them somewhere.
+ *
+ * The storage backend must also provide a way to get a URL for the file,
+ * even if the file is not yet uploaded, based on its metadata.
+ */
+export interface FileStorage {
+    put(fileStream: Readable, data: FileInfo): Promise<void>;
+    getUrl(data: FileInfo): string | Promise<string>;
+    delete(data: FileInfo): Promise<void>;
+}
+export declare class LocalFileStorage implements FileStorage {
+    private readonly host;
+    private readonly rootDirectory;
+    constructor({ rootDirectory, host, }: {
+        rootDirectory: string;
+        host: string;
+    });
+    private prepareHost;
+    put(fileStream: Readable, data: FileInfo): Promise<void>;
+    getUrl(data: FileInfo): string;
+    delete(data: FileInfo): Promise<void>;
+    private getPath;
+    private getStorageLocation;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,10 @@
+export type { MessageSender } from './MessageSender.js';
+export type { UserProfiles } from './Profiles.js';
+export type { ClientMessage, ServerMessage } from '@verdant-web/common';
+export { ReplicaType } from '@verdant-web/common';
+export { Server } from './Server.js';
+export { TokenProvider } from './TokenProvider.js';
+export { LocalFileStorage } from './files/FileStorage.js';
+export type { FileStorage, FileInfo } from './files/FileStorage.js';
+export type { TokenInfo } from './TokenVerifier.js';
+export type { LibraryInfo } from './types.js';

package/dist/esm/storage/Storage.d.ts

@@ -0,0 +1,67 @@
+import { DocumentBaseline, Operation, Ref, ReplicaType } from '@verdant-web/common';
+import { HydratedDocumentBaseline, StoredOperation, StoredReplicaInfo, FileMetadata } from '../types.js';
+import { FileInfo } from '../files/FileStorage.js';
+export interface ReplicaStorage {
+    readonly truantCutoff: number;
+    get(libraryId: string, replicaId: string): Promise<StoredReplicaInfo | null>;
+    getOrCreate(libraryId: string, replicaId: string, info: {
+        userId: string;
+        type: ReplicaType;
+    }): Promise<{
+        status: 'new' | 'existing' | 'truant';
+        replicaInfo: StoredReplicaInfo;
+    }>;
+    getAll(libraryId: string, options?: {
+        omitTruant: boolean;
+    }): Promise<StoredReplicaInfo[]>;
+    updateLastSeen(libraryId: string, replicaId: string): Promise<void>;
+    updateAckedServerOrder(libraryId: string, replicaId: string, serverOrder: number): Promise<void>;
+    updateAcknowledgedLogicalTime(libraryId: string, replicaId: string, timestamp: string): Promise<void>;
+    getEarliestAckedServerOrder(libraryId: string): Promise<number>;
+    acknowledgeOperation(libraryId: string, replicaId: string, timestamp: string): Promise<void>;
+    getGlobalAck(libraryId: string, onlineReplicaIds?: string[]): Promise<string | null>;
+    delete(libraryId: string, replicaId: string): Promise<void>;
+    deleteAll(libraryId: string): Promise<void>;
+    deleteAllForUser(libraryId: string, userId: string): Promise<void>;
+}
+export interface OperationStorage {
+    getAll(libraryId: string, oid: string): Promise<StoredOperation[]>;
+    getBeforeServerOrder(libraryId: string, beforeServerOrder: number): Promise<StoredOperation[]>;
+    getAfterServerOrder(libraryId: string, afterServerOrder: number): Promise<StoredOperation[]>;
+    getLatestServerOrder(libraryId: string): Promise<number>;
+    getCount(libraryId: string): Promise<number>;
+    insertAll(libraryId: string, replicaId: string, operations: Operation[]): Promise<void>;
+    deleteAll(libraryId: string): Promise<void>;
+    delete(libraryId: string, operations: Operation[]): Promise<void>;
+}
+export interface BaselineStorage {
+    get(libraryId: string, oid: string): Promise<HydratedDocumentBaseline | null>;
+    getAll(libraryId: string): Promise<HydratedDocumentBaseline[]>;
+    insertAll(libraryId: string, baselines: DocumentBaseline<any>[]): Promise<void>;
+    deleteAll(libraryId: string): Promise<void>;
+    getCount(libraryId: string): Promise<number>;
+    applyOperations(libraryId: string, oid: string, operations: StoredOperation[], deletedRefs?: Ref[]): Promise<void>;
+}
+export interface FileMetadataStorage {
+    get(libraryId: string, fileId: string): Promise<FileMetadata | null>;
+    getAll(libraryId: string): Promise<FileMetadata[]>;
+    deleteAll(libraryId: string): Promise<void>;
+    put(libraryId: string, fileInfo: FileInfo): Promise<void>;
+    markPendingDelete(libraryId: string, fileId: string): Promise<void>;
+    delete(libraryId: string, fileId: string): Promise<void>;
+    getPendingDelete(libraryId: string): Promise<FileMetadata[]>;
+}
+export interface StorageOptions {
+    replicaTruancyMinutes: number;
+    fileDeleteExpirationDays: number;
+}
+export interface Storage {
+    replicas: ReplicaStorage;
+    operations: OperationStorage;
+    baselines: BaselineStorage;
+    fileMetadata: FileMetadataStorage;
+    close(): Promise<void>;
+    readonly open: boolean;
+    readonly ready: Promise<void>;
+}
+export type StorageFactory = (options: StorageOptions) => Storage;

package/dist/esm/storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Storage.js';
+export * from './sql/sqlStorage.js';

package/dist/esm/storage/sql/SqlBaselines.d.ts

@@ -0,0 +1,22 @@
+import { Kysely } from 'kysely';
+import { BaselineStorage } from '../Storage.js';
+import { Database } from './tables.js';
+import { DocumentBaseline, Ref } from '@verdant-web/common';
+import { HydratedDocumentBaseline, StoredOperation } from '../../types.js';
+export declare class SqlBaselines implements BaselineStorage {
+    private db;
+    private dialect;
+    constructor(db: Kysely<Database>, dialect: 'postgres' | 'sqlite');
+    get: (libraryId: string, oid: string, { tx }?: {
+        tx?: Kysely<Database> | undefined;
+    }) => Promise<HydratedDocumentBaseline | null>;
+    getAll: (libraryId: string) => Promise<any>;
+    set: (libraryId: string, baseline: DocumentBaseline, { tx, }: {
+        tx?: Kysely<Database> | undefined;
+    }) => Promise<void>;
+    insertAll: (libraryId: string, baselines: DocumentBaseline[]) => Promise<void>;
+    private hydrate;
+    applyOperations: (libraryId: string, oid: string, operations: StoredOperation[], deletedRefs?: Ref[]) => Promise<void>;
+    deleteAll: (libraryId: string) => Promise<void>;
+    getCount: (libraryId: string) => Promise<number>;
+}

package/dist/esm/storage/sql/SqlFileMetadata.d.ts

@@ -0,0 +1,18 @@
+import { Kysely } from 'kysely';
+import { FileMetadataStorage } from '../Storage.js';
+import { Database } from './tables.js';
+import { FileMetadata } from '../../types.js';
+import { FileInfo } from '../../files/FileStorage.js';
+export declare class SqlFileMetadata implements FileMetadataStorage {
+    private db;
+    private deleteExpirationDays;
+    private dialect;
+    constructor(db: Kysely<Database>, deleteExpirationDays: number, dialect: 'postgres' | 'sqlite');
+    get: (libraryId: string, fileId: string) => Promise<FileMetadata | null>;
+    getAll: (libraryId: string) => Promise<FileMetadata[]>;
+    deleteAll: (libraryId: string) => Promise<void>;
+    put: (libraryId: string, fileInfo: FileInfo) => Promise<void>;
+    markPendingDelete: (libraryId: string, fileId: string) => Promise<void>;
+    delete: (libraryId: string, fileId: string) => Promise<void>;
+    getPendingDelete: (libraryId: string) => Promise<FileMetadata[]>;
+}

package/dist/esm/storage/sql/SqlOperations.d.ts

@@ -0,0 +1,19 @@
+import { Operation } from '@verdant-web/common';
+import { StoredOperation } from '../../types.js';
+import { OperationStorage } from '../Storage.js';
+import { Kysely } from 'kysely';
+import { Database } from './tables.js';
+export declare class SqlOperations implements OperationStorage {
+    private db;
+    private dialect;
+    constructor(db: Kysely<Database>, dialect: 'postgres' | 'sqlite');
+    private hydrate;
+    getAll: (libraryId: string, oid: string) => Promise<StoredOperation[]>;
+    getBeforeServerOrder: (libraryId: string, beforeServerOrder: number) => Promise<StoredOperation[]>;
+    getAfterServerOrder: (libraryId: string, afterServerOrder: number) => Promise<StoredOperation[]>;
+    getLatestServerOrder: (libraryId: string) => Promise<number>;
+    getCount: (libraryId: string) => Promise<number>;
+    insertAll: (libraryId: string, replicaId: string, operations: Operation[]) => Promise<void>;
+    deleteAll: (libraryId: string) => Promise<void>;
+    delete: (libraryId: string, operations: Operation[]) => Promise<void>;
+}

package/dist/esm/storage/sql/SqlReplicas.d.ts

@@ -0,0 +1,32 @@
+import { StoredReplicaInfo } from '../../types.js';
+import { ReplicaStorage } from '../Storage.js';
+import { type Kysely } from 'kysely';
+import { Database } from './tables.js';
+import { ReplicaType } from '@verdant-web/common';
+export declare class SqlReplicas implements ReplicaStorage {
+    private db;
+    private readonly replicaTruancyMinutes;
+    private readonly dialect;
+    constructor(db: Kysely<Database>, replicaTruancyMinutes: number, dialect: 'sqlite' | 'postgres');
+    get truantCutoff(): number;
+    get: (libraryId: string, replicaId: string) => Promise<StoredReplicaInfo | null>;
+    getOrCreate: (libraryId: string, replicaId: string, info: {
+        userId: string;
+        type: ReplicaType;
+    }) => Promise<{
+        status: 'new' | 'existing' | 'truant';
+        replicaInfo: StoredReplicaInfo;
+    }>;
+    getAll: (libraryId: string, options?: {
+        omitTruant: boolean;
+    } | undefined) => Promise<StoredReplicaInfo[]>;
+    updateLastSeen: (libraryId: string, replicaId: string) => Promise<void>;
+    updateAckedServerOrder: (libraryId: string, replicaId: string, serverOrder: number) => Promise<void>;
+    updateAcknowledgedLogicalTime: (libraryId: string, replicaId: string, timestamp: string) => Promise<void>;
+    getEarliestAckedServerOrder: (libraryId: string) => Promise<number>;
+    acknowledgeOperation: (libraryId: string, replicaId: string, timestamp: string) => Promise<void>;
+    getGlobalAck: (libraryId: string, onlineReplicaIds?: string[] | undefined) => Promise<string | null>;
+    delete: (libraryId: string, replicaId: string) => Promise<void>;
+    deleteAll: (libraryId: string) => Promise<void>;
+    deleteAllForUser: (libraryId: string, userId: string) => Promise<void>;
+}

package/dist/esm/storage/sql/migrations/v1.d.ts

@@ -0,0 +1,3 @@
+import { Kysely } from 'kysely';
+export declare function up(db: Kysely<any>): Promise<void>;
+export declare function down(db: Kysely<any>): Promise<void>;

package/dist/esm/storage/sql/migrations.d.ts

@@ -0,0 +1,5 @@
+import * as v1 from './migrations/v1.js';
+declare const _default: {
+    v1: typeof v1;
+};
+export default _default;

package/dist/esm/storage/sql/sqlStorage.d.ts

@@ -0,0 +1,5 @@
+import { StorageFactory } from '../Storage.js';
+export declare const sqlStorage: ({ databaseFile: dbFile, skipMigrations, }: {
+    databaseFile: string;
+    skipMigrations?: boolean | undefined;
+}) => StorageFactory;

package/dist/esm/storage/sql/tables.d.ts

@@ -0,0 +1,40 @@
+import { ReplicaType } from '@verdant-web/common';
+import { Generated, Selectable } from 'kysely';
+export interface Database {
+    OperationHistory: OperationHistoryTable;
+    DocumentBaseline: DocumentBaselineTable;
+    ReplicaInfo: ReplicaInfoTable;
+    FileMetadata: FileMetadataTable;
+}
+export interface OperationHistoryTable {
+    oid: string;
+    timestamp: string;
+    data: string;
+    serverOrder: number;
+    replicaId: string;
+    libraryId: string;
+}
+export type OperationHistoryRow = Selectable<OperationHistoryTable>;
+export interface DocumentBaselineTable {
+    oid: string;
+    snapshot: string;
+    timestamp: string;
+    libraryId: string;
+}
+export type DocumentBaselineRow = Selectable<DocumentBaselineTable>;
+export interface ReplicaInfoTable {
+    id: string;
+    libraryId: string;
+    clientId: string;
+    lastSeenWallClockTime: number | null;
+    ackedLogicalTime: string | null;
+    type: ReplicaType;
+    ackedServerOrder: Generated<number>;
+}
+export interface FileMetadataTable {
+    libraryId: string;
+    fileId: string;
+    name: string;
+    type: string;
+    pendingDeleteAt: number | null;
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,47 @@
+import { DocumentBaseline, Operation, ReplicaInfo, ReplicaType } from '@verdant-web/common';
+export interface StoredOperation extends Operation {
+    serverOrder: number;
+    replicaId: string;
+}
+export interface StoredDocumentBaseline extends Omit<DocumentBaseline<any>, 'snapshot'> {
+    snapshot: string;
+    libraryId: string;
+}
+export interface HydratedDocumentBaseline extends DocumentBaseline<any> {
+    libraryId: string;
+}
+export interface StoredReplicaInfo extends ReplicaInfo {
+    libraryId: string;
+    clientId: string;
+    lastSeenWallClockTime: number | null;
+    type: ReplicaType;
+    ackedServerOrder: number;
+}
+export type LibraryInfo<Profile = unknown> = {
+    id: string;
+    replicas: {
+        id: string;
+        ackedLogicalTime: string | null;
+        ackedServerOrder: number;
+        type: ReplicaType;
+        truant: boolean;
+        profile: Profile;
+    }[];
+    latestServerOrder: number;
+    operationsCount: number;
+    baselinesCount: number;
+    globalAck: string | null;
+};
+export interface FileMetadata {
+    libraryId: string;
+    fileId: string;
+    name: string;
+    type: string;
+    pendingDeleteAt: number | null;
+}
+declare global {
+    interface File {
+        readonly lastModified: number;
+        readonly name: string;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdant-web/server",
-  "version": "3.0.0-next.0",
+  "version": "3.0.0",
   "access": "public",
   "type": "module",
   "bin": {
@@ -33,7 +33,7 @@
     "kysely-plugin-serialize": "^0.5.7",
     "minimist": "^1.2.8",
     "ws": "^8.9.0",
-    "@verdant-web/common": "2.3.0-next.0"
+    "@verdant-web/common": "2.3.0"
   },
   "devDependencies": {
     "@types/async-lock": "^1.3.0",