@atproto/ozone 0.2.9 → 0.2.11

package/src/set/service.ts

@@ -1,230 +0,0 @@
-import { NotNull, Selectable } from 'kysely'
-import { Database } from '../db/index.js'
-import { TimeIdKeyset, paginate } from '../db/pagination.js'
-import { SetDetail } from '../db/schema/ozone_set.js'
-import { SetView } from '../lexicon/types/tools/ozone/set/defs.js'
-
-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'),
-      ])
-      .$narrowType<{ setSize: NotNull }>()
-  }
-
-  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/src/setting/constants.ts

@@ -1,3 +0,0 @@
-export const ProtectedTagSettingKey = 'tools.ozone.setting.protectedTags'
-export const PolicyListSettingKey = 'tools.ozone.setting.policyList'
-export const SeverityLevelSettingKey = 'tools.ozone.setting.severityLevels'

package/src/setting/service.ts

@@ -1,148 +0,0 @@
-import assert from 'node:assert'
-import { Selectable } from 'kysely'
-import { InvalidRequestError } from '@atproto/xrpc-server'
-import { Database } from '../db/index.js'
-import { Member } from '../db/schema/member.js'
-import { Setting, SettingScope } from '../db/schema/setting.js'
-import { Option } from '../lexicon/types/tools/ozone/setting/defs.js'
-
-export type SettingServiceCreator = (db: Database) => SettingService
-
-export class SettingService {
-  constructor(public db: Database) {}
-
-  static creator() {
-    return (db: Database) => new SettingService(db)
-  }
-
-  async query({
-    limit = 100,
-    scope,
-    did,
-    cursor,
-    prefix,
-    keys,
-  }: {
-    limit: number
-    scope?: 'personal' | 'instance'
-    did?: string
-    cursor?: string
-    prefix?: string
-    keys?: string[]
-  }): Promise<{
-    options: Selectable<Setting>[]
-    cursor?: string
-  }> {
-    let builder = this.db.db.selectFrom('setting').selectAll()
-
-    if (prefix) {
-      builder = builder.where('key', 'like', `${prefix}%`)
-    } else if (keys?.length) {
-      builder = builder.where('key', 'in', keys)
-    }
-
-    if (scope) {
-      builder = builder.where('scope', '=', scope)
-    }
-
-    if (did) {
-      builder = builder.where('did', '=', did)
-    }
-
-    if (cursor) {
-      const cursorId = parseInt(cursor, 10)
-      if (isNaN(cursorId)) {
-        throw new InvalidRequestError('invalid cursor')
-      }
-      builder = builder.where('id', '<', cursorId)
-    }
-
-    const options = await builder.orderBy('id', 'desc').limit(limit).execute()
-
-    return {
-      options,
-      cursor: options[options.length - 1]?.id.toString(),
-    }
-  }
-
-  async upsert(
-    option: Omit<Setting, 'id' | 'createdAt' | 'updatedAt'> & {
-      createdAt: Date
-      updatedAt: Date
-    },
-  ): Promise<void> {
-    await this.db.db
-      .insertInto('setting')
-      .values(option)
-      .onConflict((oc) => {
-        return oc.columns(['key', 'scope', 'did']).doUpdateSet({
-          value: option.value,
-          updatedAt: option.updatedAt,
-          description: option.description,
-          managerRole: option.managerRole,
-          lastUpdatedBy: option.lastUpdatedBy,
-        })
-      })
-      .execute()
-  }
-
-  async removeOptions(
-    keys: string[],
-    filters: {
-      did?: string
-      scope: SettingScope
-      managerRole: Member['role'][]
-    },
-  ): Promise<void> {
-    if (!keys.length) return
-
-    if (filters.scope === 'personal') {
-      assert(filters.did, 'did is required for personal scope')
-    }
-
-    let qb = this.db.db
-      .deleteFrom('setting')
-      .where('key', 'in', keys)
-      .where('scope', '=', filters.scope)
-
-    if (filters.managerRole.length) {
-      qb = qb.where('managerRole', 'in', filters.managerRole)
-    } else {
-      qb = qb.where('managerRole', 'is', null)
-    }
-
-    if (filters.did) {
-      qb = qb.where('did', '=', filters.did)
-    }
-
-    await qb.execute()
-  }
-
-  view(setting: Selectable<Setting>): Option {
-    const {
-      key,
-      value,
-      did,
-      description,
-      createdAt,
-      createdBy,
-      updatedAt,
-      lastUpdatedBy,
-      managerRole,
-      scope,
-    } = setting
-
-    return {
-      key,
-      value,
-      did,
-      scope,
-      createdBy,
-      lastUpdatedBy,
-      managerRole: managerRole || undefined,
-      description: description || undefined,
-      createdAt: createdAt.toISOString(),
-      updatedAt: updatedAt.toISOString(),
-    }
-  }
-}

package/src/setting/types.ts

@@ -1,3 +0,0 @@
-export type ProtectedTagSetting = {
-  [key: string]: { roles?: string[]; moderators?: string[] }
-}