@dabble/patches 0.2.32 → 0.3.1

package/dist/net/websocket/AuthorizationProvider.d.ts

@@ -40,7 +40,14 @@ export interface AuthorizationProvider<T extends AuthContext = AuthContext> {
     canAccess(ctx: T | undefined, docId: string, kind: Access, method: string, params?: Record<string, any>): boolean | Promise<boolean>;
 }
 /**
- * A permissive provider that authorises every action.  Used as the default so
- * existing callers that don't care about auth continue to work unchanged.
+ * A permissive provider that authorises every action.
+ * WARNING: This should only be used for development/testing purposes.
+ * Never use this in production as it allows unrestricted access.
  */
 export declare const allowAll: AuthorizationProvider;
+/**
+ * A secure default provider that denies all access.
+ * This forces developers to explicitly implement proper authorization.
+ * Use this as the default to ensure security by default.
+ */
+export declare const denyAll: AuthorizationProvider;

package/dist/net/websocket/AuthorizationProvider.js

@@ -1,7 +1,19 @@
 /**
- * A permissive provider that authorises every action.  Used as the default so
- * existing callers that don't care about auth continue to work unchanged.
+ * A permissive provider that authorises every action.
+ * WARNING: This should only be used for development/testing purposes.
+ * Never use this in production as it allows unrestricted access.
  */
 export const allowAll = {
     canAccess: () => true,
 };
+/**
+ * A secure default provider that denies all access.
+ * This forces developers to explicitly implement proper authorization.
+ * Use this as the default to ensure security by default.
+ */
+export const denyAll = {
+    canAccess: () => {
+        console.warn('Authorization check failed: No authorization provider configured. Access denied.');
+        return false;
+    },
+};

package/dist/net/websocket/PatchesWebSocket.d.ts

@@ -1,6 +1,6 @@
 import { type Signal } from '../../event-signal.js';
 import type { Change, EditableVersionMetadata, ListVersionsOptions, PatchesSnapshot, PatchesState, VersionMetadata } from '../../types.js';
-import type { ConnectionState, PatchesAPI, PatchesNotificationParams } from '../protocol/types.js';
+import type { ConnectionState, PatchesAPI } from '../protocol/types.js';
 import { type WebSocketOptions } from './WebSocketTransport.js';
 /**
  * High-level client for the Patches real-time collaboration service.
@@ -14,7 +14,7 @@ export declare class PatchesWebSocket implements PatchesAPI {
     /** Signal emitted when the underlying WebSocket connection state changes. */
     readonly onStateChange: Signal<(state: ConnectionState) => void>;
     /** Signal emitted when the server pushes document changes. */
-    readonly onChangesCommitted: Signal<(params: PatchesNotificationParams) => void>;
+    readonly onChangesCommitted: Signal<(docId: string, changes: Change[]) => void>;
     /**
      * Creates a new Patches WebSocket client instance.
      * @param url - The WebSocket server URL to connect to

package/dist/net/websocket/PatchesWebSocket.js

@@ -21,8 +21,9 @@ export class PatchesWebSocket {
         this.onStateChange = this.transport.onStateChange;
         // Register handlers for server-sent notifications
         // Note: Type assertions might be needed if rpc.on doesn't infer strongly enough
-        this.rpc.on('changesCommitted', (params /*: PatchesNotificationParams */) => {
-            this.onChangesCommitted.emit(params);
+        this.rpc.on('changesCommitted', (params) => {
+            const { docId, changes } = params;
+            this.onChangesCommitted.emit(docId, changes);
         });
     }
     // --- Connection Management ---

package/dist/net/websocket/RPCServer.d.ts

@@ -3,7 +3,7 @@ import type { PatchesHistoryManager } from '../../server/PatchesHistoryManager.j
 import type { PatchesServer } from '../../server/PatchesServer.js';
 import type { Change, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions } from '../../types.js';
 import { JSONRPCServer } from '../protocol/JSONRPCServer.js';
-import type { AuthContext, AuthorizationProvider } from './AuthorizationProvider.js';
+import { type AuthContext, type AuthorizationProvider } from './AuthorizationProvider.js';
 /**
  * High-level client for the Patches real-time collaboration service.
  * This class provides document subscription, patch notification handling,
@@ -26,7 +26,7 @@ export declare class RPCServer {
      * @param patches - The patches server instance to handle document operations
      * @param history - (Optional) History manager instance to handle versioning operations
      * @param branches - (Optional) Branch manager instance to handle branching operations
-     * @param auth - (Optional) Authorization provider implementation. Defaults to a permissive provider.
+     * @param auth - (Optional) Authorization provider implementation. Defaults to deny-all for security.
      */
     constructor({ patches, history, branches, auth }: RPCServerOptions);
     /**

package/dist/net/websocket/RPCServer.js

@@ -1,15 +1,15 @@
 import { StatusError } from '../error.js';
 import { JSONRPCServer } from '../protocol/JSONRPCServer.js';
-import { allowAll } from './AuthorizationProvider.js';
+import { denyAll } from './AuthorizationProvider.js';
 export class RPCServer {
     /**
      * Creates a new Patches WebSocket client instance.
      * @param patches - The patches server instance to handle document operations
      * @param history - (Optional) History manager instance to handle versioning operations
      * @param branches - (Optional) Branch manager instance to handle branching operations
-     * @param auth - (Optional) Authorization provider implementation. Defaults to a permissive provider.
+     * @param auth - (Optional) Authorization provider implementation. Defaults to deny-all for security.
      */
-    constructor({ patches, history, branches, auth = allowAll }) {
+    constructor({ patches, history, branches, auth = denyAll }) {
         this.rpc = new JSONRPCServer();
         this.patches = patches;
         this.history = history;

package/dist/net/websocket/SignalingService.js

@@ -56,7 +56,7 @@ export class SignalingService {
         try {
             parsed = typeof message === 'string' ? JSON.parse(message) : message;
         }
-        catch (err) {
+        catch {
             return false;
         }
         if (parsed.jsonrpc !== '2.0' || parsed.method !== 'peer-signal' || !parsed.params?.to)

package/dist/net/websocket/WebSocketServer.d.ts

@@ -1,5 +1,5 @@
 import type { ServerTransport } from '../protocol/types.js';
-import type { AuthContext, AuthorizationProvider } from './AuthorizationProvider.js';
+import { type AuthContext, type AuthorizationProvider } from './AuthorizationProvider.js';
 import type { RPCServer } from './RPCServer.js';
 /**
  * High-level client for the Patches real-time collaboration service.

package/dist/net/websocket/WebSocketServer.js

@@ -1,4 +1,4 @@
-import { allowAll } from './AuthorizationProvider.js';
+import { denyAll } from './AuthorizationProvider.js';
 /**
  * High-level client for the Patches real-time collaboration service.
  * This class provides document subscription, patch notification handling,
@@ -13,7 +13,7 @@ export class WebSocketServer {
     constructor(transport, rpcServer) {
         this.transport = transport;
         const { rpc, auth } = rpcServer;
-        this.auth = auth || allowAll;
+        this.auth = auth || denyAll;
         // Subscription operations
         rpc.registerMethod('subscribe', this.subscribe.bind(this));
         rpc.registerMethod('unsubscribe', this.unsubscribe.bind(this));

package/dist/net/websocket/WebSocketTransport.js

@@ -1,5 +1,5 @@
 import { signal } from '../../event-signal.js';
-import { deferred } from '../../utils.js';
+import { deferred } from '../../utils/deferred.js';
 import { onlineState } from './onlineState.js';
 /**
  * WebSocket-based transport implementation that provides communication over the WebSocket protocol.

package/dist/net/websocket/onlineState.d.ts

@@ -1,6 +1,6 @@
 declare class OnlineState {
-    onOnlineChange: import("../../event-signal").Signal<(isOnline: boolean) => void>;
-    _isOnline: boolean;
+    onOnlineChange: import("../../event-signal.js").Signal<(isOnline: boolean) => void>;
+    protected _isOnline: boolean;
     constructor();
     get isOnline(): boolean;
     get isOffline(): boolean;

package/dist/net/websocket/onlineState.js

@@ -1,11 +1,17 @@
-import { signal } from '../../event-signal';
+import { signal } from '../../event-signal.js';
 class OnlineState {
     constructor() {
         this.onOnlineChange = signal();
         this._isOnline = typeof navigator !== 'undefined' && navigator.onLine;
         if (typeof addEventListener === 'function') {
-            addEventListener('online', () => (this._isOnline = true) && this.onOnlineChange.emit(true));
-            addEventListener('offline', () => (this._isOnline = false) || this.onOnlineChange.emit(false));
+            addEventListener('online', () => {
+                this._isOnline = true;
+                this.onOnlineChange.emit(true);
+            });
+            addEventListener('offline', () => {
+                this._isOnline = false;
+                this.onOnlineChange.emit(false);
+            });
         }
     }
     get isOnline() {

package/dist/server/PatchesBranchManager.js

@@ -1,4 +1,6 @@
 import { createId } from 'crypto-id';
+import { createChange } from '../data/change.js';
+import { createVersionMetadata } from '../data/version.js';
 /**
  * Helps manage branches for a document. A branch is a document that is branched from another document. Its first
  * version will be the point-in-time of the original document at the time of the branch. Branches allow for parallel
@@ -36,8 +38,7 @@ export class PatchesBranchManager {
         const branchDocId = createId();
         const now = Date.now();
         // Create an initial version at the branch point rev (for snapshotting/large docs)
-        const initialVersionMetadata = {
-            id: createId(),
+        const initialVersionMetadata = createVersionMetadata({
             origin: 'main', // Branch doc versions are 'main' until merged
             startDate: now,
             endDate: now,
@@ -46,7 +47,7 @@ export class PatchesBranchManager {
             name: metadata?.name,
             groupId: branchDocId,
             branchName: metadata?.name,
-        };
+        });
         await this.store.createVersion(branchDocId, initialVersionMetadata, stateAtRev, []);
         // 2. Create the branch metadata record
         const branch = {
@@ -106,30 +107,22 @@ export class PatchesBranchManager {
         // 4. For each version, create a corresponding version in the main doc with updated fields
         let lastVersionId;
         for (const v of branchVersions) {
-            const newVersionId = createId();
-            const newVersionMetadata = {
+            const newVersionMetadata = createVersionMetadata({
                 ...v,
-                id: newVersionId,
                 origin: 'branch',
                 baseRev: branchStartRevOnSource,
                 groupId: branchId,
                 branchName: branch.name,
                 parentId: lastVersionId,
-            };
+            });
             const state = await this.store.loadVersionState(branchId, v.id);
             const changes = await this.store.loadVersionChanges(branchId, v.id);
             await this.store.createVersion(sourceDocId, newVersionMetadata, state, changes);
-            lastVersionId = newVersionId;
+            lastVersionId = newVersionMetadata.id;
         }
         // 5. Flatten all branch changes into a single change for the main doc
-        const now = Date.now();
-        const flattenedChange = {
-            id: createId(12),
-            ops: branchChanges.flatMap(c => c.ops),
-            rev: branchStartRevOnSource + branchChanges.length,
-            baseRev: branchStartRevOnSource,
-            created: now,
-        };
+        const rev = branchStartRevOnSource + branchChanges.length;
+        const flattenedChange = createChange(branchStartRevOnSource, rev, branchChanges.flatMap(c => c.ops));
         // 6. Commit the flattened change to the main doc
         let committedMergeChanges = [];
         try {

package/dist/server/PatchesHistoryManager.js

@@ -28,7 +28,7 @@ export class PatchesHistoryManager {
      */
     async createVersion(docId, metadata) {
         assertVersionMetadata(metadata);
-        return await this.patches.createVersion(docId, metadata);
+        return await this.patches.captureCurrentVersion(docId, metadata);
     }
     /**
      * Updates the name of a specific version.

package/dist/server/PatchesServer.d.ts

@@ -1,5 +1,5 @@
 import type { JSONPatch } from '../json-patch/JSONPatch.js';
-import type { Change, EditableVersionMetadata, PatchesSnapshot, PatchesState, VersionMetadata } from '../types.js';
+import type { Change, EditableVersionMetadata, PatchesState } from '../types.js';
 import type { PatchesStoreBackend } from './types.js';
 /**
  * Configuration options for the PatchesServer.
@@ -32,6 +32,13 @@ export declare class PatchesServer {
      * @returns The state of the document at the specified revision.
      */
     getDoc(docId: string, atRev?: number): Promise<PatchesState>;
+    /**
+     * Get the state of a document at a specific revision.
+     * @param docId - The ID of the document.
+     * @param rev - The revision number.
+     * @returns The state of the document at the specified revision.
+     */
+    getStateAtRevision(docId: string, atRev?: number): Promise<PatchesState>;
     /**
      * Get changes that occurred after a specific revision.
      * @param docId - The ID of the document.
@@ -62,45 +69,11 @@ export declare class PatchesServer {
      */
     deleteDoc(docId: string, originClientId?: string): Promise<void>;
     /**
-     * Create a new named version snapshot of a document's current state.
+     * Captures the current state of a document as a new version.
      * @param docId The document ID.
-     * @param name The name of the version.
+     * @param metadata Optional metadata for the version.
      * @returns The ID of the created version.
      */
-    createVersion(docId: string, metadata?: EditableVersionMetadata): Promise<string>;
-    /**
-     * Gets the state at a specific revision.
-     * @param docId The document ID.
-     * @param rev The revision number. If not provided, the latest state and its revision is returned.
-     * @returns The state at the specified revision *and* its revision number.
-     */
-    getStateAtRevision(docId: string, rev?: number): Promise<PatchesState>;
-    /**
-     * Retrieves the document state of the version before the given revision and changes after up to that revision or all
-     * changes since that version.
-     * @param docId The document ID.
-     * @param rev The revision number. If not provided, the latest state, its revision, and all changes since are returned.
-     * @returns The document state at the last version before the revision, its revision number, and all changes up to the specified revision (or all changes if no revision is provided).
-     */
-    protected _getSnapshotAtRevision(docId: string, rev?: number): Promise<PatchesSnapshot>;
-    /**
-     * Creates a new version snapshot of a document's current state.
-     * @param docId The document ID.
-     * @param state The document state at the time of the version.
-     * @param changes The changes since the last version that created the state (the last change's rev is the state's rev and will be the version's rev).
-     * @param metadata The metadata of the version.
-     * @returns The ID of the created version.
-     */
-    protected _createVersion(docId: string, state: any, changes: Change[], metadata?: EditableVersionMetadata): Promise<VersionMetadata | undefined>;
-    /**
-     * Handles offline/large batch versioning logic for multi-batch uploads.
-     * Groups changes into sessions, merges with previous batch if needed, and creates/extends versions.
-     * @param docId Document ID
-     * @param changes The incoming changes (all with the same batchId)
-     * @param baseRev The base revision for the batch
-     * @param batchId The batch identifier
-     * @returns The collapsed changes for transformation
-     */
-    protected _handleOfflineBatches(docId: string, changes: Change[], baseRev: number, batchId?: string): Promise<Change[]>;
+    captureCurrentVersion(docId: string, metadata?: EditableVersionMetadata): Promise<string>;
 }
 export declare function assertVersionMetadata(metadata?: EditableVersionMetadata): void;