@opengis/cms 0.0.13 → 0.0.15

package/server/plugins/hook.js

@@ -1,91 +1,67 @@
 import fp from 'fastify-plugin';
-import fs from 'fs';
-import config from '../config.js';
 
-// the use of fastify-plugin is required to be able
-// to export the decorators to the outer scope
+import { config, pgClients } from '@opengis/fastify-table/utils.js';
 
-async function plugin(fastify) {
-  fastify.decorate('config', config);
+import builderCache from '../routes/contentType/utils/builderCache.js';
 
-  // pre Request
-  fastify.addHook('onRequest', async (req) => {
-    req.funcs = fastify;
-    const { user } = req.session?.passport || {};
-    req.user = user;
-  });
+const matches = {
+    date: 'timestamp without time zone',
+};
 
-  // preSerialization
-  fastify.addHook('preSerialization', async (req, reply, payload) => {
-    if (req.url.includes('/suggest/') && !req.query.json) {
-      return payload?.data;
-    }
-    /* if (payload.redirect) {
-       return reply.redirect(payload.redirect);
-     }*/
-    if (reply.sent) {
-      return null;
-    }
-    if (!payload) {
-      return payload;
+const defaultColumns = [
+    {
+        name: 'created_at',
+        type: 'date',
+        default: 'now()',
+        label: 'Created at',
+        required: true,
+    },
+    {
+        name: 'created_by',
+        type: 'text',
+        label: 'Created by'
+    },
+    {
+        name: 'updated_at',
+        type: 'date',
+        default: 'now()',
+        label: 'Updated at',
+        required: true,
+    },
+    {
+        name: 'updated_by',
+        type: 'text',
+        label: 'Updated by'
     }
+];
 
-    if (['200', '400', '500', '403', '404'].includes(payload.status)) {
-      reply.status(payload.status);
-    }
-    /* if (payload.headers) {
-      reply.headers(payload.headers);
-    } */
-    if (payload.buffer) {
-      return payload.buffer;
-    }
-    if (payload.file) {
-      // const buffer = await readFile(payload.file);
-      // return reply.send(buffer);
-      const stream = fs.createReadStream(payload.file);
-      return stream;
-      // return reply.send(stream);
-    }
+function createTableSQL(name, slug = 'slug', columns = {}) {
+    const columnList = (Array.isArray(columns)
+        ? columns.filter(el => el.name)
+        : Object.entries(columns).map(el => ({ name: el[0], ...el[1] })));
 
-    if (payload.message) {
-      return payload.message;
-    }
-    return payload;
-  });
+    defaultColumns.forEach(el => columnList.push(el));
 
-  //  preValidation
-  fastify.addHook('preValidation', async (req) => {
-    const parseRawBody = ['POST', 'PUT'].includes(req.method) && req.body && typeof req.body === 'string'
-      && req.body.trim(/\r\n/g).startsWith('{')
-      && req.body.trim(/\r\n/g).endsWith('}');
-    if (parseRawBody) {
-      try {
-        req.body = JSON.parse(req.body || '{}');
-      }
-      catch (err) {
-        // throw new Error('invalid body');
-        // return { error: 'invalid body', status: 400 };
-      }
-    }
-  });
-
-  // allow upload file
-  const kIsMultipart = Symbol.for('[FastifyMultipart.isMultipart]');
-  fastify.addContentTypeParser('multipart', (request, _, done) => {
-    request[kIsMultipart] = true;
-    done(null);
-  });
-
-  // parse Body
-  function contentParser(req, body, done) {
-    const parseBody = decodeURIComponent(body.toString()).split('&').reduce((acc, el) => {
-      const [key, val] = el.split('=');
-      return { ...acc, [key]: val };
-    }, {});
-    done(null, parseBody);
-  }
+    return `CREATE TABLE IF NOT EXISTS site.${name} ();
+    ALTER TABLE site.${name} ADD COLUMN IF NOT EXISTS ${name}_id text not null default next_id() PRIMARY KEY;
+    ALTER TABLE site.${name} ADD COLUMN IF NOT EXISTS ${slug} text;
+    ${columnList.map(el => `ALTER TABLE site.${name} ADD COLUMN IF NOT EXISTS ${el.name} ${matches[el.type] || 'text'};`).join('\n')}
+    ${columnList.filter(el => el.default).map(el => `ALTER TABLE site.${name} ALTER COLUMN ${el.name} SET DEFAULT ${el.default};`).join('\n')}
+    ${columnList.filter(el => Object.hasOwn(el, 'required')).map(el => `ALTER TABLE site.${name} ALTER COLUMN ${el.name} ${el.required ? 'SET' : 'DROP'} NOT NULL;`).join('\n')}
+    ${columnList.filter(el => el.label).map(el => `COMMENT ON COLUMN site.${name}.${el.name} IS '${el.label}';`).join('\n')}`;
+}
 
-  fastify.addContentTypeParser('application/x-www-form-urlencoded', { parseAs: 'buffer' }, contentParser);
+async function plugin(app) {
+    if (config.pg && builderCache()?.length) {
+        app.addHook('onListen', async () => {
+            const files = builderCache().filter(el => el.type === 'collection' && el.provider === 'pg' && el.name);
+            const q = files.map(el => createTableSQL(el.name, el.slug, el.columns)).filter(el => el).join(';\n');
+            await pgClients.client.query(`create schema if not exists site;${q}`).catch(err => {
+                console.error('Builder deploy error:', err);
+            });
+            console.log('Builder deploy complete', files?.length);
+        });
+    }
 }
 
 export default fp(plugin);

package/server/plugins/vite.js

@@ -1,11 +1,11 @@
-import fs from 'fs';
-import path, { dirname } from 'path';
+import fs from 'node:fs';
+import path, { dirname } from 'node:path';
 import { fileURLToPath } from 'url';
 
+import { config } from '@opengis/fastify-table/utils.js';
+
 const dir = dirname(fileURLToPath(import.meta.url));
 const root = `${dir}/../..`;
-import config from '../config.js';
-
 const isProduction = process.env.NODE_ENV === 'production' || config.production;
 
 async function plugin(fastify) {
@@ -33,8 +33,7 @@ async function plugin(fastify) {
     // this is middleware for vite's dev servert
     fastify.addHook('onRequest', async (req, reply) => {
       const { user } = req.session?.passport || {};
-      const { disableAuth } = req.funcs?.config || {};
-      if (!user && !disableAuth) {
+      if (!user && config.pg && !config.auth?.disable) {
         return reply.redirect('/login');
       }
 
@@ -50,9 +49,14 @@ async function plugin(fastify) {
   // From Build
   fastify.get('*', async (req, reply) => {
     const { user } = req.session?.passport || {};
-    const assetsDir = '/dist';
-    if (!user) return reply.redirect('/login');
-    const stream = fs.createReadStream(`${assetsDir}/index.html`);
+    const indexPath = path.join(root, 'dist', 'index.html');
+    // if (!user && config.pg && !config.auth?.disable) {
+    //   return reply.redirect('/login');
+    // }
+    if (!fs.existsSync(indexPath)) {
+      return reply.status(404).send('index.html not found');
+    }
+    const stream = fs.createReadStream(indexPath);
     return reply.type('text/html').send(stream);
   });
 

package/server/routes/cms/controllers/deleteContent.js

@@ -0,0 +1,60 @@
+import { config, pgClients, dataDelete } from '@opengis/fastify-table/utils.js';
+
+import builderCache from '../../contentType/utils/builderCache.js';
+
+export default async function deleteContent(req, reply) {
+    const {
+        pg = pgClients.client,
+        params = {},
+        user = {},
+        headers = {},
+    } = req;
+
+    const { type, id } = params;
+
+    if (!type) {
+        return reply.status(400).send('not enough params: type');
+    }
+
+    if (!id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (builderCache[type]?.table && builderCache[type]?.provider === 'pg' && config.pg) {
+        const result = await dataDelete({
+            pg,
+            id,
+            table: 'site.' + builderCache[type]?.table,
+            referer: headers?.referer,
+            uid: user?.uid || 0,
+        });
+
+        const pk = pg.pk?.['site.' + builderCache[type]?.table];
+        return reply.status(200).send({ id: result?.[pk], ...result || {} });
+    }
+
+    const arr = config.pg ? await pg.query(`select array_agg(relname)::text[] from pg_class a 
+    left join pg_namespace b on a.relnamespace=b.oid 
+    where a.relam=2 and b.nspname='site'`).then(el => el.rows?.[0]?.array_agg || []) : [];
+
+    if (!arr.length) {
+        return reply.status(400).send('empty schema: site');
+    }
+
+    const table = arr.find(el => el === params.type);
+
+    if (!table) {
+        return reply.status(400).send('invalid params: type');
+    }
+
+    const result = await dataDelete({
+        pg,
+        id,
+        table: 'site.' + table,
+        referer: headers?.referer,
+        uid: user?.uid || 0,
+    });
+
+    const pk = pg.pk?.['site.' + table];
+    return reply.status(200).send({ id: result?.[pk], ...result || {} });
+}

package/server/routes/{site → cms}/controllers/deleteMedia.js

@@ -1,47 +1,47 @@
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { rm } from 'node:fs/promises';
-
-import { config, dataDelete, getFolder, pgClients } from "@opengis/fastify-table/utils.js";
-
-const rootDir = getFolder(config, 'local');
-
-export default async function deleteMedia({
-    pg = pgClients.client, params = {}, user = {}, method = 'DELETE',
-}, reply) {
-    if (!config.debug && method !== 'DELETE') {
-        return reply.status(403).send('access restricted');
-    }
-
-    if (!params?.id) {
-        return reply.status(400).send('not enough params: id');
-    }
-
-    if (!pg.pk?.['site.media']) {
-        return reply.status(404).send('table not found');
-    }
-
-    const { url: relpath, id } = await pg.query(
-        'select media_id as id, url from site.media where media_id = $1 and url is not null',
-        [params.id],
-    ).then(el => el.rows?.[0] || {});
-
-    if (!id) {
-        return reply.status(404).send('media not found: ' + params.id);
-    }
-
-    const res = await dataDelete({
-        pg,
-        id,
-        table: 'site.media',
-        uid: user?.uid || 0,
-    });
-
-    const filepath = path.join(rootDir, relpath);
-
-    if (existsSync(filepath)) {
-        await rm(filepath, { recursive: true });
-    }
-
-    return { id, ...res || {} };
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+
+import { config, dataDelete, getFolder, pgClients } from "@opengis/fastify-table/utils.js";
+
+const rootDir = getFolder(config, 'local');
+
+export default async function deleteMedia({
+    pg = pgClients.client, params = {}, user = {}, method = 'DELETE',
+}, reply) {
+    if (!config.debug && method !== 'DELETE') {
+        return reply.status(403).send('access restricted');
+    }
+
+    if (!params?.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (!pg.pk?.['site.media']) {
+        return reply.status(404).send('table not found');
+    }
+
+    const { url: relpath, id } = await pg.query(
+        'select media_id as id, url from site.media where media_id = $1 and url is not null',
+        [params.id],
+    ).then(el => el.rows?.[0] || {});
+
+    if (!id) {
+        return reply.status(404).send('media not found: ' + params.id);
+    }
+
+    const res = await dataDelete({
+        pg,
+        id,
+        table: 'site.media',
+        uid: user?.uid || 0,
+    });
+
+    const filepath = path.join(rootDir, relpath);
+
+    if (existsSync(filepath)) {
+        await rm(filepath, { recursive: true });
+    }
+
+    return { id, ...res || {} };
 }

package/server/routes/{site → cms}/controllers/downloadMedia.js

@@ -1,48 +1,48 @@
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-
-import { config, getFolder, pgClients } from "@opengis/fastify-table/utils.js";
-
-const rootDir = getFolder(config, 'local');
-
-export default async function downloadMedia({
-    pg = pgClients.client, params = {}, query = {},
-}, reply) {
-    if (!params?.id) {
-        return reply.status(400).send('not enough params: id');
-    }
-
-    if (!pg.pk?.['site.media']) {
-        return reply.status(404).send('table not found');
-    }
-
-    const { filename, mime, id, url: relpath } = await pg.query(
-        'select media_id as id, filename, mime, url from site.media where media_id = $1 and url is not null',
-        [params.id],
-    ).then(el => el.rows?.[0] || {});
-
-    if (!id) {
-        return reply.status(404).send('media not found: ' + params.id);
-    }
-
-    const filepath = path.join(rootDir, relpath);
-
-    if (!existsSync(filepath)) {
-        return reply.status(404).send('file not found');
-    }
-
-    const buffer = await readFile(filepath, { buffer: true });
-
-    // skip xml load for preview
-    if (query.preview && path.extname(filename) !== '.xml') {
-        return reply.headers({ 'Content-Type': mime }).send(buffer);
-    }
-
-    return reply
-        .headers({
-            'Content-Type': mime,
-            'Content-Disposition': `attachment; filename=${filename || path.basename(filepath)}`,
-        })
-        .send(buffer);
-}
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+
+import { config, getFolder, pgClients } from "@opengis/fastify-table/utils.js";
+
+const rootDir = getFolder(config, 'local');
+
+export default async function downloadMedia({
+    pg = pgClients.client, params = {}, query = {},
+}, reply) {
+    if (!params?.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (!pg.pk?.['site.media']) {
+        return reply.status(404).send('table not found');
+    }
+
+    const { filename, mime, id, url: relpath } = await pg.query(
+        'select media_id as id, filename, mime, url from site.media where media_id = $1 and url is not null',
+        [params.id],
+    ).then(el => el.rows?.[0] || {});
+
+    if (!id) {
+        return reply.status(404).send('media not found: ' + params.id);
+    }
+
+    const filepath = path.join(rootDir, relpath);
+
+    if (!existsSync(filepath)) {
+        return reply.status(404).send('file not found');
+    }
+
+    const buffer = await readFile(filepath, { buffer: true });
+
+    // skip xml load for preview
+    if (query.preview && path.extname(filename) !== '.xml') {
+        return reply.headers({ 'Content-Type': mime }).send(buffer);
+    }
+
+    return reply
+        .headers({
+            'Content-Type': mime,
+            'Content-Disposition': `attachment; filename=${filename || path.basename(filepath)}`,
+        })
+        .send(buffer);
+}

package/server/routes/cms/controllers/getContent.js

@@ -0,0 +1,96 @@
+import { config, pgClients, getData, getMeta } from '@opengis/fastify-table/utils.js';
+
+import builderCache from '../../contentType/utils/builderCache.js';
+
+const maxLimit = 100;
+
+const matches = {
+    16: 'yes_no', // boolean
+    701: 'number', // double precision
+    1082: 'date', // date
+    1184: 'date', // timestamp w/ time zone
+    1114: 'date', // timestamp w/o time zone
+    1700: 'number', // numeric
+};
+
+export default async function getContent(req, reply) {
+    const { pg = pgClients.client, params = {}, query = {}, user = {} } = req;
+    const { type, id } = params;
+    const { filter, state, limit = 16, page, search, order, sql } = query;
+
+    if (!type) {
+        return reply.status(400).send('not enough params: type');
+    }
+
+    if (type === 'single' && id) {
+        const cache = builderCache(id) || {};
+        const row = await pg.query('select json_object_agg(key, value) from site.single_type_values where type_name=$1', [id])
+            .then(el => el.rows?.[0]?.json_object_agg);
+        if (row) Object.assign(row, { id });
+        return {
+            pk: 'id',
+            title: cache?.title || id,
+            id,
+            columns: Object.entries(cache?.columns || {}).map(el => ({ name: el[0], ...el[1] })) || [],
+            rows: [row].filter(Boolean),
+        };
+    }
+
+    const builderData = builderCache(type);
+
+    if (builderData?.table && builderData?.provider === 'pg' && config.pg) {
+        const { columns = [] } = await getMeta({ pg, table: 'site.' + builderData.table });
+        const res = await getData({
+            pg,
+            id,
+            table: 'site.' + builderData.table,
+            filter,
+            state,
+            limit: Math.min(limit, maxLimit),
+            page,
+            search,
+            order,
+            sql,
+            user,
+        }, reply, 1);
+
+        if (columns?.length) {
+            columns.forEach(el => {
+                el.type = matches[el.dataTypeID] || 'text';
+                el.hidden = !Object.keys((builderCache(type))?.columns || {}).includes(el.name);
+            });
+        }
+
+        return { ...res || {}, columns: columns.filter(el => !el.hidden).map(({ name, title, type }) => ({ name, title, type })) };
+    }
+
+    const arr = config.pg ? await pg.query(`select array_agg(relname)::text[] from pg_class a 
+    left join pg_namespace b on a.relnamespace=b.oid 
+    where a.relam=2 and b.nspname='site'`).then(el => el.rows?.[0]?.array_agg || []) : [];
+
+    if (!arr.length) {
+        return reply.status(400).send('empty schema: site');
+    }
+
+    const table = arr.find(el => el === params.type);
+
+    if (!table) {
+        return reply.status(400).send('invalid params: type');
+    }
+
+    const res = await getData({
+        pg,
+        id,
+        table: 'site.' + table,
+        filter,
+        state,
+        limit: Math.min(limit, maxLimit),
+        page,
+        search,
+        order,
+        sql,
+        user,
+    }, reply, 1);
+
+    return res;
+}

package/server/routes/{site → cms}/controllers/getPermissions.js

@@ -1,16 +1,16 @@
-import { pgClients } from '@opengis/fastify-table/utils.js';
-
-export default async function getPermissions(req, reply) {
-    const { pg = pgClients.client, params = {}, user = {} } = req;
-
-    if (!user?.uid) {
-        return reply.status(401).send('unauthorized');
-    }
-
-    const { rows = [] } = await pg.query(
-        `select * from site.permissions where ${params.id ? 'user_id=$1' : 'true'}`,
-        [params.id].filter(Boolean),
-    );
-
-    return { permissions: rows };
+import { pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function getPermissions(req, reply) {
+    const { pg = pgClients.client, params = {}, user = {} } = req;
+
+    if (!user?.uid) {
+        return reply.status(401).send('unauthorized');
+    }
+
+    const { rows = [] } = await pg.query(
+        `select * from site.permissions where ${params.id ? 'user_id=$1' : 'true'}`,
+        [params.id].filter(Boolean),
+    );
+
+    return { permissions: rows };
 }

package/server/routes/cms/controllers/insertContent.js

@@ -0,0 +1,69 @@
+import { config, pgClients, dataInsert } from '@opengis/fastify-table/utils.js';
+
+import builderCache from '../../contentType/utils/builderCache.js';
+
+export default async function insertContent(req, reply) {
+    const {
+        pg = pgClients.client,
+        params = {},
+        user = {},
+        body = {},
+        headers = {},
+    } = req;
+
+    const { type, id = body?.id } = params;
+
+    if (!type) {
+        return reply.status(400).send('not enough params: type');
+    }
+
+    if (builderCache[type]?.table && builderCache[type]?.provider === 'pg' && config.pg) {
+        const { rows = [] } = await dataInsert({
+            pg,
+            id,
+            table: 'site.' + builderCache[type]?.table,
+            data: body,
+            referer: headers?.referer,
+            uid: user?.uid || 0,
+        }).catch(err => {
+            if (err.message?.includes?.('unique constraint')) {
+                return reply.status(400).send('Порушенні унікальності: ' + err.message?.match?.(/([^"]+)/g)?.[1]);
+            }
+            return reply.status(500).send(err.toString());
+        });
+
+        const pk = pg.pk?.['site.' + builderCache[type]?.table];
+        return reply.status(200).send({ id: rows[0]?.[pk], rows });
+    }
+
+    const arr = config.pg ? await pg.query(`select array_agg(relname)::text[] from pg_class a 
+    left join pg_namespace b on a.relnamespace=b.oid 
+    where a.relam=2 and b.nspname='site'`).then(el => el.rows?.[0]?.array_agg || []) : [];
+
+    if (!arr.length) {
+        return reply.status(400).send('empty schema: site');
+    }
+
+    const table = arr.find(el => el === params.type);
+
+    if (!table) {
+        return reply.status(400).send('invalid params: type');
+    }
+
+    const { rows = [] } = await dataInsert({
+        pg,
+        id,
+        table: 'site.' + table,
+        data: body,
+        referer: headers?.referer,
+        uid: user?.uid || 0,
+    }).catch(err => {
+        if (err.message?.includes?.('unique constraint')) {
+            return reply.status(400).send('Порушенні унікальності: ' + err.message?.match?.(/([^"]+)/g)?.[1]);
+        }
+        return reply.status(500).send(err.toString());
+    });
+
+    const pk = pg.pk?.['site.' + table];
+    return reply.status(200).send({ id: rows[0]?.[pk], rows });
+}