@powersync/service-core 0.2.2 → 0.4.0

package/src/routes/route-register.ts

@@ -0,0 +1,104 @@
+import fastify from 'fastify';
+
+import { errors, router, HTTPMethod, logger } from '@powersync/lib-services-framework';
+import { Context, ContextProvider, RequestEndpoint, RequestEndpointHandlerPayload } from './router.js';
+
+export type FastifyEndpoint<I, O, C> = RequestEndpoint<I, O, C> & {
+  parse?: boolean;
+  plugins?: fastify.FastifyPluginAsync[];
+};
+
+/**
+ * Registers endpoint definitions as routes on a Fastify app instance.
+ */
+export function registerFastifyRoutes(
+  app: fastify.FastifyInstance,
+  contextProvider: ContextProvider,
+  endpoints: FastifyEndpoint<any, any, Context>[]
+) {
+  for (const e of endpoints) {
+    // Create a new context for each route
+    app.register(async function (fastify) {
+      fastify.route({
+        url: e.path,
+        method: e.method as HTTPMethod,
+        handler: async (request, reply) => {
+          const startTime = new Date();
+          let response: router.RouterResponse;
+          try {
+            const context = await contextProvider(request);
+
+            let combined = {
+              ...(request.params as any),
+              ...(request.query as any)
+            };
+
+            if (typeof request.body === 'object' && !Buffer.isBuffer(request.body) && !Array.isArray(request.body)) {
+              combined = {
+                ...combined,
+                ...request.body
+              };
+            }
+
+            const payload: RequestEndpointHandlerPayload = {
+              context: context,
+              params: combined,
+              request
+            };
+
+            const endpointResponse = await router.executeEndpoint(e, payload);
+
+            if (router.RouterResponse.isRouterResponse(endpointResponse)) {
+              response = endpointResponse;
+            } else if (router.isAsyncIterable(endpointResponse) || Buffer.isBuffer(endpointResponse)) {
+              response = new router.RouterResponse({
+                status: 200,
+                data: endpointResponse
+              });
+            } else {
+              response = new router.RouterResponse({
+                status: 200,
+                data: { data: endpointResponse }
+              });
+            }
+          } catch (ex) {
+            const journeyError = errors.JourneyError.isJourneyError(ex) ? ex : new errors.InternalServerError(ex);
+
+            response = new router.RouterResponse({
+              status: journeyError.errorData.status || 500,
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              data: {
+                error: journeyError.errorData
+              }
+            });
+          }
+
+          Object.keys(response.headers).forEach((key) => {
+            reply.header(key, response.headers[key]);
+          });
+          reply.status(response.status);
+          try {
+            await reply.send(response.data);
+          } finally {
+            await response.afterSend?.();
+            logger.info(`${e.method} ${request.url}`, {
+              duration_ms: Math.round(new Date().valueOf() - startTime.valueOf() + Number.EPSILON),
+              status: response.status,
+              method: e.method,
+              path: request.url,
+              route: e.path
+            });
+          }
+        }
+      });
+
+      if (!(e.parse ?? true)) {
+        fastify.removeAllContentTypeParsers();
+      }
+
+      e.plugins?.forEach((plugin) => fastify.register(plugin));
+    });
+  }
+}

package/src/routes/router.ts

@@ -1,8 +1,10 @@
-import * as micro from '@journeyapps-platform/micro';
-
-import * as auth from '@/auth/auth-index.js';
+import { router } from '@powersync/lib-services-framework';
+import * as auth from '../auth/auth-index.js';
 import { CorePowerSyncSystem } from '../system/CorePowerSyncSystem.js';
 
+/**
+ * Common context for routes
+ */
 export type Context = {
   user_id?: string;
   system: CorePowerSyncSystem;
@@ -11,8 +13,34 @@ export type Context = {
   token_errors?: string[];
 };
 
+export type BasicRouterRequest = {
+  headers: Record<string, string | string[] | undefined>;
+  protocol: string;
+  hostname: string;
+};
+
+export type ContextProvider = (request: BasicRouterRequest) => Promise<Context>;
+
+export type RequestEndpoint<
+  I,
+  O,
+  C = Context,
+  Payload = RequestEndpointHandlerPayload<I, C, BasicRouterRequest>
+> = router.Endpoint<I, O, C, Payload> & {};
+
+export type RequestEndpointHandlerPayload<
+  I = any,
+  C = Context,
+  Request = BasicRouterRequest
+> = router.EndpointHandlerPayload<I, C> & {
+  request: Request;
+};
+
 /**
- * Creates a route handler given a router instance
- * TODO move away from Fastify specific types
+ * Helper function for making generics work well when defining routes
  */
-export type RouteGenerator = (router: micro.fastify.FastifyRouter<Context>) => micro.router.Route;
+export function routeDefinition<I, O, C = Context, Extension = {}>(
+  params: RequestEndpoint<I, O, C> & Extension
+): RequestEndpoint<I, O, C> & Extension {
+  return params;
+}

package/src/routes/routes-index.ts

@@ -1,5 +1,6 @@
-export * from './router.js';
-export * from './router-socket.js';
-export * from './route-generators.js';
-
 export * as auth from './auth.js';
+export * as endpoints from './endpoints/route-endpoints-index.js';
+export * as hooks from './hooks.js';
+export * from './route-register.js';
+export * from './router-socket.js';
+export * from './router.js';

package/src/runner/teardown.ts

@@ -3,13 +3,13 @@
 // 1. The replication slots on the source postgres instance (if available).
 // 2. The mongo database.
 
-import * as micro from '@journeyapps-platform/micro';
 import * as timers from 'timers/promises';
 
 import * as db from '../db/db-index.js';
 import * as storage from '../storage/storage-index.js';
 import * as utils from '../util/util-index.js';
 import * as replication from '../replication/replication-index.js';
+import { logger } from '@powersync/lib-services-framework';
 
 /**
  * Attempt to terminate a single sync rules instance.
@@ -34,9 +34,9 @@ async function terminateReplicator(
       lock
     });
 
-    micro.logger.info(`Terminating replication slot ${stream.slot_name}`);
+    logger.info(`Terminating replication slot ${stream.slot_name}`);
     await stream.terminate();
-    micro.logger.info(`Terminated replication slot ${stream.slot_name}`);
+    logger.info(`Terminated replication slot ${stream.slot_name}`);
   } finally {
     await lock.release();
   }
@@ -64,7 +64,7 @@ async function terminateReplicators(
       } catch (e) {
         retry = true;
         console.error(e);
-        micro.logger.warn(`Failed to terminate ${syncRules.slot_name}`, e);
+        logger.warn(`Failed to terminate ${syncRules.slot_name}`, e);
       }
     }
     if (!retry) {
@@ -78,22 +78,22 @@ export async function teardown(runnerConfig: utils.RunnerConfig) {
   const config = await utils.loadConfig(runnerConfig);
   const mongoDB = storage.createPowerSyncMongo(config.storage);
   try {
-    micro.logger.info(`Waiting for auth`);
+    logger.info(`Waiting for auth`);
     await db.mongo.waitForAuth(mongoDB.db);
 
     const bucketStorage = new storage.MongoBucketStorage(mongoDB, { slot_name_prefix: config.slot_name_prefix });
     const connection = config.connection;
 
-    micro.logger.info(`Terminating replication slots`);
+    logger.info(`Terminating replication slots`);
 
     if (connection) {
       await terminateReplicators(bucketStorage, connection);
     }
 
     const database = mongoDB.db;
-    micro.logger.info(`Dropping database ${database.namespace}`);
+    logger.info(`Dropping database ${database.namespace}`);
     await database.dropDatabase();
-    micro.logger.info(`Done`);
+    logger.info(`Done`);
     await mongoDB.client.close();
 
     // If there was an error connecting to postgress, the process may stay open indefinitely.
@@ -101,7 +101,7 @@ export async function teardown(runnerConfig: utils.RunnerConfig) {
     // We do not consider those errors a teardown failure.
     process.exit(0);
   } catch (e) {
-    micro.logger.error(`Teardown failure`, e);
+    logger.error(`Teardown failure`, e);
     await mongoDB.client.close();
     process.exit(1);
   }

package/src/storage/BucketStorage.ts

@@ -8,8 +8,8 @@ import {
   ToastableSqliteRow
 } from '@powersync/service-sync-rules';
 
-import * as replication from '@/replication/replication-index.js';
-import * as util from '@/util/util-index.js';
+import * as replication from '../replication/replication-index.js';
+import * as util from '../util/util-index.js';
 import { SourceTable } from './SourceTable.js';
 
 export interface BucketStorageFactory {
@@ -367,7 +367,12 @@ export interface SaveInsert {
 export interface SaveUpdate {
   tag: 'update';
   sourceTable: SourceTable;
+
+  /**
+   * This is only present when the id has changed, and will only contain replica identity columns.
+   */
   before?: SqliteRow;
+
   /**
    * A null value means null column.
    *

package/src/storage/ChecksumCache.ts

@@ -1,5 +1,5 @@
-import { BucketChecksum, OpId } from '@/util/protocol-types.js';
-import { ChecksumMap, addBucketChecksums } from '@/util/utils.js';
+import { BucketChecksum, OpId } from '../util/protocol-types.js';
+import { ChecksumMap, addBucketChecksums } from '../util/utils.js';
 import { LRUCache } from 'lru-cache/min';
 import { OrderedSet } from '@js-sdsl/ordered-set';
 

package/src/storage/MongoBucketStorage.ts

@@ -1,13 +1,13 @@
 import * as mongo from 'mongodb';
 import * as timers from 'timers/promises';
 import { LRUCache } from 'lru-cache/min';
-import * as micro from '@journeyapps-platform/micro';
 import { SqlSyncRules } from '@powersync/service-sync-rules';
 import { wrapWithAbort } from 'ix/asynciterable/operators/withabort.js';
 
-import * as replication from '@/replication/replication-index.js';
-import * as sync from '@/sync/sync-index.js';
-import * as util from '@/util/util-index.js';
+import * as replication from '../replication/replication-index.js';
+import * as sync from '../sync/sync-index.js';
+import * as util from '../util/util-index.js';
+import * as locks from '../locks/locks-index.js';
 
 import {
   ActiveCheckpoint,
@@ -23,8 +23,8 @@ import { MongoSyncBucketStorage } from './mongo/MongoSyncBucketStorage.js';
 import { PowerSyncMongo, PowerSyncMongoOptions } from './mongo/db.js';
 import { SyncRuleDocument, SyncRuleState } from './mongo/models.js';
 import { generateSlotName } from './mongo/util.js';
-import { locks } from '@journeyapps-platform/micro';
 import { v4 as uuid } from 'uuid';
+import { logger } from '@powersync/lib-services-framework';
 
 export interface MongoBucketStorageOptions extends PowerSyncMongoOptions {}
 
@@ -74,13 +74,13 @@ export class MongoBucketStorage implements BucketStorageFactory {
     const active = await this.getActiveSyncRulesContent();
 
     if (next?.sync_rules_content == sync_rules) {
-      micro.logger.info('Sync rules from configuration unchanged');
+      logger.info('Sync rules from configuration unchanged');
       return { updated: false };
     } else if (next == null && active?.sync_rules_content == sync_rules) {
-      micro.logger.info('Sync rules from configuration unchanged');
+      logger.info('Sync rules from configuration unchanged');
       return { updated: false };
     } else {
-      micro.logger.info('Sync rules updated from configuration');
+      logger.info('Sync rules updated from configuration');
       const persisted_sync_rules = await this.updateSyncRules({
         content: sync_rules,
         lock: options?.lock

package/src/storage/SourceTable.ts

@@ -1,7 +1,7 @@
 import { DEFAULT_SCHEMA, DEFAULT_TAG } from '@powersync/service-sync-rules';
 
-import * as replication from '@/replication/replication-index.js';
-import * as util from '@/util/util-index.js';
+import * as replication from '../replication/replication-index.js';
+import * as util from '../util/util-index.js';
 
 export class SourceTable {
   static readonly DEFAULT_SCHEMA = DEFAULT_SCHEMA;

package/src/storage/mongo/MongoBucketBatch.ts

@@ -1,10 +1,10 @@
-import * as micro from '@journeyapps-platform/micro';
 import { SqliteRow, SqlSyncRules } from '@powersync/service-sync-rules';
 import * as bson from 'bson';
 import * as mongo from 'mongodb';
 
-import * as util from '@/util/util-index.js';
-import * as replication from '@/replication/replication-index.js';
+import * as util from '../../util/util-index.js';
+import * as replication from '../../replication/replication-index.js';
+import { container, errors, logger } from '@powersync/lib-services-framework';
 import { BucketStorageBatch, FlushedResult, mergeToast, SaveOptions } from '../BucketStorage.js';
 import { SourceTable } from '../SourceTable.js';
 import { PowerSyncMongo } from './db.js';
@@ -187,6 +187,7 @@ export class MongoBucketBatch implements BucketStorageBatch {
         }
         const currentData = current_data_lookup.get(op.internalBeforeKey) ?? null;
         if (currentData != null) {
+          // If it will be used again later, it will be set again using nextData below
           current_data_lookup.delete(op.internalBeforeKey);
         }
         const nextData = this.saveOperation(persistedBatch!, op, currentData, op_seq);
@@ -242,6 +243,10 @@ export class MongoBucketBatch implements BucketStorageBatch {
         // Not an error if we re-apply a transaction
         existing_buckets = [];
         existing_lookups = [];
+        // Log to help with debugging if there was a consistency issue
+        logger.warn(
+          `Cannot find previous record for update on ${record.sourceTable.qualifiedName}: ${beforeId} / ${record.before?.id}`
+        );
       } else {
         const data = bson.deserialize((result.data as mongo.Binary).buffer, BSON_DESERIALIZE_OPTIONS) as SqliteRow;
         existing_buckets = result.buckets;
@@ -254,6 +259,10 @@ export class MongoBucketBatch implements BucketStorageBatch {
         // Not an error if we re-apply a transaction
         existing_buckets = [];
         existing_lookups = [];
+        // Log to help with debugging if there was a consistency issue
+        logger.warn(
+          `Cannot find previous record for delete on ${record.sourceTable.qualifiedName}: ${beforeId} / ${record.before?.id}`
+        );
       } else {
         existing_buckets = result.buckets;
         existing_lookups = result.lookups;
@@ -278,10 +287,10 @@ export class MongoBucketBatch implements BucketStorageBatch {
         );
         afterData = new bson.Binary(bson.serialize(after!));
 
-        micro.alerts.captureMessage(
+        container.reporter.captureMessage(
           `Data too big on ${record.sourceTable.qualifiedName}.${record.after?.id}: ${e.message}`,
           {
-            level: micro.errors.ErrorSeverity.WARNING,
+            level: errors.ErrorSeverity.WARNING,
             metadata: {
               replication_slot: this.slot_name,
               table: record.sourceTable.qualifiedName
@@ -292,7 +301,7 @@ export class MongoBucketBatch implements BucketStorageBatch {
     }
 
     // 2. Save bucket data
-    if (beforeId != null && beforeId != afterId) {
+    if (beforeId != null && (afterId == null || !beforeId.equals(afterId))) {
       // Source ID updated
       if (sourceTable.syncData) {
         // Delete old record
@@ -329,23 +338,23 @@ export class MongoBucketBatch implements BucketStorageBatch {
     if (afterId && after && util.isCompleteRow(after)) {
       // Insert or update
       if (sourceTable.syncData) {
-        const { results: evaluated, errors } = this.sync_rules.evaluateRowWithErrors({
+        const { results: evaluated, errors: syncErrors } = this.sync_rules.evaluateRowWithErrors({
           record: after,
           sourceTable
         });
 
-        for (let error of errors) {
-          micro.alerts.captureMessage(
+        for (let error of syncErrors) {
+          container.reporter.captureMessage(
             `Failed to evaluate data query on ${record.sourceTable.qualifiedName}.${record.after?.id}: ${error.error}`,
             {
-              level: micro.errors.ErrorSeverity.WARNING,
+              level: errors.ErrorSeverity.WARNING,
               metadata: {
                 replication_slot: this.slot_name,
                 table: record.sourceTable.qualifiedName
               }
             }
           );
-          micro.logger.error(
+          logger.error(
             `Failed to evaluate data query on ${record.sourceTable.qualifiedName}.${record.after?.id}: ${error.error}`
           );
         }
@@ -375,17 +384,17 @@ export class MongoBucketBatch implements BucketStorageBatch {
         );
 
         for (let error of paramErrors) {
-          micro.alerts.captureMessage(
+          container.reporter.captureMessage(
             `Failed to evaluate parameter query on ${record.sourceTable.qualifiedName}.${record.after?.id}: ${error.error}`,
             {
-              level: micro.errors.ErrorSeverity.WARNING,
+              level: errors.ErrorSeverity.WARNING,
               metadata: {
                 replication_slot: this.slot_name,
                 table: record.sourceTable.qualifiedName
               }
             }
           );
-          micro.logger.error(
+          logger.error(
             `Failed to evaluate parameter query on ${record.sourceTable.qualifiedName}.${after.id}: ${error.error}`
           );
         }
@@ -422,7 +431,7 @@ export class MongoBucketBatch implements BucketStorageBatch {
       };
     }
 
-    if (beforeId != afterId) {
+    if (afterId == null || !beforeId.equals(afterId)) {
       // Either a delete (afterId == null), or replaced the old replication id
       batch.deleteCurrentData(before_key);
     }
@@ -439,7 +448,7 @@ export class MongoBucketBatch implements BucketStorageBatch {
             if (e instanceof mongo.MongoError && e.hasErrorLabel('TransientTransactionError')) {
               // Likely write conflict caused by concurrent write stream replicating
             } else {
-              micro.logger.warn('Transaction error', e as Error);
+              logger.warn('Transaction error', e as Error);
             }
             await new Promise((resolve) => setTimeout(resolve, Math.random() * 50));
             throw e;
@@ -464,7 +473,7 @@ export class MongoBucketBatch implements BucketStorageBatch {
     await this.withTransaction(async () => {
       flushTry += 1;
       if (flushTry % 10 == 0) {
-        micro.logger.info(`${this.slot_name} ${description} - try ${flushTry}`);
+        logger.info(`${this.slot_name} ${description} - try ${flushTry}`);
       }
       if (flushTry > 20 && Date.now() > lastTry) {
         throw new Error('Max transaction tries exceeded');
@@ -529,13 +538,11 @@ export class MongoBucketBatch implements BucketStorageBatch {
     if (this.last_checkpoint_lsn != null && lsn <= this.last_checkpoint_lsn) {
       // When re-applying transactions, don't create a new checkpoint until
       // we are past the last transaction.
-      micro.logger.info(`Re-applied transaction ${lsn} - skipping checkpoint`);
+      logger.info(`Re-applied transaction ${lsn} - skipping checkpoint`);
       return false;
     }
     if (lsn < this.no_checkpoint_before_lsn) {
-      micro.logger.info(
-        `Waiting until ${this.no_checkpoint_before_lsn} before creating checkpoint, currently at ${lsn}`
-      );
+      logger.info(`Waiting until ${this.no_checkpoint_before_lsn} before creating checkpoint, currently at ${lsn}`);
       return false;
     }
 
@@ -599,7 +606,7 @@ export class MongoBucketBatch implements BucketStorageBatch {
   }
 
   async save(record: SaveOptions): Promise<FlushedResult | null> {
-    micro.logger.debug(`Saving ${record.tag}:${record.before?.id}/${record.after?.id}`);
+    logger.debug(`Saving ${record.tag}:${record.before?.id}/${record.after?.id}`);
 
     this.batch ??= new OperationBatch();
     this.batch.push(new RecordOperation(record));

package/src/storage/mongo/MongoSyncBucketStorage.ts

@@ -2,9 +2,9 @@ import { SqliteJsonRow, SqliteJsonValue, SqlSyncRules } from '@powersync/service
 import * as bson from 'bson';
 import * as mongo from 'mongodb';
 
-import * as db from '@/db/db-index.js';
-import * as replication from '@/replication/WalStream.js';
-import * as util from '@/util/util-index.js';
+import * as db from '../../db/db-index.js';
+import * as replication from '../../replication/WalStream.js';
+import * as util from '../../util/util-index.js';
 import {
   BucketDataBatchOptions,
   BucketStorageBatch,

package/src/storage/mongo/MongoSyncRulesLock.ts

@@ -1,8 +1,8 @@
-import * as micro from '@journeyapps-platform/micro';
 import crypto from 'crypto';
 
 import { PersistedSyncRulesContent, ReplicationLock } from '../BucketStorage.js';
 import { PowerSyncMongo } from './db.js';
+import { logger } from '@powersync/lib-services-framework';
 
 /**
  * Manages a lock on a sync rules document, so that only one process
@@ -40,7 +40,7 @@ export class MongoSyncRulesLock implements ReplicationLock {
       try {
         await this.refresh();
       } catch (e) {
-        micro.logger.error('Failed to refresh lock', e);
+        logger.error('Failed to refresh lock', e);
         clearInterval(this.refreshInterval);
       }
     }, 30_130);
@@ -59,7 +59,7 @@ export class MongoSyncRulesLock implements ReplicationLock {
     );
     if (result.modifiedCount == 0) {
       // Log and ignore
-      micro.logger.warn(`Lock already released: ${this.sync_rules_id}/${this.lock_id}`);
+      logger.warn(`Lock already released: ${this.sync_rules_id}/${this.lock_id}`);
     }
   }
 

package/src/storage/mongo/OperationBatch.ts

@@ -1,7 +1,7 @@
 import * as bson from 'bson';
 import { ToastableSqliteRow } from '@powersync/service-sync-rules';
 
-import * as util from '@/util/util-index.js';
+import * as util from '../../util/util-index.js';
 import { SaveOptions } from '../BucketStorage.js';
 
 /**

package/src/storage/mongo/PersistedBatch.ts

@@ -2,9 +2,8 @@ import { JSONBig } from '@powersync/service-jsonbig';
 import { EvaluatedParameters, EvaluatedRow } from '@powersync/service-sync-rules';
 import * as bson from 'bson';
 import * as mongo from 'mongodb';
-import * as micro from '@journeyapps-platform/micro';
 
-import * as util from '@/util/util-index.js';
+import * as util from '../../util/util-index.js';
 import { SourceTable } from '../SourceTable.js';
 import { currentBucketKey } from './MongoBucketBatch.js';
 import { MongoIdSequence } from './MongoIdSequence.js';
@@ -17,6 +16,7 @@ import {
   SourceKey
 } from './models.js';
 import { serializeLookup } from './util.js';
+import { logger } from '@powersync/lib-services-framework';
 
 /**
  * Maximum size of operations we write in a single transaction.
@@ -253,7 +253,7 @@ export class PersistedBatch {
       });
     }
 
-    micro.logger.info(
+    logger.info(
       `powersync_${this.group_id} Flushed ${this.bucketData.length} + ${this.bucketParameters.length} + ${
         this.currentData.length
       } updates, ${Math.round(this.currentSize / 1024)}kb. Last op_id: ${this.debugLastOpId}`

package/src/storage/mongo/db.ts

@@ -1,8 +1,7 @@
 import * as mongo from 'mongodb';
-import * as micro from '@journeyapps-platform/micro';
-
-import * as db from '@/db/db-index.js';
 
+import * as db from '../../db/db-index.js';
+import * as locks from '../../locks/locks-index.js';
 import {
   BucketDataDocument,
   BucketParameterDocument,
@@ -36,7 +35,7 @@ export class PowerSyncMongo {
   readonly source_tables: mongo.Collection<SourceTableDocument>;
   readonly write_checkpoints: mongo.Collection<WriteCheckpointDocument>;
   readonly instance: mongo.Collection<InstanceDocument>;
-  readonly locks: mongo.Collection<micro.locks.Lock>;
+  readonly locks: mongo.Collection<locks.Lock>;
 
   readonly client: mongo.MongoClient;
   readonly db: mongo.Db;

package/src/sync/sync.ts

@@ -1,16 +1,16 @@
-import * as micro from '@journeyapps-platform/micro';
 import { JSONBig, JsonContainer } from '@powersync/service-jsonbig';
-import { SyncParameters } from '@powersync/service-sync-rules';
+import { RequestParameters } from '@powersync/service-sync-rules';
 import { Semaphore } from 'async-mutex';
 import { AbortError } from 'ix/aborterror.js';
 
-import * as auth from '@/auth/auth-index.js';
-import * as storage from '@/storage/storage-index.js';
-import * as util from '@/util/util-index.js';
+import * as auth from '../auth/auth-index.js';
+import * as storage from '../storage/storage-index.js';
+import * as util from '../util/util-index.js';
 
+import { logger } from '@powersync/lib-services-framework';
+import { Metrics } from '../metrics/Metrics.js';
 import { mergeAsyncIterables } from './merge.js';
 import { TokenStreamOptions, tokenStream } from './util.js';
-import { Metrics } from '@/metrics/Metrics.js';
 
 /**
  * Maximum number of connections actively fetching data.
@@ -21,7 +21,7 @@ const syncSemaphore = new Semaphore(MAX_ACTIVE_CONNECTIONS);
 export interface SyncStreamParameters {
   storage: storage.BucketStorageFactory;
   params: util.StreamingSyncRequest;
-  syncParams: SyncParameters;
+  syncParams: RequestParameters;
   token: auth.JwtPayload;
   /**
    * If this signal is aborted, the stream response ends as soon as possible, without error.
@@ -71,7 +71,7 @@ export async function* streamResponse(
 async function* streamResponseInner(
   storage: storage.BucketStorageFactory,
   params: util.StreamingSyncRequest,
-  syncParams: SyncParameters,
+  syncParams: RequestParameters,
   signal: AbortSignal
 ): AsyncGenerator<util.StreamingSyncLine | string | null> {
   // Bucket state of bucket id -> op_id.
@@ -141,7 +141,7 @@ async function* streamResponseInner(
       message += `buckets: ${allBuckets.length} | `;
       message += `updated: ${limitedBuckets(diff.updatedBuckets, 20)} | `;
       message += `removed: ${limitedBuckets(diff.removedBuckets, 20)} | `;
-      micro.logger.info(message);
+      logger.info(message);
 
       const checksum_line: util.StreamingSyncCheckpointDiff = {
         checkpoint_diff: {
@@ -156,7 +156,7 @@ async function* streamResponseInner(
     } else {
       let message = `New checkpoint: ${checkpoint} | write: ${writeCheckpoint} | `;
       message += `buckets: ${allBuckets.length} ${limitedBuckets(allBuckets, 20)}`;
-      micro.logger.info(message);
+      logger.info(message);
       bucketsToFetch = allBuckets;
       const checksum_line: util.StreamingSyncCheckpoint = {
         checkpoint: {
@@ -246,7 +246,7 @@ async function* bucketDataBatch(request: BucketDataRequest) {
       if (r.data.length == 0) {
         continue;
       }
-      micro.logger.debug(`Sending data for ${r.bucket}`);
+      logger.debug(`Sending data for ${r.bucket}`);
 
       let send_data: any;
       if (binary_data) {