@dabble/patches 0.5.22 → 0.7.0

package/dist/net/websocket/RPCServer.js

@@ -1,204 +0,0 @@
-import "../../chunk-IZ2YBCUP.js";
-import { StatusError } from "../error.js";
-import { JSONRPCServer } from "../protocol/JSONRPCServer.js";
-import { denyAll } from "./AuthorizationProvider.js";
-class RPCServer {
-  rpc;
-  auth;
-  patches;
-  history;
-  branches;
-  /**
-   * 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 deny-all for security.
-   */
-  constructor({ patches, history, branches, auth = denyAll }) {
-    this.rpc = new JSONRPCServer();
-    this.patches = patches;
-    this.history = history;
-    this.branches = branches;
-    this.auth = auth;
-    this.rpc.registerMethod("getDoc", this.getDoc.bind(this));
-    this.rpc.registerMethod("getChangesSince", this.getChangesSince.bind(this));
-    this.rpc.registerMethod("commitChanges", this.commitChanges.bind(this));
-    this.rpc.registerMethod("deleteDoc", this.deleteDoc.bind(this));
-    this.rpc.registerMethod("undeleteDoc", this.undeleteDoc.bind(this));
-    if (this.history) {
-      this.rpc.registerMethod("listVersions", this.listVersions.bind(this));
-      this.rpc.registerMethod("createVersion", this.createVersion.bind(this));
-      this.rpc.registerMethod("updateVersion", this.updateVersion.bind(this));
-      this.rpc.registerMethod("getVersionState", this.getVersionState.bind(this));
-      this.rpc.registerMethod("getVersionChanges", this.getVersionChanges.bind(this));
-      this.rpc.registerMethod("listServerChanges", this.listServerChanges.bind(this));
-    }
-    if (this.branches) {
-      this.rpc.registerMethod("listBranches", this.listBranches.bind(this));
-      this.rpc.registerMethod("createBranch", this.createBranch.bind(this));
-      this.rpc.registerMethod("closeBranch", this.closeBranch.bind(this));
-      this.rpc.registerMethod("mergeBranch", this.mergeBranch.bind(this));
-    }
-    this.patches.onChangesCommitted((docId, changes, originClientId) => {
-      this.rpc.notify("changesCommitted", { docId, changes }, originClientId);
-    });
-    this.patches.onDocDeleted((docId, options, originClientId) => {
-      this.rpc.notify("docDeleted", { docId }, originClientId);
-    });
-  }
-  /**
-   * Gets the latest state (content and revision) of a document.
-   * @param connectionId - The ID of the connection making the request
-   * @param params - The document parameters
-   * @param params.docId - The ID of the document
-   * @param params.atRev - Optional revision number to get document state at
-   */
-  async getDoc(params, ctx) {
-    const { docId, atRev } = params;
-    await this.assertRead(ctx, docId, "getDoc", params);
-    return this.patches.getDoc(docId, atRev);
-  }
-  /**
-   * Gets changes that occurred for a document after a specific revision number.
-   * @param connectionId - The ID of the connection making the request
-   * @param params - The change request parameters
-   * @param params.docId - The ID of the document
-   * @param params.rev - The revision number after which to fetch changes
-   */
-  async getChangesSince(params, ctx) {
-    const { docId, rev } = params;
-    await this.assertRead(ctx, docId, "getChangesSince", params);
-    return this.patches.getChangesSince(docId, rev);
-  }
-  /**
-   * Applies a set of client-generated changes to a document on the server.
-   * @param connectionId - The ID of the connection making the request
-   * @param params - The change parameters
-   * @param params.docId - The ID of the document
-   * @param params.changes - An array of changes to apply
-   * @param params.options - Optional commit settings (e.g., forceCommit for migrations)
-   */
-  async commitChanges(params, ctx) {
-    const { docId, changes, options } = params;
-    await this.assertWrite(ctx, docId, "commitChanges", params);
-    const [priorChanges, newChanges] = await this.patches.commitChanges(docId, changes, options, ctx?.clientId);
-    return [...priorChanges, ...newChanges];
-  }
-  /**
-   * Deletes a document on the server.
-   * @param connectionId - The ID of the connection making the request
-   * @param params - The deletion parameters
-   * @param params.docId - The ID of the document to delete
-   * @param params.options - Optional deletion settings (e.g., skipTombstone)
-   */
-  async deleteDoc(params, ctx) {
-    const { docId, options } = params;
-    await this.assertWrite(ctx, docId, "deleteDoc", params);
-    await this.patches.deleteDoc(docId, options, ctx?.clientId);
-  }
-  /**
-   * Removes the tombstone for a deleted document, allowing it to be recreated.
-   * @param params - The undelete parameters
-   * @param params.docId - The ID of the document to undelete
-   */
-  async undeleteDoc(params, ctx) {
-    const { docId } = params;
-    await this.assertWrite(ctx, docId, "undeleteDoc", params);
-    return this.patches.undeleteDoc(docId);
-  }
-  // ---------------------------------------------------------------------------
-  // History Manager wrappers
-  // ---------------------------------------------------------------------------
-  async listVersions(params, ctx) {
-    this.assertHistoryEnabled();
-    const { docId, options } = params;
-    await this.assertRead(ctx, docId, "listVersions", params);
-    return this.history.listVersions(docId, options ?? {});
-  }
-  async createVersion(params, ctx) {
-    this.assertHistoryEnabled();
-    const { docId, metadata } = params;
-    await this.assertWrite(ctx, docId, "createVersion", params);
-    return this.history.createVersion(docId, metadata);
-  }
-  async updateVersion(params, ctx) {
-    this.assertHistoryEnabled();
-    const { docId, versionId, metadata } = params;
-    await this.assertWrite(ctx, docId, "updateVersion", params);
-    return this.history.updateVersion(docId, versionId, metadata);
-  }
-  async getVersionState(params, ctx) {
-    this.assertHistoryEnabled();
-    const { docId, versionId } = params;
-    await this.assertRead(ctx, docId, "getStateAtVersion", params);
-    return this.history.getStateAtVersion(docId, versionId);
-  }
-  async getVersionChanges(params, ctx) {
-    this.assertHistoryEnabled();
-    const { docId, versionId } = params;
-    await this.assertRead(ctx, docId, "getChangesForVersion", params);
-    return this.history.getChangesForVersion(docId, versionId);
-  }
-  async listServerChanges(params, ctx) {
-    this.assertHistoryEnabled();
-    const { docId, options } = params;
-    await this.assertRead(ctx, docId, "listServerChanges", params);
-    return this.history.listServerChanges(docId, options ?? {});
-  }
-  // ---------------------------------------------------------------------------
-  // Branch Manager wrappers
-  // ---------------------------------------------------------------------------
-  async listBranches(params, ctx) {
-    this.assertBranchingEnabled();
-    const { docId } = params;
-    await this.assertRead(ctx, docId, "listBranches", params);
-    return this.branches.listBranches(docId);
-  }
-  async createBranch(params, ctx) {
-    this.assertBranchingEnabled();
-    const { docId, rev, metadata } = params;
-    await this.assertWrite(ctx, docId, "createBranch", params);
-    return this.branches.createBranch(docId, rev, metadata);
-  }
-  async closeBranch(params, ctx) {
-    this.assertBranchingEnabled();
-    const { branchId } = params;
-    await this.assertWrite(ctx, branchId, "closeBranch", params);
-    return this.branches.closeBranch(branchId, "closed");
-  }
-  async mergeBranch(params, ctx) {
-    this.assertBranchingEnabled();
-    const { branchId } = params;
-    await this.assertWrite(ctx, branchId, "mergeBranch", params);
-    return this.branches.mergeBranch(branchId);
-  }
-  // ---------------------------------------------------------------------------
-  // Authorization helpers
-  // ---------------------------------------------------------------------------
-  async assertAccess(ctx, docId, kind, method, params) {
-    const ok = await this.auth.canAccess(ctx, docId, kind, method, params);
-    if (!ok) {
-      throw new StatusError(401, `${kind.toUpperCase()}_FORBIDDEN:${docId}`);
-    }
-  }
-  assertRead(ctx, docId, method, params) {
-    return this.assertAccess(ctx, docId, "read", method, params);
-  }
-  assertWrite(ctx, docId, method, params) {
-    return this.assertAccess(ctx, docId, "write", method, params);
-  }
-  assertHistoryEnabled() {
-    if (!this.history) {
-      throw new StatusError(404, "History is not enabled");
-    }
-  }
-  assertBranchingEnabled() {
-    if (!this.branches) {
-      throw new StatusError(404, "Branching is not enabled");
-    }
-  }
-}
-export {
-  RPCServer
-};

package/dist/utils/dates.d.ts

@@ -1,43 +0,0 @@
-/**
- * Date utility functions for creating and manipulating ISO 8601 timestamps.
- *
- * Client-side timestamps use local timezone offsets (e.g., +04:00).
- * Server-side timestamps use UTC with Z suffix.
- */
-/**
- * Converts a Date or ISO string to UTC format without milliseconds.
- * Example: "2025-12-26T10:00:00Z"
- */
-declare function getISO(date?: Date | string): string;
-/**
- * Formats a Date with a specific timezone offset string.
- * The date is adjusted to display the correct local time for that offset.
- */
-declare function getLocalISO(date?: Date | string, offset?: string): string;
-/**
- * Calculates milliseconds between two ISO timestamps.
- * Returns (a - b) in milliseconds.
- */
-declare function timestampDiff(a: string, b: string): number;
-/**
- * Clamps a timestamp to not exceed a limit, preserving the original timezone offset.
- * Returns the original if it's <= limit, otherwise returns limit in original's timezone.
- *
- * Example:
- *   timestamp: "2025-12-26T18:00:00+04:00" (future)
- *   limit:     "2025-12-26T10:00:00Z"      (server time)
- *   result:    "2025-12-26T14:00:00+04:00" (clamped, same instant as limit)
- */
-declare function clampTimestamp(timestamp: string, limit: string): string;
-/**
- * Extracts the timezone offset string from an ISO timestamp.
- * Returns "+04:00", "-05:00", or "Z".
- */
-declare function extractTimezoneOffset(iso: string): string;
-/**
- * Gets the local timezone offset string for the current environment.
- * Returns "+04:00", "-05:00", or "Z" for UTC.
- */
-declare function getLocalTimezoneOffset(): string;
-
-export { clampTimestamp, extractTimezoneOffset, getISO, getLocalISO, getLocalTimezoneOffset, timestampDiff };

package/dist/utils/dates.js

@@ -1,47 +0,0 @@
-import "../chunk-IZ2YBCUP.js";
-function getISO(date = /* @__PURE__ */ new Date()) {
-  const d = typeof date === "string" ? new Date(date) : date;
-  return d.toISOString().replace(/\.\d{3}/, "");
-}
-function getLocalISO(date = /* @__PURE__ */ new Date(), offset = getLocalTimezoneOffset()) {
-  const match = offset.match(/([+-])(\d{2}):(\d{2})/);
-  if (offset === "Z" || !match) return getISO(date);
-  const sign = match[1] === "+" ? 1 : -1;
-  const offsetMinutes = sign * (parseInt(match[2]) * 60 + parseInt(match[3]));
-  const localDate = new Date((typeof date === "string" ? new Date(date) : date).getTime() + offsetMinutes * 60 * 1e3);
-  return getISO(localDate).slice(0, -1) + offset;
-}
-function timestampDiff(a, b) {
-  return new Date(a).getTime() - new Date(b).getTime();
-}
-function clampTimestamp(timestamp, limit) {
-  if (!timestamp || !limit) throw new Error("Timestamp and limit are required");
-  const timestampDate = new Date(timestamp);
-  const limitDate = new Date(limit);
-  if (timestampDate <= limitDate) {
-    return timestamp;
-  }
-  const offset = extractTimezoneOffset(timestamp);
-  return getLocalISO(limitDate, offset);
-}
-function extractTimezoneOffset(iso) {
-  if (!iso) return "Z";
-  const match = iso.match(/([+-]\d{2}:\d{2}|Z)$/);
-  return match ? match[1] : "Z";
-}
-function getLocalTimezoneOffset() {
-  const offset = -(/* @__PURE__ */ new Date()).getTimezoneOffset();
-  if (offset === 0) return "Z";
-  const hours = Math.floor(Math.abs(offset) / 60);
-  const mins = Math.abs(offset) % 60;
-  const sign = offset >= 0 ? "+" : "-";
-  return `${sign}${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}`;
-}
-export {
-  clampTimestamp,
-  extractTimezoneOffset,
-  getISO,
-  getLocalISO,
-  getLocalTimezoneOffset,
-  timestampDiff
-};