ditto/src/filter.ts

import { Conf } from '@/config.ts';
import { type Event, type Filter, matchFilters, stringifyStable, z } from '@/deps.ts';
import { isReplaceableKind } from '@/kinds.ts';
import { nostrIdSchema } from '@/schemas/nostr.ts';
import { type DittoEvent } from '@/storages/types.ts';

/** Additional properties that may be added by Ditto to events. */
type Relation = 'author' | 'author_stats' | 'event_stats';

/** Custom filter interface that extends Nostr filters with extra options for Ditto. */
interface DittoFilter<K extends number = number> extends Filter<K> {
  /** Whether the event was authored by a local user. */
  local?: boolean;
  /** Additional fields to add to the returned event. */
  relations?: Relation[];
}

/** Microfilter to get one specific event by ID. */
type IdMicrofilter = { ids: [Event['id']] };
/** Microfilter to get an author. */
type AuthorMicrofilter = { kinds: [0]; authors: [Event['pubkey']] };
/** Filter to get one specific event. */
type MicroFilter = IdMicrofilter | AuthorMicrofilter;

function matchDittoFilter(filter: DittoFilter, event: DittoEvent): boolean {
  if (filter.local && !(event.user || event.pubkey === Conf.pubkey)) {
    return false;
  }

  return matchFilters([filter], event);
}

/**
 * Similar to nostr-tools `matchFilters`, but supports Ditto's custom keys.
 * Database calls are needed to look up the extra data, so it's passed in as an argument.
 */
function matchDittoFilters(filters: DittoFilter[], event: DittoEvent): boolean {
  for (const filter of filters) {
    if (matchDittoFilter(filter, event)) {
      return true;
    }
  }

  return false;
}

/** Get deterministic ID for a microfilter. */
function getFilterId(filter: MicroFilter): string {
  if ('ids' in filter) {
    return stringifyStable({ ids: [filter.ids[0]] });
  } else {
    return stringifyStable({
      kinds: [filter.kinds[0]],
      authors: [filter.authors[0]],
    });
  }
}

/** Get a microfilter from a Nostr event. */
function eventToMicroFilter(event: Event): MicroFilter {
  const [microfilter] = getMicroFilters(event);
  return microfilter;
}

/** Get all the microfilters for an event, in order of priority. */
function getMicroFilters(event: Event): MicroFilter[] {
  const microfilters: MicroFilter[] = [];
  if (event.kind === 0) {
    microfilters.push({ kinds: [0], authors: [event.pubkey] });
  }
  microfilters.push({ ids: [event.id] });
  return microfilters;
}

/** Microfilter schema. */
const microFilterSchema = z.union([
  z.object({ ids: z.tuple([nostrIdSchema]) }).strict(),
  z.object({ kinds: z.tuple([z.literal(0)]), authors: z.tuple([nostrIdSchema]) }).strict(),
]);

/** Checks whether the filter is a microfilter. */
function isMicrofilter(filter: Filter): filter is MicroFilter {
  return microFilterSchema.safeParse(filter).success;
}

/** Calculate the intrinsic limit of a filter. */
function getFilterLimit(filter: Filter): number {
  if (filter.ids && !filter.ids.length) return 0;
  if (filter.kinds && !filter.kinds.length) return 0;
  if (filter.authors && !filter.authors.length) return 0;

  return Math.min(
    Math.max(0, filter.limit ?? Infinity),
    filter.ids?.length ?? Infinity,
    filter.authors?.length &&
      filter.kinds?.every((kind) => isReplaceableKind(kind))
      ? filter.authors.length * filter.kinds.length
      : Infinity,
  );
}

/** Returns true if the filter could potentially return any stored events at all. */
function canFilter(filter: Filter): boolean {
  return getFilterLimit(filter) > 0;
}

/** Normalize the `limit` of each filter, and remove filters that can't produce any events. */
function normalizeFilters<F extends Filter>(filters: F[]): F[] {
  return filters.reduce<F[]>((acc, filter) => {
    const limit = getFilterLimit(filter);
    if (limit > 0) {
      acc.push(limit === Infinity ? filter : { ...filter, limit });
    }
    return acc;
  }, []);
}

export {
  type AuthorMicrofilter,
  canFilter,
  type DittoFilter,
  eventToMicroFilter,
  getFilterId,
  getFilterLimit,
  getMicroFilters,
  type IdMicrofilter,
  isMicrofilter,
  matchDittoFilters,
  type MicroFilter,
  normalizeFilters,
  type Relation,
};