@opengis/cms 0.0.16 → 0.0.18

package/server/plugins/adminHook.js

@@ -4,9 +4,9 @@ import { createReadStream } from 'node:fs';
 async function plugin(fastify) {
   // preSerialization
   fastify.addHook('preSerialization', async (req, reply, payload) => {
-    if (req.url.includes('/suggest/') && !req.query.json) {
+    /*if (req.url.includes('/suggest/') && !req.query.json) {
       return payload?.data;
-    }
+    }*/
     /* if (payload.redirect) {
        return reply.redirect(payload.redirect);
      }*/

package/server/plugins/hook.js

@@ -1,67 +1,59 @@
 import fp from 'fastify-plugin';
-
-import { config, pgClients } from '@opengis/fastify-table/utils.js';
-
-import builderCache from '../routes/contentType/utils/builderCache.js';
-
-const matches = {
-    date: 'timestamp without time zone',
-};
-
-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'
-    }
-];
-
-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] })));
-
-    defaultColumns.forEach(el => columnList.push(el));
-
-    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')}`;
+import { randomUUID, createHash } from 'node:crypto';
+
+import { addHook, addCron, config, pgClients } from '@opengis/fastify-table/utils.js';
+
+import getDraftKey from '../functions/getDraftKey.js';
+
+const pg = pgClients.client;
+
+const q = `select 
+    content_id as id, a.status, type, published_at, table_name as table
+from site.contents a
+left join site.content_types b
+    on a.content_type_id=b.content_type_id
+where
+    b.visible
+    and case
+            when type = 'single'
+            then
+                a.status='delayPublished'
+                and CURRENT_DATE >= published_at::date
+            else true
+        end`;
+
+async function updateDelayPublished() {
+    const rows = await pg.query(q).then(el => el.rows || []);
+
+    const result = await Promise.all(rows.map(async ({ id, status, type, table }) => {
+        if (status === 'delayPublished' && type === 'single') {
+            const { rowCount } = await pg.query(`update site.contents set status='published' where content_id=$1`, [id]);
+            return { id, type, rowCount };
+        } else if (table && type === 'collection') {
+            const { rowCount } = await pg.query(`update data."${table}" set status='published' where status='delayPublished' and now() >= published_at`);
+            return { id, type, rowCount };
+        } else {
+            return { id, type, skip: true };
+        }
+    }));
+    const r = { updated: result.reduce((acc, curr) => acc + +(curr.rowCount || 0), 0), skipped: result.filter(el => el.skip).length };
+    if (config.trace) console.log(r);
+    return r;
 }
-
 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);
-        });
-    }
+    addHook('afterUser', async ({ payload = {} }) => {
+        if (payload?.user) {
+            // get from cache, refresh hourly
+            const { draftKey, ttl } = await getDraftKey();
+            Object.assign(payload.user, { draftKey, draftKeyTTL: ttl });
+        }
+    });
+    // force refresh at restart
+    app.addHook('onListen', async () => {
+        await getDraftKey(true);
+    });
+    addCron(updateDelayPublished, 60 * 60);
+    updateDelayPublished();
 }
 
 export default fp(plugin);

package/server/plugins/vite.js

@@ -7,7 +7,7 @@ import { config } from '@opengis/fastify-table/utils.js';
 const dir = dirname(fileURLToPath(import.meta.url));
 const root = `${dir}/../..`;
 const isProduction = process.env.NODE_ENV === 'production' || config.production;
-
+console.log({ isProduction })
 async function plugin(fastify) {
   // vite server
   if (!isProduction) {
@@ -33,7 +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 || {};
-      if (!user && config.pg && !config.auth?.disable) {
+      if (!user && config.pg && !req.url.startsWith('/src/') && !config.auth?.disable) {
         return reply.redirect('/login');
       }
 
@@ -50,9 +50,9 @@ async function plugin(fastify) {
   fastify.get('*', async (req, reply) => {
     const { user } = req.session?.passport || {};
     const indexPath = path.join(root, 'dist', 'index.html');
-    // if (!user && config.pg && !config.auth?.disable) {
-    //   return reply.redirect('/login');
-    // }
+    if (!user && config.pg && !req.url.startsWith('/src/') && !config.auth?.disable) {
+      return reply.redirect('/login');
+    }
     if (!fs.existsSync(indexPath)) {
       return reply.status(404).send('index.html not found');
     }

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

@@ -0,0 +1,56 @@
+import { metaFormat, pgClients } from '@opengis/fastify-table/utils.js';
+
+const q = `select 
+count(distinct object_id) as cdtotal,
+count(distinct object_id) filter( where date_trunc('month', created_at) = date_trunc('month', CURRENT_DATE) ) as cdnewcount from site.content_data`;
+
+const q1 = `select 
+count(*) as usercount,
+count(*) filter( where date_trunc('month', cdate) = date_trunc('month', CURRENT_DATE) ) as usernewcount from admin.users`;
+
+const q2 = `select 
+count(*) as mediacount,
+count(*) filter( where date_trunc('month', created_at) = date_trunc('month', CURRENT_DATE) ) as medianewcount from site.media`;
+
+const q3 = `select type, title, updated_at, content_type_id as object_id, slug as content_id from site.contents a 
+left join lateral (select type from site.content_types where content_type_id=a.content_type_id limit 1)b on 1=1
+where 1=1 order by updated_at desc limit 5`;
+
+export default async function cmsStat({ pg = pgClients.client }, reply) {
+    if (!pg) {
+        return reply.status(500).send('empty pg');
+    }
+
+    const { cdtotal = 0, cdnewcount = 0 } = await pg.query(q).then(el => el.rows?.[0] || {});
+
+    const customTables = await pg.query(`select array_agg(table_name) from site.content_types where type='collection' and table_name is not null`).then(el => el.rows?.[0]?.array_agg || []);
+
+    const custom = await Promise.all(customTables.filter(table => pg?.pk?.[`data.${table}`]).map(async table => {
+        // await pg.query(`alter table data.${table} add column if not exists created_at timestamp with time zone not null default now()`);
+        const { total = 0, newcount = 0 } = await pg.queryCache(`select count(*) as total, count(*) filter( where date_trunc('month', created_at) = date_trunc('month', CURRENT_DATE) ) as newcount from data.${table}`, { table: `data.${table}` }).then(el => el.rows?.[0] || {});
+        return { table, total, newcount };
+    }));
+
+    const totalContent = custom.reduce((acc, el) => acc + +el.total, +cdtotal);
+    const newContent = custom.reduce((acc, el) => acc + +el.newcount, +cdnewcount);
+
+    const { usercount = 0, usernewcount = 0 } = await pg.query(q1).then(el => el.rows?.[0] || {});
+
+    const { mediacount = 0, medianewcount = 0 } = await pg.query(q2).then(el => el.rows?.[0] || {});
+
+    const { rows = [] } = await pg.query(q3);
+
+    await metaFormat({ rows, cls: { updated_by: 'core.user_mentioned' }, sufix: false }, pg);
+
+    return {
+        stat: {
+            totalContent,
+            newContent,
+            totalUsers: +usercount,
+            newUsers: +usernewcount,
+            totalMediaFiles: +mediacount,
+            newMediaFiles: +medianewcount,
+        },
+        recentContent: rows,
+    };
+}

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

@@ -0,0 +1,58 @@
+import { config, pgClients } from '@opengis/fastify-table/utils.js';
+
+const maxLimit = 50;
+
+export default async function suggest({ pg = pgClients.client, params = {}, query = {}, user = {} }, reply) {
+    const t1 = Date.now();
+
+    const { id } = params;
+    const { key, val } = query;
+
+    if (!pg?.pk) {
+        return reply.status(500).send('empty pg');
+    }
+
+    if (!id) {
+        return reply.status(400).send('not enough params');
+    }
+
+    const limit = Math.min(query.limit || 16, maxLimit);
+    const offset = query.page && query.page > 0 ? (query.page - 1) * limit : 0;
+
+    const { ctid, table } = await pg.query(
+        'select content_type_id as ctid, table_name as table, columns from site.content_types where $1 in (content_type_id, name)',
+        [id],
+    ).then(el => el.rows?.[0] || {});
+
+    if (!ctid) {
+        return reply.status(404).send('content type not found');
+    }
+
+    // site.content_data
+    if (!table) {
+        const q = `select content_id as id, title as text from site.contents where content_type_id=$1 and ${key ? `lower(title) ~ lower($2)` : (val ? 'content_id=$2' : '1=1')} limit ${limit}`;
+
+        const { rows = [] } = await pg.query(q, [ctid, (key || val)].filter(Boolean));
+
+        return {
+            time: Date.now() - t1,
+            limit,
+            count: rows.length,
+            mode: 'array',
+            sql: (config.local || user?.user_type?.includes?.('admin')) ? q : undefined,
+            data: rows,
+        };
+    }
+
+    const q = `select id, title as text from data.${table} where ${key ? `lower(title) ~ lower($1)` : (val ? 'id=$1' : '1=1')} limit ${limit}`;
+    const { rows = [] } = await pg.query(q, [key || val].filter(Boolean));
+
+    return {
+        time: Date.now() - t1,
+        limit,
+        count: rows.length,
+        mode: 'array',
+        sql: (config.local || user?.user_type?.includes?.('admin')) ? q : undefined,
+        data: rows,
+    };
+} 

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

@@ -1,60 +1,115 @@
-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 || {} });
+import { config, pgClients, dataUpdate, dataDelete } from '@opengis/fastify-table/utils.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 (id === 'pages') {
+        return reply.status(403).send('access restricted: pages contents cannot be deleted');
+    }
+
+    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='data'`).then(el => el.rows?.[0]?.array_agg || []) : [];
+
+    if (!arr.length) {
+        return reply.status(400).send('empty schema: data');
+    }
+
+    const table = arr.find(el => el === params.type);
+
+    const { ctid, dbtable } = await pg.query('select content_type_id as ctid, table_name as dbtable from site.content_types where $1 in (content_type_id, name)', [params.type])
+        .then(el => el.rows?.[0] || {});
+
+    // singletone with extra at site.content_data
+    if (!table && !dbtable && ctid) {
+        const { cid, status } = ctid === 'pages' && id
+            ? await pg.query(
+                'select content_id as cid, status from site.contents where content_id=$1 limit 1',
+                [id]).then(el => el.rows?.[0] || {})
+            : await pg.query(
+                'select content_id as cid, status from site.contents where content_type_id=$1 limit 1',
+                [ctid],
+            ).then(el => el.rows?.[0] || {});
+
+        if (!cid) {
+            return reply.status(404).send('contents not found');
+        }
+
+        if (cid === 'pages') {
+            return reply.status(403).send('access restricted: pages contents cannot be deleted');
+        }
+
+        if (status === 'archived') {
+            const row = await dataDelete({
+                pg,
+                id,
+                table: 'site.contents',
+                referer: headers?.referer,
+                uid: user?.uid || 0,
+            })
+            return { id, ...row || {} };
+        }
+
+        // archived
+        const row = await dataUpdate({
+            pg,
+            id,
+            table: 'site.contents',
+            data: {
+                status: 'archived',
+            },
+            referer: headers?.referer,
+            uid: user?.uid || 0,
+        })
+        return { id, ...row || {} };
+    }
+
+    // custom table
+    if (!table && !dbtable) {
+        return reply.status(400).send('invalid params: type');
+    }
+
+    const status = await pg.query(`select status from data."${(table || dbtable)}" where id =$1`, [id]).then(el => el.rows?.[0]?.status);
+
+    if (status === 'archived') {
+        const row = await dataDelete({
+            pg,
+            id,
+            table: 'data.' + `"${(table || dbtable)}"`,
+            referer: headers?.referer,
+            uid: user?.uid || 0,
+        })
+        return { id, ...row || {} };
+    }
+
+    // archived
+    const result = await dataUpdate({
+        pg,
+        id,
+        table: 'data.' + `"${(table || dbtable)}"`,
+        data: {
+            status: 'archived',
+        },
+        referer: headers?.referer,
+        uid: user?.uid || 0,
+    });
+
+    const pk = pg.pk?.['data.' + table || dbtable];
+    return reply.status(200).send({ id: result?.[pk], ...result || {} });
 }

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

@@ -1,47 +1,76 @@
-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, stat, readdir } from 'node:fs/promises';
+
+import { config, dataDelete, getFolder, pgClients } from "@opengis/fastify-table/utils.js";
+
+const rootDir = getFolder(config, 'local');
+const dir = '/files';
+
+export default async function deleteMedia({
+    pg = pgClients.client, params = {}, query = {}, user = {}, method = 'DELETE',
+}, reply) {
+    if (!config.debug && method !== 'DELETE') {
+        return reply.status(403).send('access restricted');
+    }
+
+    if (!params.id && query.subdir) {
+        const dirpath = path.join(rootDir, dir, query.subdir || '');
+        const exists = existsSync(dirpath);
+        const stats = await stat(dirpath);
+
+        if (!stats.isDirectory()) {
+            return reply.status(400).send('not a directory');
+        }
+
+        if (!exists) {
+            return reply.status(404).send('subdir not found: ' + query.subdir);
+        }
+
+        const content = await readdir(dirpath, { recursive: true });
+
+        if (query.subdir.startsWith('uploads') && !query.subdir.split('/')[1]) {
+            return reply.status(403).send('access restricted: uploads directory');
+        }
+
+        // only admins are allowed to delete non-empty directories
+        if (content?.length && !user?.user_type?.includes?.('admin')) {
+            return reply.status(400).send('directory is not empty');
+        }
+
+        await rm(dirpath, { recursive: true });
+        return reply.status(200).send('subdirectory successfully deleted');
+    }
+
+    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 || {} };
 }