@powersync/service-core 1.20.4 → 1.21.0

package/src/api/RouteAPI.ts

@@ -14,6 +14,16 @@ export interface ReplicationLagOptions {
   bucketStorage: SyncRulesBucketStorage;
 }
 
+export interface SlotWalBudgetInfo {
+  wal_status: string;
+  safe_wal_size?: number;
+  max_slot_wal_keep_size?: number;
+}
+
+export interface SlotWalBudgetOptions {
+  slotName: string;
+}
+
 /**
  *  Describes all the methods currently required to service the sync API endpoints.
  */
@@ -33,7 +43,7 @@ export interface RouteAPI {
    * Generates replication table information from a given pattern of tables.
    *
    * @param tablePatterns A set of table patterns which typically come from
-   *          the tables listed in sync rules definitions.
+   *          the tables listed in sync config definitions.
    *
    * @param sqlSyncRules
    * @returns A result of all the tables and columns which should be replicated
@@ -49,6 +59,13 @@ export interface RouteAPI {
    */
   getReplicationLagBytes(options: ReplicationLagOptions): Promise<number | undefined>;
 
+  /**
+   * @returns WAL budget information for the replication slot, or undefined
+   *          if the slot doesn't exist or the source doesn't support this.
+   *          Only implemented by the Postgres adapter.
+   */
+  getSlotWalBudget?(options: SlotWalBudgetOptions): Promise<SlotWalBudgetInfo | undefined>;
+
   /**
    * Get the current LSN or equivalent replication HEAD position identifier.
    *
@@ -59,7 +76,7 @@ export interface RouteAPI {
 
   /**
    * @returns The schema for tables inside the connected database. This is typically
-   *          used to validate sync rules.
+   *          used to validate sync config.
    */
   getConnectionSchema(): Promise<types.DatabaseSchema[]>;
 
@@ -75,7 +92,7 @@ export interface RouteAPI {
   shutdown(): Promise<void>;
 
   /**
-   * Get the default schema (or database) when only a table name is specified in sync rules.
+   * Get the default schema (or database) when only a table name is specified in sync config.
    */
   getParseSyncRulesOptions(): ParseSyncRulesOptions;
 }

package/src/api/api-index.ts

@@ -1,4 +1,4 @@
+export * from './api-metrics.js';
 export * from './diagnostics.js';
 export * from './RouteAPI.js';
 export * from './schema.js';
-export * from './api-metrics.js';

package/src/api/api-metrics.ts

@@ -1,5 +1,5 @@
-import { MetricsEngine } from '../metrics/MetricsEngine.js';
 import { APIMetric } from '@powersync/service-types';
+import { MetricsEngine } from '../metrics/MetricsEngine.js';
 
 /**
  *  Create and register the core API metrics.

package/src/api/diagnostics.ts

@@ -1,13 +1,14 @@
 import { logger } from '@powersync/lib-services-framework';
-import { DEFAULT_TAG, SourceTableInterface, SqlSyncRules, SyncConfigWithErrors } from '@powersync/service-sync-rules';
+import { DEFAULT_TAG, SourceTableInterface, SyncConfigWithErrors } from '@powersync/service-sync-rules';
 import { ReplicationError, SyncRulesStatus, TableInfo } from '@powersync/service-types';
 
 import * as storage from '../storage/storage-index.js';
-import { RouteAPI } from './RouteAPI.js';
+import { syncConfigYamlErrorToReplicationError } from '../util/errors.js';
+import { RouteAPI, SlotWalBudgetInfo } from './RouteAPI.js';
 
 export interface DiagnosticsOptions {
   /**
-   * Include sync rules content in response.
+   * Include sync config content in response.
    */
   include_content?: boolean;
 
@@ -62,6 +63,7 @@ export async function getSyncRulesStatus(
   const systemStorage = live_status ? bucketStorage.getInstance(sync_rules) : undefined;
   const status = await systemStorage?.getStatus();
   let replication_lag_bytes: number | undefined = undefined;
+  let slot_wal_budget: SlotWalBudgetInfo | undefined = undefined;
 
   let tables_flat: TableInfo[] = [];
 
@@ -87,6 +89,16 @@ export async function getSyncRulesStatus(
         // Ignore
         logger.warn(`Unable to get replication lag`, e);
       }
+
+      if (apiHandler.getSlotWalBudget && sync_rules.slot_name) {
+        try {
+          slot_wal_budget = await apiHandler.getSlotWalBudget({
+            slotName: sync_rules.slot_name
+          });
+        } catch (e) {
+          logger.warn(`Unable to get WAL budget`, e);
+        }
+      }
     }
   } else {
     const source_table_patterns = rules.getSourceTables();
@@ -131,26 +143,33 @@ export async function getSyncRulesStatus(
       ts: sync_rules.last_fatal_error_ts?.toISOString()
     });
   }
-  errors.push(
-    ...syncRuleErrors.map(({ type, message, location }) => {
-      const error: ReplicationError = {
-        level: type,
-        message,
+  errors.push(...syncRuleErrors.map((error) => syncConfigYamlErrorToReplicationError(error, now)));
+
+  if (
+    slot_wal_budget &&
+    slot_wal_budget.wal_status !== 'lost' &&
+    slot_wal_budget.safe_wal_size != null &&
+    slot_wal_budget.max_slot_wal_keep_size != null &&
+    slot_wal_budget.max_slot_wal_keep_size > 0
+  ) {
+    const budgetPct = Math.max(
+      0,
+      Math.round((slot_wal_budget.safe_wal_size / slot_wal_budget.max_slot_wal_keep_size) * 100)
+    );
+    if (budgetPct <= 50) {
+      errors.push({
+        level: 'warning',
+        message:
+          `WAL budget is low: ${budgetPct}% remaining. ` +
+          `The replication slot may be invalidated if WAL consumption ` +
+          `continues at this rate. Consider increasing max_slot_wal_keep_size.`,
         ts: now
-      };
-      if (location != null) {
-        error.location = {
-          start_offset: location.start,
-          end_offset: location.end
-        };
-      }
-
-      return error;
-    })
-  );
+      });
+    }
+  }
 
   if (live_status && status?.active) {
-    // Check replication lag for active sync rules.
+    // Check replication lag for active replication stream.
     // Right now we exclude mysql, since it we don't have consistent keepalives for it.
     if (sync_rules.last_checkpoint_ts == null && sync_rules.last_keepalive_ts == null) {
       errors.push({
@@ -197,6 +216,9 @@ export async function getSyncRulesStatus(
         last_checkpoint_ts: sync_rules.last_checkpoint_ts?.toISOString(),
         last_keepalive_ts: sync_rules.last_keepalive_ts?.toISOString(),
         replication_lag_bytes: replication_lag_bytes,
+        wal_status: slot_wal_budget?.wal_status,
+        safe_wal_size: slot_wal_budget?.safe_wal_size,
+        max_slot_wal_keep_size: slot_wal_budget?.max_slot_wal_keep_size,
         tables: tables_flat
       }
     ],

package/src/auth/CachedKeyCollector.ts

@@ -1,9 +1,8 @@
-import * as jose from 'jose';
+import { AuthorizationError, ErrorCode, logger } from '@powersync/lib-services-framework';
 import timers from 'timers/promises';
+import { KeyCollector, KeyResult } from './KeyCollector.js';
 import { KeySpec } from './KeySpec.js';
 import { LeakyBucket } from './LeakyBucket.js';
-import { KeyCollector, KeyResult } from './KeyCollector.js';
-import { AuthorizationError, ErrorCode, logger } from '@powersync/lib-services-framework';
 import { mapAuthConfigError } from './utils.js';
 
 /**

package/src/auth/CompoundKeyCollector.ts

@@ -1,7 +1,6 @@
-import * as jose from 'jose';
-import { KeySpec } from './KeySpec.js';
-import { KeyCollector, KeyResult } from './KeyCollector.js';
 import { AuthorizationError } from '@powersync/lib-services-framework';
+import { KeyCollector, KeyResult } from './KeyCollector.js';
+import { KeySpec } from './KeySpec.js';
 
 export class CompoundKeyCollector implements KeyCollector {
   private collectors: KeyCollector[];

package/src/auth/KeyStore.ts

@@ -4,7 +4,7 @@ import secs from '../util/secs.js';
 import { JwtPayload } from './JwtPayload.js';
 import { KeyCollector } from './KeyCollector.js';
 import { KeyOptions, KeySpec, SUPPORTED_ALGORITHMS } from './KeySpec.js';
-import { debugKeyNotFound, mapAuthError, SupabaseAuthDetails, tokenDebugDetails } from './utils.js';
+import { debugKeyNotFound, mapAuthError, SupabaseAuthDetails } from './utils.js';
 
 /**
  * KeyStore to get keys and verify tokens.

package/src/auth/RemoteJWKSCollector.ts

@@ -1,6 +1,5 @@
 import * as http from 'http';
 import * as https from 'https';
-import * as jose from 'jose';
 import fetch from 'node-fetch';
 
 import {

package/src/auth/StaticKeyCollector.ts

@@ -1,6 +1,6 @@
 import * as jose from 'jose';
-import { KeySpec } from './KeySpec.js';
 import { KeyCollector, KeyResult } from './KeyCollector.js';
+import { KeySpec } from './KeySpec.js';
 
 /**
  * Set of static keys.

package/src/auth/StaticSupabaseKeyCollector.ts

@@ -1,6 +1,6 @@
 import * as jose from 'jose';
-import { KeySpec, KeyOptions } from './KeySpec.js';
 import { KeyCollector, KeyResult } from './KeyCollector.js';
+import { KeyOptions, KeySpec } from './KeySpec.js';
 
 export const SUPABASE_KEY_OPTIONS: KeyOptions = {
   requiresAudience: ['authenticated'],

package/src/entry/commands/teardown-action.ts

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
 
+import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
 import { teardown } from '../../runner/teardown.js';
 import { extractRunnerOptions, wrapConfigCommand } from './config-command.js';
-import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
 
 const COMMAND_NAME = 'teardown';
 
@@ -13,7 +13,7 @@ export function registerTearDownAction(program: Command) {
 
   return teardownCommand
     .argument('[ack]', 'Type `TEARDOWN` to confirm teardown should occur')
-    .description('Terminate all replicating sync rules, clear remote configuration and remove all data')
+    .description('Terminate all replicating replication streams, clear remote configuration and remove all data')
     .action(async (ack, options) => {
       if (ack !== 'TEARDOWN') {
         throw new ServiceError(ErrorCode.PSYNC_S0102, 'TEARDOWN was not acknowledged.');

package/src/entry/entry-index.ts

@@ -1,6 +1,6 @@
 export * from './cli-entry.js';
+export * from './commands/compact-action.js';
 export * from './commands/config-command.js';
 export * from './commands/migrate-action.js';
 export * from './commands/start-action.js';
 export * from './commands/teardown-action.js';
-export * from './commands/compact-action.js';

package/src/events/EventsEngine.ts

@@ -1,6 +1,6 @@
-import EventEmitter from 'node:events';
 import { logger } from '@powersync/lib-services-framework';
 import { event_types } from '@powersync/service-types';
+import EventEmitter from 'node:events';
 
 export class EventsEngine {
   private emitter: EventEmitter;

package/src/index.ts

@@ -42,4 +42,6 @@ export * as utils from './util/util-index.js';
 export * from './streams/streams-index.js';
 export * as streams from './streams/streams-index.js';
 
+export * from './tracing/PerformanceTracer.js';
+
 export * as bson from 'bson';

package/src/metrics/MetricsEngine.ts

@@ -1,5 +1,5 @@
 import { logger, ServiceAssertionError } from '@powersync/lib-services-framework';
-import { Counter, UpDownCounter, ObservableGauge, MetricMetadata, MetricsFactory } from './metrics-interfaces.js';
+import { Counter, MetricMetadata, MetricsFactory, ObservableGauge, UpDownCounter } from './metrics-interfaces.js';
 
 export interface MetricsEngineOptions {
   factory: MetricsFactory;

package/src/metrics/metrics-index.ts

@@ -1,6 +1,6 @@
-export * from './MetricsEngine.js';
 export * from './metrics-interfaces.js';
-export * from './RollingBucketMax.js';
-export * from './register-metrics.js';
+export * from './MetricsEngine.js';
 export * from './open-telemetry/OpenTelemetryMetricsFactory.js';
 export * from './open-telemetry/util.js';
+export * from './register-metrics.js';
+export * from './RollingBucketMax.js';

package/src/metrics/open-telemetry/util.ts

@@ -6,8 +6,8 @@ import { ServiceContext } from '../../system/ServiceContext.js';
 import { MetricsFactory } from '../metrics-interfaces.js';
 import { OpenTelemetryMetricsFactory } from './OpenTelemetryMetricsFactory.js';
 
-import pkg from '../../../package.json' with { type: 'json' };
 import { resourceFromAttributes } from '@opentelemetry/resources';
+import pkg from '../../../package.json' with { type: 'json' };
 
 export function createOpenTelemetryMetricsFactory(context: ServiceContext): MetricsFactory {
   const { configuration, lifeCycleEngine, storageEngine } = context;

package/src/metrics/register-metrics.ts

@@ -1,9 +1,9 @@
-import { ServiceContextContainer } from '../system/ServiceContext.js';
-import { createOpenTelemetryMetricsFactory } from './open-telemetry/util.js';
-import { MetricsEngine } from './MetricsEngine.js';
 import { createCoreAPIMetrics, initializeCoreAPIMetrics } from '../api/api-metrics.js';
 import { createCoreReplicationMetrics, initializeCoreReplicationMetrics } from '../replication/replication-metrics.js';
 import { createCoreStorageMetrics, initializeCoreStorageMetrics } from '../storage/storage-metrics.js';
+import { ServiceContextContainer } from '../system/ServiceContext.js';
+import { MetricsEngine } from './MetricsEngine.js';
+import { createOpenTelemetryMetricsFactory } from './open-telemetry/util.js';
 
 export enum MetricModes {
   API = 'api',

package/src/modules/AbstractModule.ts

@@ -1,11 +1,11 @@
-import { ServiceContextContainer } from '../system/ServiceContext.js';
 import { logger } from '@powersync/lib-services-framework';
 import winston from 'winston';
 import { PersistedSyncRulesContent } from '../storage/storage-index.js';
+import { ServiceContextContainer } from '../system/ServiceContext.js';
 
 export interface TearDownOptions {
   /**
-   *  If required, tear down any configuration/state for the specific sync rules
+   *  If required, tear down any configuration/state for the specific replication stream
    */
   syncRules?: PersistedSyncRulesContent[];
 }

package/src/modules/modules-index.ts

@@ -1,3 +1,3 @@
-export * from './ModuleManager.js';
 export * from './AbstractModule.js';
 export * from './loader.js';
+export * from './ModuleManager.js';

package/src/replication/AbstractReplicationJob.ts

@@ -1,8 +1,8 @@
 import { container, logger } from '@powersync/lib-services-framework';
 import winston from 'winston';
+import { MetricsEngine } from '../metrics/MetricsEngine.js';
 import * as storage from '../storage/storage-index.js';
 import { ErrorRateLimiter } from './ErrorRateLimiter.js';
-import { MetricsEngine } from '../metrics/MetricsEngine.js';
 
 export interface AbstractReplicationJobOptions {
   id: string;
@@ -54,7 +54,7 @@ export abstract class AbstractReplicationJob {
    *  Safely stop the replication process
    */
   public async stop(): Promise<void> {
-    this.logger.info(`Stopping replication job for sync rule iteration: ${this.storage.group_id}`);
+    this.logger.info(`Stopping replication job`);
     this.abortController.abort();
     await this.isReplicatingPromise;
   }

package/src/replication/AbstractReplicator.ts

@@ -32,19 +32,19 @@ export interface AbstractReplicatorOptions {
 /**
  *   A replicator manages the mechanics for replicating data from a data source to a storage bucket.
  *   This includes copying across the original data set and then keeping it in sync with the data source using Replication Jobs.
- *   It also handles any changes to the sync rules.
+ *   It also handles any changes to the sync config.
  */
 export abstract class AbstractReplicator<T extends AbstractReplicationJob = AbstractReplicationJob> {
   protected logger: winston.Logger;
   private lockAlerted: boolean = false;
   /**
-   *  Map of replication jobs by sync rule id. Usually there is only one running job, but there could be two when
-   *  transitioning to a new set of sync rules.
+   *  Map of replication jobs by replication stream id. Usually there is only one running job, but there could be two when
+   *  transitioning to a new replication stream.
    */
   private replicationJobs = new Map<number, T>();
 
   /**
-   * Map of sync rule ids to promises that are clearing the sync rule configuration.
+   * Map of replciation stream ids to promises that are clearing the replication stream.
    *
    * We primarily do this to keep track of what we're currently clearing, but don't currently
    * use the Promise value.
@@ -68,8 +68,8 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
   abstract createJob(options: CreateJobOptions): T;
 
   /**
-   *  Clean up any configuration or state for the specified sync rule on the datasource.
-   *  Should be a no-op if the configuration has already been cleared
+   * Clean up any configuration or state for the specified replication stream on the datasource.
+   * Should be a no-op if the replication stream has already been cleared
    */
   abstract cleanUp(syncRuleStorage: storage.SyncRulesBucketStorage): Promise<void>;
 
@@ -100,7 +100,7 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
   public async start(): Promise<void> {
     this.abortController = new AbortController();
     this.runLoop().catch((e) => {
-      this.logger.error('Data source fatal replication error', e);
+      this.logger.error('Fatal replication error', e);
       container.reporter.captureException(e);
       setTimeout(() => {
         process.exit(1);
@@ -135,9 +135,9 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
 
     let configuredLock: storage.ReplicationLock | undefined = undefined;
     if (syncRules != null) {
-      this.logger.info('Loaded sync rules');
+      this.logger.info('Loaded sync config');
       try {
-        // Configure new sync rules, if they have changed.
+        // Configure new sync config, if they have changed.
         // In that case, also immediately take out a lock, so that another process doesn't start replication on it.
 
         const { lock } = await this.storage.configureSyncRules(
@@ -149,11 +149,11 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
       } catch (e) {
         // Log and re-raise to exit.
         // Should only reach this due to validation errors if exit_on_error is true.
-        this.logger.error(`Failed to update sync rules from configuration`, e);
+        this.logger.error(`Failed to update sync config`, e);
         throw e;
       }
     } else {
-      this.logger.info('No sync rules configured - configure via API');
+      this.logger.info('No sync streams or rules configured - configure via API');
     }
     while (!this.stopped) {
       await container.probes.touch();
@@ -206,7 +206,7 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
         // Remove from the list. Next refresh call will restart the job.
         existingJobs.delete(syncRules.id);
       } else {
-        // New sync rules were found (or resume after restart)
+        // New sync config was found (or resume after restart)
         try {
           let lock: storage.ReplicationLock;
           if (configuredLock?.sync_rules_id == syncRules.id) {
@@ -229,15 +229,15 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
         } catch (e) {
           if (e?.errorData?.code === ErrorCode.PSYNC_S1003) {
             if (!this.lockAlerted) {
-              this.logger.info(`[${e.errorData.code}] ${e.errorData.description}`);
+              syncRules.logger.info(`[${e.errorData.code}] ${e.errorData.description}`);
               this.lockAlerted = true;
             }
           } else {
-            // Could be a sync rules parse error,
+            // Could be a sync config parse error,
             // for example from stricter validation that was added.
             // This will be retried every couple of seconds.
-            // When new (valid) sync rules are deployed and processed, this one be disabled.
-            this.logger.error('Failed to start replication for new sync rules', e);
+            // When new (valid) sync config is deployed and processed, this one be disabled.
+            syncRules.logger.error('Failed to start replication for new sync config', e);
           }
         }
       }
@@ -246,7 +246,7 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
     this.replicationJobs = newJobs;
     this.activeReplicationJob = activeJob;
 
-    // Stop any orphaned jobs that no longer have sync rules.
+    // Stop any orphaned jobs that no longer have a replication stream.
     // Termination happens below
     for (let job of existingJobs.values()) {
       // Old - stop and clean up
@@ -254,11 +254,11 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
         await job.stop();
       } catch (e) {
         // This will be retried
-        this.logger.warn('Failed to stop old replication job}', e);
+        job.storage.logger.warn('Failed to stop old replication job', e);
       }
     }
 
-    // Sync rules stopped previously, including by a different process.
+    // Replication stream stopped previously, including by a different process.
     const stopped = await this.storage.getStoppedSyncRules();
     for (let syncRules of stopped) {
       if (this.clearingJobs.has(syncRules.id)) {
@@ -268,11 +268,11 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
 
       // We clear storage asynchronously.
       // It is important to be able to continue running the refresh loop, otherwise we cannot
-      // retry locked sync rules, for example.
+      // retry locked replication stream, for example.
       const syncRuleStorage = this.storage.getInstance(syncRules, { skipLifecycleHooks: true });
       const promise = this.terminateSyncRules(syncRuleStorage)
         .catch((e) => {
-          this.logger.warn(`Failed clean up replication config for sync rule: ${syncRules.id}`, e);
+          syncRuleStorage.logger.warn(`Failed clean up replication config`, e);
         })
         .finally(() => {
           this.clearingJobs.delete(syncRules.id);
@@ -286,12 +286,12 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
   }
 
   protected async terminateSyncRules(syncRuleStorage: storage.SyncRulesBucketStorage) {
-    this.logger.info(`Terminating sync rules: ${syncRuleStorage.group_id}...`);
+    syncRuleStorage.logger.info(`Terminating replication stream...`);
     // This deletes postgres replication slots - should complete quickly.
     // It is safe to do before or after clearing the data in the storage.
     await this.cleanUp(syncRuleStorage);
     await syncRuleStorage.terminate({ signal: this.abortController?.signal, clearStorage: true });
-    this.logger.info(`Successfully terminated sync rules: ${syncRuleStorage.group_id}`);
+    syncRuleStorage.logger.info(`Successfully terminated replication stream`);
   }
 
   abstract testConnection(): Promise<ConnectionTestResult>;

package/src/replication/replication-index.ts

@@ -1,8 +1,8 @@
 export * from './AbstractReplicationJob.js';
 export * from './AbstractReplicator.js';
 export * from './ErrorRateLimiter.js';
-export * from './ReplicationLagTracker.js';
+export * from './RelationCache.js';
+export * from './replication-metrics.js';
 export * from './ReplicationEngine.js';
+export * from './ReplicationLagTracker.js';
 export * from './ReplicationModule.js';
-export * from './replication-metrics.js';
-export * from './RelationCache.js';

package/src/replication/replication-metrics.ts

@@ -1,5 +1,5 @@
-import { MetricsEngine } from '../metrics/metrics-index.js';
 import { ReplicationMetric } from '@powersync/service-types';
+import { MetricsEngine } from '../metrics/metrics-index.js';
 
 /**
  *  Create and register the core replication metrics.

package/src/routes/endpoints/admin.ts

@@ -119,7 +119,7 @@ export const reprocess = routeDefinition({
     const apiHandler = service_context.routerEngine.getAPI();
     const next = await activeBucketStorage.getNextSyncRules(apiHandler.getParseSyncRulesOptions());
     if (next != null) {
-      throw new Error(`Busy processing sync rules - cannot reprocess`);
+      throw new Error(`Busy processing sync config - cannot reprocess`);
     }
 
     const active = await activeBucketStorage.getActiveSyncRules(apiHandler.getParseSyncRulesOptions());
@@ -127,13 +127,17 @@ export const reprocess = routeDefinition({
       throw new errors.ServiceError({
         status: 422,
         code: ErrorCode.PSYNC_S4104,
-        description: 'No active sync rules'
+        description: 'No active sync config'
       });
     }
 
+    // There are some differences between this and using asUpdateOptions():
+    // 1. This always re-parses the source YAML. If there are changes to the sync stream compiler, that can affect the sync plan.
+    // 2. If the source does not set the storage version, this will update it do the current version.
+    // We can consider tweaking this behavior in the future.
     const new_rules = await activeBucketStorage.updateSyncRules(
       storage.updateSyncRulesFromYaml(active.sync_rules.config.content, {
-        // These sync rules already passed validation. But if the rules are not valid anymore due
+        // This sync config already passed validation. But if the config is not valid anymore due
         // to a service change, we do want to report the error here.
         validate: true
       })

package/src/routes/endpoints/checkpointing.ts

@@ -33,7 +33,7 @@ export const writeCheckpoint = routeDefinition({
       const bucketStorage = await service_context.storageEngine.activeBucketStorage.getActiveStorage();
       const cp = await bucketStorage?.getCheckpoint();
       if (cp == null) {
-        throw new Error('No sync rules available');
+        throw new Error('No sync config available');
       }
       if (cp.lsn && cp.lsn >= head) {
         logger.info(`Got write checkpoint: ${head} : ${cp.checkpoint}`);

package/src/routes/endpoints/socket-route.ts

@@ -77,7 +77,7 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
           new errors.ServiceError({
             status: 500,
             code: ErrorCode.PSYNC_S2302,
-            description: 'No sync rules available'
+            description: 'No sync config available'
           })
         );
         responder.onComplete();