mongodb#Collection TypeScript Examples

/**
 * Gets mongo collection object by name
 * @param collectionName Name of collection to retreive
 * @returns Mongo collection object
 */
function getCollection(collectionName: string): Promise<Collection<any>> {
    return new Promise(async (resolve, reject) => {
        try {
            await getDB();
        }
        catch (e) {
            if (process.env.NODE_ENV == 'production') {
                reject(e);
            }
            else {
                resolve(null!);
            }
            return;
        }
        // check if collection exists
        db.listCollections({ name: collectionName })
            .next(function (err, collection) {
                if (err) reject(err);
                if (collection) {
                    resolve(db.collection(collectionName)!);
                }
                else {
                    reject(`Collection ${collectionName} does not exist!`);
                }
            });
    });
}

MongoHelper = {
  client: null as MongoClient,
  uri: null as string,

  async connect (uri: string): Promise<void> {
    this.uri = uri
    this.client = await MongoClient.connect(uri)
  },

  async disconnect (): Promise<void> {
    await this.client.close()
    this.client = null
  },

  getCollection (name: string): Collection {
    return this.client.db().collection(name)
  },

  map: (data: any): any => {
    const { _id, ...rest } = data
    return { ...rest, id: _id.toHexString() }
  },

  mapCollection: (collection: any[]): any[] => {
    return collection.map(c => MongoHelper.map(c))
  }
}

export async function configureIndexesForCollection(collection: Collection, specs: MongoIndexSpec[]) {
  // ensure indexes have a name

  specs
    .filter(spec => !spec.options?.name)
    .forEach(spec => {
      spec.options = {
        ...spec.options,
        name: computeIndexName(spec.fieldOrSpec),
      };
    });

  // create indexes that don't already exist, or modify them

  await Promise.all(
    specs.map(spec => createIndexIfNotExists(spec, collection)),
  );

  // drop indexes that do not exist anymore

  const existingIndexes: IndexSpecification[] = await collection.listIndexes().toArray();
  const indexesToDrop = existingIndexes
    .filter(index => index.name !== '_id_')
    .filter(index => specs.every(spec => spec.options.name !== index.name));

  await Promise.all(
    indexesToDrop.map(({ name }) => {
      logger.info(`Dropping index ${chalk.bold(name)}`);
      return collection.dropIndex(name);
    }),
  );
}

async function createIndexIfNotExists(spec: MongoIndexSpec, collection: Collection) {
  const indexName = spec.options.name;
  const indexNamespace = `${chalk.blue(collection.collectionName)}.${chalk.cyan(indexName)}`;

  const createIndex = () => collection.createIndex(spec.fieldOrSpec, spec.options);

  try {
    await createIndex();
    logger.debug(`Configured index ${indexNamespace}`);
  } catch (e) {
    if (
      e instanceof MongoError
      && (
        e.code === MongoErrorCode.INDEX_OPTIONS_CONFLICT
        || e.code === MongoErrorCode.INDEX_KEY_SPECS_CONFLICT
      )
    ) {
      logger.debug(`Updating index ${indexNamespace}`);

      const existingIndexes: IndexSpecification[] = await collection.listIndexes().toArray();
      const indexWithSameName = existingIndexes.find(value => value.name === spec.options.name);
      if (indexWithSameName) {
        await collection.dropIndex(indexName);
      } else {
        const indexWithSameKey = findIndexWithSameKey(existingIndexes, spec.fieldOrSpec);
        await collection.dropIndex(indexWithSameKey.name);
      }

      logger.debug(`Updated index ${indexNamespace}`);

      await createIndex();
    } else {
      throw e;
    }
  }
}

public playersCollection: Collection<Player<ObjectId>>;

public configCollection: Collection<Config<ObjectId>>;

getMemberContext = (): Collection<Member> => {
  const db = getDBInstance();
  return db.collection<Member>('members');
}

public sessionsCollection: Collection<Session<ObjectId>>;

public gameCorrectionsCollection: Collection<GameCorrection<ObjectId>>;

public gamesCollection: Collection<GameResult<ObjectId>>;

public userCollection: Collection<User<ObjectId>>;

public contestCollection: Collection<Contest<ObjectId>>;

accountCollection: Collection

surveyCollection: Collection

accountCollection: Collection

surveyCollection: Collection

accountCollection: Collection

accountCollection: Collection

surveyCollection: Collection

accountCollection: Collection

surveyCollection: Collection

accountCollection: Collection

accountCollection: Collection

surveyResultCollection: Collection

surveyCollection: Collection

accountCollection: Collection

surveyResultCollection: Collection

surveyCollection: Collection

errorCollection: Collection