@opengis/gis 0.2.167 → 0.2.169

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

@@ -0,0 +1,371 @@
+import { readFile } from 'fs/promises';
+
+import {
+    describe, test, expect, beforeAll, afterAll
+} from 'vitest';
+
+import { config, getPGAsync, isFileExists, uploadFile } from '@opengis/fastify-table/utils.js';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+const user = { uid: '2', type: 'admin' };
+
+const testId = 'testRasterId';
+
+const rasterRelPath = 'test/files/black1x1.tif';
+
+let pg;
+
+const cleanUp = async (when) => {
+    if (!pg) return;
+    const rowCount = await pg.query('delete from gis.rasters where raster_id=$1', [testId]).then(r => r.rowCount);
+    console.log(`clean up ${when} finished`, rowCount);
+}
+
+beforeAll(async () => {
+    await build();
+    pg = await getPGAsync();
+    expect(pg).toHaveProperty('pk');
+    await cleanUp('before');
+
+    const exists = await isFileExists('/files/temp/black1x1.tif');
+    if (!exists && config.s3) {
+        // upload raster to s3
+        const buffer = await readFile(rasterRelPath);
+        await uploadFile('/files/test/black1x1.tif', buffer);
+    }
+
+    await pg.query('insert into gis.rasters (raster_id,name,source_path) values($1,$2,$3)', [testId, 'unit-test', '/files/test/black1x1.tif']).catch(err => console.error(err));
+});
+
+afterAll(async () => {
+    await cleanUp('after');
+});
+
+test('GET /gis-upload-raster/:id (restrict unauthorized)', async () => {
+    const res = await injectWithHeaders({
+        method: 'GET',
+        url: `/api/gis-upload-raster/${testId}`,
+    });
+    expect(res.statusCode).toBe(403);
+});
+
+if (config.s3) {
+    describe('upload raster from s3 to mapnik for processing / tile generation', () => {
+        test('GET /gis-upload-raster/:id', async () => {
+            const res = await injectWithHeaders({
+                method: 'GET',
+                url: `/api/gis-upload-raster/${testId}`,
+                headers: { uid: user.uid, user_type: 'regular' },
+            });
+            expect(res.statusCode).toBe(200);
+            expect(res.body).not.toHaveProperty('error');
+        });
+    });
+}
+
+test('GET /gis-xml/:id', async () => {
+    const res = await injectWithHeaders({
+        method: 'GET',
+        url: `/api/gis-xml/${testId}`,
+        query: { nocache: 1 }
+    });
+    expect(res.statusCode).toBe(200);
+});
+
+describe('GET /gis-rtile', async () => {
+    test('WEBP from raster', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-rtile/${testId}/10/523/391.webp`,
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toMatch(/image\/webp/);
+        expect(res.body.length).toBeGreaterThan(200);
+    });
+
+    const cartocssId = await pg.query('select cartocss_id from gis.cartocss where config is not null and style is not null and source_path is not null and geom is not null and enabled limit 1').then(r => r.rows?.[0]?.cartocss_id);
+    expect(cartocssId).toBeTypeOf('string');
+
+    test('WEBP from cartocss', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-rtile/${cartocssId}/10/523/391.webp`,
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toMatch(/image\/webp/);
+        expect(res.body.length).toBeGreaterThan(200);
+    });
+});
+
+describe('GET /gis-raster/:id', () => {
+    test('returns raster metadata', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-raster/${testId}`,
+        });
+        expect(res.statusCode).toBe(200);
+
+        const body = res.json();
+
+        expect(body).toHaveProperty('total_size');
+        expect(typeof body.total_size).toBe('string');
+
+        expect(body).toHaveProperty('extension');
+        expect(typeof body.extension).toBe('string');
+
+        expect(body).toHaveProperty('srid');
+        expect(typeof body.srid).toBe('string');
+
+        expect(body).toHaveProperty('proj4');
+        if (!body.srid) {
+            expect(typeof body.proj4).toBe('string');
+        }
+
+        expect(body).toHaveProperty('extent');
+        expect(Array.isArray(body.extent)).toBe(true);
+        body.extent.forEach(val => expect(typeof val).toBe('number'));
+
+        expect(body).toHaveProperty('files');
+        expect(Array.isArray(body.files)).toBe(true);
+        // Optional: check FileItem structure
+        if (body.files.length) {
+            const fileItem = body.files[0];
+            expect(fileItem).toHaveProperty('name');
+            expect(fileItem).toHaveProperty('size');
+        }
+
+        expect(body).toHaveProperty('width');
+        expect(typeof body.width).toBe('string');
+
+        expect(body).toHaveProperty('height');
+        expect(typeof body.height).toBe('string');
+
+        expect(body).toHaveProperty('bands_count');
+        expect(typeof body.bands_count).toBe('string');
+
+        expect(body).toHaveProperty('resolution');
+        expect(typeof body.resolution).toBe('string');
+
+        expect(body).toHaveProperty('bands');
+        expect(Array.isArray(body.bands)).toBe(true);
+        body.bands.forEach(b => expect(typeof b).toBe('string'));
+
+        expect(body).toHaveProperty('color_depth');
+        expect(typeof body.color_depth).toBe('string');
+
+        expect(body).toHaveProperty('compression');
+        expect(typeof body.compression).toBe('string');
+    });
+});
+
+describe('Create xml for all rasters without existing one', () => {
+    test('GET /gis-create-xml/:id? (restrict unauthorized)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-create-xml`,
+        });
+        expect(res.statusCode).toBe(403);
+    });
+    test('GET /gis-create-xml/:id?', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-create-xml`,
+            headers: { uid: user.uid, user_type: user.type },
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toBe('all finished');
+    });
+});
+
+describe('GIS File system API', () => {
+    test('lists directory (restrict unauthorized)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-files',
+        });
+        expect(res.statusCode).toBe(403);
+    });
+
+    test('lists directory (restrict non-admin)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-files',
+            headers: { uid: user.uid, user_type: 'regular' },
+        });
+        expect(res.statusCode).toBe(403);
+    });
+
+    test('lists directory', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-files',
+            headers: { uid: user.uid, user_type: user.type },
+        });
+        expect(res.statusCode).toBe(200);
+
+        const body = res.json();
+        expect(body).toHaveProperty('exists');
+        expect(body).toHaveProperty('count');
+        expect(body).toHaveProperty('data');
+        expect(Array.isArray(body.data)).toBe(true);
+        expect(body.data[0]).toHaveProperty('name');
+        expect(body.data[0]).toHaveProperty('type');
+        expect(body.data[0]).toHaveProperty('size');
+    });
+
+    test('search files by key (restrict unauthorized)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-search?key=tif',
+        });
+        expect(res.statusCode).toBe(403);
+    });
+
+    test('search files by key (restrict non-admin)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-search?key=tif',
+            headers: { uid: user.uid, user_type: 'regular' },
+        });
+        expect(res.statusCode).toBe(403);
+    });
+
+    test('search files by key', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-search?key=tif',
+            headers: { uid: user.uid, user_type: user.type },
+        });
+        expect(res.statusCode).toBe(200);
+
+        const body = res.json();
+
+        expect(Array.isArray(body.data)).toBe(true);
+    });
+
+    test('gets file info', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-search?key=tif',
+            headers: { uid: user.uid, user_type: user.type },
+        });
+        expect(res.statusCode).toBe(200);
+
+        const body1 = res.json();
+
+        const { dir, name: rasterName } = body1.data.find(el => el.name.endsWith('.tif'));
+        expect(rasterName).toBeTypeOf('string');
+        const rasterPath = [dir, rasterName].filter(Boolean).join('/');
+
+        // unauthorized
+        const res1 = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-info',
+            query: {
+                path: rasterPath
+            }
+        });
+        expect(res1.statusCode).toBe(403);
+
+        // non-admin
+        const res2 = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-info',
+            query: {
+                path: rasterPath
+            },
+            headers: { uid: user.uid, user_type: 'regular' },
+        });
+        expect(res2.statusCode).toBe(403);
+
+        const res3 = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-info',
+            query: {
+                path: rasterPath
+            },
+            headers: { uid: user.uid, user_type: user.type },
+        });
+        expect(res3.statusCode).toBe(200);
+
+        const body = res3.json().data;
+
+        expect(body).toHaveProperty('exists');
+        // expect(body.exists).toBeTruthy();
+        expect(body.exists).toBeOneOf([true, false]);
+        expect(body).toHaveProperty('size');
+        expect(body).toHaveProperty('mdate');
+        expect(body).toHaveProperty('adate');
+        expect(body).toHaveProperty('cdate');
+        expect(body).toHaveProperty('name');
+    });
+
+    test('search files by size', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-search?size=1024',
+            headers: { uid: user.uid, user_type: user.type },
+        });
+
+        expect(res.statusCode).toBe(200);
+    });
+
+    test('search files by period', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-file-search?period=1w',
+            headers: { uid: user.uid, user_type: user.type },
+        });
+
+        expect(res.statusCode).toBe(200);
+    });
+});
+
+test('GET /gis-pretile/:id', async () => {
+    // unaunthorized
+    const res1 = await injectWithHeaders({
+        method: 'GET',
+        url: `/api/gis-pretile/${testId}`,
+        query: { zoom: 13 }
+    });
+    expect(res1.statusCode).toBe(403);
+
+    const res = await injectWithHeaders({
+        method: 'GET',
+        url: `/api/gis-pretile/${testId}`,
+        query: { zoom: 13 },
+        headers: { uid: user.uid, user_type: user.type },
+    });
+    expect(res.statusCode).toBe(200);
+    expect(res.body).toBe('OK');
+});
+
+test('GET /gis-clear-rtile/:id', async () => {
+    // unaunthorized
+    const res1 = await injectWithHeaders({
+        method: 'GET',
+        url: `/api/gis-clear-rtile/${testId}`,
+    });
+    expect(res1.statusCode).toBe(403);
+
+    // non-admin
+    const res2 = await injectWithHeaders({
+        method: 'GET',
+        url: `/api/gis-clear-rtile/${testId}`,
+        headers: { uid: user.uid, user_type: 'regular' },
+    });
+    expect(res2.statusCode).toBe(403);
+
+    const res = await injectWithHeaders({
+        method: 'GET',
+        url: `/api/gis-clear-rtile/${testId}`,
+        headers: { uid: user.uid, user_type: user.type },
+    });
+    const body = res.json();
+
+    expect(['ok', 'skip', 'tiles directory not found']).toContain(body.message);
+
+});

package/server/routes/mapnik/mapnik.schema.mjs

@@ -0,0 +1,190 @@
+const dirpathSchema = { type: "string", pattern: "^[а-яА-Яa-zA-Z0-9_/\\- ]+$" };
+const filepathSchema = { type: "string", pattern: "^[а-яА-Яa-zA-Z0-9_\/\\-\. ]+$" };
+
+// values hardcoded into mapnik
+const periodSchema = {
+  type: 'string', enum: ['1w', '1d', '1h', '5m', '1m']
+};
+
+export const pretileSchema = {
+  params: {
+    type: "object",
+    properties: {
+      id: { type: "string", pattern: '^([\\d\\w]+)$', },
+    },
+    required: ["id"],
+  },
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      zoom: { type: "number", exclusiveMinimum: 0, maximum: 22 },
+      max: { type: "number", exclusiveMinimum: 0, maximum: 22 },
+    },
+    required: ["zoom"],
+  },
+};
+
+export const uploadRasterSchema = {
+  params: {
+    type: "object",
+    properties: {
+      id: { type: "string", pattern: '^([\\d\\w]+)$', },
+    },
+    required: ["id"],
+  },
+}
+
+export const gisXmlSchema = {
+  params: {
+    type: "object",
+    properties: {
+      id: { type: "string", pattern: '^([\\d\\w]+)$', },
+    },
+    required: ["id"],
+  },
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      sql: { type: "number", minimum: 1, maximum: 1 },
+      nocache: { type: "string", enum: ['true', '1'] },
+      vrt: { type: "string", enum: ['true', '1'] },
+      debug: { type: "number", minimum: 1, maximum: 10 },
+    },
+  },
+};
+
+export const gisRtileSchema = {
+  params: {
+    type: "object",
+    properties: {
+      id: { type: "string", pattern: '^([\\d\\w]+)$', },
+      z: {
+        type: 'number',
+      },
+      y: {
+        type: 'number',
+      },
+      x: {
+        type: 'string',
+        pattern: '^\\d+\\.(png|webp)$',
+      },
+    },
+    required: ["id", "z", "y", "x"],
+  },
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      nocache: {
+        type: 'string', enum: ['1']
+      },
+      nottl: {
+        type: 'string', enum: ['1']
+      },
+      debug: {
+        type: 'number', minimum: 1, maximum: 10
+      },
+      // random from frontend
+      ts: {
+        type: 'string'
+      },
+    },
+  },
+};
+
+export const gisRasterSchema = {
+  params: {
+    type: "object",
+    properties: {
+      id: { type: "string", pattern: '^([\\d\\w]+)$', },
+    },
+    required: ["id"],
+  },
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      debug: { type: "number", minimum: 1, maximum: 10 },
+    },
+  },
+};
+
+export const createXmlMultiSchema = {
+  params: {
+    type: "object",
+    properties: {
+      id: { type: "string", pattern: '^([\\d\\w]+)$', },
+    },
+  },
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      nocache: { type: "number", enum: [1] },
+    },
+  },
+};
+
+export const readDirSchema = {
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      dir: dirpathSchema,
+    },
+  },
+};
+
+export const fileStatSchema = {
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    required: ['path'],
+    properties: {
+      path: filepathSchema,
+    },
+  },
+};
+
+export const fileSearchSchema = {
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      dir: dirpathSchema,
+      key: {
+        type: 'string', // filename
+      },
+      period: periodSchema,
+      size: {
+        type: 'number', minimum: 1
+      },
+      page: {
+        type: 'number', minimum: 1
+      },
+      limit: {
+        type: 'number', minimum: 1, maximum: 100
+      }
+    },
+  },
+};
+
+export const clearTilesSchema = {
+  params: {
+    type: "object",
+    properties: {
+      id: { type: "string", pattern: '^([\\d\\w]+)$', },
+    },
+  },
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      debug: { type: "number", minimum: 1, maximum: 10 },
+    },
+  },
+};
+
+export default null;

package/server/routes/mapnik.prefixless/functions/mapnikLogger.js

@@ -0,0 +1,31 @@
+import { config } from '@opengis/fastify-table/utils.js';
+import { BadRequestError, NotImplementedError } from '@opengis/fastify-table/errors.js';
+
+import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+
+export default async function mapnikLogger({
+    path: paramsPath,
+}) {
+    if (!config.mapnik?.server) {
+        throw NotImplementedError('mapnik server address needed');
+    }
+
+    const { GetLogs } = mapnik();
+    const { data, links, err } = await GetLogs({ path: paramsPath });
+
+    if (err) {
+        throw BadRequestError(err);
+    }
+
+    if (links) {
+        return {
+            headers: {
+                "Content-Type": "text/html; charset=UTF-8",
+                "Content-Security-Policy": "default-src 'none'",
+                "X-Content-Type-Options": "nosniff",
+            }, data: links.replace(/\/api\/gis-logger/g, '/logger-gis')
+        };
+    }
+
+    return { headers: { "Content-type": "text/plain; charset=UTF-8" }, data };
+}

package/server/routes/{mapnik/controllers → mapnik.prefixless/functions}/mapnikStat.js

@@ -1,19 +1,21 @@
 import { config } from '@opengis/fastify-table/utils.js';
 
+import { NotImplementedError } from '@opengis/fastify-table/errors.js';
+
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
 
 const { GetStat } = mapnik();
 
 export default async function mapnikStat({
-    params,
-}, reply) {
+    period,
+}) {
     if (!config.mapnik?.server) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+        throw NotImplementedError('mapnik server address needed');
     }
 
     const stat = await GetStat({
-        period: params.period,
+        period,
     });
 
-    return reply.status(200).send(stat);
+    return stat;
 }

package/server/routes/mapnik.prefixless/mapnik.prefixless.route.js

@@ -0,0 +1,20 @@
+import mapnikLogger from './functions/mapnikLogger.js';
+import mapnikStat from './functions/mapnikStat.js';
+
+import {
+  mapnikLoggerSchema,
+  mapnikStatSchema,
+} from './mapnik.prefixless.schema.mjs';
+
+const adminParams = { config: { role: 'admin' }, package: 'gis' };
+
+export default function route(app) {
+  app.get('/logger-gis/stat', { ...adminParams, schema: mapnikStatSchema }, async ({ query }) => {
+    const result = await mapnikStat({ period: query.period });
+    return result;
+  });
+  app.get('/logger-gis/*', { ...adminParams, schema: mapnikLoggerSchema }, async ({ params }, reply) => {
+    const result = await mapnikLogger({ path: params['*'] });
+    return reply.headers(result.headers).send(result.data);
+  });
+}