@opengis/cms 0.0.59 → 0.0.61

package/server/routes/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

@@ -34,7 +34,7 @@ export default async function insertContent(req, reply) {
     const { type, id = body?.id } = params;
 
     if (!type) {
-        return reply.status(400).send('not enough params: type');
+        return reply.status(400).send({ error: 'not enough params: type', code: 400 });
     }
 
     const arr = config.pg ? await pg.query(`select array_agg(relname)::text[] from pg_class a 
@@ -52,7 +52,7 @@ export default async function insertContent(req, reply) {
     ).then(el => el.rows?.[0]?.content_type_id) : null;
 
     if (!arr.length && (ctypeId || type) !== 'pages') {
-        return reply.status(400).send('empty schema: data');
+        return reply.status(400).send({ error: 'empty schema: data', code: 400 });
     }
 
     const table = arr.find(el => el === params.type);
@@ -78,7 +78,7 @@ export default async function insertContent(req, reply) {
         const ctid1 = body.content_type_id || ctid || 'pages';
 
         if (!cid) {
-            return reply.status(404).send('contents not found');
+            return reply.status(404).send({ error: 'contents not found', code: 404 });
         }
 
         const columnList = columns?.map?.(el => el.name) || [];
@@ -106,19 +106,30 @@ export default async function insertContent(req, reply) {
                 );
         }
 
+        const id1 = id || await pg.query('select next_id()').then(el => el.rows[0].next_id);
+
         const client = await pg.connect();
 
         try {
             await client.query('begin');
+            await dataInsert({
+                pg: client,
+                table: 'site.content_types',
+                id: id1,
+                data: { ...body, type: 'single', name: body.slug },
+                uid: user?.uid,
+            });
             const res = await dataInsert({
                 pg: client,
                 table: 'site.contents',
-                id,
-                data: { ...body, content_type_id: ctid1 },
+                id: id1,
+                data: { ...body, content_type_id: id1 },
                 uid: user?.uid,
-            }).then(el => el.rows?.[0] || {});
+            });
 
-            if (!res?.content_id) throw new Error('insert contents error');
+            if (!res?.content_id) {
+                throw new Error('insert contents error');
+            }
 
             await Promise.all(keys.map(async key => dataInsert({
                 pg: client,
@@ -155,7 +166,7 @@ export default async function insertContent(req, reply) {
             };
         } catch (err) {
             await client.query('rollback');
-            return reply.status(500).send(err.toString());
+            return reply.status(500).send({ error: err.toString(), code: 500 });
         } finally {
             client.release();
         }
@@ -163,7 +174,7 @@ export default async function insertContent(req, reply) {
 
     // custom table
     if (!table && !dbtable) {
-        return reply.status(400).send('invalid params: type');
+        return reply.status(400).send({ error: 'invalid params: type', code: 400 });
     }
 
     const client = await pg.connect();
@@ -172,7 +183,7 @@ export default async function insertContent(req, reply) {
         await client.query('begin');
 
         // const types = columns?.reduce?.((acc, curr) => ({ ...acc, [curr.name]: inputTypes[curr.type] || 'text' }), {}) || {};
-        const { rows = [] } = await dataInsert({
+        const row = await dataInsert({
             pg: client,
             id,
             table: 'data.' + `"${(table || dbtable)}"`,
@@ -181,18 +192,16 @@ export default async function insertContent(req, reply) {
             uid: user?.uid,
         }).catch(err => {
             if (err.message?.includes?.('unique constraint')) {
-                throw new Error('Порушенні унікальності: ' + err.message?.match?.(/([^']+)/g)?.[1]);
+                throw new Error('Порушенні унікальності: ' + err.message?.match?.(/([^']+)/g)?.[1] || err.message.split('unique constraint')[1]);
             }
             throw err;
-        }) || {};
-
-        const idRes = rows?.[0]?.id;
+        });
 
-        if (!idRes) {
+        if (!row?.id) {
             throw new Error('content insert error');
         }
 
-        await updateLocalization(client, idRes, body, ctid, user?.uid);
+        await updateLocalization(client, row.id, body, ctid, user?.uid);
 
         if (body?.tag_list?.length) {
             await Promise.all(body.tag_list.map(async tag => dataInsert({
@@ -200,7 +209,7 @@ export default async function insertContent(req, reply) {
                 table: 'site.tag_data',
                 data: {
                     tag_id: tag,
-                    data_id: id || idRes,
+                    data_id: id || row.id,
                 },
                 uid: user?.uid,
             })));
@@ -208,10 +217,10 @@ export default async function insertContent(req, reply) {
 
         await client.query('commit');
 
-        return reply.status(200).send({ id: idRes, rows });
+        return reply.status(200).send({ id: row.id, rows: [row] });
     } catch (err) {
         await client.query('rollback');
-        return reply.status(500).send(err.toString());
+        return reply.status(500).send({ error: err.toString(), code: 500 });
     } finally {
         client.release();
     }

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

@@ -1,50 +1,50 @@
-import { logger, pgClients, dataInsert } from '@opengis/fastify-table/utils.js';
-
-export default async function setPermissions(req, reply) {
-    const { pg = pgClients.client, params = {}, user = {}, body = {} } = req;
-
-    if (!user?.uid) {
-        return reply.status(401).send('unauthorized');
-    }
-
-    if (!params.id) {
-        return reply.status(400).send('not enough params: id');
-    }
-
-    const client = await pg.connect()
-    const result = {};
-    try {
-        await client.query('BEGIN');
-
-        const { rowCount = 0 } = await client.query(
-            `delete from site.permissions where user_id=$1`,
-            [params.id].filter(Boolean),
-        );
-
-        Object.assign(result, { deleted: rowCount });
-
-        if (Array.isArray(body.permissions) && body.permissions?.length) {
-            body.permissions.forEach((el) => {
-                Object.assign(el, { user_id: el.user_id || params.id });
-            });
-
-            await Promise.all(body.permissions.map(async (el) => dataInsert({
-                pg: client,
-                table: 'site.permissions',
-                data: el,
-                uid: user.uid,
-            })));
-
-            Object.assign(result, { inserted: body.permissions.length });
-        }
-
-        await client.query('COMMIT');
-        return reply.status(200).send(result);
-    } catch (err) {
-        await client.query('ROLLBACK');
-        logger.file('cms/permissions', { error: err.toString(), stack: err.stack });
-        return reply.status(500).send('set permissions error');
-    } finally {
-        client.release();
-    }
+import { logger, pgClients, dataInsert } from '@opengis/fastify-table/utils.js';
+
+export default async function setPermissions(req, reply) {
+    const { pg = pgClients.client, params = {}, user = {}, body = {} } = req;
+
+    if (!user?.uid) {
+        return reply.status(401).send('unauthorized');
+    }
+
+    if (!params.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    const client = await pg.connect()
+    const result = {};
+    try {
+        await client.query('BEGIN');
+
+        const { rowCount = 0 } = await client.query(
+            `delete from site.permissions where user_id=$1`,
+            [params.id].filter(Boolean),
+        );
+
+        Object.assign(result, { deleted: rowCount });
+
+        if (Array.isArray(body.permissions) && body.permissions?.length) {
+            body.permissions.forEach((el) => {
+                Object.assign(el, { user_id: el.user_id || params.id });
+            });
+
+            await Promise.all(body.permissions.map(async (el) => dataInsert({
+                pg: client,
+                table: 'site.permissions',
+                data: el,
+                uid: user.uid,
+            })));
+
+            Object.assign(result, { inserted: body.permissions.length });
+        }
+
+        await client.query('COMMIT');
+        return reply.status(200).send(result);
+    } catch (err) {
+        await client.query('ROLLBACK');
+        logger.file('cms/permissions', { error: err.toString(), stack: err.stack });
+        return reply.status(500).send('set permissions error');
+    } finally {
+        client.release();
+    }
 }

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

@@ -34,26 +34,26 @@ export default async function updateContent(req, reply) {
     const { type, id } = params;
 
     if (!type) {
-        return reply.status(400).send('not enough params: type');
+        return reply.status(400).send({ error: 'not enough params: type', code: 400 });
     }
 
     if (!id) {
-        return reply.status(400).send('not enough params: id');
+        return reply.status(400).send({ error: 'not enough params: id', code: 400 });
     }
 
     if (!Object.keys(body || {}).length) {
-        return reply.status(400).send('empty body');
+        return reply.status(400).send({ error: 'empty body', code: 400 });
     }
 
     // order priority - custom columns -> default for pages
     const { ctid, ctname, dbtable, columns: contentColumns = [] } = await pg.query('select content_type_id as ctid, name as ctname, table_name as dbtable, columns from site.content_types where content_type_id in (select content_type_id from site.contents where content_id=$1) or content_type_id=$2 order by content_type_id = \'pages\'', [id, type]).then(el => el.rows?.[0] || {});
 
-    const arr = config.pg ? await pg.query(`select array_agg(relname)::text[] from pg_class a 
+    const arr = 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='data'`).then(el => el.rows?.[0]?.array_agg || []) : [];
 
     if (!arr.length && type !== 'pages') {
-        return reply.status(400).send('empty schema: data');
+        return reply.status(400).send({ error: 'empty schema: data', code: 400 });
     }
 
     const table = arr.find(el => el === params.type);
@@ -90,25 +90,16 @@ export default async function updateContent(req, reply) {
         const ctid1 = body.content_type_id || ctid;
 
         if (!cid) {
-            return reply.status(404).send('contents not found');
+            return reply.status(404).send({ error: 'contents not found', code: 404 });
         }
 
-        // ? deprecated, blocks if only default columns provided, therefore commented for now
-        // const contentId = cid === 'pages'
-        //     ? await pg.query('select content_id from site.content_data where object_id=$1', [id]).then(el => el.rows?.[0]?.content_id)
-        //     : cid;
-
-        // if (!contentId) {
-        //     return reply.status(404).send('contents not found: 2');
-        // }
-
         const columnList = columns?.map?.(el => el.name) || [];
         const types = columns?.reduce?.((acc, curr) => ({ ...acc, [curr.name]: curr.type || 'text' }), {}) || {};
         const keys = Object.keys(body || {}).filter(key => columnList.includes(key) && !defaultColumns.includes(key));
 
 
         if (!Object.keys(body || {}).length) {
-            return reply.status(400).send('invalid payload');
+            return reply.status(400).send({ error: 'invalid payload', code: 400 });
         }
 
         const blocks = await pg.query(`select json_object_agg(field_key,field_value) from site.content_data where content_id=$1 and field_type='reference'`, [id])
@@ -117,19 +108,9 @@ export default async function updateContent(req, reply) {
         const emptyBlock = Object.keys(body).find(key => blocks[key] && (!body[key] || typeof body[key] !== 'object' || Object.keys(body[key] || {}) === 0));
 
         if (emptyBlock) {
-            return reply.status(400).send('access restricted: empty/invalid block ' + emptyBlock);
+            return reply.status(400).send({ error: 'access restricted: empty/invalid block ' + emptyBlock, code: 400 });
         }
 
-        const single = await pg.query(
-            `select content_id, content_type_id, slug FROM site.contents
-           where content_id=$1`, [params.id]
-        ).then(el => el.rows?.[0]);
-
-        const customCtExists = await pg.query(
-            `select 1 FROM site.content_types
-           where content_type_id=$1`, [params.id]
-        ).then(el => el.rowCount || 0);
-
         const client = await pg.connect();
 
         try {
@@ -137,19 +118,6 @@ export default async function updateContent(req, reply) {
 
             const res = {};
 
-            if (single && !customCtExists && (single?.content_type_id === 'pages' || single?.content_type_id === params.id)) {
-                // const loadTable = await getTemplate('table', 'single.default.table');
-                // const { columns: defaultColumns } = loadTable || {};
-                const res1 = await dataInsert({
-                    pg: client,
-                    table: 'site.content_types',
-                    id: params.id,
-                    data: { ...body, type: 'single', name: body.name === 'pages' ? (single.slug || params.id) : (body.name || body.slug) /*, columns: defaultColumns*/ },
-                    uid: user?.uid,
-                });
-                Object.assign(res, res1);
-            }
-
             const res1 = await dataUpdate({
                 pg: client,
                 table: 'site.contents',
@@ -159,9 +127,6 @@ export default async function updateContent(req, reply) {
             });
             Object.assign(res, res1);
 
-            // if (contentId) {
-            //     await client.query(`delete from site.content_data where content_id=$1`, [contentId]);
-            // }
             const objectId = (ctname === 'pages' || ['single', 'pages'].includes(type)) && id ? id : cid;
             await client.query(`delete from site.content_data where object_id=$1`, [objectId]);
             await Promise.all(keys.map(async key => dataInsert({
@@ -204,14 +169,14 @@ export default async function updateContent(req, reply) {
             };
         } catch (err) {
             await client.query('rollback');
-            return reply.status(500).send(err.toString());
+            return reply.status(500).send({ error: err.toString(), code: 500 });
         } finally {
             client.release();
         }
     }
 
     if (!table && !dbtable) {
-        return reply.status(400).send('invalid params: type');
+        return reply.status(400).send({ error: 'invalid params: type', code: 400 });
     }
 
     const client = await pg.connect();
@@ -254,13 +219,13 @@ export default async function updateContent(req, reply) {
         await client.query('commit');
 
         if (!result?.id) {
-            return reply.status(404).send('content not found');
+            return reply.status(404).send({ error: 'content not found', code: 404 });
         }
 
         return reply.status(200).send(result);
     } catch (err) {
         await client.query('rollback');
-        return reply.status(500).send(err.toString());
+        return reply.status(500).send({ error: err.toString(), code: 500 });
     } finally {
         client.release();
     }

package/server/routes/cms/utils/getCollection.js

@@ -70,7 +70,7 @@ export default async function getCollection({
 
     const finalColumns = (defaultColumns || []).concat(columns1.filter(col => defaultColumns.findIndex(el => el.name === col.name) === -1));
 
-    finalColumns.filter(el => el.default).forEach(col => {
+    finalColumns.filter(el => el.defaultColumn).forEach(col => {
         const { name, localization } = columns1.find(item => item.name === col.name) || {};
         if (name) {
             Object.assign(col, { localization });

package/server/routes/cms/utils/getSingle.js

@@ -26,7 +26,7 @@ export default async function getSingle({
 
     const columns = defaultColumns.concat(customColumns.filter(col => defaultColumns.findIndex(el => el.name === col.name) === -1));
 
-    columns.filter(el => el.default).forEach(col => {
+    columns.filter(el => el.defaultColumn).forEach(col => {
         const { name, localization } = customColumns.find(item => item.name === col.name) || {};
         if (name) {
             Object.assign(col, { localization });

package/server/routes/cms/utils/insertContentLocalization.js

@@ -41,7 +41,7 @@ export default async function insertContentLocalization({ send = () => { }, tabl
     const obj = { ...row, ...localization };
 
     const entries = Object.entries(obj).filter(([key, value]) => value && schemaKeys.includes(key) && (typeof value === 'string' || (Array.isArray(value) && value?.[0] && typeof value?.[0] === 'object' && Object.keys(value).length)));
-    // do not old localization overwrite by default
+    // do not overwrite old localization by default
     const filteredEntries = skip && targetLocalization ? entries.filter(([key]) => !Object.keys(targetLocalization).includes(key)) : entries;
 
     if (skip && targetLocalization && !filteredEntries.length) {

package/server/routes/cms/utils/requestTranslation.js

@@ -5,17 +5,26 @@ const { host = 'https://translate.softpro.ua', key = '' } = config.integrations?
 const divider = ' <divider> ';
 
 // Wrap dot notation keys in quotes
-export const arrayToPhrases = (arr, prefix = 'item') => {
+export const arrayToPhrases = (arr, prefix = 'item', mainIdx = null) => {
     if (!arr || !arr.length) return [];
-    return arr.flatMap((obj, idx) =>
-        Object.entries(obj).map(([key, value]) => ({
-            prefix,
-            value,
-            // phrase: `"${prefix}"."${key}".${idx}: ${value}`,
-            key,
-            idx
-        }))
-    );
+
+    return arr.flatMap((obj, idx) => {
+        const currentMainIdx = mainIdx ?? idx;
+
+        return Object.entries(obj).flatMap(([key, value]) => {
+            if (Array.isArray(value)) {
+                return arrayToPhrases(value, `${prefix}.${key}`, currentMainIdx);
+            }
+
+            return [{
+                prefix,
+                value,
+                key,
+                mainIdx: currentMainIdx,
+                idx,
+            }];
+        });
+    });
 };
 
 export default async function requestTranslation(entries, from = 'uk', to) {
@@ -26,17 +35,29 @@ export default async function requestTranslation(entries, from = 'uk', to) {
 
     // Translate each phrase independently
     const translatedPhrases = await Promise.all(
-        phrasesWithMeta.map(async ({ key, idx, prefix, value }) => {
+        phrasesWithMeta.map(async ({ key, idx, prefix, value, mainIdx }) => {
             if (!value || typeof value === 'number' || value?.startsWith?.('/files/')) {
-                return { key, idx, prefix, value, skip: true }; // fallback to original
+                return { key, idx, mainIdx, prefix, value, skip: true }; // fallback to original
             }
 
             try {
-                const parts = value.startsWith('<') && value.endsWith('>')
-                    ? [...value.matchAll(/(<[^>]+>)([^<]*)(<\/[^>]+>)/g)].map(([, openTag, str, closeTag]) => ({ openTag, str, closeTag }))
-                    : [{ str: value }];
+                const parts =
+                    typeof value === 'string' && value.startsWith('<') && value.endsWith('>')
+                        ? [...value.matchAll(/(<[^>]+>)|([^<]+)/gs)].map(([, tag, str]) =>
+                            tag
+                                ? { tag }
+                                : { str, tIndex: null, skip: !str.trim() || /^[—–\-.: ]+$/.test(str.trim()) ? true : false, preSpace: str.startsWith(' ') ? ' ' : '', postSpace: str.endsWith(' ') ? ' ' : '' }
+                        )
+                        : [{ str: value, tIndex: 0, skip: false }];
 
-                const q = parts.map(({ str }) => str).join(divider);
+                // assign translation index only to fragments that should be translated
+                const q = [];
+                parts.forEach((p) => {
+                    if (!p.tag && !p.skip) {
+                        p.tIndex = q.length;
+                        q.push(p.str);
+                    }
+                });
 
                 const resp = await fetch(`${host}/translate`, {
                     method: "POST",
@@ -57,20 +78,49 @@ export default async function requestTranslation(entries, from = 'uk', to) {
                 }
 
                 const body = await resp.json();
-                const resultValue = body.translatedText ? parts.map(({ openTag, str, closeTag }, i) => `${openTag || ''}${body.translatedText.split(divider)[i] || str || ''}${closeTag || ''}`).join(' ') : null;
-                return { key, idx, prefix, value: resultValue || value };
+                const translated = body.translatedText || [];
+
+                const resultValue = parts
+                    .map((p) => {
+                        if (p.tag) return p.tag;
+                        if (p.skip) return p.str; // keep original punctuation/whitespace
+                        const txt = translated[p.tIndex] ?? p.str ?? '';
+                        return `${p.preSpace || ''}${txt}${p.postSpace || ''}`; // restore spaces
+                    })
+                    .join('');
+
+                return { key, idx, mainIdx, prefix, value: resultValue || value };
             } catch (err) {
                 console.warn('translation request failed', err.toString());
-                return { key, idx, prefix, value, error: err.toString() }; // fallback
+                return { key, idx, mainIdx, prefix, value, error: err.toString() }; // fallback
             }
         })
     );
 
-    const result = translatedPhrases.reduce((acc, { key, idx, prefix, value }) => {
-        if (!acc[`${prefix}:${to}`]) acc[`${prefix}:${to}`] = Array.isArray(entries.find(e => e[0] === prefix)[1]) ? [] : null;
+    const result = translatedPhrases.reduce((acc, curr) => {
+        const { key, idx, prefix: prefix1, value, mainIdx } = curr;
+        const [prefix, subkey] = prefix1.split('.');
+
+        if (!acc[`${prefix}:${to}`]) {
+            acc[`${prefix}:${to}`] = Array.isArray(entries.find(e => e[0] === prefix)[1]) ? [] : null;
+        }
 
-        if (Array.isArray(entries.find(e => e[0] === prefix)[1])) {
-            if (!acc[`${prefix}:${to}`][idx]) acc[`${prefix}:${to}`][idx] = {};
+        if (subkey && Array.isArray(entries.find(e => e[0] === prefix)[1])) {
+            if (!acc[`${prefix}:${to}`][mainIdx]) {
+                acc[`${prefix}:${to}`][mainIdx] = {};
+            }
+            if (!acc[`${prefix}:${to}`][mainIdx][subkey]) {
+                acc[`${prefix}:${to}`][mainIdx][subkey] = [];
+            }
+            if (!acc[`${prefix}:${to}`][mainIdx][subkey]?.[idx]) {
+                acc[`${prefix}:${to}`][mainIdx][subkey][idx] = {};
+            }
+            acc[`${prefix}:${to}`][mainIdx][subkey][idx][key] = value;
+            // console.log(prefix, to, idx, subkey, mainIdx, key);
+        } else if (Array.isArray(entries.find(e => e[0] === prefix)[1])) {
+            if (!acc[`${prefix}:${to}`][idx]) {
+                acc[`${prefix}:${to}`][idx] = {};
+            }
             acc[`${prefix}:${to}`][idx][key] = value;
         } else {
             acc[`${prefix}:${to}`] = value;

package/server/routes/cms/utils/updateLocalization.js

@@ -14,16 +14,11 @@ export default async function updateLocalization(pg, id, body, contentTypeId, ui
 
     const columns = (loadTable?.columns || []).concat((contentColumns || []).filter(col => loadTable?.columns.findIndex(el => el.name === col.name) === -1));
 
-    const locales = await pg.query('select locales from site.spaces where space_id = $1 limit 1', ['default']).then(el => el.rows?.[0]?.locales || []);
-
     await pg.query('delete from site.localization where object_id=$1', [id]);
 
-    // localization disable for current space
-    if (!locales?.length) { return null; }
-
     const schemaKeys = columns.filter(el => el?.name && el.localization).map(el => el.name);
 
-    const bodyKeys = Object.keys(body || {}).filter(key => body[key] && key.includes(':') && key.split(':').pop() && locales.includes(key.split(':').pop()) && schemaKeys.includes(key.split(':').shift()));
+    const bodyKeys = Object.keys(body || {}).filter(key => body[key] && key.includes(':') && key.split(':').pop() && schemaKeys.includes(key.split(':').shift()));
     const obj = bodyKeys.reduce((acc, curr) => ({ ...acc, [curr]: body[curr] }), {});
 
     if (bodyKeys.length === 0) { return null; }

package/server/routes/cmsSpace/controllers/deleteSpace.js

@@ -1,6 +1,7 @@
 import { dataDelete, pgClients } from '@opengis/fastify-table/utils.js';
 
 export default async function deleteSpace({ pg = pgClients.client, user, params, headers = {} }, reply) {
+    return null;
     if (!params?.id) { return reply.status(400).send('not enough params: id'); }
     if (!pg?.pk) { return reply.status(400).send('empty pg'); }
     if (!pg?.pk?.['site.spaces']) { return reply.status(400).send('table not found: site.spaces'); }

package/server/routes/cmsSpace/controllers/getSpaces.js

@@ -4,6 +4,7 @@ const maxLimit = 100;
 const defaultLimit = 20;
 
 export default async function getSpaces({ pg = pgClients.client, user, params = {}, query = {} }, reply) {
+    return null;
     if (!pg?.pk) { return reply.status(400).send('empty pg'); }
     if (!pg?.pk?.['site.spaces']) { return reply.status(400).send('table not found: site.spaces'); }
 

package/server/routes/cmsSpace/controllers/insertSpace.js

@@ -1,6 +1,7 @@
 import { dataInsert, pgClients } from '@opengis/fastify-table/utils.js';
 
 export default async function insertSpace({ pg = pgClients.client, user, params, headers = {}, body = {} }, reply) {
+    return null;
     if (!pg?.pk) { return reply.status(400).send('empty pg'); }
     if (!pg?.pk?.['site.spaces']) { return reply.status(400).send('table not found: site.spaces'); }
 

package/server/routes/cmsSpace/controllers/updateSpace.js

@@ -1,6 +1,7 @@
 import { dataUpdate, pgClients } from '@opengis/fastify-table/utils.js';
 
 export default async function updateSpace({ pg = pgClients.client, user, params, headers = {}, body = {} }, reply) {
+    return null;
     // if (!params?.id) { return reply.status(400).send('not enough params: id'); }
     if (!pg?.pk) { return reply.status(400).send('empty pg'); }
     if (!pg?.pk?.['site.spaces']) { return reply.status(400).send('table not found: site.spaces'); }