fix: uncaught DynamoDB exception (#888)

### Description
- DynamoDB have rate limit, when we hit read cap, AWS SDK Client will
throw an exception, but in the implementation it was using callback. So
the callback function will never be called.
- So the value will never return to end of client.
- An uncaught exception may crash backend application in some cases



**Requirements**

- [ ] I have added test coverage for new or changed functionality
- [x] I have followed the repository's [pull request submission
guidelines](../blob/main/CONTRIBUTING.md#submitting-pull-requests)
- [x] I have validated my changes against all supported platform
versions
- the fix is aiming for node server sdk with dynamodb, should be
compatible

**Related issues**

N/A

**Describe the solution you've provided**

- try catch the error and pass undefined to callback function

**Describe alternatives you've considered**
- 1. don't use callback, this is a common and typical issue with mixing
callback, promise and async/await
- 2. to have a error type for callback. usually callback have two
parameters:
```ts
callback: (value, error) -> void
```

**Additional note**
- to cover this kind issue, better to have a integration test, we are
using Nock to re-produce this issue in our internal, but LD isn't using
such a tool, so we didn't at test in PR.

---------

Co-authored-by: Ryan Lamb <[email protected]>

Author: pivstone

packages/store/node-server-sdk-dynamodb/__tests__/DynamoDBCore.test.ts

@@ -280,6 +280,51 @@ describe('given a store with basic data', () => {
     const result = await facade.get(dataKind.features, newFeature.key);
     expect(result).toEqual(descriptor);
   });
+
+  it('handles batchWrite error during init', async () => {
+    const mockLogger = {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    };
+    const state = new DynamoDBClientState(DEFAULT_CLIENT_OPTIONS);
+    const errorCore = new DynamoDBCore(DEFAULT_TABLE_NAME, state, mockLogger);
+    const errorFacade = new AsyncCoreFacade(errorCore);
+
+    // Mock batchWrite to throw an error
+    const error = new Error('Batch write failed');
+    jest.spyOn(state, 'batchWrite').mockRejectedValueOnce(error);
+
+    // Should not throw, but should complete the callback
+    await expect(errorFacade.init([])).resolves.not.toThrow();
+
+    // Verify error was logged
+    expect(mockLogger.error).toHaveBeenCalledWith(`Error writing to DynamoDB: ${error}`);
+  });
+
+  it('handles get error', async () => {
+    const mockLogger = {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    };
+    const state = new DynamoDBClientState(DEFAULT_CLIENT_OPTIONS);
+    const errorCore = new DynamoDBCore(DEFAULT_TABLE_NAME, state, mockLogger);
+    const errorFacade = new AsyncCoreFacade(errorCore);
+
+    // Mock get to throw an error
+    const error = new Error('Get failed');
+    jest.spyOn(state, 'get').mockRejectedValueOnce(error);
+
+    // Should return undefined when get fails
+    const result = await errorFacade.get(dataKind.features, 'some-key');
+    expect(result).toBeUndefined();
+
+    // Verify error was logged with correct namespace and key
+    expect(mockLogger.error).toHaveBeenCalledWith(`Error reading features:some-key: ${error}`);
+  });
 });
 
 it('it can calculate size', () => {

packages/store/node-server-sdk-dynamodb/src/DynamoDBClientState.ts

@@ -102,7 +102,6 @@ export default class DynamoDBClientState {
         Key: key,
       }),
     );
-
     return res.Item;
   }
 

packages/store/node-server-sdk-dynamodb/src/DynamoDBCore.ts

@@ -167,7 +167,11 @@ export default class DynamoDBCore implements interfaces.PersistentDataStore {
     // Always write the initialized token when we initialize.
     ops.push({ PutRequest: { Item: this._initializedToken() } });
 
-    await this._state.batchWrite(this._tableName, ops);
+    try {
+      await this._state.batchWrite(this._tableName, ops);
+    } catch (error) {
+      this._logger?.error(`Error writing to DynamoDB: ${error}`);
+    }
     callback();
   }
 
@@ -176,13 +180,18 @@ export default class DynamoDBCore implements interfaces.PersistentDataStore {
     key: string,
     callback: (descriptor: interfaces.SerializedItemDescriptor | undefined) => void,
   ) {
-    const read = await this._state.get(this._tableName, {
-      namespace: stringValue(this._state.prefixedKey(kind.namespace)),
-      key: stringValue(key),
-    });
-    if (read) {
-      callback(this._unmarshalItem(read));
-    } else {
+    try {
+      const read = await this._state.get(this._tableName, {
+        namespace: stringValue(this._state.prefixedKey(kind.namespace)),
+        key: stringValue(key),
+      });
+      if (read) {
+        callback(this._unmarshalItem(read));
+      } else {
+        callback(undefined);
+      }
+    } catch (error) {
+      this._logger?.error(`Error reading ${kind.namespace}:${key}: ${error}`);
       callback(undefined);
     }
   }