@atproto/api 0.4.3 → 0.5.0

package/src/moderation/util.ts

@@ -0,0 +1,98 @@
+import {
+  AppBskyEmbedRecord,
+  AppBskyEmbedRecordWithMedia,
+  AppBskyFeedPost,
+} from '../client'
+import { ModerationDecision, ModerationUI } from './types'
+
+export function takeHighestPriorityDecision(
+  ...decisions: (ModerationDecision | undefined)[]
+): ModerationDecision {
+  // remove undefined decisions
+  const filtered = decisions.filter((d) => !!d) as ModerationDecision[]
+  if (filtered.length === 0) {
+    return ModerationDecision.noop()
+  }
+
+  // sort by highest priority
+  filtered.sort((a, b) => {
+    if (a.cause && b.cause) {
+      return a.cause.priority - b.cause.priority
+    }
+    if (a.cause) {
+      return -1
+    }
+    if (b.cause) {
+      return 1
+    }
+    return 0
+  })
+
+  // use the top priority
+  return filtered[0]
+}
+
+export function downgradeDecision(
+  decision: ModerationDecision,
+  { alert }: { alert: boolean },
+) {
+  decision.blur = false
+  decision.blurMedia = false
+  decision.filter = false
+  decision.noOverride = false
+  decision.alert = alert
+  if (!alert) {
+    delete decision.cause
+  }
+}
+
+export function isModerationDecisionNoop(
+  decision: ModerationDecision | undefined,
+  { ignoreFilter }: { ignoreFilter: boolean } = { ignoreFilter: false },
+): boolean {
+  if (!decision) {
+    return true
+  }
+  if (decision.alert) {
+    return false
+  }
+  if (decision.blur) {
+    return false
+  }
+  if (decision.filter && !ignoreFilter) {
+    return false
+  }
+  return true
+}
+
+export function isQuotedPost(embed: unknown): embed is AppBskyEmbedRecord.View {
+  return Boolean(
+    embed &&
+      AppBskyEmbedRecord.isView(embed) &&
+      AppBskyEmbedRecord.isViewRecord(embed.record) &&
+      AppBskyFeedPost.isRecord(embed.record.value) &&
+      AppBskyFeedPost.validateRecord(embed.record.value).success,
+  )
+}
+
+export function isQuotedPostWithMedia(
+  embed: unknown,
+): embed is AppBskyEmbedRecordWithMedia.View {
+  return Boolean(
+    embed &&
+      AppBskyEmbedRecordWithMedia.isView(embed) &&
+      AppBskyEmbedRecord.isViewRecord(embed.record.record) &&
+      AppBskyFeedPost.isRecord(embed.record.record.value) &&
+      AppBskyFeedPost.validateRecord(embed.record.record.value).success,
+  )
+}
+
+export function toModerationUI(decision: ModerationDecision): ModerationUI {
+  return {
+    cause: decision.cause,
+    filter: decision.filter,
+    blur: decision.blur,
+    alert: decision.alert,
+    noOverride: decision.noOverride,
+  }
+}

package/tests/post-moderation.test.ts

@@ -0,0 +1,46 @@
+import { moderatePost } from '../src'
+import type {
+  ModerationBehaviors,
+  ModerationBehaviorScenario,
+} from '../definitions/moderation-behaviors'
+import { ModerationBehaviorSuiteRunner } from './util/moderation-behavior'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+const suite: ModerationBehaviors = JSON.parse(
+  readFileSync(
+    join(__dirname, '..', 'definitions', 'post-moderation-behaviors.json'),
+    'utf8',
+  ),
+)
+
+const suiteRunner = new ModerationBehaviorSuiteRunner(suite)
+
+describe('Post moderation behaviors', () => {
+  const scenarios = Array.from(Object.entries(suite.scenarios))
+  it.each(scenarios)(
+    '%s',
+    (_name: string, scenario: ModerationBehaviorScenario) => {
+      const res = moderatePost(
+        suiteRunner.postScenario(scenario),
+        suiteRunner.moderationOpts(scenario),
+      )
+      expect(res.content).toBeModerationResult(
+        scenario.behaviors.content,
+        'post content',
+        JSON.stringify(res, null, 2),
+      )
+      expect(res.avatar).toBeModerationResult(
+        scenario.behaviors.avatar,
+        'post avatar',
+        JSON.stringify(res, null, 2),
+        true,
+      )
+      expect(res.embed).toBeModerationResult(
+        scenario.behaviors.embed,
+        'post embed',
+        JSON.stringify(res, null, 2),
+      )
+    },
+  )
+})

package/tests/profile-moderation.test.ts

@@ -0,0 +1,46 @@
+import { moderateProfile } from '../src'
+import type {
+  ModerationBehaviors,
+  ModerationBehaviorScenario,
+} from '../definitions/moderation-behaviors'
+import { ModerationBehaviorSuiteRunner } from './util/moderation-behavior'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+const suite: ModerationBehaviors = JSON.parse(
+  readFileSync(
+    join(__dirname, '..', 'definitions', 'profile-moderation-behaviors.json'),
+    'utf8',
+  ),
+)
+
+const suiteRunner = new ModerationBehaviorSuiteRunner(suite)
+
+describe('Post moderation behaviors', () => {
+  const scenarios = Array.from(Object.entries(suite.scenarios))
+  it.each(scenarios)(
+    '%s',
+    (_name: string, scenario: ModerationBehaviorScenario) => {
+      const res = moderateProfile(
+        suiteRunner.profileScenario(scenario),
+        suiteRunner.moderationOpts(scenario),
+      )
+      expect(res.account).toBeModerationResult(
+        scenario.behaviors.account,
+        'account',
+        JSON.stringify(res, null, 2),
+      )
+      expect(res.profile).toBeModerationResult(
+        scenario.behaviors.profile,
+        'profile content',
+        JSON.stringify(res, null, 2),
+      )
+      expect(res.avatar).toBeModerationResult(
+        scenario.behaviors.avatar,
+        'profile avatar',
+        JSON.stringify(res, null, 2),
+        true,
+      )
+    },
+  )
+})

package/tests/util/index.ts

@@ -0,0 +1,176 @@
+import {
+  AtpAgentFetchHandlerResponse,
+  ComAtprotoLabelDefs,
+  AppBskyFeedDefs,
+  AppBskyActorDefs,
+  AppBskyFeedPost,
+  AppBskyEmbedRecord,
+  AppBskyGraphDefs,
+} from '../../src'
+
+export async function fetchHandler(
+  httpUri: string,
+  httpMethod: string,
+  httpHeaders: Record<string, string>,
+  httpReqBody: unknown,
+): Promise<AtpAgentFetchHandlerResponse> {
+  // The duplex field is now required for streaming bodies, but not yet reflected
+  // anywhere in docs or types. See whatwg/fetch#1438, nodejs/node#46221.
+  const reqInit: RequestInit & { duplex: string } = {
+    method: httpMethod,
+    headers: httpHeaders,
+    body: httpReqBody
+      ? new TextEncoder().encode(JSON.stringify(httpReqBody))
+      : undefined,
+    duplex: 'half',
+  }
+  const res = await fetch(httpUri, reqInit)
+  const resBody = await res.arrayBuffer()
+  return {
+    status: res.status,
+    headers: Object.fromEntries(res.headers.entries()),
+    body: resBody ? JSON.parse(new TextDecoder().decode(resBody)) : undefined,
+  }
+}
+
+export const mock = {
+  post({
+    text,
+    reply,
+    embed,
+  }: {
+    text: string
+    reply?: AppBskyFeedPost.ReplyRef
+    embed?: AppBskyFeedPost.Record['embed']
+  }): AppBskyFeedPost.Record {
+    return {
+      $type: 'app.bsky.feed.post',
+      text,
+      reply,
+      embed,
+      langs: ['en'],
+      createdAt: new Date().toISOString(),
+    }
+  },
+
+  postView({
+    record,
+    author,
+    embed,
+    replyCount,
+    repostCount,
+    likeCount,
+    viewer,
+    labels,
+  }: {
+    record: AppBskyFeedPost.Record
+    author: AppBskyActorDefs.ProfileViewBasic
+    embed?: AppBskyFeedDefs.PostView['embed']
+    replyCount?: number
+    repostCount?: number
+    likeCount?: number
+    viewer?: AppBskyFeedDefs.ViewerState
+    labels?: ComAtprotoLabelDefs.Label[]
+  }): AppBskyFeedDefs.PostView {
+    return {
+      uri: `at://${author.did}/app.bsky.post/fake`,
+      cid: 'fake',
+      author,
+      record,
+      embed,
+      replyCount,
+      repostCount,
+      likeCount,
+      indexedAt: new Date().toISOString(),
+      viewer,
+      labels,
+    }
+  },
+
+  embedRecordView({
+    record,
+    author,
+    labels,
+  }: {
+    record: AppBskyFeedPost.Record
+    author: AppBskyActorDefs.ProfileViewBasic
+    labels?: ComAtprotoLabelDefs.Label[]
+  }): AppBskyEmbedRecord.View {
+    return {
+      $type: 'app.bsky.embed.record#view',
+      record: {
+        $type: 'app.bsky.embed.record#viewRecord',
+        uri: `at://${author.did}/app.bsky.post/fake`,
+        cid: 'fake',
+        author,
+        value: record,
+        labels,
+        indexedAt: new Date().toISOString(),
+      },
+    }
+  },
+
+  profileViewBasic({
+    handle,
+    displayName,
+    viewer,
+    labels,
+  }: {
+    handle: string
+    displayName?: string
+    viewer?: AppBskyActorDefs.ViewerState
+    labels?: ComAtprotoLabelDefs.Label[]
+  }): AppBskyActorDefs.ProfileViewBasic {
+    return {
+      did: `did:web:${handle}`,
+      handle,
+      displayName,
+      viewer,
+      labels,
+    }
+  },
+
+  actorViewerState({
+    muted,
+    mutedByList,
+    blockedBy,
+    blocking,
+    following,
+    followedBy,
+  }: {
+    muted?: boolean
+    mutedByList?: AppBskyGraphDefs.ListViewBasic
+    blockedBy?: boolean
+    blocking?: string
+    following?: string
+    followedBy?: string
+  }): AppBskyActorDefs.ViewerState {
+    return {
+      muted,
+      mutedByList,
+      blockedBy,
+      blocking,
+      following,
+      followedBy,
+    }
+  },
+
+  listViewBasic({ name }: { name: string }): AppBskyGraphDefs.ListViewBasic {
+    return {
+      uri: 'at://did:plc:fake/app.bsky.graph.list/fake',
+      cid: 'fake',
+      name,
+      purpose: 'app.bsky.graph.defs#modlist',
+      indexedAt: new Date().toISOString(),
+    }
+  },
+
+  label({ val, uri }: { val: string; uri: string }): ComAtprotoLabelDefs.Label {
+    return {
+      src: 'did:plc:fake-labeler',
+      uri,
+      val,
+      cts: new Date().toISOString(),
+    }
+  },
+}

package/tests/util/moderation-behavior.ts

@@ -0,0 +1,180 @@
+import { ModerationUI, ModerationOpts, ComAtprotoLabelDefs } from '../../src'
+import type {
+  ModerationBehaviors,
+  ModerationBehaviorScenario,
+  ModerationBehaviorResult,
+} from '../../definitions/moderation-behaviors'
+import { mock as m } from './index'
+
+expect.extend({
+  toBeModerationResult(
+    actual: ModerationUI,
+    expected: ModerationBehaviorResult | undefined,
+    context: string,
+    stringifiedResult: string,
+    ignoreCause = false,
+  ) {
+    const fail = (msg: string) => ({
+      pass: false,
+      message: () => `${msg}. Full result: ${stringifiedResult}`,
+    })
+    let cause = actual.cause?.type as string
+    if (actual.cause?.type === 'label') {
+      cause = `label:${actual.cause.labelDef.id}`
+    } else if (actual.cause?.type === 'muted') {
+      if (actual.cause.source.type === 'list') {
+        cause = 'muted-by-list'
+      }
+    }
+    if (!expected) {
+      if (!ignoreCause && actual.cause) {
+        return fail(`${context} expected to be a no-op, got ${cause}`)
+      }
+      if (actual.alert) {
+        return fail(`${context} expected to be a no-op, got alert=true`)
+      }
+      if (actual.blur) {
+        return fail(`${context} expected to be a no-op, got blur=true`)
+      }
+      if (actual.filter) {
+        return fail(`${context} expected to be a no-op, got filter=true`)
+      }
+      if (actual.noOverride) {
+        return fail(`${context} expected to be a no-op, got noOverride=true`)
+      }
+    } else {
+      if (!ignoreCause && cause !== expected.cause) {
+        return fail(`${context} expected to be ${expected.cause}, got ${cause}`)
+      }
+      if (!!actual.alert !== !!expected.alert) {
+        return fail(
+          `${context} expected to be alert=${expected.alert || false}, got ${
+            actual.alert || false
+          }`,
+        )
+      }
+      if (!!actual.blur !== !!expected.blur) {
+        return fail(
+          `${context} expected to be blur=${expected.blur || false}, got ${
+            actual.blur || false
+          }`,
+        )
+      }
+      if (!!actual.filter !== !!expected.filter) {
+        return fail(
+          `${context} expected to be filter=${expected.filter || false}, got ${
+            actual.filter || false
+          }`,
+        )
+      }
+      if (!!actual.noOverride !== !!expected.noOverride) {
+        return fail(
+          `${context} expected to be noOverride=${
+            expected.noOverride || false
+          }, got ${actual.noOverride || false}`,
+        )
+      }
+    }
+    return { pass: true, message: () => '' }
+  },
+})
+
+export class ModerationBehaviorSuiteRunner {
+  constructor(public suite: ModerationBehaviors) {}
+
+  postScenario(scenario: ModerationBehaviorScenario) {
+    if (scenario.subject !== 'post') {
+      throw new Error('Scenario subject must be "post"')
+    }
+    const author = this.profileViewBasic(scenario.author, scenario.labels)
+    return m.postView({
+      record: m.post({
+        text: 'Post text',
+      }),
+      author,
+      labels: (scenario.labels.post || []).map((val) =>
+        m.label({ val, uri: `at://${author.did}/app.bsky.feed.post/fake` }),
+      ),
+      embed: scenario.quoteAuthor
+        ? m.embedRecordView({
+            record: m.post({
+              text: 'Quoted post text',
+            }),
+            labels: (scenario.labels.quotedPost || []).map((val) =>
+              m.label({
+                val,
+                uri: `at://${author.did}/app.bsky.feed.post/fake`,
+              }),
+            ),
+            author: this.profileViewBasic(scenario.quoteAuthor, {
+              account: scenario.labels.quotedAccount,
+            }),
+          })
+        : undefined,
+    })
+  }
+
+  profileScenario(scenario: ModerationBehaviorScenario) {
+    if (scenario.subject !== 'profile') {
+      throw new Error('Scenario subject must be "profile"')
+    }
+    return this.profileViewBasic(scenario.author, scenario.labels)
+  }
+
+  profileViewBasic(
+    name: string,
+    scenarioLabels: ModerationBehaviorScenario['labels'],
+  ) {
+    const def = this.suite.users[name]
+
+    const labels: ComAtprotoLabelDefs.Label[] = []
+    if (scenarioLabels.account) {
+      for (const l of scenarioLabels.account) {
+        labels.push(m.label({ val: l, uri: `did:web:${name}` }))
+      }
+    }
+    if (scenarioLabels.profile) {
+      for (const l of scenarioLabels.profile) {
+        labels.push(
+          m.label({
+            val: l,
+            uri: `at://did:web:${name}/app.bsky.actor.profile/self`,
+          }),
+        )
+      }
+    }
+
+    return m.profileViewBasic({
+      handle: `${name}.test`,
+      labels,
+      viewer: m.actorViewerState({
+        muted: def.muted || def.mutedByList,
+        mutedByList: def.mutedByList
+          ? m.listViewBasic({ name: 'Fake List' })
+          : undefined,
+        blockedBy: def.blockedBy,
+        blocking: def.blocking
+          ? 'at://did:web:self.test/app.bsky.graph.block/fake'
+          : undefined,
+      }),
+    })
+  }
+
+  moderationOpts(scenario: ModerationBehaviorScenario): ModerationOpts {
+    return {
+      userDid: 'did:web:self.test',
+      adultContentEnabled: Boolean(
+        this.suite.configurations[scenario.cfg].adultContentEnabled,
+      ),
+      labelerSettings: [
+        {
+          labeler: {
+            did: 'did:plc:fake-labeler',
+            displayName: 'Fake Labeler',
+          },
+          settings: this.suite.configurations[scenario.cfg].settings,
+        },
+      ],
+    }
+  }
+}

package/dist/client/types/app/bsky/actor/searchActor.d.ts

@@ -1,22 +0,0 @@
-import { Headers } from '@atproto/xrpc';
-import * as AppBskyActorDefs from './defs';
-export interface QueryParams {
-    term?: string;
-    limit?: number;
-    cursor?: string;
-}
-export declare type InputSchema = undefined;
-export interface OutputSchema {
-    cursor?: string;
-    actors: AppBskyActorDefs.ProfileViewBasic[];
-    [k: string]: unknown;
-}
-export interface CallOptions {
-    headers?: Headers;
-}
-export interface Response {
-    success: boolean;
-    headers: Headers;
-    data: OutputSchema;
-}
-export declare function toKnownErr(e: any): any;

package/dist/client/types/app/bsky/actor/searchActorTypeahead.d.ts

@@ -1,20 +0,0 @@
-import { Headers } from '@atproto/xrpc';
-import * as AppBskyActorDefs from './defs';
-export interface QueryParams {
-    term?: string;
-    limit?: number;
-}
-export declare type InputSchema = undefined;
-export interface OutputSchema {
-    actors: AppBskyActorDefs.WithInfo[];
-    [k: string]: unknown;
-}
-export interface CallOptions {
-    headers?: Headers;
-}
-export interface Response {
-    success: boolean;
-    headers: Headers;
-    data: OutputSchema;
-}
-export declare function toKnownErr(e: any): any;

package/dist/client/types/com/atproto/admin/getInviteCodeUsage.d.ts

@@ -1,29 +0,0 @@
-import { Headers } from '@atproto/xrpc';
-import { ValidationResult } from '@atproto/lexicon';
-export interface QueryParams {
-}
-export declare type InputSchema = undefined;
-export interface OutputSchema {
-    total: CodesDetail;
-    user: CodesDetail;
-    admin: CodesDetail;
-    [k: string]: unknown;
-}
-export interface CallOptions {
-    headers?: Headers;
-}
-export interface Response {
-    success: boolean;
-    headers: Headers;
-    data: OutputSchema;
-}
-export declare function toKnownErr(e: any): any;
-export interface CodesDetail {
-    count: number;
-    available: number;
-    used: number;
-    disabled: number;
-    [k: string]: unknown;
-}
-export declare function isCodesDetail(v: unknown): v is CodesDetail;
-export declare function validateCodesDetail(v: unknown): ValidationResult;

package/dist/client/types/com/atproto/repo/importRepo.d.ts

@@ -1,19 +0,0 @@
-import { Headers } from '@atproto/xrpc';
-export interface QueryParams {
-}
-export declare type InputSchema = string | Uint8Array;
-export interface OutputSchema {
-    head: string;
-    [k: string]: unknown;
-}
-export interface CallOptions {
-    headers?: Headers;
-    qp?: QueryParams;
-    encoding: 'application/vnd.ipld.car';
-}
-export interface Response {
-    success: boolean;
-    headers: Headers;
-    data: OutputSchema;
-}
-export declare function toKnownErr(e: any): any;

package/dist/client/types/com/atproto/repo/uploadRepo.d.ts

@@ -1,19 +0,0 @@
-import { Headers } from '@atproto/xrpc';
-export interface QueryParams {
-}
-export declare type InputSchema = string | Uint8Array;
-export interface OutputSchema {
-    head: string;
-    [k: string]: unknown;
-}
-export interface CallOptions {
-    headers?: Headers;
-    qp?: QueryParams;
-    encoding: 'application/vnd.ipld.car';
-}
-export interface Response {
-    success: boolean;
-    headers: Headers;
-    data: OutputSchema;
-}
-export declare function toKnownErr(e: any): any;

package/dist/client/types/com/atproto/server/getUserInviteCodes.d.ts

@@ -1,31 +0,0 @@
-import { Headers, XRPCError } from '@atproto/xrpc';
-import { ValidationResult } from '@atproto/lexicon';
-export interface QueryParams {
-    includeUsed?: boolean;
-    createAvailable?: boolean;
-}
-export declare type InputSchema = undefined;
-export interface OutputSchema {
-    codes: Invite[];
-    [k: string]: unknown;
-}
-export interface CallOptions {
-    headers?: Headers;
-}
-export interface Response {
-    success: boolean;
-    headers: Headers;
-    data: OutputSchema;
-}
-export declare class DuplicateCreateError extends XRPCError {
-    constructor(src: XRPCError);
-}
-export declare function toKnownErr(e: any): any;
-export interface Invite {
-    code: string;
-    available: number;
-    uses: number;
-    [k: string]: unknown;
-}
-export declare function isInvite(v: unknown): v is Invite;
-export declare function validateInvite(v: unknown): ValidationResult;