create-mern-omar 1.0.0 → 1.1.0

package/templates/node_modules/mongodb/src/operations/set_profiling_level.ts

@@ -0,0 +1,74 @@
+import { type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import type { Db } from '../db';
+import { MongoInvalidArgumentError } from '../error';
+import { enumToString } from '../utils';
+import { CommandOperation, type CommandOperationOptions } from './command';
+
+const levelValues = new Set(['off', 'slow_only', 'all']);
+
+/** @public */
+export const ProfilingLevel = Object.freeze({
+  off: 'off',
+  slowOnly: 'slow_only',
+  all: 'all'
+} as const);
+
+/** @public */
+export type ProfilingLevel = (typeof ProfilingLevel)[keyof typeof ProfilingLevel];
+
+/** @public */
+export type SetProfilingLevelOptions = Omit<CommandOperationOptions, 'rawData'>;
+
+/** @internal */
+export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  override options: SetProfilingLevelOptions;
+  level: ProfilingLevel;
+  profile: 0 | 1 | 2;
+
+  constructor(db: Db, level: ProfilingLevel, options: SetProfilingLevelOptions) {
+    super(db, options);
+    this.options = options;
+    switch (level) {
+      case ProfilingLevel.off:
+        this.profile = 0;
+        break;
+      case ProfilingLevel.slowOnly:
+        this.profile = 1;
+        break;
+      case ProfilingLevel.all:
+        this.profile = 2;
+        break;
+      default:
+        this.profile = 0;
+        break;
+    }
+
+    this.level = level;
+  }
+
+  override get commandName() {
+    return 'profile' as const;
+  }
+
+  override buildCommandDocument(_connection: Connection): Document {
+    const level = this.level;
+
+    if (!levelValues.has(level)) {
+      // TODO(NODE-3483): Determine error to put here
+      throw new MongoInvalidArgumentError(
+        `Profiling level must be one of "${enumToString(ProfilingLevel)}"`
+      );
+    }
+
+    return { profile: this.profile };
+  }
+
+  override handleOk(
+    _response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): ProfilingLevel {
+    return this.level;
+  }
+}

package/templates/node_modules/mongodb/src/operations/stats.ts

@@ -0,0 +1,37 @@
+import type { Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import type { Db } from '../db';
+import { CommandOperation, type CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
+
+/** @public */
+export interface DbStatsOptions extends Omit<CommandOperationOptions, 'rawData'> {
+  /** Divide the returned sizes by scale value. */
+  scale?: number;
+}
+
+/** @internal */
+export class DbStatsOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  override options: DbStatsOptions;
+
+  constructor(db: Db, options: DbStatsOptions) {
+    super(db, options);
+    this.options = options;
+  }
+
+  override get commandName() {
+    return 'dbStats' as const;
+  }
+
+  override buildCommandDocument(_connection: Connection): Document {
+    const command: Document = { dbStats: true };
+    if (this.options.scale != null) {
+      command.scale = this.options.scale;
+    }
+    return command;
+  }
+}
+
+defineAspects(DbStatsOperation, [Aspect.READ_OPERATION]);

package/templates/node_modules/mongodb/src/operations/update.ts

@@ -0,0 +1,318 @@
+import type { Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { MongoInvalidArgumentError, MongoServerError } from '../error';
+import type { InferIdType } from '../mongo_types';
+import type { ClientSession } from '../sessions';
+import { formatSort, type Sort, type SortForCmd } from '../sort';
+import {
+  hasAtomicOperators,
+  type MongoDBCollectionNamespace,
+  type MongoDBNamespace
+} from '../utils';
+import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
+import { Aspect, defineAspects, type Hint } from './operation';
+
+/** @public */
+export interface UpdateOptions extends CommandOperationOptions {
+  /** A set of filters specifying to which array elements an update should apply */
+  arrayFilters?: Document[];
+  /** If true, allows the write to opt-out of document level validation */
+  bypassDocumentValidation?: boolean;
+  /** Specifies a collation */
+  collation?: CollationOptions;
+  /** Specify that the update query should only consider plans using the hinted index */
+  hint?: Hint;
+  /** When true, creates a new document if no document matches the query */
+  upsert?: boolean;
+  /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
+  let?: Document;
+}
+
+/**
+ * @public
+ * `TSchema` is the schema of the collection
+ */
+export interface UpdateResult<TSchema extends Document = Document> {
+  /** Indicates whether this write result was acknowledged. If not, then all other members of this result will be undefined */
+  acknowledged: boolean;
+  /** The number of documents that matched the filter */
+  matchedCount: number;
+  /** The number of documents that were modified */
+  modifiedCount: number;
+  /** The number of documents that were upserted */
+  upsertedCount: number;
+  /** The identifier of the inserted document if an upsert took place */
+  upsertedId: InferIdType<TSchema> | null;
+}
+
+/** @public */
+export interface UpdateStatement {
+  /** The query that matches documents to update. */
+  q: Document;
+  /** The modifications to apply. */
+  u: Document | Document[];
+  /**  If true, perform an insert if no documents match the query. */
+  upsert?: boolean;
+  /** If true, updates all documents that meet the query criteria. */
+  multi?: boolean;
+  /** Specifies the collation to use for the operation. */
+  collation?: CollationOptions;
+  /** An array of filter documents that determines which array elements to modify for an update operation on an array field. */
+  arrayFilters?: Document[];
+  /** A document or string that specifies the index to use to support the query predicate. */
+  hint?: Hint;
+  /** Specifies the sort order for the documents matched by the filter. */
+  sort?: SortForCmd;
+}
+
+/**
+ * @internal
+ * UpdateOperation is used in bulk write, while UpdateOneOperation and UpdateManyOperation are only used in the collections API
+ */
+export class UpdateOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  override options: UpdateOptions & { ordered?: boolean };
+  statements: UpdateStatement[];
+
+  constructor(
+    ns: MongoDBNamespace,
+    statements: UpdateStatement[],
+    options: UpdateOptions & { ordered?: boolean }
+  ) {
+    super(undefined, options);
+    this.options = options;
+    this.ns = ns;
+
+    this.statements = statements;
+  }
+
+  override get commandName() {
+    return 'update' as const;
+  }
+
+  override get canRetryWrite(): boolean {
+    if (super.canRetryWrite === false) {
+      return false;
+    }
+
+    return this.statements.every(op => op.multi == null || op.multi === false);
+  }
+
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    const options = this.options;
+    const command: Document = {
+      update: this.ns.collection,
+      updates: this.statements,
+      ordered: options.ordered ?? true
+    };
+
+    if (typeof options.bypassDocumentValidation === 'boolean') {
+      command.bypassDocumentValidation = options.bypassDocumentValidation;
+    }
+
+    if (options.let) {
+      command.let = options.let;
+    }
+
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
+      command.comment = options.comment;
+    }
+
+    return command;
+  }
+}
+
+/** @internal */
+export class UpdateOneOperation extends UpdateOperation {
+  constructor(
+    ns: MongoDBCollectionNamespace,
+    filter: Document,
+    update: Document,
+    options: UpdateOptions
+  ) {
+    super(ns, [makeUpdateStatement(filter, update, { ...options, multi: false })], options);
+
+    if (!hasAtomicOperators(update, options)) {
+      throw new MongoInvalidArgumentError('Update document requires atomic operators');
+    }
+  }
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): UpdateResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain typing is broken
+    if (this.explain != null) return res;
+
+    if (res.code) throw new MongoServerError(res);
+    if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
+
+    return {
+      acknowledged: this.writeConcern?.w !== 0,
+      modifiedCount: res.nModified ?? res.n,
+      upsertedId:
+        Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null,
+      upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0,
+      matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n
+    };
+  }
+}
+
+/** @internal */
+export class UpdateManyOperation extends UpdateOperation {
+  constructor(
+    ns: MongoDBCollectionNamespace,
+    filter: Document,
+    update: Document,
+    options: UpdateOptions
+  ) {
+    super(ns, [makeUpdateStatement(filter, update, { ...options, multi: true })], options);
+
+    if (!hasAtomicOperators(update, options)) {
+      throw new MongoInvalidArgumentError('Update document requires atomic operators');
+    }
+  }
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): UpdateResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain typing is broken
+    if (this.explain != null) return res;
+    if (res.code) throw new MongoServerError(res);
+    if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
+
+    return {
+      acknowledged: this.writeConcern?.w !== 0,
+      modifiedCount: res.nModified ?? res.n,
+      upsertedId:
+        Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null,
+      upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0,
+      matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n
+    };
+  }
+}
+
+/** @public */
+export interface ReplaceOptions extends CommandOperationOptions {
+  /** If true, allows the write to opt-out of document level validation */
+  bypassDocumentValidation?: boolean;
+  /** Specifies a collation */
+  collation?: CollationOptions;
+  /** Specify that the update query should only consider plans using the hinted index */
+  hint?: string | Document;
+  /** When true, creates a new document if no document matches the query */
+  upsert?: boolean;
+  /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
+  let?: Document;
+  /** Specifies the sort order for the documents matched by the filter. */
+  sort?: Sort;
+}
+
+/** @internal */
+export class ReplaceOneOperation extends UpdateOperation {
+  constructor(
+    ns: MongoDBCollectionNamespace,
+    filter: Document,
+    replacement: Document,
+    options: ReplaceOptions
+  ) {
+    super(ns, [makeUpdateStatement(filter, replacement, { ...options, multi: false })], options);
+
+    if (hasAtomicOperators(replacement)) {
+      throw new MongoInvalidArgumentError('Replacement document must not contain atomic operators');
+    }
+  }
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): UpdateResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain typing is broken
+    if (this.explain != null) return res;
+    if (res.code) throw new MongoServerError(res);
+    if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
+
+    return {
+      acknowledged: this.writeConcern?.w !== 0,
+      modifiedCount: res.nModified ?? res.n,
+      upsertedId:
+        Array.isArray(res.upserted) && res.upserted.length > 0 ? res.upserted[0]._id : null,
+      upsertedCount: Array.isArray(res.upserted) && res.upserted.length ? res.upserted.length : 0,
+      matchedCount: Array.isArray(res.upserted) && res.upserted.length > 0 ? 0 : res.n
+    };
+  }
+}
+
+export function makeUpdateStatement(
+  filter: Document,
+  update: Document | Document[],
+  options: UpdateOptions & { multi?: boolean } & { sort?: Sort }
+): UpdateStatement {
+  if (filter == null || typeof filter !== 'object') {
+    throw new MongoInvalidArgumentError('Selector must be a valid JavaScript object');
+  }
+
+  if (update == null || typeof update !== 'object') {
+    throw new MongoInvalidArgumentError('Document must be a valid JavaScript object');
+  }
+
+  const op: UpdateStatement = { q: filter, u: update };
+  if (typeof options.upsert === 'boolean') {
+    op.upsert = options.upsert;
+  }
+
+  if (options.multi) {
+    op.multi = options.multi;
+  }
+
+  if (options.hint) {
+    op.hint = options.hint;
+  }
+
+  if (options.arrayFilters) {
+    op.arrayFilters = options.arrayFilters;
+  }
+
+  if (options.collation) {
+    op.collation = options.collation;
+  }
+
+  if (!options.multi && options.sort != null) {
+    op.sort = formatSort(options.sort);
+  }
+
+  return op;
+}
+
+defineAspects(UpdateOperation, [
+  Aspect.RETRYABLE,
+  Aspect.WRITE_OPERATION,
+  Aspect.SKIP_COLLATION,
+  Aspect.SUPPORTS_RAW_DATA
+]);
+defineAspects(UpdateOneOperation, [
+  Aspect.RETRYABLE,
+  Aspect.WRITE_OPERATION,
+  Aspect.EXPLAINABLE,
+  Aspect.SKIP_COLLATION,
+  Aspect.SUPPORTS_RAW_DATA
+]);
+defineAspects(UpdateManyOperation, [
+  Aspect.WRITE_OPERATION,
+  Aspect.EXPLAINABLE,
+  Aspect.SKIP_COLLATION,
+  Aspect.SUPPORTS_RAW_DATA
+]);
+defineAspects(ReplaceOneOperation, [
+  Aspect.RETRYABLE,
+  Aspect.WRITE_OPERATION,
+  Aspect.SKIP_COLLATION,
+  Aspect.SUPPORTS_RAW_DATA
+]);

package/templates/node_modules/mongodb/src/operations/validate_collection.ts

@@ -0,0 +1,50 @@
+import { type Connection } from '..';
+import type { Admin } from '../admin';
+import { type Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { MongoUnexpectedServerResponseError } from '../error';
+import type { ClientSession } from '../sessions';
+import { CommandOperation, type CommandOperationOptions } from './command';
+
+/** @public */
+export interface ValidateCollectionOptions extends Omit<CommandOperationOptions, 'rawData'> {
+  /** Validates a collection in the background, without interrupting read or write traffic (only in MongoDB 4.4+) */
+  background?: boolean;
+}
+
+/** @internal */
+export class ValidateCollectionOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  override options: ValidateCollectionOptions;
+  collectionName: string;
+
+  constructor(admin: Admin, collectionName: string, options: ValidateCollectionOptions) {
+    super(admin.s.db, options);
+    this.options = options;
+    this.collectionName = collectionName;
+  }
+
+  override get commandName() {
+    return 'validate' as const;
+  }
+
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    // Decorate command with extra options
+    return {
+      validate: this.collectionName,
+      ...Object.fromEntries(Object.entries(this.options).filter(entry => entry[0] !== 'session'))
+    };
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    const result = super.handleOk(response);
+    if (result.result != null && typeof result.result !== 'string')
+      throw new MongoUnexpectedServerResponseError('Error with validation data');
+    if (result.result != null && result.result.match(/exception|corrupt/) != null)
+      throw new MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`);
+    if (result.valid != null && !result.valid)
+      throw new MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`);
+
+    return response;
+  }
+}

package/templates/node_modules/mongodb/src/read_concern.ts

@@ -0,0 +1,88 @@
+import type { Document } from './bson';
+
+/** @public */
+export const ReadConcernLevel = Object.freeze({
+  local: 'local',
+  majority: 'majority',
+  linearizable: 'linearizable',
+  available: 'available',
+  snapshot: 'snapshot'
+} as const);
+
+/** @public */
+export type ReadConcernLevel = (typeof ReadConcernLevel)[keyof typeof ReadConcernLevel];
+
+/** @public */
+export type ReadConcernLike = ReadConcern | { level: ReadConcernLevel } | ReadConcernLevel;
+
+/**
+ * The MongoDB ReadConcern, which allows for control of the consistency and isolation properties
+ * of the data read from replica sets and replica set shards.
+ * @public
+ *
+ * @see https://www.mongodb.com/docs/manual/reference/read-concern/index.html
+ */
+export class ReadConcern {
+  level: ReadConcernLevel | string;
+
+  /** Constructs a ReadConcern from the read concern level.*/
+  constructor(level: ReadConcernLevel) {
+    /**
+     * A spec test exists that allows level to be any string.
+     * "invalid readConcern with out stage"
+     * @see ./test/spec/crud/v2/aggregate-out-readConcern.json
+     * @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.md#unknown-levels-and-additional-options-for-string-based-readconcerns
+     */
+    this.level = ReadConcernLevel[level] ?? level;
+  }
+
+  /**
+   * Construct a ReadConcern given an options object.
+   *
+   * @param options - The options object from which to extract the write concern.
+   */
+  static fromOptions(options?: {
+    readConcern?: ReadConcernLike;
+    level?: ReadConcernLevel;
+  }): ReadConcern | undefined {
+    if (options == null) {
+      return;
+    }
+
+    if (options.readConcern) {
+      const { readConcern } = options;
+      if (readConcern instanceof ReadConcern) {
+        return readConcern;
+      } else if (typeof readConcern === 'string') {
+        return new ReadConcern(readConcern);
+      } else if ('level' in readConcern && readConcern.level) {
+        return new ReadConcern(readConcern.level);
+      }
+    }
+
+    if (options.level) {
+      return new ReadConcern(options.level);
+    }
+    return;
+  }
+
+  static get MAJORITY(): 'majority' {
+    return ReadConcernLevel.majority;
+  }
+
+  static get AVAILABLE(): 'available' {
+    return ReadConcernLevel.available;
+  }
+
+  static get LINEARIZABLE(): 'linearizable' {
+    return ReadConcernLevel.linearizable;
+  }
+
+  static get SNAPSHOT(): 'snapshot' {
+    return ReadConcernLevel.snapshot;
+  }
+
+  toJSON(): Document {
+    return { level: this.level };
+  }
+}