@oneuptime/common 13.0.1 → 13.0.3

package/UI/Utils/LabelRuleImportExport.ts

@@ -10,9 +10,12 @@ import TableColumnType from "../../Types/Database/TableColumnType";
 import BadDataException from "../../Types/Exception/BadDataException";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
+import { RuleCriteriaFilter } from "../../Types/Rules/RuleCriteria";
 import LabelRuleFile, {
+  LabelRuleCriteriaRelationNames,
   ParsedLabelRuleImport,
 } from "../../Utils/LabelRuleImportExport";
+import { isValidRuleCriteria } from "../../Utils/Rules/RuleCriteriaMatcher";
 import API from "./API/API";
 import ModelAPI from "./ModelAPI/ModelAPI";
 
@@ -60,9 +63,12 @@ export default class LabelRuleImportExport {
       ...data,
       select: LabelRuleFile.getExportSelect(data.modelType),
     });
+    const criteriaRelationNames: LabelRuleCriteriaRelationNames =
+      await this.getCriteriaRelationNames({ ...data, items });
     return LabelRuleFile.buildExportEnvelope({
       modelType: data.modelType,
       items,
+      criteriaRelationNames,
     });
   }
 
@@ -87,22 +93,40 @@ export default class LabelRuleImportExport {
       DatabaseBaseModelType,
       Map<string, Array<string>>
     > = new Map();
+    const relationTypes: Set<DatabaseBaseModelType> = new Set();
     for (const column of relationColumns) {
+      const metadata: TableColumnMetadata =
+        model.getTableColumnMetadata(column)!;
       if (
-        !parsed.items.some(
+        parsed.items.some(
           (item: ParsedLabelRuleImport["items"][number]): boolean => {
             return (item.json[column] as Array<string>).length > 0;
           },
         )
       ) {
-        continue;
+        relationTypes.add(metadata.modelType!);
       }
-      const metadata: TableColumnMetadata =
-        model.getTableColumnMetadata(column)!;
-      const relationType: DatabaseBaseModelType = metadata.modelType!;
-      if (indexes.has(relationType)) {
+    }
+    for (const item of parsed.items) {
+      const criteria: unknown = item.json["criteria"];
+      if (!isValidRuleCriteria(criteria)) {
         continue;
       }
+      for (const filter of criteria.filters) {
+        const metadata: TableColumnMetadata | undefined =
+          model.getTableColumnMetadata(filter.field);
+        if (
+          metadata?.type === TableColumnType.EntityArray &&
+          metadata.modelType &&
+          Array.isArray(filter.value) &&
+          filter.value.length > 0
+        ) {
+          relationTypes.add(metadata.modelType);
+        }
+      }
+    }
+
+    for (const relationType of relationTypes) {
       const relations: Array<BaseModel> = await this.getAll({
         modelType: relationType,
         projectId: data.projectId,
@@ -147,6 +171,41 @@ export default class LabelRuleImportExport {
             },
           );
         }
+        const criteria: unknown = item.json["criteria"];
+        if (isValidRuleCriteria(criteria)) {
+          const filters: Array<RuleCriteriaFilter> = criteria.filters.map(
+            (filter: RuleCriteriaFilter): RuleCriteriaFilter => {
+              const metadata: TableColumnMetadata | undefined =
+                model.getTableColumnMetadata(filter.field);
+              if (
+                metadata?.type !== TableColumnType.EntityArray ||
+                !metadata.modelType ||
+                !Array.isArray(filter.value)
+              ) {
+                return { ...filter };
+              }
+
+              const ids: Array<string> = filter.value.map(
+                (name: string): string => {
+                  const matches: Array<string> =
+                    indexes.get(metadata.modelType!)?.get(name) || [];
+                  if (matches.length !== 1) {
+                    errors.push(
+                      `Rule ${index + 1} (${item.json["name"]}): ${metadata.title || filter.field} "${name}" ${matches.length ? "matches multiple resources" : "was not found"} in the destination project. ${matches.length ? "Give these resources distinct names" : "Create or rename the resource"} before importing.`,
+                    );
+                    return "";
+                  }
+                  return matches[0]!;
+                },
+              );
+              return { ...filter, value: ids };
+            },
+          );
+          json["criteria"] = {
+            ...criteria,
+            filters,
+          } as unknown as JSONObject;
+        }
         return {
           index: index + 1,
           name: item.json["name"] as string,
@@ -279,6 +338,55 @@ export default class LabelRuleImportExport {
     };
   }
 
+  private static async getCriteriaRelationNames(data: {
+    modelType: DatabaseBaseModelType;
+    items: Array<BaseModel>;
+    projectId: ObjectID;
+    modelAPI?: typeof ModelAPI | undefined;
+  }): Promise<LabelRuleCriteriaRelationNames> {
+    const model: BaseModel = new data.modelType();
+    const relationTypes: Set<DatabaseBaseModelType> = new Set();
+
+    for (const item of data.items) {
+      const criteria: unknown = item.getValue("criteria");
+      if (!isValidRuleCriteria(criteria)) {
+        continue;
+      }
+      for (const filter of criteria.filters) {
+        const metadata: TableColumnMetadata | undefined =
+          model.getTableColumnMetadata(filter.field);
+        if (
+          metadata?.type === TableColumnType.EntityArray &&
+          metadata.modelType &&
+          Array.isArray(filter.value) &&
+          filter.value.length > 0
+        ) {
+          relationTypes.add(metadata.modelType);
+        }
+      }
+    }
+
+    const indexes: LabelRuleCriteriaRelationNames = new Map();
+    for (const relationType of relationTypes) {
+      const relations: Array<BaseModel> = await this.getAll({
+        modelType: relationType,
+        projectId: data.projectId,
+        modelAPI: data.modelAPI,
+        select: { _id: true, name: true } as Select<BaseModel>,
+      });
+      const names: Map<string, string> = new Map();
+      for (const relation of relations) {
+        const name: unknown = relation.getValue("name");
+        if (typeof name === "string" && relation.id) {
+          names.set(relation.id.toString(), name);
+        }
+      }
+      indexes.set(relationType, names);
+    }
+
+    return indexes;
+  }
+
   private static async getAll(data: {
     modelType: DatabaseBaseModelType;
     projectId: ObjectID;

package/UI/Utils/Navigation.ts

@@ -1,4 +1,3 @@
-import { AgnosticRouteMatch } from "@remix-run/router";
 import Hostname from "../../Types/API/Hostname";
 import Route from "../../Types/API/Route";
 import URL from "../../Types/API/URL";
@@ -45,7 +44,7 @@ abstract class Navigation {
   }
 
   public static getRoutePath(routes: Array<{ path: string }>): string {
-    const pathes: AgnosticRouteMatch[] | null = matchRoutes(
+    const pathes: ReturnType<typeof matchRoutes> = matchRoutes(
       routes,
       this.location.pathname,
     );

package/UI/esbuild-config.js

@@ -279,6 +279,41 @@ function resolvePackageRoot(packageName) {
   );
 }
 
+/**
+ * Resolve a package SUBPATH (e.g. "react-router/dom") to the file its exports
+ * map publishes, or null when the installed version publishes no such subpath.
+ *
+ * Needed because esbuild's `alias` matches path prefixes: an entry for
+ * "react-router" also rewrites "react-router/dom" to "<root>/dom", a directory
+ * that does not exist on disk because the subpath only exists in the package's
+ * exports map. Aliasing the subpath explicitly, to the file it really resolves
+ * to, is what keeps the prefix alias from swallowing it.
+ *
+ * Returns null rather than throwing: the subpath is only present from
+ * react-router 7 onward, and a version without it needs no alias at all
+ * because nothing imports it.
+ */
+function resolvePackageSubpath(packageName, subpath) {
+  const specifier = `${packageName}/${subpath}`;
+
+  const resolutionPaths = [
+    process.cwd(),
+    __dirname,
+    path.resolve(__dirname, ".."),
+    path.resolve(__dirname, "../.."),
+  ];
+
+  for (const resolutionPath of resolutionPaths) {
+    try {
+      return require.resolve(specifier, { paths: [resolutionPath] });
+    } catch (error) {
+      continue;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Create esbuild configuration for a service
  * @param {Object} options - Configuration options
@@ -306,6 +341,7 @@ function createConfig(options) {
   const reactRoot = resolvePackageRoot("react");
   const reactDomRoot = resolvePackageRoot("react-dom");
   const reactRouterRoot = resolvePackageRoot("react-router");
+  const reactRouterDomSubpath = resolvePackageSubpath("react-router", "dom");
   const reactRouterDomRoot = resolvePackageRoot("react-router-dom");
   const reactI18nextRoot = resolvePackageRoot("react-i18next");
   const i18nextRoot = resolvePackageRoot("i18next");
@@ -365,6 +401,16 @@ function createConfig(options) {
       // Public dashboards reuse widgets from the private dashboard package.
       // Their links must share the router context installed by the entry app.
       "react-router": reactRouterRoot,
+      /*
+       * react-router-dom 7 re-exports from "react-router/dom". The prefix
+       * alias above would rewrite that to "<reactRouterRoot>/dom", which is
+       * not a path on disk, and the bundle fails to build entirely. Point the
+       * subpath at the file its exports map names - the same shape as the
+       * react/jsx-runtime entries above.
+       */
+      ...(reactRouterDomSubpath
+        ? { "react-router/dom": reactRouterDomSubpath }
+        : {}),
       "react-router-dom": reactRouterDomRoot,
       // Force a single instance of i18next/react-i18next so that translations
       // initialized in the service entry are visible to Common UI components.

package/Utils/Faker.ts

@@ -2,11 +2,88 @@ import Email from "../Types/Email";
 import Name from "../Types/Name";
 import ObjectID from "../Types/ObjectID";
 import Phone from "../Types/Phone";
-import { faker } from "@faker-js/faker";
+
+/*
+ * Random values for tests and seed data.
+ *
+ * This deliberately does NOT use @faker-js/faker. The advisory on that package
+ * (GHSA-qxc2-j82w-r537, arbitrary code execution through helpers.fake) is only
+ * fixed in v10.6+, and every version from v10 ships as ESM only - which Jest,
+ * running CommonJS here, cannot load. Importing it from this file therefore
+ * took down whole suites in Home, App and Common, none of which use faker for
+ * anything beyond the four generators below.
+ *
+ * They are four generators. Owning them costs less than carrying a dependency
+ * with a remote-code-execution advisory into every test process, and none of
+ * this needs to be cryptographically random: it exists to make one test's row
+ * distinguishable from another's.
+ */
+
+const ALPHANUMERIC: string =
+  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+const FIRST_NAMES: Array<string> = [
+  "Ada",
+  "Grace",
+  "Alan",
+  "Edsger",
+  "Barbara",
+  "Ken",
+  "Margaret",
+  "Donald",
+  "Radia",
+  "Leslie",
+];
+
+const LAST_NAMES: Array<string> = [
+  "Lovelace",
+  "Hopper",
+  "Turing",
+  "Dijkstra",
+  "Liskov",
+  "Thompson",
+  "Hamilton",
+  "Knuth",
+  "Perlman",
+  "Lamport",
+];
+
+const COMPANY_ADJECTIVES: Array<string> = [
+  "Northern",
+  "Atlantic",
+  "Granite",
+  "Harbour",
+  "Meridian",
+  "Copper",
+];
+
+const COMPANY_NOUNS: Array<string> = [
+  "Logistics",
+  "Systems",
+  "Analytics",
+  "Foundry",
+  "Networks",
+  "Works",
+];
+
+type PickFunction = <T>(values: Array<T>) => T;
+
+const pick: PickFunction = <T>(values: Array<T>): T => {
+  return values[Math.floor(Math.random() * values.length)] as T;
+};
 
 export default class Faker {
   public static generateRandomString(length?: number | undefined): string {
-    return faker.string.alphanumeric(length || 10);
+    const size: number = length || 10;
+    let value: string = "";
+
+    for (let index: number = 0; index < size; index++) {
+      value += ALPHANUMERIC.charAt(
+        Math.floor(Math.random() * ALPHANUMERIC.length),
+      );
+    }
+
+    return value;
   }
 
   public static getNumberBetweenMinAndMax(data: {
@@ -18,11 +95,11 @@ export default class Faker {
   }
 
   public static generateName(): string {
-    return faker.string.alphanumeric(10);
+    return this.generateRandomString(10);
   }
 
   public static generateCompanyName(): string {
-    return faker.company.name();
+    return `${pick(COMPANY_ADJECTIVES)} ${pick(COMPANY_NOUNS)}`;
   }
 
   public static generateRandomObjectID(): ObjectID {
@@ -39,11 +116,21 @@ export default class Faker {
   }
 
   public static generateUserFullName(): Name {
-    return new Name(faker.person.fullName());
+    return new Name(`${pick(FIRST_NAMES)} ${pick(LAST_NAMES)}`);
   }
 
   public static generateEmail(): Email {
-    return new Email(faker.internet.email());
+    /*
+     * Lowercased, and the local part always starts with a letter: Email
+     * validates what it is given and throws on anything it does not accept, so
+     * a generator that can emit an invalid address would fail a caller at
+     * random rather than at a fixed input.
+     */
+    const localPart: string = `${pick(FIRST_NAMES).toLowerCase()}.${this.generateRandomString(
+      8,
+    ).toLowerCase()}`;
+
+    return new Email(`${localPart}@example.com`);
   }
 
   public static generatePhone(): Phone {