@opengis/cms 0.0.7 → 0.0.8

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@opengis/cms",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "cms",
   "type": "module",
   "author": "Softpro",
   "main": "dist/cms.js",
   "license": "EULA",
   "files": [
-  "dist/*"
-],
+    "dist/*",
+    "server",
+    "utils.js"
+  ],
   "scripts": {
     "test": "node --test test/**/*.test.js",
     "lint": "eslint . --ext .vue,.js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix --ignore-path .gitignore",
@@ -49,4 +51,4 @@
     "vitepress-plugin-tabs": "^0.5.0",
     "vitepress-sidebar": "1.30.2"
   }
-}
+}

package/server/app.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { config, execMigrations } from '@opengis/fastify-table/utils.js';
+
+config.prefix = config.prefix || '/api';
+const { prefix } = config;
+
+const cwd = process.cwd();
+
+export default async function (fastify) {
+  // core
+  fastify.register(import('./plugins/hook.js'));
+
+  fastify.register(import('@opengis/fastify-table'), config);
+  fastify.register(import('@opengis/fastify-auth'), config);
+  fastify.register(import('@opengis/fastify-file'), config);
+
+  fastify.register(import('./plugins/vite.js'));
+  // API
+  fastify.register(import('./routes/root.mjs'));
+  fastify.register(import('./routes/builder/index.mjs'), { prefix });
+  fastify.register(import('./routes/category/index.mjs'), { prefix });
+  fastify.register(import('./routes/manager/index.mjs'), { prefix });
+  fastify.register(import('./routes/media/index.mjs'), { prefix });
+  execMigrations(path.join(cwd, 'server/migrations')).catch(err => console.log(err));
+}

package/server/config.js

@@ -0,0 +1,5 @@
+import { readFile } from 'fs/promises';
+import fs from 'fs';
+const config = fs.existsSync('config.json') ? JSON.parse(await readFile('config.json')) : {};
+
+export default config;

package/server/index.js

@@ -0,0 +1,23 @@
+import Fastify from 'fastify';
+
+
+import appService from './app.js';
+import config from './config.js';
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+// Instantiate Fastify with some config
+const app = Fastify({ logger: !isProduction });
+
+// Register your application as a normal plugin.
+
+app.register(appService);
+
+process.env.PORT = process.env.PORT || config.port || 3000;
+// Start listening.
+app.listen({ host: '0.0.0.0', port: process.env.PORT }, (err) => {
+  if (err) {
+    app.log.error(err);
+    process.exit(1);
+  }
+});

package/server/migrations/media.sql

@@ -0,0 +1,30 @@
+create schema if not exists crm;
+create table if not exists crm.media();
+
+CREATE TABLE IF NOT EXISTS crm.media();
+ALTER TABLE crm.media DROP CONSTRAINT IF EXISTS crm_media_id_pkey;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS media_id text NOT NULL DEFAULT next_id();
+
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS uploaded_name text;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS file_path text;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS caption text;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS altname text;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS size numeric;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS ext text;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS tags text[];
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS uid text;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS files json;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS cdate timestamp without time zone DEFAULT (now())::timestamp without time zone;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS editor_id text;
+ALTER TABLE crm.media ADD COLUMN IF NOT EXISTS editor_date timestamp without time zone;
+ALTER TABLE crm.media ADD CONSTRAINT crm_media_id_pkey PRIMARY KEY (media_id);
+
+comment on table crm.media is 'Медіа файли';
+
+comment on column crm.media.uploaded_name is 'Назва файлу';
+comment on column crm.media.file_path is 'Відносний шлях до файлу';
+comment on column crm.media.caption is 'Заголовок';
+comment on column crm.media.altname is 'Альтернативна назва';
+comment on column crm.media.size is 'Розмір файлу';
+comment on column crm.media.ext is 'Розширення файлу';
+comment on column crm.media.tags is 'Теги файлу';

package/server/plugins/hook.js

@@ -0,0 +1,91 @@
+import fp from 'fastify-plugin';
+import fs from 'fs';
+import config from '../config.js';
+
+// the use of fastify-plugin is required to be able
+// to export the decorators to the outer scope
+
+async function plugin(fastify) {
+  fastify.decorate('config', config);
+
+  // pre Request
+  fastify.addHook('onRequest', async (req) => {
+    req.funcs = fastify;
+    const { user } = req.session?.passport || {};
+    req.user = user;
+  });
+
+  // preSerialization
+  fastify.addHook('preSerialization', async (req, reply, payload) => {
+    if (req.url.includes('/suggest/') && !req.query.json) {
+      return payload?.data;
+    }
+    /* if (payload.redirect) {
+       return reply.redirect(payload.redirect);
+     }*/
+    if (reply.sent) {
+      return null;
+    }
+    if (!payload) {
+      return payload;
+    }
+
+    if (['200', '400', '500', '403', '404'].includes(payload.status)) {
+      reply.status(payload.status);
+    }
+    /* if (payload.headers) {
+      reply.headers(payload.headers);
+    } */
+    if (payload.buffer) {
+      return payload.buffer;
+    }
+    if (payload.file) {
+      // const buffer = await readFile(payload.file);
+      // return reply.send(buffer);
+      const stream = fs.createReadStream(payload.file);
+      return stream;
+      // return reply.send(stream);
+    }
+
+    if (payload.message) {
+      return payload.message;
+    }
+    return payload;
+  });
+
+  //  preValidation
+  fastify.addHook('preValidation', async (req) => {
+    const parseRawBody = ['POST', 'PUT'].includes(req.method) && req.body && typeof req.body === 'string'
+      && req.body.trim(/\r\n/g).startsWith('{')
+      && req.body.trim(/\r\n/g).endsWith('}');
+    if (parseRawBody) {
+      try {
+        req.body = JSON.parse(req.body || '{}');
+      }
+      catch (err) {
+        // throw new Error('invalid body');
+        // return { error: 'invalid body', status: 400 };
+      }
+    }
+  });
+
+  // allow upload file
+  const kIsMultipart = Symbol.for('[FastifyMultipart.isMultipart]');
+  fastify.addContentTypeParser('multipart', (request, _, done) => {
+    request[kIsMultipart] = true;
+    done(null);
+  });
+
+  // parse Body
+  function contentParser(req, body, done) {
+    const parseBody = decodeURIComponent(body.toString()).split('&').reduce((acc, el) => {
+      const [key, val] = el.split('=');
+      return { ...acc, [key]: val };
+    }, {});
+    done(null, parseBody);
+  }
+
+  fastify.addContentTypeParser('application/x-www-form-urlencoded', { parseAs: 'buffer' }, contentParser);
+}
+
+export default fp(plugin);

package/server/plugins/vite.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const dir = dirname(fileURLToPath(import.meta.url));
+const root = `${dir}/../..`;
+import config from '../config.js';
+
+const isProduction = process.env.NODE_ENV === 'production' || config.production;
+
+async function plugin(fastify) {
+  // vite server
+  if (!isProduction) {
+    const vite = await import('vite');
+
+    const viteServer = await vite.createServer({
+      root: `${root}`,
+      server: {
+        middlewareMode: true,
+      },
+    });
+
+    // add root to watch
+    viteServer.watcher.add(root);
+
+    // hot relaod template
+    viteServer.watcher.on('all', (d, t) => {
+      if (!t.includes('module')) return;
+      console.log(d, t);
+      viteServer.ws.send({ type: 'full-reload' });
+    });
+
+    // this is middleware for vite's dev servert
+    fastify.addHook('onRequest', async (req, reply) => {
+      const { user } = req.session?.passport || {};
+      const { disableAuth } = req.funcs?.config || {};
+      if (!user && !disableAuth) {
+        return reply.redirect('/login');
+      }
+
+      const next = () => new Promise((resolve) => {
+        viteServer.middlewares(req.raw, reply.raw, () => resolve());
+      });
+      await next();
+    });
+    fastify.get('*', async () => { });
+    return;
+  }
+
+  // From Build
+  fastify.get('*', async (req, reply) => {
+    const { user } = req.session?.passport || {};
+    const assetsDir = '/dist';
+    if (!user) return reply.redirect('/login');
+    const stream = fs.createReadStream(`${assetsDir}/index.html`);
+    return reply.type('text/html').send(stream);
+  });
+
+  const fileSize = {};
+  async function staticFile(req, reply) {
+    const assetsDir = '/dist';
+    const filePath = path.join(root, assetsDir, req.url);
+    const ext = path.extname(filePath);
+
+    if (!fs.existsSync(filePath)) return { status: 404, message: 'not found' };
+    fileSize[filePath] = fileSize[filePath] || fs.statSync(filePath).size;
+    const mime = {
+      '.js': 'text/javascript', '.css': 'text/css', '.woff2': 'application/font-woff', '.png': 'image/png', '.svg': 'image/svg+xml', '.jpg': 'image/jpg',
+    }[ext];
+    reply.headers({ 'Cache-control': 'max-age=3600, public', 'Content-length': fileSize[filePath], 'Content-Encoding': 'identity' });
+
+    const stream = fs.createReadStream(filePath);
+    return mime ? reply.type(mime).send(stream) : stream;
+  }
+
+  fastify.get('/assets/*', staticFile);
+  fastify.get('/public/*', staticFile);
+}
+
+export default plugin;

package/server/routes/builder/controllers/cms.builder.delete.js

@@ -0,0 +1,21 @@
+import { dataDelete, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function builderDelete({ user = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.content_types' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const res = await dataDelete({
+    table: 'site.content_types', 
+    id: params.id,
+    uid: user?.uid
+  });
+
+  return { id: res.content_id, rows: [res] };
+}

package/server/routes/builder/controllers/cms.builder.get.js

@@ -0,0 +1,17 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function builderGet({ pg = pgClients.client, params = {} }) {
+
+
+  const { pk } = await getMeta({ table: 'site.content_types' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { rows, rowCount: total } = 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 { message: { total, rows }, status: 200 };
+}

package/server/routes/builder/controllers/cms.builder.list.js

@@ -0,0 +1,16 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function builderList({ pg = pgClients.client, query = {} }) {
+
+  const { pk } = await getMeta({ table: 'site.content_types' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+  const sql = `select a.content_type_id as id, a.* FROM site.content_types a
+  where ${query.content_type_id ? 'content_type_id=$1' : '1=1'}`
+
+  const { rows, rowCount: total } = await pg.query(sql, [query.content_type_id].filter((el) => el));
+
+  return { message: { total, rows }, status: 200 };
+}

package/server/routes/builder/controllers/cms.builder.post.js

@@ -0,0 +1,21 @@
+import { dataInsert, getMeta } from "@opengis/fastify-table/utils.js";
+
+export default async function builderPost(req) {
+  const { user = {}, body = {} } = req;
+
+  const { pk } = await getMeta({ table: "site.content_types" });
+
+  if (!pk) {
+    return { message: "table not found", status: 404 };
+  }
+
+  const resData = await dataInsert({
+    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] };
+}

package/server/routes/builder/controllers/cms.builder.put.js

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

package/server/routes/builder/index.mjs

@@ -0,0 +1,22 @@
+import cmsBuilderGet from './controllers/cms.builder.get.js';
+import cmsBuilderList from './controllers/cms.builder.list.js';
+import cmsBuilderPut from './controllers/cms.builder.put.js';
+import cmsBuilderPost from './controllers/cms.builder.post.js';
+import cmsBuilderDelete from './controllers/cms.builder.delete.js';
+
+export default async function route(app) {
+  // builder add
+  app.post('/cms-builder', { config: { policy: ['site'] }}, cmsBuilderPost);
+
+  // builder edit
+  app.put('/cms-builder/:id', { config: { policy: ['site'] }}, cmsBuilderPut);
+
+  // builder list
+  app.get('/cms-builder',  { config: { policy: ['site'] }}, cmsBuilderList);
+
+  // builder get
+  app.get('/cms-builder/:id', { config: { policy: ['site'] }}, cmsBuilderGet);
+
+  // builder delete
+  app.delete('/cms-builder/:id', { config: { policy: ['site'] }}, cmsBuilderDelete);
+}

package/server/routes/category/controllers/cms.category.delete.js

@@ -0,0 +1,21 @@
+import { dataDelete, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function categoryDelete({ user = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const res = await dataDelete({
+    table: 'site.categories', 
+    id: params.id,
+    uid: user?.uid
+  });
+
+  return { id: res.category_id, rows: [res] };
+}

package/server/routes/category/controllers/cms.category.get.js

@@ -0,0 +1,17 @@
+import { pgClients, getMeta, getTemplate } from '@opengis/fastify-table/utils.js';
+
+export default async function categoryGet({ pg = pgClients.client, params = {} }) {
+
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { rows, rowCount: total } = await pg.query(
+    `select a.category_id as id, a.* FROM site.categories a
+   where a.category_id=$1`,
+    [params.id]
+  );
+  return { message: { total, rows }, status: 200 };
+}

package/server/routes/category/controllers/cms.category.list.js

@@ -0,0 +1,16 @@
+import { pgClients, getTemplate, getMeta }  from '@opengis/fastify-table/utils.js';
+
+export default async function categoryList({ pg = pgClients.client, query = {} }) {
+
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+  const sql = `select a.category_id as id, a.* FROM site.categories a
+  where ${query.category_id ? 'category_id=$1' : '1=1'}`
+
+  const { rows, rowCount: total } = await pg.query(sql, [query.category_id].filter((el) => el));
+
+  return { message: { total, rows }, status: 200 };
+}

package/server/routes/category/controllers/cms.category.post.js

@@ -0,0 +1,21 @@
+import { dataInsert, getMeta } from "@opengis/fastify-table/utils.js";
+
+export default async function categoryPost(req) {
+  const { user = {}, body = {} } = req;
+
+  const { pk } = await getMeta({ table: "site.categories" });
+
+  if (!pk) {
+    return { message: "table not found", status: 404 };
+  }
+
+  const resData = await dataInsert({
+    table: "site.categories",
+    data: body,
+    uid: user?.uid,
+  });
+//   console.log(resData);
+  const res = resData?.rows[0];
+
+  return { id: res.category_id, rows: [res] };
+}

package/server/routes/category/controllers/cms.category.put.js

@@ -0,0 +1,23 @@
+import { dataUpdate, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function categoryPut({ body = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.categories' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const resData = await dataUpdate({
+    table: 'site.categories', 
+    data: body, 
+    id: params.id,
+  });
+//   console.log(resData)
+  const res = resData;
+
+  return { id: res.category_id, rows: [res] };
+}

package/server/routes/category/index.mjs

@@ -0,0 +1,22 @@
+import cmsCategoryGet from './controllers/cms.category.get.js';
+import cmsCategoryList from './controllers/cms.category.list.js';
+import cmsCategoryPut from './controllers/cms.category.put.js';
+import cmsCategoryPost from './controllers/cms.category.post.js';
+import cmsCategoryDelete from './controllers/cms.category.delete.js'
+
+export default async function route(app) {
+  // category add
+  app.post('/cms-category', {}, cmsCategoryPost);
+
+  // category edit
+  app.put('/cms-category/:id', {}, cmsCategoryPut);
+
+  // category list
+  app.get('/cms-category', {  config: { policy: ['site'] }}, cmsCategoryList);
+
+  // category get
+  app.get('/cms-category/:id', {}, cmsCategoryGet);
+
+  // category delete
+  app.delete('/cms-category/:id', {  config: { policy: ['site'] }}, cmsCategoryDelete);
+}

package/server/routes/manager/controllers/cms.manager.delete.js

@@ -0,0 +1,22 @@
+import { dataDelete, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function managerDelete({ user = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.contents' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const res = await dataDelete({
+    table: 'site.contents', 
+    id: params.id,
+    uid: user?.uid
+  });
+
+
+  return { id: res.content_id, rows: [res] };
+}

package/server/routes/manager/controllers/cms.manager.get.js

@@ -0,0 +1,21 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function managerGet({ pg = pgClients.client, params = {} }) {
+
+  if (!params.template && params.id) return { message: 'bad request', status: 400 }
+
+  const { pk } = await getMeta({ table: 'site.contents' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { rows, rowCount: total } = await pg.query(
+    `select a.content_id as id, a.* FROM site.contents a
+   where template=$1 and content_id=$2`, [params.template, params.id]
+  );
+
+  const { rows: type } = await pg.query(`select name, template, description, type from site.content_types where template=$1`, [params.template])
+
+  return { message: { total, rows, type: type[0] }, status: 200 };
+}

package/server/routes/manager/controllers/cms.manager.list.js

@@ -0,0 +1,31 @@
+import { pgClients, getMeta } from '@opengis/fastify-table/utils.js';
+
+const types = {
+  enabled: 'Switcher'
+};
+
+export default async function builderList({ pg = pgClients.client, params = {} }) {
+  if (!params.template) {
+    return { message: 'not enougn params: template', status: 400 }
+  }
+
+  if (!pg.pk?.['site.contents']) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const { columns = [] } = await getMeta({ table: 'site.contents' });
+
+  const { rows, rowCount: total } = await pg.query(
+    `select a.content_id as id, a.* FROM site.contents a
+   where template=$1`, [params.template]
+  );
+
+  const { rows: type } = await pg.query(`select name, template, description, type, columns from site.content_types where template=$1`, [params.template])
+
+  const columns1 = (type[0]?.columns || []).concat(
+    columns
+      .filter(el => !['cdate', 'editor_date', 'uid', 'editor_date'].includes(el.name))
+      .map(({ title, name }) => ({ title, name, type: types[name] || 'Text' }))
+  );
+  return { message: { total, rows, type: type[0], columns: columns1 }, status: 200 };
+}

package/server/routes/manager/controllers/cms.manager.post.js

@@ -0,0 +1,28 @@
+import { dataInsert, getMeta } from "@opengis/fastify-table/utils.js";
+
+export default async function builderPost(req) {
+  const { user = {}, params= {}, body = {} } = req;
+
+  if (!params.template) return { message: 'bad request', status: 400 }
+  
+  const { pk } = await getMeta({ table: "site.contents" });
+
+  if (!pk) {
+    return { message: "table not found", status: 404 };
+  }
+
+  const bodyModified = Object.assign(body, {
+    template: params.template
+  });
+
+    
+  const resData = await dataInsert({
+    table: "site.contents",
+    data: bodyModified,
+    uid: user?.uid,
+  });
+//   console.log(resData);
+  const res = resData?.rows[0];
+
+  return { id: res.content_id, rows: [res] };
+}

package/server/routes/manager/controllers/cms.manager.put.js

@@ -0,0 +1,23 @@
+import { dataUpdate, getMeta } from '@opengis/fastify-table/utils.js';
+
+export default async function managerPut({ body = {}, params = {} }) {
+
+  if (!params.id) {
+    return { message: 'id is required', status: 400 };
+  }
+  const { pk } = await getMeta({ table: 'site.contents' });
+
+  if (!pk) {
+    return { message: 'table not found', status: 404 };
+  }
+
+  const resData = await dataUpdate({
+    table: 'site.contents', 
+    data: body, 
+    id: params.id,
+  });
+  // console.log(resData)
+  const res = resData;
+
+  return { id: res.content_id, rows: [res] };
+}