@typetron/framework 0.5.22 → 0.5.25

package/Framework/Auth/index.ts

@@ -1,29 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

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

package/Framework/Middleware/AuthMiddleware.ts

@@ -1,31 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

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

package/Framework/Provider.ts

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

package/Framework/Providers/CacheProvider.ts

@@ -1,28 +0,0 @@
-'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

@@ -1,36 +0,0 @@
-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

@@ -1,31 +0,0 @@
-'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

@@ -1,141 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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)
-    }
-}