@microsoft/rayfin-guide 1.36.0-alpha.1756 → 1.36.0-alpha.1917

package/assets/docs/cli/secrets.md

@@ -4,7 +4,7 @@ sidebar_position: 50
 
 # Managing Secrets
 
-Secrets are encrypted values — API keys, connection strings, tokens — that your app needs at runtime but must never ship in client code. They are stored securely on your deployed Rayfin item and read on the server by [functions](./functions/index.md) via `ctx.getSecret(name)`.
+Secrets are encrypted values — API keys, connection strings, tokens — that your app needs at runtime but must never ship in client code. They are stored securely on your deployed Rayfin item and read on the server by [functions](./functions/index.md) via `ctx.Secrets`.
 
 Manage secrets with the `npx rayfin secret` command group:
 
@@ -105,18 +105,28 @@ Deleting a secret that does not exist reports a not-found error — run `npx ray
 
 ## Reading secrets from functions
 
-Server-side functions read secrets at runtime with `ctx.getSecret(name)`, which resolves against the deployed item's secret bag and falls back to `process.env`. Set a secret with `npx rayfin secret set <name>`, then read it by the same name inside your handler:
+Server-side functions read secrets at runtime as typed properties on `ctx.Secrets`, which resolve against the deployed item's secret bag and fall back to `process.env`. Set a secret with `npx rayfin secret set <name>`, then read it by the same name inside your handler:
 
 ```ts
-udf.func("summarize", async (ctx, input: { text: string }) => {
-  const apiKey = ctx.getSecret("OPENAI_KEY");
-  // ... call the API with apiKey
-});
+import { type RayfinContext } from "@microsoft/fabric-user-data-functions";
+
+udf.func(
+  "summarize",
+  async (ctx: RayfinContext<AppSchema>, input: { text: string }) => {
+    const apiKey = ctx.Secrets.OPENAI_KEY;
+    // ... call the API with apiKey
+  },
+  [],
+);
 ```
 
+The `RayfinContext<AppSchema>` annotation is what makes this type-safe. An unannotated `ctx` is contextually `any`, so `ctx.Secrets.OPENAI_KEY` compiles whether or not the secret is declared — and the annotation is also how typegen recognises the parameter as the injected context rather than a request-body argument.
+
+Setting the secret is what types it: the CLI regenerates `rayfin/functions/src/secrets.generated.ts`, so `ctx.Secrets.OPENAI_KEY` is a `string` and an undeclared name is a compile error. See [Secrets](../functions/secrets.md) for the full model.
+
 ## Using secrets in local development
 
-When you run functions locally with [`npx rayfin dev functions apply`](./functions/dev-apply.md), there is no deployed secret bag, so `ctx.getSecret(name)` falls back to `process.env`. To make a secret available locally, add it under `Values` in `rayfin/functions/local.settings.json` — the Azure Functions host loads those entries into `process.env`:
+When you run functions locally with [`npx rayfin dev functions apply`](./functions/dev-apply.md), there is no deployed secret bag, so `ctx.Secrets.<NAME>` falls back to `process.env`. To make a secret available locally, add it under `Values` in `rayfin/functions/local.settings.json` — the Azure Functions host loads those entries into `process.env`:
 
 ```json
 {
@@ -166,6 +176,6 @@ If `secret delete` reports the secret was not found:
 
 ## See also
 
-- [Functions](./functions/index.md) — read secrets from server-side functions with `ctx.getSecret`.
+- [Functions](./functions/index.md) — read secrets from server-side functions with `ctx.Secrets`.
 - [CLI quickstart](./quickstart.md)
 - [Environment configuration](./env-interpolation.md)

package/assets/docs/functions/connections/add-ado.md

@@ -4,10 +4,14 @@ sidebar_position: 5
 
 # Add Azure DevOps
 
-Call the [Azure DevOps REST API](https://learn.microsoft.com/en-us/rest/api/azure/devops/) from a function **as the signed-in user**, using `AudienceType.ADO`.
+Call the [Azure DevOps REST API](https://learn.microsoft.com/en-us/rest/api/azure/devops/) from a deployed function using `AudienceType.ADO`.
+
+Grant the [application identity](../index.md#application-authentication) access to your Azure DevOps organization and the permissions required by the project or resource you call.
 
 Provide your Azure DevOps **organization** (and project, if the call needs one) — e.g. `https://dev.azure.com/<org>`. The token is a standard bearer token — send it with `fetch`:
 
+`AppSchema` below is your app's data schema — the same type you pass to `RayfinClient<AppSchema>`. See [Writing functions](../writing-functions.md#accessing-data-and-request-context).
+
 ```ts
 import {
   UserDataFunctions,
@@ -22,8 +26,8 @@ const ORG = "https://dev.azure.com/<org>";
 
 udf.func(
   "listProjects",
-  async (ctx: RayfinContext): Promise<unknown> => {
-    const token = ctx.getToken(AudienceType.ADO);
+  async (ctx: RayfinContext<AppSchema, AudienceType.ADO>): Promise<unknown> => {
+    const token = ctx.Tokens.ADO;
     const res = await fetch(`${ORG}/_apis/projects?api-version=7.1`, {
       headers: { Authorization: `Bearer ${token}` },
     });
@@ -32,7 +36,7 @@ udf.func(
     }
     return res.json();
   },
-  [udf.connection({ audienceType: AudienceType.ADO })],
+  [],
 );
 ```
 

package/assets/docs/functions/connections/add-azure-resource.md

@@ -4,58 +4,24 @@ sidebar_position: 3
 
 # Add an Azure resource
 
-Connect a function to an **Azure service** — Key Vault, Cosmos DB, Blob Storage, or Event Grid — and call it **as the signed-in user**.
+Connect a deployed function to **Azure Blob Storage**.
 
-These are Azure resources, not Fabric items, so their endpoints come from the **Azure portal** (there is no Fabric lookup). Each pattern declares the connection, reads the token with `ctx.getToken()`, and wraps it with the [`ContextTokenCredential`](./index.md#wrapping-the-token-for-azure-sdk-clients) helper for the Azure SDK. See [Connecting to external resources](./index.md) for the shared model.
+Grant the [application identity](../index.md#application-authentication) the storage data permissions required by your operations.
 
-## Key Vault
+The storage account is an Azure resource, not a Fabric item, so its endpoint comes from the **Azure portal** (there is no Fabric lookup).
+The pattern declares the audience in the `RayfinContext` annotation, reads the token from `ctx.Tokens`, and wraps it with the [`ContextTokenCredential`](./index.md#wrapping-the-token-for-azure-sdk-clients) helper for the Azure SDK.
+See [Connecting to external resources](./index.md) for the shared model.
 
-Read secrets from Azure Key Vault using `AudienceType.KeyVault`.
+`AppSchema` below is your app's data schema — the same type you pass to `RayfinClient<AppSchema>`.
+See [Writing functions](../writing-functions.md#accessing-data-and-request-context).
 
-```bash
-cd rayfin/functions
-npm install @azure/keyvault-secrets @azure/identity
-```
-
-```ts
-import {
-  UserDataFunctions,
-  AudienceType,
-  type RayfinContext,
-} from "@microsoft/fabric-user-data-functions";
-import { SecretClient } from "@azure/keyvault-secrets";
-
-const udf = new UserDataFunctions();
-
-udf.func(
-  "getVaultSecret",
-  async (
-    ctx: RayfinContext,
-    kvUrl: string,
-    secretName: string,
-  ): Promise<string> => {
-    const credential = new ContextTokenCredential(
-      ctx.getToken(AudienceType.KeyVault),
-    );
-    const client = new SecretClient(kvUrl, credential);
-    const secret = await client.getSecret(secretName);
-    return secret.value ?? "";
-  },
-  [udf.connection({ audienceType: AudienceType.KeyVault })],
-);
-```
-
-Provide the vault URL (e.g. `https://my-vault.vault.azure.net/`).
-
-> To read secrets stored with Rayfin itself (rather than an external Key Vault), use [`ctx.getSecret()`](../secrets.md) instead — no connection required.
-
-## Cosmos DB
+## Blob Storage
 
-Connect to Azure Cosmos DB using `AudienceType.CosmosDB`. Pass the credential as `aadCredentials`:
+Connect to Azure Blob / Table / Queue storage using `AudienceType.Storage`:
 
 ```bash
 cd rayfin/functions
-npm install @azure/cosmos
+npm install @azure/storage-blob @azure/identity
 ```
 
 ```ts
@@ -64,53 +30,17 @@ import {
   AudienceType,
   type RayfinContext,
 } from "@microsoft/fabric-user-data-functions";
-import { CosmosClient } from "@azure/cosmos";
+import { BlobServiceClient } from "@azure/storage-blob";
 
 const udf = new UserDataFunctions();
 
-udf.func(
-  "readItems",
-  async (
-    ctx: RayfinContext,
-    endpoint: string,
-    databaseId: string,
-    containerId: string,
-  ): Promise<unknown[]> => {
-    const credential = new ContextTokenCredential(
-      ctx.getToken(AudienceType.CosmosDB),
-    );
-    const client = new CosmosClient({ endpoint, aadCredentials: credential });
-    const { resources } = await client
-      .database(databaseId)
-      .container(containerId)
-      .items.readAll()
-      .fetchAll();
-    return resources;
-  },
-  [udf.connection({ audienceType: AudienceType.CosmosDB })],
-);
-```
-
-Provide the account endpoint and the database / container names.
-
-## Blob Storage
-
-Connect to Azure Blob / Table / Queue storage using `AudienceType.Storage`:
-
-```bash
-cd rayfin/functions
-npm install @azure/storage-blob
-```
-
-```ts
-import { BlobServiceClient } from "@azure/storage-blob";
-
 udf.func(
   "listBlobs",
-  async (ctx: RayfinContext, accountUrl: string): Promise<string[]> => {
-    const credential = new ContextTokenCredential(
-      ctx.getToken(AudienceType.Storage),
-    );
+  async (
+    ctx: RayfinContext<AppSchema, AudienceType.Storage>,
+    accountUrl: string,
+  ): Promise<string[]> => {
+    const credential = new ContextTokenCredential(ctx.Tokens.Storage);
     const service = new BlobServiceClient(accountUrl, credential);
     const names: string[] = [];
     for await (const container of service.listContainers()) {
@@ -118,54 +48,10 @@ udf.func(
     }
     return names;
   },
-  [udf.connection({ audienceType: AudienceType.Storage })],
+  [],
 );
 ```
 
 Provide the storage account URL (e.g. `https://<account>.blob.core.windows.net`).
 
 > `AudienceType.Storage` also covers **OneLake** files — that Fabric case is documented in [Add a Fabric resource → OneLake files](./add-fabric-resource.md#onelake-files).
-
-## Event Grid
-
-Publish events to an Azure Event Grid topic using `AudienceType.EventGrid`. The topic endpoint is in the Azure portal → your topic → **Overview** → _Topic Endpoint_.
-
-```bash
-cd rayfin/functions
-npm install @azure/eventgrid
-```
-
-```ts
-import {
-  UserDataFunctions,
-  AudienceType,
-  type RayfinContext,
-} from "@microsoft/fabric-user-data-functions";
-import { EventGridPublisherClient } from "@azure/eventgrid";
-
-const udf = new UserDataFunctions();
-
-const TOPIC_ENDPOINT =
-  "https://<topic>.<region>.eventgrid.azure.net/api/events";
-
-udf.func(
-  "publishEvent",
-  async (ctx: RayfinContext, subject: string): Promise<string> => {
-    const client = new EventGridPublisherClient(
-      TOPIC_ENDPOINT,
-      "EventGrid",
-      new ContextTokenCredential(ctx.getToken(AudienceType.EventGrid)),
-    );
-    await client.send([
-      {
-        eventType: "Rayfin.Function.Event",
-        subject,
-        dataVersion: "1.0",
-        data: { source: "user-data-function" },
-      },
-    ]);
-    return "published";
-  },
-  [udf.connection({ audienceType: AudienceType.EventGrid })],
-);
-```

package/assets/docs/functions/connections/add-fabric-resource.md

@@ -4,11 +4,18 @@ sidebar_position: 2
 
 # Add a Fabric resource
 
-Connect a function to a **Microsoft Fabric item** — a Lakehouse, Warehouse, SQL Database, OneLake files, or an Eventhouse (KQL) — and call it **as the signed-in user**.
+Connect a deployed function to a **Microsoft Fabric item** — a Lakehouse, Warehouse, SQL Database, or OneLake files.
 
-**Before you start:** you need the item's coordinates (SQL endpoint, OneLake path, or Kusto query URI). See [Get Fabric info](./get-fabric-info.md) for how to pull them from the Fabric REST API.
+For the app's Rayfin DB, use [`ctx.getDataClient()`](../writing-functions.md#accessing-data-and-request-context) instead.
 
-All the patterns below follow the same model: declare the connection, read the token with `ctx.getToken()`, use it. See [Connecting to external resources](./index.md) for the shared model and the [`ContextTokenCredential`](./index.md#wrapping-the-token-for-azure-sdk-clients) helper referenced here.
+Grant the [application identity](../index.md#application-authentication) the required access to the workspace, item, or database for the operation you need.
+
+**Before you start:** you need the item's coordinates (SQL endpoint or OneLake path).
+See [Get Fabric info](./get-fabric-info.md) for how to pull them from the Fabric REST API.
+
+All the patterns below follow the same model: declare the audience in the `RayfinContext` annotation, read the token from `ctx.Tokens`, use it. See [Connecting to external resources](./index.md) for the shared model and the [`ContextTokenCredential`](./index.md#wrapping-the-token-for-azure-sdk-clients) helper referenced here.
+
+`AppSchema` below is your app's data schema — the same type you pass to `RayfinClient<AppSchema>`. See [Writing functions](../writing-functions.md#accessing-data-and-request-context).
 
 ## SQL databases
 
@@ -16,7 +23,7 @@ Covers Fabric **Lakehouse** (SQL analytics endpoint), **Warehouse**, **SQL Datab
 
 - **Package:** `mssql@^12.6.0` (which pulls `tedious >= 19.2.2`). Older `tedious` (`<= 19.1.2`) has a LOGIN7 FeatureExt bug that causes "socket hang up" errors against Fabric endpoints.
 - **Encryption:** `encrypt: true` (not `'strict'`). This matches ODBC `Encrypt=yes`.
-- **Auth:** `azure-active-directory-access-token` with the token from `ctx.getToken(AudienceType.Sql)`.
+- **Auth:** `azure-active-directory-access-token` with the token from `ctx.Tokens.Sql`.
 
 Install the driver in the functions project:
 
@@ -52,10 +59,10 @@ const DATABASE = "<item-guid-or-db-name>";
 udf.func(
   "queryData",
   async (
-    ctx: RayfinContext,
+    ctx: RayfinContext<AppSchema, AudienceType.Sql>,
     query: string,
   ): Promise<Record<string, unknown>[]> => {
-    const token = ctx.getToken(AudienceType.Sql);
+    const token = ctx.Tokens.Sql;
     const pool = await sql.connect({
       server: SQL_SERVER,
       database: DATABASE,
@@ -69,7 +76,7 @@ udf.func(
     await pool.close();
     return result.recordset;
   },
-  [udf.connection({ audienceType: AudienceType.Sql })],
+  [],
 );
 ```
 
@@ -79,7 +86,7 @@ Read and write files in a Lakehouse's OneLake storage using `AudienceType.Storag
 
 The OneLake DFS URL has the form `https://onelake.dfs.fabric.microsoft.com/<workspaceId>/<itemId>/Files/<path>` — get it from `oneLakeFilesPath` via [Get Fabric info](./get-fabric-info.md#lakehouse), or construct it from the workspace and item GUIDs.
 
-Call the DFS endpoint directly with the delegated token — no SDK required:
+Call the DFS endpoint directly with the app-identity token — no SDK required:
 
 ```ts
 import {
@@ -92,8 +99,11 @@ const udf = new UserDataFunctions();
 
 udf.func(
   "readFile",
-  async (ctx: RayfinContext, fileUrl: string): Promise<string> => {
-    const token = ctx.getToken(AudienceType.Storage);
+  async (
+    ctx: RayfinContext<AppSchema, AudienceType.Storage>,
+    fileUrl: string,
+  ): Promise<string> => {
+    const token = ctx.Tokens.Storage;
     const res = await fetch(fileUrl, {
       headers: { Authorization: `Bearer ${token}` },
     });
@@ -102,59 +112,16 @@ udf.func(
     }
     return await res.text();
   },
-  [udf.connection({ audienceType: AudienceType.Storage })],
+  [],
 );
 ```
 
-## Eventhouse and KQL
-
-Query a Fabric **Eventhouse** (KQL database) or a standalone Azure Data Explorer cluster using `AudienceType.Kusto`.
-
-Get the cluster's **query URI** from the Eventhouse's `properties.queryServiceUri` — see [Get Fabric info → Eventhouse](./get-fabric-info.md#eventhouse).
-
-`azure-kusto-data` accepts a token provider, so hand it a callback that returns `ctx.getToken`:
-
-```ts
-import {
-  UserDataFunctions,
-  AudienceType,
-  type RayfinContext,
-} from "@microsoft/fabric-user-data-functions";
-import { Client, KustoConnectionStringBuilder } from "azure-kusto-data";
-
-const udf = new UserDataFunctions();
-
-// Read these from the Eventhouse item — see "Get Fabric info".
-const CLUSTER_URI = "https://<cluster>.z5.kusto.fabric.microsoft.com";
-const DATABASE = "<kql-database-name>";
-
-udf.func(
-  "queryKusto",
-  async (ctx: RayfinContext, query: string): Promise<unknown[]> => {
-    const kcsb = KustoConnectionStringBuilder.withTokenProvider(
-      CLUSTER_URI,
-      async () => ctx.getToken(AudienceType.Kusto),
-    );
-    const client = new Client(kcsb);
-    const response = await client.execute(DATABASE, query);
-    return response.primaryResults[0].toJSON().data;
-  },
-  [udf.connection({ audienceType: AudienceType.Kusto })],
-);
-```
-
-Install the SDK in the functions project:
-
-```bash
-cd rayfin/functions
-npm install azure-kusto-data
-```
-
 ## Fabric REST API
 
-Call the [Fabric REST API](https://learn.microsoft.com/en-us/rest/api/fabric/) as the calling user — for example to list items or read item metadata from inside a function — using `AudienceType.Fabric`.
+Call the [Fabric REST API](https://learn.microsoft.com/en-us/rest/api/fabric/) as the app identity — for example to list items or read item metadata from inside a function — using `AudienceType.Fabric`.
+Check that the specific API supports application identities and that the app identity has the required access.
 
-The API base is fixed at `https://api.fabric.microsoft.com/v1`; `ctx.getToken(AudienceType.Fabric)` returns a token scoped for it. Send it as a bearer token with `fetch`:
+The API base is fixed at `https://api.fabric.microsoft.com/v1`; `ctx.Tokens.Fabric` returns a token scoped for it. Send it as a bearer token with `fetch`:
 
 ```ts
 import {
@@ -169,8 +136,11 @@ const FABRIC_API = "https://api.fabric.microsoft.com/v1";
 
 udf.func(
   "listWorkspaceItems",
-  async (ctx: RayfinContext, workspaceId: string): Promise<unknown> => {
-    const token = ctx.getToken(AudienceType.Fabric);
+  async (
+    ctx: RayfinContext<AppSchema, AudienceType.Fabric>,
+    workspaceId: string,
+  ): Promise<unknown> => {
+    const token = ctx.Tokens.Fabric;
     const res = await fetch(`${FABRIC_API}/workspaces/${workspaceId}/items`, {
       headers: { Authorization: `Bearer ${token}` },
     });
@@ -179,8 +149,8 @@ udf.func(
     }
     return res.json();
   },
-  [udf.connection({ audienceType: AudienceType.Fabric })],
+  [],
 );
 ```
 
-> This is the same API used in [Get Fabric info](./get-fabric-info.md) — the difference is that there you call it at **authoring time** (with an `az` token) to gather endpoints, whereas here the **function** calls it at runtime with the user's delegated token.
+> This is the same API used in [Get Fabric info](./get-fabric-info.md) — the difference is that there you call it at **authoring time** (with an `az` token) to gather endpoints, whereas here the **deployed function** calls it at runtime with the app identity's token and resource permissions.

package/assets/docs/functions/connections/add-foundry.md

@@ -4,10 +4,14 @@ sidebar_position: 4
 
 # Add Azure AI Foundry
 
-Call an **Azure AI Foundry** (Azure OpenAI / Azure AI) resource from a function **as the signed-in user**, using `AudienceType.AzureAI`.
+Call an **Azure AI Foundry** (Azure OpenAI / Azure AI) resource from a deployed function using `AudienceType.AzureAI`.
+
+Grant the [application identity](../index.md#application-authentication) the permissions required by your Azure AI resource and API.
 
 Provide the resource **endpoint** (Azure AI Foundry → your resource → _Endpoint_). The token is a standard bearer token — send it with `fetch`, or wrap it with the [`ContextTokenCredential`](./index.md#wrapping-the-token-for-azure-sdk-clients) helper for an Azure AI SDK client.
 
+`AppSchema` below is your app's data schema — the same type you pass to `RayfinClient<AppSchema>`. See [Writing functions](../writing-functions.md#accessing-data-and-request-context).
+
 ```ts
 import {
   UserDataFunctions,
@@ -22,8 +26,11 @@ const AI_ENDPOINT = "https://<resource>.services.ai.azure.com";
 
 udf.func(
   "callAzureAi",
-  async (ctx: RayfinContext, prompt: string): Promise<unknown> => {
-    const token = ctx.getToken(AudienceType.AzureAI);
+  async (
+    ctx: RayfinContext<AppSchema, AudienceType.AzureAI>,
+    prompt: string,
+  ): Promise<unknown> => {
+    const token = ctx.Tokens.AzureAI;
     const res = await fetch(`${AI_ENDPOINT}/...`, {
       method: "POST",
       headers: {
@@ -37,7 +44,7 @@ udf.func(
     }
     return res.json();
   },
-  [udf.connection({ audienceType: AudienceType.AzureAI })],
+  [],
 );
 ```
 

package/assets/docs/functions/connections/get-fabric-info.md

@@ -4,12 +4,14 @@ sidebar_position: 1
 
 # Finding resource coordinates
 
-Every connection recipe needs a real endpoint — the SQL server, the OneLake path, the Key Vault URI, the Kusto query URI, and so on.
+Every connection recipe needs a real endpoint, such as the SQL server or the OneLake path.
 This page explains **how to obtain those values from a Fabric item** so you (or an agent authoring a function) can fill them in with real data instead of guessing.
 
-**You only need the workspace and item _display names_ to start** — for example, "lakehouseA in workspaceB". Everything else (the workspace ID, item ID, SQL endpoint, OneLake path, Kusto URI) is derivable from here. Resolve those values rather than asking for anything you can look up.
+**You only need the workspace and item _display names_ to start** — for example, "lakehouseA in workspaceB".
+Everything else (the workspace ID, item ID, SQL endpoint, OneLake path) is derivable from here.
+Resolve those values rather than asking for anything you can look up.
 
-> **Why this matters:** don't hardcode a guessed endpoint. `ctx.getToken()` gives you an access token, but you still have to point the SDK at the correct URL — and that URL comes from the Fabric item's metadata, not from `process.env`.
+> **Why this matters:** don't hardcode a guessed endpoint. `ctx.Tokens` gives you an access token, but you still have to point the SDK at the correct URL — and that URL comes from the Fabric item's metadata, not from `process.env`.
 
 ## Ways to get coordinates
 
@@ -36,7 +38,7 @@ az account get-access-token \
   --query accessToken -o tsv
 ```
 
-> This is an **authoring-time** lookup — you are gathering coordinates to write into the function. At **runtime** the function itself uses `ctx.getToken(AudienceType.X)` (or, for the Fabric API specifically, `ctx.getToken(AudienceType.Fabric)` — see [Add a Fabric resource → Fabric REST API](./add-fabric-resource.md#fabric-rest-api)).
+> This is an **authoring-time** lookup — you are gathering coordinates to write into the function. At **runtime** the function itself declares the audience on its `RayfinContext` annotation and reads `ctx.Tokens.<Audience>` (for the Fabric API specifically, `ctx.Tokens.Fabric` — see [Add a Fabric resource → Fabric REST API](./add-fabric-resource.md#fabric-rest-api)).
 
 ## Step 1 — find the workspace and item ID
 
@@ -52,7 +54,7 @@ List items of a given type in a workspace (to resolve a display name to its ID):
 GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items?type=Lakehouse
 ```
 
-`type` accepts any Fabric item type — `Lakehouse`, `Warehouse`, `SQLDatabase`, `Eventhouse`, `KQLDatabase`, and so on.
+`type` accepts any Fabric item type — for these recipes, use `Lakehouse`, `Warehouse`, or `SQLDatabase`.
 Each entry returns `id`, `displayName`, and `type`. Take the `id` of the item you want.
 
 ## Step 2 — GET the item to read its coordinates
@@ -120,25 +122,6 @@ GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/sqlDatabases/{s
 
 - **Server** → `properties.serverFqdn`, **database** → `properties.databaseName`. Both are also embedded in `properties.connectionString`.
 
-### Eventhouse
-
-```http
-GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/eventhouses/{eventhouseId}
-```
-
-```json
-{
-  "type": "Eventhouse",
-  "properties": {
-    "queryServiceUri": "https://xxxxx.z5.kusto.fabric.microsoft.com",
-    "ingestionServiceUri": "https://ingest-xxxxx.z5.kusto.fabric.microsoft.com",
-    "databasesItemIds": ["<kql-database-item-id>"]
-  }
-}
-```
-
-- **Cluster / query URI** → `properties.queryServiceUri`. Use with [Eventhouse and KQL](./add-fabric-resource.md#eventhouse-and-kql). Each KQL database inside the eventhouse is listed in `databasesItemIds`.
-
 ## Coordinate lookup table
 
 | You need                       | Item type    | Endpoint                | Field                                               |
@@ -147,7 +130,6 @@ GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/eventhouses/{ev
 | SQL server (Warehouse)         | Warehouse    | `.../warehouses/{id}`   | `properties.connectionString`                       |
 | SQL server + database (SQL DB) | SQL Database | `.../sqlDatabases/{id}` | `properties.serverFqdn` / `properties.databaseName` |
 | OneLake Files / Tables URL     | Lakehouse    | `.../lakehouses/{id}`   | `properties.oneLakeFilesPath` / `oneLakeTablesPath` |
-| Kusto query URI                | Eventhouse   | `.../eventhouses/{id}`  | `properties.queryServiceUri`                        |
 | Item GUID (any item)           | any          | `.../items?type={Type}` | `id`                                                |
 
 For item types not listed here, browse the [Fabric REST API item reference](https://learn.microsoft.com/en-us/rest/api/fabric/) — each item's **Get** operation returns its coordinates under `properties`.