mongodb 4.2.1 → 4.4.0

package/src/collection.ts

@@ -1,105 +1,108 @@
-import { DEFAULT_PK_FACTORY, emitWarningOnce, resolveOptions } from './utils';
-import { ReadPreference, ReadPreferenceLike } from './read_preference';
-import {
-  normalizeHintField,
-  checkCollectionName,
-  MongoDBNamespace,
-  Callback,
-  getTopology
-} from './utils';
-import { Document, BSONSerializeOptions, resolveBSONOptions } from './bson';
-import { MongoInvalidArgumentError } from './error';
-import { UnorderedBulkOperation } from './bulk/unordered';
+import { BSONSerializeOptions, Document, resolveBSONOptions } from './bson';
+import type { AnyBulkWriteOperation, BulkWriteOptions, BulkWriteResult } from './bulk/common';
 import { OrderedBulkOperation } from './bulk/ordered';
+import { UnorderedBulkOperation } from './bulk/unordered';
 import { ChangeStream, ChangeStreamOptions } from './change_stream';
-import { WriteConcern, WriteConcernOptions } from './write_concern';
-import { ReadConcern, ReadConcernLike } from './read_concern';
 import { AggregationCursor } from './cursor/aggregation_cursor';
+import { FindCursor } from './cursor/find_cursor';
+import type { Db } from './db';
+import { MongoInvalidArgumentError } from './error';
+import type { Logger, LoggerOptions } from './logger';
+import type { PkFactory } from './mongo_client';
+import type {
+  Filter,
+  Flatten,
+  OptionalUnlessRequiredId,
+  TODO_NODE_3286,
+  UpdateFilter,
+  WithId,
+  WithoutId
+} from './mongo_types';
 import type { AggregateOptions } from './operations/aggregate';
 import { BulkWriteOperation } from './operations/bulk_write';
+import type { IndexInformationOptions } from './operations/common_functions';
+import { CountOperation, CountOptions } from './operations/count';
 import { CountDocumentsOperation, CountDocumentsOptions } from './operations/count_documents';
 import {
-  CreateIndexesOperation,
-  CreateIndexOperation,
-  DropIndexOperation,
-  DropIndexesOperation,
-  IndexesOperation,
-  IndexExistsOperation,
-  IndexInformationOperation,
-  CreateIndexesOptions,
-  DropIndexesOptions,
-  ListIndexesOptions,
-  IndexSpecification,
-  IndexDescription,
-  ListIndexesCursor
-} from './operations/indexes';
+  DeleteManyOperation,
+  DeleteOneOperation,
+  DeleteOptions,
+  DeleteResult
+} from './operations/delete';
 import { DistinctOperation, DistinctOptions } from './operations/distinct';
 import { DropCollectionOperation, DropCollectionOptions } from './operations/drop';
 import {
   EstimatedDocumentCountOperation,
   EstimatedDocumentCountOptions
 } from './operations/estimated_document_count';
+import { executeOperation } from './operations/execute_operation';
 import type { FindOptions } from './operations/find';
 import {
   FindOneAndDeleteOperation,
-  FindOneAndReplaceOperation,
-  FindOneAndUpdateOperation,
   FindOneAndDeleteOptions,
+  FindOneAndReplaceOperation,
   FindOneAndReplaceOptions,
+  FindOneAndUpdateOperation,
   FindOneAndUpdateOptions
 } from './operations/find_and_modify';
 import {
+  CreateIndexesOperation,
+  CreateIndexesOptions,
+  CreateIndexOperation,
+  DropIndexesOperation,
+  DropIndexesOptions,
+  DropIndexOperation,
+  IndexDescription,
+  IndexesOperation,
+  IndexExistsOperation,
+  IndexInformationOperation,
+  IndexSpecification,
+  ListIndexesCursor,
+  ListIndexesOptions
+} from './operations/indexes';
+import {
+  InsertManyOperation,
+  InsertManyResult,
   InsertOneOperation,
   InsertOneOptions,
-  InsertOneResult,
-  InsertManyOperation,
-  InsertManyResult
+  InsertOneResult
 } from './operations/insert';
-import {
-  UpdateOneOperation,
-  UpdateManyOperation,
-  UpdateOptions,
-  UpdateResult,
-  ReplaceOneOperation,
-  ReplaceOptions
-} from './operations/update';
-import {
-  DeleteOneOperation,
-  DeleteManyOperation,
-  DeleteOptions,
-  DeleteResult
-} from './operations/delete';
 import { IsCappedOperation } from './operations/is_capped';
 import {
-  MapReduceOperation,
   MapFunction,
-  ReduceFunction,
-  MapReduceOptions
+  MapReduceOperation,
+  MapReduceOptions,
+  ReduceFunction
 } from './operations/map_reduce';
+import type { Hint, OperationOptions } from './operations/operation';
 import { OptionsOperation } from './operations/options_operation';
 import { RenameOperation, RenameOptions } from './operations/rename';
 import { CollStats, CollStatsOperation, CollStatsOptions } from './operations/stats';
-import { executeOperation } from './operations/execute_operation';
-import type { Db } from './db';
-import type { OperationOptions, Hint } from './operations/operation';
-import type { IndexInformationOptions } from './operations/common_functions';
-import type { BulkWriteResult, BulkWriteOptions, AnyBulkWriteOperation } from './bulk/common';
-import type { PkFactory } from './mongo_client';
-import type { Logger, LoggerOptions } from './logger';
-import { FindCursor } from './cursor/find_cursor';
-import type { CountOptions } from './operations/count';
-import type {
-  Filter,
-  TODO_NODE_3286,
-  UpdateFilter,
-  WithId,
-  OptionalId,
-  Flatten
-} from './mongo_types';
+import {
+  ReplaceOneOperation,
+  ReplaceOptions,
+  UpdateManyOperation,
+  UpdateOneOperation,
+  UpdateOptions,
+  UpdateResult
+} from './operations/update';
+import { ReadConcern, ReadConcernLike } from './read_concern';
+import { ReadPreference, ReadPreferenceLike } from './read_preference';
+import {
+  Callback,
+  checkCollectionName,
+  DEFAULT_PK_FACTORY,
+  emitWarningOnce,
+  getTopology,
+  MongoDBNamespace,
+  normalizeHintField,
+  resolveOptions
+} from './utils';
+import { WriteConcern, WriteConcernOptions } from './write_concern';
 
 /** @public */
 export interface ModifyResult<TSchema = Document> {
-  value: TSchema | null;
+  value: WithId<TSchema> | null;
   lastErrorObject?: Document;
   ok: 0 | 1;
 }
@@ -109,6 +112,9 @@ export interface CollectionOptions
   extends BSONSerializeOptions,
     WriteConcernOptions,
     LoggerOptions {
+  /**
+   * @deprecated Use readPreference instead
+   */
   slaveOk?: boolean;
   /** Specify a read concern for the collection. (only MongoDB 3.2 or higher supported) */
   readConcern?: ReadConcernLike;
@@ -124,7 +130,6 @@ export interface CollectionPrivate {
   namespace: MongoDBNamespace;
   readPreference?: ReadPreference;
   bsonOptions: BSONSerializeOptions;
-  slaveOk?: boolean;
   collectionHint?: Hint;
   readConcern?: ReadConcern;
   writeConcern?: WriteConcern;
@@ -178,8 +183,7 @@ export class Collection<TSchema extends Document = Document> {
       readPreference: ReadPreference.fromOptions(options),
       bsonOptions: resolveBSONOptions(options, db),
       readConcern: ReadConcern.fromOptions(options),
-      writeConcern: WriteConcern.fromOptions(options),
-      slaveOk: options == null || options.slaveOk == null ? db.slaveOk : options.slaveOk
+      writeConcern: WriteConcern.fromOptions(options)
     };
   }
 
@@ -261,16 +265,22 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  insertOne(doc: OptionalId<TSchema>): Promise<InsertOneResult<TSchema>>;
-  insertOne(doc: OptionalId<TSchema>, callback: Callback<InsertOneResult<TSchema>>): void;
-  insertOne(doc: OptionalId<TSchema>, options: InsertOneOptions): Promise<InsertOneResult<TSchema>>;
+  insertOne(doc: OptionalUnlessRequiredId<TSchema>): Promise<InsertOneResult<TSchema>>;
+  insertOne(
+    doc: OptionalUnlessRequiredId<TSchema>,
+    callback: Callback<InsertOneResult<TSchema>>
+  ): void;
   insertOne(
-    doc: OptionalId<TSchema>,
+    doc: OptionalUnlessRequiredId<TSchema>,
+    options: InsertOneOptions
+  ): Promise<InsertOneResult<TSchema>>;
+  insertOne(
+    doc: OptionalUnlessRequiredId<TSchema>,
     options: InsertOneOptions,
     callback: Callback<InsertOneResult<TSchema>>
   ): void;
   insertOne(
-    doc: OptionalId<TSchema>,
+    doc: OptionalUnlessRequiredId<TSchema>,
     options?: InsertOneOptions | Callback<InsertOneResult<TSchema>>,
     callback?: Callback<InsertOneResult<TSchema>>
   ): Promise<InsertOneResult<TSchema>> | void {
@@ -305,19 +315,22 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  insertMany(docs: OptionalId<TSchema>[]): Promise<InsertManyResult<TSchema>>;
-  insertMany(docs: OptionalId<TSchema>[], callback: Callback<InsertManyResult<TSchema>>): void;
+  insertMany(docs: OptionalUnlessRequiredId<TSchema>[]): Promise<InsertManyResult<TSchema>>;
+  insertMany(
+    docs: OptionalUnlessRequiredId<TSchema>[],
+    callback: Callback<InsertManyResult<TSchema>>
+  ): void;
   insertMany(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options: BulkWriteOptions
   ): Promise<InsertManyResult<TSchema>>;
   insertMany(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options: BulkWriteOptions,
     callback: Callback<InsertManyResult<TSchema>>
   ): void;
   insertMany(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options?: BulkWriteOptions | Callback<InsertManyResult<TSchema>>,
     callback?: Callback<InsertManyResult<TSchema>>
   ): Promise<InsertManyResult<TSchema>> | void {
@@ -459,26 +472,29 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  replaceOne(filter: Filter<TSchema>, replacement: TSchema): Promise<UpdateResult | Document>;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>
+  ): Promise<UpdateResult | Document>;
+  replaceOne(
+    filter: Filter<TSchema>,
+    replacement: WithoutId<TSchema>,
     callback: Callback<UpdateResult | Document>
   ): void;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>,
     options: ReplaceOptions
   ): Promise<UpdateResult | Document>;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>,
     options: ReplaceOptions,
     callback: Callback<UpdateResult | Document>
   ): void;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>,
     options?: ReplaceOptions | Callback<UpdateResult | Document>,
     callback?: Callback<UpdateResult | Document>
   ): Promise<UpdateResult | Document> | void {
@@ -1279,26 +1295,29 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOneAndReplace(filter: Filter<TSchema>, replacement: Document): Promise<ModifyResult<TSchema>>;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>
+  ): Promise<ModifyResult<TSchema>>;
+  findOneAndReplace(
+    filter: Filter<TSchema>,
+    replacement: WithoutId<TSchema>,
     callback: Callback<ModifyResult<TSchema>>
   ): void;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>,
     options: FindOneAndReplaceOptions
   ): Promise<ModifyResult<TSchema>>;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>,
     options: FindOneAndReplaceOptions,
     callback: Callback<ModifyResult<TSchema>>
   ): void;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>,
     options?: FindOneAndReplaceOptions | Callback<ModifyResult<TSchema>>,
     callback?: Callback<ModifyResult<TSchema>>
   ): Promise<ModifyResult<TSchema>> | void {
@@ -1517,7 +1536,7 @@ export class Collection<TSchema extends Document = Document> {
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
   insert(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options: BulkWriteOptions,
     callback: Callback<InsertManyResult<TSchema>>
   ): Promise<InsertManyResult<TSchema>> | void {
@@ -1618,7 +1637,11 @@ export class Collection<TSchema extends Document = Document> {
     filter ??= {};
     return executeOperation(
       getTopology(this),
-      new CountDocumentsOperation(this as TODO_NODE_3286, filter, resolveOptions(this, options)),
+      new CountOperation(
+        MongoDBNamespace.fromString(this.namespace),
+        filter,
+        resolveOptions(this, options)
+      ),
       callback
     );
   }

package/src/connection_string.ts

@@ -2,22 +2,14 @@ import * as dns from 'dns';
 import * as fs from 'fs';
 import ConnectionString from 'mongodb-connection-string-url';
 import { URLSearchParams } from 'url';
-import { AuthMechanism } from './cmap/auth/defaultAuthProviders';
-import { ReadPreference, ReadPreferenceMode } from './read_preference';
-import { ReadConcern, ReadConcernLevel } from './read_concern';
-import { W, WriteConcern } from './write_concern';
-import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
-import {
-  AnyOptions,
-  Callback,
-  DEFAULT_PK_FACTORY,
-  isRecord,
-  makeClientMetadata,
-  setDifference,
-  HostAddress,
-  emitWarning
-} from './utils';
+
 import type { Document } from './bson';
+import { MongoCredentials } from './cmap/auth/mongo_credentials';
+import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './cmap/auth/providers';
+import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
+import { Encrypter } from './encrypter';
+import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
+import { Logger, LoggerLevel } from './logger';
 import {
   DriverInfo,
   MongoClient,
@@ -27,12 +19,23 @@ import {
   ServerApi,
   ServerApiVersion
 } from './mongo_client';
-import { MongoCredentials } from './cmap/auth/mongo_credentials';
-import type { TagSet } from './sdam/server_description';
-import { Logger, LoggerLevel } from './logger';
+import type { OneOrMore } from './mongo_types';
 import { PromiseProvider } from './promise_provider';
-import { Encrypter } from './encrypter';
-import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
+import { ReadConcern, ReadConcernLevel } from './read_concern';
+import { ReadPreference, ReadPreferenceMode } from './read_preference';
+import type { TagSet } from './sdam/server_description';
+import {
+  AnyOptions,
+  Callback,
+  DEFAULT_PK_FACTORY,
+  emitWarning,
+  emitWarningOnce,
+  HostAddress,
+  isRecord,
+  makeClientMetadata,
+  setDifference
+} from './utils';
+import { W, WriteConcern } from './write_concern';
 
 const VALID_TXT_RECORDS = ['authSource', 'replicaSet', 'loadBalanced'];
 
@@ -124,7 +127,12 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
         const replicaSet = txtRecordOptions.get('replicaSet') ?? undefined;
         const loadBalanced = txtRecordOptions.get('loadBalanced') ?? undefined;
 
-        if (!options.userSpecifiedAuthSource && source) {
+        if (
+          !options.userSpecifiedAuthSource &&
+          source &&
+          options.credentials &&
+          !AUTH_MECHS_AUTH_SRC_EXTERNAL.has(options.credentials.mechanism)
+        ) {
           options.credentials = MongoCredentials.merge(options.credentials, { source });
         }
 
@@ -178,8 +186,22 @@ const FALSEHOODS = new Set(['false', 'f', '0', 'n', 'no', '-1']);
 function getBoolean(name: string, value: unknown): boolean {
   if (typeof value === 'boolean') return value;
   const valueString = String(value).toLowerCase();
-  if (TRUTHS.has(valueString)) return true;
-  if (FALSEHOODS.has(valueString)) return false;
+  if (TRUTHS.has(valueString)) {
+    if (valueString !== 'true') {
+      emitWarningOnce(
+        `deprecated value for ${name} : ${valueString} - please update to ${name} : true instead`
+      );
+    }
+    return true;
+  }
+  if (FALSEHOODS.has(valueString)) {
+    if (valueString !== 'false') {
+      emitWarningOnce(
+        `deprecated value for ${name} : ${valueString} - please update to ${name} : false instead`
+      );
+    }
+    return false;
+  }
   throw new MongoParseError(`Expected ${name} to be stringified boolean value, got: ${value}`);
 }
 
@@ -198,31 +220,24 @@ function getUint(name: string, value: unknown): number {
   return parsedValue;
 }
 
-function toRecord(value: string): Record<string, any> {
-  const record = Object.create(null);
+/** Wrap a single value in an array if the value is not an array */
+function toArray<T>(value: OneOrMore<T>): T[] {
+  return Array.isArray(value) ? value : [value];
+}
+
+function* entriesFromString(value: string) {
   const keyValuePairs = value.split(',');
   for (const keyValue of keyValuePairs) {
     const [key, value] = keyValue.split(':');
     if (value == null) {
       throw new MongoParseError('Cannot have undefined values in key value pairs');
     }
-    try {
-      // try to get a boolean
-      record[key] = getBoolean('', value);
-    } catch {
-      try {
-        // try to get a number
-        record[key] = getInt('', value);
-      } catch {
-        // keep value as a string
-        record[key] = value;
-      }
-    }
+
+    yield [key, value];
   }
-  return record;
 }
 
-class CaseInsensitiveMap extends Map<string, any> {
+class CaseInsensitiveMap<Value = any> extends Map<string, Value> {
   constructor(entries: Array<[string, any]> = []) {
     super(entries.map(([k, v]) => [k.toLowerCase(), v]));
   }
@@ -256,7 +271,7 @@ export function parseOptions(
   const mongoOptions = Object.create(null);
   mongoOptions.hosts = isSRV ? [] : hosts.map(HostAddress.fromString);
 
-  const urlOptions = new CaseInsensitiveMap();
+  const urlOptions = new CaseInsensitiveMap<any[]>();
 
   if (url.pathname !== '/' && url.pathname !== '') {
     const dbName = decodeURIComponent(
@@ -318,16 +333,11 @@ export function parseOptions(
   ]);
 
   for (const key of allKeys) {
-    const values = [];
-    if (objectOptions.has(key)) {
-      values.push(objectOptions.get(key));
-    }
-    if (urlOptions.has(key)) {
-      values.push(...urlOptions.get(key));
-    }
-    if (DEFAULT_OPTIONS.has(key)) {
-      values.push(DEFAULT_OPTIONS.get(key));
-    }
+    const values = [objectOptions, urlOptions, DEFAULT_OPTIONS].flatMap(optionsObject => {
+      const options = optionsObject.get(key) ?? [];
+      return toArray(options);
+    });
+
     allOptions.set(key, values);
   }
 
@@ -388,6 +398,16 @@ export function parseOptions(
     }
 
     mongoOptions.credentials.validate();
+
+    // Check if the only auth related option provided was authSource, if so we can remove credentials
+    if (
+      mongoOptions.credentials.password === '' &&
+      mongoOptions.credentials.username === '' &&
+      mongoOptions.credentials.mechanism === AuthMechanism.MONGODB_DEFAULT &&
+      Object.keys(mongoOptions.credentials.mechanismProperties).length === 0
+    ) {
+      delete mongoOptions.credentials;
+    }
   }
 
   if (!mongoOptions.dbName) {
@@ -448,6 +468,34 @@ export function parseOptions(
     }
   }
 
+  if (mongoOptions.directConnection && mongoOptions.hosts.length !== 1) {
+    throw new MongoParseError('directConnection option requires exactly one host');
+  }
+
+  if (
+    !mongoOptions.proxyHost &&
+    (mongoOptions.proxyPort || mongoOptions.proxyUsername || mongoOptions.proxyPassword)
+  ) {
+    throw new MongoParseError('Must specify proxyHost if other proxy options are passed');
+  }
+
+  if (
+    (mongoOptions.proxyUsername && !mongoOptions.proxyPassword) ||
+    (!mongoOptions.proxyUsername && mongoOptions.proxyPassword)
+  ) {
+    throw new MongoParseError('Can only specify both of proxy username/password or neither');
+  }
+
+  const proxyOptions = ['proxyHost', 'proxyPort', 'proxyUsername', 'proxyPassword'].map(
+    key => urlOptions.get(key) ?? []
+  );
+
+  if (proxyOptions.some(options => options.length > 1)) {
+    throw new MongoParseError(
+      'Proxy options cannot be specified multiple times in the connection string'
+    );
+  }
+
   return mongoOptions;
 }
 
@@ -569,9 +617,7 @@ export const OPTIONS = {
       let source = options.credentials?.source;
       if (
         mechanism === AuthMechanism.MONGODB_PLAIN ||
-        mechanism === AuthMechanism.MONGODB_GSSAPI ||
-        mechanism === AuthMechanism.MONGODB_AWS ||
-        mechanism === AuthMechanism.MONGODB_X509
+        AUTH_MECHS_AUTH_SRC_EXTERNAL.has(mechanism)
       ) {
         // some mechanisms have '$external' as the Auth Source
         source = '$external';
@@ -590,14 +636,26 @@ export const OPTIONS = {
   },
   authMechanismProperties: {
     target: 'credentials',
-    transform({ options, values: [value] }): MongoCredentials {
-      if (typeof value === 'string') {
-        value = toRecord(value);
+    transform({ options, values: [optionValue] }): MongoCredentials {
+      if (typeof optionValue === 'string') {
+        const mechanismProperties = Object.create(null);
+
+        for (const [key, value] of entriesFromString(optionValue)) {
+          try {
+            mechanismProperties[key] = getBoolean(key, value);
+          } catch {
+            mechanismProperties[key] = value;
+          }
+        }
+
+        return MongoCredentials.merge(options.credentials, {
+          mechanismProperties
+        });
       }
-      if (!isRecord(value)) {
+      if (!isRecord(optionValue)) {
         throw new MongoParseError('AuthMechanismProperties must be an object');
       }
-      return MongoCredentials.merge(options.credentials, { mechanismProperties: value });
+      return MongoCredentials.merge(options.credentials, { mechanismProperties: optionValue });
     }
   },
   authSource: {
@@ -688,6 +746,7 @@ export const OPTIONS = {
       });
     }
   },
+  enableUtf8Validation: { type: 'boolean', default: true },
   family: {
     transform({ name, values: [value] }): 4 | 6 {
       const transformValue = getInt(name, value);
@@ -855,6 +914,18 @@ export const OPTIONS = {
   promoteValues: {
     type: 'boolean'
   },
+  proxyHost: {
+    type: 'string'
+  },
+  proxyPassword: {
+    type: 'string'
+  },
+  proxyPort: {
+    type: 'uint'
+  },
+  proxyUsername: {
+    type: 'string'
+  },
   raw: {
     default: false,
     type: 'boolean'
@@ -913,7 +984,7 @@ export const OPTIONS = {
       for (const tag of values) {
         const readPreferenceTag: TagSet = Object.create(null);
         if (typeof tag === 'string') {
-          for (const [k, v] of Object.entries(toRecord(tag))) {
+          for (const [k, v] of entriesFromString(tag)) {
             readPreferenceTag[k] = v;
           }
         }