ngx-dynamic-entity 2.5.0 → 3.0.0-rc.1

package/fesm2022/ngx-dynamic-entity.mjs

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { InjectionToken, makeEnvironmentProviders, inject, Injectable, signal, Input, ChangeDetectionStrategy, Component, ChangeDetectorRef, DestroyRef, Injector, isDevMode, ViewContainerRef, ViewChild, forwardRef, Optional, Inject, EventEmitter, ElementRef, computed, afterNextRender, HostListener, ViewChildren, Output } from '@angular/core';
 import * as i1 from '@angular/forms';
 import { ReactiveFormsModule, Validators, FormBuilder, FormGroup, FormArray, FormsModule } from '@angular/forms';
-import { resolveLabel, formatDisplayValue, normalizeLookupValues, lookupValuesToOptions, valuesMatch, resolveOptionLabel, resolveOptionValue, buildReferenceCacheKey, normalizeReferenceOptions, entityKeyFromCacheKey, applyCascadeFilter, resolveEffectiveMask, shouldMaskField, findTab, isValidUrl, isValidPhone, fileRefName, sliderBounds, ratingScale, normalizeHexColor, normalizeTags, evaluateFormRules, filterRulesForTab, evaluateFieldVisibility, fieldsUnderTab, getTabPath, fieldRefFor, flattenFieldValues, parseFieldRef, placeTabFields, normalizeArrayStructures, getTabData, getValueByPath, normalizeConfigOptions, migrateRecord, ambiguousFieldIds, toRefToken, collectFieldScopes, applyAutoPatch, refOf, isUnsafePath, valuesEqual, parseCsv, arrayBoundFor, deriveImportColumns, suggestMapping, cellText, applyMapping, decimalMarkFor, toCsv, stripIndices, CORE_VERSION, DEFAULT_ARRAY_ROWS, upgradeLegacyRefs, coerceCell, buildTemplateSpec, collectLeafTargets, formatConfigProblems } from '@dynamic-entity/core';
+import { resolveLabel, formatDisplayValue, normalizeLookupValues, lookupValuesToOptions, valuesMatch, resolveOptionLabel, resolveOptionValue, buildReferenceCacheKey, normalizeReferenceOptions, entityKeyFromCacheKey, applyCascadeFilter, resolveEffectiveMask, shouldMaskField, findTab, isValidUrl, isValidPhone, fileRefName, sliderBounds, ratingScale, normalizeHexColor, normalizeTags, evaluateFormRules, filterRulesForTab, evaluateFieldVisibility, fieldsUnderTab, getTabPath, fieldRefFor, flattenFieldValues, parseFieldRef, placeTabFields, normalizeArrayStructures, getTabData, getValueByPath, normalizeConfigOptions, migrateRecord, ambiguousFieldIds, toRefToken, collectFieldScopes, applyAutoPatch, refOf, isUnsafePath, valuesEqual, parseCsv, arrayBoundFor, deriveImportColumns, suggestMapping, cellText, applyMapping, decimalMarkFor, toCsv, stripIndices, CORE_VERSION, DEFAULT_ARRAY_ROWS, planForServer, upgradeLegacyRefs, coerceCell, buildTemplateSpec, collectLeafTargets, formatConfigProblems } from '@dynamic-entity/core';
 export { formatDisplayValue, normalizeConfig, normalizeOption, resolveLabel, resolveOptionLabel, resolveOptionValue, valuesMatch } from '@dynamic-entity/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { Subject, isObservable, firstValueFrom } from 'rxjs';
@@ -10178,6 +10178,10 @@ class LocalImportTransport {
         pending.catch(() => this.parsed.delete(file));
         return pending;
     }
+    /**
+     * The suggestion made here is always plan v2, and the return type says so. The contract's is
+     * a plan in either shape, because a 2.x server sends the older one.
+     */
     async preview(file, context) {
         const sheet = await this.read(file);
         // Sized from the headers exactly as the server sizes them, so both offer the same slots.
@@ -10314,6 +10318,8 @@ function selectionOf(spec, context, fields) {
  * to resolve — and a consumer who wants two of them, pointed at two backends, gets that for
  * free.
  */
+/** What a Dynamic Entity server calls its adapter in the `adapter` stamp on every answer. */
+const ADAPTER_NAME = 'dynamic-entity';
 /** The first release whose server says which date order it reads with, and refuses to guess one. */
 const DATE_ORDER_SINCE = [2, 5];
 /** Whether an engine version is from before the server stopped reading dates month first. */
@@ -10330,6 +10336,12 @@ class HttpImportTransport {
      * Keyed on the `File`, so it lives exactly as long as the file does.
      */
     reported = new WeakMap();
+    /**
+     * The plan versions each previewed file's server said it reads. A file with no entry was
+     * never previewed here, and one whose server said nothing is from before plan v2: either
+     * way `commit` sends nothing that only a v2 reader would understand.
+     */
+    planVersions = new WeakMap();
     constructor(options) {
         this.options = options;
     }
@@ -10382,6 +10394,22 @@ class HttpImportTransport {
             `was built against ${CORE_VERSION}. The two halves of an import are supposed to be the ` +
             'same engine — bring them into step before trusting a difference in what they produce.');
     }
+    /**
+     * Warn when the server runs another adapter, or this one at another major version.
+     *
+     * Since 3.0 a server says which adapter turned its rows into records. A server from before
+     * that says nothing, and `checkEngine` has already compared the one version it does report.
+     */
+    checkAdapter(adapter) {
+        if (!adapter)
+            return;
+        const major = (version) => String(version ?? '').split('.')[0];
+        if (adapter.name === ADAPTER_NAME && major(adapter.version) === major(CORE_VERSION))
+            return;
+        this.warn(`[ngx-dynamic-entity] The import server reads rows with the adapter ${adapter.name} ${adapter.version}; ` +
+            `this app expects ${ADAPTER_NAME} ${major(CORE_VERSION)}.x. What the server imports may differ from ` +
+            'what the review step showed. Bring the two into step.');
+    }
     async preview(file, context) {
         const body = new FormData();
         body.append('file', file, file.name || 'upload');
@@ -10394,6 +10422,8 @@ class HttpImportTransport {
             throw await failureOf(response);
         const preview = (await response.json());
         this.checkEngine(preview.engineVersion);
+        this.checkAdapter(preview.adapter);
+        this.planVersions.set(file, Array.isArray(preview.planVersions) ? preview.planVersions : undefined);
         this.reported.set(file, preview.dateOrder);
         this.checkDateOrder(context?.dateOrder, preview.dateOrder, preview.engineVersion);
         return {
@@ -10415,11 +10445,21 @@ class HttpImportTransport {
             throw new Error(`This app reads dates as ${context.dateOrder} but the import server reads them as ${reported}. ` +
                 'Nothing was imported. Set the same dateOrder on the wizard and on the server\'s router.');
         }
+        // Also before a byte is sent. A server from before plan v2 ignores what it does not know,
+        // so a plan that groups rows would import one record per row there and report success.
+        const sendable = planForServer(plan, this.planVersions.get(file));
+        if (sendable.refused) {
+            throw new Error(`This mapping uses ${sendable.refused.join(', ')}, which the import server does not read: it is from ` +
+                'before mapping plan v2 and would ignore it. Nothing was imported. Upgrade the server to ' +
+                '@dynamic-entity/server 3.0 or later.');
+        }
         const body = new FormData();
         // **The plan first, and the file second.** The server starts importing while the file is
         // still arriving — that is the whole reason it exists — so the plan has to have arrived
         // already. `FormData` preserves append order, so this ordering is the contract.
-        body.append('plan', JSON.stringify(plan));
+        // As written for a server that reads plan v2, and in 2.x form (`entity`, `configVersion`)
+        // for one that does not: the same mapping, in the words that server knows.
+        body.append('plan', JSON.stringify(sendable.plan));
         body.append('file', file, file.name || 'upload');
         const response = await this.send(`${this.base}/${this.entityOf(context)}/import`, {
             method: 'POST',
@@ -10430,6 +10470,7 @@ class HttpImportTransport {
             throw await failureOf(response);
         const result = (await response.json());
         this.checkEngine(result.engineVersion);
+        this.checkAdapter(result.adapter);
         return {
             // Empty, and not because nothing was imported. The server streamed the file precisely so
             // that fifty thousand records never had to exist at once; sending them back would undo
@@ -10443,6 +10484,8 @@ class HttpImportTransport {
             errorCount: result.errorCount ?? result.errors?.length ?? 0,
             truncated: result.truncated ?? false,
             planProblems: result.planProblems ?? [],
+            // Only a 3.0 server sends them, and only a run with something to warn about has any.
+            ...(result.warnings?.length ? { warnings: result.warnings } : {}),
         };
     }
     async template(spec, format, context, fields) {
@@ -10587,10 +10630,10 @@ const CONSTANT = -1;
 class ImportMapperComponent {
     config;
     headers = [];
-    /** The starting point, normally `suggestMapping`'s output. */
+    /** The starting point, normally `suggestMapping`'s output. A stored 2.x plan is taken too. */
     plan = null;
     language = 'en';
-    /** Emitted whenever the user changes a selection. */
+    /** Emitted whenever the user changes a selection. Always plan v2, whichever shape came in. */
     planChange = new EventEmitter();
     ui = inject(UiTextService);
     rows = signal([], ...(ngDevMode ? [{ debugName: "rows" }] : /* istanbul ignore next */ []));
@@ -10703,6 +10746,10 @@ class ImportMapperComponent {
      * Every entry of the incoming plan survives in its own position — a fixed value, a ref the
      * config no longer has — unless the user changed or removed it, and an untouched entry is
      * emitted exactly as it arrived. New selections follow, in field order.
+     *
+     * What is emitted is plan v2, whichever shape came in: `target` and `schemaVersion`, where a
+     * 2.x plan said `entity` and `configVersion`. Anything else the incoming plan carried, such
+     * as its lists and its grouping, is kept.
      */
     toPlan() {
         const rowByRef = new Map(this.rows().map(row => [row.column.ref, row]));
@@ -10740,10 +10787,13 @@ class ImportMapperComponent {
             if (entry)
                 entries.push(entry);
         }
+        // The 2.x names go: a plan carrying both is one the reader has to warn about.
+        const kept = Object.fromEntries(Object.entries(this.incoming ?? {}).filter(([key]) => key !== 'entity' && key !== 'configVersion'));
         return {
-            ...this.incoming,
-            entity: this.config?.entity ?? '',
-            configVersion: this.config?.version,
+            ...kept,
+            planVersion: 2,
+            target: this.config?.entity ?? '',
+            schemaVersion: this.config?.version,
             sourceHeaders: [...this.headers],
             entries,
         };
@@ -11042,7 +11092,8 @@ class ImportPreviewComponent {
                     lang: this.language,
                     lookups: this.lookups,
                     decimal: this.decimal,
-                    dateOrder: this.dateOrder,
+                    // The column's own order when its plan entry states one, as the commit reads it.
+                    dateOrder: entry.dateOrder ?? this.dateOrder,
                 });
                 if ('error' in outcome)
                     return { text: outcome.error, failed: true };