@powersync/service-core 0.0.0-dev-20250117095455 → 0.0.0-dev-20250214100224

package/src/storage/bson.ts

@@ -3,6 +3,8 @@ import * as bson from 'bson';
 import { SqliteJsonValue } from '@powersync/service-sync-rules';
 import { ReplicaId } from './BucketStorage.js';
 
+type NodeBuffer = Buffer<ArrayBuffer>;
+
 export const BSON_DESERIALIZE_OPTIONS: bson.DeserializeOptions = {
   // use bigint instead of Long
   useBigInt64: true
@@ -12,7 +14,7 @@ export const BSON_DESERIALIZE_OPTIONS: bson.DeserializeOptions = {
  * Lookup serialization must be number-agnostic. I.e. normalize numbers, instead of preserving numbers.
  * @param lookup
  */
-export const serializeLookupBuffer = (lookup: SqliteJsonValue[]): Buffer => {
+export const serializeLookupBuffer = (lookup: SqliteJsonValue[]): NodeBuffer => {
   const normalized = lookup.map((value) => {
     if (typeof value == 'number' && Number.isInteger(value)) {
       return BigInt(value);
@@ -20,7 +22,7 @@ export const serializeLookupBuffer = (lookup: SqliteJsonValue[]): Buffer => {
       return value;
     }
   });
-  return bson.serialize({ l: normalized }) as Buffer;
+  return bson.serialize({ l: normalized }) as NodeBuffer;
 };
 
 export const serializeLookup = (lookup: SqliteJsonValue[]) => {
@@ -40,8 +42,8 @@ export const isUUID = (value: any): value is bson.UUID => {
   return uuid._bsontype == 'Binary' && uuid.sub_type == bson.Binary.SUBTYPE_UUID;
 };
 
-export const serializeReplicaId = (id: ReplicaId): Buffer => {
-  return bson.serialize({ id }) as Buffer;
+export const serializeReplicaId = (id: ReplicaId): NodeBuffer => {
+  return bson.serialize({ id }) as NodeBuffer;
 };
 
 export const deserializeReplicaId = (id: Buffer): ReplicaId => {
@@ -53,8 +55,8 @@ export const deserializeBson = (buffer: Buffer) => {
   return bson.deserialize(buffer, BSON_DESERIALIZE_OPTIONS);
 };
 
-export const serializeBson = (document: any): Buffer => {
-  return bson.serialize(document) as Buffer;
+export const serializeBson = (document: any): NodeBuffer => {
+  return bson.serialize(document) as NodeBuffer;
 };
 
 /**
@@ -73,6 +75,6 @@ export const replicaIdEquals = (a: ReplicaId, b: ReplicaId) => {
     return false;
   } else {
     // There are many possible primitive values, this covers them all
-    return serializeReplicaId(a).equals(serializeReplicaId(b) as ArrayBuffer as Uint8Array);
+    return serializeReplicaId(a).equals(serializeReplicaId(b));
   }
 };

package/src/util/checkpointing.ts

@@ -0,0 +1,43 @@
+import { ErrorCode, logger, ServiceError } from '@powersync/lib-services-framework';
+import { RouteAPI } from '../api/RouteAPI.js';
+import { BucketStorageFactory } from '../storage/BucketStorage.js';
+
+export interface CreateWriteCheckpointOptions {
+  userId: string | undefined;
+  clientId: string | undefined;
+  api: RouteAPI;
+  storage: BucketStorageFactory;
+}
+export async function createWriteCheckpoint(options: CreateWriteCheckpointOptions) {
+  const full_user_id = checkpointUserId(options.userId, options.clientId);
+
+  const activeSyncRules = await options.storage.getActiveSyncRulesContent();
+  if (!activeSyncRules) {
+    throw new ServiceError(ErrorCode.PSYNC_S2302, `Cannot create Write Checkpoint since no sync rules are active.`);
+  }
+
+  using syncBucketStorage = options.storage.getInstance(activeSyncRules);
+
+  const { writeCheckpoint, currentCheckpoint } = await options.api.createReplicationHead(async (currentCheckpoint) => {
+    const writeCheckpoint = await syncBucketStorage.createManagedWriteCheckpoint({
+      user_id: full_user_id,
+      heads: { '1': currentCheckpoint }
+    });
+    return { writeCheckpoint, currentCheckpoint };
+  });
+
+  return {
+    writeCheckpoint: String(writeCheckpoint),
+    replicationHead: currentCheckpoint
+  };
+}
+
+export function checkpointUserId(user_id: string | undefined, client_id: string | undefined) {
+  if (user_id == null) {
+    throw new Error('user_id is required');
+  }
+  if (client_id == null) {
+    return user_id;
+  }
+  return `${user_id}/${client_id}`;
+}

package/src/util/config/compound-config-collector.ts

@@ -196,7 +196,8 @@ export class CompoundConfigCollector {
       }
     }
     return {
-      present: false
+      present: false,
+      exit_on_error: true
     };
   }
 }

package/src/util/config/sync-rules/impl/base64-sync-rules-collector.ts

@@ -15,6 +15,7 @@ export class Base64SyncRulesCollector extends SyncRulesCollector {
 
     return {
       present: true,
+      exit_on_error: baseConfig.sync_rules?.exit_on_error ?? true,
       content: Buffer.from(sync_rules_base64, 'base64').toString()
     };
   }

package/src/util/config/sync-rules/impl/filesystem-sync-rules-collector.ts

@@ -20,6 +20,7 @@ export class FileSystemSyncRulesCollector extends SyncRulesCollector {
     // Only persist the path here, and load on demand using `loadSyncRules()`.
     return {
       present: true,
+      exit_on_error: baseConfig.sync_rules?.exit_on_error ?? true,
       path: config_path ? path.resolve(path.dirname(config_path), sync_path) : sync_path
     };
   }

package/src/util/config/sync-rules/impl/inline-sync-rules-collector.ts

@@ -15,6 +15,7 @@ export class InlineSyncRulesCollector extends SyncRulesCollector {
 
     return {
       present: true,
+      exit_on_error: true,
       ...baseConfig.sync_rules
     };
   }

package/src/util/config/sync-rules/sync-rules-provider.ts

@@ -3,6 +3,8 @@ import fs from 'fs/promises';
 
 export interface SyncRulesProvider {
   get(): Promise<string | undefined>;
+
+  readonly exitOnError: boolean;
 }
 
 export class ConfigurationFileSyncRulesProvider implements SyncRulesProvider {
@@ -15,4 +17,8 @@ export class ConfigurationFileSyncRulesProvider implements SyncRulesProvider {
       return await fs.readFile(this.config.path, 'utf-8');
     }
   }
+
+  get exitOnError() {
+    return this.config.exit_on_error;
+  }
 }

package/src/util/config/types.ts

@@ -26,6 +26,7 @@ export type SyncRulesConfig = {
   present: boolean;
   content?: string;
   path?: string;
+  exit_on_error: boolean;
 };
 
 export type ResolvedPowerSyncConfig = {

package/src/util/memory-tracking.ts

@@ -25,8 +25,8 @@ export function trackMemoryUsage() {
   for (let key of Object.keys(bufferMemory)) {
     const typedKey = key as keyof typeof bufferMemory;
     const originalFunction = Buffer[typedKey] as (...args: any[]) => Buffer;
-    Buffer[typedKey] = function (...args: any[]) {
-      const buffer = originalFunction.apply(this, args);
+    Buffer[typedKey] = function <TArrayBuffer extends ArrayBufferLike = ArrayBufferLike>(...args: any[]) {
+      const buffer = originalFunction.apply(this, args) as Buffer<TArrayBuffer>;
       bufferMemory[typedKey] += buffer.byteLength;
       bufferRegistry.register(buffer, [typedKey, buffer.byteLength]);
       return buffer;

package/src/util/util-index.ts

@@ -5,6 +5,7 @@ export * from './Mutex.js';
 export * from './protocol-types.js';
 export * from './secs.js';
 export * from './utils.js';
+export * from './checkpointing.js';
 
 export * from './config.js';
 export * from './config/compound-config-collector.js';

package/src/util/utils.ts

@@ -7,6 +7,7 @@ import { BucketChecksum, OpId, OplogEntry } from './protocol-types.js';
 import * as storage from '../storage/storage-index.js';
 
 import { PartialChecksum } from '../storage/ChecksumCache.js';
+import { ServiceAssertionError } from '@powersync/lib-services-framework';
 
 export type ChecksumMap = Map<string, BucketChecksum>;
 
@@ -34,7 +35,7 @@ export function timestampToOpId(ts: bigint): OpId {
   // Dynamic values are passed in in some cases, so we make extra sure that the
   // number is a bigint and not number or Long.
   if (typeof ts != 'bigint') {
-    throw new Error(`bigint expected, got: ${ts} (${typeof ts})`);
+    throw new ServiceAssertionError(`bigint expected, got: ${ts} (${typeof ts})`);
   }
   return ts.toString(10);
 }
@@ -144,16 +145,6 @@ export function isCompleteRow(storeData: boolean, row: sync_rules.ToastableSqlit
   return !hasToastedValues(row);
 }
 
-export function checkpointUserId(user_id: string | undefined, client_id: string | undefined) {
-  if (user_id == null) {
-    throw new Error('user_id is required');
-  }
-  if (client_id == null) {
-    return user_id;
-  }
-  return `${user_id}/${client_id}`;
-}
-
 /**
  * Reduce a bucket to the final state as stored on the client.
  *