@opengis/fastify-table 1.4.88 → 1.5.0

package/{server → dist/server}/plugins/crud/funcs/validateData.js

@@ -1,83 +1,91 @@
-import config from '../../../../config.js';
-/* eslint-disable no-console */
-// eslint-disable-next-line no-control-regex
-const emailReg = /(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/g;
-
-function checkField(key, val, options, idx, body) {
-    const type = options?.type?.toLowerCase?.();
-    const isrequired = options?.validators?.includes?.('required');
-
-    // validators: [required]
-    if (type === 'switcher') {
-        // skip nulls at non-required switchers, restrict invalid values
-        if (val && typeof val !== 'boolean' && !['true', 'false'].includes(val)) {
-            return {
-                error: 'not a boolean', key, idx,
-            };
-        }
-        // restrict nulls at required switchers
-        if (isrequired && typeof val !== 'boolean' && !['true', 'false'].includes(val)) {
-            return {
-                error: 'empty required', key, idx,
-            };
-        }
-    }
-    else if (isrequired && !val) {
-        if (options?.conditions) {
-            const allowed = JSON.parse(options?.conditions?.[2] || null);
-            const check = options?.conditions?.[1] === 'in' && Array.isArray(allowed)
-                ? allowed.includes(body[options?.conditions?.[0] || ''])
-                : body[options?.conditions?.[0] || ''] === allowed;
-            if (!check) {
-                if (config.trace) console.log('validateData', 'skip conditions', key, body[options?.conditions?.[0] || ''], allowed);
-                return { key, val, idx };
-            }
-        }
-        return {
-            error: 'empty required', key, idx,
-        };
-    }
-
-    // validators: [email] / type: Email
-    if ((options.type?.toLowerCase() === 'email' || options?.validators?.includes('email')) && val && !val.match(emailReg)) {
-        return {
-            error: 'invalid email', key, val, idx,
-        };
-    }
-    return { key, val, idx };
-}
-
-function checkBody({ body = {}, arr = [], idx }) {
-    const res = Object.keys(body).reduce((acc1, key) => {
-        const input = arr.find(el => el.key === key) || {};
-
-        if (input.colModel?.length && input.type?.toLowerCase() === 'datatable') {
-            const result = body[key]?.reduce?.((acc, item, i) => {
-                const check = checkBody({ body: item, arr: input.colModel, idx: i });
-                acc.push(check);
-                return acc;
-            }, []);
-            // acc1.push(result);
-            acc1.push(...result);
-            return acc1;
-        }
-
-        const check = checkField(key, body[key], input, idx, body) || {};
-        acc1.push({ key, val: body[key], ...check });
-        return acc1;
-    }, []);
-
-    const invalidField = res.find(el => el?.error);
-
-    if (invalidField) {
-        console.warn('invalid field: ', invalidField?.key, invalidField?.error);
-        return invalidField;
-    }
-
-    return { message: 'ok' };
-}
-
-export default function validateData({ body = {}, schema = {} }) {
-    const res = checkBody({ body, arr: Object.keys(schema).map(key => ({ ...schema[key], key })) });
-    return res;
-}
+import config from "../../../../config.js";
+/* eslint-disable no-console */
+// eslint-disable-next-line no-control-regex
+const emailReg = /(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/g;
+function checkField(key, val, options, idx, body) {
+    const type = options?.type?.toLowerCase?.();
+    const isrequired = options?.validators?.includes?.("required");
+    // validators: [required]
+    if (type === "switcher") {
+        // skip nulls at non-required switchers, restrict invalid values
+        if (val && typeof val !== "boolean" && !["true", "false"].includes(val)) {
+            return {
+                error: "not a boolean",
+                key,
+                idx,
+            };
+        }
+        // restrict nulls at required switchers
+        if (isrequired &&
+            typeof val !== "boolean" &&
+            !["true", "false"].includes(val)) {
+            return {
+                error: "empty required",
+                key,
+                idx,
+            };
+        }
+    }
+    else if (isrequired && !val) {
+        if (options?.conditions) {
+            const allowed = JSON.parse(options?.conditions?.[2] || null);
+            const check = options?.conditions?.[1] === "in" && Array.isArray(allowed)
+                ? allowed.includes(body[options?.conditions?.[0] || ""])
+                : body[options?.conditions?.[0] || ""] === allowed;
+            if (!check) {
+                if (config.trace)
+                    console.log("validateData", "skip conditions", key, body[options?.conditions?.[0] || ""], allowed);
+                return { key, val, idx };
+            }
+        }
+        return {
+            error: "empty required",
+            key,
+            idx,
+        };
+    }
+    // validators: [email] / type: Email
+    if ((options.type?.toLowerCase() === "email" ||
+        options?.validators?.includes("email")) &&
+        val &&
+        !val.match(emailReg)) {
+        return {
+            error: "invalid email",
+            key,
+            val,
+            idx,
+        };
+    }
+    return { key, val, idx };
+}
+function checkBody({ body = {}, arr = [], idx }) {
+    const res = Object.keys(body).reduce((acc1, key) => {
+        const input = arr.find((el) => el.key === key) || {};
+        if (input.colModel?.length && input.type?.toLowerCase() === "datatable") {
+            const result = body[key]?.reduce?.((acc, item, i) => {
+                const check = checkBody({ body: item, arr: input.colModel, idx: i });
+                acc.push(check);
+                return acc;
+            }, []) || [];
+            // acc1.push(result);
+            acc1.push(...result);
+            return acc1;
+        }
+        const check = checkField(key, body[key], input, idx, body) || {};
+        acc1.push({ ...check, key, val: body[key] });
+        return acc1;
+    }, []);
+    const invalidField = res.find((el) => el?.error);
+    if (invalidField) {
+        console.warn("invalid field: ", invalidField?.key, invalidField?.error);
+        return invalidField;
+    }
+    return { message: "ok" };
+}
+export default function validateData({ body = {}, schema = {}, }) {
+    const res = checkBody({
+        body,
+        arr: Object.keys(schema).map((key) => ({ ...schema[key], key })),
+    });
+    return res;
+}

package/dist/server/plugins/extra/extraData.js

@@ -0,0 +1,81 @@
+import config from "../../../config.js";
+import getTemplate from "../table/funcs/getTemplate.js";
+import getMeta from "../pg/funcs/getMeta.js";
+import pgClients from "../pg/pgClients.js";
+import getInsertQuery from "../crud/funcs/utils/getInsertQuery.js";
+const defaultTable = "crm.extra_data";
+function format(key, value, schema) {
+    if (!key || !schema?.[key])
+        return value;
+    if (schema?.[key]?.type &&
+        ["Number", "Switcher"].includes(schema?.[key]?.type)) {
+        return typeof value === "string" ? JSON.parse(value) : value;
+    }
+    return value;
+}
+export default async function extraData({ table, form, id, data, uid, row = {} }, pg = pgClients.client) {
+    if (!id || !table) {
+        return null;
+    }
+    const loadTemplate = await getTemplate("form", form);
+    if (!loadTemplate?.extra)
+        return null;
+    const extraTable = config.extraData?.[table] ||
+        config.extraData?.[table.split(".").shift()] ||
+        config.extraData?.default ||
+        config.extraData ||
+        defaultTable;
+    const { pk: mainPK, columns: mainColumns = [] } = await getMeta({
+        pg,
+        table,
+    });
+    if (!mainPK) {
+        return { error: `table pk not found: ${table}`, status: 404 };
+    }
+    if (!pg.pk?.[extraTable]) {
+        return { error: `extra table pk not found: ${extraTable}`, status: 404 };
+    }
+    Object.assign(data || {}, { object_id: id });
+    const deleteRes = await pg.query(`delete from ${extraTable} where object_id=$1 and property_key = any($2::text[]) returning *`, [id, Object.keys(loadTemplate?.schema || {})]);
+    if (!data) {
+        const result = deleteRes?.rows?.reduce?.((acc, curr) => Object.assign(acc, {
+            [curr.property_key]: format(curr.property_key, curr.value_text || curr.value_array, loadTemplate?.schema),
+        }), {}) || {};
+        Object.assign(row, result);
+        return result;
+    }
+    const rows = Object.keys(data || {})
+        .filter((key) => Object.keys(loadTemplate?.schema || {}).includes(key))
+        .filter((key) => !mainColumns
+        .map((el) => el.name)
+        .concat("id", "token")
+        .includes(key))
+        .filter((key) => (Array.isArray(data[key]) ? data[key].length : true))
+        .filter((key) => !(loadTemplate?.schema?.[key]?.table &&
+        loadTemplate?.schema?.[key]?.parent_id))
+        .map((key) => ({
+        object_id: id,
+        property_key: key,
+        property_entity: table,
+        value_text: Array.isArray(data[key]) ? null : data[key],
+        value_array: Array.isArray(data[key]) ? data[key] : null,
+    }));
+    const res = await Promise.all(rows.map(async (dataRow) => {
+        const { insertQuery, args = [] } = (await getInsertQuery({
+            pg,
+            table: extraTable,
+            data: dataRow,
+            uid,
+        })) || {};
+        if (!insertQuery || !args?.length)
+            return {};
+        return pg.query(insertQuery, args).then((el) => el.rows?.[0] || {});
+    }));
+    Object.assign(row, {
+        ...res.reduce((acc, curr) => Object.assign(acc, {
+            [curr.property_key]: format(curr.property_key, curr.value_text || curr.value_array, loadTemplate?.schema),
+        }), {}),
+        id: res?.[0]?.object_id,
+    });
+    return row;
+}

package/dist/server/plugins/extra/extraDataGet.js

@@ -0,0 +1,52 @@
+import config from "../../../config.js";
+import pgClients from "../pg/pgClients.js";
+import getTemplate from "../table/funcs/getTemplate.js";
+const defaultTable = "crm.extra_data";
+function format(key, value, schema) {
+    if (!key || !schema?.[key])
+        return undefined; // skip non-existing
+    if (schema?.[key]?.type &&
+        ["datalist", "datatable", "number", "switcher"].includes(schema?.[key]?.type?.toLowerCase())) {
+        return JSON.parse(value || null);
+    }
+    return value;
+}
+export default async function extraDataGet({ rows = [], table, form }, pg = pgClients.client) {
+    const ids = rows
+        .map((row) => row.id)
+        .filter((el) => el);
+    if (!ids?.length || !form || !table) {
+        return null;
+    }
+    const loadTemplate = await getTemplate("form", form);
+    if (!loadTemplate?.extra)
+        return null;
+    const extraDataTable = config.extraData?.[table] ||
+        config.extraData?.[table.split(".").shift()] ||
+        config.extraData?.default ||
+        config.extraData ||
+        defaultTable;
+    if (!pg.pk?.[table]) {
+        return { error: `table pk not found: ${table}`, status: 404 };
+    }
+    if (!pg.pk?.[extraDataTable]) {
+        return {
+            error: `extra table pk not found: ${extraDataTable}`,
+            status: 404,
+        };
+    }
+    const { rows: extraRows = [] } = await pg.query(`select * from ${extraDataTable} where object_id=any($1::text[])`, [ids]);
+    if (rows?.length && extraRows?.length) {
+        rows.forEach((row) => {
+            Object.assign(row, {
+                ...extraRows
+                    .filter((el) => el.object_id === row.id && (el.value_text || el.value_array))
+                    .reduce((acc, curr) => {
+                    acc[curr.property_key] = format(curr.property_key, curr.value_text || curr.value_array, loadTemplate?.schema);
+                    return acc;
+                }, {}),
+            });
+        });
+    }
+    return null;
+}

package/dist/server/plugins/file/downloadFile.js

@@ -0,0 +1,15 @@
+import path from "path";
+import providers from "./providers/index.js";
+async function downloadFile(filePath, options = {}) {
+    if (!filePath)
+        return null;
+    const filename = path.basename(filePath);
+    // prefix
+    const prefix = (options.prefix === "date"
+        ? new Date().toISOString().split("T")[0]
+        : null) || (options.prefix === "3s" ? filename.substring(0, 3) : "");
+    const relativePath = path.join(path.dirname(filePath), prefix, filename);
+    const fp = providers(options);
+    return fp.downloadFile(relativePath, options);
+}
+export default downloadFile;

package/{server → dist/server}/plugins/file/getExport.js

@@ -1,38 +1,18 @@
-import routeExport from '../../routes/file/controllers/export.js';
-
-export default async function getExport({
-    pg,
-    user,
-    host,
-    unittest,
-    columns,
-    cls,
-    id,
-    cols,
-    search,
-    format,
-    table,
-    tableSql,
-    sourceName,
-    filter,
-    nocache,
-    formatAnswer,
-    sql,
-}, reply) {
-    const query = {
-        id,
-        cols,
-        search,
-        format,
-        table,
-        filter,
-        nocache,
-        formatAnswer,
-        sql,
-    };
-    const result = await routeExport({
-        pg, user, host, unittest, columns, cls, query, tableSql, sourceName,
-    }, reply);
-
-    return result;
-}
+import routeExport from '../../routes/file/controllers/export.js';
+export default async function getExport({ pg, user, host, unittest, columns, cls, id, cols, search, format, table, tableSql, sourceName, filter, nocache, formatAnswer, sql }, reply) {
+    const query = {
+        id,
+        cols,
+        search,
+        format,
+        table,
+        filter,
+        nocache,
+        formatAnswer,
+        sql,
+    };
+    const result = await routeExport({
+        pg, user, host, unittest, columns, cls, query, tableSql, sourceName,
+    }, reply);
+    return result;
+}

package/dist/server/plugins/file/isFileExists.js

@@ -0,0 +1,13 @@
+import path from "node:path";
+import providers from "./providers/index.js";
+async function isFileExists(filePath, options = {}) {
+    const filename = path.basename(filePath);
+    // prefix
+    const prefix = (options.prefix === "date"
+        ? new Date().toISOString().split("T")[0]
+        : null) || (options.prefix === "3s" ? filename.substring(0, 3) : "");
+    const relativePath = path.join(path.dirname(filePath), prefix, filename);
+    const fp = providers(options);
+    return fp.fileExists(relativePath, options);
+}
+export default isFileExists;

package/dist/server/plugins/file/providers/fs.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import isFileExists from "../utils/isFileExists.js";
+import isBuffer from "./utils/typeguards/isBuffer.js";
+import isReadableStream from "./utils/typeguards/isReadableStream.js";
+import getValidData from "./utils/getValidData.js";
+import dataTypes from "./utils/handlers/dataTypes.js";
+import getPath from "../utils/getPath.js";
+const deleteFile = () => async (fp) => {
+    const filepath = getPath(fp);
+    if (!filepath || !(await isFileExists(filepath))) {
+        throw new Error("Файл не знайдено");
+    }
+    await fsp.rm(filepath);
+};
+const moveFile = () => async (fp, destFilepath) => {
+    const filepath = getPath(fp);
+    if (!filepath || !(await isFileExists(filepath))) {
+        throw new Error("Файл не знайдено");
+    }
+    await fsp.mkdir(path.dirname(filepath), { recursive: true });
+    await fsp.mkdir(path.dirname(destFilepath), { recursive: true });
+    await fsp.copyFile(filepath, destFilepath, fs.constants.COPYFILE_FICLONE);
+    await fsp.rm(filepath);
+};
+const downloadFile = () => async (fp, options = {}) => {
+    const filepath = getPath(fp, options);
+    if (options.debug) {
+        return { original: fp, full: filepath };
+    }
+    if (!filepath || !(await isFileExists(filepath, options))) {
+        return null;
+    }
+    if (options.buffer) {
+        return fsp.readFile(filepath);
+    }
+    const fileStream = fs.createReadStream(filepath);
+    return fileStream;
+};
+const fileExists = () => async (filepath, opt = {}) => isFileExists(getPath(filepath, opt), opt);
+const uploadFile = () => async (fp, data, opt = {}) => {
+    const filepath = getPath(fp, opt);
+    const validData = await getValidData({
+        data,
+        types: [dataTypes.buffer, dataTypes.path, dataTypes.stream],
+    });
+    // const validData = data;
+    if (!filepath) {
+        throw new Error("empty filepath");
+    }
+    await fsp.mkdir(path.dirname(filepath), { recursive: true });
+    try {
+        const exists = await isFileExists(validData);
+        if (!exists) {
+            await fsp.writeFile(filepath, validData, opt);
+        }
+        else if (isBuffer(validData) || isReadableStream(validData)) {
+            await fsp.writeFile(filepath, validData, opt);
+        }
+        else {
+            await fsp.copyFile(validData, filepath);
+        }
+        return filepath;
+    }
+    catch (err) {
+        throw new Error(`Can't upload a file ${err.toString()}`);
+    }
+};
+const stat = () => async (filepath) => fsp.stat(getPath(filepath) || "");
+const getFileSize = () => async (filepath) => (await fsp.stat(getPath(filepath) || "")).size;
+const getMDate = () => async (filepath) => new Date((await fsp.stat(getPath(filepath) || "")).mtime);
+const readdir = () => async (filepath) => fsp.readdir(getPath(filepath) || "");
+export default function fsStorage() {
+    return {
+        deleteFile: deleteFile(),
+        downloadFile: downloadFile(),
+        uploadFile: uploadFile(),
+        fileExists: fileExists(),
+        stat: stat(),
+        moveFile: moveFile(),
+        getFileSize: getFileSize(),
+        getMDate: getMDate(),
+        readdir: readdir(),
+    };
+}

package/dist/server/plugins/file/providers/index.js

@@ -0,0 +1,28 @@
+import s3 from "./s3/index.js";
+import fs from "./fs.js";
+const providers = (opt) => ({
+    fs: fs(),
+    s3: s3(opt),
+});
+import config from "../../../../config.js";
+// storage s3 or file
+function dataStorage(opt = {}) {
+    const { storageList } = config;
+    const providerName = opt?.provider || (config.s3 ? "s3" : "fs");
+    if (storageList[providerName]) {
+        return storageList[providerName];
+    }
+    if (storageList[providerName] && !["fs", "s3"].includes(providerName)) {
+        return storageList[providerName];
+    }
+    const confS3 = {
+        containerName: "work",
+        accessKeyId: config.s3?.user,
+        secretAccessKey: config.s3?.password,
+        ...(config.s3 || {}),
+    };
+    const provider = providers(confS3)[providerName];
+    storageList[providerName] = provider;
+    return provider;
+}
+export default dataStorage;

package/dist/server/plugins/file/providers/mime/index.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+import types from "./mimes.js";
+function getMimeType(filename) {
+    const ext = path.extname(filename).toLocaleLowerCase().slice(1);
+    return types[ext];
+}
+export default getMimeType;