fix: Check property existence for exclude from indexes with wildcard

package.json

@@ -59,6 +59,7 @@
     "@types/node": "^20.4.9",
     "@types/proxyquire": "^1.3.28",
     "@types/sinon": "^10.0.0",
+    "async": "^3.2.4",
     "c8": "^8.0.1",
     "gapic-tools": "^0.2.0",
     "gts": "^5.0.0",

src/entity.ts

@@ -852,8 +852,11 @@ export namespace entity {
         return;
       }
 
+      const isFirstPathPartDefined =
+        entity.properties![firstPathPart] !== undefined;
       if (
         firstPathPartIsArray &&
+        isFirstPathPartDefined &&
         // check also if the property in question is actually an array value.
         entity.properties![firstPathPart].arrayValue &&
         // check if wildcard is not applied
@@ -879,7 +882,12 @@ export namespace entity {
             );
           }
         });
-      } else if (firstPathPartIsArray && hasWildCard && remainderPath === '*') {
+      } else if (
+        firstPathPartIsArray &&
+        hasWildCard &&
+        remainderPath === '*' &&
+        isFirstPathPartDefined
+      ) {
         const array = entity.properties![firstPathPart].arrayValue;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         array.values.forEach((value: any) => {
@@ -898,7 +906,7 @@ export namespace entity {
             excludePathFromEntity(entity, newPath);
           });
         } else {
-          if (hasWildCard && remainderPath === '*') {
+          if (hasWildCard && remainderPath === '*' && isFirstPathPartDefined) {
             const parentEntity = entity.properties![firstPathPart].entityValue;
 
             if (parentEntity) {
@@ -911,7 +919,7 @@ export namespace entity {
             } else {
               excludePathFromEntity(entity, firstPathPart);
             }
-          } else {
+          } else if (isFirstPathPartDefined) {
             const parentEntity = entity.properties![firstPathPart].entityValue;
             excludePathFromEntity(parentEntity, remainderPath);
           }

test/index.ts

@@ -19,15 +19,25 @@ import * as proxyquire from 'proxyquire';
 import {PassThrough, Readable} from 'stream';
 
 import * as ds from '../src';
-import {DatastoreOptions} from '../src';
-import {entity, Entity, EntityProto, EntityObject} from '../src/entity';
-import {RequestConfig} from '../src/request';
+import {Datastore, DatastoreOptions} from '../src';
+import {Datastore as OriginalDatastore} from '../src';
+import {
+  entity,
+  Entity,
+  EntityProto,
+  EntityObject,
+  Entities,
+} from '../src/entity';
+import {RequestCallback, RequestConfig} from '../src/request';
 import * as is from 'is';
 import * as sinon from 'sinon';
 import * as extend from 'extend';
+import * as protos from '../protos/protos';
+import {google} from '../protos/protos';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const v1 = require('../src/v1/index.js');
+const async = require('async');
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const fakeEntityInit: any = {
@@ -2150,4 +2160,125 @@ describe('Datastore', () => {
       assert.strictEqual(key.name, 'Test');
     });
   });
+
+  describe('Without using mocks', () => {
+    const onSaveTests = [
+      {
+        // When the property is contained in excludeFromIndexes
+        // then save should encode request without excludeFromIndexes
+        properties: {k: {stringValue: 'v'}},
+        entitiesWithoutKey: {data: {k: 'v'}},
+      },
+      {
+        // When the property is contained in excludeFromIndexes
+        // then save should ignore non-existent property in excludeFromIndexes
+        properties: {k: {stringValue: 'v', excludeFromIndexes: true}},
+        entitiesWithoutKey: {
+          data: {k: 'v'},
+          excludeFromIndexes: ['k', 'k.*'],
+        },
+      },
+      {
+        // When the property is not contained in excludeFromIndexes
+        // then save should encode a request without excludeFromIndexes
+        properties: {},
+        entitiesWithoutKey: {data: {}},
+      },
+      {
+        // When the property is not contained in excludeFromIndexes
+        // then save should ignore non-existent property in excludeFromIndexes
+        properties: {},
+        entitiesWithoutKey: {
+          data: {},
+          excludeFromIndexes: [
+            'non_exist_property', // this just ignored
+            'non_exist_property.*', // should also be ignored
+          ],
+        },
+      },
+      {
+        // When the property is not contained in excludeFromIndexes and the property is an array
+        // then save should encode a request properly when there is no wildcard
+        properties: {k: {stringValue: 'v'}},
+        entitiesWithoutKey: {
+          data: {k: 'v'},
+          excludeFromIndexes: [
+            'non_exist_property[]', // this just ignored
+          ],
+        },
+      },
+      {
+        // When the property is not contained in excludeFromIndexes and the property is an array
+        // then save should encode a request properly using a wildcard
+        properties: {k: {stringValue: 'v'}},
+        entitiesWithoutKey: {
+          data: {k: 'v'},
+          excludeFromIndexes: [
+            'non_exist_property[].*', // this just ignored
+          ],
+        },
+      },
+    ];
+
+    async.each(
+      onSaveTests,
+      (onSaveTest: {
+        properties: google.datastore.v1.IValue;
+        entitiesWithoutKey: Entities;
+      }) => {
+        it(`should pass the right properties to upsert on save with parameters: ${JSON.stringify(
+          onSaveTest
+        )}`, async () => {
+          const datastore = new OriginalDatastore({
+            namespace: `${Date.now()}`,
+          });
+          {
+            // This block of code mocks out request_ to check values passed into it.
+            const expectedConfig = {
+              client: 'DatastoreClient',
+              method: 'commit',
+              gaxOpts: {},
+              reqOpts: {
+                mutations: [
+                  {
+                    upsert: {
+                      key: {
+                        path: [{kind: 'Post', name: 'Post1'}],
+                        partitionId: {
+                          namespaceId: datastore.namespace,
+                        },
+                      },
+                      properties: onSaveTest.properties,
+                    },
+                  },
+                ],
+              },
+            };
+            // Mock out the request function to compare config passed into it.
+            datastore.request_ = (
+              config: RequestConfig,
+              callback: RequestCallback
+            ) => {
+              try {
+                assert.deepStrictEqual(config, expectedConfig);
+                callback(null, 'some-data');
+              } catch (e: any) {
+                callback(e);
+              }
+            };
+          }
+          {
+            // Attach key to entities parameter passed in and run save with those parameters.
+            const key = datastore.key(['Post', 'Post1']);
+            const entities = Object.assign(
+              {key},
+              onSaveTest.entitiesWithoutKey
+            );
+            const results = await datastore.save(entities);
+            assert.deepStrictEqual(results, ['some-data']);
+          }
+        });
+      }
+    );
+  });
 });