@atproto/bsky 0.0.81 → 0.0.83

package/src/lexicon/lexicons.ts

@@ -4572,6 +4572,15 @@ export const schemaDict = {
               maxLength: 100,
             },
           },
+          nuxs: {
+            description: 'Storage for NUXs the user has encountered.',
+            type: 'array',
+            maxLength: 100,
+            items: {
+              type: 'ref',
+              ref: 'lex:app.bsky.actor.defs#nux',
+            },
+          },
         },
       },
       bskyAppProgressGuide: {
@@ -4586,6 +4595,34 @@ export const schemaDict = {
           },
         },
       },
+      nux: {
+        type: 'object',
+        description: 'A new user experiences (NUX) storage object',
+        required: ['id', 'completed'],
+        properties: {
+          id: {
+            type: 'string',
+            maxLength: 100,
+          },
+          completed: {
+            type: 'boolean',
+            default: false,
+          },
+          data: {
+            description:
+              'Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters.',
+            type: 'string',
+            maxLength: 3000,
+            maxGraphemes: 300,
+          },
+          expiresAt: {
+            type: 'string',
+            format: 'datetime',
+            description:
+              'The date and time at which the NUX will expire and should be considered completed.',
+          },
+        },
+      },
     },
   },
   AppBskyActorGetPreferences: {

package/src/lexicon/types/app/bsky/actor/defs.ts

@@ -469,6 +469,8 @@ export interface BskyAppStatePref {
   activeProgressGuide?: BskyAppProgressGuide
   /** An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user. */
   queuedNudges?: string[]
+  /** Storage for NUXs the user has encountered. */
+  nuxs?: Nux[]
   [k: string]: unknown
 }
 
@@ -501,3 +503,24 @@ export function isBskyAppProgressGuide(v: unknown): v is BskyAppProgressGuide {
 export function validateBskyAppProgressGuide(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#bskyAppProgressGuide', v)
 }
+
+/** A new user experiences (NUX) storage object */
+export interface Nux {
+  id: string
+  completed: boolean
+  /** Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters. */
+  data?: string
+  /** The date and time at which the NUX will expire and should be considered completed. */
+  expiresAt?: string
+  [k: string]: unknown
+}
+
+export function isNux(v: unknown): v is Nux {
+  return (
+    isObj(v) && hasProp(v, '$type') && v.$type === 'app.bsky.actor.defs#nux'
+  )
+}
+
+export function validateNux(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#nux', v)
+}

package/tests/data-plane/indexing.test.ts

@@ -429,7 +429,7 @@ describe('indexing', () => {
 
   describe('indexRepo', () => {
     beforeAll(async () => {
-      network.bsky.sub.run()
+      await network.bsky.sub.restart()
       await basicSeed(sc, false)
       await network.processAll()
       await network.bsky.sub.destroy()

package/tests/data-plane/{subscription/repo.test.ts → subscription.test.ts}

@@ -1,11 +1,11 @@
 import { AtpAgent } from '@atproto/api'
 import { cborDecode, cborEncode } from '@atproto/common'
-import { DatabaseSchemaType } from '../../../src/data-plane/server/db/database-schema'
+import { DatabaseSchemaType } from '../../src/data-plane/server/db/database-schema'
 import { SeedClient, TestNetwork, basicSeed } from '@atproto/dev-env'
 import { PreparedWrite, sequencer } from '@atproto/pds'
 import { CommitData } from '@atproto/repo'
-import { ids } from '../../../src/lexicon/lexicons'
-import { forSnapshot } from '../../_util'
+import { ids } from '../../src/lexicon/lexicons'
+import { forSnapshot } from '../_util'
 
 type Database = TestNetwork['bsky']['db']
 
@@ -60,12 +60,7 @@ describe('sync', () => {
     const originalTableDump = await getTableDump()
 
     // Reprocess repos via sync subscription, on top of existing indices
-    await network.bsky.sub.destroy()
-    // Hard reset of state
-    network.bsky.sub.cursor = 0
-    network.bsky.sub.seenSeq = null
-    // Boot streams back up
-    network.bsky.sub.run()
+    await network.bsky.sub.restart()
     await network.processAll()
 
     // Permissive of indexedAt times changing

package/tests/entryway-auth.test.ts

@@ -0,0 +1,174 @@
+import * as nodeCrypto from 'node:crypto'
+import KeyEncoder from 'key-encoder'
+import * as ui8 from 'uint8arrays'
+import * as jose from 'jose'
+import * as crypto from '@atproto/crypto'
+import { AtpAgent, AtUri } from '@atproto/api'
+import { basicSeed, SeedClient, TestNetwork } from '@atproto/dev-env'
+import assert from 'node:assert'
+import { MINUTE } from '@atproto/common'
+
+const keyEncoder = new KeyEncoder('secp256k1')
+
+const derivePrivKey = async (
+  keypair: crypto.ExportableKeypair,
+): Promise<nodeCrypto.KeyObject> => {
+  const privKeyRaw = await keypair.export()
+  const privKeyEncoded = keyEncoder.encodePrivate(
+    ui8.toString(privKeyRaw, 'hex'),
+    'raw',
+    'pem',
+  )
+  return nodeCrypto.createPrivateKey(privKeyEncoded)
+}
+
+// @NOTE temporary measure, see note on entrywaySession in bsky/src/auth-verifier.ts
+describe('entryway auth', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+  let alice: string
+  let jwtPrivKey: nodeCrypto.KeyObject
+
+  beforeAll(async () => {
+    const keypair = await crypto.Secp256k1Keypair.create({ exportable: true })
+    jwtPrivKey = await derivePrivKey(keypair)
+    const entrywayJwtPublicKeyHex = ui8.toString(
+      keypair.publicKeyBytes(),
+      'hex',
+    )
+
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_entryway_auth',
+      bsky: {
+        entrywayJwtPublicKeyHex,
+      },
+    })
+    agent = network.bsky.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+    alice = sc.dids.alice
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('works', async () => {
+    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
+      .setSubject(alice)
+      .setIssuedAt()
+      .setExpirationTime('60mins')
+      .setAudience('did:web:fake.server.bsky.network')
+      .setProtectedHeader({
+        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
+        alg: 'ES256K',
+      })
+    const token = await signer.sign(jwtPrivKey)
+    const res = await agent.app.bsky.actor.getProfile(
+      { actor: sc.dids.bob },
+      { headers: { authorization: `Bearer ${token}` } },
+    )
+    expect(res.data.did).toEqual(sc.dids.bob)
+    // ensure this request is personalized for alice
+    const followingUri = res.data.viewer?.following
+    assert(followingUri)
+    const parsed = new AtUri(followingUri)
+    expect(parsed.hostname).toEqual(alice)
+  })
+
+  it('does not work on bad scopes', async () => {
+    const signer = new jose.SignJWT({ scope: 'com.atproto.refresh' })
+      .setSubject(alice)
+      .setIssuedAt()
+      .setExpirationTime('60mins')
+      .setAudience('did:web:fake.server.bsky.network')
+      .setProtectedHeader({
+        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
+        alg: 'ES256K',
+      })
+    const token = await signer.sign(jwtPrivKey)
+    const attempt = agent.app.bsky.actor.getProfile(
+      { actor: sc.dids.bob },
+      { headers: { authorization: `Bearer ${token}` } },
+    )
+    await expect(attempt).rejects.toThrow('Bad token scope')
+  })
+
+  it('does not work on expired tokens', async () => {
+    const time = Math.floor((Date.now() - 5 * MINUTE) / 1000)
+    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
+      .setSubject(alice)
+      .setIssuedAt()
+      .setExpirationTime(time)
+      .setAudience('did:web:fake.server.bsky.network')
+      .setProtectedHeader({
+        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
+        alg: 'ES256K',
+      })
+    const token = await signer.sign(jwtPrivKey)
+    const attempt = agent.app.bsky.actor.getProfile(
+      { actor: sc.dids.bob },
+      { headers: { authorization: `Bearer ${token}` } },
+    )
+    await expect(attempt).rejects.toThrow('Token has expired')
+  })
+
+  it('does not work on bad auds', async () => {
+    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
+      .setSubject(alice)
+      .setIssuedAt()
+      .setExpirationTime('60mins')
+      .setAudience('did:web:my.personal.pds.com')
+      .setProtectedHeader({
+        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
+        alg: 'ES256K',
+      })
+    const token = await signer.sign(jwtPrivKey)
+    const attempt = agent.app.bsky.actor.getProfile(
+      { actor: sc.dids.bob },
+      { headers: { authorization: `Bearer ${token}` } },
+    )
+    await expect(attempt).rejects.toThrow('Bad token aud')
+  })
+
+  it('does not work with bad signatures', async () => {
+    const fakeKey = await crypto.Secp256k1Keypair.create({ exportable: true })
+    const fakeJwtKey = await derivePrivKey(fakeKey)
+    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
+      .setSubject(alice)
+      .setIssuedAt()
+      .setExpirationTime('60mins')
+      .setAudience('did:web:my.personal.pds.com')
+      .setProtectedHeader({
+        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
+        alg: 'ES256K',
+      })
+    const token = await signer.sign(fakeJwtKey)
+    const attempt = agent.app.bsky.actor.getProfile(
+      { actor: sc.dids.bob },
+      { headers: { authorization: `Bearer ${token}` } },
+    )
+    await expect(attempt).rejects.toThrow('Token could not be verified')
+  })
+
+  it('does not work on flexible aud routes', async () => {
+    const signer = new jose.SignJWT({ scope: 'com.atproto.access' })
+      .setSubject(alice)
+      .setIssuedAt()
+      .setExpirationTime('60mins')
+      .setAudience('did:web:fake.server.bsky.network')
+      .setProtectedHeader({
+        typ: 'at+jwt', // https://www.rfc-editor.org/rfc/rfc9068.html
+        alg: 'ES256K',
+      })
+    const token = await signer.sign(jwtPrivKey)
+    const feedUri = AtUri.make(alice, 'app.bsky.feed.generator', 'fake-feed')
+    const attempt = agent.app.bsky.feed.getFeed(
+      { feed: feedUri.toString() },
+      { headers: { authorization: `Bearer ${token}` } },
+    )
+    await expect(attempt).rejects.toThrow('Malformed token')
+  })
+})

package/tests/views/actor-search.test.ts

@@ -39,7 +39,7 @@ describe.skip('pds actor search views', () => {
       .execute()
 
     // Process remaining profiles
-    network.bsky.sub.run()
+    await network.bsky.sub.restart()
     await network.processAll(50000)
     headers = await network.serviceHeaders(
       Object.values(sc.dids)[0],

package/dist/data-plane/server/subscription/index.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="node" />
-import { IdResolver } from '@atproto/identity';
-import { IndexingService } from '../indexing';
-import { Database } from '../db';
-import { ConsecutiveList, PartitionedQueue } from './util';
-import { BackgroundQueue } from '../background';
-export declare class RepoSubscription {
-    private opts;
-    ac: AbortController;
-    running: Promise<void> | undefined;
-    cursor: number;
-    seenSeq: number | null;
-    repoQueue: PartitionedQueue;
-    consecutive: ConsecutiveList<number>;
-    background: BackgroundQueue;
-    indexingSvc: IndexingService;
-    constructor(opts: {
-        service: string;
-        db: Database;
-        idResolver: IdResolver;
-        background: BackgroundQueue;
-    });
-    run(): void;
-    private process;
-    private handleMessage;
-    private handleCommit;
-    private handleUpdateHandle;
-    private handleIdentityEvt;
-    private handleAccountEvt;
-    private getSubscription;
-    destroy(): Promise<void>;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/data-plane/server/subscription/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/data-plane/server/subscription/index.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAY9C,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,OAAO,EAEL,eAAe,EACf,gBAAgB,EAGjB,MAAM,QAAQ,CAAA;AACf,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/C,qBAAa,gBAAgB;IAWzB,OAAO,CAAC,IAAI;IAVd,EAAE,kBAAwB;IAC1B,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAA;IAClC,MAAM,SAAI;IACV,OAAO,EAAE,MAAM,GAAG,IAAI,CAAO;IAC7B,SAAS,mBAAkD;IAC3D,WAAW,0BAAgC;IAC3C,UAAU,EAAE,eAAe,CAAA;IAC3B,WAAW,EAAE,eAAe,CAAA;gBAGlB,IAAI,EAAE;QACZ,OAAO,EAAE,MAAM,CAAA;QACf,EAAE,EAAE,QAAQ,CAAA;QACZ,UAAU,EAAE,UAAU,CAAA;QACtB,UAAU,EAAE,eAAe,CAAA;KAC5B;IAUH,GAAG;YAgBW,OAAO;YAqBP,aAAa;YAqCb,YAAY;YAgEZ,kBAAkB;YAIlB,iBAAiB;YAIjB,gBAAgB;IAQ9B,OAAO,CAAC,eAAe;IAkCjB,OAAO;CAMd"}

package/dist/data-plane/server/subscription/index.js

@@ -1,341 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RepoSubscription = void 0;
-const node_assert_1 = __importDefault(require("node:assert"));
-const syntax_1 = require("@atproto/syntax");
-const xrpc_server_1 = require("@atproto/xrpc-server");
-const common_1 = require("@atproto/common");
-const lexicon_1 = require("@atproto/lexicon");
-const repo_1 = require("@atproto/repo");
-const lexicons_1 = require("../../../lexicon/lexicons");
-const message = __importStar(require("../../../lexicon/types/com/atproto/sync/subscribeRepos"));
-const logger_1 = require("../../../logger");
-const indexing_1 = require("../indexing");
-const util_1 = require("./util");
-const background_1 = require("../background");
-class RepoSubscription {
-    constructor(opts) {
-        Object.defineProperty(this, "opts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: opts
-        });
-        Object.defineProperty(this, "ac", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new AbortController()
-        });
-        Object.defineProperty(this, "running", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "cursor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "seenSeq", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "repoQueue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new util_1.PartitionedQueue({ concurrency: Infinity })
-        });
-        Object.defineProperty(this, "consecutive", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new util_1.ConsecutiveList()
-        });
-        Object.defineProperty(this, "background", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "indexingSvc", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.background = new background_1.BackgroundQueue(this.opts.db);
-        this.indexingSvc = new indexing_1.IndexingService(this.opts.db, this.opts.idResolver, this.background);
-    }
-    run() {
-        if (this.running)
-            return;
-        this.ac = new AbortController();
-        this.repoQueue = new util_1.PartitionedQueue({ concurrency: Infinity });
-        this.consecutive = new util_1.ConsecutiveList();
-        this.running = this.process()
-            .catch((err) => {
-            if (err.name !== 'AbortError') {
-                // allow this to cause an unhandled rejection, let deployment handle the crash.
-                logger_1.subLogger.error({ err }, 'subscription crashed');
-                throw err;
-            }
-        })
-            .finally(() => (this.running = undefined));
-    }
-    async process() {
-        const sub = this.getSubscription();
-        for await (const msg of sub) {
-            const details = getMessageDetails(msg);
-            if ('info' in details) {
-                // These messages are not sequenced, we just log them and carry on
-                logger_1.subLogger.warn({ provider: this.opts.service, message: (0, util_1.loggableMessage)(msg) }, `sub ${details.info ? 'info' : 'unknown'} message`);
-                continue;
-            }
-            const item = this.consecutive.push(details.seq);
-            this.repoQueue.add(details.repo, async () => {
-                await this.handleMessage(item, details);
-            });
-            this.seenSeq = details.seq;
-            await this.repoQueue.main.onEmpty(); // backpressure
-        }
-    }
-    async handleMessage(item, envelope) {
-        const msg = envelope.message;
-        try {
-            if (message.isCommit(msg)) {
-                await this.handleCommit(msg);
-            }
-            else if (message.isHandle(msg)) {
-                await this.handleUpdateHandle(msg);
-            }
-            else if (message.isIdentity(msg)) {
-                await this.handleIdentityEvt(msg);
-            }
-            else if (message.isAccount(msg)) {
-                await this.handleAccountEvt(msg);
-            }
-            else if (message.isTombstone(msg)) {
-                // Ignore tombstones
-            }
-            else if (message.isMigrate(msg)) {
-                // Ignore migrations
-            }
-            else {
-                const exhaustiveCheck = msg;
-                throw new Error(`Unhandled message type: ${exhaustiveCheck['$type']}`);
-            }
-        }
-        catch (err) {
-            // We log messages we can't process and move on:
-            // otherwise the cursor would get stuck on a poison message.
-            logger_1.subLogger.error({ err, message: (0, util_1.loggableMessage)(msg) }, 'indexer message processing error');
-        }
-        finally {
-            const latest = item.complete().at(-1);
-            if (latest !== undefined) {
-                this.cursor = latest;
-            }
-        }
-    }
-    async handleCommit(msg) {
-        const indexRecords = async () => {
-            const { root, rootCid, ops } = await getOps(msg);
-            if (msg.tooBig) {
-                await this.indexingSvc.indexRepo(msg.repo, rootCid.toString());
-                await this.indexingSvc.setCommitLastSeen(root, msg);
-                return;
-            }
-            if (msg.rebase) {
-                const needsReindex = await this.indexingSvc.checkCommitNeedsIndexing(root);
-                if (needsReindex) {
-                    await this.indexingSvc.indexRepo(msg.repo, rootCid.toString());
-                }
-                await this.indexingSvc.setCommitLastSeen(root, msg);
-                return;
-            }
-            for (const op of ops) {
-                if (op.action === repo_1.WriteOpAction.Delete) {
-                    await this.indexingSvc.deleteRecord(op.uri);
-                }
-                else {
-                    try {
-                        await this.indexingSvc.indexRecord(op.uri, op.cid, op.record, op.action, // create or update
-                        msg.time);
-                    }
-                    catch (err) {
-                        if (err instanceof lexicon_1.ValidationError) {
-                            logger_1.subLogger.warn({
-                                did: msg.repo,
-                                commit: msg.commit.toString(),
-                                uri: op.uri.toString(),
-                                cid: op.cid.toString(),
-                            }, 'skipping indexing of invalid record');
-                        }
-                        else {
-                            logger_1.subLogger.error({
-                                err,
-                                did: msg.repo,
-                                commit: msg.commit.toString(),
-                                uri: op.uri.toString(),
-                                cid: op.cid.toString(),
-                            }, 'skipping indexing due to error processing record');
-                        }
-                    }
-                }
-            }
-            await this.indexingSvc.setCommitLastSeen(root, msg);
-        };
-        const results = await Promise.allSettled([
-            indexRecords(),
-            this.indexingSvc.indexHandle(msg.repo, msg.time),
-        ]);
-        (0, common_1.handleAllSettledErrors)(results);
-    }
-    async handleUpdateHandle(msg) {
-        await this.indexingSvc.indexHandle(msg.did, msg.time, true);
-    }
-    async handleIdentityEvt(msg) {
-        await this.indexingSvc.indexHandle(msg.did, msg.time, true);
-    }
-    async handleAccountEvt(msg) {
-        if (msg.active === false && msg.status === 'deleted') {
-            await this.indexingSvc.deleteActor(msg.did);
-        }
-        else {
-            await this.indexingSvc.updateActorStatus(msg.did, msg.active, msg.status);
-        }
-    }
-    getSubscription() {
-        return new xrpc_server_1.Subscription({
-            service: this.opts.service,
-            method: lexicons_1.ids.ComAtprotoSyncSubscribeRepos,
-            signal: this.ac.signal,
-            getParams: async () => {
-                return { cursor: this.cursor };
-            },
-            onReconnectError: (err, reconnects, initial) => {
-                logger_1.subLogger.warn({ err, reconnects, initial }, 'sub reconnect');
-            },
-            validate: (value) => {
-                try {
-                    return lexicons_1.lexicons.assertValidXrpcMessage(lexicons_1.ids.ComAtprotoSyncSubscribeRepos, value);
-                }
-                catch (err) {
-                    logger_1.subLogger.warn({
-                        err,
-                        seq: ifNumber(value?.['seq']),
-                        repo: ifString(value?.['repo']),
-                        commit: ifString(value?.['commit']?.toString()),
-                        time: ifString(value?.['time']),
-                        provider: this.opts.service,
-                    }, 'ingester sub skipped invalid message');
-                }
-            },
-        });
-    }
-    async destroy() {
-        this.ac.abort();
-        await this.running;
-        await this.repoQueue.destroy();
-        await this.background.processAll();
-    }
-}
-exports.RepoSubscription = RepoSubscription;
-function ifString(val) {
-    return typeof val === 'string' ? val : undefined;
-}
-function ifNumber(val) {
-    return typeof val === 'number' ? val : undefined;
-}
-function getMessageDetails(msg) {
-    if (message.isCommit(msg)) {
-        return { seq: msg.seq, repo: msg.repo, message: msg };
-    }
-    else if (message.isHandle(msg)) {
-        return { seq: msg.seq, repo: msg.did, message: msg };
-    }
-    else if (message.isIdentity(msg)) {
-        return { seq: msg.seq, repo: msg.did, message: msg };
-    }
-    else if (message.isAccount(msg)) {
-        return { seq: msg.seq, repo: msg.did, message: msg };
-    }
-    else if (message.isMigrate(msg)) {
-        return { seq: msg.seq, repo: msg.did, message: msg };
-    }
-    else if (message.isTombstone(msg)) {
-        return { seq: msg.seq, repo: msg.did, message: msg };
-    }
-    else if (message.isInfo(msg)) {
-        return { info: msg };
-    }
-    return { info: null };
-}
-async function getOps(msg) {
-    const car = await (0, repo_1.readCarWithRoot)(msg.blocks);
-    const rootBytes = car.blocks.get(car.root);
-    (0, node_assert_1.default)(rootBytes, 'Missing commit block in car slice');
-    const root = repo_1.def.commit.schema.parse((0, common_1.cborDecode)(rootBytes));
-    const ops = msg.ops.map((op) => {
-        const [collection, rkey] = op.path.split('/');
-        (0, node_assert_1.default)(collection && rkey);
-        if (op.action === repo_1.WriteOpAction.Create ||
-            op.action === repo_1.WriteOpAction.Update) {
-            (0, node_assert_1.default)(op.cid);
-            const record = car.blocks.get(op.cid);
-            (0, node_assert_1.default)(record);
-            return {
-                action: op.action === repo_1.WriteOpAction.Create
-                    ? repo_1.WriteOpAction.Create
-                    : repo_1.WriteOpAction.Update,
-                cid: op.cid,
-                record: (0, repo_1.cborToLexRecord)(record),
-                blobs: [],
-                uri: syntax_1.AtUri.make(msg.repo, collection, rkey),
-            };
-        }
-        else if (op.action === repo_1.WriteOpAction.Delete) {
-            return {
-                action: repo_1.WriteOpAction.Delete,
-                uri: syntax_1.AtUri.make(msg.repo, collection, rkey),
-            };
-        }
-        else {
-            throw new Error(`Unknown repo op action: ${op.action}`);
-        }
-    });
-    return { root, rootCid: car.root, ops };
-}
-//# sourceMappingURL=index.js.map