SQL Connect — SQL a Firebase-ben

type User @table {
  id: UUID! @default(expr: "uuidV4()")
  uid: String! @col(name: "firebase_uid") @unique
  displayName: String!
  email: String! @unique
  createdAt: Timestamp! @default(expr: "request.time")
}

type Post @table {
  id: UUID! @default(expr: "uuidV4()")
  title: String!
  content: String!
  author: User!                       # foreign key to User
  publishedAt: Timestamp
  tags: [String!]!                    # text[] PostgreSQL array
}

type Comment @table {
  id: UUID! @default(expr: "uuidV4()")
  text: String!
  post: Post!                         # M-1 relation
  author: User!
  createdAt: Timestamp! @default(expr: "request.time")
}

type Tag @table {
  id: UUID! @default(expr: "uuidV4()")
  name: String! @unique
}

# Junction table with composite key
type PostTag @table(key: ["post", "tag"]) {
  post: Post!
  tag: Tag!
  addedAt: Timestamp! @default(expr: "request.time")
}

query GetRecentPosts($limit: Int! = 20) @auth(level: PUBLIC) {
  posts(
    orderBy: [{ publishedAt: DESC }],
    where: { publishedAt: { ne: null } },
    limit: $limit
  ) {
    id
    title
    publishedAt
    author {                       # automatic join
      displayName
    }
    comments_count                 # auto-generated aggregate
  }
}

mutation CreatePost(
  $title: String!,
  $content: String!,
  $tags: [String!]!
) @auth(level: USER) {
  post_insert(data: {
    title: $title,
    content: $content,
    tags: $tags,
    author: { uid_expr: "auth.uid" }    # from the JWT
  })
}

query TopAuthorsByPostCount($limit: Int!) @auth(level: PUBLIC) {
  authors: _select(
    sql: """
      SELECT
        u.id, u.display_name,
        COUNT(p.id) AS post_count,
        RANK() OVER (ORDER BY COUNT(p.id) DESC) AS rank
      FROM users u
      LEFT JOIN posts p ON p.author = u.id
      GROUP BY u.id, u.display_name
      ORDER BY post_count DESC
      LIMIT $1
    """,
    params: [$limit]
  )
}

import { subscribeGetRecentPosts } from '@my-app/dataconnect';

// A traditional query: runs once, result comes back
const { data } = await getRecentPosts({ limit: 20 });

// A realtime query: subscribe, every change is pushed
const unsub = subscribeGetRecentPosts(
  { limit: 20 },
  ({ data }) => {
    setPosts(data.posts);          // React state update
  }
);

// Cleanup when the component unmounts
unsub();

# A user can only see their own orders
query MyOrders @auth(level: USER) {
  orders(where: { user: { uid: { eq_expr: "auth.uid" } } }) {
    id, total, createdAt
  }
}

# Only admin can delete a post (custom claim)
mutation DeletePost($id: UUID!)
  @auth(level: USER, expr: "auth.token.role == 'admin'") {
  post_delete(id: $id)
}

import {
  getRecentPosts,
  createPost,
  type GetRecentPostsResponse,
} from '@my-app/dataconnect';

// Typed query — auto-completion, type-checking
const { data, error } = await getRecentPosts({ limit: 10 });

// data.posts has exactly the type the query returns —
// no <any>, no "I hope it looks like this" assumption
data.posts.forEach(post => {
  console.log(post.title, post.author.displayName);
});

// Mutation — also typed
await createPost({
  title: 'New article',
  content: '...',
  tags: ['firebase', 'sql'],
});