@hed-hog/core 0.0.4

package/src/file/provider/azure.provider.ts

@@ -0,0 +1,174 @@
+import {
+  BlobServiceClient,
+  ContainerSASPermissions,
+  generateBlobSASQueryParameters,
+  StorageSharedKeyCredential,
+} from '@azure/storage-blob';
+import { BadRequestException } from '@nestjs/common';
+import { AbstractProvider } from './abstract.provider';
+
+export class AzureProvider extends AbstractProvider {
+  constructor(private setting: Record<string, string>) {
+    super();
+    this.initValidation();
+  }
+
+  async initValidation() {
+    if (!this.setting['storage-abs-account']) {
+      throw new BadRequestException(
+        `You must set the storage-abs-account in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-abs-key']) {
+      throw new BadRequestException(
+        `You must set the storage-abs-key in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-abs-container']) {
+      throw new BadRequestException(
+        `You must set the storage-abs-container in the setting.`,
+      );
+    }
+
+    const blobServiceClient = await this.getClient();
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+
+    const exists = await containerClient.exists();
+    if (!exists) {
+      throw new BadRequestException(
+        `The container "${this.setting['storage-abs-container']}" does not exist.`,
+      );
+    }
+  }
+
+  async getClient() {
+    const sharedKeyCredential = new StorageSharedKeyCredential(
+      this.setting['storage-abs-account'],
+      this.setting['storage-abs-key'],
+    );
+    const blobServiceClient = new BlobServiceClient(
+      `https://${this.setting['storage-abs-account']}.blob.core.windows.net`,
+      sharedKeyCredential,
+    );
+    return blobServiceClient;
+  }
+
+  async uploadFromString(
+    destination: string,
+    filename: string,
+    fileContent: string,
+    mimetype = 'text/plain',
+  ): Promise<any> {
+    const blobServiceClient = await this.getClient();
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+    const filepath = [destination, this.getFilename(filename)].join('/');
+    const blobClient = containerClient.getBlockBlobClient(filepath);
+
+    await blobClient.upload(fileContent, fileContent.length, {
+      blobHTTPHeaders: { blobContentType: mimetype },
+    });
+    return `https://${this.setting['storage-abs-container']}.azureedge.net/${filepath}`;
+  }
+
+  async upload(destination: string, file: MulterFile): Promise<any> {
+    const blobServiceClient = await this.getClient();
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+    const filepath = [destination, this.getFilename(file.originalname)].join(
+      '/',
+    );
+    const blobClient = containerClient.getBlockBlobClient(filepath);
+
+    await blobClient.uploadData(file.buffer, {
+      blobHTTPHeaders: { blobContentType: file.mimetype },
+    });
+    return `https://${this.setting['storage-abs-container']}.azureedge.net/${filepath}`;
+  }
+
+  async delete(filepath: string): Promise<any> {
+    const url = new URL(filepath);
+
+    if (!url.pathname) {
+      throw new Error(`Invalid filepath "${filepath}" for S3`);
+    }
+
+    const blobServiceClient = await this.getClient();
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+    const blobClient = containerClient.getBlockBlobClient(
+      url.pathname.split('/').slice(1).join('/'),
+    );
+
+    return await blobClient.delete();
+  }
+
+  async readStream(filepath: string): Promise<any> {
+    const blobServiceClient = await this.getClient();
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+    const blobClient = containerClient.getBlockBlobClient(filepath);
+
+    const downloadBlockBlobResponse = await blobClient.download();
+    return downloadBlockBlobResponse.readableStreamBody;
+  }
+
+  async metaData(filepath: string): Promise<any> {
+    const blobServiceClient = await this.getClient();
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+    const blobClient = containerClient.getBlockBlobClient(filepath);
+
+    const properties = await blobClient.getProperties();
+    return properties;
+  }
+  async buffer(filepath: string): Promise<any> {
+    const blobServiceClient = await this.getClient();
+
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+
+    const blobClient = containerClient.getBlockBlobClient(filepath);
+
+    const buffer = await blobClient.downloadToBuffer();
+
+    return buffer;
+  }
+  async tempURL(filepath: string, expires?: number): Promise<any> {
+    const sharedKeyCredential = new StorageSharedKeyCredential(
+      this.setting['storage-abs-account'],
+      this.setting['storage-abs-key'],
+    );
+    const blobServiceClient = new BlobServiceClient(
+      `https://${this.setting['storage-abs-account']}.blob.core.windows.net`,
+      sharedKeyCredential,
+    );
+
+    const containerClient = blobServiceClient.getContainerClient(
+      this.setting['storage-abs-container'],
+    );
+    const blobClient = containerClient.getBlobClient(filepath);
+
+    const expiresOn = new Date(new Date().getTime() + expires * 1000);
+    const blobSAS = generateBlobSASQueryParameters(
+      {
+        containerName: this.setting['storage-abs-container'],
+        blobName: filepath,
+        permissions: ContainerSASPermissions.parse('r'),
+        expiresOn,
+      },
+      sharedKeyCredential,
+    ).toString();
+    return blobClient.url + '?' + blobSAS;
+  }
+}

package/src/file/provider/gcs.provider.ts

@@ -0,0 +1,108 @@
+import { Storage } from '@google-cloud/storage';
+import { BadRequestException } from '@nestjs/common';
+import { AbstractProvider } from './abstract.provider';
+
+export class GCSProvider extends AbstractProvider {
+  private storage: Storage;
+
+  constructor(private setting: Record<string, string>) {
+    super();
+    this.initValidation();
+  }
+
+  async initValidation() {
+    if (!this.setting['storage-gcs-keyfile']) {
+      throw new BadRequestException(
+        `You must set the storage-gcs-keyfile in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-gcs-bucket']) {
+      throw new BadRequestException(
+        `You must set the storage-gcs-bucket in the setting.`,
+      );
+    }
+
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+
+    const exists = await bucket.exists();
+    if (!exists[0]) {
+      throw new BadRequestException(
+        `The bucket "${this.setting['storage-gcs-bucket']}" does not exist.`,
+      );
+    }
+  }
+
+  async getClient() {
+    if (this.storage) {
+      return this.storage;
+    }
+
+    return (this.storage = new Storage({
+      keyFilename: this.setting['storage-gcs-keyfile'],
+    }));
+  }
+
+  async uploadFromString(
+    destination: string,
+    filename: string,
+    fileContent: string,
+    mimetype?: string,
+  ): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const file = bucket.file(destination + filename);
+
+    return file.save(fileContent, {
+      contentType: mimetype,
+    });
+  }
+  async upload(destination: string, file: MulterFile): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const fileObject = bucket.file(destination + file.originalname);
+
+    return fileObject.save(file.buffer, {
+      contentType: file.mimetype,
+    });
+  }
+  async readStream(filepath: string): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const file = bucket.file(filepath);
+
+    return file.createReadStream();
+  }
+  async delete(filepath: string): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const file = bucket.file(filepath);
+
+    return file.delete();
+  }
+  async metaData(filepath: string): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const file = bucket.file(filepath);
+
+    return file.getMetadata();
+  }
+  async buffer(filepath: string): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const file = bucket.file(filepath);
+
+    return file.download();
+  }
+  async tempURL(filepath: string, expires?: number): Promise<any> {
+    const storage = await this.getClient();
+    const bucket = storage.bucket(this.setting['storage-gcs-bucket']);
+    const file = bucket.file(filepath);
+
+    return file.getSignedUrl({
+      action: 'read',
+      expires: expires || 60 * 60,
+    });
+  }
+}

package/src/file/provider/local.provider.ts

@@ -0,0 +1,141 @@
+import { BadRequestException } from '@nestjs/common';
+import { createReadStream, existsSync, promises as fs } from 'fs';
+import { mkdir, unlink, writeFile } from 'fs/promises';
+import jsonwebtoken from 'jsonwebtoken';
+import * as path from 'path';
+import { join, sep } from 'path';
+import { Stream } from 'stream';
+import { AbstractProvider } from './abstract.provider';
+
+export class LocalProvider extends AbstractProvider {
+  constructor(private setting: Record<string, string>) {
+    super();
+    this.initValidation();
+  }
+
+  async initValidation() {
+    if (!this.setting['storage-local-path']) {
+      throw new BadRequestException(
+        `You must set the storage-local-path in the setting.`,
+      );
+    }
+
+    if (!existsSync(this.setting['storage-local-path'])) {
+      await this.createFolderRecursive(this.setting['storage-local-path']);
+    }
+  }
+
+  async createFolderRecursive(path: string) {
+    const folders = join(path).split(sep);
+    let currentPath = '';
+    for (const folder of folders) {
+      currentPath = join(currentPath, folder);
+      if (!existsSync(currentPath)) {
+        await mkdir(currentPath, { recursive: true });
+      }
+    }
+  }
+
+  async uploadFromString(
+    destination: string,
+    filename: string,
+    fileContent: string,
+    mimetype?: string,
+  ): Promise<any> {
+    const storagePath = join(this.setting['storage-local-path'], destination);
+
+    if (!storagePath) {
+      throw new BadRequestException(
+        `You must set the storage-local-path in the setting.`,
+      );
+    }
+
+    if (!existsSync(storagePath)) {
+      await this.createFolderRecursive(storagePath);
+    }
+
+    if (!existsSync(storagePath)) {
+      throw new BadRequestException(
+        `The storage path does not exist: ${storagePath}`,
+      );
+    }
+
+    const filePath = join(storagePath, this.getFilename(filename));
+
+    await writeFile(filePath, fileContent);
+
+    return filePath;
+  }
+
+  async upload(destination: string, file: MulterFile): Promise<any> {
+    const storagePath = join(this.setting['storage-local-path'], destination);
+
+    if (!storagePath) {
+      throw new BadRequestException(
+        `You must set the storage-local-path in the setting.`,
+      );
+    }
+
+    if (!existsSync(storagePath)) {
+      await this.createFolderRecursive(storagePath);
+    }
+
+    if (!existsSync(storagePath)) {
+      throw new BadRequestException(
+        `The storage path does not exist: ${storagePath}`,
+      );
+    }
+    const filePath = join(storagePath, this.getFilename(file.originalname));
+
+    await writeFile(filePath, file.buffer);
+
+    return filePath;
+  }
+
+  async delete(filepath: string): Promise<any> {
+    if (!existsSync(filepath)) {
+      throw new BadRequestException(`File not found: ${filepath}`);
+    }
+
+    return unlink(filepath);
+  }
+
+  async readStream(filepath: string): Promise<Stream> {
+    return createReadStream(filepath);
+  }
+
+  async metaData(filepath: string): Promise<any> {
+    if (!existsSync(filepath)) {
+      throw new BadRequestException(`File not found: ${filepath}`);
+    }
+
+    return {
+      size: (await this.buffer(filepath)).length,
+    };
+  }
+
+  async buffer(filepath: string): Promise<Buffer> {
+   const fullPath = path.resolve(filepath);
+
+  if (!existsSync(fullPath)) {
+    throw new BadRequestException(`File not found: ${fullPath}`);
+  }
+
+  return fs.readFile(fullPath);
+  }
+
+  async tempURL(filepath: string, expires = 3600): Promise<any> {
+    try {
+      const token = jsonwebtoken.sign(
+        { filepath },
+        {
+          expiresIn: expires,
+        },
+      );
+
+      return `http://localhost:5000/file/download/${token}`;
+    } catch (error) {
+      throw new BadRequestException(error);
+    }
+  }
+}

package/src/file/provider/provider.enum.ts

@@ -0,0 +1,6 @@
+export enum EnumProvider {
+  S3 = 's3',
+  LOCAL = 'local',
+  AZURE = 'abs',
+  GCS = 'gcs',
+}

package/src/file/provider/provider.factory.ts

@@ -0,0 +1,21 @@
+import { AbstractProvider } from './abstract.provider';
+import { AzureProvider } from './azure.provider';
+import { LocalProvider } from './local.provider';
+import { EnumProvider } from './provider.enum';
+import { S3Provider } from './s3.provider';
+
+export class ProviderFactory {
+  static create(
+    providerType: EnumProvider,
+    setting: Record<string, string>,
+  ): AbstractProvider {
+    switch (providerType) {
+      case EnumProvider.S3:
+        return new S3Provider(setting);
+      case EnumProvider.LOCAL:
+        return new LocalProvider(setting);
+      case EnumProvider.AZURE:
+        return new AzureProvider(setting);
+    }
+  }
+}

package/src/file/provider/s3.provider.ts

@@ -0,0 +1,204 @@
+import {
+    DeleteObjectCommand,
+    GetObjectCommand,
+    HeadBucketCommand,
+    HeadObjectCommand,
+    PutObjectCommand,
+    S3,
+    S3Client,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { BadRequestException } from '@nestjs/common';
+import { Readable } from 'stream';
+import { AbstractProvider } from './abstract.provider';
+
+export class S3Provider extends AbstractProvider {
+  private S3: S3 | undefined;
+  private S3Client: S3Client | undefined;
+
+  constructor(private setting: Record<string, string>) {
+    super();
+    this.initValidation();
+  }
+
+  async buffer(filepath: string): Promise<Buffer> {
+    const s3 = await this.getClient();
+    const url = new URL(filepath);
+    if (!url.pathname) {
+      throw new Error(`Invalid filepath "${filepath}" for S3`);
+    }
+    const command = new GetObjectCommand({
+      Bucket: this.setting['storage-s3-bucket'],
+      Key: url.pathname.split('/').slice(1).join('/'),
+    });
+    const result = await s3.send(command);
+    // @ts-ignore
+    const stream = result.Body as Readable;
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  async initValidation() {
+    if (!this.setting['storage-s3-key']) {
+      throw new BadRequestException(
+        `You must set the storage-s3-key in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-s3-secret']) {
+      throw new BadRequestException(
+        `You must set the storage-s3-secret in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-s3-region']) {
+      throw new BadRequestException(
+        `You must set the storage-s3-region in the setting.`,
+      );
+    }
+
+    if (!this.setting['storage-s3-bucket']) {
+      throw new BadRequestException(
+        `You must set the storage-s3-bucket in the setting.`,
+      );
+    }
+
+    const s3 = await this.getClient();
+
+    try {
+      await s3.send(
+        new HeadBucketCommand({
+          Bucket: this.setting['storage-s3-bucket'],
+        }),
+      );
+    } catch (error) {
+      throw new BadRequestException(
+        `The bucket "${this.setting['storage-s3-bucket']}" does not exist or you do not have access to it.`,
+      );
+    }
+  }
+
+  async getClient() {
+    if (this.S3) {
+      return this.S3;
+    }
+
+    this.S3Client = new S3Client({
+      credentials: {
+        accessKeyId: this.setting['storage-s3-key'],
+        secretAccessKey: this.setting['storage-s3-secret'],
+      },
+      region: this.setting['storage-s3-region'],
+    });
+
+    return (this.S3 = new S3({
+      credentials: {
+        accessKeyId: this.setting['storage-s3-key'],
+        secretAccessKey: this.setting['storage-s3-secret'],
+      },
+      region: this.setting['storage-s3-region'],
+    }));
+  }
+
+  async getS3Client() {
+    if (this.S3Client) {
+      return this.S3Client;
+    }
+    this.S3Client = new S3Client({
+      credentials: {
+        accessKeyId: this.setting['storage-s3-key'],
+        secretAccessKey: this.setting['storage-s3-secret'],
+      },
+      region: this.setting['storage-s3-region'],
+    });
+    return this.S3Client;
+  }
+
+  async uploadFromString(
+    destination: string,
+    filename: string,
+    fileContent: string,
+  ): Promise<any> {
+    const s3 = await this.getClient();
+    const command = new PutObjectCommand({
+      Bucket: this.setting['storage-s3-bucket'],
+      Key: [destination, this.getFilename(filename)].join('/'),
+      Body: fileContent,
+    });
+    await s3.send(command);
+    // S3 v3 não retorna Location diretamente, construa a URL:
+    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${destination}/${this.getFilename(filename)}`;
+  }
+
+  async upload(destination: string, file: MulterFile): Promise<any> {
+    const s3 = await this.getClient();
+    const command = new PutObjectCommand({
+      Bucket: this.setting['storage-s3-bucket'],
+      Key: [destination, this.getFilename(file.originalname)].join('/'),
+      Body: file.buffer,
+    });
+    await s3.send(command);
+    return `https://${this.setting['storage-s3-bucket']}.s3.${this.setting['storage-s3-region']}.amazonaws.com/${destination}/${this.getFilename(file.originalname)}`;
+  }
+
+  async delete(filepath: string): Promise<any> {
+    const s3 = await this.getClient();
+    const url = new URL(filepath);
+    if (!url.pathname) {
+      throw new Error(`Invalid filepath "${filepath}" for S3`);
+    }
+    await s3.send(
+      new DeleteObjectCommand({
+        Bucket: this.setting['storage-s3-bucket'],
+        Key: url.pathname.split('/').slice(1).join('/'),
+      }),
+    );
+    return true;
+  }
+
+  async readStream(filepath: string): Promise<Readable> {
+    const s3 = await this.getClient();
+    const url = new URL(filepath);
+    if (!url.pathname) {
+      throw new Error(`Invalid filepath "${filepath}" for S3`);
+    }
+    const command = new GetObjectCommand({
+      Bucket: this.setting['storage-s3-bucket'],
+      Key: url.pathname.split('/').slice(1).join('/'),
+    });
+    const result = await s3.send(command);
+    // @ts-ignore
+    return result.Body as Readable;
+  }
+
+  async metaData(filepath: string): Promise<any> {
+    const s3 = await this.getClient();
+    const url = new URL(filepath);
+    if (!url.pathname) {
+      throw new Error(`Invalid filepath "${filepath}" for S3`);
+    }
+    const command = new HeadObjectCommand({
+      Bucket: this.setting['storage-s3-bucket'],
+      Key: url.pathname.split('/').slice(1).join('/'),
+    });
+    const result = await s3.send(command);
+    return result; // returns metadata
+  }
+
+  async tempURL(filepath: string, expires = 3600): Promise<string> {
+    const s3Client = await this.getS3Client();
+    const url = new URL(filepath);
+    if (!url.pathname) {
+      throw new Error(`Invalid filepath "${filepath}" for S3`);
+    }
+    const command = new GetObjectCommand({
+      Bucket: this.setting['storage-s3-bucket'],
+      Key: url.pathname.split('/').slice(1).join('/'),
+    });
+    // Use S3Client instance for getSignedUrl
+    return await getSignedUrl(s3Client as any, command, { expiresIn: expires });
+  }
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+// Core Module
+export * from './core.module';
+
+// Auth Module
+export * from './auth/auth.service';
+export * from './auth/guards/auth.guard';
+
+// Menu Module
+export * from './menu/menu.service';
+
+// Permission Module
+export * from './role/guards/role.guard';
+export * from './role/role.service';
+
+// Screen Module
+export * from './screen/screen.service';
+
+// User Module
+export * from './user/constants/user.constants';
+export * from './user/user.service';
+
+export * from './mail/mail.module';
+export * from './mail/mail.service';
+
+export * from './setting/setting.service';
+