@opengis/cms 0.0.16 → 0.0.18

package/server/routes/contentType/controllers/addContentType.js

@@ -0,0 +1,162 @@
+import { config, logger, dataInsert, pgClients } from '@opengis/fastify-table/utils.js';
+
+import updateCustomContentTable from '../utils/updateCustomContentTable.js'; // custom table
+import updateContents from '../utils/updateContents.js'; // site.contents + site.content_data
+
+const columns = [
+  {
+    name: 'slug',
+    label: 'Slug',
+    type: 'slug',
+    parent: 'title',
+    required: true
+  },
+  {
+    name: 'title',
+    label: 'Заголовок',
+    type: 'text',
+    required: true
+  },
+  {
+    name: 'status',
+    label: 'Статус',
+    type: 'select',
+    data: "content.status",
+    required: true
+  },
+  {
+    name: 'published_at',
+    label: 'Дата публікації',
+    type: 'date',
+    required: true
+  },
+  {
+    name: 'is_pin',
+    label: 'Закріпити контент',
+    type: 'boolean',
+    required: false,
+    default: 'false',
+    hidden: true,
+  },
+  {
+    name: 'meta',
+    label: 'Meta',
+    type: 'datalist',
+    hidden: true,
+  },
+  {
+    name: 'created_at',
+    label: 'Дата та час створення',
+    type: 'datetime',
+    default: 'now()',
+    hidden: true,
+  },
+  {
+    name: 'updated_at',
+    label: 'Дата та час редагування',
+    type: 'datetime',
+    default: 'now()',
+    hidden: true,
+  },
+  {
+    name: 'created_by',
+    type: 'text',
+    label: 'Автор',
+    hidden: true
+  },
+  {
+    name: 'updated_by',
+    type: 'text',
+    label: 'Редактор',
+    default: 'now()',
+    hidden: true
+  }
+];
+
+export default async function builderPost(req, reply) {
+  const { pg = pgClients.client, user = {}, body = {} } = req;
+
+  if (!pg?.pk?.['site.content_types']) {
+    return reply.status(404).send('table not found');
+  }
+
+  const { customTable = true } = body;
+
+  if (!body.name) {
+    return reply.status(400).send('not enough body params: name');
+  }
+
+  if (typeof body.name !== 'string') {
+    return reply.status(400).send('invalid body params: name not as string');
+  }
+
+  const rowCount = await pg.query('select content_type_id as id from site.content_types where name=$1', [body.name]).then(el => el.rowCount);
+
+  if (rowCount > 0) {
+    return reply.status(400).send('Тип контенту з даною назвою вже існує');
+  }
+
+  const tablename = body.type === 'collection' && true ? body.name.toLowerCase().replace(/ /g, '').replace(/'/g, "''").replace(/'/g, '').replace(/-/g, '_') : undefined; // customTable
+
+  const client = await pg.connect();
+
+  try {
+    await client.query('BEGIN');
+
+    const columns1 = (body.fields || body.columns || columns.filter(el => !el.hidden)).filter(el => el.name).map(el => Object.assign(el, { name: el.name.toLowerCase() })); // for rest crud
+
+    if (body.type === 'single') {
+      const singleColumns = [
+        {
+          name: 'main_image',
+          label: 'Головне зображення',
+          type: 'image',
+          required: false
+        },
+        {
+          name: 'single_body',
+          label: 'Контент',
+          type: 'richtext',
+          required: false
+        },
+        {
+          name: 'single_sections',
+          label: 'Секції',
+          type: 'reference',
+          required: false
+        },
+      ]
+      columns1.push(...singleColumns);
+    }
+
+    const { rows = [] } = await dataInsert({
+      pg: client,
+      table: 'site.content_types',
+      data: {
+        ...body,
+        table_name: tablename,
+        columns: columns1,
+      },
+      uid: user?.uid,
+    });
+
+    Object.assign(body, { slug: body.slug || body.name });
+
+    if (tablename) {
+      await updateCustomContentTable({ pg: client, id: rows?.[0]?.content_type_id, columns });
+    }
+
+    const res = await updateContents(client, rows?.[0]?.content_type_id, body, user?.uid);
+    Object.assign(rows?.[0], res || {}); // update rows with contents
+
+    await client.query('COMMIT');
+
+    return reply.status(200).send({ id: rows?.[0]?.content_type_id, rows });
+  } catch (err) {
+    await client.query('ROLLBACK');
+    logger.file('cms/contentType', { error: err.toString(), stack: err.stack });
+    return reply.status(500).send('Помилка при додаванні типу контенту');
+  } finally {
+    client.release();
+  }
+}

package/server/routes/contentType/controllers/contentTypeList.js

@@ -0,0 +1,54 @@
+import { config, pgClients } from '@opengis/fastify-table/utils.js';
+
+const maxLimit = 100;
+
+export default async function builderList({ pg = pgClients.client, query = {} }, reply) {
+  if (!pg) {
+    return reply.status(200).send({ total: 0, msg: 'empty pg', rows: [] });
+  }
+
+  const limit = Math.min(maxLimit, query.limit || 16);
+  const offset = query.page && query.page > 0 ? (query.page - 1) * limit : 0;
+
+  const q = `select a.content_type_id as id, a.name, a.title, a.description, a.table_name as table, type, columns, a.include_search, json_build_object('locales', locales, 'default_locale', default_locale, 'name', space_name) as space FROM site.content_types a
+  left join lateral ( select locales, default_locale, name as space_name from site.spaces where space_id= 'default' limit 1) b on 1=1
+  where ${query.type === 'collection' ? `type='collection'` : (query.type === 'single' ? `type='single'` : '1=1')}`;
+
+  const where = query.search?.replace ? `(name ilike '%${query.search.replace(/'/, "''")}%' or title ilike '%${query.search.replace(/'/, "''")}%')` : '1=1';
+  const q1 = q + `and ${where} order by case when status='archived' then true else false end limit ${limit} offset ${offset}`;
+
+  if (query.sql) return q1;
+
+  const { rows = [] } = await pg.query(q1);
+
+  const { total = 0, filtered = 0 } = await pg.query(`select 
+    count(*)::int as total,
+    count(*) filter (where ${where})::int as filtered 
+    from (${q})q`
+  ).then(el => el.rows?.[0] || {});
+
+  await Promise.all(rows.map(async row => {
+    if (row.table && false) {
+      await pg.query('alter table data.' + row.table + ' add column if not exists created_at timestamp with time zone not null default now()');
+      await pg.query('alter table data.' + row.table + ' add column if not exists updated_at timestamp with time zone not null default now()');
+      await pg.query('alter table data.' + row.table + ' add column if not exists created_by text');
+      await pg.query('alter table data.' + row.table + ' add column if not exists updated_by text');
+    }
+
+    const q2 = row.table
+      ? `select count(*) from data."${row.table}" where $1=$1`
+      : `select count(*) from site.contents where $1=$1 and ${row.id === 'pages' ? `slug <> 'pages' and content_type_id in (select content_type_id from site.content_types where type = 'single' or content_type_id='pages')` : 'content_type_id=$1'}`;
+
+    const q1 = row.table
+      ? `select updated_at from data."${row.table}" where $1=$1 order by updated_at desc limit 1`
+      : `select updated_at from site.content_data where content_id in ( select content_id from site.contents where content_type_id=$1 limit 1) order by updated_at desc limit 1`;
+
+    const count = await pg.queryCache(q2, { table: row.table ? `data.${row.table}` : 'site.content_data', args: [row.id] }).then(el => el.rows?.[0]?.count || '0');
+
+    const lastEdit = await pg.queryCache(q1, { table: row.table ? `data.${row.table}` : 'site.content_data', args: [row.id] }).then(el => el.rows?.[0]?.updated_at);
+
+    Object.assign(row, { columns: undefined, fields: row.columns?.length || '0', entries: +count, last_edit: lastEdit });
+  }));
+
+  return reply.status(200).send({ total, filtered, count: rows.length, provider: 'pg', rows });
+}

package/server/routes/contentType/controllers/delContentType.js

@@ -0,0 +1,75 @@
+import { dataUpdate, dataDelete, pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function builderDelete({ pg = pgClients.client, user = {}, params = {} }, reply) {
+  if (!params.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  if (!pg?.pk?.['site.content_types']) {
+    return reply.status(404).send('table not found');
+  }
+
+  const { cid, table, title, type } = await pg.query(
+    `select content_type_id as cid, table_name as table, title, type from site.content_types where $1 in (content_type_id, name)`,
+    [params.id],
+  ).then(el => el.rows?.[0] || {});
+
+  if (!cid) {
+    return reply.status(404).send('content type not found');
+  }
+
+  if (cid === 'pages') {
+    return reply.status(403).send('access restricted: pages content type cannot be deleted');
+  }
+
+  // await pg.query('delete from site.content_data where content_id in (select content_id from site.contents where content_type_id=$1)', [cid]);
+  // await pg.query('delete from site.contents where content_type_id=$1', [cid]);
+
+  if (table) {
+    // await pg.query(`drop table if exists data."${table}"`);
+    if (pg?.pk && false) {
+      delete pg.pk[`data."${table}"`];
+      pg.tlist = pg.tlist.filter(el => el !== `data."${table}"`);
+    }
+
+    // await pg.query('delete from site.content_data where content_id in (select content_id from site.contents where content_type_id=$1)', [cid])
+
+    // await pg.query('delete from site.contents where content_type_id=$1', [cid]);
+  }
+
+  // cascade
+  const contentIds = await pg.query('select array_agg(content_id) from site.contents where content_type_id=$1 and title<>$2', [cid, title])
+    .then(el => el.rows?.[0]?.array_agg || []);
+
+  if (contentIds.length) {
+    // await pg.query('delete from site.content_data where content_id=any($1)', [contentIds]);
+  }
+
+  if (type === 'collection' && table) {
+    const count = await pg.query(`select count(*)::int from data."${table}"`).then(el => el.rows?.[0]?.count || 0);
+    if (count === 0) {
+      await pg.query('delete from site.contents where content_type_id=$1', [cid]);
+      const res = await dataDelete({
+        pg,
+        table: 'site.content_types',
+        id: cid,
+        uid: user?.uid
+      });
+      // await pg.query(`drop table if exists data."${table}"`);
+      return { id: cid, rows: [res].filter(Boolean) };
+    }
+  }
+
+  // console.log('archived', cid, contentIds);
+  const res = await dataUpdate({
+    pg,
+    table: 'site.content_types',
+    id: cid,
+    data: {
+      status: 'archived',
+    },
+    uid: user?.uid
+  });
+
+  return { id: cid, rows: [res].filter(Boolean) };
+}

package/server/routes/contentType/controllers/editContentType.js

@@ -0,0 +1,61 @@
+import { config, dataUpdate, pgClients } from '@opengis/fastify-table/utils.js';
+
+import updateCustomContentTable from '../utils/updateCustomContentTable.js';
+import updateContents from '../utils/updateContents.js';
+
+export default async function builderPut(req, reply) {
+  const { pg = pgClients.client, body = {}, params = {}, user = {} } = req;
+  if (!params.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  if (!pg?.pk?.['site.content_types']) {
+    return reply.status(404).send('table not found');
+  }
+
+  const { cid, table } = await pg.query(
+    `select content_type_id as cid, table_name as table, type from site.content_types where $1 in (content_type_id, name)`,
+    [params.id],
+  ).then(el => el.rows?.[0] || {});
+
+  if (!cid) {
+    return reply.status(404).send('content type not found');
+  }
+
+  const columns = (body.fields || body.columns)?.filter?.(el => el.name)?.map?.(el => Object.assign(el, { name: el.name.toLowerCase() })); // for rest crud
+
+  const client = await pg.connect();
+
+  client.options = pg.options;
+  client.tlist = pg.tlist;
+  client.pgType = pg.pgType;
+  client.relkinds = pg.relkinds;
+  client.pk = pg.pk;
+
+  try {
+    await client.query('begin');
+
+    if (table) {
+      await updateCustomContentTable({ pg: client, id: cid, columns });
+    }
+
+    await dataUpdate({
+      pg: client,
+      table: 'site.content_types',
+      id: cid,
+      data: body,
+      uid: user?.uid,
+    });
+
+    const row = await updateContents(client, cid, { ...body, slug: body.slug || body.name }, user?.uid);
+
+    await client.query('commit');
+
+    return { id: row?.content_type_id, rows: [row].filter(Boolean) };
+  } catch (err) {
+    await client.query('rollback');
+    throw err;
+  } finally {
+    client.release();
+  }
+}

package/server/routes/contentType/controllers/getContentType.js

@@ -0,0 +1,37 @@
+import { pgClients, getTemplate } from '@opengis/fastify-table/utils.js';
+
+export default async function builderGet({ pg = pgClients.client, params = {} }, reply) {
+  if (!params.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  if (!pg?.pk?.['site.content_types']) {
+    return reply.status(404).send('table not found');
+  }
+
+  const row = await pg.query(
+    `select content_type_id as id, * FROM site.content_types
+   where $1 in (content_type_id, name)`, [params.id]
+  ).then(el => el.rows?.[0]);
+
+  if (!row) {
+    return reply.status(404).send('content type not found');
+  }
+
+  const space = await pg.query(
+    'select name, default_locale, locales from site.spaces where space_id = $1', ['default'],
+  ).then(el => el.rows?.[0] || {});
+  Object.assign(row, { space });
+
+  const loadTable = params.id === 'pages' ? await getTemplate('table', 'single.default.table') : {};
+
+  const columns = params.id === 'pages' ? loadTable?.columns : row.columns;
+  Object.assign(row, { columns });
+
+  // filter system / hidden
+  if (Array.isArray(row.columns)) {
+    row.columns.filter(col => !col.hidden);
+  }
+
+  return reply.status(200).send(row);
+}

package/server/routes/contentType/index.mjs

@@ -1,25 +1,35 @@
-import cmsTypeGet from './controllers/cms.type.get.js';
-import cmsTypeList from './controllers/cms.type.list.js';
-import cmsTypePut from './controllers/cms.type.put.js';
-import cmsTypePost from './controllers/cms.type.post.js';
-import cmsTypeDelete from './controllers/cms.type.delete.js';
+import getContentType from './controllers/getContentType.js';
+import contentTypeList from './controllers/contentTypeList.js';
+import editContentType from './controllers/editContentType.js';
+import addContentType from './controllers/addContentType.js';
+import delContentType from './controllers/delContentType.js';
 
-const policy = ['public'];
+const params = { config: { policy: ['public'] } };
 
 export default async function route(app) {
-  // Type add
-  app.post('/cms-type', { config: { policy } }, cmsTypePost);
+  const schema = {
+    params: {
+      type: 'object',
+      properties: {
+        id: {
+          type: 'string'
+        },
+      },
+    },
+    body: {
+      type: 'object',
+      required: ['name'],
+      properties: {
+        name: { type: 'string' }
+      }
+    }
+  };
 
-  // Type edit
-  app.put('/cms-type/:id', { config: { policy } }, cmsTypePut);
+  app.get('/cms', params, contentTypeList);
+  app.get('/cms-type', params, contentTypeList);
 
-  // Type list
-  app.get('/cms', { config: { policy } }, cmsTypeList);
-  app.get('/cms-type', { config: { policy } }, cmsTypeList);
-
-  // Type get
-  app.get('/cms-type/:id', { config: { policy } }, cmsTypeGet);
-
-  // Type delete
-  app.delete('/cms-type/:id', { config: { policy } }, cmsTypeDelete);
+  app.post('/cms-type', { ...params, schema }, addContentType);
+  app.put('/cms-type/:id', { ...params, schema }, editContentType);
+  app.get('/cms-type/:id', params, getContentType);
+  app.delete('/cms-type/:id', params, delContentType);
 }

package/server/routes/contentType/utils/updateContents.js

@@ -0,0 +1,29 @@
+import { dataInsert, dataUpdate } from "@opengis/fastify-table/utils.js";
+
+export default async function updateContents(pg, id, data, uid) {
+    if (!pg?.pk || !id) return null;
+
+    const contentId = await pg.query(
+        `select content_id from site.contents where content_type_id = $1 order by content_id=content_type_id desc limit 1`, // update pages collection, avoid singles
+        [id],
+    ).then(el => el.rows?.[0]?.content_id);
+
+    if (contentId) {
+        const result = await dataUpdate({
+            pg,
+            id: contentId,
+            table: 'site.contents',
+            data,
+            uid,
+        });
+        return result;
+    }
+
+    const result = await dataInsert({
+        pg,
+        table: 'site.contents',
+        data: { ...data || {}, content_type_id: id },
+        uid,
+    }).then(el => el.rows?.[0]);
+    return result;
+}

package/server/routes/contentType/utils/updateCustomContentTable.js

@@ -0,0 +1,56 @@
+import { existsSync, readFileSync } from 'node:fs';
+
+import { getMeta } from '@opengis/fastify-table/utils.js';
+
+const inputTypes = existsSync('input-types.json') ? JSON.parse(readFileSync('input-types.json') || '{}') : {};
+
+const types = {
+    number: 'numeric',
+    datetime: 'timestamp without time zone',
+    boolean: 'boolean',
+    date: 'date',
+    array: 'text[]',
+    FileList: 'text[]',
+};
+
+export default async function updateCustomContentTable({ pg, id, columns = [] }) {
+    if (!pg?.pk || !id) return null;
+
+    const { table_name: tablename, dbcolumns } = await pg.query(
+        `select table_name, columns as dbcolumns from site.content_types where content_type_id = $1`,
+        [id],
+    ).then(el => el.rows?.[0] || {});
+
+    if (!tablename) return null;
+
+    const droppedColumns = (dbcolumns || []).filter(el => columns.findIndex(col => col.name === el.name) === -1);
+    // console.log(droppedColumns);
+
+    const q = `create table if not exists data."${tablename}" 
+    ( id text not null default next_id() PRIMARY KEY );
+     ${droppedColumns.map(col => `
+        alter table data."${tablename}" add column if not exists "${col.name}" text;
+        alter table data."${tablename}" alter column "${col.name}" drop not null;`).join('\n')}
+     ${columns?.filter?.(col => col.name)?.map?.(col => `
+        alter table data."${tablename}" add column if not exists "${col.name}" ${types[col.type] || inputTypes[col.type] || 'text'} ${col.required ? ' not null ' : ''};
+        alter table data."${tablename}" alter column "${col.name}" ${col.required ? ' set ' : ' drop '}  not null;
+        alter table data."${tablename}" alter column "${col.name}" set default ${col.default ? col.default : 'null'};
+        comment on column data."${tablename}"."${col.name}" is ${col.label ? `'${col.label.replace(/'/g, "''")}'` : 'null'} `
+    ).join(';') || ''}`;
+    await pg.query(q);
+    await pg.query(`alter table data."${tablename}" add column if not exists created_at timestamp with time zone not null default now()`);
+    await pg.query(`alter table data."${tablename}" add column if not exists updated_at timestamp with time zone not null default now()`);
+    await pg.query(`alter table data."${tablename}" add column if not exists created_by text`);
+    await pg.query(`alter table data."${tablename}" add column if not exists updated_by text`);
+    await pg.query(`alter table data."${tablename}" drop constraint if exists c${id}_slug_unique;alter table data."${tablename}" add constraint c${id}_slug_unique UNIQUE (slug);`);
+
+    // force meta columns refresh to avoid crud skips
+    getMeta({ pg, table: `data.${tablename}` }, true);
+
+    if (pg?.pk && pg.tlist && !pg.tlist.find(el => el === `data.${tablename}`)) {
+        pg.pk[`data.${tablename}`] = 'id';
+        pg.tlist?.push?.(`data.${tablename}`);
+    }
+
+    return null;
+}

package/server/routes/feedback/controllers/email.list.js

@@ -0,0 +1,25 @@
+export default async function feedbackList(req, reply) {
+    const { pg, user = {}, query } = req;
+    const { uid } = user;
+    if (!uid) return reply.code(401).send({ message: 'Not authorized', status: 401 });
+
+    const { page = 1, limit = 16 } = query;
+    const offset = limit * (page - 1) || 0;
+
+    const { total, filtered } = await pg.one(`select count(*)::int as total from site.feedback`)
+
+    const { rows = [] } = await pg.query(`
+        select 
+            row_number() over(order by created_at desc) as num,
+            subscription_id,
+            email,
+            created_at,
+            enabled
+        from site.subscription
+        order by created_at desc
+        limit ${limit} offset ${offset}
+        `);
+
+    const status = rows?.length ? 200 : 204;
+    return reply.code(status).send({ message: { total, filtered, rows }, status })
+}

package/server/routes/feedback/controllers/feedback.js

@@ -0,0 +1,49 @@
+import { pgClients, dataInsert, config } from '@opengis/fastify-table/utils.js';
+
+const refererAllow = config?.refererAllow || ['127.0.0.1', 'localhost', 'softpro.ua', 'opengis.info'];
+
+function checkReferer(headers) {
+    if (config?.local) return true;
+    if (!headers?.referer) return false;
+    return refererAllow.some(allowed => headers.referer.includes(allowed));
+}
+
+export default async function feedback({ body = {}, pg = pgClients.client, headers, params }, reply) {
+    reply
+        .header('Access-Control-Allow-Origin', '*')
+        .header('Access-Control-Allow-Methods', 'POST, OPTIONS')
+        .header('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (!checkReferer(headers)) {
+        return reply.status(403).send('access restricted');
+    }
+
+    if ((params?.type !== 'vacancy') && (!body?.message_text || !body?.email)) {
+        return reply.status(400).send('message_text and email is required');
+    }
+
+    if ((params?.type === 'vacancy') && !body?.user_name) {
+        return reply.status(400).send('user_name is required');
+    }
+
+    const allowedFields = ['title', 'message_text', 'email', 'phone', 'user_name', 'resume_link', 'linkedin_link', 'portfolio_link', 'telegram_link'];
+    const data = Object.fromEntries(
+        Object.entries(body).filter(([key]) => allowedFields.includes(key))
+    );
+    data["feedback_type"] = params?.type;
+
+    const { rows } = await dataInsert({
+        table: 'site.feedback',
+        data: {
+            ...data,
+            headers
+        },
+        pg
+    });
+
+    if (!rows?.length) {
+        return reply.status(500).send('insert error');
+    }
+
+    return reply.status(200).send('Звернення додано успішно');
+}

package/server/routes/feedback/controllers/feedback.list.js

@@ -0,0 +1,38 @@
+import { getFilterSQL } from '@opengis/fastify-table/utils.js';
+
+export default async function feedbackList(req, reply) {
+    const { pg, user = {}, query } = req;
+    const { uid } = user;
+    if (!uid) return reply.code(401).send({ message: 'Not authorized', status: 401 });
+
+    const { page = 1, limit = 16, filter = null } = query;
+    const offset = limit * (page - 1) || 0;
+
+    const { q: filterQuery } = await getFilterSQL({
+        filter, table: 'site.feedback'
+    });
+
+    const { total, filtered } = await pg.one(`select count(*)::int as total, (count(*) filter(where ${filterQuery ? `${filterQuery}` : '1=1'}))::int as  filtered from site.feedback`)
+
+    const { rows = [] } = await pg.query(`
+        select 
+            row_number() over(order by created_at desc) as num,
+            email,
+            message_id,
+            user_name,
+            message_text,
+            feedback_type,
+            phone,
+            created_at,
+            linkedin_link,
+            portfolio_link,
+            telegram_link
+        from site.feedback
+        where created_at is not null ${filterQuery ? `and ${filterQuery}` : ''}
+        order by created_at desc
+        limit ${limit} offset ${offset}
+        `);
+
+    const status = rows?.length ? 200 : 204;
+    return reply.code(status).send({ message: { total, filtered, rows }, status })
+}