saas-backend-kit 1.0.0 → 1.0.1

package/dist/index.js

@@ -7,6 +7,8 @@ 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 +70,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;
@@ -1154,6 +1161,180 @@ express.Response.prototype.paginated = function(data, page, limit, total) {
 };
 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";
+  }
+};
+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)
+};
+
 // src/plugin.ts
 init_logger();
 init_config();
@@ -1299,5 +1480,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