@atproto/pds 0.5.12 → 0.5.14

package/tests/invites-admin.test.ts

@@ -1,252 +0,0 @@
-import { AtpAgent } from '@atproto/api'
-import { randomStr } from '@atproto/crypto'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import type { DidString } from '@atproto/syntax'
-
-describe('pds admin invite views', () => {
-  let network: TestNetworkNoAppView
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'views_admin_invites',
-      pds: {
-        inviteRequired: true,
-        inviteInterval: 1,
-      },
-    })
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  let alice: DidString
-  let bob: DidString
-  let carol: DidString
-
-  beforeAll(async () => {
-    const adminCode = await agent.api.com.atproto.server.createInviteCode(
-      { useCount: 10 },
-      { encoding: 'application/json', headers: network.pds.adminAuthHeaders() },
-    )
-
-    await sc.createAccount('alice', {
-      handle: 'alice.test',
-      email: 'alice@test.com',
-      password: 'alice',
-      inviteCode: adminCode.data.code,
-    })
-    await sc.createAccount('bob', {
-      handle: 'bob.test',
-      email: 'bob@test.com',
-      password: 'bob',
-      inviteCode: adminCode.data.code,
-    })
-    await sc.createAccount('carol', {
-      handle: 'carol.test',
-      email: 'carol@test.com',
-      password: 'carol',
-      inviteCode: adminCode.data.code,
-    })
-
-    alice = sc.dids.alice
-    bob = sc.dids.bob
-    carol = sc.dids.carol
-
-    const aliceCodes = await agent.api.com.atproto.server.getAccountInviteCodes(
-      {},
-      { headers: sc.getHeaders(alice) },
-    )
-    await agent.api.com.atproto.server.getAccountInviteCodes(
-      {},
-      { headers: sc.getHeaders(bob) },
-    )
-    await agent.api.com.atproto.server.createInviteCode(
-      { useCount: 5, forAccount: alice },
-      { encoding: 'application/json', headers: network.pds.adminAuthHeaders() },
-    )
-    await agent.api.com.atproto.admin.disableInviteCodes(
-      { codes: [adminCode.data.code], accounts: [bob] },
-      { encoding: 'application/json', headers: network.pds.adminAuthHeaders() },
-    )
-
-    const useCode = async (code: string) => {
-      const name = randomStr(8, 'base32')
-      await agent.api.com.atproto.server.createAccount({
-        handle: `${name}.test`,
-        email: `${name}@test.com`,
-        password: name,
-        inviteCode: code,
-      })
-    }
-
-    await useCode(aliceCodes.data.codes[0].code)
-    await useCode(aliceCodes.data.codes[1].code)
-  })
-
-  it('gets a list of invite codes by recency', async () => {
-    const result = await agent.api.com.atproto.admin.getInviteCodes(
-      {},
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    let lastDate = result.data.codes[0].createdAt
-    for (const code of result.data.codes) {
-      expect(code.createdAt <= lastDate).toBeTruthy()
-      lastDate = code.createdAt
-    }
-    expect(result.data.codes.length).toBe(12)
-    expect(result.data.codes[0]).toMatchObject({
-      available: 5,
-      disabled: false,
-      forAccount: alice,
-      createdBy: 'admin',
-    })
-    expect(result.data.codes[0].uses.length).toBe(0)
-    expect(result.data.codes.at(-1)).toMatchObject({
-      available: 10,
-      disabled: true,
-      forAccount: 'admin',
-      createdBy: 'admin',
-    })
-    expect(result.data.codes.at(-1)?.uses.length).toBe(3)
-  })
-
-  it('paginates by recency', async () => {
-    const full = await agent.api.com.atproto.admin.getInviteCodes(
-      {},
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    const first = await agent.api.com.atproto.admin.getInviteCodes(
-      { limit: 5 },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    const second = await agent.api.com.atproto.admin.getInviteCodes(
-      { cursor: first.data.cursor },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    const combined = [...first.data.codes, ...second.data.codes]
-    expect(combined).toEqual(full.data.codes)
-  })
-
-  it('gets a list of invite codes by usage', async () => {
-    const result = await agent.api.com.atproto.admin.getInviteCodes(
-      { sort: 'usage' },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    let lastUseCount = result.data.codes[0].uses.length
-    for (const code of result.data.codes) {
-      expect(code.uses.length).toBeLessThanOrEqual(lastUseCount)
-      lastUseCount = code.uses.length
-    }
-    expect(result.data.codes[0]).toMatchObject({
-      available: 10,
-      disabled: true,
-      forAccount: 'admin',
-      createdBy: 'admin',
-    })
-    expect(result.data.codes[0].uses.length).toBe(3)
-  })
-
-  it('paginates by usage', async () => {
-    const full = await agent.api.com.atproto.admin.getInviteCodes(
-      { sort: 'usage' },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    const first = await agent.api.com.atproto.admin.getInviteCodes(
-      { sort: 'usage', limit: 5 },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    const second = await agent.api.com.atproto.admin.getInviteCodes(
-      { sort: 'usage', cursor: first.data.cursor },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    const combined = [...first.data.codes, ...second.data.codes]
-    expect(combined).toEqual(full.data.codes)
-  })
-
-  it('hydrates invites into admin.getAccountInfo', async () => {
-    const aliceView = await agent.api.com.atproto.admin.getAccountInfo(
-      { did: alice },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(aliceView.data.invitedBy?.available).toBe(10)
-    expect(aliceView.data.invitedBy?.uses.length).toBe(3)
-    expect(aliceView.data.invites?.length).toBe(6)
-  })
-
-  it('disables an account from getting additional invite codes', async () => {
-    await agent.api.com.atproto.admin.disableAccountInvites(
-      { account: carol },
-      { encoding: 'application/json', headers: network.pds.adminAuthHeaders() },
-    )
-
-    const repoRes = await agent.api.com.atproto.admin.getAccountInfo(
-      { did: carol },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(repoRes.data.invitesDisabled).toBe(true)
-
-    const invRes = await agent.api.com.atproto.server.getAccountInviteCodes(
-      {},
-      { headers: sc.getHeaders(carol) },
-    )
-    expect(invRes.data.codes.length).toBe(0)
-  })
-
-  it('allows setting reason when enabling and disabling invite codes', async () => {
-    await agent.api.com.atproto.admin.enableAccountInvites(
-      { account: carol },
-      { encoding: 'application/json', headers: network.pds.adminAuthHeaders() },
-    )
-
-    const afterEnable = await agent.api.com.atproto.admin.getAccountInfo(
-      { did: carol },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(afterEnable.data.invitesDisabled).toBe(false)
-
-    await agent.api.com.atproto.admin.disableAccountInvites(
-      { account: carol },
-      { encoding: 'application/json', headers: network.pds.adminAuthHeaders() },
-    )
-
-    const afterDisable = await agent.api.com.atproto.admin.getAccountInfo(
-      { did: carol },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(afterDisable.data.invitesDisabled).toBe(true)
-  })
-
-  it('creates codes in the background but disables them', async () => {
-    const res = await network.pds.ctx.accountManager.db.db
-      .selectFrom('invite_code')
-      .where('forAccount', '=', carol)
-      .selectAll()
-      .execute()
-    expect(res.length).toBe(5)
-    expect(res.every((row) => row.disabled === 1))
-  })
-
-  it('re-enables an accounts invites', async () => {
-    await agent.api.com.atproto.admin.enableAccountInvites(
-      { account: carol },
-      { encoding: 'application/json', headers: network.pds.adminAuthHeaders() },
-    )
-
-    const repoRes = await agent.api.com.atproto.admin.getAccountInfo(
-      { did: carol },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    expect(repoRes.data.invitesDisabled).toBe(false)
-
-    const invRes = await agent.api.com.atproto.server.getAccountInviteCodes(
-      {},
-      { headers: sc.getHeaders(carol) },
-    )
-    expect(invRes.data.codes.length).toBeGreaterThan(0)
-  })
-})

package/tests/moderation.test.ts

@@ -1,280 +0,0 @@
-import assert from 'node:assert'
-import {
-  $Typed,
-  AtpAgent,
-  ComAtprotoAdminDefs,
-  ComAtprotoRepoStrongRef,
-} from '@atproto/api'
-import { ImageRef, SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import { BlobNotFoundError } from '@atproto/repo'
-import basicSeed from './seeds/basic.js'
-
-describe('moderation', () => {
-  let network: TestNetworkNoAppView
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let repoSubject: $Typed<ComAtprotoAdminDefs.RepoRef>
-  let recordSubject: $Typed<ComAtprotoRepoStrongRef.Main>
-  let blobSubject: $Typed<ComAtprotoAdminDefs.RepoBlobRef>
-  let blobRef: ImageRef
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'moderation',
-    })
-
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await basicSeed(sc)
-    await network.processAll()
-    repoSubject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: sc.dids.bob,
-    }
-    const post = sc.posts[sc.dids.carol][0]
-    recordSubject = {
-      $type: 'com.atproto.repo.strongRef',
-      uri: post.ref.uriStr,
-      cid: post.ref.cidStr,
-    }
-    blobRef = post.images[1]
-    blobSubject = {
-      $type: 'com.atproto.admin.defs#repoBlobRef',
-      did: sc.dids.carol,
-      cid: blobRef.image.ref.toString(),
-    }
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('takes down accounts', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.pds.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        did: repoSubject.did,
-      },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    assert(ComAtprotoAdminDefs.isRepoRef(res.data.subject))
-    expect(res.data.subject.did).toEqual(sc.dids.bob)
-    expect(res.data.takedown?.applied).toBe(true)
-    expect(res.data.takedown?.ref).toBe('test-repo')
-  })
-
-  it('restores takendown accounts', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: false },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.pds.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        did: repoSubject.did,
-      },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    assert(ComAtprotoAdminDefs.isRepoRef(res.data.subject))
-    expect(res.data.subject.did).toEqual(sc.dids.bob)
-    expect(res.data.takedown?.applied).toBe(false)
-    expect(res.data.takedown?.ref).toBeUndefined()
-  })
-
-  it('takes down records', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: recordSubject,
-        takedown: { applied: true, ref: 'test-record' },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.pds.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        uri: recordSubject.uri,
-      },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    assert(ComAtprotoRepoStrongRef.isMain(res.data.subject))
-    expect(res.data.subject.uri).toEqual(recordSubject.uri)
-    expect(res.data.takedown?.applied).toBe(true)
-    expect(res.data.takedown?.ref).toBe('test-record')
-  })
-
-  it('restores takendown records', async () => {
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: recordSubject,
-        takedown: { applied: false },
-      },
-      {
-        encoding: 'application/json',
-        headers: network.pds.adminAuthHeaders(),
-      },
-    )
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        uri: recordSubject.uri,
-      },
-      { headers: network.pds.adminAuthHeaders() },
-    )
-    assert(ComAtprotoRepoStrongRef.isMain(res.data.subject))
-    expect(res.data.subject.uri).toEqual(recordSubject.uri)
-    expect(res.data.takedown?.applied).toBe(false)
-    expect(res.data.takedown?.ref).toBeUndefined()
-  })
-
-  describe('blob takedown', () => {
-    it('takes down blobs', async () => {
-      await agent.api.com.atproto.admin.updateSubjectStatus(
-        {
-          subject: blobSubject,
-          takedown: { applied: true, ref: 'test-blob' },
-        },
-        {
-          encoding: 'application/json',
-          headers: network.pds.adminAuthHeaders(),
-        },
-      )
-      const res = await agent.api.com.atproto.admin.getSubjectStatus(
-        {
-          did: blobSubject.did,
-          blob: blobSubject.cid,
-        },
-        { headers: network.pds.adminAuthHeaders() },
-      )
-      assert(ComAtprotoAdminDefs.isRepoBlobRef(res.data.subject))
-      expect(res.data.subject.did).toEqual(blobSubject.did)
-      assert(ComAtprotoAdminDefs.isRepoBlobRef(res.data.subject))
-      expect(res.data.subject.cid).toEqual(blobSubject.cid)
-      expect(res.data.takedown?.applied).toBe(true)
-      expect(res.data.takedown?.ref).toBe('test-blob')
-    })
-
-    it('removes blob from the store', async () => {
-      const tryGetBytes = network.pds.ctx
-        .blobstore(blobSubject.did)
-        .getBytes(blobRef.image.ref)
-      await expect(tryGetBytes).rejects.toThrow(BlobNotFoundError)
-    })
-
-    it('prevents blob from being referenced again.', async () => {
-      const referenceBlob = sc.post(sc.dids.carol, 'pic', [], [blobRef])
-      await expect(referenceBlob).rejects.toThrow('Could not find blob:')
-    })
-
-    it('prevents blob from being reuploaded', async () => {
-      const attempt = sc.uploadFile(
-        sc.dids.carol,
-        '../dev-env/assets/key-alt.jpg',
-        'image/jpeg',
-      )
-      await expect(attempt).rejects.toThrow(
-        'Blob has been takendown, cannot re-upload',
-      )
-    })
-
-    it('prevents image blob from being served.', async () => {
-      const attempt = agent.api.com.atproto.sync.getBlob({
-        did: sc.dids.carol,
-        cid: blobRef.image.ref.toString(),
-      })
-      await expect(attempt).rejects.toThrow('Blob not found')
-    })
-
-    it('restores blob when takedown is removed', async () => {
-      await agent.api.com.atproto.admin.updateSubjectStatus(
-        {
-          subject: blobSubject,
-          takedown: { applied: false },
-        },
-        {
-          encoding: 'application/json',
-          headers: network.pds.adminAuthHeaders(),
-        },
-      )
-
-      // Can post and reference blob
-      const post = await sc.post(sc.dids.carol, 'pic', [], [blobRef])
-      expect(post.images[0].image.ref.equals(blobRef.image.ref)).toBeTruthy()
-
-      // Can fetch through image server
-      const res = await agent.api.com.atproto.sync.getBlob({
-        did: sc.dids.carol,
-        cid: blobRef.image.ref.toString(),
-      })
-
-      expect(res.data.byteLength).toBeGreaterThan(9000)
-    })
-
-    it('prevents blobs of takendown accounts from being served.', async () => {
-      await agent.api.com.atproto.admin.updateSubjectStatus(
-        {
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.carol,
-          },
-          takedown: { applied: true },
-        },
-        {
-          encoding: 'application/json',
-          headers: network.pds.adminAuthHeaders(),
-        },
-      )
-      const blobParams = {
-        did: sc.dids.carol,
-        cid: blobRef.image.ref.toString(),
-      }
-      // public, disallow
-      const attempt1 = agent.api.com.atproto.sync.getBlob(blobParams)
-      await expect(attempt1).rejects.toThrow(/Repo has been takendown/)
-      // logged-in, disallow
-      const attempt2 = agent.api.com.atproto.sync.getBlob(blobParams, {
-        headers: sc.getHeaders(sc.dids.bob),
-      })
-      await expect(attempt2).rejects.toThrow(/Repo has been takendown/)
-      // logged-in as account, allow
-      const res1 = await agent.api.com.atproto.sync.getBlob(blobParams, {
-        headers: sc.getHeaders(sc.dids.carol),
-      })
-      expect(res1.data.byteLength).toBeGreaterThan(9000)
-      // admin role, allow
-      const res2 = await agent.api.com.atproto.sync.getBlob(blobParams, {
-        headers: network.pds.adminAuthHeaders(),
-      })
-      expect(res2.data.byteLength).toBeGreaterThan(9000)
-      // revert takedown
-      await agent.api.com.atproto.admin.updateSubjectStatus(
-        {
-          subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
-            did: sc.dids.carol,
-          },
-          takedown: { applied: false },
-        },
-        {
-          encoding: 'application/json',
-          headers: network.pds.adminAuthHeaders(),
-        },
-      )
-    })
-  })
-})

package/tests/moderator-auth.test.ts

@@ -1,177 +0,0 @@
-import assert from 'node:assert'
-import * as plc from '@did-plc/lib'
-import { AtpAgent } from '@atproto/api'
-import { Keypair, Secp256k1Keypair } from '@atproto/crypto'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import { $Typed } from '@atproto/lex'
-import { createServiceAuthHeaders } from '@atproto/xrpc-server'
-import { com } from '../src/lexicons/index.js'
-import usersSeed from './seeds/users.js'
-
-describe('moderator auth', () => {
-  let network: TestNetworkNoAppView
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let repoSubject: $Typed<com.atproto.admin.defs.RepoRef>
-
-  let modServiceDid: string
-  let altModDid: string
-  let modServiceKey: Secp256k1Keypair
-  let pdsDid: string
-
-  const opAndDid = async (handle: string, key: Keypair) => {
-    const op = await plc.signOperation(
-      {
-        type: 'plc_operation',
-        alsoKnownAs: [handle],
-        verificationMethods: {
-          atproto: key.did(),
-        },
-        rotationKeys: [key.did()],
-        services: {},
-        prev: null,
-      },
-      key,
-    )
-    const did = await plc.didForCreateOp(op)
-    return { op, did }
-  }
-
-  beforeAll(async () => {
-    // kinda goofy but we need to know the dids before creating the testnet for the PDS's config
-    modServiceKey = await Secp256k1Keypair.create()
-    const modServiceInfo = await opAndDid('mod.test', modServiceKey)
-    const altModInfo = await opAndDid('alt-mod.test', modServiceKey)
-    modServiceDid = modServiceInfo.did
-    altModDid = altModInfo.did
-
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'pds_moderator_auth',
-      pds: {
-        modServiceDid: modServiceInfo.did,
-        modServiceUrl: 'https://mod.invalid',
-      },
-    })
-
-    pdsDid = network.pds.ctx.cfg.service.did
-
-    const plcClient = network.plc.getClient()
-    await plcClient.sendOperation(modServiceInfo.did, modServiceInfo.op)
-    await plcClient.sendOperation(altModInfo.did, altModInfo.op)
-
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await usersSeed(sc)
-    await network.processAll()
-    repoSubject = {
-      $type: 'com.atproto.admin.defs#repoRef',
-      did: sc.dids.bob,
-    }
-  }, 20_000) // @NOTE seeding can take a while
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('allows service auth requests from the configured appview did', async () => {
-    const updateHeaders = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: pdsDid,
-      lxm: com.atproto.admin.updateSubjectStatus.$lxm,
-      keypair: modServiceKey,
-    })
-    await agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...updateHeaders,
-        encoding: 'application/json',
-      },
-    )
-
-    const getHeaders = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: pdsDid,
-      lxm: com.atproto.admin.getSubjectStatus.$lxm,
-      keypair: modServiceKey,
-    })
-    const res = await agent.api.com.atproto.admin.getSubjectStatus(
-      {
-        did: repoSubject.did,
-      },
-      getHeaders,
-    )
-    assert(com.atproto.admin.defs.repoRef.$matches(res.data.subject))
-    expect(res.data.subject.did).toBe(repoSubject.did)
-    expect(res.data.takedown?.applied).toBe(true)
-  })
-
-  it('does not allow requests from another did', async () => {
-    const headers = await createServiceAuthHeaders({
-      iss: altModDid,
-      aud: pdsDid,
-      lxm: com.atproto.admin.updateSubjectStatus.$lxm,
-      keypair: modServiceKey,
-    })
-    const attempt = agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...headers,
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow('Untrusted issuer')
-  })
-
-  it('does not allow requests with a bad signature', async () => {
-    const badKey = await Secp256k1Keypair.create()
-    const headers = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: pdsDid,
-      lxm: com.atproto.admin.updateSubjectStatus.$lxm,
-      keypair: badKey,
-    })
-    const attempt = agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...headers,
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow(
-      'jwt signature does not match jwt issuer',
-    )
-  })
-
-  it('does not allow requests with a bad aud', async () => {
-    // repo subject is bob, so we set alice as the audience
-    const headers = await createServiceAuthHeaders({
-      iss: modServiceDid,
-      aud: sc.dids.alice,
-      lxm: com.atproto.admin.updateSubjectStatus.$lxm,
-      keypair: modServiceKey,
-    })
-    const attempt = agent.api.com.atproto.admin.updateSubjectStatus(
-      {
-        subject: repoSubject,
-        takedown: { applied: true, ref: 'test-repo' },
-      },
-      {
-        ...headers,
-        encoding: 'application/json',
-      },
-    )
-    await expect(attempt).rejects.toThrow(
-      'jwt audience does not match service did',
-    )
-  })
-})