@opengis/cms 0.0.13 → 0.0.15

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,
+    });
+}

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

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import { existsSync, rmSync, writeFileSync } from 'node:fs';
+
+import contentDir from '../utils/contentDir.js';
+import contentTypeExists from '../utils/contentTypeExists.js';
+
+export default async function updateContent(req, reply) {
+    const { params = {}, body = {} } = req;
+    const { type, id } = params;
+    const { content } = body;
+
+    if (!type) {
+        return reply.status(400).send('not enough params: type');
+    }
+
+    if (!id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (!content) {
+        return reply.status(400).send('not enough body params: content');
+    }
+
+    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 });
+    writeFileSync(filepath, content, { recursive: true });
+
+    return reply.status(200).send({ id, type, filepath });
+}

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

@@ -0,0 +1,49 @@
+import path from 'node:path';
+import { mkdir, rename } from 'node:fs/promises';
+
+import { config, getFolder } from "@opengis/fastify-table/utils.js";
+
+import { getMimeType, getFileType, uploadMultiPart } from '@opengis/fastify-file/utils.js';
+
+const rootDir = getFolder(config, 'local');
+
+export default async function uploadMedia(req, reply) {
+    const { query = {} } = req;
+
+    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, '/');
+
+        return reply.status(200).send({
+            relpath,
+            mime,
+            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/fileContent/index.mjs

@@ -0,0 +1,54 @@
+// type
+import cmsTypeGet from './type/getContentType.js';
+import cmsTypeList from './type/contentTypeList.js';
+import cmsTypePut from './type/updateContentType.js';
+import cmsTypePost from './type/createContentType.js';
+import cmsTypeDelete from './type/deleteContentType.js';
+
+// media
+import listMedia from './data/listMedia.js';
+import metadata from './data/metadataMedia.js';
+import uploadMedia from './data/uploadMedia.js';
+import del from './data/deleteMedia.js';
+import download from './data/downloadMedia.js';
+
+// content
+import getContent from './data/getContent.js';
+import insertContent from './data/insertContent.js';
+import updateContent from './data/updateContent.js';
+import deleteContent from './data/deleteContent.js';
+
+const schemaObj = {
+  type: 'object',
+  properties: {
+    params: {
+      type: 'string',
+      enum: ['preview', 'download'],
+    }
+  }
+};
+
+const params = { config: { policy: ['site', 'user'] } };
+
+export default async function route(app) {
+  // content type
+  app.post('/cms-type', { config: { policy: ['site'] } }, cmsTypePost);
+  app.put('/cms-type/:id', { config: { policy: ['site'] } }, cmsTypePut);
+  app.get('/cms-type', { config: { policy: ['site'] } }, cmsTypeList);
+  app.get('/cms-type/:id', { config: { policy: ['site'] } }, cmsTypeGet);
+  app.delete('/cms-type/:id', { config: { policy: ['site'] } }, cmsTypeDelete);
+
+  // content media
+  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/*', params, metadata); // preview + metadata + download via query params
+  app.delete('/cms-media/*', params, del);
+
+  // content data
+  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/fileContent/type/contentTypeList.js

@@ -0,0 +1,7 @@
+import { contentTypes } from '../utils/astroBuilderCache.js';
+
+export default async function builderList({ params = {} }, reply) {
+  const rows = Object.values(contentTypes || {}).filter(Boolean);
+
+  return reply.status(200).send({ total: rows.length, rows });
+}

package/server/routes/fileContent/type/createContentType.js

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+
+import { config } from '@opengis/fastify-table/utils.js';
+
+import contentDir from '../utils/contentDir.js';
+import contentTypeExists from '../utils/contentTypeExists.js';
+
+export default async function builderPost(req, reply) {
+  const { body = {} } = req;
+
+  if (!body.type) { Object.assign(body, { type: 'collection' }) };
+
+  if (!body.slug) {
+    return reply.status(400).send('not enough body params: slug');
+  }
+
+  if (typeof body.slug !== 'string' || body.slug.includes('..')) {
+    return reply.status(409).send('invalid body params: slug');
+  }
+
+  if (contentTypeExists(body.slug)) {
+    return reply.status(400).send('type already exists');
+  }
+
+  // support watcher?
+  mkdirSync(path.join(contentDir, body.slug), { recursive: true });
+  writeFileSync(path.join(contentDir, body.slug, 'metadata.json'), JSON.stringify(body));
+
+  return { id: body.slug, rows: [body] };
+}

package/server/routes/fileContent/type/deleteContentType.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { rm } from 'node:fs/promises';
+
+import { config } from '@opengis/fastify-table/utils.js';
+
+import contentDir from '../utils/contentDir.js';
+import contentTypeExists from '../utils/contentTypeExists.js';
+
+export default async function builderDelete({
+  params = {},
+}, reply) {
+  if (!params.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  if (config.cms?.provider !== 'file') {
+    return reply.status(400).send('invalid provider');
+  }
+
+  if (!contentTypeExists(params.id)) {
+    return reply.status(400).send('nothing to delete');
+  }
+
+  if (params.id) {
+    await rm(path.join(contentDir, params.id), { recursive: true });
+  }
+
+  return { id: params.id };
+}

package/server/routes/fileContent/type/getContentType.js

@@ -0,0 +1,15 @@
+import { config } from '@opengis/fastify-table/utils.js';
+
+import { contentTypes } from '../utils/astroBuilderCache.js';
+
+export default async function builderGet({ params = {} }, reply) {
+  if (!params.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  if (config.cms?.provider !== 'file') {
+    return reply.status(400).send('invalid provider');
+  }
+
+  return reply.status(200).send({ total: contentTypes[params.id] ? 1 : 0, rows: [contentTypes[params.id]].filter(Boolean) });
+}