@typetron/framework 0.5.21 → 0.5.22

package/Testing/TestCase.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,78 @@
+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/package.json

@@ -2,7 +2,7 @@
     "name": "@typetron/framework",
     "description": "Modern Node.js framework for modern apps written in Typescript",
     "license": "MIT",
-    "version": "0.5.21",
+    "version": "0.5.22",
     "keywords": [
         "typetron",
         "framework",
@@ -80,9 +80,5 @@
     "repository": {
         "type": "git",
         "url": "https://github.com/typetron/framework.git"
-    },
-
-    "files": [
-        "build/**/*"
-    ]
+    }
 }

package/tests/.nycrc.json

@@ -0,0 +1,19 @@
+{
+	"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

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