@azure/data-tables 13.0.0-alpha.20211109.5 → 13.0.1-alpha.20211206.1

package/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Release History
 
-## 13.0.0 (2021-11-09)
+## 13.0.1 (Unreleased)
+
+### Features Added
+
+### Breaking Changes
+
+### Bugs Fixed
+
+### Other Changes
+
+## 13.0.0 (2021-11-11)
+
+### Acknowledgments
+
+Thank you to our developer community members who helped to make the Azure Tables client library better with their contributions to this release:
+
+- Daniel Hensby _([GitHub](https://github.com/dhensby))_
 
 ### Features Added
 
@@ -21,7 +37,7 @@
 - Issue #18521 - `upsertEntity` doesn't work with "" for partition or row keys. [#18586](https://github.com/Azure/azure-sdk-for-js/pull/18586)
 
 ### Other Changes
-
+- Export RestError [#18635](https://github.com/Azure/azure-sdk-for-js/pull/18635). (A community contribution, courtesy of _[dhensby](https://github.com/dhensby))_
 ## 12.1.2 (2021-09-07)
 
 ### Bugs Fixed

package/README.md

@@ -17,6 +17,7 @@ Azure Cosmos DB provides a Table API for applications that are written for Azure
 - The Azure Tables client library can seamlessly target either Azure table storage or Azure Cosmos DB table service endpoints with no code changes.
 
 Key links:
+
 - [Source code](https://github.com/Azure/azure-sdk-for-js/blob/main/sdk/tables/data-tables/)
 - [Package (NPM)](https://www.npmjs.com/package/@azure/data-tables)
 - [API reference documentation](https://docs.microsoft.com/javascript/api/@azure/data-tables)
@@ -123,6 +124,7 @@ const { TableServiceClient, AzureNamedKeyCredential } = require("@azure/data-tab
 The `TableServiceClient` requires a URL to the table service and an access credential. It also optionally accepts some settings in the `options` parameter.
 
 #### `TableServiceClient` 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.
@@ -202,6 +204,7 @@ main();
 #### Create a new table
 
 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");
@@ -216,13 +219,42 @@ const serviceClient = new TableServiceClient(
 );
 
 async function main() {
-  const tableName = `newtable${new Date().getTime()}`;
+  const tableName = `newtable`;
+  // If the table 'newTable' already exists, createTable doesn' throw
   await serviceClient.createTable(tableName);
 }
 
 main();
 ```
 
+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");
+
+const account = "<account>";
+const accountKey = "<accountkey>";
+
+const credential = new AzureNamedKeyCredential(account, accountKey);
+const serviceClient = new TableServiceClient(
+  `https://${account}.table.core.windows.net`,
+  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();
+```
+
 ### Create the table client
 
 The `TableClient` is created in a similar way as the `TableServiceClient` with the difference that `TableClient` takes a table name as a parameter
@@ -247,6 +279,7 @@ const client = new TableClient(`https://${account}.table.core.windows.net`, tabl
 ```
 
 #### `TableClient` with `TokenCredential` (Azure Active Directory)
+
 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.
@@ -356,33 +389,31 @@ main();
 The Azure Tables Client SDK also works with Azurite, an Azure Storage and Tables API compatible server emulator. Please refer to the ([Azurite repository](https://github.com/Azure/Azurite#azurite-v3)) on how to get started using it.
 
 ### Connecting to Azurite with Connection String shortcut
+
 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
-import { TableClient } from "@azure/data-tables"
+import { TableClient } from "@azure/data-tables";
 
 const connectionString = "UseDevelopmentStorage=true";
 const client = TableClient.fromConnectionString(connectionString, "myTable");
 ```
 
 ### Connecting to Azurite without Connection String shortcut
+
 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
-import { TableClient, AzureNamedKeyCredential } from "@azure/data-tables"
+import { TableClient, AzureNamedKeyCredential } from "@azure/data-tables";
 
 const client = new TableClient(
   "<Azurite-http-table-endpoint>",
   "myTable",
-  new AzureNamedKeyCredential(
-    "<Azurite-account-name>",
-    "<Azurite-account-key>"
-  ),
+  new AzureNamedKeyCredential("<Azurite-account-name>", "<Azurite-account-key>"),
   { allowInsecureConnection: true }
 );
 ```
 
-
 ## Troubleshooting
 
 ### General

package/dist/index.js

@@ -3068,7 +3068,7 @@ class GeneratedClientContext extends coreClient.ServiceClient {
         const defaults = {
             requestContentType: "application/json; charset=utf-8"
         };
-        const packageDetails = `azsdk-js-data-tables/13.0.0`;
+        const packageDetails = `azsdk-js-data-tables/13.0.1`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix
             ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}`
             : `${packageDetails}`;
@@ -3382,6 +3382,40 @@ function signURLWithSAS(request, credential) {
     request.url = url.toString();
 }
 
+// Copyright (c) Microsoft Corporation.
+function handleTableAlreadyExists(error, options = {}) {
+    var _a, _b, _c;
+    const responseError = getErrorResponse(error);
+    if (responseError &&
+        responseError.status === 409 &&
+        ((_a = responseError.parsedBody.odataError) === null || _a === void 0 ? void 0 : _a.code) === "TableAlreadyExists") {
+        (_b = options.logger) === null || _b === void 0 ? void 0 : _b.info(`Table ${options.tableName} already Exists`);
+        if (options.onResponse) {
+            options.onResponse(responseError, {});
+        }
+    }
+    else {
+        options === null || options === void 0 ? void 0 : options.span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: (_c = error) === null || _c === void 0 ? void 0 : _c.message });
+        throw error;
+    }
+}
+function getErrorResponse(error) {
+    if (!isRestError(error)) {
+        return undefined;
+    }
+    const errorResponse = error.response;
+    if (!errorResponse || !isTableServiceErrorResponse(errorResponse.parsedBody)) {
+        return undefined;
+    }
+    return errorResponse;
+}
+function isRestError(error) {
+    return error.name === "RestError";
+}
+function isTableServiceErrorResponse(errorResponseBody) {
+    return Boolean(errorResponseBody === null || errorResponseBody === void 0 ? void 0 : errorResponseBody.odataError);
+}
+
 // Copyright (c) Microsoft Corporation.
 /**
  * A TableServiceClient represents a Client to the Azure Tables service allowing you
@@ -3479,16 +3513,10 @@ class TableServiceClient {
     async createTable(name, options = {}) {
         const { span, updatedOptions } = createSpan("TableServiceClient-createTable", options);
         try {
-            await this.table.create({ name }, Object.assign(Object.assign({}, updatedOptions), { responsePreference: "return-content" }));
+            await this.table.create({ name }, Object.assign({}, updatedOptions));
         }
         catch (e) {
-            if (e.statusCode === 409) {
-                logger.info("TableServiceClient-createTable: Table Already Exists");
-            }
-            else {
-                span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-                throw e;
-            }
+            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { span, logger, tableName: name }));
         }
         finally {
             span.end();
@@ -4453,7 +4481,7 @@ class TableClient {
      * // calling create table will create the table used
      * // to instantiate the TableClient.
      * // Note: If the table already
-     * // exists this function doesn't fail.
+     * // exists this function doesn't throw.
      * await client.createTable();
      * ```
      */
@@ -4464,13 +4492,7 @@ class TableClient {
             await this.table.create({ name: this.tableName }, updatedOptions);
         }
         catch (e) {
-            if (e.statusCode === 409) {
-                logger.info("TableClient-createTable: Table Already Exists");
-            }
-            else {
-                span.setStatus({ code: coreTracing.SpanStatusCode.ERROR, message: e.message });
-                throw e;
-            }
+            handleTableAlreadyExists(e, Object.assign(Object.assign({}, updatedOptions), { span, logger, tableName: this.tableName }));
         }
         finally {
             span.end();
@@ -4989,6 +5011,12 @@ Object.defineProperty(exports, 'AzureSASCredential', {
         return coreAuth.AzureSASCredential;
     }
 });
+Object.defineProperty(exports, 'RestError', {
+    enumerable: true,
+    get: function () {
+        return coreRestPipeline.RestError;
+    }
+});
 exports.TableClient = TableClient;
 exports.TableServiceClient = TableServiceClient;
 exports.TableTransaction = TableTransaction;