@azure/data-tables 13.3.1-alpha.20250224.1 → 13.3.1-alpha.20250226.1

package/README.md

@@ -109,14 +109,14 @@ Common uses of the Table service include:
 
 To use the clients, import the package in your file:
 
-```javascript
-const AzureTables = require("@azure/data-tables");
+```ts snippet:ignore
+import * as azureTables from "@azure/data-tables";
 ```
 
 Alternatively, selectively import only the types you need:
 
-```javascript
-const { TableServiceClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ignore
+import { TableServiceClient, AzureNamedKeyCredential } from "@azure/data-tables";
 ```
 
 ### Create the Table service client
@@ -128,8 +128,8 @@ The `TableServiceClient` requires a URL to the table service and an access crede
 You can instantiate a `TableServiceClient` with a `AzureNamedKeyCredential` by passing account-name and account-key as arguments. (The account-name and account-key can be obtained from the azure portal.)
 [ONLY AVAILABLE IN NODE.JS RUNTIME]
 
-```javascript
-const { TableServiceClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleCreateClient_NamedKeyCredential
+import { AzureNamedKeyCredential, TableServiceClient } from "@azure/data-tables";
 
 const account = "<account>";
 const accountKey = "<accountkey>";
@@ -152,9 +152,9 @@ To access a table resource with a `TokenCredential`, the authenticated identity
 With the `@azure/identity` package, you can seamlessly authorize requests in both development and production environments.
 To learn more about Azure AD integration in Azure Storage, see the [Azure.Identity README](https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity/README.md)
 
-```javascript
-const { TableServiceClient } = require("@azure/data-tables");
-const { DefaultAzureCredential } = require("@azure/identity");
+```ts snippet:ReadmeSampleCreateClient_TokenCredential
+import { DefaultAzureCredential } from "@azure/identity";
+import { TableServiceClient } from "@azure/data-tables";
 
 // DefaultAzureCredential expects the following three environment variables:
 // - AZURE_TENANT_ID: The tenant ID in Azure Active Directory
@@ -173,8 +173,8 @@ const clientWithAAD = new TableServiceClient(
 
 Also, You can instantiate a `TableServiceClient` with a shared access signatures (SAS). You can get the SAS token from the Azure Portal.
 
-```javascript
-const { TableServiceClient, AzureSASCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleCreateClient_SASToken
+import { TableServiceClient, AzureSASCredential } from "@azure/data-tables";
 
 const account = "<account name>";
 const sas = "<service Shared Access Signature Token>";
@@ -189,8 +189,8 @@ const serviceClientWithSAS = new TableServiceClient(
 
 You can list tables within an account through a `TableServiceClient` instance calling the `listTables` function. This function returns a `PageableAsyncIterator` that you can consume using `for-await-of`
 
-```javascript
-const { TableServiceClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleListTables
+import { AzureNamedKeyCredential, TableServiceClient } from "@azure/data-tables";
 
 const account = "<account>";
 const accountKey = "<accountkey>";
@@ -201,22 +201,11 @@ const serviceClient = new TableServiceClient(
   credential,
 );
 
-async function main() {
-  const tablesIter = serviceClient.listTables();
-  let i = 1;
-  for await (const table of tablesIter) {
-    console.log(`Table${i}: ${table.name}`);
-    i++;
-    // Output:
-    // Table1: testTable1
-    // Table1: testTable2
-    // Table1: testTable3
-    // Table1: testTable4
-    // Table1: testTable5
-  }
+let i = 0;
+const tables = serviceClient.listTables();
+for await (const table of tables) {
+  console.log(`Table${++i}: ${table.name}`);
 }
-
-main();
 ```
 
 #### Create a new table
@@ -224,8 +213,8 @@ main();
 You can create a table through a `TableServiceClient` instance calling the `createTable` function. This function takes the name of the table to create as a parameter.
 Note that `createTable` won't throw an error when the table already exists.
 
-```javascript
-const { TableServiceClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleCreateTable
+import { AzureNamedKeyCredential, TableServiceClient } from "@azure/data-tables";
 
 const account = "<account>";
 const accountKey = "<accountkey>";
@@ -236,19 +225,15 @@ const serviceClient = new TableServiceClient(
   credential,
 );
 
-async function main() {
-  const tableName = `newtable`;
-  // If the table 'newTable' already exists, createTable doesn't throw
-  await serviceClient.createTable(tableName);
-}
-
-main();
+const tableName = "newtable";
+// If the table 'newTable' already exists, createTable doesn't throw
+await serviceClient.createTable(tableName);
 ```
 
 Here is a sample that demonstrates how to test if the table already exists when attempting to create it:
 
-```javascript
-const { TableServiceClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleCreateTable_IfExists
+import { AzureNamedKeyCredential, TableServiceClient } from "@azure/data-tables";
 
 const account = "<account>";
 const accountKey = "<accountkey>";
@@ -259,18 +244,14 @@ const serviceClient = new TableServiceClient(
   credential,
 );
 
-async function main() {
-  const tableName = `newtable${new Date().getTime()}`;
-  await serviceClient.createTable(tableName, {
-    onResponse: (response) => {
-      if (response.status === 409) {
-        console.log(`Table ${tableName} already exists`);
-      }
-    },
-  });
-}
-
-main();
+const tableName = `newtable${+new Date()}`;
+await serviceClient.createTable(tableName, {
+  onResponse: (response) => {
+    if (response.status === 409) {
+      console.log(`Table ${tableName} already exists`);
+    }
+  },
+});
 ```
 
 ### Create the table client
@@ -282,8 +263,8 @@ The `TableClient` is created in a similar way as the `TableServiceClient` with t
 You can instantiate a `TableClient` with a `AzureNamedKeyCredential` by passing account-name and account-key as arguments. (The account-name and account-key can be obtained from the azure portal.)
 [ONLY AVAILABLE IN NODE.JS RUNTIME]
 
-```javascript
-const { TableClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleCreateTableClient_NamedKeyCredential
+import { AzureNamedKeyCredential, TableClient } from "@azure/data-tables";
 
 // Enter your storage account name and shared key
 const account = "<account>";
@@ -307,9 +288,9 @@ To access a table resource with a `TokenCredential`, the authenticated identity
 With the `@azure/identity` package, you can seamlessly authorize requests in both development and production environments.
 To learn more about Azure AD integration in Azure Storage, see the [Azure.Identity README](https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity/README.md)
 
-```javascript
-const { TableClient } = require("@azure/data-tables");
-const { DefaultAzureCredential } = require("@azure/identity");
+```ts snippet:ReadmeSampleCreateTableClient_TokenCredential
+import { DefaultAzureCredential } from "@azure/identity";
+import { TableClient } from "@azure/data-tables";
 
 // DefaultAzureCredential expects the following three environment variables:
 // - AZURE_TENANT_ID: The tenant ID in Azure Active Directory
@@ -330,8 +311,8 @@ const clientWithAAD = new TableClient(
 
 You can instantiate a `TableClient` with a shared access signatures (SAS). You can get the SAS token from the Azure Portal.
 
-```javascript
-const { TableClient, AzureSASCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleCreateTableClient_SASToken
+import { TableClient, AzureSASCredential } from "@azure/data-tables";
 
 const account = "<account name>";
 const sas = "<service Shared Access Signature Token>";
@@ -344,42 +325,12 @@ const clientWithSAS = new TableClient(
 );
 ```
 
-#### `TableClient` with TokenCredential (AAD)
-
-Azure Tables provides integration with Azure Active Directory (Azure AD) for identity-based authentication of requests
-to the Table service when targeting a Storage endpoint. With Azure AD, you can use role-based access control (RBAC) to
-grant access to your Azure Table resources to users, groups, or applications.
-
-To access a table resource with a `TokenCredential`, the authenticated identity should have either the "Storage Table Data Contributor" or "Storage Table Data Reader" role.
-
-With the `@azure/identity` package, you can seamlessly authorize requests in both development and production environments.
-To learn more about Azure AD integration in Azure Storage, see the [Azure.Identity README](https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/identity/identity/README.md)
-
-```javascript
-const { TableClient } = require("@azure/data-tables");
-const { DefaultAzureCredential } = require("@azure/identity");
-
-// DefaultAzureCredential expects the following three environment variables:
-// - AZURE_TENANT_ID: The tenant ID in Azure Active Directory
-// - AZURE_CLIENT_ID: The application (client) ID registered in the AAD tenant
-// - AZURE_CLIENT_SECRET: The client secret for the registered application
-const credential = new DefaultAzureCredential();
-const account = "<account name>";
-const tableName = "<tableName>";
-
-const clientWithAAD = new TableClient(
-  `https://${account}.table.core.windows.net`,
-  tableName,
-  credential,
-);
-```
-
 #### List Entities in a table
 
 You can list entities within a table by through a `TableClient` instance calling the `listEntities` function. This function returns a `PageableAsyncIterator` that you can consume using `for-await-of`
 
-```javascript
-const { TableClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleListEntities
+import { AzureNamedKeyCredential, TableClient } from "@azure/data-tables";
 
 const account = "<account>";
 const accountKey = "<accountkey>";
@@ -388,29 +339,19 @@ const tableName = "<tableName>";
 const credential = new AzureNamedKeyCredential(account, accountKey);
 const client = new TableClient(`https://${account}.table.core.windows.net`, tableName, credential);
 
-async function main() {
-  const entitiesIter = client.listEntities();
-  let i = 1;
-  for await (const entity of entitiesIter) {
-    console.log(`Entity${i}: PartitionKey: ${entity.partitionKey} RowKey: ${entity.rowKey}`);
-    i++;
-    // Output:
-    // Entity1: PartitionKey: P1 RowKey: R1
-    // Entity2: PartitionKey: P2 RowKey: R2
-    // Entity3: PartitionKey: P3 RowKey: R3
-    // Entity4: PartitionKey: P4 RowKey: R4
-  }
+let i = 0;
+const entities = client.listEntities();
+for await (const entity of entities) {
+  console.log(`Entity${++i}: PartitionKey: ${entity.partitionKey} RowKey: ${entity.rowKey}`);
 }
-
-main();
 ```
 
 #### Create a new entity and add it to a table
 
 You can create a new Entity in a table by through a `TableClient` instance calling the `createEntity` function. This function takes the entity to insert as a parameter. The entity must contain `partitionKey` and `rowKey`.
 
-```javascript
-const { TableClient, AzureNamedKeyCredential } = require("@azure/data-tables");
+```ts snippet:ReadmeSampleCreateEntity
+import { AzureNamedKeyCredential, TableClient } from "@azure/data-tables";
 
 const account = "<account>";
 const accountKey = "<accountkey>";
@@ -419,17 +360,13 @@ const tableName = "<tableName>";
 const credential = new AzureNamedKeyCredential(account, accountKey);
 const client = new TableClient(`https://${account}.table.core.windows.net`, tableName, credential);
 
-async function main() {
-  const testEntity = {
-    partitionKey: "P1",
-    rowKey: "R1",
-    foo: "foo",
-    bar: 123,
-  };
-  await client.createEntity(testEntity);
-}
-
-main();
+const testEntity = {
+  partitionKey: "P1",
+  rowKey: "R1",
+  foo: "foo",
+  bar: 123,
+};
+await client.createEntity(testEntity);
 ```
 
 ## Azurite and Storage Emulator
@@ -440,7 +377,7 @@ The Azure Tables Client SDK also works with Azurite, an Azure Storage and Tables
 
 The easiest way to connect to Azurite from your application is to configure a connection string that references the shortcut `UseDevelopmentStorage=true`. The shortcut is equivalent to the full connection string for the emulator, which specifies the account name, the account key, and the emulator endpoints for each of the Azure Storage services: ([see more](https://github.com/Azure/Azurite#http-connection-strings)). Using this shortcut, the Azure Tables Client SDK would setup the default connection string and `allowInsecureConnection` in the client options.
 
-```typescript
+```ts snippet:ReadmeSampleCreateTableClient_ConnectionString
 import { TableClient } from "@azure/data-tables";
 
 const connectionString = "UseDevelopmentStorage=true";
@@ -451,7 +388,7 @@ const client = TableClient.fromConnectionString(connectionString, "myTable");
 
 You can connect to azurite manually without using the connection string shortcut by specifying the service URL and `AzureNamedKeyCredential` or a custom connection string. However, `allowInsecureConnection` will need to be set manually in case Azurite runs in an `http` endpoint.
 
-```typescript
+```ts snippet:ReadmeSampleCreateTableClient_Azurite
 import { TableClient, AzureNamedKeyCredential } from "@azure/data-tables";
 
 const client = new TableClient(
@@ -473,16 +410,12 @@ When you interact with Tables service using the Javascript/Typescript SDK, error
 
 Enabling logging may help uncover useful information about failures. In order to see a log of HTTP requests and responses, set the `AZURE_LOG_LEVEL` environment variable to `info`. Alternatively, logging can be enabled at runtime by calling `setLogLevel` in the `@azure/logger`:
 
-```javascript
-const { setLogLevel } = require("@azure/logger");
+```ts snippet:SetLogLevel
+import { setLogLevel } from "@azure/logger";
 
 setLogLevel("info");
 ```
 
-## Next steps
-
-More code samples coming soon Issue#10531
-
 ## Contributing
 
 This project welcomes contributions and suggestions. Most contributions require you to agree to a