@atproto/bsync 0.0.18 → 0.0.20

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 collection = 3;
+   */
+  collection = ''
+
+  /**
+   * @generated from field: string rkey = 4;
+   */
+  rkey = ''
+
+  /**
+   * @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: 'collection', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: 'rkey', 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 collection = 1;
+   */
+  collection = ''
+
+  /**
+   * @generated from field: string actor_did = 2;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: string rkey = 3;
+   */
+  rkey = ''
+
+  /**
+   * @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: 'collection', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'rkey', 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)

package/src/routes/put-operation.ts

@@ -0,0 +1,101 @@
+import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
+import { sql } from 'kysely'
+import { ensureValidNsid, ensureValidRecordKey } from '@atproto/syntax'
+import { AppContext } from '../context'
+import { Database } from '../db'
+import { OperationMethod, createOperationChannel } from '../db/schema/operation'
+import { Service } from '../proto/bsync_connect'
+import {
+  Method,
+  PutOperationRequest,
+  PutOperationResponse,
+} from '../proto/bsync_pb'
+import { authWithApiKey } from './auth'
+import { isValidDid } from './util'
+
+export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
+  async putOperation(req, handlerCtx) {
+    authWithApiKey(ctx, handlerCtx)
+    const { db } = ctx
+    const op = validateOp(req)
+    const id = await db.transaction(async (txn) => {
+      return putOp(txn, op)
+    })
+    return new PutOperationResponse({
+      operation: {
+        id: String(id),
+        collection: op.collection,
+        actorDid: op.actorDid,
+        rkey: op.rkey,
+        method: op.method,
+        payload: op.payload,
+      },
+    })
+  },
+})
+
+const putOp = async (db: Database, op: Operation) => {
+  const { ref } = db.db.dynamic
+  const { id } = await db.db
+    .insertInto('operation')
+    .values({
+      collection: op.collection,
+      actorDid: op.actorDid,
+      rkey: op.rkey,
+      method: op.method,
+      payload: op.payload,
+    })
+    .returning('id')
+    .executeTakeFirstOrThrow()
+  await sql`notify ${ref(createOperationChannel)}`.execute(db.db) // emitted transactionally
+  return id
+}
+
+const validateOp = (req: PutOperationRequest): Operation => {
+  try {
+    ensureValidNsid(req.collection)
+  } catch (error) {
+    throw new ConnectError(
+      'operation collection is invalid NSID',
+      Code.InvalidArgument,
+    )
+  }
+
+  if (!isValidDid(req.actorDid)) {
+    throw new ConnectError(
+      'operation actor_did is invalid DID',
+      Code.InvalidArgument,
+    )
+  }
+
+  try {
+    ensureValidRecordKey(req.rkey)
+  } catch (error) {
+    throw new ConnectError('operation rkey is required', Code.InvalidArgument)
+  }
+
+  if (
+    req.method !== Method.CREATE &&
+    req.method !== Method.UPDATE &&
+    req.method !== Method.DELETE
+  ) {
+    throw new ConnectError('operation method is invalid', Code.InvalidArgument)
+  }
+
+  if (req.method === Method.DELETE && req.payload.length > 0) {
+    throw new ConnectError(
+      'cannot specify a payload when method is DELETE',
+      Code.InvalidArgument,
+    )
+  }
+
+  return req as Operation
+}
+
+type Operation = {
+  collection: string
+  actorDid: string
+  rkey: string
+  payload: Uint8Array
+  method: OperationMethod
+}

package/src/routes/scan-operations.ts

@@ -0,0 +1,67 @@
+import { once } from 'node:events'
+import { ServiceImpl } from '@connectrpc/connect'
+import { AppContext } from '../context'
+import { createOperationChannel } from '../db/schema/operation'
+import { Service } from '../proto/bsync_connect'
+import { ScanOperationsResponse } from '../proto/bsync_pb'
+import { authWithApiKey } from './auth'
+import { combineSignals, validCursor } from './util'
+
+export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
+  async scanOperations(req, handlerCtx) {
+    authWithApiKey(ctx, handlerCtx)
+    const { db, events } = ctx
+    const limit = req.limit || 1000
+    const cursor = validCursor(req.cursor)
+    const nextOpPromise = once(events, createOperationChannel, {
+      signal: 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 ScanOperationsResponse({
+          operations: [],
+          cursor: req.cursor,
+        })
+      }
+      ops = await nextOpPageQb.execute()
+      if (!ops.length) {
+        return new ScanOperationsResponse({
+          operations: [],
+          cursor: req.cursor,
+        })
+      }
+    }
+
+    const lastOp = ops[ops.length - 1]
+
+    return new ScanOperationsResponse({
+      operations: ops.map((op) => ({
+        id: op.id.toString(),
+        collection: op.collection,
+        actorDid: op.actorDid,
+        rkey: op.rkey,
+        method: op.method,
+        payload: op.payload,
+      })),
+      cursor: lastOp.id.toString(),
+    })
+  },
+})