@typetron/framework 0.5.22 → 0.5.24

package/Testing/TestCase.ts

@@ -1,193 +0,0 @@
-import '../Support/Math'
-import { ErrorHandlerInterface, Handler as HTTPHandler, Http, HttpError, Request as HttpRequest, Response } from '../Router/Http'
-import { IncomingHttpHeaders } from 'http'
-import { Application, DatabaseProvider } from '../Framework'
-import { Router } from '../Router'
-import { Auth, User } from '../Framework/Auth'
-import { ActionRequest } from '../Router/Websockets/types'
-import { Handler as WebsocketsHandler, WebSocket } from '../Router/Websockets'
-import { Container } from '../Container'
-import { ID } from '@Typetron/Database'
-import { anything, instance, mock, when } from 'ts-mockito'
-import { Crypt } from '@Typetron/Encryption'
-import { Request } from '@Typetron/Router/Request'
-import { HttpRoute } from '@Typetron/Router/Http/HttpRoute'
-
-export abstract class TestCase {
-    static app: Application
-    app: Container
-
-    // tslint:disable-next-line:no-any
-    actionListeners = new Map<string, (response: any) => void>()
-
-    providersNeedingReboot = [
-        DatabaseProvider
-    ]
-
-    abstract bootstrapApp(): Promise<Application>
-
-
-    async before() {
-        if (!TestCase.app) {
-            TestCase.app = await this.bootstrapApp()
-        }
-        await TestCase.app.registerProviders(this.providersNeedingReboot)
-        this.app = TestCase.app.createChildContainer()
-
-        const crypt = mock(Crypt)
-        when(crypt.hash(anything(), anything())).thenCall(value => `testing-${value}`)
-        when(crypt.compare(anything(), anything())).thenCall((first, second) => Promise.resolve(`testing-${first}` === second))
-
-        this.app.set(Crypt, instance(crypt))
-    }
-
-    async after() {}
-
-    async loginById(id: ID) {
-        await this.app.get(Auth).loginById(id)
-    }
-
-    /**
-     * @deprecated
-     */
-    async login(user: User) {
-        await this.loginById(user.id)
-    }
-
-    async actingAs(user: User) {
-        await this.app.get(Auth).loginUser(user)
-    }
-
-    get<T extends string | object | undefined>(routeName: string, content = {}, headers: IncomingHttpHeaders = {}): Promise<Response<T>> {
-        return this.request(Http.Method.GET, routeName, content, headers) as Promise<Response<T>>
-    }
-
-    post<T extends string | object | undefined>(
-        route: string | [string, Record<string, string | number>],
-        content = {},
-        headers: IncomingHttpHeaders = {}
-    ): Promise<Response<T>> {
-        return this.request(Http.Method.POST, route, content, headers) as Promise<Response<T>>
-    }
-
-    patch<T extends string | object | undefined>(
-        route: string | [string, Record<string, string | number>],
-        content = {},
-        headers: IncomingHttpHeaders = {}
-    ): Promise<Response<T>> {
-        return this.request(Http.Method.PATCH, route, content, headers) as Promise<Response<T>>
-    }
-
-    put<T extends string | object | undefined>(
-        route: string | [string, Record<string, string | number>],
-        content = {},
-        headers: IncomingHttpHeaders = {}
-    ): Promise<Response<T>> {
-        return this.request(Http.Method.PUT, route, content, headers) as Promise<Response<T>>
-    }
-
-    delete<T extends string | object | undefined>(
-        route: string | [string, Record<string, string | number>],
-        content = {},
-        headers: IncomingHttpHeaders = {}
-    ): Promise<Response<T>> {
-        return this.request(Http.Method.DELETE, route, content, headers) as Promise<Response<T>>
-    }
-
-    async action<T extends string | object | undefined>(action: string, content?: ActionRequest['message']): Promise<Response<T>> {
-        const socketMock = mock(WebSocket)
-
-        when(socketMock.publishAndSend(anything(), anything(), anything())).thenCall((topic, calledActon, message) => {
-            const callback = this.actionListeners.get(calledActon)
-            callback?.(message)
-        })
-
-        when(socketMock.send(anything(), anything())).thenCall((calledActon, message) => {
-            const callback = this.actionListeners.get(calledActon)
-            callback?.(message)
-        })
-
-        const container = this.app.createChildContainer()
-        container.set(WebSocket, instance(socketMock))
-
-        const request = new Request(action, content?.body)
-
-        // TODO find a way to save parameters so they can be retrieved easily in the Resolvers (check EntityResolver for example)
-        content?.parameters?.forEach(parameter => {
-            request.parameters[String.random(15)] = parameter
-        })
-
-        try {
-            return await this.app.get(WebsocketsHandler).handle(container, request)
-        } catch (error) {
-            if (error instanceof HttpError) {
-                const errorResponse = await this.app.get(ErrorHandlerInterface).handle(error)
-                console.error(errorResponse.body)
-                return errorResponse as Response<T>
-            }
-            throw error
-        }
-    }
-
-    on<T>(action: string, callback: (response: T) => void) {
-        this.actionListeners.set(action, callback)
-    }
-
-    private async request(
-        method: Http.Method,
-        routeName: string | [string, Record<string, string | number>],
-        content = {},
-        headers: IncomingHttpHeaders = {}
-    ) {
-        let routeParameters = {}
-        if (typeof routeName !== 'string') {
-            [routeName, routeParameters] = routeName
-        }
-
-        const router = this.app.get(Router)
-        const route = router.routes.findWhere('name', routeName) as HttpRoute
-        if (!route) {
-            throw new Error(`Route '${routeName}' not found`)
-        }
-        const parameters = this.convertRouteParametersToString(routeParameters) || {}
-
-        const auth = this.app.get(Auth)
-        if (auth.identifier) {
-            const token = await auth.sign(auth.identifier)
-            headers.authorization = `Bearer ${token}`
-        }
-
-        const request = new HttpRequest(route.getUrl(parameters), method, {}, {}, content)
-
-        request.setHeadersLoader(() => {
-            return headers
-        })
-        request.getHeader = <T extends string | string[] | undefined>(name: keyof IncomingHttpHeaders | string): T => {
-            return headers[String(name).toLowerCase()] as T
-        }
-
-        let response: Response
-        try {
-            response = await this.app.get(HTTPHandler).handle(this.app as Application, request)
-
-            if (response.body instanceof Buffer) {
-                response.body = response.body.toString()
-            }
-
-            return response
-
-        } catch (error) {
-            if (error instanceof HttpError) {
-                return this.app.get(ErrorHandlerInterface).handle(error)
-            }
-            throw error
-        }
-    }
-
-    private convertRouteParametersToString(routeParameters: Record<string, string | number>) {
-        Object.keys(routeParameters).forEach(key => {
-            routeParameters[key] = String(routeParameters[key])
-        })
-        return routeParameters as Record<string, string>
-    }
-}

package/Validation/Rule.ts

@@ -1,9 +0,0 @@
-import { RuleInterface } from './RuleInterface'
-
-export abstract class Rule implements RuleInterface {
-    abstract identifier: string
-
-    abstract message(attribute: string, value: string | number | object | boolean | undefined): string;
-
-    abstract passes(attribute: string, value: string | number | object | boolean | undefined): boolean ;
-}

package/Validation/RuleInterface.ts

@@ -1,10 +0,0 @@
-import { RuleValue } from '.'
-
-export interface RuleInterface {
-    identifier: string;
-
-    passes(attribute: string, value?: RuleValue): boolean;
-
-    message(attribute: string, value: RuleValue): string;
-}
-

package/Validation/Rules/Email.ts

@@ -1,20 +0,0 @@
-import { RuleInterface, RuleValue } from '..'
-import { Rule } from '../Rule'
-import { Type } from '@Typetron/Support'
-
-export function Email(message?: string): Type<RuleInterface> {
-    return class extends Rule {
-        identifier = 'email'
-
-        private regex = /^(?:[a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)])$/
-
-        passes(attribute: string, value: RuleValue): boolean {
-            return this.regex.test(String(value).trim())
-        }
-
-        message(attribute: string): string {
-            return message ?? `The ${attribute} must be a valid email address`
-        }
-    }
-
-}

package/Validation/Rules/FileExtension.ts

@@ -1,21 +0,0 @@
-import { Rule, RuleInterface } from '@Typetron/Validation'
-import { Type } from '@Typetron/Support'
-import { File } from '@Typetron/Storage'
-
-export function FileExtension(extensions: string[], message?: string): Type<RuleInterface> {
-    return class extends Rule {
-        identifier = 'fileExtension'
-
-        passes(attribute: string, value?: File): boolean {
-            return value?.extension ? extensions.includes(value.extension) : false
-        }
-
-        message(attribute: string, value?: File): string {
-            const messagePart = extensions.length === 1
-                ? `the '.${extensions.first()}' extension`
-                : `these extensions: ${extensions.map(extension => `.${extension}`).join(', ')}`
-
-            return message ?? `The ${attribute} must have ${messagePart}`
-        }
-    }
-}

package/Validation/Rules/MaxLength.ts

@@ -1,17 +0,0 @@
-import { RuleInterface, RuleValue } from '..'
-import { Rule } from '../Rule'
-import { Type } from '../../Support'
-
-export function MaxLength(max: number, message?: string): Type<RuleInterface> {
-    return class extends Rule {
-        identifier = 'maxLength'
-
-        passes(attribute: string, value: RuleValue): boolean {
-            return Boolean(value && String(value).length <= max)
-        }
-
-        message(attribute: string): string {
-            return message ?? `The ${attribute} must have at most ${max} characters`
-        }
-    }
-}

package/Validation/Rules/MinLength.ts

@@ -1,18 +0,0 @@
-import { RuleInterface } from '../RuleInterface'
-import { RuleValue } from '..'
-import { Type } from '../../Support'
-import { Rule } from '../Rule'
-
-export function MinLength(min: number, message?: string): Type<RuleInterface> {
-    return class extends Rule {
-        identifier = 'minLength'
-
-        passes(attribute: string, value: RuleValue): boolean {
-            return Boolean(value && String(value).length >= min)
-        }
-
-        message(attribute: string): string {
-            return message ?? `The ${attribute} must have at least ${min} characters`
-        }
-    }
-}

package/Validation/Rules/Optional.ts

@@ -1,18 +0,0 @@
-import { RuleInterface, RuleValue } from '..'
-import { Rule } from '../Rule'
-import { Type } from '@Typetron/Support'
-
-export function Optional(): Type<RuleInterface> {
-    return class extends Rule {
-        identifier = 'optional'
-
-        passes(attribute: string, value: RuleValue): boolean {
-            return true // TODO
-        }
-
-        message(attribute: string): string {
-            return ''
-        }
-    }
-}
-

package/Validation/Rules/Required.ts

@@ -1,29 +0,0 @@
-import { RuleInterface, RuleValue } from '..'
-import { Type } from '@Typetron/Support'
-
-export function Required(message?: string): Type<RuleInterface> {
-    return class {
-        identifier = 'required'
-
-        passes(attribute: string, value: RuleValue): boolean {
-
-            if (value === undefined || value === null) {
-                return false
-            }
-
-            if (typeof value === 'string' && value.trim() === '') {
-                return false
-            }
-
-            if (value.constructor === Array && value.length === 0) {
-                return false
-            }
-
-            return true
-        }
-
-        message(attribute: string): string {
-            return message ?? `The ${attribute} is required`
-        }
-    }
-}

package/Validation/Validator.ts

@@ -1,7 +0,0 @@
-import { RuleInterface } from './RuleInterface'
-import { Type } from '../Support'
-
-export abstract class Validator<T> {
-    protected constructor(public data: T, public rules: { [key in keyof T]?: (RuleInterface | Type<RuleInterface>)[] }) {
-    }
-}

package/Validation/index.ts

@@ -1,12 +0,0 @@
-// tslint:disable-next-line:no-any
-export type RuleValue = any
-export * from './RuleInterface'
-export * from './Validator'
-export * from './Rule'
-export * from './Rules/MaxLength'
-export * from './Rules/MinLength'
-export * from './Rules/FileExtension'
-export * from './Rules/Required'
-export * from './Rules/Email'
-export * from './Rules/Optional'
-// export * from './Rules/FileExtension'

package/benchmark.ts

@@ -1,47 +0,0 @@
-// clinic flame -- node -r ts-node/register -r tsconfig-paths/register benchmark.js
-
-import 'reflect-metadata'
-import '@Typetron/Support'
-import { Handler, Http, Request } from './Router/Http'
-import { Container } from './Container'
-import { Get } from './Router'
-import Method = Http.Method
-
-class Controller {
-    @Get()
-    read() {
-        return 'Hello world!!!'
-    }
-}
-
-async function main() {
-
-    const app = new Container()
-    const handler = app.get(Handler)
-
-    handler.addRoute('', Method.GET, Controller, 'read', 'read')
-
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    // const request = await Request.capture({
-    //     url: 'http://localhost:3000',
-    //     method: 'GET',
-    //     headers: {}
-    // })
-    // await handler.handle(app, request)
-
-    console.time('test')
-    for (let i = 0; i < 1_000_000_0; i++) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        const request = await Request.capture({
-            url: 'http://localhost:3000',
-            method: 'GET',
-            headers: {}
-        })
-        await handler.handle(app, request)
-    }
-    console.timeEnd('test')
-}
-
-main()

package/eslint.config.mjs

@@ -1,78 +0,0 @@
-import js from '@eslint/js'
-import tsEslint from '@typescript-eslint/eslint-plugin'
-import tsParser from '@typescript-eslint/parser'
-
-export default [
-    {
-        ignores : ['node_modules/**', 'build/**', '*.js', '*.mjs']
-    },
-    js.configs.recommended,
-    {
-        files : ['**/*.ts'],
-        languageOptions : {
-            parser : tsParser,
-            parserOptions : {
-                ecmaVersion : 'latest',
-                sourceType : 'module'
-            },
-            globals : {
-                console : 'readonly',
-                process : 'readonly',
-                Buffer : 'readonly',
-                __dirname : 'readonly',
-                __filename : 'readonly',
-                exports : 'readonly',
-                module : 'readonly',
-                require : 'readonly',
-                global : 'readonly',
-                setTimeout : 'readonly',
-                setInterval : 'readonly',
-                clearTimeout : 'readonly',
-                clearInterval : 'readonly',
-                URL : 'readonly'
-            }
-        },
-        plugins : {
-            '@typescript-eslint' : tsEslint
-        },
-        rules : {
-            // Disable conflicting rules
-            'no-unused-vars' : 'off',
-            'no-shadow' : 'off',
-
-            // Basic rules
-            'max-len' : ['warn', { code : 140, tabWidth : 4 }],
-            'no-async-promise-executor' : 'off',
-
-            // TypeScript rules
-            '@typescript-eslint/no-explicit-any' : 'off',
-            '@typescript-eslint/no-unused-vars' : 'warn',
-            '@typescript-eslint/ban-ts-comment' : 'warn',
-            '@typescript-eslint/no-inferrable-types' : 'off',
-            '@typescript-eslint/no-empty-interface' : 'error',
-
-            // Code quality rules derived from tslint config
-            'curly' : 'error',
-            'eqeqeq' : ['error', 'always', { null : 'ignore' }],
-            'no-bitwise' : 'error',
-            'no-console' : ['error', { allow : ['warn', 'error', 'info'] }],
-            'no-debugger' : 'error',
-            'no-eval' : 'error',
-            'no-throw-literal' : 'error',
-            'no-trailing-spaces' : 'off',
-            'no-undef-init' : 'error',
-            'no-unsafe-finally' : 'error',
-            'quotes' : ['error', 'single', { avoidEscape : true }],
-            'radix' : 'error',
-            'semi' : ['error', 'never'],
-            'prefer-const' : 'error'
-        }
-    },
-    {
-        files : ['tests/**/*.ts'],
-        rules : {
-            '@typescript-eslint/no-unused-vars' : 'off',
-            '@typescript-eslint/no-explicit-any' : 'off'
-        }
-    }
-]

package/tests/.nycrc.json

@@ -1,19 +0,0 @@
-{
-	"check-coverage": true,
-	"lines": 80,
-	"statements": 80,
-	"functions": 80,
-	"branches": 80,
-	"include": [
-		"./**/*.ts"
-	],
-	"exclude": [
-		"./tests/**/*.ts",
-		"./dist/**"
-	],
-	"reporter": [
-		"lcov",
-		"text-summary"
-	],
-	"all": true
-}

package/tests/Cache/DatabaseStoreTest.ts

@@ -1,110 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { CacheItem, DatabaseStore } from '@Typetron/Cache'
-import { expect } from 'chai'
-import { createHash } from 'crypto'
-import { Connection, Query, SqliteDriver } from '@Typetron/Database'
-import { Storage } from '@Typetron/Storage'
-
-const tableName = 'cache'
-const databaseFilePath = './tests/Cache/database.sqlite'
-
-@suite
-class DatabaseStoreTest {
-
-    databaseStore = new DatabaseStore(tableName)
-
-    static async before() {
-        Query.connection = new Connection(new SqliteDriver(databaseFilePath))
-    }
-
-    static async after() {
-        await new Storage().deleteDirectory(databaseFilePath)
-    }
-
-    private getCacheRecord(name: string) {
-        const cacheKeyHash = createHash('sha1').update(name).digest('hex')
-        return Query.table<CacheItem<unknown>>(tableName).where('name', cacheKeyHash).first()
-    }
-
-    @test
-    async returnsUndefinedIfRecordDoesntExist() {
-        const value = await this.databaseStore.get('tests')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async testPutCreatesRecord() {
-        const contents = 'test'
-
-        await this.databaseStore.set('foo', contents)
-
-        const cacheRecord = await this.getCacheRecord('foo')
-        expect(cacheRecord).to.exist
-        expect((cacheRecord as CacheItem<any>).value).to.be.equal(JSON.stringify(contents))
-    }
-
-    @test
-    async testExpirationValueIsWrittenInCacheRecord() {
-        const durationInSeconds = 60
-        const expirationTime = Date.now() + durationInSeconds * 1000
-
-        await this.databaseStore.set('expireTest', 'value', durationInSeconds)
-        const cacheRecord = await this.getCacheRecord('expireTest')
-
-        expect(cacheRecord).to.exist
-        expect(new Date((cacheRecord as CacheItem<unknown>).date ?? Infinity).getTime()).to.be.closeTo(expirationTime, 1000) // Allowing a 1-second difference
-    }
-
-    @test
-    async testCacheValueIsUndefinedIfExpired() {
-        const durationInSeconds = -60 // Setting a past expiration
-
-        await this.databaseStore.set('anotherExpiredTest', 'value', durationInSeconds)
-
-        const value = await this.databaseStore.get('anotherExpiredTest')
-        expect(value).to.be.undefined
-
-        const cacheRecord = await this.getCacheRecord('anotherExpiredTest')
-        expect(cacheRecord).to.be.undefined
-    }
-
-    @test
-    async testDeleteMethodDeletesRecordFromDatabase() {
-        await this.databaseStore.set('deleteTest', 'value')
-
-        await this.databaseStore.delete('deleteTest')
-
-        const cacheRecord = await this.getCacheRecord('deleteTest')
-        expect(cacheRecord).to.be.undefined
-    }
-
-    @test
-    async testFlushMethodDeletesAllRecords() {
-        await this.databaseStore.set('flushTest', 'value')
-
-        await this.databaseStore.flush()
-
-        const allRecords = await Query.table(tableName).get()
-        expect(allRecords.length).to.be.equal(0)
-    }
-
-    @test
-    async testRememberMethodCreatesRecordIfNotExists() {
-        const value = await this.databaseStore.remember('rememberTest', 'defaultValue', 60)
-
-        expect(value).to.equal('defaultValue')
-
-        const cacheRecord = await this.getCacheRecord('rememberTest')
-        expect(cacheRecord).to.exist
-        expect((cacheRecord as CacheItem<any>).value).to.be.equal(JSON.stringify('defaultValue'))
-    }
-
-    @test
-    async testRememberMethodReturnsExistingValue() {
-        await this.databaseStore.set('rememberTest2', 'existingValue')
-
-        const value = await this.databaseStore.remember('rememberTest2', 'defaultValue', 60)
-
-        expect(value).to.equal('existingValue')
-    }
-}