@opengis/gis 0.2.167 → 0.2.169

package/server/routes/{gis/services → services/functions}/add.service.js

@@ -1,3 +1,4 @@
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
 import { dataDelete, dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
 
 async function updateTemplate(client, body, uid, id) {
@@ -19,46 +20,43 @@ async function updateTemplate(client, body, uid, id) {
     return rowCount;
 }
 export default async function addService({
-    method, params = {}, body, pg = pgClients.client, user = {},
-}, reply) {
-    if (method === 'PUT' && !params.id) {
-        return reply.status(400).send('not enough params: id');
+    method, id, body, uid = '0'
+}, pg = pgClients.client) {
+    if (method === 'PUT' && !id) {
+        throw BadRequestError('not enough params: id');
     }
 
-    const { uid = '0' } = user;
-
     const client = await pg.connect();
     try {
         await client.query('begin');
 
         if (method === 'POST') {
-            const { rows = [] } = await dataInsert({
+            const row = await dataInsert({
                 pg: client,
-                id: params.id,
+                id,
                 table: 'gis.services',
                 data: body,
                 uid,
-            });
-            const istemplate = await updateTemplate(client, body.html, uid, rows[0]?.service_id);
+            }).then(r => r.rows[0]);
+            await updateTemplate(client, body.html, uid, row.service_id);
             await client.query('commit');
-            return reply.status(200).send(rows[0]);
+            return row;
         }
 
-
         const row = await dataUpdate({
             pg: client,
-            id: params.id,
+            id,
             table: 'gis.services',
             data: body,
             uid,
         });
-        const istemplate = await updateTemplate(client, body.html, uid, params.id);
+        await updateTemplate(client, body.html, uid, id);
         await client.query('commit');
-        return reply.status(200).send(row);
+        return row;
 
     } catch (err) {
         await client.query('rollback');
-        return reply.status(500).send(err.toString());
+        throw err;
     } finally {
         client.release();
     }

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

@@ -0,0 +1,93 @@
+const ROUTE_URL = process.env.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({ from, to, via, mode, alternatives, steps, optimize, surface, weight }) {
+  const points = buildRoutePoints(from, to, via);
+  const query = { from, to, via, mode, alternatives, steps, optimize, surface, weight };
+  const url = `${ROUTE_URL}?steps=true&alternatives=true${routeOptionsQuery(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 payload;
+}

package/server/routes/{gis/services → services/functions}/del.service.js

@@ -1,13 +1,13 @@
 import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
 
 export default async function deleteService({
-    params = {}, pg = pgClients.client, user = {},
-}, reply) {
+    id, uid,
+}, pg = pgClients.client) {
     const row = await dataDelete({
         pg,
-        id: params.id,
+        id,
         table: 'gis.services',
-        uid: user?.uid,
+        uid,
     });
-    return reply.status(200).send(row);
+    return row;
 }

package/server/routes/{gis/services → services/functions}/get.service.users.js

@@ -1,3 +1,4 @@
+import { BadRequestError } from '@opengis/fastify-table/errors.js';
 import { pgClients } from '@opengis/fastify-table/utils.js';
 
 /**
@@ -7,7 +8,7 @@ import { pgClients } from '@opengis/fastify-table/utils.js';
  * @summary Апі повертає перелік користувачів, які мають доступ до георесурсу
  * @alias getServiceUsers
  * @tag services
- * @param {String} params.id Ідентифікатор георесурсу (service_id)
+ * @param {String} id Ідентифікатор георесурсу (service_id)
  * @param {Number} query.limit Кількість записів на сторінці (макс. 100, за замовчуванням 20)
  * @param {Number} query.offset Зміщення для пагінації
  * @param {String} query.search Текстовий пошук за прізвищем, іменем, по-батькові або логіном
@@ -15,13 +16,16 @@ import { pgClients } from '@opengis/fastify-table/utils.js';
  *
  * @example /api/gis-service-users/3054579335420708639?limit=8&offset=0
  */
-export default async function getServiceUsers({ params = {}, query = {}, pg = pgClients.client }, reply) {
-  const { id } = params;
-  const limit = Math.min(parseInt(query.limit, 10) || 20, 100);
-  const offset = parseInt(query.offset, 10) || 0;
-  const search = query.search?.trim() || '';
+export default async function getServiceUsers({ id, search: querySearch = '', limit: queryLimit = 10, offset = 0 }, pg = pgClients.client) {
+  const limit = Math.min(queryLimit, 100);
 
-  if (!id) return reply.status(400).send({ message: 'service_id is required' });
+  const search = querySearch?.trim() || '';
+
+  if (!id) {
+    throw BadRequestError('service_id is required');
+  }
+
+  const args = search ? [id, `%${search}%`] : [id];
 
   const searchFilter = search
     ? `and (
@@ -49,7 +53,7 @@ export default async function getServiceUsers({ params = {}, query = {}, pg = pg
     where a.service_id = $1
     ${searchFilter}
     order by user_full_name
-    limit ${limit} offset ${offset}
+    limit $${args.length + 1}::bigint offset $${args.length + 2}::bigint
   `;
 
   const countSql = `
@@ -60,15 +64,13 @@ export default async function getServiceUsers({ params = {}, query = {}, pg = pg
     ${searchFilter}
   `;
 
-   const args = search ? [id, `%${search}%`] : [id];
-
   const [{ rows }, countResult] = await Promise.all([
-    pg.query(sql, args),
+    pg.query(sql, args.concat([limit, offset])),
     pg.query(countSql, args).then((r) => r.rows?.[0]?.total ?? 0),
   ]);
 
-  return reply.status(200).send({
+  return {
     rows,
     count: countResult,
-  });
+  };
 }

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

@@ -0,0 +1,34 @@
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
+import { metaFormat, pgClients, getTemplate } from '@opengis/fastify-table/utils.js';
+
+export default async function getServicesCol({ id, column }, pg = pgClients.client) {
+  const row = await getTemplate('layer', id) || await pg.query(`
+           SELECT 
+               service_id, source_path, attributes
+           FROM gis.services where ${id ? 'service_id=$1' : '1=1'}
+       `, [id].filter(Boolean)).then(r => r.rows[0] || {});
+
+  if (!row.source_path) {
+    throw NotFoundError('source not found');
+  }
+
+  const fields = await pg.query(`SELECT * FROM ${row.source_path} limit 0`).then(r => r.fields);
+  const field = fields.find(el => el.name === column);
+
+  if (!field) {
+    throw NotFoundError('column not found: ' + column);
+  }
+
+  const rows = await pg.query(`SELECT ${column}::text as id, ${column}, count(*) FROM ${row.source_path} 
+        where ${column} is not null group by ${column} order by count(*) desc limit 10`).then(r => r.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[`${column}_data`], ...row, [`${column}_data`]: undefined, [column]: undefined,
+  }));
+
+  return { rows: rows1, field, fields };
+}

package/server/routes/{gis/services → services/functions}/get.services.js

@@ -1,3 +1,4 @@
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
 import {
   dataUpdate, getMeta, pgClients, yml2json, getTemplate,
 } from '@opengis/fastify-table/utils.js';
@@ -12,10 +13,14 @@ const columnType = {
   'timestamp with time zone': 'date',
 };
 
-export default async function getServices({ params = {}, pg = pgClients.client }, reply) {
-  const t = await getTemplate('layer', params.id);
+export default async function getServices({ id }, pg = pgClients.client) {
+  const t = await getTemplate('layer', id);
   if (t) return t;
-  if (!pg.tlist.includes('gis.services')) return { status: 404, message: 'not found' };
+
+  if (!pg.tlist.includes('gis.services')) {
+    throw NotFoundError('table not found');
+  }
+
   const rows = await pg.query(`
         SELECT 
             service_id, service_key, name, description, keywords, category, holder, group_id, b.group_name, service_type, card_mode,
@@ -24,18 +29,18 @@ export default async function getServices({ params = {}, pg = pgClients.client }
             metadata_url, thumbnail_url, created_by, updated_by, updated_at, created_at, template 
         FROM gis.services a
         left join lateral (select group_name from gis.group_list where group_id=a.group_id)b on 1=1
-        where ${params.id ? 'service_id=$1' : '1=1'}
-    `, [params.id].filter(Boolean)).then(el => el.rows || []);
+        where ${id ? 'service_id=$1' : '1=1'}
+    `, [id].filter(Boolean)).then(r => r.rows || []);
 
-  if (params.id && !rows.length) {
-    return reply.status(404).send('service not found');
+  if (id && !rows.length) {
+    throw NotFoundError('service not found');
   }
 
   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 || {}) : {};
 
-  if (params.id) {
-    const html = await pg.query('select body from admin.templates where template_id=$1', [params.id]).then(el => el.rows?.[0]?.body);
+  if (id) {
+    const html = await pg.query('select body from admin.templates where template_id=$1', [id]).then(r => r.rows?.[0]?.body);
     Object.assign(rows[0], { html });
   }
 
@@ -43,13 +48,13 @@ export default async function getServices({ params = {}, pg = pgClients.client }
     Object.assign(row, { count: totals[row.source_path] || 0 });
   });
 
-  const { columns = [] } = await getMeta({ pg, table: rows[0].source_path }) || {};
+  const columns = rows[0].source_path ? await getMeta({ pg, table: rows[0].source_path }).then(r => r?.columns || []) : [];
 
   const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
 
   const noCenterIds = rows.filter(row => !row.center && row.bbox).map(row => row.service_id);
 
-  const centers = noCenterIds.length ? await pg.query('SELECT json_object_agg(service_id, st_pointonsurface(bbox)::json) FROM gis.services where service_id=any($1)', [noCenterIds].filter(Boolean)).then(el => el.rows?.[0]?.json_object_agg || {}) : {};
+  const centers = noCenterIds.length ? await pg.query('SELECT json_object_agg(service_id, st_pointonsurface(bbox)::json) FROM gis.services where service_id=any($1)', [noCenterIds].filter(Boolean)).then(r => r.rows?.[0]?.json_object_agg || {}) : {};
 
   await Promise.all(rows.filter(row => centers[row.service_id]).map(async (row) => {
     // console.log('update service center', row.service_id, JSON.stringify(centers[row.service_id]));
@@ -73,12 +78,12 @@ export default async function getServices({ params = {}, pg = pgClients.client }
     filters: row.filters.map(filter => ({ ...filter, api: `/api/suggest/${row.source_path}:${filter.name}${filter.data && filter.name !== filter.data ? `?sel=${filter.data}` : ''}` })),
   }));
 
-  if (params.id) {
-    return reply.status(200).send({ ...rows[0], fields });
+  if (id) {
+    return { ...rows[0], fields };
   }
 
-  return reply.status(200).send({
+  return {
     rows,
     fields,
-  });
+  };
 }

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

@@ -0,0 +1,76 @@
+// import getLayerGeom from './functions/get.layer.geom.js';
+import getServices from './functions/get.services.js';
+import getServiceUsers from './functions/get.service.users.js';
+import deleteService from './functions/del.service.js';
+import addService from './functions/add.service.js';
+import getServicesCol from './functions/get.services.col.js';
+// import legendAuto from './functions/legend.auto.js';
+import createRoute from './functions/create.route.js';
+
+import {
+    getServicesSchema,
+    getServicesColSchema,
+    addServiceSchema,
+    editServiceSchema,
+    deleteServiceSchema,
+    getServiceUsersSchema,
+    createRouteSchema,
+} from './services.schema.js';
+const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
+async function route(app) {
+    app.get('/gis-service/:id?', { ...publicParams, schema: getServicesSchema }, async ({ params, pg }) => {
+        const result = await getServices({
+            id: params.id,
+        }, pg);
+        return result;
+    });
+    app.get('/gis-service/:id/:col', { ...publicParams, schema: getServicesColSchema }, async ({ params, pg }) => {
+        const result = await getServicesCol({
+            id: params.id,
+            column: params.col,
+        }, pg);
+        return result;
+    });
+    app.post('/gis-service/:id?', { ...publicParams, schema: addServiceSchema }, async ({ method, params, body, user, pg }) => {
+        const result = await addService({
+            method,
+            id: params.id,
+            body,
+            uid: user?.uid,
+        }, pg);
+        return result;
+    });
+    app.put('/gis-service/:id', { ...publicParams, schema: editServiceSchema }, async ({ method, params, body, user, pg }) => {
+        const result = await addService({
+            method,
+            id: params.id,
+            body,
+            uid: user?.uid,
+        }, pg);
+        return result;
+    });
+    app.delete('/gis-service/:id', { ...publicParams, schema: deleteServiceSchema }, async ({ params, user, pg }) => {
+        const result = await deleteService({
+            id: params.id,
+            uid: user?.uid
+        }, pg);
+        return result;
+    });
+    // app.get('/legend-auto/:id', { ...publicParams, schema: legendAutoSchema }, legendAuto);
+    app.get('/gis-service-users/:id', { ...publicParams, schema: getServiceUsersSchema }, async ({ params, query, pg }) => {
+        const result = await getServiceUsers({
+            id: params.id,
+            search: query.search,
+            limit: query.limit,
+            offset: query.offset,
+        }, pg);
+        return result;
+    });
+    app.get('/routes', { ...publicParams, schema: createRouteSchema }, async ({ query }) => {
+        const { from, to, via, mode, alternatives, steps, optimize, surface, weight } = query;
+        const result = await createRoute({ from, to, via, mode, alternatives, steps, optimize, surface, weight });
+        return result;
+    });
+}
+export default route;

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

@@ -0,0 +1,168 @@
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+
+import { getPGAsync } from '@opengis/fastify-table/utils.js';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+let pg;
+
+beforeAll(async () => {
+    await build();
+
+    pg = await getPGAsync();
+
+    await cleanUp('before');
+});
+
+afterAll(async () => {
+    await cleanUp('after');
+});
+
+const testId = 'testService';
+
+const cleanUp = async (when) => {
+    if (!pg) return;
+    const rowCount1 = await pg.query('delete from gis.services where service_id=$1', [testId]).then(r => r.rowCount || 0);
+    const rowCount4 = await pg.query('delete from gis.services_users_rel where service_id=$1', [testId]).then(r => r.rowCount || 0);
+    console.log(`clean up finished: ${when}`, rowCount1, rowCount4);
+};
+
+describe('GIS routes', () => {
+    test('GET /gis-service + /gis-service/:id + /gis-service/:id/:col returns 200', async () => {
+        const res = await injectWithHeaders({
+            url: '/api/gis-service',
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('rows');
+        expect(res.body.rows.length).toBeGreaterThan(0);
+        expect(res.body).toHaveProperty('fields');
+        expect(res.body.fields.length).toBeGreaterThan(0);
+
+        expect(res.body.rows[0].service_id).toBeDefined();
+
+        const res1 = await injectWithHeaders({
+            url: `/api/gis-service/${res.body.rows[0].service_id}`,
+        });
+
+        expect(res1.statusCode).toBe(200);
+        expect(res1.body).toHaveProperty('service_id');
+        expect(res1.body).toHaveProperty('name');
+        expect(res1.body).toHaveProperty('service_key');
+
+        const res2 = await injectWithHeaders({
+            url: `/api/gis-service/${res.body.rows[0].service_id}/${res.body.fields[0].name}`,
+        });
+
+        expect(res2.statusCode).toBe(200);
+        expect(res2.body).toHaveProperty('rows');
+        expect(res2.body).toHaveProperty('fields');
+
+        expect(res2.body).toHaveProperty('field');
+        expect(res2.body.field).toHaveProperty('name');
+        expect(res2.body.field.name).toBe(res.body.fields[0].name);
+    });
+
+    test('POST /gis-service returns 200', async () => {
+        await pg.query('delete from gis.services where service_id=$1', [testId]);
+        const res = await injectWithHeaders({
+            method: 'POST',
+            url: `/api/gis-service/${testId}`,
+            payload: {
+                name: 'unit test',
+                service_type: 'other'
+            }
+        });
+
+        expect(res.statusCode, res.body).toBe(200);
+        expect(res.body).toHaveProperty('service_id');
+        expect(res.body).toHaveProperty('name');
+        expect(res.body).toHaveProperty('service_type');
+    });
+
+    test('PUT /gis-service/:id returns 200', async () => {
+        const payload = {
+            service_type: 'geojson'
+        };
+        const res = await injectWithHeaders({
+            method: 'PUT',
+            url: `/api/gis-service/${testId}`,
+            payload
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('service_id');
+        expect(res.body).toHaveProperty('name');
+        expect(res.body).toHaveProperty('service_type');
+        expect(res.body.service_type).toBe(payload.service_type);
+    });
+
+    // ! before delete
+    test('GET /gis-service-users/:id returns 200', async () => {
+        await pg.query('insert into gis.services_users_rel (user_id, service_id, actions) values($1,$2,$3)', ['2', testId, ['read']]).catch(err => console.error(err));
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-service-users/${testId}`,
+            query: {
+                // search: '',
+                limit: 1,
+                offset: 0
+            }
+        });
+
+        expect(res.statusCode, res.body).toBe(200);
+        expect(res.body).toHaveProperty('count');
+        expect(res.body).toHaveProperty('rows');
+        expect(res.body.rows).toBeInstanceOf(Array);
+        expect(res.body.rows.length).toBeGreaterThan(0);
+        expect(res.body.rows[0]).toHaveProperty('actions');
+        expect(res.body.rows[0].actions).toBeInstanceOf(Array);
+        expect(res.body.rows[0].actions.length).toBe(1);
+        expect(res.body.rows[0].actions[0]).toBe('read');
+        expect(res.body.rows[0]).toHaveProperty('user_id');
+        expect(res.body.rows[0]).toHaveProperty('user_full_name');
+    });
+
+    test('DELETE /gis-service/:id returns 200', async () => {
+        const res = await injectWithHeaders({
+            method: 'DELETE',
+            url: `/api/gis-service/${testId}`,
+        });
+
+        expect(res.statusCode).toBe(200);
+    });
+
+    test('GET /routes returns 200', async () => {
+        const res = await injectWithHeaders({
+            url: '/api/routes',
+            query: {
+                from: '30.50,50.00',
+                to: '31.50,49.50',
+                alternatives: 'true',
+                steps: 'true'
+            }
+        });
+
+        expect(res.statusCode).toBe(200);
+        // skip if rate limited by cloudflare
+        if (res.body?.status !== 429) {
+            expect(res.body).toBeInstanceOf(Array);
+            expect(res.body.length).toBeGreaterThan(0);
+            expect(res.body[0]).toHaveProperty('alternative');
+            expect(res.body[0]).toHaveProperty('geom');
+            expect(res.body[0]).toHaveProperty('instructions');
+            expect(res.body[0].instructions).toBeInstanceOf(Array);
+            expect(res.body[0].instructions.length).toBeGreaterThan(0);
+            expect(res.body[0].instructions[0]).toHaveProperty('geometry');
+            expect(res.body[0].instructions[0]).toHaveProperty('mode');
+            expect(res.body[0].instructions[0]).toHaveProperty('driving_side');
+            expect(res.body[0].instructions[0]).toHaveProperty('duration');
+            expect(res.body[0].instructions[0]).toHaveProperty('distance');
+            expect(res.body[0].instructions[0]).toHaveProperty('weight');
+            expect(res.body[0].instructions[0]).toHaveProperty('name');
+            expect(res.body[0]).toHaveProperty('distance');
+            expect(res.body[0].distance).toBeTypeOf('number');
+            expect(res.body[0]).toHaveProperty('time_for_route');
+        }
+    });
+});