Function memFilter

packages/infra/src/Store/Memory.ts:209–311

(f: FilterArgs<T, U>)

}

export function memFilter<T extends FieldValues, U extends keyof T = never>(f: FilterArgs<T, U>) {
  type M = U extends undefined ? T : Pick<T, U>
  return ((c: T[]): M[] => {
    const sel = f.select

    const selectPerRow = (r: T[]): M[] => {
      if (!sel) return r as M[]

      // Detect aggregate mode: any select item has `aggregate` key
      const hasAggregates = sel.some((s) => typeof s === "object" && s !== null && "aggregate" in s)
      if (hasAggregates) {
        // GROUP BY + aggregate
        const fieldItems = sel.filter((s): s is { key: string; path: string } =>
          typeof s === "object" && s !== null && "path" in s && !("aggregate" in s)
        )
        const aggregateItems = sel.filter((s): s is { key: string; aggregate: AggregateIrExpression } =>
          typeof s === "object" && s !== null && "aggregate" in s
        )
        const groups = new Map<string, T[]>()
        for (const row of r) {
          const key = fieldItems.map((fi) => JSON.stringify(get(row, fi.path))).join("\0")
          const existing = groups.get(key) ?? []
          existing.push(row)
          groups.set(key, existing)
        }
        return [...groups.values()].map((rows) => {
          const result: Record<string, unknown> = {}
          for (const fi of fieldItems) result[fi.key] = get(rows[0]!, fi.path)
          for (const ai of aggregateItems) result[ai.key] = computeAggregateValue(rows, ai.aggregate)
          return result as M
        })
      }

      return r.map((i) => {
        const [keys, entries] = pipe(
          sel,
          Array.partition((entry) => typeof entry === "string" ? Result.fail(String(entry)) : Result.succeed(entry))
        )
        const subKeys = entries.filter((entry): entry is { key: string; subKeys: readonly string[] } =>
          typeof entry === "object" && entry !== null && "subKeys" in entry
        )
        const computedKeys = entries.filter((entry): entry is {
          key: string
          computed: ComputedProjectionIrExpression
        } => typeof entry === "object" && entry !== null && "computed" in entry)
        const pathKeys = entries.filter((entry): entry is { key: string; path: string } =>
          typeof entry === "object" && entry !== null && "path" in entry && !("aggregate" in entry)
        )
        const n = Struct.pick(i, keys)
        subKeys.forEach((subKey) => {
          n[subKey.key] = i[subKey.key]!.map(Struct.pick(subKey.subKeys as never[]))
        })
        computedKeys.forEach((entry) => {
          ;(n as Record<string, unknown>)[entry.key] = computeProjectionValue(i, entry.computed)
        })
        pathKeys.forEach((entry) => {
          ;(n as Record<string, unknown>)[entry.key] = get(i, entry.path)
        })