@opengis/cms 0.0.16 → 0.0.18

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

@@ -0,0 +1,82 @@
+import { pgClients, getData, getMeta } from "@opengis/fastify-table/utils.js";
+
+import additionalData from "./additionalData.js";
+
+export default async function getCollection({
+    table, id, limit, maxLimit, order, search, tags, filter, state, page, desc, sql, locale, contextQuery, statusQuery, columns, preview, user, defaultColumns, fields, defaultFields = [], defaultFilters = []
+}, reply, pg = pgClients.client) {
+    if (!table || !pg.pk?.['data.' + table]) {
+        return { message: 'content table not found', status: 404 };
+    }
+
+    const isPinExists = await pg.query(`
+        SELECT 1
+        FROM pg_catalog.pg_attribute a
+        JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+        JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+        WHERE n.nspname = 'data'
+        AND c.relname = $1
+        AND a.attname = 'is_pin'
+        AND a.attnum > 0
+        AND NOT a.attisdropped;
+    `, [table]).then(el => el.rowCount);
+
+    const defaultOrder = `case when status='archived' then true else false end ${isPinExists ? ', is_pin desc' : ''}, published_at desc nulls last`;
+
+    const localeQuery = locale && locale !== 'uk' ? `id in ( select object_id from site.localization where REVERSE(split_part(REVERSE(field_key), ':', 1)) = '${locale.replace(/'/g, "''")}' )` : undefined;
+    const tagQuery = tags ? `id in (SELECT data_id FROM site.tag_data td left join site.tags ts on td.tag_id=ts.tag_id WHERE ts.slug = any('{ ${tags.replace(/'/g, "''")} }'::text[]) or ts.tag_id = any('{ ${tags.replace(/'/g, "''")} }'::text[]))` : null;
+    const cQuery = [id ? `'${id}' in (id,slug)` : contextQuery, localeQuery, ((columns || []).concat(defaultColumns || [])).find(col => col.name === 'status') ? statusQuery : null, tagQuery].filter(Boolean).join(' and ');
+
+    const columnList = await getMeta({
+        pg,
+        table: 'data.' + `"${table}"`
+    }).then(el => el.columns?.map?.(col => col.name) || []);
+    const existingFields = fields && !id ? defaultFields.concat((fields || '').split(',')).filter(colName => columnList.includes(colName)).join(',') : null;
+
+    const filterList = defaultFilters.concat(columns.map(col => ({ name: col.name, type: col.type && ['date', 'datetime'].includes(col.type) ? 'Date' : 'Text', label: col.label, sql: col.sql })));
+
+    const res = await getData({
+        pg,
+        table: 'data.' + `"${table}"`,
+        columns: existingFields,
+        filterList,
+        query: {
+            filter,
+            state,
+            limit: Math.min(limit, maxLimit),
+            page,
+            search,
+            order: order ? order : defaultOrder,
+            desc,
+            sql
+        },
+        user,
+        contextQuery: cQuery,
+    }, reply, true);
+
+    const locales = await pg.query(`select array_agg(distinct REVERSE(split_part(REVERSE(field_key), ':', 1))) from site.localization where object_id in (select id from ${'data.' + `"${table}"`})`).then(el => el.rows?.[0]?.array_agg || []);
+
+    // Apply localization and tags etc.
+    if (res?.rows?.length) {
+        await additionalData(pg, res.rows, locale, id ? null : existingFields);
+    };
+
+    const columns1 = !id
+        ? columns?.map(col => Object.assign(col, { type: col.name === 'published_at' ? 'date' : col.type }))?.filter?.(el => !el.hidden)
+        : columns?.filter?.(el => !el.hidden);
+
+    const finalColumns = (defaultColumns || []).concat(columns1.filter(col => defaultColumns.findIndex(el => el.name === col.name) === -1));
+
+    finalColumns.filter(el => el.default).forEach(col => {
+        const { name, localization } = columns1.find(item => item.name === col.name) || {};
+        if (name) {
+            Object.assign(col, { localization });
+        }
+    });
+
+    if (res?.columns) {
+        Object.assign(res, { type: 'collection', locales, preview_path: preview, columns: finalColumns });
+    }
+
+    return res;
+}

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

@@ -0,0 +1,188 @@
+import path from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+
+import { pgClients, metaFormat, getFilterSQL, getFilter, getMeta } from '@opengis/fastify-table/utils.js';
+
+const inputTypes = existsSync('input-types.json') ? JSON.parse(readFileSync('input-types.json') || '{}') : {};
+
+import additionalData from "./additionalData.js";
+
+export default async function getSingle({
+    contentId: contentId1, id: id1, limit: queryLimit, maxLimit, search, filter, locale, statusQuery, user, sql, page, defaultColumns = [], fields, defaultFields = [], defaultFilters = [],
+}, pg = pgClients.client) {
+    const id = id1 || (contentId1 === 'pages' ? undefined : contentId1) || '';
+    const contentId = id1 ? contentId1 : "pages";
+
+    // defaultColumns.push({
+    //     "name": "content_type_id",
+    //     "label": "Тип сторінки",
+    //     "type": "select",
+    //     "data": "cms.page_type"
+    // });
+
+    const customColumns = await pg.query(`
+            SELECT columns FROM site.content_types WHERE content_type_id in (select content_type_id from site.contents where content_id=$1) limit 1
+        `, [id1 || contentId]).then(el => el.rows?.[0]?.columns || []);
+
+    const contentQuery = contentId === 'pages' || !id
+        ? `(type = 'single' or content_type_id = 'pages')`
+        : 'content_type_id=(select content_type_id from site.contents where content_id=$2)';
+
+    const columns = defaultColumns.concat(customColumns.filter(col => defaultColumns.findIndex(el => el.name === col.name) === -1));
+
+    columns.filter(el => el.default).forEach(col => {
+        const { name, localization } = customColumns.find(item => item.name === col.name) || {};
+        if (name) {
+            Object.assign(col, { localization });
+        }
+    });
+
+    const limit = Math.min(maxLimit, +(queryLimit || 20));
+    const offset = page && page > 0 && !id ? (page - 1) * limit : 0;
+
+    const fData = filter
+        ? await getFilterSQL({
+            pg,
+            table: 'site.contents',
+            filter,
+            search,
+            filterList: defaultFilters,
+            query: `
+              content_type_id IN (
+              SELECT content_type_id
+              FROM site.content_types
+              WHERE ${contentQuery || 'true'}
+            )
+          `,
+        })
+        : {
+            optimizedSQL: 'SELECT * FROM site.contents WHERE true',
+        };
+
+    const localeQuery = locale && locale !== 'uk' && pg.pk?.['site.contents'] ? `${pg.pk?.['site.contents']} in ( select object_id from site.localization where REVERSE( split_part( REVERSE(field_key), ':', 1) ) = '${locale.replace(/'/g, "''")}' )` : undefined;
+
+    const columnList = await getMeta({
+        pg,
+        table: 'site.contents',
+    }).then(el => el.columns?.map?.(col => col.name) || []);
+    const existingFields = fields && contentId === 'pages' || !id ? defaultFields.concat((fields || '').split(',')).filter(colName => columnList.includes(colName)).concat(['content_id AS id']).join(',') : '';
+    const extraKeys = fields ? fields.split(',').filter(key => !defaultFields.includes(key)) : [];
+    const cols = existingFields.length ? existingFields.concat(extraKeys?.length ? `,"extraKeys"` : []) : `content_id AS id,
+        content_id,
+        created_by,
+        title,
+        slug,
+        meta,
+        published_by,
+        published_at,
+        status,
+        content_type_id,
+        /* content_type_id AS type, */
+        main_image
+        ${contentId === 'pages' || !id ? `,"extraKeys"` : ''}`;
+
+    const q = `
+      SELECT ${cols} FROM (${fData.optimizedSQL}) a
+      ${extraKeys || id ? `LEFT JOIN LATERAL (
+        SELECT json_agg(row_to_json(q)) AS "extraKeys"
+        FROM (
+          SELECT field_key, field_type, field_value, field_value_object
+          FROM site.content_data
+          WHERE content_id = a.content_id
+        ) q
+      ) b ON true` : ''}
+
+        LEFT JOIN LATERAL (
+            SELECT type FROM site.content_types WHERE content_type_id=a.content_type_id LIMIT 1
+        )c ON true
+
+      WHERE $1=$1 and $2=$2
+      and ${statusQuery || 'true'}
+      and ${localeQuery || '1=1'}
+      and ${contentQuery || 'true'} 
+      and ${id ? `$2 in (slug, content_id)` : 'true'}
+      order by case when status='archived' then true else false end, published_at desc nulls last
+      LIMIT ${limit} OFFSET ${id ? 0 : offset}
+    `;
+
+    if (sql && user?.user_type?.includes?.('admin')) {
+        return q; // Expose raw SQL for debugging
+    }
+
+    const { total = 0, filtered = 0 } = await pg.query(`
+      SELECT COUNT(*)::int as total,
+      count(*) FILTER(WHERE ${fData.q || "true"})::int as filtered
+      FROM site.contents
+      WHERE content_type_id IN (
+        SELECT content_type_id
+        FROM site.content_types
+        WHERE ${localeQuery || '1=1'} 
+        and $1=$1 and $2=$2 and ${contentQuery || 'true'} 
+      )
+    and ${statusQuery || 'true'}
+    `, [contentId, id]).then(el => el.rows?.[0] || {});
+
+    const { rows = [] } = await pg.query(q, [contentId, id || '']);
+
+    const locales = await pg.query(`select array_agg(distinct REVERSE(split_part(REVERSE(field_key), ':', 1))) from site.localization 
+        where object_id in (select content_id from site.contents 
+            where content_type_id IN (
+                SELECT content_type_id FROM site.content_types where $1=$1 and $2=$2 and ${contentQuery || 'true'}
+            )
+            and ${statusQuery || 'true'}
+        )`, [contentId, id]
+    ).then(el => el.rows?.[0]?.array_agg || []);
+
+    // Flatten extra fields into main object
+    const rows1 = rows.map(row => ({
+        ...row,
+        ...Object.fromEntries(
+            row.extraKeys?.filter(k => extraKeys?.length ? extraKeys.includes(k.field_key) : true)?.map(k =>
+                [k.field_key, inputTypes[k.field_type] === 'json' || k.field_key === 'meta'
+                    ? k.field_value_object
+                    : k.field_value]
+            ) || []
+        ),
+        extraKeys: undefined,
+    }));
+
+    // Apply localization and tags etc.
+    await additionalData(pg, rows1, locale, contentId === 'pages' || !id ? [existingFields, extraKeys].filter(Boolean).join(',') : null);
+
+    // Apply metadata formatting
+    await metaFormat({
+        rows: rows1,
+        cls: {
+            created_by: 'core.user_mentioned',
+            // content_type_id: 'cms.type_id',
+            // type: 'cms.type_id',
+        },
+        sufix: false,
+    }, pg);
+
+    const { list: filters = [] } = await getFilter({
+        pg, table: 'single.default.table', user, filter: `content_type_id in (select content_type_id from site.content_types where type='single' or content_type_id='pages')`
+    }) || {};
+
+    const finalColumns = !id
+        ? columns?.map?.(col => Object.assign(col, { type: col.name === 'published_at' ? 'date' : col.type }))?.filter?.(el => !el.hidden)
+        : columns?.filter?.(el => !el.hidden);
+
+    rows1.filter(row => row.single_sections?.length).forEach(row => {
+        row.single_sections.filter(section => section.documents?.length).forEach(section => {
+            section.documents.filter(doc => doc.file).forEach(doc => Object.assign(doc, { file_name: path.basename(doc.file) }));
+        });
+    });
+
+    return {
+        locales,
+        type: 'single',
+        total,
+        filtered,
+        count: rows1.length,
+        pk: 'id',
+        rows: rows1,
+        columns: finalColumns,
+        filters,
+    };
+}

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

@@ -0,0 +1,87 @@
+import { dataInsert, pgClients } from "@opengis/fastify-table/utils.js";
+
+import requestTranslation from "./requestTranslation.js";
+
+export default async function insertContentLocalization({ send = () => { }, table, id, from, to, nocache, schemaKeys, user }, pg = pgClients.client) {
+    if (!to) {
+        const resp = { error: 'not enough query params: to', code: 400 };
+        send(resp.error + ': ' + id);
+        return resp;
+    }
+
+    const row = await pg.query(`select * ${table ? '' : ',content_id as id'} from ${table ? `data."${table}"` : 'site.contents'} where $1 in (id,slug)`, [id]).then(el => el.rows?.[0]);
+
+    if (!row) {
+        const resp = { error: 'content not found', code: 404 };
+        send(resp.error + ': ' + id);
+        return resp;
+    }
+
+    const localizationExists = await pg.query('select 1 from site.localization where object_id=$1 and field_key is not null and split_part(field_key,\':\',2)=$2', [row.id, to])
+        .then(el => el.rowCount);
+
+    if (localizationExists && !nocache) {
+        const resp = { error: 'target localization already exists', code: 400 };
+        send(resp.error + ': ' + id);
+        return resp;
+    }
+
+    const localization = await pg.query('select json_object_agg(split_part(field_key,\':\',2),field_value) from site.localization where object_id=$1 and field_key is not null and split_part(field_key,\':\',2)=$2', [row.id, from])
+        .then(el => el.rows?.[0]?.json_object_agg || {});
+
+    if (!row) {
+        const resp = { error: 'content not found', code: 404 };
+        send(resp.error + ': ' + id);
+        return resp;
+    }
+
+    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)));
+    const skipped = schemaKeys.filter(key => !entries.map(([el]) => el).includes(key));
+
+    const { result, error, code = 200 } = await requestTranslation(entries, from, to);
+
+    if (error && code) {
+        send(error + ': ' + id);
+        return { error, code };
+    }
+
+    const arr = Object.keys(result).reduce((acc, curr) => {
+        acc.push({
+            field_key: curr,
+            field_value: result[curr],
+            object_id: id,
+        });
+        return acc;
+    }, []);
+
+    const client = await pg.connect();
+
+    try {
+        await client.query('begin');
+
+        if (nocache) {
+            const deleted = await client.query('delete from site.localization where object_id=$1 and split_part(field_key,\':\',2)=$2', [id, to]).then(el => el.rowCount || 0);
+            send(`deleted existing localizations: ${deleted}, ${id}`);
+            console.log('deleted existing localizations: ', deleted, id);
+        }
+
+        await Promise.all(arr.map(async row => dataInsert({
+            pg: client,
+            table: 'site.localization',
+            data: row,
+            uid: user?.uid,
+        })));
+        await client.query('commit');
+
+        send(`translation success: ${table}/${id}`);
+        return { table, id: row.id, keys: schemaKeys, skipped, to };
+    } catch (err) {
+        await client.query('rollback');
+        send(`translation error: ${err.toString()} (${id})`);
+        return { error: err.toString(), code: 500 };
+    } finally {
+        client.release();
+    }
+}

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

@@ -0,0 +1,85 @@
+import { config } from "@opengis/fastify-table/utils.js";
+
+const { host = 'https://translate.softpro.ua', key = '' } = config.integrations?.translation || {};
+
+const divider = ' <divider> ';
+
+// Wrap dot notation keys in quotes
+export const arrayToPhrases = (arr, prefix = 'item') => {
+    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
+        }))
+    );
+};
+
+export default async function requestTranslation(entries, from = 'uk', to) {
+    // Flatten all phrases
+    const phrasesWithMeta = entries.flatMap(([key, value]) =>
+        Array.isArray(value) ? arrayToPhrases(value, key) : [{ key, value, prefix: key }]
+    );
+
+    // Translate each phrase independently
+    const translatedPhrases = await Promise.all(
+        phrasesWithMeta.map(async ({ key, idx, prefix, value }) => {
+            if (!value || typeof value === 'number' || value?.startsWith?.('/files/')) {
+                return { key, idx, 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 q = parts.map(({ str }) => str).join(divider);
+
+                const resp = await fetch(`${host}/translate`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        q,
+                        source: from || "auto",
+                        target: to,
+                        format: "text",
+                        api_key: key
+                    }),
+                });
+
+                if (resp.status !== 200 || resp.headers.get('content-type') !== 'application/json') {
+                    const err = await resp.text();
+                    console.warn('translation request error', resp.status, err);
+                    return { key, idx, prefix, value, error: err }; // fallback to original
+                }
+
+                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 };
+            } catch (err) {
+                console.warn('translation request failed', err.toString());
+                return { key, idx, 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;
+
+        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;
+        }
+
+        return acc;
+    }, {});
+
+    const errors = translatedPhrases.filter(({ error }) => !!error).length;
+
+    return { result, errors };
+}

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

@@ -0,0 +1,48 @@
+import { dataInsert, getTemplate } from "@opengis/fastify-table/utils.js";
+
+export default async function updateLocalization(pg, id, body, contentTypeId, uid) {
+    if (!pg || !id || !body || !contentTypeId) { return null };
+
+    const 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, contentTypeId]).then(el => el.rows?.[0]?.columns || []);
+
+    // const contentColumns = await pg.query('select columns from site.content_types where content_type_id=$1', [contentTypeId])
+    //     .then(el => el.rows?.[0]?.columns || []);
+
+    const loadTable = contentTypeId === 'pages' ? await getTemplate('table', 'single.default.table') : {};
+
+    const columns = contentTypeId === 'pages'
+        ? (loadTable?.columns || []).concat(contentColumns.filter(col => loadTable?.columns.findIndex(el => el.name === col.name) === -1))
+        : contentColumns;
+
+    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 obj = bodyKeys.reduce((acc, curr) => ({ ...acc, [curr]: body[curr] }), {});
+
+    if (bodyKeys.length === 0) { return null; }
+
+    const arr = Object.keys(obj).reduce((acc, curr) => {
+        acc.push({
+            field_key: curr,
+            field_value: body[curr],
+            object_id: id,
+        });
+        return acc;
+    }, []);
+
+    await Promise.all(arr.map(async row => dataInsert({
+        pg,
+        table: 'site.localization',
+        data: row,
+        uid,
+    })));
+
+    return obj;
+}

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

@@ -0,0 +1,26 @@
+import { dataDelete, pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function deleteSpace({ pg = pgClients.client, user, params, headers = {} }, reply) {
+    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'); }
+
+    if (params?.id && params.id === 'default') {
+        return reply.status(400).send('default space cannot be deleted');
+    }
+
+    const exists = await pg.query('select space_id from site.spaces where space_id=$1', [params.id]).then(el => el.rows?.[0]?.space_id);
+    if (!exists) { return reply.status(404).send('space not found: ' + params.id); }
+
+    const { referer } = headers;
+
+    const res = await dataDelete({
+        pg,
+        table: 'site.spaces',
+        id: params?.id,
+        uid: user?.uid,
+        referer,
+    });
+
+    return { id: params.id, ...res || {} };
+}

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

@@ -0,0 +1,28 @@
+import { pgClients } from '@opengis/fastify-table/utils.js';
+
+const maxLimit = 100;
+const defaultLimit = 20;
+
+export default async function getSpaces({ pg = pgClients.client, user, params = {}, query = {} }, reply) {
+    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'); }
+
+    const limit = Math.min(maxLimit, +(query.limit || defaultLimit));
+    const offset = query.page && query.page > 0 && !params.id ? (query.page - 1) * limit : 0;
+
+    const q = `select * from site.spaces where ${params.id ? 'space_id=$1' : '1=1'} limit ${limit} offset ${offset}`;
+    if (query.sql && user?.uid) return q;
+
+    const { rows = [] } = await pg.query(q, [params.id].filter(Boolean));
+
+    const total = await pg.queryCache('select count(*) from site.spaces', { table: 'site.spaces' }).then(el => el.rows?.[0]?.count || 0);
+
+    rows.forEach(row => Object.assign(row, { id: row.space_id }));
+
+    if (params.id) {
+        if (!rows.length) { return reply.status(404).send('space not found: ' + params.id); }
+        return reply.status(200).send(rows[0]);
+    }
+
+    return { total, filtered: rows.length, rows };
+}

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

@@ -0,0 +1,22 @@
+import { dataInsert, pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function insertSpace({ pg = pgClients.client, user, params, headers = {}, body = {} }, reply) {
+    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'); }
+
+    const exists = params?.id ? await pg.query('select space_id from site.spaces where space_id=$1', [params.id]).then(el => el.rows?.[0]?.space_id) : false;
+    if (exists) { return reply.status(400).send('space aleady exists: ' + params?.id); }
+
+    const { referer } = headers;
+
+    const res = await dataInsert({
+        pg,
+        table: 'site.spaces',
+        data: body,
+        id: params?.id,
+        uid: user?.uid,
+        referer,
+    });
+
+    return { id: res?.rows?.[0]?.space_id, rows: res?.rows || [] };
+}

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

@@ -0,0 +1,24 @@
+import { dataUpdate, pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function updateSpace({ pg = pgClients.client, user, params, headers = {}, body = {} }, reply) {
+    // 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'); }
+
+    const id = 'default';
+    const exists = await pg.query('select space_id from site.spaces where space_id=$1', [id]).then(el => el.rows?.[0]?.space_id);
+    if (!exists) { return reply.status(404).send('space not found: ' + id); }
+
+    const { referer } = headers;
+
+    const res = await dataUpdate({
+        pg,
+        table: 'site.spaces',
+        data: body,
+        id,
+        uid: user?.uid,
+        referer,
+    });
+
+    return { id, ...res || {} };
+}

package/server/routes/cmsSpace/index.mjs

@@ -0,0 +1,20 @@
+// space
+import getSpaces from './controllers/getSpaces.js';
+import insertSpace from './controllers/insertSpace.js';
+import updateSpace from './controllers/updateSpace.js';
+import deleteSpace from './controllers/deleteSpace.js';
+
+const params = {
+    config: {
+        policy: [
+            'public'
+        ]
+    }
+};
+
+export default async function route(app) {
+    app.get('/cms-space/:id?', params, getSpaces);
+    app.post('/cms-space/:id?', params, insertSpace);
+    app.put('/cms-space/:id?', params, updateSpace);
+    app.delete('/cms-space/:id', params, deleteSpace);
+}