refactor(cli): update notification handling to use startNotificationFetch

Author: jiashengguo

packages/cli/src/actions/action-utils.ts

@@ -219,39 +219,60 @@ export async function getZenStackPackages(
     return result.filter((p) => !!p);
 }
 
-const FETCH_CLI_CONFIG_TIMEOUT = 500;
-const CLI_CONFIG_ENDPOINT = 'https://zenstack.dev/config/cli.json';
+const FETCH_CLI_MAX_TIME = 1000;
+const CLI_CONFIG_ENDPOINT = 'https://zenstack.dev/config/cli-v3.json';
 
-export async function showNotification() {
-    try {
-        const fetchResult = await fetch(CLI_CONFIG_ENDPOINT, {
-            headers: { accept: 'application/json' },
-            signal: AbortSignal.timeout(FETCH_CLI_CONFIG_TIMEOUT),
-        });
+const notificationSchema = z.object({
+    notifications: z.array(z.object({ title: z.string(), url: z.url().optional(), active: z.boolean() })),
+});
 
-        if (!fetchResult.ok) {
-            return;
-        }
+/**
+ * Starts the notification fetch in the background. Returns a callback that,
+ * when invoked check if the fetch is complete. If not complete, it will wait until the max time is reached.
+ * After that, if fetch is still not complete, just return.
+ */
+export function startNotificationFetch() {
+    let fetchedData: z.infer<typeof notificationSchema> | undefined = undefined;
+    let fetchComplete = false;
 
-        const data = await fetchResult.json();
-        const schema = z.object({
-            notifications: z.array(z.object({ title: z.string(), url: z.url().optional(), active: z.boolean() })),
+    const start = Date.now();
+
+    fetch(CLI_CONFIG_ENDPOINT, {
+        headers: { accept: 'application/json' },
+    })
+        .then(async (res) => {
+            if (!res.ok) return;
+            const data = await res.json();
+            const parseResult = notificationSchema.safeParse(data);
+            if (parseResult.success) {
+                fetchedData = parseResult.data;
+            }
+        })
+        .catch(() => {
+            // noop
+        })
+        .finally(() => {
+            fetchComplete = true;
         });
-        const parseResult = schema.safeParse(data);
 
-        if (parseResult.success) {
-            const activeItems = parseResult.data.notifications.filter((item) => item.active);
-            // return a random active item
-            if (activeItems.length > 0) {
-                const item = activeItems[Math.floor(Math.random() * activeItems.length)]!;
-                if (item.url) {
-                    console.log(terminalLink(item.title, item.url));
-                } else {
-                    console.log(item.title);
-                }
+    return async () => {
+        const elapsed = Date.now() - start;
+
+        if (!fetchComplete && elapsed < FETCH_CLI_MAX_TIME) {
+            // wait for the timeout
+            await new Promise((resolve) => setTimeout(resolve, FETCH_CLI_MAX_TIME - elapsed));
+        }
+
+        if (!fetchComplete || !fetchedData) return;
+        const activeItems = fetchedData.notifications.filter((item) => item.active);
+        // show a random active item
+        if (activeItems.length > 0) {
+            const item = activeItems[Math.floor(Math.random() * activeItems.length)]!;
+            if (item.url) {
+                console.log(terminalLink(item.title, item.url));
+            } else {
+                console.log(item.title);
             }
         }
-    } catch {
-        // noop
-    }
+    };
 }

packages/cli/src/actions/generate.ts

@@ -14,7 +14,7 @@ import { CliError } from '../cli-error';
 import * as corePlugins from '../plugins';
 import { getOutputPath, getSchemaFile, getZenStackPackages, loadSchemaDocument } from './action-utils';
 import semver from 'semver';
-import { showNotification } from './action-utils';
+import { startNotificationFetch } from './action-utils';
 
 type Options = {
     schema?: string;
@@ -37,11 +37,12 @@ export async function run(options: Options) {
     } catch (err) {
         console.warn(colors.yellow(`Failed to check for mismatched ZenStack packages: ${err}`));
     }
+
+    const maybeShowNotification = !options.offline && !options.silent ? startNotificationFetch() : undefined;
+
     const model = await pureGenerate(options, false);
 
-    if (!options.offline && !options.silent) {
-        await showNotification();
-    }
+    await maybeShowNotification?.();
 
     if (options.watch) {
         const logsEnabled = !options.silent;