@geogirafe/lib-geoportal 1.1.0-dev.2402672760 → 1.1.0-dev.2407038460

package/models/serverwfs.d.ts

@@ -12,6 +12,8 @@ declare class ServerWfs<WfsXmlTypes = XmlTypes> {
     };
     initialized: boolean;
     constructor(name: string, url: string);
+    addLayer(layer: string): void;
+    removeLayer(layer: string): void;
     addLayerAttribute(layer: string, name: string, type: string): void;
     getGeometryColumnNameToFeatureTypes(featureTypes: string[]): Record<string, string[]>;
 }

package/models/serverwfs.js

@@ -9,11 +9,17 @@ class ServerWfs {
         this.url = url;
         this.initialized = false;
     }
-    addLayerAttribute(layer, name, type) {
-        if (!(layer in this.layers)) {
-            // Layer does not exists yet
+    addLayer(layer) {
+        if (!this.layers[layer]) {
             this.layers[layer] = [];
         }
+    }
+    removeLayer(layer) {
+        delete this.layers[layer];
+        delete this.featureTypeToGeometryColumnName[layer];
+    }
+    addLayerAttribute(layer, name, type) {
+        this.addLayer(layer);
         this.layers[layer].push({
             name: name,
             type: type

package/package.json

@@ -5,7 +5,7 @@
     "name": "GeoGirafe PSC",
     "url": "https://doc.geomapfish.dev"
   },
-  "version": "1.1.0-dev.2402672760",
+  "version": "1.1.0-dev.2407038460",
   "type": "module",
   "engines": {
     "node": ">=20.19.0"

package/service-worker.js

@@ -60,8 +60,9 @@ function handleMessage(event) {
         audience = data.audience ?? [];
         log(`audience changed: ${audience}`);
     }
+    audienceExcludedPaths = [];
     if (data.audienceExcludedPaths) {
-        audienceExcludedPaths = data.audienceExcludedPaths ? data.audienceExcludedPaths.map((str) => new RegExp(str)) : [];
+        audienceExcludedPaths = data.audienceExcludedPaths.map((str) => new RegExp(str));
         log(`audienceExcludedPaths changed: ${audienceExcludedPaths}`);
     }
     if (data.access_token) {
@@ -253,6 +254,6 @@ async function openIndexedDB() {
 }
 function log(str, error) {
     if (logLevel === 'debug') {
-        console.debug(`SW: ${str}`, error);
+        console.debug(`SW: ${str}`, error ?? '');
     }
 }

package/templates/public/about.json

@@ -1 +1 @@
-{"version":"1.1.0-dev.2402672760", "build":"2402672760", "date":"23/03/2026"}
+{"version":"1.1.0-dev.2407038460", "build":"2407038460", "date":"25/03/2026"}

package/tools/wfs/wfsclient.d.ts

@@ -32,9 +32,10 @@ export default class WfsClient<WfsXmlTypes = XmlTypes> {
     private configMaxFeatures;
     getServerWfs(): Promise<ServerWfs<WfsXmlTypes>>;
     protected describeFeatureType(): Promise<ServerWfs<WfsXmlTypes>>;
-    private describeFeatureTypeInternal;
+    private requestDescribeFeatureType;
+    private parseDescribeFeatureTypeResponse;
     private initializeAttribute;
-    protected manageLayerAttribute(serverWfs: ServerWfs<WfsXmlTypes>, element: Element, featureType: string): boolean;
+    protected manageLayerAttribute(serverWfs: ServerWfs<WfsXmlTypes>, element: Element, featureType: string): void;
     protected validateLayerAttributeType(type: string): boolean;
     protected getElementToTypeName(xml: Document): Record<string, string>;
     protected getDescribeFeatureTypeUrl(): string;

package/tools/wfs/wfsclient.js

@@ -48,7 +48,7 @@ export default class WfsClient {
     }
     describeFeatureType() {
         if (!this.serverWfs) {
-            this.serverWfs = this.describeFeatureTypeInternal();
+            this.serverWfs = this.parseDescribeFeatureTypeResponse();
             this.serverWfs.catch((error) => {
                 const msg = `WFS server with URL ${this.wfsUrl} could not be initialized. Error: `;
                 console.error(msg, error);
@@ -57,12 +57,15 @@ export default class WfsClient {
         }
         return this.serverWfs;
     }
-    async describeFeatureTypeInternal() {
-        const serverWfs = new ServerWfs('', this.wfsUrl);
+    async requestDescribeFeatureType() {
         const url = this.getDescribeFeatureTypeUrl();
         const response = await fetch(url);
         const content = await response.text();
-        const xml = new DOMParser().parseFromString(content, 'text/xml');
+        return new DOMParser().parseFromString(content, 'text/xml');
+    }
+    async parseDescribeFeatureTypeResponse() {
+        const serverWfs = new ServerWfs('', this.wfsUrl);
+        const xml = await this.requestDescribeFeatureType();
         // First, find all direct "element" children
         const elementTypeToName = this.getElementToTypeName(xml);
         // Then, find all "complexType" elements
@@ -83,48 +86,39 @@ export default class WfsClient {
         }
         const featureType = elementTypeToName[typeName];
         const elements = tag.getElementsByTagName('sequence')[0].getElementsByTagName('element');
-        let geometryAttributeFound = false;
-        for (const element of elements) {
-            if (this.manageLayerAttribute(serverWfs, element, featureType)) {
-                geometryAttributeFound = true;
+        try {
+            serverWfs.addLayer(featureType);
+            for (const element of elements) {
+                this.manageLayerAttribute(serverWfs, element, featureType);
+            }
+            // If we didn't find any geometry attribute for this featureType, wfs querying won't be possible
+            if (!serverWfs.featureTypeToGeometryColumnName[featureType]) {
+                throw new Error(`No Geometry column for the type ${featureType}`);
             }
         }
-        // If we didn't find any geometry attribute for this featureType, then we have a problem
-        // Because the wfs query won't be possible
-        if (!geometryAttributeFound) {
-            throw new Error('No Geometry column for the type ' + featureType);
+        catch (error) {
+            serverWfs.removeLayer(featureType);
+            console.error(`Error while parsing feature type ${typeName}: ${error}`);
         }
     }
     manageLayerAttribute(serverWfs, element, featureType) {
-        let geometryAttributeFound = false;
-        const type = element.getAttribute('type');
-        if (type?.startsWith('gml:')) {
-            // We are on the geometry attribute
-            const geometryAttributeName = element.getAttribute('name');
-            if (geometryAttributeName) {
-                serverWfs.featureTypeToGeometryColumnName[featureType] = geometryAttributeName;
-                geometryAttributeFound = true;
-            }
-            else {
-                throw new Error('Why is geometryAttributeName null here ?');
-            }
+        const attributeType = element.getAttribute('type');
+        const attributeName = element.getAttribute('name');
+        if (!attributeName || !attributeType) {
+            console.warn(`Error while loading attributes for layer ${featureType}. Attribute name and/or type is missing. Element ignored.`);
+            return;
         }
-        else {
-            // We are not on a geometry attribute, but on a normal attribute
-            // We update the WMS Layer with its attribute information
-            const attrName = element.getAttribute('name');
-            const attrType = element.getAttribute('type');
-            if (!attrName || !attrType) {
-                console.warn(`Error while loading attribute for layer ${featureType}. Querying or filtering this layer won't work correctly.`);
-            }
-            else if (this.validateLayerAttributeType(attrType)) {
-                serverWfs.addLayerAttribute(featureType, attrName, attrType);
-            }
-            else {
-                console.warn(`Unmanaged layer attribute type: ${attrType} for attribute ${attrName} of featureType ${featureType}. ${attrName} ignored.`);
-            }
+        // Handle the geometry attribute
+        if (attributeType.startsWith('gml:')) {
+            serverWfs.featureTypeToGeometryColumnName[featureType] = attributeName;
+            return;
+        }
+        // Handle all remaining regular attributes
+        if (!this.validateLayerAttributeType(attributeType)) {
+            console.warn(`Unmanaged layer attribute type: ${attributeType} for attribute ${attributeName} of featureType ${featureType}. ${attributeName} ignored.`);
+            return;
         }
-        return geometryAttributeFound;
+        serverWfs.addLayerAttribute(featureType, attributeName, attributeType);
     }
     validateLayerAttributeType(type) {
         return xmlTypesStrList.includes(type);

package/tools/wfs/wfsclient.spec.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-import { vi, afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { vi, afterAll, describe, expect, it, beforeEach } from 'vitest';
 import { WfsClientMapServer } from './wfsclient';
 import ServerOgc from '../../models/serverogc';
 import MockHelper from '../tests/mockhelper';
@@ -9,8 +9,9 @@ describe('WfsClient', () => {
     let context;
     let server;
     let client;
-    beforeAll(() => {
+    beforeEach(() => {
         context = MockHelper.startMocking();
+        vi.resetAllMocks();
         server = new ServerOgc('testOgcServer', {
             url: 'https://wms-1.test.url',
             wfsSupport: true,
@@ -116,4 +117,82 @@ describe('WfsClient', () => {
             expect(completeOptions[1].geometryName).toBe('geom');
         });
     });
+    describe('describeFeatureType', () => {
+        const xmlResponse = `
+      <schema
+        targetNamespace="http://mapserver.gis.umn.edu/mapserver" 
+        xmlns:ms="http://mapserver.gis.umn.edu/mapserver" 
+        xmlns:ogc="http://www.opengis.net/ogc"
+        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+        xmlns="http://www.w3.org/2001/XMLSchema"
+        xmlns:gml="http://www.opengis.net/gml"
+        elementFormDefault="qualified" version="0.1" >
+        <import namespace="http://www.opengis.net/gml" schemaLocation="http://schemas.opengis.net/gml/3.1.1/base/gml.xsd" />
+        
+        <element name="testlayer1" type="ms:testlayer1Type" substitutionGroup="gml:_Feature" />
+        <complexType name="testlayer1Type">
+          <complexContent>
+            <extension base="gml:AbstractFeatureType">
+              <sequence>
+                <element name="geom" type="gml:SurfacePropertyType" minOccurs="0" maxOccurs="1"/>
+                <element name="text_de" minOccurs="0" type="string"/>
+              </sequence>
+            </extension>
+          </complexContent>
+        </complexType>
+      </schema>
+    `;
+        const mockDescribeFeatureRequest = async (xmlResponse) => {
+            const describeFeatureTypeResponse = new DOMParser().parseFromString(xmlResponse, 'application/xml');
+            // @ts-ignore
+            vi.spyOn(client, 'requestDescribeFeatureType').mockReturnValue(
+            // @ts-ignore
+            new Promise((resolve) => resolve(describeFeatureTypeResponse)));
+        };
+        it('registers the features type described in the response', async () => {
+            await mockDescribeFeatureRequest(xmlResponse);
+            const server = await client.getServerWfs();
+            expect(server.layers).toBeDefined();
+            expect(Object.keys(server.layers)).toContain('testlayer1');
+            expect(server.layers['testlayer1']).toEqual([{ name: 'text_de', type: 'string' }]);
+        });
+        it('registers the feature type even if it does not have any attributes except a geometry', async () => {
+            const xmlNoAttributes = xmlResponse.replace('<element name="text_de" minOccurs="0" type="string"/>', '');
+            await mockDescribeFeatureRequest(xmlNoAttributes);
+            const server = await client.getServerWfs();
+            expect(server.layers).toBeDefined();
+            expect(Object.keys(server.layers)).toContain('testlayer1');
+            expect(server.layers['testlayer1']).toEqual([]);
+        });
+        it('ignores an attribute if its type is missing', async () => {
+            const xmlNoType = xmlResponse.replace('<element name="text_de" minOccurs="0" type="string"/>', '<element name="text_de" minOccurs="0"/>');
+            await mockDescribeFeatureRequest(xmlNoType);
+            const server = await client.getServerWfs();
+            expect(server.layers).toBeDefined();
+            expect(Object.keys(server.layers)).toContain('testlayer1');
+            expect(server.layers['testlayer1']).toEqual([]);
+        });
+        it('ignores an attribute if its name is missing', async () => {
+            const xmlNoAttributeName = xmlResponse.replace('<element name="text_de" minOccurs="0" type="string"/>', '<element minOccurs="0" type="string"/>');
+            await mockDescribeFeatureRequest(xmlNoAttributeName);
+            const server = await client.getServerWfs();
+            expect(server.layers).toBeDefined();
+            expect(Object.keys(server.layers)).toContain('testlayer1');
+            expect(server.layers['testlayer1']).toEqual([]);
+        });
+        it('ignores the feature type if it does not contain a geometry attribute', async () => {
+            const xmlNoGeometry = xmlResponse.replace('<element name="geom" type="gml:SurfacePropertyType" minOccurs="0" maxOccurs="1"/>', '');
+            await mockDescribeFeatureRequest(xmlNoGeometry);
+            const server = await client.getServerWfs();
+            expect(server.layers).toBeDefined();
+            expect(Object.keys(server.layers)).toEqual([]);
+        });
+        it('ignores the feature type if the geometry attribute has no geometry name', async () => {
+            const xmlNoGeometryName = xmlResponse.replace('<element name="geom" type="gml:SurfacePropertyType" minOccurs="0" maxOccurs="1"/>', '<element type="gml:SurfacePropertyType" minOccurs="0" maxOccurs="1"/>');
+            await mockDescribeFeatureRequest(xmlNoGeometryName);
+            const server = await client.getServerWfs();
+            expect(server.layers).toBeDefined();
+            expect(Object.keys(server.layers)).toEqual([]);
+        });
+    });
 });