@opengis/gis 0.2.168 → 0.2.169

package/server/routes/gis/services/create.route.js

@@ -1,96 +0,0 @@
-const ROUTE_URL = 'https://data.gki.com.ua/api/osrm-routes'
-
-function parseCoordPair(raw) {
-  const [lngRaw, latRaw] = String(raw || '').split(',')
-  const lng = Number(lngRaw)
-  const lat = Number(latRaw)
-
-  if (
-    !Number.isFinite(lng)
-    || !Number.isFinite(lat)
-    || lng < -180
-    || lng > 180
-    || lat < -90
-    || lat > 90
-  ) {
-    throw new Error('invalid coordinate')
-  }
-
-  return [lng, lat]
-}
-
-function buildRoutePoints(from, to, via) {
-  const points = [parseCoordPair(from)]
-  if (via) {
-    for (const segment of String(via).split(';')) {
-      const trimmed = segment.trim()
-      if (trimmed) points.push(parseCoordPair(trimmed))
-    }
-  }
-  points.push(parseCoordPair(to))
-  return points
-}
-
-function routeOptionsQuery(query) {
-  const params = new URLSearchParams()
-  for (const key of ['optimize', 'surface', 'weight', 'mode']) {
-    const value = typeof query?.[key] === 'string' ? query[key].trim() : ''
-    if (value) params.set(key, value)
-  }
-  const qs = params.toString()
-  return qs ? `&${qs}` : ''
-}
-
-function buildSegmentsBody(points) {
-  const segments = []
-  for (let i = 0; i < points.length - 1; i += 1) {
-    segments.push([
-      [points[i][0], points[i][1]],
-      [points[i + 1][0], points[i + 1][1]],
-    ])
-  }
-  return JSON.stringify(segments)
-}
-
-export default async function createRouteHandler(req, reply) {
-  try {
-    const points = buildRoutePoints(req.query.from, req.query.to, req.query.via)
-    const url = `${ROUTE_URL}?steps=true&alternatives=true${routeOptionsQuery(req.query)}`
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Accept: 'application/json',
-      },
-      body: buildSegmentsBody(points),
-      signal: AbortSignal.timeout(10_000),
-    }).catch(error => ({
-      ok: false,
-      status: 502,
-      headers: new Headers({ 'content-type': 'application/json' }),
-      text: async () => JSON.stringify({ error: String(error), code: 502 }),
-    }))
-
-    const contentType = response.headers?.get?.('content-type') || 'application/json'
-    const text = await response.text()
-    let payload = text
-
-    if (contentType.includes('application/json')) {
-      try {
-        payload = text ? JSON.parse(text) : null
-      } catch {
-        payload = text
-      }
-    }
-
-    return reply
-      .status(response.status || 200)
-      .header('Content-Type', contentType)
-      .send(payload)
-  } catch (err) {
-    const message = err?.message || 'external route provider request failed'
-    const statusCode = /invalid coordinate/i.test(message) ? 400 : 502
-    return reply.status(statusCode).send({ error: message, code: statusCode })
-  }
-}

package/server/routes/gis/services/get.services.col.js

@@ -1,33 +0,0 @@
-import { metaFormat, pgClients, getTemplate } from '@opengis/fastify-table/utils.js';
-
-export default async function getServicesCol({ params = {}, pg = pgClients.client }, reply) {
-  const row = await getTemplate('layer', params.id) || await pg.query(`
-           SELECT 
-               service_id, source_path, attributes
-           FROM gis.services where ${params.id ? 'service_id=$1' : '1=1'}
-       `, [params.id].filter(Boolean)).then(el => el.rows[0] || {});
-
-  if (!row.source_path) {
-    return reply.status(404).send({ code: 404, message: 'source not found' });
-  }
-
-  const fields = await pg.query(` SELECT *  FROM ${row.source_path} limit 0`).then(el => el.fields);
-  const field = fields.find(el => el.name === params.col);
-
-  if (!field) {
-    return reply.status(404).send({ message: { error: 'column not found', fields }, code: 404 });
-  }
-
-  const rows = await pg.query(`SELECT ${params.col}::text as id, ${params.col}, count(*) FROM ${row.source_path} 
-        where ${params.col} is not null group by ${params.col} order by count(*) desc limit 10`).then(el => el.rows || []);
-
-  const cls = row.attributes?.filter?.((col) => col.name && col.data && ['select', 'badge', 'tags'].includes(col.format)).reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {}) || {};
-
-  await metaFormat({ rows, table: row.source_path, cls });
-
-  const rows1 = rows.map(row => ({
-    ...row[`${params.col}_data`], ...row, [`${params.col}_data`]: undefined, [params.col]: undefined,
-  }));
-
-  return reply.status(200).send({ rows: rows1, field, fields });
-}

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

@@ -1,56 +0,0 @@
-import { pgClients, getMeta, getSelect, getSelectVal } from "@opengis/fastify-table/utils.js";
-
-export default async function mapCatalogAttribute({ pg = pgClients.client, params = {}, query = {} }, reply) {
-    const { service, attr } = params;
-    if (!service) {
-        return reply.status(404).send('not enough params: service');
-    }
-
-    if (!attr) {
-        return reply.status(404).send('not enough params: attr');
-    }
-
-    if (!pg.pk?.['gis.services']) {
-        return reply.status(404).send('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',
-        [params.service]
-    ).then(el => el.rows?.[0]?.source_path);
-
-    if (!source) {
-        return reply.status(404).send('service not found');
-    }
-
-    const cls = await getSelect(query.cls || attr, pg);
-    const colname = query.cls ? attr : attr.split(':').pop();
-
-    if (!colname) {
-        return reply.status(400).send('invalid params: attr');
-    }
-
-    const { columns = [] } = await getMeta({ pg, table: source });
-    const { dataTypeID } = columns.find(el => el.name === colname) || {};
-
-    const q = 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);
-
-    const ids = countArr.rows.map(el => el.id);
-
-    const clsData = await getSelectVal({ pg, values: ids, name: query.cls || attr });
-
-    const legend = countArr.rows.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(el => { return el.rows?.[0] || {}; });
-
-    return reply.status(200).send({ legend, min, max });
-}

package/server/routes/map/index.mjs

@@ -1,259 +0,0 @@
-import map from './controllers/map.js';
-import mapTiles from './controllers/mapTiles.js';
-import mapFeatures from './controllers/mapFeatures.js';
-
-import mapCatalog from './controllers/mapCatalog.js';
-import mapCatalogAttribute from './controllers/mapCatalogAttribute.js';
-
-import vtile from './controllers/vtile.js';
-import vtile1 from './vtile1.js';
-import clearTiles from './controllers/clearTiles.js';
-import geojson from './controllers/geojson.js';
-import jsonData from './controllers/jsonData.js';
-import layerList from './controllers/layerList.js';
-
-import mapFormat from './controllers/mapFormat.js';
-import parseGeoFile from './controllers/parseGeoFile.js';
-import maps from './controllers/maps.js';
-import gisIconApi from './controllers/gis.icon.js';
-import markerIconApi from './controllers/marker_icon.js';
-
-import getMap from './maps/get.map.js';
-import addMap from './maps/add.map.js';
-import delMap from './maps/del.map.js';
-
-import getWidget from './widgets/get.widget.js';
-import addWidget from './widgets/add.widget.js';
-import delWidget from './widgets/del.widget.js';
-
-import gisConvert from './controllers/gis.convert.js';
-import pointHeight from './controllers/pointHeight.js';
-
-const gisConvertSchema = {
-  body: {
-    type: 'object',
-    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'] },
-    ],
-  },
-};
-
-const schemaInfo = {
-  type: 'object',
-  properties: {
-    publicParams: {
-      slug: {
-        type: 'string',
-      },
-      z: {
-        type: 'number',
-      },
-      y: {
-        type: 'number',
-      },
-      x: {
-        type: 'string',
-        pattern: '^\\d+\\.(pbf|vmt)$',
-      },
-      id: {
-        type: 'string',
-      },
-    },
-  },
-};
-
-const mapFormatSchema = {
-  querystring: {
-    type: 'object',
-    properties: {
-      lat: {
-        type: 'number',
-        minimum: 1,
-        maximum: 90,
-      },
-      lng: {
-        type: 'number',
-        minimum: -180,
-        maximum: 180,
-      },
-      radius: {
-        type: 'number',
-        minimum: 1,
-        maximum: 1000,
-      },
-    },
-  },
-};
-
-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' }] },
-      },
-    },
-  },
-};
-
-const publicParams = {
-  config: { policy: 'L0' },
-  schema: schemaInfo,
-  package: 'gis',
-}; // * L0 === public
-const privilegedParams = {
-  config: { policy: 'L1', role: 'admin' },
-  schema: schemaInfo,
-  package: 'gis',
-}; // ? just auth or admin
-
-export default async function route(app) {
-  if (!app.hasRoute({ method: 'GET', url: '/gis-map/:id?' })) {
-    app.get('/gis-map/:id?', publicParams, getMap);
-  }
-  if (!app.hasRoute({ method: 'POST', url: '/gis-map/:id?' })) {
-    app.post('/gis-map/:id?', privilegedParams, addMap);
-  }
-  if (!app.hasRoute({ method: 'PUT', url: '/gis-map/:id' })) {
-    app.put('/gis-map/:id', privilegedParams, addMap);
-  }
-  if (!app.hasRoute({ method: 'DELETE', url: '/gis-map/:id' })) {
-    app.delete('/gis-map/:id', privilegedParams, delMap);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/gis-widget/:map/:id?' })) {
-    app.get('/gis-widget/:map/:id?', publicParams, getWidget);
-  }
-  if (!app.hasRoute({ method: 'POST', url: '/gis-widget/:map/:id?' })) {
-    app.post('/gis-widget/:map/:id?', privilegedParams, addWidget);
-  }
-  if (!app.hasRoute({ method: 'PUT', url: '/gis-widget/:map/:id' })) {
-    app.put('/gis-widget/:map/:id', privilegedParams, addWidget);
-  }
-  if (!app.hasRoute({ method: 'DELETE', url: '/gis-widget/:map/:id' })) {
-    app.delete('/gis-widget/:map/:id', privilegedParams, delWidget);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/maps' })) {
-    app.get('/maps', publicParams, maps);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/map/:slug' })) {
-    app.get('/map/:slug', publicParams, map);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/map-tiles/:slug/:z/:y/:x' })) {
-    app.get('/map-tiles/:slug/:z/:y/:x', publicParams, mapTiles);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/map-features/:slug/:id' })) {
-    app.get('/map-features/:slug/:id', publicParams, mapFeatures);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/map-features-point/:slug' })) {
-    app.get('/map-features-point/:slug', publicParams, mapFeatures);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/map-catalog' })) {
-    app.get('/map-catalog', publicParams, mapCatalog);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/map-catalog/:service/:attr' })) {
-    app.get('/map-catalog/:service/:attr', publicParams, mapCatalogAttribute);
-  }
-  // if (!app.hasRoute({ method: 'GET', url: '/layer-rtile/:id/:z/:y/:x' })) {
-  //   app.get('/layer-rtile/:id/:z/:y/:x', publicParams, rtile);
-  // }
-  if (!app.hasRoute({ method: 'GET', url: '/layer-vtile/:id/:z/:y/:x' })) {
-    app.get('/layer-vtile/:id/:z/:y/:x', publicParams, vtile);
-  }
-
-  if (
-    !app.hasRoute({ method: 'GET', url: '/api/vtile/:layer/:lang/:z/:y/:x' })
-  ) {
-    console.log('\x1b[34m%s\x1b[0m', 'add vtile from gis');
-    app.get('/vtile/:layer/:lang/:z/:y/:x', publicParams, vtile1);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/api/gis-clear-vtile/:id' })) {
-    app.get('/gis-clear-vtile/:id', publicParams, clearTiles);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/api/geojson/:layer' })) {
-    console.log('\x1b[34m%s\x1b[0m', 'add geojson from gis');
-    app.get('/geojson/:layer', publicParams, geojson);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/api/json/:layer' })) {
-    console.log('\x1b[34m%s\x1b[0m', 'add json from gis');
-    app.get('/json/:layer', publicParams, jsonData);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/api/gis-layer-list' })) {
-    console.log('\x1b[34m%s\x1b[0m', 'add gis-layer-list from gis');
-    app.get('/gis-layer-list', publicParams, layerList);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/gis-icon/*' })) {
-    app.get('/gis-icon/*', publicParams, gisIconApi);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/icon/*' })) {
-    app.get('/icon/*', publicParams, gisIconApi);
-  }
-  if (!app.hasRoute({ method: 'GET', url: '/marker-icon/*' })) {
-    app.get('/marker-icon/*', publicParams, gisIconApi);
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/api/map-format' })) {
-    app.get(
-      '/map-format',
-      { ...publicParams, schema: mapFormatSchema },
-      mapFormat,
-    );
-  }
-
-  if (!app.hasRoute({ method: 'GET', url: '/api/coords/height' })) {
-    app.get(
-      '/coords/height',
-      { ...publicParams, schema: pointHeightSchema },
-      pointHeight,
-    );
-  }
-
-  if (!app.hasRoute({ method: 'POST', url: '/api/gis-parse-geo' })) {
-    app.post('/gis-parse-geo', publicParams, parseGeoFile);
-  }
-
-  if (!app.hasRoute({ method: 'POST', url: '/api/gis-convert' })) {
-    app.post(
-      '/gis-convert',
-      { config: { policy: 'L0' }, schema: gisConvertSchema, package: 'gis' },
-      gisConvert,
-    );
-  }
-}

package/server/routes/map/maps/add.map.js

@@ -1,43 +0,0 @@
-import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
-
-export default async function addMap({
-  method, params = {}, body, pg = pgClients.client, user = {},
-}, reply) {
-  const { uid } = user;
-
-  if (!uid) {
-    return reply.status(401).send('unauthorized');
-  }
-
-  if (method === 'POST') {
-    if (!body?.name) {
-      return reply.status(400).send('not enough body params: name');
-    }
-
-    if (!body?.map_key) {
-      return reply.status(400).send('not enough body params: map_key');
-    }
-
-    const { rows = [] } = await dataInsert({
-      pg,
-      id: params.id,
-      table: 'gis.maps',
-      data: body,
-      uid,
-    });
-    return reply.status(200).send(rows[0]);
-  }
-
-  if (!params.id) {
-    return reply.status(400).send('not enough params: id');
-  }
-
-  const row = await dataUpdate({
-    pg,
-    id: params.id,
-    table: 'gis.maps',
-    data: body,
-    uid,
-  });
-  return reply.status(200).send(row);
-}

package/server/routes/map/widgets/add.widget.js

@@ -1,39 +0,0 @@
-import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
-export default async function addWidget({
-    method, params = {}, body, pg = pgClients.client, user = {},
-}, reply) {
-    const { uid } = user;
-
-    if (!uid) {
-        return reply.status(401).send('unauthorized');
-    }
-
-    if (!params.map) {
-        return reply.status(400).send('not enough params: map id');
-    }
-
-    if (method === 'PUT' && !params.id) {
-        return reply.status(400).send('not enough params: id');
-    }
-
-    if (method === 'POST') {
-        Object.assign(body, { map_id: params.map });
-        const { rows = [] } = await dataInsert({
-            pg,
-            id: params.id,
-            table: 'gis.widgets',
-            data: body,
-            uid,
-        });
-        return reply.status(200).send(rows[0]);
-    }
-
-    const row = await dataUpdate({
-        pg,
-        id: params.id,
-        table: 'gis.widgets',
-        data: body,
-        uid,
-    });
-    return reply.status(200).send(row);
-}

package/server/routes/map/widgets/del.widget.js

@@ -1,23 +0,0 @@
-import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
-
-export default async function delWidget({
-    params = {}, pg = pgClients.client, user = {},
-}, reply) {
-    const { uid } = user;
-
-    if (!uid) {
-        return reply.status(401).send('unauthorized');
-    }
-
-    if (!params.map) {
-        return reply.status(400).send('not enough params: map id');
-    }
-
-    const row = await dataDelete({
-        pg,
-        id: params.id,
-        table: 'gis.widgets',
-        uid,
-    });
-    return reply.status(200).send(row);
-}

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

@@ -1,28 +0,0 @@
-import { config } from '@opengis/fastify-table/utils.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({
-    query,
-}, reply) {
-    if (!config.mapnik?.server) {
-        return reply.status(400).send({ error: 'mapnik server not configured', code: 400 });
-    }
-
-    if (config.ready?.mapnik !== true) {
-        return reply.status(400).send({ error: 'mapnik server not ready', code: 400 });
-    }
-
-    const { path } = query || {};
-
-    if (!path) {
-        return reply.status(400).send({ error: 'not enough query params: path', code: 400 });
-    }
-
-    const relpath = `raster/${[config.mapnik?.folder, path].filter(Boolean).join('/')}`;
-    const data = await FileStat({ path: relpath });
-    return { data };
-}

package/server/routes/mapnik/controllers/mapnikLogger.js

@@ -1,29 +0,0 @@
-import { config } from '@opengis/fastify-table/utils.js';
-
-import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
-
-const { GetLogs } = mapnik();
-
-export default async function mapnikLogger({
-    params,
-}, reply) {
-    if (!config.mapnik?.server) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
-    }
-
-    const { data, links, err } = await GetLogs({ path: params['*'] });
-    console.log(links);
-    if (err) {
-        return reply.status(400).send(err);
-    }
-
-    if (links) {
-        return reply.headers({
-            "Content-Type": "text/html; charset=UTF-8",
-            "Content-Security-Policy": "default-src 'none'",
-            "X-Content-Type-Options": "nosniff",
-        }).send(links.replace(/\/api\/gis-logger/g, '/logger-gis'));
-    }
-
-    return reply.headers({ "Content-type": "text/plain; charset=UTF-8" }).send(data);
-}