@powersync/service-core 1.20.5 → 1.21.0

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/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();

package/src/routes/endpoints/sync-rules.ts

@@ -43,12 +43,12 @@ export const deploySyncRules = routeDefinition({
     const { storageEngine } = service_context;
 
     if (service_context.configuration.sync_rules.present) {
-      // If sync rules are configured via the config, disable deploy via the API.
+      // If sync config is configured via the service config, disable deploy via the API.
       throw new errors.ServiceError({
         status: 422,
         code: ErrorCode.PSYNC_S4105,
-        description: 'Sync rules API disabled',
-        details: 'Use the management API to deploy sync rules'
+        description: 'Sync config API disabled',
+        details: 'Update sync config in the service configuration'
       });
     }
     const content = payload.params.content;
@@ -65,7 +65,7 @@ export const deploySyncRules = routeDefinition({
       throw new errors.ServiceError({
         status: 422,
         code: ErrorCode.PSYNC_R0001,
-        description: 'Sync rules parsing failed',
+        description: 'Sync config parsing failed',
         details: e.message
       });
     }
@@ -115,7 +115,7 @@ export const currentSyncRules = routeDefinition({
       throw new errors.ServiceError({
         status: 422,
         code: ErrorCode.PSYNC_S4104,
-        description: 'No active sync rules'
+        description: 'No active sync config'
       });
     }
 
@@ -162,13 +162,13 @@ export const reprocessSyncRules = routeDefinition({
       throw new errors.ServiceError({
         status: 422,
         code: ErrorCode.PSYNC_S4104,
-        description: 'No active sync rules'
+        description: 'No active sync config'
       });
     }
 
     const new_rules = await activeBucketStorage.updateSyncRules(
       updateSyncRulesFromYaml(sync_rules.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 rules are not valid anymore due
         // to a service change, we do want to report the error here.
         validate: true
       })

package/src/routes/endpoints/sync-stream.ts

@@ -68,7 +68,7 @@ export const syncStreamed = routeDefinition({
       throw new errors.ServiceError({
         status: 500,
         code: ErrorCode.PSYNC_S2302,
-        description: 'No sync rules available'
+        description: 'No sync config available'
       });
     }
 
@@ -121,7 +121,7 @@ export const syncStreamed = routeDefinition({
       });
 
       stream.on('end', () => {
-        // Auth failure or switch to new sync rules
+        // Auth failure or switch to new sync config
         closeReason ??= 'service closing stream';
       });
 

package/src/runner/teardown.ts

@@ -35,13 +35,13 @@ export async function teardown(runnerConfig: utils.RunnerConfig) {
 }
 
 async function terminateSyncRules(storageFactory: storage.BucketStorageFactory, moduleManager: modules.ModuleManager) {
-  logger.info(`Terminating sync rules...`);
+  logger.info(`Terminating replication stream...`);
   const start = Date.now();
   const locks: storage.ReplicationLock[] = [];
   while (Date.now() - start < 120_000) {
     let retry = false;
     const replicatingSyncRules = await storageFactory.getReplicatingSyncRules();
-    // Lock all the replicating sync rules
+    // Lock all the replicating replication streams
     for (const replicatingSyncRule of replicatingSyncRules) {
       const lock = await replicatingSyncRule.lock();
       locks.push(lock);
@@ -50,10 +50,10 @@ async function terminateSyncRules(storageFactory: storage.BucketStorageFactory,
     const stoppedSyncRules = await storageFactory.getStoppedSyncRules();
     const combinedSyncRules = [...replicatingSyncRules, ...stoppedSyncRules];
     try {
-      // Clean up any module specific configuration for the sync rules
+      // Clean up any module specific configuration for the replication stream
       await moduleManager.tearDown({ syncRules: combinedSyncRules });
 
-      // Mark the sync rules as terminated
+      // Mark the replication stream as terminated
       for (let syncRules of combinedSyncRules) {
         const syncRulesStorage = storageFactory.getInstance(syncRules);
         // The storage will be dropped at the end of the teardown, so we don't need to clear it here

package/src/storage/BucketStorage.ts

@@ -2,36 +2,36 @@ import { ToastableSqliteRow } from '@powersync/service-sync-rules';
 
 export enum SyncRuleState {
   /**
-   * New sync rules - needs to be processed (initial replication).
+   * New replication stream - needs to be processed (initial replication).
    *
-   * While multiple sets of sync rules _can_ be in PROCESSING,
+   * While multiple replication streams _can_ be in PROCESSING,
    * it's generally pointless, so we only keep one in that state.
    */
   PROCESSING = 'PROCESSING',
 
   /**
-   * Sync rule processing is done, and can be used for sync.
+   * Intial processing is done, and can be used for sync.
    *
-   * Only one set of sync rules should be in ACTIVE or ERRORED state.
+   * Only one replication stream should be in ACTIVE or ERRORED state.
    */
   ACTIVE = 'ACTIVE',
   /**
-   * This state is used when the sync rules has been replaced,
+   * This state is used when the replication stream has been replaced,
    * and replication is or should be stopped.
    */
   STOP = 'STOP',
   /**
-   * After sync rules have been stopped, the data needs to be
+   * After replication stream has been stopped, the data needs to be
    * deleted. Once deleted, the state is TERMINATED.
    */
   TERMINATED = 'TERMINATED',
 
   /**
-   * Sync rules has run into a permanent replication error. It
-   * is still the "active" sync rules for syncing to users,
+   * Replication stream has run into a permanent replication error. It
+   * is still the "active" replication stram for syncing to users,
    * but should not replicate anymore.
    *
-   * It will transition to STOP when a new sync rules is activated.
+   * It will transition to STOP when a new replication stream is activated.
    */
   ERRORED = 'ERRORED'
 }

package/src/storage/BucketStorageFactory.ts

@@ -17,17 +17,17 @@ import { SyncRulesBucketStorage } from './SyncRulesBucketStorage.js';
 /**
  * Represents a configured storage provider.
  *
- * The provider can handle multiple copies of sync rules concurrently, each with their own storage.
- * This is to handle replication of a new version of sync rules, while the old version is still active.
+ * The provider can handle multiple replication streams concurrently, each with their own storage.
+ * This is to handle replication of a new version of sync config, while the old replication stream is still active.
  *
- * Storage APIs for a specific copy of sync rules are provided by the `SyncRulesBucketStorage` instances.
+ * Storage APIs for a specific replication stream are provided by the `SyncRulesBucketStorage` instances.
  */
 export abstract class BucketStorageFactory
   extends BaseObserver<BucketStorageFactoryListener>
   implements AsyncDisposable
 {
   /**
-   * Update sync rules from configuration, if changed.
+   * Update sync config from configuration, if changed.
    */
   async configureSyncRules(
     options: UpdateSyncRulesOptions
@@ -36,42 +36,42 @@ export abstract class BucketStorageFactory
     const active = await this.getActiveSyncRulesContent();
 
     if (next?.sync_rules_content == options.config.yaml) {
-      logger.info('Sync rules from configuration unchanged');
+      logger.info('Sync config unchanged');
       return { updated: false };
     } else if (next == null && active?.sync_rules_content == options.config.yaml) {
-      logger.info('Sync rules from configuration unchanged');
+      logger.info('Sync config unchanged');
       return { updated: false };
     } else {
-      logger.info('Sync rules updated from configuration');
+      logger.info('Sync config updated');
       const persisted_sync_rules = await this.updateSyncRules(options);
       return { updated: true, persisted_sync_rules, lock: persisted_sync_rules.current_lock ?? undefined };
     }
   }
 
   /**
-   * Get a storage instance to query sync data for specific sync rules.
+   * Get a storage instance to query sync data for specific sync config.
    */
   abstract getInstance(syncRules: PersistedSyncRulesContent, options?: GetIntanceOptions): SyncRulesBucketStorage;
 
   /**
-   * Deploy new sync rules.
+   * Deploy new sync config.
    */
   abstract updateSyncRules(options: UpdateSyncRulesOptions): Promise<PersistedSyncRulesContent>;
 
   /**
    * Indicate that a slot was removed, and we should re-sync by creating
-   * a new sync rules instance.
+   * a new replication stream.
    *
    * This is roughly the same as deploying a new version of the current sync
-   * rules, but also accounts for cases where the current sync rules are not
-   * the latest ones.
+   * config, but also accounts for cases where the current sync config is not
+   * the latest one.
    *
    * Replication should be restarted after this.
    */
   abstract restartReplication(sync_rules_group_id: number): Promise<void>;
 
   /**
-   * Get the sync rules used for querying.
+   * Get the sync config used for querying.
    */
   async getActiveSyncRules(options: ParseSyncRulesOptions): Promise<PersistedSyncRules | null> {
     const content = await this.getActiveSyncRulesContent();
@@ -79,12 +79,12 @@ export abstract class BucketStorageFactory
   }
 
   /**
-   * Get the sync rules used for querying.
+   * Get the sync config used for querying.
    */
   abstract getActiveSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
 
   /**
-   * Get the sync rules that will be active next once done with initial replicatino.
+   * Get the sync config that will be active next once done with initial replicatino.
    */
   async getNextSyncRules(options: ParseSyncRulesOptions): Promise<PersistedSyncRules | null> {
     const content = await this.getNextSyncRulesContent();
@@ -92,17 +92,17 @@ export abstract class BucketStorageFactory
   }
 
   /**
-   * Get the sync rules that will be active next once done with initial replicatino.
+   * Get the sync config that will be active next once done with initial replicatino.
    */
   abstract getNextSyncRulesContent(): Promise<PersistedSyncRulesContent | null>;
 
   /**
-   * Get all sync rules currently replicating. Typically this is the "active" and "next" sync rules.
+   * Get all sync config currently replicating. Typically this is the "active" and "next" sync config.
    */
   abstract getReplicatingSyncRules(): Promise<PersistedSyncRulesContent[]>;
 
   /**
-   * Get all sync rules stopped but not terminated yet.
+   * Get all sync config stopped but not terminated yet.
    */
   abstract getStoppedSyncRules(): Promise<PersistedSyncRulesContent[]>;
 
@@ -112,12 +112,12 @@ export abstract class BucketStorageFactory
   abstract getActiveStorage(): Promise<SyncRulesBucketStorage | null>;
 
   /**
-   * Get storage size of active sync rules.
+   * Get storage size of active replication stream.
    */
   abstract getStorageMetrics(): Promise<StorageMetrics>;
 
   /**
-   * Get the unique identifier for this instance of Powersync
+   * Get the unique identifier for this instance of Powersync.
    */
   abstract getPowerSyncInstanceId(): Promise<string>;
 
@@ -161,6 +161,12 @@ export interface UpdateSyncRulesOptions {
      * compiler.
      */
     plan: SerializedSyncPlan | null;
+
+    /**
+     * Parsed sync config, primarily to generate a definition mapping.
+     * Not persisted, and the defaultSchema used for parsing is not relevant.
+     */
+    parsed: SyncConfigWithErrors;
   };
   lock?: boolean;
   storageVersion?: number;
@@ -198,10 +204,11 @@ export function updateSyncRulesFromYaml(
 }
 
 export function updateSyncRulesFromConfig(
-  { config, errors }: SyncConfigWithErrors,
+  parsed: SyncConfigWithErrors,
   options?: Omit<UpdateSyncRulesOptions, 'config'>
 ): UpdateSyncRulesOptions {
   let plan: SerializedSyncPlan | null = null;
+  const { config, errors } = parsed;
   if (config instanceof PrecompiledSyncConfig) {
     const eventDescriptors: Record<string, string[]> = {};
     for (const event of config.eventDescriptors) {
@@ -216,7 +223,7 @@ export function updateSyncRulesFromConfig(
     };
   }
 
-  return { config: { yaml: config.content, plan }, ...options };
+  return { config: { yaml: config.content, plan, parsed }, ...options };
 }
 
 export interface GetIntanceOptions {

package/src/storage/PersistedSyncRulesContent.ts

@@ -1,4 +1,4 @@
-import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
+import { logger as defaultLogger, ErrorCode, Logger, ServiceError } from '@powersync/lib-services-framework';
 import {
   CompatibilityContext,
   CompatibilityOption,
@@ -29,7 +29,7 @@ export interface PersistedSyncRulesContentData {
   readonly compiled_plan: SerializedSyncPlan | null;
   readonly slot_name: string;
   /**
-   * True if this is the "active" copy of the sync rules.
+   * True if this is the "active" copy of the sync config.
    */
   readonly active: boolean;
   readonly storageVersion: number;
@@ -49,6 +49,7 @@ export abstract class PersistedSyncRulesContent implements PersistedSyncRulesCon
   readonly slot_name!: string;
   readonly active!: boolean;
   readonly storageVersion!: number;
+  readonly logger: Logger;
 
   readonly last_checkpoint_lsn!: string | null;
 
@@ -61,6 +62,7 @@ export abstract class PersistedSyncRulesContent implements PersistedSyncRulesCon
 
   constructor(data: PersistedSyncRulesContentData) {
     Object.assign(this, data);
+    this.logger = defaultLogger.child({ prefix: `[${this.slot_name}] ` });
   }
 
   /**
@@ -73,7 +75,7 @@ export abstract class PersistedSyncRulesContent implements PersistedSyncRulesCon
     if (storageConfig == null) {
       throw new ServiceError(
         ErrorCode.PSYNC_S1005,
-        `Unsupported storage version ${this.storageVersion} for sync rules ${this.id}`
+        `Unsupported storage version ${this.storageVersion} for replication stream ${this.id}`
       );
     }
     return storageConfig;
@@ -103,6 +105,10 @@ export abstract class PersistedSyncRulesContent implements PersistedSyncRulesCon
         sourceText: this.sync_rules_content
       });
 
+      // Note: If the original content did not define a storage version, this will still set the storage version.
+      // This means asUpdateOptions will not change the storage version, even if the default changes.
+      precompiled.storageVersion = this.storageVersion;
+
       const errors: YamlError[] = [];
       if (this.compiled_plan.errors) {
         for (const error of this.compiled_plan.errors) {
@@ -144,8 +150,10 @@ export abstract class PersistedSyncRulesContent implements PersistedSyncRulesCon
   }
 
   asUpdateOptions(options?: Omit<UpdateSyncRulesOptions, 'config'>): UpdateSyncRulesOptions {
+    // defaultSchema is not relevant for the parsed version here
+    const parsed = this.parsed({ defaultSchema: 'not_applicable' });
     return {
-      config: { yaml: this.sync_rules_content, plan: this.compiled_plan },
+      config: { yaml: this.sync_rules_content, plan: this.compiled_plan, parsed: parsed.sync_rules },
       ...options
     };
   }

package/src/storage/SourceTable.ts

@@ -28,7 +28,7 @@ export class SourceTable implements SourceEntityDescriptor {
   static readonly DEFAULT_TAG = DEFAULT_TAG;
 
   /**
-   * True if the table is used in sync rules for data queries.
+   * True if the table is used in sync config for data queries.
    *
    * This value is resolved externally, and cached here.
    *
@@ -37,7 +37,7 @@ export class SourceTable implements SourceEntityDescriptor {
   public syncData = true;
 
   /**
-   * True if the table is used in sync rules for data queries.
+   * True if the table is used in sync config for data queries.
    *
    * This value is resolved externally, and cached here.
    *
@@ -46,7 +46,7 @@ export class SourceTable implements SourceEntityDescriptor {
   public syncParameters = true;
 
   /**
-   * True if the table is used in sync rules for events.
+   * True if the table is used in sync config for events.
    *
    * This value is resolved externally, and cached here.
    *

package/src/storage/StorageVersionConfig.ts

@@ -45,7 +45,7 @@ export const STORAGE_VERSION_3 = 3;
 export const LEGACY_STORAGE_VERSION = STORAGE_VERSION_1;
 
 /**
- * Default storage version for newly persisted sync rules.
+ * Default storage version for newly persisted replication streams.
  */
 export const CURRENT_STORAGE_VERSION = STORAGE_VERSION_2;