@typetron/framework 0.5.2 → 0.5.3

package/benchmark-index.js

@@ -1,20 +0,0 @@
-const path = require('path')
-const fs = require('fs')
-
-const tsConfigPaths = require('tsconfig-paths')
-const appTsConfigPath = path.join(process.cwd(), 'tsconfig.json')
-const tsConfig = require(path.join(__dirname, 'tsconfig.json'))
-
-require('ts-node').register({
-	project : fs.existsSync(appTsConfigPath) ? appTsConfigPath : path.join(__dirname, 'tsconfig.json'),
-	transpileOnly : true,
-	skipIgnore : true,
-	preferTsExts : true,
-})
-
-tsConfigPaths.register({
-	baseUrl : __dirname,
-	paths : tsConfig.compilerOptions.paths
-})
-
-require('./benchmark')

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/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')
-    }
-}

package/tests/Cache/FileStoreTest.ts

@@ -1,93 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { FileStore } from '@Typetron/Cache'
-import { Storage } from '@Typetron/Storage'
-import { expect } from 'chai'
-
-const directory = './tests/Cache/.cache'
-
-@suite
-class FileStoreTest {
-    storage = new Storage()
-    fileStore = new FileStore(this.storage, directory)
-
-    static async after() {
-        const storage = new Storage()
-        if (await storage.exists(directory)) {
-            await storage.deleteDirectory(directory)
-        }
-    }
-
-    @test
-    async returnsUndefinedIfKeyDoesNotExist() {
-        const value = await this.fileStore.get('nonexistentKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canStoreAndRetrieveData() {
-        await this.fileStore.set('testKey', 'testValue')
-        const value = await this.fileStore.get('testKey')
-        expect(value).to.equal('testValue')
-    }
-
-    @test
-    async canDeleteData() {
-        await this.fileStore.set('testKey', 'testValue')
-        await this.fileStore.delete('testKey')
-        const value = await this.fileStore.get('testKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canFlushAllData() {
-        await this.fileStore.set('key1', 'value1')
-        await this.fileStore.set('key2', 'value2')
-        await this.fileStore.flush()
-        const value1 = await this.fileStore.get('key1')
-        const value2 = await this.fileStore.get('key2')
-        expect(value1).to.be.undefined
-        expect(value2).to.be.undefined
-    }
-
-    @test
-    async respectsExpiration() {
-        await this.fileStore.set('expiringKey', 'expiringValue', 0.01)
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const value = await this.fileStore.get('expiringKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canCheckIfKeyExists() {
-        await this.fileStore.set('testKey', 'testValue')
-        const exists = await this.fileStore.has('testKey')
-        expect(exists).to.be.true
-        const nonExistent = await this.fileStore.has('nonexistentKey')
-        expect(nonExistent).to.be.false
-    }
-
-    @test
-    async canRememberValue() {
-        const value = await this.fileStore.remember('rememberKey', 'rememberValue', 0.01)
-        expect(value).to.equal('rememberValue')
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const expiredValue = await this.fileStore.get('rememberKey')
-        expect(expiredValue).to.be.undefined
-    }
-
-    @test
-    async getMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        const value1 = await this.fileStore.get('nonexistentKey', 'defaultValue')
-        expect(value1).to.equal('defaultValue')
-        const value2 = await this.fileStore.get('nonexistentKey', () => 'defaultValue')
-        expect(value2).to.equal('defaultValue')
-    }
-
-    @test
-    async rememberMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        const value1 = await this.fileStore.remember('nonexistentKey', 'defaultValue', 0.01)
-        expect(value1).to.equal('defaultValue')
-        const value2 = await this.fileStore.remember('nonexistentKey2', () => 'defaultValue', 0.01)
-        expect(value2).to.equal('defaultValue')
-    }
-}

package/tests/Cache/MemoryStoreTest.ts

@@ -1,92 +0,0 @@
-import { suite, test } from '@testdeck/mocha'
-import { MemoryStore } from '@Typetron/Cache'
-import { expect } from 'chai'
-
-@suite
-class MemoryStoreTest {
-    memoryStore = new MemoryStore()
-
-    @test
-    async returnsUndefinedIfKeyDoesNotExist() {
-        const value = await this.memoryStore.get('nonexistentKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canStoreAndRetrieveData() {
-        await this.memoryStore.set('testKey', 'testValue')
-        expect(this.memoryStore.cache.has('testKey')).to.be.true
-        const value = await this.memoryStore.get('testKey')
-        expect(value).to.equal('testValue')
-    }
-
-    @test
-    async canDeleteData() {
-        await this.memoryStore.set('testKey', 'testValue')
-        await this.memoryStore.delete('testKey')
-        const value = await this.memoryStore.get('testKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canFlushAllData() {
-        await this.memoryStore.set('key1', 'value1')
-        await this.memoryStore.set('key2', 'value2')
-        await this.memoryStore.flush()
-        const value1 = await this.memoryStore.get('key1')
-        const value2 = await this.memoryStore.get('key2')
-        expect(value1).to.be.undefined
-        expect(value2).to.be.undefined
-    }
-
-    @test
-    async respectsExpiration() {
-        await this.memoryStore.set('expiringKey', 'expiringValue', 0.01)
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const value = await this.memoryStore.get('expiringKey')
-        expect(value).to.be.undefined
-    }
-
-    @test
-    async canCheckIfKeyExists() {
-        await this.memoryStore.set('testKey', 'testValue')
-        const exists = await this.memoryStore.has('testKey')
-        expect(exists).to.be.true
-        const nonExistent = await this.memoryStore.has('nonexistentKey')
-        expect(nonExistent).to.be.false
-    }
-
-    @test
-    async canRememberValue() {
-        const value = await this.memoryStore.remember('rememberKey', 'rememberValue', 0.01)
-        expect(value).to.equal('rememberValue')
-        expect(this.memoryStore.cache.has('rememberKey')).to.be.true
-        await new Promise(resolve => setTimeout(resolve, 11))
-        const expiredValue = await this.memoryStore.get('rememberKey')
-        expect(expiredValue).to.be.undefined
-    }
-
-    @test
-    async getMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        // Non-function default value
-        const value1 = await this.memoryStore.get('nonexistentKey', 'defaultValue')
-        expect(value1).to.equal('defaultValue')
-
-        // Function default value
-        const value2 = await this.memoryStore.get('nonexistentKey', () => 'defaultValue')
-        expect(value2).to.equal('defaultValue')
-    }
-
-    @test
-    async rememberMethodCanAcceptNonFunctionAndFunctionAsDefaultValue() {
-        // Non-function default value
-        const value1 = await this.memoryStore.remember('nonexistentKey', 'defaultValue', 0.01)
-        expect(value1).to.equal('defaultValue')
-        expect(this.memoryStore.cache.has('nonexistentKey')).to.be.true
-
-        // Function default value
-        const value2 = await this.memoryStore.remember('nonexistentKey2', () => 'defaultValue', 0.01)
-        expect(value2).to.equal('defaultValue')
-        expect(this.memoryStore.cache.has('nonexistentKey2')).to.be.true
-    }
-}

package/tests/Container/ContainerTest.ts

@@ -1,336 +0,0 @@
-import { expect } from 'chai'
-import { suite, test } from '@testdeck/mocha'
-import { BaseResolver, Container, Inject, Injectable, Scope } from '../../Container'
-import { ServiceIdentifier } from '../../Container/Contracts'
-
-@suite
-class ContainerTest {
-    @test
-    givesSingletonContainer() {
-        const container = Container.getInstance()
-        expect(container).instanceOf(Container)
-        expect(Container.getInstance()).to.be.equal(container)
-        expect(Container.getInstance()).instanceOf(Container)
-    }
-
-    @test
-    overwritesSingletonContainer() {
-        const container = Container.setInstance(new Container)
-        expect(container).equal(Container.getInstance())
-        const container2 = new Container
-        Container.setInstance(container2)
-        expect(container).not.equal(Container.getInstance())
-        expect(container2).equal(Container.getInstance())
-    }
-
-    @test
-    createsInstance() {
-        const container = new Container()
-
-        @Injectable()
-        class Request {}
-
-        expect(container.get(Request)).instanceOf(Request)
-    }
-
-    // @test
-    // bindsCallbacks() {
-    //     class Dependency {}
-    //
-    //     const container = new Container;
-    //
-    //     @Injectable() // not possible right now
-    //     function myFunction(dependency: Dependency) {
-    //         return dependency;
-    //     };
-    //     expect(container.call(myFunction())).to.be.instanceOf(Dependency);
-    // }
-
-    @test
-    singletonScope() {
-        class Request {}
-
-        const container = new Container()
-        const request = container.get(Request)
-        expect(request).to.be.equal(container.get(Request))
-    }
-
-    @test
-    transientScope() {
-        @Injectable(Scope.TRANSIENT)
-        class Request {}
-
-        const container = new Container()
-        const request1 = container.get(Request)
-        const request2 = container.get(Request)
-        expect(request1).not.to.be.equal(request2)
-    }
-
-    @test
-    requestScope() {
-        @Injectable(Scope.REQUEST)
-        class Request {}
-
-        const container = new Container()
-        const childContainer = container.createChildContainer()
-        const request = childContainer.get(Request)
-        expect(container.getInstances().size).to.be.equal(0)
-        expect(childContainer.getInstances().size).to.be.equal(2)
-        expect(request).to.be.instanceof(Request)
-    }
-
-    // @test
-    // requestScopeWithSingletonDependencyFromParenContainer() {
-    //     @Injectable(Scope.REQUEST)
-    //     class Request {}
-    //
-    //     class Controller {
-    //         @Inject()
-    //         request: Request;
-    //     }
-    //
-    //     const container = new Container();
-    //     const childContainer = container.createChildContainer();
-    //     const controller = childContainer.get(Controller);
-    //     expect(Object.values(container.getInstances())).to.have.length(0);
-    //     expect(Object.values(childContainer.getInstances())).to.have.length(1);
-    //     expect(Object.values(childContainer.getInstances())[0]).to.be.instanceof(Request);
-    // }
-
-    @test
-    bindsStringToImplementation() {
-        @Injectable(Scope.TRANSIENT)
-        class Request {}
-
-        const container = new Container()
-        const request = container.get(Request)
-        container.set('request', request)
-
-        expect(request).to.be.equal(container.get('request'))
-    }
-
-    @test
-    bindsImplementationsWithTheSameName() {
-        const namespaceA = {
-            Request: class Request {}
-        }
-        const namespaceB = {
-            Request: class Request {}
-        }
-        const namespaceC = {
-            Request: class Request {}
-        }
-
-        const container = new Container()
-        const requestA = container.get(namespaceA.Request)
-        const requestB = container.get(namespaceB.Request)
-        const requestC = container.get(namespaceC.Request)
-        expect(requestA).to.be.instanceOf(namespaceA.Request)
-        expect(requestB).to.be.instanceOf(namespaceB.Request)
-        expect(requestC).to.be.instanceOf(namespaceC.Request)
-    }
-
-    @test
-    bindsClassToInterface() {
-        abstract class StorageInterface {}
-
-        class DiskStorage implements StorageInterface {}
-
-        class CloudStorage implements StorageInterface {}
-
-        const container = new Container()
-        container.set(StorageInterface, new DiskStorage)
-        expect(container.get(StorageInterface)).to.be.instanceOf(DiskStorage)
-        container.set(StorageInterface, new CloudStorage())
-        expect(container.get(StorageInterface)).to.be.instanceOf(CloudStorage)
-    }
-
-    @test
-    throwsExceptionIfCannotResolve() {
-        const container = new Container
-        expect(() => container.get('DoesNotExist')).to.throw(`No instance found for 'DoesNotExist'`)
-    }
-
-    @test
-    throwsExceptionIfCannotFindAnAbstractName() {
-        const container = new Container
-        const x = {} as typeof Container
-        expect(() => container.get(x)).to.throw(`Cannot get abstract name for ${x}`)
-    }
-
-    @test
-    resolvesDependenciesFromClassProperties() {
-        const container = new Container()
-
-        @Injectable()
-        class UserRepository {
-        }
-
-        @Injectable()
-        class AuthService {
-            @Inject()
-            userRepository: UserRepository
-        }
-
-        @Injectable()
-        class UserController {
-            @Inject()
-            authService: AuthService
-        }
-
-        const userController = container.get(UserController)
-        expect(userController).instanceOf(UserController)
-        expect(userController.authService).instanceOf(AuthService)
-        expect(userController.authService.userRepository).instanceOf(UserRepository)
-    }
-
-    @test
-    resolvesDependenciesFromConstructorParameters() {
-        const container = new Container
-
-        @Injectable()
-        class UserRepository {
-        }
-
-        @Injectable()
-        class AuthService {
-            constructor(public userRepository: UserRepository) {
-            }
-        }
-
-        @Injectable()
-        class UserController {
-            constructor(public authService: AuthService) {
-            }
-        }
-
-        const userController = container.get(UserController)
-        expect(userController).instanceOf(UserController)
-        expect(userController.authService).instanceOf(AuthService)
-        expect(userController.authService.userRepository).instanceOf(UserRepository)
-    }
-
-    // @test
-    // async throwsExceptionIfDependencyCannotBeResolved() {
-    //     const container = new Container;
-    //
-    //     @Injectable()
-    //     class UserController {
-    //         constructor(public userRepository: object) {
-    //         }
-    //     }
-    //
-    //     await expect(() => container.get(UserController)).to.throw(`No binding found for parameter 0 in 'UserController'`);
-    // }
-
-    @test
-    createsChildContainer() {
-        const container = new Container()
-        const childContainer = container.createChildContainer()
-        expect(childContainer).to.be.instanceOf(Container)
-        expect(childContainer).not.to.equal(container)
-    }
-
-    @test
-    childContainerGetsObjectFromParentContainer() {
-        class Storage {}
-
-        const container = new Container()
-        const childContainer = container.createChildContainer()
-
-        const storage = container.get(Storage)
-        expect(childContainer.get(Storage)).to.equal(storage)
-    }
-
-    @test
-    dependenciesHaveTheScopeSingleton() {
-        class Request {}
-
-        const container = new Container()
-        const childContainer = container.createChildContainer()
-
-        const request = childContainer.get(Request)
-        expect(childContainer.get(Request)).to.equal(request)
-    }
-
-    @test
-    async resolvesAsyncDependencies() {
-        class User {}
-
-        class Request {
-            @Inject()
-            user: User
-        }
-
-        class UserResolver extends BaseResolver {
-            canResolve<T>(abstract: ServiceIdentifier<T>): boolean {
-                return abstract === User
-            }
-
-            async resolve<T>(abstract: ServiceIdentifier<T>, parameters: object[]): Promise<T> {
-                await new Promise(resolve => setTimeout(resolve, 1))
-                return new User as T
-            }
-        }
-
-        const container = new Container()
-        container.resolvers.unshift(new UserResolver(container))
-
-        const request = container.get(Request)
-        expect(request).to.be.instanceof(Promise)
-        const resolvedRequest = await container.get(Request)
-        expect(resolvedRequest).to.be.instanceof(Request)
-    }
-
-    @test
-    async injectsDependencyUsingStringAlias() {
-        class SomeClass {
-            @Inject('theCode')
-            code: number
-        }
-
-        const container = new Container()
-        container.set('theCode', 123)
-
-        const instance = container.get(SomeClass)
-
-        expect(instance.code).to.be.equal(123)
-
-    }
-
-    // @test
-    // async customDecorators() {
-    //     class Database {
-    //         debug = false;
-    //
-    //         async init() {
-    //             this.debug = true;
-    //         }
-    //     }
-    //
-    //     function CustomDecorator() {
-    //         return function (target: Object, targetKey: string) {
-    //             // @ts-ignore
-    //             console.log('thi ->', this);
-    //             const metadata = InjectableMetadata.get(target.constructor);
-    //             metadata.dependencies[targetKey] = AuthUserIdentifier;
-    //             metadata.scope = Scope.REQUEST;
-    //             InjectableMetadata.set(metadata, target.constructor);
-    //         };
-    //         // return Container.createPropertyDecorator(container => {
-    //         //
-    //         // });
-    //     }
-    //
-    //     class Controller {
-    //         @CustomDecorator()
-    //         database: Database;
-    //     }
-    //
-    //     const container = new Container();
-    //     const controller = await container.get(Controller);
-    //
-    //     expect(controller.database).to.be.instanceof(Database);
-    //     expect(controller.database.debug).to.equal(true);
-    // }
-}