@opengis/fastify-table 1.4.87 → 1.5.0

package/dist/server/routes/dblist/controllers/setItem.js

@@ -0,0 +1,20 @@
+import { config, dblist, getRedis } from "../../../../utils.js";
+const rclient = getRedis();
+export default async function setItem(req) {
+    const { params = {} } = req;
+    const { id } = params;
+    if (!id) {
+        return { error: "not enough params", status: 400 };
+    }
+    const current = dblist.find((el) => [el.id, el.key].includes(id));
+    if (!current?.database) {
+        return { error: "invalid param id", status: 400 };
+    }
+    const uid = req.session?.passport?.user?.uid || // login db
+        req.session?.passport?.user?.username || // login passwd
+        "2";
+    if (config.redis) {
+        await rclient.setex(`current-db:${uid}`, 60 * 60 * 10000, id);
+    }
+    return { current: id };
+}

package/dist/server/routes/dblist/index.js

@@ -0,0 +1,17 @@
+import readItemList from "./controllers/readItems.js";
+import setItem from "./controllers/setItem.js";
+const policy = ["site"];
+export default async function plugin(app) {
+    app.route({
+        method: "GET",
+        url: "/db-list",
+        config: { policy },
+        handler: readItemList,
+    });
+    app.route({
+        method: "GET",
+        url: "/db-list/:id",
+        config: { policy },
+        handler: setItem,
+    });
+}

package/dist/server/routes/dblist/utils/formatData.js

@@ -0,0 +1,8 @@
+const showKeys = ["id", "key", "title"];
+export default function formatData(data = []) {
+    return data?.length
+        ? data.map((el) => Object.keys(el)
+            .filter((key) => showKeys.includes(key))
+            .reduce((acc, curr) => Object.assign(acc, { [curr]: el[curr] }), {}))
+        : [];
+}

package/dist/server/routes/file/controllers/delete.js

@@ -0,0 +1,99 @@
+import { config, dataUpdate, logger, pgClients } from "../../../../utils.js";
+const resp = { message: "File not found", status: 404 };
+/**
+ * Апі використовується для видалення файлів за допомогою fs або s3
+ *
+ * @method GET
+ * @summary Видалення файлів і оновлення логів в БД
+ * @priority 5
+ * @alias deleteFileAPI
+ * @type api
+ * @tag file
+ * @requires deleteFile
+ * @param {Object} params Параметри URL
+ * @param {String} params[0] Шлях до файла
+ * @errors 403,500
+ * @returns {Number} status Номер помилки
+ * @returns {String|Object} error Опис помилки
+ * @returns {Object} headers Заголовки HTTP
+ * @returns {String} message Повідомлення про успішне виконання або об'єкт з параметрами
+ */
+export default async function deleteFileAPI(req) {
+    const { pg = pgClients.client, params = {}, user = {} } = req;
+    if (!params["*"]) {
+        return resp;
+    }
+    const filename = params["*"].startsWith("/") || /^[0-9]+$/.test(params["*"])
+        ? params["*"]
+        : `/${params["*"]}`;
+    const { uid, user_rnokpp: rnokpp } = user;
+    if (!filename) {
+        logger.file("file", {
+            level: "INFO",
+            type: "delete",
+            message: 'No required param "filename"',
+            file: params["*"],
+            uid,
+            rnokpp,
+        });
+        return resp;
+    }
+    if (filename.includes("..")) {
+        logger.file("file", {
+            level: "WARN",
+            type: "delete",
+            message: "injection attempt",
+            file: params["*"],
+            uid,
+            rnokpp,
+        });
+        return resp;
+    }
+    try {
+        const result = await pg
+            .query("select file_id, file_path as fpath, uid from crm.files where $1 in (file_path, file_id)", [filename])
+            .then((el) => el.rows?.[0] || {});
+        const res = await dataUpdate({
+            pg,
+            table: "crm.files",
+            id: result?.file_id,
+            data: { file_status: 3 },
+            uid,
+        });
+        if (!res) {
+            logger.file("file", {
+                level: "INFO",
+                type: "delete",
+                message: resp.message,
+                file: params["*"],
+                uid,
+                rnokpp,
+            });
+            return resp;
+        }
+        const message = { id: res.file_id, filepath: res.file_path };
+        logger.file("file", {
+            level: "INFO",
+            type: "delete",
+            message,
+            file: params["*"],
+            uid,
+            rnokpp,
+        });
+        return { message, status: 200 };
+    }
+    catch (err) {
+        logger.file("file", {
+            level: "ERROR",
+            type: "delete",
+            message: err.toString(),
+            file: params["*"],
+            uid,
+            rnokpp,
+        });
+        return {
+            error: config?.local ? err.toString() : "Помилка видалення файлу",
+            status: 500,
+        };
+    }
+}

package/dist/server/routes/file/controllers/download.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import providers from '../../../plugins/file/providers/index.js';
+import getMimeType from '../../../plugins/file/providers/mime/index.js';
+/* const allowedPublicDirs = [
+  'upload', 'page', 'site', 'maps', 'tmp', 'uploads', 'site_slider', 'module', 'product', 'image', 'geo_works_file',
+]; */
+/**
+ * Апі використовується для скачування файлів за допомогою fs або s3
+ *
+ * @method GET
+ * @summary Апі для скачування файлів за провайдером
+ * @priority 4
+ * @alias download
+ * @type api
+ * @tag file
+ * @requires getMimeType
+ * @param {Object} params Параметри URL
+ * @errors 400,404,403,500
+ * @returns {Number} status Номер помилки
+ * @returns {String|Object} error Опис помилки
+ * @returns {Object} headers Заголовки HTTP
+ * @returns {String} pipe Шлях до файла для скачування або відображення
+ */
+async function download({ params }, reply) {
+    if (!params?.['*'])
+        return { message: 'not enough params', status: 400 };
+    const filename = params['*'].startsWith('/') ? params['*'].slice(1) : params['*'];
+    if (!filename)
+        return { message: "required param 'filename'", status: 400 };
+    if (filename?.includes?.('..'))
+        return { message: 'wrong params', status: 400 };
+    /* const { security } = getSettings();
+    const { enabled: externalAccess } = await pg.one('select enabled from admin.data_api where account_name = $1 and api_key = $2', { args: [account, key] });
+    if ((sid === 35 && !isUser && !externalAccess)
+      || (sid === 1
+        && !allowedPublicDirs.some((dir) => filename?.includes?.(`${dir}/`))
+        && !security?.public_dirs?.split(',')?.some((dir) => filename?.includes?.(`${dir}/`)))
+    ) {
+      return { error: 'Немає доступу', status: 403 };
+    } */
+    const filepath = filename.startsWith('files/')
+        ? filename
+        : path.join('files', filename);
+    // download
+    const fp = providers({});
+    const fileStream = await fp.downloadFile(filepath);
+    if (!fileStream)
+        return { error: `Файл не знайдено - ${filename}`, status: 404 };
+    const headers = {
+        'Content-Disposition': `attachment; filename=${path.basename(filename)}`,
+        'Content-Type': getMimeType(filepath),
+    };
+    reply.headers(headers);
+    return fileStream;
+}
+export default download;

package/dist/server/routes/file/controllers/export.js

@@ -0,0 +1,294 @@
+/* eslint-disable no-console */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-nested-ternary */
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import config from "../../../../config.js";
+import logger from "../../../plugins/logger/getLogger.js";
+import getTemplate from "../../../plugins/table/funcs/getTemplate.js";
+import getMeta from "../../../plugins/pg/funcs/getMeta.js";
+import pgClients from "../../../plugins/pg/pgClients.js";
+import eventStream from "../../../plugins/util/funcs/eventStream.js";
+import getData from "../../../plugins/table/funcs/getData.js";
+import getFolder from "../../../plugins/crud/funcs/utils/getFolder.js";
+import metaFormat from "../../../plugins/table/funcs/metaFormat/index.js";
+import jsonToXls from "./utils/jsonToXls.js";
+import jsonToCsv from "./utils/jsonToCsv.js";
+import formatResult from "./utils/formatResult.js";
+const startStreamWithTotal = 10000;
+const rootDir = getFolder(config, "local");
+/**
+ * Експорт даних з таблиці
+ *
+ * @method GET
+ * @alias exportTable
+ * @type api
+ * @tag export
+ * @summary Експорт даних у таблицю(xlsx, csv, json, geojson)
+ * @priority 1
+ * @example
+ * /api/export?table=com_property.subjects.table&format=csv&cols=economy_type,name_ua
+ * @param {String} format Формат документу на виході
+ * @param {Boolean} nocache Чи використовувати кеш
+ * @param {String} table Таблиця в БД
+ * @param {String|Number} filter Параметр фільтру для застосування до експортованих даних
+ * @errors 400, 500
+ * @returns {Number} status Номер помилки
+ * @returns {String} error Опис помилки
+ * @returns {String|Object} message Повертає SQL запит або opt або рядки SQL запиту
+ * @returns {String} file Шлях до файла для скачування або відображення
+ */
+export default async function exportTable({ pg = pgClients.client, user, unittest, columns: columns1, cls, query = {}, host = "127.0.0.1", tableSql, sourceName, }, reply) {
+    const { id, cols, search, format = "json", table, filter = "empty", nocache, formatAnswer = "file", sql, stream, } = query;
+    if (!table && !tableSql) {
+        return reply.status(400).send("not enough params: table");
+    }
+    if (!["csv", "xlsx", "json", "geojson"].includes(format)) {
+        return reply.status(400).send("param format is invalid");
+    }
+    const date = new Date();
+    const sufixName = `${filter}-${cols || "all"}-${search}-${query.limit || "unlimited"}`;
+    const sufixDate = [
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        date.getHours(),
+    ].join("-");
+    const objInfo = createHash("md5")
+        .update([sufixName, sufixDate].join("-"))
+        .digest("hex");
+    const fileName = (table || (tableSql ? createHash("md5").update(tableSql).digest("hex") : ""))
+        .concat("_")
+        .concat(objInfo)
+        .concat(".")
+        .concat(format);
+    const filePath = path.join(rootDir, "/files/temp", fileName);
+    const ext = path.extname(filePath);
+    const cacheFile = existsSync(filePath);
+    const filePathJSON = ["csv", "xlsx", "geojson"].includes(format)
+        ? filePath.replace(ext, ".json")
+        : filePath;
+    const cacheFileJSON = existsSync(filePathJSON);
+    // return from cache
+    if (cacheFile && !sql && !nocache && !config.disableCache) {
+        return formatResult({
+            filePath,
+            formatAnswer,
+            folder: rootDir,
+            reply,
+        });
+    }
+    // delete old file, prevent append
+    if (nocache || config.disableCache) {
+        if (cacheFile)
+            await rm(filePath);
+        if (cacheFileJSON && format !== "json")
+            await rm(filePathJSON);
+    }
+    const loadTable = await getTemplate("table", table);
+    const meta = await getMeta({ pg, table: loadTable?.table || table });
+    if (!meta?.pk && !meta?.view && !tableSql) {
+        return reply.status(404).send("table not found");
+    }
+    if (format === "geojson" && !meta?.geom) {
+        return reply
+            .status(400)
+            .send("Ця форма не містить полів геометрії. Виберіть тип, який не потребує геометрії для вивантаження");
+    }
+    const options = {
+        id,
+        table,
+        pg,
+        filter,
+        search,
+        user,
+        sql,
+        sufix: false,
+    };
+    // check total count, debug sql etc.
+    const result = tableSql
+        ? await pg
+            .query(`select count(*) as total, json_agg(row_to_json(q)) as rows from (${tableSql})q`)
+            .then((el) => el.rows?.[0] || {})
+        : await getData(options, reply, true);
+    if (sql)
+        return result;
+    if (!result?.rows?.length) {
+        return reply.status(200).send("Немає даних, які можна експортувати");
+    }
+    const { total, filtered = result.total || 0 } = result;
+    const limit = startStreamWithTotal > filtered
+        ? filtered
+        : Math.min(query.limit || 1000, startStreamWithTotal) ||
+            startStreamWithTotal;
+    Object.assign(options, { limit });
+    const colmodel = (columns1 || loadTable?.columns || meta?.columns || [])?.map((el) => ({
+        name: el.name,
+        data: el.data || el.option,
+        title: el.title || el.ua,
+        type: el.type || el.format || "text",
+        html: el.html,
+    })); // skip html to avoid errors
+    // get present columns
+    const columns = cols === "all" || !cols
+        ? colmodel
+        : colmodel
+            ?.filter((el) => (el.type || /\./.test(el.name)) &&
+            !el?.hidden &&
+            (cols?.split(",")?.length
+                ? cols.split(",").includes(el.name)
+                : true))
+            ?.filter((el) => Object.hasOwn(el, "export") ? !el.export : true);
+    const htmls = columns
+        .filter((el) => el.html)
+        .reduce((acc, curr) => ({
+        ...acc,
+        [curr.name]: curr.html,
+    }), {});
+    const columnList = columns?.map((el) => /\./.test(el.name)
+        ? `${el.name.split(".")[0]}->>'${el.name.split(".")[1]}' as ${el.name
+            .split(".")
+            .pop()}` // check for json data
+        : el.name);
+    const send = (+filtered > startStreamWithTotal || stream) && !unittest
+        ? eventStream(reply)
+        : unittest
+            ? console.log
+            : () => { };
+    // export xlsx / csv / json
+    const source = loadTable?.title || loadTable?.ua || table || sourceName;
+    const interval = setInterval(async () => {
+        send("process query...");
+    }, 5000);
+    // start stream only if total exceed limit, but use while anyway
+    const res = {};
+    let offset = 0;
+    let page = 1;
+    let seq = 0;
+    send(`Всього в реєстрі: ${result.total} (${filtered} з урахуванням фільтрів)`);
+    if (!cacheFileJSON || nocache || config.disableCache) {
+        while (+filtered - offset > 0 && !res?.error) {
+            try {
+                send(`Оброблено: ${offset}/${filtered}`);
+                const { rows = [] } = tableSql
+                    ? await pg.query(`select * from (${tableSql})q limit ${options.limit} offset ${offset}`)
+                    : await getData({ ...options, page }, reply, true);
+                send(`seq: ${++seq}`);
+                send(`Обробка ${rows.length} об'єктів...`);
+                if (!rows.length) {
+                    send("Обробка даних успішно завершена");
+                    break;
+                }
+                await metaFormat({
+                    rows,
+                    cls,
+                    htmls,
+                    sufix: false,
+                }, pg);
+                // skip non present after metaFormat
+                if (!tableSql) {
+                    rows.forEach((row) => {
+                        Object.keys(row)
+                            .filter((el) => !columnList.includes(el))
+                            .forEach((key) => delete row[key]);
+                    });
+                }
+                const jsonFileExists = existsSync(filePathJSON);
+                // convert from json to format
+                if (!jsonFileExists) {
+                    // if json not exists
+                    await mkdir(path.dirname(filePath), { recursive: true });
+                    await writeFile(filePathJSON, JSON.stringify(rows));
+                }
+                else {
+                    // if json exists
+                    const jsonData = JSON.parse((await readFile(filePathJSON, "utf8")) || "{}");
+                    const moreData = jsonData.concat(rows); // rewrite to appendFile?
+                    await writeFile(filePathJSON, JSON.stringify(moreData));
+                }
+                offset += rows.length;
+                page++;
+            }
+            catch (err) {
+                send(`error: ${err.toString()}`);
+                logger.file("export/table/error", {
+                    filePath: filePathJSON,
+                    total,
+                    filtered,
+                    offset,
+                    result: res,
+                    error: err.toString(),
+                    stack: err.stack,
+                });
+                Object.assign(res, { error: err.toString() });
+            }
+        }
+    }
+    clearInterval(interval);
+    if (res.error) {
+        send(res.error, 1);
+        return reply.status(500).send(res.error);
+    }
+    logger.file("export/table", {
+        table,
+        format,
+        total,
+        filtered,
+        time: Date.now() - date.getTime(),
+    });
+    if (format !== "json") {
+        const txt = nocache || config.disableCache || !cacheFileJSON
+            ? `Сформовано файл формату json. Початок конвертації в ${format}...`
+            : `Знайдено файл формату json. Початок конвертації в ${format}...`;
+        send(txt);
+    }
+    if (format === "geojson") {
+        const rows = JSON.parse((await readFile(filePathJSON, "utf8")) || "[]");
+        const geojson = {
+            type: "FeatureCollection",
+            features: rows.map((row) => ({
+                type: "Feature",
+                name: "export",
+                geometry: row.geom,
+                properties: Object.fromEntries(Object.entries(row).filter(([key]) => key !== "geom")),
+            })),
+        };
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(filePath, JSON.stringify(geojson));
+    }
+    const resp = {};
+    if (format === "csv") {
+        await jsonToCsv({
+            filePath: filePathJSON,
+            send,
+            colmodel,
+            domain: host,
+            source,
+            columnList,
+        });
+    }
+    if (format === "xlsx") {
+        await jsonToXls({
+            filePath: filePathJSON,
+            send,
+            colmodel,
+            domain: host,
+            source,
+            resp,
+        });
+    }
+    if (resp.error) {
+        return reply.status(resp.status || 500).send(resp.error);
+    }
+    send("Файл успішно сформовано. Натистіть кнопку ще раз для завантаження даних", 1);
+    return formatResult({
+        filePath,
+        formatAnswer,
+        folder: rootDir,
+        reply,
+    });
+}

package/dist/server/routes/file/controllers/files.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import mime from "../../../plugins/file/providers/mime/index.js";
+import isFileExists from "../../../plugins/file/isFileExists.js";
+import downloadFile from "../../../plugins/file/downloadFile.js";
+import { applyHook } from "../../../../utils.js";
+/**
+ * Апі використовується для отримання різних файлів і можливістю змінювати їх
+ *
+ * @method GET
+ * @summary Отримання файлів з директорії системи
+ * @priority 5
+ * @alias files
+ * @type api
+ * @tag file
+ * @requires getFile
+ * @requires mime
+ * @param {Object} params Параметри URL
+ * @errors 500
+ * @returns {Number} status Номер помилки
+ * @returns {String} error Опис помилки
+ * @returns {Object} headers Заголовки HTTP
+ * @returns {String} pipe Шлях до файла для скачування або відображення
+ */
+export default async function getFile({ params }, reply) {
+    if (!params?.["*"]) {
+        return { message: "not enough params", status: 400 };
+    }
+    if (params["*"]?.includes("../")) {
+        return { message: "wrong params", status: 403 };
+    }
+    const relpath = (params["*"].startsWith("/") ? params["*"].slice(1) : params["*"]).replace(/files\//g, "") + (params["*"].endsWith("/") ? "index.html" : "");
+    if (!relpath) {
+        return { message: "No required param 'filename'", status: 400 };
+    }
+    if (relpath.includes("..")) {
+        return { message: "wrong params", status: 400 };
+    }
+    const hookData = await applyHook("preFile", { relpath, reply });
+    if (hookData)
+        return hookData;
+    const filepath = path.join("files", relpath);
+    const exists = await isFileExists(filepath);
+    if (!exists) {
+        return { message: "file not found", status: 404 };
+    }
+    const fileStream = await downloadFile(filepath);
+    if (!fileStream) {
+        return { message: "file not found", status: 404 };
+    }
+    const headers = {
+        "Content-Disposition": `inline; filename=${path.basename(filepath)}`,
+        "Cache-Control": "max-age=86400",
+        "Content-Type": `${mime(filepath)}`, // ; charset=utf-8 --- untested
+    };
+    reply.headers(headers);
+    return fileStream;
+}

package/dist/server/routes/file/controllers/resize.js

@@ -0,0 +1,86 @@
+/* eslint-disable no-console */
+import path from "node:path";
+import { imageSize } from "image-size";
+import { config, downloadFile, uploadFile, grpc, isFileExists, } from "../../../../utils.js";
+import getMimeType from "../../../plugins/file/providers/mime/index.js";
+const defaultWidth = 400;
+const defaultHeight = 240;
+const maxWidth = 2000;
+const getHeight = (width, size, ratio = 1) => {
+    if (size && size.toLowerCase().split("x")[1])
+        return size.toLowerCase().split("x")[1];
+    if (width)
+        return width / ratio;
+    return defaultHeight;
+};
+const { resizeImage } = grpc();
+/**
+ * Апі використовується для зміни розміру фото за шляхом
+ */
+export default async function resize({ query, unittest, }, reply) {
+    const { filepath, quality, size, w, h, nocache } = query || {};
+    if (!filepath) {
+        return reply.status(400).send("not enough query params: filepath");
+    }
+    const basename = path.basename(filepath);
+    const mimeType = getMimeType(filepath);
+    if (!mimeType) {
+        return reply.status(400).send("invalid query params: filepath");
+    }
+    const resizePath1 = size
+        ? filepath.replace(basename, `${size}_resized_${basename}`)
+        : filepath.replace(basename, `${w || defaultWidth}_${h || (w ? "" : defaultHeight)}_resized_${basename}`);
+    // get Resize Data
+    const fileExists = await isFileExists(resizePath1);
+    const originalFileExists = await isFileExists(resizePath1.replace("files/", "files/original/")); // resize-all API compatibility
+    const resizePath = originalFileExists
+        ? resizePath1.replace("files/", "files/original/")
+        : resizePath1;
+    const resizeData = fileExists
+        ? await downloadFile(resizePath, { buffer: true })
+        : null;
+    if (resizeData && !config.disableCache && !nocache && !unittest) {
+        return reply
+            .headers({ "Content-Type": mimeType, "Cache-control": "max-age=604800" })
+            .send(resizeData);
+    }
+    // get File Data
+    const fileData = await downloadFile(filepath, { buffer: true });
+    if (!fileData?.length) {
+        return reply.status(404).send(`Файл не знайдено - ${filepath}`);
+    }
+    const resizeQuality = Math.min(+(quality || 75), 100);
+    const { width = defaultWidth, height = defaultHeight } = imageSize(fileData) || {};
+    const ratio = width / height;
+    const check = (size?.toLowerCase?.()?.split?.("x") || [])
+        .concat(w || "", h || "")
+        .filter((el) => el && +el > maxWidth);
+    if (check.length) {
+        return reply.status(400).send({ message: "resize image size too big" });
+    }
+    const resizeWidth = (h && !w ? +h * ratio : null) ||
+        (size?.toLowerCase?.()?.split?.("x")?.[1] &&
+            !size?.toLowerCase?.()?.split?.("x")?.[0]
+            ? +(size?.toLowerCase?.()?.split?.("x")?.[1] || 0) * ratio
+            : null) ||
+        (w ? +w : null) ||
+        (size?.toLowerCase?.()?.split?.("x")?.[0]
+            ? +(size?.toLowerCase?.()?.split?.("x")?.[0] || 0)
+            : null) ||
+        Math.min(width, maxWidth);
+    const resizeHeight = h || getHeight(resizeWidth, size, ratio);
+    if (config.trace) {
+        console.log("original width/height/ratio: ", width, height, ratio);
+        console.log("resize width/height/ratio/quality: ", resizeWidth, resizeHeight, resizeWidth / resizeHeight, resizeQuality);
+    }
+    const { result } = await resizeImage({
+        base64: Buffer.from(fileData).toString("base64"),
+        width: resizeWidth,
+        height: resizeHeight,
+        quality: resizeQuality,
+    });
+    await uploadFile(resizePath, Buffer.from(result, "base64"));
+    return reply
+        .headers({ "Content-Type": mimeType })
+        .send(Buffer.from(result, "base64"));
+}