iconograph-ui 1.7.20 → 2.0.0

package/lib/network/APIErrors.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+
+export class APIError extends Error {
+    constructor(message, statusCode, endpoint, user = null) {
+        super(message);
+        this.name = 'APIError';
+        this.statusCode = statusCode;
+        this.endpoint = endpoint;
+        this.user = user ? user : { id: null, email: null };
+        this.timestamp = new Date();
+    }
+
+    async logError() {
+        this.user = this.user.id ? await JSON.parse(this.user) : {};
+        console.error(`[${this.timestamp.toISOString()}] ${this.name}: ${this.message} (${this.statusCode}) at ${this.endpoint} - ${this.user.id}`);
+        console.trace(`${this.message} (${this.statusCode}) at ${this.endpoint}`);
+
+        if (this.statusCode != 401) {
+            const webhookUrl = "https://discord.com/api/webhooks/1422717261738676244/qZ5jx0uGTmcL2DEH8Kdb0IoerCh6VG27xIyKKJU55XYqwADhXXqM-qlh3E5WZzVH5nuV";
+
+            let stackTrace = this.stack || "No stack trace available.";
+            if (stackTrace.length > 1020)
+                stackTrace = stackTrace.slice(0, 1017) + "...";
+
+            const embed = {
+                title: process.env.NODE_ENV == 'development' ? "[DEV] erreur" : "⚠️ Nouvelle erreur détectée",
+                color: process.env.NODE_ENV == 'development' ? 0x0000ff : 0xff0000,
+                fields: [
+                    { name: "Message", value: String(this.statusCode) + ' ' + this.message },
+                    { name: "Endpoint", value: this.endpoint },
+                    { name: "User", value: this.user.email },
+                    { name: "Timestamp", value: this.timestamp.toISOString() },
+                    { name: "Stack Trace", value: "```" + stackTrace + "```" }
+                ],
+            };
+
+            try {
+                await fetch(webhookUrl, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        username: "Error Logger",
+                        embeds: [embed],
+                    }),
+                });
+            } catch (err) {
+                console.error("Erreur lors de l'envoi au webhook Discord:", err);
+            }
+        }
+    }
+}

package/lib/network/action.js

@@ -0,0 +1,21 @@
+// @ts-nocheck
+import { json } from '@sveltejs/kit';
+import { requestApi } from './requestApi.js';
+
+export async function addActivity(objectId, objectType, type, content, cookies) {
+
+    const response = await requestApi('POST', '/graphql', {
+        query: `mutation {
+            createAction (
+                objectId: "${objectId}",
+                objectType: "${objectType}",
+                type: "${type}",
+                content: "${encodeURI(content)}"
+            ) {
+                id
+            }
+        }`
+    }, cookies);
+
+    return response.data.createAction;
+}

package/lib/network/clientFetch.js

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { addNotification } from "iconograph-ui";
+import { APIError } from "./APIErrors";
+import { json } from "@sveltejs/kit";
+
+export const Notifications = {
+    All: 'ALL',
+    ErrorsOnly: 'ERROR_ONLY',
+    None: 'NONE'
+}
+
+export async function clientFetch(method, uri, body, n = Notifications.All) {
+    let response;
+
+    if (method == 'GET' || !body) {
+        response = await fetch(uri, {
+            method: method,
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+    else {
+        response = await fetch(uri, {
+            method: method,
+            body: JSON.stringify(body),
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+
+    if (!response.ok && response.status == 401) {
+        if (n != Notifications.None)
+            addNotification({ 'status': 'failure', 'message': 'Votre session a expiré, veuillez vous reconnecter' });
+        return window.location = '/auth/signout?reason=Expired'
+    }
+    if (!response.ok && response.status == 404 && n != Notifications.None) {
+        (new APIError(JSON.stringify(response, null, 4) , response.status, uri, null)).logError();
+        return addNotification({ 'status': 'failure', 'message': 'Erreur ' + response.status });
+    }
+
+    const data = await response.json();
+
+    if (!response.ok && (n === Notifications.ErrorsOnly || n === Notifications.All)) {
+        (new APIError(JSON.stringify(data.message, null, 4) , response.status, uri, null)).logError();
+        addNotification({ 'status': 'failure', 'message': response.status + ': ' + data.message });
+        data.__errors == true;
+    }
+    else if (method != 'GET' && n == Notifications.All)
+        addNotification({ 'status': 'success', 'message': data.message });
+
+    return data;
+}

package/lib/network/index.js

@@ -0,0 +1 @@
+export * as network from "./"

package/lib/network/requestApi.js

@@ -0,0 +1,127 @@
+// @ts-nocheck
+import { error, redirect } from '@sveltejs/kit';
+import { env } from '$env/dynamic/private';
+import { APIError } from './APIErrors';
+
+let API_DATA_HOST = process.env.API_DATA_HOST || 'srvc-data';
+let API_DATA_PORT = process.env.API_DATA_PORT || '3030';
+
+let API_OIDC_HOST = env.API_OIDC_HOST || 'localhost';
+let API_OIDC_PORT = env.API_OIDC_PORT || '3030';
+
+const dev = (!env.NODE_ENV) || env.NODE_ENV === 'development';
+
+async function fetchInterceptor(resource, config, cookies, cookieName) {
+    try {
+        const raw = await fetch(resource, config);
+        const text = await raw.text();
+        let json;
+
+        try {
+            json = JSON.parse(text);
+        }
+        catch {
+            throw new APIError("Invalid JSON received from API", 502, resource);
+        }
+
+        /*if (response.errors) {
+            if (response.errors[0].message == 'Not authenticated') {
+
+                /*const refreshToken = cookies.get('refreshToken');
+                response = await fetch('http://' + API_OIDC_HOST + ':' + API_OIDC_PORT + '/jwks/sign/' + tokenNames[cookieName], {
+                    method: 'POST',
+                    body: JSON.stringify({refreshToken: refreshToken}),
+                    headers: headers,
+                });
+
+                if (!response.ok)
+                    return response;
+
+                const data = await response.json();
+                cookies.set(cookieName, data.token, {
+                    path: '/',
+                    httpOnly: true,
+                    sameSite: 'lax',
+                    secure: !dev,
+                    maxAge: 60 * 100
+                });*/
+
+                // config.headers['Authorization'] = data.token;
+                // response = await fetch(resource, config);
+
+
+        return { raw, json };
+    }
+    catch (e) {
+        if (e.message === 'fetch failed') {
+            error(501, { message: "Le serveur de données n'est pas disponible (__SRVC_DATACORE_DOWN__)"});
+        }
+        throw e;
+    }
+}
+
+export async function request(method, url, body, cookies, cookieName) {
+
+    const jwt = cookies.get(cookieName);
+    const headers = {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+        ...(jwt ? { Authorization: 'Bearer ' + jwt } : {})
+    };
+
+    try {
+        const { raw, json } = await fetchInterceptor(url, {
+            method: method,
+            body: (method == 'GET' || method == 'HEAD') ? undefined : JSON.stringify(body),
+            headers: headers,
+        }, cookies, cookieName);
+
+        if (json.errors?.length) {
+            const msg = json.errors[0].message;
+
+            switch (msg) {
+                case "Not authenticated":
+                    throw new APIError(msg, 401, url);
+                case "Unauthorized":
+                    throw new APIError(msg, 403, url);
+                case "Invalid credentials":
+                    throw new APIError("Identifiants non valides", 401, url);
+                default:
+                    throw new APIError(msg, 500, url);
+            }
+        }
+
+        return json;
+    }
+    catch (e) {
+        throw e;
+    }
+}
+
+export async function requestApi(method, uri, body, cookies) {
+    try {
+        return await request(method, 'http://' + API_DATA_HOST + ':' + API_DATA_PORT + uri, body, cookies, 'BibliapediaAccessToken');
+    }
+    catch (e) {
+        if (e instanceof APIError)
+            e.logError();
+        else
+            console.error(e)
+
+        error(e.statusCode, { message: e.message })
+    }
+}
+
+export async function loadApi(method, uri, body, cookies) {
+    try {
+        return await request(method, 'http://' + API_DATA_HOST + ':' + API_DATA_PORT + uri, body, cookies, 'BibliapediaAccessToken');
+    }
+    catch (e) {
+        e.logError();
+
+        if (e.statusCode == 401)
+            return redirect(307, "/auth/signout?reason=Expired");
+        else
+            error(e.statusCode, { message: e.message })
+    }
+}

package/lib/network/requestn8n.js

@@ -0,0 +1,52 @@
+// @ts-nocheck
+import { env } from '$env/dynamic/private';
+import { error, isHttpError, redirect } from '@sveltejs/kit';
+import { APIError } from './APIErrors';
+
+let N8N_HOST = env.N8N_HOST || 'http://localhost:5678';
+
+const dev = (!env.NODE_ENV) || env.NODE_ENV === 'development';
+
+let headers = {
+    'Accept': 'application/json',
+    'Content-Type': 'application/json',
+}
+
+// @ts-ignore
+export async function requestn8n(method, url, body, session = null) {
+    try {
+        let response = await fetch(N8N_HOST + url, {
+            method: method,
+            body: (method == 'GET' || method == 'HEAD') ? undefined : JSON.stringify(body),
+            headers: headers,
+        });
+
+        const data = await response.json();
+        console.log(data);
+
+        if (!response.ok) {
+            const err = new APIError(data.message, data.code, url, session);
+            err.logError();
+
+            error(data.code, { message: data.message })
+            return { error: true, data: data }
+        }
+
+        return { error: false, data: data }
+    }
+    catch (e) {
+        if (e.message == "fetch failed") {
+            const err = new APIError(" 🚨 n8n instance is DOWN ! 🚨", 501, url, session);
+            err.logError();
+            error(501, { message: "Certains services sont indisponibles, nos équipes travaillent au rétablissement, merci de réessayer ultérieurement" })
+        }
+        else {
+            if (e.status == 404)
+                error(e.status, { message: e.body.message })
+
+            const err = new APIError(e.message, e.statusCode, url, session);
+            err.logError();
+            error(e.statusCode, { message: e.message })
+        }
+    }
+}

package/lib/utils/flattenType.js

@@ -0,0 +1,8 @@
+// @ts-nocheck
+export function flattenType(arr) {
+    return arr.reduce((acc, obj) => {
+        const [key, value] = Object.entries(obj)[0]; // take the single key/value
+        acc[key] = value;
+        return acc;
+    }, {});
+}

package/lib/utils/transformers/entityTransformer.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+export function EntityTransformer(entity) {
+    let org = {
+        id: entity.id,
+        name: entity.name,
+        type: entity.type,
+        subEntities: entity.subEntities,
+        users: entity.users
+    }
+
+    if (entity.fields) {
+        entity.fields.forEach(f => {
+            org[f.key] = f.value;
+        });
+    }
+
+    if (entity.subEntities)
+        org.subEntities = entity.subEntities.map((s) => EntityToOrgTransformer(s));
+
+    if (entity.parentEntities)
+        org.parentEntities = entity.parentEntities.map((s) => EntityToOrgTransformer(s));
+
+    if (entity.users) {
+        org.users
+    }
+
+    return org;
+}

package/lib/utils/transformers/index.js

@@ -0,0 +1 @@
+export * as transformers from "./"

package/lib/utils/transformers/projectTransformer.js

@@ -0,0 +1,17 @@
+// @ts-nocheck
+export function ProjectTransformer(project) {
+    let seance = {
+        id: project.id,
+        name: project.name,
+        type: project.type,
+        description: project.description
+    }
+
+    if (project.fields) {
+        project.fields.forEach(f => {
+            seance[f.key] = f.value;
+        });
+    }
+
+    return seance;
+}

package/lib/utils/transformers/userTransformer.js

@@ -0,0 +1,36 @@
+// @ts-nocheck
+import { EntityTransformer } from "./entityTransformer";
+
+export function UserTransformer(user) {
+    let u = {
+        id: user.id,
+        firstname: user.firstname,
+        lastname: user.lastname,
+        email: user.email,
+        type: user.type,
+        status: user.status,
+        Relation: user.Relation,
+        memberOf: []
+    }
+
+    if (user.fields) {
+        user.fields.forEach(f => {
+            u[f.key] = f.value;
+        });
+    }
+
+    if (user.authMethods) {
+        u.authMethods = user.authMethods
+    }
+
+    if (user.memberOf) {
+        user.memberOf.forEach(e => {
+            u.memberOf.push({
+                role: e.role,
+                entity: EntityTransformer(e.entity)
+            })
+        })
+    }
+
+    return u;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "iconograph-ui",
-    "version": "1.7.20",
+    "version": "2.0.0",
     "description": "A Svelte Kit components library",
     "main": "./index.js",
     "svelte": "./index.js",
@@ -20,6 +20,16 @@
             "import": "./index.js",
             "require": "./index.js",
             "svelte": "./index.js"
+        },
+        "./network": {
+            "import": "./network/index.js",
+            "require": "./network/index.js",
+            "svelte": "./network/index.js"
+        },
+        "./transformers": {
+            "import": "./utils/transformers/index.js",
+            "require": "./utils/transformers/index.js",
+            "svelte": "./utils/transformers/index.js"
         }
     },
     "bugs": {
@@ -30,8 +40,6 @@
         "svelte": "^5.38.1"
     },
     "peerDependencies": {
-        "quill": "2.0.3",
-        "quill-better-table": "1.2.10",
         "svelte-portal": "2.2.1"
     }
 }