@aws-amplify/datastore 5.0.32 → 5.0.33-s-auth.30d0cd2.0

package/dist/esm/datastore/datastore.mjs

@@ -10,10 +10,10 @@ import { ExclusiveStorage } from '../storage/storage.mjs';
 import { ModelRelationship } from '../storage/relationship.mjs';
 import { SyncEngine, ControlMessage } from '../sync/index.mjs';
 import { isIdentifierObject, AuthModeStrategyType, isNonModelFieldType, isModelFieldType, isSchemaModelWithAttributes, isGraphQLScalarType, GraphQLScalarType } from '../types.mjs';
-import { isNode } from './utils.mjs';
 import { monotonicUlidFactory, USER, establishRelationAndKeys, isModelConstructor, extractPrimaryKeyFieldNames, registerNonModelClass, errorMessages, inMemoryPagination, extractPrimaryKeysAndValues, DeferredCallbackResolver, isIdManaged, isIdOptionallyManaged, mergePatches, STORAGE, SYNC, DATASTORE, sortCompareFunction, getTimestampFields, isNullOrUndefined } from '../util.mjs';
 import { recursivePredicateFor, internals, predicateFor } from '../predicates/next.mjs';
 import { getIdentifierValue } from '../sync/utils.mjs';
+import { isNode } from './utils.mjs';
 import { ModelSortPredicateCreator } from '../predicates/sort.mjs';
 
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
@@ -90,6 +90,8 @@ const buildSeedPredicate = (modelConstructor) => {
     });
 };
 // exporting syncClasses for testing outbox.test.ts
+// TODO(eslint): refactor not to export non-constant
+// eslint-disable-next-line import/no-mutable-exports
 let syncClasses;
 let userClasses;
 let dataStoreClasses;
@@ -224,7 +226,7 @@ const initSchema = (userSchema) => {
             // compatibility with legacy/pre-PK codegen for lazy loading to inject
             // index fields into the model definition.
             // definition.cloudFields = { ...definition.fields };
-            const indexes = schema.namespaces[namespace].relationships[model.name].indexes;
+            const { indexes } = schema.namespaces[namespace].relationships[model.name];
             const indexFields = new Set();
             for (const index of indexes) {
                 for (const indexField of index[1]) {
@@ -305,7 +307,7 @@ const checkSchemaCodegenVersion = (codegenVersion) => {
     let isValid = false;
     try {
         const versionParts = codegenVersion.split('.');
-        const [major, minor, patch, patchrevision] = versionParts;
+        const [major, minor] = versionParts;
         isValid = Number(major) === majorVersion && Number(minor) >= minorVersion;
     }
     catch (err) {
@@ -337,9 +339,9 @@ const createTypeClasses = namespace => {
  * metadata fields (_version, _deleted, etc.) exposed on the model itself.
  */
 const instancesMetadata = new WeakSet();
-function modelInstanceCreator(modelConstructor, init) {
+function modelInstanceCreator(ModelConstructor, init) {
     instancesMetadata.add(init);
-    return new modelConstructor(init);
+    return new ModelConstructor(init);
 }
 const validateModelFields = (modelDefinition) => (k, v) => {
     const fieldDefinition = modelDefinition.fields[k];
@@ -411,9 +413,7 @@ const validateModelFields = (modelDefinition) => (k, v) => {
                     }
                 }
             }
-            else if (!isRequired && v === undefined) {
-                return;
-            }
+            else if (!isRequired && v === undefined) ;
             else if (typeof v !== jsType && v !== null) {
                 throw new Error(`Field ${name} should be of type ${jsType}, ${typeof v} received. ${v}`);
             }
@@ -573,7 +573,9 @@ const createModelClass = (modelDefinition) => {
             // are only create to provide a consistent view of the data for fields pre/post sync
             // where possible. (not all fields can be normalized pre-sync, because they're generally
             // "cloud managed" fields, like createdAt and updatedAt.)
-            const normalized = produce(baseInstance, (draft) => normalize(modelDefinition, draft));
+            const normalized = produce(baseInstance, (draft) => {
+                normalize(modelDefinition, draft);
+            });
             initPatches.set(normalized, patches);
             return normalized;
         }
@@ -651,7 +653,7 @@ const createModelClass = (modelDefinition) => {
         pkField: extractPrimaryKeyFieldNames(modelDefinition),
     });
     for (const relationship of allModelRelationships) {
-        const field = relationship.field;
+        const { field } = relationship;
         Object.defineProperty(clazz.prototype, modelDefinition.fields[field].name, {
             set(model) {
                 if (!(typeof model === 'object' || typeof model === 'undefined'))
@@ -661,7 +663,7 @@ const createModelClass = (modelDefinition) => {
                     // Avoid validation error when processing AppSync response with nested
                     // selection set. Nested entitites lack version field and can not be validated
                     // TODO: explore a more reliable method to solve this
-                    if (model.hasOwnProperty('_version')) {
+                    if (Object.prototype.hasOwnProperty.call(model, '_version')) {
                         const modelConstructor = Object.getPrototypeOf(model || {})
                             .constructor;
                         if (!isValidModelConstructor(modelConstructor)) {
@@ -699,7 +701,7 @@ const createModelClass = (modelDefinition) => {
                 // if the memos already has a result for this field, we'll use it.
                 // there is no "cache" invalidation of any kind; memos are permanent to
                 // keep an immutable perception of the instance.
-                if (!instanceMemos.hasOwnProperty(field)) {
+                if (!Object.prototype.hasOwnProperty.call(instanceMemos, field)) {
                     // before we populate the memo, we need to know where to look for relatives.
                     // today, this only supports DataStore. Models aren't managed elsewhere in Amplify.
                     if (getAttachment(this) === ModelAttachment.DataStore) {
@@ -708,9 +710,9 @@ const createModelClass = (modelDefinition) => {
                         // drop the promise into the memo's synchronously, eliminating the chance
                         // for a race.
                         const resultPromise = instance.query(relationship.remoteModelConstructor, base => base.and(q => {
-                            return relationship.remoteJoinFields.map((field, index) => {
+                            return relationship.remoteJoinFields.map((joinField, index) => {
                                 // TODO: anything we can use instead of `any` here?
-                                return q[field].eq(this[relationship.localJoinFields[index]]);
+                                return q[joinField].eq(this[relationship.localJoinFields[index]]);
                             });
                         }));
                         // results in hand, how we return them to the caller depends on the relationship type.
@@ -912,10 +914,10 @@ function getModelConstructorByModelName(namespaceName, modelName) {
  * @param version The expected schema version.
  */
 async function checkSchemaVersion(storage, version) {
-    const Setting = dataStoreClasses.Setting;
+    const SettingCtor = dataStoreClasses.Setting;
     const modelDefinition = schema.namespaces[DATASTORE].models.Setting;
     await storage.runExclusive(async (s) => {
-        const [schemaVersionSetting] = await s.query(Setting, ModelPredicateCreator.createFromAST(modelDefinition, {
+        const [schemaVersionSetting] = await s.query(SettingCtor, ModelPredicateCreator.createFromAST(modelDefinition, {
             and: { key: { eq: SETTING_SCHEMA_VERSION } },
         }), { page: 0, limit: 1 });
         if (schemaVersionSetting !== undefined &&
@@ -926,7 +928,7 @@ async function checkSchemaVersion(storage, version) {
             }
         }
         else {
-            await s.save(modelInstanceCreator(Setting, {
+            await s.save(modelInstanceCreator(SettingCtor, {
                 key: SETTING_SCHEMA_VERSION,
                 value: JSON.stringify(version),
             }));
@@ -1049,9 +1051,9 @@ class DataStore {
                 this.state = DataStoreState.Starting;
                 if (this.initialized === undefined) {
                     logger.debug('Starting DataStore');
-                    this.initialized = new Promise((res, rej) => {
-                        this.initResolve = res;
-                        this.initReject = rej;
+                    this.initialized = new Promise((resolve, reject) => {
+                        this.initResolve = resolve;
+                        this.initReject = reject;
                     });
                 }
                 else {
@@ -1113,7 +1115,7 @@ class DataStore {
                 if (!this.storage) {
                     throw new Error('No storage to query');
                 }
-                //#region Input validation
+                // #region Input validation
                 if (!isValidModelConstructor(modelConstructor)) {
                     const msg = 'Constructor is not for a valid model';
                     logger.error(msg, { modelConstructor });
@@ -1160,7 +1162,7 @@ class DataStore {
                         result = inMemoryPagination(result, pagination);
                     }
                 }
-                //#endregion
+                // #endregion
                 const returnOne = isQueryOne(identifierOrCriteria) ||
                     isIdentifierObject(identifierOrCriteria, modelDefinition);
                 return attached(returnOne ? result[0] : result, ModelAttachment.DataStore);
@@ -1187,7 +1189,9 @@ class DataStore {
                 // are ALWAYS present, whereas update patches are only present if copyOf
                 // was used to create the instance.
                 const patchesTuple = updatedPatchesTuple || initPatchesTuple;
-                const modelConstructor = model ? model.constructor : undefined;
+                const modelConstructor = model
+                    ? model.constructor
+                    : undefined;
                 if (!isValidModelConstructor(modelConstructor)) {
                     const msg = 'Object is not an instance of a valid model';
                     logger.error(msg, { model });
@@ -1350,15 +1354,15 @@ class DataStore {
                 : undefined;
             if (modelOrConstructor && modelConstructor === undefined) {
                 const model = modelOrConstructor;
-                const modelConstructor = model && Object.getPrototypeOf(model).constructor;
-                if (isValidModelConstructor(modelConstructor)) {
+                const resolvedModelConstructor = model && Object.getPrototypeOf(model).constructor;
+                if (isValidModelConstructor(resolvedModelConstructor)) {
                     if (identifierOrCriteria) {
                         logger.warn('idOrCriteria is ignored when using a model instance', {
                             model,
                             identifierOrCriteria,
                         });
                     }
-                    return this.observe(modelConstructor, model.id);
+                    return this.observe(resolvedModelConstructor, model.id);
                 }
                 else {
                     const msg = 'The model is not an instance of a PersistentModelConstructor';
@@ -1424,8 +1428,12 @@ class DataStore {
                                     observer.next(message);
                                 }
                             }, 'datastore observe message handler'),
-                        error: err => observer.error(err),
-                        complete: () => observer.complete(),
+                        error: err => {
+                            observer.error(err);
+                        },
+                        complete: () => {
+                            observer.complete();
+                        },
                     });
                 }, 'datastore observe observable initialization')
                     .catch(this.handleAddProcError('DataStore.observe()'))
@@ -1496,9 +1504,9 @@ class DataStore {
                         // We need to post-filter results instead of passing criteria through
                         // to have visibility into items that move from in-set to out-of-set.
                         // We need to explicitly remove those items from the existing snapshot.
-                        handle = this.observe(model).subscribe(({ element, model, opType }) => this.runningProcesses.isOpen &&
+                        handle = this.observe(model).subscribe(({ element, model: observedModel, opType }) => this.runningProcesses.isOpen &&
                             this.runningProcesses.add(async () => {
-                                const itemModelDefinition = getModelDefinition(model);
+                                const itemModelDefinition = getModelDefinition(observedModel);
                                 const idOrPk = getIdentifierValue(itemModelDefinition, element);
                                 if (executivePredicate &&
                                     !(await executivePredicate.matches(element))) {
@@ -1525,7 +1533,7 @@ class DataStore {
                                 else {
                                     itemsChanged.set(idOrPk, element);
                                 }
-                                const isSynced = this.sync?.getModelSyncedStatus(model) ?? false;
+                                const isSynced = this.sync?.getModelSyncedStatus(observedModel) ?? false;
                                 const limit = itemsChanged.size - deletedItemIds.length >=
                                     this.syncPageSize;
                                 if (limit || isSynced) {
@@ -1599,8 +1607,8 @@ class DataStore {
                  * @param itemsToSort A array of model type.
                  */
                 const sortItems = (itemsToSort) => {
-                    const modelDefinition = getModelDefinition(model);
-                    const pagination = this.processPagination(modelDefinition, options);
+                    const sortingModelDefinition = getModelDefinition(model);
+                    const pagination = this.processPagination(sortingModelDefinition, options);
                     const sortPredicates = ModelSortPredicateCreator.getPredicates(pagination.sort);
                     if (sortPredicates.length) {
                         const compareFn = sortCompareFunction(sortPredicates);
@@ -1633,7 +1641,7 @@ class DataStore {
         };
         this.configure = (config = {}) => {
             this.amplifyContext.InternalAPI = this.InternalAPI;
-            const { DataStore: configDataStore, authModeStrategyType: configAuthModeStrategyType, conflictHandler: configConflictHandler, errorHandler: configErrorHandler, maxRecordsToSync: configMaxRecordsToSync, syncPageSize: configSyncPageSize, fullSyncInterval: configFullSyncInterval, syncExpressions: configSyncExpressions, authProviders: configAuthProviders, storageAdapter: configStorageAdapter, ...configFromAmplify } = config;
+            const { DataStore: configDataStore, authModeStrategyType: configAuthModeStrategyType, maxRecordsToSync: configMaxRecordsToSync, syncPageSize: configSyncPageSize, fullSyncInterval: configFullSyncInterval, syncExpressions: configSyncExpressions, authProviders: configAuthProviders, storageAdapter: configStorageAdapter, ...configFromAmplify } = config;
             const currentAppSyncConfig = Amplify.getConfig().API?.GraphQL;
             const appSyncConfig = {
                 aws_appsync_graphqlEndpoint: currentAppSyncConfig?.endpoint,