@oneuptime/common 12.0.6 → 12.0.8

package/Tests/UI/Components/Workflow/ModelColumnEditor.test.ts

@@ -0,0 +1,287 @@
+/*
+ * The two pure decisions behind the column row editor: whether a stored value
+ * can be shown as rows at all, and what the rows serialize back to.
+ *
+ * The serialization side matters most — the string this produces is handed
+ * straight to the server, where JSONFunctions.deserialize has to turn the
+ * operator wrappers back into the QueryHelper objects TypeORM understands.
+ */
+
+import {
+  ModelColumnEditorMode,
+  buildColumnValueJson,
+  classifyColumnValueCompatibility,
+} from "../../../../UI/Components/Workflow/ModelColumnEditor";
+import { ModelSchemaColumn } from "../../../../UI/Components/Workflow/ModelSchema";
+import Dictionary from "../../../../Types/Dictionary";
+import { DictionaryEntryValue } from "../../../../UI/Components/Dictionary/DictionaryFilterOperator";
+import { JSONObject, ObjectType } from "../../../../Types/JSON";
+import GreaterThan from "../../../../Types/BaseDatabase/GreaterThan";
+import Includes from "../../../../Types/BaseDatabase/Includes";
+import IsNull from "../../../../Types/BaseDatabase/IsNull";
+import NotEqual from "../../../../Types/BaseDatabase/NotEqual";
+import Search from "../../../../Types/BaseDatabase/Search";
+import { describe, expect, test } from "@jest/globals";
+
+type MakeColumnFunction = (
+  id: string,
+  type?: string | undefined,
+) => ModelSchemaColumn;
+
+const makeColumn: MakeColumnFunction = (
+  id: string,
+  type?: string | undefined,
+): ModelSchemaColumn => {
+  return {
+    id: id,
+    title: id,
+    type: type || "ShortText",
+    isRelation: false,
+  };
+};
+
+const COLUMNS: Array<ModelSchemaColumn> = [
+  makeColumn("_id", "ObjectID"),
+  makeColumn("name"),
+  makeColumn("createdAt", "Date"),
+  makeColumn("isEnabled", "Boolean"),
+];
+
+describe("classifyColumnValueCompatibility — plain values", () => {
+  test("an empty query is representable", () => {
+    expect(
+      classifyColumnValueCompatibility({}, COLUMNS, ModelColumnEditorMode.Query)
+        .compatible,
+    ).toBe(true);
+  });
+
+  test("scalar values are representable", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { name: "abc", isEnabled: true },
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      );
+
+    expect(result.compatible).toBe(true);
+    expect(result.reasons).toEqual([]);
+  });
+
+  test("a null value is representable", () => {
+    expect(
+      classifyColumnValueCompatibility(
+        { name: null } as unknown as JSONObject,
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      ).compatible,
+    ).toBe(true);
+  });
+
+  test("text that is not a JSON object is not representable", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        null,
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      );
+
+    expect(result.compatible).toBe(false);
+    expect(result.reasons[0]).toMatch(/isn't a JSON object/);
+  });
+
+  /*
+   * An unknown column is exactly the "id" versus "_id" mistake. Say so, but
+   * keep the rows — the builder needs to see the row to fix it.
+   */
+  test("an unknown column is reported without locking the editor", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { id: "abc" },
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      );
+
+    expect(result.compatible).toBe(true);
+    expect(result.reasons[0]).toMatch(/"id" isn't a known column/);
+  });
+
+  test("columns are not checked when the schema failed to load", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { anything: "abc" },
+        [],
+        ModelColumnEditorMode.Query,
+      );
+
+    expect(result.compatible).toBe(true);
+    expect(result.reasons).toEqual([]);
+  });
+});
+
+describe("classifyColumnValueCompatibility — operators", () => {
+  test("a query shows the operators the rows support", () => {
+    const supported: Array<string> = [
+      ObjectType.EqualTo,
+      ObjectType.NotEqual,
+      ObjectType.Search,
+      ObjectType.NotContains,
+      ObjectType.StartsWith,
+      ObjectType.EndsWith,
+      ObjectType.GreaterThan,
+      ObjectType.GreaterThanOrEqual,
+      ObjectType.LessThan,
+      ObjectType.LessThanOrEqual,
+      ObjectType.IsNull,
+      ObjectType.NotNull,
+      ObjectType.Includes,
+      ObjectType.IncludesNone,
+    ];
+
+    for (const objectType of supported) {
+      const result: { compatible: boolean } = classifyColumnValueCompatibility(
+        { name: { _type: objectType, value: "x" } },
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      );
+
+      expect(result.compatible).toBe(true);
+    }
+  });
+
+  test("an operator the rows cannot show keeps the JSON editor", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { createdAt: { _type: ObjectType.InBetween, value: "x" } },
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      );
+
+    expect(result.compatible).toBe(false);
+    expect(result.reasons[0]).toMatch(/InBetween/);
+  });
+
+  /*
+   * A record is a set of values to write. An operator there would be nonsense,
+   * so it belongs in the JSON editor where the builder can see what they have.
+   */
+  test("an operator in a record is not representable", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { name: { _type: ObjectType.NotEqual, value: "x" } },
+        COLUMNS,
+        ModelColumnEditorMode.Record,
+      );
+
+    expect(result.compatible).toBe(false);
+  });
+
+  test("a nested relation query keeps the JSON editor", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { project: { _id: "abc" } },
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      );
+
+    expect(result.compatible).toBe(false);
+    expect(result.reasons.join(" ")).toMatch(/nested record/);
+  });
+
+  test("a bare array keeps the JSON editor and suggests the operator", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { name: ["a", "b"] } as unknown as JSONObject,
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      );
+
+    expect(result.compatible).toBe(false);
+    expect(result.reasons[0]).toMatch(/is any of/);
+  });
+});
+
+describe("buildColumnValueJson", () => {
+  test("an empty set collapses to empty text, so required still fires", () => {
+    expect(buildColumnValueJson({})).toBe("");
+  });
+
+  test("a row with no column name is dropped", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      "": "orphan",
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(buildColumnValueJson(rows)).toBe("");
+  });
+
+  test("plain values serialize as plain JSON", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      name: "abc",
+      isEnabled: true,
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(JSON.parse(buildColumnValueJson(rows))).toEqual({
+      name: "abc",
+      isEnabled: true,
+    });
+  });
+
+  /*
+   * The contract with the server: every operator wrapper has to come out as
+   * {_type, value}, because that is the only shape JSONFunctions.deserialize
+   * turns back into a QueryHelper object.
+   */
+  test("an operator serializes to the shape the server rehydrates", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      name: new NotEqual<string>("abc"),
+    } as unknown as Dictionary<DictionaryEntryValue>;
+
+    expect(JSON.parse(buildColumnValueJson(rows))).toEqual({
+      name: { _type: ObjectType.NotEqual, value: "abc" },
+    });
+  });
+
+  test("every operator the editor offers round-trips through JSON", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      a: new NotEqual<string>("x"),
+      b: new Search("y"),
+      c: new GreaterThan<number>(5),
+      d: new IsNull(),
+      e: new Includes(["p", "q"]),
+    } as unknown as Dictionary<DictionaryEntryValue>;
+
+    const parsed: JSONObject = JSON.parse(buildColumnValueJson(rows));
+
+    expect((parsed["a"] as JSONObject)["_type"]).toBe(ObjectType.NotEqual);
+    expect((parsed["b"] as JSONObject)["_type"]).toBe(ObjectType.Search);
+    expect((parsed["c"] as JSONObject)["_type"]).toBe(ObjectType.GreaterThan);
+    expect((parsed["d"] as JSONObject)["_type"]).toBe(ObjectType.IsNull);
+    expect((parsed["e"] as JSONObject)["_type"]).toBe(ObjectType.Includes);
+  });
+
+  test("a template placeholder survives as an ordinary string value", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      _id: "{{local.components.api-get-1.returnValues.response-body}}",
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(JSON.parse(buildColumnValueJson(rows))).toEqual({
+      _id: "{{local.components.api-get-1.returnValues.response-body}}",
+    });
+  });
+
+  test("what it emits is readable again by the compatibility check", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      name: new NotEqual<string>("abc"),
+      isEnabled: true,
+    } as unknown as Dictionary<DictionaryEntryValue>;
+
+    const roundTripped: JSONObject = JSON.parse(buildColumnValueJson(rows));
+
+    expect(
+      classifyColumnValueCompatibility(
+        roundTripped,
+        COLUMNS,
+        ModelColumnEditorMode.Query,
+      ).compatible,
+    ).toBe(true);
+  });
+});

package/Tests/UI/Components/Workflow/ModelColumnEditorServerContract.test.ts

@@ -0,0 +1,185 @@
+/*
+ * The contract that matters: what the row editor writes into a workflow
+ * argument has to survive the trip to the server and come back out as the
+ * QueryHelper objects TypeORM understands.
+ *
+ * The builder writes a JSON string. RunWorkflow.getComponentArguments parses
+ * it, and FindManyBaseModel (and every other database component) hands the
+ * result to JSONFunctions.deserialize before it reaches the query builder.
+ * This walks that whole path, so a change to either end that breaks the other
+ * fails here rather than at run time.
+ */
+
+import {
+  ModelColumnEditorMode,
+  buildColumnValueJson,
+  classifyColumnValueCompatibility,
+} from "../../../../UI/Components/Workflow/ModelColumnEditor";
+import Dictionary from "../../../../Types/Dictionary";
+import { DictionaryEntryValue } from "../../../../UI/Components/Dictionary/DictionaryFilterOperator";
+import { JSONObject } from "../../../../Types/JSON";
+import JSONFunctions from "../../../../Types/JSONFunctions";
+import EqualToOrNull from "../../../../Types/BaseDatabase/EqualToOrNull";
+import GreaterThan from "../../../../Types/BaseDatabase/GreaterThan";
+import GreaterThanOrEqual from "../../../../Types/BaseDatabase/GreaterThanOrEqual";
+import Includes from "../../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../../Types/BaseDatabase/IncludesNone";
+import IsNull from "../../../../Types/BaseDatabase/IsNull";
+import LessThan from "../../../../Types/BaseDatabase/LessThan";
+import NotEqual from "../../../../Types/BaseDatabase/NotEqual";
+import NotNull from "../../../../Types/BaseDatabase/NotNull";
+import Search from "../../../../Types/BaseDatabase/Search";
+import StartsWith from "../../../../Types/BaseDatabase/StartsWith";
+import { describe, expect, test } from "@jest/globals";
+
+type RoundTripFunction = (rows: Dictionary<DictionaryEntryValue>) => JSONObject;
+
+/**
+ * Builder rows -> stored string -> parsed by the runner -> deserialized by the
+ * component. Exactly the path a real run takes.
+ */
+const roundTrip: RoundTripFunction = (
+  rows: Dictionary<DictionaryEntryValue>,
+): JSONObject => {
+  const stored: string = buildColumnValueJson(rows);
+  const parsedByRunner: JSONObject = JSON.parse(stored);
+
+  return JSONFunctions.deserialize(parsedByRunner) as JSONObject;
+};
+
+describe("row editor output survives the server's deserialization", () => {
+  test("a plain equality stays a plain value", () => {
+    const result: JSONObject = roundTrip({
+      name: "acme",
+    } as Dictionary<DictionaryEntryValue>);
+
+    expect(result["name"]).toBe("acme");
+  });
+
+  test("a not-equal comes back as a NotEqual", () => {
+    const result: JSONObject = roundTrip({
+      name: new NotEqual<string>("acme"),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(result["name"]).toBeInstanceOf(NotEqual);
+    expect((result["name"] as NotEqual<string>).value).toBe("acme");
+  });
+
+  test("a contains comes back as a Search", () => {
+    const result: JSONObject = roundTrip({
+      name: new Search("acm"),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(result["name"]).toBeInstanceOf(Search);
+  });
+
+  test("a starts-with comes back as a StartsWith", () => {
+    const result: JSONObject = roundTrip({
+      name: new StartsWith("ac"),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(result["name"]).toBeInstanceOf(StartsWith);
+  });
+
+  test("numeric comparisons keep their type and their number", () => {
+    const result: JSONObject = roundTrip({
+      a: new GreaterThan<number>(5),
+      b: new GreaterThanOrEqual<number>(6),
+      c: new LessThan<number>(7),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(result["a"]).toBeInstanceOf(GreaterThan);
+    expect((result["a"] as GreaterThan<number>).value).toBe(5);
+    expect(result["b"]).toBeInstanceOf(GreaterThanOrEqual);
+    expect(result["c"]).toBeInstanceOf(LessThan);
+  });
+
+  test("the null checks come back as IsNull and NotNull", () => {
+    const result: JSONObject = roundTrip({
+      a: new IsNull(),
+      b: new NotNull(),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(result["a"]).toBeInstanceOf(IsNull);
+    expect(result["b"]).toBeInstanceOf(NotNull);
+  });
+
+  test("membership operators keep their whole list", () => {
+    const result: JSONObject = roundTrip({
+      a: new Includes(["x", "y"]),
+      b: new IncludesNone(["z"]),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(result["a"]).toBeInstanceOf(Includes);
+    expect((result["a"] as Includes).values).toEqual(["x", "y"]);
+    expect(result["b"]).toBeInstanceOf(IncludesNone);
+  });
+
+  test("equal-to-or-null survives", () => {
+    const result: JSONObject = roundTrip({
+      a: new EqualToOrNull<string>("x"),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(result["a"]).toBeInstanceOf(EqualToOrNull);
+  });
+
+  test("several conditions in one query all survive together", () => {
+    const result: JSONObject = roundTrip({
+      name: new Search("acme"),
+      isEnabled: true,
+      count: new GreaterThan<number>(3),
+      deletedAt: new IsNull(),
+    } as unknown as Dictionary<DictionaryEntryValue>);
+
+    expect(Object.keys(result).sort()).toEqual([
+      "count",
+      "deletedAt",
+      "isEnabled",
+      "name",
+    ]);
+    expect(result["isEnabled"]).toBe(true);
+    expect(result["name"]).toBeInstanceOf(Search);
+  });
+
+  /*
+   * A template is substituted before the component ever sees the value, so at
+   * this point it is just a string — it must not be mistaken for structure.
+   */
+  test("a template placeholder passes through untouched", () => {
+    const result: JSONObject = roundTrip({
+      _id: "{{local.components.api-get-1.returnValues.response-body}}",
+    } as Dictionary<DictionaryEntryValue>);
+
+    expect(result["_id"]).toBe(
+      "{{local.components.api-get-1.returnValues.response-body}}",
+    );
+  });
+
+  test("a record of values to write deserializes to plain values", () => {
+    const stored: string = buildColumnValueJson({
+      name: "acme",
+      isEnabled: true,
+      count: 4,
+    } as Dictionary<DictionaryEntryValue>);
+
+    expect(JSONFunctions.deserialize(JSON.parse(stored))).toEqual({
+      name: "acme",
+      isEnabled: true,
+      count: 4,
+    });
+  });
+
+  test("what the editor emits, the editor can read back", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      name: new Search("acme"),
+      count: new GreaterThan<number>(3),
+    } as unknown as Dictionary<DictionaryEntryValue>;
+
+    const stored: JSONObject = JSON.parse(buildColumnValueJson(rows));
+
+    expect(
+      classifyColumnValueCompatibility(stored, [], ModelColumnEditorMode.Query)
+        .compatible,
+    ).toBe(true);
+  });
+});

package/Tests/UI/Components/Workflow/ModelSchema.test.ts

@@ -0,0 +1,174 @@
+jest.mock("../../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      get: jest.fn(),
+      getFriendlyMessage: jest.fn((err: unknown) => {
+        return String(err);
+      }),
+    },
+  };
+});
+
+import {
+  ModelSchemaColumn,
+  fetchModelSchema,
+  findColumn,
+  isBooleanColumn,
+  isNumericColumn,
+  isScalarColumn,
+} from "../../../../UI/Components/Workflow/ModelSchema";
+import API from "../../../../UI/Utils/API/API";
+import HTTPErrorResponse from "../../../../Types/API/HTTPErrorResponse";
+import { afterEach, describe, expect, test } from "@jest/globals";
+
+type MakeColumnFunction = (
+  overrides: Partial<ModelSchemaColumn>,
+) => ModelSchemaColumn;
+
+const makeColumn: MakeColumnFunction = (
+  overrides: Partial<ModelSchemaColumn>,
+): ModelSchemaColumn => {
+  return {
+    id: "name",
+    title: "Name",
+    type: "ShortText",
+    isRelation: false,
+    ...overrides,
+  };
+};
+
+describe("isScalarColumn", () => {
+  test("accepts the column types a single input can hold", () => {
+    const scalarTypes: Array<string> = [
+      "ShortText",
+      "LongText",
+      "ObjectID",
+      "Number",
+      "Boolean",
+      "Date",
+      "Email",
+      "URL",
+      "Markdown",
+    ];
+
+    for (const type of scalarTypes) {
+      expect(isScalarColumn(makeColumn({ type: type }))).toBe(true);
+    }
+  });
+
+  test("rejects a relation, however it is typed", () => {
+    expect(
+      isScalarColumn(makeColumn({ type: "ShortText", isRelation: true })),
+    ).toBe(false);
+    expect(
+      isScalarColumn(makeColumn({ type: "Entity", isRelation: true })),
+    ).toBe(false);
+  });
+
+  test("rejects types a single box cannot hold", () => {
+    expect(isScalarColumn(makeColumn({ type: "JSON" }))).toBe(false);
+    expect(isScalarColumn(makeColumn({ type: "Buffer" }))).toBe(false);
+    expect(isScalarColumn(makeColumn({ type: "EntityArray" }))).toBe(false);
+  });
+
+  test("rejects a type it has never heard of", () => {
+    expect(isScalarColumn(makeColumn({ type: "SomethingNew" }))).toBe(false);
+  });
+});
+
+describe("isNumericColumn", () => {
+  test("is true for the two numeric types", () => {
+    expect(isNumericColumn(makeColumn({ type: "Number" }))).toBe(true);
+    expect(isNumericColumn(makeColumn({ type: "PositiveNumber" }))).toBe(true);
+  });
+
+  test("is false for everything else", () => {
+    expect(isNumericColumn(makeColumn({ type: "ShortText" }))).toBe(false);
+    expect(isNumericColumn(makeColumn({ type: "Boolean" }))).toBe(false);
+  });
+});
+
+describe("isBooleanColumn", () => {
+  test("is true only for Boolean", () => {
+    expect(isBooleanColumn(makeColumn({ type: "Boolean" }))).toBe(true);
+    expect(isBooleanColumn(makeColumn({ type: "ShortText" }))).toBe(false);
+  });
+});
+
+describe("findColumn", () => {
+  const columns: Array<ModelSchemaColumn> = [
+    makeColumn({ id: "_id" }),
+    makeColumn({ id: "name" }),
+  ];
+
+  test("finds a column by id", () => {
+    expect(findColumn(columns, "_id")?.id).toBe("_id");
+  });
+
+  test("returns nothing for an id that isn't there", () => {
+    expect(findColumn(columns, "id")).toBeUndefined();
+  });
+
+  test("is case sensitive, as column names are", () => {
+    expect(findColumn(columns, "Name")).toBeUndefined();
+  });
+
+  test("copes with an empty list", () => {
+    expect(findColumn([], "name")).toBeUndefined();
+  });
+});
+
+describe("fetchModelSchema", () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  type MockedGetFunction = (value: unknown) => void;
+
+  const mockGet: MockedGetFunction = (value: unknown): void => {
+    (API.get as unknown as jest.Mock).mockResolvedValue(value);
+  };
+
+  test("returns the columns the endpoint sent", async () => {
+    mockGet({
+      data: { tableName: "Monitor", columns: [makeColumn({ id: "_id" })] },
+    });
+
+    const columns: Array<ModelSchemaColumn> = await fetchModelSchema("Monitor");
+
+    expect(columns).toHaveLength(1);
+    expect(columns[0]?.id).toBe("_id");
+  });
+
+  test("returns an empty list when the endpoint sends no columns", async () => {
+    mockGet({ data: { tableName: "Monitor" } });
+
+    await expect(fetchModelSchema("Monitor")).resolves.toEqual([]);
+  });
+
+  test("throws when the endpoint answers with an error", async () => {
+    const errorResponse: HTTPErrorResponse = new HTTPErrorResponse(
+      500,
+      { message: "boom" },
+      {},
+    );
+
+    mockGet(errorResponse);
+
+    await expect(fetchModelSchema("Monitor")).rejects.toBe(errorResponse);
+  });
+
+  test("escapes the table name into the path", async () => {
+    mockGet({ data: { columns: [] } });
+
+    await fetchModelSchema("Weird/Name");
+
+    const call: { url: { toString: () => string } } = (
+      API.get as unknown as jest.Mock
+    ).mock.calls[0][0] as { url: { toString: () => string } };
+
+    expect(call.url.toString()).toContain("Weird%2FName");
+    expect(call.url.toString()).not.toContain("Weird/Name");
+  });
+});