Fix/circular reference rendering (#10)

* Add cyclic examples

* FIx the recursive cyclic bug

* Refactor code

Author: pranavpsawant

examples/bookstore/README.md

@@ -11,6 +11,9 @@ The BookStore service exercises every proto3 feature gRPC Studio supports:
 | Feature | Where |
 |---------|-------|
 | Deep nesting (3 levels) | `Book` → `Publisher` → `Address` → `Coordinates` |
+| Recursive (direct) | `Book.prequel` — a `Book` inside a `Book` |
+| Recursive (repeated) | `Book.sequels` — `repeated Book` |
+| Recursive (indirect) | `Book.lineage` → `BookLineage.predecessor` → `Book`, plus `BookLineage.branches` |
 | Enums | `Genre`, `Availability` |
 | Repeated scalar | `alternate_titles` |
 | Repeated message | `reviews`, `editions` |
@@ -60,16 +63,25 @@ The server starts with 3 pre-loaded books:
 
 | ID | Title | Genre | Availability | Highlights |
 |----|-------|-------|--------------|------------|
-| book-001 | Dune | Science | In stock | Full publisher, reviews, editions, map tags, struct metadata |
+| book-001 | Harry Potter and the Philosopher's Stone | Fantasy | In stock | Full publisher, reviews, editions, map tags, struct metadata, **recursive relatives** |
 | book-002 | The Hobbit | Fantasy | Preorder | Series info (oneOf), alternate titles, formats in metadata |
 | book-003 | Goodnight Moon | Children | In stock | Internal SKU (oneOf), no publisher, minimal records |
 
+book-001 carries all three cycle shapes: a `prequel` (Fantastic Beasts), two
+`sequels` (Chamber of Secrets, Goblet of Fire — Chamber of Secrets in turn has
+its own `sequels`, so the payload is three `Book` levels deep), and a `lineage`
+chain with recursive `branches`. The related volumes are reachable only through
+those fields; they are not separate `ListBooks` records.
+
 ## RPCs to Try
 
 - **ListBooks** — returns all books, supports `genre_filter` and `availability_filter`
-- **GetBook** — `{ "id": "book-001" }` to see Dune with all nested types
+- **GetBook** — `{ "id": "book-001" }` to see the Philosopher's Stone with all nested types
 - **CreateBook** — create a new book with any combination of fields
 - **SearchBooks** — text search with `query`, filter by `genres` array, `max_page_count`, `max_price_usd`
+- **GetBookSeries** — `{ "id": "book-001", "depth": 4 }` returns a `Book` whose
+  `prequel`, `sequels` and `lineage` nest to the requested depth. Use this to
+  stress a renderer against a cyclic schema; `depth` is capped at 10
 - **WatchBooks** — server stream that emits random catalog events every 2 seconds
 - **BulkCreateBooks** — send multiple books as a client stream
 - **CheckStock** — send `{ "book_id": "book-001", "warehouses": ["east", "west"] }` and get quantities back

examples/bookstore/proto/bookstore.proto

@@ -100,6 +100,26 @@ message Edition {
   bool signed_copy = 7;
 }
 
+// ---------------------------------------------------------------------------
+// Recursive / cyclic message types
+//
+// The schema graph below contains cycles: Book → Book (direct), Book →
+// repeated Book, and Book → BookLineage → Book (indirect). BookLineage is
+// also recursive through its own type. Any renderer that walks the descriptor
+// eagerly will recurse forever here, so these fields exercise cycle detection
+// in both request forms (CreateBook takes a Book) and response views (GetBook
+// returns a Book).
+// ---------------------------------------------------------------------------
+
+message BookLineage {
+  string catalog_id = 1;
+  // Indirect cycle: BookLineage → Book → BookLineage
+  Book predecessor = 2;
+  // Self-recursive: BookLineage → BookLineage
+  repeated BookLineage branches = 3;
+  int32 generation = 4;
+}
+
 // ---------------------------------------------------------------------------
 // Main Book message — exercises every proto3 feature
 // ---------------------------------------------------------------------------
@@ -147,6 +167,15 @@ message Book {
 
   // Any — extensible typed payload (e.g. for event-specific data)
   google.protobuf.Any extra_info = 22;
+
+  // Direct self-reference — Book contains a Book
+  Book prequel = 23;
+
+  // Repeated self-reference — Book contains many Books
+  repeated Book sequels = 24;
+
+  // Indirect self-reference — Book → BookLineage → Book
+  BookLineage lineage = 25;
 }
 
 // ---------------------------------------------------------------------------
@@ -210,6 +239,14 @@ message BulkCreateBooksResponse {
   repeated string errors = 3;
 }
 
+// Recursive messages
+
+message GetBookSeriesRequest {
+  string id = 1;
+  // How many prequel/sequel levels to populate (default 3, max 10).
+  int32 depth = 2;
+}
+
 message StockCheckRequest {
   string book_id = 1;
   repeated string warehouses = 2;
@@ -235,6 +272,9 @@ service BookStoreService {
   rpc ListBooks(ListBooksRequest) returns (ListBooksResponse);
   rpc SearchBooks(SearchBooksRequest) returns (ListBooksResponse);
 
+  // Recursive payloads — response nests Book inside Book several levels deep
+  rpc GetBookSeries(GetBookSeriesRequest) returns (Book);
+
   // Server streaming — live catalog event feed
   rpc WatchBooks(WatchBooksRequest) returns (stream BookEvent);
 

examples/bookstore/proto/bookstore_descriptor.bin

@@ -134,6 +134,77 @@ function SearchBooks(call, callback) {
   callback(null, { books: results, next_page_token: '', total_count: results.length });
 }
 
+// ---------------------------------------------------------------------------
+// Recursive payload — Book nested inside Book
+//
+// Builds a series chain `depth` levels deep using the self-referencing fields
+// (prequel / sequels / lineage). Useful for exercising renderers against
+// cyclic schemas: the descriptor cycle is infinite, but the payload is not.
+// ---------------------------------------------------------------------------
+
+const MAX_SERIES_DEPTH = 10;
+const DEFAULT_SERIES_DEPTH = 3;
+
+// Strip self-referencing fields so a seeded book can be used as a chain node
+// without dragging its own (already-populated) relatives along.
+function withoutRelatives(book) {
+  const { prequel: _prequel, sequels: _sequels, lineage: _lineage, ...rest } = book;
+  return rest;
+}
+
+function buildSeries(book, depth, generation) {
+  const node = withoutRelatives(book);
+  if (depth <= 0) return node;
+
+  const predecessor = buildSeries(book, depth - 1, generation + 1);
+
+  return {
+    ...node,
+    // Direct self-reference
+    prequel: {
+      ...predecessor,
+      id: `${book.id}-prequel${generation}`,
+      title: `${book.title}: Book ${generation}`,
+    },
+    // Repeated self-reference
+    sequels: [
+      {
+        ...buildSeries(book, depth - 1, generation + 1),
+        id: `${book.id}-sequel${generation}a`,
+        title: `${book.title}: Book ${generation + 1}`,
+      },
+      {
+        ...withoutRelatives(book),
+        id: `${book.id}-sequel${generation}b`,
+        title: `${book.title}: Companion Volume`,
+      },
+    ],
+    // Indirect self-reference — Book → BookLineage → Book
+    lineage: {
+      catalog_id: `cat-${book.id}-${generation}`,
+      generation,
+      predecessor,
+      branches: [
+        {
+          catalog_id: `cat-${book.id}-${generation}-a`,
+          generation: generation + 1,
+          branches: [],
+        },
+      ],
+    },
+  };
+}
+
+function GetBookSeries(call, callback) {
+  const book = store.get(call.request.id);
+  if (!book) return notFound(call, callback, call.request.id);
+
+  const requested = call.request.depth || DEFAULT_SERIES_DEPTH;
+  const depth = Math.min(Math.max(requested, 0), MAX_SERIES_DEPTH);
+
+  callback(null, buildSeries(book, depth, 1));
+}
+
 // ---------------------------------------------------------------------------
 // Server streaming — live catalog event feed
 // ---------------------------------------------------------------------------
@@ -258,6 +329,7 @@ module.exports = {
   DeleteBook,
   ListBooks,
   SearchBooks,
+  GetBookSeries,
   WatchBooks,
   BulkCreateBooks,
   CheckStock,