fix: Check property existence for exclude from indexes with wildcard

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

@@ -20,15 +20,23 @@ import {PassThrough, Readable} from 'stream';
 
 import * as ds from '../src';
 import {Datastore, DatastoreOptions} from '../src';
-import {entity, Entity, EntityProto, EntityObject} from '../src/entity';
-import {RequestConfig} from '../src/request';
+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';
-const async = require('async');
+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 = {
@@ -2319,6 +2327,128 @@ async.each(
         });
       });
 
+      describe('without using mocks', () => {
+        describe('on save tests', () => {
+          const onSaveTests = [
+            {
+              description:
+                'should encode a save request without excludeFromIndexes',
+              properties: {k: {stringValue: 'v'}},
+              entitiesWithoutKey: {data: {k: 'v'}},
+            },
+            {
+              description:
+                'should add exclude from indexes to property k and ignore excludeFromIndexes with wildcard',
+              properties: {k: {stringValue: 'v', excludeFromIndexes: true}},
+              entitiesWithoutKey: {
+                data: {k: 'v'},
+                excludeFromIndexes: ['k', 'k.*'],
+              },
+            },
+            {
+              description:
+                'should encode a save request without properties and without excludeFromIndexes',
+              properties: {},
+              entitiesWithoutKey: {data: {}},
+            },
+            {
+              description:
+                'should encode a save request with no properties ignoring excludeFromIndexes for a property not on save data',
+              properties: {},
+              entitiesWithoutKey: {
+                data: {},
+                excludeFromIndexes: [
+                  'non_exist_property', // this just ignored
+                  'non_exist_property.*', // should also be ignored
+                ],
+              },
+            },
+            {
+              description:
+                'should encode a save request with one property ignoring excludeFromIndexes for a property not on save data',
+              properties: {k: {stringValue: 'v'}},
+              entitiesWithoutKey: {
+                data: {k: 'v'},
+                excludeFromIndexes: [
+                  'non_exist_property[]', // this just ignored
+                ],
+              },
+            },
+            {
+              description:
+                'should encode a save request with one property ignoring excludeFromIndexes for a property with a wildcard not on save data',
+              properties: {k: {stringValue: 'v'}},
+              entitiesWithoutKey: {
+                data: {k: 'v'},
+                excludeFromIndexes: [
+                  'non_exist_property[].*', // this just ignored
+                ],
+              },
+            },
+          ];
+
+          async.each(
+            onSaveTests,
+            (onSaveTest: {
+              description: string;
+              properties: google.datastore.v1.IValue;
+              entitiesWithoutKey: Entities;
+            }) => {
+              it(`${onSaveTest.description}`, 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']);
+                }
+              });
+            }
+          );
+        });
+      });
+
       describe('multi-db support', () => {
         it('should get the database id from the client', async () => {
           const otherDatastore = new Datastore({