@oneuptime/common 11.7.1 → 11.7.2

package/UI/Components/Table/Table.tsx

@@ -78,9 +78,19 @@ export interface ComponentProps<T extends GenericObject> {
   bulkSelectedItems?: Array<T> | undefined;
   onBulkSelectedItemAdded?: ((item: T) => void) | undefined;
   onBulkSelectedItemRemoved?: ((item: T) => void) | undefined;
-  onBulkSelectAllItems?: (() => void) | undefined;
+  /*
+   * Resolves to whether every matching row really got selected. The table
+   * only claims "all items selected" when it did - otherwise a failed
+   * select-all would hide the Select All button while leaving just the
+   * current page selected, with no way to retry.
+   */
+  onBulkSelectAllItems?: (() => Promise<boolean>) | undefined;
   onBulkSelectItemsOnCurrentPage?: (() => void) | undefined;
   onBulkClearAllItems?: (() => void) | undefined;
+  bulkSelectionError?: string | undefined;
+  isBulkSelectAllLoading?: boolean | undefined;
+  isBulkSelectionTruncated?: boolean | undefined;
+  bulkSelectionTotalCount?: number | undefined;
   matchBulkSelectedItemByField?: keyof T | undefined; // which field to use to match selected items. For exmaple this could be '_id'
   onBulkActionEnd?: (() => void) | undefined;
   onBulkActionStart?: (() => void) | undefined;
@@ -156,6 +166,18 @@ const Table: TableFunction = <T extends GenericObject>(
   useEffect(() => {
     if (props.bulkSelectedItems) {
       setBulkSelectedItems(props.bulkSelectedItems);
+
+      /*
+       * "All items selected" is a claim about a selection that exists, so it
+       * cannot outlive one. The parent drops the selection whenever the query
+       * changes underneath it (and after a bulk action completes), and this
+       * state is local to the table - without this, the next single row the
+       * user ticked would re-open the bulk bar with the "Select All" button
+       * still hidden, as though everything matching were already selected.
+       */
+      if (props.bulkSelectedItems.length === 0) {
+        setIsAllItemsSelected(false);
+      }
     }
   }, [props.bulkSelectedItems]);
 
@@ -238,16 +260,20 @@ const Table: TableFunction = <T extends GenericObject>(
           if (props.matchBulkSelectedItemByField === undefined) {
             return;
           }
-          const index: number = bulkSelectedItems.findIndex((x: T) => {
-            return (
-              x[props.matchBulkSelectedItemByField!]?.toString() ===
-              item[props.matchBulkSelectedItemByField!]?.toString()
-            );
-          });
 
-          if (index > -1) {
-            bulkSelectedItems.splice(index, 1);
-          }
+          /*
+           * Rebuild rather than splice: this array is the parent's state
+           * array by reference (see the sync effect above), so mutating it
+           * in place edits React state behind React's back.
+           */
+          setBulkSelectedItems(
+            bulkSelectedItems.filter((x: T) => {
+              return (
+                x[props.matchBulkSelectedItemByField!]?.toString() !==
+                item[props.matchBulkSelectedItemByField!]?.toString()
+              );
+            }),
+          );
 
           props.onBulkSelectedItemRemoved?.(item);
         }}
@@ -301,14 +327,27 @@ const Table: TableFunction = <T extends GenericObject>(
             props.onBulkClearAllItems?.();
             setIsAllItemsSelected(false);
           }}
-          onSelectAllClick={() => {
-            props.onBulkSelectAllItems?.();
-            setIsAllItemsSelected(true);
+          onSelectAllClick={async () => {
+            const didSelectAllItems: boolean =
+              (await props.onBulkSelectAllItems?.()) ?? false;
+
+            /*
+             * Only on success. Otherwise the bulk bar would hide the Select
+             * All button and claim everything was selected while the
+             * selection is still just the current page.
+             */
+            if (didSelectAllItems) {
+              setIsAllItemsSelected(true);
+            }
           }}
           selectedItems={bulkSelectedItems}
           singularLabel={translatedSingularLabel}
           pluralLabel={translatedPluralLabel}
           isAllItemsSelected={isAllItemsSelected}
+          errorMessage={props.bulkSelectionError}
+          isSelectingAllItems={props.isBulkSelectAllLoading}
+          isSelectionTruncated={props.isBulkSelectionTruncated}
+          totalMatchingItemsCount={props.bulkSelectionTotalCount}
           onActionStart={props.onBulkActionStart}
           onActionEnd={() => {
             setIsAllItemsSelected(false);

package/UI/Components/Table/Types/Column.ts

@@ -15,6 +15,24 @@ export default interface Column<T extends GenericObject> {
   alignItem?: AlignItem | undefined;
   key?: keyof T | null; //can be null because actions column does not have a key.
   hideOnMobile?: boolean | undefined; // Hide column on mobile devices
+  /*
+   * Every field that backs this cell, in declaration order. A ModelTable
+   * column may declare more than one - e.g. the alert "Affected Resources"
+   * cell spans hosts / kubernetesClusters / dockerHosts / podmanHosts /
+   * services - while `key` only ever holds the first one, because that is the
+   * one used for sorting and for the default renderer. CSV export reads all
+   * of them so it does not silently drop the rest. Defaults to [key].
+   */
+  exportKeys?: Array<string> | undefined;
+  /*
+   * Exact text for this column's CSV cell, overriding the value read off the
+   * row. Use it when the rendered cell is built from something the row does
+   * not carry under the column's own field (data fetched alongside the table,
+   * a computed summary, several fields combined into one phrase).
+   */
+  getExportValue?: ((item: T) => string) | undefined;
+  // Leave this column out of the CSV export entirely.
+  disableCsvExport?: boolean | undefined;
   getElement?:
     | ((item: T, onBeforeFetchData?: T | undefined) => ReactElement)
     | undefined;

package/UI/Utils/Project.ts

@@ -4,7 +4,7 @@ import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBas
 import SubscriptionPlan, {
   PlanType,
 } from "../../Types/Billing/SubscriptionPlan";
-import { JSONObject } from "../../Types/JSON";
+import { JSONObject, JSONValue } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import Project from "../../Models/DatabaseModels/Project";
 import SubscriptionStatus, {
@@ -14,29 +14,193 @@ import Navigation from "./Navigation";
 import SessionStorage from "./SessionStorage";
 import Telemetry from "./Telemetry/Telemetry";
 
+/**
+ * Session storage key that pins a browser tab to the project it is showing.
+ * Session storage (and not local storage) so two tabs can show two different
+ * projects at the same time.
+ */
+export const CURRENT_PROJECT_ID_STORAGE_KEY: string = "current_project_id";
+
+/**
+ * Local storage key that remembers the last project the user opened on this
+ * browser. Unlike {@link CURRENT_PROJECT_ID_STORAGE_KEY} this survives closing
+ * the tab, which is what makes the dashboard reopen on the project the user
+ * left off on instead of always falling back to the first project.
+ */
+export const LAST_ACCESSED_PROJECT_ID_STORAGE_KEY: string =
+  "last_accessed_project_id";
+
 export default class ProjectUtil {
+  /**
+   * The project the user is currently looking at, resolved in priority order:
+   *
+   * 1. `/dashboard/:projectId/...` in the URL - the page the user actually
+   *    opened, so a deep link always wins over anything we have cached.
+   * 2. `current_project_id` in session storage - keeps this tab on the project
+   *    it was already showing while the user moves around routes that do not
+   *    carry a project id (e.g. `/dashboard`).
+   * 3. `last_accessed_project_id` in local storage - the project this user last
+   *    opened on this browser, so closing the tab and coming back to
+   *    `/dashboard` reopens that project rather than the first one.
+   */
   public static getCurrentProjectId(): ObjectID | null {
-    // if this is not available in the url, check the session storage
-    const currentProjectId: string | undefined = SessionStorage.getItem(
-      `current_project_id`,
-    ) as string;
+    const projectIdInUrl: ObjectID | null = this.getProjectIdFromUrl();
 
-    if (currentProjectId && ObjectID.isValidUUID(currentProjectId)) {
-      return new ObjectID(currentProjectId);
+    if (projectIdInUrl) {
+      return projectIdInUrl;
     }
 
-    let projectId: string | undefined = Navigation.getFirstParam(2);
+    const projectIdInSession: ObjectID | null = this.toProjectId(
+      SessionStorage.getItem(CURRENT_PROJECT_ID_STORAGE_KEY),
+    );
 
-    if (projectId && projectId.includes(":projectId")) {
-      projectId = undefined;
+    if (projectIdInSession) {
+      return projectIdInSession;
     }
 
-    // Only return the projectId if it's a valid UUID
-    if (projectId && ObjectID.isValidUUID(projectId)) {
-      return new ObjectID(projectId);
+    return this.getLastAccessedProjectId();
+  }
+
+  /**
+   * The project id in the current URL, if the user is on a project scoped route
+   * like `/dashboard/:projectId/...`. Returns null on routes that carry no
+   * project id (`/dashboard`, `/dashboard/welcome`, ...).
+   */
+  public static getProjectIdFromUrl(): ObjectID | null {
+    const projectId: string | undefined = Navigation.getFirstParam(2);
+
+    if (!projectId || projectId.includes(":projectId")) {
+      return null;
     }
 
-    return null;
+    return this.toProjectId(projectId);
+  }
+
+  /**
+   * The last project this user opened on this browser. Persisted in local
+   * storage so it outlives the tab. It is cleared on logout (which clears all
+   * of local storage) and when the project is deleted.
+   */
+  public static getLastAccessedProjectId(): ObjectID | null {
+    return this.toProjectId(
+      LocalStorage.getItem(LAST_ACCESSED_PROJECT_ID_STORAGE_KEY),
+    );
+  }
+
+  public static setLastAccessedProjectId(
+    projectId: ObjectID | string | null | undefined,
+  ): void {
+    const id: ObjectID | null = this.toProjectId(projectId);
+
+    if (!id) {
+      // Never persist junk - an unusable value would only shadow the fallbacks.
+      this.clearLastAccessedProjectId();
+      return;
+    }
+
+    LocalStorage.setItem(LAST_ACCESSED_PROJECT_ID_STORAGE_KEY, id.toString());
+  }
+
+  public static clearLastAccessedProjectId(): void {
+    LocalStorage.removeItem(LAST_ACCESSED_PROJECT_ID_STORAGE_KEY);
+  }
+
+  /**
+   * Picks the project the dashboard should load out of the projects the user
+   * has access to.
+   *
+   * Candidates are tried in order - current project (URL / this tab), then the
+   * last project opened on this browser, then the first project the user has
+   * access to. A candidate that is not in `projects` is skipped, because the
+   * user may have left, lost access to, or deleted it since.
+   */
+  public static getProjectToSelect(data: {
+    projects: Array<Project>;
+    currentProjectId?: ObjectID | null | undefined;
+    lastAccessedProjectId?: ObjectID | null | undefined;
+  }): Project | null {
+    const projects: Array<Project> = this.getSelectableProjects(data.projects);
+
+    const candidateIds: Array<ObjectID | null | undefined> = [
+      data.currentProjectId,
+      data.lastAccessedProjectId,
+    ];
+
+    for (const candidateId of candidateIds) {
+      if (!candidateId) {
+        continue;
+      }
+
+      const project: Project | undefined = projects.find((project: Project) => {
+        return project._id?.toString() === candidateId.toString();
+      });
+
+      if (project) {
+        return project;
+      }
+    }
+
+    return projects[0] || null;
+  }
+
+  /**
+   * {@link getProjectToSelect} with the candidates read off storage / the URL.
+   */
+  public static getProjectToLoad(projects: Array<Project>): Project | null {
+    return this.getProjectToSelect({
+      projects: projects,
+      currentProjectId: this.getCurrentProjectId(),
+      lastAccessedProjectId: this.getLastAccessedProjectId(),
+    });
+  }
+
+  /**
+   * The project the dashboard should switch to now that the list of projects
+   * the user has access to has (re)loaded, or null when whatever is already
+   * selected should stand.
+   *
+   * A selection is left alone as long as the user still has access to it -
+   * otherwise a project the user just picked (or just created) would be
+   * overruled by whatever we happened to have remembered.
+   */
+  public static getProjectToSelectOnProjectsLoaded(data: {
+    projects: Array<Project>;
+    selectedProject?: Project | null | undefined;
+  }): Project | null {
+    const projects: Array<Project> = this.getSelectableProjects(data.projects);
+
+    if (projects.length === 0) {
+      // Nothing to select yet - the list is still loading, or the user has no projects.
+      return null;
+    }
+
+    const selectedProjectId: string | undefined =
+      data.selectedProject?._id?.toString();
+
+    const isSelectionStillAccessible: boolean = Boolean(
+      selectedProjectId &&
+        projects.some((project: Project) => {
+          return project._id?.toString() === selectedProjectId;
+        }),
+    );
+
+    if (isSelectionStillAccessible) {
+      return null;
+    }
+
+    return this.getProjectToLoad(projects);
+  }
+
+  /**
+   * The projects that can actually be opened - a project without an id cannot
+   * be navigated to (`/dashboard/undefined`), so it is never a candidate.
+   */
+  private static getSelectableProjects(
+    projects: Array<Project> | null | undefined,
+  ): Array<Project> {
+    return (projects || []).filter((project: Project) => {
+      return Boolean(project?._id);
+    });
   }
 
   public static setIsSubscriptionInactiveOrOverdue(data: {
@@ -91,12 +255,19 @@ export default class ProjectUtil {
   public static getCurrentProject(): Project | null {
     const currentProjectId: string | undefined =
       this.getCurrentProjectId()?.toString();
-    if (!LocalStorage.getItem(`project_${currentProjectId}`)) {
+
+    if (!currentProjectId) {
       return null;
     }
+
     const projectJson: JSONObject = LocalStorage.getItem(
       `project_${currentProjectId}`,
     ) as JSONObject;
+
+    if (!projectJson) {
+      return null;
+    }
+
     return BaseModel.fromJSON(projectJson, Project) as Project;
   }
 
@@ -107,7 +278,10 @@ export default class ProjectUtil {
       project = BaseModel.toJSON(project, Project);
     }
     LocalStorage.setItem(`project_${currentProjectId}`, project);
-    SessionStorage.setItem(`current_project_id`, currentProjectId);
+    SessionStorage.setItem(CURRENT_PROJECT_ID_STORAGE_KEY, currentProjectId);
+
+    // Remember this project for the next time the user opens the dashboard.
+    this.setLastAccessedProjectId(currentProjectId);
 
     // Keep RUM span context in sync with the project being viewed.
     if (currentProjectId) {
@@ -118,8 +292,18 @@ export default class ProjectUtil {
   public static clearCurrentProject(): void {
     const currentProjectId: string | undefined =
       this.getCurrentProjectId()?.toString();
-    LocalStorage.setItem(`project_${currentProjectId}`, null);
-    SessionStorage.setItem(`current_project_id`, null);
+
+    if (currentProjectId) {
+      LocalStorage.removeItem(`project_${currentProjectId}`);
+    }
+
+    SessionStorage.removeItem(CURRENT_PROJECT_ID_STORAGE_KEY);
+
+    /*
+     * The project is gone (or the user is leaving it), so it must not be
+     * reopened the next time the dashboard loads.
+     */
+    this.clearLastAccessedProjectId();
   }
 
   public static getCurrentPlan(): PlanType | null {
@@ -137,4 +321,16 @@ export default class ProjectUtil {
       getAllEnvVars(),
     );
   }
+
+  private static toProjectId(
+    value: JSONValue | ObjectID | string | null | undefined,
+  ): ObjectID | null {
+    const id: string | undefined = value?.toString();
+
+    if (id && ObjectID.isValidUUID(id)) {
+      return new ObjectID(id);
+    }
+
+    return null;
+  }
 }

package/UI/Utils/TableColumnsToCsv.ts

@@ -262,9 +262,58 @@ export default class TableColumnsToCsv {
     return null;
   }
 
+  /*
+   * The fields a column contributes to the export. A ModelTable column can
+   * declare several (a cell that renders hosts + clusters + services in one
+   * place), and BaseModelTable forwards all of them as exportKeys; `key`
+   * alone is only the first. Falls back to the single key for tables that
+   * build their Table columns by hand.
+   */
+  public static getExportKeys<T extends GenericObject>(
+    column: Column<T>,
+  ): Array<string> {
+    if (column.exportKeys && column.exportKeys.length > 0) {
+      return column.exportKeys;
+    }
+
+    if (column.key === null || column.key === undefined) {
+      return [];
+    }
+
+    return [String(column.key)];
+  }
+
+  /*
+   * A column that renders entirely through getElement still has to declare a
+   * field so the row gets fetched at all, and the convention for that is
+   * `field: { _id: true }` - the "Owners" column on alerts, incidents,
+   * monitors and friends. The id is plumbing, not the cell's value, so
+   * exporting it writes a raw UUID under a header like "Owners". Treat such a
+   * column as presentational and leave it out, the same way a column with no
+   * key at all is left out. A column that genuinely shows the id says so with
+   * FieldType.ObjectID, and one that wants its rendered content in the file
+   * says so with getExportValue.
+   */
+  public static isPlaceholderIdColumn<T extends GenericObject>(
+    column: Column<T>,
+  ): boolean {
+    if (!column.getElement) {
+      return false;
+    }
+
+    if (column.type === FieldType.ObjectID) {
+      return false;
+    }
+
+    const keys: Array<string> = this.getExportKeys(column);
+
+    return keys.length === 1 && keys[0] === "_id";
+  }
+
   /*
    * Columns that can be exported: everything except the Actions column (which
-   * only holds buttons) and columns without a data key (purely presentational).
+   * only holds buttons), columns that opted out, columns without a data key
+   * (purely presentational), and placeholder id columns.
    */
   public static getExportableColumns<T extends GenericObject>(
     columns: Columns<T>,
@@ -274,7 +323,20 @@ export default class TableColumnsToCsv {
         return false;
       }
 
-      if (column.key === null || column.key === undefined) {
+      if (column.disableCsvExport) {
+        return false;
+      }
+
+      // An explicit export value makes even a keyless column exportable.
+      if (column.getExportValue) {
+        return true;
+      }
+
+      if (this.getExportKeys(column).length === 0) {
+        return false;
+      }
+
+      if (this.isPlaceholderIdColumn(column)) {
         return false;
       }
 
@@ -286,13 +348,31 @@ export default class TableColumnsToCsv {
     item: T,
     column: Column<T>,
   ): string {
-    if (column.key === null || column.key === undefined) {
-      return "";
+    if (column.getExportValue) {
+      return column.getExportValue(item) || "";
     }
 
-    const rawValue: unknown = this.getRawValueByPath(item, String(column.key));
+    /*
+     * Every declared field goes into the one cell, joined the same way a
+     * multi-value field is, so a cell that renders several relations exports
+     * all of them. Blanks are dropped (only one of the relations is usually
+     * set) and repeats are collapsed (the same entity reachable through two
+     * of them should not be listed twice).
+     */
+    const values: Array<string> = [];
+
+    for (const key of this.getExportKeys(column)) {
+      const formatted: string = this.formatValueForCsv(
+        this.getRawValueByPath(item, key),
+        column.type,
+      );
+
+      if (formatted.length > 0 && !values.includes(formatted)) {
+        values.push(formatted);
+      }
+    }
 
-    return this.formatValueForCsv(rawValue, column.type);
+    return values.join("; ");
   }
 
   /*

package/UI/esbuild-config.js

@@ -182,6 +182,25 @@ function createFileLoaderPlugin() {
   };
 }
 
+// Copy Monaco's runtime next to the bundle so the editor loads from this
+// install instead of cdn.jsdelivr.net, which is unreachable when self-hosted
+// offline. Only min/vs is copied - the rest of the package is sources and
+// type definitions the browser never asks for.
+//
+// Every frontend gets a copy. Forms/Fields/FormField.tsx imports CodeEditor
+// directly, so every service that renders a form pulls the editor into its
+// bundle - there is no service to skip. Gating this on the built output only
+// looked selective; it matched all five services and risked a silent offline
+// 404 the moment a code field showed up somewhere unexpected.
+function copyMonacoAssets(outdir) {
+  const source = path.join(resolvePackageRoot("monaco-editor"), "min", "vs");
+  const destination = path.resolve(path.dirname(outdir), "assets/monaco/vs");
+
+  fs.rmSync(destination, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.cpSync(source, destination, { recursive: true });
+}
+
 // Read environment variables from .env file
 function readEnvFile(pathToFile) {
   if (!fs.existsSync(pathToFile)) {
@@ -265,6 +284,11 @@ function createConfig(options) {
     splitting: true,
     publicPath,
     define: {
+      // Monaco resolves its runtime against this at load time. import.meta is
+      // empty at the es2017 target, so the path has to come from the build.
+      "process.env.MONACO_ASSET_PATH": JSON.stringify(
+        `${publicPath.replace(/dist\/$/, "")}assets/monaco/vs`,
+      ),
       "process.env.NODE_ENV": JSON.stringify(
         isDev ? "development" : "production",
       ),
@@ -319,6 +343,9 @@ async function build(config, serviceName) {
   try {
     const result = await esbuild.build(config);
 
+    copyMonacoAssets(config.outdir);
+    console.log(`📦 Copied Monaco assets for ${serviceName}`);
+
     if (isAnalyze && result.metafile) {
       const analyzeText = await esbuild.analyzeMetafile(result.metafile);
       console.log(`\n📊 Bundle analysis for ${serviceName}:`);
@@ -345,6 +372,13 @@ async function build(config, serviceName) {
 async function watch(config, serviceName) {
   try {
     const context = await esbuild.context(config);
+
+    // The copy no longer reads the built output, so it can run before the
+    // first build instead of forcing an extra one just to have something to
+    // inspect. context.watch() does the initial build on its own.
+    copyMonacoAssets(config.outdir);
+    console.log(`📦 Copied Monaco assets for ${serviceName}`);
+
     await context.watch();
     console.log(`👀 Watching ${serviceName} for changes...`);
   } catch (error) {

package/Utils/Monitor/MonitorProbeSelectionUtil.ts

@@ -0,0 +1,72 @@
+/*
+ * Which probes a brand-new monitor starts out with.
+ *
+ * The server applies this same rule in
+ * MonitorService.addDefaultProbesToMonitor (as a database query rather than a
+ * filter over a list). The create form uses it to pre-select the probe picker,
+ * so what the user sees before pressing "Create Monitor" is what they would
+ * have got anyway - and can now change.
+ */
+
+export interface ProbeSelectionCandidate {
+  id: string;
+  isGlobalProbe: boolean;
+  shouldAutoEnableProbeOnNewMonitors: boolean;
+}
+
+export default class MonitorProbeSelectionUtil {
+  /*
+   * A probe is auto-enabled on new monitors when it opts in with
+   * shouldAutoEnableProbeOnNewMonitors - except that global probes are skipped
+   * entirely for projects that turned off "add global probes by default".
+   */
+  public static getDefaultSelectedProbeIds(data: {
+    probes: Array<ProbeSelectionCandidate>;
+    doNotAddGlobalProbesByDefaultOnNewMonitors?: boolean | undefined;
+  }): Array<string> {
+    const skipGlobalProbes: boolean =
+      data.doNotAddGlobalProbesByDefaultOnNewMonitors === true;
+
+    const selected: Array<string> = [];
+
+    for (const probe of data.probes || []) {
+      if (!probe || !probe.id) {
+        continue;
+      }
+
+      if (!probe.shouldAutoEnableProbeOnNewMonitors) {
+        continue;
+      }
+
+      if (probe.isGlobalProbe && skipGlobalProbes) {
+        continue;
+      }
+
+      selected.push(probe.id);
+    }
+
+    return MonitorProbeSelectionUtil.dedupeProbeIds(selected);
+  }
+
+  /*
+   * Probe ids reach the server as plain strings and the same probe can be
+   * offered by more than one source, so duplicates have to go: MonitorProbe
+   * has no unique index and MonitorProbeService rejects the second insert with
+   * "Probe is already added to this monitor."
+   */
+  public static dedupeProbeIds(probeIds: Array<string>): Array<string> {
+    const seen: Set<string> = new Set<string>();
+    const deduped: Array<string> = [];
+
+    for (const probeId of probeIds || []) {
+      if (!probeId || seen.has(probeId)) {
+        continue;
+      }
+
+      seen.add(probeId);
+      deduped.push(probeId);
+    }
+
+    return deduped;
+  }
+}

package/build/dist/Models/DatabaseModels/DashboardDomain.js

@@ -351,6 +351,7 @@ __decorate([
         description: "Full domain of your dashboard (like dashboard.acmeinc.com). This is autogenerated and is derived from subdomain and domain.",
         example: "dashboard.acmeinc.com",
     }),
+    Index(),
     Column({
         nullable: false,
         type: ColumnType.ShortText,