fix: Check property existence for exclude from indexes with wildcard

src/entity.ts

@@ -855,6 +855,7 @@ export namespace entity {
       if (
         firstPathPartIsArray &&
         // check also if the property in question is actually an array value.
+        typeof entity.properties![firstPathPart] !== 'undefined' &&
         entity.properties![firstPathPart].arrayValue &&
         // check if wildcard is not applied
         !hasWildCard
@@ -879,7 +880,12 @@ export namespace entity {
             );
           }
         });
-      } else if (firstPathPartIsArray && hasWildCard && remainderPath === '*') {
+      } else if (
+        firstPathPartIsArray &&
+        hasWildCard &&
+        remainderPath === '*' &&
+        typeof entity.properties![firstPathPart] !== 'undefined'
+      ) {
         const array = entity.properties![firstPathPart].arrayValue;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         array.values.forEach((value: any) => {
@@ -898,22 +904,26 @@ export namespace entity {
             excludePathFromEntity(entity, newPath);
           });
         } else {
-          if (hasWildCard && remainderPath === '*') {
-            const parentEntity = entity.properties![firstPathPart].entityValue;
-
-            if (parentEntity) {
-              Object.keys(parentEntity.properties).forEach(path => {
-                const newPath = parentEntity.properties[path].arrayValue
-                  ? path + '[].*'
-                  : path + '.*';
-                excludePathFromEntity(parentEntity, newPath);
-              });
+          if (typeof entity.properties![firstPathPart] !== 'undefined') {
+            if (hasWildCard && remainderPath === '*') {
+              const parentEntity =
+                entity.properties![firstPathPart].entityValue;
+
+              if (parentEntity) {
+                Object.keys(parentEntity.properties).forEach(path => {
+                  const newPath = parentEntity.properties[path].arrayValue
+                    ? path + '[].*'
+                    : path + '.*';
+                  excludePathFromEntity(parentEntity, newPath);
+                });
+              } else {
+                excludePathFromEntity(entity, firstPathPart);
+              }
             } else {
-              excludePathFromEntity(entity, firstPathPart);
+              const parentEntity =
+                entity.properties![firstPathPart].entityValue;
+              excludePathFromEntity(parentEntity, remainderPath);
             }
-          } else {
-            const parentEntity = entity.properties![firstPathPart].entityValue;
-            excludePathFromEntity(parentEntity, remainderPath);
           }
         }
       }

test/index.ts

@@ -19,9 +19,10 @@ import * as proxyquire from 'proxyquire';
 import {PassThrough, Readable} from 'stream';
 
 import * as ds from '../src';
-import {DatastoreOptions} from '../src';
+import {Datastore, DatastoreOptions} from '../src';
+import {Datastore as OriginalDatastore} from '../src';
 import {entity, Entity, EntityProto, EntityObject} from '../src/entity';
-import {RequestConfig} from '../src/request';
+import {RequestCallback, RequestConfig} from '../src/request';
 import * as is from 'is';
 import * as sinon from 'sinon';
 import * as extend from 'extend';
@@ -2150,4 +2151,181 @@ describe('Datastore', () => {
       assert.strictEqual(key.name, 'Test');
     });
   });
+
+  describe('Without using mocks', () => {
+    const Datastore = OriginalDatastore;
+    describe('using save to evaluate excludeFromIndexes', () => {
+      function getExpectedConfig(
+        properties: any,
+        namespace: string | undefined
+      ) {
+        return {
+          client: 'DatastoreClient',
+          method: 'commit',
+          gaxOpts: {},
+          reqOpts: {
+            mutations: [
+              {
+                upsert: {
+                  key: {
+                    path: [{kind: 'Post', name: 'Post1'}],
+                    partitionId: {
+                      namespaceId: namespace,
+                    },
+                  },
+                  properties,
+                },
+              },
+            ],
+          },
+        };
+      }
+      describe('when the property is contained in excludeFromIndexes', () => {
+        const datastore = new Datastore({
+          namespace: `${Date.now()}`,
+        });
+        const namespace = datastore.namespace;
+        const key = datastore.key(['Post', 'Post1']);
+        it('should encode a request without excludeFromIndexes', async () => {
+          const expectedConfig = getExpectedConfig(
+            {k: {stringValue: 'v'}},
+            namespace
+          );
+          datastore.request_ = (
+            config: RequestConfig,
+            callback: RequestCallback
+          ) => {
+            try {
+              assert.deepStrictEqual(config, expectedConfig);
+              callback(null, 'some-data');
+            } catch (e: any) {
+              callback(e);
+            }
+          };
+          const results = await datastore.save({
+            key,
+            data: {k: 'v'},
+          });
+          assert.deepStrictEqual(results, ['some-data']);
+        });
+        it('should ignore non-existent property in excludeFromIndexes', async () => {
+          const expectedConfig = getExpectedConfig(
+            {k: {stringValue: 'v', excludeFromIndexes: true}},
+            namespace
+          );
+          datastore.request_ = (
+            config: RequestConfig,
+            callback: RequestCallback
+          ) => {
+            try {
+              assert.deepStrictEqual(config, expectedConfig);
+              callback(null, 'some-data');
+            } catch (e: any) {
+              callback(e);
+            }
+          };
+          const results = await datastore.save({
+            key,
+            data: {k: 'v'},
+            excludeFromIndexes: ['k', 'k.*'],
+          });
+          assert.deepStrictEqual(results, ['some-data']);
+        });
+      });
+      describe('when the property is not contained in excludeFromIndexes', () => {
+        const datastore = new Datastore({
+          namespace: `${Date.now()}`,
+        });
+        const namespace = datastore.namespace;
+        const expectedConfig = getExpectedConfig({}, namespace);
+        datastore.request_ = (
+          config: RequestConfig,
+          callback: RequestCallback
+        ) => {
+          try {
+            assert.deepStrictEqual(config, expectedConfig);
+            callback(null, 'some-data');
+          } catch (e: any) {
+            callback(e);
+          }
+        };
+        const key = datastore.key(['Post', 'Post1']);
+        it('should encode a request without excludeFromIndexes', async () => {
+          const results = await datastore.save({
+            key,
+            data: {},
+          });
+          assert.deepStrictEqual(results, ['some-data']);
+        });
+        it('should ignore non-existent property in excludeFromIndexes', async () => {
+          const results = await datastore.save({
+            key,
+            data: {},
+            excludeFromIndexes: [
+              'non_exist_property', // this just ignored
+              'non_exist_property.*', // should also be ignored
+            ],
+          });
+          assert.deepStrictEqual(results, ['some-data']);
+        });
+      });
+      describe('when the property is not contained in excludeFromIndexes and the property is an array', () => {
+        const datastore = new Datastore({
+          namespace: `${Date.now()}`,
+        });
+        const namespace = datastore.namespace;
+        const key = datastore.key(['Post', 'Post1']);
+        it('should encode a request when there is no wildcard', async () => {
+          const expectedConfig = getExpectedConfig(
+            {k: {stringValue: 'v'}},
+            namespace
+          );
+          datastore.request_ = (
+            config: RequestConfig,
+            callback: RequestCallback
+          ) => {
+            try {
+              assert.deepStrictEqual(config, expectedConfig);
+              callback(null, 'some-data');
+            } catch (e: any) {
+              callback(e);
+            }
+          };
+          const results = await datastore.save({
+            key,
+            data: {k: 'v'},
+            excludeFromIndexes: [
+              'non_exist_property[]', // this just ignored
+            ],
+          });
+          assert.deepStrictEqual(results, ['some-data']);
+        });
+        it('should encode a request when using a wildcard', async () => {
+          const expectedConfig = getExpectedConfig(
+            {k: {stringValue: 'v'}},
+            namespace
+          );
+          datastore.request_ = (
+            config: RequestConfig,
+            callback: RequestCallback
+          ) => {
+            try {
+              assert.deepStrictEqual(config, expectedConfig);
+              callback(null, 'some-data');
+            } catch (e: any) {
+              callback(e);
+            }
+          };
+          const results = await datastore.save({
+            key,
+            data: {k: 'v'},
+            excludeFromIndexes: [
+              'non_exist_property[].*', // this just ignored
+            ],
+          });
+          assert.deepStrictEqual(results, ['some-data']);
+        });
+      });
+    });
+  });
 });