@oneuptime/common 12.0.25 → 12.0.27

package/Types/Database/DateColumnValue.ts

@@ -0,0 +1,184 @@
+import OneUptimeDate from "../Date";
+import { JSONObject, JSONValue } from "../JSON";
+import { TableColumnMetadata } from "./TableColumn";
+import TableColumnType from "./TableColumnType";
+
+/*
+ * Column types whose in-memory representation is a JavaScript `Date`.
+ *
+ * One entry today, but named rather than compared inline so the set is
+ * discoverable from the coercion below and from the tests that pin it.
+ */
+const DATE_TABLE_COLUMN_TYPES: Set<TableColumnType> = new Set<TableColumnType>([
+  TableColumnType.Date,
+]);
+
+export function isDateTableColumnType(
+  type: TableColumnType | undefined | null,
+): boolean {
+  if (!type) {
+    return false;
+  }
+
+  return DATE_TABLE_COLUMN_TYPES.has(type);
+}
+
+/*
+ * The shapes a date column may arrive in as a bare string, and only those.
+ *
+ * The gate is deliberately narrow. moment's fallback parser accepts almost
+ * anything and invents a date for it — "12" becomes 2001-12-01 and "0"
+ * becomes 2000-01-01 — so handing it every string that lands on a date column
+ * would silently manufacture values. Everything the product actually produces
+ * is ISO-shaped: `<input type="date">` yields "YYYY-MM-DD",
+ * `<input type="datetime-local">` yields "YYYY-MM-DDTHH:mm", JSON.stringify of
+ * a Date yields a Z-suffixed instant, and Postgres renders "YYYY-MM-DD
+ * HH:mm:ss". Anything else is left exactly as it was.
+ */
+const ISO_DATE_ONLY: RegExp = /^\d{4}-\d{2}-\d{2}$/;
+const ISO_DATE_TIME_WITHOUT_ZONE: RegExp =
+  /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d{1,9})?)$/;
+const ISO_DATE_TIME_WITH_ZONE: RegExp =
+  /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d{1,9})?(?:Z|[+-]\d{2}:?\d{2})$/;
+
+/*
+ * Rewrite a recognised date string into an unambiguous instant, or return null
+ * when it is not one of the recognised shapes.
+ *
+ * A string with no timezone designator is read as UTC, which is not an
+ * arbitrary choice: it is exactly what happened before this coercion existed.
+ * The raw string used to travel to Postgres untouched, where a `timestamptz`
+ * column parses an offset-less literal in the session timezone — UTC in every
+ * OneUptime deployment. Reading it as UTC here keeps the stored instant
+ * identical, and makes it independent of whatever timezone the Node process
+ * happens to run in, which the local-time parse in moment's default mode is
+ * not.
+ */
+type NormalizeIsoDateStringFunction = (value: string) => string | null;
+
+const normalizeIsoDateString: NormalizeIsoDateStringFunction = (
+  value: string,
+): string | null => {
+  if (ISO_DATE_ONLY.test(value)) {
+    return `${value}T00:00:00.000Z`;
+  }
+
+  const withoutZone: RegExpMatchArray | null = value.match(
+    ISO_DATE_TIME_WITHOUT_ZONE,
+  );
+
+  if (withoutZone) {
+    return `${withoutZone[1]}T${withoutZone[2]}Z`;
+  }
+
+  if (ISO_DATE_TIME_WITH_ZONE.test(value)) {
+    return value.replace(" ", "T");
+  }
+
+  return null;
+};
+
+/*
+ * Normalize a JSON value destined for a date column.
+ *
+ * The dashboard's date form field is an `<input type="date">`, and a DOM
+ * input's value is a *string* — there is no Date input event in HTML. So a
+ * date picked in a form reached the API as the JSON string "2027-01-01", and
+ * `BaseModel.fromJSON` assigned it to the model verbatim. Postgres accepts
+ * that string happily, which is why it went unnoticed on every date field in
+ * the product: the string only becomes visible when something reads the column
+ * back off the saved model, because TypeORM's `save()` returns the entity it
+ * was handed rather than a re-read row.
+ *
+ * That is what broke enterprise licence creation. The row was inserted, and
+ * then `EnterpriseLicenseService.onCreateSuccess` called
+ * `createdItem.expiresAt.toISOString()` on a string — a TypeError, thrown
+ * after the INSERT had already committed. The admin saw "Server Error" while
+ * a licence row was created for every attempt.
+ *
+ * Normalizing here — where the column's declared type is known, on both the
+ * browser side (ModelForm -> BaseModel.fromJSON) and the server side
+ * (BaseAPI -> BaseModel.fromJSON) — means a date column holds a Date by the
+ * time any hook, validator or query sees it. Mirrors
+ * Types/Database/NumericColumnValue, which fixed the same class of bug for
+ * `<input type="number">`.
+ *
+ * Only strings in a recognised ISO shape that parse to a valid date are
+ * converted. A blank string, a garbage string and an impossible date like
+ * "2027-13-45" are all left alone, so validation rejects them with a message
+ * about the field instead of this function inventing a value.
+ */
+export function coerceDateColumnValue(value: unknown): unknown {
+  if (typeof value !== "string") {
+    return value;
+  }
+
+  const trimmed: string = value.trim();
+
+  if (trimmed.length === 0) {
+    return value;
+  }
+
+  const normalized: string | null = normalizeIsoDateString(trimmed);
+
+  if (!normalized) {
+    return value;
+  }
+
+  let parsed: Date;
+
+  try {
+    parsed = OneUptimeDate.fromString(normalized);
+  } catch {
+    return value;
+  }
+
+  if (!(parsed instanceof Date) || Number.isNaN(parsed.getTime())) {
+    return value;
+  }
+
+  return parsed;
+}
+
+/*
+ * The minimum a model has to offer for its date columns to be found.
+ * Every DatabaseBaseModel satisfies it; asking for only this keeps the
+ * coercion usable from the API layer without dragging the model class in.
+ */
+export interface ColumnMetadataSource {
+  getTableColumnMetadata: (columnName: string) => TableColumnMetadata;
+}
+
+/*
+ * Coerce the date columns of a loose JSON patch, in place.
+ *
+ * `BaseModel.fromJSON` does this on its way to building a model, but an update
+ * never builds one — `BaseAPI.updateItem` goes from the request body straight
+ * to a partial entity — so without this a PUT and a POST disagree about
+ * whether "2027-01-01" is a Date. That matters because the save-time hooks
+ * read these values before the database gets a chance to parse them.
+ *
+ * Values that are not strings are left exactly as they are, including the
+ * `() => string` raw SQL expressions a PartialEntity may carry.
+ */
+export function coerceDateColumnsInJSON(
+  json: JSONObject,
+  model: ColumnMetadataSource,
+): JSONObject {
+  for (const key of Object.keys(json)) {
+    const tableColumnMetadata: TableColumnMetadata =
+      model.getTableColumnMetadata(key);
+
+    if (!tableColumnMetadata) {
+      continue;
+    }
+
+    if (!isDateTableColumnType(tableColumnMetadata.type)) {
+      continue;
+    }
+
+    json[key] = coerceDateColumnValue(json[key]) as JSONValue;
+  }
+
+  return json;
+}

package/Types/Database/TableColumn.ts

@@ -33,6 +33,19 @@ export interface TableColumnMetadata {
   canReadOnRelationQuery?: boolean;
   hideColumnInDocumentation?: boolean;
   modelType?: { new (): BaseModel };
+  /*
+   * Lazy form of modelType, resolved on read rather than at decoration time.
+   *
+   * A relation between two models that import each other (Monitor <->
+   * NetworkDevice) is a circular import: whichever module the loader reaches
+   * second sees the first as `undefined` while its own decorators run, so an
+   * eager `modelType: TheOtherModel` captures `undefined` and every later
+   * select on that relation throws "modelType is not found". A thunk defers the
+   * dereference until read time - after every module has finished loading - so
+   * both directions resolve regardless of load order. getTableColumn(s) below
+   * resolve it into modelType, so nothing downstream needs to know it was lazy.
+   */
+  modelTypeThunk?: () => { new (): BaseModel };
   defaultValue?: string | number | boolean | JSONObject; // default value for the column, can be a string, number, or boolean
   forceGetDefaultValueOnCreate?: () => string | number | boolean; // overwrites any value that is being passed and generates a new one. Useful for generating OTPs, etc.
   example?: string | number | boolean | JSONObject | Array<JSONObject>; // example value for API documentation
@@ -43,6 +56,26 @@ export default (props: TableColumnMetadata): ReflectionMetadataType => {
   return Reflect.metadata(tableColumn, props);
 };
 
+/*
+ * Resolve a lazy modelTypeThunk into modelType on first read, in place.
+ *
+ * Mutating the singleton rather than returning a copy is deliberate: callers
+ * (and the caching layer below) rely on getTableColumn(s) handing back the very
+ * same metadata object every time - identity is part of the contract. The write
+ * is idempotent (once modelType is set the thunk is never called again) and
+ * every module has finished loading by the time any query reads a column, so
+ * the thunk resolves to the fully-defined related model.
+ */
+function resolveModelType(
+  metadata: TableColumnMetadata | undefined,
+): TableColumnMetadata | undefined {
+  if (metadata && !metadata.modelType && metadata.modelTypeThunk) {
+    metadata.modelType = metadata.modelTypeThunk();
+  }
+
+  return metadata;
+}
+
 type GetTableColumnFunction = <T extends BaseModel>(
   target: T,
   propertyKey: string,
@@ -52,10 +85,12 @@ export const getTableColumn: GetTableColumnFunction = <T extends BaseModel>(
   target: T,
   propertyKey: string,
 ): TableColumnMetadata => {
-  return Reflect.getMetadata(
-    tableColumn,
-    target,
-    propertyKey,
+  return resolveModelType(
+    Reflect.getMetadata(
+      tableColumn,
+      target,
+      propertyKey,
+    ) as TableColumnMetadata,
   ) as TableColumnMetadata;
 };
 
@@ -93,7 +128,7 @@ export const getTableColumns: GetTableColumnsFunction = <T extends BaseModel>(
         key,
       ) as TableColumnMetadata | undefined;
       if (metadata) {
-        dictonary[key] = metadata;
+        dictonary[key] = resolveModelType(metadata) as TableColumnMetadata;
       }
     }
 

package/Types/Date.ts

@@ -636,6 +636,43 @@ export default class OneUptimeDate {
     return date.toISOString();
   }
 
+  /*
+   * The ISO instant for a value that is *declared* a Date but may not be one
+   * at runtime.
+   *
+   * TypeORM's save() hands back the entity it was given, so a date column read
+   * off a freshly created model holds whatever the caller supplied — a real
+   * Date once BaseModel.fromJSON has coerced it, a raw string from any caller
+   * that bypasses that path. `.toISOString()` on the latter is a TypeError,
+   * and post-create hooks are exactly where such a throw does the most damage:
+   * the row is already committed, so it converts a completed write into a
+   * server error the caller retries.
+   *
+   * Returns null for anything that is not a usable date, so a caller reporting
+   * an optional timestamp reports "unknown" instead of failing.
+   */
+  public static toIsoStringOrNull(
+    date: Date | string | undefined | null,
+  ): string | null {
+    if (!date) {
+      return null;
+    }
+
+    let parsedDate: Date;
+
+    try {
+      parsedDate = this.fromString(date);
+    } catch {
+      return null;
+    }
+
+    if (!(parsedDate instanceof Date) || Number.isNaN(parsedDate.getTime())) {
+      return null;
+    }
+
+    return parsedDate.toISOString();
+  }
+
   public static getCurrentMomentDate(): moment.Moment {
     return moment();
   }

package/Types/Email/EmailTemplateType.ts

@@ -12,6 +12,7 @@ enum EmailTemplateType {
   PasswordChanged = "PasswordChanged.hbs",
   TwoFactorBackupCodeUsed = "TwoFactorBackupCodeUsed.hbs",
   TwoFactorBackupCodesRegenerated = "TwoFactorBackupCodesRegenerated.hbs",
+  TwoFactorBackupCodesCreated = "TwoFactorBackupCodesCreated.hbs",
   ProbeOwnerAdded = "ProbeOwnerAdded.hbs",
   InviteMember = "InviteMember.hbs",
   EmailChanged = "EmailChanged.hbs",

package/Types/JSON.ts

@@ -12,6 +12,8 @@ import IncludesNone from "./BaseDatabase/IncludesNone";
 import StartsWith from "./BaseDatabase/StartsWith";
 import EndsWith from "./BaseDatabase/EndsWith";
 import NotContains from "./BaseDatabase/NotContains";
+import Wildcard from "./BaseDatabase/Wildcard";
+import NotWildcard from "./BaseDatabase/NotWildcard";
 import LessThan from "./BaseDatabase/LessThan";
 import LessThanOrEqual from "./BaseDatabase/LessThanOrEqual";
 import NotEqual from "./BaseDatabase/NotEqual";
@@ -83,6 +85,8 @@ export enum ObjectType {
   StartsWith = "StartsWith",
   EndsWith = "EndsWith",
   NotContains = "NotContains",
+  Wildcard = "Wildcard",
+  NotWildcard = "NotWildcard",
   DashboardComponent = "DashboardComponent",
   DashboardViewConfig = "DashboardViewConfig",
 }
@@ -180,6 +184,10 @@ export type JSONValue =
   | Array<EndsWith<string>>
   | NotContains<string>
   | Array<NotContains<string>>
+  | Wildcard<string>
+  | Array<Wildcard<string>>
+  | NotWildcard<string>
+  | Array<NotWildcard<string>>
   | DashboardViewConfig;
 
 export interface JSONObject {

package/Types/Log/LogQueryToFilter.ts

@@ -1,31 +1,37 @@
 /**
- * Converts parsed log query tokens into a Query<Log> object compatible with
- * the AnalyticsDatabaseService query system.
+ * Compiles the log search bar's query string into a `Query<Log>` for the
+ * AnalyticsDatabaseService.
+ *
+ * The grammar itself lives in `Common/Types/Telemetry/TelemetrySearchQuery` —
+ * shared with traces, metrics and exceptions, so `@platform.team:a*` means the
+ * same thing on every explorer. Everything here is log-specific: which names
+ * are columns, which alias to what, and how severity is spelled in the data.
  */
 
-import {
-  ParsedToken,
-  TokenType,
-  FilterOperator,
-  parseLogQuery,
-} from "./LogQueryParser";
 import Search from "../BaseDatabase/Search";
-import NotEqual from "../BaseDatabase/NotEqual";
-import GreaterThan from "../BaseDatabase/GreaterThan";
-import GreaterThanOrEqual from "../BaseDatabase/GreaterThanOrEqual";
-import LessThan from "../BaseDatabase/LessThan";
-import LessThanOrEqual from "../BaseDatabase/LessThanOrEqual";
+import {
+  SearchToken,
+  SearchTokenType,
+  SearchValueOperator,
+  SearchQueryValue,
+  parseSearchQuery,
+  predicateToQueryValue,
+} from "../Telemetry/TelemetrySearchQuery";
 
 export interface LogFilter {
-  body?: string | Search<string>;
-  severityText?: string;
-  primaryEntityId?: string;
-  traceId?: string;
-  spanId?: string;
+  body?: string | Search<string> | Array<unknown>;
+  severityText?: unknown;
+  primaryEntityId?: unknown;
+  traceId?: unknown;
+  spanId?: unknown;
   attributes?: Record<string, unknown>;
   [key: string]: unknown;
 }
 
+/**
+ * Columns a bare `field:value` token can address. Anything else is treated as
+ * an attribute, which is what makes `k8s.pod:foo` work without an `@`.
+ */
 const TOP_LEVEL_FIELDS: Set<string> = new Set([
   "severityText",
   "primaryEntityId",
@@ -34,9 +40,34 @@ const TOP_LEVEL_FIELDS: Set<string> = new Set([
   "body",
 ]);
 
+export const LOG_FIELD_ALIASES: Record<string, string> = {
+  severity: "severityText",
+  severitytext: "severityText",
+  level: "severityText",
+  service: "primaryEntityId",
+  primaryentityid: "primaryEntityId",
+  trace: "traceId",
+  traceid: "traceId",
+  span: "spanId",
+  spanid: "spanId",
+  message: "body",
+  msg: "body",
+  log: "body",
+  body: "body",
+};
+
+/**
+ * Field names that may be followed by a space before their value
+ * (`severity: error`). Kept to known names so ordinary prose containing a
+ * colon stays free text rather than becoming a filter on an invented field.
+ */
+export const LOG_KNOWN_FIELD_KEYS: Set<string> = new Set(
+  Object.keys(LOG_FIELD_ALIASES),
+);
+
 /*
- * Severity values stored in the database use title case (e.g. "Error", "Debug").
- * Normalise user input so that "error" matches "Error", etc.
+ * Severity values stored in the database use title case (e.g. "Error",
+ * "Debug"). Normalise user input so that "error" matches "Error".
  */
 const SEVERITY_CANONICAL: Record<string, string> = {
   fatal: "Fatal",
@@ -50,138 +81,145 @@ const SEVERITY_CANONICAL: Record<string, string> = {
   unspecified: "Unspecified",
 };
 
-function normalizeSeverityValue(value: string): string {
+type NormalizeSeverityValueFunction = (value: string) => string;
+
+const normalizeSeverityValue: NormalizeSeverityValueFunction = (
+  value: string,
+): string => {
   return SEVERITY_CANONICAL[value.toLowerCase()] || value;
-}
+};
 
-function applyFieldFilter(filter: LogFilter, token: ParsedToken): void {
-  if (!token.field) {
-    return;
+type CanonicalizeTokenFunction = (token: SearchToken) => SearchToken;
+
+/*
+ * Severity is an enum spelled in title case in ClickHouse, and users type it
+ * however they like. Canonicalising here — on the predicate, before it is
+ * compiled — means the normalisation applies to every operator, not just
+ * equality: `severity:(error OR warn)` and `-severity:debug` get it too.
+ */
+const canonicalizeToken: CanonicalizeTokenFunction = (
+  token: SearchToken,
+): SearchToken => {
+  if (token.key !== "severityText") {
+    return token;
   }
 
-  let value: string = token.value;
+  return {
+    ...token,
+    predicate: {
+      ...token.predicate,
+      value: normalizeSeverityValue(token.predicate.value),
+      values: token.predicate.values.map(normalizeSeverityValue),
+    },
+  };
+};
 
-  // Normalise severity values to match database casing
-  if (token.field === "severityText") {
-    value = normalizeSeverityValue(value);
-  }
+type AssignFunction = (
+  target: Record<string, unknown>,
+  key: string,
+  value: unknown,
+) => void;
 
-  if (TOP_LEVEL_FIELDS.has(token.field)) {
-    applyTopLevelFilter(filter, token.field, value, token.operator);
-  } else {
-    applyAttributeFilter(filter, token.field, value, token.operator);
+/*
+ * Two filters on one key AND together rather than the second overwriting the
+ * first — `@k:a* @k:*b` is "starts with a and ends with b". The compilers
+ * accept an array of operators on a column and on a map sub-key and compile
+ * each one; a bare string cannot join such an array, so the first wins in
+ * that case (a plain equality already pins the value).
+ */
+const assign: AssignFunction = (
+  target: Record<string, unknown>,
+  key: string,
+  value: unknown,
+): void => {
+  const existing: unknown = target[key];
+
+  if (existing === undefined) {
+    target[key] = value;
+    return;
   }
-}
 
-function applyTopLevelFilter(
-  filter: LogFilter,
-  field: string,
-  value: string,
-  operator: FilterOperator,
-): void {
-  switch (operator) {
-    case FilterOperator.Contains:
-    case FilterOperator.Wildcard:
-      filter[field] = new Search(value.replace(/\*/g, ""));
-      break;
-    case FilterOperator.GreaterThan:
-      filter[field] = new GreaterThan(parseNumericOrString(value));
-      break;
-    case FilterOperator.GreaterThanOrEqual:
-      filter[field] = new GreaterThanOrEqual(parseNumericOrString(value));
-      break;
-    case FilterOperator.LessThan:
-      filter[field] = new LessThan(parseNumericOrString(value));
-      break;
-    case FilterOperator.LessThanOrEqual:
-      filter[field] = new LessThanOrEqual(parseNumericOrString(value));
-      break;
-    case FilterOperator.NotEquals:
-      filter[field] = new NotEqual(value);
-      break;
-    case FilterOperator.Equals:
-    default:
-      filter[field] = value;
-      break;
+  if (typeof existing === "string" || typeof value === "string") {
+    return;
   }
-}
 
-function applyAttributeFilter(
-  filter: LogFilter,
-  field: string,
-  value: string,
-  operator: FilterOperator,
-): void {
-  if (!filter.attributes) {
-    filter.attributes = {};
-  }
+  target[key] = Array.isArray(existing)
+    ? [...existing, value]
+    : [existing, value];
+};
 
-  switch (operator) {
-    case FilterOperator.Contains:
-    case FilterOperator.Wildcard:
-      filter.attributes[field] = new Search(value.replace(/\*/g, ""));
-      break;
-    case FilterOperator.NotEquals:
-      filter.attributes[field] = new NotEqual(value);
-      break;
-    case FilterOperator.GreaterThan:
-      filter.attributes[field] = new GreaterThan(parseNumericOrString(value));
-      break;
-    case FilterOperator.GreaterThanOrEqual:
-      filter.attributes[field] = new GreaterThanOrEqual(
-        parseNumericOrString(value),
-      );
-      break;
-    case FilterOperator.LessThan:
-      filter.attributes[field] = new LessThan(parseNumericOrString(value));
-      break;
-    case FilterOperator.LessThanOrEqual:
-      filter.attributes[field] = new LessThanOrEqual(
-        parseNumericOrString(value),
-      );
-      break;
-    case FilterOperator.Equals:
-    default:
-      filter.attributes[field] = value;
-      break;
-  }
-}
+type ApplyFreeTextFunction = (filter: LogFilter, phrase: string) => void;
 
-function applyFreeTextFilter(filter: LogFilter, token: ParsedToken): void {
-  if (filter.body && filter.body instanceof Search) {
-    const existing: string = filter.body.toString();
-    filter.body = new Search(`${existing} ${token.value}`);
-  } else if (filter.body && typeof filter.body === "string") {
-    filter.body = new Search(`${filter.body} ${token.value}`);
-  } else {
-    filter.body = new Search(token.value);
+/*
+ * Each free-text phrase is its own contains-predicate on the body. They are
+ * NOT concatenated: `foo severity:error bar` means "the line mentions foo and
+ * mentions bar", never the phrase "foo bar", which never occurred in any log
+ * line and matched nothing.
+ */
+const applyFreeText: ApplyFreeTextFunction = (
+  filter: LogFilter,
+  phrase: string,
+): void => {
+  if (phrase.trim().length === 0) {
+    return;
   }
-}
 
-function parseNumericOrString(value: string): number | string {
-  const num: number = Number(value);
-  return isNaN(num) ? value : num;
-}
+  assign(filter as Record<string, unknown>, "body", new Search(phrase));
+};
 
 export function queryStringToFilter(queryString: string): LogFilter {
-  const tokens: Array<ParsedToken> = parseLogQuery(queryString);
+  const tokens: Array<SearchToken> = parseSearchQuery(queryString, {
+    knownFieldKeys: LOG_KNOWN_FIELD_KEYS,
+    fieldAliases: LOG_FIELD_ALIASES,
+  });
+
   const filter: LogFilter = {};
 
   for (const token of tokens) {
-    switch (token.type) {
-      case TokenType.FreeText:
-        applyFreeTextFilter(filter, token);
-        break;
-      case TokenType.FieldFilter:
-        applyFieldFilter(filter, token);
-        break;
-      case TokenType.AttributeFilter:
-        applyFieldFilter(filter, token);
-        break;
+    if (token.type === SearchTokenType.FreeText) {
+      applyFreeText(filter, token.predicate.value);
+      continue;
+    }
+
+    const canonical: SearchToken = canonicalizeToken(token);
+    const compiled: SearchQueryValue = predicateToQueryValue(
+      canonical.predicate,
+    );
+
+    /*
+     * An `@`-prefixed token is ALWAYS an attribute, even when the key happens
+     * to spell a column name. `@body:x` used to filter the body column and
+     * `@traceId:x` the traceId column, silently ignoring the `@` that says
+     * "look in the attributes map".
+     */
+    if (
+      canonical.type === SearchTokenType.Field &&
+      TOP_LEVEL_FIELDS.has(canonical.key)
+    ) {
+      assign(filter as Record<string, unknown>, canonical.key, compiled);
+      continue;
+    }
+
+    if (!filter.attributes) {
+      filter.attributes = {};
     }
+
+    assign(filter.attributes, canonical.key, compiled);
   }
 
   return filter;
 }
 
+/**
+ * Does this query string carry any filter at all?
+ *
+ * Used by callers that need to tell "the user typed nothing" from "the user
+ * typed something that parsed to nothing".
+ */
+export function isEmptyLogQuery(queryString: string): boolean {
+  return parseSearchQuery(queryString).length === 0;
+}
+
+export { SearchValueOperator };
+
 export default queryStringToFilter;