working search for simple dates (local date regex)

hkong-mitre · hkong-mitre · commit 953250df475b · 2025-09-24T21:01:13.000-04:00
diff --git a/src/search/SearchQueryBuilder.test.unit.ts b/src/search/SearchQueryBuilder.test.unit.ts
@@ -110,6 +110,7 @@ describe(`SearchQueryBuilder`, () => {
       metadataOnly: true
     }],
     [`CAPEC-64`, { default_operator: 'OR' }],
+    [`2023-12-21`, { track_total_hits: true }],
   ]
   testCases.forEach((test: [string, Partial<SearchOptions>]) => {
     it(`(${test[0]},${JSON.stringify(test[1])})..buildQuery() correctly returns the expected query`, async () => {
diff --git a/src/search/SearchQueryBuilder.ts b/src/search/SearchQueryBuilder.ts
@@ -2,20 +2,35 @@ import { CveResult } from '../result/CveResult.js';
 import { SearchOptions } from './BasicSearchManager.js';
 import { SearchRequest } from './SearchRequest.js';
 
+
 /**
  * a search query builder that analyzes a user's search text and builds a proper search query
  *  for OpenSearch
  */
 export class SearchQueryBuilder {
 
   /** default number of results to return when not specified */
-  static kDefaultNumResults = 25
+  static kDefaultNumResults = 25;
+
+  /** the JSON paths to CVE fields that are of the date type */
+  static kDateFieldPaths = [
+    'cveMetadata.datePublished',
+    'cveMetadata.dateRejected',
+    'cveMetadata.dateReserved',
+    'cveMetadata.dateUpdated',
+    'containers.cna.datePublic',
+    'containers.cna.providerMetadata.dateUpdated',
+    'containers.cna.timeline.time',
+    'containers.adp.metrics.other.content.dateAdded',
+    'containers.adp.metrics.other.content.timestamp',
+    'containers.adp.providerMetadata.dateUpdated'
+  ];
 
   /** the user entered text */
   _searchText: string;
 
   /** search options when validating input and building query string */
-  _searchOptions: SearchOptions
+  _searchOptions: SearchOptions;
 
   /** the searchRequest based on the search term(s) from the user */
   _searchRequest: SearchRequest;
@@ -44,9 +59,9 @@ export class SearchQueryBuilder {
     if (this._searchOptions.size < this._searchOptions.from) {
       this._searchOptions.size = this._searchOptions.from + 1;
     }
-    this._searchRequest = new SearchRequest(searchText)
+    this._searchRequest = new SearchRequest(searchText);
   }
-  
+
 
   /** builds the proper query for openSearch */
   buildQuery(): CveResult {
@@ -61,25 +76,56 @@ export class SearchQueryBuilder {
     let q = {
       query: {}
     };
-    // ----- query_string
-    q.query['query_string'] = {
-      query: `${this._searchText}`,
-      default_operator: this._searchOptions.default_operator
-    };
 
-    // ----- _source, which specifies which CVE fields are to be returned
-    const source: string[] = [];
-    if (this._searchOptions.metadataOnly) {
-      source.push("cveMetadata", "containers.cna.descriptions.value");
-    }
-    if (source.length > 0) {
-      q['_source'] = source;
+    // right now, we only handle 2 types of queries: 
+    //  1. date/date ranges
+    //  2. query_string for everything else
+    const isDate = SearchRequest.isDateString(this._searchText);
+    if (isDate) {
+      // assemble all the date fields into an array
+      let dateFields = [];
+      SearchQueryBuilder.kDateFieldPaths.map(path => {
+        let field = `{
+          "range": {
+            "${path}": {
+              "gte": "${this._searchText}"
+            }
+          }
+        }`;
+        dateFields.push(JSON.parse(field));
+      });
+      console.log(`dateFields:  ${JSON.stringify(dateFields, null, 2)}`);
+      q = {
+        query: {
+          bool: {
+            should: dateFields,
+            minimum_should_match: 1
+          }
+        }
+      };
     }
-    // ----- search only in fields
-    if (this._searchOptions.fields) {
-      source.push(...this._searchOptions.fields);
+    else {
+      q = {
+        query: {
+          query_string: {
+            query: this._searchText,
+            default_operator: this._searchOptions.default_operator
+          }
+        }
+      };
+      // ----- _source, which specifies which CVE fields are to be returned
+      const source: string[] = [];
+      if (this._searchOptions.metadataOnly) {
+        source.push("cveMetadata", "containers.cna.descriptions.value");
+      }
+      if (source.length > 0) {
+        q['_source'] = source;
+      }
+      // ----- search only in fields
+      if (this._searchOptions.fields) {
+        source.push(...this._searchOptions.fields);
+      }
     }
-
     // console.log(`***${JSON.stringify(q, null, 2)}`)
     // ----- track_total_hits
     if (this._searchOptions.track_total_hits) {
diff --git a/src/search/SearchRequest.ts b/src/search/SearchRequest.ts
@@ -50,7 +50,7 @@ export type SearchRequestTypeId = Extract<keyof typeof SearchRequestType, string
 //   'OPENSEARCH_OPS': `only in opensearch_ops field (generated at upsertion)`
 // } as const
 
-export type QueryType = "query_string" | "date_range"; //| "phrase"
+// export type QueryType = "query_string" | "date_range"; //| "phrase"
 
 
 /** SearchRequest has 2 goals:
@@ -460,6 +460,9 @@ export class SearchRequest {
     else if (SearchRequest.isQuotedString(searchText)) {
       return 'SEARCH_PHRASE';
     }
+    else if (SearchRequest.isDateString(searchText)) {
+      return 'SEARCH_DATE';
+    }
     else if (searchText.includes('*')) {
       return 'SEARCH_AS_WILDCARD_ASTERISK'
     }
diff --git a/src/search/__snapshots__/SearchQueryBuilder.test.unit.ts.snap b/src/search/__snapshots__/SearchQueryBuilder.test.unit.ts.snap
@@ -95,6 +95,109 @@ CveResult {
 }
 `;
 
+exports[`SearchQueryBuilder (2023-12-21,{"track_total_hits":true})..buildQuery() correctly returns the expected query 1`] = `
+CveResult {
+  "data": Object {
+    "processedSearchText": "2023-12-21",
+    "q": Object {
+      "from": 0,
+      "query": Object {
+        "bool": Object {
+          "minimum_should_match": 1,
+          "should": Array [
+            Object {
+              "range": Object {
+                "cveMetadata.datePublished": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "cveMetadata.dateRejected": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "cveMetadata.dateReserved": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "cveMetadata.dateUpdated": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "containers.cna.datePublic": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "containers.cna.providerMetadata.dateUpdated": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "containers.cna.timeline.time": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "containers.adp.metrics.other.content.dateAdded": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "containers.adp.metrics.other.content.timestamp": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+            Object {
+              "range": Object {
+                "containers.adp.providerMetadata.dateUpdated": Object {
+                  "gte": "2023-12-21",
+                },
+              },
+            },
+          ],
+        },
+      },
+      "size": 25,
+      "sort": Array [
+        Object {
+          "cveMetadata.cveId.keyword": Object {
+            "order": "desc",
+          },
+        },
+      ],
+      "track_total_hits": true,
+    },
+    "searchTextType": "SEARCH_DATE",
+  },
+  "errors": undefined,
+  "notes": Array [
+    "search text is a date (ISO 8601)",
+  ],
+  "status": "ok",
+}
+`;
+
 exports[`SearchQueryBuilder (CAPEC-64,{"default_operator":"OR"})..buildQuery() correctly returns the expected query 1`] = `
 CveResult {
   "data": Object {
diff --git a/src/search/test_cases/search_dates.test.unit.ts b/src/search/test_cases/search_dates.test.unit.ts
@@ -5,7 +5,7 @@ describe('Date Search (unit tests)', () => {
 
   describe('SearchRequest.tokenizeSearchText()', () => {
     // expected defaults to false in this series!
-    const testCases: Array<{ input: string; expected?: boolean; }> = [
+    const testCases: Array<{ input?: string | null; expected?: boolean; }> = [
       // valid dates
       { input: `2025-09-18`, expected: true },
       { input: `2024-02-29`, expected: true },  // leap year
@@ -14,23 +14,25 @@ describe('Date Search (unit tests)', () => {
       { input: undefined },
       { input: `` }, // empty string
       { input: `   ` }, // whitespace
+      { input: `2025` },   // year only
+      { input: `2025-01` },   // year and month only
       { input: `2025-09-01/2025-09-18` },   // date range
-      { input: `2025-09-18T12:00:00:00.000Z`}, // datetime Z
+      { input: `2025-09-18T12:00:00:00.000Z` }, // datetime Z
       { input: `2025-09-18T12:00:00:00.000+05:00` }, // datetime offset
       { input: `2025-02-29` },  // not a leap year
       { input: `1899-12-30` },  // out of range date
       { input: `T12:00:00:00.000Z` },  // ISO 8601 time
 
       // malformed dates
-      { input: '2023-4-01'},          // month not zero‑padded
-      { input: '23-04-01'},           // year not 4‑digit
-      { input: '2023-13-01'},         // month > 12
-      { input: '2023-00-10'},         // month 00
-      { input: '2023-02-30'},         // day > 28/29
-      { input: '2023-01-00'},         // day 00
+      { input: '2023-4-01' },          // month not zero‑padded
+      { input: '23-04-01' },           // year not 4‑digit
+      { input: '2023-13-01' },         // month > 12
+      { input: '2023-00-10' },         // month 00
+      { input: '2023-02-30' },         // day > 28/29
+      { input: '2023-01-00' },         // day 00
 
       // non‑ISO strings
-      { input: 'April 1, 2023'},
+      { input: 'April 1, 2023' },
       { input: '2023/04/01' },
       { input: '19/01/2023' },
       { input: '01/19/2023' },
@@ -53,9 +55,9 @@ describe('Date Search (unit tests)', () => {
     ];
 
     testCases.forEach(({ input, expected }) => {
-      it(`isDateString() should match proper dates and recognize non-dates --> '${input}':  ${expected??false}`, () => {
+      it(`isDateString() should match proper dates and recognize non-dates --> '${input}':  ${expected ?? false}`, () => {
         const result = SearchRequest.isDateString(input);
-        expected = expected ?? false
+        expected = expected ?? false;
         expect(result).toEqual(expected);
       });
     });

Original file line number	Diff line number	Diff line change
@@ -110,6 +110,7 @@ describe(`SearchQueryBuilder`, () => {
`110`	`110`	`metadataOnly: true`
`111`	`111`	`}],`
`112`	`112`	[`CAPEC-64`, { default_operator: 'OR' }],
	`113`	+ [`2023-12-21`, { track_total_hits: true }],
`113`	`114`	`]`
`114`	`115`	`testCases.forEach((test: [string, Partial<SearchOptions>]) => {`
`115`	`116`	it(`(${test[0]},${JSON.stringify(test[1])})..buildQuery() correctly returns the expected query`, async () => {