@opengis/fastify-table 1.4.88 → 1.5.0

package/dist/server/plugins/sqlite/funcs/init.js

@@ -0,0 +1,45 @@
+/* eslint-disable no-console */
+function init(client) {
+    if (!client) {
+        return;
+    }
+    const rows = client.prepare(`WITH tables AS (
+    SELECT name AS table_name
+    FROM sqlite_master
+    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+  ),
+  pk_columns AS (
+    SELECT
+      m.name AS table_name,
+      ti.name AS column_name,
+      ti.pk
+    FROM sqlite_master m
+    JOIN pragma_table_info(m.name) AS ti
+    WHERE ti.pk = 1
+  )
+  SELECT table_name, column_name
+  FROM pk_columns
+  WHERE table_name IN (
+    SELECT table_name
+    FROM pk_columns
+    GROUP BY table_name
+    HAVING COUNT(*) = 1
+  )
+  ORDER BY table_name;`).all();
+    const pk = Object.fromEntries(rows.map((row) => [row.table_name, row.column_name]));
+    const tlist = client.prepare('SELECT name FROM sqlite_master WHERE type=\'table\' AND name NOT LIKE \'sqlite_%\';').all().reduce((acc, curr) => {
+        acc.push(curr.name);
+        return acc;
+    }, []);
+    async function query(q, args = []) {
+        const data = client.prepare(q.replace(/\$\d+/g, '?')).all(...args);
+        return Promise.resolve({ rows: data, rowCount: data.length });
+    }
+    Object.assign(client, {
+        query,
+        pk,
+        tlist,
+    });
+    console.log('sqlite db connected', client.name || ':memory:');
+}
+export default init;

package/dist/server/plugins/sqlite/index.js

@@ -0,0 +1,8 @@
+import fp from "fastify-plugin";
+import sqliteClients from "./sqliteClients.js";
+async function dbPlugin(app, opt) {
+    app.addHook("onClose", async () => {
+        Object.keys(sqliteClients).forEach((key) => sqliteClients[key].close());
+    });
+}
+export default fp(dbPlugin);

package/dist/server/plugins/sqlite/sqliteClients.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+const { name: execName } = path.parse(process.argv0);
+// import Database from 'better-sqlite3';
+const { default: Database } = execName === "bun"
+    ? // @ts-expect-error bun internal module
+        { default: (await import("bun:sqlite")).Database }
+    : await import("better-sqlite3");
+import config from "../../../config.js";
+import init from "./funcs/init.js";
+const sqliteClients = {};
+if (config.sqlite) {
+    const client = new Database(config.sqlite?.name || ":memory:", execName === "bun"
+        ? undefined
+        : {
+            readonly: config.sqlite?.readonly || false,
+            fileMustExist: config.sqlite?.fileMustExist || false,
+            timeout: config.sqlite?.statement_timeout || 10000,
+            verbose: config.trace ? console.log : undefined,
+        });
+    client.init = () => init(client);
+    client.init();
+    sqliteClients.client = client;
+}
+export default sqliteClients;

package/dist/server/plugins/table/funcs/addMenu.js

@@ -0,0 +1,12 @@
+import { basename } from "node:path";
+import { existsSync } from "node:fs";
+import menuDirs from "./menuDirs.js";
+export default function addMenu(filepath) {
+    if (basename(filepath) !== "menu.json") {
+        throw new Error("addMenu: filepath must be a menu.json file");
+    }
+    if (filepath && !menuDirs.includes(filepath) && existsSync(filepath)) {
+        menuDirs.push(filepath);
+    }
+    return menuDirs;
+}

package/dist/server/plugins/table/funcs/addTemplateDir.js

@@ -0,0 +1,16 @@
+/* eslint-disable no-console */
+import { existsSync, readFileSync } from "node:fs";
+import userTemplateDir from "./userTemplateDir.js";
+import customTokens from "./customTokens.js";
+import yml2json from "../../yml/funcs/yml2json.js";
+export default function addTemplateDir(dir) {
+    if (dir && !userTemplateDir.includes(dir)) {
+        userTemplateDir.push(dir);
+        if (existsSync(`${dir}/tokens.yml`)) {
+            const json = yml2json(readFileSync(`${dir}/tokens.yml`));
+            Object.assign(customTokens, json);
+            console.log("load user tokens", dir);
+        }
+    }
+    return userTemplateDir;
+}

package/dist/server/plugins/table/funcs/customTokens.js

@@ -0,0 +1,2 @@
+const userTokens = {};
+export default userTokens;

package/dist/server/plugins/table/funcs/getData.js

@@ -0,0 +1,25 @@
+import routeData from "../../../routes/table/controllers/tableData.js";
+export default async function getData({ id, table, pg, headers, filter, state, limit, page, search, user, order, desc, sql, contextQuery, sufix, filterList, }, reply, called) {
+    const params = { table, id };
+    const query = {
+        filter,
+        limit,
+        page,
+        search,
+        sql,
+        state,
+        order,
+        desc,
+    };
+    const result = await routeData({
+        pg,
+        headers,
+        params,
+        query,
+        user,
+        contextQuery,
+        sufix,
+        filterList,
+    }, reply, called);
+    return result;
+}

package/dist/server/plugins/table/funcs/getFilter.js

@@ -0,0 +1,18 @@
+import routeFilter from "../../../routes/table/controllers/filter.js";
+import pgClients from "../../pg/pgClients.js";
+export default async function getFilter({ pg = pgClients.client, table, filter, custom, state, search, user, }, reply) {
+    const params = { table };
+    const query = {
+        filter,
+        custom,
+        state,
+        search,
+    };
+    const result = await routeFilter({
+        pg,
+        params,
+        query,
+        user,
+    }, reply, 1);
+    return result;
+}

package/dist/server/plugins/table/funcs/getFilterSQL/index.js

@@ -0,0 +1,201 @@
+import getTemplate from "../getTemplate.js";
+import getSelect from "../getSelect.js";
+import pgClients from "../../../pg/pgClients.js";
+import config from "../../../../../config.js";
+// filter util
+import getTableSql from "./util/getTableSql.js";
+import getFilterQuery from "./util/getFilterQuery.js";
+import getOptimizedQuery from "./util/getOptimizedQuery.js";
+import getFilter from "../getFilter.js";
+const checkInline = {};
+const defaultTable = "crm.extra_data";
+function getExtraQuery(mainColumns, schema, table, pk) {
+    const extraColumns = Object.keys(schema || {})
+        .filter((key) => !mainColumns.map((el) => el?.name).includes(key))
+        .map((key) => ({ name: key, type: schema[key]?.type }));
+    return {
+        q: extraColumns
+            .map((el) => `,(select value_text as "${el.name.replace(/'/g, "''")}" from ${table} where property_key='${el.name.replace(/'/g, "''")}' and object_id=t.${pk} limit 1)`)
+            .join(" "),
+        extraColumns,
+    };
+}
+export default async function getFilterSQL({ table, filter, pg = pgClients.client, search, filterList, query, custom, state, uid, objectId, order, }) {
+    if (!table)
+        return { error: "param table is required", status: 400 };
+    const body = await getTemplate("table", table);
+    const loadTemplate = body?.form
+        ? await getTemplate("form", body?.form)
+        : null;
+    const { extra } = loadTemplate || {};
+    const extraDataTable = extra
+        ? config.extraData?.[body.table] ||
+            config.extraData?.[body.table.split(".").shift()] ||
+            config.extraData?.default ||
+            config.extraData ||
+            defaultTable
+        : undefined;
+    const { fields: fieldsModel = [] } = body?.table && pg.pk?.[body.table]
+        ? await pg.query(`select * from ${body.table} limit 0`)
+        : {};
+    const { q: extraSqlColumns, extraColumns = [] } = pg.pk?.[extraDataTable] && pg.pk?.[body.table || table]
+        ? getExtraQuery(fieldsModel, loadTemplate?.schema, extraDataTable, pg.pk[body.table || table])
+        : {};
+    // console.log('extra getFilterSQL', extraDataTable, pg.pk?.[extraDataTable]);
+    // check sql inline fields count
+    if (body?.table && !checkInline[body?.table] && body?.sql?.length) {
+        const filterSql = body.sql.filter((el) => !el?.disabled && (el.inline ?? true));
+        const sqlTable = filterSql
+            .map((el, i) => ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `)
+            ?.join("") || "";
+        const d = await Promise.all(filterSql.map((el, i) => pg
+            .query(`select  ${el.name || `t${i}`}.* from(select * from ${body.table})t ${sqlTable} limit 0`)
+            .then((item) => item.fields)));
+        d.forEach((el, i) => {
+            filterSql[i].inline = el.length === 1;
+            filterSql[i].fields = el.map((f) => f.name);
+        });
+        checkInline[body?.table] = body.sql;
+    }
+    else if (checkInline[body?.table]) {
+        body.sql = checkInline[body?.table];
+    }
+    const sqlTable = body?.sql?.length
+        ? body.sql
+            .filter((el) => !el?.disabled &&
+            !el.inline &&
+            el?.sql?.replace &&
+            (!el.sql.includes("{{uid}}") || uid))
+            .map((el, i) => ` left join lateral (${el.sql.replace("{{uid}}", uid)}) ${el.name || `t${i}`} on 1=1 `)
+            .join("")
+        : null;
+    const sqlInline = body?.sql
+        ?.filter?.((el) => el.inline)
+        .map((el) => `,(${el.sql})`)
+        .join("");
+    const fieldQuery = `select * ${extraSqlColumns || ""} ${sqlInline || ""} from ${body?.table || table} t ${sqlTable || ""} limit 0`;
+    const { fields = [] } = await pg.query(fieldQuery);
+    const autoSearchColumn = fields
+        ?.filter((el) => pg.pgType?.[el.dataTypeID] === "text")
+        ?.map((el) => el.name)
+        .join(",");
+    const searchColumn = body?.search_column || body?.meta?.search || autoSearchColumn;
+    const fieldsList = (fieldsModel || fields)?.map((el) => el.name);
+    try {
+        const tableSQL = await getTableSql({
+            pg,
+            body,
+            table,
+            fields,
+        });
+        const sval = `ilike '%${decodeURIComponent(search?.replace?.(/%/g, "%25") || "")
+            .replace(/'/g, "''")
+            .replace(/%/g, "\\%")}%'`;
+        const searchQuery = search && searchColumn
+            ? ` (${searchColumn
+                .split(",")
+                ?.map((name) => {
+                const { pk } = tableSQL.find((el) => el.name === name) || {};
+                return pk && !fieldsList.includes(name)
+                    ? `${pk} in (select ${pk} from (${fieldQuery.replace(/limit 0/g, "")} where ${name} ${sval} )q where 1=1)`
+                    : `${name} ${sval}`;
+            })
+                .join(" or ")} )`
+            : "";
+        const filterResponse = (await getFilter({
+            pg,
+            table,
+            user: { uid },
+        }, null));
+        const filterList1 = await Promise.all((filterList || [])
+            .concat(filterResponse?.inline || [])
+            .concat(filterResponse?.custom || [])
+            .concat(filterResponse?.state || [])
+            .concat(filterResponse?.list || [])
+            ?.filter((el) => el.id || el.name)
+            ?.map(async (el) => {
+            Object.assign(el, { name: el.name || el.id });
+            if (el.name &&
+                extraColumns.find((item) => item?.name === el?.name)) {
+                Object.assign(el, {
+                    extra: {
+                        table: extraDataTable,
+                        input: extraColumns.find((item) => item?.name === el?.name)
+                            ?.type,
+                    },
+                });
+            }
+            if (!el?.data)
+                return el;
+            // const cls = await getTemplate(['cls', 'select'], el.data); // only git cls
+            const cls = await getSelect(el.data, pg); // git + db cls
+            if (Array.isArray(cls?.arr) && cls.arr.length) {
+                Object.assign(el, {
+                    cls: el.data,
+                    options: cls,
+                    select: `select code, name from admin.cls where parent='${el.data}'`,
+                });
+            }
+            else if (typeof (cls?.sql || cls) === "string") {
+                Object.assign(el, { select: cls?.sql || cls });
+            }
+            return el;
+        }));
+        const modelQuery = body?.model || body?.table || table;
+        const filters = getFilterQuery({
+            pg,
+            filter,
+            table: modelQuery,
+            tableSQL,
+            fields,
+            filterList: filterList1,
+            uid,
+            objectId,
+        });
+        // filter
+        const customQuery = body?.filterCustom?.length && custom
+            ? body.filterCustom?.find((el) => el.name === custom)?.sql
+            : null;
+        const stateQuery = body?.filterState?.length && state
+            ? body.filterState?.find((el) => el.name === state)?.sql
+            : null;
+        const filterQuery = filters
+            ?.filter((el) => el.query)
+            ?.map((el) => `${el.query}`)
+            .join(" and ");
+        const q = [
+            body?.query,
+            query,
+            searchQuery,
+            filterQuery,
+            stateQuery,
+            customQuery,
+        ]
+            .filter((el) => el)
+            .join(" and ");
+        // table
+        const obj = {
+            body,
+            extraSqlColumns,
+            table,
+            q,
+        };
+        const optimizedSQL = `select * from ${getOptimizedQuery(obj)} ${order ? `order by ${order}` : ""}`;
+        const tableCount = getOptimizedQuery(obj, true);
+        return {
+            filterList,
+            filters,
+            q,
+            optimizedSQL,
+            sqlTable,
+            extraSqlColumns,
+            tableCount,
+            table: modelQuery,
+            // filter parts
+            searchQuery,
+        };
+    }
+    catch (err) {
+        throw err;
+    }
+}

package/dist/server/plugins/table/funcs/getFilterSQL/util/formatValue.js

@@ -0,0 +1,131 @@
+import applyHookSync from "../../../../hook/funcs/applyHookSync.js";
+import getRangeQuery from "./getRangeQuery.js";
+export default function formatValue({ pg, table, filter = {}, name, value, dataTypeID, uid = 1, optimize, }) {
+    const { extra, sql, select, strict, options /* default: defaultValue, */ } = filter;
+    const pk = pg?.pk && table ? pg.pk[table] : undefined;
+    const filterType = filter.type?.toLowerCase?.() || "text";
+    if (filterType === "text" && value && filter?.columns) {
+        const columns = filter.columns.split(",");
+        const sval = `ilike '%${decodeURIComponent(value.replace(/%/g, "%25")).replace(/%/g, "\\%")}%'`;
+        const query = `(${columns
+            .map((el) => `"${el}" ${sval}`)
+            .join(" or ")})`;
+        return { op: "~", query };
+    }
+    const fieldType = pg?.pgType?.[dataTypeID] || pg?.pgType?.[{ date: 1114 }[filterType] || 25];
+    const hookData = applyHookSync("onFormatValue", {
+        pg,
+        pk,
+        table,
+        name,
+        value,
+        filterType,
+        fieldType,
+        filter,
+        dataTypeID,
+        uid,
+        optimize,
+    });
+    if (hookData) {
+        return hookData?.query ? hookData : { op: "=", query: hookData };
+    }
+    if (!name ||
+        !value ||
+        (!dataTypeID && !extra && !sql && !options) ||
+        extra?.input?.toLowerCase?.() === "datatable" ||
+        (!["check", "autocomplete", "tags", "avatar", "radio"].includes(filterType) &&
+            options?.find?.((el) => el?.sql))) {
+        return {};
+    }
+    // my rows
+    if (value === "me" && uid) {
+        return { op: "=", query: `${name}::text = '${uid}'` };
+    }
+    const matchNull = { null: "is null", notnull: "is not null" }[value];
+    // null = true is null, not false
+    const matchBoolean = fieldType === "boolean"
+        ? { true: "is true", false: "is false" }[value]
+        : null;
+    const matchMulti = fieldType?.includes("[]")
+        ? `::text[] && '{${value}}'::text[]`
+        : null;
+    const match = matchNull ||
+        matchBoolean ||
+        matchMulti ||
+        `::text=any('{${value}}'::text[])`;
+    // geometry
+    if (["geometry"].includes(fieldType || "")) {
+        if (matchNull) {
+            return { op: "nullable", query: `${name} ${matchNull}` };
+        }
+        const bbox = value?.[0]?.split?.("_");
+        if (bbox?.length !== 4) {
+            return {};
+        }
+        const query = ` ${name} && 'box(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d `;
+        return { op: "&&", query };
+    }
+    const querysql = sql
+        ?.replace?.(/= ?any\(\$1\)/g, `::text=any('{ ${value} }'::text[])`)
+        ?.replace?.(/\$1/g, `'${value}'`);
+    const op = filterType === "text" && !strict ? "~" : "=";
+    // text
+    if (["text"].includes(filterType)) {
+        // with sql subquery
+        if (sql) {
+            return { op: "=", query: querysql };
+        }
+        // extra table, example: crm.extra_data
+        if (extra?.table && pk) {
+            const query = `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_text ${matchNull || `${op} '${value}'`} )`;
+            return { op, query };
+        }
+        // select / cls
+        if (select) {
+            const subquery = matchNull
+                ? `name ${matchNull}`
+                : `lower(name::text) ~ lower('${value}')`;
+            return {
+                op,
+                query: `${name}::text in ( ( with q(id,name) as (${select}) select id from q where ${subquery}) )`,
+            };
+        }
+        // nullable
+        if (matchNull) {
+            const query = `${name} ${matchNull}`;
+            return { op, query };
+        }
+        // default
+        const query = `lower(${name}::text) ${op} lower('${value}')`;
+        return { op, query };
+    }
+    // date: 01.01.2024-31.12.2024 / number range: 100-500
+    if (["date", "datepicker", "range"].includes(filterType)) {
+        const query = getRangeQuery(value, name, fieldType, filterType, sql, extra, pk);
+        return { op: "between", query };
+    }
+    /* select query - from admin.cls / filter options */
+    if (["check", "autocomplete", "tags", "avatar", "radio"].includes(filterType)) {
+        // multiple checks with predefined query
+        if (options?.find?.((el) => el?.sql)) {
+            const query = options
+                .filter((el) => value.split(",").includes(el.id))
+                .map((el) => el.sql || "false")
+                .join(" and ") || "false";
+            return { op: "=", query };
+        }
+        // with sql subquery
+        if (sql) {
+            return { op: "=", query: querysql };
+        }
+        // extra table, example: crm.extra_data
+        if (extra?.table && pk) {
+            const query = `${pk} in (select object_id from ${extra.table} where property_key='${name}' and value_text ${matchNull || `='${value}'`} )`;
+            return { op: "=", query };
+        }
+        // nullable + default
+        const query = `${name} ${match}`;
+        return { op: "=", query };
+    }
+    return {};
+}

package/dist/server/plugins/table/funcs/getFilterSQL/util/getCustomQuery.js

@@ -0,0 +1,11 @@
+async function getCustomQuery({ pg, table, customFilter }) {
+    if (!customFilter)
+        return null;
+    const customFilterList = customFilter?.split(',')?.map((el) => el?.split('_').pop());
+    const { property_json: customFilterSQL } = await pg.one(`select json_agg(json_build_object('id',property_id,'name',property_key,'query',property_text)
+  ) as property_json from admin.properties where property_key is not null and property_entity='customQuery' and object_id=$1`, [table]);
+    const data = customFilterSQL?.length ? customFilterSQL.filter((el) => customFilterList.includes(el.id)) || [] : [];
+    const customQuery = data?.map((el) => el.query).join(' and ');
+    return `${customQuery}`;
+}
+export default getCustomQuery;

package/dist/server/plugins/table/funcs/getFilterSQL/util/getFilterQuery.js

@@ -0,0 +1,84 @@
+/* eslint-disable no-continue */
+import pgClients from "../../../../pg/pgClients.js";
+import formatValue from "./formatValue.js";
+/**
+ * @param {Number} opt.json - (1|0) 1 - Результат - Object, 0 - String
+ * @param {String} opt.query - запит до таблиці
+ * @param {String} opt.hash - інформація з хешу по запиту
+ */
+function getFilterQuery({ pg = pgClients.client, filter: filterStr = "", table = "", tableSQL = [], fields, filterList, uid, objectId, }) {
+    // if (!filterStr) return null; // filter list API
+    const mainOperators = ["=", "~", ">", "<"];
+    const filterQueryArray = decodeURIComponent(filterStr
+        ?.replace?.(/%/g, "%25")
+        ?.replace?.(/%/g, "\\%")
+        ?.replace?.(/(^,)|(,$)/g, ""))
+        ?.replace?.(/'/g, "''")
+        ?.split?.(/[;|]/) || [];
+    // default filter value form checkboxes, autocomplete or sql-defined only - if not called from card
+    const filterDefaultQueryArray = !objectId
+        ? filterList
+            ?.filter?.((el) => el.name &&
+            !filterStr?.includes?.(`${el.name}=`) &&
+            el.default &&
+            (el.options || el.sql))
+            ?.map?.((el) => `${el.name}=${el.default}`) || []
+        : [];
+    // concat default + request filters
+    const arr = filterQueryArray
+        .concat(filterDefaultQueryArray)
+        .filter((el) => el);
+    const resultList = [];
+    for (let i = 0; i < arr.length; i += 1) {
+        const item = arr[i];
+        if (!item) {
+            continue;
+        }
+        const splitby = mainOperators?.find((el) => item.indexOf(el) !== -1) || "=";
+        const [name] = item.split(splitby);
+        // skip already added filter
+        if (resultList.find((el) => el.name === name)) {
+            continue;
+        }
+        // filter
+        const filter = filterList?.find?.((el) => el.type && el.name === name) || { type: "text" };
+        const { strict, extra } = filter;
+        // find all value
+        const value = arr
+            .filter((el) => el.split(splitby)?.[0] === name)
+            .map((el) => el.substring((name?.length || 0) + 1))
+            .join(",");
+        const optimize = fields?.find((el) => el.name === name)
+            ? null
+            : tableSQL.find((el) => el.name === name);
+        // find field and skip not exists
+        const { dataTypeID } = fields?.find((el) => el.name === name) ||
+            fields?.find((el) => el.name === optimize?.pk) ||
+            {};
+        // format query
+        const { op, query, filterType, fieldType } = formatValue({
+            pg,
+            table,
+            filter,
+            name,
+            value,
+            dataTypeID,
+            uid,
+            optimize,
+        }) || {};
+        if (!query)
+            continue;
+        resultList.push({
+            name,
+            value,
+            query,
+            operator: op,
+            filterType,
+            type: fieldType,
+            strict,
+            extra,
+        });
+    }
+    return resultList;
+}
+export default getFilterQuery;

package/dist/server/plugins/table/funcs/getFilterSQL/util/getOptimizedQuery.js

@@ -0,0 +1,11 @@
+export default function getOptimizedQuery({ body, extraSqlColumns, table, q, }, count) {
+    const order = body?.orderby || body?.order
+        ? `order by ${body?.orderby || body?.order}`
+        : "";
+    const tableName = body?.table || body?.model || table;
+    const sqlList = body?.sql
+        ?.filter((el) => !el.disabled && el?.sql?.replace && (count ? el.count !== false : true))
+        .map((el) => ` left join lateral (${el.filter ? el.sql.replace(/limit 1/gi, "") : el.sql}) as ${el.name} on 1=1 `)
+        .join(" ");
+    return `(select * ${extraSqlColumns || ""} from ${tableName} t ${sqlList ? ` ${sqlList}` : ""} where 1=1 and ${q?.replace("q.", "t.") || "1=1"} ${order})q`;
+}