@opengis/gis 0.2.168 → 0.2.170

package/server/routes/map/{controllers → functions}/mapFormat.js

@@ -1,3 +1,4 @@
+import { BadRequestError } from '@opengis/fastify-table/errors.js';
 import {
   pgClients, getTemplate, handlebars, metaFormat,
   getMeta,
@@ -15,11 +16,11 @@ function getLayerTableQuery({
   const q = `SELECT
   ${pk} as "id"
   ,'${el.key}' as "key"
-  ${nogeom ? '' : `,st_asgeojson(${srid !== 4326 ? `st_transform(${geom}, 4326)` : geom})::json as geom`}, ${srid !== 4326 ? `st_transform(${geom}, 4326)` : geom}::box2d as box2d, ${columns ? `row_to_json(t)` : 'null'} as "data" 
-  ${point ? `,st_distance(${el.srid !== 4326 ? `st_transform(${geom}, 4326)` : geom},'${point} ') as distance` : ''} 
-  FROM ${table} t WHERE ${tableQuery || '1 = 1'} and st_isvalid(${geom}) and st_srid(${geom}) > 0
+  ${nogeom ? '' : `,st_asgeojson(${srid !== 4326 ? `st_transform(${geom || 'geom'}, 4326)` : (geom || 'geom')})::json as geom`}, ${srid !== 4326 ? `st_transform(${geom || 'geom'}, 4326)` : (geom || 'geom')}::box2d as box2d, ${columns ? `row_to_json(t)` : 'null'} as "data" 
+  ${point ? `,st_distance(${el.srid !== 4326 ? `st_transform(${geom || 'geom'}, 4326)` : (geom || 'geom')},'${point} ') as distance` : ''} 
+  FROM ${table} t WHERE ${tableQuery || '1 = 1'} and st_isvalid(${geom || 'geom'}) and st_srid(${geom || 'geom'}) > 0
   and ${point
-      ? `case when ST_GeometryType(${geom}) in ('ST_Polygon','ST_MultiPolygon', 'ST_LineString','ST_MultiLineString', 'ST_MultiPoint', 'ST_Point') then st_intersects(${srid !== 4326 ? `st_transform(${geom}, 4326)` : geom}, ${buffer}) else false end`
+      ? `case when ST_GeometryType(${geom || 'geom'}) in ('ST_Polygon','ST_MultiPolygon', 'ST_LineString','ST_MultiLineString', 'ST_MultiPoint', 'ST_Point') then st_intersects(${srid !== 4326 ? `st_transform(${geom || 'geom'}, 4326)` : (geom || 'geom')}, ${buffer}) else false end`
       : '1=1'}
   and ${id ? `${pk}='${id.replace(/'/g, "")}'` : '2=2'} 
   ${point ? 'order by distance' : ''} limit 10`;
@@ -53,14 +54,14 @@ async function getLayersData({
       radius,
     }, pg)
     : cartocss.config
-        .filter((el, idx, arr) => el.key && el.table && pg.pk?.[el.table]
-          && arr.findIndex(item => item.table === el.table && item.query === el.query) === idx)
-        .map(el => getLayerTableQuery({
-          el, id, point, nogeom, radius,
-        }, pg)).join(' union all ');
+      .filter((el, idx, arr) => el.key && el.table && pg.pk?.[el.table]
+        && arr.findIndex(item => item.table === el.table && item.query === el.query) === idx)
+      .map(el => getLayerTableQuery({
+        el, id, point, nogeom, radius,
+      }, pg)).join(' union all ');
 
   // console.time(q);
-  const rows = await pg.query(q).then(el => el.rows || []);
+  const rows = await pg.query(q).then(r => r.rows || []);
   // console.timeEnd(q);
 
   if (!rows.length) {
@@ -96,13 +97,13 @@ async function getLayersData({
 }
 
 async function getTableData({
-  service, layer, id, user, nogeom,
+  service, layer, id, uid, nogeom,
 }, pg = pgClients.client) {
   const {
     source_path: tname, card, template,
   } = service || {};
 
-  const columns = (card || []).filter((col) => (user?.uid ? true : !col.is_admin));
+  const columns = (card || []).filter((col) => (uid ? true : !col.is_admin));
 
   if (!tname) {
     return { error: 'missing source_path', code: 400 };
@@ -125,7 +126,7 @@ async function getTableData({
   const rows = await pg.query(
     `SELECT ${pk} as "id", ${!nogeom ? 'st_asgeojson(geom)::json as geom, geom::box2d as box2d' : ''} ${!nogeom && filteredColumns?.length > 0 ? ',' : ''}  ${filteredColumns.map((n) => `"${n}"`).join(', ')} FROM ${tname} WHERE ${pk} = $1`,
     [id],
-  ).then(el => el.rows || []);
+  ).then(r => r.rows || []);
 
   if (!rows.length) {
     return { error: 'object not found', code: 404 };
@@ -136,7 +137,7 @@ async function getTableData({
     .reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
 
   const htmlTemplate = pg?.pk?.['admin.templates'] && service?.card_mode === 'html'
-    ? await pg.query('select body from admin.templates where name=$1 limit 1', [template || layer]).then(el => el.rows?.[0]?.body)
+    ? await pg.query('select body from admin.templates where name=$1 limit 1', [template || layer]).then(r => r.rows?.[0]?.body)
     : null;
 
   return {
@@ -148,44 +149,40 @@ async function getTableData({
   };
 }
 
-export default async function mapFormat({ pg = pgClients.client, query = {}, user }, reply) {
-  const {
-    layer, id, lat, lng, nogeom, radius = 50,
-  } = query;
-
+export default async function mapFormat({ layer, id, lat, lng, nogeom, radius = 50, uid }, pg = pgClients.client) {
   const t1 = Date.now();
 
   if (!layer) {
-    return reply.status(400).send({ error: 'not enough query params: layer', code: 400 });
+    throw BadRequestError('not enough query params: layer');
   }
 
-  const service = await getTemplate('layer', layer) || (pg.pk?.['gis.services'] ? await pg.query('SELECT * FROM gis.services WHERE service_id = $1', [layer]).then(el => el.rows[0]) : null);
-  const cartocss = pg.pk?.['gis.cartocss'] ? await pg.query('SELECT * FROM gis.cartocss WHERE cartocss_id = $1', [layer]).then(el => el.rows[0]) : null;
+  const service = await getTemplate('layer', layer) || (pg.pk?.['gis.services'] ? await pg.query('SELECT * FROM gis.services WHERE service_id = $1', [layer]).then(r => r.rows[0]) : null);
+  const cartocss = pg.pk?.['gis.cartocss'] ? await pg.query('SELECT * FROM gis.cartocss WHERE cartocss_id = $1', [layer]).then(r => r.rows[0]) : null;
 
   if (!cartocss && !id) {
-    return reply.status(400).send({ error: 'not enough query params: id', code: 400 });
+    throw BadRequestError('not enough query params: id');
   }
 
   if (cartocss && !(cartocss.config?.length || cartocss.card_table)) {
-    return reply.status(400).send({ error: 'invalid layer settings: empty config', code: 400 });
+    throw BadRequestError('invalid layer settings: empty config');
   }
 
   if (cartocss && !(lat && lng) && !id) {
-    return reply.status(400).send({ error: 'not enough query params: lat and lng / id', code: 400 });
+    throw BadRequestError('not enough query params: lat and lng / id');
   }
 
   const {
-    ids, rows, data, columns, classifiers, tname, template, error, code = 500, htmlTemplate,
+    ids, rows, data, columns, classifiers, tname, template, error, htmlTemplate,
   } = cartocss
       ? await getLayersData({
         cartocss, id, lng, lat, radius, nogeom,
       }, pg)
       : await getTableData({
-        service, layer, id, user, nogeom,
+        service, layer, id, uid, nogeom,
       }, pg);
 
   if (error) {
-    return reply.status(code).send({ error, code });
+    throw new Error(error);
   }
 
   rows.forEach(row => Object.assign(row, { box2d: undefined, bounds: row.box2d ? row.box2d.replace(/[A-Z\)\(]+/g, '').split(/[ ,]+/).map(el => el - 0) : null }));

package/server/routes/map/{controllers → functions}/mapTiles.js

@@ -1,30 +1,37 @@
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { readFile, stat, mkdir, writeFile } from 'node:fs/promises';
+import {
+    readFile, stat, mkdir, writeFile,
+} from 'node:fs/promises';
 
-import Sphericalmercator from '@mapbox/sphericalmercator';
+import { SphericalMercator } from '@mapbox/sphericalmercator';
 
-import { getTemplate, pgClients, getFilterSQL, getMeta } from '@opengis/fastify-table/utils.js';
+const mercator = new SphericalMercator({ size: 256 });
+
+import {
+    getTemplate, pgClients, getFilterSQL, getMeta,
+} from '@opengis/fastify-table/utils.js';
 
 import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 
 const limit = 3000;
-const mercator = new Sphericalmercator({ size: 256 });
+
 const types = { point: 'ST_Point', polygon: 'ST_Polygon,ST_MultiPolygon' };
 const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by', 'created_at', 'updated_by', 'updated_at'];
 
-export default async function mapTiles({ pg = pgClients.client, params = {}, query = {}, unittest }, reply) {
-    const { slug, y, z } = params;
-    const { sql, nocache, filter, pointZoom, type, layers, layer } = query;
-    const x = params.x?.split?.('.')?.[0] - 0;
+const unittest = process.env.NODE_ENV === 'test' || process.env.VITEST;
 
+export default async function mapTiles({
+    slug, x, y, z, sql, nocache, filter, pointZoom, type, layers, layer,
+}, pg = pgClients.client) {
     if (!slug) {
-        return reply.status(400).send('not enough params: slug');
+        throw BadRequestError('not enough params: slug');
     }
 
     if (!x || !y || !z) {
-        return reply.status(400).send('not enough params: xyz');
+        throw BadRequestError('not enough params: xyz');
     }
 
     const bbox = mercator.bbox(+y, +x, +z, false);
@@ -39,7 +46,7 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
 
     const filepath = path.join(
         rootFolder,
-        `/map/vtile/${slug}/${hash ? `${createHash('md5').update(hash).digest('hex')}/` : ''}${z}/${x}/${y}.pbf`
+        `/map/vtile/${slug}/${hash ? `${createHash('md5').update(hash).digest('hex')}/` : ''}${z}/${x}/${y}.pbf`,
     );
 
     if (existsSync(filepath) && z < 13 && !nocache && !sql && !unittest) {
@@ -47,14 +54,14 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
         const ageInMs = Date.now() - birthtimeMs;
         if (ageInMs < 86400000) {
             const buffer = await readFile(filepath);
-            return reply.status(200).headers(headers).send(buffer);
+            return { headers, data: buffer };
         }
     }
 
     const loadTemplate = await getTemplate('map', slug);
 
     if (!loadTemplate) {
-        return reply.status(404).send('map not found');
+        throw NotFoundError('map not found');
     }
 
     const index = loadTemplate?.find?.(el => el[0].split('.').shift() === 'index')?.[1];
@@ -64,22 +71,24 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
         : loadTemplate?.filter?.(el => el[0].split('.').shift() !== 'index')?.map(el => ({ ...el[1], id: el[0].replace('.yml', '').replace('.json', '') }));
 
     if (!layers1?.length) {
-        return reply.status(404).send('map layers not found');
+        throw NotFoundError('map layers not found');
     }
 
     layers1.forEach(el => Object.assign(el, { name: el.name || el.id }));
 
-    const layers2 = layers1.filter(el => el.name && el.source_path).filter(el => layers ? layers.includes(el.name) : true).filter(el => layer ? el.name === layer : true);
+    const layers2 = layers1.filter(el => el.name && el.source_path).filter(el => (layers ? layers.includes(el.name) : true)).filter(el => (layer ? el.name === layer : true));
 
     if (!layers2.length) {
-        return reply.status(404).send('map layers sources not provided / invalid query params');
+        throw NotFoundError('map layers sources not provided / invalid query params');
     }
 
     const allFilters = loadTemplate.widgets?.filter?.(el => el.type === 'filters') || [];
-    const { filters: filterList = [], layer_id: layerId } = allFilters.find(el => layer ? el.config?.layer_id === layer : el.default)?.config || allFilters[0]?.config || {};
+    const { filters: filterList = [], layer_id: layerId } = allFilters.find(el => (layer ? el.config?.layer_id === layer : el.default))?.config || allFilters[0]?.config || {};
 
     const q = (await Promise.all(layers2.map(async (layer) => {
-        const { source_path: source, id, name, style, geometry_type: gt, query: lquery, geometry_column: gCol } = layer;
+        const {
+            source_path: source, id, name, style, geometry_type: gt, query: lquery, geometry_column: gCol,
+        } = layer;
         const loadTable = await getTemplate('table', source);
 
         const table = loadTable?.table || source;
@@ -89,7 +98,9 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
         if (!columns?.length) return null;
 
         const pk = pg.pk?.[table] || loadTable?.key;
-        const fData = filter && layerId === name ? await getFilterSQL({ pg, table: source, filterList, filter }) : {};
+        const fData = filter && layerId === name ? await getFilterSQL({
+            pg, table: source, filterList, filter,
+        }) : {};
 
         const geomCol = parseInt(z, 10) < parseInt(pointZoom || '0', 10) || (style?.centroid && gt === 'point')
             ? `ST_Centroid(${geom})`
@@ -98,11 +109,9 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
         const columnsFiltered = columns
             .filter(el => !['json', 'geometry'].includes(pg.pgType?.[el.dataTypeID]) && !systemColumns.includes(el.name));
 
-        const props = columnsFiltered.map(el => {
-            return el.type?.[0] === '_'
-                ? `${el.name}[1] as ${el.name}`
-                : `${el.name}${['int4'].includes(el.type) ? '::text' : ''}`;
-        });
+        const props = columnsFiltered.map(el => (el.type?.[0] === '_'
+            ? `${el.name}[1] as ${el.name}`
+            : `${el.name}${['int4'].includes(el.type) ? '::text' : ''}`));
 
         return `SELECT ST_AsMVT(q, '${(id || name).replace(/'/g, "''")}', 4096, 'geom','row') as tile
                       FROM (
@@ -129,8 +138,8 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
                       ) q`;
     }))).filter(el => el).join(' union all ');
 
-    if (sql === '1') return q;
-    if (sql === '2') return filepath.replace(/\\/g, '/');
+    if (sql === 1) return q;
+    if (sql === 2) return filepath.replace(/\\/g, '/');
 
     const tile = await pg.query(q);
 
@@ -138,9 +147,9 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
         console.log(slug, q);
     }
 
-    if (sql === '3') return tile.rows.map((el) => el.tile);
+    if (sql === 3) return tile.rows.map((el) => el.tile);
 
-    if (sql === '4') return tile.rows.map((el) => el.tile);
+    if (sql === 4) return tile.rows.map((el) => el.tile);
 
     const buffer = Buffer.concat(tile.rows.map((el) => Buffer.from(el.tile)));
 
@@ -149,5 +158,5 @@ export default async function mapTiles({ pg = pgClients.client, params = {}, que
         await writeFile(filepath, buffer, 'binary');
     }
 
-    return reply.status(200).headers(headers).send(buffer);
-}
+    return { headers, data: buffer };
+}

package/server/routes/map/{controllers → functions}/maps.js

@@ -7,10 +7,10 @@ const list = arr.map(el => {
     return { name, slug: el[0] };
 });
 
-export default async function mapList(req, reply) {
+export default async function mapList() {
     if (!arr.length) {
-        return reply.status(200).send([]);
+        return [];
     }
 
-    return reply.status(200).send(list);
+    return list;
 }

package/server/routes/map/{controllers → functions}/marker_icon.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'url';
+import { fileURLToPath } from 'node:url';
 
 async function downloadImage(url, file) {
   const resp = await fetch(url);

package/server/routes/map/{controllers → functions}/parseGeoFile.js

@@ -1,3 +1,5 @@
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+
 const GEOMETRY_TYPES = new Set([
   'Point',
   'MultiPoint',
@@ -50,20 +52,19 @@ function normalizeToFeatureCollection(input) {
  * @param {string} body.content - вміст файлу
  * @param {string} [body.filename] - ім'я файлу
  */
-export default async function parseGeoFile({ body = {} }, reply) {
-  const { content, filename = '' } = body;
 
+export default async function parseGeoFile({ content, filename = '' }) {
   if (!content || typeof content !== 'string') {
-    return reply.status(400).send({ error: 'Потрібен вміст файлу (content)' });
+    throw BadRequestError('Потрібен вміст файлу (content)');
   }
 
   if (content.length > MAX_FILE_SIZE) {
-    return reply.status(400).send({ error: 'Максимальний розмір файлу — 50MB' });
+    throw BadRequestError('Максимальний розмір файлу — 50MB');
   }
 
   const lowerName = String(filename).toLowerCase();
   if (lowerName && !lowerName.endsWith('.json') && !lowerName.endsWith('.geojson')) {
-    return reply.status(400).send({ error: 'Підтримуються лише файли GeoJSON (.geojson, .json)' });
+    throw BadRequestError('Підтримуються лише файли GeoJSON (.geojson, .json)');
   }
 
   let parsed;
@@ -71,16 +72,14 @@ export default async function parseGeoFile({ body = {} }, reply) {
     parsed = JSON.parse(content);
   }
   catch {
-    return reply.status(400).send({ error: 'Некоректний JSON' });
+    throw BadRequestError('Некоректний JSON');
   }
 
   const normalized = normalizeToFeatureCollection(parsed);
+
   if (!normalized?.features?.length) {
-    return reply.status(400).send({ error: 'Не вдалося розпізнати геометрію GeoJSON' });
+    throw BadRequestError('Не вдалося розпізнати геометрію GeoJSON');
   }
 
-  return reply
-    .status(200)
-    .header('Content-Type', 'application/json')
-    .send(normalized);
+  return normalized;
 }

package/server/routes/map/{controllers → functions}/pointHeight.js

@@ -1,15 +1,12 @@
 const DEFAULT_ENDPOINT = 'https://api.opentopodata.org/v1/srtm90m';
 
-function parseLatLng(query) {
-  const lat = Number(query?.lat);
-  const lng = Number(query?.lng);
+function parseLatLng({ lat, lng }) {
   if (!Number.isFinite(lat) || !Number.isFinite(lng)) {
     throw new Error('lat and lng are required');
   }
   if (Math.abs(lat) > 90 || Math.abs(lng) > 180) {
     throw new Error('coordinates out of range');
   }
-  return { lat, lng };
 }
 
 function getEndpoint() {
@@ -42,9 +39,8 @@ async function fetchHeight(lat, lng) {
   }
 }
 
-export default async function pointHeight(ctx = {}) {
-  const query = ctx?.query ?? ctx ?? {};
-  const { lat, lng } = parseLatLng(query);
+export default async function pointHeight({ lat, lng }) {
+  parseLatLng({ lat, lng });
   const height = await fetchHeight(lat, lng);
 
   return {

package/server/routes/map/{controllers → functions}/vtile.js

@@ -5,16 +5,18 @@ import {
     readFile, stat, mkdir, writeFile,
 } from 'node:fs/promises';
 
-import Sphericalmercator from '@mapbox/sphericalmercator';
+import { SphericalMercator } from '@mapbox/sphericalmercator';
+
+const mercator = new SphericalMercator({ size: 256 });
 
 import {
-    getTemplate, pgClients, getFilterSQL, getMeta, yml2json, getColumnCLS, getSelect,
+    getTemplate, pgClients, getFilterSQL, getMeta, yml2json, getColumnCLS,
 } from '@opengis/fastify-table/utils.js';
 
 import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
 
 const limit = 3000;
-const mercator = new Sphericalmercator({ size: 256 });
+
 const types = { point: 'ST_Point', polygon: 'ST_Polygon,ST_MultiPolygon' };
 const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by', 'created_at', 'updated_by', 'updated_at'];
 

package/server/routes/map/{vtile1.js → functions/vtile1.js}

@@ -10,43 +10,46 @@ import {
   readFile, stat, mkdir, writeFile,
 } from 'node:fs/promises';
 
-import Sphericalmercator from '@mapbox/sphericalmercator';
+import { load } from 'js-yaml';
 
-const mercator = new Sphericalmercator({ size: 256 });
+import { SphericalMercator } from '@mapbox/sphericalmercator';
 
-// import { SphericalMercator } from '@mapbox/sphericalmercator';
-// const mercator = new SphericalMercator({ size: 256 });
+const mercator = new SphericalMercator({ size: 256 });
 
 import {
   getColumnCLS, getTemplate, getMeta, getFilterSQL, getSelect,
+  pgClients,
+  getFilterSQLParametrized,
 } from '@opengis/fastify-table/utils.js';
-import * as yaml from 'js-yaml';
-import rootFolder from '../../plugins/mapnik/funcs/rootFolder.mjs';
+
+import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
 
 const propsCache = {};
 
-export default async function vtile({
-  params = {}, query, pg, user,
-}, reply) {
-  const { y, z } = params;
-  const x = params.x.split('.')[0] - 0;
-  const {
-    type, nocache, sql, clusterZoom, filter, nottl,
-  } = query;
+const types = { point: 'ST_Point' /* ,ST_MultiPoint */, polygon: 'ST_Polygon,ST_MultiPolygon' };
 
+export default async function vtile({
+  x, y, z, layer: paramsLayer, type, nocache, sql, clusterZoom, filter, nottl, uid, filter: queryFilter, all: queryAll, sql: querySql, pointZoom,
+}, pg = pgClients.client) {
   const hash = [type, clusterZoom, filter].join();
 
   const filepath = path.join(
     rootFolder,
-    `/vtile/${params.layer}/${hash ? `${createHash('md5').update(hash).digest('hex')}/` : ''}${z}/${x}/${y}.vmt`,
+    `/vtile/${paramsLayer}/${hash ? `${createHash('md5').update(hash).digest('hex')}/` : ''}${z}/${x}/${y}.vmt`,
   );
 
   // layer
-  const [map, layer] = params.layer.includes(':') ? params.layer.split(':') : [null, params.layer];
+  const [_, layer] = paramsLayer.includes(':') ? paramsLayer.split(':') : [null, paramsLayer];
 
   // service
-  const data = await getTemplate('layer', layer) || await pg.query(`select * from gis.services where ${!user?.uid ? 'is_public and is_active' : '1=1'} and service_id=$1`, [layer]).then(el => el.rows?.[0]);
-  const style = typeof data?.style === 'object' ? data?.style : yaml.load(data?.style);
+  const data = await getTemplate('layer', layer) || await pg.query(`select * from gis.services where ${!uid ? 'is_public and is_active' : '1=1'} and service_id=$1`, [layer]).then(r => r.rows?.[0]);
+
+  if (!data) {
+    throw NotFoundError('layer not found');
+  }
+
+  const style = typeof data?.style === 'object' ? data?.style : load(data?.style);
 
   const cacheZoom = style?.cacheZoom || 13;
   const ttl = typeof style?.ttl === 'number' && style.ttl >= 0 ? style.ttl : 86400000;
@@ -56,7 +59,7 @@ export default async function vtile({
     const ageInMs = Date.now() - birthtimeMs;
     if (ageInMs < ttl) {
       const buffer = await readFile(filepath);
-      return reply.status(200).headers(headers).send(buffer);
+      return { headers, data: buffer };
     }
   }
 
@@ -69,20 +72,20 @@ export default async function vtile({
   const bbox = mercator.bbox(+y, +x, +z, false/* , '900913' */);
   const bbox2d = `'BOX(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d`;
 
-  const filterData = query.filter ? await getFilterSQL({
-    filter: query.filter, table, filterList,
-  }) : {};
+  const filterData = queryFilter ? await getFilterSQLParametrized({
+    filter: queryFilter, table, filterList, pg,
+  }) : { args: [] };
 
   // meta
-  const metaTable = await getMeta({ pg, table });
-  if (metaTable.error) { return metaTable; }
-  const { pk: pkey = data.key, columns } = metaTable; // if view - specify via template
+  const metaTable = table ? await getMeta({ pg, table }) : {};
+
+  const { pk: pkey = data.key, columns = [] } = metaTable; // if view - specify via template
 
   // props
   const statusColumn = style?.colorAttr || style?.iconAttr ? columns.filter(col => col.name === style.colorAttr || style?.iconAttr) : [];
-  const props = !query.all ? (statusColumn || []).concat(data.popup || []).concat(data.card || []) : columns.filter(el => !['json', 'geometry'].includes(pg.pgType[el.dataTypeID]) && !['uid', 'cdate', 'editor_id', 'editor_date'].includes(el.name));
+  const props = !queryAll ? (statusColumn || []).concat(data.popup || []).concat(data.card || []) : columns.filter(el => !['json', 'geometry'].includes(pg.pgType[el.dataTypeID]) && !['uid', 'cdate', 'editor_id', 'editor_date'].includes(el.name));
 
-  const cache = layer + (query.all ? '-all' : '') + JSON.stringify(data.popup || []).length;
+  const cache = layer + (queryAll ? '-all' : '') + JSON.stringify(data.popup || []).length;
   const propsWithCls = propsCache[cache] ?? await Promise.all(props.map(async (col, idx) => {
     const key = col.name;
     const select = data.popup?.find(el => el.name === key);
@@ -109,17 +112,16 @@ export default async function vtile({
   propsCache[cache] = propsCache[cache] || propsWithCls;
 
   const geomCol = (style?.type === 'point' ? `ST_Centroid(${geom})` : null)
-    || (parseInt(z, 10) < parseInt(query.pointZoom || style?.pointZoom || style?.iconZoom || '0', 10) ? `ST_Centroid(${geom})` : geom);
+    || (parseInt(z, 10) < parseInt(pointZoom || style?.pointZoom || style?.iconZoom || '0', 10) ? `ST_Centroid(${geom})` : geom);
 
   const koef = {
     10: 0.1, 11: 0.05, 12: 0.005, 13: 0.001, 14: 0.001, 15: 0.0005,
   }[z] || 0.0005;
 
-  const types = { point: 'ST_Point' /* ,ST_MultiPoint */, polygon: 'ST_Polygon,ST_MultiPolygon' };
   const clusterZoom1 = style?.clusterZoom || clusterZoom;
   const queryMode = ((clusterZoom1 - z) > 2 ? 1 : null) || ((clusterZoom1 - z) > 0 ? 2 : null) || 3;
   // console.log(z, clusterZoom, queryMode);
-  const props1 = props.filter((el, idx, arr) => idx === arr.findIndex(item => item.name === el.name));
+  // const props1 = props.filter((el, idx, arr) => idx === arr.findIndex(item => item.name === el.name));
   const q = {
     1: `SELECT ST_AsMVT(q, '${layer}', 4096, 'geom','row') as tile
             FROM (
@@ -166,8 +168,12 @@ export default async function vtile({
                 ) q`,
   }[queryMode];
 
-  if (query.sql === '1') { return q; }
-  const tile = await pg.query(q);
+  if (querySql === 1) {
+    return q;
+  }
+
+  const args = filterData?.args || [];
+  const tile = await pg.query(q, args);
   const buffer = Buffer.concat(tile.rows.map((el) => Buffer.from(el.tile)));
 
   if (!nocache) {
@@ -175,5 +181,5 @@ export default async function vtile({
     await writeFile(filepath, buffer, 'binary');
   }
 
-  return reply.headers({ ...headers, 'Cache-Control': nocache || nottl ? 'no-cache' : headers['Cache-Control'] }).send(buffer);
+  return { headers: { ...headers, 'Cache-Control': nocache || nottl ? 'no-cache' : headers['Cache-Control'] }, data: buffer };
 }