@opengis/cms 0.0.14 → 0.0.15

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

@@ -1,66 +1,66 @@
-import path from 'node:path';
-import { mkdir, rename } from 'node:fs/promises';
-
-import { config, getFolder, dataInsert, pgClients } from "@opengis/fastify-table/utils.js";
-
-import { getMimeType, getFileType, uploadMultiPart } from '@opengis/fastify-file/utils.js';
-import { existsSync } from 'node:fs';
-
-const rootDir = getFolder(config, 'local');
-
-export default async function uploadMedia(req, reply) {
-    const { pg = pgClients.client, user = {}, body = {}, query = {} } = req;
-
-    if (!pg.pk?.['site.media']) {
-        return reply.status(404).send('table not found');
-    }
-
-    if (query.subdir && (typeof query.subdir !== 'string' || query.subdir.includes('..'))) {
-        return reply.status(403).send('invalid query params: subdir');
-    }
-
-    // upload assets
-    if (req.headers['content-type']?.split?.(';')?.shift?.() === 'multipart/form-data') {
-        const file = await uploadMultiPart(req);
-        const filename = `${file.newFilename}${path.extname(file.filepath)}`;
-        const mime = getMimeType(file.filepath);
-        const filetype = getFileType(file.filepath);
-
-        const newfilepath = path.join(rootDir, 'media', query.subdir || '', filename);
-        await mkdir(path.dirname(newfilepath), { recursive: true });
-        await rename(file.filepath, newfilepath);
-
-        const relpath = path.join('/media', query.subdir || '', filename).replace(/\\/g, '/');
-        const id = await dataInsert({
-            pg,
-            table: 'site.media',
-            data: {
-                filename: file.originalFilename,
-                filetype,
-                url: relpath,
-                mime,
-                filesize: file.size,
-            },
-            uid: user?.uid || 0,
-        }).then(el => el?.rows?.[0]?.media_id);
-
-        return reply.status(200).send({
-            relpath: path.join('/media', query.subdir || '').replace(/\\/g, '/'),
-            id,
-            filename,
-            filetype,
-            type: 'file',
-        });
-    }
-
-    // create directory
-    const relpath = path.join('/media', query.subdir).replace(/\\/g, '/');
-    const dirpath = path.join(rootDir, relpath);
-    await mkdir(dirpath, { recursive: true });
-
-    return reply.status(200).send({
-        relpath,
-        dirname: path.basename(query.subdir),
-        type: 'dir',
-    });
+import path from 'node:path';
+import { mkdir, rename } from 'node:fs/promises';
+
+import { config, getFolder, dataInsert, pgClients } from "@opengis/fastify-table/utils.js";
+
+import { getMimeType, getFileType, uploadMultiPart } from '@opengis/fastify-file/utils.js';
+import { existsSync } from 'node:fs';
+
+const rootDir = getFolder(config, 'local');
+
+export default async function uploadMedia(req, reply) {
+    const { pg = pgClients.client, user = {}, body = {}, query = {} } = req;
+
+    if (!pg.pk?.['site.media']) {
+        return reply.status(404).send('table not found');
+    }
+
+    if (query.subdir && (typeof query.subdir !== 'string' || query.subdir.includes('..'))) {
+        return reply.status(403).send('invalid query params: subdir');
+    }
+
+    // upload assets
+    if (req.headers['content-type']?.split?.(';')?.shift?.() === 'multipart/form-data') {
+        const file = await uploadMultiPart(req);
+        const filename = `${file.newFilename}${path.extname(file.filepath)}`;
+        const mime = getMimeType(file.filepath);
+        const filetype = getFileType(file.filepath);
+
+        const newfilepath = path.join(rootDir, 'media', query.subdir || '', filename);
+        await mkdir(path.dirname(newfilepath), { recursive: true });
+        await rename(file.filepath, newfilepath);
+
+        const relpath = path.join('/media', query.subdir || '', filename).replace(/\\/g, '/');
+        const id = await dataInsert({
+            pg,
+            table: 'site.media',
+            data: {
+                filename: file.originalFilename,
+                filetype,
+                url: relpath,
+                mime,
+                filesize: file.size,
+            },
+            uid: user?.uid || 0,
+        }).then(el => el?.rows?.[0]?.media_id);
+
+        return reply.status(200).send({
+            relpath: path.join('/media', query.subdir || '').replace(/\\/g, '/'),
+            id,
+            filename,
+            filetype,
+            type: 'file',
+        });
+    }
+
+    // create directory
+    const relpath = path.join('/media', query.subdir).replace(/\\/g, '/');
+    const dirpath = path.join(rootDir, relpath);
+    await mkdir(dirpath, { recursive: true });
+
+    return reply.status(200).send({
+        relpath,
+        dirname: path.basename(query.subdir),
+        type: 'dir',
+    });
 }

package/server/routes/{site → cms}/index.mjs

@@ -25,21 +25,21 @@ const schemaObj = {
     }
 };
 
-const params = { config: { policy: ['site', 'user'] } };
+const params = { config: { policy: ['public'] } };
 
 export default async function route(app) {
-    app.post('/site-permissions/:id', params, setPermissions);
-    app.get('/site-permissions/:id?', params, getPermissions);
+    app.post('/cms-permissions/:id', params, setPermissions);
+    app.get('/cms-permissions/:id?', params, getPermissions);
 
-    app.post('/site-media/upload', params, uploadMedia);
-    app.get('/site-media', params, listMedia);
-    app.get('/site-media/:id/file', { ...params, schema: schemaObj }, download);
-    app.get('/site-media/:id', params, metadata);
-    app.delete('/site-media/:id', params, del);
-    app.get('/site-media/:id/delete', params, del); // debug
+    app.post('/cms-media/upload', params, uploadMedia);
+    app.get('/cms-media', params, listMedia);
+    app.get('/cms-media/:id/file', { ...params, schema: schemaObj }, download);
+    app.get('/cms-media/:id', params, metadata);
+    app.delete('/cms-media/:id', params, del);
+    app.get('/cms-media/:id/delete', params, del); // debug
 
-    app.get('/site/:type/:id?', params, getContent);
-    app.post('/site/:type/:id?', params, insertContent);
-    app.put('/site/:type/:id', params, updateContent);
-    app.delete('/site/:type/:id', params, deleteContent);
+    app.get('/cms/:type/:id?', params, getContent);
+    app.post('/cms/:type/:id?', params, insertContent);
+    app.put('/cms/:type/:id', params, updateContent);
+    app.delete('/cms/:type/:id', params, deleteContent);
 }

package/server/routes/contentType/controllers/cms.type.delete.js

@@ -0,0 +1,22 @@
+import { dataDelete, getMeta, 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');
+  }
+
+  const { pk } = await getMeta({ pg, table: 'site.content_types' });
+
+  if (!pk) {
+    return reply.status(404).send('table not found');
+  }
+
+  const res = await dataDelete({
+    pg,
+    table: 'site.content_types',
+    id: params.id,
+    uid: user?.uid
+  });
+
+  return { id: res.content_id, rows: [res] };
+}

package/server/routes/contentType/controllers/cms.type.get.js

@@ -0,0 +1,22 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+import cache from '../utils/builderCache.js';
+
+export default async function builderGet({ pg = pgClients.client, params = {} }, reply) {
+  if (!params.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  const { pk } = await getMeta({ pg, table: 'site.content_types' });
+
+  if (cache[params.id]) {
+    return reply.status(200).send({ total: 1, rows: [cache[params.id]] });
+  }
+
+  const { rows = [], rowCount: total = 0 } = pk ? await pg.query(
+    `select a.content_type_id as id, a.* FROM site.content_types a
+   where a.content_type_id=$1`, [params.id]
+  ) : {};
+
+  return reply.status(200).send({ total, rows });
+}

package/server/routes/contentType/controllers/cms.type.list.js

@@ -0,0 +1,25 @@
+import { config, pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+import builderCache from '../utils/builderCache.js';
+
+export default async function builderList({ pg = pgClients.client, query = {} }, reply) {
+
+  const { pk } = await getMeta({ pg, table: 'site.content_types' });
+
+  if (config.cms?.provider === 'pg') {
+    const cache = builderCache();
+    return reply.status(200).send({ total: cache?.length, rows: cache });
+  }
+
+  if (!pk) {
+    return reply.status(404).send('table not found');
+  }
+
+  const q = `select a.content_type_id as id, a.name, a.title, a.description, a.table_name as table FROM site.content_types a
+  where ${query.content_type_id ? 'content_type_id=$1' : '1=1'}`
+
+  const { rows = [] } = pk ? await pg.query(q, [query.content_type_id].filter((el) => el)) : {};
+  rows.forEach(row => Object.assign(row, { provider: 'pg' }));
+
+  return reply.status(200).send({ total: rows.length, rows });
+}

package/server/routes/contentType/controllers/cms.type.post.js

@@ -0,0 +1,22 @@
+import { dataInsert, getMeta, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function builderPost(req, reply) {
+  const { pg = pgClients.client, user = {}, body = {} } = req;
+
+  const { pk } = await getMeta({ pg, table: 'site.content_types' });
+
+  if (!pk) {
+    return reply.status(404).send('table not found');
+  }
+
+  const resData = await dataInsert({
+    pg,
+    table: "site.content_types",
+    data: body,
+    uid: user?.uid,
+  });
+  //   console.log(resData);
+  const res = resData?.rows?.[0];
+
+  return { id: res?.content_type_id, rows: [res].filter(Boolean) };
+}

package/server/routes/contentType/controllers/cms.type.put.js

@@ -0,0 +1,24 @@
+import { dataUpdate, getMeta, pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function builderPut(req, reply) {
+  const { pg = pgClients.client, body = {}, params = {} } = req;
+  if (!params.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+  const { pk } = await getMeta({ pg, table: 'site.content_types' });
+
+  if (!pk) {
+    return reply.status(404).send('table not found');
+  }
+
+  const resData = await dataUpdate({
+    pg,
+    table: 'site.content_types',
+    data: body,
+    id: params.id,
+  });
+  //   console.log(resData)
+  const res = resData;
+
+  return { id: res.content_type_id, rows: [res].filter(Boolean) };
+}

package/server/routes/contentType/index.mjs

@@ -0,0 +1,25 @@
+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';
+
+const policy = ['public'];
+
+export default async function route(app) {
+  // Type add
+  app.post('/cms-type', { config: { policy } }, cmsTypePost);
+
+  // Type edit
+  app.put('/cms-type/:id', { config: { policy } }, cmsTypePut);
+
+  // 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);
+}

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

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+
+import { subscribe } from '@parcel/watcher';
+
+import { config, yml2json } from '@opengis/fastify-table/utils.js';
+
+function parseYml(filepath) {
+    const name = path.basename(filepath, '.yml');
+
+    const yml = readFileSync(filepath, 'utf8');
+    const json = yml2json(yml);
+
+    return {
+        [name]: {
+            ...json,
+            name,
+            id: json?.type === 'single' ? name : undefined,
+            table: json?.type === 'single' ? undefined : name,
+            provider: json.provider || 'pg',
+            slug: json?.type === 'single' ? name : (json.slug || 'slug')
+        }
+    };
+}
+
+const content = config.cms?.root && existsSync(config.cms?.root)
+    ? readdirSync(config.cms?.root, { withFileTypes: true })
+    : [];
+
+const files = content.filter(el => el.isFile() && path.extname(el.name) === '.yml');
+
+const cache = files.reduce((acc, curr) => {
+    return { ...acc, ...parseYml(path.join(config.cms.root, curr.name)) };
+}, {});
+
+async function watchDirectory() {
+    await subscribe(config.cms.root, (err, events) => {
+        if (err) throw new Error(err.toString());
+
+        const { path: filepath, type } = events[0];
+        const name = path.basename(filepath, '.yml');
+        if (path.extname(filepath) === '.yml') {
+            if (type !== 'delete') { cache[name] = parseYml(filepath); }
+            if (type === 'delete') { delete cache[name]; }
+        }
+    });
+}
+
+if (config.cms?.root && config.local) {
+    watchDirectory();
+}
+
+export default function builderCache(name) {
+    if (name) {
+        return cache[name];
+    }
+    return Object.values(cache || {});
+}

package/server/routes/fileContent/data/deleteContent.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import { existsSync, rmSync } from 'node:fs';
+
+import contentDir from '../utils/contentDir.js';
+import contentTypeExists from '../utils/contentTypeExists.js';
+
+export default async function deleteContent(req, reply) {
+    const { params = {} } = 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 (!contentTypeExists(type)) {
+        return reply.status(400).send('invalid params: type');
+    }
+
+
+    const filepath = [path.join(contentDir, type, `${id}.mdoc`), path.join(contentDir, type, `${id}.md`)]
+        .find(el => existsSync(el));
+
+    if (!filepath) {
+        return reply.status(404).send('file not found');
+    }
+
+    rmSync(filepath, { recursive: true });
+
+    return reply.status(200).send({ id, type, filepath });
+}

package/server/routes/fileContent/data/deleteMedia.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import { existsSync, rmSync } from 'node:fs';
+
+import { config, getFolder } from "@opengis/fastify-table/utils.js";
+
+const rootDir = getFolder(config, 'local');
+
+export default async function deleteMedia({
+    params = {},
+}, reply) {
+    if (!params['*']) {
+        return reply.status(400).send('not enough params');
+    }
+
+    if (typeof params['*'] !== 'string' || params['*'].includes('..')) {
+        return reply.status(403).send('invalid params');
+    }
+
+    const filepath = path.join(rootDir, params['*']);
+
+    if (!existsSync(filepath)) {
+        return reply.status(404).send('file not found');
+    }
+
+    rmSync(filepath, { recursive: true });
+
+    return { filepath: params['*'] };
+}

package/server/routes/fileContent/data/downloadMedia.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+
+import { config, getFolder } from "@opengis/fastify-table/utils.js";
+import { downloadFile, isFileExists, getMimeType } from '@opengis/fastify-file/utils.js';
+
+const rootDir = getFolder(config, 'local');
+
+export default async function downloadMedia({
+    params = {}, query = {},
+}, reply) {
+    if (!params['*']) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (typeof params['*'] !== 'string' || params['*'].includes('..')) {
+        return reply.status(403).send('invalid params');
+    }
+
+    const filepath = path.join(rootDir, params['*']);
+
+    const exists = await isFileExists(filepath);
+
+    if (!exists) {
+        return reply.status(404).send('file not found');
+    }
+
+    const buffer = await downloadFile(filepath, { buffer: true });
+    const mime = getMimeType(filepath);
+
+    // skip xml load for preview
+    if (query.preview && path.extname(filepath) !== '.xml') {
+        return reply.headers({ 'Content-Type': mime }).send(buffer);
+    }
+
+    return reply
+        .headers({
+            'Content-Type': mime,
+            'Content-Disposition': `attachment; filename=${path.basename(filepath)}`,
+        })
+        .send(buffer);
+}

package/server/routes/fileContent/data/getContent.js

@@ -0,0 +1,32 @@
+import { config } from '@opengis/fastify-table/utils.js';
+
+import contentTypeExists from '../utils/contentTypeExists.js';
+import { contentTypes } from '../utils/astroBuilderCache.js';
+
+export default async function getContent(req, reply) {
+    const { params = {} } = req;
+    const { type, id } = params;
+
+    if (!type) {
+        return reply.status(400).send('not enough params: type');
+    }
+
+    const metadata = contentTypeExists(type, 'metadata.json');
+
+    if (!metadata) {
+        return reply.status(400).send('invalid params: type');
+    }
+
+    if (!id) {
+        const rows = Object.values(contentTypes || {});
+        return { metadata, rows };
+    }
+
+    const data = contentTypeExists(type, id);
+
+    if (!data) {
+        return reply.status(404).send('file not found');
+    }
+
+    return { metadata, data };
+}

package/server/routes/fileContent/data/insertContent.js

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { writeFileSync } from 'node:fs';
+
+import contentDir from '../utils/contentDir.js';
+import contentTypeExists from '../utils/contentTypeExists.js';
+
+const extension = 'mdoc'; // extract from collection?
+
+export default async function insertContent(req, reply) {
+    const { params = {}, body = {} } = req;
+    const { slug, content } = body;
+
+    if (!params.type) {
+        return reply.status(400).send('not enough params: type');
+    }
+
+    if (!slug) {
+        return reply.status(400).send('not enough body params: slug');
+    }
+
+    if (!content) {
+        return reply.status(400).send('not enough body params: content');
+    }
+
+    if (typeof content !== 'string') {
+        return reply.status(400).send('invalid params: content');
+    }
+
+    if (!contentTypeExists(params.type)) {
+        return reply.status(400).send('invalid params: type');
+    }
+
+    const filepath = path.join(contentDir, params.type, `${slug}.${extension}`);
+    writeFileSync(filepath, content, { recursive: true });
+
+    return reply.status(200).send({ id: slug, type: params.type, filepath });
+}

package/server/routes/fileContent/data/listMedia.js

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+
+import { config, getFolder } from '@opengis/fastify-table/utils.js';
+
+const rootDir = getFolder(config, 'local');
+mkdirSync(path.join(rootDir, 'media'), { recursive: true });
+
+export default async function listMedia(req, reply) {
+    const { query = {} } = req;
+    const { subdir = '' } = query;
+
+    if (typeof subdir !== 'string' || subdir.includes('..')) {
+        return reply.status(403).send('invalid params: subdir');
+    }
+
+    const relpath = path.join('/media', subdir).replace(/\\/g, '/');
+    const dirpath = path.join(rootDir, relpath).replace(/\\/g, '/');
+
+    if (!existsSync(dirpath)) {
+        return { data: [], relpath, msg: 'directory not exists' };
+    }
+
+    const isDirectory = (await stat(dirpath)).isDirectory();
+
+    const items = isDirectory ? await readdir(dirpath, { withFileTypes: true }) : [];
+
+    const content = items.map(el => ({ type: el.isDirectory() ? 'dir' : 'file', name: el.name }));
+
+    await Promise.all(content.filter(el => el.type === 'dir').map(async (item) => {
+        const items = await readdir(path.join(dirpath, item.name));
+        Object.assign(item, { count: items.length, exists: true });
+    }));
+
+    content.filter(el => el.type === 'file').forEach(item => {
+        item.exists = true;
+    });
+
+    const result = { relpath, data: content };
+
+    if (config.debug) {
+        Object.assign(result, { rootDir });
+    }
+
+    return result;
+}

package/server/routes/fileContent/data/metadataMedia.js

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+
+import { config, getFolder } from "@opengis/fastify-table/utils.js";
+import { stat } from 'node:fs/promises';
+
+import downloadMedia from './downloadMedia.js';
+
+const rootDir = getFolder(config, 'local');
+
+export default async function metadataMedia(req, reply) {
+    if (!req.query?.metadata) return downloadMedia(req, reply);
+
+    const { params = {}, } = req;
+
+    if (!params['*']) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (typeof params['*'] !== 'string' || params['*'].includes('..')) {
+        return reply.status(403).send('invalid params: subdir');
+    }
+
+    const filepath = path.join(rootDir, params['*']);
+
+    const stats = existsSync(filepath) ? await stat(filepath) : null;
+
+    if (!stats) {
+        return reply.status(404).send('file not found');
+    }
+
+    return reply.status(200).send({
+        ...stats,
+        url: `${req.routeOptions.url}/${params['*']}?download=1`.replace(/\*/g, '').replace(/\/\//g, ''),
+        filepath: `${req.routeOptions.url}/${params['*']}`.replace(/\*/g, '').replace(/\/\//g, ''),
+        exists: true,
+    });
+}