@powersync/service-core 0.5.0 → 0.6.0

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

@@ -3,20 +3,13 @@ import { RequestParameters } from '@powersync/service-sync-rules';
 import { serialize } from 'bson';
 
 import { Metrics } from '../../metrics/Metrics.js';
-import { streamResponse } from '../../sync/sync.js';
+import * as sync from '../../sync/sync-index.js';
 import * as util from '../../util/util-index.js';
 import { SocketRouteGenerator } from '../router-socket.js';
 import { SyncRoutes } from './sync-stream.js';
-import { RequestTracker } from '../../sync/RequestTracker.js';
 
 export const syncStreamReactive: SocketRouteGenerator = (router) =>
   router.reactiveStream<util.StreamingSyncRequest, any>(SyncRoutes.STREAM, {
-    authorize: ({ context }) => {
-      return {
-        authorized: !!context.token_payload,
-        errors: ['Authentication required'].concat(context.token_errors ?? [])
-      };
-    },
     validator: schema.createTsCodecValidator(util.StreamingSyncRequest, { allowAdditional: true }),
     handler: async ({ context, params, responder, observer, initialN }) => {
       const { system } = context;
@@ -67,9 +60,9 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
       });
 
       Metrics.getInstance().concurrent_connections.add(1);
-      const tracker = new RequestTracker();
+      const tracker = new sync.RequestTracker();
       try {
-        for await (const data of streamResponse({
+        for await (const data of sync.streamResponse({
           storage,
           params: {
             ...params,

package/src/routes/route-register.ts

@@ -1,6 +1,6 @@
-import fastify from 'fastify';
+import type fastify from 'fastify';
 
-import { errors, router, HTTPMethod, logger } from '@powersync/lib-services-framework';
+import { errors, HTTPMethod, logger, router } from '@powersync/lib-services-framework';
 import { Context, ContextProvider, RequestEndpoint, RequestEndpointHandlerPayload } from './router.js';
 
 export type FastifyEndpoint<I, O, C> = RequestEndpoint<I, O, C> & {

package/src/routes/router-socket.ts

@@ -1,13 +1,13 @@
+import { IReactiveStream, ReactiveSocketRouter } from '@powersync/service-rsocket-router';
 import * as t from 'ts-codec';
-import { ReactiveSocketRouter, IReactiveStream } from '@powersync/service-rsocket-router';
 
 import { Context } from './router.js';
 
-export const RSocketContextMeta = t.object({
-  token: t.string
-});
-
 /**
  * Creates a socket route handler given a router instance
  */
 export type SocketRouteGenerator = (router: ReactiveSocketRouter<Context>) => IReactiveStream;
+
+export const RSocketContextMeta = t.object({
+  token: t.string
+});

package/src/routes/router.ts

@@ -36,6 +36,8 @@ export type RequestEndpointHandlerPayload<
   request: Request;
 };
 
+export type RouteDefinition<I = any, O = any> = RequestEndpoint<I, O>;
+
 /**
  * Helper function for making generics work well when defining routes
  */

package/src/routes/routes-index.ts

@@ -1,4 +1,6 @@
 export * as auth from './auth.js';
+export * from './configure-fastify.js';
+export * from './configure-rsocket.js';
 export * as endpoints from './endpoints/route-endpoints-index.js';
 export * as hooks from './hooks.js';
 export * from './route-register.js';

package/src/storage/BucketStorage.ts

@@ -426,4 +426,11 @@ export interface CompactOptions {
    * not be compacted, to avoid invalidating checkpoints in use.
    */
   maxOpId?: bigint;
+
+  /**
+   * If specified, compact only the specific buckets.
+   *
+   * If not specified, compacts all buckets.
+   */
+  compactBuckets?: string[];
 }

package/src/storage/mongo/MongoCompactor.ts

@@ -55,6 +55,7 @@ export class MongoCompactor {
   private moveBatchQueryLimit: number;
   private clearBatchLimit: number;
   private maxOpId: bigint | undefined;
+  private buckets: string[] | undefined;
 
   constructor(private db: PowerSyncMongo, private group_id: number, options?: MongoCompactOptions) {
     this.idLimitBytes = (options?.memoryLimitMB ?? DEFAULT_MEMORY_LIMIT_MB) * 1024 * 1024;
@@ -62,6 +63,7 @@ export class MongoCompactor {
     this.moveBatchQueryLimit = options?.moveBatchQueryLimit ?? DEFAULT_MOVE_BATCH_QUERY_LIMIT;
     this.clearBatchLimit = options?.clearBatchLimit ?? DEFAULT_CLEAR_BATCH_LIMIT;
     this.maxOpId = options?.maxOpId;
+    this.buckets = options?.compactBuckets;
   }
 
   /**
@@ -70,6 +72,19 @@ export class MongoCompactor {
    * See /docs/compacting-operations.md for details.
    */
   async compact() {
+    if (this.buckets) {
+      for (let bucket of this.buckets) {
+        // We can make this more efficient later on by iterating
+        // through the buckets in a single query.
+        // That makes batching more tricky, so we leave for later.
+        await this.compactInternal(bucket);
+      }
+    } else {
+      await this.compactInternal(undefined);
+    }
+  }
+
+  async compactInternal(bucket: string | undefined) {
     const idLimitBytes = this.idLimitBytes;
 
     let currentState: CurrentBucketState | null = null;
@@ -77,14 +92,14 @@ export class MongoCompactor {
     // Constant lower bound
     const lowerBound: BucketDataKey = {
       g: this.group_id,
-      b: new MinKey() as any,
+      b: bucket ?? (new MinKey() as any),
       o: new MinKey() as any
     };
 
     // Upper bound is adjusted for each batch
     let upperBound: BucketDataKey = {
       g: this.group_id,
-      b: new MaxKey() as any,
+      b: bucket ?? (new MaxKey() as any),
       o: new MaxKey() as any
     };
 

package/src/sync/sync-index.ts

@@ -1,6 +1,7 @@
 export * from './BroadcastIterable.js';
 export * from './LastValueSink.js';
 export * from './merge.js';
+export * from './RequestTracker.js';
 export * from './safeRace.js';
 export * from './sync.js';
 export * from './util.js';