@atproto/ozone 0.1.49 → 0.1.51

package/src/set/service.ts

@@ -0,0 +1,227 @@
+import Database from '../db'
+import { Selectable } from 'kysely'
+import { SetDetail } from '../db/schema/ozone_set'
+import { SetView } from '../lexicon/types/tools/ozone/set/defs'
+import { paginate, TimeIdKeyset } from '../db/pagination'
+
+export type SetServiceCreator = (db: Database) => SetService
+
+export class SetService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new SetService(db)
+  }
+
+  buildQueryForSetWithSize() {
+    return this.db.db.selectFrom('set_detail as s').select([
+      's.id',
+      's.name',
+      's.description',
+      's.createdAt',
+      's.updatedAt',
+      (eb) =>
+        eb
+          .selectFrom('set_value')
+          .select((e) => e.fn.count<number>('setId').as('count'))
+          .whereRef('setId', '=', 's.id')
+          .as('setSize'),
+    ])
+  }
+
+  async query({
+    limit,
+    cursor,
+    namePrefix,
+    sortBy,
+    sortDirection,
+  }: {
+    limit: number
+    cursor?: string
+    namePrefix?: string
+    sortBy: 'name' | 'createdAt' | 'updatedAt'
+    sortDirection: 'asc' | 'desc'
+  }): Promise<{
+    sets: Selectable<SetDetail & { setSize: number }>[]
+    cursor?: string
+  }> {
+    let qb = this.buildQueryForSetWithSize().limit(limit)
+
+    if (namePrefix) {
+      qb = qb.where('s.name', 'like', `${namePrefix}%`)
+    }
+
+    if (cursor) {
+      if (sortBy === 'name') {
+        qb = qb.where('s.name', sortDirection === 'asc' ? '>' : '<', cursor)
+      } else {
+        qb = qb.where(
+          `s.${sortBy}`,
+          sortDirection === 'asc' ? '>' : '<',
+          new Date(cursor),
+        )
+      }
+    }
+
+    qb = qb.orderBy(`s.${sortBy}`, sortDirection)
+
+    const sets = await qb.execute()
+    const lastItem = sets.at(-1)
+
+    return {
+      sets,
+      cursor: lastItem
+        ? sortBy === 'name'
+          ? lastItem?.name
+          : lastItem?.[sortBy].toISOString()
+        : undefined,
+    }
+  }
+
+  async getByName(name: string): Promise<Selectable<SetDetail> | undefined> {
+    const query = this.db.db
+      .selectFrom('set_detail')
+      .selectAll()
+      .where('name', '=', name)
+
+    return await query.executeTakeFirst()
+  }
+
+  async getByNameWithSize(
+    name: string,
+  ): Promise<Selectable<SetDetail & { setSize: number }> | undefined> {
+    return await this.buildQueryForSetWithSize()
+      .where('s.name', '=', name)
+      .executeTakeFirst()
+  }
+
+  async getSetWithValues({
+    name,
+    limit,
+    cursor,
+  }: {
+    name: string
+    limit: number
+    cursor?: string
+  }): Promise<
+    | {
+        set: Selectable<SetDetail & { setSize: number }>
+        values: string[]
+        cursor?: string
+      }
+    | undefined
+  > {
+    const set = await this.getByNameWithSize(name)
+    if (!set) return undefined
+
+    const { ref } = this.db.db.dynamic
+    const qb = this.db.db
+      .selectFrom('set_value')
+      .selectAll()
+      .where('setId', '=', set.id)
+
+    const keyset = new TimeIdKeyset(ref(`createdAt`), ref('id'))
+    const paginatedBuilder = paginate(qb, {
+      limit,
+      cursor,
+      keyset,
+      direction: 'asc',
+    })
+
+    const result = await paginatedBuilder.execute()
+
+    return {
+      set,
+      values: result.map((v) => v.value),
+      cursor: keyset.packFromResult(result),
+    }
+  }
+  async upsert({
+    name,
+    description,
+  }: Pick<SetDetail, 'name' | 'description'>): Promise<void> {
+    await this.db.db
+      .insertInto('set_detail')
+      .values({
+        name,
+        description,
+        updatedAt: new Date(),
+      })
+      .onConflict((oc) => {
+        // if description is provided as a string, even an empty one, update it
+        // otherwise, just update the updatedAt timestamp
+        return oc.column('name').doUpdateSet(
+          typeof description === 'string'
+            ? {
+                description,
+                updatedAt: new Date(),
+              }
+            : { updatedAt: new Date() },
+        )
+      })
+      .execute()
+  }
+
+  async addValues(setId: number, values: string[]): Promise<void> {
+    await this.db.transaction(async (txn) => {
+      const now = new Date()
+      const query = txn.db
+        .insertInto('set_value')
+        .values(
+          values.map((value) => ({
+            setId,
+            value,
+            createdAt: now,
+          })),
+        )
+        .onConflict((oc) => oc.columns(['setId', 'value']).doNothing())
+
+      await query.execute()
+
+      // Update the set's updatedAt timestamp
+      await txn.db
+        .updateTable('set_detail')
+        .set({ updatedAt: now })
+        .where('id', '=', setId)
+        .execute()
+    })
+  }
+
+  async removeValues(setId: number, values: string[]): Promise<void> {
+    if (values.length < 1) {
+      return
+    }
+    await this.db.transaction(async (txn) => {
+      const query = txn.db
+        .deleteFrom('set_value')
+        .where('setId', '=', setId)
+        .where('value', 'in', values)
+
+      await query.execute()
+
+      // Update the set's updatedAt timestamp
+      await txn.db
+        .updateTable('set_detail')
+        .set({ updatedAt: new Date() })
+        .where('id', '=', setId)
+        .execute()
+    })
+  }
+
+  async removeSet(setId: number): Promise<void> {
+    await this.db.transaction(async (txn) => {
+      await txn.db.deleteFrom('set_value').where('setId', '=', setId).execute()
+      await txn.db.deleteFrom('set_detail').where('id', '=', setId).execute()
+    })
+  }
+
+  view(set: Selectable<SetDetail> & { setSize: number }): SetView {
+    return {
+      name: set.name,
+      description: set.description || undefined,
+      setSize: set.setSize,
+      createdAt: set.createdAt.toISOString(),
+      updatedAt: set.updatedAt.toISOString(),
+    }
+  }
+}

package/tests/__snapshots__/sets.test.ts.snap

@@ -0,0 +1,46 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ozone-sets querySets returns all sets when no parameters are provided 1`] = `
+Array [
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "description": "Another test set",
+    "name": "another-set",
+    "setSize": 0,
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+  },
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "description": "Test set 1",
+    "name": "test-set-1",
+    "setSize": 0,
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+  },
+  Object {
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "name": "test-set-2",
+    "setSize": 0,
+    "updatedAt": "1970-01-01T00:00:00.000Z",
+  },
+]
+`;
+
+exports[`ozone-sets upsertSet creates a new set 1`] = `
+Object {
+  "createdAt": "1970-01-01T00:00:00.000Z",
+  "description": "A new test set",
+  "name": "new-test-set",
+  "setSize": 0,
+  "updatedAt": "1970-01-01T00:00:00.000Z",
+}
+`;
+
+exports[`ozone-sets upsertSet updates an existing set 1`] = `
+Object {
+  "createdAt": "1970-01-01T00:00:00.000Z",
+  "description": "Updated description",
+  "name": "new-test-set",
+  "setSize": 0,
+  "updatedAt": "1970-01-01T00:00:00.000Z",
+}
+`;

package/tests/sets.test.ts

@@ -0,0 +1,246 @@
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import AtpAgent, {
+  ToolsOzoneSetDefs,
+  ToolsOzoneSetQuerySets,
+} from '@atproto/api'
+import { forSnapshot } from './_util'
+import { ids } from '../src/lexicon/lexicons'
+
+describe('ozone-sets', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+
+  const sampleSet1 = {
+    name: 'test-set-1',
+    description: 'Test set 1',
+  }
+
+  const sampleSet2 = {
+    name: 'test-set-2',
+  }
+
+  const sampleSet3 = {
+    name: 'another-set',
+    description: 'Another test set',
+  }
+
+  const upsertSet = async (set: ToolsOzoneSetDefs.Set) => {
+    const { data } = await agent.tools.ozone.set.upsertSet(set, {
+      encoding: 'application/json',
+      headers: await network.ozone.modHeaders(
+        ids.ToolsOzoneSetUpsertSet,
+        'admin',
+      ),
+    })
+
+    return data
+  }
+
+  const removeSet = async (name: string) => {
+    await agent.tools.ozone.set.deleteSet(
+      { name },
+      {
+        encoding: 'application/json',
+        headers: await network.ozone.modHeaders(
+          ids.ToolsOzoneSetDeleteSet,
+          'admin',
+        ),
+      },
+    )
+  }
+
+  const addValues = async (name: string, values: string[]) => {
+    await agent.tools.ozone.set.addValues(
+      { name, values },
+      {
+        encoding: 'application/json',
+        headers: await network.ozone.modHeaders(
+          ids.ToolsOzoneSetAddValues,
+          'admin',
+        ),
+      },
+    )
+  }
+
+  const getValues = async (name: string, limit?: number, cursor?: string) => {
+    const { data } = await agent.tools.ozone.set.getValues(
+      { name, limit, cursor },
+      {
+        headers: await network.ozone.modHeaders(
+          ids.ToolsOzoneSetGetValues,
+          'moderator',
+        ),
+      },
+    )
+    return data
+  }
+
+  const querySets = async (params: ToolsOzoneSetQuerySets.QueryParams) => {
+    const { data } = await agent.tools.ozone.set.querySets(params, {
+      headers: await network.ozone.modHeaders(
+        ids.ToolsOzoneSetQuerySets,
+        'moderator',
+      ),
+    })
+    return data
+  }
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_sets',
+    })
+    agent = network.ozone.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('querySets', () => {
+    beforeAll(async () => {
+      await Promise.all([
+        upsertSet(sampleSet1),
+        upsertSet(sampleSet2),
+        upsertSet(sampleSet3),
+      ])
+    })
+    afterAll(async () => {
+      await Promise.all([
+        removeSet(sampleSet1.name),
+        removeSet(sampleSet2.name),
+        removeSet(sampleSet3.name),
+      ])
+    })
+    it('returns all sets when no parameters are provided', async () => {
+      const result = await querySets({})
+      expect(result.sets.length).toBe(3)
+      expect(forSnapshot(result.sets)).toMatchSnapshot()
+    })
+
+    it('limits the number of returned sets', async () => {
+      const result = await querySets({ limit: 2 })
+      expect(result.sets.length).toBe(2)
+      expect(result.cursor).toBeDefined()
+    })
+
+    it('returns sets after the cursor', async () => {
+      const firstPage = await querySets({ limit: 2 })
+      const secondPage = await querySets({ cursor: firstPage.cursor })
+      expect(secondPage.sets.length).toBe(1)
+      expect(secondPage.sets[0].name).toBe('test-set-2')
+    })
+
+    it('filters sets by name prefix', async () => {
+      const result = await querySets({ namePrefix: 'test-' })
+      expect(result.sets.length).toBe(2)
+      expect(result.sets.map((s) => s.name)).toEqual([
+        'test-set-1',
+        'test-set-2',
+      ])
+    })
+
+    it('sorts sets by given column and direction', async () => {
+      const sortedByName = await querySets({ sortBy: 'name' })
+      expect(sortedByName.sets.map((s) => s.name)).toEqual([
+        'another-set',
+        'test-set-1',
+        'test-set-2',
+      ])
+      const reverseSortedByName = await querySets({
+        sortBy: 'name',
+        sortDirection: 'desc',
+      })
+      expect(reverseSortedByName.sets.map((s) => s.name)).toEqual([
+        'test-set-2',
+        'test-set-1',
+        'another-set',
+      ])
+    })
+  })
+
+  describe('upsertSet', () => {
+    afterAll(async () => {
+      await removeSet('new-test-set')
+    })
+    it('creates a new set', async () => {
+      const result = await upsertSet({
+        name: 'new-test-set',
+        description: 'A new test set',
+      })
+      expect(forSnapshot(result)).toMatchSnapshot()
+    })
+
+    it('updates an existing set', async () => {
+      const result = await upsertSet({
+        name: 'new-test-set',
+        description: 'Updated description',
+      })
+      expect(forSnapshot(result)).toMatchSnapshot()
+    })
+
+    it('allows setting empty description', async () => {
+      const result = await upsertSet({
+        name: 'new-test-set',
+        description: '',
+      })
+      expect(result.description).toBeUndefined()
+    })
+  })
+
+  describe('addValues', () => {
+    beforeAll(async () => {
+      await upsertSet(sampleSet1)
+      await upsertSet(sampleSet2)
+    })
+    afterAll(async () => {
+      await removeSet(sampleSet1.name)
+      await removeSet(sampleSet2.name)
+    })
+    it('adds new values to an existing set', async () => {
+      const newValues = ['value1', 'value2', 'value3']
+      await addValues(sampleSet1.name, newValues)
+
+      const result = await getValues(sampleSet1.name)
+      expect(result.values).toEqual(expect.arrayContaining(newValues))
+    })
+
+    it('does not duplicate existing values', async () => {
+      const initialValues = ['initial1', 'initial2']
+      await addValues(sampleSet2.name, initialValues)
+
+      const newValues = ['initial2', 'new1', 'new2']
+      await addValues(sampleSet2.name, newValues)
+
+      const result = await getValues(sampleSet2.name)
+      expect(result.values).toEqual(
+        expect.arrayContaining([...initialValues, 'new1', 'new2']),
+      )
+      expect(result.values.filter((v) => v === 'initial2').length).toBe(1)
+    })
+  })
+
+  describe('getValues', () => {
+    beforeAll(async () => {
+      await upsertSet(sampleSet1)
+    })
+    afterAll(async () => {
+      await removeSet(sampleSet1.name)
+    })
+    it('paginates values from a set', async () => {
+      const allValues = Array.from({ length: 9 }, (_, i) => `value${i}`)
+      await addValues(sampleSet1.name, allValues)
+
+      const firstPage = await getValues(sampleSet1.name, 3)
+      const secondPage = await getValues(sampleSet1.name, 3, firstPage.cursor)
+      const lastPage = await getValues(sampleSet1.name, 3, secondPage.cursor)
+
+      expect(firstPage.values).toEqual(allValues.slice(0, 3))
+      expect(secondPage.values).toEqual(allValues.slice(3, 6))
+      expect(lastPage.values).toEqual(allValues.slice(6, 9))
+    })
+  })
+})