velocious 1.0.591 → 1.0.593

package/build/src/testing/shared-transaction-connection-coordinator.d.ts

@@ -2,9 +2,9 @@
  * Registers test-only serialization owned by the active broker.
  * @param {object} connection - Parent physical connection.
  * @param {(callback: () => Promise<unknown>) => Promise<unknown>} coordinator - Serializer.
- * @returns {void}
+ * @returns {symbol} - Opaque owner for broker-internal connection calls.
  */
-export declare function setSharedTransactionCoordinator(connection: object, coordinator: (callback: () => Promise<unknown>) => Promise<unknown>): void;
+export declare function setSharedTransactionCoordinator(connection: object, coordinator: (callback: () => Promise<unknown>) => Promise<unknown>): symbol;
 /**
  * Removes a broker-owned coordinator without disturbing a replacement.
  * @param {object} connection - Parent physical connection.
@@ -15,9 +15,10 @@ export declare function clearSharedTransactionCoordinator(connection: object, co
 /**
  * Runs parent work through broker serialization when registered.
  * @template T
- * @param {object} connection - Parent physical connection.
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
  * @param {() => Promise<T>} callback - Parent operation.
+ * @param {symbol} [operationOwner] - Broker owner for an already-coordinated operation.
  * @returns {Promise<T>} - Operation result.
  */
-export declare function coordinateSharedTransactionConnection<T>(connection: object, callback: () => Promise<T>): Promise<T>;
+export declare function coordinateSharedTransactionConnection<T>(connection: import("../database/drivers/base.js").default, callback: () => Promise<T>, operationOwner?: symbol): Promise<T>;
 //# sourceMappingURL=shared-transaction-connection-coordinator.d.ts.map

package/build/src/testing/shared-transaction-connection-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-transaction-connection-coordinator.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,UAAU,EAJ/C,MAI+C,EAAE,WAAW,EAH5D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGO,GAF1D,IAAI,CAIhB;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAJjD,MAIiD,EAAE,WAAW,EAH9D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGS,GAF5D,IAAI,CAIhB;AAED;;;;;;GAMG;AACH,wBAAsB,qCAAqC,CAL9C,CAAC,EAK8C,UAAU,EAJ3D,MAI2D,EAAE,QAAQ,EAHrE,MAAM,OAAO,CAAC,CAAC,CAGsD,GAFnE,OAAO,CAAC,CAAC,CAAC,CAOtB"}
+{"version":3,"file":"shared-transaction-connection-coordinator.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,UAAU,EAJ/C,MAI+C,EAAE,WAAW,EAH5D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGO,GAF1D,MAAM,CAOlB;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAJjD,MAIiD,EAAE,WAAW,EAH9D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGS,GAF5D,IAAI,CAIhB;AAED;;;;;;;GAOG;AACH,wBAAsB,qCAAqC,CAN9C,CAAC,EAM8C,UAAU,EAL3D,OAAO,6BAA6B,EAAE,OAKqB,EAAE,QAAQ,EAJrE,MAAM,OAAO,CAAC,CAAC,CAIsD,EAAE,cAAc,AAH7F,CACA,EADQ,MAGqF,GAFnF,OAAO,CAAC,CAAC,CAAC,CAiBtB"}

package/build/src/testing/shared-transaction-connection-coordinator.js

@@ -1,14 +1,16 @@
 // @ts-check
-/** @type {WeakMap<object, (callback: () => Promise<unknown>) => Promise<unknown>>} */
+/** @type {WeakMap<object, {coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, owner: symbol}>} */
 const coordinators = new WeakMap();
 /**
  * Registers test-only serialization owned by the active broker.
  * @param {object} connection - Parent physical connection.
  * @param {(callback: () => Promise<unknown>) => Promise<unknown>} coordinator - Serializer.
- * @returns {void}
+ * @returns {symbol} - Opaque owner for broker-internal connection calls.
  */
 export function setSharedTransactionCoordinator(connection, coordinator) {
-    coordinators.set(connection, coordinator);
+    const owner = Symbol("shared-transaction-coordinator");
+    coordinators.set(connection, { coordinator, owner });
+    return owner;
 }
 /**
  * Removes a broker-owned coordinator without disturbing a replacement.
@@ -17,20 +19,29 @@ export function setSharedTransactionCoordinator(connection, coordinator) {
  * @returns {void}
  */
 export function clearSharedTransactionCoordinator(connection, coordinator) {
-    if (coordinators.get(connection) === coordinator)
+    if (coordinators.get(connection)?.coordinator === coordinator)
         coordinators.delete(connection);
 }
 /**
  * Runs parent work through broker serialization when registered.
  * @template T
- * @param {object} connection - Parent physical connection.
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
  * @param {() => Promise<T>} callback - Parent operation.
+ * @param {symbol} [operationOwner] - Broker owner for an already-coordinated operation.
  * @returns {Promise<T>} - Operation result.
  */
-export async function coordinateSharedTransactionConnection(connection, callback) {
-    const coordinator = coordinators.get(connection);
-    if (!coordinator)
+export async function coordinateSharedTransactionConnection(connection, callback, operationOwner) {
+    const registration = coordinators.get(connection);
+    if (!registration)
+        return await callback();
+    if (operationOwner === registration.owner)
+        return await callback();
+    const environmentHandler = connection.configuration.getEnvironmentHandler();
+    if (environmentHandler.getSharedTransactionCoordinatorOwner(connection) === registration.owner) {
         return await callback();
-    return /** @type {T} */ (await coordinator(callback));
+    }
+    return /** @type {T} */ (await registration.coordinator(async () => {
+        return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, registration.owner, callback);
+    }));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/sync/conflict-strategy.js

@@ -63,6 +63,9 @@ export async function applySyncReplayResultToLocalMutationLog({mutationLog, reco
  * @returns {import("./local-mutation-log.js").LocalMutationStatus} - Local mutation-log status.
  */
 export function replayResultLocalStatus(result) {
+  if (result.syncState === "conflict") return "conflict"
+  if (result.syncState === "failed" || result.syncState === "rejected") return "rejected"
+  if (result.syncState === "successful" || result.syncState === "duplicate") return "synced"
   if (result.status === "conflict") return "conflict"
   if (result.status === "error" || result.status === "rejected") return "rejected"
   if (result.status === "success" && replayResultHasFailedApplication(result)) return "rejected"

package/build/sync/local-mutation-log.js

@@ -148,6 +148,30 @@ export default class LocalMutationLog {
     })
   }
 
+  /**
+   * Replaces the mutation payload of a still-pending record. Used when an
+   * acknowledged predecessor supplies the authoritative base for its successor.
+   * @param {{id: string, mutation: import("./device-identity.js").SyncMutation}} args - Record and replacement mutation.
+   * @returns {Promise<LocalMutationLogRecord>} Updated record.
+   */
+  async updateMutation({id, mutation}) {
+    return await withStorageKeyLock(this.storageKey, async () => {
+      const rawRecord = await this.storage.record(this.storageKey, id)
+
+      if (!rawRecord) throw new Error(`No local mutation log record '${id}'`)
+
+      const record = normalizeRecord(rawRecord)
+
+      if (!PENDING_STATUSES.has(record.status)) throw new Error(`Cannot update mutation for ${record.status} local mutation '${id}'`)
+
+      record.mutation = normalizeMutation(mutation)
+      record.updatedAt = this.currentTimestamp()
+      await this.storage.updateRecord(this.storageKey, cloneRecord(record))
+
+      return cloneRecord(record)
+    })
+  }
+
   /**
    * Prunes terminal records that are no longer needed for replay dependencies.
    * @param {object} [args] - Compaction options.

package/build/sync/sync-api-client-types.js

@@ -73,6 +73,9 @@
 /**
  * @typedef {object} SyncReplayItem
  * @property {string | number} id - Sync id.
+ * @property {Record<string, ReturnType<typeof JSON.parse>>} [conflict] - Structured durable conflict payload.
+ * @property {string} [reason] - Rejection reason.
+ * @property {string | number | null} [serverVersion] - Authoritative version after successful replay.
  * @property {string} syncState - Replay state.
  */
 

package/build/sync/sync-api-client.js

@@ -3,6 +3,7 @@
 import {optionalBoolean, optionalInteger} from "typanic"
 
 import recordChanges from "../database/record-changes.js"
+import {applySyncReplayResultToLocalMutationLog} from "./conflict-strategy.js"
 
 /** @typedef {import("./sync-api-client-types.js").SyncChangeApplyResult} SyncChangeApplyResult */
 /** @typedef {import("./sync-api-client-types.js").SyncChangeEnvelope} SyncChangeEnvelope */
@@ -21,6 +22,208 @@ const syncTaskPromises = new Map()
  * persistence/auth hooks.
  */
 export default class SyncApiClient {
+  /**
+   * Appends one conflict-tracked intent to the existing durable mutation log.
+   * @param {object} args - Queue arguments.
+   * @param {string | number | null} args.baseVersion - Authoritative version observed before the local mutation.
+   * @param {import("./sync-client-types.js").SyncClientConflictTrackingConfig} args.conflictTracking - Durable tracking configuration.
+   * @param {Record<string, unknown>} args.data - Backend-safe mutation attributes.
+   * @param {"create" | "update" | "destroy"} args.operation - Local operation.
+   * @param {ReturnType<typeof JSON.parse>} args.resource - Local resource.
+   * @param {string} args.resourceType - Resource type.
+   * @param {string} args.syncType - Wire operation.
+   * @returns {Promise<import("./local-mutation-log.js").LocalMutationLogRecord>} Appended intent.
+   */
+  static async queueConflictTrackedSync({baseVersion, conflictTracking, data, operation, resource, resourceType, syncType}) {
+    const resourceId = String(resource.id())
+    const records = await conflictTracking.mutationLog.records()
+    const predecessor = records
+      .filter((record) => record.mutation.model === resourceType && record.mutation.payload?.resourceId === resourceId)
+      .at(-1)
+    const clientMutationId = conflictTracking.clientMutationId()
+    const now = conflictTracking.now ? conflictTracking.now() : new Date()
+    const predecessorTime = predecessor ? new Date(predecessor.mutation.occurredAt).getTime() : Number.NEGATIVE_INFINITY
+    const occurredAt = new Date(Math.max(now.getTime(), predecessorTime + 1)).toISOString()
+
+    return await conflictTracking.mutationLog.append({
+      dependencies: predecessor ? [{clientMutationId: predecessor.mutation.clientMutationId, model: resourceType}] : [],
+      mutation: {
+        actorDeviceId: conflictTracking.actorDeviceId,
+        actorUserId: conflictTracking.actorUserId,
+        attributes: /** @type {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue>} */ (data),
+        baseVersion,
+        clientMutationId,
+        model: resourceType,
+        occurredAt,
+        offlineGrantId: conflictTracking.offlineGrantId,
+        operation,
+        payload: {resourceId, syncType},
+        policyHash: conflictTracking.policyHash
+      }
+    })
+  }
+
+  /**
+   * Drains the existing mutation log in predecessor order. Independent records
+   * continue after durable conflicts/rejections; successors stay blocked.
+   * @param {object} args - Replay arguments.
+   * @param {string} args.authenticationToken - Authentication token.
+   * @param {number} [args.batchSize] - Batch size.
+   * @param {import("./sync-client-types.js").SyncClientConflictTrackingConfig} args.conflictTracking - Tracking configuration.
+   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ReturnType<typeof JSON.parse>>>}) => Promise<SyncReplayResponse>} args.postReplay - Transport boundary.
+   * @param {(identity: string) => number} args.remoteGeneration - Current remote generation.
+   * @param {string} args.resourceType - Resource whose log records should drain.
+   * @returns {Promise<void>} Resolves when no ready intent remains.
+   */
+  static async replayConflictTrackedSyncs({authenticationToken, batchSize, conflictTracking, postReplay, remoteGeneration, resourceType}) {
+    const maxBatchSize = this.normalizedBatchSize(batchSize)
+
+    while (true) {
+      const records = await conflictTracking.mutationLog.records()
+      const statuses = new Map(records.map((record) => [record.mutation.clientMutationId, record.status]))
+      const pending = records.filter((record) => record.status === "pending" && record.mutation.model === resourceType)
+      const ready = pending.filter((record) => record.dependencies.every((dependency) => statuses.get(dependency.clientMutationId) === "synced"))
+
+      if (ready.length === 0) return
+
+      const groups = this.conflictReplayGroups({pending, ready}).slice(0, maxBatchSize)
+      const generations = new Map(groups.map((group) => [group[0].mutation.clientMutationId, remoteGeneration(this.conflictRecordIdentity(group[0]))]))
+      const response = await postReplay({
+        authenticationToken,
+        syncs: groups.map((group) => this.conflictReplayPayload(group))
+      })
+
+      this.ensureSuccessfulResponse(response)
+
+      const responsesById = new Map((response.syncs || []).map((result) => [String(result.id), result]))
+
+      for (const group of groups) {
+        const result = responsesById.get(group[0].mutation.clientMutationId)
+
+        if (!result) throw new Error(`Sync response missing result for mutation ${group[0].mutation.clientMutationId}`)
+        if (!["successful", "duplicate", "conflict", "failed", "rejected"].includes(result.syncState)) {
+          throw new Error(`Invalid sync state returned for mutation ${group[0].mutation.clientMutationId}: ${result.syncState}`)
+        }
+
+        for (const record of group) {
+          await applySyncReplayResultToLocalMutationLog({mutationLog: conflictTracking.mutationLog, record, result: /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (result)})
+        }
+
+        if (["successful", "duplicate"].includes(result.syncState) && result.serverVersion !== undefined) {
+          const identity = this.conflictRecordIdentity(group[0])
+
+          if (remoteGeneration(identity) === generations.get(group[0].mutation.clientMutationId)) {
+            await this.rebaseConflictSuccessor({conflictTracking, predecessor: group[group.length - 1], serverVersion: result.serverVersion})
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Builds safe transport groups from root-ready records and their successors.
+   * @param {{pending: Array<import("./local-mutation-log.js").LocalMutationLogRecord>, ready: Array<import("./local-mutation-log.js").LocalMutationLogRecord>}} args - Pending and root-ready records.
+   * @returns {Array<Array<import("./local-mutation-log.js").LocalMutationLogRecord>>} Safe transport groups.
+   */
+  static conflictReplayGroups({pending, ready}) {
+    const groups = []
+    const selectedIdentities = new Set()
+
+    for (const record of ready) {
+      const identity = this.conflictRecordIdentity(record)
+
+      if (selectedIdentities.has(identity)) continue
+
+      const group = [record]
+      let tail = record
+
+      while (true) {
+        const successor = pending.find((candidate) => candidate.dependencies.some((dependency) => dependency.clientMutationId === tail.mutation.clientMutationId))
+
+        if (!successor || !this.canCoalesceConflictRecords(tail, successor)) break
+        group.push(successor)
+        tail = successor
+      }
+
+      groups.push(group)
+      selectedIdentities.add(identity)
+    }
+
+    return groups
+  }
+
+  /**
+   * Checks whether two durable intents can share one transport mutation.
+   * @param {import("./local-mutation-log.js").LocalMutationLogRecord} left - Earlier intent.
+   * @param {import("./local-mutation-log.js").LocalMutationLogRecord} right - Later intent.
+   * @returns {boolean} Whether scalar updates can share one transport mutation.
+   */
+  static canCoalesceConflictRecords(left, right) {
+    if (left.mutation.operation !== "update" || right.mutation.operation !== "update") return false
+    if (this.conflictRecordIdentity(left) !== this.conflictRecordIdentity(right)) return false
+    if (left.mutation.baseVersion !== right.mutation.baseVersion) return false
+    if (!this.scalarSyncAttributes(left.mutation.attributes) || !this.scalarSyncAttributes(right.mutation.attributes)) return false
+
+    return !Object.keys(left.mutation.attributes || {}).some((key) => Object.hasOwn(right.mutation.attributes || {}, key))
+  }
+
+  /**
+   * Checks whether attributes contain scalar JSON values only.
+   * @param {Record<string, import("../configuration-types.js").FrontendModelSyncJsonValue> | undefined} attributes - Attributes.
+   * @returns {boolean} Whether every value is scalar.
+   */
+  static scalarSyncAttributes(attributes) {
+    return Boolean(attributes) && Object.values(attributes || {}).every((value) => value === null || ["string", "number", "boolean"].includes(typeof value))
+  }
+
+  /**
+   * Builds one replay envelope for a safe transport group.
+   * @param {Array<import("./local-mutation-log.js").LocalMutationLogRecord>} group - Transport group.
+   * @returns {Record<string, ReturnType<typeof JSON.parse>>} Replay envelope.
+   */
+  static conflictReplayPayload(group) {
+    const first = group[0]
+    const payload = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ ({
+      baseVersion: first.mutation.baseVersion,
+      clientUpdatedAt: first.mutation.occurredAt,
+      data: Object.assign({}, ...group.map((record) => record.mutation.attributes || {})),
+      id: first.mutation.clientMutationId,
+      resourceId: first.mutation.payload?.resourceId,
+      resourceType: first.mutation.model,
+      syncType: first.mutation.payload?.syncType
+    })
+
+    return payload
+  }
+
+  /**
+   * Builds a stable resource identity for ordering and remote generations.
+   * @param {import("./local-mutation-log.js").LocalMutationLogRecord} record - Record.
+   * @returns {string} Resource identity.
+   */
+  static conflictRecordIdentity(record) {
+    return `${record.mutation.model}:${String(record.mutation.payload?.resourceId)}`
+  }
+
+  /**
+   * Rebases the direct pending successor from an authoritative acknowledgement.
+   * @param {object} args - Rebase args.
+   * @param {import("./sync-client-types.js").SyncClientConflictTrackingConfig} args.conflictTracking - Tracking config.
+   * @param {import("./local-mutation-log.js").LocalMutationLogRecord} args.predecessor - Acknowledged predecessor.
+   * @param {string | number | null} args.serverVersion - Authoritative server version.
+   * @returns {Promise<void>}
+   */
+  static async rebaseConflictSuccessor({conflictTracking, predecessor, serverVersion}) {
+    const successor = (await conflictTracking.mutationLog.pendingRecords())
+      .find((record) => record.dependencies.some((dependency) => dependency.clientMutationId === predecessor.mutation.clientMutationId))
+
+    if (!successor) return
+
+    await conflictTracking.mutationLog.updateMutation({
+      id: successor.id,
+      mutation: {...successor.mutation, baseVersion: serverVersion}
+    })
+  }
   /**
    * Serializes sync work with the same key so callers do not have to keep app-local locks.
    * @param {string} key - Lock key.

package/build/sync/sync-client-types.js

@@ -17,6 +17,20 @@
  * @property {Record<string, ReturnType<typeof JSON.parse>>} [params] - Static subscribe params. The framework injects `authenticationToken` automatically.
  */
 
+/**
+ * Durable optimistic-version tracking configuration. Identity/grant fields are
+ * retained in the shared LocalMutationLog mutation shape used by offline sync.
+ * @typedef {object} SyncClientConflictTrackingConfig
+ * @property {string} actorDeviceId - Stable device identity.
+ * @property {string} actorUserId - Stable user identity.
+ * @property {() => string} clientMutationId - Durable idempotency-id generator.
+ * @property {import("./local-mutation-log.js").default} mutationLog - Existing durable mutation log.
+ * @property {() => Date} [now] - Mutation clock.
+ * @property {string} offlineGrantId - Grant identifier retained with intent.
+ * @property {string} policyHash - Policy hash retained with intent.
+ * @property {string} [versionAttribute] - Authoritative version attribute; defaults to updatedAt when present.
+ */
+
 /**
  * Declarative per-resource sync policy.
  * @typedef {object} SyncClientResourceConfig
@@ -26,6 +40,7 @@
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["findRecordForDelete"]} [findRecordForDelete] - Custom pull-apply delete resolver.
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["afterApply"]} [afterApply] - Post-apply hook.
  * @property {string[]} [booleanAttributes] - Attributes coerced through sync boolean parsing when queueing.
+ * @property {SyncClientConflictTrackingConfig} [conflictTracking] - Opt-in durable base-version conflict tracking.
  * @property {string[]} [localOnlyAttributes] - Attributes stripped from queued payloads.
  * @property {"upsert" | ((args: {operation: "create" | "update" | "destroy", record: ReturnType<typeof JSON.parse>}) => string)} [syncType] - Maps a mutation operation to a sync type. The "upsert" flag queues creates and updates as "update" rows (the server upserts by resource id) and destroys as "delete". Defaults to the operation name with destroy mapped to "delete".
  * @property {(args: {operation: "create" | "update" | "destroy", record: ReturnType<typeof JSON.parse>}) => Record<string, ReturnType<typeof JSON.parse>>} [trackedData] - Custom queued-payload builder for tracked mutations.
@@ -42,6 +57,7 @@
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["afterApply"]} [afterApply] - Post-apply hook.
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["attributes"]} [attributes] - Pull-apply attribute mapper. Required for resources that receive pulled changes.
  * @property {string[]} [booleanAttributes] - Extra boolean attributes merged with the boolean columns derived from column types.
+ * @property {SyncClientConflictTrackingConfig} [conflictTracking] - Opt-in durable base-version conflict tracking.
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["findRecord"]} [findRecord] - Custom pull-apply record resolver.
  * @property {import("./sync-api-client-types.js").SyncResourceConfig["findRecordForDelete"]} [findRecordForDelete] - Custom pull-apply delete resolver.
  * @property {string[]} [localOnlyAttributes] - Extra local-only attributes merged with the derived primary key, createdAt/updatedAt, and sync bookkeeping attributes.