@powersync/service-core 1.27.0 → 1.27.1

package/src/routes/endpoints/admin.ts

@@ -8,11 +8,12 @@ import {
   SqlSyncRules,
   StaticSchema
 } from '@powersync/service-sync-rules';
-import { internal_routes } from '@powersync/service-types';
+import { internal_routes, ServiceInfo } from '@powersync/service-types';
 
 import { DEFAULT_HYDRATION_STATE } from '@powersync/service-sync-rules';
 import * as api from '../../api/api-index.js';
 import * as storage from '../../storage/storage-index.js';
+import { POWERSYNC_VERSION } from '../../util/version.js';
 import { authApi } from '../auth.js';
 import { routeDefinition } from '../router.js';
 
@@ -58,19 +59,28 @@ export const diagnostics = routeDefinition({
     const { context } = payload;
     const { service_context } = context;
     const include_content = payload.params.sync_rules_content ?? false;
+    const serviceResponse: { service: ServiceInfo } = {
+      service: {
+        version: POWERSYNC_VERSION
+      }
+    };
 
     const apiHandler = service_context.routerEngine.getAPI();
 
     const status = await apiHandler.getConnectionStatus();
     if (!status) {
       return internal_routes.DiagnosticsResponse.encode({
+        ...serviceResponse,
         connections: []
       });
     }
 
     const {
-      storageEngine: { activeBucketStorage }
+      storageEngine: { activeBucketStorage },
+      configuration
     } = service_context;
+
+    const sync_config_source = configuration?.sync_rules.present ? 'config' : 'api';
     const active = await activeBucketStorage.getActiveSyncConfig();
     const deploying = await activeBucketStorage.getDeployingSyncConfig();
 
@@ -102,6 +112,7 @@ export const diagnostics = routeDefinition({
           );
 
     return internal_routes.DiagnosticsResponse.encode({
+      ...serviceResponse,
       connections: [
         {
           ...status,
@@ -110,7 +121,8 @@ export const diagnostics = routeDefinition({
         }
       ],
       active_sync_rules: active_status,
-      deploying_sync_rules: deploying_status
+      deploying_sync_rules: deploying_status,
+      sync_config_source
     });
   }
 });
@@ -161,11 +173,18 @@ export const reprocess = routeDefinition({
     // 1. This always re-parses the source YAML. If there are changes to the Sync Streams 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 parsed = SqlSyncRules.fromYaml(active.content.sync_rules_content, {
+      ...apiHandler.getParseSyncRulesOptions(),
+      schema: undefined,
+      // 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.
+      throwOnError: true
+    });
+    storage.logSyncConfigErrors(parsed);
+    await api.assertSourceCapabilities(apiHandler, parsed.config);
+
     const new_rules = await activeBucketStorage.updateSyncRules(
-      storage.updateSyncRulesFromYaml(active.content.sync_rules_content, {
-        // 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,
+      storage.updateSyncRulesFromConfig(parsed, {
         version_label: active.content.version_label,
         forceNewReplicationStream: true
       })
@@ -188,7 +207,6 @@ export const reprocess = routeDefinition({
 
 class FakeSyncRulesContentForValidation extends storage.PersistedSyncConfigContent {
   constructor(
-    private readonly apiHandler: api.RouteAPI,
     private readonly schema: SourceSchema,
     data: storage.PersistedSyncConfigContentData
   ) {
@@ -197,7 +215,7 @@ class FakeSyncRulesContentForValidation extends storage.PersistedSyncConfigConte
 
   parsed(options: storage.ParseSyncConfigOptions): storage.ParsedSyncConfigSet {
     const syncConfig = SqlSyncRules.fromYaml(this.sync_rules_content, {
-      ...this.apiHandler.getParseSyncRulesOptions(),
+      ...options,
       schema: this.schema
     });
 
@@ -237,7 +255,7 @@ export const validate = routeDefinition({
     const schemaData = await api.getConnectionsSchema(apiHandler);
     const schema = new StaticSchema(schemaData.connections);
 
-    const sync_rules = new FakeSyncRulesContentForValidation(apiHandler, schema, {
+    const sync_rules = new FakeSyncRulesContentForValidation(schema, {
       // Dummy values
       replicationStreamId: 0,
       replicationStreamName: '',

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

@@ -2,9 +2,10 @@ import { ErrorCode, errors, router, schema } from '@powersync/lib-services-frame
 import { SqlSyncRules, SyncConfigWithErrors, SyncRulesErrors } from '@powersync/service-sync-rules';
 import type { FastifyPluginAsync } from 'fastify';
 import * as t from 'ts-codec';
+import { assertSourceCapabilities } from '../../api/source-capabilities.js';
 
-import { RouteAPI } from '../../api/RouteAPI.js';
-import { updateSyncRulesFromConfig, updateSyncRulesFromYaml } from '../../storage/BucketStorageFactory.js';
+import { PatternResult, RouteAPI } from '../../api/RouteAPI.js';
+import { logSyncConfigErrors, updateSyncRulesFromConfig } from '../../storage/BucketStorageFactory.js';
 import { authApi } from '../auth.js';
 import { routeDefinition } from '../router.js';
 
@@ -55,6 +56,7 @@ export const deploySyncRules = routeDefinition({
     let syncConfig: SyncConfigWithErrors;
 
     try {
+      // First ensure the SyncConfig parses correctly
       const apiHandler = service_context.routerEngine.getAPI();
       syncConfig = SqlSyncRules.fromYaml(content, {
         ...apiHandler.getParseSyncRulesOptions(),
@@ -70,6 +72,10 @@ export const deploySyncRules = routeDefinition({
       });
     }
 
+    logSyncConfigErrors(syncConfig);
+    // Validate if the current sources support the configuration specified in the sync config
+    await assertSourceCapabilities(service_context.routerEngine.getAPI(), syncConfig.config);
+
     const sync_rules = await storageEngine.activeBucketStorage.updateSyncRules(updateSyncRulesFromConfig(syncConfig));
 
     return {
@@ -176,11 +182,18 @@ export const reprocessSyncRules = routeDefinition({
     }
 
     const sync_rules = active.content;
+    const parsed = SqlSyncRules.fromYaml(sync_rules.sync_rules_content, {
+      ...payload.context.service_context.routerEngine.getAPI().getParseSyncRulesOptions(),
+      schema: undefined,
+      // 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.
+      throwOnError: true
+    });
+    logSyncConfigErrors(parsed);
+    await assertSourceCapabilities(payload.context.service_context.routerEngine.getAPI(), parsed.config);
+
     const new_rules = await activeBucketStorage.updateSyncRules(
-      updateSyncRulesFromYaml(sync_rules.sync_rules_content, {
-        // 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,
+      updateSyncRulesFromConfig(parsed, {
         version_label: sync_rules.version_label,
         forceNewReplicationStream: true
       })
@@ -208,11 +221,31 @@ async function debugSyncRules(apiHandler: RouteAPI, sync_rules: string) {
       // No schema-based validation at this point
       schema: undefined
     });
-    const source_table_patterns = rules.config.getSourceTables();
-    const resolved_tables = await apiHandler.getDebugTablesInfo(source_table_patterns, rules.config);
+    const errors: string[] = [];
+    const warnings = rules.errors.filter((error) => error.type === 'warning').map((error) => error.message);
+    const recordError = (error: any) => {
+      errors.push(...(error instanceof SyncRulesErrors ? error.errors.map((e) => e.message) : [error.message]));
+    };
+    try {
+      const diagnostics = (await apiHandler.validateSourceCapabilities?.(rules.config)) ?? [];
+      for (const diagnostic of diagnostics) {
+        (diagnostic.level === 'fatal' ? errors : warnings).push(diagnostic.message);
+      }
+    } catch (e) {
+      recordError(e);
+    }
+    let resolved_tables: PatternResult[] = [];
+    try {
+      const source_table_patterns = rules.config.getSourceTables();
+      resolved_tables = await apiHandler.getDebugTablesInfo(source_table_patterns, rules.config);
+    } catch (e) {
+      recordError(e);
+    }
 
     return {
-      valid: true,
+      valid: errors.length == 0,
+      ...(warnings.length > 0 ? { warnings } : {}),
+      ...(errors.length > 0 ? { errors } : {}),
       bucket_definitions: rules.config.debugRepresentation(),
       source_tables: resolved_tables,
       data_tables: rules.config.debugGetOutputTables()

package/src/storage/BucketStorageFactory.ts

@@ -227,14 +227,15 @@ export function updateSyncRulesFromYaml(
   content: string,
   options?: Omit<UpdateSyncRulesOptions, 'config'> & { validate?: boolean }
 ): UpdateSyncRulesOptions {
+  const { validate, ...updateOptions } = options ?? {};
   const config = SqlSyncRules.fromYaml(content, {
     // No schema-based validation at this point
     schema: undefined,
     defaultSchema: options?.defaultSchema ?? 'not_applicable', // Not needed for validation
-    throwOnError: options?.validate ?? false
+    throwOnError: validate ?? false
   });
 
-  return updateSyncRulesFromConfig(config, options);
+  return updateSyncRulesFromConfig(config, updateOptions);
 }
 
 export function updateSyncRulesFromConfig(
@@ -261,6 +262,25 @@ export function updateSyncRulesFromConfig(
   return { config: { yaml: config.content, plan, parsed }, ...options };
 }
 
+/**
+ * Logs the errors and warnings of a parsed sync config
+ *
+ * Call this where a sync config is loaded or deployed, so that operators see these in the service logs and not only
+ * in the diagnostics and validate API responses.
+ *
+ * Fatal errors usually throw during parsing before this is reached. They can reach this when the sync config is parsed
+ * without validation, such as at startup with `exit_on_error: false`.
+ */
+export function logSyncConfigErrors(parsed: SyncConfigWithErrors, log: typeof logger = logger) {
+  for (const error of parsed.errors) {
+    if (error.type == 'warning') {
+      log.warn(`Sync config warning: ${error.message}`);
+    } else {
+      log.error(`Sync config error: ${error.message}`);
+    }
+  }
+}
+
 export interface GetIntanceOptions {
   /**
    * The job lease, including a lease acquired during initial configuration.

package/src/storage/PersistedSyncConfigContent.ts

@@ -10,6 +10,7 @@ import {
   HydrationState,
   nodeSqlite,
   PrecompiledSyncConfig,
+  SourceConnectionMap,
   SqlSyncRules,
   SyncConfigWithErrors,
   versionedHydrationState,
@@ -202,6 +203,8 @@ export interface PersistedSyncConfigContentData {
   readonly version_label?: string;
 }
 export type PersistedSyncConfigId = string;
+
 export interface ParseSyncConfigOptions {
   defaultSchema: string;
+  connections?: SourceConnectionMap;
 }

package/src/storage/StorageProvider.ts

@@ -31,5 +31,8 @@ export interface StorageProvider {
    */
   type: string;
 
+  /**
+   * Creates active storage during storage-engine startup.
+   */
   getStorage(options: GetStorageOptions): Promise<ActiveStorage>;
 }

package/src/storage/SyncRulesBucketStorage.ts

@@ -11,7 +11,7 @@ import * as util from '../util/util-index.js';
 import { BucketStorageBatch, FlushedResult, SaveUpdate } from './BucketStorageBatch.js';
 import { BucketStorageFactory } from './BucketStorageFactory.js';
 import { ParsedSyncConfigSet } from './ParsedSyncConfigSet.js';
-import { ParseSyncConfigOptions } from './PersistedSyncConfigContent.js';
+import type { ParseSyncConfigOptions } from './PersistedSyncConfigContent.js';
 import { SourceEntityDescriptor } from './SourceEntity.js';
 import { SourceTable } from './SourceTable.js';
 import { SourceTableCandidateReconciler } from './SourceTableReconciler.js';

package/src/storage/implementation/IncrementalReprocessingCompatibility.ts

@@ -1,4 +1,4 @@
-import { CompatibilityContext } from '@powersync/service-sync-rules';
+import { CompatibilityContext, sourceTableConfigsEqual } from '@powersync/service-sync-rules';
 import { Logger } from 'winston';
 import { SerializedSyncPlan, UpdateSyncRulesOptions } from '../BucketStorageFactory.js';
 
@@ -37,5 +37,17 @@ export function isCompatible(
     return false;
   }
 
+  if (
+    existingPlans.some(
+      (existing) =>
+        !sourceTableConfigsEqual(
+          existing!.plan.sourceTableConfig ?? {},
+          updateConfig.plan!.plan.sourceTableConfig ?? {}
+        )
+    )
+  ) {
+    logger.info('Source table configuration changed - incremental reprocessing not supported');
+    return false;
+  }
   return true;
 }

package/test/src/AbstractReplicator.test.ts

@@ -1,6 +1,9 @@
+import type { RouteAPI } from '@/api/RouteAPI.js';
+import { assertSourceCapabilities } from '@/api/source-capabilities.js';
 import { AbstractReplicationJob } from '@/replication/AbstractReplicationJob.js';
 import { AbstractReplicator, AbstractReplicatorOptions, CreateJobOptions } from '@/replication/AbstractReplicator.js';
 import { PersistedReplicationStream } from '@/storage/PersistedReplicationStream.js';
+import type { ReplicationLock } from '@/storage/ReplicationLock.js';
 import { SyncRulesBucketStorage } from '@/storage/SyncRulesBucketStorage.js';
 import { describe, expect, it, vi } from 'vitest';
 
@@ -45,6 +48,21 @@ class TestReplicator extends AbstractReplicator {
     return (this as any).heartbeatIntervalNanos;
   }
 
+  async runStartupForTest(): Promise<void> {
+    const controller = new AbortController();
+    controller.abort();
+    (this as any).abortController = controller;
+    await (this as any).runLoop();
+  }
+
+  async refreshForTest(configuredLock?: ReplicationLock): Promise<{ replicationJobStarted: boolean }> {
+    (this as any).abortController = new AbortController();
+    return (this as any).refresh({
+      configuredLock,
+      loadedVersionLabel: this.syncRuleProvider.versionLabel
+    });
+  }
+
   shouldHandleStreamForTest(
     replicationStream: PersistedReplicationStream,
     loadedSyncRules: string | undefined,
@@ -54,6 +72,144 @@ class TestReplicator extends AbstractReplicator {
   }
 }
 
+describe('AbstractReplicator startup sync config', () => {
+  it.each([true, false])('respects exit_on_error=%s for unsupported file-loaded filters', async (exitOnError) => {
+    const yaml = /* yaml */ `
+      # sync config fixture.
+      config:
+        edition: 3
+        source_table_options:
+          orders:
+            mongodb_filter_expression: { $eq: ['$$doc.active', true] }
+      streams:
+        orders:
+          query: SELECT * FROM orders
+    `;
+    const configureSyncRules = vi.fn(
+      async (_options: import('@/storage/BucketStorageFactory.js').UpdateSyncRulesOptions) => ({ updated: false })
+    );
+    const replicator = new TestReplicator(async () => {}, {
+      id: 'test',
+      storageEngine: {
+        activeBucketStorage: { configureSyncRules }
+      } as unknown as AbstractReplicatorOptions['storageEngine'],
+      configuration: { connections: [{ type: 'postgresql' }] },
+      syncRuleProvider: { get: async () => yaml, exitOnError, versionLabel: undefined },
+      metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+      rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+    });
+    if (exitOnError) {
+      await expect(replicator.runStartupForTest()).rejects.toThrow('only supported by MongoDB sources');
+      expect(configureSyncRules).not.toHaveBeenCalled();
+    } else {
+      await expect(replicator.runStartupForTest()).resolves.toBeUndefined();
+      expect(configureSyncRules).toHaveBeenCalledOnce();
+      expect(configureSyncRules.mock.calls[0][0].config.plan?.errors).toEqual([
+        expect.objectContaining({
+          level: 'fatal',
+          message: expect.stringContaining('only supported by MongoDB sources')
+        })
+      ]);
+    }
+  });
+
+  it.each(
+    [true, false].flatMap((exitOnError) =>
+      (['warning', 'valid', 'unexpected error'] as const).map((result) => ({ exitOnError, result }))
+    )
+  )(
+    'checks source capabilities before persistence: $result, exit_on_error=$exitOnError',
+    async ({ result, exitOnError }) => {
+      const yaml = /* yaml */ `
+        # sync config fixture.
+        config:
+          edition: 3
+        streams:
+          orders:
+            query: SELECT * FROM orders
+      `;
+      const calls: string[] = [];
+      const configureSyncRules = vi.fn(async () => {
+        calls.push('persist');
+        return { updated: false };
+      });
+      const replicator = new TestReplicator(async () => {}, {
+        id: 'test',
+        storageEngine: {
+          activeBucketStorage: { configureSyncRules }
+        } as unknown as AbstractReplicatorOptions['storageEngine'],
+        syncRuleProvider: { get: async () => yaml, exitOnError, versionLabel: undefined },
+        metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+        rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+      });
+      replicator.registerSourceCapabilitiesAssertion((config) =>
+        assertSourceCapabilities(
+          {
+            async validateSourceCapabilities() {
+              calls.push('validate');
+              if (result === 'unexpected error') throw new Error('Source validation failed');
+              return result === 'warning' ? [{ level: 'warning', message: 'Missing index' }] : [];
+            }
+          } as unknown as RouteAPI,
+          config
+        )
+      );
+
+      if (result === 'unexpected error' && exitOnError) {
+        await expect(replicator.runStartupForTest()).rejects.toThrow('Source validation failed');
+        expect(calls).toEqual(['validate']);
+      } else {
+        await replicator.runStartupForTest();
+        expect(calls).toEqual(['validate', 'persist']);
+      }
+    }
+  );
+
+  it.each([true, false])('retains source-table options with exit_on_error=%s', async (exitOnError) => {
+    const yaml = /* yaml */ `
+      {
+        config: { edition: 3, source_table_options: { orders: { mongodb_filter_expression: 'disabled' } } },
+        streams: { orders: { query: SELECT * FROM orders } }
+      }
+    `;
+    const configureSyncRules = vi.fn(async () => ({ updated: false }));
+    const replicator = new TestReplicator(async () => {}, {
+      id: 'test',
+      storageEngine: {
+        activeBucketStorage: { configureSyncRules }
+      } as unknown as AbstractReplicatorOptions['storageEngine'],
+      syncRuleProvider: { get: async () => yaml, exitOnError, versionLabel: 'v2' },
+      metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+      rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+    });
+
+    await replicator.runStartupForTest();
+
+    expect(configureSyncRules).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        lock: true,
+        version_label: 'v2',
+        config: expect.objectContaining({
+          parsed: expect.objectContaining({
+            errors: [],
+            config: expect.objectContaining({
+              plan: expect.objectContaining({
+                sourceTableConfig: { orders: { mongodb_filter_expression: 'disabled' } }
+              })
+            })
+          }),
+          plan: expect.objectContaining({
+            plan: expect.objectContaining({
+              version: 3,
+              sourceTableConfig: { orders: { mongodb_filter_expression: 'disabled' } }
+            })
+          })
+        })
+      })
+    );
+  });
+});
+
 describe('AbstractReplicator heartbeat interval', () => {
   const options: AbstractReplicatorOptions = {
     id: 'test',

package/test/src/diagnostics.test.ts

@@ -205,4 +205,132 @@ describe('getSyncRulesStatus WAL budget warnings', () => {
     expect(result!.version_label).toBe('v6');
     expect(result!.errors).toEqual([expect.objectContaining({ level: 'fatal', message: 'Invalid sync config' })]);
   });
+
+  test('reports each sync config error with its source location when parsing fails', async () => {
+    const yaml = `
+config:
+  edition: 3
+streams:
+  global:
+    query: SELECT id FROM test_table
+    unknown_key: true
+`;
+    const content = makeSyncRulesContent();
+    content.parsed = (options?: any) => {
+      SqlSyncRules.fromYaml(yaml, { ...options, defaultSchema: 'public', throwOnError: true });
+      throw new Error('Expected parsing to fail');
+    };
+
+    const result = await getSyncRulesStatus(makeRouteAPI(), content, OPTIONS, makeSystemStorage());
+
+    expect(result!.errors).toHaveLength(1);
+    const [error] = result!.errors;
+    expect(error.level).toBe('fatal');
+    expect(error.message).not.toContain('Expected parsing to fail');
+    expect(yaml.slice(error.location!.start_offset, error.location!.end_offset)).toBe('unknown_key');
+  });
+});
+
+describe('source capability validation', () => {
+  test('exposes stored replication errors when source checks cannot run', async () => {
+    const content = makeSyncRulesContent({
+      status: {
+        id: '1',
+        replicationStreamId: 1,
+        state: storage.SyncRuleState.PROCESSING,
+        last_checkpoint_lsn: null,
+        last_fatal_error: 'Source capability unavailable',
+        last_fatal_error_ts: new Date(),
+        last_keepalive_ts: null,
+        last_checkpoint_ts: null
+      }
+    });
+    const result = await getSyncRulesStatus(
+      makeRouteAPI(),
+      content,
+      {
+        ...OPTIONS,
+        check_connection: false,
+        active: false,
+        include_content: true
+      },
+      makeSystemStorage()
+    );
+    expect(result?.content).toBe(MINIMAL_SYNC_RULES);
+    expect(result?.errors).toContainEqual(
+      expect.objectContaining({
+        level: 'fatal',
+        message: 'Source capability unavailable'
+      })
+    );
+  });
+
+  test('reports capability failures alongside table diagnostics', async () => {
+    const api = makeRouteAPI();
+    api.validateSourceCapabilities = async () => [
+      { level: 'fatal', message: 'Source capability unavailable' },
+      { level: 'warning', message: 'Source advisory', location: { start_offset: 1, end_offset: 4 } }
+    ];
+    api.getDebugTablesInfo = async () => [
+      {
+        schema: 'public',
+        pattern: 'items',
+        wildcard: false,
+        table: {
+          schema: 'public',
+          name: 'items',
+          data_queries: true,
+          parameter_queries: false,
+          replication_id: [],
+          errors: [{ level: 'warning', message: 'Index missing' }]
+        }
+      }
+    ];
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
+    expect(result!.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ level: 'fatal', message: 'Source capability unavailable' }),
+        expect.objectContaining({ level: 'warning', message: 'Index missing' }),
+        expect.objectContaining({
+          level: 'warning',
+          message: 'Source advisory',
+          location: { start_offset: 1, end_offset: 4 }
+        })
+      ])
+    );
+    expect(result!.connections[0].tables).toHaveLength(1);
+  });
+
+  test('preserves both validation failures and continues independent diagnostics', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'extended',
+      safe_wal_size: 4 * GB,
+      max_slot_wal_keep_size: 10 * GB
+    });
+    api.validateSourceCapabilities = async () => {
+      throw new Error('Source capability unavailable');
+    };
+    api.getDebugTablesInfo = async () => {
+      throw new Error('Table metadata unavailable');
+    };
+    const result = await getSyncRulesStatus(api, makeSyncRulesContent(), OPTIONS, makeSystemStorage());
+    expect(result!.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ level: 'fatal', message: 'Source capability unavailable' }),
+        expect.objectContaining({ level: 'fatal', message: 'Table metadata unavailable' }),
+        expect.objectContaining({ level: 'warning', message: expect.stringContaining('WAL budget') })
+      ])
+    );
+  });
+
+  test('does not check capabilities when connection checks are disabled', async () => {
+    const api = makeRouteAPI();
+    let called = false;
+    api.validateSourceCapabilities = async () => {
+      called = true;
+      return [];
+    };
+    await getSyncRulesStatus(api, makeSyncRulesContent(), { ...OPTIONS, check_connection: false }, makeSystemStorage());
+    expect(called).toBe(false);
+  });
 });