@atproto/ozone 0.1.125 → 0.1.127

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

@@ -0,0 +1,76 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.safelink.defs'
+
+/** An event for URL safety decisions */
+export interface Event {
+  $type?: 'tools.ozone.safelink.defs#event'
+  /** Auto-incrementing row ID */
+  id: number
+  eventType: EventType
+  /** The URL that this rule applies to */
+  url: string
+  pattern: PatternType
+  action: ActionType
+  reason: ReasonType
+  /** DID of the user who created this rule */
+  createdBy: string
+  createdAt: string
+  /** Optional comment about the decision */
+  comment?: string
+}
+
+const hashEvent = 'event'
+
+export function isEvent<V>(v: V) {
+  return is$typed(v, id, hashEvent)
+}
+
+export function validateEvent<V>(v: V) {
+  return validate<Event & V>(v, id, hashEvent)
+}
+
+export type EventType = 'addRule' | 'updateRule' | 'removeRule' | (string & {})
+export type PatternType = 'domain' | 'url' | (string & {})
+export type ActionType = 'block' | 'warn' | 'whitelist' | (string & {})
+export type ReasonType = 'csam' | 'spam' | 'phishing' | 'none' | (string & {})
+
+/** Input for creating a URL safety rule */
+export interface UrlRule {
+  $type?: 'tools.ozone.safelink.defs#urlRule'
+  /** The URL or domain to apply the rule to */
+  url: string
+  pattern: PatternType
+  action: ActionType
+  reason: ReasonType
+  /** Optional comment about the decision */
+  comment?: string
+  /** DID of the user added the rule. */
+  createdBy: string
+  /** Timestamp when the rule was created */
+  createdAt: string
+  /** Timestamp when the rule was last updated */
+  updatedAt: string
+}
+
+const hashUrlRule = 'urlRule'
+
+export function isUrlRule<V>(v: V) {
+  return is$typed(v, id, hashUrlRule)
+}
+
+export function validateUrlRule<V>(v: V) {
+  return validate<UrlRule & V>(v, id, hashUrlRule)
+}

package/src/lexicon/types/tools/ozone/safelink/queryEvents.ts

@@ -0,0 +1,68 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as ToolsOzoneSafelinkDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.safelink.queryEvents'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** Cursor for pagination */
+  cursor?: string
+  /** Maximum number of results to return */
+  limit: number
+  /** Filter by specific URLs or domains */
+  urls?: string[]
+  /** Filter by pattern type */
+  patternType?: string
+  /** Sort direction */
+  sortDirection: 'asc' | 'desc' | (string & {})
+}
+
+export interface OutputSchema {
+  /** Next cursor for pagination. Only present if there are more results. */
+  cursor?: string
+  events: ToolsOzoneSafelinkDefs.Event[]
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/safelink/queryRules.ts

@@ -0,0 +1,74 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as ToolsOzoneSafelinkDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.safelink.queryRules'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** Cursor for pagination */
+  cursor?: string
+  /** Maximum number of results to return */
+  limit: number
+  /** Filter by specific URLs or domains */
+  urls?: string[]
+  /** Filter by pattern type */
+  patternType?: string
+  /** Filter by action types */
+  actions?: string[]
+  /** Filter by reason type */
+  reason?: string
+  /** Filter by rule creator */
+  createdBy?: string
+  /** Sort direction */
+  sortDirection: 'asc' | 'desc' | (string & {})
+}
+
+export interface OutputSchema {
+  /** Next cursor for pagination. Only present if there are more results. */
+  cursor?: string
+  rules: ToolsOzoneSafelinkDefs.UrlRule[]
+}
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/safelink/removeRule.ts

@@ -0,0 +1,62 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as ToolsOzoneSafelinkDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.safelink.removeRule'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The URL or domain to remove the rule for */
+  url: string
+  pattern: ToolsOzoneSafelinkDefs.PatternType
+  /** Optional comment about why the rule is being removed */
+  comment?: string
+  /** Optional DID of the user. Only respected when using admin auth. */
+  createdBy?: string
+}
+
+export type OutputSchema = ToolsOzoneSafelinkDefs.Event
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'RuleNotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/lexicon/types/tools/ozone/safelink/updateRule.ts

@@ -0,0 +1,64 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import express from 'express'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import type * as ToolsOzoneSafelinkDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'tools.ozone.safelink.updateRule'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The URL or domain to update the rule for */
+  url: string
+  pattern: ToolsOzoneSafelinkDefs.PatternType
+  action: ToolsOzoneSafelinkDefs.ActionType
+  reason: ToolsOzoneSafelinkDefs.ReasonType
+  /** Optional comment about the update */
+  comment?: string
+  /** Optional DID to credit as the creator. Only respected for admin_token authentication. */
+  createdBy?: string
+}
+
+export type OutputSchema = ToolsOzoneSafelinkDefs.Event
+
+export interface HandlerInput {
+  encoding: 'application/json'
+  body: InputSchema
+}
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'RuleNotFound'
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA
+  params: QueryParams
+  input: HandlerInput
+  req: express.Request
+  res: express.Response
+  resetRouteRateLimits: () => Promise<void>
+}
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput

package/src/safelink/service.ts

@@ -0,0 +1,304 @@
+import { Selectable } from 'kysely'
+import { ToolsOzoneSafelinkDefs } from '@atproto/api'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import {
+  SafelinkActionType,
+  SafelinkPatternType,
+  SafelinkReasonType,
+} from '../api/util'
+import { Database } from '../db'
+import { SafelinkEvent, SafelinkRule } from '../db/schema/safelink'
+
+export type SafelinkRuleServiceCreator = (db: Database) => SafelinkRuleService
+
+export class SafelinkRuleService {
+  constructor(public db: Database) {}
+
+  static creator() {
+    return (db: Database) => new SafelinkRuleService(db)
+  }
+
+  formatEvent(event: Selectable<SafelinkEvent>): ToolsOzoneSafelinkDefs.Event {
+    return {
+      id: event.id,
+      eventType: event.eventType,
+      url: event.url,
+      pattern: event.pattern,
+      action: event.action,
+      reason: event.reason,
+      createdBy: event.createdBy,
+      createdAt: new Date(event.createdAt).toISOString(),
+      comment: event.comment || undefined,
+    }
+  }
+
+  async addRule({
+    url,
+    pattern,
+    action,
+    reason,
+    createdBy,
+    comment,
+  }: {
+    url: string
+    pattern: SafelinkPatternType
+    action: SafelinkActionType
+    reason: SafelinkReasonType
+    createdBy: string
+    comment?: string
+  }): Promise<Selectable<SafelinkEvent>> {
+    const existingRule = await this.getActiveRule(url, pattern)
+    if (existingRule) {
+      throw new InvalidRequestError(
+        'A rule for this URL/domain already exists',
+        'RuleAlreadyExists',
+      )
+    }
+
+    const now = new Date().toISOString()
+    const rule = {
+      url,
+      pattern,
+      action,
+      reason,
+      createdBy,
+      comment: comment || null,
+      createdAt: now,
+    }
+
+    return await this.db.transaction(async (txn) => {
+      const event = await txn.db
+        .insertInto('safelink_event')
+        .values({
+          eventType: 'addRule',
+          ...rule,
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow()
+
+      await txn.db
+        .insertInto('safelink_rule')
+        .values({ ...rule, updatedAt: now })
+        .execute()
+
+      return event
+    })
+  }
+
+  async updateRule({
+    url,
+    pattern,
+    action,
+    reason,
+    createdBy,
+    comment,
+  }: {
+    url: string
+    pattern: SafelinkPatternType
+    action: SafelinkActionType
+    reason: SafelinkReasonType
+    createdBy: string
+    comment?: string
+  }): Promise<Selectable<SafelinkEvent>> {
+    const existingRule = await this.getActiveRule(url, pattern)
+    if (!existingRule) {
+      throw new InvalidRequestError(
+        'No active rule found for this URL/domain',
+        'RuleNotFound',
+      )
+    }
+
+    const now = new Date().toISOString()
+    const rule = {
+      action,
+      reason,
+      createdBy,
+      comment: comment || null,
+    }
+
+    return await this.db.transaction(async (txn) => {
+      const event = await txn.db
+        .insertInto('safelink_event')
+        .values({
+          createdAt: now,
+          url: existingRule.url,
+          pattern: existingRule.pattern,
+          eventType: 'updateRule',
+          ...rule,
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow()
+
+      await txn.db
+        .updateTable('safelink_rule')
+        .set(rule)
+        .where('url', '=', existingRule.url)
+        .where('pattern', '=', existingRule.pattern)
+        .execute()
+
+      return event
+    })
+  }
+
+  async removeRule({
+    url,
+    pattern,
+    createdBy,
+    comment,
+  }: {
+    url: string
+    pattern: SafelinkPatternType
+    createdBy: string
+    comment?: string
+  }): Promise<Selectable<SafelinkEvent>> {
+    const existingRule = await this.getActiveRule(url, pattern)
+    if (!existingRule) {
+      throw new InvalidRequestError(
+        'No active rule found for this URL/domain',
+        'RuleNotFound',
+      )
+    }
+
+    return await this.db.transaction(async (txn) => {
+      const event = await txn.db
+        .insertInto('safelink_event')
+        .values({
+          eventType: 'removeRule',
+          url,
+          pattern,
+          action: existingRule.action,
+          reason: existingRule.reason,
+          createdBy,
+          comment: comment || null,
+          createdAt: new Date().toISOString(),
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow()
+
+      await txn.db
+        .deleteFrom('safelink_rule')
+        .where('url', '=', url)
+        .where('pattern', '=', pattern)
+        .execute()
+
+      return event
+    })
+  }
+
+  async getActiveRule(url: string, pattern: SafelinkPatternType) {
+    const rule = await this.db.db
+      .selectFrom('safelink_rule')
+      .selectAll()
+      .where('url', '=', url)
+      .where('pattern', '=', pattern)
+      .executeTakeFirst()
+
+    if (!rule) {
+      return null
+    }
+
+    return rule
+  }
+
+  async getActiveRules({
+    cursor,
+    limit = 50,
+    urls,
+    patternType,
+    actions,
+    reason,
+    createdBy,
+    direction = 'desc',
+  }: {
+    cursor?: string
+    limit?: number
+    urls?: string[]
+    patternType?: SafelinkPatternType
+    actions?: SafelinkActionType[]
+    reason?: SafelinkReasonType
+    createdBy?: string
+    direction?: 'asc' | 'desc'
+  } = {}): Promise<{
+    rules: Selectable<SafelinkRule>[]
+    cursor?: string
+  }> {
+    let query = this.db.db.selectFrom('safelink_rule').selectAll()
+
+    if (urls && urls.length > 0) {
+      query = query.where('url', 'in', urls)
+    }
+
+    if (patternType) {
+      query = query.where('pattern', '=', patternType)
+    }
+
+    if (actions && actions.length > 0) {
+      query = query.where('action', 'in', actions)
+    }
+
+    if (reason) {
+      query = query.where('reason', '=', reason)
+    }
+
+    if (createdBy) {
+      query = query.where('createdBy', '=', createdBy)
+    }
+
+    if (cursor) {
+      query = query.where(
+        'id',
+        direction === 'asc' ? '>' : '<',
+        parseInt(cursor, 10),
+      )
+    }
+
+    const rules = await query.orderBy('id', direction).limit(limit).execute()
+
+    return {
+      rules,
+      cursor: rules.at(-1)?.id?.toString(),
+    }
+  }
+
+  async queryEvents({
+    cursor,
+    limit = 50,
+    urls,
+    patternType,
+    direction = 'desc',
+  }: {
+    cursor?: string
+    limit?: number
+    urls?: string[]
+    patternType?: SafelinkPatternType
+    direction?: 'asc' | 'desc'
+  } = {}): Promise<{
+    events: Selectable<SafelinkEvent>[]
+    cursor?: string
+  }> {
+    let query = this.db.db.selectFrom('safelink_event').selectAll()
+
+    if (urls && urls.length > 0) {
+      query = query.where('url', 'in', urls)
+    }
+
+    if (patternType) {
+      query = query.where('pattern', '=', patternType)
+    }
+
+    if (cursor) {
+      query = query.where(
+        'id',
+        direction === 'asc' ? '>' : '<',
+        parseInt(cursor, 10),
+      )
+    }
+
+    const events = await query.orderBy('id', direction).limit(limit).execute()
+
+    return {
+      events,
+      cursor: events.at(-1)?.id?.toString(),
+    }
+  }
+}