saas-backend-kit 1.0.0 → 1.0.2

package/dist/index.js

@@ -6,7 +6,8 @@ var bullmq = require('bullmq');
 var jwt = require('jsonwebtoken');
 var bcrypt = require('bcryptjs');
 var nodemailer = require('nodemailer');
-var express = require('express');
+var clientS3 = require('@aws-sdk/client-s3');
+var s3RequestPresigner = require('@aws-sdk/s3-request-presigner');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -68,7 +69,12 @@ var init_config = __esm({
       SLACK_WEBHOOK_URL: zod.z.string().optional(),
       RATE_LIMIT_WINDOW: zod.z.string().default("1m"),
       RATE_LIMIT_LIMIT: zod.z.string().default("100"),
-      LOG_LEVEL: zod.z.enum(["fatal", "error", "warn", "info", "debug", "trace"]).default("info")
+      LOG_LEVEL: zod.z.enum(["fatal", "error", "warn", "info", "debug", "trace"]).default("info"),
+      AWS_REGION: zod.z.string().default("us-east-1"),
+      AWS_ACCESS_KEY_ID: zod.z.string().optional(),
+      AWS_SECRET_ACCESS_KEY: zod.z.string().optional(),
+      AWS_S3_BUCKET: zod.z.string().optional(),
+      AWS_ENDPOINT: zod.z.string().optional()
     });
     ConfigManager = class {
       config = null;
@@ -440,6 +446,7 @@ var init_express = __esm({
       cleanupInterval;
       constructor() {
         this.cleanupInterval = setInterval(() => this.cleanup(), 6e4);
+        this.cleanupInterval.unref();
       }
       cleanup() {
         const now = Date.now();
@@ -570,7 +577,7 @@ var JWTService = class {
     return jwt__default.default.verify(token, this.refreshSecret);
   }
   refreshTokens(refreshToken) {
-    const payload = this.verifyRefreshToken(refreshToken);
+    const { iat, exp, nbf, ...payload } = this.verifyRefreshToken(refreshToken);
     return this.generateTokenPair(payload);
   }
 };
@@ -1047,6 +1054,8 @@ init_express();
 
 // src/index.ts
 init_config();
+
+// src/response/index.ts
 var ResponseHelper = class {
   static success(res, data, message, statusCode = 200) {
     const response2 = {
@@ -1113,46 +1122,226 @@ var ResponseHelper = class {
     return res.status(204).send();
   }
 };
-express.Response.prototype.success = function(data, message, statusCode = 200) {
-  return ResponseHelper.success(this, data, message, statusCode);
-};
-express.Response.prototype.created = function(data, message) {
-  return ResponseHelper.created(this, data, message);
-};
-express.Response.prototype.updated = function(data, message) {
-  return ResponseHelper.updated(this, data, message);
-};
-express.Response.prototype.deleted = function(message) {
-  return ResponseHelper.deleted(this, message);
-};
-express.Response.prototype.error = function(error, statusCode = 400, code, details) {
-  return ResponseHelper.error(this, error, statusCode, code, details);
-};
-express.Response.prototype.badRequest = function(error, code) {
-  return ResponseHelper.badRequest(this, error, code);
-};
-express.Response.prototype.unauthorized = function(error, code) {
-  return ResponseHelper.unauthorized(this, error, code);
-};
-express.Response.prototype.forbidden = function(error, code) {
-  return ResponseHelper.forbidden(this, error, code);
-};
-express.Response.prototype.notFound = function(error, code) {
-  return ResponseHelper.notFound(this, error, code);
-};
-express.Response.prototype.conflict = function(error, code) {
-  return ResponseHelper.conflict(this, error, code);
-};
-express.Response.prototype.validationError = function(error, details) {
-  return ResponseHelper.validationError(this, error, details);
-};
-express.Response.prototype.internalError = function(error) {
-  return ResponseHelper.internalError(this, error);
+try {
+  const proto = __require("express").response;
+  if (proto) {
+    proto.success = function(data, message, statusCode = 200) {
+      return ResponseHelper.success(this, data, message, statusCode);
+    };
+    proto.created = function(data, message) {
+      return ResponseHelper.created(this, data, message);
+    };
+    proto.updated = function(data, message) {
+      return ResponseHelper.updated(this, data, message);
+    };
+    proto.deleted = function(message) {
+      return ResponseHelper.deleted(this, message);
+    };
+    proto.error = function(error, statusCode = 400, code, details) {
+      return ResponseHelper.error(this, error, statusCode, code, details);
+    };
+    proto.badRequest = function(error, code) {
+      return ResponseHelper.badRequest(this, error, code);
+    };
+    proto.unauthorized = function(error, code) {
+      return ResponseHelper.unauthorized(this, error, code);
+    };
+    proto.forbidden = function(error, code) {
+      return ResponseHelper.forbidden(this, error, code);
+    };
+    proto.notFound = function(error, code) {
+      return ResponseHelper.notFound(this, error, code);
+    };
+    proto.conflict = function(error, code) {
+      return ResponseHelper.conflict(this, error, code);
+    };
+    proto.validationError = function(error, details) {
+      return ResponseHelper.validationError(this, error, details);
+    };
+    proto.internalError = function(error) {
+      return ResponseHelper.internalError(this, error);
+    };
+    proto.paginated = function(data, page, limit, total) {
+      return ResponseHelper.paginated(this, data, page, limit, total);
+    };
+  }
+} catch {
+}
+var response = ResponseHelper;
+
+// src/upload/index.ts
+init_config();
+init_logger();
+var S3Service = class {
+  client = null;
+  bucket;
+  initialized = false;
+  constructor() {
+    this.bucket = "";
+  }
+  initialize(config2) {
+    this.client = new clientS3.S3Client({
+      region: config2.region || "us-east-1",
+      credentials: config2.accessKeyId && config2.secretAccessKey ? {
+        accessKeyId: config2.accessKeyId,
+        secretAccessKey: config2.secretAccessKey
+      } : void 0,
+      endpoint: config2.endpoint,
+      forcePathStyle: config2.forcePathStyle || false
+    });
+    this.bucket = config2.bucket;
+    this.initialized = true;
+    exports.logger.info("S3 service initialized", { bucket: this.bucket });
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      const region = exports.config.get("AWS_REGION") || "us-east-1";
+      const bucket = exports.config.get("AWS_S3_BUCKET") || "";
+      this.initialize({
+        region,
+        accessKeyId: exports.config.get("AWS_ACCESS_KEY_ID"),
+        secretAccessKey: exports.config.get("AWS_SECRET_ACCESS_KEY"),
+        bucket,
+        endpoint: exports.config.get("AWS_ENDPOINT")
+      });
+    }
+  }
+  async upload(file, options = {}) {
+    this.ensureInitialized();
+    const key = options.key || this.generateKey();
+    const contentType = options.contentType || this.guessContentType(key);
+    const command = new clientS3.PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: file,
+      ContentType: contentType,
+      Metadata: options.metadata
+    });
+    await this.client.send(command);
+    const url = await this.getSignedUrl(key, { expiresIn: options.expiresIn || 3600 });
+    exports.logger.info("File uploaded to S3", { key, bucket: this.bucket, contentType });
+    return {
+      key,
+      url,
+      bucket: this.bucket,
+      contentType
+    };
+  }
+  async uploadImage(file, filename, options = {}) {
+    const key = options.key || `images/${Date.now()}-${filename}`;
+    return this.upload(file, {
+      ...options,
+      key,
+      contentType: options.contentType || this.getImageContentType(filename)
+    });
+  }
+  async uploadVideo(file, filename, options = {}) {
+    const key = options.key || `videos/${Date.now()}-${filename}`;
+    return this.upload(file, {
+      ...options,
+      key,
+      contentType: options.contentType || this.getVideoContentType(filename)
+    });
+  }
+  async delete(key) {
+    this.ensureInitialized();
+    const command = new clientS3.DeleteObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    });
+    await this.client.send(command);
+    exports.logger.info("File deleted from S3", { key, bucket: this.bucket });
+  }
+  async getSignedUrl(key, options = {}) {
+    this.ensureInitialized();
+    const command = new clientS3.GetObjectCommand({
+      Bucket: this.bucket,
+      Key: key
+    });
+    return s3RequestPresigner.getSignedUrl(this.client, command, {
+      expiresIn: options.expiresIn || 3600
+    });
+  }
+  async getPublicUrl(key) {
+    return `https://${this.bucket}.s3.${exports.config.get("AWS_REGION") || "us-east-1"}.amazonaws.com/${key}`;
+  }
+  async listFiles(prefix, maxKeys = 1e3) {
+    this.ensureInitialized();
+    const command = new clientS3.ListObjectsV2Command({
+      Bucket: this.bucket,
+      Prefix: prefix,
+      MaxKeys: maxKeys
+    });
+    const response2 = await this.client.send(command);
+    return (response2.Contents || []).map((item) => ({
+      key: item.Key || "",
+      lastModified: item.LastModified,
+      size: item.Size
+    }));
+  }
+  generateKey() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 15);
+    return `uploads/${timestamp}-${random}`;
+  }
+  guessContentType(key) {
+    const ext = key.split(".").pop()?.toLowerCase();
+    const contentTypes = {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      mov: "video/quicktime",
+      avi: "video/x-msvideo",
+      pdf: "application/pdf",
+      json: "application/json",
+      txt: "text/plain"
+    };
+    return contentTypes[ext || ""] || "application/octet-stream";
+  }
+  getImageContentType(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const imageTypes = {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml"
+    };
+    return imageTypes[ext || ""] || "image/jpeg";
+  }
+  getVideoContentType(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const videoTypes = {
+      mp4: "video/mp4",
+      webm: "video/webm",
+      mov: "video/quicktime",
+      avi: "video/x-msvideo",
+      mkv: "video/x-matroska",
+      ogv: "video/ogg"
+    };
+    return videoTypes[ext || ""] || "video/mp4";
+  }
 };
-express.Response.prototype.paginated = function(data, page, limit, total) {
-  return ResponseHelper.paginated(this, data, page, limit, total);
+var s3Service = new S3Service();
+var upload = {
+  initialize: (config2) => s3Service.initialize(config2),
+  file: (file, options) => s3Service.upload(file, options),
+  image: (file, filename, options) => s3Service.uploadImage(file, filename, options),
+  video: (file, filename, options) => s3Service.uploadVideo(file, filename, options),
+  delete: (key) => s3Service.delete(key),
+  getSignedUrl: (key, options) => s3Service.getSignedUrl(key, options),
+  getPublicUrl: (key) => s3Service.getPublicUrl(key),
+  listFiles: (prefix, maxKeys) => s3Service.listFiles(prefix, maxKeys)
 };
-var response = ResponseHelper;
 
 // src/plugin.ts
 init_logger();
@@ -1299,5 +1488,7 @@ exports.notification = notification;
 exports.notify = notify;
 exports.rateLimit = rateLimit;
 exports.response = response;
+exports.s3Service = s3Service;
+exports.upload = upload;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map