pangea-server 1.0.1

package/dist/database/model-decorators/relations.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasMany = exports.HasOne = exports.BelongsTo = void 0;
+const seq = __importStar(require("sequelize-typescript"));
+exports.BelongsTo = getRelation(seq.BelongsTo);
+exports.HasOne = getRelation(seq.HasOne);
+exports.HasMany = getRelation(seq.HasMany);
+// internal functions
+function getRelation(relationFn) {
+    return function (getModelFn, options = {}) {
+        return function (target, propertyName) {
+            const { foreignKey, ...relOptions } = options;
+            relationFn(getModelFn, { as: propertyName, ...(foreignKey && { foreignKey }) })(target, propertyName);
+            const model = target.constructor;
+            const { eager = relationFn !== seq.HasMany, required = relationFn === seq.BelongsTo ? !model.Columns[`${propertyName}Id`].allowNull : false, paranoid = relationFn !== seq.BelongsTo, joinDepth = 1, ...restOptions } = relOptions;
+            model.AddRelation(propertyName, { model: getModelFn(), eager, required, paranoid, joinDepth, ...restOptions });
+        };
+    };
+}

package/dist/database/model-decorators/string-columns.d.ts

@@ -0,0 +1,9 @@
+import type { ColGeneralOptions, ColNullable, ColOptional } from './decorators.types';
+type ColStrOptions = ColGeneralOptions & ColOptional & {
+    minLength?: number;
+    maxLength?: number;
+    regex?: RegExp;
+};
+export declare function ColStr(options?: ColStrOptions & ColNullable): (target: any, propertyName: string) => void;
+export declare function ColText(options?: ColStrOptions): (target: any, propertyName: string) => void;
+export {};

package/dist/database/model-decorators/string-columns.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColText = exports.ColStr = void 0;
+const seq = __importStar(require("sequelize-typescript"));
+const column_1 = require("./column");
+// resources
+const refs_1 = require("../../resources/refs");
+function ColStr(options = {}) {
+    const { maxLength = refs_1.refs.stringLengths.medium, ...restOptions } = options;
+    return getStrColumn(seq.DataType.STRING(maxLength), { ...restOptions, maxLength });
+}
+exports.ColStr = ColStr;
+function ColText(options) {
+    return getStrColumn(seq.DataType.TEXT, options);
+}
+exports.ColText = ColText;
+// internal functions
+function getStrColumn(type, options = {}) {
+    const { minLength = 0, maxLength = Infinity, regex, ...restOptions } = options;
+    return (0, column_1.Column)(type, {
+        ...restOptions,
+        fallbackDefaultValue: '',
+        validate: {
+            len: [minLength, maxLength],
+            ...(regex ? { is: regex } : {}),
+        },
+    });
+}

package/dist/database/model-decorators/table.d.ts

@@ -0,0 +1,6 @@
+import type { Index } from '../database.types';
+type TableOptions = {
+    indexes?: Index[];
+};
+export declare function Table(tableName: string, options?: TableOptions): (target: BaseModelCtor) => void;
+export {};

package/dist/database/model-decorators/table.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = void 0;
+const seq = __importStar(require("sequelize-typescript"));
+// helpers
+const pangea_helpers_1 = require("pangea-helpers");
+function Table(tableName, options = {}) {
+    const { indexes } = options;
+    return function (target) {
+        const tableIndexes = indexes || [];
+        const columnIndexes = target.ColumnIndexes;
+        const allIndexes = [...tableIndexes, ...columnIndexes];
+        seq.Table({
+            tableName,
+            charset: 'utf8mb4',
+            collate: 'utf8mb4_general_ci',
+            underscored: true,
+            timestamps: true,
+            paranoid: true,
+            indexes: allIndexes.map(({ field, fields, ...restIndex }) => {
+                return {
+                    ...restIndex,
+                    fields: fields ? fields.map(pangea_helpers_1.camelToSnake) : field ? [(0, pangea_helpers_1.camelToSnake)(field)] : [],
+                };
+            }),
+        })(target);
+        const excludedAttributes = target.ExcludedAttributes;
+        if (!excludedAttributes.length)
+            return;
+        seq.DefaultScope(() => ({ attributes: { exclude: excludedAttributes } }))(target);
+        seq.Scopes(() => ({ withExcludedAttributes: { attributes: { include: excludedAttributes } } }))(target);
+    };
+}
+exports.Table = Table;

package/dist/database/models/base-model.class.d.ts

@@ -0,0 +1,33 @@
+import { Model, Column } from 'sequelize-typescript';
+import type { Index, DefaultValue, GetModelFn } from '../database.types';
+type Column = {
+    allowNull: boolean;
+    defaultValue: DefaultValue | undefined;
+};
+type Columns = Record<string, Column>;
+type Relation = {
+    getModelFn: GetModelFn;
+    eager: boolean;
+    required: boolean;
+    paranoid: boolean;
+    joinDepth: number;
+};
+type Relations = Record<string, Relation>;
+export declare abstract class BaseModel extends Model {
+    private static __ExcludedAttributes?;
+    private static __Columns?;
+    private static __ColumnIndexes?;
+    private static __Relations?;
+    id: ModelId;
+    static get ExcludedAttributes(): string[];
+    static get Columns(): Columns;
+    static get ColumnIndexes(): Index[];
+    static get Relations(): Relations;
+    static AddExcludedAttribute(attribute: string): void;
+    static AddColumn(colName: string, col: Column): void;
+    static AddColumnIndex(index: Index): void;
+    static AddRelation(relName: string, rel: Relation): void;
+    static __SetObject(key: string): void;
+    static __SetArray(key: string): void;
+}
+export {};

package/dist/database/models/base-model.class.js

@@ -0,0 +1,76 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModel = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+class BaseModel extends sequelize_typescript_1.Model {
+    static get ExcludedAttributes() {
+        return this.__ExcludedAttributes || [];
+    }
+    static get Columns() {
+        return this.__Columns || {};
+    }
+    static get ColumnIndexes() {
+        return this.__ColumnIndexes || [];
+    }
+    static get Relations() {
+        return this.__Relations || {};
+    }
+    static AddExcludedAttribute(attribute) {
+        this.__SetArray('__ExcludedAttributes');
+        this.__ExcludedAttributes.push(attribute);
+    }
+    static AddColumn(colName, col) {
+        this.__SetObject('__Columns');
+        this.__Columns[colName] = col;
+    }
+    static AddColumnIndex(index) {
+        this.__SetArray('__ColumnIndexes');
+        this.__ColumnIndexes.push(index);
+    }
+    static AddRelation(relName, rel) {
+        this.__SetObject('__Relations');
+        this.__Relations[relName] = rel;
+    }
+    static __SetObject(key) {
+        if (Object.prototype.hasOwnProperty.call(this, key))
+            return;
+        const result = {};
+        let current = Object.getPrototypeOf(this);
+        while (current && current !== Function.prototype) {
+            const inherited = current[key];
+            if (inherited)
+                Object.assign(result, inherited);
+            current = Object.getPrototypeOf(current);
+        }
+        this[key] = result;
+    }
+    static __SetArray(key) {
+        if (Object.prototype.hasOwnProperty.call(this, key))
+            return;
+        const result = [];
+        let current = Object.getPrototypeOf(this);
+        while (current && current !== Function.prototype) {
+            const inherited = current[key];
+            if (inherited)
+                result.unshift(...inherited);
+            current = Object.getPrototypeOf(current);
+        }
+        this[key] = result;
+    }
+}
+exports.BaseModel = BaseModel;
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    sequelize_typescript_1.AutoIncrement,
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Number)
+], BaseModel.prototype, "id", void 0);

package/dist/database/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-model.class';
+export * from './user.model';

package/dist/database/models/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base-model.class"), exports);
+__exportStar(require("./user.model"), exports);

package/dist/database/models/user.model.d.ts

@@ -0,0 +1,5 @@
+import { BaseModel } from './base-model.class';
+export declare abstract class User extends BaseModel {
+    username: string;
+    password?: ColExcluded<string>;
+}

package/dist/database/models/user.model.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const base_model_class_1 = require("./base-model.class");
+const decorators_1 = require("../decorators");
+class User extends base_model_class_1.BaseModel {
+}
+exports.User = User;
+__decorate([
+    decorators_1.col.Str({ unique: true, minLength: 8, maxLength: 'short' }),
+    __metadata("design:type", String)
+], User.prototype, "username", void 0);
+__decorate([
+    decorators_1.col.Str({ exclude: true, maxLength: 'medium' }),
+    __metadata("design:type", Object)
+], User.prototype, "password", void 0);

package/dist/database/seed.helpers.d.ts

@@ -0,0 +1,4 @@
+import type { Models, Seeds } from './database.types';
+export declare function dropTables(): Promise<void>;
+export declare function syncTables(): Promise<void>;
+export declare function seedTables<M extends Models>(models: M, seeds: Seeds<M>): Promise<void>;

package/dist/database/seed.helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedTables = exports.syncTables = exports.dropTables = void 0;
+const db_client_1 = require("./db-client");
+const db_class_1 = require("./db.class");
+// helpers
+const helpers_1 = require("../helpers");
+async function dropTables() {
+    (0, helpers_1.printInfo)('database', 'dropping tables...');
+    const dbClient = (0, db_client_1.getDbClient)();
+    await dbClient.drop();
+    (0, helpers_1.printSuccess)('database', 'tables dropped');
+}
+exports.dropTables = dropTables;
+async function syncTables() {
+    const dbClient = (0, db_client_1.getDbClient)();
+    await dbClient.sync();
+}
+exports.syncTables = syncTables;
+async function seedTables(models, seeds) {
+    (0, helpers_1.printInfo)('database', 'seeding tables...');
+    const modelsToSeed = Object.values(models)
+        .filter(() => (0, helpers_1.getEnvBool)('DB_INCLUDE_TESTING_SEEDS'))
+        .map((model) => model.name);
+    const modelsWithData = modelsToSeed.filter((modelName) => seeds[modelName]?.length);
+    const tx = await (0, db_client_1.getDbClient)().transaction();
+    const db = new db_class_1.Db(tx);
+    try {
+        await db.disableForeignKeyChecks();
+        await Promise.all(modelsWithData.map(async (modelName) => {
+            const data = seeds[modelName];
+            await db.insertMany(models[modelName], data);
+        }));
+        await db.enableForeignKeyChecks();
+        await tx.commit();
+    }
+    catch (err) {
+        await db.enableForeignKeyChecks();
+        await tx.rollback();
+        throw err;
+    }
+    (0, helpers_1.printSuccess)('database', 'tables seeded');
+}
+exports.seedTables = seedTables;

package/dist/helpers/console.helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function printInfo(label: string | undefined, msg: string): void;
+export declare function printSuccess(label: string | undefined, msg: string): void;
+export declare function printWarning(label: string | undefined, warning: string | Error): void;
+type PrintDangerConfig = {
+    printError?: boolean;
+};
+export declare function printDanger(label: string | undefined, danger: string | Error, config?: PrintDangerConfig): void;
+export {};

package/dist/helpers/console.helpers.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printDanger = exports.printWarning = exports.printSuccess = exports.printInfo = void 0;
+function printInfo(label, msg) {
+    const finalLabel = label || 'info';
+    console.log(`\x1b[34m[${finalLabel}]\x1b[0m`, msg);
+}
+exports.printInfo = printInfo;
+function printSuccess(label, msg) {
+    const finalLabel = label || 'success';
+    console.log(`\x1b[32m[${finalLabel}]\x1b[0m`, msg);
+}
+exports.printSuccess = printSuccess;
+function printWarning(label, warning) {
+    const finalLabel = label || 'warning';
+    const msg = warning instanceof Error ? `${warning.name}: ${warning.message}` : warning;
+    console.warn(`\x1b[33m[${finalLabel}]\x1b[0m`, msg);
+}
+exports.printWarning = printWarning;
+function printDanger(label, danger, config) {
+    const { printError } = config || {};
+    const finalLabel = label || 'danger';
+    const isError = danger instanceof Error;
+    const msg = isError ? `${danger.name}: ${danger.message}` : danger;
+    console.error(`\x1b[31m[${finalLabel}]\x1b[0m`, msg);
+    if (isError && printError)
+        console.error(danger);
+}
+exports.printDanger = printDanger;

package/dist/helpers/controllers.helpers.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class BaseController {
+}

package/dist/helpers/controllers.helpers.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseController = void 0;
+class BaseController {
+}
+exports.BaseController = BaseController;

package/dist/helpers/env.helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function getEnvStr(key: string, raiseException?: boolean): string;
+export declare function getEnvInt(key: string, raiseException?: boolean): number;
+export declare function getEnvFloat(key: string, raiseException?: boolean): number;
+export declare function getEnvBool(key: string, raiseException?: boolean): boolean;

package/dist/helpers/env.helpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvBool = exports.getEnvFloat = exports.getEnvInt = exports.getEnvStr = void 0;
+const dotenv_1 = require("dotenv");
+// init dotenv
+(0, dotenv_1.config)();
+function __getEnv(key, raiseException) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (raiseException)
+            throw new Error(`${key} key is required in the .env file`);
+        return '';
+    }
+    return value;
+}
+function getEnvStr(key, raiseException = true) {
+    return __getEnv(key, raiseException);
+}
+exports.getEnvStr = getEnvStr;
+function getEnvInt(key, raiseException = true) {
+    return parseInt(__getEnv(key, raiseException));
+}
+exports.getEnvInt = getEnvInt;
+function getEnvFloat(key, raiseException = true) {
+    return parseFloat(__getEnv(key, raiseException));
+}
+exports.getEnvFloat = getEnvFloat;
+function getEnvBool(key, raiseException = false) {
+    const value = __getEnv(key, raiseException);
+    return value.toLowerCase() === 'true';
+}
+exports.getEnvBool = getEnvBool;

package/dist/helpers/error.helpers.d.ts

@@ -0,0 +1,20 @@
+import type { StatusCodeName, StatusCode, ErrorCode } from '../types/error.types';
+type AppErrorCtor = {
+    statusCodeName: StatusCodeName;
+    errorCode: ErrorCode;
+    err?: Error;
+    message?: string;
+};
+export declare class AppError extends Error {
+    name: string;
+    statusCode: StatusCode;
+    errorCode: ErrorCode;
+    originalError?: Error;
+    message: string;
+    constructor(config: AppErrorCtor);
+    static Throw(config: AppErrorCtor): never;
+    static ThrowEntityNotFound(): never;
+    static ThrowUnauthorized(): never;
+    static ThrowInvalidCredentials(): never;
+}
+export {};

package/dist/helpers/error.helpers.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = void 0;
+const http_status_codes_1 = require("http-status-codes");
+class AppError extends Error {
+    constructor(config) {
+        super();
+        this.name = 'AppError';
+        const { statusCodeName, errorCode, err, message } = config;
+        this.statusCode = http_status_codes_1.StatusCodes[statusCodeName];
+        this.errorCode = errorCode;
+        if (err)
+            this.originalError = err;
+        this.message = message || err?.message || errorCode;
+    }
+    static Throw(config) {
+        throw new AppError(config);
+    }
+    static ThrowEntityNotFound() {
+        this.Throw({ statusCodeName: 'NOT_FOUND', errorCode: 'ENTITY_NOT_FOUND' });
+    }
+    static ThrowUnauthorized() {
+        this.Throw({ statusCodeName: 'UNAUTHORIZED', errorCode: 'UNAUTHORIZED', message: 'Unauthorized access' });
+    }
+    static ThrowInvalidCredentials() {
+        this.Throw({ statusCodeName: 'UNAUTHORIZED', errorCode: 'INVALID_CREDENTIALS', message: 'Invalid credentials' });
+    }
+}
+exports.AppError = AppError;

package/dist/helpers/file.helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function deleteFile(fileName: string | null | undefined): Promise<void>;
+export declare function deleteFiles(fileNames: string[]): Promise<void[]>;
+export declare function uploadImage(image: UploadableImage | undefined, previousImage: string | null | undefined, ...folders: string[]): Promise<string>;
+export declare function uploadImages(images: UploadableImage[] | undefined, ...folders: string[]): Promise<string[]>;

package/dist/helpers/file.helpers.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadImages = exports.uploadImage = exports.deleteFiles = exports.deleteFile = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const aws_sdk_1 = __importDefault(require("aws-sdk"));
+const sharp_1 = __importDefault(require("sharp"));
+// helpers
+const error_helpers_1 = require("./error.helpers");
+const print_helpers_1 = require("./print.helpers");
+const env_helpers_1 = require("./env.helpers");
+const random_helpers_1 = require("./random.helpers");
+const bucketName = (() => {
+    const appName = (0, env_helpers_1.getEnvStr)('APP_NAME');
+    const environment = (0, env_helpers_1.getEnvStr)('ENVIRONMENT');
+    if (environment === 'production')
+        return appName;
+    return `${appName}-${environment}`;
+})();
+const endpointUrl = 'nyc3.digitaloceanspaces.com';
+const s3 = new aws_sdk_1.default.S3({
+    endpoint: new aws_sdk_1.default.Endpoint(endpointUrl),
+    accessKeyId: (0, env_helpers_1.getEnvStr)('DIGITAL_OCEAN_SPACES_ACCESS_KEY'),
+    secretAccessKey: (0, env_helpers_1.getEnvStr)('DIGITAL_OCEAN_SPACES_SECRET_KEY'),
+});
+async function deleteFile(fileName) {
+    if (!fileName)
+        return;
+    await s3
+        .deleteObject({
+        Bucket: bucketName,
+        Key: fileName,
+    })
+        .promise();
+    (0, print_helpers_1.printInfo)('file', `file deleted from ${fileName}`);
+}
+exports.deleteFile = deleteFile;
+async function deleteFiles(fileNames) {
+    return Promise.all(fileNames.map((fileName) => deleteFile(fileName)));
+}
+exports.deleteFiles = deleteFiles;
+async function uploadImage(image, previousImage, ...folders) {
+    if (!image)
+        error_helpers_1.AppError.Throw({ statusCodeName: 'BAD_REQUEST', errorCode: 'IMAGE_NOT_SENT' });
+    await deleteFile(previousImage);
+    const imageBuffer = typeof image === 'string' ? await promises_1.default.readFile(path_1.default.join(process.cwd(), image)) : image.buffer;
+    const max_size_kb = 200;
+    const max_size_bytes = max_size_kb * 1024;
+    const qualityRatio = imageBuffer.length > max_size_bytes ? max_size_bytes / imageBuffer.length : 1;
+    const qualityMultiplier = 2;
+    const targetQuality = Math.floor(qualityRatio * 100 * qualityMultiplier);
+    const quality = Math.max(10, Math.min(100, targetQuality));
+    const bufferCompressed = await (0, sharp_1.default)(imageBuffer)
+        .png({
+        quality,
+    })
+        .toBuffer();
+    const params = {
+        Bucket: bucketName,
+        Key: `${folders.join('/')}/${(0, random_helpers_1.getRandomString)('short')}`,
+        Body: bufferCompressed,
+        ContentType: 'image/jpeg',
+        ACL: 'public-read',
+    };
+    const res = await s3.upload(params).promise();
+    (0, print_helpers_1.printInfo)('file', `file uploaded to ${res.Location}`);
+    return res.Key;
+}
+exports.uploadImage = uploadImage;
+async function uploadImages(images, ...folders) {
+    if (!images)
+        error_helpers_1.AppError.Throw({ statusCodeName: 'BAD_REQUEST', errorCode: 'IMAGES_NOT_SENT' });
+    return Promise.all(images.map((image) => uploadImage(image, undefined, ...folders)));
+}
+exports.uploadImages = uploadImages;

package/dist/helpers/hashing.helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function hashPassword(pass: string): Promise<string>;
+export declare function comparePasswords(plainPass: string, encryptedPass: string): Promise<boolean>;

package/dist/helpers/hashing.helpers.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comparePasswords = exports.hashPassword = void 0;
+const bcrypt_1 = __importDefault(require("bcrypt"));
+async function hashPassword(pass) {
+    const saltRounds = 10;
+    return await bcrypt_1.default.hash(pass, saltRounds);
+}
+exports.hashPassword = hashPassword;
+async function comparePasswords(plainPass, encryptedPass) {
+    return await bcrypt_1.default.compare(plainPass, encryptedPass);
+}
+exports.comparePasswords = comparePasswords;

package/dist/helpers/html-sanitize.helpers.d.ts

@@ -0,0 +1,4 @@
+import { type StringLength } from '../resources';
+export declare function sanitizeHtml(html: string): string;
+export declare function removeHtmlTags(html: string): string;
+export declare function getHtmlSanitized(html: string | null, maxLength?: StringLength | number): string | null;