@firestitch/system 18.0.42 → 18.0.44

package/app/modules/system/components/dashboard/dashboard.component.d.ts

@@ -1,14 +1,22 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { BuildData } from '@firestitch/build';
+import { Observable } from 'rxjs';
 import { DashboardAction } from './../../interfaces/dashboard-action';
 import * as i0 from "@angular/core";
 export declare class DashboardComponent implements OnInit, OnDestroy {
     private _message;
     private _cdRef;
     private _buildService;
-    init: () => any;
-    upgrade: () => any;
-    load: () => any;
+    private _process;
+    private _api;
+    /**
+     * All three are optional. Left unset, the component reads the standard system
+     * endpoints itself — the paths every application using this library already
+     * serves. One is supplied only to point the component somewhere else.
+     */
+    init: () => Observable<any>;
+    upgrade: () => Observable<any>;
+    load: () => Observable<any>;
     actions: DashboardAction[];
     dashboard: any;
     buttonActions: DashboardAction[];
@@ -19,7 +27,43 @@ export declare class DashboardComponent implements OnInit, OnDestroy {
     ngOnDestroy(): void;
     actionClick(action: any): void;
     initClick(): void;
+    /**
+     * Run the pending upgrades as a process rather than behind a spinner.
+     *
+     * A spinner says the same thing for ten seconds and for ten minutes, which is
+     * the whole problem: an upgrade that rebuilds the largest table in a schema
+     * looks exactly like one that has hung, and the only way anybody found out
+     * which was to wait for a proxy to give up.
+     *
+     * Works whether or not the application's endpoint streams. Where it does, each
+     * NDJSON event becomes a line in the process log — which function is running,
+     * how far through it is, what each one cost. Where it does not, the single
+     * reply produces no lines and the process is simply a labelled spinner, which
+     * is what every application had before this.
+     */
     upgradeClick(): void;
+    /**
+     * One emission off the upgrade endpoint, as a line for the process log — or
+     * null for anything with nothing to say, which is dropped rather than logged.
+     *
+     * `FsApi.stream()` wraps every NDJSON line in a `StreamEventData`, and
+     * `FsProcess` logs a string emission verbatim. So the mapping happens here: an
+     * object handed to the log renders as `[object Object]`.
+     *
+     * `ping` is deliberately silent. It is the heartbeat that stops a proxy
+     * closing a run that is still working, it fires after every statement, and it
+     * would bury the events worth reading.
+     */
+    private _upgradeLine;
+    private _dashboardGet;
+    private _init;
+    /**
+     * The upgrade endpoint is read as a stream by default, which is what fills the
+     * process log line by line while the run is still going. An application that
+     * supplies its own `upgrade` decides for itself — a plain request emits once,
+     * produces no lines, and the process is a labelled spinner.
+     */
+    private _upgrade;
     private _load;
     static ɵfac: i0.ɵɵFactoryDeclaration<DashboardComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DashboardComponent, "fs-system-dashboard", never, { "init": { "alias": "init"; "required": false; }; "upgrade": { "alias": "upgrade"; "required": false; }; "load": { "alias": "load"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; }, {}, never, never, true, never>;

package/app/modules/system/interfaces/index.d.ts

@@ -2,3 +2,4 @@ export * from './dashboard-action';
 export * from './process-action';
 export * from './process';
 export * from './system-config';
+export * from './upgrade-event';

package/app/modules/system/interfaces/upgrade-event.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One NDJSON line off a streaming upgrade endpoint.
+ *
+ * The framework's system view streams these only when the caller asks for a
+ * stream, so an application that has not opted in emits an ordinary reply and
+ * none of this applies — see `DashboardComponent._upgradeLine()`, which treats
+ * anything unrecognised as having nothing to log.
+ *
+ * `start` arrives once with the full list of pending functions, because "working
+ * on 2 of 9" is only meaningful to somebody who was told there were 9. `upgrade`
+ * arrives twice per function, on either side of it, carrying what it cost.
+ * `ping` is the heartbeat and says nothing.
+ */
+export interface UpgradeEvent {
+    type: 'start' | 'upgrade' | 'log' | 'ping' | 'done';
+    state?: 'started' | 'completed' | 'failed';
+    name?: string;
+    index?: number;
+    total?: number;
+    completed?: number;
+    duration?: string;
+    seconds?: number;
+    message?: string;
+    functions?: string[];
+}

package/esm2022/app/modules/system/components/dashboard/dashboard.component.mjs

@@ -1,8 +1,10 @@
 import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, inject } from '@angular/core';
+import { FsApi, StreamEventData } from '@firestitch/api';
 import { FsBuildService } from '@firestitch/build';
 import { FsMessage } from '@firestitch/message';
+import { FsProcess, ProcessState } from '@firestitch/process';
 import { Subject } from 'rxjs';
-import { takeUntil } from 'rxjs/operators';
+import { filter, map, take, takeUntil } from 'rxjs/operators';
 import { differenceInMinutes } from 'date-fns';
 import { FsSkeletonModule } from '@firestitch/skeleton';
 import { FsLabelModule } from '@firestitch/label';
@@ -21,6 +23,13 @@ export class DashboardComponent {
     _message = inject(FsMessage);
     _cdRef = inject(ChangeDetectorRef);
     _buildService = inject(FsBuildService);
+    _process = inject(FsProcess);
+    _api = inject(FsApi);
+    /**
+     * All three are optional. Left unset, the component reads the standard system
+     * endpoints itself — the paths every application using this library already
+     * serves. One is supplied only to point the component somewhere else.
+     */
     init;
     upgrade;
     load;
@@ -54,20 +63,105 @@ export class DashboardComponent {
         action.click();
     }
     initClick() {
-        this.init()
+        this._init()
             .subscribe(() => {
             this._message.success('Successfully initialized the system');
         });
     }
+    /**
+     * Run the pending upgrades as a process rather than behind a spinner.
+     *
+     * A spinner says the same thing for ten seconds and for ten minutes, which is
+     * the whole problem: an upgrade that rebuilds the largest table in a schema
+     * looks exactly like one that has hung, and the only way anybody found out
+     * which was to wait for a proxy to give up.
+     *
+     * Works whether or not the application's endpoint streams. Where it does, each
+     * NDJSON event becomes a line in the process log — which function is running,
+     * how far through it is, what each one cost. Where it does not, the single
+     * reply produces no lines and the process is simply a labelled spinner, which
+     * is what every application had before this.
+     */
     upgradeClick() {
-        this.upgrade()
-            .subscribe(() => {
+        const process = this._process.run('System upgrade', this._upgrade()
+            .pipe(map((event) => this._upgradeLine(event)), filter((line) => line !== null)));
+        // The pending-upgrade count on this screen is the thing the button was
+        // pressed to change, so it is re-read when the run settles — including when
+        // it FAILS, because a run that stopped halfway still completed everything
+        // before the one that broke.
+        process.completed$
+            .pipe(take(1), takeUntil(this._destroy$))
+            .subscribe((state) => {
             this._load();
-            this._message.success('Successfully upgraded the system');
+            if (state === ProcessState.Success) {
+                this._message.success('Successfully upgraded the system');
+            }
         });
     }
+    /**
+     * One emission off the upgrade endpoint, as a line for the process log — or
+     * null for anything with nothing to say, which is dropped rather than logged.
+     *
+     * `FsApi.stream()` wraps every NDJSON line in a `StreamEventData`, and
+     * `FsProcess` logs a string emission verbatim. So the mapping happens here: an
+     * object handed to the log renders as `[object Object]`.
+     *
+     * `ping` is deliberately silent. It is the heartbeat that stops a proxy
+     * closing a run that is still working, it fires after every statement, and it
+     * would bury the events worth reading.
+     */
+    _upgradeLine(event) {
+        const data = (event instanceof StreamEventData ? event.data : event);
+        if (typeof data === 'string') {
+            return data;
+        }
+        if (!data || !data.type || data.type === 'ping') {
+            return null;
+        }
+        const step = `${data.index} of ${data.total}`;
+        switch (data.type) {
+            case 'start':
+                return data.total
+                    ? `${data.total} upgrade(s) to run: ${(data.functions || []).join(', ')}`
+                    : 'Nothing to upgrade';
+            case 'upgrade':
+                if (data.state === 'started') {
+                    return `${step} ${data.name}…`;
+                }
+                return data.state === 'completed'
+                    ? `${step} ${data.name} — ${data.duration}`
+                    : `${step} ${data.name} FAILED — ${data.message}`;
+            case 'done':
+                return data.completed
+                    ? `Completed ${data.completed} upgrade(s)`
+                    : 'Nothing to upgrade';
+            default:
+                return data.message || null;
+        }
+    }
+    _dashboardGet() {
+        return this.load
+            ? this.load()
+            : this._api.get('system/dashboard', {}, { key: 'dashboard' });
+    }
+    _init() {
+        return this.init
+            ? this.init()
+            : this._api.get('system/init', {}, { key: '' });
+    }
+    /**
+     * The upgrade endpoint is read as a stream by default, which is what fills the
+     * process log line by line while the run is still going. An application that
+     * supplies its own `upgrade` decides for itself — a plain request emits once,
+     * produces no lines, and the process is a labelled spinner.
+     */
+    _upgrade() {
+        return this.upgrade
+            ? this.upgrade()
+            : this._api.stream('GET', 'system/upgrade', { stream: true }, { key: '' });
+    }
     _load() {
-        this.load()
+        this._dashboardGet()
             .subscribe((dashboard) => {
             this.dashboard = dashboard;
             this.dashboard.cronRanAttention = !dashboard.cronRan ||
@@ -99,4 +193,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImpor
             }], actions: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.component.js","sourceRoot":"","sources":["../../../../../../../src/app/modules/system/components/dashboard/dashboard.component.ts","../../../../../../../src/app/modules/system/components/dashboard/dashboard.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, OnDestroy, OnInit, inject } from '@angular/core';\n\nimport { BuildData, FsBuildService } from '@firestitch/build';\nimport { FsMessage } from '@firestitch/message';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { differenceInMinutes } from 'date-fns';\n\nimport { DashboardAction } from './../../interfaces/dashboard-action';\nimport { FsSkeletonModule } from '@firestitch/skeleton';\nimport { FsLabelModule } from '@firestitch/label';\nimport { NgClass } from '@angular/common';\nimport { MatIcon } from '@angular/material/icon';\nimport { MatTooltip } from '@angular/material/tooltip';\nimport { MatButton } from '@angular/material/button';\nimport { FsMenuModule } from '@firestitch/menu';\nimport { FsDateModule } from '@firestitch/date';\n\n\n@Component({\n    selector: 'fs-system-dashboard',\n    templateUrl: './dashboard.component.html',\n    styleUrls: ['./dashboard.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    standalone: true,\n    imports: [\n        FsSkeletonModule,\n        FsLabelModule,\n        NgClass,\n        MatIcon,\n        MatTooltip,\n        MatButton,\n        FsMenuModule,\n        FsDateModule,\n    ],\n})\nexport class DashboardComponent implements OnInit, OnDestroy {\n  private _message = inject(FsMessage);\n  private _cdRef = inject(ChangeDetectorRef);\n  private _buildService = inject(FsBuildService);\n\n\n  @Input() public init: () => any;\n  @Input() public upgrade: () => any;\n  @Input() public load: () => any;\n\n  @Input() public actions: DashboardAction[] = [];\n\n  public dashboard;\n  public buttonActions: DashboardAction[] = [];\n  public build: BuildData;\n  public menuActions: DashboardAction[] = [];\n\n  private _destroy$ = new Subject();\n\n  public ngOnInit() {\n    this._load();\n    this.buttonActions = this.actions.filter((item) => {\n      return !item.menu; \n    });\n    this.menuActions = this.actions.filter((item) => {\n      return item.menu; \n    });\n\n    this.build = this._buildService.build;\n    this._buildService.build$\n      .pipe(\n        takeUntil(this._destroy$),\n      )\n      .subscribe((build: BuildData) => {\n        this.build = build;\n        this._cdRef.markForCheck();\n      });\n  }\n\n  public ngOnDestroy() {\n    this._destroy$.next(null);\n    this._destroy$.complete();\n  }\n\n  public actionClick(action) {\n    action.click();\n  }\n\n  public initClick() {\n    this.init()\n      .subscribe(() => {\n        this._message.success('Successfully initialized the system');\n      });\n  }\n\n  public upgradeClick() {\n    this.upgrade()\n      .subscribe(() => {\n        this._load();\n        this._message.success('Successfully upgraded the system');\n      });\n  }\n\n  private _load() {\n    this.load()\n      .subscribe((dashboard) => {\n        this.dashboard = dashboard;\n        this.dashboard.cronRanAttention = !dashboard.cronRan ||\n         differenceInMinutes(new Date(), new Date(dashboard.cronRan)) > 15;\n        this._cdRef.markForCheck();\n      });\n  }\n}\n","<div *fsSkeleton=\"dashboard\">\n  <div class=\"fs-row.gap-lg.wrap.align-start\">\n    <div>\n      <h2>\n        Server\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Date/Time\n        </fs-label>\n        {{ dashboard.serverTime | fsDateFormat: 'date-time' }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Timezone\n        </fs-label>\n        {{ dashboard.serverTimezone }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Hostname\n        </fs-label>\n        {{ dashboard.serverHostname }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Directory\n        </fs-label>\n        {{ dashboard.appDirectory }}\n      </fs-label-field>\n    </div>\n    <div>\n      <h2>\n        System\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Mode\n        </fs-label>\n        {{ dashboard.appMode }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Notification Recipients\n        </fs-label>\n        {{ dashboard.notifyRecipients.join(', ') }}\n      </fs-label-field>\n    </div>\n    <div>\n      <h2>\n        Database\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Name\n        </fs-label>\n        {{ dashboard.databaseName }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Date/Time\n        </fs-label>\n        {{ dashboard.databaseTime | fsDateFormat: 'date-time' }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Timezone\n        </fs-label>\n        {{ dashboard.databaseTimezone }}\n      </fs-label-field>\n    </div>\n    @if (build || dashboard.upgrades.length) {\n      <div>\n        @if (build) {\n          <h2>\n            Build\n          </h2>\n          <fs-label-field>\n            <fs-label>\n              Version\n            </fs-label>\n            {{ build.version || 'Unknown' }}\n          </fs-label-field>\n          <fs-label-field>\n            <fs-label>\n              Date\n            </fs-label>\n            {{ (build.date | fsDateFormat: 'date-time') || 'Unknown' }}\n          </fs-label-field>\n        }\n        @if (dashboard.upgrades.length) {\n          <fs-label-field>\n            <fs-label>\n              Pending Upgrades\n            </fs-label>\n            <span\n              class=\"attention\"\n              [ngClass]=\"{ 'needs-attention': !!dashboard.upgrades.length }\">\n              {{ dashboard.upgrades.length }}\n              <mat-icon\n                [matTooltip]=\"dashboard.upgrades.join('\\n')\"\n                matTooltipClass=\"tooltip-pending-upgrades\">\n                warning\n              </mat-icon>\n            </span>\n          </fs-label-field>\n        }\n      </div>\n    }\n    <div>\n      <h2>\n        Cron\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Last Ran\n        </fs-label>\n        <span\n          class=\"attention\"\n          [ngClass]=\"{ 'needs-attention': dashboard.cronRanAttention }\">\n          @if (!dashboard.cronRan) {\n            <span>\n              Never\n            </span>\n          }\n          @if (dashboard.cronRan) {\n            <span>\n              {{ dashboard.cronRan | fsDateFormat: 'date-time' }}\n            </span>\n          }\n          <mat-icon>\n            warning\n          </mat-icon>\n        </span>\n      </fs-label-field>\n    </div>\n  </div>\n  <div>\n    <div class=\"actions\">\n      <button\n        mat-stroked-button\n        (click)=\"upgradeClick()\">\n        Run Upgrades\n      </button>\n      <button\n        mat-stroked-button\n        (click)=\"initClick()\">\n        Init System\n      </button>\n      @for (action of buttonActions; track action) {\n        <button\n          mat-stroked-button\n          (click)=\"actionClick(action)\">\n          {{ action.label }}\n        </button>\n      }\n      @if (menuActions.length) {\n        <fs-menu buttonClass=\"mat-stroked-button menu-button\">\n          @for (action of menuActions; track action) {\n            <ng-template\n              fs-menu-item\n              (click)=\"actionClick(action)\">\n              {{ action.label }}\n            </ng-template>\n          }\n        </fs-menu>\n      }\n    </div>\n  </div>\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.component.js","sourceRoot":"","sources":["../../../../../../../src/app/modules/system/components/dashboard/dashboard.component.ts","../../../../../../../src/app/modules/system/components/dashboard/dashboard.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, OnDestroy, OnInit, inject } from '@angular/core';\n\nimport { FsApi, StreamEventData } from '@firestitch/api';\nimport { BuildData, FsBuildService } from '@firestitch/build';\nimport { FsMessage } from '@firestitch/message';\nimport { FsProcess, ProcessState } from '@firestitch/process';\n\nimport { Observable, Subject } from 'rxjs';\nimport { filter, map, take, takeUntil } from 'rxjs/operators';\n\nimport { differenceInMinutes } from 'date-fns';\n\nimport { DashboardAction } from './../../interfaces/dashboard-action';\nimport { FsSkeletonModule } from '@firestitch/skeleton';\nimport { FsLabelModule } from '@firestitch/label';\nimport { NgClass } from '@angular/common';\nimport { MatIcon } from '@angular/material/icon';\nimport { MatTooltip } from '@angular/material/tooltip';\nimport { MatButton } from '@angular/material/button';\nimport { FsMenuModule } from '@firestitch/menu';\nimport { FsDateModule } from '@firestitch/date';\nimport { UpgradeEvent } from './../../interfaces/upgrade-event';\n\n\n@Component({\n    selector: 'fs-system-dashboard',\n    templateUrl: './dashboard.component.html',\n    styleUrls: ['./dashboard.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    standalone: true,\n    imports: [\n        FsSkeletonModule,\n        FsLabelModule,\n        NgClass,\n        MatIcon,\n        MatTooltip,\n        MatButton,\n        FsMenuModule,\n        FsDateModule,\n    ],\n})\nexport class DashboardComponent implements OnInit, OnDestroy {\n  private _message = inject(FsMessage);\n  private _cdRef = inject(ChangeDetectorRef);\n  private _buildService = inject(FsBuildService);\n  private _process = inject(FsProcess);\n  private _api = inject(FsApi);\n\n\n  /**\n   * All three are optional. Left unset, the component reads the standard system\n   * endpoints itself — the paths every application using this library already\n   * serves. One is supplied only to point the component somewhere else.\n   */\n  @Input() public init: () => Observable<any>;\n  @Input() public upgrade: () => Observable<any>;\n  @Input() public load: () => Observable<any>;\n\n  @Input() public actions: DashboardAction[] = [];\n\n  public dashboard;\n  public buttonActions: DashboardAction[] = [];\n  public build: BuildData;\n  public menuActions: DashboardAction[] = [];\n\n  private _destroy$ = new Subject();\n\n  public ngOnInit() {\n    this._load();\n    this.buttonActions = this.actions.filter((item) => {\n      return !item.menu; \n    });\n    this.menuActions = this.actions.filter((item) => {\n      return item.menu; \n    });\n\n    this.build = this._buildService.build;\n    this._buildService.build$\n      .pipe(\n        takeUntil(this._destroy$),\n      )\n      .subscribe((build: BuildData) => {\n        this.build = build;\n        this._cdRef.markForCheck();\n      });\n  }\n\n  public ngOnDestroy() {\n    this._destroy$.next(null);\n    this._destroy$.complete();\n  }\n\n  public actionClick(action) {\n    action.click();\n  }\n\n  public initClick() {\n    this._init()\n      .subscribe(() => {\n        this._message.success('Successfully initialized the system');\n      });\n  }\n\n  /**\n   * Run the pending upgrades as a process rather than behind a spinner.\n   *\n   * A spinner says the same thing for ten seconds and for ten minutes, which is\n   * the whole problem: an upgrade that rebuilds the largest table in a schema\n   * looks exactly like one that has hung, and the only way anybody found out\n   * which was to wait for a proxy to give up.\n   *\n   * Works whether or not the application's endpoint streams. Where it does, each\n   * NDJSON event becomes a line in the process log — which function is running,\n   * how far through it is, what each one cost. Where it does not, the single\n   * reply produces no lines and the process is simply a labelled spinner, which\n   * is what every application had before this.\n   */\n  public upgradeClick() {\n    const process = this._process.run(\n      'System upgrade',\n      this._upgrade()\n        .pipe(\n          map((event) => this._upgradeLine(event)),\n          filter((line): line is string => line !== null),\n        ),\n    );\n\n    // The pending-upgrade count on this screen is the thing the button was\n    // pressed to change, so it is re-read when the run settles — including when\n    // it FAILS, because a run that stopped halfway still completed everything\n    // before the one that broke.\n    process.completed$\n      .pipe(\n        take(1),\n        takeUntil(this._destroy$),\n      )\n      .subscribe((state: ProcessState) => {\n        this._load();\n\n        if (state === ProcessState.Success) {\n          this._message.success('Successfully upgraded the system');\n        }\n      });\n  }\n\n  /**\n   * One emission off the upgrade endpoint, as a line for the process log — or\n   * null for anything with nothing to say, which is dropped rather than logged.\n   *\n   * `FsApi.stream()` wraps every NDJSON line in a `StreamEventData`, and\n   * `FsProcess` logs a string emission verbatim. So the mapping happens here: an\n   * object handed to the log renders as `[object Object]`.\n   *\n   * `ping` is deliberately silent. It is the heartbeat that stops a proxy\n   * closing a run that is still working, it fires after every statement, and it\n   * would bury the events worth reading.\n   */\n  private _upgradeLine(event: unknown): string | null {\n    const data: UpgradeEvent = (event instanceof StreamEventData ? event.data : event) as UpgradeEvent;\n\n    if (typeof data === 'string') {\n      return data;\n    }\n\n    if (!data || !data.type || data.type === 'ping') {\n      return null;\n    }\n\n    const step = `${data.index} of ${data.total}`;\n\n    switch (data.type) {\n      case 'start':\n        return data.total\n          ? `${data.total} upgrade(s) to run: ${(data.functions || []).join(', ')}`\n          : 'Nothing to upgrade';\n\n      case 'upgrade':\n        if (data.state === 'started') {\n          return `${step} ${data.name}…`;\n        }\n\n        return data.state === 'completed'\n          ? `${step} ${data.name} — ${data.duration}`\n          : `${step} ${data.name} FAILED — ${data.message}`;\n\n      case 'done':\n        return data.completed\n          ? `Completed ${data.completed} upgrade(s)`\n          : 'Nothing to upgrade';\n\n      default:\n        return data.message || null;\n    }\n  }\n\n  private _dashboardGet(): Observable<any> {\n    return this.load\n      ? this.load()\n      : this._api.get('system/dashboard', {}, { key: 'dashboard' });\n  }\n\n  private _init(): Observable<any> {\n    return this.init\n      ? this.init()\n      : this._api.get('system/init', {}, { key: '' });\n  }\n\n  /**\n   * The upgrade endpoint is read as a stream by default, which is what fills the\n   * process log line by line while the run is still going. An application that\n   * supplies its own `upgrade` decides for itself — a plain request emits once,\n   * produces no lines, and the process is a labelled spinner.\n   */\n  private _upgrade(): Observable<any> {\n    return this.upgrade\n      ? this.upgrade()\n      : this._api.stream('GET', 'system/upgrade', { stream: true }, { key: '' });\n  }\n\n  private _load() {\n    this._dashboardGet()\n      .subscribe((dashboard) => {\n        this.dashboard = dashboard;\n        this.dashboard.cronRanAttention = !dashboard.cronRan ||\n         differenceInMinutes(new Date(), new Date(dashboard.cronRan)) > 15;\n        this._cdRef.markForCheck();\n      });\n  }\n}\n","<div *fsSkeleton=\"dashboard\">\n  <div class=\"fs-row.gap-lg.wrap.align-start\">\n    <div>\n      <h2>\n        Server\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Date/Time\n        </fs-label>\n        {{ dashboard.serverTime | fsDateFormat: 'date-time' }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Timezone\n        </fs-label>\n        {{ dashboard.serverTimezone }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Hostname\n        </fs-label>\n        {{ dashboard.serverHostname }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Directory\n        </fs-label>\n        {{ dashboard.appDirectory }}\n      </fs-label-field>\n    </div>\n    <div>\n      <h2>\n        System\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Mode\n        </fs-label>\n        {{ dashboard.appMode }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Notification Recipients\n        </fs-label>\n        {{ dashboard.notifyRecipients.join(', ') }}\n      </fs-label-field>\n    </div>\n    <div>\n      <h2>\n        Database\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Name\n        </fs-label>\n        {{ dashboard.databaseName }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Date/Time\n        </fs-label>\n        {{ dashboard.databaseTime | fsDateFormat: 'date-time' }}\n      </fs-label-field>\n      <fs-label-field>\n        <fs-label>\n          Timezone\n        </fs-label>\n        {{ dashboard.databaseTimezone }}\n      </fs-label-field>\n    </div>\n    @if (build || dashboard.upgrades.length) {\n      <div>\n        @if (build) {\n          <h2>\n            Build\n          </h2>\n          <fs-label-field>\n            <fs-label>\n              Version\n            </fs-label>\n            {{ build.version || 'Unknown' }}\n          </fs-label-field>\n          <fs-label-field>\n            <fs-label>\n              Date\n            </fs-label>\n            {{ (build.date | fsDateFormat: 'date-time') || 'Unknown' }}\n          </fs-label-field>\n        }\n        @if (dashboard.upgrades.length) {\n          <fs-label-field>\n            <fs-label>\n              Pending Upgrades\n            </fs-label>\n            <span\n              class=\"attention\"\n              [ngClass]=\"{ 'needs-attention': !!dashboard.upgrades.length }\">\n              {{ dashboard.upgrades.length }}\n              <mat-icon\n                [matTooltip]=\"dashboard.upgrades.join('\\n')\"\n                matTooltipClass=\"tooltip-pending-upgrades\">\n                warning\n              </mat-icon>\n            </span>\n          </fs-label-field>\n        }\n      </div>\n    }\n    <div>\n      <h2>\n        Cron\n      </h2>\n      <fs-label-field>\n        <fs-label>\n          Last Ran\n        </fs-label>\n        <span\n          class=\"attention\"\n          [ngClass]=\"{ 'needs-attention': dashboard.cronRanAttention }\">\n          @if (!dashboard.cronRan) {\n            <span>\n              Never\n            </span>\n          }\n          @if (dashboard.cronRan) {\n            <span>\n              {{ dashboard.cronRan | fsDateFormat: 'date-time' }}\n            </span>\n          }\n          <mat-icon>\n            warning\n          </mat-icon>\n        </span>\n      </fs-label-field>\n    </div>\n  </div>\n  <div>\n    <div class=\"actions\">\n      <button\n        mat-stroked-button\n        (click)=\"upgradeClick()\">\n        Run Upgrades\n      </button>\n      <button\n        mat-stroked-button\n        (click)=\"initClick()\">\n        Init System\n      </button>\n      @for (action of buttonActions; track action) {\n        <button\n          mat-stroked-button\n          (click)=\"actionClick(action)\">\n          {{ action.label }}\n        </button>\n      }\n      @if (menuActions.length) {\n        <fs-menu buttonClass=\"mat-stroked-button menu-button\">\n          @for (action of menuActions; track action) {\n            <ng-template\n              fs-menu-item\n              (click)=\"actionClick(action)\">\n              {{ action.label }}\n            </ng-template>\n          }\n        </fs-menu>\n      }\n    </div>\n  </div>\n</div>"]}

package/esm2022/app/modules/system/interfaces/index.mjs

@@ -2,4 +2,5 @@ export * from './dashboard-action';
 export * from './process-action';
 export * from './process';
 export * from './system-config';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvc3lzdGVtL2ludGVyZmFjZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC1hY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9jZXNzLWFjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3Byb2Nlc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9zeXN0ZW0tY29uZmlnJztcbiJdfQ==
+export * from './upgrade-event';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvc3lzdGVtL2ludGVyZmFjZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGFzaGJvYXJkLWFjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3Byb2Nlc3MtYWN0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvY2Vzcyc7XG5leHBvcnQgKiBmcm9tICcuL3N5c3RlbS1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi91cGdyYWRlLWV2ZW50JztcbiJdfQ==

package/esm2022/app/modules/system/interfaces/upgrade-event.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBncmFkZS1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvbW9kdWxlcy9zeXN0ZW0vaW50ZXJmYWNlcy91cGdyYWRlLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIE9uZSBOREpTT04gbGluZSBvZmYgYSBzdHJlYW1pbmcgdXBncmFkZSBlbmRwb2ludC5cbiAqXG4gKiBUaGUgZnJhbWV3b3JrJ3Mgc3lzdGVtIHZpZXcgc3RyZWFtcyB0aGVzZSBvbmx5IHdoZW4gdGhlIGNhbGxlciBhc2tzIGZvciBhXG4gKiBzdHJlYW0sIHNvIGFuIGFwcGxpY2F0aW9uIHRoYXQgaGFzIG5vdCBvcHRlZCBpbiBlbWl0cyBhbiBvcmRpbmFyeSByZXBseSBhbmRcbiAqIG5vbmUgb2YgdGhpcyBhcHBsaWVzIOKAlCBzZWUgYERhc2hib2FyZENvbXBvbmVudC5fdXBncmFkZUxpbmUoKWAsIHdoaWNoIHRyZWF0c1xuICogYW55dGhpbmcgdW5yZWNvZ25pc2VkIGFzIGhhdmluZyBub3RoaW5nIHRvIGxvZy5cbiAqXG4gKiBgc3RhcnRgIGFycml2ZXMgb25jZSB3aXRoIHRoZSBmdWxsIGxpc3Qgb2YgcGVuZGluZyBmdW5jdGlvbnMsIGJlY2F1c2UgXCJ3b3JraW5nXG4gKiBvbiAyIG9mIDlcIiBpcyBvbmx5IG1lYW5pbmdmdWwgdG8gc29tZWJvZHkgd2hvIHdhcyB0b2xkIHRoZXJlIHdlcmUgOS4gYHVwZ3JhZGVgXG4gKiBhcnJpdmVzIHR3aWNlIHBlciBmdW5jdGlvbiwgb24gZWl0aGVyIHNpZGUgb2YgaXQsIGNhcnJ5aW5nIHdoYXQgaXQgY29zdC5cbiAqIGBwaW5nYCBpcyB0aGUgaGVhcnRiZWF0IGFuZCBzYXlzIG5vdGhpbmcuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVXBncmFkZUV2ZW50IHtcbiAgdHlwZTogJ3N0YXJ0JyB8ICd1cGdyYWRlJyB8ICdsb2cnIHwgJ3BpbmcnIHwgJ2RvbmUnO1xuICBzdGF0ZT86ICdzdGFydGVkJyB8ICdjb21wbGV0ZWQnIHwgJ2ZhaWxlZCc7XG4gIG5hbWU/OiBzdHJpbmc7XG4gIGluZGV4PzogbnVtYmVyO1xuICB0b3RhbD86IG51bWJlcjtcbiAgY29tcGxldGVkPzogbnVtYmVyO1xuICBkdXJhdGlvbj86IHN0cmluZztcbiAgc2Vjb25kcz86IG51bWJlcjtcbiAgbWVzc2FnZT86IHN0cmluZztcbiAgZnVuY3Rpb25zPzogc3RyaW5nW107XG59XG4iXX0=

package/esm2022/public_api.mjs

@@ -17,4 +17,4 @@ export { LinkifyPipe } from './app/modules/system/pipes/linkify.pipe';
 export { ApiLogStates, CronStates, ProcessStates } from './app/modules/system/consts';
 export { ApiLogState, CronState, ProcessState } from './app/modules/system/enums';
 export { FS_SYSTEM_CONFIG } from './app/modules/system/injectors/system-config.injector';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/firestitch-system.mjs

@@ -47,7 +47,7 @@ import { FsApi, RequestMethod, StreamEventData, StreamEventType } from '@firesti
 import { Subject, timer, Observable } from 'rxjs';
 import { addMinutes, addHours, addDays, subSeconds, differenceInSeconds, getDaysInMonth, differenceInMinutes } from 'date-fns';
 import { FsMessage } from '@firestitch/message';
-import { FsProcess } from '@firestitch/process';
+import { FsProcess, ProcessState as ProcessState$1 } from '@firestitch/process';
 import { FsPrompt } from '@firestitch/prompt';
 import { SelectionActionType } from '@firestitch/selection';
 import { FsBuildService } from '@firestitch/build';
@@ -848,6 +848,13 @@ class DashboardComponent {
     _message = inject(FsMessage);
     _cdRef = inject(ChangeDetectorRef);
     _buildService = inject(FsBuildService);
+    _process = inject(FsProcess);
+    _api = inject(FsApi);
+    /**
+     * All three are optional. Left unset, the component reads the standard system
+     * endpoints itself — the paths every application using this library already
+     * serves. One is supplied only to point the component somewhere else.
+     */
     init;
     upgrade;
     load;
@@ -881,20 +888,105 @@ class DashboardComponent {
         action.click();
     }
     initClick() {
-        this.init()
+        this._init()
             .subscribe(() => {
             this._message.success('Successfully initialized the system');
         });
     }
+    /**
+     * Run the pending upgrades as a process rather than behind a spinner.
+     *
+     * A spinner says the same thing for ten seconds and for ten minutes, which is
+     * the whole problem: an upgrade that rebuilds the largest table in a schema
+     * looks exactly like one that has hung, and the only way anybody found out
+     * which was to wait for a proxy to give up.
+     *
+     * Works whether or not the application's endpoint streams. Where it does, each
+     * NDJSON event becomes a line in the process log — which function is running,
+     * how far through it is, what each one cost. Where it does not, the single
+     * reply produces no lines and the process is simply a labelled spinner, which
+     * is what every application had before this.
+     */
     upgradeClick() {
-        this.upgrade()
-            .subscribe(() => {
+        const process = this._process.run('System upgrade', this._upgrade()
+            .pipe(map((event) => this._upgradeLine(event)), filter((line) => line !== null)));
+        // The pending-upgrade count on this screen is the thing the button was
+        // pressed to change, so it is re-read when the run settles — including when
+        // it FAILS, because a run that stopped halfway still completed everything
+        // before the one that broke.
+        process.completed$
+            .pipe(take(1), takeUntil(this._destroy$))
+            .subscribe((state) => {
             this._load();
-            this._message.success('Successfully upgraded the system');
+            if (state === ProcessState$1.Success) {
+                this._message.success('Successfully upgraded the system');
+            }
         });
     }
+    /**
+     * One emission off the upgrade endpoint, as a line for the process log — or
+     * null for anything with nothing to say, which is dropped rather than logged.
+     *
+     * `FsApi.stream()` wraps every NDJSON line in a `StreamEventData`, and
+     * `FsProcess` logs a string emission verbatim. So the mapping happens here: an
+     * object handed to the log renders as `[object Object]`.
+     *
+     * `ping` is deliberately silent. It is the heartbeat that stops a proxy
+     * closing a run that is still working, it fires after every statement, and it
+     * would bury the events worth reading.
+     */
+    _upgradeLine(event) {
+        const data = (event instanceof StreamEventData ? event.data : event);
+        if (typeof data === 'string') {
+            return data;
+        }
+        if (!data || !data.type || data.type === 'ping') {
+            return null;
+        }
+        const step = `${data.index} of ${data.total}`;
+        switch (data.type) {
+            case 'start':
+                return data.total
+                    ? `${data.total} upgrade(s) to run: ${(data.functions || []).join(', ')}`
+                    : 'Nothing to upgrade';
+            case 'upgrade':
+                if (data.state === 'started') {
+                    return `${step} ${data.name}…`;
+                }
+                return data.state === 'completed'
+                    ? `${step} ${data.name} — ${data.duration}`
+                    : `${step} ${data.name} FAILED — ${data.message}`;
+            case 'done':
+                return data.completed
+                    ? `Completed ${data.completed} upgrade(s)`
+                    : 'Nothing to upgrade';
+            default:
+                return data.message || null;
+        }
+    }
+    _dashboardGet() {
+        return this.load
+            ? this.load()
+            : this._api.get('system/dashboard', {}, { key: 'dashboard' });
+    }
+    _init() {
+        return this.init
+            ? this.init()
+            : this._api.get('system/init', {}, { key: '' });
+    }
+    /**
+     * The upgrade endpoint is read as a stream by default, which is what fills the
+     * process log line by line while the run is still going. An application that
+     * supplies its own `upgrade` decides for itself — a plain request emits once,
+     * produces no lines, and the process is a labelled spinner.
+     */
+    _upgrade() {
+        return this.upgrade
+            ? this.upgrade()
+            : this._api.stream('GET', 'system/upgrade', { stream: true }, { key: '' });
+    }
     _load() {
-        this.load()
+        this._dashboardGet()
             .subscribe((dashboard) => {
             this.dashboard = dashboard;
             this.dashboard.cronRanAttention = !dashboard.cronRan ||