@opengis/gis 0.0.4 → 0.0.6

package/server/routes/gis/registers/funcs/handleRegistryRequest.js

@@ -0,0 +1,100 @@
+import { attachClassifiers } from './classifiers.js';
+import { extractVisibleColumns } from './columns.js';
+import { getMeta, getFilterSQL } from "@opengis/fastify-table/utils.js";
+
+export async function handleRegistryRequest({ settings, query, object_id, offset, limit, page, pg }) {
+    const { name, table_name, columns, filters, query: whereQuery, order, pk, register_id, is_files } = settings;
+    const parsedColumns = Array.isArray(columns) ? columns : JSON.parse(columns);
+    const filtersParsed = Array.isArray(filters) ? filters : JSON.parse(filters);
+    const activeFilters = filtersParsed.filter((f) => f.disabled !== true);
+    const { geom } = await getMeta({ pg, table: table_name });
+
+    const mode = object_id ? "card" : "table";
+    const visibleColumns = extractVisibleColumns(parsedColumns, mode);
+    const selectColumns = visibleColumns.map((col) => col.name);
+    const columnsInfo = visibleColumns.map((col) => ({
+        name: col.name,
+        ua: col.ua,
+        format: col.format,
+        data: col.data,
+        view_type: col.view_type
+    }));
+
+    const classifiers = visibleColumns
+        .filter((col) => col.data && ["select", "badge", "tags"].includes(col.format))
+        .map((col) => ({ name: col.name, classifier: col.data }));
+
+    if (object_id) {
+        const sql = `
+            SELECT "${pk}" as id, ${selectColumns.join(", ")} ${geom ? `, st_asgeojson(${geom})::json as geom` : ''}
+            FROM ${table_name}
+            WHERE ${pk} = $1
+        `;
+        const {
+            rows: [row],
+        } = await pg.query(sql, [object_id]);
+
+        //if (!row) return reply.code(404).send({ message: 'Object not found', status: 404 });
+        if (!row) throw new Error('Object not found');
+
+        await attachClassifiers(row, classifiers);
+
+        return {
+            row,
+            columns: columnsInfo,
+            register_id,
+            name,
+            is_files,
+        };
+    }
+
+    const { search, filter } = query || {};
+    const { q: sqlFilter } = (filter || search)
+        ? await getFilterSQL({
+            table: table_name,
+            search: search,
+            filter: filter,
+            filterList: filters,
+            json: 1
+        })
+        : { q: '1=1' };
+
+    const whereConditions = [whereQuery, sqlFilter].filter(Boolean).join(' AND ');
+    const whereClause = whereConditions ? `WHERE ${whereConditions}` : '';
+
+    const sqlBase = `FROM ${table_name} ${whereClause}`;
+    const sqlOrder = order ? `ORDER BY ${order}` : "";
+    const sqlLimit = `LIMIT $1 OFFSET $2`;
+
+    const sqlSelect = `SELECT "${pk}" as id, ${selectColumns.join(", ")} ${geom ? `, st_asgeojson(${geom})::json as geom` : ''} ${sqlBase}`;
+    const dataQuery = `${sqlSelect} ${sqlOrder} ${sqlLimit}`;
+    const totalQuery = `SELECT COUNT(*) ${sqlBase}`;
+
+    const [dataRes, countRes] = await Promise.all([
+        pg.query(dataQuery, [limit, offset]),
+        pg.query(totalQuery),
+    ]);
+
+    const rows = await attachClassifiers(dataRes.rows, classifiers);
+    const total = parseInt(countRes.rows[0]?.count || 0, 10);
+
+    const listConfig = {};
+    for (const col of parsedColumns) {
+        if (col.view_type === 'title') listConfig.title = col.name;
+        if (col.view_type === 'subtitle') listConfig.subtitle = col.name;
+    }
+
+    return {
+        register_id,
+        name,
+        rows,
+        total,
+        columns: columnsInfo,
+        filters: activeFilters,
+        limit,
+        page,
+        config: {
+            listConfig
+        }
+    };
+}

package/server/routes/gis/registers/gis.registry.js

@@ -0,0 +1,32 @@
+import { pgClients, getTemplate } from "@opengis/fastify-table/utils.js";
+import { handleRegistryRequest } from './funcs/handleRegistryRequest.js';
+const pg = pgClients.client;
+
+export default async function gisRegistry(req = {}) {
+    const { params = {}, query = {} } = req;
+    const { slug } = params;
+    const { page = 1, limit = 9, object_id } = query;
+    const offset = limit * (page - 1);
+
+    //if (!slug) return reply.code(404).send({ message: 'Params slug is required', status: 404 });
+    if (!slug) throw new Error('Params slug is required');
+
+    const {
+        rows: [registry],
+    } = await pg.query(
+        `SELECT register_id, name, table_name, columns, filters, query, "order", pk, register_key, is_files
+        FROM gis.registers
+        WHERE register_key = $1`,
+        [slug]
+    );
+    
+    if (registry) {
+        return await handleRegistryRequest({ settings: registry, query, object_id, offset, limit, page, pg });
+    }
+
+    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');
+
+    return await handleRegistryRequest({ settings: registryTemplate, query, object_id, offset, limit, page, pg });
+}

package/server/routes/gis/registers/gis.registry.list.js

@@ -0,0 +1,59 @@
+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;
+    const offset = limit * (page - 1);
+
+    const dbResult = await pg.query(
+        `SELECT register_key, name, description, keywords
+        FROM gis.registers
+        WHERE is_public = true AND is_active = true`
+    );
+
+    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');
+
+        templates = ( await Promise.all(
+            registryListTemplate.map(async ([slug]) => {
+                try {
+                    const tpl = await getTemplate('registry', slug);
+                    if (tpl?.visible === false) return null;
+
+                    const { register_key, name, description, keywords } = tpl;
+                    return { register_key, name, description, keywords };
+                } catch {
+                    return null;
+                }
+            })
+        ));
+    }
+
+    const filteredBySearch = search
+        ? templates.filter(tpl => {
+            const q = search.toLowerCase();
+            return (
+                tpl.name?.toLowerCase().includes(q) ||
+                tpl.description?.toLowerCase().includes(q) ||
+                tpl.keywords?.join(' ').toLowerCase().includes(q)
+            );
+        })
+        : templates;
+
+    const paged = filteredBySearch.slice(offset, offset + limit);
+
+    return {
+        rows: paged,
+        total: filteredBySearch.length,
+        page: parseInt(page, 10),
+        limit: parseInt(limit, 10),
+        offset
+    };
+}

package/server/routes/gis/registers/insert.columns.js

@@ -0,0 +1,107 @@
+import { getToken } from '@opengis/fastify-table/utils.js';
+/**
+ * Автозаповнення колонок Реєстру
+ *
+ * @method put
+ * @summary Автозаповнення колонок Реєстру
+ * @alias gis.registers
+ * @type api
+ * @tag dataset
+ * @param   {String} token - токен
+ * @returns {Number} status - номер помилки
+ * @returns {String} error - опис помилки
+ * @returns {String} message - повідомлення про успішне виконання і передача певних даних
+ */
+export default async function insertColumns(req,reply) {
+  const {pg, user, params} = req;
+  const token = params.token;
+  if (!token) return { message: 'empty token', status: 400 };
+  try {
+
+    const tokenData = await getToken({ token, uid: user?.uid });
+    if (!tokenData) return reply.code(400).send({ message: 'access restricted', status: 400 });
+
+    const { id, type } = JSON.parse(tokenData) || {};
+    if (!id||!type) return reply.code(403).send({ message: 'access restricted', status: 403 });
+    if (!['services','registers'].includes(type)) return reply.code(403).send({ message: 'invalid type', status: 403 });
+
+    const tableColumn =  (type === 'registers') ? 'table_name':'source_path';
+    const jsonColumn = (type === 'registers') ? 'columns':'attributes';
+    const pk = (type === 'registers')?'register_id':'service_id';
+
+    const select = `update gis.${type} set ${jsonColumn}=
+        (select
+        jsonb_agg(row_to_json(q)) as column_list
+        from
+        (select 
+          q.column_name as name,
+          case 
+            when q.column_name='editor_id' and comment is null then 'Хто редагував'
+            when q.column_name ilike '%geom%' and comment is null then 'Геометрія'
+            when q.column_name='editor_date' and comment is null then 'Дата редагування'
+            when q.column_name='image' and comment is null then 'Зображення'
+            when q.column_name='file' and comment is null then 'Файл'
+            when q.column_name='files' and comment is null then 'Файли'
+            else comment
+          end as ua, 
+          case 
+            when q.data_type in ('text','character varying') then 'text'
+            when q.data_type ='ARRAY' then 'tags'
+            when q.data_type in ('integer','numeric','double precision') then 'number'
+            when q.data_type ='boolean' then 'yes/no'
+            when q.data_type='USER-DEFINED' then 'geom'
+            when q.data_type in ('date','timestamp without time zone') then 'date'
+          end as format,
+          '' as data,
+          false as hidden_register,
+          false as hidden_card
+        from 
+          (
+            select 
+              column_name, 
+              data_type, 
+              table_schema || '.' || table_name as table_name 
+            from 
+              (
+                select 
+                  distinct table_name, 
+                  table_schema, 
+                  column_name, 
+                  data_type
+                from 
+                  information_schema.columns
+              ) q
+          ) q 
+        
+          left join lateral (
+             SELECT
+                pgd.description AS comment,
+                 pgns.nspname||'.'||pgc.relname AS table_name,
+                pg_attribute.attname AS column_name
+                
+                FROM
+                pg_catalog.pg_description pgd
+                JOIN pg_catalog.pg_class pgc ON pgd.objoid = pgc.oid
+                JOIN pg_catalog.pg_namespace pgns ON pgc.relnamespace = pgns.oid
+                JOIN pg_catalog.pg_attribute pg_attribute ON pgc.oid = pg_attribute.attrelid
+                AND pg_attribute.attnum = pgd.objsubid
+          )b on b.column_name=q.column_name and b.table_name=q.table_name
+        where 
+          q.table_name = (
+            select 
+              ${tableColumn} 
+            from 
+              gis.${type} 
+            where
+             ${pk} = '${id}'
+          ) and q.column_name not in ('cdate','uid') and q.data_type<>'json')q
+        )
+        where ${pk} = '${id}'
+        `;
+    await pg.one(select);
+
+    return { message: 'Колонки заповнені упішно', status: 200 };
+  } catch (err) {
+    return reply.code(500).send({ message: err.message, status: 500 });
+  }
+}

package/server/routes/gis/registers/insert.filters.js

@@ -0,0 +1,110 @@
+import { getToken } from '@opengis/fastify-table/utils.js';
+
+/**
+ * Автозаповнення фільтрів Реєстру
+ *
+ * @method put
+ * @summary Автозаповнення фільтрів Реєстру
+ * @alias createDatasetFromApplicationApi
+ * @type api
+ * @tag dataset
+ * @param   {String} token - токен Реєстру
+ * @returns {Number} status - номер помилки
+ * @returns {String} error - опис помилки
+ * @returns {String} message - повідомлення про успішне виконання і передача певних даних
+ * @returns {String} headers - заголовки HTTP
+ */
+export default async function insertFilters(req,reply) {
+  const {
+    pg, user, params,
+  } =req;
+  const token = params.token ;
+  if (!token) return { message: 'empty token', status: 400 };
+  try {
+
+    const tokenData = await getToken({ token, uid: user?.uid });
+    if (!tokenData) return reply.code(400).send({ message: 'access restricted', status: 400 });
+
+    const { id, type } = JSON.parse(tokenData) || {};
+
+    if (!id||!type) return reply.code(403).send({ message: 'access restricted', status: 403 });
+    if (!['services','registers'].includes(type)) return reply.code(403).send({ message: 'invalid type', status: 403 });
+
+    const tableColumn =  (type === 'registers') ? 'table_name':'source_path';
+    const pk = (type === 'registers')?'register_id':'service_id';
+
+
+    const select = `update gis.${type} set filters=
+        (select
+          jsonb_agg(row_to_json(q)) as filter_list
+          from
+          (select 
+            q.column_name as id,
+            case 
+              when q.column_name='editor_id' and comment is null then 'Хто редагував'
+              when q.column_name ilike '%geom%' and comment is null then 'Геометрія'
+              when q.column_name='editor_date' and comment is null then 'Дата редагування'
+              when q.column_name='image' and comment is null then 'Зображення'
+              when q.column_name='file' and comment is null then 'Файл'
+               when q.column_name='files' and comment is null then 'Файли'
+              else comment
+            end as label, 
+            case 
+              when q.data_type in ('text','character varying','integer','numeric','double precision') then 'Text'
+              when q.data_type ='ARRAY' then 'Tags'
+              when q.data_type ='boolean' then 'Switcher'
+              when q.data_type in ('date','timestamp without time zone') then 'Date'
+              --else q.data_type
+            end as type,
+            '' as data,
+            false as disabled
+          from 
+            (
+              select 
+                column_name, 
+                data_type, 
+                table_schema || '.' || table_name as table_name 
+              from 
+                (
+                  select 
+                    distinct table_name, 
+                    table_schema, 
+                    column_name, 
+                    data_type
+                  from 
+                    information_schema.columns
+                ) q
+            ) q 
+          
+            left join lateral (
+               SELECT
+                  pgd.description AS comment,
+                   pgns.nspname||'.'||pgc.relname AS table_name,
+                  pg_attribute.attname AS column_name
+                  
+                  FROM
+                  pg_catalog.pg_description pgd
+                  JOIN pg_catalog.pg_class pgc ON pgd.objoid = pgc.oid
+                  JOIN pg_catalog.pg_namespace pgns ON pgc.relnamespace = pgns.oid
+                  JOIN pg_catalog.pg_attribute pg_attribute ON pgc.oid = pg_attribute.attrelid
+                  AND pg_attribute.attnum = pgd.objsubid
+            )b on b.column_name=q.column_name and b.table_name=q.table_name
+          where 
+            q.table_name = (
+              select 
+                ${tableColumn} 
+              from 
+                gis.${type} 
+              where
+               ${pk} = '${id}'
+            ) and q.column_name not in ('cdate','uid','geom') and q.data_type not in ('json','USER-DEFINED'))q
+        )
+        where ${pk} = '${id}'
+        `;
+    await pg.one(select);
+
+    return { message: 'Фільтри заповнені упішно', status: 200 };
+  } catch (err) {
+    return reply.code(500).send({ message: err.message, status: 500 });
+  }
+}

package/server/routes/gis/registers/map.registry.js

@@ -0,0 +1,79 @@
+import { pgClients, getFilterSQL, getTemplate } from "@opengis/fastify-table/utils.js";
+import { attachClassifiers } from './funcs/classifiers.js';
+const pg = pgClients.client;
+
+export default async function mapRegistry(req,reply) {
+const { params = {}, query = {} } = req;
+    const { slug, id } = params;
+    const { filter, page = 1 } = query;
+
+    if (!slug || !id) return reply.code(404).send({ message: 'Params slug and id is required', status: 404 });
+
+    const mapTemplate = await getTemplate('map', slug);
+    if (!mapTemplate) return reply.code(404).send({ message: 'Template not found', status: 404 });
+
+    const listWidget = mapTemplate.widgets?.find(w => w.type === 'list' && w.visible !== false && w.id === id);
+    if (!listWidget) return reply.code(404).send({ message: 'List widget not found', status: 404 });
+
+    const {
+        table,
+        pk,
+        query: baseQuery = '1=1',
+        order,
+        config = {},
+        name = '',
+    } = listWidget;
+
+    const { columns = [], filters = [], limit: configLimit = 20 } = config;
+    const limit = query.limit || configLimit;
+    const offset = limit * (page - 1);
+    const selectColumns = columns.map(col => col.name);
+
+    const classifiers = columns
+        .filter(col => col.data && ["select", "badge", "tags"].includes(col.format))
+        .map(col => ({ name: col.name, classifier: col.data }));
+
+
+    const { q: sqlFilter } = filter
+        ? await getFilterSQL({ table, filter, json: 1 })
+        : { q: '1=1' };
+
+    const whereConditions = [baseQuery, sqlFilter].filter(Boolean).join(" AND ");
+    const whereClause = whereConditions ? `WHERE ${whereConditions}` : "";
+
+    const sqlBase = `FROM ${table} ${whereClause}`;
+    const sqlOrder = order ? `ORDER BY ${order}` : "";
+    const sqlLimit = `LIMIT $1 OFFSET $2`;
+    const sqlSelect = `SELECT ${pk} as id, ${selectColumns.join(", ")} 
+    ${sqlBase}`;
+    const dataQuery = `${sqlSelect} ${sqlOrder} ${sqlLimit}`;
+    const totalQuery = `SELECT COUNT(*) ${sqlBase}`;
+
+    const [dataRes, countRes] = await Promise.all([
+        pg.query(dataQuery, [limit, offset]),
+        pg.query(totalQuery)
+    ]);
+
+    const rows = await attachClassifiers(dataRes?.rows, classifiers);
+    const total = parseInt(countRes?.rows[0]?.count || 0, 10);
+
+    const listViewConfig = {};
+    columns.forEach(col => {
+        if (col.view_type === 'title') listViewConfig.title = col?.name;
+        if (col.view_type === 'subtitle') listViewConfig.subtitle = col?.name;
+    });
+
+    return {
+        name,
+        rows,
+        total,
+        columns,
+        filters,
+        config: {
+            ...listWidget,
+            list: {
+                ...listViewConfig
+            }
+        }
+    };
+}

package/server/routes/gis/services/get.layer.geom.js

@@ -0,0 +1,27 @@
+export default async function getLayerGeom(req) {
+  const { pg, params, query } = req;
+
+  const { id } = params;
+  if (!id) return { message: 'id is empty', status: 403 };
+
+  const selectTable = `select source_path,geometry_column from gis.services where service_id='${id}'`;
+  const { source_path: table, geometry_column: geometryColumn = 'geom' } = await pg.one(selectTable);
+  if (!table) return;
+  const selectGeom = `
+    SELECT 'FeatureCollection' As type,
+                               json_agg(q) as features
+                        FROM (
+                                SELECT 'Feature' as type,
+                                     row_number() over() as id, st_asgeojson(
+                                    st_force2d(${geometryColumn}),
+                                        6,
+                                        0
+                                    ) :: json as geometry
+                              from ${table}
+                              where ${geometryColumn} is not null) q`;
+  if (query?.sql) return selectGeom;
+  const { rows } = await pg.query(selectGeom);
+
+  return { message: rows, status: 200 };
+
+}

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

@@ -0,0 +1,123 @@
+import path from 'node:path';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'url';
+import { createHash } from 'node:crypto';
+
+import { config, getMeta, getTemplate, getTemplateSync, pgClients, getSelect, getSelectVal, getTemplatePath } from '@opengis/fastify-table/utils.js';
+
+const { prefix = '/api' } = config;
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const maps = getTemplatePath('map')?.map?.(el => {
+    const { name = el[0] } = getTemplateSync('map', el[0]) || {};
+    return { slug: el[0], name };
+});
+
+async function processObject(loadTemplate, pg = pgClients.client, unittest) {
+    const { bbox = [], center = [] } = loadTemplate?.source_path && pg.pk?.[loadTemplate.source_path]
+        ? await pg.query(`select
+                array[ST_XMin(env), ST_YMin(env), ST_XMax(env),ST_YMax(env)] as bbox,
+                st_asgeojson(st_centroid(env))::json->'coordinates' as center
+            from ( select st_extent(geom) as env from ${loadTemplate.source_path} where ${loadTemplate.source_query || '1=1'})q`
+        ).then(el => el.rows?.[0] || {})
+        : {};
+    loadTemplate.map = { bbox, center };
+
+
+    if (!loadTemplate?.widgets?.length) return;
+    // add legend if not exists in widget
+    const idx = loadTemplate.widgets.findIndex(el => el.type === 'attribute_style');
+    const { source_path: attrTable, attribute, cls: clsName, legend = [], colors } = loadTemplate.widgets.find(el => el.type === 'attribute_style')?.config || {};
+    const colors1 = colors || ['red', 'black', 'blue', 'green', 'orange'];
+
+    if (!legend?.length && attribute && attrTable) {
+        const { columns = {} } = await getMeta({ pg, table: attrTable });
+        const { dataTypeID = 0 } = columns.find(item => item.name === attribute) || {};
+        const q = pg.pgType?.[dataTypeID]?.includes?.('[]')
+            ? `select unnest(${attribute})::text as id,count(*) from ${attrTable} group by unnest(${attribute}) limit 100`
+            : `select ${attribute}::text as id,count(*) from ${attrTable} group by ${attribute} limit 100`;
+
+        if (config.trace || unittest) console.log(q);
+        const countArr = await pg.queryCache(q, { time: 5 });
+
+        const ids = countArr.rows.map(item => item.id);
+
+        const cls = await getSelect(clsName, pg);
+        const clsData = await getSelectVal({ pg, values: ids, cls: clsName });
+
+        const options = countArr.rows.map((cel, idx) => {
+            const data = cls?.arr?.find?.(c => c.id?.toString?.() === cel.id?.toString?.()) || { text: clsData?.[cel.id]?.text || clsData?.[cel.id] };
+            const color = (colors?.length ? colors1[idx % colors1.length] : null) || data?.color || colors1[idx % colors1.length];
+            return { ...cel, ...data, color };
+        });
+        loadTemplate.widgets[idx].config.legend = options;
+    }
+
+
+    const { source_path: table, filters = [] } = loadTemplate.widgets.find(el => el.type === 'filters')?.config || {};
+
+    filters.forEach(el => Object.assign(el, { name: el.name || el.id }));
+
+    // md5 hash for suggest security
+    filters.filter(el => el.type?.toLowerCase() === 'select').map(async (el) => {
+        const hash = createHash('md5').update([table, el.name].join()).digest('hex');
+        el.api = `${prefix}/suggest/hash-${hash}`;
+        const filepath = path.join(dirname, `../../../../log/suggest/${hash}.json`);
+        if (existsSync(filepath)) { return; };
+        mkdirSync(path.dirname(filepath), { recursive: true });
+        writeFileSync(filepath, JSON.stringify({ table, column: el.name }), { encoding: 'utf8' });
+    });
+
+    // add options to filters
+    if (filters.filter(el => el.data).length && table) {
+        const { columns = {} } = await getMeta({ pg, table });
+        await Promise.all(filters.filter(el => el.data && el.name).map(async (el) => {
+            const { dataTypeID = 0 } = columns.find(item => item.name === el.name) || {};
+            const q = pg.pgType?.[dataTypeID]?.includes?.('[]')
+                ? `select unnest(${el.name})::text as id,count(*) from ${table} group by unnest(${el.name}) limit 100`
+                : `select ${el.name}::text as id,count(*) from ${table} group by ${el.name} limit 100`;
+
+            if (config.trace || unittest) console.log(q);
+            const countArr = await pg.queryCache(q, { time: 5 });
+
+            const ids = countArr.rows.map(item => item.id);
+
+            const cls = await getSelect(el.data, pg);
+            const clsData = await getSelectVal({ pg, values: ids, name: el.data });
+
+            const options = 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 };
+            });
+            Object.assign(el, { options });
+        }));
+    }
+    return loadTemplate;
+}
+
+export default async function map({ pg = pgClients.client, params = {}, unittest }, reply) {
+    const { slug } = params;
+
+    const loadTemplate = await getTemplate('map', slug);
+
+    if (!loadTemplate) {
+        return reply.status(404).send('map not found');
+    }
+
+    if (!Array.isArray(loadTemplate)) {
+        await processObject(loadTemplate, pg, unittest);
+        return { ...loadTemplate, maps };
+    }
+
+    const index = loadTemplate?.find?.(el => el[0].split('.').shift() === 'index')?.[1];
+
+    if (!index) {
+        return reply.status(404).send('map index not found');
+    }
+
+    await processObject(index, pg, unittest);
+
+    const layers = loadTemplate?.filter?.(el => el[0].split('.').shift() !== 'index')?.map(el => ({ ...el[1], id: el[0].replace('.yml', '').replace('.json', '') }));
+
+    return reply.status(200).send({ ...index, layers, maps });
+}