nongo-driver 3.3.17 → 3.3.19

package/src/atlas-api.ts

@@ -1,120 +1,305 @@
 import deepEqual from 'deep-equal';
-import rp from 'request-promise';
+import { request } from 'undici';
+import crypto from 'node:crypto';
 import Logger from 'wbb-logger';
-import {Analyzer, AtlasParams, AtlasSearchIndex, CreateSearchIndex} from './interface/atlas';
+import { Analyzer, AtlasParams, AtlasSearchIndex, CreateSearchIndex } from './interface/atlas';
 
 const logger = new Logger('atlas-api.ts');
 
-export default class AtlasApi {
+type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+
+function md5(input: string) {
+  return crypto.createHash('md5').update(input).digest('hex');
+}
+
+function randomHex(bytes = 16) {
+  return crypto.randomBytes(bytes).toString('hex');
+}
+
+function parseWwwAuthenticate(header: string) {
+  // Expects something like: Digest realm="...", nonce="...", qop="auth", opaque="...", algorithm=MD5
+  // We’ll parse key="value" pairs.
+  const schemeMatch = header.match(/^\s*Digest\s+/i);
+  if (!schemeMatch) return null;
+
+  const params: Record<string, string> = {};
+  const rest = header.replace(/^\s*Digest\s+/i, '');
+
+  // Split by commas not inside quotes
+  const parts = rest.match(/([a-z0-9_-]+)=(?:"[^"]*"|[^,]*)/gi) ?? [];
+  for (const part of parts) {
+    const idx = part.indexOf('=');
+    const k = part.slice(0, idx).trim();
+    let v = part.slice(idx + 1).trim();
+    if (v.startsWith('"') && v.endsWith('"')) v = v.slice(1, -1);
+    params[k] = v;
+  }
+  return params;
+}
+
+function buildDigestAuthHeader(opts: {
+  username: string;
+  password: string;
+  method: string;
+  uri: string; // path + query, not full URL
+  challenge: Record<string, string>;
+  nc: number;
+  cnonce: string;
+}) {
+  const { username, password, method, uri, challenge, nc, cnonce } = opts;
+
+  const realm = challenge.realm ?? '';
+  const nonce = challenge.nonce ?? '';
+  const qopRaw = challenge.qop ?? '';
+  const opaque = challenge.opaque;
+  const algorithm = (challenge.algorithm ?? 'MD5').toUpperCase();
 
+  // We implement the common case Atlas uses: MD5 + qop=auth
+  // If qop has multiple values, pick auth if present.
+  const qop = qopRaw
+    .split(',')
+    .map((s) => s.trim())
+    .find((v) => v === 'auth') ?? (qopRaw ? qopRaw.split(',')[0].trim() : undefined);
+
+  if (algorithm !== 'MD5') {
+    // Atlas is typically MD5; if it ever changes, you’ll want to extend this.
+    throw new Error(`Unsupported digest algorithm: ${algorithm}`);
+  }
+
+  const ha1 = md5(`${username}:${realm}:${password}`);
+  const ha2 = md5(`${method}:${uri}`);
+
+  const ncHex = nc.toString(16).padStart(8, '0');
+
+  let response: string;
+  if (qop) {
+    response = md5(`${ha1}:${nonce}:${ncHex}:${cnonce}:${qop}:${ha2}`);
+  } else {
+    // RFC legacy
+    response = md5(`${ha1}:${nonce}:${ha2}`);
+  }
+
+  const pieces: string[] = [];
+  pieces.push(`username="${username}"`);
+  pieces.push(`realm="${realm}"`);
+  pieces.push(`nonce="${nonce}"`);
+  pieces.push(`uri="${uri}"`);
+  pieces.push(`response="${response}"`);
+
+  if (opaque) pieces.push(`opaque="${opaque}"`);
+  if (algorithm) pieces.push(`algorithm=${algorithm}`);
+
+  if (qop) {
+    pieces.push(`qop=${qop}`);
+    pieces.push(`nc=${ncHex}`);
+    pieces.push(`cnonce="${cnonce}"`);
+  }
+
+  return `Digest ${pieces.join(', ')}`;
+}
+
+export default class AtlasApi {
   private readonly ftsUrl: string;
-  private readonly defaultOptions;
+
+  // digest state
+  private nonceCountByNonce = new Map<string, number>();
+  private lastChallenge: Record<string, string> | null = null;
 
   constructor(private params: AtlasParams) {
-    const {baseUrl, groupId, clusterName, publicKey, privateKey} = params;
-
-    this.defaultOptions = {
-      auth: {
-        user: publicKey,
-        pass: privateKey,
-        sendImmediately: false,
-      },
-      json: true,
+    const { baseUrl, groupId, clusterName } = params;
+    this.ftsUrl = `${baseUrl}/groups/${groupId}/clusters/${clusterName}/fts`;
+  }
+
+  private async digestJsonRequest<T>(method: HttpMethod, url: string, body?: unknown): Promise<T> {
+    const { publicKey, privateKey } = this.params;
+
+    const headers: Record<string, string> = {
+      accept: 'application/json',
     };
 
-    this.ftsUrl = `${baseUrl}/groups/${groupId}/clusters/${clusterName}/fts`;
+    let requestBody: string | undefined;
+    if (body !== undefined) {
+      headers['content-type'] = 'application/json';
+      requestBody = JSON.stringify(body);
+    }
+
+    // 1) Try with cached digest challenge if we have one (avoids an extra 401 round-trip)
+    const tryOnce = async (authHeader?: string) => {
+      const h = authHeader ? { ...headers, authorization: authHeader } : headers;
+
+      const res = await request(url, { method, headers: h, body: requestBody });
+      const contentType = (res.headers['content-type'] ?? '').toString();
+      const raw = await res.body.text();
+
+      return { res, contentType, raw };
+    };
+
+    // If we already have a challenge cached, attempt auth immediately
+    if (this.lastChallenge?.nonce) {
+      const challenge = this.lastChallenge;
+      const nonce = challenge.nonce;
+      const nc = (this.nonceCountByNonce.get(nonce) ?? 0) + 1;
+      this.nonceCountByNonce.set(nonce, nc);
+
+      const u = new URL(url);
+      const uri = `${u.pathname}${u.search}`; // must be path+query for digest
+
+      const auth = buildDigestAuthHeader({
+        username: publicKey,
+        password: privateKey,
+        method,
+        uri,
+        challenge,
+        nc,
+        cnonce: randomHex(8),
+      });
+
+      const attempt = await tryOnce(auth);
+      if (attempt.res.statusCode !== 401) {
+        return this.handleResponse<T>(method, url, attempt.res.statusCode, attempt.contentType, attempt.raw);
+      }
+      // fall through and re-challenge below
+    }
+
+    // 2) No cached challenge (or cached failed). Make an unauthenticated request to get WWW-Authenticate
+    const first = await tryOnce(undefined);
+
+    if (first.res.statusCode !== 401) {
+      return this.handleResponse<T>(method, url, first.res.statusCode, first.contentType, first.raw);
+    }
+
+    const wwwAuth = first.res.headers['www-authenticate'];
+    const wwwAuthStr = Array.isArray(wwwAuth) ? wwwAuth.join(', ') : (wwwAuth ?? '').toString();
+
+    const challenge = parseWwwAuthenticate(wwwAuthStr);
+    if (!challenge?.nonce) {
+      const err = new Error(`401 from Atlas but no Digest challenge found in WWW-Authenticate header`);
+      (err as any).statusCode = 401;
+      (err as any).wwwAuthenticate = wwwAuthStr;
+      throw err;
+    }
+
+    // cache challenge for next requests
+    this.lastChallenge = challenge;
+
+    const nonce = challenge.nonce;
+    const nc = (this.nonceCountByNonce.get(nonce) ?? 0) + 1;
+    this.nonceCountByNonce.set(nonce, nc);
+
+    const u = new URL(url);
+    const uri = `${u.pathname}${u.search}`;
+
+    const auth = buildDigestAuthHeader({
+      username: publicKey,
+      password: privateKey,
+      method,
+      uri,
+      challenge,
+      nc,
+      cnonce: randomHex(8),
+    });
+
+    // 3) Retry with Digest Authorization
+    const second = await tryOnce(auth);
+    return this.handleResponse<T>(method, url, second.res.statusCode, second.contentType, second.raw);
+  }
+
+  private handleResponse<T>(
+    method: string,
+    url: string,
+    statusCode: number,
+    contentType: string,
+    raw: string,
+  ): T {
+    if (statusCode < 200 || statusCode >= 300) {
+      let parsed: any = raw;
+      if (contentType.includes('application/json')) {
+        try {
+          parsed = raw ? JSON.parse(raw) : null;
+        } catch {
+          // keep raw
+        }
+      }
+
+      const err = new Error(`Atlas API request failed: ${method} ${url} -> ${statusCode}`) as any;
+      err.statusCode = statusCode;
+      err.body = parsed;
+      throw err;
+    }
+
+    if (!raw) return undefined as unknown as T;
+    if (contentType.includes('application/json')) return JSON.parse(raw) as T;
+    return raw as unknown as T;
   }
 
   public async putCustomAnalyzers(analyzers: Analyzer[]): Promise<Analyzer[]> {
     const url = `${this.ftsUrl}/analyzers`;
-    return rp({
-      ...this.defaultOptions,
-      url,
-      body: analyzers,
-    });
+    // Keep whatever your API expects. Many Atlas endpoints use PUT for replacement semantics.
+    return this.digestJsonRequest<Analyzer[]>('PUT', url, analyzers);
   }
 
   public async getSearchIndexes(db: string, collection: string): Promise<AtlasSearchIndex[]> {
     const url = `${this.ftsUrl}/indexes/${db}/${collection}`;
-    return rp({
-      ...this.defaultOptions,
-      url,
-    });
+    return this.digestJsonRequest<AtlasSearchIndex[]>('GET', url);
   }
 
   public async createSearchIndex(db: string, collection: string, index: CreateSearchIndex): Promise<any> {
     this.logIndexChange(db, collection, 'Creating', index.name);
     const url = `${this.ftsUrl}/indexes`;
-    return rp({
-      ...this.defaultOptions,
-      method: 'POST',
-      url,
-      body: {
-        collectionName: collection,
-        database: db,
-        ...index,
-      },
+    return this.digestJsonRequest<any>('POST', url, {
+      collectionName: collection,
+      database: db,
+      ...index,
     });
   }
 
-  public async ensureSearchIndexes(db: string, collection: string, createParams: CreateSearchIndex[]): Promise<AtlasSearchIndex[]> {
+  public async ensureSearchIndexes(db: string, collection: string, createParams: CreateSearchIndex[]) {
     const existingIndexes = await this.getSearchIndexes(db, collection);
     const toRemove = new Map<string, AtlasSearchIndex>();
     existingIndexes.forEach((e) => toRemove.set(e.name, e));
 
     for (const cParams of createParams) {
-      const {name} = cParams;
-      const existing = toRemove.get(name);
-
+      const existing = toRemove.get(cParams.name);
       if (existing) {
-        toRemove.delete(name);
+        toRemove.delete(cParams.name);
         await this.updateSearchIndex(db, collection, existing, cParams);
       } else {
         await this.createSearchIndex(db, collection, cParams);
       }
-
     }
 
     for (const index of toRemove.values()) {
       await this.deleteSearchIndex(db, collection, index);
     }
 
-    return await this.getSearchIndexes(db, collection);
+    return this.getSearchIndexes(db, collection);
   }
 
-  public async updateSearchIndex(db: string, collection: string, existingIndex: AtlasSearchIndex, createParams: CreateSearchIndex): Promise<any> {
-    if (deepEqual(existingIndex.mappings, createParams.mappings)) {
-      return;
-    }
+  public async updateSearchIndex(
+    db: string,
+    collection: string,
+    existingIndex: AtlasSearchIndex,
+    createParams: CreateSearchIndex,
+  ): Promise<any> {
+    if (deepEqual(existingIndex.mappings, createParams.mappings)) return;
 
     this.logIndexChange(db, collection, 'Updating', createParams.name);
-
     const url = `${this.ftsUrl}/indexes/${existingIndex.indexID}`;
 
-    return rp({
-      ...this.defaultOptions,
-      method: 'PATCH',
-      url,
-      body: {
-        collectionName: collection,
-        database: db,
-        ...createParams,
-      },
+    return this.digestJsonRequest<any>('PATCH', url, {
+      collectionName: collection,
+      database: db,
+      ...createParams,
     });
   }
 
   public async deleteSearchIndex(db: string, collection: string, existingIndex: AtlasSearchIndex): Promise<any> {
     this.logIndexChange(db, collection, 'Deleting', existingIndex.name);
     const url = `${this.ftsUrl}/indexes/${existingIndex.indexID}`;
-    return rp({
-      ...this.defaultOptions,
-      method: 'DELETE',
-      url,
-    });
+    return this.digestJsonRequest<any>('DELETE', url);
   }
 
   private logIndexChange(db: string, collection: string, action: string, indexName: string) {
     logger.info(`${action} search index "${indexName}" for collection ${db}.${collection}`);
   }
-
 }

package/src/interface/atlas/index.ts

@@ -14,6 +14,7 @@ export interface AtlasSearchIndex {
   mappings: Mappings;
   name: string;
   status: string;
+  synonyms: string[];
 }
 
 export interface Analyzer {

package/src/model.ts

@@ -22,9 +22,9 @@ import {CreateSearchIndex} from './interface';
 import MongoIndex from './mongo-index';
 import Nongo from './nongo';
 import Validator from './validator';
-import { ICache } from './cache';
+import {ICache} from './cache';
 
-import crypto from "crypto";
+import crypto from 'crypto';
 
 const DEFAULT_PATHS = ['_id', 'revision', 'history', 'diffs'];
 
@@ -36,7 +36,6 @@ function excludePathsFromDiff(diff, excludedPaths = DEFAULT_PATHS) {
   });
 }
 
-
 export default abstract class Model<
   T extends {
     _id?: ObjectId;
@@ -63,12 +62,16 @@ export default abstract class Model<
   private collectionRevision: string | null;
   private collectionEnvironmentMapping: string | null;
 
-  constructor(public nongo: Nongo, public obj: T, public cacheObject?: ICache) {
+  constructor(
+    public nongo: Nongo,
+    public obj: T,
+    public cacheObject?: ICache,
+  ) {
     // Set this.db if nongo given
     if (nongo) {
       this.db = nongo.db;
     }
-    if ( cacheObject ) { 
+    if (cacheObject) {
       this.cache = cacheObject;
     }
 
@@ -165,9 +168,8 @@ export default abstract class Model<
       // Get id of newest revision, so we can use that to find the appropriate mapping
       // this is in case the object we're trying to save either doesn't have _id (for example if it's being imported)
       // or if the _id simply isn't correct for the environment
-      const {revision, newestRevisionId} = await this.getLatestRevisionNumber(
-        revisionQuery,
-      );
+      const {revision, newestRevisionId} =
+        await this.getLatestRevisionNumber(revisionQuery);
       this.obj.previousRevision = this.obj.revision;
       this.obj.revision = revision;
       // needed to create a new environment mapping
@@ -207,7 +209,9 @@ export default abstract class Model<
           .insertOne(this.obj);
         insertedRevisionId = r.insertedId.toHexString();
       }
-      if (this.obj.revision !== 1) {
+      if (this.obj.deleted) {
+        await this.removeEnvironmentMapping(environmentId, newestRevisionId, insertedRevisionId);
+      } else if (this.obj.revision !== 1) {
         // update relevant mappings
         await this.updateEnvironmentMapping(
           insertedRevisionId,
@@ -215,8 +219,7 @@ export default abstract class Model<
           environmentId,
           clientEnv.isLive,
         );
-      }
-      if (this.obj.revision === 1) {
+      } else if (this.obj.revision === 1) {
         // latest revision id, as that's what we just inserted, and need to save as baseline
         await this.createEnvironmentMapping(
           environmentId,
@@ -224,9 +227,6 @@ export default abstract class Model<
           clientEnv.isLive,
         );
       }
-      if (this.obj.deleted) {
-        await this.removeEnvironmentMapping(environmentId, newestRevisionId);
-      }
     } else {
       // Upsert non revision models
       await this.db
@@ -234,7 +234,7 @@ export default abstract class Model<
         .replaceOne({_id: this.obj._id}, this.obj, {upsert: true});
     }
 
-    this.invalidateCache({ _id : this.obj._id });
+    this.invalidateCache({_id: this.obj._id});
 
     // Return the saved model
     return this;
@@ -243,11 +243,15 @@ export default abstract class Model<
   private async removeEnvironmentMapping(
     environmentId: string,
     latestRevisionId: string,
+    newRevisionId: string,
   ): Promise<void> {
     const path = `environments.${environmentId}`;
     await this.db
       .collection(this.collectionEnvironmentMapping)
-      .updateOne({latestRevisionId}, {$unset: {[path]: ''}});
+      .updateOne(
+        {latestRevisionId},
+        {$unset: {[path]: ''}, $set: {latestRevisionId: newRevisionId}},
+      );
   }
 
   private async createEnvironmentMapping(
@@ -491,9 +495,9 @@ export default abstract class Model<
     );
   }
 
-  private getCacheKey(query: Filter<Document>, operation: string ): string {
+  private getCacheKey(query: Filter<Document>, operation: string): string {
     const q = JSON.stringify(query, Object.keys(query).sort()); // stable stringify
-    const hash = crypto.createHash("md5").update(q).digest("hex"); // short key
+    const hash = crypto.createHash('md5').update(q).digest('hex'); // short key
     return `${this.db.databaseName}:${this.collection}:${operation}:${hash}`;
   }
 
@@ -530,7 +534,7 @@ export default abstract class Model<
   public async findOne(query: Filter<Document> = {}): Promise<this> {
     query = this.prepareQuery(query);
 
-    const cacheKey = this.getCacheKey(query, "findOne");
+    const cacheKey = this.getCacheKey(query, 'findOne');
 
     // Check cache
     if (this.useCache && this.cache.has(cacheKey)) {

package/test/atlas-api.test.ts

@@ -4,21 +4,21 @@ import {AtlasParams, AtlasSearchIndex, CreateSearchIndex} from '../src/interface
 import {setUpInterceptors} from './atlas-api-nock';
 
 const groupId = '5b06b6b34e658110696b1da3';
-const clusterName = 'wbb-stage';
+const clusterName = 'wbb-staging';
 const collectionName = 'Entity';
-const database = 'monmouth-county-council';
+const database = 'afeltham';
 
 const params: AtlasParams = {
   groupId,
   baseUrl: 'https://cloud.mongodb.com/api/atlas/v1.0',
-  publicKey: 'aPublicKey',
-  privateKey: 'aPrivateKey',
+  publicKey: 'pfkjhdxk',
+  privateKey: '37bed739-c794-4dec-bd52-90fb4f1bd1cd',
   clusterName,
 };
 
 it('Search index management', async () => {
 
-  setUpInterceptors();
+  // setUpInterceptors();
 
   const createIndex = (name: string): CreateSearchIndex => ({
     mappings: {dynamic: true},
@@ -35,18 +35,20 @@ it('Search index management', async () => {
     {
       collectionName,
       database,
-      indexID: '606c53edf81dfe4a33b5caeb',
+      indexID: '6961209db2890435699787f5',
       mappings: {dynamic: true},
       name: 'index1',
-      status: 'IN_PROGRESS',
+      status: 'STEADY',
+      "synonyms": [],
     },
     {
       collectionName,
       database,
-      indexID: '606c53ed4012d1669a8bbeed',
+      indexID: '696120a1b289043569978f80',
       mappings: {dynamic: true},
       name: 'index2',
-      status: 'IN_PROGRESS',
+      status: 'STEADY',
+      "synonyms": [],
     },
   ];
   expect(firstEnsure).toStrictEqual(firstExpected);
@@ -59,4 +61,4 @@ it('Search index management', async () => {
   // Instead just make sure all the interceptors were used
   expect(nock.isDone());
 
-});
+}, 10000);

package/test/database-helper.ts

@@ -11,7 +11,9 @@ let mongoMemoryServer: MongoMemoryServer;
 const getInMemoryServer = async () => {
   if (!mongoMemoryServer) {
     logger.info("Using in memory server.");
-    mongoMemoryServer = await MongoMemoryServer.create();
+    mongoMemoryServer = await MongoMemoryServer.create({
+      binary: {version: "6.0.6"},
+    });
   }
   return mongoMemoryServer;
 };

package/test/model-versioning.test.ts

@@ -69,8 +69,8 @@ describe('Testing nongo revisioning', () => {
     expect(models.length).toEqual(2);
   })
 
-  it('Should revert to revision 0.0.1', async () => {
-    const revision = await nongo.col(DummyModelWithRevision).getRevision({name: "John", revision: "0.0.1"});
+  it('Should revert to revision 1', async () => {
+    const revision = await nongo.col(DummyModelWithRevision).getRevision({name: "John", revision: 1});
     expect(revision.obj.revision).toEqual("0.0.1");
     const model = await nongo.col(DummyModelWithRevision).findOne({name: 'Nick'});
     const latestDoc = await nongo.col(DummyModelWithRevision).revertVersion(model.obj._id);

package/test/models/dummy-model-changed-obj.ts

@@ -0,0 +1,12 @@
+// This file was generated using nongo-driver's TsInterfaceGenerator.
+export default interface DummyModelChangedObj {
+  'name': string;
+  'pets': Array<{
+    'species'?: string;
+    'likes'?: {
+      'food'?: string[];
+      'drink'?: string[];
+    };
+  }>;
+  '_id'?: any;
+}

package/test/models/dummy-model-obj.ts

@@ -0,0 +1,40 @@
+// This file was generated using nongo-driver's TsInterfaceGenerator.
+export default interface DummyModelObj {
+  'dontStripChildren'?: any;
+  'dontStripChildren2'?: any;
+  'exampleMap'?: {[key: string]: {
+    'mapValueField': string;
+  }};
+  'created'?: Date;
+  'arrayOfObject'?: object[];
+  'name': string;
+  'age': number;
+  'pets': Array<{
+    'species'?: string;
+    'likes'?: {
+      'food'?: string[];
+      'drink'?: string[];
+    };
+  }>;
+  'job': {
+    'role': string;
+    'at'?: string;
+  };
+  'location'?: {
+    'address1'?: string;
+  };
+  'autoInit': {
+    'initArray': Array<{
+      'nestedObj': any;
+    }>;
+    'initNestedObj'?: {
+      'hello'?: string;
+    };
+    'initNestedNative'?: any;
+  };
+  'notEmptyFields'?: {
+    'aString': string;
+    'anArray': string[];
+  };
+  '_id'?: any;
+}