@praxisui/dynamic-form 1.0.0-beta.40 → 1.0.0-beta.41

package/fesm2022/praxisui-dynamic-form.mjs

@@ -22,7 +22,7 @@ import { MatBadgeModule } from '@angular/material/badge';
 import { firstValueFrom, BehaviorSubject, Subject, debounceTime as debounceTime$1, takeUntil as takeUntil$1 } from 'rxjs';
 import { take, takeUntil, debounceTime, finalize, map } from 'rxjs/operators';
 import * as i1$2 from '@praxisui/core';
-import { PraxisIconDirective, RULE_PROPERTY_SCHEMA, FIELD_METADATA_CAPABILITIES, deepMerge, ASYNC_CONFIG_STORAGE, migrateFormLayoutRule, ensureIds, LoggerService, createCorporateLoggerConfig, ConsoleLoggerSink, ResourceQuickConnectComponent, normalizeFormConfig as normalizeFormConfig$1, mapFieldDefinitionsToMetadata, syncWithServerMetadata, PRAXIS_LOADING_CTX, normalizeControlTypeKey, resolveSpan, resolveOffset, resolveOrder, resolveHidden, fetchWithETag, resolveControlTypeAlias, getTextTransformer, MemoryCacheAdapter, LocalStorageCacheAdapter, SchemaMetadataClient, buildSchemaId, CONNECTION_STORAGE, PRAXIS_LOADING_RENDERER, FORM_HOOKS_PRESETS, EmptyStateCardComponent, createDefaultFormConfig, isValidFormConfig, ComponentMetadataRegistry, FieldControlType, GLOBAL_ACTION_CATALOG, getGlobalActionCatalog, GLOBAL_ACTION_SPEC_CATALOG, getGlobalActionUiSchema } from '@praxisui/core';
+import { PraxisIconDirective, RULE_PROPERTY_SCHEMA, FIELD_METADATA_CAPABILITIES, deepMerge, ASYNC_CONFIG_STORAGE, migrateFormLayoutRule, ensureIds, LoggerService, createCorporateLoggerConfig, ConsoleLoggerSink, ResourceQuickConnectComponent, normalizeFormConfig as normalizeFormConfig$1, mapFieldDefinitionsToMetadata, syncWithServerMetadata, PRAXIS_LOADING_CTX, normalizeControlTypeKey, resolveSpan, resolveOffset, resolveOrder, resolveHidden, buildSchemaId, fetchWithETag, resolveControlTypeAlias, getTextTransformer, MemoryCacheAdapter, LocalStorageCacheAdapter, SchemaMetadataClient, CONNECTION_STORAGE, PRAXIS_LOADING_RENDERER, FORM_HOOKS_PRESETS, EmptyStateCardComponent, createDefaultFormConfig, isValidFormConfig, ComponentMetadataRegistry, FieldControlType, GLOBAL_ACTION_CATALOG, getGlobalActionCatalog, GLOBAL_ACTION_SPEC_CATALOG, getGlobalActionUiSchema } from '@praxisui/core';
 import * as i1 from '@praxisui/dynamic-fields';
 import { getControlTypeCatalog, ConfirmDialogComponent, DynamicFieldLoaderDirective } from '@praxisui/dynamic-fields';
 import { BaseAiAdapter, PraxisAiAssistantComponent } from '@praxisui/ai';
@@ -6190,6 +6190,79 @@ class PraxisDynamicForm {
         const id = this.componentKeyId();
         return id ? `form-schema-meta:${id}` : null;
     }
+    getSchemaMetaIndexKey() {
+        const key = this.getSchemaMetaKey();
+        return key ? `${key}:index` : null;
+    }
+    getSchemaMetaKeyForSchemaId(schemaId) {
+        const scopeKey = this.getSchemaMetaKey();
+        const id = String(schemaId || '').trim();
+        if (!scopeKey || !id)
+            return null;
+        return `${scopeKey}:schema:${id}`;
+    }
+    getSchemaMetaKeyForContext(context) {
+        try {
+            const schemaId = buildSchemaId(context);
+            return this.getSchemaMetaKeyForSchemaId(schemaId) || this.getSchemaMetaKey();
+        }
+        catch {
+            return this.getSchemaMetaKey();
+        }
+    }
+    loadStoredSchemaMeta(key) {
+        if (!key)
+            return Promise.resolve(undefined);
+        return firstValueFrom(this.asyncConfigStorage.loadConfig(key))
+            .then((value) => value ?? undefined)
+            .catch(() => undefined);
+    }
+    rememberSchemaMetaContext(schemaId) {
+        const id = String(schemaId || '').trim();
+        if (!id)
+            return;
+        const indexKey = this.getSchemaMetaIndexKey();
+        if (!indexKey)
+            return;
+        this.asyncConfigStorage
+            .loadConfig(indexKey)
+            .pipe(take(1))
+            .subscribe({
+            next: (stored) => {
+                const unique = new Set((Array.isArray(stored) ? stored : [])
+                    .map((item) => String(item || '').trim())
+                    .filter((item) => !!item));
+                unique.add(id);
+                this.asyncConfigStorage
+                    .saveConfig(indexKey, Array.from(unique))
+                    .pipe(take(1))
+                    .subscribe({ error: () => { } });
+            },
+            error: () => { },
+        });
+    }
+    isSameSchemaContext(left, right) {
+        if (!left || !right)
+            return false;
+        return (left.path === right.path &&
+            left.operation === right.operation &&
+            left.schemaType === right.schemaType &&
+            left.includeInternalSchemas === right.includeInternalSchemas &&
+            left.tenant === right.tenant &&
+            left.locale === right.locale &&
+            left.apiOrigin === right.apiOrigin);
+    }
+    isStoredSchemaMetaForContext(storedMeta, schemaId, context) {
+        if (!storedMeta || typeof storedMeta !== 'object')
+            return false;
+        const storedSchemaId = String(storedMeta.schemaId || '').trim();
+        if (storedSchemaId && storedSchemaId !== schemaId)
+            return false;
+        const storedContext = storedMeta.schemaContext;
+        if (storedContext && !this.isSameSchemaContext(storedContext, context))
+            return false;
+        return true;
+    }
     getPrefsKey() {
         const id = this.componentKeyId();
         return id ? `form-schema-prefs:${id}` : null;
@@ -6362,13 +6435,27 @@ class PraxisDynamicForm {
     // Verify-only using ETag without downloading schema body
     async verifyServerSchemaVersion() {
         try {
-            const metaKey = this.getSchemaMetaKey();
-            if (!this.resourcePath || !metaKey)
+            if (!this.resourcePath)
                 return;
             // Only verify when we already have a base configuration (sections)
             if ((this.config?.sections?.length ?? 0) === 0)
                 return;
             const ctx = this.buildSchemaContext();
+            const schemaContext = {
+                path: ctx.path,
+                operation: ctx.operation,
+                schemaType: ctx.schemaType,
+                includeInternalSchemas: ctx.includeInternalSchemas,
+                tenant: ctx.tenant,
+                locale: ctx.locale,
+                apiOrigin: ctx.apiOrigin,
+            };
+            const currentSchemaId = buildSchemaId(schemaContext);
+            const scopedMetaKey = this.getSchemaMetaKeyForSchemaId(currentSchemaId) ||
+                this.getSchemaMetaKeyForContext(schemaContext) ||
+                this.getSchemaMetaKey();
+            if (!scopedMetaKey)
+                return;
             const baseUrl = ctx.baseUrl;
             const u = new URL(baseUrl);
             u.searchParams.set('path', ctx.path);
@@ -6376,8 +6463,20 @@ class PraxisDynamicForm {
             u.searchParams.set('schemaType', String(ctx.schemaType || 'response'));
             u.searchParams.set('includeInternalSchemas', String(!!ctx.includeInternalSchemas));
             // Load previously persisted meta (serverHash)
-            const persistedMeta = await firstValueFrom(this.asyncConfigStorage.loadConfig(metaKey)).catch(() => undefined);
-            const previousHash = persistedMeta?.serverHash || this.lastSchemaMeta?.serverHash;
+            const scopedMeta = await this.loadStoredSchemaMeta(scopedMetaKey);
+            const legacyScopeKey = this.getSchemaMetaKey();
+            const legacyMeta = legacyScopeKey && legacyScopeKey !== scopedMetaKey
+                ? await this.loadStoredSchemaMeta(legacyScopeKey)
+                : undefined;
+            const persistedMeta = this.isStoredSchemaMetaForContext(scopedMeta, currentSchemaId, schemaContext)
+                ? scopedMeta
+                : this.isStoredSchemaMetaForContext(legacyMeta, currentSchemaId, schemaContext)
+                    ? legacyMeta
+                    : undefined;
+            const lastLocalHash = this.isSameSchemaContext(this.lastSchemaMeta?.context, schemaContext)
+                ? this.lastSchemaMeta?.serverHash
+                : undefined;
+            const previousHash = persistedMeta?.serverHash || lastLocalHash;
             // If we have no prior hash and no base, skip verification (handled by initial fetch)
             if (!previousHash && (this.config?.sections?.length ?? 0) === 0) {
                 return;
@@ -6397,14 +6496,22 @@ class PraxisDynamicForm {
             const res = await fetchWithETag({ url: u.toString(), schemaHash: previousHash, tenant, locale });
             const nowIso = new Date().toISOString();
             const metaToSave = { ...(persistedMeta || {}) };
+            metaToSave.schemaId = currentSchemaId;
+            metaToSave.schemaContext = schemaContext;
             metaToSave.lastVerifiedAt = nowIso;
+            if (!metaToSave.serverHash && previousHash) {
+                metaToSave.serverHash = previousHash;
+            }
             if (res.status === 304) {
-                this.asyncConfigStorage.saveConfig(metaKey, metaToSave).subscribe();
+                this.asyncConfigStorage.saveConfig(scopedMetaKey, metaToSave).subscribe();
+                this.rememberSchemaMetaContext(currentSchemaId);
                 // Mirror meta in memory (config.metadata) without persisting config
                 try {
                     const mem = { ...(this.config.metadata || {}) };
                     if (metaToSave.serverHash)
                         mem.serverHash = metaToSave.serverHash;
+                    mem.schemaId = metaToSave.schemaId;
+                    mem.schemaContext = metaToSave.schemaContext;
                     mem.lastVerifiedAt = metaToSave.lastVerifiedAt;
                     this.config = { ...this.config, metadata: mem };
                     this.cdr.markForCheck();
@@ -6420,19 +6527,22 @@ class PraxisDynamicForm {
             // status === 200: server hash changed (or first verification without hash). Do not apply schema here.
             const newHash = res.schemaHash;
             metaToSave.serverHash = newHash;
-            this.asyncConfigStorage.saveConfig(metaKey, metaToSave).subscribe();
+            this.asyncConfigStorage.saveConfig(scopedMetaKey, metaToSave).subscribe();
+            this.rememberSchemaMetaContext(currentSchemaId);
             // Mirror meta in memory (config.metadata) without persisting config
             try {
                 const mem = { ...(this.config.metadata || {}) };
                 if (metaToSave.serverHash)
                     mem.serverHash = metaToSave.serverHash;
+                mem.schemaId = metaToSave.schemaId;
+                mem.schemaContext = metaToSave.schemaContext;
                 mem.lastVerifiedAt = metaToSave.lastVerifiedAt;
                 this.config = { ...this.config, metadata: mem };
                 this.cdr.markForCheck();
             }
             catch { }
-            // Only mark outdated when there was a previous base and we are in edit mode
-            const hadBase = (this.config?.sections?.length ?? 0) > 0 || !!previousHash;
+            // Only mark outdated when there is a confirmed prior hash for this context.
+            const hadBase = !!previousHash;
             this.schemaOutdated = !!(this.editModeEnabled && hadBase);
             this.schemaStatusChange.emit({ outdated: this.schemaOutdated, serverHash: newHash, lastVerifiedAt: metaToSave.lastVerifiedAt, formId: this.formId });
             // Load state for new hash
@@ -9019,6 +9129,15 @@ class PraxisDynamicForm {
             return this.schemaCache;
         }
         const ctx = this.buildSchemaContext();
+        const schemaContext = {
+            path: ctx.path,
+            operation: ctx.operation,
+            schemaType: ctx.schemaType,
+            includeInternalSchemas: ctx.includeInternalSchemas,
+            tenant: ctx.tenant,
+            locale: ctx.locale,
+            apiOrigin: ctx.apiOrigin,
+        };
         const loadingCtx = this.buildLoadingContext('schema', 'Carregando configuração…', true);
         this.beginLoading(loadingCtx);
         this.emitLoadingState('schema', 'loading', 'Carregando schema do formulário...');
@@ -9052,8 +9171,8 @@ class PraxisDynamicForm {
                 ? legacyResult.pipe(take(1))
                 : legacyResult);
             try {
-                const schemaId = buildSchemaId(ctx);
-                this.lastSchemaMeta = { schemaId, serverHash: '', context: ctx };
+                const schemaId = buildSchemaId(schemaContext);
+                this.lastSchemaMeta = { schemaId, context: schemaContext };
             }
             catch { }
             this.schemaCache = legacyDefs;
@@ -9089,19 +9208,27 @@ class PraxisDynamicForm {
                 }
             }
             catch { }
-            const schemaId = buildSchemaId(ctx);
-            this.lastSchemaMeta = { schemaId, serverHash: entry.schemaHash, context: ctx };
+            const schemaId = buildSchemaId(schemaContext);
+            this.lastSchemaMeta = { schemaId, serverHash: entry.schemaHash, context: schemaContext };
             this.schemaCache = defs;
             this.emitLoadingState('schema', 'success', 'Schema carregado.');
             // Persist meta for future ETag verifications
             try {
-                const metaKey = this.getSchemaMetaKey();
+                const metaKey = this.getSchemaMetaKeyForSchemaId(schemaId) ||
+                    this.getSchemaMetaKeyForContext(schemaContext) ||
+                    this.getSchemaMetaKey();
                 if (metaKey) {
                     const nowIso = new Date().toISOString();
                     this.asyncConfigStorage
-                        .saveConfig(metaKey, { serverHash: entry.schemaHash, lastVerifiedAt: nowIso })
+                        .saveConfig(metaKey, {
+                        schemaId,
+                        schemaContext,
+                        serverHash: entry.schemaHash,
+                        lastVerifiedAt: nowIso,
+                    })
                         .pipe(take(1))
                         .subscribe({ error: () => { } });
+                    this.rememberSchemaMetaContext(schemaId);
                 }
             }
             catch { }
@@ -15522,7 +15649,31 @@ class PraxisDynamicFormConfigEditor {
                 }
                 this.schemaPrefs = { ...this.schemaPrefs, ...allowed };
             }
-            this.serverMeta = (await firstValueFrom(this.storage.loadConfig(`form-schema-meta:${key}`)).catch(() => undefined)) || undefined;
+            const schemaScopeKey = `form-schema-meta:${key}`;
+            const schemaId = String(this.editedConfig?.metadata?.schemaId ||
+                this.initialConfig?.metadata?.schemaId ||
+                '').trim();
+            const schemaMetaCandidates = [];
+            if (schemaId) {
+                schemaMetaCandidates.push(`${schemaScopeKey}:schema:${schemaId}`);
+            }
+            if (!schemaId) {
+                const storedIds = await firstValueFrom(this.storage.loadConfig(`${schemaScopeKey}:index`)).catch(() => []);
+                const ids = (Array.isArray(storedIds) ? storedIds : [])
+                    .map((item) => String(item || '').trim())
+                    .filter((item) => !!item);
+                ids.forEach((id) => schemaMetaCandidates.push(`${schemaScopeKey}:schema:${id}`));
+            }
+            schemaMetaCandidates.push(schemaScopeKey); // legacy fallback
+            let resolvedMeta;
+            for (const candidate of Array.from(new Set(schemaMetaCandidates))) {
+                const loaded = await firstValueFrom(this.storage.loadConfig(candidate)).catch(() => undefined);
+                if (loaded && typeof loaded === 'object') {
+                    resolvedMeta = loaded;
+                    break;
+                }
+            }
+            this.serverMeta = resolvedMeta || undefined;
         }
         catch { }
         this.cdr.detectChanges();