@opengis/fastify-table 1.4.88 → 1.5.1

package/dist/server/plugins/crud/funcs/dataUpdate.js

@@ -0,0 +1,198 @@
+import getPG from "../../pg/funcs/getPG.js";
+import getMeta from "../../pg/funcs/getMeta.js";
+import getRedis from "../../redis/funcs/getRedis.js";
+import pgClients from "../../pg/pgClients.js";
+import getTemplate from "../../table/funcs/getTemplate.js";
+import config from "../../../../config.js";
+import extraData from "../../extra/extraData.js";
+import logChanges from "./utils/logChanges.js";
+import logger from "../../logger/getLogger.js";
+import getInsertQuery from "./utils/getInsertQuery.js";
+const rclient = getRedis();
+const srids = {};
+function assignValue(key, i, srid = 4326, columnType = "text") {
+    if (key === "geom" && columnType === "geometry") {
+        return `"${key}"=st_setsrid(st_geomfromgeojson($${i + 2}::json),4326)`;
+    }
+    if (key?.includes("geom") && columnType === "geometry") {
+        return `"${key}"=st_setsrid(st_geomfromgeojson($${i + 2}::json),${srid})`;
+    }
+    return `"${key}"=$${i + 2}`;
+}
+export default async function dataUpdate({ table, tokenData, referer, id, data, pg: pg1, uid, }) {
+    if (!data || !table || !id)
+        return null;
+    const pg = pg1 || getPG({ name: "client" });
+    if (!pg)
+        return null;
+    // pg client single transaction support
+    if (!pg?.pk && config.pg) {
+        pg.options = pgClients.client?.options;
+        pg.tlist = pgClients.client?.tlist;
+        pg.pgType = pgClients.client?.pgType;
+        pg.relkinds = pgClients.client?.relkinds;
+        pg.pk = pgClients.client?.pk;
+    }
+    const { columns, pk } = await getMeta({ pg, table });
+    if (!columns)
+        return null;
+    const names = columns.map((el) => el.name);
+    const types = columns.reduce((acc, { name, dataTypeID }) => ({
+        ...acc,
+        [name]: pg.pgType?.[dataTypeID],
+    }), {});
+    const filterData = Object.keys(data).filter((el) => 
+    /* typeof data[el] === 'boolean' ? true : data[el] &&  */ names?.includes(el) &&
+        !["editor_date", "editor_id", "updated_by", "updated_at"].includes(el));
+    const systemColumns = [
+        ["editor_date", "now()"],
+        ["updated_at", "now()"],
+        uid ? ["editor_id", `'${uid.replace(/'/g, "''")}'`] : null,
+        uid ? ["updated_by", `'${uid.replace(/'/g, "''")}'`] : null,
+    ]
+        .filter((el) => el && names.includes(el[0]))
+        .map((el) => `${el[0]} = ${el[1]}`)
+        .join(",");
+    const filterValue = filterData
+        .map((el) => {
+        const { dataTypeID = 25 } = columns.find((col) => col?.name === el) || {};
+        if (pg.pgType[dataTypeID]?.endsWith("[]") &&
+            ["string", "number"].includes(typeof data[el])) {
+            Object.assign(data, { [el]: data[el].split(",") });
+        }
+        return [el, data[el]];
+    })
+        .map((el) => typeof el[1] === "object" && types[el[0]]?.includes?.("json") && el[1]
+        ? JSON.stringify(el[1])
+        : el[1]);
+    // update geometry with srid
+    if (!srids[table] && pg.tlist?.includes("public.geometry_columns")) {
+        const { srids1 } = await pg
+            .query(`select json_object_agg(_table,rel) as srids1 from (
+      select  f_table_schema||'.'||f_table_name as _table, 
+        json_object_agg(f_geometry_column, case when srid = 0 then 4326 else srid end) as rel 
+      from public.geometry_columns group by f_table_schema||'.'||f_table_name
+      )q`)
+            .then((res1) => res1.rows?.[0] || {});
+        Object.assign(srids, srids1);
+    }
+    const updateQuery = `UPDATE ${table} SET ${systemColumns ? `${systemColumns}${filterData?.length ? "," : ""}` : ""}
+
+  ${filterData
+        ?.map((key, i) => assignValue(key, i, srids[table]?.[key] || 4326, pg.pgType?.[columns.find((col) => col.name === key)?.dataTypeID || ""]))
+        ?.join(",")} 
+  WHERE ${pk}::text = $1::text returning *`;
+    // console.log(updateQuery, filterValue);
+    // for transactions
+    const isClient = typeof pg.query === "function" && typeof pg.release === "function";
+    const client = isClient ? pg : await pg.connect();
+    if (isClient || !client.pk) {
+        client.options = pg.options;
+        client.tlist = pg.tlist;
+        client.pgType = pg.pgType;
+        client.relkinds = pg.relkinds;
+        client.pk = pg.pk;
+    }
+    try {
+        if (!isClient) {
+            await client.query("begin;");
+        }
+        const res = (await client
+            .query(updateQuery, [id, ...filterValue])
+            .catch((err) => {
+            logger.file("crud/update", {
+                error: err.toString(),
+                stack: err.stack,
+                table,
+                id,
+                referer,
+                uid,
+                data,
+                q: updateQuery,
+            });
+            throw err;
+        })
+            .then((el) => el?.rows?.[0])) || {};
+        await extraData({
+            table,
+            form: tokenData?.form,
+            id,
+            data,
+            uid,
+            row: res,
+        }, client);
+        // foreign key dataTable (table + parent_id)
+        const formData = tokenData?.form
+            ? (await getTemplate("form", tokenData.form)) || {}
+            : {};
+        const schema = formData?.schema || formData;
+        const parentKeys = Object.keys(schema || {})?.filter((key) => Array.isArray(data[key]) &&
+            schema?.[key]?.table &&
+            schema?.[key]?.parent_id /* && body[key].length */);
+        if (parentKeys?.length) {
+            await Promise.all(parentKeys?.map(async (key) => {
+                const objId = data[schema[key].parent_id] ||
+                    data?.id ||
+                    res?.[schema[key]?.parent_id] ||
+                    res?.[pg.pk?.[table] || ""];
+                // delete old extra data
+                await client.query(`delete from ${schema[key].table} where ${schema[key].parent_id}=$1`, [objId]); // rewrite?
+                // insert new extra data
+                if (Array.isArray(data[key]) && data[key]?.length) {
+                    const parentKey = schema[key].parent_id;
+                    const extraRows = await Promise.all(data[key]?.map?.(async (row) => {
+                        Object.assign(row, { [parentKey]: objId });
+                        const parentRes = await getInsertQuery({
+                            pg: client,
+                            table: schema[key].table,
+                            data: row,
+                            uid,
+                        });
+                        if (!parentRes?.insertQuery || !parentRes?.args?.length)
+                            return null;
+                        const { rows = [] } = await client.query(parentRes.insertQuery, parentRes.args);
+                        return rows[0];
+                    }));
+                    Object.assign(res, { [key]: extraRows.filter(Boolean) });
+                }
+            }));
+        }
+        await logChanges({
+            pg,
+            table,
+            tokenData,
+            referer,
+            data,
+            id,
+            uid,
+            type: "UPDATE",
+        });
+        if (config.redis) {
+            rclient.incr(`pg:${table}:crud`);
+        }
+        if (!isClient) {
+            await client.query("commit;");
+        }
+        return res || {};
+    }
+    catch (err) {
+        logger.file("crud/update", {
+            error: err.toString(),
+            stack: err.stack,
+            table,
+            id,
+            referer,
+            uid,
+            form: tokenData?.form,
+        });
+        if (!isClient) {
+            await client.query("rollback;");
+        }
+        throw err;
+    }
+    finally {
+        if (!isClient) {
+            client.release();
+        }
+    }
+}

package/dist/server/plugins/crud/funcs/getAccess.js

@@ -0,0 +1,82 @@
+import pgClients from '../../pg/pgClients.js';
+import getTemplate from '../../table/funcs/getTemplate.js';
+import applyHook from '../../hook/funcs/applyHook.js';
+const allActions = ['view', 'edit', 'add', 'del'];
+const q = `select a.route_id as id, d.actions as user_roles, d.actions as role_actions, coalesce(b.actions, array['view']) as interface_actions, b.scope, c.role_id
+from admin.routes a 
+left join admin.role_access b on 
+  a.route_id=b.route_id
+left join admin.roles c on 
+  b.role_id=c.role_id 
+  and c.enabled
+left join admin.user_roles d on 
+  c.role_id=d.role_id 
+  and ( case when 
+            d.expiration is not null 
+            then d.expiration > CURRENT_DATE 
+            else 1=1 
+        end )
+where $1 in (a.route_id, a.alias, a.table_name) and $2 in (b.user_uid, d.user_uid)`;
+/**
+ * @param {Array} user_roles.actions Actions - user actions <> group actions
+ * @param {Array} role_access.actions Actions - user actions = group actions
+ * @param {String} body.actions Actions from table template
+ * @param {String} table Table name / Interface alias
+ * @param {Object} user User object
+ * @param {String} user.uid User ID
+ * @param {String} user.user_type User type
+ * @returns { scope: String, roles: String[], actions: String[], query: String }
+ */
+export default async function getAccess({ table, form, user = {} }, pg = pgClients.client) {
+    if (!table)
+        return null;
+    const hookData = await applyHook('getAccess', { table, user, pg });
+    if (hookData)
+        return hookData;
+    const { uid, user_type: userType = 'regular' } = user;
+    if (userType === 'superadmin') {
+        return { actions: allActions, query: '1=1' };
+    }
+    const body = await getTemplate('table', table);
+    const tableActions = !body && form
+        ? allActions // if db table and form => full access (token)
+        : ['view'].concat(body?.actions || body?.action_default || []);
+    if (userType === 'admin') {
+        if (!(body?.actions || body?.action_default) && (body?.form || form)) {
+            return { actions: allActions, query: '1=1' };
+        }
+        return { actions: tableActions, query: '1=1' };
+    }
+    if (body?.public || body?.access === 'public') {
+        return { actions: tableActions, query: '1=1' };
+    }
+    if (body?.access === 'user' && uid) {
+        return { actions: tableActions, query: '1=1' };
+    }
+    if (!uid) {
+        return { actions: [], query: '1=1' };
+    }
+    const userAccess = pg?.pk?.['admin.routes']
+        && pg.pk?.['admin.role_access']
+        && pg.pk?.['admin.roles']
+        && pg.pk?.['admin.user_roles']
+        ? await pg.query(q, [table, uid])
+            .then((el) => ({
+            ...(el.rows[0] || {}),
+            roles: el.rows?.map?.((row) => row.role_id) || [],
+            actions: el.rows?.map?.((row) => row.actions).flat() || [],
+            interface_actions: el.rows?.map?.((row) => row.interface_actions).flat() || []
+        }))
+        : {};
+    const query = userAccess?.scope === 'my' ? `uid='${uid}'` : '1=1';
+    const actions = userAccess?.interface_actions
+        ?.filter((el) => userAccess?.role_actions?.length ? userAccess?.role_actions.includes(el) : true)
+        ?.filter((el) => tableActions.includes(el))
+        ?.filter?.((el, idx, arr) => arr.indexOf(el) === idx);
+    return {
+        scope: userAccess?.scope,
+        roles: userAccess?.roles,
+        actions,
+        query,
+    };
+}

package/dist/server/plugins/crud/funcs/getOpt.js

@@ -0,0 +1,13 @@
+import config from "../../../../config.js";
+import getRedis from "../../redis/funcs/getRedis.js";
+const rclient = getRedis({ db: 0 });
+export default async function getOpt(token, uid = 0) {
+    if (!config.redis)
+        return null;
+    const key = `opt:${uid}:${token}`;
+    // console.log(key);
+    const data = await rclient.get(key);
+    if (!data)
+        return null;
+    return JSON.parse(data);
+}

package/dist/server/plugins/crud/funcs/getToken.js

@@ -0,0 +1,24 @@
+import config from "../../../../config.js";
+import getRedis from "../../redis/funcs/getRedis.js";
+// import { config, getRedis } from '../../../../utils.js';
+function sprintf(str, ...args) {
+    return str.replace(/%s/g, () => args.shift());
+}
+const keys = {
+    r: "%s:token:view:%s",
+    a: "%s:token:add:%s",
+    w: "%s:token:edit:%s",
+    e: "%s:token:exec:%s",
+};
+const rclient = getRedis({ db: 0 });
+async function getToken({ uid, token, json }) {
+    if (!config.redis)
+        return null;
+    const mode = "w";
+    // if (mode === 'r') return token;
+    const key = sprintf(keys[mode], config?.pg?.database, uid?.toString());
+    const id = await rclient.hget(key, token);
+    // console.log(key, token);
+    return json && id?.[0] === "{" ? JSON.parse(id) : id;
+}
+export default getToken;

package/dist/server/plugins/crud/funcs/isFileExists.js

@@ -0,0 +1,11 @@
+import { access } from 'fs/promises';
+const isFileExists = async (filepath) => {
+    try {
+        await access(filepath);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+};
+export default isFileExists;

package/dist/server/plugins/crud/funcs/setOpt.js

@@ -0,0 +1,19 @@
+import { createHash, randomUUID } from "crypto";
+import config from "../../../../config.js";
+import getRedis from "../../redis/funcs/getRedis.js";
+const random = randomUUID();
+const rclient = getRedis({ db: 0 });
+function md5(string) {
+    return createHash("md5").update(string).digest("hex");
+}
+export default function setOpt(params, uid = 0) {
+    if (!config.redis)
+        return null;
+    const token = Buffer.from(md5(typeof params === "object" ? JSON.stringify(params) : params) + random, "hex")
+        .toString("base64")
+        .replace(/[+-=]+/g, "");
+    // const token = md5(params);
+    const key = `opt:${uid}:${token}`;
+    rclient.set(key, JSON.stringify(params), "EX", 60 * 60);
+    return token;
+}

package/dist/server/plugins/crud/funcs/setToken.js

@@ -0,0 +1,41 @@
+import { createHash, randomUUID } from "crypto";
+import config from "../../../../config.js";
+import getRedis from "../../redis/funcs/getRedis.js";
+const rclient = getRedis({ db: 0 });
+// import { config, getRedis } from '../../../../utils.js';
+const generateCodes = (ids, userToken) => {
+    const token = userToken || randomUUID();
+    const notNullIds = ids.filter((el) => el);
+    const obj = {};
+    const codes = notNullIds.reduce((acc, id) => {
+        const newToken = createHash("sha1")
+            .update(token + id)
+            .digest("base64url")
+            .replace(/-/g, "");
+        acc[newToken] = id;
+        obj[id] = newToken;
+        return acc;
+    }, {});
+    return { codes, obj };
+};
+function setToken({ ids: idsOrigin, uid, array, }) {
+    if (!config.redis) {
+        return array ? [] : {};
+    }
+    if (!uid) {
+        return array ? [{ user: "empty" }] : { user: "empty" };
+    }
+    if (!Object.keys(idsOrigin).length) {
+        return array ? [{ ids: "empty" }] : { ids: "empty" };
+    }
+    const ids = idsOrigin.map((el) => typeof el === "object" ? JSON.stringify(el) : el);
+    // TODO generate salt
+    const { codes, obj } = generateCodes(ids, uid);
+    if (!Object.keys(codes).length)
+        return { ids: "empty" };
+    rclient.hmset(`${config.pg.database}:token:edit:${uid}`, Object.entries(codes).flat());
+    // console.log(`${config.pg.database}:token:edit:${uid}`, idsOrigin, Object.values(obj));
+    // TODO дополнительно писать в hset token -> uid
+    return array ? Object.values(obj) : obj;
+}
+export default setToken;

package/dist/server/plugins/crud/funcs/utils/getFolder.js

@@ -0,0 +1,13 @@
+import path from "node:path";
+import config from "../../../../../config.js";
+export default function getFolder(req, type = "server") {
+    if (!["server", "local"].includes(type))
+        throw new Error("params type is invalid");
+    const types = {
+        local: req.root || config.root,
+        server: req.mapServerRoot || config.mapServerRoot,
+    };
+    const dbname = req.pg?.options?.database || config.pg?.database; // request / config params / default config params
+    const filepath = path.posix.join(types[type] || `/data/local/${dbname || ""}`, req.folder || config.folder || "");
+    return filepath;
+}

package/dist/server/plugins/crud/funcs/utils/getInsertQuery.js

@@ -0,0 +1,54 @@
+import getMeta from "../../../pg/funcs/getMeta.js";
+export default async function getInsertQuery({ pg, table, data, id, uid, }) {
+    if (!pg?.pk || !data) {
+        return null;
+    }
+    const { columns } = await getMeta({ pg, table });
+    if (!columns) {
+        return null;
+    }
+    const names = columns.map((col) => col.name);
+    Object.assign(data, {
+        ...(id && pg.pk?.[table] ? { [pg.pk?.[table]]: id } : {}),
+        ...(table !== "admin.users" ? { uid } : {}),
+        editor_id: uid,
+        created_by: uid,
+        updated_by: uid,
+    });
+    const systemColumns = [
+        "cdate",
+        "editor_date",
+        "created_at",
+        "updated_at",
+    ]
+        .filter((el) => names.includes(el))
+        .map((el) => [el, "now()"]);
+    const systemColumnNames = systemColumns.map((el) => el[0]);
+    const filterData = Object.keys(data)
+        .filter((el) => !systemColumnNames.includes(el) &&
+        (typeof data[el] === "boolean" ? true : data[el]) &&
+        names.includes(el))
+        .map((el) => [el, data[el]]);
+    const insertQuery = `insert into ${table}
+
+    ( ${filterData
+        ?.map((key) => `"${key[0]}"`)
+        .concat(systemColumnNames)
+        .join(",")}) 
+
+    values  (${filterData
+        ?.map((key, i) => key[0] === "geom"
+        ? `st_setsrid(st_geomfromgeojson($${i + 1}::json),4326)`
+        : `$${i + 1}`)
+        .concat(systemColumns.map((el) => el[1]))
+        .join(",")}) 
+    
+    returning *`;
+    const args = [
+        ...filterData.map((el) => typeof el[1] === "object" &&
+            (!Array.isArray(el[1]) || typeof el[1]?.[0] === "object")
+            ? JSON.stringify(el[1])
+            : el[1]),
+    ];
+    return { insertQuery, args };
+}

package/dist/server/plugins/crud/funcs/utils/logChanges.js

@@ -0,0 +1,144 @@
+import { createHash } from "node:crypto";
+import getTemplate from "../../../table/funcs/getTemplate.js";
+import metaFormat from "../../../table/funcs/metaFormat/index.js";
+const defaultTitles = {
+    editor_date: "Дата оновлення",
+    editor_id: "Редактор",
+    сdate: "Дата створення",
+    uid: "Автор",
+    body: "Зміст",
+    entity_id: "ID Сутності",
+    entity_type: "Таблиця сутності",
+    file_path: "Шлях до файлу",
+    uploaded_name: "Назва файлу",
+    size: "Розмір файлу",
+    ext: "Розширення файлу",
+};
+function getValue(val, tableName) {
+    if (!val)
+        return null;
+    if (["crm.files"].includes(tableName)) {
+        return typeof val === "object" ? JSON.stringify(val) : val;
+    }
+    return typeof val === "object"
+        ? JSON.stringify(val)?.substring?.(0, 30)
+        : val?.toString?.()?.substring?.(0, 30);
+}
+// extract titles and cls from form schema
+// alt: extract table template from referer -> form
+export default async function logChanges({ pg, table: table1, tokenData, referer, id, data, uid = 1, type, }) {
+    const table = table1.replace(/"/g, "");
+    if (!id) {
+        console.error("param id is required");
+        return null;
+    }
+    if (!table || !pg.pk?.[table]) {
+        console.error("table not found");
+        return null;
+    }
+    if (!pg.pk?.["log.table_changes"] || !pg.pk?.["log.table_changes_data"]) {
+        console.error("log table not found");
+        return null;
+    }
+    if (!type) {
+        console.error("invalid type");
+        return null;
+    }
+    try {
+        const { change_id: changeId } = await pg
+            .query(`insert into log.table_changes(change_date,change_type,change_user_id,entity_type,entity_id) 
+    values(CURRENT_DATE, $1, $2, $3, $4) returning change_id`, [type, uid, table, id])
+            .then((el) => el.rows?.[0] || {});
+        const q = `select json_object_agg(entity_key, value_hash) from (
+      select
+        entity_key,
+        value_hash,
+        ( rank() over (partition by entity_key order by cdate desc) = 1 ) as is_latest
+      from log.table_changes_data
+
+      where change_id in (
+        select
+          change_id
+        from log.table_changes
+        where entity_id=$1
+        and entity_type=$2
+      )
+
+    )q where is_latest`;
+        // console.log(q, type, id);
+        const old = type !== "INSERT"
+            ? await pg
+                .query(q, [id, table])
+                .then((el) => el.rows?.[0]?.json_object_agg || {})
+            : {};
+        const body = await getTemplate("form", tokenData?.form);
+        const schema = body?.schema || body || {};
+        const titles = Object.keys(schema).reduce((acc, curr) => Object.assign(acc, { [curr]: schema[curr].title || schema[curr].ua }), {});
+        const cls = Object.keys(schema)
+            .filter((el) => schema[el]?.data)
+            .reduce((acc, curr) => Object.assign(acc, { [curr]: schema[curr].data }), {});
+        const data1 = data
+            ? await metaFormat({
+                rows: [data],
+                cls,
+                sufix: false,
+                reassign: false,
+            }, pg)
+            : null;
+        const newObj = Object.fromEntries(Object.entries(data1?.[0] || {}).map((el) => [
+            [titles[el[0]] || defaultTitles[el[0]] || el[0]],
+            el[1],
+        ]));
+        const changesData = Object.keys(newObj || {})
+            .map((el) => ({
+            change_id: changeId,
+            entity_key: el,
+            value_old: getValue(old?.[el], table),
+            value_new: type === "DELETE" ? null : getValue(newObj?.[el], table),
+            value_hash: newObj?.[el]
+                ? createHash("md5").update(JSON.stringify(newObj?.[el])).digest("hex")
+                : null,
+            uid,
+        }))
+            .filter((el) => old?.[el.entity_key] !== el.value_hash);
+        const res = await Promise.all(changesData.map(async (el) => {
+            const insertQuery = `insert into log.table_changes_data (${Object.entries(el)
+                ?.map((key) => `"${key[0]}"`)
+                .join(",")}) 
+      values (${Object.entries(el)
+                ?.map((key, i) => `$${i + 1}`)
+                .join(",")}) returning *`;
+            const { rows = [] } = (await pg.query(insertQuery, [
+                ...Object.entries(el).map((el1) => el1[1] &&
+                    typeof el1[1] === "object" &&
+                    (!Array.isArray(el1[1]) || typeof el1[1]?.[0] === "object")
+                    ? JSON.stringify(el1[1])
+                    : el1[1]),
+            ])) || {};
+            return rows[0];
+        }));
+        const newData = type === "DELETE"
+            ? {}
+            : (Array.isArray(res) ? res : [res]).reduce((acc, curr) => Object.assign(acc, { [curr.entity_key]: curr.value_new }), {});
+        // console.log('logChanges OK', type);
+        return {
+            change_id: changeId,
+            entity_type: table,
+            entity_id: id,
+            uid,
+            change_type: type,
+            old,
+            new: newData,
+        };
+    }
+    catch (err) {
+        console.error("logChanges error", type, table, id, data, err.toString());
+        return {
+            error: err.toString(),
+            entity_type: table,
+            entity_id: id,
+            uid,
+            change_type: type,
+        };
+    }
+}