# Filtering Subscriptions by Publication Name in QuickSlice

## Goal

Query subscriptions for a user (e.g., `zeu.dev`) and filter by the resolved publication's name (e.g., publications containing "banana").

## Limitation

**Direct filtering is not supported.** The `publicationResolved` field on `SiteStandardGraphSubscription` doesn't accept `where` arguments, so you cannot filter subscriptions based on attributes of the resolved publication in a single query.

This query shape is **not possible**:

```graphql
# ❌ Does not work
query {
  siteStandardGraphSubscription(
    where: {
      actorHandle: { eq: "zeu.dev" },
      publicationResolved: { name: { contains: "banana" } }  # Not supported
    }
  ) {
    edges {
      node {
        publicationResolved { ... }
      }
    }
  }
}
```

## Workaround: Reverse the Query Direction

Instead of starting from subscriptions, start from publications and traverse to subscriptions:

```graphql
query GetSubscribedPublicationsByName($did: String!, $nameFilter: String!) {
  siteStandardPublication(first: 50, where: { name: { contains: $nameFilter }}) {
    edges {
      node {
        uri
        name
        description
        siteStandardGraphSubscriptionViaPublication(
          first: 1,
          where: { did: { eq: $did }}
        ) {
          edges {
            node {
              uri
              actorHandle
            }
          }
        }
      }
    }
  }
}
```

Variables:
```json
{
  "did": "did:plc:gotnvwkr56ibs33l4hwgfoet",
  "nameFilter": "banana"
}
```

### Client-Side Filtering Required

This query returns all publications matching the name filter. To get only those the user is subscribed to, filter results where `siteStandardGraphSubscriptionViaPublication.edges` is non-empty:

```typescript
const subscribedPublications = result.siteStandardPublication.edges
  .filter(edge => edge.node.siteStandardGraphSubscriptionViaPublication.edges.length > 0)
  .map(edge => edge.node);
```

## Gotcha: Use `did` Instead of `actorHandle` on Nested Connections

When filtering nested connections (like `siteStandardGraphSubscriptionViaPublication`), filtering by `actorHandle` silently fails and returns empty results. Use `did` instead:

```graphql
# ❌ Does not work - returns empty
siteStandardGraphSubscriptionViaPublication(
  where: { actorHandle: { eq: "zeu.dev" }}
)

# ✅ Works correctly
siteStandardGraphSubscriptionViaPublication(
  where: { did: { eq: "did:plc:gotnvwkr56ibs33l4hwgfoet" }}
)
```

This is likely because `actorHandle` is a resolved/computed field rather than an indexed database column.

## Alternative: Client-Side Filtering

If you need the original query shape (subscriptions → publications), fetch all subscriptions with resolved publications and filter client-side:

```graphql
query GetAllSubscriptionsForUser {
  siteStandardGraphSubscription(
    first: 100,
    where: { actorHandle: { eq: "zeu.dev" }}
  ) {
    edges {
      node {
        uri
        publicationResolved {
          ... on SiteStandardPublication {
            uri
            name
            description
          }
        }
      }
    }
  }
}
```

Then filter in code:

```typescript
const filtered = result.siteStandardGraphSubscription.edges
  .filter(edge =>
    edge.node.publicationResolved?.name?.includes("banana")
  );
```

## Feature Request

To support the original query pattern natively, QuickSlice would need to add ref field filtering support:

```graphql
# Hypothetical future syntax
siteStandardGraphSubscription(
  where: {
    actorHandle: { eq: "zeu.dev" },
    publication: {
      ref: { name: { contains: "banana" } }  # Filter on resolved ref fields
    }
  }
)
```