@catbee/utils 1.1.0 → 2.0.0-next.1

package/exception/index.mjs

@@ -0,0 +1,338 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { HttpStatusCodes } from '@catbee/utils/http-status-codes';
+import { getLogger } from '@catbee/utils/logger';
+import { ErrorResponse } from '@catbee/utils/response';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var HttpError = class extends ErrorResponse {
+  static {
+    __name(this, "HttpError");
+  }
+  /**
+  * Creates a new HTTP error instance.
+  * @param status - A valid HTTP status code (e.g., 400, 500).
+  * @param message - The error message to return to the client.
+  */
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+var InternalServerErrorException = class extends ErrorResponse {
+  static {
+    __name(this, "InternalServerErrorException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Internal server error".
+  */
+  constructor(message = "Internal server error") {
+    super(message);
+    this.status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
+  }
+};
+var UnauthorizedException = class extends ErrorResponse {
+  static {
+    __name(this, "UnauthorizedException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Unauthorized".
+  */
+  constructor(message = "Unauthorized") {
+    super(message);
+    this.status = HttpStatusCodes.UNAUTHORIZED;
+  }
+};
+var BadRequestException = class extends ErrorResponse {
+  static {
+    __name(this, "BadRequestException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Bad request".
+  */
+  constructor(message = "Bad request") {
+    super(message);
+    this.status = HttpStatusCodes.BAD_REQUEST;
+  }
+};
+var NotFoundException = class extends ErrorResponse {
+  static {
+    __name(this, "NotFoundException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Resource not found".
+  */
+  constructor(message = "Resource not found") {
+    super(message);
+    this.status = HttpStatusCodes.NOT_FOUND;
+  }
+};
+var ForbiddenException = class extends ErrorResponse {
+  static {
+    __name(this, "ForbiddenException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Forbidden".
+  */
+  constructor(message = "Forbidden") {
+    super(message);
+    this.status = HttpStatusCodes.FORBIDDEN;
+  }
+};
+var ConflictException = class extends ErrorResponse {
+  static {
+    __name(this, "ConflictException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Conflict".
+  */
+  constructor(message = "Conflict") {
+    super(message);
+    this.status = HttpStatusCodes.CONFLICT;
+  }
+};
+var BadGatewayException = class extends ErrorResponse {
+  static {
+    __name(this, "BadGatewayException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Bad Gateway".
+  */
+  constructor(message = "Bad Gateway") {
+    super(message);
+    this.status = HttpStatusCodes.BAD_GATEWAY;
+  }
+};
+var TooManyRequestsException = class extends ErrorResponse {
+  static {
+    __name(this, "TooManyRequestsException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Too many requests".
+  */
+  constructor(message = "Too many requests") {
+    super(message);
+    this.status = HttpStatusCodes.TOO_MANY_REQUESTS;
+  }
+};
+var ServiceUnavailableException = class extends ErrorResponse {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Service Unavailable".
+  */
+  constructor(message = "Service Unavailable") {
+    super(message);
+    this.status = HttpStatusCodes.SERVICE_UNAVAILABLE;
+  }
+};
+var GatewayTimeoutException = class extends ErrorResponse {
+  static {
+    __name(this, "GatewayTimeoutException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Gateway Timeout".
+  */
+  constructor(message = "Gateway Timeout") {
+    super(message);
+    this.status = HttpStatusCodes.GATEWAY_TIMEOUT;
+  }
+};
+var UnprocessableEntityException = class extends ErrorResponse {
+  static {
+    __name(this, "UnprocessableEntityException");
+  }
+  details;
+  /**
+  * @param message - Optional custom message. Defaults to "Unprocessable Entity".
+  * @param details - Optional validation details or additional error context.
+  */
+  constructor(message = "Unprocessable Entity", details) {
+    super(message), this.details = details;
+    this.status = HttpStatusCodes.UNPROCESSABLE_ENTITY;
+  }
+};
+var MethodNotAllowedException = class extends ErrorResponse {
+  static {
+    __name(this, "MethodNotAllowedException");
+  }
+  allowedMethods;
+  /**
+  * @param message - Optional custom message. Defaults to "Method Not Allowed".
+  * @param allowedMethods - Optional array of allowed HTTP methods.
+  */
+  constructor(message = "Method Not Allowed", allowedMethods) {
+    super(message), this.allowedMethods = allowedMethods;
+    this.status = HttpStatusCodes.METHOD_NOT_ALLOWED;
+  }
+};
+var NotAcceptableException = class extends ErrorResponse {
+  static {
+    __name(this, "NotAcceptableException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Not Acceptable".
+  */
+  constructor(message = "Not Acceptable") {
+    super(message);
+    this.status = HttpStatusCodes.NOT_ACCEPTABLE;
+  }
+};
+var RequestTimeoutException = class extends ErrorResponse {
+  static {
+    __name(this, "RequestTimeoutException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Request Timeout".
+  */
+  constructor(message = "Request Timeout") {
+    super(message);
+    this.status = HttpStatusCodes.REQUEST_TIMEOUT;
+  }
+};
+var UnsupportedMediaTypeException = class extends ErrorResponse {
+  static {
+    __name(this, "UnsupportedMediaTypeException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Unsupported Media Type".
+  */
+  constructor(message = "Unsupported Media Type") {
+    super(message);
+    this.status = HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE;
+  }
+};
+var PayloadTooLargeException = class extends ErrorResponse {
+  static {
+    __name(this, "PayloadTooLargeException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Payload Too Large".
+  */
+  constructor(message = "Payload Too Large") {
+    super(message);
+    this.status = HttpStatusCodes.PAYLOAD_TOO_LARGE;
+  }
+};
+var InsufficientStorageException = class extends ErrorResponse {
+  static {
+    __name(this, "InsufficientStorageException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Insufficient Storage".
+  */
+  constructor(message = "Insufficient Storage") {
+    super(message);
+    this.status = HttpStatusCodes.INSUFFICIENT_STORAGE;
+  }
+};
+function isHttpError(error) {
+  return error instanceof ErrorResponse;
+}
+__name(isHttpError, "isHttpError");
+function createHttpError(status, message) {
+  switch (status) {
+    case HttpStatusCodes.BAD_REQUEST:
+      return new BadRequestException(message);
+    case HttpStatusCodes.UNAUTHORIZED:
+      return new UnauthorizedException(message);
+    case HttpStatusCodes.FORBIDDEN:
+      return new ForbiddenException(message);
+    case HttpStatusCodes.NOT_FOUND:
+      return new NotFoundException(message);
+    case HttpStatusCodes.METHOD_NOT_ALLOWED:
+      return new MethodNotAllowedException(message);
+    case HttpStatusCodes.NOT_ACCEPTABLE:
+      return new NotAcceptableException(message);
+    case HttpStatusCodes.REQUEST_TIMEOUT:
+      return new RequestTimeoutException(message);
+    case HttpStatusCodes.CONFLICT:
+      return new ConflictException(message);
+    case HttpStatusCodes.GONE:
+      return new HttpError(HttpStatusCodes.GONE, message || "Gone");
+    case HttpStatusCodes.PAYLOAD_TOO_LARGE:
+      return new PayloadTooLargeException(message);
+    case HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE:
+      return new UnsupportedMediaTypeException(message);
+    case HttpStatusCodes.UNPROCESSABLE_ENTITY:
+      return new UnprocessableEntityException(message);
+    case HttpStatusCodes.TOO_MANY_REQUESTS:
+      return new TooManyRequestsException(message);
+    case HttpStatusCodes.INTERNAL_SERVER_ERROR:
+      return new InternalServerErrorException(message);
+    case HttpStatusCodes.BAD_GATEWAY:
+      return new BadGatewayException(message);
+    case HttpStatusCodes.SERVICE_UNAVAILABLE:
+      return new ServiceUnavailableException(message);
+    case HttpStatusCodes.GATEWAY_TIMEOUT:
+      return new GatewayTimeoutException(message);
+    case HttpStatusCodes.INSUFFICIENT_STORAGE:
+      return new InsufficientStorageException(message);
+    default:
+      return new HttpError(status, message || `HTTP Error ${status}`);
+  }
+}
+__name(createHttpError, "createHttpError");
+function hasErrorShape(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+__name(hasErrorShape, "hasErrorShape");
+function getErrorMessage(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (hasErrorShape(error)) {
+    return error.message;
+  }
+  return "Unknown error occurred";
+}
+__name(getErrorMessage, "getErrorMessage");
+function withErrorHandling(handler) {
+  return async (...args) => {
+    try {
+      return await handler(...args);
+    } catch (err) {
+      if (isHttpError(err)) {
+        throw err;
+      }
+      getLogger().error({
+        err
+      }, "Caught error in handler");
+      let status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
+      if (hasErrorShape(err) && typeof err.status === "number") {
+        status = err.status;
+      }
+      throw createHttpError(status, getErrorMessage(err));
+    }
+  };
+}
+__name(withErrorHandling, "withErrorHandling");
+
+export { BadGatewayException, BadRequestException, ConflictException, ForbiddenException, GatewayTimeoutException, HttpError, InsufficientStorageException, InternalServerErrorException, MethodNotAllowedException, NotAcceptableException, NotFoundException, PayloadTooLargeException, RequestTimeoutException, ServiceUnavailableException, TooManyRequestsException, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, createHttpError, getErrorMessage, hasErrorShape, isHttpError, withErrorHandling };

package/fs/index.cjs

@@ -0,0 +1,287 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+'use strict';
+
+var fs = require('fs');
+var fsp = require('fs/promises');
+var os = require('os');
+var path = require('path');
+var promises = require('stream/promises');
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var fsp__default = /*#__PURE__*/_interopDefault(fsp);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+async function fileExists(path2) {
+  try {
+    await fsp__default.default.access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(fileExists, "fileExists");
+async function readJsonFile(path2) {
+  try {
+    const data = await fsp__default.default.readFile(path2, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+__name(readJsonFile, "readJsonFile");
+async function readJsonOrDefault(path2, defaultValue) {
+  const res = await safeReadJsonFile(path2);
+  return res.data === null ? defaultValue : res.data;
+}
+__name(readJsonOrDefault, "readJsonOrDefault");
+async function writeJsonFile(path2, data, space = 2) {
+  const json = JSON.stringify(data, null, space);
+  await fsp__default.default.writeFile(path2, json, "utf-8");
+}
+__name(writeJsonFile, "writeJsonFile");
+async function deleteFileIfExists(path2) {
+  try {
+    await fsp__default.default.unlink(path2);
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return true;
+    return false;
+  }
+}
+__name(deleteFileIfExists, "deleteFileIfExists");
+async function readFile(path2, encoding = "utf-8") {
+  return await fsp__default.default.readFile(path2, encoding);
+}
+__name(readFile, "readFile");
+function readFileSync(path2, encoding = "utf-8") {
+  return fs__default.default.readFileSync(path2, encoding);
+}
+__name(readFileSync, "readFileSync");
+async function safeReadFile(path2, encoding = "utf-8") {
+  try {
+    const data = await fsp__default.default.readFile(path2, encoding);
+    return {
+      data,
+      error: null
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: new Error(`Failed to read file ${path2}: ${error.message}`)
+    };
+  }
+}
+__name(safeReadFile, "safeReadFile");
+function safeReadFileSync(path2, encoding = "utf-8") {
+  try {
+    const data = fs__default.default.readFileSync(path2, encoding);
+    return {
+      data,
+      error: null
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: new Error(`Failed to read file ${path2}: ${error.message}`)
+    };
+  }
+}
+__name(safeReadFileSync, "safeReadFileSync");
+async function writeFile(path2, content, encoding = "utf-8") {
+  try {
+    await fsp__default.default.writeFile(path2, content, encoding);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(writeFile, "writeFile");
+async function appendFile(path2, content, encoding = "utf-8") {
+  try {
+    await fsp__default.default.appendFile(path2, content, encoding);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(appendFile, "appendFile");
+async function copyFile(source, destination, overwrite = false) {
+  try {
+    const flags = overwrite ? 0 : fsp__default.default.constants.COPYFILE_EXCL;
+    await fsp__default.default.copyFile(source, destination, flags);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(copyFile, "copyFile");
+async function moveFile(oldPath, newPath) {
+  try {
+    await fsp__default.default.rename(oldPath, newPath);
+    return true;
+  } catch {
+    try {
+      await fsp__default.default.copyFile(oldPath, newPath);
+      await fsp__default.default.unlink(oldPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+__name(moveFile, "moveFile");
+async function getFileStats(path2) {
+  try {
+    return await fsp__default.default.stat(path2);
+  } catch {
+    return null;
+  }
+}
+__name(getFileStats, "getFileStats");
+async function createTempFile({ prefix = "tmp-", extension = "", dir = os.tmpdir(), content } = {}) {
+  const ext = extension ? extension.startsWith(".") ? extension : `.${extension}` : "";
+  const filename = `${prefix}${crypto.randomUUID()}${ext}`;
+  const filepath = path__default.default.join(dir, filename);
+  if (content) {
+    await fsp__default.default.writeFile(filepath, content);
+  } else {
+    await fsp__default.default.writeFile(filepath, "");
+  }
+  return filepath;
+}
+__name(createTempFile, "createTempFile");
+async function streamFile(source, destination) {
+  const readStream = fs__default.default.createReadStream(source);
+  const writeStream = fs__default.default.createWriteStream(destination);
+  try {
+    await promises.pipeline(readStream, writeStream);
+  } catch (error) {
+    readStream.destroy();
+    writeStream.destroy();
+    throw error;
+  }
+}
+__name(streamFile, "streamFile");
+async function readDirectory(dirPath, options = {}) {
+  const files = await fsp__default.default.readdir(dirPath);
+  let result = files;
+  if (options.filter) {
+    result = result.filter((file) => options.filter.test(file));
+  }
+  if (options.fullPaths) {
+    result = result.map((file) => path__default.default.join(dirPath, file));
+  }
+  return result;
+}
+__name(readDirectory, "readDirectory");
+async function createDirectory(dirPath, recursive = true) {
+  try {
+    await fsp__default.default.mkdir(dirPath, {
+      recursive
+    });
+    return true;
+  } catch (err) {
+    return err.code === "EEXIST";
+  }
+}
+__name(createDirectory, "createDirectory");
+async function safeReadJsonFile(path2) {
+  try {
+    const content = await fsp__default.default.readFile(path2, "utf-8");
+    try {
+      const data = JSON.parse(content);
+      return {
+        data,
+        error: null
+      };
+    } catch (error) {
+      return {
+        data: null,
+        error: new Error(`Invalid JSON in file ${path2}: ${error.message}`)
+      };
+    }
+  } catch (error) {
+    return {
+      data: null,
+      error: new Error(`Failed to read file ${path2}: ${error.message}`)
+    };
+  }
+}
+__name(safeReadJsonFile, "safeReadJsonFile");
+async function isFile(path2) {
+  try {
+    const stat = await fsp__default.default.stat(path2);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+__name(isFile, "isFile");
+async function getFileSize(path2) {
+  try {
+    const stat = await fsp__default.default.stat(path2);
+    return stat.size;
+  } catch {
+    return -1;
+  }
+}
+__name(getFileSize, "getFileSize");
+async function readFileBuffer(path2) {
+  try {
+    return await fsp__default.default.readFile(path2);
+  } catch {
+    return null;
+  }
+}
+__name(readFileBuffer, "readFileBuffer");
+
+exports.appendFile = appendFile;
+exports.copyFile = copyFile;
+exports.createDirectory = createDirectory;
+exports.createTempFile = createTempFile;
+exports.deleteFileIfExists = deleteFileIfExists;
+exports.fileExists = fileExists;
+exports.getFileSize = getFileSize;
+exports.getFileStats = getFileStats;
+exports.isFile = isFile;
+exports.moveFile = moveFile;
+exports.readDirectory = readDirectory;
+exports.readFile = readFile;
+exports.readFileBuffer = readFileBuffer;
+exports.readFileSync = readFileSync;
+exports.readJsonFile = readJsonFile;
+exports.readJsonOrDefault = readJsonOrDefault;
+exports.safeReadFile = safeReadFile;
+exports.safeReadFileSync = safeReadFileSync;
+exports.safeReadJsonFile = safeReadJsonFile;
+exports.streamFile = streamFile;
+exports.writeFile = writeFile;
+exports.writeJsonFile = writeJsonFile;