@opengis/gis 0.2.167 → 0.2.169

package/server/routes/metadata/metadata.schema.js

@@ -0,0 +1,53 @@
+export const editMetadataSchema = {
+    params: {
+        type: 'object',
+        required: ['type', 'id'],
+        properties: {
+            type: { type: 'string', enum: ['raster', 'css', 'dataset', 'service'] },
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+    body: {
+        type: 'object',
+        // additionalProperties: false,
+        properties: {
+            geom: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', enum: ['Point', 'LineString', 'Polygon'] },
+                    coordinates: { type: 'array' },
+                },
+                required: ['type', 'coordinates'],
+            },
+            description: { type: 'string' },
+            group_id: { type: 'string' },
+            keywords: {
+                type: 'array',
+                items: { type: 'string' },
+            },
+            is_public: { type: 'boolean' },
+            is_active: { type: 'boolean' },
+            service_key: { type: 'string' },
+            producer: { type: 'string' },
+            category: { type: 'string' },
+            license: { type: 'string' },
+            year: { type: 'string' },
+            service_url: { type: 'string' },
+            metadata_url: { type: 'string' },
+            thumbnail_url: { type: 'string' },
+            query: { type: 'string' },
+        },
+    },
+};
+
+export const metadataXMLSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+};
+
+export default null;

package/server/routes/{gis/ogc → ogc/functions}/map.info.point.js

@@ -1,3 +1,4 @@
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 import {
   pgClients, handlebars, getMeta, getTemplate, getFilterSQL,
 } from '@opengis/fastify-table/utils.js';
@@ -12,26 +13,26 @@ const columnType = {
   'timestamp with time zone': 'date',
 };
 
-export default async function mapInfoPoint(req, reply) {
-  const { pg = pgClients.client, query = {} } = req;
-  const {
-    x, y, layers, index = 0,
-  } = query;
+export default async function mapInfoPoint({ x, y, layers, index = 0, sql }, pg = pgClients.client) {
   const time = Date.now();
 
   if (!x || !y || !layers) {
-    return reply.status(400).send('not enough query params: x, y, layers are required');
+    throw BadRequestError('not enough query params: x, y, layers are required');
   }
 
-  const rows = pg?.pk?.['gis.ogc_service'] ? await pg.query('select * from gis.ogc_service WHERE enabled and table_name is not null and ogc_service_id = any($1)', [layers.split(',')]).then(el => el.rows || []) : [];
+  const rows = pg?.pk?.['gis.ogc_service'] ? await pg.query('select * from gis.ogc_service WHERE enabled and table_name is not null and ogc_service_id = any($1)', [layers.split(',')]).then(r => r.rows || []) : [];
 
   if (!rows.length) {
-    return reply.status(404).send('layers not found');
+    throw NotFoundError('layers not found');
   }
 
-  const point = `srid=4326;point(${x} ${y})`; // 30, 50
+  const args = [];
 
-  const srids = pg.queryCache ? await pg.queryCache('select json_agg(srid) as srids from spatial_ref_sys').then(el => el.rows?.[0]?.srids || {}) : {};
+  // 30, 50
+  args.push(x);
+  args.push(y);
+
+  const srids = pg.queryCache ? await pg.queryCache('select json_agg(srid) as srids from spatial_ref_sys').then(r => r.rows?.[0]?.srids || {}) : {};
 
   await Promise.all(rows.map(async (layer, idx) => {
     const { table_name: source, ogc_service_id: layerId } = layer;
@@ -39,7 +40,7 @@ export default async function mapInfoPoint(req, reply) {
     const meta = await getMeta({ pg, table: loadTable?.table || source });
     const { geom = 'geom' } = meta || {};
     const { table = source, columns = meta?.columns } = loadTable || {};
-    const { srid, x } = await pg.query(`select st_srid(${geom}) as srid, st_x(st_pointonsurface(${geom})) as x from ${table} where geom is not null limit 1`).then(el => el.rows?.[0] || {});
+    const { srid, x } = await pg.query(`select st_srid(${geom}) as srid, st_x(st_pointonsurface(${geom})) as x from ${table} where geom is not null limit 1`).then(r => r.rows?.[0] || {});
 
     const cls = columns
       ?.filter(el => el.name && el.data)
@@ -66,41 +67,33 @@ export default async function mapInfoPoint(req, reply) {
   const qList = unique.map((el) => ({
     query: `select ${el.pk}::text as pk, '${el.layer}' as layer, '${el.table}' as table,
     row_to_json(t) as data, 
-    st_distance(${el.geomColumn},'${point.replace(/'/g, "''")}') as distance,
+    st_distance(${el.geomColumn}, st_setsrid(st_makepoint($1,$2),4326)) as distance,
     st_asgeojson(${el.geomColumn})::json as geom from (${el.optimizedSQL}) t 
     where 1=1`,
     queryCount: `select 1 from (${el.optimizedSQL})t where 1=1`,
-    /* where: `case
-                    when ST_GeometryType(${el.geomColumn}) in ('ST_Polygon','ST_MultiPolygon')
-                    then st_intersects(${el.geomColumn},st_buffer('${point.replace(/'/g, "''")}',${el.step}))
-
-                    when ST_GeometryType(${el.geomColumn}) in ('ST_Line','ST_MultiLineString', 'ST_MultiPoint', 'ST_Point')
-                    then st_distance(${el.geomColumn},'${point.replace(/'/g, "''")}') < ${el.step}
-                    else false
-                end`, */
-    where: `${el.geomColumn} && '${point.replace(/'/g, "''")}'`,
+    where: `${el.geomColumn} && st_setsrid(st_makepoint($1,$2),4326)`,
   }));
 
-  const q = qList.map(el => `${el.query} and ${el.where}`).join(' union all ').concat(` order by distance limit 1 offset ${Math.max(+index || 0, 0)}`);
+  const q = qList.map(el => `${el.query} and ${el.where}`).join(' union all ').concat(` order by distance limit 1 offset $3::bigint`);
 
   const qCount = qList.map(el => `${el.queryCount} and ${el.where}`).join(' union all ');
 
-  if (query.sql === '1') return q;
-  if (query.sql === '2') return qCount;
+  if (sql === 1 && process.platform === 'win32') return q;
+  if (sql === 2 && process.platform === 'win32') return qCount;
 
-  const count = await pg.query(qCount).then(el => el.rowCount);
+  const count = await pg.query(qCount, args).then(el => el.rowCount);
 
-  const row = await pg.query(q).then(el => el.rows?.[0]);
+  const row = await pg.query(q, args.concat([Math.max(+index || 0, 0)])).then(r => r.rows?.[0]);
 
   if (!row) {
-    return reply.status(404).send('object not found');
+    throw NotFoundError('object not found');
   }
 
-  const { columns = [] } = await getMeta({ pg, table: row.table }) || {};
+  const columns = row.table ? await getMeta({ pg, table: row.table }).then(r => r.columns || []) : [];
   const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
 
   const htmlTemplate = pg?.pk?.['admin.templates'] && row.layer && false
-    ? await pg.query('select body from admin.templates where name=$1 limit 1', [row.layer]).then(el => el.rows?.[0]?.body)
+    ? await pg.query('select body from admin.templates where name=$1 limit 1', [row.layer]).then(r => r.rows?.[0]?.body)
     : rows.find(el => el.ogc_service_id === row.layer)?.html;
 
   const html = await handlebars.compile(htmlTemplate || 'template not found')(row.data);

package/server/routes/ogc/ogc.route.js

@@ -0,0 +1,21 @@
+import mapInfoPoint from './functions/map.info.point.js';
+
+import {
+    mapInfoPointSchema,
+} from './ogc.schema.js';
+
+const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
+async function route(app) {
+    app.get('/map-info-point', { ...publicParams, schema: mapInfoPointSchema }, async ({ query, pg }) => {
+        const result = await mapInfoPoint({
+            x: query.x,
+            y: query.y,
+            layers: query.layers,
+            index: query.index,
+            sql: query.sql
+        }, pg);
+        return result;
+    });
+}
+export default route;

package/server/routes/ogc/ogc.route.test.js

@@ -0,0 +1,54 @@
+import { beforeAll, describe, expect, test } from 'vitest';
+
+import { getPGAsync } from '@opengis/fastify-table/utils.js';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+let pg;
+
+describe('OGC routes', () => {
+    beforeAll(async () => {
+        await build();
+
+        pg = await getPGAsync();
+    });
+
+    test('GET /map-info-point validates query', async () => {
+        const { id, table } = await pg.query('select ogc_service_id as id, table_name as table from gis.ogc_service WHERE enabled and table_name is not null limit 1').then(r => r.rows[0]) || {};
+        expect(table).toBeDefined();
+        const { x, y } = await pg.query(`select st_x(st_pointonsurface(geom)) as x, st_y(st_pointonsurface(geom)) as y from ${table} where geom is not null limit 1`).then(r => r.rows[0]) || {};
+        expect(x).toBeDefined();
+        expect(y).toBeDefined();
+        const res = await injectWithHeaders({
+            url: '/api/map-info-point',
+            query: {
+                x,
+                y,
+                layers: id,
+                // index: 0,
+            },
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('time');
+        expect(res.body).toHaveProperty('index');
+        expect(res.body.index).toBeTypeOf('number');
+        expect(res.body).toHaveProperty('count');
+        expect(res.body.count).toBeTypeOf('number');
+        expect(res.body.count).toBeGreaterThan(0);
+        expect(res.body).toHaveProperty('data');
+        expect(res.body).toHaveProperty('fields');
+        expect(res.body.data).toHaveProperty('layer');
+        expect(res.body.data).toHaveProperty('geom');
+        expect(res.body.data).toHaveProperty('id');
+        expect(res.body.data).toHaveProperty('distance');
+        expect(res.body.data).toHaveProperty('data');
+        expect(res.body.data.data).toHaveProperty('geom');
+        expect(res.body.fields).toBeInstanceOf(Array);
+        expect(res.body.fields.length).toBeGreaterThan(0);
+        expect(res.body.fields[0]).toHaveProperty('name');
+        expect(res.body.fields[0]).toHaveProperty('type');
+        expect(res.body.fields[0]).toHaveProperty('label');
+        expect(res.body).toHaveProperty('html');
+    });
+});

package/server/routes/ogc/ogc.schema.js

@@ -0,0 +1,16 @@
+export const mapInfoPointSchema = {
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            sql: { type: 'number', enum: [1, 2] },
+            x: { type: 'number', minimum: -180, maximum: 180 }, // longitude
+            y: { type: 'number', minimum: -90, maximum: 90 }, // latitude
+            layers: { type: 'string' },
+            index: { type: 'number', minimum: 0 },
+        },
+        required: ['x', 'y', 'layers'],
+    },
+};
+
+export default null;

package/server/routes/permissions/functions/catalog.permissions.edit.js

@@ -0,0 +1,20 @@
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function catalogPermissionsEdit({ uid, body }, pg = pgClients.client) {
+    if (!uid) {
+        throw BadRequestError('not enough params: id');
+    }
+
+    if (!body?.length) {
+        throw BadRequestError('body is empty');
+    }
+
+    await pg.query(`delete from gis.services_users_rel where user_id = $1`, [uid]);
+
+    const promises = body.map(el => pg.query(`insert into gis.services_users_rel (service_id,user_id,created_by,actions) values ($1,$2,$2,$3)`, [el.service_id, uid, el.actions]));
+
+    await Promise.all(promises);
+
+    return { status: 201, message: `Inserted ${body?.length} permissions` };
+}

package/server/routes/permissions/functions/catalog.permissions.js

@@ -0,0 +1,13 @@
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function catalogPermissions({ uid }, pg = pgClients.client) {
+    if (!uid) {
+        throw BadRequestError('not enough params: id');
+    }
+
+    const { total, layer_list } = await pg.query(
+        `select count(*)::int as total, array_agg(json_build_object('service_id',service_id,'actions',actions)) as layer_list from gis.services_users_rel where user_id=$1`, [uid]).then(r => r.rows?.[0] || {});
+
+    return { total, layer_list };
+}

package/server/routes/permissions/{controllers → functions}/gis.catalog.js

@@ -1,16 +1,15 @@
-import getPermissions from './utils/get.permissions.js';
+import { pgClients } from '@opengis/fastify-table/utils.js';
 
-export default async function gisCatalog(req, reply) {
-  const { pg, user } = req;
-
-  if (!user?.uid) return reply.status(403).send({ status: 403, message: 'access restricted' });
+import getPermissions from './get.permissions.js';
 
+export default async function gisCatalog({ uid }, pg = pgClients.client) {
   // permissions
-  const { all_layers, group_list, layer_list } = await getPermissions({ pg, uid: user.uid });
+  const { all_layers, group_list, layer_list } = await getPermissions({ pg, uid });
+
   if (!all_layers && !group_list?.length && !layer_list?.length) {
-    return reply.status(200).send({
+    return {
       status: 204, categoriesCount: 0, layersCount: 0, servicesCount: 0, rastersCount: 0, categories: [], layers: [],
-    });
+    };
   }
 
   // groups
@@ -74,7 +73,8 @@ export default async function gisCatalog(req, reply) {
     layers,
 
   };
-  const statusCode = (!layersCount && !categoriesCount) ? 204 : 200;
 
-  return reply.status(statusCode).send(res);
+  // const statusCode = (!layersCount && !categoriesCount) ? 204 : 200;
+
+  return res;
 }

package/server/routes/permissions/permissions.route.js

@@ -0,0 +1,35 @@
+import catalogPermissions from './functions/catalog.permissions.js';
+import catalogPermissionsEdit from './functions/catalog.permissions.edit.js';
+import gisCatalog from './functions/gis.catalog.js';
+
+const privateParams = { config: { policy: 'L1' } };
+
+import { getCatalogPermissionsSchema, editCatalogPermissionsSchema } from './permissions.schema.js';
+
+export default function route(fastify) {
+  if (!fastify.hasRoute({ method: 'GET', url: '/api/catalog' })) {
+    console.log('\x1b[34m%s\x1b[0m', 'add catalog from gis');
+    // does not use any parameters - schema is not neccessary
+    fastify.get('/catalog', { ...privateParams, schema: {} }, async ({ user, pg }) => {
+      const result = await gisCatalog({ uid: user?.uid }, pg);
+      return result;
+    });
+  }
+  if (!fastify.hasRoute({ method: 'GET', url: '/api/catalog-permissions/:uid' })) {
+    console.log('\x1b[34m%s\x1b[0m', 'add catalog-permissions from gis');
+    fastify.get('/catalog-permissions/:uid', { ...privateParams, schema: getCatalogPermissionsSchema }, async ({ params, pg }) => {
+      const result = await catalogPermissions({ uid: params.uid }, pg);
+      return result;
+    });
+  }
+  if (!fastify.hasRoute({ method: 'POST', url: '/api/catalog-permissions/:uid' })) {
+    console.log('\x1b[34m%s\x1b[0m', 'add catalog-permissions-edit from gis');
+    fastify.post('/catalog-permissions/:uid', { ...privateParams, schema: editCatalogPermissionsSchema }, async ({ params, body, pg }) => {
+      const result = await catalogPermissionsEdit({
+        uid: params.uid,
+        body,
+      }, pg);
+      return result;
+    });
+  }
+}

package/server/routes/permissions/permissions.route.test.js

@@ -0,0 +1,35 @@
+import {
+    describe, test, expect, beforeAll, afterAll,
+} from 'vitest';
+
+import {
+    getPGAsync,
+} from '@opengis/fastify-table/utils.js';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+const user = { uid: '1', user_type: 'admin' };
+
+let pg;
+
+describe('permissions api test', () => {
+    beforeAll(async () => {
+        await build();
+        pg = await getPGAsync();
+    });
+
+    afterAll(async () => {
+    });
+
+    test('GET /catalog', async () => {
+
+    });
+
+    test('POST /catalog-permissions/:uid', async () => {
+
+    });
+
+    test('GET /catalog-permissions/:uid', async () => {
+
+    });
+});

package/server/routes/permissions/permissions.schema.js

@@ -0,0 +1,44 @@
+export const getCatalogPermissionsSchema = {
+    params: {
+        type: 'object',
+        required: ['uid'],
+        properties: {
+            uid: {
+                type: 'string', pattern: '^([\\d\\w]+)$'
+            },
+        },
+    },
+};
+
+export const editCatalogPermissionsSchema = {
+    params: {
+        type: 'object',
+        required: ['uid'],
+        properties: {
+            uid: {
+                type: 'string', pattern: '^([\\d\\w]+)$'
+            },
+        },
+    },
+    body: {
+        type: 'array',
+        items: {
+            type: 'object',
+            required: ['service_id', 'actions'],
+            properties: {
+                service_id: {
+                    type: 'string', pattern: '^([\\d\\w]+)$'
+                },
+                actions: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['view', 'edit', 'add', 'del']
+                    }
+                }
+            }
+        }
+    }
+};
+
+export default null;

package/server/routes/registers/functions/add.registry.js

@@ -0,0 +1,37 @@
+import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+
+export default async function addGisRegistry({
+    method, body, slug, uid,
+}, pg = pgClients.client) {
+    if (method === 'POST' && !body?.register_key) {
+        throw BadRequestError('not enough body params: register_key');
+    }
+
+    if (method === 'POST') {
+        const res = await dataInsert({
+            pg,
+            id: slug,
+            table: 'gis.registers',
+            data: body,
+            uid,
+        });
+        return res.data;
+    }
+
+    if (!slug) {
+        throw BadRequestError('not enough params: slug');
+    }
+
+    const id = await pg.query('select register_id from gis.registers where register_key=$1', [slug]).then(r => r.rows?.[0]?.register_id) || slug;
+
+    const row = await dataUpdate({
+        pg,
+        id,
+        table: 'gis.registers',
+        data: body,
+        uid,
+    });
+
+    return row;
+}

package/server/routes/{gis/registers/funcs → registers/functions}/classifiers.js

@@ -54,7 +54,7 @@ export async function attachClassifiers(rowOrRows, classifiers, table) {
     return rowOrRows;
 }
 
-export async function populateFilterOptions({ pg, table, filters, columns, whereConditions }) {
+export async function populateFilterOptions({ pg, table, filters, columns, whereConditions, args = [] }) {
     if (!filters?.length || !table || !columns?.length) return;
 
     const optimizedSQL = `select * from ${table} where ${whereConditions || '1=1'}`;
@@ -78,7 +78,7 @@ export async function populateFilterOptions({ pg, table, filters, columns, where
                     ? `select unnest(${el.id})::text as id,count(*) from (${optimizedSQL})q group by unnest(${el.id}) limit 100`
                     : `select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id} limit 100`;
 
-                const countArr = await pg.queryCache(q, { table });
+                const countArr = await pg.queryCache(q, { args, table });
 
                 if (countArr.timeout) {
                     Object.assign(el, { timeout: countArr.timeout });

package/server/routes/{gis/registers → registers/functions}/del.registry.js

@@ -1,15 +1,15 @@
 import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
 
 export default async function deleteGisRegistry({
-    params = {}, pg = pgClients.client, user = {},
-}, reply) {
-    const id = await pg.query('select register_id from gis.registers where register_key=$1', [params.slug]).then(el => el.rows?.[0]?.register_id) || params.slug;
+    slug, uid,
+}, pg = pgClients.client) {
+    const id = await pg.query('select register_id from gis.registers where register_key=$1', [slug]).then(el => el.rows?.[0]?.register_id) || slug;
 
     const row = await dataDelete({
         pg,
         id,
         table: 'gis.registers',
-        uid: user?.uid,
+        uid,
     });
-    return reply.status(200).send(row);
+    return row;
 }

package/server/routes/{gis/registers/funcs → registers/functions}/get.info.js

@@ -1,13 +1,16 @@
 import { pgClients } from '@opengis/fastify-table/utils.js';
-import { attachClassifiers } from '../../../gis/registers/funcs/classifiers.js';
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
+
+import { attachClassifiers } from '../../registers/functions/classifiers.js';
+
 const pg = pgClients.client;
 
-export default async function getInfo({ finalInfo, format }, reply) {
+export default async function getInfo({ finalInfo, format }) {
   if (!finalInfo) return { error: 'No data found' };
 
   const table = finalInfo?.table_name;
   const queryCondition = finalInfo?.query || '1=1';
-  const columns = finalInfo?.columns || finalInfo?.attributes || '[]';
+  const columns = finalInfo?.columns || finalInfo?.attributes || [];
   const exportable = columns.filter(c => c.is_export);
   const selectNames = exportable.map(c => `"${c.name}"`);
   const selectSQL = `
@@ -51,9 +54,10 @@ export default async function getInfo({ finalInfo, format }, reply) {
     };
   }
 
-  const { rows } = await pg.query(selectSQL);
+  const rows = await pg.query(selectSQL).then(r => r.rows || []);
+
   if (!rows?.length) {
-    return reply.status(404).send({ message: 'Немає даних, які можна експортувати', status: 404 });
+    throw NotFoundError('Немає даних, які можна експортувати');
   }
 
   const classifiers = exportable

package/server/routes/{gis/registers → registers/functions}/gis.export.js

@@ -1,12 +1,16 @@
 import { createReadStream } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+
 import {
- grpc, config, getMeta, getFolder, jsonToCsv,
+    grpc, config, getMeta, getFolder, jsonToCsv,
+    pgClients,
 } from '@opengis/fastify-table/utils.js';
 
-import getInfo from './funcs/get.info.js';
-import ContentType from './funcs/content.type.js';
+import { BadRequestError, NotImplementedError } from '@opengis/fastify-table/errors.js';
+
+import getInfo from './get.info.js';
+import ContentType from './content.type.js';
 
 const { jsonToXls, geojsonToShp } = grpc();
 const rootDir = getFolder(config, 'local');
@@ -19,14 +23,18 @@ const rootDir = getFolder(config, 'local');
  * @returns {boolean} File
  */
 
-export default async function gisExport({ pg, query = {}, params = {} }, reply) {
-    const { format } = query;
-    const { slug, type } = params;
+export default async function gisExport({ slug, type, format }, pg = pgClients.client) {
     if (!['csv', 'xlsx', 'shp', 'geojson'].includes(format)) {
-        return reply.code(401).send({ message: 'Param format is invalid. Allowed: csv, xlsx, shp, geojson', status: 404 });
+        throw BadRequestError('invalid params: format. Allowed: csv, xlsx, shp, geojson');
+    }
+
+    if (!slug) {
+        throw BadRequestError('not enough params: slug');
+    }
+
+    if (!type) {
+        throw BadRequestError('not enough params: type');
     }
-    if (!slug) return reply.code(401).send({ message: 'slug is not defined', status: 404 });
-    if (!type) return reply.code(401).send({ message: 'type is not defined', status: 404 });
 
     let registerInfo;
     let serviceInfo;
@@ -50,13 +58,13 @@ export default async function gisExport({ pg, query = {}, params = {} }, reply)
     const finalInfo = registerInfo?.rows[0] || serviceInfo?.rows[0];
 
     const exportable = finalInfo?.columns?.filter(c => c.is_export);
-    const colmodel = exportable.map(col => ({
+    const colmodel = (exportable || []).map(col => ({
         name: col.name,
         title: col.ua || col.name,
     }));
     const {
- rows, table, srid, sqlList,
-} = await getInfo({ finalInfo, format }, reply);
+        rows, table, srid, sqlList,
+    } = await getInfo({ finalInfo, format });
     let filePath = ['csv', 'geojson', 'xlsx'].includes(format) ? path.join(rootDir, `/files/tmp/export_${table}_${Date.now()}.${format}`) : path.join(rootDir, `/files/tmp/export_${table}_${Date.now()}.zip`);
     const ext = path.extname(filePath);
     const filePathJSON = ['csv', 'geojson', 'shp'].includes(format) ? filePath.replace(ext, '.json') : filePath;
@@ -64,16 +72,12 @@ export default async function gisExport({ pg, query = {}, params = {} }, reply)
 
     const meta = await getMeta({ pg, table });
     if ((format === 'geojson' || format === 'shp') && !meta?.geom) {
-        return reply.status(400).send('Ця таблиця не містить полів геометрії. Виберіть тип, який не потребує геометрії для вивантаження');
+        throw BadRequestError('Ця таблиця не містить полів геометрії. Виберіть тип, який не потребує геометрії для вивантаження');
     }
 
     if (format === 'xlsx') {
         if (!jsonToXls) {
-            const message = 'Сервіс конвертації jsonToXls тимчасово недоступний. Спробуйте експортувати дані у іншому форматі...';
-            const error = new Error(message);
-            error.status = 503;
-
-            throw error;
+            throw NotImplementedError('Сервіс конвертації jsonToXls тимчасово недоступний. Спробуйте експортувати дані у іншому форматі...');
         }
         const { result } = await jsonToXls({
             json: JSON.stringify(rows),
@@ -145,9 +149,11 @@ export default async function gisExport({ pg, query = {}, params = {} }, reply)
         exportFilePath = exportedZipPaths[0];
     }
 
-    reply.header('Content-Disposition', `attachment; filename=${encodeURIComponent(path.basename(exportFilePath))}`);
-    reply.header('Content-Type', ContentType[format]);
+    const headers = {
+        'Content-Disposition': `attachment; filename=${encodeURIComponent(path.basename(exportFilePath))}`,
+        'Content-Type': ContentType[format]
+    };
 
     const fileStream = createReadStream(exportFilePath);
-    return reply.send(fileStream);
+    return { headers, data: fileStream };
 }