@opengis/gis 0.2.176 → 0.2.178

package/server/routes/metadata/functions/editMetadata.js

@@ -1,35 +1,35 @@
-import { BadRequestError, NotFoundError } from "@opengis/fastify-table/errors.js";
-import { pgClients, dataUpsert } from "@opengis/fastify-table/utils.js";
-
-export default async function editMetadata({ id, type, body, uid }, pg = pgClients.client) {
-  if (!type) {
-    throw BadRequestError('not enough params: type');
-  }
-
-  const q = {
-    raster: 'select 1 from gis.rasters where raster_id = $1',
-    css: 'select 1 from gis.cartocss where cartocss_id = $1',
-    dataset: 'select 1 from gis.dataset where dataset_id = $1',
-    service: 'select 1 from gis.services where service_id = $1',
-  }[type];
-
-  if (!q) {
-    throw BadRequestError('invalid params: type');
-  }
-
-  const exists = await pg.query(q, [id]).then(r => r.rowCount || 0);
-
-  if (!exists) {
-    throw NotFoundError(`${type} not found: ${id}`);
-  }
-
-  const data = await dataUpsert({
-    pg,
-    id: id,
-    table: 'gis.metadata',
-    data: { ...body, type: type, layer_id: id },
-    uid,
-  });
-
-  return data;
-}
+import { BadRequestError, NotFoundError } from "@opengis/fastify-table/errors.js";
+import { pgClients, dataUpsert } from "@opengis/fastify-table/utils.js";
+
+export default async function editMetadata({ id, type, body, uid }, pg = pgClients.client) {
+  if (!type) {
+    throw BadRequestError('not enough params: type');
+  }
+
+  const q = {
+    raster: 'select 1 from gis.rasters where raster_id = $1',
+    css: 'select 1 from gis.cartocss where cartocss_id = $1',
+    dataset: 'select 1 from gis.dataset where dataset_id = $1',
+    service: 'select 1 from gis.services where service_id = $1',
+  }[type];
+
+  if (!q) {
+    throw BadRequestError('invalid params: type');
+  }
+
+  const exists = await pg.query(q, [id]).then(r => r.rowCount || 0);
+
+  if (!exists) {
+    throw NotFoundError(`${type} not found: ${id}`);
+  }
+
+  const data = await dataUpsert({
+    pg,
+    id: id,
+    table: 'gis.metadata',
+    data: { ...body, type: type, layer_id: id },
+    uid,
+  });
+
+  return data;
+}

package/server/routes/metadata/functions/metadataXML.js

@@ -1,19 +1,19 @@
-import { handlebars, getTemplate } from "@opengis/fastify-table/utils.js";
-import { BadRequestError } from "@opengis/fastify-table/errors.js";
-
-// currently unused
-export default async function metadataXml({ id }) {
-  if (!id) {
-    throw BadRequestError('not enough params: id');
-  }
-
-  const pt = await getTemplate('templates', 'ISO19136_2017_gml_template');
-  const data = await handlebars.compile(pt)({ id });
-
-  return {
-    headers: {
-      'Content-Type': 'text/xml; charset=utf-8',
-    },
-    data
-  };
-}
+import { handlebars, getTemplate } from "@opengis/fastify-table/utils.js";
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+
+// currently unused
+export default async function metadataXml({ id }) {
+  if (!id) {
+    throw BadRequestError('not enough params: id');
+  }
+
+  const pt = await getTemplate('templates', 'ISO19136_2017_gml_template');
+  const data = await handlebars.compile(pt)({ id });
+
+  return {
+    headers: {
+      'Content-Type': 'text/xml; charset=utf-8',
+    },
+    data
+  };
+}

package/server/routes/metadata/metadata.route.js

@@ -1,26 +1,26 @@
-// import metadataXML from './functions/metadataXML.js';
-import editMetadata from './functions/editMetadata.js';
-
-import {
-    editMetadataSchema,
-} from './metadata.schema.js';
-
-const privateParams = { config: { policy: 'L1', package: 'gis' } };
-// const publicParams = { config: { policy: 'L0', package: 'gis' } };
-
-async function route(app) {
-    /*app.get('/xml/:id', { ...publicParams, schema: metadataXMLSchema }, async ({ params }, reply) => {
-        const result = await metadataXML({ id: params.id });
-        return reply.headers(result.headers).send(result.data);
-    });*/
-    app.post('/gis-metadata/:type/:id', { ...privateParams, schema: editMetadataSchema }, async ({ params, body, user, pg }) => {
-        const result = await editMetadata({
-            id: params.id,
-            type: params.type,
-            body,
-            uid: user?.uid,
-        }, pg);
-        return result;
-    });
-}
-export default route;
+// import metadataXML from './functions/metadataXML.js';
+import editMetadata from './functions/editMetadata.js';
+
+import {
+    editMetadataSchema,
+} from './metadata.schema.js';
+
+const privateParams = { config: { policy: 'L1', package: 'gis' } };
+// const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
+async function route(app) {
+    /*app.get('/xml/:id', { ...publicParams, schema: metadataXMLSchema }, async ({ params }, reply) => {
+        const result = await metadataXML({ id: params.id });
+        return reply.headers(result.headers).send(result.data);
+    });*/
+    app.post('/gis-metadata/:type/:id', { ...privateParams, schema: editMetadataSchema }, async ({ params, body, user, pg }) => {
+        const result = await editMetadata({
+            id: params.id,
+            type: params.type,
+            body,
+            uid: user?.uid,
+        }, pg);
+        return result;
+    });
+}
+export default route;

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

@@ -1,47 +1,47 @@
-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 = 'testCss';
-const user = { id: '2', type: 'admin' };
-
-const cleanUp = async (when) => {
-    if (!pg) return;
-    const rowCount = await pg.query('delete from gis.cartocss where cartocss_id=$1', [testId]).then(r => r.rowCount || 0);
-    const rowCount3 = await pg.query('delete from gis.metadata where metadata_id=$1', [testId]).then(r => r.rowCount || 0);
-    console.log(`clean up finished: ${when}`, rowCount, rowCount3);
-};
-
-describe('GIS routes', () => {
-    test('POST /gis-metadata/:type/:id returns 200', async () => {
-        await pg.query('insert into gis.cartocss(cartocss_id,name) values($1,$2)', [testId, 'unit-test']).catch(err => console.error(err));
-        const res = await injectWithHeaders({
-            method: 'POST',
-            url: `/api/gis-metadata/css/${testId}`,
-            payload: {
-                layer_id: testId
-            },
-            headers: { uid: user.id, user_type: user.type }
-        });
-
-        expect(res.statusCode).toBe(200);
-        expect(res.body).toHaveProperty('metadata_id');
-        expect(res.body.metadata_id).toBe(testId);
-    });
+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 = 'testCss';
+const user = { id: '2', type: 'admin' };
+
+const cleanUp = async (when) => {
+    if (!pg) return;
+    const rowCount = await pg.query('delete from gis.cartocss where cartocss_id=$1', [testId]).then(r => r.rowCount || 0);
+    const rowCount3 = await pg.query('delete from gis.metadata where metadata_id=$1', [testId]).then(r => r.rowCount || 0);
+    console.log(`clean up finished: ${when}`, rowCount, rowCount3);
+};
+
+describe('GIS routes', () => {
+    test('POST /gis-metadata/:type/:id returns 200', async () => {
+        await pg.query('insert into gis.cartocss(cartocss_id,name) values($1,$2)', [testId, 'unit-test']).catch(err => console.error(err));
+        const res = await injectWithHeaders({
+            method: 'POST',
+            url: `/api/gis-metadata/css/${testId}`,
+            payload: {
+                layer_id: testId
+            },
+            headers: { uid: user.id, user_type: user.type }
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('metadata_id');
+        expect(res.body.metadata_id).toBe(testId);
+    });
 });

package/server/routes/metadata/metadata.schema.js

@@ -1,53 +1,53 @@
-export const editMetadataSchema = {
-    params: {
-        type: 'object',
-        required: ['type', 'id'],
-        properties: {
-            type: { type: 'string', enum: ['raster', 'css', 'dataset', 'service'] },
-            id: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-        },
-    },
-    body: {
-        type: 'object',
-        // additionalProperties: false,
-        properties: {
-            geom: {
-                type: 'object',
-                properties: {
-                    type: { type: 'string', enum: ['Point', 'LineString', 'Polygon'] },
-                    coordinates: { type: 'array' },
-                },
-                required: ['type', 'coordinates'],
-            },
-            description: { type: 'string' },
-            group_id: { type: 'string' },
-            keywords: {
-                type: 'array',
-                items: { type: 'string' },
-            },
-            is_public: { type: 'boolean' },
-            is_active: { type: 'boolean' },
-            service_key: { type: 'string' },
-            producer: { type: 'string' },
-            category: { type: 'string' },
-            license: { type: 'string' },
-            year: { type: 'string' },
-            service_url: { type: 'string' },
-            metadata_url: { type: 'string' },
-            thumbnail_url: { type: 'string' },
-            query: { type: 'string' },
-        },
-    },
-};
-
-export const metadataXMLSchema = {
-    params: {
-        type: 'object',
-        required: ['id'],
-        properties: {
-            id: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
-        },
-    },
-};
-
-export default null;
+export const editMetadataSchema = {
+    params: {
+        type: 'object',
+        required: ['type', 'id'],
+        properties: {
+            type: { type: 'string', enum: ['raster', 'css', 'dataset', 'service'] },
+            id: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+        },
+    },
+    body: {
+        type: 'object',
+        // additionalProperties: false,
+        properties: {
+            geom: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', enum: ['Point', 'LineString', 'Polygon'] },
+                    coordinates: { type: 'array' },
+                },
+                required: ['type', 'coordinates'],
+            },
+            description: { type: 'string' },
+            group_id: { type: 'string' },
+            keywords: {
+                type: 'array',
+                items: { type: 'string' },
+            },
+            is_public: { type: 'boolean' },
+            is_active: { type: 'boolean' },
+            service_key: { type: 'string' },
+            producer: { type: 'string' },
+            category: { type: 'string' },
+            license: { type: 'string' },
+            year: { type: 'string' },
+            service_url: { type: 'string' },
+            metadata_url: { type: 'string' },
+            thumbnail_url: { type: 'string' },
+            query: { type: 'string' },
+        },
+    },
+};
+
+export const metadataXMLSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+        },
+    },
+};
+
+export default null;

package/server/routes/ogc/functions/map.info.point.js

@@ -1,117 +1,117 @@
-import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
-import {
-  pgClients, handlebars, getMeta, getTemplate, getFilterSQL,
-} from '@opengis/fastify-table/utils.js';
-
-const columnType = {
-  text: 'text',
-  date: 'date',
-  bool: 'yes/no',
-  numeric: 'number',
-  integer: 'number',
-  'timestamp without time zone': 'date',
-  'timestamp with time zone': 'date',
-};
-
-export default async function mapInfoPoint({ x, y, layers, index = 0, sql }, pg = pgClients.client) {
-  const time = Date.now();
-
-  if (!x || !y || !layers) {
-    throw BadRequestError('not enough query params: x, y, layers are required');
-  }
-
-  const rows = pg?.pk?.['gis.ogc_service'] ? await pg.query('select * from gis.ogc_service WHERE enabled and table_name is not null and ogc_service_id = any($1)', [layers.split(',')]).then(r => r.rows || []) : [];
-
-  if (!rows.length) {
-    throw NotFoundError('layers not found');
-  }
-
-  const args = [];
-
-  // 30, 50
-  args.push(x);
-  args.push(y);
-
-  const srids = pg.queryCache ? await pg.queryCache('select json_agg(srid) as srids from spatial_ref_sys').then(r => r.rows?.[0]?.srids || {}) : {};
-
-  await Promise.all(rows.map(async (layer, idx) => {
-    const { table_name: source, ogc_service_id: layerId } = layer;
-    const loadTable = await getTemplate('table', source);
-    const meta = await getMeta({ pg, table: loadTable?.table || source });
-    const { geom = 'geom' } = meta || {};
-    const { table = source, columns = meta?.columns } = loadTable || {};
-    const { srid, x } = await pg.query(`select st_srid(${geom}) as srid, st_x(st_pointonsurface(${geom})) as x from ${table} where geom is not null limit 1`).then(r => r.rows?.[0] || {});
-
-    const cls = columns
-      ?.filter(el => el.name && el.data)
-      ?.reduce?.((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
-
-    const pk = pg.pk?.[table] || loadTable?.key;
-
-    const { optimizedSQL } = await getFilterSQL({ pg, table: source, query: layer?.query });
-
-    Object.assign(layer, {
-      layer: (layerId || idx.toString())?.replace?.(/'/g, "''"),
-      table,
-      pk,
-      cls,
-      geomColumn: srid === 4326 ? geom : `st_transform(${geom},4326)`,
-      optimizedSQL,
-      srid,
-      step: srids?.includes?.(srid - 0) && srid !== 4326 && x > 100 ? 10 : 0.0002,
-    });
-  }));
-
-  const unique = rows.filter((el, idx, arr) => el.table && arr.map((item) => item.table).indexOf(el.table) === idx);
-
-  const qList = unique.map((el) => ({
-    query: `select ${el.pk}::text as pk, '${el.layer}' as layer, '${el.table}' as table,
-    row_to_json(t) as data, 
-    st_distance(${el.geomColumn}, st_setsrid(st_makepoint($1,$2),4326)) as distance,
-    st_asgeojson(${el.geomColumn})::json as geom from (${el.optimizedSQL}) t 
-    where 1=1`,
-    queryCount: `select 1 from (${el.optimizedSQL})t where 1=1`,
-    where: `${el.geomColumn} && st_setsrid(st_makepoint($1,$2),4326)`,
-  }));
-
-  const q = qList.map(el => `${el.query} and ${el.where}`).join(' union all ').concat(` order by distance limit 1 offset $3::bigint`);
-
-  const qCount = qList.map(el => `${el.queryCount} and ${el.where}`).join(' union all ');
-
-  if (sql === 1 && process.platform === 'win32') return q;
-  if (sql === 2 && process.platform === 'win32') return qCount;
-
-  const count = await pg.query(qCount, args).then(el => el.rowCount);
-
-  const row = await pg.query(q, args.concat([Math.max(+index || 0, 0)])).then(r => r.rows?.[0]);
-
-  if (!row) {
-    throw NotFoundError('object not found');
-  }
-
-  const columns = row.table ? await getMeta({ pg, table: row.table }).then(r => r.columns || []) : [];
-  const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
-
-  const htmlTemplate = pg?.pk?.['admin.templates'] && row.layer && false
-    ? await pg.query('select body from admin.templates where name=$1 limit 1', [row.layer]).then(r => r.rows?.[0]?.body)
-    : rows.find(el => el.ogc_service_id === row.layer)?.html;
-
-  const html = await handlebars.compile(htmlTemplate || 'template not found')(row.data);
-
-  const res = {
-    time: Date.now() - time,
-    index,
-    count,
-    data: {
-      layer: row.layer,
-      geom: row.geom,
-      id: row.pk,
-      distance: row.distance,
-      data: row.data,
-    },
-    fields,
-    html,
-  };
-
-  return res;
-}
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
+import {
+  pgClients, handlebars, getMeta, getTemplate, getFilterSQL,
+} from '@opengis/fastify-table/utils.js';
+
+const columnType = {
+  text: 'text',
+  date: 'date',
+  bool: 'yes/no',
+  numeric: 'number',
+  integer: 'number',
+  'timestamp without time zone': 'date',
+  'timestamp with time zone': 'date',
+};
+
+export default async function mapInfoPoint({ x, y, layers, index = 0, sql }, pg = pgClients.client) {
+  const time = Date.now();
+
+  if (!x || !y || !layers) {
+    throw BadRequestError('not enough query params: x, y, layers are required');
+  }
+
+  const rows = pg?.pk?.['gis.ogc_service'] ? await pg.query('select * from gis.ogc_service WHERE enabled and table_name is not null and ogc_service_id = any($1)', [layers.split(',')]).then(r => r.rows || []) : [];
+
+  if (!rows.length) {
+    throw NotFoundError('layers not found');
+  }
+
+  const args = [];
+
+  // 30, 50
+  args.push(x);
+  args.push(y);
+
+  const srids = pg.queryCache ? await pg.queryCache('select json_agg(srid) as srids from spatial_ref_sys').then(r => r.rows?.[0]?.srids || {}) : {};
+
+  await Promise.all(rows.map(async (layer, idx) => {
+    const { table_name: source, ogc_service_id: layerId } = layer;
+    const loadTable = await getTemplate('table', source);
+    const meta = await getMeta({ pg, table: loadTable?.table || source });
+    const { geom = 'geom' } = meta || {};
+    const { table = source, columns = meta?.columns } = loadTable || {};
+    const { srid, x } = await pg.query(`select st_srid(${geom}) as srid, st_x(st_pointonsurface(${geom})) as x from ${table} where geom is not null limit 1`).then(r => r.rows?.[0] || {});
+
+    const cls = columns
+      ?.filter(el => el.name && el.data)
+      ?.reduce?.((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
+
+    const pk = pg.pk?.[table] || loadTable?.key;
+
+    const { optimizedSQL } = await getFilterSQL({ pg, table: source, query: layer?.query });
+
+    Object.assign(layer, {
+      layer: (layerId || idx.toString())?.replace?.(/'/g, "''"),
+      table,
+      pk,
+      cls,
+      geomColumn: srid === 4326 ? geom : `st_transform(${geom},4326)`,
+      optimizedSQL,
+      srid,
+      step: srids?.includes?.(srid - 0) && srid !== 4326 && x > 100 ? 10 : 0.0002,
+    });
+  }));
+
+  const unique = rows.filter((el, idx, arr) => el.table && arr.map((item) => item.table).indexOf(el.table) === idx);
+
+  const qList = unique.map((el) => ({
+    query: `select ${el.pk}::text as pk, '${el.layer}' as layer, '${el.table}' as table,
+    row_to_json(t) as data, 
+    st_distance(${el.geomColumn}, st_setsrid(st_makepoint($1,$2),4326)) as distance,
+    st_asgeojson(${el.geomColumn})::json as geom from (${el.optimizedSQL}) t 
+    where 1=1`,
+    queryCount: `select 1 from (${el.optimizedSQL})t where 1=1`,
+    where: `${el.geomColumn} && st_setsrid(st_makepoint($1,$2),4326)`,
+  }));
+
+  const q = qList.map(el => `${el.query} and ${el.where}`).join(' union all ').concat(` order by distance limit 1 offset $3::bigint`);
+
+  const qCount = qList.map(el => `${el.queryCount} and ${el.where}`).join(' union all ');
+
+  if (sql === 1 && process.platform === 'win32') return q;
+  if (sql === 2 && process.platform === 'win32') return qCount;
+
+  const count = await pg.query(qCount, args).then(el => el.rowCount);
+
+  const row = await pg.query(q, args.concat([Math.max(+index || 0, 0)])).then(r => r.rows?.[0]);
+
+  if (!row) {
+    throw NotFoundError('object not found');
+  }
+
+  const columns = row.table ? await getMeta({ pg, table: row.table }).then(r => r.columns || []) : [];
+  const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
+
+  const htmlTemplate = pg?.pk?.['admin.templates'] && row.layer && false
+    ? await pg.query('select body from admin.templates where name=$1 limit 1', [row.layer]).then(r => r.rows?.[0]?.body)
+    : rows.find(el => el.ogc_service_id === row.layer)?.html;
+
+  const html = await handlebars.compile(htmlTemplate || 'template not found')(row.data);
+
+  const res = {
+    time: Date.now() - time,
+    index,
+    count,
+    data: {
+      layer: row.layer,
+      geom: row.geom,
+      id: row.pk,
+      distance: row.distance,
+      data: row.data,
+    },
+    fields,
+    html,
+  };
+
+  return res;
+}

package/server/routes/ogc/ogc.route.js

@@ -1,21 +1,21 @@
-import mapInfoPoint from './functions/map.info.point.js';
-
-import {
-    mapInfoPointSchema,
-} from './ogc.schema.js';
-
-const publicParams = { config: { policy: 'L0', package: 'gis' } };
-
-async function route(app) {
-    app.get('/map-info-point', { ...publicParams, schema: mapInfoPointSchema }, async ({ query, pg }) => {
-        const result = await mapInfoPoint({
-            x: query.x,
-            y: query.y,
-            layers: query.layers,
-            index: query.index,
-            sql: query.sql
-        }, pg);
-        return result;
-    });
-}
-export default route;
+import mapInfoPoint from './functions/map.info.point.js';
+
+import {
+    mapInfoPointSchema,
+} from './ogc.schema.js';
+
+const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
+async function route(app) {
+    app.get('/map-info-point', { ...publicParams, schema: mapInfoPointSchema }, async ({ query, pg }) => {
+        const result = await mapInfoPoint({
+            x: query.x,
+            y: query.y,
+            layers: query.layers,
+            index: query.index,
+            sql: query.sql
+        }, pg);
+        return result;
+    });
+}
+export default route;