@typetron/framework 0.4.0-rc8 → 0.5.0-rc1

package/.eslintrc-old.js

@@ -0,0 +1,208 @@
+/*
+👋 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

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

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

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

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

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

package/Cache/types.ts

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

package/Container/ClassResolver.ts

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