@atproto/pds 0.4.56 → 0.4.57

package/src/lexicon/types/tools/ozone/communication/defs.ts

@@ -15,6 +15,8 @@ export interface TemplateView {
   /** Subject of the message, used in emails. */
   contentMarkdown: string
   disabled: boolean
+  /** Message language. */
+  lang?: string
   /** DID of the user who last updated the template. */
   lastUpdatedBy: string
   createdAt: string

package/src/lexicon/types/tools/ozone/communication/updateTemplate.ts

@@ -16,6 +16,8 @@ export interface InputSchema {
   id: string
   /** Name of the template. */
   name?: string
+  /** Message language. */
+  lang?: string
   /** Content of the template, markdown supported, can contain variable placeholders. */
   contentMarkdown?: string
   /** Subject of the message, used in emails. */
@@ -42,6 +44,7 @@ export interface HandlerSuccess {
 export interface HandlerError {
   status: number
   message?: string
+  error?: 'DuplicateTemplateName'
 }
 
 export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough

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

@@ -26,6 +26,7 @@ export interface InputSchema {
     | ToolsOzoneModerationDefs.ModEventMuteReporter
     | ToolsOzoneModerationDefs.ModEventUnmuteReporter
     | ToolsOzoneModerationDefs.ModEventReverseTakedown
+    | ToolsOzoneModerationDefs.ModEventResolveAppeal
     | ToolsOzoneModerationDefs.ModEventEmail
     | ToolsOzoneModerationDefs.ModEventTag
     | { $type: string; [k: string]: unknown }

package/src/repo/prepare.ts

@@ -29,6 +29,7 @@ import {
   InvalidRecordError,
   PreparedWrite,
   PreparedBlobRef,
+  ValidationStatus,
 } from './types'
 import * as lex from '../lexicon/lexicons'
 import { isRecord as isFeedGenerator } from '../lexicon/types/app/bsky/feed/generator'
@@ -39,7 +40,10 @@ import { isRecord as isList } from '../lexicon/types/app/bsky/graph/list'
 import { isRecord as isProfile } from '../lexicon/types/app/bsky/actor/profile'
 import { hasExplicitSlur } from '../handle/explicit-slurs'
 
-export const assertValidRecord = (record: Record<string, unknown>) => {
+export const assertValidRecordWithStatus = (
+  record: Record<string, unknown>,
+  opts: { requireLexicon: boolean },
+): ValidationStatus => {
   if (typeof record.$type !== 'string') {
     throw new InvalidRecordError('No $type provided')
   }
@@ -48,7 +52,11 @@ export const assertValidRecord = (record: Record<string, unknown>) => {
     assertValidCreatedAt(record)
   } catch (e) {
     if (e instanceof LexiconDefNotFoundError) {
-      throw new InvalidRecordError(e.message)
+      if (opts.requireLexicon) {
+        throw new InvalidRecordError(e.message)
+      } else {
+        return 'unknown'
+      }
     }
     throw new InvalidRecordError(
       `Invalid ${record.$type} record: ${
@@ -56,6 +64,7 @@ export const assertValidRecord = (record: Record<string, unknown>) => {
       }`,
     )
   }
+  return 'valid'
 }
 
 // additional more rigorous check on datetimes
@@ -98,12 +107,15 @@ export const prepareCreate = async (opts: {
   record: RepoRecord
   validate?: boolean
 }): Promise<PreparedCreate> => {
-  const { did, collection, swapCid, validate = true } = opts
-  const record = setCollectionName(collection, opts.record, validate)
-  if (validate) {
-    assertValidRecord(record)
+  const { did, collection, swapCid, validate } = opts
+  const maybeValidate = validate !== false
+  const record = setCollectionName(collection, opts.record, maybeValidate)
+  let validationStatus: ValidationStatus
+  if (maybeValidate) {
+    validationStatus = assertValidRecordWithStatus(record, {
+      requireLexicon: validate === true,
+    })
   }
-
   const nextRkey = TID.next()
   const rkey = opts.rkey || nextRkey.toString()
   // @TODO: validate against Lexicon record 'key' type, not just overall recordkey syntax
@@ -115,7 +127,8 @@ export const prepareCreate = async (opts: {
     cid: await cidForSafeRecord(record),
     swapCid,
     record,
-    blobs: blobsForWrite(record, validate),
+    blobs: blobsForWrite(record, maybeValidate),
+    validationStatus,
   }
 }
 
@@ -127,10 +140,14 @@ export const prepareUpdate = async (opts: {
   record: RepoRecord
   validate?: boolean
 }): Promise<PreparedUpdate> => {
-  const { did, collection, rkey, swapCid, validate = true } = opts
-  const record = setCollectionName(collection, opts.record, validate)
-  if (validate) {
-    assertValidRecord(record)
+  const { did, collection, rkey, swapCid, validate } = opts
+  const maybeValidate = validate !== false
+  const record = setCollectionName(collection, opts.record, maybeValidate)
+  let validationStatus: ValidationStatus
+  if (maybeValidate) {
+    validationStatus = assertValidRecordWithStatus(record, {
+      requireLexicon: validate === true,
+    })
   }
   assertNoExplicitSlurs(rkey, record)
   return {
@@ -139,7 +156,8 @@ export const prepareUpdate = async (opts: {
     cid: await cidForSafeRecord(record),
     swapCid,
     record,
-    blobs: blobsForWrite(record, validate),
+    blobs: blobsForWrite(record, maybeValidate),
+    validationStatus,
   }
 }
 

package/src/repo/types.ts

@@ -3,6 +3,8 @@ import { AtUri } from '@atproto/syntax'
 import { WriteOpAction } from '@atproto/repo'
 import { RepoRecord } from '@atproto/lexicon'
 
+export type ValidationStatus = 'valid' | 'unknown' | undefined
+
 export type BlobConstraint = {
   accept?: string[]
   maxSize?: number
@@ -21,6 +23,7 @@ export type PreparedCreate = {
   swapCid?: CID | null
   record: RepoRecord
   blobs: PreparedBlobRef[]
+  validationStatus: ValidationStatus
 }
 
 export type PreparedUpdate = {
@@ -30,6 +33,7 @@ export type PreparedUpdate = {
   swapCid?: CID | null
   record: RepoRecord
   blobs: PreparedBlobRef[]
+  validationStatus: ValidationStatus
 }
 
 export type PreparedDelete = {

package/tests/crud.test.ts

@@ -6,7 +6,7 @@ import { TestNetworkNoAppView } from '@atproto/dev-env'
 import { cidForCbor, TID, ui8ToArrayBuffer } from '@atproto/common'
 import { BlobNotFoundError } from '@atproto/repo'
 import * as Post from '../src/lexicon/types/app/bsky/feed/post'
-import { paginateAll } from './_util'
+import { forSnapshot, paginateAll } from './_util'
 import AppContext from '../src/context'
 import { ids, lexicons } from '../src/lexicon/lexicons'
 
@@ -565,8 +565,9 @@ describe('crud operations', () => {
     expect(got.data.value['$type']).toBe(uri.collection)
   })
 
-  it('requires the schema to be known if validating', async () => {
+  it('requires the schema to be known if explicitly validating', async () => {
     const prom = aliceAgent.api.com.atproto.repo.createRecord({
+      validate: true,
       repo: aliceAgent.accountDid,
       collection: 'com.example.foobar',
       record: { $type: 'com.example.foobar' },
@@ -576,6 +577,16 @@ describe('crud operations', () => {
     )
   })
 
+  it('does not require the schema to be known if not explicitly validating', async () => {
+    const prom = await aliceAgent.api.com.atproto.repo.createRecord({
+      // validate not set
+      repo: aliceAgent.accountDid,
+      collection: 'com.example.foobar',
+      record: { $type: 'com.example.foobar' },
+    })
+    expect(prom.data.validationStatus).toBe('unknown')
+  })
+
   it('requires the $type to match the schema', async () => {
     await expect(
       aliceAgent.api.com.atproto.repo.createRecord({
@@ -637,6 +648,7 @@ describe('crud operations', () => {
   describe('unvalidated writes', () => {
     it('disallows creation of unknown lexicons when validate is set to true', async () => {
       const attempt = aliceAgent.api.com.atproto.repo.createRecord({
+        validate: true,
         repo: aliceAgent.accountDid,
         collection: 'com.example.record',
         record: {
@@ -648,52 +660,157 @@ describe('crud operations', () => {
       )
     })
 
-    it('allows creation of unknown lexicons when validate is set to false', async () => {
-      const res = await aliceAgent.api.com.atproto.repo.createRecord({
+    it('allows creation of unknown lexicons when validate is not set to true', async () => {
+      // validate: default
+      const res1 = await aliceAgent.api.com.atproto.repo.createRecord({
         repo: aliceAgent.accountDid,
         collection: 'com.example.record',
         record: {
-          blah: 'thing',
+          blah: 'thing1',
         },
+      })
+      expect(res1.data.validationStatus).toBe('unknown')
+      const record1 = await ctx.actorStore.read(
+        aliceAgent.accountDid,
+        (store) =>
+          store.record.getRecord(new AtUri(res1.data.uri), res1.data.cid),
+      )
+      expect(record1?.value).toEqual({
+        $type: 'com.example.record',
+        blah: 'thing1',
+      })
+      // validate: false
+      const res2 = await aliceAgent.api.com.atproto.repo.createRecord({
         validate: false,
+        repo: aliceAgent.accountDid,
+        collection: 'com.example.record',
+        record: {
+          blah: 'thing2',
+        },
       })
-      const record = await ctx.actorStore.read(aliceAgent.accountDid, (store) =>
-        store.record.getRecord(new AtUri(res.data.uri), res.data.cid),
+      expect(res2.data.validationStatus).toBeUndefined()
+      const record2 = await ctx.actorStore.read(
+        aliceAgent.accountDid,
+        (store) =>
+          store.record.getRecord(new AtUri(res2.data.uri), res2.data.cid),
       )
-      expect(record?.value).toEqual({
+      expect(record2?.value).toEqual({
         $type: 'com.example.record',
-        blah: 'thing',
+        blah: 'thing2',
       })
     })
 
     it('allows update of unknown lexicons when validate is set to false', async () => {
       const createRes = await aliceAgent.api.com.atproto.repo.createRecord({
+        validate: false,
         repo: aliceAgent.accountDid,
         collection: 'com.example.record',
         record: {
           blah: 'thing',
         },
-        validate: false,
       })
       const uri = new AtUri(createRes.data.uri)
-      const updateRes = await aliceAgent.api.com.atproto.repo.putRecord({
+      // validate: default
+      const updateRes1 = await aliceAgent.api.com.atproto.repo.putRecord({
         repo: aliceAgent.accountDid,
         collection: 'com.example.record',
         rkey: uri.rkey,
         record: {
           blah: 'something else',
         },
+      })
+      const record1 = await ctx.actorStore.read(
+        aliceAgent.accountDid,
+        (store) => store.record.getRecord(uri, updateRes1.data.cid),
+      )
+      expect(record1?.value).toEqual({
+        $type: 'com.example.record',
+        blah: 'something else',
+      })
+      // validate: false
+      const updateRes2 = await aliceAgent.api.com.atproto.repo.putRecord({
         validate: false,
+        repo: aliceAgent.accountDid,
+        collection: 'com.example.record',
+        rkey: uri.rkey,
+        record: {
+          blah: 'something else',
+        },
       })
-      const record = await ctx.actorStore.read(aliceAgent.accountDid, (store) =>
-        store.record.getRecord(uri, updateRes.data.cid),
+      const record2 = await ctx.actorStore.read(
+        aliceAgent.accountDid,
+        (store) => store.record.getRecord(uri, updateRes2.data.cid),
       )
-      expect(record?.value).toEqual({
+      expect(record2?.value).toEqual({
         $type: 'com.example.record',
         blah: 'something else',
       })
     })
 
+    it('applyWrites returns results with validation status', async () => {
+      const existing1 = await aliceAgent.api.com.atproto.repo.createRecord({
+        validate: false,
+        repo: aliceAgent.accountDid,
+        collection: 'com.example.record',
+        record: {
+          blah: 'thing1',
+        },
+      })
+      const existing2 = await aliceAgent.api.com.atproto.repo.createRecord({
+        validate: false,
+        repo: aliceAgent.accountDid,
+        collection: 'com.example.record',
+        record: {
+          blah: 'thing2',
+        },
+      })
+      const {
+        data: { results },
+      } = await aliceAgent.com.atproto.repo.applyWrites({
+        repo: aliceAgent.accountDid,
+        writes: [
+          {
+            $type: `${ids.ComAtprotoRepoApplyWrites}#create`,
+            action: 'create',
+            collection: ids.AppBskyFeedPost,
+            value: {
+              $type: ids.AppBskyFeedPost,
+              text: '👋',
+              createdAt: new Date().toISOString(),
+            },
+          },
+          {
+            $type: `${ids.ComAtprotoRepoApplyWrites}#update`,
+            action: 'update',
+            collection: 'com.example.record',
+            rkey: new AtUri(existing1.data.uri).rkey,
+            value: {},
+          },
+          {
+            $type: `${ids.ComAtprotoRepoApplyWrites}#delete`,
+            action: 'delete',
+            collection: 'com.example.record',
+            rkey: new AtUri(existing2.data.uri).rkey,
+          },
+        ],
+      })
+      expect(forSnapshot(results)).toEqual([
+        {
+          $type: `${ids.ComAtprotoRepoApplyWrites}#createResult`,
+          cid: 'cids(0)',
+          uri: 'record(0)',
+          validationStatus: 'valid',
+        },
+        {
+          $type: `${ids.ComAtprotoRepoApplyWrites}#updateResult`,
+          cid: 'cids(1)',
+          uri: 'record(1)',
+          validationStatus: 'unknown',
+        },
+        { $type: `${ids.ComAtprotoRepoApplyWrites}#deleteResult` },
+      ])
+    })
+
     it('correctly associates images with unknown record types', async () => {
       const file = await fs.readFile(
         '../dev-env/src/seed/img/key-portrait-small.jpg',