domain: Add id field to server objects.

This id will be passed around in events to uniquely identify a server.
This id is not user generated, it is generated in app by domain-util.ts
and stored in our JSON DB. This commit just adds the logic for
generating and storing the id in the JSON DB. This commit does not make
use of this newly added id, that will be done in further commits to keep
the commits readable.

In further commits, we will also start setting tabId in the rendered
code to this id. We generate a random hex string for this id instead of
having a numeric incremental ID. The reason for this is to avoid
overhead of maintaining an ever increasingly numeric id while trying to
make sure that ID collisions don't happen. Since we don't store our data
in a real database, we can't have incremental primary keys by default
and it makes little sense to implement that on our own, when this field
is just being passed around to communicate b/w code and is not shown to
humans.

Author: shubham-padia

app/common/typed-ipc.ts

@@ -1,5 +1,5 @@
 import type {DndSettings} from "./dnd-util.ts";
-import type {MenuProperties, ServerConfig} from "./types.ts";
+import type {MenuProperties, ServerSettings} from "./types.ts";
 
 export type MainMessage = {
   "clear-app-settings": () => void;
@@ -26,7 +26,7 @@ export type MainMessage = {
 };
 
 export type MainCall = {
-  "get-server-settings": (domain: string) => ServerConfig;
+  "get-server-settings": (domain: string) => ServerSettings;
   "is-online": (url: string) => boolean;
   "poll-clipboard": (key: Uint8Array, sig: Uint8Array) => string | undefined;
   "save-server-icon": (iconURL: string) => string | null;

app/common/types.ts

@@ -12,13 +12,16 @@ export type NavigationItem =
   | "Shortcuts";
 
 export type ServerConfig = {
+  id: string;
   url: string;
   alias: string;
   icon: string;
   zulipVersion: string;
   zulipFeatureLevel: number;
 };
 
+export type ServerSettings = Omit<ServerConfig, "id">;
+
 export type TabRole = "server" | "function";
 export type TabPage = "Settings" | "About";
 

app/main/request.ts

@@ -10,7 +10,7 @@ import {z} from "zod";
 
 import Logger from "../common/logger-util.ts";
 import * as Messages from "../common/messages.ts";
-import type {ServerConfig} from "../common/types.ts";
+import type {ServerSettings} from "../common/types.ts";
 
 /* Request: domain-util */
 
@@ -42,7 +42,7 @@ const generateFilePath = (url: string): string => {
 export const _getServerSettings = async (
   domain: string,
   session: Session,
-): Promise<ServerConfig> => {
+): Promise<ServerSettings> => {
   const response = await session.fetch(domain + "/api/v1/server_settings");
   if (!response.ok) {
     throw new Error(Messages.invalidZulipServerError(domain));

app/renderer/js/utils/domain-util.ts

@@ -1,3 +1,5 @@
+import assert from "node:assert";
+import {randomBytes} from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -11,26 +13,43 @@ import * as EnterpriseUtil from "../../../common/enterprise-util.ts";
 import Logger from "../../../common/logger-util.ts";
 import * as Messages from "../../../common/messages.ts";
 import * as t from "../../../common/translation-util.ts";
-import type {ServerConfig} from "../../../common/types.ts";
+import type {ServerConfig, ServerSettings} from "../../../common/types.ts";
 import defaultIcon from "../../img/icon.png";
 import {ipcRenderer} from "../typed-ipc-renderer.ts";
 
 const logger = new Logger({
   file: "domain-util.log",
 });
 
+export function generateDomainId(): string {
+  return randomBytes(5).toString("hex");
+}
+
 // For historical reasons, we store this string in domain.json to denote a
 // missing icon; it does not change with the actual icon location.
 export const defaultIconSentinel = "../renderer/img/icon.png";
 
-const serverConfigSchema = z.object({
+const storedServerSchema = z.object({
+  id: z.string().optional(),
   url: z.url(),
   alias: z.string(),
   icon: z.string(),
   zulipVersion: z.string().default("unknown"),
   zulipFeatureLevel: z.number().default(0),
 });
 
+const serverConfigSchema = storedServerSchema.extend({
+  id: z.string(),
+});
+
+function addServerId(server: z.infer<typeof storedServerSchema>): ServerConfig {
+  assert.ok(server.id === undefined);
+  return serverConfigSchema.parse({
+    ...server,
+    id: generateDomainId(),
+  });
+}
+
 let database!: JsonDB;
 
 reloadDatabase();
@@ -88,8 +107,8 @@ export async function addDomain(server: {
     server.icon = defaultIconSentinel;
   }
 
-  serverConfigSchema.parse(server);
-  database.push("/domains[]", server, true);
+  const serverWithId = addServerId(storedServerSchema.parse(server));
+  database.push("/domains[]", serverWithId, true);
   reloadDatabase();
 }
 
@@ -117,7 +136,7 @@ export function duplicateDomain(domain: string): boolean {
 export async function checkDomain(
   domain: string,
   silent = false,
-): Promise<ServerConfig> {
+): Promise<ServerSettings> {
   if (!silent && duplicateDomain(domain)) {
     // Do not check duplicate in silent mode
     throw new Error("This server has been added.");
@@ -126,13 +145,13 @@ export async function checkDomain(
   domain = formatUrl(domain);
 
   try {
-    return await getServerSettings(domain);
+    return storedServerSchema.parse(await getServerSettings(domain));
   } catch {
     throw new Error(Messages.invalidZulipServerError(domain));
   }
 }
 
-async function getServerSettings(domain: string): Promise<ServerConfig> {
+async function getServerSettings(domain: string): Promise<ServerSettings> {
   return ipcRenderer.invoke("get-server-settings", domain);
 }
 
@@ -151,7 +170,11 @@ export async function updateSavedServer(
   const serverConfig = getDomain(index);
   const oldIcon = serverConfig.icon;
   try {
-    const newServerConfig = await checkDomain(url, true);
+    const newServerSetting = await checkDomain(url, true);
+    const newServerConfig: ServerConfig = {
+      ...newServerSetting,
+      id: serverConfig.id,
+    };
     const localIconUrl = await saveServerIcon(newServerConfig.icon);
     if (!oldIcon || localIconUrl !== defaultIconSentinel) {
       newServerConfig.icon = localIconUrl;
@@ -168,6 +191,31 @@ export async function updateSavedServer(
   }
 }
 
+function ensureDomainIds(): void {
+  try {
+    const domains = storedServerSchema
+      .array()
+      .parse(database.getObject<unknown>("/domains"));
+
+    let changed = false;
+
+    const updatedDomains = domains.map((server) => {
+      if (server.id === undefined) {
+        changed = true;
+        server = addServerId(server);
+      }
+
+      return server;
+    });
+
+    if (changed) {
+      database.push("/domains", updatedDomains, true);
+    }
+  } catch (error: unknown) {
+    if (!(error instanceof DataError)) throw error;
+  }
+}
+
 function reloadDatabase(): void {
   const domainJsonPath = path.join(
     app.getPath("userData"),
@@ -192,6 +240,7 @@ function reloadDatabase(): void {
   }
 
   database = new JsonDB(domainJsonPath, true, true);
+  ensureDomainIds();
 }
 
 export function formatUrl(domain: string): string {