@opengis/gis 0.2.176 → 0.2.177

package/server/routes/registers/functions/gis.registry.list.js

@@ -1,61 +1,61 @@
-import { NotFoundError } from "@opengis/fastify-table/errors.js";
-import { pgClients, getTemplatePath, getTemplate } from "@opengis/fastify-table/utils.js";
-
-export default async function gisRegistryList({ page = 1, limit = 9, search = '' }, pg = pgClients.client) {
-
-    const offset = limit * (page - 1);
-
-    const dbResult = await pg.query(
-        `SELECT register_key, name, description, keywords
-        FROM gis.registers
-        WHERE is_public = true AND is_active = true`
-    );
-
-    let templates = dbResult?.rows;
-    let fromDatabase = true;
-
-    if (!templates?.length) {
-        fromDatabase = false;
-
-        const registryListTemplate = getTemplatePath('registry');
-
-        if (!registryListTemplate?.length) {
-            throw NotFoundError('Templates not found');
-        }
-
-        templates = (await Promise.all(
-            registryListTemplate.map(async ([slug]) => {
-                try {
-                    const tpl = await getTemplate('registry', slug);
-                    if (tpl?.visible === false) return null;
-
-                    const { register_key, name, description, keywords } = tpl;
-                    return { register_key, name, description, keywords };
-                } catch {
-                    return null;
-                }
-            })
-        ));
-    }
-
-    const filteredBySearch = search
-        ? templates.filter(tpl => {
-            const q = search.toLowerCase();
-            return (
-                tpl.name?.toLowerCase().includes(q) ||
-                tpl.description?.toLowerCase().includes(q) ||
-                tpl.keywords?.join(' ').toLowerCase().includes(q)
-            );
-        })
-        : templates;
-
-    const paged = filteredBySearch.slice(offset, offset + limit);
-
-    return {
-        rows: paged,
-        total: filteredBySearch.length,
-        page,
-        limit,
-        offset
-    };
-}
+import { NotFoundError } from "@opengis/fastify-table/errors.js";
+import { pgClients, getTemplatePath, getTemplate } from "@opengis/fastify-table/utils.js";
+
+export default async function gisRegistryList({ page = 1, limit = 9, search = '' }, pg = pgClients.client) {
+
+    const offset = limit * (page - 1);
+
+    const dbResult = await pg.query(
+        `SELECT register_key, name, description, keywords
+        FROM gis.registers
+        WHERE is_public = true AND is_active = true`
+    );
+
+    let templates = dbResult?.rows;
+    let fromDatabase = true;
+
+    if (!templates?.length) {
+        fromDatabase = false;
+
+        const registryListTemplate = getTemplatePath('registry');
+
+        if (!registryListTemplate?.length) {
+            throw NotFoundError('Templates not found');
+        }
+
+        templates = (await Promise.all(
+            registryListTemplate.map(async ([slug]) => {
+                try {
+                    const tpl = await getTemplate('registry', slug);
+                    if (tpl?.visible === false) return null;
+
+                    const { register_key, name, description, keywords } = tpl;
+                    return { register_key, name, description, keywords };
+                } catch {
+                    return null;
+                }
+            })
+        ));
+    }
+
+    const filteredBySearch = search
+        ? templates.filter(tpl => {
+            const q = search.toLowerCase();
+            return (
+                tpl.name?.toLowerCase().includes(q) ||
+                tpl.description?.toLowerCase().includes(q) ||
+                tpl.keywords?.join(' ').toLowerCase().includes(q)
+            );
+        })
+        : templates;
+
+    const paged = filteredBySearch.slice(offset, offset + limit);
+
+    return {
+        rows: paged,
+        total: filteredBySearch.length,
+        page,
+        limit,
+        offset
+    };
+}

package/server/routes/registers/functions/gis.suggest.js

@@ -0,0 +1,284 @@
+import { BadRequestError, NotFoundError } from "@opengis/fastify-table/errors.js";
+import { getColumnCLS, getMeta, getRedis, metaFormat } from "@opengis/fastify-table/utils.js";
+
+import getTableColumnMeta from "./getTableColumnMeta.js";
+
+const rclient = getRedis();
+
+const count = false;
+const maxLimit = 100;
+
+export default async function gisSuggest({ token, key, val, limit: limit1 = 50 }, pg) {
+    const time = Date.now();
+
+    const redisKey = `${pg?.options?.database}:registry-filter:${token}`;
+
+    const cache = await rclient.get(redisKey);
+
+    if (!cache) {
+        throw BadRequestError('invalid params: token');
+    }
+
+    const { register, filter } = JSON.parse(cache);
+
+    const {
+        rows: [registry],
+    } = await pg.query(
+        `SELECT register_id, table_name, filters FROM gis.registers WHERE register_id=$1`,
+        [register],
+    );
+
+    if (!registry) {
+        throw NotFoundError('registry not found');
+    }
+
+    if (!registry.table_name) {
+        throw new Error('registry table not set');
+    }
+
+    const filterData = (registry.filters).find(el => el.name === filter);
+
+    if (!filterData) {
+        throw new Error('registry filter not found');
+    }
+
+    const { name, data: cls } = filterData;
+
+    const metaColumns = await getMeta({ pg, table: registry.table_name }).then((r) => r.columns || []);
+
+    const { dataTypeID } = metaColumns.find((col) => col.name === name);
+
+    if (!dataTypeID) {
+        throw NotFoundError('registry column not found: ' + name);
+    }
+
+    const clsMeta = await getTableColumnMeta({
+        table: registry.table_name,
+        column: name,
+        filtered: !!(key || val),
+        key,
+    });
+
+    const { arr, searchQuery } = clsMeta;
+
+    const limit = Math.min(limit1 || maxLimit, maxLimit);
+
+    const [schemaName, tableName] = registry.table_name.split('.');
+
+    const table = [`"${schemaName}"`, `"${tableName}"`].join('.').replace(
+        /'/g,
+        "''"
+    );
+
+    // table:column + cls
+    if (arr && !cls) {
+        const sqlCls = count
+            ? `select value, count(*) from (select ${pg.pgType?.[dataTypeID]?.includes("[]")
+                ? `unnest("${name}")`
+                : `"${name}"`
+            } as value from ${table} where 1=1)q group by value`
+            : `select array_agg(distinct value)::text[] from (select ${pg.pgType?.[dataTypeID]?.includes("[]")
+                ? `unnest("${name}")`
+                : `"${name}"`
+            } as value from ${table} where 1=1)q`;
+
+        if (pg?.pk?.[registry.table_name] && !cls) {
+            const qRes = await pg.queryCache(sqlCls, {
+                table: registry.table_name,
+            });
+            const vals =
+                (count
+                    ? qRes.rows?.map?.((el) => el.value?.toString?.() || null)
+                    : qRes.rows?.[0]?.array_agg) || [];
+
+            const lower = key?.toLowerCase?.();
+            const data1 =
+                key || val
+                    ? arr
+                        ?.filter(
+                            (el) =>
+                                !lower ||
+                                (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1
+                        )
+                        ?.filter(
+                            (el) => !val || val?.split?.(",")?.includes?.(el.id)
+                        )
+                    : arr;
+
+            const data2 = data1.filter((el) =>
+                el.id === "null"
+                    ? vals.includes(null)
+                    : el.id && vals.includes(el.id.toString())
+            );
+
+            const data = data2.slice(0, limit);
+
+            if (data.length && count) {
+                const counts = qRes.rows?.reduce?.(
+                    (acc, curr) => ({
+                        ...acc,
+                        [curr.value]: curr.count,
+                    }),
+                    {}
+                );
+                data.forEach((el) =>
+                    Object.assign(el, { count: counts?.[el.id] || 0 })
+                );
+            }
+
+            return {
+                time: Date.now() - time,
+                limit,
+                count: data.length,
+                total: arr.length,
+                mode: "array",
+                sql: process.platform === 'win32' ? sqlCls : undefined,
+                data,
+            };
+        }
+    }
+
+    // cls
+    if (arr) {
+        const lower = key?.toLowerCase();
+        const data1 =
+            key || val
+                ? arr
+                    ?.filter(
+                        (el) =>
+                            !lower ||
+                            (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1
+                    )
+                    ?.filter((el) => !val || val?.split?.(",")?.includes?.(el.id))
+                : arr;
+        const data = data1.slice(0, Math.min(limit1 || limit, limit));
+
+        return {
+            time: Date.now() - time,
+            limit,
+            count: data.length,
+            total: arr.length,
+            mode: "array",
+            data,
+        };
+    }
+
+    const args = [];
+    const where = [];
+
+    // select, with search by text support
+    if (key && typeof key === "string") {
+        args.push(key.toLowerCase());
+        where.push(searchQuery);
+    }
+
+    // pk
+    if (clsMeta.pk) {
+        where.push(`${clsMeta.pk} is not null`);
+    }
+
+    // filter by value
+    if (clsMeta.pk && typeof val === "string") {
+        args.push(val.split(","));
+        where.push(`${clsMeta.pk}=any($${args.length})`);
+    }
+
+    // filter
+    if (pg.pk?.[registry.table_name] && !cls && dataTypeID) {
+        where.push(
+            `id in (select ${pg.pgType[dataTypeID]?.includes("[]")
+                ? `unnest("${name}")`
+                : `"${name}"`
+            } from ${(registry.table_name).replace(/'/g, "''")})`
+        );
+    }
+
+    // order by value if not specified explicitly
+    const order = clsMeta.original.toLowerCase().includes("order by")
+        ? ""
+        : "order by 2";
+
+    const whereQuery = where.filter(Boolean).join(" and ") || "true";
+
+    args.push(limit);
+
+    let sqlSuggest = !cls
+        ? `${clsMeta.original}
+          WHERE EXISTS ( SELECT 1 FROM ${(registry.table_name).replace(
+            /'/g,
+            "''"
+        )} o 
+            WHERE ${pg.pgType[dataTypeID]?.includes("[]")
+            ? `c.id = ANY(o."${name}")`
+            : `o."${name}" IS NOT DISTINCT FROM c.id`
+        } ) and ${whereQuery || "true"}
+          ${order} LIMIT $${args.length}::bigint`
+        : `with c(id,text) as ( ${clsMeta.original} where ${whereQuery} ${order}) select * from c LIMIT $${args.length}::bigint`;
+
+    if (sqlSuggest.includes("{{parent}}")) {
+        args.push(parent || "");
+        sqlSuggest = sqlSuggest.replace(/(['"]?){{parent}}\1/gi, `$${args.length}`);
+    }
+
+    if (sqlSuggest.includes("{{uid}}")) {
+        args.push(uid || "0");
+        sqlSuggest = sqlSuggest.replace(/(['"]?){{uid}}\1/gi, `$${args.length}`);
+    }
+
+    const dataNew = await pg
+        .query(sqlSuggest, args)
+        .then((r) => r.rows || []);
+
+    // in case id / text = Boolean
+    const data = dataNew.filter(
+        (el) => Object.hasOwn(el, "id") && Object.hasOwn(el, "text")
+    );
+
+    data
+        .filter((el) => el.id === null)
+        .forEach((el) =>
+            Object.assign(el, { id: "null", text: "Показати порожні значення" })
+        );
+
+    // table:column + select
+    if (!cls) {
+        const { name: clsName = name, type = "select" } =
+            getColumnCLS(registry.table_name, name) || {};
+
+        await metaFormat(
+            {
+                rows: data,
+                table: registry.table_name,
+                cls: { text: clsName },
+                sufix: true,
+            },
+            pg
+        );
+
+        return {
+            time: Date.now() - time,
+            limit,
+            count: data.length,
+            total: clsMeta.count - 0,
+            mode: type === "cls" ? "array" : "sql",
+            db: clsMeta.db,
+            sql: process.platform === 'win32' ? sqlSuggest : undefined,
+            data: data.map((el) => ({
+                count: el.count,
+                id: el.id,
+                text: el.text_text || el.text,
+                ...(el.text_data || {}),
+            })),
+        };
+    }
+
+    return {
+        time: Date.now() - time,
+        limit,
+        count: data.length,
+        total: clsMeta.count - 0,
+        mode: "sql",
+        sql: process.platform === 'win32' ? sqlSuggest : undefined,
+        data,
+    };
+}