@oneuptime/common 12.0.25 → 12.0.26

package/Types/BaseDatabase/NotWildcard.ts

@@ -0,0 +1,86 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+import { toLikePattern } from "./WildcardPattern";
+
+/**
+ * "matches none of these globs" — the negation of {@link Wildcard}, produced
+ * by `-@key:value*` in the telemetry search bar.
+ *
+ * It is a class of its own rather than a flag because every compiler in the
+ * codebase dispatches on operator identity, and because the negated form is
+ * not simply `NOT <positive form>` at the edges: on a nullable scalar the
+ * predicate has to let NULL through, and on a map sub-key it has to let rows
+ * that lack the key entirely through — the same asymmetry `NotContains`
+ * carries.
+ */
+export default class NotWildcard<T extends string> extends QueryOperator<T> {
+  private _values: Array<T> = [];
+
+  public get values(): Array<T> {
+    return this._values;
+  }
+
+  public set values(v: Array<T>) {
+    this._values = v;
+  }
+
+  /** The first glob. Convenience for the overwhelmingly common single case. */
+  public get value(): T {
+    return (this._values[0] ?? "") as T;
+  }
+
+  public constructor(value: T | Array<T>) {
+    super();
+    this.values = Array.isArray(value) ? value : [value];
+  }
+
+  /**
+   * The canonical DSL rendering, so that a value which slips into a
+   * string-coercing code path degrades to something a human can read rather
+   * than to `[object Object]`.
+   */
+  public override toString(): T {
+    if (this._values.length === 1) {
+      return (this._values[0] ?? "") as T;
+    }
+
+    return `(${this._values.join(" OR ")})` as T;
+  }
+
+  /** The globs compiled to LIKE/ILIKE patterns, in order. */
+  public toPatterns(): Array<string> {
+    return this._values.map((glob: T) => {
+      return toLikePattern(glob?.toString() || "");
+    });
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.NotWildcard,
+      value: (this as NotWildcard<T>).values.map((glob: T) => {
+        return glob?.toString() || "";
+      }),
+    };
+  }
+
+  public static override fromJSON<T extends string>(
+    json: JSONObject,
+  ): NotWildcard<T> {
+    if (json["_type"] === ObjectType.NotWildcard) {
+      const value: unknown = json["value"];
+
+      if (Array.isArray(value)) {
+        return new NotWildcard<T>(
+          value.map((entry: unknown) => {
+            return String(entry ?? "") as T;
+          }),
+        );
+      }
+
+      return new NotWildcard<T>((value as T) || ("" as T));
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/BaseDatabase/Wildcard.ts

@@ -0,0 +1,89 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+import { toLikePattern } from "./WildcardPattern";
+
+/**
+ * "matches any of these globs" — `api-*`, `*.internal`, `svc-?`.
+ *
+ * The payload is an ARRAY of globs so that one operator covers both a single
+ * pattern (`@k:a*`) and an any-of list that mixes patterns with literals
+ * (`@k:(a* OR bravo)`). `Query<T>` has no OR node and is not getting one, so
+ * folding the disjunction into the operator is what makes an OR over one key
+ * expressible at all.
+ *
+ * The globs are stored exactly as the user typed them, escapes intact: the
+ * LIKE pattern is derived at compile time by `toLikePattern`, so the client
+ * never has to know which database it is talking to and a filter that
+ * round-trips through a saved view or a URL stays readable.
+ */
+export default class Wildcard<T extends string> extends QueryOperator<T> {
+  private _values: Array<T> = [];
+
+  public get values(): Array<T> {
+    return this._values;
+  }
+
+  public set values(v: Array<T>) {
+    this._values = v;
+  }
+
+  /** The first glob. Convenience for the overwhelmingly common single case. */
+  public get value(): T {
+    return (this._values[0] ?? "") as T;
+  }
+
+  public constructor(value: T | Array<T>) {
+    super();
+    this.values = Array.isArray(value) ? value : [value];
+  }
+
+  /**
+   * The canonical DSL rendering, so that a value which slips into a
+   * string-coercing code path degrades to something a human can read rather
+   * than to `[object Object]`.
+   */
+  public override toString(): T {
+    if (this._values.length === 1) {
+      return (this._values[0] ?? "") as T;
+    }
+
+    return `(${this._values.join(" OR ")})` as T;
+  }
+
+  /** The globs compiled to LIKE/ILIKE patterns, in order. */
+  public toPatterns(): Array<string> {
+    return this._values.map((glob: T) => {
+      return toLikePattern(glob?.toString() || "");
+    });
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.Wildcard,
+      value: (this as Wildcard<T>).values.map((glob: T) => {
+        return glob?.toString() || "";
+      }),
+    };
+  }
+
+  public static override fromJSON<T extends string>(
+    json: JSONObject,
+  ): Wildcard<T> {
+    if (json["_type"] === ObjectType.Wildcard) {
+      const value: unknown = json["value"];
+
+      if (Array.isArray(value)) {
+        return new Wildcard<T>(
+          value.map((entry: unknown) => {
+            return String(entry ?? "") as T;
+          }),
+        );
+      }
+
+      return new Wildcard<T>((value as T) || ("" as T));
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/BaseDatabase/WildcardPattern.ts

@@ -0,0 +1,176 @@
+/*
+ * Glob → SQL LIKE translation, shared by every wildcard-capable filter.
+ *
+ * Users type globs (`api-*`, `*.internal`, `a?c`); ClickHouse and Postgres
+ * speak LIKE patterns (`%`, `_`). The two alphabets overlap in the worst
+ * possible way: a `%` a user typed literally is a match-anything token to the
+ * database, and an `_` matches any single character. So the translation has to
+ * happen in ONE pass that can tell a metacharacter the user meant from one the
+ * database will read — running `escapeIlikePattern` first and then replacing
+ * `*` would work, but running it after would escape the `%` this function just
+ * produced, and every caller getting that order wrong is a silent
+ * match-nothing.
+ *
+ * Grammar:
+ *   *      → zero or more characters   (LIKE `%`)
+ *   ?      → exactly one character     (LIKE `_`)
+ *   \*     → a literal asterisk        (also \? \\ , and \<anything> is that
+ *                                       character, literally)
+ *   %  _   → literal, escaped for the database
+ *
+ * Both databases honour backslash escapes inside LIKE patterns, and every
+ * pattern this module produces is bound as a query parameter — never
+ * interpolated — so this is a correctness concern, not an injection one.
+ */
+
+/*
+ * How many globs one wildcard filter may carry.
+ *
+ * Unlike `IN (...)`, which binds one array parameter, each glob is its own
+ * ILIKE predicate — the cost is multiplicative in the number of patterns and
+ * the filter comes straight off a request body. A user typing an any-of list
+ * will never approach this; a request that does is refused with a 400 that
+ * names the limit rather than being silently truncated into a filter that
+ * means something narrower than what was asked for.
+ */
+export const MAX_WILDCARD_PATTERNS: number = 50;
+
+type EscapeLiteralCharFunction = (character: string) => string;
+
+/** Escape one literal character so LIKE reads it as itself. */
+const escapeLiteralChar: EscapeLiteralCharFunction = (
+  character: string,
+): string => {
+  if (character === "\\") {
+    return "\\\\";
+  }
+
+  if (character === "%") {
+    return "\\%";
+  }
+
+  if (character === "_") {
+    return "\\_";
+  }
+
+  return character;
+};
+
+export type GlobToLikePatternFunction = (glob: string) => string;
+
+/**
+ * Translate a user-typed glob into a LIKE/ILIKE pattern.
+ *
+ * `toLikePattern("api-*")` → `"api-%"`, `toLikePattern("*.internal")` →
+ * `"%.internal"`, `toLikePattern("100%")` → `"100\\%"` (a literal percent,
+ * because the user typed no wildcard at all).
+ */
+export const toLikePattern: GlobToLikePatternFunction = (
+  glob: string,
+): string => {
+  let pattern: string = "";
+
+  for (let index: number = 0; index < glob.length; index++) {
+    const character: string = glob[index]!;
+
+    if (character === "\\") {
+      /*
+       * A trailing lone backslash is the user's literal backslash — there is
+       * no next character for it to escape.
+       */
+      const escaped: string | undefined = glob[index + 1];
+
+      if (escaped === undefined) {
+        pattern += escapeLiteralChar("\\");
+        continue;
+      }
+
+      pattern += escapeLiteralChar(escaped);
+      index++;
+      continue;
+    }
+
+    if (character === "*") {
+      pattern += "%";
+      continue;
+    }
+
+    if (character === "?") {
+      pattern += "_";
+      continue;
+    }
+
+    pattern += escapeLiteralChar(character);
+  }
+
+  return pattern;
+};
+
+export type HasWildcardFunction = (value: string) => boolean;
+
+/**
+ * Does this value contain an UNESCAPED wildcard?
+ *
+ * This is what decides whether a typed value becomes a wildcard predicate or
+ * plain equality, so it has to honour the same escapes `toLikePattern` does:
+ * `a\*b` is a literal three-character-plus value, not a glob.
+ */
+export const hasWildcard: HasWildcardFunction = (value: string): boolean => {
+  for (let index: number = 0; index < value.length; index++) {
+    const character: string = value[index]!;
+
+    if (character === "\\") {
+      // Skip whatever it escapes; an escaped `*` is not a wildcard.
+      index++;
+      continue;
+    }
+
+    if (character === "*" || character === "?") {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export type EscapeWildcardsFunction = (value: string) => string;
+
+/**
+ * Make a value glob-inert, for building a search string out of data.
+ *
+ * A value that came from the data itself (a facet value the user clicked, an
+ * attribute copied off a log row) must round-trip as itself — a Kubernetes
+ * container arg like `--foo=*` or a URL pattern `/api/*` would otherwise come
+ * back as a wildcard and match far more than the row it was copied from.
+ */
+export const escapeWildcards: EscapeWildcardsFunction = (
+  value: string,
+): string => {
+  return value.replace(/([\\*?])/g, "\\$1");
+};
+
+/**
+ * Strip the escapes from a glob, recovering the literal text the user meant.
+ *
+ * Used to render a chip and to fall back to exact equality when a value turns
+ * out to carry no wildcard after all.
+ */
+export const unescapeWildcards: EscapeWildcardsFunction = (
+  value: string,
+): string => {
+  let literal: string = "";
+
+  for (let index: number = 0; index < value.length; index++) {
+    const character: string = value[index]!;
+
+    if (character === "\\" && index + 1 < value.length) {
+      literal += value[index + 1]!;
+      index++;
+      continue;
+    }
+
+    literal += character;
+  }
+
+  return literal;
+};

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 {