@opengis/fastify-table 2.0.18 → 2.0.20

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

@@ -1,11 +1,40 @@
-import { readFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import config from "../../../../config.js";
 import loadTemplate from "./loadTemplate.js";
-import { existsSync } from "node:fs";
-async function getColumnCLSData(name) {
-    const exists = existsSync("module/cls.json");
-    const json = exists
-        ? JSON.parse((await readFile("module/cls.json", "utf-8")) || "{}")
-        : {};
+import getTemplates from "./getTemplates.js";
+import getTemplateSync from "./getTemplateSync.js";
+const cls = getTemplates("cls")
+    .map((el) => el[0])
+    .reduce((acc, curr) => ({ ...acc, [curr]: curr }), {});
+const select = getTemplates("select")
+    .map((el) => el[0])
+    .reduce((acc, curr) => ({ ...acc, [curr]: curr }), {});
+const exists = existsSync("module/cls.json");
+const json = exists
+    ? JSON.parse(readFileSync("module/cls.json", "utf-8") || "{}")
+    : {};
+Object.assign(json, cls, select);
+function getColumnCLSData(table, name) {
+    const type = select[`${table}.${name}`] || select[name || ""]
+        ? "select"
+        : json[`${table}.${name}`] || json[name || ""]
+            ? "cls"
+            : null;
+    if (!type)
+        return null;
+    // name = table + column or name = column
+    if (!name?.includes(".") && (json[`${table}.${name}`] || json[name || ""])) {
+        const clsName = json[`${table}.${name}`] || json[name || ""];
+        const result = { name: clsName, type };
+        if (type === "select") {
+            const data = getTemplateSync("select", clsName);
+            Object.assign(result, {
+                sql: typeof data === "string" ? data : data?.sql,
+            });
+        }
+        return result;
+    }
+    // name = table
     return name
         ? Object.keys(json)
             .filter((key) => key.startsWith(`${name}.`))
@@ -15,11 +44,11 @@ async function getColumnCLSData(name) {
         }), {})
         : json;
 }
-export default async function getColumnCLS(name) {
-    const key = [name, "column-cls"].filter(Boolean).join("-");
-    if (loadTemplate[key]) {
+export default function getColumnCLS(table, name) {
+    const key = [name, table, "column-cls"].filter(Boolean).join("-");
+    if (loadTemplate[key] && !config.local) {
         return loadTemplate[key];
     }
-    loadTemplate[key] = await getColumnCLSData(name);
+    loadTemplate[key] = getColumnCLSData(table, name);
     return loadTemplate[key];
 }

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

@@ -7,8 +7,8 @@ export default function getTemplateDir(type) {
     const arr = Array.isArray(type)
         ? type.map((el) => getTemplatePath(el)).flat()
         : getTemplatePath(type);
-    if (!loadTemplate[type]) {
-        loadTemplate[type] = arr.filter((el) => fs.existsSync(el[1]));
+    if (!loadTemplate[type.toString()]) {
+        loadTemplate[type.toString()] = arr.filter((el) => fs.existsSync(el[1]));
     }
-    return loadTemplate[type];
+    return loadTemplate[type.toString()];
 }

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

@@ -1,5 +1,6 @@
 import { handlebars } from "../../../../helpers/index.js";
 import getTemplate from "../getTemplate.js";
+import getTemplates from "../getTemplates.js";
 import getSelectVal from "./getSelectVal.js";
 import pgClients from "../../../pg/pgClients.js";
 export default async function metaFormat({ rows: original, table, cls = {}, htmls = {}, sufix = true, reassign = true, }, pg = pgClients.client) {
@@ -11,11 +12,21 @@ export default async function metaFormat({ rows: original, table, cls = {}, html
         name: el,
         data: loadTable?.meta?.cls[el],
     }));
+    const list = getTemplates(["cls", "select"]).map((el) => el[0]);
+    const columnNameAsCls = Object.keys(original?.[0] || {})
+        .filter((key) => list.includes(`${table}.${key}`) || list.includes(key))
+        .map((key) => ({
+        name: key,
+        data: list.find((clsName) => [key, `${table}.${key}`].includes(clsName)),
+    }));
     const htmlCols = Object.keys(htmls || {})
         .map((key) => ({ name: key, html: htmls[key] }))
         .concat(loadTable?.columns?.filter?.((e) => e.name && e.html && e.format && ["html", "slot"].includes(e.format)) || []);
     if (!original?.length ||
-        (!selectCols?.length && !metaCls?.length && !htmlCols?.length))
+        (!selectCols?.length &&
+            !metaCls?.length &&
+            !columnNameAsCls.length &&
+            !htmlCols?.length))
         return original;
     const rows = reassign ? original : JSON.parse(JSON.stringify(original));
     // html && slot (vue component) format
@@ -31,7 +42,10 @@ export default async function metaFormat({ rows: original, table, cls = {}, html
         }));
     }));
     // cls & select format
-    await Promise.all(selectCols.concat(metaCls)?.map(async (attr) => {
+    await Promise.all(selectCols
+        .concat(metaCls)
+        .concat(columnNameAsCls)
+        ?.map(async (attr) => {
         const values = [
             ...new Set(rows?.map((el) => el[attr.name]).flat()),
         ].filter((el) => (typeof el === "boolean" ? true : el));
@@ -52,9 +66,7 @@ export default async function metaFormat({ rows: original, table, cls = {}, html
             }
             else {
                 Object.assign(el, {
-                    [val?.color ? `${attr.name}_data` : `${attr.name}_text`]: val.color
-                        ? val
-                        : val.text || val,
+                    [val?.color ? `${attr.name}_data` : `${attr.name}_text`]: val.color ? val : val.text || val,
                 });
             }
         });

package/dist/server/routes/table/controllers/filter.js

@@ -18,6 +18,9 @@ export default async function filterAPI(req, reply, iscalled) {
     if (!table) {
         return { status: 404, message: "not found" };
     }
+    if (!pg.pk?.[table]) {
+        return { status: 404, message: "table not found" };
+    }
     const sqlTable = sql
         ?.filter?.((el) => !el?.disabled && el?.sql?.replace)
         ?.map?.((el, i) => ` left join lateral (${el.sql.replace("{{uid}}", user?.uid)}) ${el.name || `t${i}`} on 1=1 `)

package/dist/server/routes/table/controllers/suggest.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
-import { config, getPG, getTemplate, getSelectMeta, getMeta, applyHook, getSelectVal, logger, getSelect, } from "../../../../utils.js";
+import { config, getPG, getTemplate, getSelectMeta, getMeta, applyHook, getSelectVal, logger, getSelect, metaFormat, getColumnCLS, } from "../../../../utils.js";
 const limit = 50;
 const headers = {
     "Access-Control-Allow-Origin": "*",
@@ -208,6 +208,27 @@ export default async function suggest(req) {
     // const { rows: dataNew1 } = dataNew.length < limit ? await pg.query(sqlSuggest, query.key ? [`${query.key}`] : []) : {};
     // const ids = dataNew.map((el) => el.id);
     const data = dataNew.filter((el) => el.id && el.text);
+    if (tableName && column) {
+        const { name = column, type = "select" } = getColumnCLS(tableName, column) || {};
+        await metaFormat({
+            rows: data,
+            table: tableName,
+            cls: { text: name },
+            sufix: true,
+        });
+        return {
+            time: Date.now() - time,
+            limit: Math.min(query.limit || meta.limit || limit, limit),
+            count: data.length,
+            total: meta.count - 0,
+            mode: type === "cls" ? "array" : "sql",
+            db: meta.db,
+            data: data.map((el) => ({
+                count: el.count,
+                ...(el.text_data || {}),
+            })),
+        };
+    }
     if (query.sel) {
         const clsData = await getSelectVal({
             pg,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "2.0.18",
+  "version": "2.0.20",
   "type": "module",
   "description": "core-plugins",
   "keywords": [