@opengis/gis 0.2.167 → 0.2.169

package/server/routes/map/map.schema.js

@@ -0,0 +1,356 @@
+export const gisConvertSchema = {
+  body: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      encoding: {
+        type: 'string',
+        // python is case insensitive and ignores "-"
+        enum: ['LATIN-1', 'CP1251', 'UTF-8'],
+      },
+      // srid: {
+      //   type: 'number',
+      //   minimum: 1,
+      // },
+      file: {
+        type: 'string',
+      },
+      filename: {
+        type: 'string',
+      },
+      filepath: {
+        type: 'string',
+      },
+    },
+    anyOf: [
+      { required: ['file', 'filename'] },
+      { required: ['filepath'] },
+    ],
+  },
+};
+
+export const mapFormatSchema = {
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['layer'],
+    properties: {
+      lat: {
+        type: 'number',
+        minimum: 1,
+        maximum: 90,
+      },
+      lng: {
+        type: 'number',
+        minimum: -180,
+        maximum: 180,
+      },
+      radius: {
+        type: 'number',
+        minimum: 1,
+        maximum: 1000,
+      },
+      layer: {
+        type: 'string', pattern: "^([\\d\\w._-]+)$"
+      },
+      id: {
+        type: 'string', pattern: "^([\\d\\w._-]+)$"
+      },
+      nogeom: {
+        type: 'string', enum: ['1', 'true']
+      }
+    },
+  },
+};
+
+export const pointHeightSchema = {
+  querystring: {
+    type: 'object',
+    required: ['lat', 'lng'],
+    properties: {
+      lat: { type: 'number', minimum: -90, maximum: 90 },
+      lng: { type: 'number', minimum: -180, maximum: 180 },
+    },
+  },
+  response: {
+    200: {
+      type: 'object',
+      properties: {
+        lat: { type: 'number' },
+        lng: { type: 'number' },
+        height: { anyOf: [{ type: 'number' }, { type: 'null' }] },
+      },
+    },
+  },
+};
+
+export const getIconSchema = {
+  params: {
+    type: 'object',
+    required: ['*'],
+    properties: {
+      '*': { type: 'string' },
+    },
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      nocache: { type: 'string', enum: ['true', '1'] },
+    },
+  },
+};
+
+export const mapTilesSchema = {
+  params: {
+    type: 'object',
+    required: ['slug', 'z', 'x', 'y'],
+    properties: {
+      slug: {
+        type: 'string',
+      },
+      z: {
+        type: 'number',
+      },
+      y: {
+        type: 'number',
+      },
+      x: {
+        type: 'string',
+        pattern: '^\\d+\\.(pbf|vmt)$',
+      },
+    },
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      nocache: { type: 'string', enum: ['1'] },
+      filter: { type: 'string', /** pattern: "" */ },
+      type: { type: 'string', /** enum: [] */ },
+      layer: { type: 'string', /** pattern: "" */ },
+      layers: { type: 'string', /** pattern: "" */ },
+      sql: { type: 'number', minimum: 1, maximum: 4 },
+      pointZoom: { type: 'number', minimum: 1, maximum: 25 },
+    },
+  },
+};
+
+export const mapFeaturesPointSchema = {
+  params: {
+    type: 'object',
+    required: ['slug'],
+    properties: {
+      slug: {
+        type: 'string',
+      },
+    },
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      x: { type: 'number', minimum: -180, maximum: 180 }, // longitude
+      y: { type: 'number', minimum: -90, maximum: 90 }, // latitude
+      sql: { type: 'number', enum: [1] },
+    },
+  },
+};
+export const mapFeaturesSchema = {
+  params: {
+    type: 'object',
+    required: ['slug', 'id'],
+    properties: {
+      slug: {
+        type: 'string',
+      },
+      id: {
+        type: 'string', pattern: "^([\\d\\w_.-]+)$"
+      },
+    },
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      sql: { type: 'number', enum: [1] },
+    },
+  },
+};
+
+export const mapCatalogAttributeSchema = {
+  params: {
+    type: 'object',
+    required: ['service', 'attr'],
+    properties: {
+      service: {
+        type: 'string', pattern: "^([\\d\\w_.-]+)$"
+      },
+      attr: {
+        type: 'string', pattern: "^([\\d\\w_.-]+)$"
+      },
+    },
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      cls: { type: 'string', pattern: "^([\\d\\w_.-]+)$" },
+    },
+  },
+};
+
+export const vtileSchema = {
+  params: {
+    type: 'object',
+    properties: {
+      layer: {
+        type: 'string',
+      },
+      lang: {
+        type: 'string', enum: ['ua']
+      },
+      z: {
+        type: 'number',
+      },
+      y: {
+        type: 'number',
+      },
+      x: {
+        type: 'string',
+        pattern: '^\\d+\\.(pbf|vmt)$',
+      },
+    },
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      type: {
+        type: 'string', enum: ['point', 'polygon', 'line']
+      },
+      nocache: {
+        type: 'string', enum: ['1', 'true']
+      },
+      clusterZoom: {
+        type: 'number', minimum: 1, maximum: 25
+      },
+      nottl: {
+        type: 'string', enum: ['1', 'true']
+      },
+      filter: {
+        type: 'string'
+      },
+      all: {
+        type: 'string', enum: ['1', 'true']
+      },
+      sql: {
+        type: 'number', enum: [1]
+      },
+      pointZoom: {
+        type: 'number', minimum: 1, maximum: 25
+      },
+    }
+  }
+};
+
+export const clearTilesSchema = {
+  params: {
+    type: 'object',
+    properties: {
+      id: {
+        type: 'string', pattern: '^([\\d\\w]+)$'
+      },
+    },
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      debug: {
+        type: 'number', enum: [1]
+      },
+    }
+  }
+};
+
+export const mapSchema = {
+  params: {
+    type: 'object',
+    required: ['slug'],
+    properties: {
+      slug: {
+        type: 'string', pattern: "^([\\d\\w_.-]+)$"
+      },
+    },
+  },
+};
+
+export const geojsonSchema = {
+  params: {
+    type: 'object',
+    properties: {
+      layer: { type: 'string', pattern: "^([\\d\\w,.-_]+)$" },
+    }
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      sql: { type: 'number', enum: [1, 2] },
+      nocache: { type: 'number', enum: [1] },
+      srid: { type: 'number', minimum: 1 },
+      type: { type: 'string', enum: ['centroid'] },
+      extent: { type: 'string', pattern: "^([\\d\\s,.-]+)$" },
+    }
+  }
+};
+
+export const jsonDataSchema = {
+  params: {
+    type: 'object',
+    properties: {
+      layer: { type: 'string', pattern: "^([\\d\\w,.-_]+)$" },
+    }
+  },
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      sql: { type: 'number', enum: [1, 2] },
+      nocache: { type: 'number', enum: [1] },
+      page: { type: 'number', minimum: 1 },
+      limit: { type: 'number', minimum: 1, maximum: 1000 },
+      // where: { type: 'string' }, // ? possible sql injection
+    }
+  }
+};
+export const layerListSchema = {
+  querystring: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      sql: {
+        type: 'number', enum: [1]
+      }
+    }
+  }
+};
+
+export const parseGeoFileSchema = {
+  body: {
+    type: 'object',
+    additionalProperties: false,
+    required: ['content'],
+    properties: {
+      content: {
+        type: 'string'
+      },
+      filename: {
+        type: 'string'
+      }
+    }
+  }
+};
+
+export default null;

package/server/routes/mapnik/{controllers → functions}/clearTiles.js

@@ -1,6 +1,8 @@
 import { createHash } from 'node:crypto';
 
-import { config, logger, pgClients } from '@opengis/fastify-table/utils.js';
+import { config, pgClients } from '@opengis/fastify-table/utils.js';
+
+import { BadRequestError, NotFoundError, NotImplementedError } from '@opengis/fastify-table/errors.js';
 
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
 
@@ -22,26 +24,26 @@ const { ClearTile } = mapnik();
  */
 
 export default async function clearTiles({
-    pg = pgClients.client, params, query,
-}, reply) {
+    id, debug,
+}, pg = pgClients.client) {
     if (!ClearTile) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+        throw NotImplementedError('mapnik server address needed');
     }
 
-    if (!params.id) {
-        return reply.status(400).send({ error: 'not enough params: id', code: 400 });
+    if (!id) {
+        throw BadRequestError('not enough params: id');
     }
 
-    const decodedPath = Buffer.from(params.id, 'base64url').toString('utf-8');
+    const decodedPath = Buffer.from(id, 'base64url').toString('utf-8');
 
     const raster = pg.pk?.['gis.rasters']
         ? await pg.query(`select raster_id, source_path from gis.rasters where raster_id=$1::text union all
-        select raster_id, source_path from gis.rasters where source_path=$2::text`, [params.id, decodedPath]).then(el => el.rows?.[0] || {})
+        select raster_id, source_path from gis.rasters where source_path=$2::text`, [id, decodedPath]).then(r => r.rows?.[0] || {})
         : {};
 
     const carto = pg.pk?.['gis.cartocss']
         ? await pg.query(`select cartocss_id, source_path from gis.cartocss where cartocss_id=$1::text union all
-        select cartocss_id, source_path from gis.cartocss where source_path=$2::text`, [params.id, decodedPath]).then(el => el.rows?.[0] || {})
+        select cartocss_id, source_path from gis.cartocss where source_path=$2::text`, [id, decodedPath]).then(r => r.rows?.[0] || {})
         : {};
 
     if (!raster.raster_id && !carto.cartocss_id) {
@@ -49,7 +51,7 @@ export default async function clearTiles({
     }
 
     if (!raster.source_path && !carto.cartocss_id) {
-        return reply.status(404).send({ error: 'raster / cartocss not found', code: 404 });
+        throw NotFoundError('raster / cartocss not found');
     }
 
     const getParams = () => {
@@ -64,7 +66,7 @@ export default async function clearTiles({
 
     const { path: relpath, name } = getParams();
 
-    if (query.debug) {
+    if (debug) {
         const md5 = raster.source_path
             ? createHash('md5').update(raster.source_path).digest('hex')
             : undefined;
@@ -81,26 +83,21 @@ export default async function clearTiles({
         };
     }
 
-    try {
-        const data = await ClearTile({
-            path: relpath, // for rasters only
-            name, // for cartocss
-        });
-
-        // if empty directory not found (no tiles rendered yet)
-        if (data.result === 'skip') {
-            return reply.status(200).send({ message: 'tiles directory not found', code: 200 });
-        }
 
-        // if cache deleted or empty directory exists = ok
-        if (data.result === 'success') {
-            return reply.status(200).send({ message: 'ok', code: 200 });
-        }
+    const data = await ClearTile({
+        path: relpath, // for rasters only
+        name, // for cartocss
+    });
 
-        throw new Error(data.err);
+    // if empty directory not found (no tiles rendered yet)
+    if (data.result === 'skip') {
+        return { message: 'tiles directory not found', code: 200 };
     }
-    catch (err) {
-        logger.file('clearTiles/error', { error: err.toString(), stack: err.stack });
-        return reply.status(500).send({ error: config.local ? err.toString() : 'clearTiles error', code: 500 });
+
+    // if cache deleted or empty directory exists = ok
+    if (data.result === 'success') {
+        return { message: 'ok', code: 200 };
     }
+
+    throw new Error(data.err);
 }

package/server/routes/mapnik/{controllers → functions}/createXml.js

@@ -1,35 +1,34 @@
 import path from 'node:path';
 
-import { config, pgClients, eventStream } from '@opengis/fastify-table/utils.js';
+import { config, pgClients } from '@opengis/fastify-table/utils.js';
 
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+import { BadRequestError, NotFoundError, NotImplementedError } from '@opengis/fastify-table/errors.js';
 
 const { GetRasterStatus, CreateXML } = mapnik();
 
 export default async function createXml({
-    pg = pgClients.client, params, query,
-}, reply) {
+    id, vrt, debug, nocache, callback = () => { },
+}, pg = pgClients.client) {
     if (!GetRasterStatus || !CreateXML) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+        throw NotImplementedError('mapnik server address needed');
     }
 
-    const { id } = params;
-
     if (!id) {
-        return reply.status(400).send({ error: 'not enough params: id', code: 400 });
+        throw BadRequestError('not enough params: id');
     }
 
     const data = pg.pk?.['gis.rasters']
         ? await pg.query('select raster_id as id, source_path, srid, raster_zoom from gis.rasters where raster_id=$1::text', [id])
-            .then(el => el.rows?.[0])
+            .then(r => r.rows?.[0])
         : null;
 
     if (!data?.id) {
-        return reply.status(404).send({ error: 'raster not found', code: 404 });
+        throw NotFoundError('raster not found')
     }
 
     if (!data.source_path) {
-        return reply.status(400).send({ error: 'raster source_path not set', code: 400 });
+        throw BadRequestError('raster source_path not set');
     }
 
     // const relpath = `/map/raster/${data.source_path}`;
@@ -39,16 +38,14 @@ export default async function createXml({
     const uploadStatus = path.extname(data.source_path) ? await GetRasterStatus({ path: relpath }) : {};
 
     if (uploadStatus.exists === false) {
-        return reply.status(400).send({ error: 'raster not uploaded', code: 400 });
+        throw BadRequestError('raster not uploaded');
     }
 
     if (uploadStatus.finished === false) {
-        return reply.status(400).send({ error: 'upload not finished', code: 400 });
+        throw BadRequestError('upload not finished');
     }
 
-    const callback = eventStream(reply);
-
-    const proj4 = data.srid && pg.pk?.['public.spatial_ref_sys'] ? await pg.query('select proj4text from public.spatial_ref_sys where srid=$1', [data.srid]).then(el => el.rows?.[0]?.proj4text) : undefined;
+    const proj4 = data.srid && pg.pk?.['public.spatial_ref_sys'] ? await pg.query('select proj4text from public.spatial_ref_sys where srid=$1', [data.srid]).then(r => r.rows?.[0]?.proj4text) : undefined;
 
     // create at xml/:id with name only, always - by path
     const resp = await CreateXML({
@@ -57,11 +54,11 @@ export default async function createXml({
         previewZoom: data.raster_zoom, // preview<=>detailed, default = 16 if file size > 1GB
         // srid: data.srid, // auto detected if not supplied
         proj4,
-        vrt: query.vrt, // force vrt even if relpath leads to single raster file
-        debug: query.debug, // stream debug info
-        nocache: query.nocache, // recreate if exists
+        vrt, // force vrt even if relpath leads to single raster file
+        debug, // stream debug info
+        nocache, // recreate if exists
     }, callback);
 
-    callback('finish', 1);
-    return reply.status(200).send(resp);
+    callback('finish', true);
+    return resp;
 }

package/server/routes/mapnik/{controllers → functions}/createXmlMulti.js

@@ -3,6 +3,7 @@ import {
 } from '@opengis/fastify-table/utils.js';
 
 import checkRasterFile from '../../../plugins/mapnik/funcs/checkRasterFile.js';
+import { NotFoundError, NotImplementedError } from '@opengis/fastify-table/errors.js';
 
 // todo: add to kamianske, remove custom api and test
 // addHook('beforeCreateXmlMulti', ({ list = [], id }) => {
@@ -22,20 +23,14 @@ import checkRasterFile from '../../../plugins/mapnik/funcs/checkRasterFile.js';
 // });
 
 export default async function createXmlMulti({
-    pg = pgClients.client, params, query,
-}, reply) {
+    id, nocache, callback = () => { }
+}, pg = pgClients.client) {
     if (!config.mapnik?.server) {
-        return reply.code(400).send({
-            error: 'mapnik grpc service address not set',
-            code: 400,
-        });
+        throw NotImplementedError('mapnik grpc service address not set');
     }
 
     if (config.ready?.mapnik !== true) {
-        return reply.code(400).send({
-            error: 'mapnik grpc service not ready',
-            code: 400,
-        });
+        return NotImplementedError('mapnik grpc service not ready');
     }
 
     const list = [{
@@ -43,18 +38,19 @@ export default async function createXmlMulti({
         relpath: 'source_path',
         table: 'gis.rasters',
         srid: 'srid',
-        query: `source_path is not null ${params.id ? ` and raster_id = '${params.id}'` : ''}`,
+        query: `source_path is not null ${id ? ` and raster_id = $1` : ''}`,
+        args: [id].filter(Boolean)
     }];
 
-    applyHookSync('beforeCreateXmlMulti', { list, id: params.id });
+    applyHookSync('beforeCreateXmlMulti', { list, id });
 
     const rows = await Promise.all(list.filter(el => el.id && el.table && el.relpath).map(async el => pg.query(el.q ? `select ${el.id} as id, ${el.relpath} as relpath, '${el.table}' as table from (${el.q})q` : `select ${el.id} as id, ${el.relpath} as relpath, '${el.table}' as table, ${el.srid || ''} as srid from ${el.table} where ${el.query || 'true'}`).then(e => e.rows || []))).then(e => e.flat());
 
     if (!rows.length) {
-        return reply.status(404).send({ error: 'empty rows', code: 404 });
+        throw NotFoundError('empty rows');
     }
 
-    const results = await checkRasterFile({ rows, reply, nocache: query.nocache });
+    const results = await checkRasterFile({ rows, callback, nocache });
 
     const q = Object.keys(results || {}).filter(key => results[key] && results[key].extent).map(key => {
         const { extent } = results[key];
@@ -72,5 +68,5 @@ export default async function createXmlMulti({
 
     if (q.length) await pg.query(q.join(';\n'));
 
-    return reply.status(200).send('all finished');
+    return 'all finished';
 }

package/server/routes/mapnik/{controllers → functions}/fileSearch.js

@@ -1,6 +1,7 @@
 import { config } from '@opengis/fastify-table/utils.js';
 
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+import { BadRequestError, NotImplementedError } from '@opengis/fastify-table/errors.js';
 
 const { FileSearch } = mapnik();
 
@@ -8,21 +9,17 @@ const maxLimit = 100;
 
 // example: GET /api/gis-file-search?dir=raster/dpt&key=Аркуш_5_1_изм_ДПТ_смт_Карнаухівка_А2_modified_k
 export default async function fileSearch({
-    query,
-}, reply) {
+    dir, key, period, size, page, limit: queryLimit,
+}) {
     if (!FileSearch) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+        throw NotImplementedError('mapnik server address needed');
     }
 
-    const {
-        dir, key, period, size, page,
-    } = query;
-
-    const limit = Math.min(query.limit || 16, maxLimit);
+    const limit = Math.min(queryLimit || 16, maxLimit);
     const offset = page && page > 0 ? (page - 1) * limit : 0;
 
     if (!key && !period && !size) {
-        return reply.status(400).send({ error: 'not enough query params: key / period / size', code: 400 });
+        throw BadRequestError('not enough query params: key / period / size');
     }
 
     const relpath = `raster/${[config.mapnik?.folder, dir].filter(Boolean).join('/')}`;

package/server/routes/mapnik/functions/fileStat.js

@@ -0,0 +1,28 @@
+import { config } from '@opengis/fastify-table/utils.js';
+
+import { BadRequestError, NotImplementedError } from '@opengis/fastify-table/errors.js';
+
+import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+
+const { FileStat } = mapnik();
+
+// example: GET /api/gis-file-info?path=raster/henplan_osnovne_kreslennia.tif
+export default async function fileStat({
+    path: queryPath,
+}) {
+    if (!config.mapnik?.server) {
+        throw NotImplementedError('mapnik server not configured');
+    }
+
+    if (config.ready?.mapnik !== true) {
+        throw NotImplementedError('mapnik server not ready');
+    }
+
+    if (!queryPath) {
+        throw BadRequestError('not enough query params: path');
+    }
+
+    const relpath = `raster/${[config.mapnik?.folder, queryPath].filter(Boolean).join('/')}`;
+    const data = await FileStat({ path: relpath });
+    return { data };
+}