@typetron/framework 0.5.22 → 0.5.25

package/tests/Router/HttpHandlerTest.ts

@@ -1,72 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Handler, Http, Request } from '../../Router/Http'
-import { expect } from 'chai'
-import { Container } from '@Typetron/Container'
-import { Body, Controller, Get } from '../../Router'
-
-@suite
-class HttpHandlerTest {
-    private container: Container
-
-    async before() {
-        this.container = new Container()
-        Container.setInstance(this.container)
-    }
-
-    @test
-    'gives error when two routes have the same path'() {
-
-        class MyController {
-            index() {}
-        }
-
-        const handler = this.container.get(Handler)
-        handler.addRoute('', Http.Method.GET, MyController, 'index', 'index')
-
-        expect(() => handler.addRoute('', Http.Method.POST, MyController, 'index', 'index'))
-            .to.not.throw(`There is already a route with the same url: [GET] ''`)
-        expect(() => handler.addRoute('', Http.Method.GET, MyController, 'index', 'index'))
-            .to.throw(`There is already a route with the same url: [GET] ''`)
-    }
-
-    @test
-    async 'returns the value from the @Body'() {
-        @Controller()
-        class MyController {
-            @Get('list')
-            list(@Body() value: string) {
-                return value
-            }
-
-            @Get('create')
-            create(@Body() value: string) {
-                return value
-            }
-        }
-
-        const router = this.container.get(Handler)
-
-        const listContent = await router.handle(this.container, new Request('list', Http.Method.GET, undefined, {}, 'test'))
-        expect(listContent.body).to.be.equal('test')
-
-        const createContent = await router.handle(this.container, new Request('create', Http.Method.GET))
-        expect(createContent.body).to.be.equal(undefined)
-    }
-
-    // @test
-    // async 'caches route urls'(done: Function) {
-    //     class Controller {
-    //         index() {}
-    //     }
-    //
-    //     const router = new Router()
-    //     router.add('', Http.Method.GET, Controller, 'index', 'index')
-    //
-    //     expect(router.cachedRoutes).to.be.have.length(0)
-    //
-    //     const app = new Container()
-    //     const request = new Request('', Http.Method.GET)
-    //     await router.handle(app as Application, request)
-    //     expect(router.findRouteIndex).to.be.called.once // ???
-    // }
-}

package/tests/Router/RequestTest.ts

@@ -1,77 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { expect } from 'chai'
-import { Http, Request } from '../../Router/Http'
-import { IncomingHttpHeaders } from 'http'
-import { File } from '../../Storage'
-
-@suite
-class RequestTest {
-
-    private request: Request
-
-    before() {
-        this.request = new Request('http://example.com/test?name=value', Http.Method.GET)
-        this.request.setHeadersLoader(() => {
-            return {'content-type': 'text/html'}
-        })
-        this.request.getHeader = <T extends string | string[] | undefined>(name: keyof IncomingHttpHeaders | string): T => {
-            return 'text/html' as T
-        }
-    }
-
-    @test
-    'uri getter should return correct uri'() {
-        expect(this.request.uri).to.equal('/test')
-    }
-
-    @test
-    'method getter should return correct method'() {
-        expect(this.request.method).to.equal(Http.Method.GET)
-    }
-
-    // Assuming that the commented url getter is uncommented in your code
-    @test
-    'url getter should return correct url'() {
-        expect(this.request.url).to.equal('http://example.com/test?name=value')
-    }
-
-    @test
-    'query getter should parse and return correct query parameters'() {
-        expect(this.request.query).to.deep.equal({name: 'value'})
-    }
-
-    @test
-    'cookies getter should parse and return correct cookies'() {
-        expect(this.request.cookies).to.deep.equal({todo: 'parse cookies'})
-    }
-
-    @test
-    'body getter and setter should return and set body correctly'() {
-        this.request.body = {test: 'data'}
-        expect(this.request.body).to.deep.equal({test: 'data'})
-    }
-
-    @test
-    'files getter and setter should return and set files correctly'() {
-        const dummyFile = { // Just a mock structure based on what you provided
-            originalName: 'test.txt',
-            directory: '/tmp',
-            saved: true,
-            path: '/tmp/test.txt'
-        } as File
-
-        this.request.files = {testFile: dummyFile}
-        expect(this.request.files).to.deep.equal({testFile: dummyFile})
-    }
-
-    @test
-    'headers getter should return correct headers'() {
-        expect(this.request.headers).to.deep.equal({'content-type': 'text/html'})
-    }
-
-    @test
-    'header value is returned'() {
-        expect(this.request.getHeader('random header')).to.deep.equal('text/html')
-    }
-}
-

package/tests/Router/WebSocketsHandlerTest.ts

@@ -1,51 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Handler } from '../../Router/Websockets'
-import { expect } from 'chai'
-import { Container } from '@Typetron/Container'
-import { Action, Body, Controller } from '../../Router'
-import { Request } from '../../Router/Request'
-
-@suite
-class WebSocketsHandlerTest {
-
-    @test
-    'gives error when two actions have the same path'() {
-        const container = new Container()
-
-        class Controller {
-            list() {}
-        }
-
-        const router = container.get(Handler)
-        router.addAction('list', Controller, 'list')
-
-        expect(() => router.addAction('list', Controller, 'index')).to.throw(`There is already an action with the same name: 'list'`)
-    }
-
-    @test
-    async 'returns the value from the @Body'() {
-        const container = Container.getInstance()
-
-        @Controller()
-        class MyController {
-            @Action()
-            list(@Body() value: string) {
-                return value
-            }
-
-            @Action()
-            create(@Body() value: string) {
-                return value
-            }
-        }
-
-        const router = container.get(Handler)
-
-        const listContent = await router.handle(container, new Request('list', 'test'))
-        expect(listContent.body).to.be.equal('test')
-
-        const createContent = await router.handle(container, new Request('create'))
-        expect(createContent.body).to.be.equal(undefined)
-    }
-
-}

package/tests/Storage/StorageTest.ts

@@ -1,97 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { File, Storage } from '../../Storage'
-import { expect } from 'chai'
-import * as path from 'path'
-
-const directory = './tests/Storage/.storage'
-
-@suite
-class StorageTest {
-    storage = new Storage()
-
-    @test
-    async canReadFiles() {
-        const file = new File('testFile.txt')
-        file.directory = directory
-        // Create the file before trying to save it
-        await this.storage.put(path.join(directory, file.name), 'test content')
-
-        const content = await this.storage.read(path.join(directory, file.name))
-        expect(content).to.be.instanceOf(Buffer)
-        expect(content.toString()).to.equal('test content')
-    }
-
-    @test
-    async canCheckIfFileExists() {
-        const file = new File('testFile.txt')
-        file.directory = directory
-        // Create the file before trying to save it
-        await this.storage.put(path.join(directory, file.name), 'test content')
-
-        const exists = await this.storage.exists(path.join(directory, file.name))
-        expect(exists).to.be.true
-    }
-
-    @test
-    async canSaveFiles() {
-        const file = new File('testFile.txt')
-        file.directory = directory
-        // Create the file before trying to save it
-        await this.storage.put(path.join(directory, file.name), 'test content')
-        const savedFile = await this.storage.save(file, './tests/Storage/.storage/alternative.txt')
-        expect(savedFile).to.be.instanceOf(File)
-        expect(savedFile.name).to.equal(file.name)
-        expect(await this.storage.exists(savedFile.path)).to.be.true
-    }
-
-    @test
-    async canWriteToFile() {
-        const filePath = path.join(directory, 'testFile.txt')
-        const file = await this.storage.put(filePath, 'test content')
-        expect(file).to.be.instanceOf(File)
-        expect(file.name).to.equal('testFile.txt')
-        const content = await this.storage.read(path.join(directory, file.name))
-        expect(content).to.be.instanceOf(Buffer)
-        expect(content.toString()).to.equal('test content')
-    }
-
-    @test
-    async canCreateDirectory() {
-        await this.storage.makeDirectory(directory)
-        const exists = await this.storage.exists(directory)
-        expect(exists).to.be.true
-    }
-
-    @test
-    async canDeleteDirectory() {
-        await this.storage.makeDirectory(directory)
-        await this.storage.deleteDirectory(directory)
-        const exists = await this.storage.exists(directory)
-        expect(exists).to.be.false
-    }
-
-    @test
-    async canDeleteFile() {
-        const file = new File('testFile.txt')
-        file.directory = directory
-        // Create the file before trying to save it
-        await this.storage.put(path.join(directory, file.name), 'test content')
-
-        await this.storage.delete(path.join(directory, file.name))
-        const exists = await this.storage.exists(path.join(directory, file.name))
-        expect(exists).to.be.false
-    }
-
-    @test
-    async cannotDeleteWithoutFileName() {
-        try {
-            // Attempt to delete a directory instead of a file
-            await this.storage.delete(directory)
-            throw new Error('Expected an error to be thrown, but none was thrown.')
-        } catch (unknownError) {
-            const error = unknownError as Error
-            expect(error).to.be.instanceOf(Error)
-            expect(error.message).to.equal('Can not delete because this path leads to a directory and not a file.')
-        }
-    }
-}

package/tests/Support/ArrayTest.ts

@@ -1,167 +0,0 @@
-import { expect } from 'chai'
-import { suite, test } from '@testdeck/mocha'
-import '../../Support'
-
-interface User {
-    name: string;
-    age: number;
-    admin: boolean;
-}
-
-@suite
-class ArrayTest {
-
-    joe = {
-        name: 'Joe',
-        age: 20,
-        admin: false
-    }
-    doe = {
-        name: 'Doe',
-        age: 21,
-        admin: true
-    }
-
-    users: User[] = []
-
-    before() {
-        this.users = [this.joe, this.doe]
-    }
-
-    @test
-    empty() {
-        expect([].empty()).to.be.equal(true)
-        expect([1].empty()).to.be.equal(false)
-    }
-
-    @test
-    findWhere() {
-        expect(this.users.findWhere('name', 'Joe')).to.be.equal(this.joe)
-    }
-
-    @test
-    pluck() {
-        expect(this.users.pluck('name')).to.have.members([this.joe.name, this.doe.name])
-    }
-
-    @test
-    remove() {
-        this.users.remove(this.joe)
-        expect(this.users).to.have.members([this.doe])
-    }
-
-    @test
-    removeMany() {
-        this.users.remove(this.joe, this.doe)
-        expect(this.users).to.have.length(0)
-    }
-
-    @test
-    where() {
-        expect(this.users.where('name', this.joe.name)).to.have.members([this.joe])
-        expect([this.joe].where('admin', false)).to.have.length(1)
-    }
-
-    @test
-    whereNot() {
-        expect(this.users.whereNot('name', this.joe.name)).to.have.members([this.doe])
-        expect([this.doe].whereNot('admin', false)).to.have.length(1)
-    }
-
-    @test
-    whereWithDefaultValue() {
-        expect(this.users.where('admin')).to.have.members([this.doe])
-    }
-
-    @test
-    whereIn() {
-        expect(this.users.whereIn('name', [this.joe.name, this.doe.name])).to.have.members([this.joe, this.doe])
-    }
-
-    @test
-    whereNotIn() {
-        expect(this.users.whereNotIn('name', [this.joe.name])).to.have.members([this.doe])
-    }
-
-    @test
-    first() {
-        expect(this.users.first()).to.be.equal(this.joe)
-    }
-
-    @test
-    groupBy() {
-        expect(this.users.groupBy('age')).to.deep.equal({
-            20: [this.joe],
-            21: [this.doe],
-        })
-    }
-
-    @test
-    groupByCallback() {
-        expect(this.users.groupBy(user => user.age)).to.deep.equal({
-            20: [this.joe],
-            21: [this.doe],
-        })
-    }
-
-    @test
-    uniqueValue() {
-        const data = [1, 1, 2, 3]
-        expect(data.unique()).to.be.deep.equal([1, 2, 3])
-    }
-
-    @test
-    uniqueValueBasedOnKey() {
-        const data = [
-            {id: 1},
-            {id: 1},
-        ]
-        expect(data.unique('id')).to.be.deep.equal([{id: 1}])
-    }
-
-    @test
-    uniqueValueBasedOnCallback() {
-        const data = [
-            {age: 20},
-            {age: 20},
-            {age: 30},
-        ]
-        expect(data.unique(item => item.age)).to.be.deep.equal([{age: 20}, {age: 30}])
-    }
-
-    @test
-    sumNumbers() {
-        expect([1, 2, 3].sum()).to.be.equal(6)
-    }
-
-    @test
-    sumObjectProperties() {
-        expect(this.users.sum('age')).to.be.equal(this.joe.age + this.doe.age)
-    }
-
-    @test
-    sumCallback() {
-        expect(this.users.sum(user => user.age)).to.be.equal(this.joe.age + this.doe.age)
-    }
-
-    @test
-    whenNotEmpty() {
-        let index = false;
-        [1].whenNotEmpty(() => index = true)
-        expect(index).to.be.equal(true)
-    }
-
-    @test
-    whenNotEmptyPassesTheArrayInTheCallback() {
-        let index = false;
-        [1, 2, 3].filter(i => i >= 2).whenNotEmpty(values => index = values.length === 2)
-        expect(index).to.be.equal(true)
-    }
-
-    @test
-    whenEmpty() {
-        let index = false;
-        [].whenEmpty(() => index = true)
-        expect(index).to.be.equal(true)
-    }
-}

package/tests/Support/StringTest.ts

@@ -1,18 +0,0 @@
-import { expect } from 'chai'
-import { suite, test } from '@testdeck/mocha'
-
-@suite
-class StringTest {
-    @test
-    shouldLimitStringAddingThreeDotsAtTheEnd() {
-        expect('text'.limit(3)).to.be.equal('...')
-        expect('texts'.limit(4)).to.be.equal('t...')
-        expect('text'.limit(5)).to.be.equal('text')
-    }
-
-    @test
-    shouldLimitStringWithCustomEnding() {
-        expect('Testing this text'.limit(12, ' More...')).to.be.equal('Test More...')
-    }
-
-}

package/tests/Validation/RulesTest.ts

@@ -1,54 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { Email } from '../../Validation'
-import { expect } from 'chai'
-
-@suite
-class RulesTest {
-    @test
-    shouldLimitStringAddingThreeDotsAtTheEnd() {
-        const validEmails = [
-            'email@example.com',
-            'firstname.lastname@example.com',
-            'email@subdomain.example.com',
-            'firstname+lastname@example.com',
-            'email@123.123.123.123',
-            'email@[123.123.123.123]',
-            '"email"@example.com',
-            '1234567890@example.com',
-            'email@example-one.com',
-            '_______@example.com',
-            'email@example.name',
-            'email@example.museum',
-            'email@example.co.jp',
-            'firstname-lastname@example.com',
-        ]
-        const invalidEmails = [
-            'plainaddress',
-            '#@%^%#$@#$@#.com',
-            '@example.com',
-            'Joe Smith <email@example.com>',
-            'email.example.com',
-            'email@example@example.com',
-            '.email@example.com',
-            'email.@example.com',
-            'email..email@example.com',
-            'あいうえお@example.com',
-            'email@example.com (Joe Smith)',
-            'email@example',
-            'email@-example.com',
-            'email@example..com',
-            'Abc..123@example.com',
-        ]
-
-        const rule = new (Email())
-
-        validEmails.forEach(email => {
-            expect(rule.passes('', email), email).to.be.equal(true)
-        })
-
-        invalidEmails.forEach(email => {
-            expect(rule.passes('', email), email).to.be.equal(false)
-        })
-    }
-
-}

package/tests/tsconfig.json

@@ -1,5 +0,0 @@
-{
-	"extends": "../tsconfig.json",
-	"exclude": []
-}
-

package/tsconfig.json

@@ -1,53 +0,0 @@
-{
-	"compilerOptions": {
-		"module": "commonjs",
-        "target": "ES2023",
-		"experimentalDecorators": true,
-		"emitDecoratorMetadata": true,
-		"sourceMap": true,
-		"declaration": true,
-		"strict": true,
-		"esModuleInterop": true,
-		"strictPropertyInitialization": false,
-		"forceConsistentCasingInFileNames": true,
-		//		"useDefineForClassFields": true, // TODO some tests fail when using this flag
-		"declarationMap": true,
-		//		"noUnusedLocals": true,
-		//		"noUnusedParameters": true,
-        "outDir": "./build",
-		"noImplicitAny": true,
-		//		"noUncheckedIndexedAccess": true,
-		"moduleResolution": "node",
-		"lib": [
-			"esnext"
-		],
-		"types": [
-			"reflect-metadata",
-			"@types/node"
-		],
-		"baseUrl": ".",
-		"paths": {
-			"@Typetron/*": [
-				"*"
-			]
-		}
-	},
-    "files": [
-        "types.d.ts"
-    ],
-    "include": [
-		"Cache",
-		"Container",
-		"Database",
-		"Encryption",
-		"Forms",
-		"Framework",
-		"Models",
-        "Mail",
-		"Router",
-		"Storage",
-		"Support",
-        "Testing"
-	]
-}
-

package/types.d.ts

@@ -1,8 +0,0 @@
-declare module 'fast-url-parser' {
-    export function parse(url: string): Url
-
-    type Url = URL & {
-        format(): string
-        query: string
-    }
-}