@atproto/bsync 0.0.19 → 0.0.21

package/dist/routes/scan-operations.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const operation_1 = require("../db/schema/operation");
+const bsync_pb_1 = require("../proto/bsync_pb");
+const auth_1 = require("./auth");
+const util_1 = require("./util");
+exports.default = (ctx) => ({
+    async scanOperations(req, handlerCtx) {
+        (0, auth_1.authWithApiKey)(ctx, handlerCtx);
+        const { db, events } = ctx;
+        const limit = req.limit || 1000;
+        const cursor = (0, util_1.validCursor)(req.cursor);
+        const nextOpPromise = (0, node_events_1.once)(events, operation_1.createOperationChannel, {
+            signal: (0, util_1.combineSignals)(ctx.shutdown, AbortSignal.timeout(ctx.cfg.service.longPollTimeoutMs)),
+        });
+        nextOpPromise.catch(() => null); // ensure timeout is always handled
+        const nextOpPageQb = db.db
+            .selectFrom('operation')
+            .selectAll()
+            .where('id', '>', cursor ?? -1)
+            .orderBy('id', 'asc')
+            .limit(limit);
+        let ops = await nextOpPageQb.execute();
+        if (!ops.length) {
+            // if there were no ops on the page, wait for an event then try again.
+            try {
+                await nextOpPromise;
+            }
+            catch (err) {
+                ctx.shutdown.throwIfAborted();
+                return new bsync_pb_1.ScanOperationsResponse({
+                    operations: [],
+                    cursor: req.cursor,
+                });
+            }
+            ops = await nextOpPageQb.execute();
+            if (!ops.length) {
+                return new bsync_pb_1.ScanOperationsResponse({
+                    operations: [],
+                    cursor: req.cursor,
+                });
+            }
+        }
+        const lastOp = ops[ops.length - 1];
+        return new bsync_pb_1.ScanOperationsResponse({
+            operations: ops.map((op) => ({
+                id: op.id.toString(),
+                actorDid: op.actorDid,
+                namespace: op.namespace,
+                key: op.key,
+                method: op.method,
+                payload: op.payload,
+            })),
+            cursor: lastOp.id.toString(),
+        });
+    },
+});
+//# sourceMappingURL=scan-operations.js.map

package/dist/routes/scan-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-operations.js","sourceRoot":"","sources":["../../src/routes/scan-operations.ts"],"names":[],"mappings":";;AAAA,6CAAkC;AAGlC,sDAA+D;AAE/D,gDAA0D;AAC1D,iCAAuC;AACvC,iCAAoD;AAEpD,kBAAe,CAAC,GAAe,EAAwC,EAAE,CAAC,CAAC;IACzE,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,UAAU;QAClC,IAAA,qBAAc,EAAC,GAAG,EAAE,UAAU,CAAC,CAAA;QAC/B,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,GAAG,CAAA;QAC1B,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,IAAI,IAAI,CAAA;QAC/B,MAAM,MAAM,GAAG,IAAA,kBAAW,EAAC,GAAG,CAAC,MAAM,CAAC,CAAA;QACtC,MAAM,aAAa,GAAG,IAAA,kBAAI,EAAC,MAAM,EAAE,kCAAsB,EAAE;YACzD,MAAM,EAAE,IAAA,qBAAc,EACpB,GAAG,CAAC,QAAQ,EACZ,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,CACvD;SACF,CAAC,CAAA;QACF,aAAa,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAA,CAAC,mCAAmC;QAEnE,MAAM,YAAY,GAAG,EAAE,CAAC,EAAE;aACvB,UAAU,CAAC,WAAW,CAAC;aACvB,SAAS,EAAE;aACX,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC;aAC9B,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC;aACpB,KAAK,CAAC,KAAK,CAAC,CAAA;QAEf,IAAI,GAAG,GAAG,MAAM,YAAY,CAAC,OAAO,EAAE,CAAA;QAEtC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;YAChB,sEAAsE;YACtE,IAAI,CAAC;gBACH,MAAM,aAAa,CAAA;YACrB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,GAAG,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAA;gBAC7B,OAAO,IAAI,iCAAsB,CAAC;oBAChC,UAAU,EAAE,EAAE;oBACd,MAAM,EAAE,GAAG,CAAC,MAAM;iBACnB,CAAC,CAAA;YACJ,CAAC;YACD,GAAG,GAAG,MAAM,YAAY,CAAC,OAAO,EAAE,CAAA;YAClC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC;gBAChB,OAAO,IAAI,iCAAsB,CAAC;oBAChC,UAAU,EAAE,EAAE;oBACd,MAAM,EAAE,GAAG,CAAC,MAAM;iBACnB,CAAC,CAAA;YACJ,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAElC,OAAO,IAAI,iCAAsB,CAAC;YAChC,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAC3B,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,EAAE;gBACpB,QAAQ,EAAE,EAAE,CAAC,QAAQ;gBACrB,SAAS,EAAE,EAAE,CAAC,SAAS;gBACvB,GAAG,EAAE,EAAE,CAAC,GAAG;gBACX,MAAM,EAAE,EAAE,CAAC,MAAM;gBACjB,OAAO,EAAE,EAAE,CAAC,OAAO;aACpB,CAAC,CAAC;YACH,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE;SAC7B,CAAC,CAAA;IACJ,CAAC;CACF,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/bsync",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "license": "MIT",
   "description": "Sychronizing service for app.bsky App View (Bluesky API)",
   "keywords": [
@@ -28,7 +28,7 @@
     "pino-http": "^8.2.1",
     "typed-emitter": "^2.1.0",
     "@atproto/common": "^0.4.11",
-    "@atproto/syntax": "^0.4.0"
+    "@atproto/syntax": "^0.4.1"
   },
   "devDependencies": {
     "@bufbuild/buf": "^1.28.1",

package/proto/bsync.proto

@@ -67,6 +67,44 @@ message ScanNotifOperationsResponse {
 }
 
 
+enum Method {
+  METHOD_UNSPECIFIED = 0;
+  METHOD_CREATE = 1;
+  METHOD_UPDATE = 2;
+  METHOD_DELETE = 3;
+}
+
+message Operation {
+  string id = 1;
+  string actor_did = 2;
+  string namespace = 3;
+  string key = 4;
+  Method method = 5;
+  bytes payload = 6;
+}
+
+message PutOperationRequest {
+  string actor_did = 1;
+  string namespace = 2;
+  string key = 3;
+  Method method = 4;
+  bytes payload = 5;
+}
+
+message PutOperationResponse {
+  Operation operation = 1;
+}
+
+message ScanOperationsRequest {
+  string cursor = 1;
+  int32 limit = 2;
+}
+
+message ScanOperationsResponse {
+  repeated Operation operations = 1;
+  string cursor = 2;
+}
+
 
 // Ping
 message PingRequest {}
@@ -79,6 +117,8 @@ service Service {
   rpc ScanMuteOperations(ScanMuteOperationsRequest) returns (ScanMuteOperationsResponse);
   rpc AddNotifOperation(AddNotifOperationRequest) returns (AddNotifOperationResponse);
   rpc ScanNotifOperations(ScanNotifOperationsRequest) returns (ScanNotifOperationsResponse);
+  rpc PutOperation(PutOperationRequest) returns (PutOperationResponse);
+  rpc ScanOperations(ScanOperationsRequest) returns (ScanOperationsResponse);
   // Ping
   rpc Ping(PingRequest) returns (PingResponse);
 }

package/src/context.ts

@@ -4,6 +4,7 @@ import { ServerConfig } from './config'
 import { Database } from './db'
 import { createMuteOpChannel } from './db/schema/mute_op'
 import { createNotifOpChannel } from './db/schema/notif_op'
+import { createOperationChannel } from './db/schema/operation'
 
 export type AppContextOptions = {
   db: Database
@@ -43,4 +44,5 @@ export class AppContext {
 export type AppEvents = {
   [createMuteOpChannel]: () => void
   [createNotifOpChannel]: () => void
+  [createOperationChannel]: () => void
 }

package/src/db/migrations/20250527T022203400Z-add-operation.ts

@@ -0,0 +1,20 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('operation')
+    .addColumn('id', 'bigserial', (col) => col.primaryKey())
+    .addColumn('collection', 'varchar', (col) => col.notNull())
+    .addColumn('actorDid', 'varchar', (col) => col.notNull())
+    .addColumn('rkey', 'varchar', (col) => col.notNull())
+    .addColumn('method', 'int2', (col) => col.notNull())
+    .addColumn('payload', sql`bytea`)
+    .addColumn('createdAt', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
+    )
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('operation').execute()
+}

package/src/db/migrations/20250603T163446567Z-alter-operation.ts

@@ -0,0 +1,19 @@
+import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .alterTable('operation')
+    .renameColumn('collection', 'namespace')
+    .execute()
+
+  await db.schema.alterTable('operation').renameColumn('rkey', 'key').execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .alterTable('operation')
+    .renameColumn('namespace', 'collection')
+    .execute()
+
+  await db.schema.alterTable('operation').renameColumn('key', 'rkey').execute()
+}

package/src/db/migrations/index.ts

@@ -4,3 +4,5 @@
 
 export * as _20240108T220751294Z from './20240108T220751294Z-init'
 export * as _20240717T224303472Z from './20240717T224303472Z-notif-ops'
+export * as _20250527T022203400Z from './20250527T022203400Z-add-operation'
+export * as _20250603T163446567Z from './20250603T163446567Z-alter-operation'

package/src/db/schema/index.ts

@@ -3,11 +3,13 @@ import * as muteItem from './mute_item'
 import * as muteOp from './mute_op'
 import * as notifItem from './notif_item'
 import * as notifOp from './notif_op'
+import * as op from './operation'
 
 export type DatabaseSchemaType = muteItem.PartialDB &
   muteOp.PartialDB &
   notifItem.PartialDB &
-  notifOp.PartialDB
+  notifOp.PartialDB &
+  op.PartialDB
 
 export type DatabaseSchema = Kysely<DatabaseSchemaType>
 

package/src/db/schema/operation.ts

@@ -0,0 +1,20 @@
+import { GeneratedAlways } from 'kysely'
+import { Method } from '../../proto/bsync_pb'
+
+export type OperationMethod = Method.CREATE | Method.UPDATE | Method.DELETE
+
+export interface Operation {
+  id: GeneratedAlways<number>
+  actorDid: string
+  namespace: string
+  key: string
+  method: OperationMethod
+  payload: Uint8Array
+  createdAt: GeneratedAlways<Date>
+}
+
+export const tableName = 'operation'
+
+export type PartialDB = { [tableName]: Operation }
+
+export const createOperationChannel = 'operation_create' // used with listen/notify

package/src/index.ts

@@ -6,6 +6,7 @@ import { ServerConfig } from './config'
 import { AppContext, AppContextOptions } from './context'
 import { createMuteOpChannel } from './db/schema/mute_op'
 import { createNotifOpChannel } from './db/schema/notif_op'
+import { createOperationChannel } from './db/schema/operation'
 import { dbLogger, loggerMiddleware } from './logger'
 import routes from './routes'
 
@@ -92,6 +93,7 @@ export class BsyncService {
     // if these error, unhandled rejection should cause process to exit
     conn.query(`listen ${createMuteOpChannel}`)
     conn.query(`listen ${createNotifOpChannel}`)
+    conn.query(`listen ${createOperationChannel}`)
     conn.on('notification', (notif) => {
       if (notif.channel === createMuteOpChannel) {
         this.ctx.events.emit(createMuteOpChannel)
@@ -99,6 +101,9 @@ export class BsyncService {
       if (notif.channel === createNotifOpChannel) {
         this.ctx.events.emit(createNotifOpChannel)
       }
+      if (notif.channel === createOperationChannel) {
+        this.ctx.events.emit(createOperationChannel)
+      }
     })
   }
 }

package/src/proto/bsync_connect.ts

@@ -10,10 +10,14 @@ import {
   AddNotifOperationResponse,
   PingRequest,
   PingResponse,
+  PutOperationRequest,
+  PutOperationResponse,
   ScanMuteOperationsRequest,
   ScanMuteOperationsResponse,
   ScanNotifOperationsRequest,
   ScanNotifOperationsResponse,
+  ScanOperationsRequest,
+  ScanOperationsResponse,
 } from './bsync_pb'
 import { MethodKind } from '@bufbuild/protobuf'
 
@@ -61,6 +65,24 @@ export const Service = {
       O: ScanNotifOperationsResponse,
       kind: MethodKind.Unary,
     },
+    /**
+     * @generated from rpc bsync.Service.PutOperation
+     */
+    putOperation: {
+      name: 'PutOperation',
+      I: PutOperationRequest,
+      O: PutOperationResponse,
+      kind: MethodKind.Unary,
+    },
+    /**
+     * @generated from rpc bsync.Service.ScanOperations
+     */
+    scanOperations: {
+      name: 'ScanOperations',
+      I: ScanOperationsRequest,
+      O: ScanOperationsResponse,
+      kind: MethodKind.Unary,
+    },
     /**
      * Ping
      *

package/src/proto/bsync_pb.ts

@@ -13,6 +13,38 @@ import type {
 } from '@bufbuild/protobuf'
 import { Message, proto3 } from '@bufbuild/protobuf'
 
+/**
+ * @generated from enum bsync.Method
+ */
+export enum Method {
+  /**
+   * @generated from enum value: METHOD_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: METHOD_CREATE = 1;
+   */
+  CREATE = 1,
+
+  /**
+   * @generated from enum value: METHOD_UPDATE = 2;
+   */
+  UPDATE = 2,
+
+  /**
+   * @generated from enum value: METHOD_DELETE = 3;
+   */
+  DELETE = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(Method)
+proto3.util.setEnumType(Method, 'bsync.Method', [
+  { no: 0, name: 'METHOD_UNSPECIFIED' },
+  { no: 1, name: 'METHOD_CREATE' },
+  { no: 2, name: 'METHOD_UPDATE' },
+  { no: 3, name: 'METHOD_DELETE' },
+])
+
 /**
  * @generated from message bsync.MuteOperation
  */
@@ -689,6 +721,329 @@ export class ScanNotifOperationsResponse extends Message<ScanNotifOperationsResp
   }
 }
 
+/**
+ * @generated from message bsync.Operation
+ */
+export class Operation extends Message<Operation> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = ''
+
+  /**
+   * @generated from field: string actor_did = 2;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: string namespace = 3;
+   */
+  namespace = ''
+
+  /**
+   * @generated from field: string key = 4;
+   */
+  key = ''
+
+  /**
+   * @generated from field: bsync.Method method = 5;
+   */
+  method = Method.UNSPECIFIED
+
+  /**
+   * @generated from field: bytes payload = 6;
+   */
+  payload = new Uint8Array(0)
+
+  constructor(data?: PartialMessage<Operation>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.Operation'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'namespace', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: 'key', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 5, name: 'method', kind: 'enum', T: proto3.getEnumType(Method) },
+    { no: 6, name: 'payload', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): Operation {
+    return new Operation().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): Operation {
+    return new Operation().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): Operation {
+    return new Operation().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: Operation | PlainMessage<Operation> | undefined,
+    b: Operation | PlainMessage<Operation> | undefined,
+  ): boolean {
+    return proto3.util.equals(Operation, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.PutOperationRequest
+ */
+export class PutOperationRequest extends Message<PutOperationRequest> {
+  /**
+   * @generated from field: string actor_did = 1;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: string namespace = 2;
+   */
+  namespace = ''
+
+  /**
+   * @generated from field: string key = 3;
+   */
+  key = ''
+
+  /**
+   * @generated from field: bsync.Method method = 4;
+   */
+  method = Method.UNSPECIFIED
+
+  /**
+   * @generated from field: bytes payload = 5;
+   */
+  payload = new Uint8Array(0)
+
+  constructor(data?: PartialMessage<PutOperationRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.PutOperationRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'namespace', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'key', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: 'method', kind: 'enum', T: proto3.getEnumType(Method) },
+    { no: 5, name: 'payload', kind: 'scalar', T: 12 /* ScalarType.BYTES */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PutOperationRequest {
+    return new PutOperationRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationRequest {
+    return new PutOperationRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationRequest {
+    return new PutOperationRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: PutOperationRequest | PlainMessage<PutOperationRequest> | undefined,
+    b: PutOperationRequest | PlainMessage<PutOperationRequest> | undefined,
+  ): boolean {
+    return proto3.util.equals(PutOperationRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.PutOperationResponse
+ */
+export class PutOperationResponse extends Message<PutOperationResponse> {
+  /**
+   * @generated from field: bsync.Operation operation = 1;
+   */
+  operation?: Operation
+
+  constructor(data?: PartialMessage<PutOperationResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.PutOperationResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'operation', kind: 'message', T: Operation },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PutOperationResponse {
+    return new PutOperationResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationResponse {
+    return new PutOperationResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PutOperationResponse {
+    return new PutOperationResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: PutOperationResponse | PlainMessage<PutOperationResponse> | undefined,
+    b: PutOperationResponse | PlainMessage<PutOperationResponse> | undefined,
+  ): boolean {
+    return proto3.util.equals(PutOperationResponse, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.ScanOperationsRequest
+ */
+export class ScanOperationsRequest extends Message<ScanOperationsRequest> {
+  /**
+   * @generated from field: string cursor = 1;
+   */
+  cursor = ''
+
+  /**
+   * @generated from field: int32 limit = 2;
+   */
+  limit = 0
+
+  constructor(data?: PartialMessage<ScanOperationsRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.ScanOperationsRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'limit', kind: 'scalar', T: 5 /* ScalarType.INT32 */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): ScanOperationsRequest {
+    return new ScanOperationsRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsRequest {
+    return new ScanOperationsRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsRequest {
+    return new ScanOperationsRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: ScanOperationsRequest | PlainMessage<ScanOperationsRequest> | undefined,
+    b: ScanOperationsRequest | PlainMessage<ScanOperationsRequest> | undefined,
+  ): boolean {
+    return proto3.util.equals(ScanOperationsRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.ScanOperationsResponse
+ */
+export class ScanOperationsResponse extends Message<ScanOperationsResponse> {
+  /**
+   * @generated from field: repeated bsync.Operation operations = 1;
+   */
+  operations: Operation[] = []
+
+  /**
+   * @generated from field: string cursor = 2;
+   */
+  cursor = ''
+
+  constructor(data?: PartialMessage<ScanOperationsResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.ScanOperationsResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: 'operations',
+      kind: 'message',
+      T: Operation,
+      repeated: true,
+    },
+    { no: 2, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): ScanOperationsResponse {
+    return new ScanOperationsResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsResponse {
+    return new ScanOperationsResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): ScanOperationsResponse {
+    return new ScanOperationsResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | ScanOperationsResponse
+      | PlainMessage<ScanOperationsResponse>
+      | undefined,
+    b:
+      | ScanOperationsResponse
+      | PlainMessage<ScanOperationsResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(ScanOperationsResponse, a, b)
+  }
+}
+
 /**
  * Ping
  *

package/src/routes/index.ts

@@ -4,8 +4,10 @@ import { AppContext } from '../context'
 import { Service } from '../proto/bsync_connect'
 import addMuteOperation from './add-mute-operation'
 import addNotifOperation from './add-notif-operation'
+import putOperation from './put-operation'
 import scanMuteOperations from './scan-mute-operations'
 import scanNotifOperations from './scan-notif-operations'
+import scanOperations from './scan-operations'
 
 export default (ctx: AppContext) => (router: ConnectRouter) => {
   return router.service(Service, {
@@ -13,6 +15,8 @@ export default (ctx: AppContext) => (router: ConnectRouter) => {
     ...scanMuteOperations(ctx),
     ...addNotifOperation(ctx),
     ...scanNotifOperations(ctx),
+    ...putOperation(ctx),
+    ...scanOperations(ctx),
     async ping() {
       const { db } = ctx
       await sql`select 1`.execute(db.db)