Antigravity × Firebase Data Connect：GraphQL型安全APIをAIで最速構築する実践アーキテクチャ

# dataconnect/schema/schema.gql
 
type User @table {
  id: UUID! @col(name: "user_id") @default(expr: "uuidV4()")
  email: String! @col(dataType: "varchar(255)") @unique
  displayName: String! @col(name: "display_name", dataType: "varchar(100)")
  createdAt: Date! @col(name: "created_at") @default(expr: "request.time")
  posts: [Post!]! @hasMany(foreignKey: "author_id")
}
 
type Post @table {
  id: UUID! @col(name: "post_id") @default(expr: "uuidV4()")
  title: String! @col(dataType: "varchar(500)")
  content: String! @col(dataType: "text")
  published: Boolean! @default(value: false)
  authorId: UUID! @col(name: "author_id")
  author: User! @belongsTo(foreignKey: "author_id")
  tags: [Tag!]! @manyToMany(joinTable: "PostTag")
  createdAt: Date! @col(name: "created_at") @default(expr: "request.time")
  updatedAt: Date @col(name: "updated_at")
}
 
type Tag @table {
  id: UUID! @col(name: "tag_id") @default(expr: "uuidV4()")
  name: String! @col(dataType: "varchar(50)") @unique
  posts: [Post!]! @manyToMany(joinTable: "PostTag")
}

# dataconnect/connector/queries.gql
 
# 公開済み投稿の一覧（ページネーション付き）
query ListPublishedPosts($limit: Int, $offset: Int) @auth(level: PUBLIC) {
  posts(
    where: { published: { eq: true } }
    orderBy: [{ createdAt: DESC }]
    limit: $limit
    offset: $offset
  ) {
    id
    title
    createdAt
    author {
      id
      displayName
    }
    tags {
      name
    }
  }
}
 
# ユーザーの全投稿（認証必須）
query GetUserPosts($userId: UUID!) @auth(level: USER) {
  posts(
    where: {
      authorId: { eq: $userId }
      # 自分の投稿のみアクセス可能
      _and: [{ authorId: { eq_expr: "auth.uid" } }]
    }
    orderBy: [{ createdAt: DESC }]
  ) {
    id
    title
    published
    createdAt
    updatedAt
  }
}
 
# 投稿詳細（公開済みのみ、または自分の投稿）
query GetPostDetail($postId: UUID!) @auth(level: PUBLIC) {
  post(
    id: $postId
    where: {
      _or: [
        { published: { eq: true } }
        { authorId: { eq_expr: "auth.uid" } }
      ]
    }
  ) {
    id
    title
    content
    published
    createdAt
    updatedAt
    author {
      id
      displayName
    }
    tags {
      id
      name
    }
  }
}

# dataconnect/connector/mutations.gql
 
# 投稿の新規作成（認証必須）
mutation CreatePost($title: String!, $content: String!, $tagIds: [UUID!]) @auth(level: USER) {
  post_insert(data: {
    title: $title
    content: $content
    authorId_expr: "auth.uid"
    tags: { connect: $tagIds }
  }) {
    id
    title
    createdAt
  }
}
 
# 投稿の更新（オーナーのみ）
mutation UpdatePost($postId: UUID!, $title: String, $content: String, $published: Boolean) @auth(level: USER) {
  post_update(
    id: $postId
    data: {
      title: $title
      content: $content
      published: $published
      updatedAt_expr: "request.time"
    }
    where: { authorId: { eq_expr: "auth.uid" } }
  ) {
    id
    title
    published
    updatedAt
  }
}
 
# 投稿の削除（オーナーのみ）
mutation DeletePost($postId: UUID!) @auth(level: USER) {
  post_delete(
    id: $postId
    where: { authorId: { eq_expr: "auth.uid" } }
  )
}

// src/lib/dataconnect.ts
 
import {
  connectDataConnectEmulator,
  getDataConnect,
} from "firebase/data-connect";
import { connectorConfig } from "@firebasegen/my-app-connector";
 
// 開発環境ではエミュレーターに接続
const dc = getDataConnect(connectorConfig);
if (process.env.NODE_ENV === "development") {
  connectDataConnectEmulator(dc, "localhost", 9399);
}
 
export { dc };

// src/app/posts/page.tsx（Next.js App Router の例）
 
import {
  executeQuery,
  listPublishedPostsRef,
} from "@firebasegen/my-app-connector";
import { dc } from "@/lib/dataconnect";
 
async function getPosts(limit = 10, offset = 0) {
  try {
    const result = await executeQuery(listPublishedPostsRef(dc, { limit, offset }));
    return result.data.posts;
  } catch (error) {
    // Data Connect のエラーは FirebaseError 型
    if (error instanceof Error && error.message.includes("permission")) {
      console.error("アクセス権限エラー:", error.message);
      return [];
    }
    throw error;
  }
}
 
export default async function PostsPage() {
  const posts = await getPosts();
  return (
    <ul>
      {posts.map((post) => (
        <li key={post.id}>
          <a href={`/posts/${post.id}`}>{post.title}</a>
          <span>{post.author.displayName}</span>
        </li>
      ))}
    </ul>
  );
}

# ❌ 危険：ログイン済みなら誰でも他人の投稿を削除できる
mutation DeletePost($postId: UUID!) @auth(level: USER) {
  post_delete(id: $postId)
}
 
# ✅ 安全：自分の投稿しか削除できない
mutation DeletePost($postId: UUID!) @auth(level: USER) {
  post_delete(
    id: $postId
    where: { authorId: { eq_expr: "auth.uid" } }
  )
}

// src/lib/auth-dataconnect.ts
 
import { getAuth, onAuthStateChanged } from "firebase/auth";
import { getDataConnect, setInitialUserToken } from "firebase/data-connect";
import { connectorConfig } from "@firebasegen/my-app-connector";
 
const auth = getAuth();
const dc = getDataConnect(connectorConfig);
 
// Firebase Auth の状態変化を Data Connect に反映する
onAuthStateChanged(auth, async (user) => {
  if (user) {
    const token = await user.getIdToken();
    await setInitialUserToken(dc, token);
  } else {
    // ログアウト時はトークンをクリア
    await setInitialUserToken(dc, undefined);
  }
});

// src/app/actions/posts.ts
 
"use server";
 
import { revalidatePath } from "next/cache";
import { executeMutation, createPostRef } from "@firebasegen/my-app-connector";
import { dc } from "@/lib/dataconnect";
 
export async function createPost(title: string, content: string) {
  try {
    const result = await executeMutation(
      createPostRef(dc, { title, content })
    );
    // Next.js のキャッシュを無効化
    revalidatePath("/posts");
    return { success: true, post: result.data.post_insert };
  } catch (error) {
    console.error("投稿作成エラー:", error);
    return { success: false, error: "投稿の作成に失敗しました" };
  }
}

import { z } from "zod";
 
const uuidSchema = z.string().uuid("無効なIDフォーマットです");
 
export async function getPost(postId: string) {
  // バリデーション
  const validatedId = uuidSchema.parse(postId);
  
  try {
    const result = await executeQuery(
      getPostDetailRef(dc, { postId: validatedId })
    );
    return result.data.post;
  } catch (error) {
    if (error instanceof z.ZodError) {
      throw new Error("無効なリクエストです");
    }
    throw error;
  }
}

function formatJST(dateString: string): string {
  return new Intl.DateTimeFormat("ja-JP", {
    timeZone: "Asia/Tokyo",
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
    hour: "2-digit",
    minute: "2-digit",
  }).format(new Date(dateString));
}

# 本番環境へのデプロイ
firebase deploy --only dataconnect
 
# スキーママイグレーション（破壊的変更がある場合）
firebase dataconnect:sql:migrate --force
 
# デプロイ前のドライラン（推奨）
firebase dataconnect:sql:migrate --dry-run

// カスタム MCP サーバー：Data Connect をAIエージェントに公開する例
// mcp-server/src/tools/dataconnect.ts
 
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { executeQuery, listPublishedPostsRef } from "@firebasegen/my-app-connector";
import { dc } from "../lib/dataconnect.js";
 
export function registerDataConnectTools(server: Server) {
  server.setRequestHandler("tools/call", async (request) => {
    if (request.params.name === "get_recent_posts") {
      const { limit = 5 } = request.params.arguments as { limit?: number };
      
      try {
        const result = await executeQuery(
          listPublishedPostsRef(dc, { limit })
        );
        return {
          content: [{
            type: "text",
            text: JSON.stringify(result.data.posts, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: `エラー: ${error instanceof Error ? error.message : "不明なエラー"}`
          }],
          isError: true
        };
      }
    }
  });
}

# dataconnect/connector/queries.gql
# 高頻度エンドポイント：リレーションは浅く保つ
 
query ListPostsForFeed($limit: Int) @auth(level: PUBLIC) {
  posts(
    where: { published: { eq: true } }
    orderBy: [{ createdAt: DESC }]
    limit: $limit
  ) {
    id
    title
    createdAt
    # 1階層のリレーションは JOIN 1回で済む
    author {
      id
      displayName
    }
    # タグは中間テーブル経由でも配列を返すだけなので許容範囲
    tags {
      name
    }
    # 避けたい例: author { posts { ... } } / author { followers { ... } }
  }
}

# キーセットページネーション：最後に取得した投稿の位置から続きを読む
query ListPostsAfter(
  $cursorCreatedAt: Date!
  $cursorId: UUID!
  $limit: Int
) @auth(level: PUBLIC) {
  posts(
    where: {
      published: { eq: true }
      _or: [
        { createdAt: { lt: $cursorCreatedAt } }
        {
          createdAt: { eq: $cursorCreatedAt }
          id: { lt: $cursorId }
        }
      ]
    }
    orderBy: [{ createdAt: DESC }, { id: DESC }]
    limit: $limit
  ) {
    id
    title
    createdAt
  }
}

// src/app/actions/batch-import.ts
 
"use server";
 
import { executeMutation, postInsertManyRef } from "@firebasegen/my-app-connector";
import { dc } from "@/lib/dataconnect";
 
const MAX_BATCH = 500;
 
export async function importPosts(
  posts: Array<{ title: string; content: string }>
) {
  if (posts.length === 0) return { imported: 0 };
  if (posts.length > MAX_BATCH) {
    // 分割は呼び出し側の責務にして、境界を越えたら早期に失敗させる
    throw new Error(`バッチサイズが上限(${MAX_BATCH}件)を超えています`);
  }
 
  try {
    const result = await executeMutation(
      postInsertManyRef(dc, {
        data: posts.map((p) => ({
          title: p.title,
          content: p.content,
          // authorId_expr はサーバー側で auth.uid に解決される
          authorId_expr: "auth.uid",
        })),
      })
    );
    return { imported: result.data.post_insertMany.length };
  } catch (error) {
    console.error("バッチインポート失敗:", error);
    throw new Error("インポートに失敗しました");
  }
}

// src/lib/dataconnect-analytics.ts
 
import { getDataConnect } from "firebase/data-connect";
import { replicaConnectorConfig } from "@firebasegen/my-app-connector-analytics";
 
// 集計・レポート専用。書き込みには使わない
export const dcAnalytics = getDataConnect(replicaConnectorConfig);

// src/__tests__/posts.test.ts
 
import { describe, it, expect, vi, beforeEach } from "vitest";
import { getPosts } from "@/app/posts/actions";
 
// 生成された SDK をモックする
vi.mock("@firebasegen/my-app-connector", () => ({
  executeQuery: vi.fn(),
  listPublishedPostsRef: vi.fn(),
}));
 
import { executeQuery } from "@firebasegen/my-app-connector";
 
describe("getPosts", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });
 
  it("クエリ成功時に投稿を返す", async () => {
    vi.mocked(executeQuery).mockResolvedValue({
      data: {
        posts: [
          {
            id: "550e8400-e29b-41d4-a716-446655440000",
            title: "テスト投稿",
            createdAt: "2026-04-15T05:30:00Z",
            author: { id: "user-123", displayName: "テストユーザー" },
            tags: [{ name: "firebase" }],
          },
        ],
      },
    } as never);
 
    const result = await getPosts(5, 0);
    expect(result).toHaveLength(1);
    expect(result[0].title).toBe("テスト投稿");
  });
 
  it("権限エラー時は空配列を返す", async () => {
    vi.mocked(executeQuery).mockRejectedValue(new Error("permission denied"));
    expect(await getPosts(5, 0)).toEqual([]);
  });
 
  it("権限エラー以外はそのまま投げ直す", async () => {
    vi.mocked(executeQuery).mockRejectedValue(new Error("network timeout"));
    await expect(getPosts(5, 0)).rejects.toThrow("network timeout");
  });
});

// vitest.setup.ts
 
import { initializeApp } from "firebase/app";
import {
  connectDataConnectEmulator,
  getDataConnect,
} from "firebase/data-connect";
import { connectorConfig } from "@firebasegen/my-app-connector";
 
const app = initializeApp({ projectId: "demo-test-project" });
 
const dc = getDataConnect(app, connectorConfig);
connectDataConnectEmulator(dc, "localhost", 9399);
 
export { dc };

// src/lib/dataconnect-instrumented.ts
 
import {
  executeQuery as sdkExecuteQuery,
  executeMutation as sdkExecuteMutation,
} from "firebase/data-connect";
 
const SLOW_QUERY_MS = 1000;
const SLOW_MUTATION_MS = 2000;
 
type QueryRef = Parameters<typeof sdkExecuteQuery>[0];
type MutationRef = Parameters<typeof sdkExecuteMutation>[0];
 
function refName(ref: unknown): string {
  return (ref as { name?: string })?.name ?? "unknown-operation";
}
 
export async function executeQuery(ref: QueryRef) {
  const start = Date.now();
  const name = refName(ref);
 
  try {
    const result = await sdkExecuteQuery(ref);
    const duration = Date.now() - start;
    if (duration > SLOW_QUERY_MS) {
      console.warn(`[DataConnect] slow query "${name}": ${duration}ms`);
    }
    return result;
  } catch (error) {
    console.error(
      `[DataConnect] query "${name}" failed after ${Date.now() - start}ms:`,
      error
    );
    throw error;
  }
}
 
export async function executeMutation(ref: MutationRef) {
  const start = Date.now();
  const name = refName(ref);
 
  try {
    const result = await sdkExecuteMutation(ref);
    const duration = Date.now() - start;
    if (duration > SLOW_MUTATION_MS) {
      console.warn(`[DataConnect] slow mutation "${name}": ${duration}ms`);
    }
    return result;
  } catch (error) {
    console.error(`[DataConnect] mutation "${name}" failed:`, error);
    throw error;
  }
}