@typetron/framework 0.5.20 → 0.5.22

package/tests/Router/HttpHandlerTest.ts

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

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

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

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

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

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

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

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

package/tsconfig.json

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

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

package/build/Cache/Cache.d.ts

@@ -1,9 +0,0 @@
-export declare abstract class Cache {
-    abstract has(name: string): Promise<boolean>;
-    abstract get<T>(name: string, defaultValue?: T | (() => T | Promise<T>)): Promise<T | undefined>;
-    abstract remember<T>(name: string, defaultValue?: T | (() => T | Promise<T>), duration?: number): Promise<T | undefined>;
-    abstract set(name: string, data: any, duration?: number): Promise<void>;
-    abstract delete(name: string): Promise<void>;
-    abstract flush(): Promise<void>;
-}
-//# sourceMappingURL=Cache.d.ts.map

package/build/Cache/Cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../Cache/Cache.ts"],"names":[],"mappings":"AAAA,8BAAsB,KAAK;IACvB,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAE5C,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAEhG,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAExH,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAEvE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAE5C,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAClC"}

package/build/Cache/Cache.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cache = void 0;
-class Cache {
-}
-exports.Cache = Cache;
-//# sourceMappingURL=Cache.js.map

package/build/Cache/Cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Cache.js","sourceRoot":"","sources":["../../Cache/Cache.ts"],"names":[],"mappings":";;;AAAA,MAAsB,KAAK;CAY1B;AAZD,sBAYC"}

package/build/Cache/Stores/DatabaseStore.d.ts

@@ -1,16 +0,0 @@
-import { Cache } from '@Typetron/Cache';
-export declare class DatabaseStore extends Cache {
-    table: string;
-    constructor(table: string);
-    private get cacheTable();
-    private getNameHash;
-    has(name: string): Promise<boolean>;
-    get<T>(name: string, defaultValue?: T | (() => T | Promise<T>)): Promise<T | undefined>;
-    remember<T>(name: string, defaultValue?: T | (() => T | Promise<T>), durationInSeconds?: number): Promise<T | undefined>;
-    set(name: string, value: any, durationInSeconds?: number): Promise<void>;
-    delete(name: string): Promise<void>;
-    flush(): Promise<void>;
-    private getDefaultValue;
-    private makeSureTheTableExists;
-}
-//# sourceMappingURL=DatabaseStore.d.ts.map

package/build/Cache/Stores/DatabaseStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DatabaseStore.d.ts","sourceRoot":"","sources":["../../../Cache/Stores/DatabaseStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAOvC,qBAAa,aAAc,SAAQ,KAAK;IACjB,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;IAIhC,OAAO,KAAK,UAAU,GAErB;IAED,OAAO,CAAC,WAAW;IAIb,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKnC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAqBvF,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAYxH,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBxE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAId,eAAe;YAQf,sBAAsB;CAwBvC"}