@ruiapp/rapid-core 0.9.7 → 0.9.8

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export { default as EntityManager } from "./dataAccess/entityManager";
 export * from "./dataAccess/entityManager";
 export * from "./utilities/accessControlUtility";
 export * from "./utilities/entityUtility";
+export * from "./utilities/fsUtility";
 export * from "./utilities/jwtUtility";
 export * from "./utilities/timeUtility";
 export * from "./utilities/passwordUtility";

package/dist/index.js

@@ -7,11 +7,11 @@ var events = require('events');
 var Router = require('koa-tree-router');
 var qs = require('qs');
 var dayjs = require('dayjs');
+var fs = require('fs');
+var path = require('path');
 var jsonwebtoken = require('jsonwebtoken');
 var crypto = require('crypto');
 var bcrypt = require('bcryptjs');
-var path = require('path');
-var fs = require('fs');
 var uuid = require('uuid');
 var nodemailer = require('nodemailer');
 var cron = require('cron');
@@ -22,10 +22,10 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
 var bcrypt__default = /*#__PURE__*/_interopDefaultLegacy(bcrypt);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var nodemailer__default = /*#__PURE__*/_interopDefaultLegacy(nodemailer);
 
 function fixBigIntJSONSerialize() {
@@ -4941,6 +4941,128 @@ function getEntityRelationTargetId(entity, propName, targetColumnName) {
     }
 }
 
+async function readFile(path) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].readFile(path, null, (err, data) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(data);
+            }
+        });
+    });
+}
+async function copyFile(fromPath, toPath) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].copyFile(fromPath, toPath, (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+async function removeFile(path) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].rm(path, (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+async function moveFile(fromPath, toPath) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].rename(fromPath, toPath, (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+async function appendFile(path, data) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].appendFile(path, Buffer.from(data), (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+async function writeFile(path, data) {
+    return new Promise((resolve, reject) => {
+        fs__default["default"].writeFile(path, Buffer.from(data), (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+function ensureDirectoryExists(dirPath) {
+    if (!fs__default["default"].existsSync(dirPath)) {
+        const parentDirPath = path__default["default"].dirname(dirPath);
+        if (parentDirPath == dirPath) {
+            return;
+        }
+        ensureDirectoryExists(parentDirPath);
+        fs__default["default"].mkdirSync(dirPath);
+    }
+}
+function enumFileBaseNamesInDirectory(options) {
+    const { dirPath, prefix, fileNameFilter } = options;
+    let fileNames = [];
+    let resolvedDirPath = dirPath;
+    const isRelative = dirPath.startsWith(".") || dirPath.startsWith("..");
+    if (isRelative) {
+        resolvedDirPath = path__default["default"].join(process.cwd(), dirPath);
+    }
+    if (!fs__default["default"].existsSync(resolvedDirPath)) {
+        console.warn(`Directory '${resolvedDirPath}' not found.`);
+        return [];
+    }
+    const files = fs__default["default"].readdirSync(resolvedDirPath);
+    for (const fileName of files) {
+        const filePathName = path__default["default"].join(resolvedDirPath, fileName);
+        const fileStat = fs__default["default"].statSync(filePathName);
+        if (fileStat.isDirectory()) {
+            fileNames = fileNames.concat(enumFileBaseNamesInDirectory({
+                dirPath: filePathName,
+                prefix: prefix ? `${prefix}/${fileName}` : fileName,
+                fileNameFilter,
+            }));
+        }
+        else if (fileStat.isFile()) {
+            if (fileNameFilter && !fileNameFilter(fileName)) {
+                continue;
+            }
+            const baseName = path__default["default"].parse(fileName).name;
+            if (prefix) {
+                fileNames.push(`${prefix}/${baseName}`);
+            }
+            else {
+                fileNames.push(baseName);
+            }
+        }
+    }
+    fileNames.sort();
+    return fileNames;
+}
+
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 /**
@@ -7373,31 +7495,6 @@ class AuthPlugin {
     }
 }
 
-async function readFile(path) {
-    return new Promise((resolve, reject) => {
-        fs__default["default"].readFile(path, null, (err, data) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve(data);
-            }
-        });
-    });
-}
-async function appendFile(path, data) {
-    return new Promise((resolve, reject) => {
-        fs__default["default"].appendFile(path, Buffer.from(data), (err) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-
 function getFileBaseName(pathname) {
     const extName = path__default["default"].extname(pathname);
     return path__default["default"].basename(pathname, extName);
@@ -7511,7 +7608,7 @@ async function handler$8(plugin, ctx, options) {
     const fileKey = `${uuid.v1()}${extName}`;
     const filePathName = path__default["default"].join(server.config.localFileStoragePath, fileKey);
     const fileBuffer = await file.arrayBuffer();
-    await appendFile(filePathName, fileBuffer);
+    await writeFile(filePathName, fileBuffer);
     ctx.output = { ok: true, fileKey };
 }
 
@@ -9706,12 +9803,16 @@ exports.ServerOperationPlugin = ServerOperationPlugin;
 exports.SettingPlugin = SettingPlugin;
 exports.StateMachinePlugin = StateMachinePlugin;
 exports.WebhooksPlugin = WebhooksPlugin;
+exports.appendFile = appendFile;
 exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;
+exports.copyFile = copyFile;
 exports.createJwt = createJwt;
 exports.decodeJwt = decodeJwt;
 exports.deleteCookie = deleteCookie;
 exports.detectChangedFieldsOfEntity = detectChangedFieldsOfEntity;
+exports.ensureDirectoryExists = ensureDirectoryExists;
 exports.entityHelper = entityHelper;
+exports.enumFileBaseNamesInDirectory = enumFileBaseNamesInDirectory;
 exports.formatDateTimeWithTimezone = formatDateTimeWithTimezone;
 exports.generateJwtSecretKey = generateJwtSecretKey;
 exports.generatePasswordHash = generatePasswordHash;
@@ -9725,8 +9826,12 @@ exports.isAccessAllowed = isAccessAllowed;
 exports.licenseHelper = licenseHelper;
 exports.mapDbRowToEntity = mapDbRowToEntity;
 exports.metaHelper = metaHelper;
+exports.moveFile = moveFile;
+exports.readFile = readFile;
+exports.removeFile = removeFile;
 exports.setCookie = setCookie;
 exports.tryValidateLicense = tryValidateLicense;
 exports.validateLicense = validateLicense;
 exports.validatePassword = validatePassword;
 exports.verifyJwt = verifyJwt;
+exports.writeFile = writeFile;

package/dist/utilities/fsUtility.d.ts

@@ -4,3 +4,11 @@ export declare function copyFile(fromPath: string, toPath: string): Promise<void
 export declare function removeFile(path: string): Promise<void>;
 export declare function moveFile(fromPath: string, toPath: string): Promise<void>;
 export declare function appendFile(path: string, data: ArrayBuffer): Promise<void>;
+export declare function writeFile(path: string, data: ArrayBuffer): Promise<void>;
+export declare function ensureDirectoryExists(dirPath: string): void;
+export type EnumFileBaseNamesOptions = {
+    dirPath: string;
+    prefix?: string;
+    fileNameFilter?: (fileName: string) => boolean;
+};
+export declare function enumFileBaseNamesInDirectory(options: EnumFileBaseNamesOptions): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.9.7",
+  "version": "0.9.8",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -20,6 +20,7 @@ export * from "./dataAccess/entityManager";
 
 export * from "./utilities/accessControlUtility";
 export * from "./utilities/entityUtility";
+export * from "./utilities/fsUtility";
 export * from "./utilities/jwtUtility";
 export * from "./utilities/timeUtility";
 export * from "./utilities/passwordUtility";

package/src/plugins/fileManage/actionHandlers/uploadFile.ts

@@ -1,5 +1,5 @@
 import { v1 as uuidv1 } from "uuid";
-import { appendFile } from "~/utilities/fsUtility";
+import { writeFile } from "~/utilities/fsUtility";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import path from "path";
 import { isArray } from "lodash";
@@ -27,7 +27,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   const filePathName = path.join(server.config.localFileStoragePath, fileKey);
 
   const fileBuffer = await file.arrayBuffer();
-  await appendFile(filePathName, fileBuffer);
+  await writeFile(filePathName, fileBuffer);
 
   ctx.output = { ok: true, fileKey };
 }

package/src/utilities/fsUtility.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import path from "path";
 
 export async function readFile(path: string): Promise<Buffer> {
   return new Promise((resolve, reject) => {
@@ -59,3 +60,78 @@ export async function appendFile(path: string, data: ArrayBuffer): Promise<void>
     });
   });
 }
+
+export async function writeFile(path: string, data: ArrayBuffer): Promise<void> {
+  return new Promise((resolve, reject) => {
+    fs.writeFile(path, Buffer.from(data), (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+export function ensureDirectoryExists(dirPath: string) {
+  if (!fs.existsSync(dirPath)) {
+    const parentDirPath = path.dirname(dirPath);
+    if (parentDirPath == dirPath) {
+      return;
+    }
+    ensureDirectoryExists(parentDirPath);
+
+    fs.mkdirSync(dirPath);
+  }
+}
+
+export type EnumFileBaseNamesOptions = {
+  dirPath: string;
+  prefix?: string;
+  fileNameFilter?: (fileName: string) => boolean;
+};
+
+export function enumFileBaseNamesInDirectory(options: EnumFileBaseNamesOptions): string[] {
+  const { dirPath, prefix, fileNameFilter } = options;
+  let fileNames = [];
+
+  let resolvedDirPath = dirPath;
+  const isRelative = dirPath.startsWith(".") || dirPath.startsWith("..");
+  if (isRelative) {
+    resolvedDirPath = path.join(process.cwd(), dirPath);
+  }
+
+  if (!fs.existsSync(resolvedDirPath)) {
+    console.warn(`Directory '${resolvedDirPath}' not found.`);
+    return [];
+  }
+
+  const files = fs.readdirSync(resolvedDirPath);
+  for (const fileName of files) {
+    const filePathName = path.join(resolvedDirPath, fileName);
+    const fileStat = fs.statSync(filePathName);
+    if (fileStat.isDirectory()) {
+      fileNames = fileNames.concat(
+        enumFileBaseNamesInDirectory({
+          dirPath: filePathName,
+          prefix: prefix ? `${prefix}/${fileName}` : fileName,
+          fileNameFilter,
+        }),
+      );
+    } else if (fileStat.isFile()) {
+      if (fileNameFilter && !fileNameFilter(fileName)) {
+        continue;
+      }
+
+      const baseName = path.parse(fileName).name;
+      if (prefix) {
+        fileNames.push(`${prefix}/${baseName}`);
+      } else {
+        fileNames.push(baseName);
+      }
+    }
+  }
+
+  fileNames.sort();
+  return fileNames;
+}