@opengis/gis 0.2.168 → 0.2.170

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

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 
 import * as solidIcons from '@fortawesome/free-solid-svg-icons';
 import sharp from 'sharp';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 
 const iconFilenamePattern = /^([a-z][a-z0-9]*)-(s|m|l|xl)-(fa|ar)-([a-z0-9-]+)\+([a-f0-9]{3,8})\.(png|svg)$/i;
 const validColorLengths = new Set([3, 4, 6, 8]);
@@ -48,7 +49,7 @@ const pinConfig = {
 };
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
-const pinDirectory = path.join(dirname, 'pin');
+const pinDirectory = path.join(dirname, '../pin');
 const iconDirectory = path.join(process.cwd(), 'log', 'icon');
 const iconDirectoryReady = mkdir(iconDirectory, { recursive: true });
 
@@ -192,16 +193,28 @@ async function getIcon(options, nocache = false) {
   return icon;
 }
 
-export default async function gisIconApi(req, reply) {
-  const options = parseIconFilename(req.params?.['*'] || '');
-  if (!options) return reply.status(400).send('invalid icon name');
+export default async function gisIconApi({ name, nocache }) {
+  if (!name) {
+    throw BadRequestError('not enough params: name');
+  }
+
+  const options = parseIconFilename(name);
+
+  if (!options) {
+    throw BadRequestError('invalid icon name');
+  }
 
-  const nocache = !!req.query?.nocache;
   const image = await getIcon(options, nocache);
-  if (!image) return reply.status(404).send('icon not found');
 
-  return reply
-    .type(contentTypeByFormat[options.format])
-    .header('Cache-Control', nocache ? 'no-cache' : 'public, max-age=31536000, immutable')
-    .send(image);
+  if (!image) {
+    throw NotFoundError('icon not found');
+  }
+
+  return {
+    headers: {
+      'Content-Type': contentTypeByFormat[options.format],
+      'Cache-Control': nocache ? 'no-cache' : 'public, max-age=31536000, immutable'
+    },
+    data: image
+  }
 }

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

@@ -10,9 +10,12 @@ import {
 } from '@opengis/fastify-table/utils.js';
 
 import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 
 const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by', 'created_at', 'updated_by', 'updated_at', 'geom'];
 
+const unittest = process.env.NODE_ENV === 'test' || process.env.VITEST;
+
 /**
  * Повертає JSON дані для реєстру на основі налаштувань з gis.registers
  * 
@@ -25,19 +28,15 @@ const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by',
  * @param {boolean} query.nocache - не використовувати кеш
  */
 export default async function jsonData({
-    pg = pgClients.client, params = {}, query = {}, unittest,
-}, reply) {
-    const { layer } = params;
-    const {
-        page = 1,
-        limit = 100,
-        where,
-        sql,
-        nocache
-    } = query;
-
+    layer,
+    page = 1,
+    limit = 100,
+    // where,
+    sql,
+    nocache
+}, pg = pgClients.client) {
     if (!layer) {
-        return reply.status(400).send('not enough params: layer (register_id)');
+        throw BadRequestError('not enough params: layer (register_id)');
     }
 
     const registerId = layer.replace('.json', '');
@@ -46,7 +45,7 @@ export default async function jsonData({
     const offset = (pageNum - 1) * limitNum;
 
     if (!pg.pk?.['gis.registers']) {
-        return reply.status(404).send('registers table not found');
+        throw NotFoundError('registers table not found');
     }
 
     const register = await pg.query(
@@ -61,10 +60,10 @@ export default async function jsonData({
         from gis.registers 
         where register_id = $1 and is_active = true and is_public = true`,
         [registerId],
-    ).then(el => el.rows?.[0]);
+    ).then(r => r.rows?.[0]);
 
     if (!register) {
-        return reply.status(404).send('register not found or not available');
+        throw NotFoundError('register not found or not available');
     }
 
     const {
@@ -76,11 +75,11 @@ export default async function jsonData({
     } = register;
 
     if (!table) {
-        return reply.status(400).send('invalid register table_name');
+        throw BadRequestError('invalid register table_name');
     }
 
     if (!pg.pk?.[table]?.length) {
-        return reply.status(404).send('table not found');
+        throw NotFoundError('table not found');
     }
 
     const meta = await getMeta({ pg, table });
@@ -102,11 +101,11 @@ export default async function jsonData({
     ).join(', ');
 
     if (!props) {
-        return reply.status(400).send('no columns to select');
+        throw BadRequestError('no columns to select');
     }
 
     const cacheHash = createHash('md5')
-        .update([registerId, where, registerQuery, pageNum, limitNum].filter(el => el).join('-'))
+        .update([registerId, /*where,*/ registerQuery, pageNum, limitNum].filter(el => el).join('-'))
         .digest('hex');
 
     const today = new Date().toISOString().split('T')[0];
@@ -120,17 +119,19 @@ export default async function jsonData({
         const ageInMs = Date.now() - birthtimeMs;
         if (ageInMs < 86400000) {
             const content = await readFile(filepath, 'utf8');
-            return reply
-                .status(200)
-                .header('Content-Type', 'application/json')
-                .header('Cache-Control', 'public, max-age=86400')
-                .send(content);
+            return {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+                data: content
+            }
         }
     }
 
     const whereConditions = [
         registerQuery || '1=1',
-        where || 'true',
+        /*where ||*/ 'true',
     ].join(' AND ');
 
     const quotedTable = table.split('.').map(el => `"${el}"`).join('.');
@@ -150,56 +151,56 @@ export default async function jsonData({
         OFFSET ${offset}
     `;
 
-    if (sql === '1') return { countQuery, dataQuery };
-    if (sql === '2') return filepath.replace(/\\/g, '/');
-
-    try {
-        const [countResult, dataResult] = await Promise.all([
-            pg.query(countQuery),
-            pg.query(dataQuery),
-        ]);
-
-        const total = parseInt(countResult.rows[0]?.total || 0, 10);
-        const rows = dataResult.rows || [];
-
-        // Обробка класифікаторів
-        if (columns && Array.isArray(columns)) {
-            const classifiers = columns
-                .filter(col => col.data && ['select', 'badge', 'tags', 'integer', 'text', 'text[]'].includes(col.format))
-                .reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
-
-            if (Object.keys(classifiers).length > 0) {
-                await metaFormat({
-                    rows,
-                    table,
-                    cls: classifiers,
-                    suffix: true,
-                });
-            }
-        }
+    if (sql === 1) return { countQuery, dataQuery };
+    if (sql === 2) return filepath.replace(/\\/g, '/');
+
 
-        const result = {
-            register_id: registerId,
-            total,
-            page: pageNum,
-            limit: limitNum,
-            pages: Math.ceil(total / limitNum),
-            data: rows,
-        };
+    const [countResult, dataResult] = await Promise.all([
+        pg.query(countQuery),
+        pg.query(dataQuery),
+    ]);
 
-        const jsonString = JSON.stringify(result);
+    const total = parseInt(countResult.rows[0]?.total || 0, 10);
+    const rows = dataResult.rows || [];
 
-        if (!nocache && !unittest) {
-            await mkdir(path.dirname(filepath), { recursive: true });
-            await writeFile(filepath, jsonString, 'utf8');
+    // Обробка класифікаторів
+    if (columns && Array.isArray(columns)) {
+        const classifiers = columns
+            .filter(col => col.data && ['select', 'badge', 'tags', 'integer', 'text', 'text[]'].includes(col.format))
+            .reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
+
+        if (Object.keys(classifiers).length > 0) {
+            await metaFormat({
+                rows,
+                table,
+                cls: classifiers,
+                suffix: true,
+            });
         }
+    }
+
+    const result = {
+        register_id: registerId,
+        total,
+        page: pageNum,
+        limit: limitNum,
+        pages: Math.ceil(total / limitNum),
+        data: rows,
+    };
+
+    const jsonString = JSON.stringify(result);
 
-        return reply
-            .status(200)
-            .header('Content-Type', 'application/json')
-            .header('Cache-Control', nocache ? 'no-cache' : 'public, max-age=86400')
-            .send(jsonString);
-    } catch (err) {
-        return reply.status(500).send({ error: err.message });
+    if (!nocache && !unittest) {
+        await mkdir(path.dirname(filepath), { recursive: true });
+        await writeFile(filepath, jsonString, 'utf8');
     }
+
+    return {
+        headers: {
+            'Content-Type': 'application/json',
+            'Cache-Control': nocache ? 'no-cache' : 'public, max-age=86400',
+        },
+        data: jsonString
+    }
+
 }

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

@@ -1,12 +1,13 @@
 import {
-  config, pgClients, yml2json, getTemplates, getTemplate,
+  pgClients, yml2json, getTemplates, getTemplate,
 } from '@opengis/fastify-table/utils.js';
-import getPermissions from '../../permissions/controllers/utils/get.permissions.js';
+
+import getPermissions from '../../permissions/functions/get.permissions.js';
 
 export default async function layerList({
-  pg = pgClients.client, query = {}, user = {},
-}, reply) {
-  const { sql } = query;
+  sql, uid,
+}, pg = pgClients.client) {
+
   const layers = getTemplates('layer');
   const files = Promise.all(layers.map(async (el) => {
     const layer = await getTemplate('layer', el[0]);
@@ -15,25 +16,24 @@ export default async function layerList({
 
   if (!pg.pk?.['gis.services'] && !pg.pk?.['gis.ogc_service'] && !pg.pk?.['gis.rasters'] && !pg.pk?.['gis.cartocss']) {
     return files;
-    // return reply.status(404).send('services table not found');
   }
 
-  const { all_layers, layer_list } = (user.uid) ? await getPermissions({ pg, uid: user.uid }) : { all_layers: false, layer_list: [] };
+  const { all_layers, layer_list } = uid ? await getPermissions({ pg, uid }) : { all_layers: false, layer_list: [] };
 
   const whereServices = (all_layers === true) ? '1=1'
-    : (user.uid && !all_layers) ? '( s.is_public or s.service_id = any($1))'
+    : (uid && !all_layers) ? '( s.is_public or s.service_id = any($1))'
       : 'is_public';
 
   const whereOgcServices = (all_layers === true) ? '1=1'
-    : (user.uid && !all_layers) ? '( s.ispublic or s.ogc_service_id = any($1))'
+    : (uid && !all_layers) ? '( s.ispublic or s.ogc_service_id = any($1))'
       : 'ispublic';
 
   const whereRasters = (all_layers === true) ? '1=1'
-    : (user.uid && !all_layers) ? '(s.is_public or s.raster_id = any($1))'
+    : (uid && !all_layers) ? '(s.is_public or s.raster_id = any($1))'
       : 'is_public';
 
   const whereCartocss = (all_layers === true) ? '1=1'
-    : (user.uid && !all_layers) ? '(s.is_public or s.cartocss_id = any($1))'
+    : (uid && !all_layers) ? '(s.is_public or s.cartocss_id = any($1))'
       : 'is_public';
   const q = `
    select * from 
@@ -71,20 +71,20 @@ export default async function layerList({
      )q order by q.name
     `;
 
-  if (user.uid && sql) return q;
+  if (uid && sql) return q;
 
-  const rows = await pg.query(q, (user.uid && !all_layers) ? [layer_list] : []).then(el => el.rows || []);
+  const rows = await pg.query(q, (uid && !all_layers) ? [layer_list] : []).then(r => r.rows || []);
 
   const totals = pg.queryCache ? await pg.queryCache('select json_object_agg(oid::regclass, reltuples) from pg_class')
-    .then(el => el.rows?.[0]?.json_object_agg || {}) : {};
+    .then(r => r.rows?.[0]?.json_object_agg || {}) : {};
   rows.filter(row => row.source_path).forEach(row => Object.assign(row, { count: totals[row.source_path] || 0 }));
 
   const groupIds = rows.map(el => el.group_id).filter(Boolean);
-  const groupNames = groupIds.length ? await pg.query('select json_object_agg(group_id,group_name) from gis.group_list where group_id=any($1)', [groupIds]).then(el => el.rows?.[0]?.json_object_agg || {}) : {};
+  const groupNames = groupIds.length ? await pg.query('select json_object_agg(group_id,group_name) from gis.group_list where group_id=any($1)', [groupIds]).then(r => r.rows?.[0]?.json_object_agg || {}) : {};
   rows.filter(el => el.group_id).forEach(row => Object.assign(row, { group_name: groupNames[row.group_id] }));
 
   if (!rows.length) {
-    return reply.status(200).send([]);
+    return [];
   }
 
   // parse service style
@@ -98,5 +98,5 @@ export default async function layerList({
 
   // return files;
 
-  return reply.status(200).send(rows.concat(files));
+  return rows.concat(files);
 }

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

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import { createHash } from 'node:crypto';
 
 import { config, getMeta, getTemplate, getTemplateSync, pgClients, getSelect, getSelectVal, getTemplatePath } from '@opengis/fastify-table/utils.js';
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
 
 const { prefix = '/api' } = config;
 const dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -13,7 +14,7 @@ const maps = getTemplatePath('map')?.map?.(el => {
     return { slug: el[0], name };
 });
 
-async function processObject(loadTemplate, pg = pgClients.client, unittest) {
+async function processObject(loadTemplate, pg = pgClients.client, unittest = process.env.NODE_ENV === 'test' || process.env.VITEST) {
     // default center for all maps (frontend dependends on it)
     const { bbox = [], center = [30, 50] } = loadTemplate?.source_path && pg.pk?.[loadTemplate.source_path]
         ? await pg.query(`select
@@ -96,29 +97,27 @@ async function processObject(loadTemplate, pg = pgClients.client, unittest) {
     return loadTemplate;
 }
 
-export default async function map({ pg = pgClients.client, params = {}, unittest }, reply) {
-    const { slug } = params;
-
+export default async function map({ slug }, pg = pgClients.client) {
     const loadTemplate = await getTemplate('map', slug);
 
     if (!loadTemplate) {
-        return reply.status(404).send('map not found');
+        throw NotFoundError('map not found');
     }
 
     if (!Array.isArray(loadTemplate)) {
-        await processObject(loadTemplate, pg, unittest);
+        await processObject(loadTemplate, pg);
         return { ...loadTemplate, maps };
     }
 
     const index = loadTemplate?.find?.(el => el[0].split('.').shift() === 'index')?.[1];
 
     if (!index) {
-        return reply.status(404).send('map index not found');
+        throw NotFoundError('map index not found');
     }
 
-    await processObject(index, pg, unittest);
+    await processObject(index, pg);
 
     const layers = loadTemplate?.filter?.(el => el[0].split('.').shift() !== 'index')?.map(el => ({ ...el[1], id: el[0].replace('.yml', '').replace('.json', '') }));
 
-    return reply.status(200).send({ ...index, layers, maps });
+    return { ...index, layers, maps };
 }

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

@@ -14,7 +14,7 @@ function getBBox(coordinates) {
     );
 }
 
-export default async function mapCatalog({ pg = pgClients.client }, reply) {
+export default async function mapCatalog({ } = {}, pg = pgClients.client) {
     const { rows: services = [] } = pg.pk?.['gis.services']
         ? await pg.query(`select 
                 service_id as id, name, service_type, service_url as url, 
@@ -50,17 +50,17 @@ export default async function mapCatalog({ pg = pgClients.client }, reply) {
             from gis.rasters where is_active and is_public`
         )
         : {};
-    
-     const { rows: ogc = [] } = pg.pk?.['gis.ogc_service']
+
+    const { rows: ogc = [] } = pg.pk?.['gis.ogc_service']
         ? await pg.query(
             `select
                 service_id as id, name, 'raster' as source_type,  url
             from gis.ogc_service `
         )
         : {};
-    
-    
-    
+
+
+
     rasters.forEach(el => {
         el.url = `${prefix}/layer-rtile/${el.id}/{z}/{x}/{y}.png`;
     });
@@ -69,5 +69,5 @@ export default async function mapCatalog({ pg = pgClients.client }, reply) {
         el.bbox = getBBox(el.bbox);
     });
 
-    return reply.status(200).send({ services, rasters: rasters.concat(ogc) });
+    return { services, rasters: rasters.concat(ogc) };
 }

package/server/routes/map/functions/mapCatalogAttribute.js

@@ -0,0 +1,54 @@
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+import { pgClients, getMeta, getSelect, getSelectVal } from "@opengis/fastify-table/utils.js";
+
+export default async function mapCatalogAttribute({ service, attr, cls: queryCls }, pg = pgClients.client) {
+    if (!service) {
+        throw BadRequestError('not enough params: service');
+    }
+
+    if (!attr) {
+        throw BadRequestError('not enough params: attr');
+    }
+
+    if (!pg.pk?.['gis.services']) {
+        throw NotFoundError('services table not found');
+    }
+
+    const source = await pg.query(
+        'select source_path from gis.services where service_id=$1 and is_active and is_public',
+        [service]
+    ).then(r => r.rows?.[0]?.source_path);
+
+    if (!source) {
+        throw NotFoundError('service not found');
+    }
+
+    const cls = await getSelect(queryCls || attr, pg);
+    const colname = queryCls ? attr : attr.split(':').pop();
+
+    if (!colname) {
+        throw BadRequestError('invalid params: attr');
+    }
+
+    const columns = await getMeta({ pg, table: source }).then(r => r.columns || []);
+    const { dataTypeID } = columns.find(col => col.name === colname) || {};
+
+    const q = dataTypeID && pg.pgType[dataTypeID]?.includes('[]')
+        ? `select unnest(${colname})::text as id,count(*) from ${source} group by unnest(${colname}) limit 100`
+        : `select ${colname}::text as id,count(*) from ${source} group by ${colname} limit 100`;
+
+    const countArr = await pg.queryCache(q).then(r => r.rows || []);
+
+    const clsData = await getSelectVal({ pg, values: countArr.map(el => el.id), name: queryCls || attr });
+
+    const legend = countArr.map(cel => {
+        const data = cls?.arr?.find(c => c.id?.toString?.() === cel.id?.toString?.()) || { text: clsData?.[cel.id]?.text || clsData?.[cel.id] };
+        return { ...cel, ...data };
+    });
+
+    const { min, max } = await pg.queryCache(
+        `select min(${attr}), max(${attr}) from ${source} where 1=1`,
+    ).then(r => r.rows?.[0] || {});
+
+    return { legend, min, max };
+}

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

@@ -1,23 +1,23 @@
-import { getMeta, getFilterSQL, getTemplate, metaFormat, pgClients, yml2json } from '@opengis/fastify-table/utils.js';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
+import {
+    getMeta, getFilterSQL, getTemplate, metaFormat, pgClients, yml2json,
+} from '@opengis/fastify-table/utils.js';
 
 const layerMetaColumns = ['id', 'name', 'label', 'source', 'table', 'pk', 'geomColumn', 'srid', 'cls', 'htmls'];
 
-export default async function mapFeaturesPoint({ pg = pgClients.client, params = {}, query = {} }, reply) {
-    const { slug, id } = params;
-    const { x, y, sql } = query;
-
+export default async function mapFeaturesPoint({ slug, id, x, y, sql }, pg = pgClients.client) {
     if (!slug) {
-        return reply.status(400).send('not enough params: slug');
+        throw BadRequestError('not enough params: slug');
     }
 
     if (!(x && y) && !id) {
-        return reply.status(400).send('not enough params: xy');
+        throw BadRequestError('not enough params: xy');
     }
 
     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];
@@ -26,21 +26,21 @@ export default async function mapFeaturesPoint({ pg = pgClients.client, params =
         ? loadTemplate?.layers
         : loadTemplate?.filter?.(el => el[0].split('.').shift() !== 'index')?.map(el => ({ ...el[1], id: el[0].replace('.yml', '').replace('.json', '') }));
 
-    const serviceLayers = await Promise.all(layers1.filter(el => typeof el === 'string').map(async (layer) => {
+    const serviceLayers = await Promise.all((layers1 || []).filter(el => typeof el === 'string').map(async (layer) => {
         const layerData = await getTemplate('layer', layer);
         const serviceData = layerData || await pg.query('select service_id as id, *, st_asgeojson(bbox)::json as bbox, st_asgeojson(center)::json as center from gis.services where service_id=$1', [layer]).then(el => el.rows?.[0]);
         serviceData.style = yml2json(serviceData.style);
         return { ...serviceData, id: layer, visible: true };
     }));
 
-    const layers = layers1.filter(el => el && typeof el === 'object').concat(serviceLayers);
+    const layers = (layers1 || []).filter(el => el && typeof el === 'object').concat(serviceLayers);
 
     if (!layers?.length) {
-        return reply.status(404).send('map layers not found');
+        throw NotFoundError('map layers not found');
     }
 
     if (!layers.filter(el => el.source_path).length) {
-        return reply.status(404).send('map layers sources not provided');
+        throw NotFoundError('map layers sources not provided');
     }
 
     const point = `srid=4326;point(${x} ${y})`; // 30, 50
@@ -48,7 +48,9 @@ export default async function mapFeaturesPoint({ pg = pgClients.client, params =
     const { srids } = await pg.queryCache?.('select json_agg(srid) as srids from spatial_ref_sys').then(el => el.rows?.[0] || {}) || {};
 
     await Promise.all(layers.map(async (layer, idx) => {
-        const { source_path: source, srid = 4326, id: layerId, name } = layer;
+        const {
+            source_path: source, srid = 4326, id: layerId, name,
+        } = layer;
 
         const loadTable = await getTemplate('table', source);
         const meta = await getMeta({ pg, table: loadTable?.table || source });
@@ -100,19 +102,21 @@ export default async function mapFeaturesPoint({ pg = pgClients.client, params =
     where ${where}`;
     }).join(' union all ').concat(' order by distance');
 
-    if (sql === '1') return q;
+    if (sql === 1) return q;
 
     const { rows: objects = [] } = await pg.query(q);
 
     if (!objects.length) {
-        return reply.status(200).send(`object not found: ${id}`);
+        return `object not found: ${id}`;
     }
 
     const layerData = layers.find((el) => (el.id || el.name) === objects[0].layer) || {};
     const rows = objects.slice(0, 1).map(el => ({ ...el.data, data: undefined }));
 
     const { cls, htmls } = layerData;
-    await metaFormat({ rows, cls, htmls, sufix: false }, pg);
+    await metaFormat({
+        rows, cls, htmls, sufix: false,
+    }, pg);
 
     const resp = {
         meta: {
@@ -125,5 +129,5 @@ export default async function mapFeaturesPoint({ pg = pgClients.client, params =
         },
     };
 
-    return reply.status(200).send(resp);
-}
+    return resp;
+}