@yomotech/view-toolkit 0.0.53 → 0.0.54

package/fesm2022/yomotech-view-toolkit.mjs

@@ -866,43 +866,28 @@ class Couchdb {
     constructor(utilityService) {
         this.utilityService = utilityService;
     }
-    /**
-     * Angular web development:
-     * /couchdb-api -> Angular proxy -> https://couchdb.yomotech.de
-     *
-     * Capacitor Android/iOS:
-     * Direct native request to https://couchdb.yomotech.de
-     */
-    get couchDbBaseUrl() {
-        return Capacitor.isNativePlatform()
-            ? this.remoteCouchDbBaseUrl
-            : this.webProxyBaseUrl;
-    }
     async getTenantDatabases(tenantKey) {
         const normalizedTenantKey = tenantKey?.trim();
         if (!normalizedTenantKey) {
             throw new Error('Missing tenantKey');
         }
-        const response = await fetch(`${this.couchDbBaseUrl}/tenant-dbs`, {
-            method: 'GET',
-            cache: 'no-store',
-            headers: {
-                Accept: 'application/json',
-                'X-Tenant-Key': normalizedTenantKey,
-            },
+        const result = await this.sendGetRequest('/tenant-dbs', {
+            Accept: 'application/json',
+            'X-Tenant-Key': normalizedTenantKey,
         });
-        const data = await this.parseJsonOrText(response);
-        if (!response.ok) {
-            throw new Error(`GET /tenant-dbs -> ${response.status} ` +
-                `${this.stringifyErrorDetails(data)}`);
-        }
-        console.log('data: ', data);
-        // if (!Array.isArray(data) || !Array.isArray(data.databases)) {
-        //   throw new Error(
-        //     `Invalid /tenant-dbs response: ${this.stringifyErrorDetails(data)}`
-        //   );
-        // }
-        return data;
+        if (!result.ok) {
+            throw new Error(`GET /tenant-dbs -> ${result.status} ` +
+                `${this.stringifyErrorDetails(result.data)}`);
+        }
+        if (Array.isArray(result.data)) {
+            return result.data;
+        }
+        if (result.data &&
+            Array.isArray(result.data.databases)) {
+            return result.data.databases;
+        }
+        throw new Error(`Invalid /tenant-dbs response: ` +
+            `${this.stringifyErrorDetails(result.data)}`);
     }
     async getFileContentFromCouchDb(couchDbName, filePath) {
         try {
@@ -916,51 +901,56 @@ class Couchdb {
                 console.error('Missing file path');
                 return null;
             }
-            const response = await fetch(this.getDocumentUrl(dbName, docId), {
-                method: 'GET',
-                cache: 'no-store',
-                headers: await this.getReadHeaders(),
-            });
-            const doc = await this.parseJsonOrText(response);
-            if (!response.ok) {
-                console.error(`Failed to fetch file "${docId}" from "${dbName}": ` +
-                    `${response.status}`, doc);
+            const path = this.getDocumentPath(dbName, docId);
+            const result = await this.sendGetRequest(path, await this.getReadHeaders());
+            const doc = result.data;
+            if (!result.ok) {
+                console.error(`Failed to fetch file "${docId}" ` +
+                    `from "${dbName}": ` +
+                    `${result.status}`, doc);
                 return null;
             }
             if (!doc?.data) {
-                console.error(`Document "${docId}" does not contain file data`);
+                console.error(`Document "${docId}" ` +
+                    `does not contain file data`);
                 return null;
             }
+            const fileName = doc.name ||
+                doc.path ||
+                docId;
             if (doc.type === 'media' ||
                 doc.type === 'base64file' ||
-                this.isBinaryMediaFile(doc.name || doc.path || docId, doc.contentType)) {
-                const fileName = doc.name || doc.path || docId;
+                this.isBinaryMediaFile(fileName, doc.contentType)) {
                 const mimeType = this.getMimeType(fileName, doc.contentType);
                 return {
-                    type: doc.type || 'base64file',
+                    type: doc.type ||
+                        'base64file',
                     mimeType,
                     base64: doc.data,
-                    src: `data:${mimeType};base64,${doc.data}`,
+                    src: `data:${mimeType};base64,` +
+                        `${doc.data}`,
                     name: doc.name,
                     path: doc.path,
                     metadata: doc.metadata || {},
                 };
             }
             const decodedContent = this.fromBase64(doc.data);
-            if (this.isJsonFile(doc.name || doc.path || docId, doc.contentType)) {
+            if (this.isJsonFile(fileName, doc.contentType)) {
                 try {
                     return JSON.parse(decodedContent);
                 }
                 catch (jsonError) {
-                    console.error(`Failed to parse JSON for file "${docId}"`, jsonError);
+                    console.error(`Failed to parse JSON ` +
+                        `for file "${docId}"`, jsonError);
                     return decodedContent;
                 }
             }
             return decodedContent;
         }
         catch (error) {
-            console.error(`Unexpected error while fetching file "${filePath}" ` +
-                `from "${couchDbName}"`, error);
+            console.error(`Unexpected error while fetching ` +
+                `file "${filePath}" from ` +
+                `"${couchDbName}"`, error);
             return null;
         }
     }
@@ -973,35 +963,119 @@ class Couchdb {
         if (!docId) {
             throw new Error('Missing file path');
         }
-        const response = await fetch(this.getDocumentUrl(dbName, docId), {
-            method: 'GET',
-            cache: 'no-store',
-            headers: await this.getReadHeaders(),
-        });
-        const doc = await this.parseJsonOrText(response);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch image "${docId}" from "${dbName}": ` +
-                `${response.status} ${this.stringifyErrorDetails(doc)}`);
+        const path = this.getDocumentPath(dbName, docId);
+        const result = await this.sendGetRequest(path, await this.getReadHeaders());
+        const doc = result.data;
+        if (!result.ok) {
+            throw new Error(`Failed to fetch image ` +
+                `"${docId}" from "${dbName}": ` +
+                `${result.status} ` +
+                `${this.stringifyErrorDetails(doc)}`);
         }
         if (!doc?.data) {
-            throw new Error(`Document "${docId}" does not contain image data`);
+            throw new Error(`Document "${docId}" ` +
+                `does not contain image data`);
+        }
+        const mimeType = this.getMimeType(doc.name ||
+            doc.path ||
+            docId, doc.contentType);
+        return (`data:${mimeType};base64,` +
+            `${doc.data}`);
+    }
+    async sendGetRequest(path, headers) {
+        const normalizedPath = path.startsWith('/')
+            ? path
+            : `/${path}`;
+        if (Capacitor.isNativePlatform()) {
+            return this.sendNativeGetRequest(normalizedPath, headers);
         }
-        const mimeType = this.getMimeType(doc.name || doc.path || docId, doc.contentType);
-        return `data:${mimeType};base64,${doc.data}`;
+        return this.sendWebGetRequest(normalizedPath, headers);
     }
-    getDocumentUrl(dbName, docId) {
-        return (`${this.getDbUrl(dbName)}/` +
-            `${encodeURIComponent(docId)}`);
+    async sendNativeGetRequest(path, headers) {
+        const url = `${this.remoteCouchDbBaseUrl}${path}`;
+        console.log('[CouchDB][Native] GET:', url);
+        try {
+            const response = await CapacitorHttp.get({
+                url,
+                headers,
+                connectTimeout: 15000,
+                readTimeout: 30000,
+            });
+            const data = this.normalizeNativeResponseData(response.data);
+            return {
+                ok: response.status >= 200 &&
+                    response.status < 300,
+                status: response.status,
+                data: data,
+            };
+        }
+        catch (error) {
+            console.error('[CouchDB][Native] Request failed:', error);
+            return {
+                ok: false,
+                status: this.extractNativeErrorStatus(error),
+                data: this.extractNativeErrorData(error),
+            };
+        }
     }
-    getDbUrl(dbName) {
-        const normalizedDbName = dbName
-            ?.trim()
-            .toLowerCase();
-        if (!normalizedDbName) {
-            throw new Error('Missing CouchDB database name');
+    async sendWebGetRequest(path, headers) {
+        const url = `${this.webProxyBaseUrl}${path}`;
+        console.log('[CouchDB][Web] GET:', url);
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                cache: 'no-store',
+                headers,
+            });
+            const data = await this.parseJsonOrText(response);
+            return {
+                ok: response.ok,
+                status: response.status,
+                data: data,
+            };
+        }
+        catch (error) {
+            console.error('[CouchDB][Web] Request failed:', error);
+            return {
+                ok: false,
+                status: 0,
+                data: error,
+            };
+        }
+    }
+    normalizeNativeResponseData(data) {
+        if (typeof data !== 'string') {
+            return data;
+        }
+        if (!data.trim()) {
+            return null;
         }
-        return (`${this.couchDbBaseUrl}/` +
-            `${encodeURIComponent(normalizedDbName)}`);
+        try {
+            return JSON.parse(data);
+        }
+        catch {
+            return data;
+        }
+    }
+    extractNativeErrorStatus(error) {
+        const status = error?.status ??
+            error?.response?.status ??
+            error?.data?.status;
+        return Number.isFinite(Number(status))
+            ? Number(status)
+            : 0;
+    }
+    extractNativeErrorData(error) {
+        return (error?.data ??
+            error?.response?.data ??
+            error?.message ??
+            error);
+    }
+    getDocumentPath(dbName, docId) {
+        const encodedDbName = encodeURIComponent(dbName.trim().toLowerCase());
+        const encodedDocId = encodeURIComponent(docId.trim());
+        return (`/${encodedDbName}/` +
+            `${encodedDocId}`);
     }
     async getReadHeaders() {
         return {
@@ -1012,7 +1086,8 @@ class Couchdb {
     async buildTenantHeaders() {
         const tenantKey = await this.utilityService.getStorage('tenantKey');
         const tenantName = await this.utilityService.getStorage('tenantName');
-        const selectedTenant = await this.utilityService.getLocalStorage('selectedTenant');
+        const selectedTenant = await this.utilityService
+            .getLocalStorage('selectedTenant');
         if (typeof tenantKey === 'string' &&
             tenantKey.trim()) {
             return {
@@ -1028,7 +1103,8 @@ class Couchdb {
         const tenant = normalizedTenantName ||
             normalizedSelectedTenant;
         if (!tenant) {
-            throw new Error('Missing tenantKey, tenantName, or selectedTenant');
+            throw new Error('Missing tenantKey, tenantName, ' +
+                'or selectedTenant');
         }
         return {
             'X-Tenant': tenant,
@@ -1069,12 +1145,20 @@ class Couchdb {
     }
     isJsonFile(fileNameOrPath, contentType) {
         const lower = (fileNameOrPath || '').toLowerCase();
+        const normalizedContentType = (contentType || '')
+            .toLowerCase()
+            .split(';')[0]
+            .trim();
         return (lower.endsWith('.json') ||
-            contentType === 'application/json');
+            normalizedContentType ===
+                'application/json');
     }
     isBinaryMediaFile(fileNameOrPath, contentType) {
         const lower = (fileNameOrPath || '').toLowerCase();
-        const type = (contentType || '').toLowerCase();
+        const type = (contentType || '')
+            .toLowerCase()
+            .split(';')[0]
+            .trim();
         return (type.startsWith('image/') ||
             type.startsWith('video/') ||
             type.startsWith('audio/') ||
@@ -1094,8 +1178,11 @@ class Couchdb {
             lower.endsWith('.pdf'));
     }
     getMimeType(fileNameOrPath, contentType) {
-        if (contentType) {
-            return contentType;
+        if (contentType &&
+            contentType.trim()) {
+            return contentType
+                .split(';')[0]
+                .trim();
         }
         const lower = (fileNameOrPath || '').toLowerCase();
         if (lower.endsWith('.png')) {