@powersync/service-core 0.0.0-dev-20250507151436 → 0.0.0-dev-20250611110033

package/src/auth/RemoteJWKSCollector.ts

@@ -4,6 +4,7 @@ import * as jose from 'jose';
 import fetch from 'node-fetch';
 
 import {
+  AuthorizationError,
   ErrorCode,
   LookupOptions,
   makeHostnameLookupFunction,
@@ -46,28 +47,43 @@ export class RemoteJWKSCollector implements KeyCollector {
     this.agent = this.resolveAgent();
   }
 
-  async getKeys(): Promise<KeyResult> {
+  private async getJwksData(): Promise<any> {
     const abortController = new AbortController();
     const timeout = setTimeout(() => {
       abortController.abort();
     }, 30_000);
 
-    const res = await fetch(this.url, {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json'
-      },
-      signal: abortController.signal,
-      agent: this.agent
-    });
-
-    if (!res.ok) {
-      throw new jose.errors.JWKSInvalid(`JWKS request failed with ${res.statusText}`);
-    }
+    try {
+      const res = await fetch(this.url, {
+        method: 'GET',
+        headers: {
+          Accept: 'application/json'
+        },
+        signal: abortController.signal,
+        agent: this.agent
+      });
+
+      if (!res.ok) {
+        throw new AuthorizationError(ErrorCode.PSYNC_S2204, `JWKS request failed with ${res.statusText}`, {
+          configurationDetails: `JWKS URL: ${this.url}`
+        });
+      }
 
-    const data = (await res.json()) as any;
+      return (await res.json()) as any;
+    } catch (e) {
+      throw new AuthorizationError(ErrorCode.PSYNC_S2204, `JWKS request failed`, {
+        configurationDetails: `JWKS URL: ${this.url}`,
+        // This covers most cases of FetchError
+        // `cause: e` could lose the error message
+        cause: { message: e.message, code: e.code }
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
 
-    clearTimeout(timeout);
+  async getKeys(): Promise<KeyResult> {
+    const data = await this.getJwksData();
 
     // https://github.com/panva/jose/blob/358e864a0cccf1e0f9928a959f91f18f3f06a7de/src/jwks/local.ts#L36
     if (
@@ -75,7 +91,14 @@ export class RemoteJWKSCollector implements KeyCollector {
       !Array.isArray(data.keys) ||
       !(data.keys as any[]).every((key) => typeof key == 'object' && !Array.isArray(key))
     ) {
-      return { keys: [], errors: [new jose.errors.JWKSInvalid(`No keys in found in JWKS response`)] };
+      return {
+        keys: [],
+        errors: [
+          new AuthorizationError(ErrorCode.PSYNC_S2204, `Invalid JWKS response`, {
+            configurationDetails: `JWKS URL: ${this.url}. Response:\n${JSON.stringify(data, null, 2)}`
+          })
+        ]
+      };
     }
 
     let keys: KeySpec[] = [];

package/src/auth/auth-index.ts

@@ -8,3 +8,4 @@ export * from './LeakyBucket.js';
 export * from './RemoteJWKSCollector.js';
 export * from './StaticKeyCollector.js';
 export * from './StaticSupabaseKeyCollector.js';
+export * from './utils.js';

package/src/auth/utils.ts

@@ -0,0 +1,102 @@
+import { AuthorizationError, ErrorCode } from '@powersync/lib-services-framework';
+import * as jose from 'jose';
+
+export function mapJoseError(error: jose.errors.JOSEError, token: string): AuthorizationError {
+  const tokenDetails = tokenDebugDetails(token);
+  if (error.code === jose.errors.JWSInvalid.code || error.code === jose.errors.JWTInvalid.code) {
+    return new AuthorizationError(ErrorCode.PSYNC_S2101, 'Token is not a well-formed JWT. Check the token format.', {
+      tokenDetails,
+      cause: error
+    });
+  } else if (error.code === jose.errors.JWTClaimValidationFailed.code) {
+    // Jose message: missing required "sub" claim
+    const claim = (error as jose.errors.JWTClaimValidationFailed).claim;
+    return new AuthorizationError(
+      ErrorCode.PSYNC_S2101,
+      `JWT payload is missing a required claim ${JSON.stringify(claim)}`,
+      {
+        cause: error,
+        tokenDetails
+      }
+    );
+  } else if (error.code == jose.errors.JWTExpired.code) {
+    // Jose message: "exp" claim timestamp check failed
+    return new AuthorizationError(ErrorCode.PSYNC_S2103, `JWT has expired`, {
+      cause: error,
+      tokenDetails
+    });
+  }
+  return new AuthorizationError(ErrorCode.PSYNC_S2101, error.message, { cause: error });
+}
+
+export function mapAuthError(error: any, token: string): AuthorizationError {
+  if (error instanceof AuthorizationError) {
+    error.tokenDetails ??= tokenDebugDetails(token);
+    return error;
+  } else if (error instanceof jose.errors.JOSEError) {
+    return mapJoseError(error, token);
+  }
+  return new AuthorizationError(ErrorCode.PSYNC_S2101, error.message, {
+    cause: error,
+    tokenDetails: tokenDebugDetails(token)
+  });
+}
+
+export function mapJoseConfigError(error: jose.errors.JOSEError): AuthorizationError {
+  return new AuthorizationError(ErrorCode.PSYNC_S2201, error.message ?? 'Authorization error', { cause: error });
+}
+
+export function mapAuthConfigError(error: any): AuthorizationError {
+  if (error instanceof AuthorizationError) {
+    return error;
+  } else if (error instanceof jose.errors.JOSEError) {
+    return mapJoseConfigError(error);
+  }
+  return new AuthorizationError(ErrorCode.PSYNC_S2201, error.message ?? 'Auth configuration error', { cause: error });
+}
+
+/**
+ * Decode token for debugging purposes.
+ *
+ * We use this to add details to our logs. We don't log the entire token, since it may for example
+ * a password incorrectly used as a token.
+ */
+function tokenDebugDetails(token: string): string {
+  try {
+    // For valid tokens, we return the header and payload
+    const header = jose.decodeProtectedHeader(token);
+    const payload = jose.decodeJwt(token);
+    return `<header: ${JSON.stringify(header)} payload: ${JSON.stringify(payload)}>`;
+  } catch (e) {
+    // Token fails to parse. Return some details.
+    return invalidTokenDetails(token);
+  }
+}
+
+function invalidTokenDetails(token: string): string {
+  const parts = token.split('.');
+  if (parts.length !== 3) {
+    return `<token with ${parts.length} parts (needs 3), length=${token.length}>`;
+  }
+
+  const [headerB64, payloadB64, signatureB64] = parts;
+
+  try {
+    JSON.parse(Buffer.from(headerB64, 'base64url').toString('utf8'));
+  } catch (e) {
+    return `<token with unparsable header>`;
+  }
+
+  try {
+    JSON.parse(Buffer.from(payloadB64, 'base64url').toString('utf8'));
+  } catch (e) {
+    return `<token with unparsable payload>`;
+  }
+  try {
+    Buffer.from(signatureB64, 'base64url');
+  } catch (e) {
+    return `<token with unparsable signature>`;
+  }
+
+  return `<invalid JWT, length=${token.length}>`;
+}

package/src/index.ts

@@ -41,3 +41,5 @@ export * as utils from './util/util-index.js';
 
 export * from './streams/streams-index.js';
 export * as streams from './streams/streams-index.js';
+
+export * as bson from 'bson';

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

@@ -1,11 +1,11 @@
 import { Meter, ValueType } from '@opentelemetry/api';
 import {
   Counter,
-  ObservableGauge,
-  UpDownCounter,
   MetricMetadata,
   MetricsFactory,
-  Precision
+  ObservableGauge,
+  Precision,
+  UpDownCounter
 } from '../metrics-interfaces.js';
 
 export class OpenTelemetryMetricsFactory implements MetricsFactory {

package/src/replication/AbstractReplicationJob.ts

@@ -78,4 +78,9 @@ export abstract class AbstractReplicationJob {
   public get isStopped(): boolean {
     return this.abortController.signal.aborted;
   }
+
+  /**
+   * Get replication lag for this job in ms.
+   */
+  abstract getReplicationLagMillis(): Promise<number | undefined>;
 }

package/src/replication/AbstractReplicator.ts

@@ -8,6 +8,7 @@ import { AbstractReplicationJob } from './AbstractReplicationJob.js';
 import { ErrorRateLimiter } from './ErrorRateLimiter.js';
 import { ConnectionTestResult } from './ReplicationModule.js';
 import { MetricsEngine } from '../metrics/MetricsEngine.js';
+import { ReplicationMetric } from '@powersync/service-types';
 
 // 5 minutes
 const PING_INTERVAL = 1_000_000_000n * 300n;
@@ -42,6 +43,11 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
    *  @private
    */
   private replicationJobs = new Map<number, T>();
+  /**
+   * Used for replication lag computation.
+   */
+  private activeReplicationJob: T | undefined = undefined;
+
   private stopped = false;
 
   // First ping is only after 5 minutes, not when starting
@@ -87,6 +93,17 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
         process.exit(1);
       }, 1000);
     });
+    this.metrics.getObservableGauge(ReplicationMetric.REPLICATION_LAG_SECONDS).setValueProvider(async () => {
+      const lag = await this.getReplicationLagMillis().catch((e) => {
+        this.logger.error('Failed to get replication lag', e);
+        return undefined;
+      });
+      if (lag == null) {
+        return undefined;
+      }
+      // ms to seconds
+      return Math.round(lag / 1000);
+    });
   }
 
   public async stop(): Promise<void> {
@@ -161,8 +178,12 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
     const existingJobs = new Map<number, T>(this.replicationJobs.entries());
     const replicatingSyncRules = await this.storage.getReplicatingSyncRules();
     const newJobs = new Map<number, T>();
+    let activeJob: T | undefined = undefined;
     for (let syncRules of replicatingSyncRules) {
       const existingJob = existingJobs.get(syncRules.id);
+      if (syncRules.active && activeJob == null) {
+        activeJob = existingJob;
+      }
       if (existingJob && !existingJob.isStopped) {
         // No change
         existingJobs.delete(syncRules.id);
@@ -188,6 +209,9 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
 
           newJobs.set(syncRules.id, newJob);
           newJob.start();
+          if (syncRules.active) {
+            activeJob = newJob;
+          }
         } catch (e) {
           // Could be a sync rules parse error,
           // for example from stricter validation that was added.
@@ -199,6 +223,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.
     // Termination happens below
@@ -236,4 +261,26 @@ export abstract class AbstractReplicator<T extends AbstractReplicationJob = Abst
   }
 
   abstract testConnection(): Promise<ConnectionTestResult>;
+
+  /**
+   * Measure replication lag in milliseconds.
+   *
+   * In general, this is the difference between now() and the time the oldest record, that we haven't committed yet,
+   * has been written (committed) to the source database.
+   *
+   * This is roughly a measure of the _average_ amount of time we're behind.
+   * If we get a new change as soon as each previous one has finished processing, and each change takes 1000ms
+   * to process, the average replication lag will be 500ms, not 1000ms.
+   *
+   * 1. When we are actively replicating, this is the difference between now and when the time the change was
+   *    written to the source database.
+   * 2. When the replication stream is idle, this is either 0, or the delay for keepalive messages to make it to us.
+   * 3. When the active replication stream is an error state, this is the time since the last successful commit.
+   * 4. If there is no active replication stream, this is undefined.
+   *
+   * "processing" replication streams are not taken into account for this metric.
+   */
+  async getReplicationLagMillis(): Promise<number | undefined> {
+    return this.activeReplicationJob?.getReplicationLagMillis();
+  }
 }

package/src/replication/RelationCache.ts

@@ -0,0 +1,25 @@
+import { SourceTable } from '../storage/SourceTable.js';
+
+export class RelationCache<T> {
+  private cache = new Map<string | number, SourceTable>();
+  private idFunction: (item: T | SourceTable) => string | number;
+
+  constructor(idFunction: (item: T | SourceTable) => string | number) {
+    this.idFunction = idFunction;
+  }
+
+  update(table: SourceTable) {
+    const id = this.idFunction(table);
+    this.cache.set(id, table);
+  }
+
+  get(source: T | SourceTable): SourceTable | undefined {
+    const id = this.idFunction(source);
+    return this.cache.get(id);
+  }
+
+  delete(source: T | SourceTable): boolean {
+    const id = this.idFunction(source);
+    return this.cache.delete(id);
+  }
+}

package/src/replication/replication-index.ts

@@ -4,3 +4,4 @@ export * from './ErrorRateLimiter.js';
 export * from './ReplicationEngine.js';
 export * from './ReplicationModule.js';
 export * from './replication-metrics.js';
+export * from './RelationCache.js';

package/src/replication/replication-metrics.ts

@@ -26,6 +26,11 @@ export function createCoreReplicationMetrics(engine: MetricsEngine): void {
     name: ReplicationMetric.CHUNKS_REPLICATED,
     description: 'Total number of replication chunks'
   });
+
+  engine.createObservableGauge({
+    name: ReplicationMetric.REPLICATION_LAG_SECONDS,
+    description: 'Replication lag between the source database and PowerSync instance'
+  });
 }
 
 /**
@@ -42,4 +47,6 @@ export function initializeCoreReplicationMetrics(engine: MetricsEngine): void {
   rows_replicated_total.add(0);
   transactions_replicated_total.add(0);
   chunks_replicated_total.add(0);
+  // REPLICATION_LAG_SECONDS is not explicitly initialized - the value remains "unknown" until the first value
+  // is reported.
 }

package/src/routes/RouterEngine.ts

@@ -81,7 +81,7 @@ export class RouterEngine {
     logger.info('Starting Router Engine...');
 
     if (!this.hasRoutes) {
-      logger.warn('No routes have been registered. Router Engine will not continue.');
+      logger.info('Router Engine will not start an HTTP server as no routes have been registered.');
       return;
     }
 

package/src/routes/auth.ts

@@ -4,6 +4,7 @@ import * as auth from '../auth/auth-index.js';
 import { ServiceContext } from '../system/ServiceContext.js';
 import * as util from '../util/util-index.js';
 import { BasicRouterRequest, Context, RequestEndpointHandlerPayload } from './router.js';
+import { AuthorizationError, AuthorizationResponse, ErrorCode, ServiceError } from '@powersync/lib-services-framework';
 
 export function endpoint(req: BasicRouterRequest) {
   const protocol = req.headers['x-forwarded-proto'] ?? req.protocol;
@@ -95,25 +96,25 @@ export function getTokenFromHeader(authHeader: string = ''): string | null {
   return token ?? null;
 }
 
-export const authUser = async (payload: RequestEndpointHandlerPayload) => {
+export const authUser = async (payload: RequestEndpointHandlerPayload): Promise<AuthorizationResponse> => {
   return authorizeUser(payload.context, payload.request.headers.authorization as string);
 };
 
-export async function authorizeUser(context: Context, authHeader: string = '') {
+export async function authorizeUser(context: Context, authHeader: string = ''): Promise<AuthorizationResponse> {
   const token = getTokenFromHeader(authHeader);
   if (token == null) {
     return {
       authorized: false,
-      errors: ['Authentication required']
+      error: new AuthorizationError(ErrorCode.PSYNC_S2106, 'Authentication required')
     };
   }
 
-  const { context: tokenContext, errors } = await generateContext(context.service_context, token);
+  const { context: tokenContext, tokenError } = await generateContext(context.service_context, token);
 
   if (!tokenContext) {
     return {
       authorized: false,
-      errors
+      error: tokenError
     };
   }
 
@@ -140,7 +141,7 @@ export async function generateContext(serviceContext: ServiceContext, token: str
   } catch (err) {
     return {
       context: null,
-      errors: [err.message]
+      tokenError: auth.mapAuthError(err, token)
     };
   }
 }

package/src/routes/configure-fastify.ts

@@ -1,4 +1,6 @@
 import type fastify from 'fastify';
+import * as uuid from 'uuid';
+
 import { registerFastifyRoutes } from './route-register.js';
 
 import * as system from '../system/system-index.js';
@@ -9,7 +11,7 @@ import { PROBES_ROUTES } from './endpoints/probes.js';
 import { SYNC_RULES_ROUTES } from './endpoints/sync-rules.js';
 import { SYNC_STREAM_ROUTES } from './endpoints/sync-stream.js';
 import { createRequestQueueHook, CreateRequestQueueParams } from './hooks.js';
-import { RouteDefinition } from './router.js';
+import { ContextProvider, RouteDefinition } from './router.js';
 
 /**
  * A list of route definitions to be registered as endpoints.
@@ -58,10 +60,11 @@ export const DEFAULT_ROUTE_OPTIONS = {
 export function configureFastifyServer(server: fastify.FastifyInstance, options: FastifyServerConfig) {
   const { service_context, routes = DEFAULT_ROUTE_OPTIONS } = options;
 
-  const generateContext = async () => {
+  const generateContext: ContextProvider = async (request, options) => {
     return {
       user_id: undefined,
-      service_context: service_context
+      service_context: service_context,
+      logger: options.logger
     };
   };
 

package/src/routes/configure-rsocket.ts

@@ -1,8 +1,9 @@
 import { deserialize } from 'bson';
 import * as http from 'http';
+import * as uuid from 'uuid';
 
-import { errors, logger } from '@powersync/lib-services-framework';
-import { ReactiveSocketRouter, RSocketRequestMeta } from '@powersync/service-rsocket-router';
+import { ErrorCode, errors, logger } from '@powersync/lib-services-framework';
+import { ReactiveSocketRouter, RSocketRequestMeta, TypedBuffer } from '@powersync/service-rsocket-router';
 
 import { ServiceContext } from '../system/ServiceContext.js';
 import { generateContext, getTokenFromHeader } from './auth.js';
@@ -22,40 +23,58 @@ export function configureRSocket(router: ReactiveSocketRouter<Context>, options:
   const { route_generators = DEFAULT_SOCKET_ROUTES, server, service_context } = options;
 
   router.applyWebSocketEndpoints(server, {
-    contextProvider: async (data: Buffer) => {
-      const { token, user_agent } = RSocketContextMeta.decode(deserialize(data) as any);
+    contextProvider: async (data: TypedBuffer): Promise<Context & { token: string }> => {
+      const connectionLogger = logger.child({
+        // timestamp-based uuid - useful for requests
+        rid: `s/${uuid.v7()}`
+      });
+      const { token, user_agent } = RSocketContextMeta.decode(decodeTyped(data) as any);
 
       if (!token) {
-        throw new errors.AuthorizationError('No token provided');
+        throw new errors.AuthorizationError(ErrorCode.PSYNC_S2106, 'No token provided');
       }
 
       try {
         const extracted_token = getTokenFromHeader(token);
         if (extracted_token != null) {
-          const { context, errors: token_errors } = await generateContext(options.service_context, extracted_token);
+          const { context, tokenError } = await generateContext(options.service_context, extracted_token);
           if (context?.token_payload == null) {
-            throw new errors.AuthorizationError(token_errors ?? 'Authentication required');
+            throw new errors.AuthorizationError(ErrorCode.PSYNC_S2106, 'Authentication required');
           }
 
           return {
             token,
             user_agent,
             ...context,
-            token_errors: token_errors,
-            service_context: service_context as RouterServiceContext
+            token_error: tokenError,
+            service_context: service_context as RouterServiceContext,
+            logger: connectionLogger
           };
         } else {
-          throw new errors.AuthorizationError('No token provided');
+          // Token field is present, but did not contain a token.
+          throw new errors.AuthorizationError(ErrorCode.PSYNC_S2106, 'No valid token provided');
         }
       } catch (ex) {
-        logger.error(ex);
+        connectionLogger.error(ex);
         throw ex;
       }
     },
     endpoints: route_generators.map((generator) => generator(router)),
-    metaDecoder: async (meta: Buffer) => {
-      return RSocketRequestMeta.decode(deserialize(meta) as any);
+    metaDecoder: async (meta: TypedBuffer) => {
+      return RSocketRequestMeta.decode(decodeTyped(meta) as any);
     },
-    payloadDecoder: async (rawData?: Buffer) => rawData && deserialize(rawData)
+    payloadDecoder: async (rawData?: TypedBuffer) => rawData && decodeTyped(rawData)
   });
 }
+
+function decodeTyped(data: TypedBuffer) {
+  switch (data.mimeType) {
+    case 'application/json':
+      const decoder = new TextDecoder();
+      return JSON.parse(decoder.decode(data.contents));
+    case 'application/bson':
+      return deserialize(data.contents);
+  }
+
+  throw new errors.UnsupportedMediaType(`Expected JSON or BSON request, got ${data.mimeType}`);
+}

package/src/routes/endpoints/admin.ts

@@ -168,6 +168,8 @@ export const validate = routeDefinition({
       // Dummy values
       id: 0,
       slot_name: '',
+      active: false,
+      last_checkpoint_lsn: '',
 
       parsed() {
         return {

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

@@ -1,4 +1,4 @@
-import { ErrorCode, errors, logger, schema } from '@powersync/lib-services-framework';
+import { ErrorCode, errors, schema } from '@powersync/lib-services-framework';
 import { RequestParameters } from '@powersync/service-sync-rules';
 import { serialize } from 'bson';
 
@@ -13,12 +13,26 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
   router.reactiveStream<util.StreamingSyncRequest, any>(SyncRoutes.STREAM, {
     validator: schema.createTsCodecValidator(util.StreamingSyncRequest, { allowAdditional: true }),
     handler: async ({ context, params, responder, observer, initialN, signal: upstreamSignal }) => {
-      const { service_context } = context;
+      const { service_context, logger } = context;
       const { routerEngine, metricsEngine, syncContext } = service_context;
 
+      logger.defaultMeta = {
+        ...logger.defaultMeta,
+        user_id: context.token_payload?.sub,
+        client_id: params.client_id,
+        user_agent: context.user_agent
+      };
+      const streamStart = Date.now();
+
+      // Best effort guess on why the stream was closed.
+      // We use the `??=` operator everywhere, so that we catch the first relevant
+      // event, which is usually the most specific.
+      let closeReason: string | undefined = undefined;
+
       // Create our own controller that we can abort directly
       const controller = new AbortController();
       upstreamSignal.addEventListener('abort', () => {
+        closeReason ??= 'client closing stream';
         controller.abort();
       });
       if (upstreamSignal.aborted) {
@@ -67,6 +81,7 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
       const syncRules = bucketStorage.getParsedSyncRules(routerEngine.getAPI().getParseSyncRulesOptions());
 
       const removeStopHandler = routerEngine.addStopHandler(() => {
+        closeReason ??= 'process shutdown';
         controller.abort();
       });
 
@@ -88,7 +103,8 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
             keep_alive: false
           },
           tracker,
-          signal
+          signal,
+          logger
         })) {
           if (signal.aborted) {
             break;
@@ -131,22 +147,22 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
             });
           }
         }
+        closeReason ??= 'service closing stream';
       } catch (ex) {
         // Convert to our standard form before responding.
         // This ensures the error can be serialized.
         const error = new errors.InternalServerError(ex);
         logger.error('Sync stream error', error);
+        closeReason ??= 'stream error';
         responder.onError(error);
       } finally {
         responder.onComplete();
         removeStopHandler();
         disposer();
         logger.info(`Sync stream complete`, {
-          user_id: syncParams.user_id,
-          client_id: params.client_id,
-          user_agent: context.user_agent,
-          operations_synced: tracker.operationsSynced,
-          data_synced_bytes: tracker.dataSyncedBytes
+          ...tracker.getLogMeta(),
+          stream_ms: Date.now() - streamStart,
+          close_reason: closeReason ?? 'unknown'
         });
         metricsEngine.getUpDownCounter(APIMetric.CONCURRENT_CONNECTIONS).add(-1);
       }

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

@@ -202,13 +202,13 @@ async function debugSyncRules(apiHandler: RouteAPI, sync_rules: string) {
 
     return {
       valid: true,
-      bucket_definitions: rules.bucket_descriptors.map((d) => {
-        let all_parameter_queries = [...d.parameter_queries.values()].flat();
-        let all_data_queries = [...d.data_queries.values()].flat();
+      bucket_definitions: rules.bucketDescriptors.map((d) => {
+        let all_parameter_queries = [...d.parameterQueries.values()].flat();
+        let all_data_queries = [...d.dataQueries.values()].flat();
         return {
           name: d.name,
-          bucket_parameters: d.bucket_parameters,
-          global_parameter_queries: d.global_parameter_queries.map((q) => {
+          bucket_parameters: d.bucketParameters,
+          global_parameter_queries: d.globalParameterQueries.map((q) => {
             return {
               sql: q.sql
             };
@@ -217,7 +217,7 @@ async function debugSyncRules(apiHandler: RouteAPI, sync_rules: string) {
             return {
               sql: q.sql,
               table: q.sourceTable,
-              input_parameters: q.input_parameters
+              input_parameters: q.inputParameters
             };
           }),