@wabot-dev/framework 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/src/{repository → addon/repository}/pg/PgCrudRepository.js

@@ -1,5 +1,6 @@
 import * as shortUUID from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
+import { CustomError } from '../../../core/error/CustomError.js';
 
 class PgCrudRepository extends PgRepositoryBase {
     config;
@@ -17,6 +18,26 @@ class PgCrudRepository extends PgRepositoryBase {
         const items = await this.query(sql, [id]);
         return items.at(0) ?? null;
     }
+    async findByIds(ids) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE id IN (${ids.map((_, i) => '$' + (i + 1)).join(',')})
+      LIMIT 1
+    `;
+        const items = await this.query(sql, ids);
+        return items;
+    }
+    async findOrThrow(id) {
+        const item = await this.find(id);
+        if (!item) {
+            throw new CustomError({
+                message: `Not found ${this.config.constructor.name} with id = '${id}'}`,
+                httpCode: 404,
+            });
+        }
+        return item;
+    }
     async findAll() {
         const sql = `
       SELECT ${this.columns}
@@ -46,10 +67,10 @@ class PgCrudRepository extends PgRepositoryBase {
          SET ${this.updates}
       WHERE id = $${this.columnsList.length + 1}
     `;
-        await this.exec(sql, [...this.values(item), item.getId()]);
+        await this.exec(sql, [...this.values(item), item.id]);
     }
     async discard(item) {
-        const _item = await this.find(item.getId());
+        const _item = await this.find(item.id);
         if (!_item) {
             throw new Error('Not found');
         }

package/dist/src/{repository → addon/repository}/pg/PgRepositoryBase.js

@@ -32,8 +32,8 @@ class PgRepositoryBase {
     }
     values(item) {
         return [
-            item.getId(),
-            item.getCreatedAt(),
+            item.id,
+            item.createdAt,
             JSON.stringify(item['data']),
             ...this.columnsList.slice(3).map((x) => this.addColumns[x].value(item)),
         ];

package/dist/src/addon/rest-controller/jwt/@jwtGuard.js

@@ -0,0 +1,17 @@
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { middleware } from '../../../feature/rest-controller/metadata/@middleware.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import '../../../feature/express/ExpressProvider.js';
+import 'express';
+import 'path';
+import { JwtGuardMiddleware } from './JwtGuardMiddleware.js';
+
+function jwtGuard() {
+    return function (target, propertyKey) {
+        middleware(JwtGuardMiddleware)(target, propertyKey);
+    };
+}
+
+export { jwtGuard };

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

@@ -0,0 +1,31 @@
+import { __decorate, __metadata } from 'tslib';
+import { JwtSigner } from './JwtSigner.js';
+import { JwtRefreshTokenRepository } from './JwtRefreshTokenRepository.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+import { injectable } from '../../../core/injection/index.js';
+import { Auth } from '../../../core/auth/Auth.js';
+
+let Jwt = class Jwt {
+    auth;
+    jwtSigner;
+    jwtRefreshTokenRepository;
+    constructor(auth, jwtSigner, jwtRefreshTokenRepository) {
+        this.auth = auth;
+        this.jwtSigner = jwtSigner;
+        this.jwtRefreshTokenRepository = jwtRefreshTokenRepository;
+    }
+    async createToken() {
+        const authInfo = this.auth.require();
+        const refreshToken = new JwtRefreshToken({ authInfo });
+        await this.jwtRefreshTokenRepository.create(refreshToken);
+        return await this.jwtSigner.signAccessAndRefreshToken(refreshToken);
+    }
+};
+Jwt = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Auth,
+        JwtSigner,
+        JwtRefreshTokenRepository])
+], Jwt);
+
+export { Jwt };

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

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import { isModel } from '../../../core/validation/metadata/@isModel.js';
+import '../../../core/injection/index.js';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { JwtTokenDto } from './JwtTokenDto.js';
+
+class JwtAccessAndRefreshTokenDto {
+    access;
+    refresh;
+}
+__decorate([
+    isModel(JwtTokenDto),
+    __metadata("design:type", JwtTokenDto)
+], JwtAccessAndRefreshTokenDto.prototype, "access", void 0);
+__decorate([
+    isModel(JwtTokenDto),
+    __metadata("design:type", JwtTokenDto)
+], JwtAccessAndRefreshTokenDto.prototype, "refresh", void 0);
+
+export { JwtAccessAndRefreshTokenDto };

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

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../../../core/env/Env.js';
+import { singleton } from '../../../core/injection/index.js';
+
+let JwtConfig = class JwtConfig {
+    secretOrPublicKey;
+    secretOrPrivateKey;
+    algorithm;
+    accessExpirationSeconds;
+    refreshExpirationSeconds;
+    constructor(env) {
+        this.algorithm = env.requireString('JWT_ALGORITHM', { default: 'HS256' });
+        this.secretOrPublicKey = env.requireString('JWT_SECRET');
+        this.secretOrPrivateKey = env.requireString('JWT_SECRET');
+        this.accessExpirationSeconds = env.requireNumber('JWT_ACCESS_EXPIRATION_SECONDS', {
+            default: 10 * 60,
+        });
+        this.refreshExpirationSeconds = env.requireNumber('JWT_REFRESH_EXPIRATION_SECONDS', {
+            default: 365 * 24 * 3600,
+        });
+    }
+};
+JwtConfig = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Env])
+], JwtConfig);
+
+export { JwtConfig };

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

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from 'tslib';
+import { CustomError } from '../../../core/error/CustomError.js';
+import { injectable } from '../../../core/injection/index.js';
+import jwt from 'jsonwebtoken';
+import { JwtConfig } from './JwtConfig.js';
+import { Auth } from '../../../core/auth/Auth.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/auth/Auth.js

@@ -0,0 +1,24 @@
+import { __decorate } from 'tslib';
+import { CustomError } from '../error/CustomError.js';
+import { scoped, Lifecycle } from '../injection/index.js';
+
+let Auth = class Auth {
+    authInfo = null;
+    require() {
+        if (!this.authInfo) {
+            throw new CustomError({ message: 'Unauthorized', httpCode: 401 });
+        }
+        return this.authInfo;
+    }
+    assign(authInfo) {
+        if (this.authInfo) {
+            throw new CustomError({ message: 'Authorization info already assigned', httpCode: 401 });
+        }
+        this.authInfo = authInfo;
+    }
+};
+Auth = __decorate([
+    scoped(Lifecycle.ContainerScoped)
+], Auth);
+
+export { Auth };

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 };