@typetron/framework 0.5.6 → 0.5.8

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.6",
+    "version": "0.5.8",
     "keywords": [
         "typetron",
         "framework",
@@ -20,7 +20,6 @@
         "test": "mocha",
         "test:watch": "mocha --watch",
         "preversion": "npm test",
-        "publish": "npm publish ./build",
         "lint": "eslint ."
     },
     "engines": {

package/.eslintrc-old.js

@@ -1,208 +0,0 @@
-/*
-👋 Hi! This file was autogenerated by tslint-to-eslint-config.
-https://github.com/typescript-eslint/tslint-to-eslint-config
-
-It represents the closest reasonable ESLint configuration to this
-project's original TSLint configuration.
-
-We recommend eventually switching this configuration to extend from
-the recommended rulesets in typescript-eslint.
-https://github.com/typescript-eslint/tslint-to-eslint-config/blob/master/docs/FAQs.md
-
-Happy linting! 💖
-*/
-module.exports = {
-	'env' : {
-		'es6' : true,
-		'node' : true
-	},
-	'parser' : '@typescript-eslint/parser',
-	'parserOptions' : {
-		'project' : 'tsconfig.json',
-		'sourceType' : 'module'
-	},
-	'plugins' : [
-		'eslint-plugin-import',
-		'eslint-plugin-no-null',
-		'eslint-plugin-jsdoc',
-		'@angular-eslint/eslint-plugin',
-		'@typescript-eslint',
-		'@typescript-eslint/tslint'
-	],
-	'root' : true,
-	'rules' : {
-		'@angular-eslint/component-class-suffix' : 'error',
-		'@angular-eslint/directive-class-suffix' : 'error',
-		'@angular-eslint/no-input-rename' : 'error',
-		'@angular-eslint/no-output-on-prefix' : 'error',
-		'@angular-eslint/no-output-rename' : 'error',
-		'@angular-eslint/use-pipe-transform-interface' : 'error',
-		'@typescript-eslint/ban-types' : 'error',
-		'@typescript-eslint/dot-notation' : 'off',
-		'@typescript-eslint/explicit-member-accessibility' : [
-			'off',
-			{
-				'accessibility' : 'explicit'
-			}
-		],
-		'@typescript-eslint/indent' : 'error',
-		'@typescript-eslint/member-delimiter-style' : [
-			'off',
-			{
-				'multiline' : {
-					'delimiter' : 'semi',
-					'requireLast' : true
-				},
-				'singleline' : {
-					'delimiter' : 'semi',
-					'requireLast' : false
-				}
-			}
-		],
-		'@typescript-eslint/naming-convention' : [
-			'error',
-			{
-				'selector' : 'variable',
-				'format' : [
-					'camelCase',
-					'UPPER_CASE'
-				],
-				'leadingUnderscore' : 'forbid',
-				'trailingUnderscore' : 'forbid'
-			}
-		],
-		'@typescript-eslint/no-empty-function' : 'off',
-		'@typescript-eslint/no-empty-interface' : 'error',
-		'@typescript-eslint/no-explicit-any' : 'error',
-		'@typescript-eslint/no-inferrable-types' : 'off',
-		'@typescript-eslint/no-misused-new' : 'error',
-		'@typescript-eslint/no-non-null-assertion' : 'error',
-		'@typescript-eslint/no-shadow' : [
-			'error',
-			{
-				'hoist' : 'all'
-			}
-		],
-		'@typescript-eslint/no-unused-expressions' : 'error',
-		'@typescript-eslint/no-use-before-define' : 'error',
-		'@typescript-eslint/prefer-function-type' : 'error',
-		'@typescript-eslint/quotes' : [
-			'error',
-			'single'
-		],
-		'@typescript-eslint/semi' : [
-			'off',
-			'always'
-		],
-		'@typescript-eslint/type-annotation-spacing' : 'error',
-		'@typescript-eslint/unified-signatures' : 'error',
-		'arrow-body-style' : 'error',
-		'brace-style' : [
-			'error',
-			'1tbs'
-		],
-		'constructor-super' : 'error',
-		'curly' : 'error',
-		'dot-notation' : 'off',
-		'eol-last' : 'off',
-		'eqeqeq' : [
-			'error',
-			'smart'
-		],
-		'guard-for-in' : 'off',
-		'id-denylist' : 'off',
-		'id-match' : 'off',
-		'import/no-default-export' : 'error',
-		'import/no-deprecated' : 'warn',
-		'indent' : 'off',
-		'jsdoc/no-types' : 'error',
-		'max-len' : [
-			'error',
-			{
-				'code' : 140
-			}
-		],
-		'no-bitwise' : 'error',
-		'no-caller' : 'error',
-		'no-console' : [
-			'error',
-			{
-				'allow' : [
-					'log',
-					'warn',
-					'dir',
-					'timeLog',
-					'assert',
-					'clear',
-					'count',
-					'countReset',
-					'group',
-					'groupEnd',
-					'table',
-					'dirxml',
-					'error',
-					'groupCollapsed',
-					'Console',
-					'profile',
-					'profileEnd',
-					'timeStamp',
-					'context'
-				]
-			}
-		],
-		'no-debugger' : 'error',
-		'no-empty' : 'off',
-		'no-empty-function' : 'off',
-		'no-eval' : 'error',
-		'no-fallthrough' : 'error',
-		'no-new-wrappers' : 'error',
-		'no-null/no-null' : 'error',
-		'no-restricted-imports' : [
-			'error',
-			'rxjs/Rx'
-		],
-		'no-shadow' : 'off',
-		'no-throw-literal' : 'error',
-		'no-trailing-spaces' : 'off',
-		'no-undef-init' : 'error',
-		'no-underscore-dangle' : 'off',
-		'no-unused-expressions' : 'off',
-		'no-unused-labels' : 'error',
-		'no-use-before-define' : 'off',
-		'no-var' : 'error',
-		'prefer-const' : 'error',
-		'quotes' : 'off',
-		'radix' : 'error',
-		'semi' : 'off',
-		'spaced-comment' : [
-			'error',
-			'always',
-			{
-				'markers' : [
-					'/'
-				]
-			}
-		],
-		'@typescript-eslint/tslint/config' : [
-			'error',
-			{
-				'rules' : {
-					'import-spacing' : true,
-					'no-unsafe-any' : true,
-					'use-host-property-decorator' : true,
-					'use-input-property-decorator' : true,
-					'use-life-cycle-interface' : true,
-					'use-output-property-decorator' : true,
-					'whitespace' : [
-						true,
-						'check-branch',
-						'check-decl',
-						'check-operator',
-						'check-separator',
-						'check-type'
-					]
-				}
-			}
-		]
-	}
-}

package/Cache/Cache.ts

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

package/Cache/Stores/DatabaseStore.ts

@@ -1,120 +0,0 @@
-import { Cache } from '@Typetron/Cache'
-import { Query } from '@Typetron/Database'
-import { JSONSafeParse } from '@Typetron/Support/utils'
-import { CacheItem } from '@Typetron/Cache/types'
-import { createHash } from 'crypto'
-import { Create } from '@Typetron/Database/Drivers/SQLite/Create'
-
-export class DatabaseStore extends Cache {
-    constructor(public table: string) {
-        super()
-    }
-
-    private get cacheTable() {
-        return new Query<CacheItem<unknown>>().table(this.table)
-    }
-
-    private getNameHash(name: string) {
-        return createHash('sha1').update(name).digest('hex')
-    }
-
-    async has(name: string): Promise<boolean> {
-        const row = await this.cacheTable.where('name', this.getNameHash(name)).first()
-        return !!row
-    }
-
-    async get<T>(name: string, defaultValue?: T | (() => T | Promise<T>)): Promise<T | undefined> {
-        if (!await Query.connection.driver.tableExists(this.table)) {
-            return undefined
-        }
-
-        const row = await this.cacheTable.where('name', this.getNameHash(name)).first()
-
-        if (!row) {
-            return this.getDefaultValue(defaultValue)
-        }
-
-        const currentTime = Date.now()
-
-        if (row.date && row.date < currentTime) {
-            await this.delete(name)
-            return this.getDefaultValue(defaultValue)
-        }
-
-        return JSONSafeParse<T>(String(row.value))
-    }
-
-    async remember<T>(name: string, defaultValue?: T | (() => T | Promise<T>), durationInSeconds?: number): Promise<T | undefined> {
-        const value = await this.get<T>(name)
-
-        if (!value) {
-            const newValue = await this.getDefaultValue(defaultValue)
-            await this.set(name, newValue, durationInSeconds)
-            return newValue
-        }
-
-        return value
-    }
-
-    async set(name: string, value: any, durationInSeconds?: number): Promise<void> {
-        await this.makeSureTheTableExists()
-        const expirationTime = durationInSeconds ? Date.now() + durationInSeconds * 1000 : undefined
-        const serializedValue = JSON.stringify(value)
-
-        const existing = await this.cacheTable.where('name', this.getNameHash(name)).first()
-
-        if (existing) {
-            await this.cacheTable.where('name', this.getNameHash(name)).update({
-                value: serializedValue,
-                date: expirationTime
-            })
-        } else {
-            await this.cacheTable.insert({
-                name: this.getNameHash(name),
-                value: serializedValue,
-                date: expirationTime
-            })
-        }
-    }
-
-    async delete(name: string): Promise<void> {
-        await this.cacheTable.where('name', this.getNameHash(name)).delete()
-    }
-
-    async flush(): Promise<void> {
-        await this.cacheTable.delete()
-    }
-
-    private async getDefaultValue<T>(defaultValue?: (() => (Promise<T> | T)) | T) {
-        const valueFunction = typeof defaultValue === 'function'
-            ? defaultValue as () => Promise<T> | T
-            : () => defaultValue
-
-        return valueFunction()
-    }
-
-    private async makeSureTheTableExists() {
-        if (!await Query.connection.driver.tableExists(this.table)) {
-            const createStatement = new Create(this.table, [
-                {
-                    name: 'name',
-                    type: 'string',
-                    primaryKey: true,
-                    nullable: true,
-                },
-                {
-                    name: 'value',
-                    type: 'string',
-                    nullable: true,
-                },
-                {
-                    name: 'date',
-                    type: 'integer',
-                    nullable: true,
-                },
-            ])
-
-            await Query.connection.driver.run(createStatement.toSQL())
-        }
-    }
-}

package/Cache/Stores/FileStore.ts

@@ -1,69 +0,0 @@
-import { Cache } from '@Typetron/Cache'
-import { Storage } from '@Typetron/Storage'
-import { createHash } from 'node:crypto'
-import path from 'node:path'
-import { JSONSafeParse } from '@Typetron/Support/utils'
-import { CacheItem } from '@Typetron/Cache/types'
-
-export class FileStore extends Cache {
-    constructor(public storage: Storage, public directory: string) {
-        super()
-    }
-
-    async has(name: string): Promise<boolean> {
-        return await this.storage.exists(this.path(name))
-    }
-
-    async get<T>(name: string, defaultValue?: T | (() => T | Promise<T>)): Promise<T | undefined> {
-        const item: CacheItem<T> = await this.storage.read(this.path(name))
-            .then(async (data) => JSONSafeParse<CacheItem<T>>(data.toString()) ?? {value: await this.getDefaultValue<T>(defaultValue)})
-            .catch(async () => ({value: await this.getDefaultValue<T>(defaultValue)}))
-
-        if (item['date'] && item['date'] < new Date().getTime()) {
-            await this.delete(name)
-            return this.getDefaultValue(defaultValue)
-        }
-
-        return item['value']
-    }
-
-    async remember<T>(name: string, defaultValue?: T | (() => T | Promise<T>), durationInSeconds?: number): Promise<T | undefined> {
-        const data = await this.get<T>(name)
-
-        if (data !== undefined) {
-            return data
-        }
-
-        const value = await this.getDefaultValue(defaultValue)
-        await this.set(name, value, durationInSeconds)
-        return value
-    }
-
-    async set(name: string, value: any, durationInSeconds?: number): Promise<void> {
-        await this.storage.put(this.path(name), JSON.stringify({
-            value,
-            date: durationInSeconds ? Date.now() + durationInSeconds * 1000 : undefined
-        } as CacheItem<unknown>))
-    }
-
-    async delete(name: string): Promise<void> {
-        await this.storage.delete(this.path(name))
-    }
-
-    async flush(): Promise<void> {
-        await this.storage.deleteDirectory(this.directory)
-    }
-
-    private path(key: string): string {
-        const hashKey = createHash('sha1').update(key).digest('hex')
-        return path.join(this.directory, '/', hashKey)
-    }
-
-    private async getDefaultValue<T>(defaultValue?: (() => (Promise<T> | T)) | T) {
-        const valueFunction = typeof defaultValue === 'function'
-            ? defaultValue as () => Promise<T> | T
-            : () => defaultValue
-
-        return valueFunction()
-    }
-}

package/Cache/Stores/MemoryStore.ts

@@ -1,71 +0,0 @@
-import { Cache } from '@Typetron/Cache'
-import { CacheItem } from '@Typetron/Cache/types'
-
-export class MemoryStore extends Cache {
-    public cache: Map<string, CacheItem<unknown>> = new Map()
-
-    async has(name: string): Promise<boolean> {
-        const cacheItem = this.cache.get(name)
-
-        if (!cacheItem) {
-            return false
-        }
-
-        const currentTime = Date.now()
-
-        if (cacheItem.date && cacheItem.date < currentTime) {
-            this.cache.delete(name)
-            return false
-        }
-
-        return true
-    }
-
-    async get<T>(name: string, defaultValue?: T | (() => T | Promise<T>)): Promise<T | undefined> {
-        const cacheItem = this.cache.get(name)
-
-        if (!await this.has(name)) {
-            return this.getDefaultValue(defaultValue)
-        }
-
-        return cacheItem!.value as T
-    }
-
-    // return (cacheItem as CacheItem<T>).value as T
-    async remember<T>(name: string, defaultValue?: T | (() => T | Promise<T>), durationInSeconds?: number): Promise<T | undefined> {
-        const cacheItem = this.cache.get(name)
-
-        if (await this.has(name)) {
-            return cacheItem!.value as T
-        }
-
-        const value = await this.getDefaultValue(defaultValue)
-        await this.set(name, value, durationInSeconds)
-        return value
-    }
-
-    async set(name: string, value: any, durationInSeconds?: number): Promise<void> {
-        const expirationTime = durationInSeconds ? Date.now() + durationInSeconds * 1000 : Infinity
-
-        this.cache.set(name, {
-            value: value,
-            date: expirationTime
-        })
-    }
-
-    async delete(name: string): Promise<void> {
-        this.cache.delete(name)
-    }
-
-    async flush(): Promise<void> {
-        this.cache.clear()
-    }
-
-    private async getDefaultValue<T>(defaultValue?: (() => (Promise<T> | T)) | T) {
-        const valueFunction = typeof defaultValue === 'function'
-            ? defaultValue as () => Promise<T> | T
-            : () => defaultValue
-
-        return valueFunction()
-    }
-}

package/Cache/index.ts

@@ -1,5 +0,0 @@
-export * from './types'
-export * from './Cache'
-export * from './Stores/MemoryStore'
-export * from './Stores/FileStore'
-export * from './Stores/DatabaseStore'

package/Cache/types.ts

@@ -1,4 +0,0 @@
-export interface CacheItem<T>{
-    value?: T
-    date?: number
-}

package/Container/ClassResolver.ts

@@ -1,106 +0,0 @@
-import { Constructor } from '../Support'
-import { BaseResolver } from './Resolver'
-import { InjectableMetadata, Scope } from './Metadata'
-import { Container } from './Container'
-import { ParametersTypesMetadata } from '@Typetron/Support/Metadata'
-
-export class ClassResolver extends BaseResolver {
-    canResolve<T>(abstract: Constructor<T>): boolean {
-        return abstract.prototype && abstract.prototype.constructor.name
-    }
-
-    resolve<T>(abstract: Constructor<T>, parametersValues: object[]) {
-
-        // TODO improve this since it looks very hard to write next time
-        const parametersTypes: Constructor[] = ParametersTypesMetadata.get(abstract).parameters
-            ?? (ParametersTypesMetadata.get(abstract).parameters = Reflect.getMetadata('design:paramtypes', abstract) ?? [])
-
-        const parameters = parametersTypes.map((parameterType, index) => {
-            if (parametersValues[index]) {
-                return parametersValues[index]
-            }
-            if (parameterType.name === 'Object' && parametersValues[index]) {
-                parameterType = parametersValues[index] as Constructor // || this.getParameterValue(abstract, index);
-            }
-            return this.container.get(parameterType)
-        })
-
-        const instance = new abstract(...parameters)
-
-        const metadata = InjectableMetadata.get(abstract)
-        let asyncDependencies = 0
-        let resolve: (value: T | PromiseLike<T>) => void
-        let reject: (reason?: unknown) => void
-        for (const dependency in metadata.dependencies) {
-            const dependencyAbstract = metadata.dependencies[dependency]
-            if (!dependencyAbstract) {
-                continue
-            }
-            const value = this.container.get(dependencyAbstract) as T[keyof T]
-            if (value instanceof Promise) {
-                asyncDependencies++
-                value
-                    .then((resolvedValue) => {
-                        instance[dependency as keyof T] = resolvedValue
-                        asyncDependencies--
-                        if (!asyncDependencies) {
-                            resolve(instance)
-                        }
-                    })
-                    .catch((error) => {
-                        reject(error)
-                    })
-            } else {
-                instance[dependency as keyof T] = value
-            }
-        }
-        if (asyncDependencies) {
-            return new Promise<T>((resolveFunction, rejectFunction) => {
-                resolve = resolveFunction
-                reject = rejectFunction
-            })
-        }
-
-        return instance
-    }
-
-    // TODO figure out how to use this better
-    // private getParameterValue<T>(abstract: Constructor<T>, index: number) {
-    //     const injectMetadata = Reflect.getMetadata('container:inject', abstract);
-    //     if (!injectMetadata) {
-    //         throw new Error(`No binding found for parameter ${index} in '${abstract.name}'`);
-    //     }
-    //     const value = injectMetadata.find((metadata: any) => metadata.index === index);
-    //     return value.abstract;
-    // }
-
-    reload<T>(
-        abstract: Constructor<T>,
-        concrete: T,
-        container: Container = this.container
-    ): T {
-        const metadata = InjectableMetadata.get(abstract)
-        for (const dependencyName in metadata.dependencies) {
-            if (!metadata.dependencies[dependencyName]) {
-                continue
-            }
-            const dependency = metadata.dependencies[dependencyName]
-            if (!dependency) {
-                continue
-            }
-            if (typeof dependency === 'symbol') {
-                concrete[dependencyName as keyof T] = container.get(
-                    dependency
-                ) as T[keyof T]
-                continue
-            }
-            const dependencyMetadata = InjectableMetadata.get(dependency)
-            if (dependencyMetadata.scope === Scope.REQUEST) {
-                concrete[dependencyName as keyof T] = container.get(
-                    dependency
-                ) as T[keyof T]
-            }
-        }
-        return concrete
-    }
-}