@opengis/fastify-table 1.4.8 → 1.4.10

package/config.js

@@ -10,6 +10,7 @@ const config = fileName ? JSON.parse(readFileSync(fileName)) : {};
 // npm run dev === cross-env NODE_ENV=development
 // alt: node --env=development
 Object.assign(config, {
+  storageList: {},
   allTemplates: config?.allTemplates || {},
   skipCheckPolicyRoutes: [],
   env: process.env?.NODE_ENV || process.argv[2]?.split?.('=')?.pop?.(),

package/index.js

@@ -112,6 +112,11 @@ async function plugin(fastify, opt) {
   menuRoutes(fastify, opt);
   templatesRoutes(fastify, opt);
 
+  // from fastify-file
+  fastify.register(import('./server/routes/file/index.mjs'), opt);
+  fastify.register(import('./server/routes/grpc/index.mjs'), opt);
+  await fastify.register(import('@fastify/multipart')); // file upload
+
   fastify.get('/api/test-proxy', {}, (req) => ({ ...req.headers || {}, sessionId: req.session?.sessionId }));
   fastify.get('/api/config', { config: { policy: ['admin', 'site'] } }, () => config);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/fastify-table",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "type": "module",
   "description": "core-plugins",
   "keywords": [
@@ -26,14 +26,20 @@
     "test:routes": "node --test .\\test\\routes",
     "test:functions": "node --test .\\test\\functions",
     "compress": "node compress.js",
-    "dev": "cross-env NODE_ENV=development node server.js"
+    "dev": "set NODE_ENV=development&& node server.js"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "3.554.0",
     "@fastify/http-proxy": "11.1.2",
+    "@fastify/multipart": "9.0.3",
+    "@grpc/grpc-js": "1.10.6",
+    "@grpc/proto-loader": "0.7.12",
     "dotenv": "16.5.0",
     "fastify": "5.3.3",
     "fastify-plugin": "5.0.1",
+    "formidable": "3.5.1",
     "handlebars": "4.7.8",
+    "image-size": "1.2.0",
     "ioredis": "5.3.2",
     "js-yaml": "4.1.0",
     "markdown-it": "14.1.0",
@@ -45,7 +51,6 @@
     "uglify-js": "3.19.3"
   },
   "devDependencies": {
-    "cross-env": "7.0.3",
     "eslint": "8.49.0",
     "eslint-config-airbnb": "19.0.4"
   },

package/server/plugins/file/downloadFile.js

@@ -0,0 +1,18 @@
+import path from 'path';
+import providers from './providers/index.js';
+
+async function downloadFile(filePath, options = {}) {
+  if (!filePath) return null;
+  const filename = path.basename(filePath);
+
+  // prefix
+  const prefix = (options.prefix === 'date' ? new Date().toISOString().split('T')[0] : null)
+    || (options.prefix === '3s' ? filename.substring(0, 3) : '');
+
+  const relativePath = path.join(path.dirname(filePath), prefix, filename);
+
+  const fp = providers(options);
+  return fp.downloadFile(relativePath, options);
+}
+
+export default downloadFile;

package/server/plugins/file/getExport.js

@@ -0,0 +1,38 @@
+import routeExport from '../../routes/file/controllers/export.js';
+
+export default async function getExport({
+    pg,
+    user,
+    host,
+    unittest,
+    columns,
+    cls,
+    id,
+    cols,
+    search,
+    format,
+    table,
+    tableSql,
+    sourceName,
+    filter,
+    nocache,
+    formatAnswer,
+    sql,
+}, reply) {
+    const query = {
+        id,
+        cols,
+        search,
+        format,
+        table,
+        filter,
+        nocache,
+        formatAnswer,
+        sql,
+    };
+    const result = await routeExport({
+        pg, user, host, unittest, columns, cls, query, tableSql, sourceName,
+    }, reply);
+
+    return result;
+}

package/server/plugins/file/isFileExists.js

@@ -0,0 +1,17 @@
+import path from 'path';
+import providers from './providers/index.js';
+
+async function isFileExists(filePath, options = { }) {
+  const filename = path.basename(filePath);
+
+  // prefix
+  const prefix = (options.prefix === 'date' ? new Date().toISOString().split('T')[0] : null)
+    || (options.prefix === '3s' ? filename.substring(0, 3) : '');
+
+  const relativePath = path.join(path.dirname(filePath), prefix, filename);
+
+  const fp = providers(options);
+  return fp.fileExists(relativePath, options);
+}
+
+export default isFileExists;

package/server/plugins/file/providers/fs.js

@@ -0,0 +1,100 @@
+import fs from 'node:fs';
+
+import fsp from 'node:fs/promises';
+
+import path from 'node:path';
+import isFileExists from '../utils/isFileExists.js';
+
+import isBuffer from './utils/typeguards/isBuffer.js';
+import isReadableStream from './utils/typeguards/isReadableStream.js';
+
+import getValidData from './utils/getValidData.js';
+import dataTypes from './utils/handlers/dataTypes.js';
+
+import getPath from '../utils/getPath.js';
+
+const deleteFile = () => async (fp) => {
+  const filepath = getPath(fp);
+  if (!await isFileExists(filepath)) {
+    throw new Error('Файл не знайдено');
+  }
+  await fsp.rm(filepath);
+};
+
+const moveFile = () => async (fp, destFilepath) => {
+  const filepath = getPath(fp);
+  if (!await isFileExists(filepath)) {
+    throw new Error('Файл не знайдено');
+  }
+  await fsp.mkdir(path.dirname(filepath), { recursive: true });
+  await fsp.mkdir(path.dirname(destFilepath), { recursive: true });
+
+  await fsp.copyFile(filepath, destFilepath, fs.constants.COPYFILE_FICLONE);
+  await fsp.deleteFile(filepath);
+};
+
+const downloadFile = () => async (fp, options = {}) => {
+  const filepath = getPath(fp, options);
+  if (options.debug) {
+    return { original: fp, full: filepath };
+  }
+  if (!await isFileExists(filepath, options)) {
+    return null;
+  }
+  if (options.buffer) {
+    // const test = await readFile(filepath);
+    return fsp.readFile(filepath);
+  }
+  const fileStream = fs.createReadStream(filepath);
+  return fileStream;
+};
+
+const fileExists = () => async (filepath, opt = {}) => isFileExists(getPath(filepath, opt), opt);
+
+const uploadFile = () => async (fp, data, opt = {}) => {
+  const filepath = getPath(fp, opt);
+  const validData = await getValidData({ data, types: [dataTypes.buffer, dataTypes.path, dataTypes.stream] });
+  // const validData = data;
+  await fsp.mkdir(path.dirname(filepath), { recursive: true });
+  try {
+    const exists = await isFileExists(validData);
+
+    if (!exists) {
+      await fsp.writeFile(filepath, validData, opt);
+    }
+    else if (isBuffer(validData) || isReadableStream(validData)) {
+      await fsp.writeFile(filepath, validData, opt);
+    }
+    else {
+      await fsp.copyFile(validData, filepath);
+    }
+    return filepath;
+  }
+  catch (err) {
+    // console.log(err.toString());
+
+    throw new Error(`Can't upload a file ${err.toString()}`);
+  }
+};
+
+const stat = () => async (filepath) => fsp.stat(getPath(filepath));
+
+const getFileSize = () => async (filepath) => (await fsp.stat(getPath(filepath))).size;
+
+const getMDate = () => async (filepath) => new Date((await fsp.stat(getPath(filepath))).mtime);
+
+const readdir = () => async (filepath) => fsp.readdir(getPath(getPath(filepath)));
+
+export default function fsStorage(opt) {
+  return {
+    deleteFile: deleteFile(opt),
+    downloadFile: downloadFile(opt),
+    uploadFile: uploadFile(opt),
+    fileExists: fileExists(opt),
+    stat: stat(opt),
+    moveFile: moveFile(opt),
+    getFileSize: getFileSize(opt),
+    getMDate: getMDate(opt),
+    readdir: readdir(opt),
+  };
+}

package/server/plugins/file/providers/index.d.ts

@@ -0,0 +1,49 @@
+import { Readable } from 'stream';
+
+interface IListElement {
+  login?: string;
+  password?: string;
+  endpoint?: string;
+  containerName?: string;
+  accessKeyId?: string;
+  secretAccessKey?: string;
+}
+
+interface IList {
+  [key: string]: IListElement;
+}
+
+interface IArgs {
+  name: string;
+  list: IList;
+}
+
+interface IUploadArgs {
+  filepath: string;
+  data: string | Buffer | ReadableStream;
+}
+
+interface IInputArgs {
+  filepath: string;
+}
+
+interface IObjects {
+  Key: string
+}
+
+interface IDownloadOptions {
+  buffer: boolean
+}
+
+interface Ifuncs {
+  deleteFile: (filepath: string) => Promise<any>;
+  downloadFile: (filepath: string, options: IDownloadOptions) => Promise<Readable | Buffer>;
+  uploadFile: (opt: IUploadArgs) => Promise<any>;
+  moveFile: (filepath: string, destFilepath: string) => Promise<any>;
+  fileExists: (filepath: string) => Promise<boolean>;
+  readdir: (filepath: string) => Promise<[IObjects]>
+  getFileSize: (filepath) => Promise<number>;
+  getMDate: (filepath) => Promise<Date>;
+}
+
+export = function (opt?: IArgs): Ifuncs { }

package/server/plugins/file/providers/index.js

@@ -0,0 +1,36 @@
+import s3 from './s3/index.js';
+import fs from './fs.js';
+
+const providers = (opt) => ({
+  fs: fs(opt),
+  s3: s3(opt),
+});
+
+import config from '../../../../config.js';
+
+// storage s3 or file
+function dataStorage(opt) {
+  const { storageList } = config;
+  const providerName = opt?.provider || (config.s3 ? 's3' : 'fs');
+
+  if (storageList[providerName]) {
+    return storageList[providerName];
+  }
+
+  if (storageList[providerName] && !['fs', 's3'].includes(providerName)) {
+    return storageList[providerName];
+  }
+
+  const confS3 = {
+    containerName: 'work',
+    accessKeyId: config.s3?.user,
+    secretAccessKey: config.s3?.password,
+    ...config.s3 || {},
+  };
+  const provider = providers(confS3)[providerName];
+
+  storageList[providerName] = provider;
+  return provider;
+}
+
+export default dataStorage;

package/server/plugins/file/providers/mime/index.js

@@ -0,0 +1,12 @@
+import path from 'node:path';
+
+import types from './mimes.js';
+
+function getMimeType(filename) {
+  const ext = path.extname(filename)
+    .toLocaleLowerCase()
+    .slice(1);
+  return types[ext] || null;
+}
+
+export default getMimeType;