elseware-nodejs 1.5.1 → 1.5.3

package/dist/index.cjs

@@ -1,18 +1,18 @@
 'use strict';
 
+var mongoose = require('mongoose');
+var dotenv = require('dotenv');
 var storageBlob = require('@azure/storage-blob');
 var fs = require('fs');
 var cloudinaryModule = require('cloudinary');
-var mongoose = require('mongoose');
-var dotenv = require('dotenv');
 var jwt = require('jsonwebtoken');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var cloudinaryModule__default = /*#__PURE__*/_interopDefault(cloudinaryModule);
 var mongoose__default = /*#__PURE__*/_interopDefault(mongoose);
 var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var cloudinaryModule__default = /*#__PURE__*/_interopDefault(cloudinaryModule);
 var jwt__default = /*#__PURE__*/_interopDefault(jwt);
 
 // src/errors/appError.ts
@@ -250,160 +250,6 @@ function pickFields(obj, fields, options = {}) {
   }
   return result;
 }
-var AzureBlobService = class {
-  containerName;
-  blobServiceClient;
-  containerClient;
-  sharedKeyCredential;
-  constructor(config) {
-    const { connectionString, accountName, accountKey, containerName } = config;
-    this.containerName = containerName;
-    this.blobServiceClient = storageBlob.BlobServiceClient.fromConnectionString(connectionString);
-    this.containerClient = this.blobServiceClient.getContainerClient(containerName);
-    this.sharedKeyCredential = new storageBlob.StorageSharedKeyCredential(
-      accountName,
-      accountKey
-    );
-  }
-  // Upload file
-  async uploadFile(localPath, blobName, onProgress) {
-    const blockBlobClient = this.containerClient.getBlockBlobClient(blobName);
-    const fileSize = fs__default.default.statSync(localPath).size;
-    const readStream = fs__default.default.createReadStream(localPath);
-    await blockBlobClient.uploadStream(
-      readStream,
-      4 * 1024 * 1024,
-      // buffer size
-      20,
-      // max concurrency
-      {
-        onProgress: (ev) => {
-          if (onProgress) {
-            const percent = (ev.loadedBytes / fileSize * 100).toFixed(2);
-            onProgress(percent);
-          }
-        }
-      }
-    );
-    return blockBlobClient.url;
-  }
-  // Download file
-  async downloadFile(blobName, downloadPath, onProgress) {
-    const blobClient = this.containerClient.getBlobClient(blobName);
-    const response = await blobClient.download();
-    const fileSize = response.contentLength || 0;
-    let downloaded = 0;
-    return new Promise((resolve, reject) => {
-      const writable = fs__default.default.createWriteStream(downloadPath);
-      response.readableStreamBody?.on("data", (chunk) => {
-        downloaded += chunk.length;
-        if (onProgress && fileSize > 0) {
-          const percent = (downloaded / fileSize * 100).toFixed(2);
-          onProgress(percent);
-        }
-      });
-      response.readableStreamBody?.pipe(writable);
-      writable.on("finish", resolve);
-      writable.on("error", reject);
-    });
-  }
-  // Delete file
-  async deleteFile(blobName) {
-    const blobClient = this.containerClient.getBlobClient(blobName);
-    await blobClient.deleteIfExists();
-    return true;
-  }
-  // List blobs
-  async listFiles(prefix = "") {
-    const result = [];
-    for await (const blob of this.containerClient.listBlobsFlat({ prefix })) {
-      result.push(blob.name);
-    }
-    return result;
-  }
-  // Check existence
-  async blobExists(blobName) {
-    const blobClient = this.containerClient.getBlobClient(blobName);
-    return blobClient.exists();
-  }
-  // Generate temporary read-only SAS URL
-  async generateSasUrl(blobName, expiresInMinutes = 60) {
-    const blobClient = this.containerClient.getBlobClient(blobName);
-    const sasToken = storageBlob.generateBlobSASQueryParameters(
-      {
-        containerName: this.containerName,
-        blobName: blobClient.name,
-        expiresOn: new Date(Date.now() + expiresInMinutes * 60 * 1e3),
-        permissions: storageBlob.BlobSASPermissions.parse("r")
-        // read-only
-      },
-      this.sharedKeyCredential
-    ).toString();
-    return `${blobClient.url}?${sasToken}`;
-  }
-};
-var cloudinary = cloudinaryModule__default.default.v2;
-var CloudinaryService = class {
-  rootFolder;
-  constructor(config) {
-    const { cloudName, apiKey, apiSecret, rootFolder } = config;
-    cloudinary.config({
-      cloud_name: cloudName,
-      api_key: apiKey,
-      api_secret: apiSecret,
-      secure: true
-    });
-    this.rootFolder = rootFolder;
-  }
-  // Upload file to Cloudinary
-  async uploadFile(filePath, options = {}) {
-    if (!fs__default.default.existsSync(filePath)) {
-      throw new Error(`File not found: ${filePath}`);
-    }
-    const folderPath = this.buildFolderPath(options.folder);
-    const result = await cloudinary.uploader.upload(filePath, {
-      folder: folderPath,
-      public_id: options.publicId,
-      resource_type: options.resourceType || "auto"
-    });
-    return result.public_id;
-  }
-  // Delete asset by public ID
-  async deleteFile(publicId) {
-    const result = await cloudinary.uploader.destroy(publicId);
-    return result.result === "ok";
-  }
-  // Check if asset exists
-  async fileExists(publicId) {
-    try {
-      await cloudinary.api.resource(publicId);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  // Generate optimized delivery URL
-  generateUrl(publicId, options = {}) {
-    return cloudinary.url(publicId, {
-      secure: true,
-      ...options
-    });
-  }
-  // Create folder (idempotent)
-  async createFolder(folder) {
-    try {
-      await cloudinary.api.create_folder(folder);
-    } catch (err) {
-    }
-  }
-  buildFolderPath(subFolder) {
-    if (!this.rootFolder && !subFolder) return void 0;
-    if (this.rootFolder && subFolder) {
-      return `${this.rootFolder}/${subFolder}`;
-    }
-    return this.rootFolder || subFolder;
-  }
-};
 
 // src/utils/errorToString.ts
 function errorToString(error) {
@@ -5297,6 +5143,160 @@ var validate = (schema) => (req, _res, next) => {
   }
   next();
 };
+var AzureBlobStorageService = class {
+  containerName;
+  blobServiceClient;
+  containerClient;
+  sharedKeyCredential;
+  constructor(config) {
+    const { connectionString, accountName, accountKey, containerName } = config;
+    this.containerName = containerName;
+    this.blobServiceClient = storageBlob.BlobServiceClient.fromConnectionString(connectionString);
+    this.containerClient = this.blobServiceClient.getContainerClient(containerName);
+    this.sharedKeyCredential = new storageBlob.StorageSharedKeyCredential(
+      accountName,
+      accountKey
+    );
+  }
+  // Upload file
+  async uploadFile(localPath, blobName, onProgress) {
+    const blockBlobClient = this.containerClient.getBlockBlobClient(blobName);
+    const fileSize = fs__default.default.statSync(localPath).size;
+    const readStream = fs__default.default.createReadStream(localPath);
+    await blockBlobClient.uploadStream(
+      readStream,
+      4 * 1024 * 1024,
+      // buffer size
+      20,
+      // max concurrency
+      {
+        onProgress: (ev) => {
+          if (onProgress) {
+            const percent = (ev.loadedBytes / fileSize * 100).toFixed(2);
+            onProgress(percent);
+          }
+        }
+      }
+    );
+    return blockBlobClient.url;
+  }
+  // Download file
+  async downloadFile(blobName, downloadPath, onProgress) {
+    const blobClient = this.containerClient.getBlobClient(blobName);
+    const response = await blobClient.download();
+    const fileSize = response.contentLength || 0;
+    let downloaded = 0;
+    return new Promise((resolve, reject) => {
+      const writable = fs__default.default.createWriteStream(downloadPath);
+      response.readableStreamBody?.on("data", (chunk) => {
+        downloaded += chunk.length;
+        if (onProgress && fileSize > 0) {
+          const percent = (downloaded / fileSize * 100).toFixed(2);
+          onProgress(percent);
+        }
+      });
+      response.readableStreamBody?.pipe(writable);
+      writable.on("finish", resolve);
+      writable.on("error", reject);
+    });
+  }
+  // Delete file
+  async deleteFile(blobName) {
+    const blobClient = this.containerClient.getBlobClient(blobName);
+    await blobClient.deleteIfExists();
+    return true;
+  }
+  // List blobs
+  async listFiles(prefix = "") {
+    const result = [];
+    for await (const blob of this.containerClient.listBlobsFlat({ prefix })) {
+      result.push(blob.name);
+    }
+    return result;
+  }
+  // Check existence
+  async blobExists(blobName) {
+    const blobClient = this.containerClient.getBlobClient(blobName);
+    return blobClient.exists();
+  }
+  // Generate temporary read-only SAS URL
+  async generateSasUrl(blobName, expiresInMinutes = 60) {
+    const blobClient = this.containerClient.getBlobClient(blobName);
+    const sasToken = storageBlob.generateBlobSASQueryParameters(
+      {
+        containerName: this.containerName,
+        blobName: blobClient.name,
+        expiresOn: new Date(Date.now() + expiresInMinutes * 60 * 1e3),
+        permissions: storageBlob.BlobSASPermissions.parse("r")
+        // read-only
+      },
+      this.sharedKeyCredential
+    ).toString();
+    return `${blobClient.url}?${sasToken}`;
+  }
+};
+var cloudinary = cloudinaryModule__default.default.v2;
+var CloudinaryService = class {
+  rootFolder;
+  constructor(config) {
+    const { cloudName, apiKey, apiSecret, rootFolder } = config;
+    cloudinary.config({
+      cloud_name: cloudName,
+      api_key: apiKey,
+      api_secret: apiSecret,
+      secure: true
+    });
+    this.rootFolder = rootFolder;
+  }
+  // Upload file to Cloudinary
+  async uploadFile(filePath, options = {}) {
+    if (!fs__default.default.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const folderPath = this.buildFolderPath(options.folder);
+    const result = await cloudinary.uploader.upload(filePath, {
+      folder: folderPath,
+      public_id: options.publicId,
+      resource_type: options.resourceType || "auto"
+    });
+    return result.public_id;
+  }
+  // Delete asset by public ID
+  async deleteFile(publicId) {
+    const result = await cloudinary.uploader.destroy(publicId);
+    return result.result === "ok";
+  }
+  // Check if asset exists
+  async fileExists(publicId) {
+    try {
+      await cloudinary.api.resource(publicId);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // Generate optimized delivery URL
+  generateUrl(publicId, options = {}) {
+    return cloudinary.url(publicId, {
+      secure: true,
+      ...options
+    });
+  }
+  // Create folder (idempotent)
+  async createFolder(folder) {
+    try {
+      await cloudinary.api.create_folder(folder);
+    } catch (err) {
+    }
+  }
+  buildFolderPath(subFolder) {
+    if (!this.rootFolder && !subFolder) return void 0;
+    if (this.rootFolder && subFolder) {
+      return `${this.rootFolder}/${subFolder}`;
+    }
+    return this.rootFolder || subFolder;
+  }
+};
 var JWTService = class {
   accessSecret;
   refreshSecret;
@@ -5307,8 +5307,8 @@ var JWTService = class {
   constructor(options) {
     this.accessSecret = options.accessSecret;
     this.refreshSecret = options.refreshSecret;
-    this.accessExpires = options.accessExpires || "15m";
-    this.refreshExpires = options.refreshExpires || "30d";
+    this.accessExpires = this.parseExpires(options.accessExpires, "15m");
+    this.refreshExpires = this.parseExpires(options.refreshExpires, "30d");
     this.nodeEnv = options.nodeEnv || "development";
     this.refreshCookieName = options.refreshCookieName || "refreshJwt";
   }
@@ -5348,14 +5348,18 @@ var JWTService = class {
   // Token Extraction
   // ---------------------------------
   extractToken(req) {
+    let token = null;
     if (req.headers.authorization?.startsWith("Bearer ")) {
-      return req.headers.authorization.split(" ")[1];
+      token = req.headers.authorization.split(" ")[1];
+      return token ? this.normalizeToken(token) : null;
     }
     if (req.cookies?.[this.refreshCookieName]) {
-      return req.cookies[this.refreshCookieName];
+      token = req.cookies[this.refreshCookieName];
+      return token ? this.normalizeToken(token) : null;
     }
     if (req.cookies?.jwt) {
-      return req.cookies.jwt;
+      token = req.cookies.jwt;
+      return token ? this.normalizeToken(token) : null;
     }
     return null;
   }
@@ -5388,6 +5392,25 @@ var JWTService = class {
     this.setRefreshTokenCookie(res, refreshToken);
     return accessToken;
   }
+  // ---------------------------------
+  // Internal Helpers
+  // ---------------------------------
+  normalizeToken(token) {
+    token = token.trim();
+    if (token.startsWith('"') && token.endsWith('"')) {
+      try {
+        return JSON.parse(token);
+      } catch {
+        return token.slice(1, -1);
+      }
+    }
+    return token;
+  }
+  parseExpires(value, fallback) {
+    if (!value) return fallback;
+    if (typeof value === "number") return value;
+    return value;
+  }
 };
 
 // src/utils/time.ts
@@ -5426,7 +5449,7 @@ exports.AVLTree = AVLTree;
 exports.AdjacencyList = AdjacencyList;
 exports.AdjacencyMatrix = AdjacencyMatrix;
 exports.AppError = AppError;
-exports.AzureBlobService = AzureBlobService;
+exports.AzureBlobStorageService = AzureBlobStorageService;
 exports.BPlusTree = BPlusTree;
 exports.BTree = BTree;
 exports.BinaryHeap = BinaryHeap;