@typetron/framework 0.4.0-rc9 → 0.5.0

package/Support/Array.ts

@@ -0,0 +1,184 @@
+export {}
+
+type ArrayItemCallback<T, R = T> = (item: T, index: number, array: T[]) => R;
+
+declare global {
+    interface Array<T> {
+        empty(): boolean;
+
+        random(): T;
+
+        randomIndex(): number;
+
+        pluck<K extends keyof T>(this: T[], property: K): T[K][];
+
+        mapAsync<U>(callback: ArrayItemCallback<T, Promise<U>>, thisArg?: this): Promise<U[]>;
+
+        forEachAsync(callback: ArrayItemCallback<T, void>, thisArg?: this): Promise<void>;
+
+        // tslint:disable-next-line:no-any
+        findWhere<K extends keyof T>(this: T[], property: K, value: T[K] | ArrayItemCallback<T, unknown>): T | undefined;
+
+        first(this: T[], defaultValue?: T): T | undefined;
+
+        last(this: T[], defaultValue?: T): T | undefined;
+
+        remove<T>(this: T[], ...items: T[]): void;
+
+        where<K extends keyof T>(this: T[], property: K, value?: T[K]): T[];
+
+        whereNot<K extends keyof T>(this: T[], property: K, value?: T[K]): T[];
+
+        whereIn<K extends keyof T>(this: T[], property: K, value: T[K][]): T[];
+
+        whereNotIn<K extends keyof T>(this: T[], property: K, value: T[K][]): T[];
+
+        groupBy<K extends keyof T>(this: T[], property: K): Record<K, T[]>;
+
+        sortBy<K extends keyof T>(this: T[], key: K, order?: 'ASC' | 'DESC' | 1 | -1): T[]
+
+        groupBy<U extends string | number | symbol>(this: T[], callback: ArrayItemCallback<T, U>): Record<U, T[]>;
+
+        unique<K extends keyof T>(this: T[], key?: K | ((item: T, index: number) => unknown)): T[];
+
+        sum<T extends number>(this: T[]): number;
+
+        sum<K extends keyof T, U extends number>(key: K | ArrayItemCallback<T, U>): U;
+
+        whenNotEmpty(this: T[], callback: (values: T[]) => void): this;
+
+        whenEmpty(callback: () => void): this;
+    }
+}
+
+Array.prototype.empty = function() {
+    return !this.length
+}
+
+Array.prototype.random = function() {
+    return this[Math.randomInt(0, this.length - 1)]
+}
+
+Array.prototype.randomIndex = function() {
+    return Math.randomInt(0, this.length - 1)
+}
+
+// tslint:disable-next-line:no-any
+Array.prototype.findWhere = function <T, K extends keyof T>(property: K, value: T[K] | ArrayItemCallback<T, unknown>) {
+    return this.find(item => item[property] === value)
+}
+
+Array.prototype.pluck = function <T, K extends keyof T, U>(property: K) {
+    return this.map((item: T) => item[property] as unknown as U)
+}
+
+Array.prototype.remove = function <T>(...items: T[]) {
+    return items.map(item => {
+        const index = this.indexOf(item)
+        if (index === -1) {
+            return
+        }
+        this.splice(this.indexOf(item), 1)
+    })
+}
+
+Array.prototype.where = function <T, K extends keyof T>(property: K, value?: T[K]) {
+    return this.filter(item => value !== undefined ? item[property] === value : item[property])
+}
+
+Array.prototype.whereNot = function <T, K extends keyof T>(property: K, value?: T[K]) {
+    return this.filter(item => value !== undefined ? item[property] !== value : !item[property])
+}
+
+Array.prototype.whereIn = function <T, K extends keyof T>(property: K, values: (T[K])[]) {
+    return this.filter(item => values.includes(item[property]))
+}
+
+Array.prototype.whereNotIn = function <T, K extends keyof T>(property: K, values: (T[K])[]) {
+    return this.filter(item => !values.includes(item[property]))
+}
+
+Array.prototype.first = function(defaultValue = undefined) {
+    const [first] = this
+    return first || defaultValue
+}
+
+Array.prototype.last = function(defaultValue = undefined) {
+    return this[this.length - 1] || defaultValue
+}
+
+Array.prototype.groupBy = function <T, K extends keyof T, U>(property: K | ArrayItemCallback<T, U>) {
+    const callback = property instanceof Function ? property : (item: T) => item[property]
+    return this.reduce((accumulator, item, index, array) => {
+        const key = callback(item, index, array);
+        (accumulator[key] = accumulator[key] || []).push(item)
+        return accumulator
+    }, {})
+}
+
+Array.prototype.sortBy = function <T, K extends keyof T>(this: T[], key: K, order?: 'ASC' | 'DESC' | 1 | -1): T[] {
+    const o = (order === 'ASC' ? 1 : order === 'DESC' ? -1 : order) || 1
+    return this.sort((a, b) => a[key] > b[key] ? 1 * o : b[key] > a[key] ? -1 * o : 0)
+}
+
+Array.prototype.forEachAsync = async function <T>(callback: ArrayItemCallback<T, void>, thisArg: T[]) {
+    for (let index = 0; index < this.length; index++) {
+        await callback.call(thisArg, this[index], index, this)
+    }
+}
+
+Array.prototype.mapAsync = async function <T, U>(callback: ArrayItemCallback<T, Promise<U>>, thisArg: T[]) {
+    if (!this.length) {
+        return []
+    }
+    const promises = []
+    for (let index = 0; index < this.length; index++) {
+        promises.push(callback.call(thisArg, this[index], index, this))
+    }
+    return Promise.all(promises)
+}
+
+Array.prototype.unique = function <T, K extends keyof T>(property?: K | ((item: T, index: number) => unknown)): T[] {
+    if (!property) {
+        return [...new Set(this)] as T[]
+    }
+
+    let callback: (item: T, index: number, list: T[]) => unknown
+    if (typeof property === 'function') {
+        callback = property
+    } else {
+        callback = (item) => item[property]
+    }
+
+    const exists = new Set
+    return this.filter((item, index) => {
+        let id: unknown
+        if (!exists.has(id = callback(item, index, this))) {
+            exists.add(id)
+            return true
+        }
+    })
+}
+
+Array.prototype.sum = function <T, K extends keyof T, U extends number>(property?: K | ArrayItemCallback<T, U>) {
+    const callback = property instanceof Function ? property : (item: T) => property ? item[property] : item
+    return this.reduce((accumulator, item, index, array) => {
+        return accumulator + callback(item, index, array)
+    }, 0)
+}
+
+Array.prototype.whenNotEmpty = function <T>(callback: (values: T[]) => void) {
+    if (!this.empty()) {
+        callback(this)
+    }
+
+    return this
+}
+
+Array.prototype.whenEmpty = function(callback: () => void) {
+    if (this.empty()) {
+        callback()
+    }
+
+    return this
+}

package/Support/Math.ts

@@ -0,0 +1,12 @@
+export {}
+declare global {
+    interface Math {
+        randomInt(min?: number, max?: number): number;
+    }
+}
+
+Math.randomInt = function (min: number = Number.MIN_SAFE_INTEGER, max: number = Number.MAX_SAFE_INTEGER) {
+    min = Math.ceil(min)
+    max = Math.floor(max)
+    return Math.floor(Math.random() * (max - min + 1)) + min
+}

package/Support/Metadata.ts

@@ -0,0 +1,31 @@
+import { Constructor } from './index'
+
+export function MetadataKey(key: string) {
+    return class Metadata {
+        // tslint:disable-next-line:no-any
+        static get<T extends Metadata>(this: typeof Metadata & Constructor<T>, target: any, defaultValue?: T): T {
+            // This handles the copy of dependencies from the parent to the child.
+            // It's hacky because `newInjectable.dependencies` is a property of InjectableMetadata
+            if (target.__proto__._metadata_?.['injectable'] && target.__proto__._metadata_ === target._metadata_) {
+                const newInjectable = new this
+                Object.assign(newInjectable, target.__proto__._metadata_['injectable'])
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                newInjectable.dependencies = {...target.__proto__._metadata_['injectable'].dependencies}
+                target['_metadata_'] = {injectable: newInjectable}
+                return newInjectable
+            }
+            return (target['_metadata_'] || (target['_metadata_'] = {[key]: new this}))[key]
+                || (target['_metadata_'][key] = defaultValue ?? new this)
+        }
+
+        static set<T extends Metadata>(this: typeof Metadata & Constructor<T>, metadata: T, target: any) {
+            const metadataBag = target['_metadata_'] || (target['_metadata_'] = {})
+            return metadataBag[key] = metadata
+        }
+    }
+}
+
+export class ParametersTypesMetadata<T> extends MetadataKey('design:paramtypes') {
+    parameters: T
+}

package/Support/String.ts

@@ -0,0 +1,38 @@
+export {}
+declare global {
+    interface StringConstructor {
+        random(length?: number, stringDomain?: string): string;
+
+        randomAlphaNum(length?: number): string;
+    }
+
+    interface String {
+        capitalize(): this;
+
+        limit(length: number, end?: string): this;
+    }
+}
+
+const string = '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~'
+String.random = function(length = Math.randomInt(1, 15), stringDomain = string) {
+    const characters = stringDomain.split('')
+    let word = ''
+    for (let i = 0; i < length; i++) {
+        word += characters.random()
+    }
+    return word
+}
+String.randomAlphaNum = function(length: number) {
+    return this.random(length, 'abcdefghijklmnopqrstuvwxyz1234567890')
+}
+
+String.prototype.capitalize = function () {
+    return this.charAt(0).toUpperCase() + this.slice(1)
+}
+
+String.prototype.limit = function (limit: number, end = '...') {
+    if (limit < this.length) {
+        return this.substring(0, limit - end.length) + end
+    }
+    return this
+}

package/Support/index.ts

@@ -0,0 +1,19 @@
+import './Array'
+import './String'
+import './Math'
+import './utils'
+
+export type KeysOfType<T, Condition> = { [P in keyof T]: T[P] extends Condition ? P : never }[keyof T]
+export type ChildKeys<Child, Parent> = Exclude<keyof Child, keyof Parent>
+export type ChildObject<Child, Parent> = Omit<Child, keyof Parent>
+
+// tslint:disable-next-line:no-any
+export type Type<T> = new(...args: any[]) => T
+export type AnyFunction<T = any> = (...args: any[]) => T
+
+export interface Abstract<T> {
+    prototype: T;
+}
+
+// tslint:disable-next-line:no-any
+export type Constructor<T = object> = new(...args: any[]) => T

package/Support/utils.ts

@@ -0,0 +1,7 @@
+export function JSONSafeParse<T>(text?: string) {
+    try {
+        return text ? JSON.parse(text) as T : undefined
+    } catch (error) {
+        return undefined
+    }
+}

package/Testing/TestCase.ts

@@ -0,0 +1,193 @@
+import '../Support/Math'
+import { ErrorHandlerInterface, Handler as HTTPHandler, Http, HttpError, Request as HttpRequest, Response } from '../Router/Http'
+import { IncomingHttpHeaders } from 'http'
+import { Application, DatabaseProvider } from '../Framework'
+import { Router } from '../Router'
+import { Auth, User } from '../Framework/Auth'
+import { ActionRequest } from '../Router/Websockets/types'
+import { Handler as WebsocketsHandler, WebSocket } from '../Router/Websockets'
+import { Container } from '../Container'
+import { ID } from '@Typetron/Database'
+import { anything, instance, mock, when } from 'ts-mockito'
+import { Crypt } from '@Typetron/Encryption'
+import { Request } from '@Typetron/Router/Request'
+import { HttpRoute } from '@Typetron/Router/Http/HttpRoute'
+
+export abstract class TestCase {
+    static app: Application
+    app: Container
+
+    // tslint:disable-next-line:no-any
+    actionListeners = new Map<string, (response: any) => void>()
+
+    providersNeedingReboot = [
+        DatabaseProvider
+    ]
+
+    abstract bootstrapApp(): Promise<Application>
+
+
+    async before() {
+        if (!TestCase.app) {
+            TestCase.app = await this.bootstrapApp()
+        }
+        await TestCase.app.registerProviders(this.providersNeedingReboot)
+        this.app = TestCase.app.createChildContainer()
+
+        const crypt = mock(Crypt)
+        when(crypt.hash(anything(), anything())).thenCall(value => `testing-${value}`)
+        when(crypt.compare(anything(), anything())).thenCall((first, second) => Promise.resolve(`testing-${first}` === second))
+
+        this.app.set(Crypt, instance(crypt))
+    }
+
+    async after() {}
+
+    async loginById(id: ID) {
+        await this.app.get(Auth).loginById(id)
+    }
+
+    /**
+     * @deprecated
+     */
+    async login(user: User) {
+        await this.loginById(user.id)
+    }
+
+    async actingAs(user: User) {
+        await this.app.get(Auth).loginUser(user)
+    }
+
+    get<T extends string | object | undefined>(routeName: string, content = {}, headers: IncomingHttpHeaders = {}): Promise<Response<T>> {
+        return this.request(Http.Method.GET, routeName, content, headers) as Promise<Response<T>>
+    }
+
+    post<T extends string | object | undefined>(
+        route: string | [string, Record<string, string | number>],
+        content = {},
+        headers: IncomingHttpHeaders = {}
+    ): Promise<Response<T>> {
+        return this.request(Http.Method.POST, route, content, headers) as Promise<Response<T>>
+    }
+
+    patch<T extends string | object | undefined>(
+        route: string | [string, Record<string, string | number>],
+        content = {},
+        headers: IncomingHttpHeaders = {}
+    ): Promise<Response<T>> {
+        return this.request(Http.Method.PATCH, route, content, headers) as Promise<Response<T>>
+    }
+
+    put<T extends string | object | undefined>(
+        route: string | [string, Record<string, string | number>],
+        content = {},
+        headers: IncomingHttpHeaders = {}
+    ): Promise<Response<T>> {
+        return this.request(Http.Method.PUT, route, content, headers) as Promise<Response<T>>
+    }
+
+    delete<T extends string | object | undefined>(
+        route: string | [string, Record<string, string | number>],
+        content = {},
+        headers: IncomingHttpHeaders = {}
+    ): Promise<Response<T>> {
+        return this.request(Http.Method.DELETE, route, content, headers) as Promise<Response<T>>
+    }
+
+    async action<T extends string | object | undefined>(action: string, content?: ActionRequest['message']): Promise<Response<T>> {
+        const socketMock = mock(WebSocket)
+
+        when(socketMock.publishAndSend(anything(), anything(), anything())).thenCall((topic, calledActon, message) => {
+            const callback = this.actionListeners.get(calledActon)
+            callback?.(message)
+        })
+
+        when(socketMock.send(anything(), anything())).thenCall((calledActon, message) => {
+            const callback = this.actionListeners.get(calledActon)
+            callback?.(message)
+        })
+
+        const container = this.app.createChildContainer()
+        container.set(WebSocket, instance(socketMock))
+
+        const request = new Request(action, content?.body)
+
+        // TODO find a way to save parameters so they can be retrieved easily in the Resolvers (check EntityResolver for example)
+        content?.parameters?.forEach(parameter => {
+            request.parameters[String.random(15)] = parameter
+        })
+
+        try {
+            return await this.app.get(WebsocketsHandler).handle(container, request)
+        } catch (error) {
+            if (error instanceof HttpError) {
+                const errorResponse = await this.app.get(ErrorHandlerInterface).handle(error)
+                console.error(errorResponse.body)
+                return errorResponse as Response<T>
+            }
+            throw error
+        }
+    }
+
+    on<T>(action: string, callback: (response: T) => void) {
+        this.actionListeners.set(action, callback)
+    }
+
+    private async request(
+        method: Http.Method,
+        routeName: string | [string, Record<string, string | number>],
+        content = {},
+        headers: IncomingHttpHeaders = {}
+    ) {
+        let routeParameters = {}
+        if (typeof routeName !== 'string') {
+            [routeName, routeParameters] = routeName
+        }
+
+        const router = this.app.get(Router)
+        const route = router.routes.findWhere('name', routeName) as HttpRoute
+        if (!route) {
+            throw new Error(`Route '${routeName}' not found`)
+        }
+        const parameters = this.convertRouteParametersToString(routeParameters) || {}
+
+        const auth = this.app.get(Auth)
+        if (auth.id) {
+            const token = await auth.sign(auth.id)
+            headers.authorization = `Bearer ${token}`
+        }
+
+        const request = new HttpRequest(route.getUrl(parameters), method, {}, {}, content)
+
+        request.setHeadersLoader(() => {
+            return headers
+        })
+        request.getHeader = <T extends string | string[] | undefined>(name: keyof IncomingHttpHeaders | string): T => {
+            return headers[String(name).toLowerCase()] as T
+        }
+
+        let response: Response
+        try {
+            response = await this.app.get(HTTPHandler).handle(this.app as Application, request)
+
+            if (response.body instanceof Buffer) {
+                response.body = response.body.toString()
+            }
+
+            return response
+
+        } catch (error) {
+            if (error instanceof HttpError) {
+                return this.app.get(ErrorHandlerInterface).handle(error)
+            }
+            throw error
+        }
+    }
+
+    private convertRouteParametersToString(routeParameters: Record<string, string | number>) {
+        Object.keys(routeParameters).forEach(key => {
+            routeParameters[key] = String(routeParameters[key])
+        })
+        return routeParameters as Record<string, string>
+    }
+}

package/Validation/Rule.ts

@@ -0,0 +1,9 @@
+import { RuleInterface } from './RuleInterface'
+
+export abstract class Rule implements RuleInterface {
+    abstract identifier: string
+
+    abstract message(attribute: string, value: string | number | object | boolean | undefined): string;
+
+    abstract passes(attribute: string, value: string | number | object | boolean | undefined): boolean ;
+}

package/Validation/RuleInterface.ts

@@ -0,0 +1,10 @@
+import { RuleValue } from '.'
+
+export interface RuleInterface {
+    identifier: string;
+
+    passes(attribute: string, value?: RuleValue): boolean;
+
+    message(attribute: string, value: RuleValue): string;
+}
+

package/Validation/Rules/Email.ts

@@ -0,0 +1,20 @@
+import { RuleInterface, RuleValue } from '..'
+import { Rule } from '../Rule'
+import { Type } from '@Typetron/Support'
+
+export function Email(message?: string): Type<RuleInterface> {
+    return class extends Rule {
+        identifier = 'email'
+
+        private regex = /^(?:[a-z0-9!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)])$/
+
+        passes(attribute: string, value: RuleValue): boolean {
+            return this.regex.test(String(value).trim())
+        }
+
+        message(attribute: string): string {
+            return message ?? `The ${attribute} must be a valid email address`
+        }
+    }
+
+}

package/Validation/Rules/FileExtension.ts

@@ -0,0 +1,21 @@
+import { Rule, RuleInterface } from '@Typetron/Validation'
+import { Type } from '@Typetron/Support'
+import { File } from '@Typetron/Storage'
+
+export function FileExtension(extensions: string[], message?: string): Type<RuleInterface> {
+    return class extends Rule {
+        identifier = 'fileExtension'
+
+        passes(attribute: string, value?: File): boolean {
+            return value?.extension ? extensions.includes(value.extension) : false
+        }
+
+        message(attribute: string, value?: File): string {
+            const messagePart = extensions.length === 1
+                ? `the '.${extensions.first()}' extension`
+                : `these extensions: ${extensions.map(extension => `.${extension}`).join(', ')}`
+
+            return message ?? `The ${attribute} must have ${messagePart}`
+        }
+    }
+}

package/Validation/Rules/MaxLength.ts

@@ -0,0 +1,17 @@
+import { RuleInterface, RuleValue } from '..'
+import { Rule } from '../Rule'
+import { Type } from '../../Support'
+
+export function MaxLength(max: number, message?: string): Type<RuleInterface> {
+    return class extends Rule {
+        identifier = 'maxLength'
+
+        passes(attribute: string, value: RuleValue): boolean {
+            return Boolean(value && String(value).length <= max)
+        }
+
+        message(attribute: string): string {
+            return message ?? `The ${attribute} must have at most ${max} characters`
+        }
+    }
+}

package/Validation/Rules/MinLength.ts

@@ -0,0 +1,18 @@
+import { RuleInterface } from '../RuleInterface'
+import { RuleValue } from '..'
+import { Type } from '../../Support'
+import { Rule } from '../Rule'
+
+export function MinLength(min: number, message?: string): Type<RuleInterface> {
+    return class extends Rule {
+        identifier = 'minLength'
+
+        passes(attribute: string, value: RuleValue): boolean {
+            return Boolean(value && String(value).length >= min)
+        }
+
+        message(attribute: string): string {
+            return message ?? `The ${attribute} must have at least ${min} characters`
+        }
+    }
+}

package/Validation/Rules/Optional.ts

@@ -0,0 +1,18 @@
+import { RuleInterface, RuleValue } from '..'
+import { Rule } from '../Rule'
+import { Type } from '@Typetron/Support'
+
+export function Optional(): Type<RuleInterface> {
+    return class extends Rule {
+        identifier = 'optional'
+
+        passes(attribute: string, value: RuleValue): boolean {
+            return true // TODO
+        }
+
+        message(attribute: string): string {
+            return ''
+        }
+    }
+}
+

package/Validation/Rules/Required.ts

@@ -0,0 +1,29 @@
+import { RuleInterface, RuleValue } from '..'
+import { Type } from '@Typetron/Support'
+
+export function Required(message?: string): Type<RuleInterface> {
+    return class {
+        identifier = 'required'
+
+        passes(attribute: string, value: RuleValue): boolean {
+
+            if (value === undefined || value === null) {
+                return false
+            }
+
+            if (typeof value === 'string' && value.trim() === '') {
+                return false
+            }
+
+            if (value.constructor === Array && value.length === 0) {
+                return false
+            }
+
+            return true
+        }
+
+        message(attribute: string): string {
+            return message ?? `The ${attribute} is required`
+        }
+    }
+}

package/Validation/Validator.ts

@@ -0,0 +1,7 @@
+import { RuleInterface } from './RuleInterface'
+import { Type } from '../Support'
+
+export abstract class Validator<T> {
+    protected constructor(public data: T, public rules: { [key in keyof T]?: (RuleInterface | Type<RuleInterface>)[] }) {
+    }
+}

package/Validation/index.ts

@@ -0,0 +1,12 @@
+// tslint:disable-next-line:no-any
+export type RuleValue = any
+export * from './RuleInterface'
+export * from './Validator'
+export * from './Rule'
+export * from './Rules/MaxLength'
+export * from './Rules/MinLength'
+export * from './Rules/FileExtension'
+export * from './Rules/Required'
+export * from './Rules/Email'
+export * from './Rules/Optional'
+// export * from './Rules/FileExtension'