@typetron/framework 0.5.21 → 0.5.22

package/Framework/Auth/index.ts

@@ -0,0 +1,29 @@
+import { Container, InjectableMetadata, Scope } from '../../Container'
+import { ControllerMetadata, MethodMetadata } from '../../Router/Metadata'
+
+export * from './Auth'
+export * from './User'
+export * from './Authenticatable'
+
+export const AuthUserIdentifier = Symbol('framework.auth:userIdentifier')
+
+export function AuthUser() {
+    return function(target: object, property: string, parameterIndex?: number) {
+        if (parameterIndex === undefined) {
+            const metadata = InjectableMetadata.get(target.constructor)
+            metadata.dependencies[property] = AuthUserIdentifier
+            metadata.scope = Scope.REQUEST
+            InjectableMetadata.set(metadata, target.constructor)
+        } else {
+            const metadata = ControllerMetadata.get(target.constructor)
+
+            const methodMetadata = metadata.methods[property] || new MethodMetadata()
+            methodMetadata.parametersOverrides[parameterIndex] = async function(container: Container) {
+                return await container.get(AuthUserIdentifier)
+            }
+            metadata.methods[property] = methodMetadata
+
+            ControllerMetadata.set(metadata, target.constructor)
+        }
+    }
+}

package/Framework/Config/AppConfig.ts

@@ -0,0 +1,25 @@
+import { BaseConfig } from './BaseConfig'
+import { GlobalMiddleware } from '../../Router'
+import { Abstract, Type } from '../../Support'
+import { Provider } from '../Provider'
+import { HttpMiddleware } from '@Typetron/Router/Http/Middleware'
+import { WebsocketMiddleware } from '@Typetron/Router/Websockets/Middleware'
+
+export class AppConfig extends BaseConfig<AppConfig> {
+    environment: string
+    server: 'node' | 'uNetworking' = 'node'
+    debug = true
+    port: number
+    websocketsPort?: number
+    middleware: {
+        global: Abstract<GlobalMiddleware>[],
+        http: Abstract<HttpMiddleware>[],
+        websocket: Abstract<WebsocketMiddleware>[],
+    } = {
+        global: [],
+        http: [],
+        websocket: [],
+    }
+    providers: Type<Provider> []
+    staticAssets?: {url: string, path: string, basePath?: boolean, indexFile?: string}[]
+}

package/Framework/Config/AuthConfig.ts

@@ -0,0 +1,11 @@
+import { User } from '../Auth'
+import { BaseConfig } from './BaseConfig'
+import { EntityKeys } from '@Typetron/Database'
+
+export class AuthConfig<T extends User> extends BaseConfig<AuthConfig<T>> {
+    entity: typeof User
+    signature: string
+    duration: number
+    saltRounds: number
+    identityColumn: EntityKeys<T>
+}

package/Framework/Config/BaseConfig.ts

@@ -0,0 +1,9 @@
+import { ChildObject } from '../../Support'
+
+export class BaseConfig<T> {
+    constructor(private newValues: Partial<ChildObject<T, BaseConfig<T>>>) {}
+
+    applyNewValues() {
+        Object.assign(this, this.newValues)
+    }
+}

package/Framework/Config/CacheConfig.ts

@@ -0,0 +1,38 @@
+import { BaseConfig } from './BaseConfig'
+
+export type CacheStoreKey = keyof CacheConfig['drivers']
+
+export class CacheConfig extends BaseConfig<CacheConfig> {
+    default: CacheStoreKey = process.env?.CACHE_DRIVER as CacheStoreKey ?? 'file'
+
+    drivers = {
+        file: {
+            path: 'cache/data',
+        },
+
+        memory: {},
+
+        database: {
+            table: 'cache',
+            connection: null,
+        },
+        //
+        // redis: {
+        //     connection: 'cache',
+        //     lock_connection: 'default',
+        // },
+        //
+        // memcached: {
+        //     persistent_id: process.env.MEMCACHED_PERSISTENT_ID,
+        //     sasl: [process.env.MEMCACHED_USERNAME, process.env.MEMCACHED_PASSWORD],
+        //     options: {
+        //         // Memcached::OPT_CONNECT_TIMEOUT : 2000,
+        //     },
+        //     servers: {
+        //         host: process.env.MEMCACHED_HOST ?? '127.0.0.1',
+        //         port: process.env.MEMCACHED_PORT ?? '11211',
+        //         weight: 100,
+        //     },
+        // },
+    }
+}

package/Framework/Config/DatabaseConfig.ts

@@ -0,0 +1,21 @@
+import { BaseConfig } from './BaseConfig'
+import { MysqlDriver, SqliteDriver } from '@Typetron/Database'
+import { DatabaseDriver } from '@Typetron/Database/Drivers/DatabaseDriver'
+
+export class DatabaseConfig extends BaseConfig<DatabaseConfig> {
+    synchronizeSchema = false
+    entities: string
+    migrationsDirectory = 'Database/migrations'
+    seedersDirectory = 'Database/seeders'
+    driver: keyof this['drivers'] = process.env.databaseDriver as keyof this['drivers'] ?? 'sqlite'
+
+    drivers: Record<string, () => DatabaseDriver> = {
+        sqlite: () => new SqliteDriver(process.env.database ?? 'database.sqlite'),
+        mysql: () => new MysqlDriver({
+            host: process.env.databaseHost,
+            user: process.env.databaseUser,
+            password: process.env.databasePassword,
+            database: process.env.database,
+        }),
+    }
+}

package/Framework/Config/MailConfig.ts

@@ -0,0 +1,30 @@
+import { BaseConfig } from './BaseConfig'
+
+export type Mailers = keyof MailConfig['mailers']
+
+export class MailConfig extends BaseConfig<MailConfig> {
+    default: Mailers = process.env?.MAILER as Mailers ?? 'memory'
+
+    from: {
+        email: string,
+        name?: string,
+    }
+
+    mailers: {
+        memory: any,
+
+        SendGrid?: {
+            key: string,
+        },
+        SES?: {
+            // TODO
+        },
+        Mailgun?: {
+            // TODO
+        },
+        Postmark?: {
+            // TODO
+        },
+
+    }
+}

package/Framework/Config/index.ts

@@ -0,0 +1,6 @@
+export * from './BaseConfig'
+export * from './AppConfig'
+export * from './AuthConfig'
+export * from './DatabaseConfig'
+export * from './CacheConfig'
+export * from './MailConfig'

package/Framework/Middleware/AuthMiddleware.ts

@@ -0,0 +1,31 @@
+import { Inject, Injectable } from '../../Container'
+import { RequestHandler } from '../../Router'
+import { Http, HttpError, Request } from '../../Router/Http'
+import * as jwt from 'jsonwebtoken'
+import { Auth } from '../Auth'
+import { HttpMiddleware } from '@Typetron/Router/Http/Middleware'
+
+@Injectable()
+export class AuthMiddleware implements HttpMiddleware {
+
+    @Inject()
+    auth: Auth
+
+    async handle(request: Request, next: RequestHandler) {
+        if (this.auth.identifier && this.auth.expiresAt > new Date()) {
+            return next(request)
+        }
+        const authHeader = request.headers.authorization || (request.body as Record<string, string>)?.token || ''
+        const token = authHeader.replace('Bearer ', '')
+        try {
+            await this.auth.verify(token)
+            return next(request)
+        } catch (error) {
+            if (error instanceof jwt.TokenExpiredError || error instanceof jwt.JsonWebTokenError) {
+                throw new HttpError('Unauthenticated', Http.Status.UNAUTHORIZED)
+            }
+            throw new HttpError((error as Error).message, Http.Status.BAD_REQUEST)
+        }
+    }
+
+}

package/Framework/Middleware/CorsMiddleware.ts

@@ -0,0 +1,32 @@
+import { Inject, Injectable } from '../../Container'
+import { RequestHandler } from '../../Router'
+import { ErrorHandlerInterface, Request, Response } from '../../Router/Http'
+import { HttpMiddleware } from '@Typetron/Router/Http/Middleware'
+
+@Injectable()
+export class CorsMiddleware extends HttpMiddleware {
+
+    @Inject()
+    errorHandler: ErrorHandlerInterface
+
+    async handle(request: Request, next: RequestHandler) {
+        let response: Response
+        if (request.method.toLowerCase() === 'options') {
+            response = new Response(undefined)
+            response.setHeaders({
+                'Access-Control-Allow-Methods': 'GET, PUT, PATCH, POST, DELETE',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+            })
+        } else {
+            try {
+                response = await next(request)
+            } catch (error) {
+                response = await this.errorHandler.handle(error as Error, request)
+            }
+        }
+
+        response.setHeader('Access-Control-Allow-Origin', '*')
+        return response
+    }
+
+}

package/Framework/Middleware/StaticAssetsMiddleware.ts

@@ -0,0 +1,76 @@
+import { Inject, Injectable } from '../../Container'
+import { RequestHandler, RouteNotFoundError } from '../../Router'
+import { Storage } from '../../Storage'
+import { Http, Request, Response } from '../../Router/Http'
+import { AppConfig } from '../Config'
+import * as path from 'path'
+import { HttpMiddleware } from '@Typetron/Router/Http/Middleware'
+
+@Injectable()
+export class StaticAssetsMiddleware extends HttpMiddleware {
+
+    @Inject()
+    appConfig: AppConfig
+
+    @Inject()
+    storage: Storage
+
+    mimeTypes: {[key: string]: string} = {
+        'txt': 'text/plain',
+        'js': 'text/javascript',
+        'html': 'text/html',
+        'css': 'text/css',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'png': 'image/png',
+        'webp': 'image/webp',
+        'gif': 'image/gif',
+    }
+
+    async handle(request: Request, next: RequestHandler) {
+        try {
+            return await next(request)
+        } catch (error) {
+            if (request.method.toLowerCase() === Http.Method.GET.toLowerCase() && error instanceof RouteNotFoundError) {
+                return this.loadStaticAsset(error, request)
+            }
+            throw error
+        }
+    }
+
+    async loadStaticAsset(error: RouteNotFoundError, request: Request): Promise<Response> {
+        const configs = this.appConfig.staticAssets ?? []
+        for (const config of configs) {
+            if (!request.uri.match(config.url)) {
+                continue
+            }
+
+            let realPath = path.join(config.path, request.uri)
+            let extension = path.extname(realPath).substring(1)
+            if (!extension) {
+                realPath = path.join(realPath, 'index.html')
+                extension = 'html'
+            }
+            if (!await this.storage.exists(realPath)) {
+                if (config.basePath) {
+                    const basePath = path.join(config.path, config.indexFile ?? 'index.html')
+
+                    return this.getResponse(basePath)
+                }
+
+                continue
+            }
+            return this.getResponse(realPath, extension)
+        }
+
+        throw error
+    }
+
+    private async getResponse(filePath: string, extension?: string) {
+        extension = extension ?? path.extname(filePath).substring(1)
+        const file = await this.storage.read(filePath)
+        const contentType = this.mimeTypes[extension || 'application/octet-stream'] || this.mimeTypes.txt
+        return new Response(file, Http.Status.OK, {'Content-type': contentType})
+    }
+}
+

package/Framework/Middleware/index.ts

@@ -0,0 +1,2 @@
+export * from './AuthMiddleware'
+export * from './CorsMiddleware'

package/Framework/Provider.ts

@@ -0,0 +1,9 @@
+import { Container, Inject } from '@Typetron/Container'
+
+export abstract class Provider {
+
+    @Inject()
+    public app: Container
+
+    abstract register(): void | Promise<void>;
+}

package/Framework/Providers/CacheProvider.ts

@@ -0,0 +1,28 @@
+'use strict'
+
+import { Container, Inject } from '@Typetron/Container'
+import { Cache, DatabaseStore, FileStore, MemoryStore } from '@Typetron/Cache'
+import { Storage } from '@Typetron/Storage'
+import { Provider } from '../Provider'
+import { CacheConfig, CacheStoreKey } from '../Config'
+
+const cacheStores: Record<CacheStoreKey, (...args: any[]) => Cache> = {
+    file: (app: Container, config: CacheConfig) => {
+        return new FileStore(app.get(Storage), config.drivers.file.path)
+    },
+    memory: () => {
+        return new MemoryStore()
+    },
+    database: (app: Container, config: CacheConfig) => {
+        return new DatabaseStore(config.drivers.database.table)
+    },
+}
+
+export class CacheProvider extends Provider {
+    @Inject()
+    config: CacheConfig
+
+    public register() {
+        this.app.set(Cache, cacheStores[this.config.default](this.app, this.config))
+    }
+}

package/Framework/Providers/DatabaseProvider.ts

@@ -0,0 +1,36 @@
+import { Provider } from '../Provider'
+import { DatabaseConfig } from '../Config'
+import { Inject } from '../../Container'
+import { Connection, Entity, Query } from '@Typetron/Database'
+import { Storage } from '../../Storage'
+
+export class DatabaseProvider extends Provider {
+
+    @Inject()
+    databaseConfig: DatabaseConfig
+
+    @Inject()
+    storage: Storage
+
+    async register() {
+        const driver = this.databaseConfig.drivers[this.databaseConfig.driver]
+        if (!driver) {
+            throw new Error(`Driver '${this.databaseConfig.driver}' is not defined in the 'database.drivers' config`)
+        }
+        Query.connection = new Connection(driver())
+        if (this.databaseConfig.synchronizeSchema) {
+            await this.synchronize(Query.connection)
+        }
+    }
+
+    private async synchronize(connection: Connection) {
+        const entityFiles = await this.storage.files(this.databaseConfig.entities, true)
+        const entitiesImports: (typeof Entity)[] = await Promise.all(
+            entityFiles.map(file => import(file.path))
+        )
+        const entitiesMetadata = entitiesImports.flatMap(item => Object.values(item).pluck('metadata'))
+
+        await connection.driver.schema.synchronize(entitiesMetadata)
+    }
+
+}

package/Framework/Providers/MailProvider.ts

@@ -0,0 +1,31 @@
+'use strict'
+
+import { Container, Inject } from '@Typetron/Container'
+import { Provider } from '../Provider'
+import { MailConfig, Mailers } from '../Config'
+import { Mailer, MemoryTransport } from '@Typetron/Mail'
+import { MailTransport } from '@Typetron/Mail/MailTransport'
+import { SendGridTransport } from '@Typetron/Mail/Transports/SendGridTransport'
+
+const mailers: Partial<Record<Mailers, (...args: any[]) => MailTransport>> = {
+    memory: (app: Container, config: MailConfig) => {
+        return new MemoryTransport()
+    },
+    SendGrid: (app: Container, config: MailConfig) => {
+        if (!config.mailers.SendGrid?.key) {
+            throw new Error('SendGrid key is not set')
+        }
+
+        return new SendGridTransport(config.mailers.SendGrid?.key)
+    },
+}
+
+export class MailProvider extends Provider {
+    @Inject()
+    config: MailConfig
+
+    public register() {
+        const transport = mailers[this.config.default]?.(this.app, this.config)
+        this.app.set(Mailer, new Mailer(this.config.from, transport))
+    }
+}

package/Framework/Providers/WebsocketsProvider.ts

@@ -0,0 +1,141 @@
+import { Provider } from '../Provider'
+import { Container, Inject } from '../../Container'
+import { AppConfig } from '../Config'
+import { App, WebSocket as uWebSocket } from 'uWebSockets.js'
+import { TextDecoder } from 'util'
+import { ErrorHandlerInterface, HttpError, Response } from '../../Router/Http'
+import { ActionErrorResponse, Handler, WebSocket } from '../../Router/Websockets'
+import { ActionRequest, ActionResponse } from '@Typetron/Router/Websockets'
+import { Request } from '@Typetron/Router/Websockets/Request'
+
+enum WebsocketMessageStatus {
+    OK = 'OK',
+    Error = 'Error',
+}
+
+export class WebsocketsProvider extends Provider {
+
+    @Inject()
+    appConfig: AppConfig
+
+    @Inject()
+    handler: Handler
+
+    @Inject()
+    errorHandler: ErrorHandlerInterface
+
+    sockets = new Map<string | number, WebSocket>()
+
+    register(): void | Promise<void> {
+        const port = this.appConfig.websocketsPort
+
+        if (!port) {
+            throw new Error('Please define a port for the Websockets server.')
+        }
+
+        const stringDecoder = new TextDecoder()
+
+        const app = App().get('/*', res => {
+            res.end('Typetron Websockets server. Please do not use this url. Work in progress')
+        }).ws('/', {
+
+            /* There are many common helper features */
+            idleTimeout: 40,
+            maxBackpressure: 1024 * 1000 * 5,   // 5 MB tolerance is safer
+            // maxPayloadLength: 1024 * 1000 * 20, // 20 MB per message
+            // compression: DEDICATED_COMPRESSOR_3KB,
+            // compression: DISABLED,
+            maxPayloadLength: 64 * 1024 * 1024,
+
+            open: (socket: uWebSocket<any>) => {
+                const socketWrapper = new WebSocket(socket, this.app.createChildContainer())
+                this.handler.onOpen?.run(socketWrapper.connection.container, {})
+            },
+            close: async (socket: uWebSocket<any>, code, message) => {
+                console.info('connection closed', code, Buffer.from(message).toString())
+                const extendedSocket = socket as uWebSocket<any> & {container: Container}
+                await this.handler.onClose?.run(extendedSocket.container, {}).catch(error => {
+                    console.info('socket close error ->', error)
+                })
+            },
+
+            /* For brevity we skip the other actions (upgrade, open, ping, pong, close) */
+            message: async (socket, message, isBinary) => {
+                let data: ActionRequest
+                try {
+                    const jsonData = stringDecoder.decode(message)
+                    data = JSON.parse(jsonData)
+                } catch (_error) {
+                    const error = _error as Error
+                    const errorMessage = {
+                        message: {
+                            message: error.message,
+                            stack: error.stack?.split('\n') ?? ['<could not generate stack>']
+                        },
+                        status: WebsocketMessageStatus.Error
+                    }
+                    socket.send(JSON.stringify(errorMessage), isBinary, true)
+                    return
+                }
+
+                try {
+                    const extendedSocket = socket as uWebSocket<any> & {container: Container}
+                    const response = await this.handleAction(extendedSocket.container, data)
+                    const action = data.action
+                    const sentResponse: ActionResponse<unknown> = {
+
+                        action,
+                        message: response.body,
+                        status: WebsocketMessageStatus.OK,
+
+                        $id: data['$id']
+                    }
+                    if (response.status >= 200 && response.status <= 399) {
+                        sentResponse.status = WebsocketMessageStatus.OK
+                    } else {
+                        sentResponse.status = WebsocketMessageStatus.Error
+                    }
+
+                    socket.send(JSON.stringify(sentResponse), isBinary, true)
+
+                } catch (err) {
+                    const error = err as HttpError
+                    const errorMessage: ActionErrorResponse = {
+                        '$id': data['$id'],
+                        message: {
+                            message: String(error.content ?? error.message),
+                            stack: error.stack?.split('\n') ?? ['could not generate stack']
+                        },
+                        action: data.action,
+                        status: WebsocketMessageStatus.Error
+                    }
+                    if (errorMessage.message) {
+                        const response = await this.errorHandler.handle(error) as Response<Error>
+                        errorMessage.message.message = response.body.message
+                    }
+                    console.error(errorMessage)
+                    socket.send(JSON.stringify(errorMessage), isBinary, true)
+                }
+
+            },
+            dropped: (ws, message) => {
+                console.info('socket dropped', ws.getUserData(), new TextDecoder().decode(message))
+            }
+
+        }).listen(port, (listenSocket) => {
+            if (listenSocket) {
+                console.info(`Websocket server started on port ${port}`)
+            }
+        })
+    }
+
+    private async handleAction(container: Container, {action, message}: ActionRequest) {
+        const request = new Request(action, message?.body)
+
+        // TODO find a way to save parameters so they can be retrieved easily in the Resolvers (check routeEntity resolver for example)
+        message?.parameters?.forEach(parameter => {
+            request.parameters[String.random(15)] = parameter
+        })
+        return this.handler.handle(container, request)
+    }
+}

package/Framework/Resolvers/AuthResolver.ts

@@ -0,0 +1,23 @@
+import { BaseResolver } from '../../Container'
+import { Auth, AuthUserIdentifier } from '../Auth'
+
+export class AuthResolver extends BaseResolver {
+
+    async resolve<T>(abstract: symbol, parameters: object[]): Promise<T> {
+        const auth = this.container.get(Auth)
+        if (!auth.identifier) {
+            return undefined as unknown as T
+        }
+        return await auth.user() as unknown as T
+    }
+
+    canResolve<T>(abstract: symbol): boolean {
+        return abstract === AuthUserIdentifier
+    }
+
+    // private setScopeToRequest() {
+    //     const metadata = InjectableMetadata.get(User);
+    //     metadata.scope = Scope.REQUEST;
+    //     InjectableMetadata.set(metadata, User);
+    // }
+}

package/Framework/Resolvers/EntityResolver.ts

@@ -0,0 +1,41 @@
+import { Constructor } from '../../Support'
+import { Entity, EntityConstructor } from '../../Database'
+import { Request } from '../../Router/Request'
+import { BaseResolver, Container, InjectableMetadata, Scope } from '../../Container'
+import { EntityNotFoundError } from '../../Database/EntityNotFoundError'
+
+export class EntityResolver extends BaseResolver {
+
+    constructor(container: Container) {
+        super(container)
+        this.setEntityScopeToRequest()
+    }
+
+    async resolve<T>(abstract: EntityConstructor<Entity> & typeof Entity, parametersValues: object[]): Promise<T> {
+        let entity: Entity | undefined
+        const request = this.container.get(Request)
+        const requestParameterName = abstract.name
+        const parameter = request.parameters[requestParameterName] ?? Number(parametersValues[0])
+        if (parameter) {
+            entity = await abstract.find(parameter)
+            if (!entity) {
+                throw new EntityNotFoundError(abstract, `Entity '${requestParameterName}' with ${abstract.getPrimaryKey()} '${parameter}' not found`)
+            }
+        } else {
+            throw new Error(`No parameter found that can be used as an entity identifier for the '${requestParameterName}' entity. Did you forget to add the '{${requestParameterName}}' parameter on the route?`)
+        }
+
+        // @ts-ignore
+        return entity
+    }
+
+    canResolve<T>(abstract: Constructor<T>): boolean {
+        return abstract.prototype instanceof Entity
+    }
+
+    private setEntityScopeToRequest() {
+        const metadata = InjectableMetadata.get(Entity)
+        metadata.scope = Scope.TRANSIENT
+        InjectableMetadata.set(metadata, Entity)
+    }
+}