@opengis/admin 0.1.0

package/server/plugins/hook.js

@@ -0,0 +1,94 @@
+import fp from 'fastify-plugin';
+
+import fs from 'fs';
+import path from 'path'
+
+import config from '../../config.js';
+
+
+
+// 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 (['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,64 @@
+import fs from 'fs';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const dir = dirname(fileURLToPath(import.meta.url));
+const root = `${dir}/../..`;
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+async function plugin(fastify) {
+  // vite server
+  if (!isProduction) {
+    const vite = await import('vite');
+    const viteDevMiddleware = (
+      await vite.createServer({
+        server: {
+          middlewareMode: true,
+        },
+      })
+    ).middlewares;
+
+    // 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.send('access restricted');
+      }
+
+      const next = () => new Promise((resolve) => {
+        viteDevMiddleware(req.raw, reply.raw, () => resolve());
+      });
+      await next();
+    });
+    fastify.get('*', async () => { });
+    return;
+  }
+
+  // From Build
+  fastify.get('*', async (req, reply) => {
+    const { user } = req.session?.passport || {};
+
+    // if (!user) return reply.redirect('/login');
+    const stream = fs.createReadStream('dist/index.html');
+    return reply.type('text/html').send(stream);
+  });
+
+  async function staticFile(req, reply) {
+    const assetsDir = 'dist';
+    const filePath = path.join(root, assetsDir, req.url);
+    const ext = path.extname(filePath);
+    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' });
+    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/data/controllers/cardData.js

@@ -0,0 +1,30 @@
+import getTemplate from "../../templates/funcs/getTemplate.js";
+// import yaml from 'js-yaml';
+import getTableData from "./tableData.js";
+
+export default async function getCardData({
+    pg, funcs, params = {}, session = {},
+}) {
+    const { table, id } = params;
+    const time = Date.now();
+
+    const template = await getTemplate('card', table);
+
+    const tableTemplate = await getTemplate('table', table);
+    const index = template.find(el => el[0] === 'index.yml')?.[1] || {}
+    //return template
+
+    const data = {};
+    const { message, rows = [] } = await getTableData({ pg, funcs, params: { table, id }, session });
+
+    if (message) return { message };
+
+    await Promise.all(template.filter(el => el[0].includes('.hbs')).map(async (el) => {
+        const htmlContent = await funcs.handlebars.compile(el[1])(rows[0]);
+        const name = el[0].substring(0, el[0].lastIndexOf('.'))
+        data[name] = htmlContent;
+    }));
+
+    return { time: Date.now() - time, ...index, data, rows, columns: tableTemplate?.columns || tableTemplate?.colModel };
+
+}

package/server/routes/data/controllers/metaFormat/getSelectVal.js

@@ -0,0 +1,19 @@
+import getTemplate from "../../../templates/funcs/getTemplate.js";
+
+export default async function getSelectVal({ pg, redis, name, values }) {
+  const cls = await getTemplate(['select', 'cls'], name);
+  if (!cls) return;    
+  if ((Array.isArray(cls) && !cls?.length) && !cls?.sql) return null;
+  const key = `select:${name}`;
+  const cache = !Array.isArray(cls) ? (await redis.hmget(key, values)).reduce((p, el, i) => ({ ...p, [values[i]]: el }), {}) : {};
+
+  const data = Array.isArray(cls) ? cls : (values.filter(el => !cache[el]).length
+    ? await pg.query(`with c(id,text) as (${cls.sql}) select * from c where id = any('{${values.filter(el => !cache[el])}}')`).then(el => el.rows)
+    : []);
+
+  const clsAr = { ...cache, ...data.reduce((p, el) => ({ ...p, [el.id.toString()]: el.color ? el : el.text }), {}) };
+  if (!cls.arr && data.length) {
+    redis.hmset(key, clsAr);
+  }
+  return clsAr;
+}

package/server/routes/data/controllers/metaFormat/index.js

@@ -0,0 +1,29 @@
+import getTemplate from "../../../templates/funcs/getTemplate.js";
+import getSelectVal from './getSelectVal.js';
+
+export default async function metaFormat({ funcs, rows, table }) {
+  const loadTable = await getTemplate('table', table);
+  const selectCols = loadTable?.colModel?.filter((e) => e.name && e.option).map((el) => ({ ...el, data: el.option }))
+    .concat(loadTable?.columns?.filter((e) => e.data) || []);
+  const metaCls = Object.keys(loadTable?.meta?.cls || {}).map((el) => ({ name: el, data: loadTable?.meta?.cls[el] }));
+  if (!selectCols?.length && !metaCls?.length) return rows;
+
+  const pg = funcs.getPG();
+  const redis = funcs.getRedis();
+
+  // cls & select format
+  await Promise.all(selectCols.concat(metaCls)?.map(async (attr) => {    
+    const values = [...new Set(rows?.map((el) => el[attr.name]).flat())].filter((el) => el);
+    if (!values.length) return null;
+      const cls = await getSelectVal({ pg, redis, name: attr.data, values });
+    if (!cls) return null;
+    rows.forEach(el => {
+      const val = el[attr.name]?.map?.(c => cls[c] || c) || cls[el[attr.name]] || el[attr.name];
+      if (!val) return;
+      Object.assign(el, { [val?.color ? `${attr.name}_data` : `${attr.name}_text`]: (val.color ? val : val.text || val) });
+    });
+    return null;
+  }));
+
+  return rows;
+}

package/server/routes/data/controllers/tableData.js

@@ -0,0 +1,129 @@
+import getTemplate from "../../templates/funcs/getTemplate.js";
+
+import getMeta from "@opengis/fastify-table/pg/funcs/getMeta.js";
+import getAccess from "@opengis/fastify-table/crud/funcs/getAccess.js";
+import setToken from "@opengis/fastify-table/crud/funcs/setToken.js";
+import getFilterSQL from "@opengis/fastify-table/table/funcs/getFilterSQL/index.js";
+import gisIRColumn from "@opengis/fastify-table/table/controllers/utils/gisIRColumn.js";
+import metaFormat from "./metaFormat/index.js";
+
+const maxLimit = 100;
+
+export default async function getTableData(req) {
+    const time = Date.now();
+
+    const {
+        pg, params, funcs = {}, query = {}, opt = {}, session = {},
+    } = req;
+    const { uid } = session.passport?.user || {};
+
+    try {
+        const loadTable = await getTemplate('table', params.table);
+
+        if (!loadTable) {
+            return { message: 'template not found', status: 404 };
+        }
+
+        const {
+            table,  sql, cardSql, filter_list: filters, form, meta, sqlColumns, ispublic,
+        } = loadTable;
+        const columns = loadTable.columns || loadTable.colModel;
+
+        const { pk, columns: dbColumns = [] } = await getMeta(table);
+
+        if (!pk) {
+            return { message: `table not found: ${table}`, status: 404 };
+        }
+
+        const cols = columns.filter((el) => el.name !== 'geom').map((el) => el.name || el).join(',');
+
+        const metaCols = Object.keys(loadTable?.meta?.cls || {}).filter((el) => !cols.includes(el)).length
+            ? `,${Object.keys(loadTable?.meta?.cls || {})?.filter((el) => !cols.includes(el)).join(',')}`
+            : '';
+
+        const columnList = dbColumns.map((el) => el.name || el).join(',');
+
+        const sqlTable = sql?.filter?.((el) => !el?.disabled && el?.sql?.replace).map((el, i) => ` left join lateral (${el.sql.replace('{{uid}}', uid)}) ${el.name || `t${i}`} on 1=1 `)?.join('') || '';
+
+        const cardSqlFiltered = opt?.id || params.id ? (cardSql?.filter?.((el) => !el?.disabled && el?.name && el?.sql?.replace) || []) : [];
+        const cardSqlTable = cardSqlFiltered.length ? cardSqlFiltered.map((el, i) => ` left join lateral (select json_agg(row_to_json(q)) as ${el.name} from (${el.sql})q) ct${i}  on 1=1 `).join('') || '' : '';
+
+        if (params.id && columnList.includes(params.id)) {
+            return gisIRColumn({
+                pg, funcs, layer: params.table, column: params.id, sql: query.sql,
+            });
+        }
+
+        const fData = query.filter || query.search ? await getFilterSQL({
+            filter: query.filter,
+            search: query.search,
+            table: params.table,
+            json: 1,
+        }) : {};
+
+        const keyQuery = query.key && loadTable.key && !(opt?.id || params.id) ? `${loadTable.key}=$1` : null;
+
+        const limit = Math.min(maxLimit, +(query.limit || 20));
+
+        const offset = query.page && query.page > 0 ? ` offset ${(query.page - 1) * limit}` : '';
+        // id, query, filter
+        const [orderColumn, orderDir] = (query.order || loadTable.order || '').split(/[- ]/);
+
+        const order = columnList.includes(orderColumn) && orderColumn?.length ? `order by ${orderColumn} ${query.desc || orderDir === 'desc' ? 'desc' : ''}` : '';
+
+        const state = loadTable.filterState && query.state ? loadTable.filterState[query.state]?.sql : null;
+
+        const custom = loadTable.filterCustom && query.custom ? loadTable.filterCustom[query.custom]?.sql : null;
+
+        const search = loadTable.meta?.search && query.search ? `(${loadTable.meta?.search.split(',').map(el => `${el} ilike '%${query.search}%'`).join(' or ')})` : null;
+
+        const queryBbox = query?.bbox ? query.bbox.replace(/ /g, ',').split(',')?.map((el) => el - 0) : [];
+
+        const queryPolyline = meta?.bbox && query?.polyline ? `ST_Contains(ST_MakePolygon(ST_LineFromEncodedPolyline('${query?.polyline}')),${meta.bbox})` : undefined;
+
+        const bbox = meta?.bbox && queryBbox.filter((el) => !Number.isNaN(el))?.length === 4 ? `${meta.bbox} && 'box(${queryBbox[0]} ${queryBbox[1]},${queryBbox[2]} ${queryBbox[3]})'::box2d ` : undefined;
+
+        const access = await getAccess(req, params.table);
+
+        const where = [(opt?.id || params.id ? ` "${pk}" = $1` : null), keyQuery, loadTable.query, fData.q, state, custom, search, access?.query || '1=1', bbox, queryPolyline].filter((el) => el);
+
+        const cardColumns = cardSqlFiltered.length ? `,${cardSqlFiltered.map((el) => el.name)}` : '';
+        const q = `select  ${pk ? `"${pk}" as id,` : ''} ${columnList.includes('geom') ? 'st_asgeojson(geom)::json as geom,' : ''} ${query.id || query.key ? '*' : sqlColumns || cols || '*'} ${metaCols} ${cardColumns} from ${table} t ${sqlTable} ${cardSqlTable} where ${where.join(' and ') || 'true'} ${order} ${offset}  limit ${limit}`;
+
+        if (query.sql === '1') { return { message: q }; }
+
+        const { rows } = await pg.query(q, (opt?.id || params.id ? [opt?.id || params.id] : null) || (query.key && loadTable.key ? [query.key] : []));
+
+        const total = keyQuery || opt?.id || params.id ? rows.length : await pg.queryCache(`select count(*) from ${table} t ${sqlTable} where ${where.join(' and ') || 'true'}`).then((el) => (el?.rows[0]?.count || 0) - 0);
+
+        await metaFormat({ funcs, rows, table: params.table });
+
+        const res = {
+            time: Date.now() - time, card: loadTable.card, actions: loadTable.actions, access, total, count: rows.length, pk, form, rows, meta, columns, filters,
+        };
+
+        if (!funcs.config?.security?.disableToken) {
+            const addTokens = setToken({
+                ids: [JSON.stringify({ add: loadTable.table, form: loadTable.form })],
+                mode: 'a',
+                uid: funcs.config?.auth?.disable || ispublic ? '1' : uid,
+                array: 1,
+            });
+            Object.assign(res, { addToken: addTokens[0] });
+
+            rows.forEach((row) => {
+                const editTokens = setToken({
+                    ids: [JSON.stringify({ id: row.id, table: loadTable.table, form: loadTable.form })],
+                    mode: 'w',
+                    uid: funcs.config?.auth?.disable || ispublic ? '1' : uid,
+                    array: 1,
+                });
+                Object.assign(row, { token: editTokens[0] });
+            });
+        }
+
+        return res;
+    } catch (err) {
+        return { message: err.toString(), status: 500 };
+    }
+}

package/server/routes/data/controllers/tableDataId.js

@@ -0,0 +1,28 @@
+import getTemplate from "../../templates/funcs/getTemplate.js";
+import getTableData from "./tableData.js";
+
+export default async function tableDataId({
+    pg, funcs, params = {}, session = {},
+}, reply) {
+    const { name, id } = params;
+
+    const data = await getTemplate('pt', `${name}.pt`);
+
+
+    if (!data) {
+        return { message: `invalid template: ${name}.pt`, status: 400 };
+    }
+
+    const { message, status = 500, rows = [] } = await getTableData({ pg, params: { name, id }, session });
+    if (message) {
+        return { message, status };
+    }
+
+    if (!rows.length) {
+        return { message: `data not found: ${name}/${id}`, status: 404 };
+    }
+
+    const htmlContent = await funcs.handlebars.compile(data)(rows[0]);
+
+    return reply.headers({ 'Content-Type': 'text/html; charset=utf-8' }).send(htmlContent);
+}

package/server/routes/data/controllers/tableFilter.js

@@ -0,0 +1,51 @@
+import getTemplate from '../../templates/funcs/getTemplate.js';
+
+export default async function tableFilter(req) {
+    const time = Date.now();
+    const { pg, funcs = {}, params = {}, query = {} } = req;
+
+    if (!params.name) {
+        return { message: 'not enouggh params: name', status: 400 };
+    }
+
+
+
+
+    const loadTable = await getTemplate('table', params.name);
+
+    if (!loadTable) {
+        return { message: 'table not found', status: 404 };
+    }
+
+    const { columns } = await funcs.getMeta({ table: loadTable.table });
+
+    const filters = loadTable?.filter_list || loadTable?.filters || loadTable?.filterList || [];
+    filters.forEach(el => {
+        Object.assign(el, { id: el.name });
+    })
+    await Promise.all(filters.filter((el) => el.data).map(async (el) => {
+
+        const cls = await getTemplate(['cls', 'select'], el.data)
+
+
+        if (!cls?.length || !Array.isArray(cls) || !loadTable.table) return;
+        const { dataTypeID } = columns.find((item) => item.name === el.name) || {};
+        const countArr = pg.pgType[dataTypeID]?.includes('[]')
+            ? await pg.queryCache(`select unnest(${el.name})::text as id,count(*) from ${loadTable.table} group by unnest(${el.name})`)
+            : await pg.queryCache(`select ${el.name}::text as id,count(*) from ${loadTable.table} group by ${el.name}`);
+
+        const options = countArr.rows.map(cel => {
+            const data = cls.find(c => c.id === cel.id);
+            return { ...cel, ...data };
+        });
+        Object.assign(el, { options });
+    }));
+
+    return {
+        time: Date.now() - time,
+        list: filters,
+        custom: loadTable?.filterCustom?.map(el => ({ label: el.label })),
+        inline: loadTable?.filterInline,
+        state: loadTable?.filterState?.map(el => ({ label: el.label })),
+    };
+}

package/server/routes/data/index.mjs

@@ -0,0 +1,10 @@
+import tableData from "./controllers/tableData.js";
+import tableDataId from "./controllers/tableDataId.js";
+import cardData from "./controllers/cardData.js";
+import tableFilter from "./controllers/tableFilter.js";
+
+export default async function route(fastify) {
+    fastify.get(`/table-data/:table`, tableData);
+    fastify.get(`/table-data/:table/:id`, cardData);
+    fastify.get(`/table-filter/:name`, tableFilter);
+}

package/server/routes/menu/controllers/getMenu.js

@@ -0,0 +1,50 @@
+import { readdir, readFile } from 'fs/promises';
+import { join } from 'path';
+import config from '../../../../config.js';
+
+const findMenuJsons = async (startPath, filter) => {
+    const files = await readdir(startPath, { withFileTypes: true });
+
+    return await files.reduce(async (prevPromise, file) => {
+        const acc = await prevPromise;
+        const filePath = join(startPath, file.name);
+
+        if (file.isDirectory()) {
+            const nestedFiles = await findMenuJsons(filePath, filter);
+            return acc.concat(nestedFiles);
+        } else if (file.name === filter) {
+            acc.push(filePath);
+        }
+
+        return acc;
+    }, Promise.resolve([]));
+
+}
+
+const readJsonFiles = async (filePaths) => {
+    const menu = []
+    await Promise.all(
+        filePaths.map(async (filePath) => {
+            const content = JSON.parse(await readFile(filePath, 'utf-8'));
+            content.forEach(el => {
+                menu.push(el)
+            });
+
+
+        })
+    );
+    return menu;
+}
+
+export default async function adminMenu() {
+    const cwd = process.cwd();
+    //const typeDir = join(cwd, (config.templateDir || 'server/templates'));
+    const modulesDir = join(cwd, 'module');
+
+    // const menus = await findMenuJsons(typeDir, 'menu.json');
+    const menuModules = await findMenuJsons(modulesDir, 'menu.json');
+
+    const jsons = await readJsonFiles(menuModules);
+
+    return jsons;
+}

package/server/routes/menu/index.mjs

@@ -0,0 +1,5 @@
+import adminMenu from './controllers/getMenu.js';
+
+export default async function (fastify, opts) {
+  fastify.get(`/user-menu`, adminMenu);
+}

package/server/routes/root.mjs

@@ -0,0 +1,3 @@
+export default async function (fastify, opts) {
+  fastify.get(`/test`, () => { return { test: true } });
+}

package/server/routes/templates/controllers/getTemplate.js

@@ -0,0 +1,9 @@
+import getTemplate from "../funcs/getTemplate.js"
+
+export default async function getTemplateApi({
+    params = {},
+}) {
+    const { type, name } = params;
+    const data = await getTemplate(type, name);
+    return data || { message: `template not found "${name}"`, status: 404 };
+}

package/server/routes/templates/funcs/addTempateFolder.js

@@ -0,0 +1,47 @@
+import path from 'path';
+import { statSync, existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+
+import loadTemplate from './loadTemplate.js';
+
+export default async function addTempateFolder(dir) {
+    if (!existsSync(dir)) {
+        throw new Error(`dir not found: ${dir}`);
+    }
+    const subdirs = (await readdir(dir, { withFileTypes: true }))?.filter((dirent) => statSync(path.join(dirent.path, dirent.name)).isDirectory());
+    await Promise.all(subdirs.map(async (dirent) => {
+        const content = dirent.name !== 'card' ? await readdir(path.join(dirent.path, dirent.name), { withFileTypes: true }) : [];
+        loadTemplate[dirent.name] = loadTemplate[dirent.name] || {};
+        const files = content?.filter((el) => !statSync(path.join(el.path, el.name)).isDirectory());
+        await Promise.all(files?.map(async (el) => {
+            const data = await readFile(path.join(el.path, el.name), 'utf-8');
+
+            if (['select', 'interface'].includes(dirent.name) && path.extname(el.name) === '.json') {
+                loadTemplate[dirent.name][el.name.replace(path.extname(el.name), '.setting')] = JSON.parse(data);
+                return;
+            }
+
+            loadTemplate[dirent.name][el.name.replace(path.extname(el.name), '')] = path.extname(el.name) === '.json' ? JSON.parse(data) : data;
+        }));
+        console.log(dir, dirent.name, files.map((el) => el.name));
+    }));
+    const carddir = subdirs.find((el) => el.name === 'card');
+    const cardSubdirs = carddir ? (await readdir(path.join(carddir.path, carddir.name), { withFileTypes: true }))?.filter((dirent) => statSync(path.join(dirent.path, dirent.name)).isDirectory()) : [];
+
+    await Promise.all(cardSubdirs.map(async (dirent) => {
+        const content = await readdir(path.join(dirent.path, dirent.name), { withFileTypes: true });
+        const files = content?.filter((el) => !statSync(path.join(el.path, el.name)).isDirectory());
+        loadTemplate['card'] = loadTemplate['card'] || {};
+        await Promise.all(files?.map(async (el) => {
+            loadTemplate['card'][dirent.name] = loadTemplate['card'][dirent.name] || {};
+            const data = await readFile(path.join(el.path, el.name), 'utf-8');
+            if (path.extname(el.name) === '.yml') {
+                loadTemplate['card'][dirent.name]['config'] = data;
+            } else {
+                loadTemplate['card'][dirent.name][path.parse(el.name).name] = data;
+            }
+        }));
+        console.log('card', dir, dirent.name, files.map((el) => el.name));
+    }));
+    console.log(dir, 'finish');
+}

package/server/routes/templates/funcs/getTemplate.js

@@ -0,0 +1,70 @@
+import { readdir, readFile } from 'fs/promises';
+import path from 'path';
+import yaml from 'js-yaml';
+
+import getTemplatePath from './getTemplatePath.js';
+import loadTemplate from './loadTemplate.js';
+
+
+async function readFileData(file) {
+    const data = await readFile(file, 'utf-8');
+    const ext = file.substring(file.lastIndexOf('.') + 1);
+
+    if (ext === 'yml') {
+        return yaml.load(data);
+    }
+    if (ext === 'json') {
+        return JSON.parse(data);
+    }
+    return data;
+};
+
+const isProduction = process.env.NODE_ENV === 'production';
+
+async function getTemplateData(template) {
+
+    // dir template: dashboard, card  
+    if (template[0][3]) {
+        const files = await readdir(template[0][1]);
+        const data = await Promise.all(files.map(async el => readFileData(path.join(template[0][1], el))))
+        return files.map((el, i) => [el, data[i]])
+    }
+
+    // one file template: table, form
+    if (template.length === 1) {
+        const data = await readFileData(template[0][1])
+        return data
+    }
+
+    // multi file template: select, etc 
+    if (template.length > 1) {
+        const data = await Promise.all(template.map(async el => await readFileData(el[1])))
+        const result = {}
+        template.forEach((el, i) => {
+            Object.assign(result, typeof data[i] === 'object' ? data[i] : { [el[2]]: data[i] })
+        })
+        return result
+    }
+}
+export default async function getTemplate(type, name) {
+    if (!type) return null;
+    if (!name) return null;
+
+    const key = type + ':' + name;
+    if (name === 'cache' && !isProduction) return loadTemplate;      // all cache debug   
+    if (loadTemplate[key] && isProduction) return loadTemplate[key]; // from cache
+
+    // type one or multi 
+    const templateList = Array.isArray(type) ?
+        type.map(el => getTemplatePath(el)).filter(list => list?.filter(el => el[0] === name).length)[0] || [] :
+        getTemplatePath(type);
+
+    // find template 
+    const template = templateList?.filter(el => el[0] === name)
+    if (name === 'list' && !isProduction) return templateList; // all template debug   
+
+    if (!template.length) return null; // not found
+
+    loadTemplate[key] = await getTemplateData(template);
+    return loadTemplate[key];
+}