@opengis/fastify-table 2.5.0 → 2.5.2

package/dist/server/routes/file/index.js

@@ -7,7 +7,7 @@ import download from "./controllers/download.js";
 import exportTable from "./controllers/export.js";
 import uploadImage from "./controllers/uploadImage.js";
 import deleteFileAPI from "./controllers/delete.js";
-import { resizeSchema } from "./schema.js";
+import { resizeSchema, exportSchema } from "./schema.js";
 const tags = ["core", "file"];
 const { uploadPolicy = "L1" } = config;
 const publicParams = { config: { tags, policy: "L0" } };
@@ -15,7 +15,9 @@ const privateParams = { config: { tags, policy: uploadPolicy } };
 function plugin(app, opt = {}) {
     app.get("/files/*", publicParams, files);
     if (!app.hasRoute({ method: "GET", url: "/file/resize" })) {
-        app.get("/file/resize", {
+        app.route({
+            method: "GET",
+            url: "/file/resize",
             config: {
                 ...publicParams,
                 rateLimit: config.rateLimit
@@ -26,13 +28,26 @@ function plugin(app, opt = {}) {
                     : undefined,
             },
             schema: resizeSchema,
-        }, resize);
+            handler: resize,
+        });
     }
-    app.get("/api/resize-all", { config: { tags, role: "admin" }, schema: resizeSchema }, resizeAll);
+    app.route({
+        method: "GET",
+        url: "/api/resize-all",
+        config: { tags, role: "admin" },
+        schema: resizeSchema,
+        handler: resizeAll,
+    });
     app.post("/file/upload/*", privateParams, upload);
     app.post("/file/upload-image/*", privateParams, uploadImage);
     app.get("/file/download/*", publicParams, download);
     app.get("/file/delete/*", publicParams, deleteFileAPI);
-    app.get(`/api/export`, publicParams, exportTable);
+    app.route({
+        method: "GET",
+        url: "/api/export",
+        ...publicParams,
+        schema: exportSchema,
+        handler: exportTable,
+    });
 }
 export default plugin;

package/dist/server/routes/file/schema.d.ts

@@ -1,7 +1,7 @@
 declare const resizeSchema: {
-    type: string;
-    properties: {
-        querystring: {
+    querystring: {
+        type: string;
+        properties: {
             filepath: {
                 type: string;
             };
@@ -27,7 +27,30 @@ declare const resizeSchema: {
         };
     };
 };
+declare const exportSchema: {
+    querystring: {
+        type: string;
+        properties: {
+            limit: {
+                type: string;
+                minimum: number;
+            };
+            batchLimit: {
+                type: string;
+                minimum: number;
+            };
+            page: {
+                type: string;
+                minimum: number;
+            };
+            key: {
+                type: string;
+                pattern: string;
+            };
+        };
+    };
+};
 declare const _default: null;
 export default _default;
-export { resizeSchema };
+export { resizeSchema, exportSchema };
 //# sourceMappingURL=schema.d.ts.map

package/dist/server/routes/file/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../server/routes/file/schema.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWjB,CAAC;;AAEF,wBAAoB;AAEpB,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../server/routes/file/schema.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcjB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;CAUjB,CAAC;;AAEF,wBAAoB;AAEpB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC"}

package/dist/server/routes/file/schema.js

@@ -1,14 +1,28 @@
 const resizeSchema = {
-    type: 'object',
-    properties: {
-        querystring: {
-            filepath: { type: 'string' },
-            quality: { type: 'number', exclusiveMinimum: 0, maximum: 100 },
-            size: { type: 'string', pattern: '^((\\d{1,4})x(\\d{1,4})|(\\d{1,4})x|x(\\d{1,4}))$' },
-            w: { type: 'number', minimum: 1, maximum: 2048 },
-            h: { type: 'number', minimum: 1, maximum: 2048 },
+    querystring: {
+        type: "object",
+        properties: {
+            filepath: { type: "string" },
+            quality: { type: "number", exclusiveMinimum: 0, maximum: 100 },
+            size: {
+                type: "string",
+                pattern: "^((\\d{1,4})x(\\d{1,4})|(\\d{1,4})x|x(\\d{1,4}))$",
+            },
+            w: { type: "number", minimum: 1, maximum: 2048 },
+            h: { type: "number", minimum: 1, maximum: 2048 },
+        },
+    },
+};
+const exportSchema = {
+    querystring: {
+        type: "object",
+        properties: {
+            limit: { type: "number", minimum: 1 },
+            batchLimit: { type: "number", minimum: 1 },
+            page: { type: "number", minimum: 1 },
+            key: { type: "string", pattern: "^([\\d\\w_.-]+)$" },
         },
     },
 };
 export default null;
-export { resizeSchema };
+export { resizeSchema, exportSchema };

package/dist/server/routes/logger/controllers/utils/checkUserAccess.js

@@ -0,0 +1,22 @@
+import config from "../../../../../config.js";
+const { accessToken = "0NWcGQxKRP8AsRxD" } = config.auth || {};
+/**
+ *
+ * @summary check user access to logger interface - per admin user type or user group
+ * @returns {Object} message, status
+ */
+export default function checkUserAccess({ user = {}, token, }) {
+    if (token && token === accessToken) {
+        return { message: "access granted", status: 200 };
+    }
+    // console.log(user);
+    if (!user.user_type?.includes?.("admin") &&
+        !config?.local &&
+        !config.auth?.disable) {
+        return { message: "access restricted", status: 403 };
+    }
+    /* if (!['admin', 'superadmin']?.includes(user.user_type) && count === '0') {
+      return { message: 'access restricted', status: 403 };
+    } */
+    return { message: "access granted", status: 200 };
+}

package/dist/server/routes/logger/controllers/utils/getRootDir.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-console */
+import fs from "node:fs";
+import path from "node:path";
+import config from "../../../../../config.js";
+// import { existsSync } from 'fs';
+let logDir = null;
+export default function getRootDir() {
+    // absolute / relative path
+    if (logDir)
+        return logDir;
+    const file = ["config.json", "/data/local/config.json"].find((el) => fs.existsSync(el) ? el : null);
+    const root = file === "config.json" ? process.cwd() : "/data/local";
+    logDir = config.logDir || path.join(root, config.log?.dir || "log");
+    console.log({ logDir });
+    return logDir;
+    // windows debug support
+    /* const customLogDir = process.cwd().includes(':') ? 'c:/data/local' : '/data/local';
+    // docker default path
+    if (existsSync(customLogDir)) {
+      return path.join(customLogDir, config.folder || '', 'log');
+    }
+  
+    // non-docker default path
+    return path.join(config.root || '/data/local', config.folder || '', 'log'); */
+}

package/dist/server/routes/table/controllers/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../server/routes/table/controllers/search.ts"],"names":[],"mappings":"AAoIA,wBAA8B,MAAM,CAAC,EACnC,EAAqB,EACrB,KAAU,GACX,EAAE,GAAG;;;;;;GAmCL"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../../server/routes/table/controllers/search.ts"],"names":[],"mappings":"AAkJA,wBAA8B,MAAM,CAAC,EACnC,EAAqB,EACrB,KAAU,GACX,EAAE,GAAG;;;;;;GAmCL"}

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

@@ -11,7 +11,7 @@ async function getData({ pg = pgClients.client, tableName, query = {}, maxLimit,
         return null;
     }
     const { table, columns, meta } = loadTable;
-    const { pk, view } = await getMeta({ pg, table });
+    const { pk, view } = (await getMeta({ pg, table }).catch((err) => null)) || {};
     if (!pk && !view) {
         return null;
     }
@@ -20,14 +20,19 @@ async function getData({ pg = pgClients.client, tableName, query = {}, maxLimit,
     const order = cols.includes(orderColumn) && orderColumn?.length
         ? `order by ${orderColumn} ${query.desc || orderDir === "desc" ? "desc" : ""}`
         : "";
+    const args = [];
     const limit = Math.max(maxLimit - res.rows.length, 0);
-    // Math.max(query.offset - res.rows.length,0)
-    const offset = query.page && query.page > 0 ? ` offset ${(query.page - 1) * limit}` : "";
+    args.push(limit);
+    const offset = query.page && query.page > 0 ? (query.page - 1) * limit : 0;
+    args.push(offset);
+    if (meta?.search && query.key) {
+        args.push(`%${query.key}%`);
+    }
     const search1 = meta?.search && query.key
         ? `(${meta?.search
             .concat(meta?.title ? `,${meta?.title}` : "")
             .split(",")
-            .map((el) => `${el}::text ilike '%${query.key}%'`)
+            .map((el) => `${el}::text ilike $3`)
             .join(" or ")})`
         : "false";
     const where = [!pk ? "false" : "true", loadTable.query, search1].filter(Boolean);
@@ -40,23 +45,26 @@ async function getData({ pg = pgClients.client, tableName, query = {}, maxLimit,
         meta?.title ? `${meta.title} as title` : "",
     ]
         .filter((el) => el)
-        .join(",")} from ${table} t ${sqlTable} where ${where.join(" and ") || "true"} ${order} ${offset} limit ${limit}`;
+        .join(",")} from ${table} t ${sqlTable} where ${where.join(" and ") || "true"} ${order} limit $1 offset $2`;
     if (query.sql) {
         res.sql.push(q);
         return null;
     }
-    const rows = await pg.query(q).then((el) => el.rows || []);
+    const rows = await pg.query(q, args).then((r) => r.rows || []);
     const filtered = pg.queryCache
         ? await pg
-            .queryCache(`select count(*) from ${table} t ${sqlTable} where ${where.join(" and ") || "true"}`)
-            .then((el) => +(el?.rows[0]?.count || 0))
+            .queryCache(`select count(*) from ${table} t ${sqlTable} where ${where.join(" and ").replace(/\$3/g, "$1") || "true"}`, {
+            args: [meta?.search && query.key ? query.key : undefined].filter(Boolean),
+            table,
+        })
+            .then((r) => +(r?.rows[0]?.count || 0))
         : 0;
     const total = pg.queryCache
         ? await pg
             .queryCache(`select count(*) from ${table}`)
-            .then((el) => +(el?.rows[0]?.count || 0))
+            .then((r) => +(r?.rows[0]?.count || 0))
         : 0;
-    await metaFormat({ rows, table: tableName });
+    await metaFormat({ rows, table: tableName }, pg);
     res.total += +total;
     res.filtered += +filtered;
     rows.forEach((row) => {
@@ -83,7 +91,7 @@ export default async function search({ pg = pgClients.client, query = {}, }) {
         total: 0,
         filtered: 0,
     };
-    const maxLimit = Math.min(100, query.limit || "16");
+    const maxLimit = Math.min(100, +query.limit || 16);
     await sequence(tables, {
         pg,
         query,

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

@@ -68,7 +68,7 @@ export async function getTableColumnMeta({ table, template, column, selectName,
 export default async function suggest(req) {
     const time = Date.now();
     const { params, user, query = {}, pg: pg1 = pgClients.client } = req;
-    const { lang = "ua", parent = "" } = query;
+    const { lang = "ua", parent } = query;
     const debugMode = config.local ||
         user?.user_type?.includes?.("admin") ||
         process.env.NODE_ENV === "test" ||

package/dist/server/routes/table/functions/getData.d.ts

@@ -20,5 +20,5 @@ export default function dataAPI({ pg, params, table, id, headers, query, user, c
     accessQuery?: string;
     columns?: string[];
     isExport?: boolean;
-}, reply1?: FastifyReply, called?: any): Promise<any>;
+}, reply?: FastifyReply, called?: any): Promise<any>;
 //# sourceMappingURL=getData.d.ts.map

package/dist/server/routes/table/functions/getData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getData.d.ts","sourceRoot":"","sources":["../../../../../server/routes/table/functions/getData.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAwFzD,wBAA8B,OAAO,CACnC,EACE,EAAqB,EACrB,MAAM,EACN,KAAK,EACL,EAAE,EACF,OAAY,EACZ,KAAU,EACV,IAAS,EACT,YAAY,EACZ,YAAY,EACZ,KAAY,EACZ,UAAU,EACV,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,YAAY,EACrB,QAAgB,GACjB,EAAE;IACD,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,MAAM,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,GAAG,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,EACD,MAAM,CAAC,EAAE,YAAY,EACrB,MAAM,CAAC,EAAE,GAAG,gBAq3Bb"}
+{"version":3,"file":"getData.d.ts","sourceRoot":"","sources":["../../../../../server/routes/table/functions/getData.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAwFzD,wBAA8B,OAAO,CACnC,EACE,EAAqB,EACrB,MAAM,EACN,KAAK,EACL,EAAE,EACF,OAAY,EACZ,KAAU,EACV,IAAS,EACT,YAAY,EACZ,YAAY,EACZ,KAAY,EACZ,UAAU,EACV,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,gBAAgB,EAC7B,OAAO,EAAE,YAAY,EACrB,QAAgB,GACjB,EAAE;IACD,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,MAAM,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,GAAG,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,EACD,KAAK,CAAC,EAAE,YAAY,EACpB,MAAM,CAAC,EAAE,GAAG,gBA64Bb"}

package/dist/server/routes/table/functions/getData.js

@@ -54,13 +54,11 @@ function getOrder(queryOrder, queryDesc, defaultOrder, columnList, sqlColumns, i
 const checkInline = {};
 const maxLimit = 100;
 const defaultLimit = 20;
-export default async function dataAPI({ pg = pgClients.client, params, table, id, headers = {}, query = {}, user = {}, contextQuery, searchColumn, sufix = true, filterList, actions: actionsParam, accessQuery: accessQueryParam, columns: columnsParam, isExport = false, }, reply1, called) {
+export default async function dataAPI({ pg = pgClients.client, params, table, id, headers = {}, query = {}, user = {}, contextQuery, searchColumn, sufix = true, filterList, actions: actionsParam, accessQuery: accessQueryParam, columns: columnsParam, isExport = false, }, reply, called) {
     const time = Date.now();
     const timeArr = [Date.now()];
     const { uid } = user;
-    const reply = reply1 || mockReply;
     const method = "GET";
-    const checkQuery = (item) => user?.user_type === "superadmin" ? !item.includes("{{uid}}") : true;
     const paramsTable = params?.table || table;
     if (!paramsTable) {
         throw BadRequestError("not enough params: table");
@@ -210,14 +208,14 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
         !el.inline &&
         el?.sql?.replace &&
         !(isExport && el.export === false))
-        .map((el, i) => ` left join lateral (${el.sql.replace("{{uid}}", uid)}) ${el.name || `t${i}`} on 1=1 `)
+        .map((el, i) => ` left join lateral (${el.sql.replace("{{uid}}", `$${idx.uid}`)}) ${el.name || `t${i}`} on 1=1 `)
         ?.join("") || "";
     const cardSqlFiltered = objectId
         ? cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) || []
         : [];
     const cardSqlTable = cardSqlFiltered.length
         ? cardSqlFiltered
-            .map((el, i) => ` left join lateral (${el.sql.replace("{{uid}}", uid)}) ct${i}  on 1=1 `)
+            .map((el, i) => ` left join lateral (${el.sql.replace("{{uid}}", `$${idx.uid}`)}) ct${i}  on 1=1 `)
             .join("\n") || ""
         : "";
     const sqlInline = loadTable?.sql
@@ -277,21 +275,40 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
     const keyQuery = query?.key && (loadTable?.key || tokenData?.key) && !objectId
         ? `${loadTable?.key || tokenData?.key}=$1`
         : null;
+    const idx = {};
+    const args = (objectId ? [objectId] : null) ||
+        (query?.key && loadTable.key ? [query.key] : []);
+    if (args[0]) {
+        Object.assign(idx, { id: 1 });
+    }
+    const isSingle = !!idx.id;
     const limit = (called
         ? query?.limit || defaultLimit
         : Math.min(maxLimit, +(query?.limit || defaultLimit))) || defaultLimit;
-    const offset = query?.page && query?.page > 0 && !objectId
-        ? ` offset ${(query?.page - 1) * limit}`
-        : "";
+    args.push(limit);
+    Object.assign(idx, { limit: idx.id ? 2 : 1 });
+    const offset = query?.page && query?.page > 0 && !objectId ? (query?.page - 1) * limit : 0;
+    args.push(offset);
+    Object.assign(idx, { offset: idx.id ? 3 : 2 });
     const order = getOrder(query?.order, query?.desc, loadTable?.order, columnList, loadTable?.sqlColumns, !!called);
+    const isSearchable = Array.isArray(loadTable?.meta?.search) &&
+        loadTable.meta.search.length &&
+        query?.search &&
+        !isSingle;
+    if (isSearchable) {
+        args.push(`%${query.search.replace(/%/g, "\\%")}%`);
+        Object.assign(idx, { search: Object.keys(idx).length + 1 });
+    }
+    if (meta?.bbox && query?.polyline) {
+        args.push(query.polyline);
+        Object.assign(idx, { polyline: Object.keys(idx).length + 1 });
+    }
     if (config.trace)
         console.log(order);
-    const search = loadTable?.meta?.search && query?.search
+    const search = isSearchable
         ? `(${loadTable?.meta?.search
             ?.split(",")
-            ?.map((el) => `${el} ilike '%${query?.search
-            .replace(/%/g, "\\%")
-            .replace(/'/g, "''")}%'`)
+            ?.map((el) => `${el} ilike $${idx.search}`)
             .join(" or ")})`
         : null;
     const queryBbox = query?.bbox
@@ -301,7 +318,7 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
             ?.map((el) => el - 0)
         : [];
     const queryPolyline = meta?.bbox && query?.polyline
-        ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline('${query?.polyline}')),${meta.bbox})`
+        ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline($${idx.polyline})),${meta.bbox})`
         : undefined;
     const bbox = meta?.bbox && queryBbox.filter((el) => !Number.isNaN(el))?.length === 4
         ? `${meta.bbox} && 'box(${queryBbox[0]} ${queryBbox[1]},${queryBbox[2]} ${queryBbox[3]})'::box2d `
@@ -318,7 +335,7 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
         ? await handlebars.compile(params?.query)({ user, uid })
         : undefined;
     const where = [
-        objectId ? ` "${pk}" = $1` : null,
+        objectId ? ` "${pk}" = $${idx.id}` : null,
         keyQuery,
         loadTable?.query,
         tokenData?.query,
@@ -330,40 +347,36 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
         queryPolyline,
         interfaceQuery,
         interfaceQuery1,
-    ]
-        .filter(Boolean)
-        .filter((el) => checkQuery(el));
-    const q = `select  ${pk ? `"${pk}" as id,` : ""} 
-                     ${objectId || query?.key
-        ? "*"
-        : columnsParam || sqlColumns || cols || "*"} 
-                     ${metaCols}
-                     ${dbColumns.filter((el) => pg.pgType?.[el.dataTypeID] === "geometry").length && !columnsParam
+    ].filter(Boolean);
+    const q1 = `select  ${pk ? `"${pk}" as id,` : ""} 
+  ${objectId || query?.key ? "*" : columnsParam || sqlColumns || cols || "*"} 
+  ${metaCols}
+  ${dbColumns.filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
+        .length && !columnsParam
         ? `,${dbColumns
             .filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
             .map((el) => `st_asgeojson("${el.name.replace(/'/g, "''")}")::json as "${el.name.replace(/'/g, "''")}"`)
             .join(",")}`
         : ""} 
-                     from (select * ${sql
+  from (select * ${sql
         ?.filter((el) => el.inline && !(isExport && el.export === false))
         .map((el) => `,(${el.sql})`)
         .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t  ${sqlTable} ) t 
                       
-                     ${objectId ? cardSqlTable : ""} 
-                     where ${where.join(" and ") || "true"} 
-                     ${order} ${offset} limit ${limit}`.replace(/{{uid}}/g, uid);
+  ${objectId ? cardSqlTable : ""} 
+  where ${where.join(" and ") || "true"} 
+  ${order} limit $${idx.limit} offset $${idx.offset}`;
+    if (q1.includes("{{uid}}")) {
+        args.push(uid || "");
+        Object.assign(idx, { uid: Object.keys(idx).length + 1 });
+    }
+    const q = q1.replace(/{{uid}}/g, `$${idx.uid}`);
     if (config.trace)
         console.log(q);
     if (query?.sql === "1") {
         return q;
     }
-    const { rows = [] } = await pg
-        .query(q, (objectId ? [objectId] : null) ||
-        (query?.key && loadTable.key ? [query?.key] : []))
-        .catch((err) => {
-        console.error(err.toString());
-        throw err;
-    });
+    const rows = await pg.query(q, args).then((r) => r.rows || []);
     if (!rows.length &&
         headers?.referer?.includes?.("/card/") &&
         headers?.referer?.includes?.(templateName)) {
@@ -395,17 +408,38 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
             });
         });
     }
+    const idx1 = {};
+    const args1 = [];
+    if (idx.search) {
+        args1.push(args[idx.search - 1]);
+        Object.assign(idx1, { search: Object.keys(idx1).length + 1 });
+    }
+    if (idx.uid) {
+        args1.push(args[idx.uid - 1]);
+        Object.assign(idx1, { uid: Object.keys(idx1).length + 1 });
+    }
+    if (idx.polyline) {
+        args1.push(args[idx.polyline - 1]);
+        Object.assign(idx1, { polyline: Object.keys(idx1).length + 1 });
+    }
+    const search1 = idx.search
+        ? `(${loadTable.meta.search
+            .split(",")
+            .map((el) => `${el} ilike $${idx1.search}`)
+            .join(" or ")})`
+        : null;
+    const queryPolyline1 = idx.polyline
+        ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline($${idx1.polyline})),${meta.bbox})`
+        : undefined;
     const filterWhere = [
         fData.q,
-        search,
+        search1,
         bbox,
-        queryPolyline,
+        queryPolyline1,
         interfaceQuery,
         loadTable?.query,
         tokenData?.query,
-    ]
-        .filter(Boolean)
-        .filter((el) => checkQuery(el));
+    ].filter(Boolean);
     const aggColumns = columns
         .filter((el) => el.agg)
         .reduce((acc, curr) => Object.assign(acc, { [curr.name]: curr.agg }), {});
@@ -416,21 +450,20 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
     }))
         .filter((el) => ["numeric", "double precision"].includes(el.type) && aggColumns[el.name]);
     const qCount = `select 
-            count(*)::int as total,  
-            count(*) FILTER(WHERE ${filterWhere.join(" and ") || "true"})::int as filtered
-            ${aggregates.length
+  count(*)::int as total,  
+  count(*) FILTER(WHERE ${filterWhere.join(" and ") || "true"})::int as filtered
+  ${aggregates.length
         ? `,${aggregates
             .map((el) => `${aggColumns[el.name]}(${el.name}) FILTER(WHERE ${filterWhere.join(" and ") || "true"}) as ${el.name}`)
             .join(",")}`
         : ""}
-            from (select * ${sql
+  from (select * ${sql
         ?.filter((el) => el.inline)
         .map((el) => `,(${el.sql})`)
         .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t ${sqlTable})t 
-            where ${[loadTable?.query, tokenData?.query, accessQuery, contextQuery]
+  where ${[loadTable?.query, tokenData?.query, accessQuery, contextQuery]
         .filter(Boolean)
-        .filter((el) => checkQuery(el))
-        .join(" and ") || "true"} `.replace(/{{uid}}/g, uid);
+        .join(" and ") || "true"} `.replace(/{{uid}}/g, `$${idx1.uid}`);
     if (query?.sql === "2") {
         return qCount;
     }
@@ -438,6 +471,7 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
         ? { total: rows.length, filtered: rows.length }
         : await pg
             .queryCache?.(qCount, {
+            args: args1,
             table: loadTable?.table || tokenData?.table,
             time: 5,
         })

package/dist/server/routes/table/index.js

@@ -32,7 +32,8 @@ function plugin(app, opt = {}) {
         },
         schema: suggestSchema,
     }, suggest);
-    app.get("/data/:table/:id?", { config: { tags, policy }, schema: tableSchema }, data);
+    app.get("/data/:table/:id?", { config: { tags, policy, allowSql: true }, schema: tableSchema }, // query.polyline support w/ allowSql
+    data);
     app.get("/table-data/:table", { config: { tags, auth: "creds", policy: "L2" }, schema: tableDataSchema }, data);
     app.get("/table-data/:table/:id", { config: { tags, policy }, schema: tableDataIdSchema }, cardData);
     app.get("/data-info/:id?", { config: { tags, policy }, schema: tableSchema }, dataInfo);

package/dist/server/routes/table/schema.d.ts

@@ -4,11 +4,11 @@ declare const tableDataSchema: {
         querystring: {
             limit: {
                 type: string;
-                pattern: string;
+                minimum: number;
             };
             page: {
                 type: string;
-                pattern: string;
+                minimum: number;
             };
             order: {
                 type: string;
@@ -36,7 +36,6 @@ declare const tableDataSchema: {
             };
             sql: {
                 type: string;
-                pattern: string;
             };
         };
         params: {
@@ -57,11 +56,11 @@ declare const tableSchema: {
         querystring: {
             limit: {
                 type: string;
-                pattern: string;
+                minimum: number;
             };
             page: {
                 type: string;
-                pattern: string;
+                minimum: number;
             };
             order: {
                 type: string;
@@ -85,7 +84,6 @@ declare const tableSchema: {
             };
             sql: {
                 type: string;
-                pattern: string;
             };
         };
         params: {
@@ -106,11 +104,11 @@ declare const searchSchema: {
         querystring: {
             page: {
                 type: string;
-                pattern: string;
+                minimum: number;
             };
             limit: {
                 type: string;
-                pattern: string;
+                minimum: number;
             };
             order: {
                 type: string;
@@ -161,11 +159,9 @@ declare const suggestSchema: {
             };
             sql: {
                 type: string;
-                pattern: string;
             };
             count: {
                 type: string;
-                pattern: string;
             };
         };
         params: {};

package/dist/server/routes/table/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../server/routes/table/schema.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBhB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBlB,CAAC;AAEF,QAAA,MAAM,UAAU;;;;;;;;;;;;;;CAQf,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;CAOjB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;CAUtB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;CAQtB,CAAC;AAEF,OAAO,EACL,eAAe,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,iBAAiB,GAC1H,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../server/routes/table/schema.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBhB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBlB,CAAC;AAEF,QAAA,MAAM,UAAU;;;;;;;;;;;;;;CAQf,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;CAOjB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;CAUtB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;CAQtB,CAAC;AAEF,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,UAAU,EACV,YAAY,EACZ,iBAAiB,GAClB,CAAC"}