@firestitch/report 18.0.16 → 18.0.17

package/app/reports/dialogs/entity-functions/entity-functions.component.d.ts

@@ -1,12 +1,13 @@
-import { SemanticEntityFunction, SemanticEntityFunctions } from '../../interfaces/report.interface';
+import { SemanticEntityFunction, SemanticEntityFunctions, SemanticFunctionSource } from '../../interfaces/report.interface';
 import * as i0 from "@angular/core";
 export interface EntityFunctionsDialogData {
     entityKey: string;
-    source: 'model' | 'handler';
+    source: SemanticFunctionSource;
 }
 export declare class EntityFunctionsComponent {
     private static readonly KIND_COLORS;
     private static readonly KIND_ORDER;
+    private static readonly SOURCE_LABELS;
     private readonly _data;
     readonly entityKey: string;
     readonly sourceLabel: string;

package/app/reports/dialogs/global-settings/components/semantic-database/semantic-database.component.d.ts

@@ -1,19 +1,28 @@
-import { SemanticBuildEntity, SemanticBuildStage, SemanticBuildStatus, SemanticBuildTable } from '../../../../interfaces/report.interface';
+import { SemanticBuildEntity, SemanticBuildStatus, SemanticBuildTable, SemanticFunctionSource } from '../../../../interfaces/report.interface';
 import * as i0 from "@angular/core";
+interface SemanticUnitView {
+    key: string;
+    name: string;
+    hasTable: boolean;
+    entity: SemanticBuildEntity | null;
+    model: string | null;
+    functionCount: number;
+}
 export declare class SemanticDatabaseComponent {
     private static readonly ACTIVE_STATES;
     private static readonly STATE_LABELS;
-    private static readonly DONE_COLOR;
     private static readonly PENDING_COLOR;
-    readonly stageKeys: string[];
-    readonly stageLabels: Record<string, string>;
+    private static readonly NAME_SUFFIX;
     readonly status: import("@angular/core").WritableSignal<SemanticBuildStatus>;
+    readonly filter: import("@angular/core").WritableSignal<string>;
     readonly building: import("@angular/core").WritableSignal<boolean>;
     readonly buildActive: import("@angular/core").Signal<boolean>;
     readonly buildStateLabel: import("@angular/core").Signal<string>;
     readonly hasCatalog: import("@angular/core").Signal<boolean>;
     readonly excludedTables: import("@angular/core").Signal<SemanticBuildTable[]>;
     readonly unlinkedJunctions: import("@angular/core").Signal<SemanticBuildTable[]>;
+    readonly units: import("@angular/core").Signal<SemanticUnitView[]>;
+    readonly filteredUnits: import("@angular/core").Signal<SemanticUnitView[]>;
     readonly coverage: import("@angular/core").Signal<string>;
     private readonly _tables;
     private _buildFinalized;
@@ -51,16 +60,29 @@ export declare class SemanticDatabaseComponent {
      * confirms success.
      */
     private _announceOutcome;
-    stageColor(stage: SemanticBuildStage): string;
-    stageTooltip(stage: SemanticBuildStage): string;
+    pendingColor(): string;
+    /**
+     * The build stages this row is still owed, or [] when it is fully built. A
+     * stopped or interrupted build is the only way to get a non-empty list.
+     */
+    pendingStages(unit: SemanticUnitView): string[];
+    setFilter(value: string): void;
     /**
-     * Open the child dialog listing one group of an entity's cached functions —
-     * the model class's or the handler class's. The dialog fetches fresh on open,
-     * so the tab never holds function payloads.
+     * Open the child dialog listing one group of a unit's cached functions — an
+     * entity's model or handler class, or a standalone class's code. The dialog
+     * fetches fresh on open, so the tab never holds function payloads.
      */
-    openFunctions(entity: SemanticBuildEntity, source: 'model' | 'handler'): void;
+    openFunctions(unit: SemanticUnitView, source: SemanticFunctionSource): void;
     private _init;
+    /**
+     * What a reader recognizes the unit by: its class's short name, minus the
+     * `Model` suffix that every model carries and none of them are distinguished
+     * by. Falls back to the cache key for a unit whose class could not be
+     * resolved, so a row never renders nameless.
+     */
+    private _displayName;
     private _refreshStatus;
     static ɵfac: i0.ɵɵFactoryDeclaration<SemanticDatabaseComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SemanticDatabaseComponent, "fs-ai-report-global-settings-semantic-database", never, {}, {}, never, never, true, never>;
 }
+export {};

package/app/reports/interfaces/report.interface.d.ts

@@ -210,6 +210,8 @@ export interface SemanticBuildEnum {
 export interface SemanticBuildEntity {
     key: string;
     table: string;
+    model: string | null;
+    handler: string | null;
     columns: number;
     relationships: number;
     enums: SemanticBuildEnum[];
@@ -219,6 +221,11 @@ export interface SemanticBuildEntity {
     handlerFunctionCount: number;
     stages: Record<string, SemanticBuildStage>;
 }
+export interface SemanticBuildClass {
+    key: string;
+    model: string | null;
+    functionCount: number;
+}
 export type SemanticTableClassification = 'entity' | 'junction' | 'excluded';
 export interface SemanticBuildTable {
     table: string;
@@ -229,14 +236,17 @@ export interface SemanticBuildTable {
 export interface SemanticBuildDetail {
     generatedAt: Date | null;
     entityCount: number;
+    classCount: number;
     functionCount: number;
     entities: SemanticBuildEntity[];
+    classes: SemanticBuildClass[];
     tableCount: number;
     junctionCount: number;
     unlinkedJunctionCount: number;
     excludedCount: number;
     tables: SemanticBuildTable[];
 }
+export type SemanticFunctionSource = 'model' | 'handler' | 'class';
 export interface SemanticEntityFunction {
     class: string;
     method: string;
@@ -244,7 +254,7 @@ export interface SemanticEntityFunction {
     kind: string;
     summary: string;
     produces: string;
-    source: 'model' | 'handler';
+    source: SemanticFunctionSource;
 }
 export interface SemanticEntityFunctions {
     entity: string;

package/esm2022/app/reports/dialogs/entity-functions/entity-functions.component.mjs

@@ -12,10 +12,10 @@ import * as i1 from "@firestitch/chip";
 import * as i2 from "@firestitch/date";
 import * as i3 from "@firestitch/dialog";
 import * as i4 from "@firestitch/skeleton";
-// One group of an entity's AI-classified cached code functions — the model
-// class's or the handler class's, per the source it was opened for. Fetched on
-// open from the shared per-entity endpoint (one payload carries both groups,
-// each row tagged with its source) and filtered client-side.
+// One group of a unit's AI-classified cached code functions — an entity's model
+// or handler class, or the single group of a standalone code class. Fetched on
+// open from the shared per-key endpoint (one payload carries every group, each
+// row tagged with its source) and filtered client-side.
 export class EntityFunctionsComponent {
     // One color per AI classification kind, so a function's nature reads at a glance.
     static KIND_COLORS = {
@@ -28,15 +28,23 @@ export class EntityFunctionsComponent {
     };
     // Interesting logic first: derived values and rules, then data access, then the rest.
     static KIND_ORDER = ['calculation', 'business-rule', 'query', 'mutation', 'accessor', 'other'];
+    // The dialog title per group. A standalone class has no model/handler split,
+    // so its one group is just the code the build read.
+    static SOURCE_LABELS = {
+        model: 'Model functions',
+        handler: 'Handler functions',
+        class: 'Code functions',
+    };
     _data = inject(MAT_DIALOG_DATA);
     entityKey = this._data.entityKey;
-    sourceLabel = this._data.source === 'model' ? 'Model functions' : 'Handler functions';
+    sourceLabel = EntityFunctionsComponent.SOURCE_LABELS[this._data.source];
     // null until loaded — gates the list behind the skeleton.
     entityFunctions = signal(null);
-    // The class this group's functions were discovered from.
+    // The class this group's functions were discovered from. A standalone code
+    // class has no handler, so its group reads the model slot like 'model' does.
     discoveredClass = computed(() => {
         const loaded = this.entityFunctions();
-        return this._data.source === 'model' ? loaded?.modelClass : loaded?.handlerClass;
+        return this._data.source === 'handler' ? loaded?.handlerClass : loaded?.modelClass;
     });
     // This group's functions, ordered by kind priority then method name.
     functions = computed(() => this._sortFunctions((this.entityFunctions()?.functions ?? [])
@@ -78,4 +86,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                         FsSkeletonModule,
                     ], template: "<fs-dialog>\n  <fs-dialog-title>\n    {{ entityKey }} \u2014 {{ sourceLabel }}\n  </fs-dialog-title>\n  <mat-dialog-content>\n    <div *fsSkeleton=\"entityFunctions()\">\n      @if (entityFunctions(); as fns) {\n        @if (functions().length) {\n          @if (fns.generatedAt) {\n            <div class=\"hint functions-generated\">\n              Discovered from {{ discoveredClass() }} &middot;\n              <fs-date\n                  [date]=\"fns.generatedAt\"\n                  format=\"date-time\">\n              </fs-date>\n            </div>\n          }\n          <div class=\"functions-list\">\n            @for (fn of functions(); track fn.class + '::' + fn.method) {\n              <div class=\"function-row\">\n                <div class=\"function-head\">\n                  <fs-chip\n                      size=\"tiny\"\n                      [backgroundColor]=\"kindColor(fn.kind)\"\n                      color=\"#ffffff\">\n                    {{ fn.kind }}\n                  </fs-chip>\n                  <code class=\"function-method\">{{ fn.method }}</code>\n                </div>\n                <div class=\"function-summary\">{{ fn.summary }}</div>\n                @if (fn.produces) {\n                  <div class=\"function-produces hint\">Produces: {{ fn.produces }}</div>\n                }\n              </div>\n            }\n          </div>\n        } @else {\n          <div class=\"hint\">\n            No functions cached for this entity yet \u2014 run a build to discover its code.\n          </div>\n        }\n      }\n    </div>\n  </mat-dialog-content>\n  <mat-dialog-actions>\n    <button\n        type=\"button\"\n        mat-button\n        color=\"primary\"\n        [mat-dialog-close]=\"undefined\">\n      Close\n    </button>\n  </mat-dialog-actions>\n</fs-dialog>\n", styles: [".hint{margin:0;color:#0009;font-size:13px;line-height:1.5}.functions-generated{margin-bottom:10px}.functions-list{display:flex;flex-direction:column}.functions-list .function-row{display:flex;flex-direction:column;gap:3px;padding:10px 0}.functions-list .function-row+.function-row{border-top:1px solid rgba(0,0,0,.08)}.functions-list .function-row .function-head{display:flex;align-items:center;gap:8px}.functions-list .function-row .function-method{font-family:monospace;font-size:13px;font-weight:600}.functions-list .function-row .function-summary{color:#000000bf}.functions-list .function-row .function-produces{padding-left:10px}\n"] }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-functions.component.js","sourceRoot":"","sources":["../../../../../../src/app/reports/dialogs/entity-functions/entity-functions.component.ts","../../../../../../src/app/reports/dialogs/entity-functions/entity-functions.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nimport { MatButton } from '@angular/material/button';\nimport { MAT_DIALOG_DATA, MatDialogActions, MatDialogClose, MatDialogContent } from '@angular/material/dialog';\n\nimport { FsChipModule } from '@firestitch/chip';\nimport { FsDateModule } from '@firestitch/date';\nimport { FsDialogModule } from '@firestitch/dialog';\nimport { FsSkeletonModule } from '@firestitch/skeleton';\n\nimport { ReportData } from '../../data/report.data';\nimport {\n  SemanticEntityFunction,\n  SemanticEntityFunctions,\n} from '../../interfaces/report.interface';\n\n\nexport interface EntityFunctionsDialogData {\n  entityKey: string;\n  source: 'model' | 'handler';\n}\n\n\n// One group of an entity's AI-classified cached code functions — the model\n// class's or the handler class's, per the source it was opened for. Fetched on\n// open from the shared per-entity endpoint (one payload carries both groups,\n// each row tagged with its source) and filtered client-side.\n@Component({\n  templateUrl: './entity-functions.component.html',\n  styleUrls: ['./entity-functions.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    MatButton,\n    MatDialogContent,\n    MatDialogActions,\n    MatDialogClose,\n    FsChipModule,\n    FsDateModule,\n    FsDialogModule,\n    FsSkeletonModule,\n  ],\n})\nexport class EntityFunctionsComponent {\n\n  // One color per AI classification kind, so a function's nature reads at a glance.\n  private static readonly KIND_COLORS: Record<string, string> = {\n    'calculation': '#1565c0',\n    'business-rule': '#6a1b9a',\n    'query': '#00695c',\n    'mutation': '#e65100',\n    'accessor': '#546e7a',\n    'other': '#757575',\n  };\n\n  // Interesting logic first: derived values and rules, then data access, then the rest.\n  private static readonly KIND_ORDER = ['calculation', 'business-rule', 'query', 'mutation', 'accessor', 'other'];\n\n  private readonly _data = inject<EntityFunctionsDialogData>(MAT_DIALOG_DATA);\n\n  public readonly entityKey = this._data.entityKey;\n  public readonly sourceLabel = this._data.source === 'model' ? 'Model functions' : 'Handler functions';\n\n  // null until loaded — gates the list behind the skeleton.\n  public readonly entityFunctions = signal<SemanticEntityFunctions | null>(null);\n\n  // The class this group's functions were discovered from.\n  public readonly discoveredClass = computed<string | null>(() => {\n    const loaded = this.entityFunctions();\n\n    return this._data.source === 'model' ? loaded?.modelClass : loaded?.handlerClass;\n  });\n\n  // This group's functions, ordered by kind priority then method name.\n  public readonly functions = computed<SemanticEntityFunction[]>(() =>\n    this._sortFunctions(\n      (this.entityFunctions()?.functions ?? [])\n        .filter((fn) => fn.source === this._data.source),\n    ),\n  );\n\n  constructor() {\n    inject(ReportData).semanticEntityFunctions(this._data.entityKey)\n      .pipe(takeUntilDestroyed())\n      .subscribe((entityFunctions: SemanticEntityFunctions) => {\n        this.entityFunctions.set(entityFunctions);\n      });\n  }\n\n  public kindColor(kind: string): string {\n    return EntityFunctionsComponent.KIND_COLORS[kind] ?? EntityFunctionsComponent.KIND_COLORS.other;\n  }\n\n  private _sortFunctions(functions: SemanticEntityFunction[]): SemanticEntityFunction[] {\n    return [...functions]\n      .sort((a, b) => {\n        const kindDiff = this._kindRank(a.kind) - this._kindRank(b.kind);\n\n        return kindDiff !== 0 ? kindDiff : a.method.localeCompare(b.method);\n      });\n  }\n\n  private _kindRank(kind: string): number {\n    const rank = EntityFunctionsComponent.KIND_ORDER.indexOf(kind);\n\n    return rank === -1 ? EntityFunctionsComponent.KIND_ORDER.length : rank;\n  }\n}\n","<fs-dialog>\n  <fs-dialog-title>\n    {{ entityKey }} — {{ sourceLabel }}\n  </fs-dialog-title>\n  <mat-dialog-content>\n    <div *fsSkeleton=\"entityFunctions()\">\n      @if (entityFunctions(); as fns) {\n        @if (functions().length) {\n          @if (fns.generatedAt) {\n            <div class=\"hint functions-generated\">\n              Discovered from {{ discoveredClass() }} &middot;\n              <fs-date\n                  [date]=\"fns.generatedAt\"\n                  format=\"date-time\">\n              </fs-date>\n            </div>\n          }\n          <div class=\"functions-list\">\n            @for (fn of functions(); track fn.class + '::' + fn.method) {\n              <div class=\"function-row\">\n                <div class=\"function-head\">\n                  <fs-chip\n                      size=\"tiny\"\n                      [backgroundColor]=\"kindColor(fn.kind)\"\n                      color=\"#ffffff\">\n                    {{ fn.kind }}\n                  </fs-chip>\n                  <code class=\"function-method\">{{ fn.method }}</code>\n                </div>\n                <div class=\"function-summary\">{{ fn.summary }}</div>\n                @if (fn.produces) {\n                  <div class=\"function-produces hint\">Produces: {{ fn.produces }}</div>\n                }\n              </div>\n            }\n          </div>\n        } @else {\n          <div class=\"hint\">\n            No functions cached for this entity yet — run a build to discover its code.\n          </div>\n        }\n      }\n    </div>\n  </mat-dialog-content>\n  <mat-dialog-actions>\n    <button\n        type=\"button\"\n        mat-button\n        color=\"primary\"\n        [mat-dialog-close]=\"undefined\">\n      Close\n    </button>\n  </mat-dialog-actions>\n</fs-dialog>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-functions.component.js","sourceRoot":"","sources":["../../../../../../src/app/reports/dialogs/entity-functions/entity-functions.component.ts","../../../../../../src/app/reports/dialogs/entity-functions/entity-functions.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nimport { MatButton } from '@angular/material/button';\nimport { MAT_DIALOG_DATA, MatDialogActions, MatDialogClose, MatDialogContent } from '@angular/material/dialog';\n\nimport { FsChipModule } from '@firestitch/chip';\nimport { FsDateModule } from '@firestitch/date';\nimport { FsDialogModule } from '@firestitch/dialog';\nimport { FsSkeletonModule } from '@firestitch/skeleton';\n\nimport { ReportData } from '../../data/report.data';\nimport {\n  SemanticEntityFunction,\n  SemanticEntityFunctions,\n  SemanticFunctionSource,\n} from '../../interfaces/report.interface';\n\n\nexport interface EntityFunctionsDialogData {\n  entityKey: string;\n  source: SemanticFunctionSource;\n}\n\n\n// One group of a unit's AI-classified cached code functions — an entity's model\n// or handler class, or the single group of a standalone code class. Fetched on\n// open from the shared per-key endpoint (one payload carries every group, each\n// row tagged with its source) and filtered client-side.\n@Component({\n  templateUrl: './entity-functions.component.html',\n  styleUrls: ['./entity-functions.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    MatButton,\n    MatDialogContent,\n    MatDialogActions,\n    MatDialogClose,\n    FsChipModule,\n    FsDateModule,\n    FsDialogModule,\n    FsSkeletonModule,\n  ],\n})\nexport class EntityFunctionsComponent {\n\n  // One color per AI classification kind, so a function's nature reads at a glance.\n  private static readonly KIND_COLORS: Record<string, string> = {\n    'calculation': '#1565c0',\n    'business-rule': '#6a1b9a',\n    'query': '#00695c',\n    'mutation': '#e65100',\n    'accessor': '#546e7a',\n    'other': '#757575',\n  };\n\n  // Interesting logic first: derived values and rules, then data access, then the rest.\n  private static readonly KIND_ORDER = ['calculation', 'business-rule', 'query', 'mutation', 'accessor', 'other'];\n\n  // The dialog title per group. A standalone class has no model/handler split,\n  // so its one group is just the code the build read.\n  private static readonly SOURCE_LABELS: Record<SemanticFunctionSource, string> = {\n    model: 'Model functions',\n    handler: 'Handler functions',\n    class: 'Code functions',\n  };\n\n  private readonly _data = inject<EntityFunctionsDialogData>(MAT_DIALOG_DATA);\n\n  public readonly entityKey = this._data.entityKey;\n  public readonly sourceLabel = EntityFunctionsComponent.SOURCE_LABELS[this._data.source];\n\n  // null until loaded — gates the list behind the skeleton.\n  public readonly entityFunctions = signal<SemanticEntityFunctions | null>(null);\n\n  // The class this group's functions were discovered from. A standalone code\n  // class has no handler, so its group reads the model slot like 'model' does.\n  public readonly discoveredClass = computed<string | null>(() => {\n    const loaded = this.entityFunctions();\n\n    return this._data.source === 'handler' ? loaded?.handlerClass : loaded?.modelClass;\n  });\n\n  // This group's functions, ordered by kind priority then method name.\n  public readonly functions = computed<SemanticEntityFunction[]>(() =>\n    this._sortFunctions(\n      (this.entityFunctions()?.functions ?? [])\n        .filter((fn) => fn.source === this._data.source),\n    ),\n  );\n\n  constructor() {\n    inject(ReportData).semanticEntityFunctions(this._data.entityKey)\n      .pipe(takeUntilDestroyed())\n      .subscribe((entityFunctions: SemanticEntityFunctions) => {\n        this.entityFunctions.set(entityFunctions);\n      });\n  }\n\n  public kindColor(kind: string): string {\n    return EntityFunctionsComponent.KIND_COLORS[kind] ?? EntityFunctionsComponent.KIND_COLORS.other;\n  }\n\n  private _sortFunctions(functions: SemanticEntityFunction[]): SemanticEntityFunction[] {\n    return [...functions]\n      .sort((a, b) => {\n        const kindDiff = this._kindRank(a.kind) - this._kindRank(b.kind);\n\n        return kindDiff !== 0 ? kindDiff : a.method.localeCompare(b.method);\n      });\n  }\n\n  private _kindRank(kind: string): number {\n    const rank = EntityFunctionsComponent.KIND_ORDER.indexOf(kind);\n\n    return rank === -1 ? EntityFunctionsComponent.KIND_ORDER.length : rank;\n  }\n}\n","<fs-dialog>\n  <fs-dialog-title>\n    {{ entityKey }} — {{ sourceLabel }}\n  </fs-dialog-title>\n  <mat-dialog-content>\n    <div *fsSkeleton=\"entityFunctions()\">\n      @if (entityFunctions(); as fns) {\n        @if (functions().length) {\n          @if (fns.generatedAt) {\n            <div class=\"hint functions-generated\">\n              Discovered from {{ discoveredClass() }} &middot;\n              <fs-date\n                  [date]=\"fns.generatedAt\"\n                  format=\"date-time\">\n              </fs-date>\n            </div>\n          }\n          <div class=\"functions-list\">\n            @for (fn of functions(); track fn.class + '::' + fn.method) {\n              <div class=\"function-row\">\n                <div class=\"function-head\">\n                  <fs-chip\n                      size=\"tiny\"\n                      [backgroundColor]=\"kindColor(fn.kind)\"\n                      color=\"#ffffff\">\n                    {{ fn.kind }}\n                  </fs-chip>\n                  <code class=\"function-method\">{{ fn.method }}</code>\n                </div>\n                <div class=\"function-summary\">{{ fn.summary }}</div>\n                @if (fn.produces) {\n                  <div class=\"function-produces hint\">Produces: {{ fn.produces }}</div>\n                }\n              </div>\n            }\n          </div>\n        } @else {\n          <div class=\"hint\">\n            No functions cached for this entity yet — run a build to discover its code.\n          </div>\n        }\n      }\n    </div>\n  </mat-dialog-content>\n  <mat-dialog-actions>\n    <button\n        type=\"button\"\n        mat-button\n        color=\"primary\"\n        [mat-dialog-close]=\"undefined\">\n      Close\n    </button>\n  </mat-dialog-actions>\n</fs-dialog>\n"]}