@opengis/gis 0.2.167 → 0.2.169

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

@@ -1,21 +1,26 @@
 import { pgClients, getTemplate } from "@opengis/fastify-table/utils.js";
+import { BadRequestError, ConflictError, NotFoundError } from "@opengis/fastify-table/errors.js";
 
-import { handleRegistryRequest } from './funcs/handleRegistryRequest.js';
+import { handleRegistryRequest } from './handleRegistryRequest.js';
 
 const maxLimit = 100;
 const defaultLimit = 9;
 
 export default async function gisRegistry({
-  pg = pgClients.client, params = {}, query = {},
-}) {
-  const { slug, objectId } = params;
-  const { sql } = query;
+  slug, objectId, search, filter, sql, page, limit: queryLimit,
+}, pg = pgClients.client) {
 
-  const limit = Math.min(query.limit || defaultLimit, maxLimit);
-  const offset = query.page && query.page > 0 && !objectId ? (query.page - 1) * limit : 0;
+  if (sql && process.platform !== 'win32') {
+    throw ConflictError('query.sql is not allowed');
+  }
+
+  const limit = Math.min(queryLimit || defaultLimit, maxLimit);
+
+  const offset = page && page > 0 && !objectId ? (page - 1) * limit : 0;
 
-  // if (!slug) return reply.code(404).send({ message: 'Params slug is required', status: 404 });
-  if (!slug) throw new Error('Params slug is required');
+  if (!slug) {
+    throw BadRequestError('Params slug is required');
+  }
 
   const {
     rows: [registry],
@@ -31,23 +36,25 @@ export default async function gisRegistry({
   if (registry) {
     return handleRegistryRequest({
       settings: registry,
-      query,
+      query: { search, filter },
       object_id: objectId,
       offset,
       limit,
-      page: query.page,
+      page,
       pg,
       sql,
     });
   }
 
   const registryTemplate = await getTemplate('registry', slug);
-  // if (!registryTemplate) return reply.code(404).send({ message: 'Template not found', status: 404 });
-  if (!registryTemplate) throw new Error('Template not found');
+
+  if (!registryTemplate) {
+    throw NotFoundError('Template not found: ' + slug);
+  }
 
   return handleRegistryRequest({
     settings: registryTemplate,
-    query,
+    query: { search, filter },
     object_id: objectId,
     register_key: registry.register_key,
     is_downloadable: registry?.is_downloadable || registryTemplate?.is_downloadable,
@@ -57,7 +64,7 @@ export default async function gisRegistry({
     service_id: registryTemplate.service_id,
     offset,
     limit,
-    page: query.page,
+    page,
     pg,
     sql,
   });

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

@@ -1,9 +1,8 @@
+import { NotFoundError } from "@opengis/fastify-table/errors.js";
 import { pgClients, getTemplatePath, getTemplate } from "@opengis/fastify-table/utils.js";
-const pg = pgClients.client;
 
-export default async function gisRegistryList(req = {}) {
-    const { query = {} } = req;
-    const { page = 1, limit = 9, search = '' } = query;
+export default async function gisRegistryList({ page = 1, limit = 9, search = '' }, pg = pgClients.client) {
+
     const offset = limit * (page - 1);
 
     const dbResult = await pg.query(
@@ -14,14 +13,17 @@ export default async function gisRegistryList(req = {}) {
 
     let templates = dbResult?.rows;
     let fromDatabase = true;
-    
+
     if (!templates?.length) {
         fromDatabase = false;
 
-        const registryListTemplate = await getTemplatePath('registry');
-        if (!registryListTemplate?.length) throw new Error('Templates not found');
+        const registryListTemplate = getTemplatePath('registry');
+
+        if (!registryListTemplate?.length) {
+            throw NotFoundError('Templates not found');
+        }
 
-        templates = ( await Promise.all(
+        templates = (await Promise.all(
             registryListTemplate.map(async ([slug]) => {
                 try {
                     const tpl = await getTemplate('registry', slug);
@@ -52,8 +54,8 @@ export default async function gisRegistryList(req = {}) {
     return {
         rows: paged,
         total: filteredBySearch.length,
-        page: parseInt(page, 10),
-        limit: parseInt(limit, 10),
+        page,
+        limit,
         offset
     };
 }

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

@@ -1,6 +1,6 @@
-import { getMeta, getFilterSQL, metaFormat } from "@opengis/fastify-table/utils.js";
+import { getMeta, getFilterSQL, metaFormat, getFilterSQLParametrized } from "@opengis/fastify-table/utils.js";
 import { populateFilterOptions } from './classifiers.js';
- import { extractVisibleColumns } from './columns.js';
+import { extractVisibleColumns } from './columns.js';
 
 const columnType = {
   text: 'text',
@@ -75,28 +75,28 @@ export async function handleRegistryRequest({
   }
 
   const { search, filter } = query || {};
-  const { q: sqlFilter } = (filter || search)
-    ? await getFilterSQL({
+  const { q: sqlFilter, args = [] } = (filter || search)
+    ? await getFilterSQLParametrized({
       table: table_name,
       search,
       filter,
       filterList: activeFilters,
     })
-    : { q: '1=1' };
+    : { q: '1=1', args: [] };
 
   const whereConditions = [whereQuery, sqlFilter].filter(Boolean).join(' AND ');
 
   const sqlBase = `FROM ${table_name} WHERE ${whereConditions || 'true'}`;
   const sqlOrder = order ? `ORDER BY ${order}` : "";
-  const sqlLimit = `LIMIT $1 OFFSET $2`;
+  const sqlLimit = `LIMIT $${args.length + 1}::bigint OFFSET $${args.length + 2}::bigint`;
 
   const sqlSelect = `SELECT "${pk}" as id ${selectColumns.length ? `, ${selectColumns.join(", ")}` : ''} ${geom ? `, st_asgeojson(${geom})::json as geom` : ''} ${sqlBase}`;
   const dataQuery = `${sqlSelect} ${sqlOrder} ${sqlLimit}`;
 
   if (sql) return dataQuery;
 
-  const rows = await pg.query(dataQuery, [limit, offset]).then(el => el.rows || []);
-  const total = await pg.query(`SELECT COUNT(*) ${sqlBase}`).then(el => +(el.rows[0]?.count || 0));
+  const rows = await pg.query(dataQuery, args.concat([limit, offset])).then(el => el.rows || []);
+  const total = await pg.query(`SELECT COUNT(*) ${sqlBase}`, args).then(el => +(el.rows[0]?.count || 0));
 
   await metaFormat({
     rows, table: table_name, cls: classifiers, sufix: true,
@@ -117,9 +117,13 @@ export async function handleRegistryRequest({
     filters: activeFilters,
     columns,
     whereConditions,
+    args
   });
 
   return {
+    total,
+    limit,
+    page,
     register_id,
     name,
     card,
@@ -127,13 +131,10 @@ export async function handleRegistryRequest({
     register_key,
     description,
     rows,
-    total,
     service_id,
     columns: visibleColumns,
     filters: activeFilters,
     fields,
-    limit,
-    page,
     view,
     is_downloadable,
     is_map,

package/server/routes/registers/registers.route.js

@@ -0,0 +1,80 @@
+import gisRegistry from './functions/gis.registry.js';
+import gisRegistryList from './functions/gis.registry.list.js';
+// import mapRegistry from './functions/map.registry.js';
+import gisExport from './functions/gis.export.js';
+import addGisRegistry from './functions/add.registry.js';
+import deleteGisRegistry from './functions/del.registry.js';
+
+import {
+    gisRegistrySchema,
+    gisRegistryListSchema,
+    addGisRegistrySchema,
+    editGisRegistrySchema,
+    deleteGisRegistrySchema,
+    gisExportSchema,
+} from './registers.schema.js';
+
+const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
+async function route(app) {
+    app.get('/gis-registry/:slug', { ...publicParams, schema: gisRegistrySchema }, async ({ params, query, pg }) => {
+        const result = await gisRegistry({
+            slug: params.slug,
+            search: query.search,
+            filter: query.filter,
+            page: query.page,
+            limit: query.limit,
+            sql: query.sql,
+        }, pg);
+        return result;
+    });
+    app.get('/gis-registry/:slug/:objectId', { ...publicParams, schema: gisRegistrySchema }, async ({ params, query, pg }) => {
+        const result = await gisRegistry({
+            slug: params.slug,
+            objectId: params.objectId,
+            search: query.search,
+            filter: query.filter,
+            page: query.page,
+            limit: query.limit,
+            sql: query.sql,
+        }, pg);
+        return result;
+    });
+    app.get('/gis-registry', { ...publicParams, schema: gisRegistryListSchema }, async ({ query, pg }) => {
+        const result = await gisRegistryList({
+            page: query.page,
+            limit: query.limit,
+            search: query.search,
+        }, pg);
+        return result;
+    });
+    app.post('/gis-registry/:slug?', { ...publicParams, schema: addGisRegistrySchema }, async ({ method, params, body, user, pg }) => {
+        const result = await addGisRegistry({
+            method, slug: params.slug, body, uid: user?.uid,
+        }, pg);
+        return result;
+    });
+    app.put('/gis-registry/:slug', { ...publicParams, schema: editGisRegistrySchema }, async ({ method, params, body, user, pg }) => {
+        const result = await addGisRegistry({
+            method, slug: params.slug, body, uid: user?.uid,
+        }, pg);
+        return result;
+    });
+    app.delete('/gis-registry/:slug', { ...publicParams, schema: deleteGisRegistrySchema }, async ({ params, user, pg }) => {
+        const result = await deleteGisRegistry({
+            slug: params.slug,
+            uid: user?.uid,
+        }, pg);
+        return result;
+    });
+    // app.get('/map-registry/:slug/:id', { ...publicParams, schema: mapRegistrySchema }, mapRegistry);
+    app.get('/gis-export/:type/:slug', { ...publicParams, schema: gisExportSchema }, async ({ params, query, pg }, reply) => {
+        const result = await gisExport({
+            slug: params.slug,
+            type: params.type,
+            format: query.format,
+        }, pg);
+        return reply.headers(result.headers).send(result.data);
+    });
+}
+export default route;

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

@@ -0,0 +1,145 @@
+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 = 'testRegister';
+
+const cleanUp = async (when) => {
+    if (!pg) return;
+    const rowCount2 = await pg.query('delete from gis.registers where register_id=$1', [testId]).then(r => r.rowCount || 0);
+    console.log(`clean up finished: ${when}`, rowCount2);
+};
+
+describe('GIS routes', () => {
+    test('GET /gis-registry/:slug returns 200', async () => {
+        const { slug, table } = await pg.query('SELECT register_id as slug, table_name as table FROM gis.registers where table_name is not null limit 1').then(r => r.rows[0]) || {};
+        const pkey = pg.pk?.[table];
+        expect(pkey).toBeDefined();
+
+        const res = await injectWithHeaders({
+            url: `/api/gis-registry/${slug}`,
+        });
+
+        expect(res.statusCode).toBe(200);
+        [
+            "total", "limit", "page", "register_id", "name", "card", "table_name", "register_key", "description",
+            "rows", "service_id", "columns", "filters", "fields", "view", "is_downloadable", "is_map", "is_register",
+            "is_files", "config"
+        ].forEach(key => expect(res.body).toHaveProperty(key));
+    });
+
+    test('GET /gis-registry/:slug/:objectId returns 200', async () => {
+        const { slug, table } = await pg.query('SELECT register_id as slug, table_name as table FROM gis.registers where table_name is not null limit 1').then(r => r.rows[0]) || {};
+        const pkey = pg.pk?.[table];
+        expect(pkey).toBeDefined();
+
+        const objectId = await pg.query(`select ${pkey} from ${table} limit 1`).then(r => r.rows?.[0]?.[pkey]);
+        expect(objectId).toBeDefined();
+
+        const url = `/api/gis-registry/${slug}/${objectId}`;
+        const res = await injectWithHeaders({
+            url,
+        });
+
+        expect(res.statusCode, url).toBe(200);
+        [
+            "row", "card", "d", "columns", "is_downloadable", "register_key", "register_id", "service_id",
+            "name", "is_files", "is_map", "is_register"
+        ].forEach(key => expect(res.body).toHaveProperty(key));
+    });
+
+    test('GET /gis-registry returns 200', async () => {
+        const res = await injectWithHeaders({
+            url: '/api/gis-registry',
+        });
+
+        expect(res.statusCode).toBe(200);
+        ["rows", "total", "page", "limit", "offset"].forEach(key => expect(res.body).toHaveProperty(key));
+    });
+
+    test('POST /gis-registry returns 200', async () => {
+        const table = pg.tlist.find(el => el.includes('parcel') || el.includes('address') || el.includes('street')) || pg.tlist[0];
+        await pg.query('delete from gis.registers where register_id=$1', [testId]);
+
+        const payload = {
+            register_key: 'unit-test',
+            name: 'unit-test',
+            table_name: table
+        };
+
+        const res = await injectWithHeaders({
+            method: 'POST',
+            url: `/api/gis-registry/${testId}`,
+            payload
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('register_id');
+        expect(res.body).toHaveProperty('register_key');
+        expect(res.body).toHaveProperty('name');
+        expect(res.body.name).toBe(payload.name);
+        expect(res.body).toHaveProperty('table_name');
+    });
+
+    test('PUT /gis-registry/:slug returns 200', async () => {
+        const payload = {
+            name: 'unit-test edited',
+        };
+        const res = await injectWithHeaders({
+            method: 'PUT',
+            url: `/api/gis-registry/${testId}`,
+            payload
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('register_id');
+        expect(res.body).toHaveProperty('register_key');
+        expect(res.body).toHaveProperty('name');
+        expect(res.body.name).toBe(payload.name);
+        expect(res.body).toHaveProperty('table_name');
+    });
+
+    // ! before delete
+    test('GET /gis-export/:type/:slug returns 200', async () => {
+        const res = await injectWithHeaders({
+            url: `/api/gis-export/register/${testId}`,
+            format: 'csv'
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.headers).toHaveProperty('content-type');
+        expect(res.headers['content-type']).toBe('text/csv');
+        expect(res.headers).toHaveProperty('content-disposition');
+        expect(res.headers['content-disposition']).toMatch('attachment; filename=');
+        expect(res.body.length).toBeGreaterThan(0);
+    });
+
+    test('DELETE /gis-registry/:slug returns 200', async () => {
+        const res = await injectWithHeaders({
+            method: 'DELETE',
+            url: `/api/gis-registry/${testId}`,
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('register_id');
+        expect(res.body).toHaveProperty('register_key');
+        expect(res.body).toHaveProperty('name');
+        expect(res.body).toHaveProperty('table_name');
+    });
+});

package/server/routes/registers/registers.schema.js

@@ -0,0 +1,246 @@
+const queryFilterSchema = { type: 'string', pattern: '^([\\w\\d_-]+)=([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' };
+const querySearchSchema = { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' };
+
+const registerSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        register_id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        service_id: { type: ['string', 'null'], pattern: '^([\\d\\w]+)$' },
+
+        name: { type: 'string' },
+        description: { type: ['string', 'null'] },
+        keywords: { type: ['array', 'string', 'null'] },
+        holder: { type: ['string', 'null'] },
+
+        table_name: { type: 'string' },
+        pk: { type: 'string' },
+        query: { type: ['string', 'null'] },
+        geometry_column: { type: ['string', 'null'] },
+        sql_list: { type: ['array', 'string', 'null'] },
+
+        is_active: { type: 'boolean' },
+        is_public: { type: 'boolean' },
+
+        filters: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                // ? ua / label
+                required: ['name', 'type'],
+                properties: {
+                    ua: { type: 'string' },
+                    data: { type: 'string' },
+                    name: { type: 'string' },
+                    type: { type: 'string' },
+                    label: { type: 'string' },
+                },
+            },
+        },
+
+        columns: {
+            type: 'array',
+            items: {
+                type: 'object',
+            },
+        },
+
+        metadata: {
+            type: ['object', 'null'],
+        },
+
+        created_at: { type: 'string' },
+        created_by: { type: 'string' },
+        updated_by: { type: 'string' },
+        updated_at: { type: 'string' },
+
+        image: { type: ['string', 'null'] },
+        order: { type: ['string', 'null'] },
+        register_key: { type: ['string', 'null'] },
+
+        is_files: { type: 'boolean' },
+        view: { type: 'string' },
+
+        card: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                // ? ua / title / label
+                // ? format / type
+                required: ['name'],
+                properties: {
+                    name: { type: 'string' },
+                    title: { type: 'string' },
+                    type: { type: 'string' },
+                    label: { type: 'string' },
+                    format: { type: 'string' },
+                    meta: { type: 'string' },
+
+                    ua: { type: 'string' },
+                    data: { type: 'string' },
+                },
+            },
+        },
+
+        is_downloadable: { type: 'boolean' },
+        is_map: { type: 'boolean' },
+        is_register: { type: 'boolean' },
+
+        group_id: { type: ['string', 'null'] },
+
+        geom_type: { type: 'string' },
+
+        // This is a JSON string containing a GeoJSON Polygon
+        bbox: { type: 'string' },
+
+        keywords_text: { type: ['string', 'null'] },
+
+        token: { type: 'string' },
+
+        is_public_data: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['id', 'text'],
+            properties: {
+                id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+                text: { type: 'string' },
+                icon: { type: ['string', 'null'] },
+                color: { type: 'string' },
+            },
+        },
+
+        view_text: { type: 'string' },
+
+        is_active_data: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['id', 'text'],
+            properties: {
+                id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+                text: { type: 'string' },
+                icon: { type: ['string', 'null'] },
+                color: { type: 'string' },
+            },
+        },
+
+        is_downloadable_data: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['id', 'text'],
+            properties: {
+                id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+                text: { type: 'string' },
+                icon: { type: ['string', 'null'] },
+                color: { type: 'string' },
+            },
+        },
+
+        service_id_text: { type: 'string' },
+        geom_type_text: { type: 'string' },
+
+        tableData: {
+            type: 'array',
+            items: {
+                type: 'object',
+            },
+        },
+    },
+};
+
+export const gisRegistrySchema = {
+    params: {
+        type: 'object',
+        required: ['slug'],
+        properties: {
+            slug: { type: 'string' },
+            objectId: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            filter: queryFilterSchema,
+            search: querySearchSchema,
+            limit: {
+                type: 'number',
+                minimum: 1,
+            },
+            page: {
+                type: 'number',
+                minimum: 1,
+            },
+            sql: {
+                type: 'string',
+                pattern: "^(\\d)$"
+            }
+        },
+    },
+};
+
+export const gisRegistryListSchema = {
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            search: querySearchSchema,
+            limit: {
+                type: 'number',
+                minimum: 1,
+            },
+            page: {
+                type: 'number',
+                minimum: 1,
+            },
+        },
+    },
+};
+
+export const addGisRegistrySchema = {
+    body: { ...registerSchema, required: ['name', 'register_key', 'table_name'] },
+};
+
+export const editGisRegistrySchema = {
+    params: {
+        type: 'object',
+        required: ['slug'],
+        properties: {
+            slug: { type: 'string' },
+        },
+    },
+    body: registerSchema
+};
+
+export const deleteGisRegistrySchema = {
+    params: {
+        type: 'object',
+        required: ['slug'],
+        properties: {
+            slug: { type: 'string' },
+        },
+    },
+};
+
+export const mapRegistrySchema = {};
+
+export const gisExportSchema = {
+    params: {
+        type: 'object',
+        required: ['slug'],
+        properties: {
+            slug: { type: 'string' },
+            type: { type: 'string', enum: ['register', 'service'] },
+        },
+    },
+    querystring: {
+        type: 'object',
+        properties: {
+            format: { type: 'string', enum: ['csv', 'xlsx', 'shp', 'geojson'], default: 'csv' },
+        },
+    },
+};
+
+export default null;