@wabot-dev/framework 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/src/addon/rest-controller/jwt/JwtGuardMiddleware.js

@@ -0,0 +1,50 @@
+import { __decorate, __metadata } from 'tslib';
+import { CustomError } from '../../../core/error/CustomError.js';
+import { injectable } from '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import 'path';
+import 'debug';
+import '../../../feature/express/ExpressProvider.js';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { Auth } from '../../../feature/rest-controller/auth/Auth.js';
+import jwt from 'jsonwebtoken';
+import { JwtConfig } from './JwtConfig.js';
+
+let JwtGuardMiddleware = class JwtGuardMiddleware {
+    config;
+    auth;
+    constructor(config, auth) {
+        this.config = config;
+        this.auth = auth;
+    }
+    async handle(req, res, container) {
+        const authorization = req.header('Authorization');
+        if (!authorization) {
+            throw new CustomError({ httpCode: 401, message: 'Authorization header not available' });
+        }
+        const [bearer, token] = authorization.split(' ');
+        if (bearer.toLowerCase() !== 'bearer' || !token) {
+            throw new CustomError({ httpCode: 401, message: 'Authorization should be a bearer token' });
+        }
+        try {
+            const jwtPayload = jwt.verify(token, this.config.secretOrPublicKey, {
+                algorithms: [this.config.algorithm],
+            });
+            this.auth.assign(jwtPayload);
+        }
+        catch (err) {
+            throw new CustomError({
+                httpCode: 401,
+                message: err instanceof Error ? `Invalid token: ${err.message}` : 'Invalid token',
+                cause: err instanceof Error ? err : undefined,
+            });
+        }
+    }
+};
+JwtGuardMiddleware = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [JwtConfig,
+        Auth])
+], JwtGuardMiddleware);
+
+export { JwtGuardMiddleware };

package/dist/src/addon/rest-controller/jwt/JwtRefreshToken.js

@@ -0,0 +1,9 @@
+import { Entity } from '../../../core/entity/Entity.js';
+
+class JwtRefreshToken extends Entity {
+    get authInfo() {
+        return this.data.authInfo;
+    }
+}
+
+export { JwtRefreshToken };

package/dist/src/addon/rest-controller/jwt/JwtRefreshTokenRepository.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+import { Pool } from 'pg';
+import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+
+let JwtRefreshTokenRepository = class JwtRefreshTokenRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            schema: 'wabot',
+            table: 'jwt_refresh_token',
+            constructor: JwtRefreshToken,
+        });
+    }
+};
+JwtRefreshTokenRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], JwtRefreshTokenRepository);
+
+export { JwtRefreshTokenRepository };

package/dist/src/addon/rest-controller/jwt/JwtSigner.js

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from 'tslib';
+import { JwtConfig } from './JwtConfig.js';
+import jwt from 'jsonwebtoken';
+import { JwtTokenDto } from './JwtTokenDto.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+import { JwtAccessAndRefreshTokenDto } from './JwtAccessAndRefreshTokenDto.js';
+import { injectable } from '../../../core/injection/index.js';
+import { Mapper } from '../../../core/mapper/Mapper.js';
+
+let JwtSigner = class JwtSigner {
+    config;
+    mapper;
+    constructor(config, mapper) {
+        this.config = config;
+        this.mapper = mapper;
+    }
+    async signAccessToken(info) {
+        const _authInfo = info instanceof JwtRefreshToken
+            ? {
+                ...info.authInfo,
+                refreshTokenId: info.id,
+            }
+            : info;
+        const token = jwt.sign(_authInfo, this.config.secretOrPrivateKey, {
+            expiresIn: this.config.accessExpirationSeconds,
+        });
+        const expiration = new Date().getTime() + this.config.accessExpirationSeconds * 1000;
+        return this.mapper.map({ token, expiration }, JwtTokenDto);
+    }
+    async signRefreshToken(refreshToken) {
+        const token = jwt.sign({ refreshTokenId: refreshToken.id }, this.config.secretOrPrivateKey, {
+            expiresIn: this.config.refreshExpirationSeconds,
+        });
+        const expiration = new Date().getTime() + this.config.refreshExpirationSeconds * 1000;
+        return this.mapper.map({ token, expiration }, JwtTokenDto);
+    }
+    async signAccessAndRefreshToken(refreshToken) {
+        const access = await this.signAccessToken(refreshToken);
+        const refresh = await this.signRefreshToken(refreshToken);
+        return this.mapper.map({ access, refresh }, JwtAccessAndRefreshTokenDto);
+    }
+};
+JwtSigner = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [JwtConfig, Mapper])
+], JwtSigner);
+
+export { JwtSigner };

package/dist/src/addon/rest-controller/jwt/JwtTokenDto.js

@@ -0,0 +1,22 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../../core/injection/index.js';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { isDate } from '../../validation/is-date/@isDate.js';
+import { isNotEmpty } from '../../validation/is-not-empty/@isNotEmpty.js';
+import { isString } from '../../validation/is-string/@isString.js';
+
+class JwtTokenDto {
+    token;
+    expiration;
+}
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], JwtTokenDto.prototype, "token", void 0);
+__decorate([
+    isDate(),
+    __metadata("design:type", Date)
+], JwtTokenDto.prototype, "expiration", void 0);
+
+export { JwtTokenDto };

package/dist/src/addon/validation/is-boolean/@isBoolean.js

@@ -0,0 +1,17 @@
+import { container } from '../../../core/injection/index.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateIsBoolean } from './validateIsBoolean.js';
+
+function isBoolean() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsBoolean,
+        });
+    };
+}
+
+export { isBoolean };

package/dist/src/addon/validation/is-boolean/validateIsBoolean.js

@@ -0,0 +1,12 @@
+function validateIsBoolean(value) {
+    if (typeof value !== 'boolean') {
+        return {
+            error: { description: `boolean value is required` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsBoolean };

package/dist/src/addon/validation/is-date/@isDate.js

@@ -0,0 +1,17 @@
+import { container } from '../../../core/injection/index.js';
+import { validateIsDate } from './validateIsDate.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+
+function isDate() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsDate,
+        });
+    };
+}
+
+export { isDate };

package/dist/src/addon/validation/is-date/validateIsDate.js

@@ -0,0 +1,16 @@
+function validateIsDate(value) {
+    const _value = new Date(value);
+    const time = _value.getTime();
+    if ((typeof value !== 'number' && typeof value !== 'string' && !(value instanceof Date)) ||
+        isNaN(time) ||
+        time < 0) {
+        return {
+            error: { description: `Date value is not valid` },
+        };
+    }
+    return {
+        value: _value,
+    };
+}
+
+export { validateIsDate };

package/dist/src/addon/validation/is-not-empty/@isNotEmpty.js

@@ -0,0 +1,17 @@
+import { container } from '../../../core/injection/index.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateIsNotEmpty } from './validateIsNotEmpty.js';
+
+function isNotEmpty() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsNotEmpty,
+        });
+    };
+}
+
+export { isNotEmpty };

package/dist/src/addon/validation/is-not-empty/validateIsNotEmpty.js

@@ -0,0 +1,12 @@
+function validateIsNotEmpty(value) {
+    if (value === '' || (Array.isArray(value) && value.length === 0)) {
+        return {
+            error: { description: `empty value not allowed` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsNotEmpty };

package/dist/src/addon/validation/is-number/@isNumber.js

@@ -0,0 +1,17 @@
+import { container } from '../../../core/injection/index.js';
+import { validateIsNumber } from './validateIsNumber.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+
+function isNumber() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsNumber,
+        });
+    };
+}
+
+export { isNumber };

package/dist/src/addon/validation/is-number/validateIsNumber.js

@@ -0,0 +1,12 @@
+function validateIsNumber(value) {
+    if (typeof value !== 'number') {
+        return {
+            error: { description: `number value is required` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsNumber };

package/dist/src/addon/validation/is-present/@isPresent.js

@@ -0,0 +1,17 @@
+import { container } from '../../../core/injection/index.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateIsPresent } from './validateIsPresent.js';
+
+function isPresent() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsPresent,
+        });
+    };
+}
+
+export { isPresent };

package/dist/src/addon/validation/is-present/validateIsPresent.js

@@ -0,0 +1,12 @@
+function validateIsPresent(value) {
+    if (value == null) {
+        return {
+            error: { description: `not present` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsPresent };

package/dist/src/addon/validation/is-string/@isString.js

@@ -0,0 +1,17 @@
+import { container } from '../../../core/injection/index.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateIsString } from './validateIsString.js';
+
+function isString() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsString,
+        });
+    };
+}
+
+export { isString };

package/dist/src/addon/validation/is-string/validateIsString.js

@@ -0,0 +1,12 @@
+function validateIsString(value) {
+    if (typeof value !== 'string') {
+        return {
+            error: { description: `string value is required` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsString };

package/dist/src/addon/validation/max/@max.js

@@ -0,0 +1,18 @@
+import { container } from '../../../core/injection/index.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateMax } from './validateMax.js';
+
+function max(limit) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateMax,
+            validatorOptions: { limit },
+        });
+    };
+}
+
+export { max };

package/dist/src/addon/validation/max/validateMax.js

@@ -0,0 +1,17 @@
+function validateMax(value, options) {
+    if (value == null) {
+        return {
+            error: { description: `null or undefined value can't be validated with max` },
+        };
+    }
+    if (Number(value) > Number(options.limit)) {
+        return {
+            error: { description: `exceeds the established max limit` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateMax };

package/dist/src/addon/validation/min/@min.js

@@ -0,0 +1,18 @@
+import { container } from '../../../core/injection/index.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateMin } from './validateMin.js';
+
+function min(limit) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateMin,
+            validatorOptions: { limit },
+        });
+    };
+}
+
+export { min };

package/dist/src/addon/validation/min/validateMin.js

@@ -0,0 +1,17 @@
+function validateMin(value, options) {
+    if (value == null) {
+        return {
+            error: { description: `null or undefined value can't be validated with min` },
+        };
+    }
+    if (Number(value) < Number(options.limit)) {
+        return {
+            error: { description: `exceeds the established min limit` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateMin };

package/dist/src/core/{Persistent.js → entity/Entity.js}

@@ -1,22 +1,32 @@
-class Persistent {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-    getId() {
+import { Storable } from '../storable/Storable.js';
+
+class Entity extends Storable {
+    get id() {
         if (!this.data.id) {
             throw new Error('id is required');
         }
         return this.data.id;
     }
-    getCreatedAt() {
+    /**
+     * @deprecated use id
+     */
+    getId() {
+        return this.id;
+    }
+    get createdAt() {
         if (!this.data.createdAt) {
             throw new Error('createdAt is required');
         }
         return new Date(this.data.createdAt);
     }
+    /**
+     * @deprecated use createdAt
+     */
+    getCreatedAt() {
+        return this.createdAt;
+    }
     update(newData) {
-        this.data = newData;
+        this.data = { ...this.data, ...newData, updatedAt: new Date().getTime() };
     }
     wasCreated() {
         return !!this.data.createdAt || !!this.data.id;
@@ -33,5 +43,10 @@ class Persistent {
         this.data.discardedAt = new Date().getTime();
     }
 }
+/**
+ * @deprecated Should use Entity
+ */
+class Persistent extends Entity {
+}
 
-export { Persistent };
+export { Entity, Persistent };

package/dist/src/core/env/Env.js

@@ -0,0 +1,39 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from 'tsyringe';
+
+let Env = class Env {
+    envType;
+    constructor() {
+        this.envType = process.env.WABOT_ENV ?? 'development';
+    }
+    isDevelopment() {
+        return this.envType === 'development';
+    }
+    isProduction() {
+        return this.envType === 'production';
+    }
+    isTesting() {
+        return this.envType === 'testing';
+    }
+    requireString(varName, options) {
+        const value = process.env[varName] ?? options?.default;
+        if (!value)
+            throw new Error(`Env Variable ${varName} is required`);
+        return value;
+    }
+    requireNumber(varName, options) {
+        const strValue = this.requireString(varName, {
+            default: options?.default != null ? String(options.default) : undefined,
+        });
+        const value = Number(strValue);
+        if (isNaN(value))
+            throw new Error(`Env Variable ${varName} should have number format`);
+        return value;
+    }
+};
+Env = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], Env);
+
+export { Env };

package/dist/src/core/error/CustomError.js

@@ -0,0 +1,15 @@
+class CustomError extends Error {
+    humanMessage;
+    code;
+    httpCode;
+    info;
+    constructor(data) {
+        super(data.message, { cause: data.cause });
+        this.humanMessage = data.humanMessage;
+        this.code = data.code;
+        this.httpCode = data.httpCode;
+        this.info = data.info;
+    }
+}
+
+export { CustomError };

package/dist/src/core/injection/index.js

@@ -0,0 +1,4 @@
+await import('reflect-metadata');
+const { injectable, container, singleton, inject, scoped, Lifecycle } = await import('tsyringe');
+
+export { Lifecycle, container, inject, injectable, scoped, singleton };

package/dist/src/core/mapper/Mapper.js

@@ -0,0 +1,42 @@
+import { Storable } from '../storable/Storable.js';
+import { CustomError } from '../error/CustomError.js';
+import '../injection/index.js';
+import '../validation/metadata/ValidationMetadataStore.js';
+import { validate } from '../validation/validate.js';
+
+function deepCopyWithStorable(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return obj.getTime();
+    }
+    if (obj instanceof Storable) {
+        return deepCopyWithStorable(obj['data']);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepCopyWithStorable(item));
+    }
+    const copy = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            copy[key] = deepCopyWithStorable(obj[key]);
+        }
+    }
+    return copy;
+}
+class Mapper {
+    map(data, ctor) {
+        const validationResult = validate(deepCopyWithStorable(data), ctor);
+        if (validationResult.error) {
+            throw new CustomError({
+                httpCode: 500,
+                message: `Cant map value to ${ctor.name}`,
+                info: validationResult.error,
+            });
+        }
+        return validationResult.value;
+    }
+}
+
+export { Mapper };

package/dist/src/core/random/Random.js

@@ -0,0 +1,37 @@
+import { randomBytes } from 'node:crypto';
+
+const DIGITS = '0123456789';
+const CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+class Random {
+    static slug(name, options) {
+        const base = name
+            .toLowerCase()
+            .trim()
+            .replace(/[\s\_]+/g, '-') // spaces/underscores to hyphens
+            .replace(/[^a-z0-9\-]/g, '') // remove non-alphanumeric except hyphens
+            .replace(/\-+/g, '-') // collapse multiple hyphens
+            .replace(/^\-+|\-+$/g, ''); // trim hyphens from ends
+        const random = this.string(options.randomLength);
+        return `${base}-${random}`;
+    }
+    static string(length) {
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = bytes[i] % CHARSET.length;
+            result += CHARSET[index];
+        }
+        return result;
+    }
+    static numberCode(length) {
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = bytes[i] % 10; // 0–9
+            result += DIGITS[index];
+        }
+        return result;
+    }
+}
+
+export { Random };

package/dist/src/core/storable/Storable.js

@@ -0,0 +1,8 @@
+class Storable {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+}
+
+export { Storable };

package/dist/src/core/validation/metadata/@isArray.js

@@ -0,0 +1,18 @@
+import { container } from '../../injection/index.js';
+import { validateArray } from '../validators/validateArray.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+
+function isArray(options) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateArray,
+            validatorOptions: options,
+        });
+    };
+}
+
+export { isArray };