@atproto/ozone 0.1.45 → 0.1.47

package/src/lexicon/lexicons.ts

@@ -1686,6 +1686,11 @@ export const schemaDict = {
             },
           },
         },
+        errors: [
+          {
+            name: 'RecordNotFound',
+          },
+        ],
       },
     },
   },
@@ -4190,6 +4195,10 @@ export const schemaDict = {
               ref: 'lex:com.atproto.label.defs#label',
             },
           },
+          pinnedPost: {
+            type: 'ref',
+            ref: 'lex:com.atproto.repo.strongRef',
+          },
         },
       },
       profileAssociated: {
@@ -4812,6 +4821,10 @@ export const schemaDict = {
               type: 'ref',
               ref: 'lex:com.atproto.repo.strongRef',
             },
+            pinnedPost: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
             createdAt: {
               type: 'string',
               format: 'datetime',
@@ -5468,6 +5481,9 @@ export const schemaDict = {
           embeddingDisabled: {
             type: 'boolean',
           },
+          pinned: {
+            type: 'boolean',
+          },
         },
       },
       feedViewPost: {
@@ -5484,7 +5500,10 @@ export const schemaDict = {
           },
           reason: {
             type: 'union',
-            refs: ['lex:app.bsky.feed.defs#reasonRepost'],
+            refs: [
+              'lex:app.bsky.feed.defs#reasonRepost',
+              'lex:app.bsky.feed.defs#reasonPin',
+            ],
           },
           feedContext: {
             type: 'string',
@@ -5536,6 +5555,10 @@ export const schemaDict = {
           },
         },
       },
+      reasonPin: {
+        type: 'object',
+        properties: {},
+      },
       threadViewPost: {
         type: 'object',
         required: ['post'],
@@ -5693,7 +5716,10 @@ export const schemaDict = {
           },
           reason: {
             type: 'union',
-            refs: ['lex:app.bsky.feed.defs#skeletonReasonRepost'],
+            refs: [
+              'lex:app.bsky.feed.defs#skeletonReasonRepost',
+              'lex:app.bsky.feed.defs#skeletonReasonPin',
+            ],
           },
           feedContext: {
             type: 'string',
@@ -5713,6 +5739,10 @@ export const schemaDict = {
           },
         },
       },
+      skeletonReasonPin: {
+        type: 'object',
+        properties: {},
+      },
       threadgateView: {
         type: 'object',
         properties: {
@@ -6078,6 +6108,10 @@ export const schemaDict = {
               ],
               default: 'posts_with_replies',
             },
+            includePins: {
+              type: 'boolean',
+              default: false,
+            },
           },
         },
         output: {
@@ -7162,7 +7196,7 @@ export const schemaDict = {
         type: 'record',
         key: 'tid',
         description:
-          "Record defining interaction gating rules for a thread (aka, reply controls). The record key (rkey) of the threadgate record must match the record key of the thread's root post, and that record must be in the same repository..",
+          "Record defining interaction gating rules for a thread (aka, reply controls). The record key (rkey) of the threadgate record must match the record key of the thread's root post, and that record must be in the same repository.",
         record: {
           type: 'object',
           required: ['post', 'createdAt'],
@@ -8236,6 +8270,12 @@ export const schemaDict = {
                   ref: 'lex:app.bsky.actor.defs#profileView',
                 },
               },
+              isFallback: {
+                type: 'boolean',
+                description:
+                  'If true, response has fallen-back to generic results, and is not scoped using relativeToDid',
+                default: false,
+              },
             },
           },
         },
@@ -9192,6 +9232,12 @@ export const schemaDict = {
                   ref: 'lex:app.bsky.unspecced.defs#skeletonSearchActor',
                 },
               },
+              relativeToDid: {
+                type: 'string',
+                format: 'did',
+                description:
+                  'DID of the account these suggestions are relative to. If this is returned undefined, suggestions are based on the viewer.',
+              },
             },
           },
         },
@@ -11602,6 +11648,49 @@ export const schemaDict = {
       },
     },
   },
+  ToolsOzoneModerationGetRecords: {
+    lexicon: 1,
+    id: 'tools.ozone.moderation.getRecords',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get details about some records.',
+        parameters: {
+          type: 'params',
+          required: ['uris'],
+          properties: {
+            uris: {
+              type: 'array',
+              maxLength: 100,
+              items: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['records'],
+            properties: {
+              records: {
+                type: 'array',
+                items: {
+                  type: 'union',
+                  refs: [
+                    'lex:tools.ozone.moderation.defs#recordViewDetail',
+                    'lex:tools.ozone.moderation.defs#recordViewNotFound',
+                  ],
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   ToolsOzoneModerationGetRepo: {
     lexicon: 1,
     id: 'tools.ozone.moderation.getRepo',
@@ -11634,6 +11723,49 @@ export const schemaDict = {
       },
     },
   },
+  ToolsOzoneModerationGetRepos: {
+    lexicon: 1,
+    id: 'tools.ozone.moderation.getRepos',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get details about some repositories.',
+        parameters: {
+          type: 'params',
+          required: ['dids'],
+          properties: {
+            dids: {
+              type: 'array',
+              maxLength: 100,
+              items: {
+                type: 'string',
+                format: 'did',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repos'],
+            properties: {
+              repos: {
+                type: 'array',
+                items: {
+                  type: 'union',
+                  refs: [
+                    'lex:tools.ozone.moderation.defs#repoViewDetail',
+                    'lex:tools.ozone.moderation.defs#repoViewNotFound',
+                  ],
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   ToolsOzoneModerationQueryEvents: {
     lexicon: 1,
     id: 'tools.ozone.moderation.queryEvents',
@@ -12450,7 +12582,9 @@ export const ids = {
   ToolsOzoneModerationEmitEvent: 'tools.ozone.moderation.emitEvent',
   ToolsOzoneModerationGetEvent: 'tools.ozone.moderation.getEvent',
   ToolsOzoneModerationGetRecord: 'tools.ozone.moderation.getRecord',
+  ToolsOzoneModerationGetRecords: 'tools.ozone.moderation.getRecords',
   ToolsOzoneModerationGetRepo: 'tools.ozone.moderation.getRepo',
+  ToolsOzoneModerationGetRepos: 'tools.ozone.moderation.getRepos',
   ToolsOzoneModerationQueryEvents: 'tools.ozone.moderation.queryEvents',
   ToolsOzoneModerationQueryStatuses: 'tools.ozone.moderation.queryStatuses',
   ToolsOzoneModerationSearchRepos: 'tools.ozone.moderation.searchRepos',

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

@@ -7,6 +7,7 @@ import { isObj, hasProp } from '../../../../util'
 import { CID } from 'multiformats/cid'
 import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs'
 import * as AppBskyGraphDefs from '../graph/defs'
+import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef'
 
 export interface ProfileViewBasic {
   did: string
@@ -74,6 +75,7 @@ export interface ProfileViewDetailed {
   createdAt?: string
   viewer?: ViewerState
   labels?: ComAtprotoLabelDefs.Label[]
+  pinnedPost?: ComAtprotoRepoStrongRef.Main
   [k: string]: unknown
 }
 

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

@@ -20,6 +20,7 @@ export interface Record {
     | ComAtprotoLabelDefs.SelfLabels
     | { $type: string; [k: string]: unknown }
   joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main
+  pinnedPost?: ComAtprotoRepoStrongRef.Main
   createdAt?: string
   [k: string]: unknown
 }

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

@@ -55,6 +55,7 @@ export interface ViewerState {
   threadMuted?: boolean
   replyDisabled?: boolean
   embeddingDisabled?: boolean
+  pinned?: boolean
   [k: string]: unknown
 }
 
@@ -73,7 +74,7 @@ export function validateViewerState(v: unknown): ValidationResult {
 export interface FeedViewPost {
   post: PostView
   reply?: ReplyRef
-  reason?: ReasonRepost | { $type: string; [k: string]: unknown }
+  reason?: ReasonRepost | ReasonPin | { $type: string; [k: string]: unknown }
   /** Context provided by feed generator that may be passed back alongside interactions. */
   feedContext?: string
   [k: string]: unknown
@@ -134,6 +135,22 @@ export function validateReasonRepost(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.feed.defs#reasonRepost', v)
 }
 
+export interface ReasonPin {
+  [k: string]: unknown
+}
+
+export function isReasonPin(v: unknown): v is ReasonPin {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#reasonPin'
+  )
+}
+
+export function validateReasonPin(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#reasonPin', v)
+}
+
 export interface ThreadViewPost {
   post: PostView
   parent?:
@@ -265,7 +282,10 @@ export function validateGeneratorViewerState(v: unknown): ValidationResult {
 
 export interface SkeletonFeedPost {
   post: string
-  reason?: SkeletonReasonRepost | { $type: string; [k: string]: unknown }
+  reason?:
+    | SkeletonReasonRepost
+    | SkeletonReasonPin
+    | { $type: string; [k: string]: unknown }
   /** Context that will be passed through to client and may be passed to feed generator back alongside interactions. */
   feedContext?: string
   [k: string]: unknown
@@ -300,6 +320,22 @@ export function validateSkeletonReasonRepost(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.feed.defs#skeletonReasonRepost', v)
 }
 
+export interface SkeletonReasonPin {
+  [k: string]: unknown
+}
+
+export function isSkeletonReasonPin(v: unknown): v is SkeletonReasonPin {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.feed.defs#skeletonReasonPin'
+  )
+}
+
+export function validateSkeletonReasonPin(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.feed.defs#skeletonReasonPin', v)
+}
+
 export interface ThreadgateView {
   uri?: string
   cid?: string

package/src/lexicon/types/app/bsky/feed/getAuthorFeed.ts

@@ -20,6 +20,7 @@ export interface QueryParams {
     | 'posts_with_media'
     | 'posts_and_author_threads'
     | (string & {})
+  includePins: boolean
 }
 
 export type InputSchema = undefined

package/src/lexicon/types/app/bsky/graph/getSuggestedFollowsByActor.ts

@@ -17,6 +17,8 @@ export type InputSchema = undefined
 
 export interface OutputSchema {
   suggestions: AppBskyActorDefs.ProfileView[]
+  /** If true, response has fallen-back to generic results, and is not scoped using relativeToDid */
+  isFallback?: boolean
   [k: string]: unknown
 }
 

package/src/lexicon/types/app/bsky/unspecced/getSuggestionsSkeleton.ts

@@ -23,6 +23,8 @@ export type InputSchema = undefined
 export interface OutputSchema {
   cursor?: string
   actors: AppBskyUnspeccedDefs.SkeletonSearchActor[]
+  /** DID of the account these suggestions are relative to. If this is returned undefined, suggestions are based on the viewer. */
+  relativeToDid?: string
   [k: string]: unknown
 }
 

package/src/lexicon/types/com/atproto/repo/getRecord.ts

@@ -39,6 +39,7 @@ export interface HandlerSuccess {
 export interface HandlerError {
   status: number
   message?: string
+  error?: 'RecordNotFound'
 }
 
 export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough

package/src/lexicon/types/tools/ozone/moderation/getRecords.ts

@@ -0,0 +1,50 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ToolsOzoneModerationDefs from './defs'
+
+export interface QueryParams {
+  uris: string[]
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  records: (
+    | ToolsOzoneModerationDefs.RecordViewDetail
+    | ToolsOzoneModerationDefs.RecordViewNotFound
+    | { $type: string; [k: string]: unknown }
+  )[]
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/moderation/getRepos.ts

@@ -0,0 +1,50 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { ValidationResult, BlobRef } from '@atproto/lexicon'
+import { lexicons } from '../../../../lexicons'
+import { isObj, hasProp } from '../../../../util'
+import { CID } from 'multiformats/cid'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import * as ToolsOzoneModerationDefs from './defs'
+
+export interface QueryParams {
+  dids: string[]
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  repos: (
+    | ToolsOzoneModerationDefs.RepoViewDetail
+    | ToolsOzoneModerationDefs.RepoViewNotFound
+    | { $type: string; [k: string]: unknown }
+  )[]
+  [k: string]: unknown
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/mod-service/views.ts

@@ -223,25 +223,33 @@ export class ModerationViews {
     }
   }
 
-  async repoDetail(
-    did: string,
+  async repoDetails(
+    dids: string[],
     labelers?: ParsedLabelers,
-  ): Promise<RepoViewDetail | undefined> {
+  ): Promise<Map<string, RepoView>> {
+    const results = new Map<string, RepoView>()
     const [repos, localLabels, externalLabels] = await Promise.all([
-      this.repos([did]),
-      this.labels(did),
-      this.getExternalLabels([did], labelers),
+      this.repos(dids),
+      this.labels(dids),
+      this.getExternalLabels(dids, labelers),
     ])
-    const repo = repos.get(did)
-    if (!repo) return
 
-    return {
-      ...repo,
-      moderation: {
-        ...repo.moderation,
-      },
-      labels: [...localLabels, ...externalLabels],
-    }
+    repos.forEach((repo, did) => {
+      const labels = [
+        ...(localLabels.get(did) || []),
+        ...(externalLabels.get(did) || []),
+      ]
+      const repoView = {
+        ...repo,
+        labels,
+        moderation: {
+          ...repo.moderation,
+        },
+      }
+      results.set(did, repoView)
+    })
+
+    return results
   }
 
   async fetchRecords(
@@ -308,47 +316,59 @@ export class ModerationViews {
     }, new Map<string, RecordView>())
   }
 
-  async recordDetail(
-    subject: RecordSubject,
+  async recordDetails(
+    subjects: RecordSubject[],
     labelers?: ParsedLabelers,
-  ): Promise<RecordViewDetail | undefined> {
-    const [records, subjectStatusesResult] = await Promise.all([
-      this.records([subject]),
-      this.getSubjectStatus([subject.uri]),
-    ])
-    const record = records.get(subject.uri)
-    if (!record) return undefined
+  ): Promise<Map<string, RecordViewDetail>> {
+    const subjectUris = subjects.map((s) => s.uri)
+    const [records, subjectStatusesResult, localLabels, externalLabels] =
+      await Promise.all([
+        this.records(subjects),
+        this.getSubjectStatus(subjectUris),
+        this.labels(subjectUris),
+        this.getExternalLabels(subjectUris, labelers),
+      ])
+
+    const results = new Map<string, RecordViewDetail>()
+
+    await Promise.all(
+      Array.from(records.entries()).map(async ([uri, record]) => {
+        const selfLabels = getSelfLabels({
+          uri: record.uri,
+          cid: record.cid,
+          record: record.value,
+        })
 
-    const status = subjectStatusesResult.get(subject.uri)
+        const status = subjectStatusesResult.get(uri)
+        const blobs = await this.blob(findBlobRefs(record.value))
 
-    const [blobs, labels, externalLabels, subjectStatus] = await Promise.all([
-      this.blob(findBlobRefs(record.value)),
-      this.labels(record.uri),
-      this.getExternalLabels([record.uri], labelers),
-      status ? this.formatSubjectStatus(status) : Promise.resolve(undefined),
-    ])
-    const selfLabels = getSelfLabels({
-      uri: record.uri,
-      cid: record.cid,
-      record: record.value,
-    })
+        results.set(uri, {
+          ...record,
+          blobs,
+          moderation: {
+            ...record.moderation,
+            subjectStatus: status
+              ? this.formatSubjectStatus(status)
+              : undefined,
+          },
+          labels: [
+            ...(localLabels.get(uri) || []),
+            ...selfLabels,
+            ...(externalLabels.get(uri) || []),
+          ],
+        })
+      }),
+    )
 
-    return {
-      ...record,
-      blobs,
-      moderation: {
-        ...record.moderation,
-        subjectStatus,
-      },
-      labels: [...labels, ...selfLabels, ...externalLabels],
-    }
+    return results
   }
 
   async getExternalLabels(
     subjects: string[],
     labelers?: ParsedLabelers,
-  ): Promise<Label[]> {
-    if (!labelers?.dids.length && !labelers?.redact.size) return []
+  ): Promise<Map<string, Label[]>> {
+    const results = new Map<string, Label[]>()
+    if (!labelers?.dids.length && !labelers?.redact.size) return results
     try {
       const {
         data: { labels },
@@ -356,13 +376,20 @@ export class ModerationViews {
         uriPatterns: subjects,
         sources: labelers.dids,
       })
-      return labels
+      labels.forEach((label) => {
+        if (!results.has(label.uri)) {
+          results.set(label.uri, [label])
+          return
+        }
+        results.get(label.uri)?.push(label)
+      })
+      return results
     } catch (err) {
       httpLogger.error(
         { err, subjects, labelers },
         'failed to resolve labels from appview',
       )
-      return []
+      return results
     }
   }
 
@@ -452,14 +479,28 @@ export class ModerationViews {
     })
   }
 
-  async labels(subject: string, includeNeg?: boolean): Promise<Label[]> {
+  async labels(
+    subjects: string[],
+    includeNeg?: boolean,
+  ): Promise<Map<string, Label[]>> {
+    const labels = new Map<string, Label[]>()
     const res = await this.db.db
       .selectFrom('label')
-      .where('label.uri', '=', subject)
+      .where('label.uri', 'in', subjects)
       .if(!includeNeg, (qb) => qb.where('neg', '=', false))
       .selectAll()
       .execute()
-    return Promise.all(res.map((l) => this.formatLabelAndEnsureSig(l)))
+
+    await Promise.all(
+      res.map(async (labelRow) => {
+        const signedLabel = await this.formatLabelAndEnsureSig(labelRow)
+        if (!labels.has(labelRow.uri)) {
+          labels.set(labelRow.uri, [])
+        }
+        labels.get(labelRow.uri)?.push(signedLabel)
+      }),
+    )
+    return labels
   }
 
   async formatLabelAndEnsureSig(row: LabelRow) {