@typetron/framework 0.5.3 → 0.5.4

package/benchmark-index.js

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

@@ -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/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.3",
+    "version": "0.5.4",
     "keywords": [
         "typetron",
         "framework",
@@ -15,11 +15,12 @@
         "name": "Ionel Lupu"
     },
     "scripts": {
-        "build": "tsc",
+        "build": "tsc && cp package.json build/",
         "dev": "tsc --watch",
         "test": "mocha",
         "test:watch": "mocha --watch",
         "preversion": "npm test",
+        "publish": "npm publish ./build",
         "lint": "eslint ."
     },
     "engines": {
@@ -63,6 +64,9 @@
         "url": "https://github.com/typetron/framework.git"
     },
     "files": [
-        "build/"
+        "**/*.ts",
+        "**/*.js",
+        "**/*.ts.map",
+        "**/*.js.map"
     ]
 }

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

package/tests/Cache/FileStoreTest.ts

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

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