@opengis/gis 0.2.168 → 0.2.170

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

@@ -1,18 +1,19 @@
-import SphericalMercator from '@mapbox/sphericalmercator';
+import { SphericalMercator } from '@mapbox/sphericalmercator';
 
 import {
-  config, logger, eventStream, pgClients,
+  config, logger, pgClients,
 } from '@opengis/fastify-table/utils.js';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 
-import convertBoundToTile from '../functions/convertBoundToTile.js';
+import convertBoundToTile from './convertBoundToTile.js';
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
-import cartoBounds from '../functions/cartoBounds.js';
-import rasterInfo from './rasterInfo.js';
-
-const { RenderTile } = mapnik();
+// import cartoBounds from '../functions/cartoBounds.js';
+// import rasterInfo from './rasterInfo.js';
 
 const mercator = new SphericalMercator({ size: 256 });
 
+const { RenderTile } = mapnik();
+
 const MAX_LIMIT = 100000;
 
 const CONCURRENCY = 5;
@@ -39,35 +40,31 @@ async function runPool(tasks, limit) {
 const maxBounds = [23, 44, 40, 53];
 
 export default async function pretile({
-  pg = pgClients.client, params, query,
-}, reply) {
-  const { zoom = 11, max = 15 } = query || {};
-
+  id, zoom = 11, max = 15, callback = () => { },
+}, pg = pgClients.client) {
   if (zoom > max) {
-    return reply.status(422).send({ error: 'Error: querystring/max must be > querystring/zoom', code: 422 });
+    throw BadRequestError('Error: querystring/max must be > querystring/zoom');
   }
 
-  const data = await pg.query(`select *, geom::box2d as bounds, 'raster' as source_type from gis.rasters where raster_id=$1`, [params.id]).then(el => el.rows?.[0])
-    || await pg.query(`select *, geom::box2d as bounds, 'css' as source_type from gis.cartocss where cartocss_id=$1`, [params.id]).then(el => el.rows?.[0]);
+  const data = await pg.query(`select *, geom::box2d as bounds, 'raster' as source_type from gis.rasters where raster_id=$1`, [id]).then(r => r.rows?.[0])
+    || await pg.query(`select *, geom::box2d as bounds, 'css' as source_type from gis.cartocss where cartocss_id=$1`, [id]).then(r => r.rows?.[0]);
 
   if (!data) {
-    return reply.status(404).send({ error: 'not found', code: 404 });
+    throw NotFoundError('raster/css not found');
   }
 
   if (!data.bounds || data.bounds === 'BOX(-180 -85.05112877980659,180 85.05112877980659)') {
-    return reply.status(400).send({ error: 'geom is not set', code: 400 });
+    throw BadRequestError('geom is not set');
   }
 
-  const send = eventStream(reply);
-
   try {
     const relpath = data.source_type === 'raster' ? ['raster', config.mapnik?.folder, data.source_path].filter(Boolean).join('/') : null;
-    const name = data.source_type === 'css' ? ['vector', config.mapnik?.folder || '', data.source_path || params.id].filter(Boolean).join('/') : null;
+    const name = data.source_type === 'css' ? ['vector', config.mapnik?.folder || '', data.source_path || id].filter(Boolean).join('/') : null;
 
     // refresh extent
     const bounds = data.bounds.replace(')', '').substr(4).split(/[, ]/g).map((el) => el - 0);
 
-    send(`start: ${data.name} ${params.id} ${bounds} ${data.srid} ${data.proj4}`);
+    callback(`start: ${data.name} ${id} ${bounds} ${data.srid} ${data.proj4}`);
 
     bounds[0] = Math.max(bounds[0], maxBounds[0]);
     bounds[1] = Math.max(bounds[1], maxBounds[1]);
@@ -75,7 +72,7 @@ export default async function pretile({
     bounds[2] = Math.min(bounds[2], maxBounds[2]);
     bounds[3] = Math.min(bounds[3], maxBounds[3]);
 
-    send({
+    callback({
       bounds, minzoom: zoom, maxzoom: max, maxBounds,
     });
 
@@ -83,12 +80,12 @@ export default async function pretile({
       bounds, minzoom: zoom, maxzoom: max, mercator,
     });
 
-    send(tiles);
+    callback(tiles);
 
     const tileLen = tiles.reduce((acc, el) => acc + el.count, 0);
 
     if (tileLen > MAX_LIMIT) {
-      send({ MAX_LIMIT });
+      callback({ MAX_LIMIT });
     }
 
     let tileNum = 0;
@@ -106,8 +103,8 @@ export default async function pretile({
         return ys.map((y) => async () => {
           if (tileNum > MAX_LIMIT) return;
 
-          const tilePath = `${params.id}/${z}/${x}/${y}.png`;
-          send(`Start ${tileNum + 1}/${tileLen} ${tilePath}`);
+          const tilePath = `${id}/${z}/${x}/${y}.png`;
+          callback(`Start ${tileNum + 1}/${tileLen} ${tilePath}`);
 
           const time = Date.now();
 
@@ -115,12 +112,12 @@ export default async function pretile({
           const render = await RenderTile({ path: relpath, name, bbox });
 
           if (render?.err) {
-            send(render.err);
+            callback(render.err);
             return;
           }
 
-          send(
-            `${tileNum + 1}/${tileLen} ${config.local || config.debug ? render.tile_path : params.id} len:${render.base64.length} cache: ${!!render?.cache} time:${Date.now() - time}ms`,
+          callback(
+            `${tileNum + 1}/${tileLen} ${config.local || config.debug ? render.tile_path : id} len:${render.base64.length} cache: ${!!render?.cache} time:${Date.now() - time}ms`,
           );
           tileNum += 1;
         });
@@ -129,16 +126,13 @@ export default async function pretile({
 
     await runPool(tasks, CONCURRENCY);
 
-    send('OK');
+    callback('OK');
     return 'OK';
   }
   catch (err) {
     const error = config.local || config.debug ? err.toString() : 'pretile error';
-    send(error);
-    logger.file('pretile.error', { error: err.toString(), stack: err.stack, id: params.id });
-    return reply.status(500).send({ error, code: 500 });
-  }
-  finally {
-    send('finish', true);
+    callback(error);
+    logger.file('pretile.error', { error: err.toString(), stack: err.stack, id });
+    throw err;
   }
 }

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

@@ -1,6 +1,7 @@
 import { config, pgClients } from '@opengis/fastify-table/utils.js';
 
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+import { BadRequestError, NotImplementedError } from '@opengis/fastify-table/errors.js';
 
 const { GetRasterInfo } = mapnik();
 
@@ -8,28 +9,36 @@ const { prefix = '/api' } = config;
 
 // example: GET /api/gis-raster/9be8f8c51746
 export default async function rasterInfo({
-    pg = pgClients.client, params, query,
-}, reply) {
+    id, debug,
+}, pg = pgClients.client) {
     const time = Date.now();
+
+    if (!id) {
+        throw NotImplementedError('not enough params: id');
+    }
+
     if (!config.mapnik?.server) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+        throw NotImplementedError('mapnik server address needed');
     }
 
     const raster = pg.pk?.['gis.rasters']
-        ? await pg.query('select raster_id, source_path, name, description, raster_key, is_active, is_public, srid, proj4, geom from gis.rasters where raster_id=$1::text', [params.id])
-            .then(el => el.rows?.[0] || {})
+        ? await pg.query('select raster_id, source_path, name, description, raster_key, is_active, is_public, srid, proj4, st_asgeojson(geom)::json as geom from gis.rasters where raster_id=$1::text', [id])
+            .then(r => r.rows?.[0] || {})
         : {};
 
     if (raster.raster_id && !raster.source_path) {
-        return reply.status(400).send({ error: 'empty source_path', code: 400 });
+        throw BadRequestError('empty source_path');
     }
 
     if (!raster.raster_id) {
-        const decodedPath = Buffer.from(params.id, 'base64url').toString('utf-8');
+        const decodedPath = Buffer.from(id, 'base64url').toString('utf-8');
         Object.assign(raster, { source_path: decodedPath });
     }
 
-    const proj4 = raster.proj4 || (raster.srid && pg.pk?.['public.spatial_ref_sys'] ? await pg.query('select proj4text from public.spatial_ref_sys where srid=$1', [raster.srid]).then(el => el.rows?.[0]?.proj4text) : undefined);
+    const proj4 = raster.proj4
+        || (raster.srid && pg.pk?.['public.spatial_ref_sys']
+            ? await pg.query('select proj4text from public.spatial_ref_sys where srid=$1', [raster.srid]).then(r => r.rows?.[0]?.proj4text)
+            : undefined);
 
     const relpath = ['raster', config.mapnik?.folder, raster.source_path].filter(Boolean).join('/');
 
@@ -38,12 +47,12 @@ export default async function rasterInfo({
         proj4,
     }).catch(err => ({ error: err.toString() }));
 
-    if (query.debug) {
+    if (debug) {
         return { data, cache, raster };
     }
 
     if (!raster.geom && Array.isArray(data?.extent)) {
-        await pg.query(`update gis.rasters set geom = ST_MakeEnvelope(${data.extent.join(',')}) where raster_id = $1`, [raster.raster_id]);
+        await pg.query(`update gis.rasters set geom = ST_MakeEnvelope($2,$3,$4,$5) where raster_id = $1`, [raster.raster_id, ...data.extent]);
     }
 
     return {

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

@@ -1,4 +1,5 @@
 import { config } from '@opengis/fastify-table/utils.js';
+import { NotImplementedError } from '@opengis/fastify-table/errors.js';
 
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
 
@@ -6,13 +7,12 @@ const { ReadDir } = mapnik();
 
 // example: GET /api/gis-files?dir=raster/genplan
 export default async function readDir({
-    query,
-}, reply) {
+    dir,
+}) {
     if (!ReadDir) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+        throw NotImplementedError('mapnik server address needed');
     }
 
-    const { dir } = query;
     const relpath = `raster/${[config.mapnik?.folder, dir].filter(Boolean).join('/')}`;
 
     const {

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

@@ -0,0 +1,164 @@
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+import { SphericalMercator } from '@mapbox/sphericalmercator';
+
+const mercator = new SphericalMercator({ size: 256 });
+
+import {
+    config, logger, pgClients,
+} from '@opengis/fastify-table/utils.js';
+
+import { BadRequestError, ForbiddenError, NotFoundError } from '@opengis/fastify-table/errors.js';
+
+import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+
+const { RenderTile } = mapnik();
+
+const meta = !!config?.mapnik?.meta;
+
+/**
+ * Формування растрового tile cartoCss
+ *
+ * @method GET
+ * @alias rtile
+ * @param {String} bbox - bbox
+ * @param {Number} height - висота по координатам
+ * @param {Number} width - ширина по координатам
+ * @param {String} data - стилізація
+ * @param {String} lang - мова
+ * @param {String} z - координата z
+ * @param {String} x - координата y
+ * @param {String} y - координата x
+ */
+
+export default async function gisRtile({
+    id, z, y, x, debug, nocache, nottl, uid,
+}, pg = pgClients.client) {
+    if (!RenderTile) {
+        throw BadRequestError('mapnik server address needed');
+    }
+
+    if (!id) {
+        throw BadRequestError('not enough params: id');
+    }
+
+    if (!x || !y || !z) {
+        throw BadRequestError('not enough params: xyz');
+    }
+
+    const decodedPath = Buffer.from(id, 'base64url').toString('utf-8');
+
+    const data = pg.pk?.['gis.rasters']
+        ? await pg.queryCache(`select raster_id as id, source_path, is_public, 'raster' as type from gis.rasters where raster_id=$1::text or source_path=$2::text`, { args: [id, decodedPath], table: 'gis.rasters' })
+            .then(r => r.rows?.[0] || {})
+        : {};
+
+    const carto = pg.pk?.['gis.cartocss']
+        ? await pg.queryCache('select cartocss_id, source_path, is_public, is_static from gis.cartocss where cartocss_id=$1::text', { args: [id], table: 'gis.cartocss' }).then(r => r.rows?.[0] || {})
+        : {};
+
+    if (carto.cartocss_id) {
+        Object.assign(data, {
+            id: carto.cartocss_id,
+            source_path: carto.source_path,
+            is_public: carto.is_public,
+            is_static: carto.is_static,
+            type: 'css',
+        });
+    }
+
+    if (!uid && !config.local && data.is_public === false && process.env.NODE_ENV !== 'test' && !process.env.VITEST) {
+        throw ForbiddenError('access restricted');
+    }
+
+    if (!data.id && data.type !== 'css') {
+        Object.assign(data, { source_path: decodedPath });
+    }
+
+    if (!data.source_path && data.type !== 'css') {
+        throw NotFoundError('raster / cartocss not found');
+    }
+
+    const bbox = mercator.bbox(y, x, z, false, '900913');
+
+    const ttl = (nocache ? '0' : null)
+        || (data.type === 'css' && !data.is_static ? '1w' : null);
+
+    const md5 = data.source_path
+        ? createHash('md5').update(data.source_path).digest('hex')
+        : undefined;
+    const base64 = data.source_path
+        ? Buffer.from(data.source_path).toString('base64url')
+        : undefined;
+
+    const getParams = () => {
+        if (data.type === 'css' && data.source_path) {
+            return { name: path.posix.join('vector', config.mapnik?.folder || '', data.source_path) };
+        }
+        if (data.type === 'css') {
+            return { name: path.posix.join('xml', config.mapnik?.folder || '', id) };
+        }
+        return { path: path.posix.join('raster', config.mapnik?.folder || '', data.source_path) };
+    };
+
+    const { path: rpath, name } = getParams();
+
+    const param = {
+        path: rpath, // for rasters only
+        name, // required for cartocss
+        width: 256,
+        bbox,
+        ttl,
+        format: 'webp',
+        meta,
+        base64: false,
+        debug,
+    };
+
+    const result = await RenderTile(param);
+
+    if (result.err) {
+        logger.file('rtile/error', {
+            error: result.err, x, y, z, id: data.id, type: data.type,
+        });
+        throw new Error(result.err);
+    }
+
+    if (meta) {
+        const accelPath = result.tile_path?.startsWith('/') ? result.tile_path : `/${result.tile_path}`;
+        const metaHeaders = {
+            'Content-Type': 'image/webp',
+            'Cache-Control': nocache || nottl ? 'no-store, no-cache, must-revalidate' : 'public, max-age=2592000',
+            'X-Accel-Redirect': accelPath,
+        };
+        if (debug) {
+            return {
+                headers: metaHeaders,
+                base64: result.base64,
+                z,
+                x,
+                y,
+            };
+        }
+        return { headers: metaHeaders, code: 204 };
+    }
+
+    if (debug) {
+        return {
+            ...result,
+            name,
+            path: rpath,
+            ttl,
+            md5_path: md5,
+            base64_path: base64,
+            raster: !!data.id,
+            carto: data.type === 'css',
+            is_static: data.type === 'css' ? data.is_static : true,
+        };
+    }
+
+    const buffer = result.data || Buffer.from(result.base64, 'base64');
+
+    return { headers: { 'Content-Type': 'image/webp', 'Cache-Control': nocache || nottl ? 'no-store, no-cache, must-revalidate' : 'public, max-age=2592000' }, data: buffer };
+}

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

@@ -3,9 +3,11 @@ import { ListObjectsV2Command } from '@aws-sdk/client-s3';
 
 /* eslint-disable no-await-in-loop */
 import {
-    config, isFileExists, logger, pgClients, eventStream, downloadFile, s3Client,
+    config, isFileExists, logger, pgClients, downloadFile, s3Client,
 } from '@opengis/fastify-table/utils.js';
 
+import { BadRequestError, NotFoundError, NotImplementedError } from '@opengis/fastify-table/errors.js';
+
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
 
 const { UploadRaster, GetRasterStatus } = mapnik();
@@ -26,7 +28,7 @@ async function uploadRasterFile({
     id, prefix, relpath: relpathOriginal, callback = () => { },
 }) {
     const metadata = await isFileExists(relpathOriginal);
-    const relpath = relpathOriginal.replace(config.folder, '').replace(prefix, '');
+    const relpath = ['raster', config.mapnik?.folder || '', relpathOriginal.replace(/\/\//, '/').replace(config.folder, '')].join('/');
 
     let offset = 0;
 
@@ -95,29 +97,27 @@ async function uploadRasterFile({
 }
 
 export default async function uploadRaster({
-    pg = pgClients.client, params,
-}, reply) {
+    id, callback = () => { },
+}, pg = pgClients.client) {
     if (!UploadRaster || !GetRasterStatus) {
-        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 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 prefix = '/map/raster';
@@ -129,29 +129,24 @@ export default async function uploadRaster({
             Prefix: path.join(config.folder, relpath).replace(/\\/g, '/'),
         }));
         if (!metadata.Contents?.length) {
-            return reply.status(404).send({
-                error: 'invalid: raster source_path: not found / empty directory',
-                code: 404,
-            });
+            throw NotFoundError('invalid: raster source_path: not found / empty directory');
         }
 
         // list rasters, skip preview subdir content, skip folders from s3 directory name of which only starts with same characters, but does not exactly match
         const files = metadata.Contents.map(file => file.Key).filter((file) => path.basename(path.dirname(file)) === path.basename(relpath) && !path.basename(path.dirname(file)).startsWith('preview') && path.extname(file).toLowerCase() === '.tif');
 
         if (!files.length) {
-            return reply.status(400).send({
-                error: 'invalid: raster source_path: no raster files at directory',
-                code: 400,
-            });
+            throw BadRequestError('invalid: raster source_path: no raster files at directory');
         }
-        const callback = eventStream(reply);
+
         await sequence(files, { id, prefix, callback }, uploadRasterFile);
-        return callback('finish', 1);
+        return 'uploaded';
     }
 
-    const callback = eventStream(reply);
+
     await uploadRasterFile({
-        id, prefix, callback, relpath,
+        id, prefix, callback, relpath: data.source_path,
     });
-    return callback('finish', 1);
+
+    return 'uploaded';
 }

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

@@ -18,6 +18,7 @@ const getGeomColumn = (geoms, customColumn) => {
 };
 
 import cartoBounds from './cartoBounds.js';
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
 
 function cartoData(el, extent, pg) {
     const minzoom = el.minzoom ? (+el.minzoom || 5) : 5;
@@ -53,6 +54,32 @@ export default async function uploadXML({
     if (!id || !dataset?.length || Array.isArray(dataset) === false) {
         return null;
     }
+
+    const tlist = await pg
+        .query(
+            `SELECT
+        array_agg(
+          (
+            SELECT
+              nspname
+            FROM
+              pg_namespace
+            WHERE
+              oid = relnamespace
+          ) || '.' || relname
+        ) tlist
+      FROM
+        pg_class
+      WHERE
+        relkind IN ('r', 'v', 'm')`
+        )
+        .then((d) => d.rows[0].tlist);
+
+    const { table: missingTable } = dataset.find(el => el.active !== false && el.table && !tlist.includes(el.table)) || {};
+    if (missingTable) {
+        throw NotFoundError('table not found: ' + missingTable);
+    }
+
     await Promise.all(dataset.filter((el) => el.active !== false).map(async el => {
         const { table } = el;
 

package/server/routes/mapnik/mapnik.route.js

@@ -0,0 +1,102 @@
+import { eventStream } from '@opengis/fastify-table/utils.js';
+
+import uploadRaster from './functions/uploadRaster.js';
+import createXml from './functions/createXml.js';
+import rtile from './functions/rtile.js';
+import rasterInfo from './functions/rasterInfo.js';
+
+import createXmlMulti from './functions/createXmlMulti.js';
+import readDir from './functions/readDir.js';
+import fileStat from './functions/fileStat.js';
+import fileSearch from './functions/fileSearch.js';
+import clearTiles from './functions/clearTiles.js';
+import pretile from './functions/pretile.js';
+
+import {
+  pretileSchema,
+  uploadRasterSchema,
+  gisXmlSchema,
+  gisRtileSchema,
+  gisRasterSchema,
+  createXmlMultiSchema,
+  readDirSchema,
+  fileStatSchema,
+  fileSearchSchema,
+  clearTilesSchema,
+} from './mapnik.schema.mjs';
+
+const publicParams = { config: { policy: 'L0' }, package: 'gis' }; // L0 === public
+const adminParams = { config: { role: 'admin' }, package: 'gis' };
+const privateParams = { config: { policy: 'L1' }, package: 'gis' }; // L1 === authorized only
+
+export default function route(app) {
+  app.get('/gis-upload-raster/:id', { ...privateParams, schema: uploadRasterSchema }, async ({ params, pg }, reply) => {
+    const callback = process.env.NODE_ENV === 'test' || process.env.VITEST ? console.log : eventStream(reply);
+    const result = await uploadRaster({ id: params.id, callback }, pg).catch(err => ({ error: err.toString() }));
+    callback(result?.error || 'finish', true);
+    return result;
+  });
+  app.get('/gis-xml/:id', { ...publicParams, schema: gisXmlSchema }, async ({ params, query }, reply) => {
+    const callback = process.env.NODE_ENV === 'test' || process.env.VITEST ? console.log : eventStream(reply);
+    const result = await createXml({ id: params.id, vrt: query.vrt, debug: query.debug, nocache: query.nocache, callback }).catch(err => ({ error: err.toString() }));
+    callback(result?.error || 'finish', true);
+    return result;
+  });
+  app.get('/gis-rtile/:id/:z/:y/:x', { ...publicParams, schema: gisRtileSchema }, async ({ params, query, user, pg }, reply) => {
+    const result = await rtile({
+      id: params.id,
+      z: params.z,
+      y: params.y,
+      x: params.x.split('.')[0] - 0,
+      uid: user?.uid,
+      debug: query.debug,
+      nocache: query.nocache,
+      nottl: query.nottl,
+    }, pg);
+    if (query.debug) {
+      return result;
+    }
+
+    if (result.code === 204) {
+      return reply.headers(result.headers).code(204).send();
+    }
+
+    return reply.headers(result.headers).send(result.data);
+  });
+  app.get('/gis-raster/:id', { ...publicParams, schema: gisRasterSchema }, async ({ params, query, pg }) => {
+    const result = await rasterInfo({ id: params.id, debug: query.debug }, pg);
+    return result;
+  });
+
+  app.get('/gis-create-xml/:id?', { ...adminParams, schema: createXmlMultiSchema }, async ({ params, query, pg }, reply) => {
+    const callback = process.env.NODE_ENV === 'test' || process.env.VITEST ? console.log : eventStream(reply);
+    const result = await createXmlMulti({
+      id: params.id, nocache: query.nocache, callback
+    }, pg).catch(err => ({ error: err.toString() }));
+    callback(result?.error || 'finish', true);
+    return result;
+  });
+  app.get('/gis-files', { ...adminParams, schema: readDirSchema }, async ({ query }) => {
+    const result = await readDir({ dir: query.dir });
+    return result;
+  });
+  app.get('/gis-file-info', { ...adminParams, schema: fileStatSchema }, async ({ query }) => {
+    const result = await fileStat({ path: query.path });
+    return result;
+  });
+  app.get('/gis-file-search', { ...adminParams, schema: fileSearchSchema }, async ({ query }) => {
+    const { dir, key, period, size, page, limit } = query;
+    const result = await fileSearch({ dir, key, period, size, page, limit });
+    return result;
+  });
+  app.get('/gis-clear-rtile/:id', { ...adminParams, schema: clearTilesSchema }, async ({ params, query }) => {
+    const result = await clearTiles({ id: params.id, debug: query.debug });
+    return result;
+  });
+  app.get('/gis-pretile/:id', { ...adminParams, schema: pretileSchema }, async ({ params, query, pg }, reply) => {
+    const callback = process.env.NODE_ENV === 'test' || process.env.VITEST ? console.log : eventStream(reply);
+    const result = await pretile({ id: params.id, zoom: query.zoom, max: query.max, callback }, pg).catch(err => ({ error: err.toString() }));
+    callback(result?.error || 'finish', true);
+    return result;
+  });
+}