@typetron/framework 0.5.3 → 0.5.5

package/Database/Types.ts

@@ -0,0 +1,165 @@
+import { Query } from './Query'
+import { StringExpression } from './StringExpression'
+import { EntityQuery } from './EntityQuery'
+
+export enum Operators {
+    '=' = '=',
+    '<' = '<',
+    '<=' = '<=',
+    '>' = '>',
+    '>=' = '>=',
+    '!=' = '!=',
+    'AND' = 'AND',
+    'OR' = 'OR',
+    'IS' = 'IS',
+    'IN' = 'IN',
+    'NOT IN' = 'NOT IN',
+    'LIKE' = 'LIKE',
+    'IS NOT' = 'IS NOT',
+}
+
+export enum JoinType {
+    INNER = 'INNER',
+    LEFT = 'LEFT',
+    RIGHT = 'RIGHT'
+}
+
+export type BooleanOperator = 'AND' | 'OR' | 'XOR';
+export type Operator = keyof typeof Operators;
+export type SqlValue = string | number | Date | undefined;
+export type SqlValueMap = {[key: string]: SqlValue};
+
+class JoinClause {
+    type: keyof typeof JoinType
+    table: string
+    first: string
+    operator: Operator
+    second: string
+}
+
+export interface BaseComponents {
+    table: string;
+}
+
+export interface CreateComponents {
+    table: string;
+    columns: (string | StringExpression)[];
+}
+
+export interface SelectComponents extends BaseComponents {
+    distinct?: boolean;
+    columns: (string | StringExpression)[];
+    aggregate?: {
+        function: string,
+        columns: string[];
+    };
+    joins: JoinClause[];
+    wheres: SqlClause[];
+    groups: string[];
+    orders: [string, Direction][];
+    having: Where[];
+    limit?: {from: number, count?: number};
+}
+
+export interface InsertComponents extends BaseComponents {
+    insert?: SqlValueMap[];
+}
+
+export interface UpdateComponents extends BaseComponents {
+    update?: SqlValueMap;
+}
+
+export interface Components extends BaseComponents, SelectComponents, InsertComponents, UpdateComponents, CreateComponents {
+}
+
+// export interface SelectComponents extends Components {
+//     distinct = false;
+//     select: string[] = ['*'];
+//     insert?: {};
+//     delete?: boolean;
+//     joins?: JoinClause[];
+//     wheres?: Where[];
+//     orderBy?: OrderBy[];
+// }
+
+export type WhereFunction = (query: Query) => void;
+export type WhereCondition = {[key: string]: string | number};
+// export type WhereValue = SqlValue | WhereFunction | WhereCondition;
+export type WhereValue = SqlValue;
+
+export type Direction = 'ASC' | 'DESC';
+
+export interface SqlClause {
+    toSql(): string;
+
+    getValues(): SqlValue[];
+}
+
+class SqlExpression implements SqlClause {
+    constructor(private sql: string, private values: SqlValue[] = []) {}
+
+    toSql() {
+        return this.sql
+    }
+
+    getValues() {
+        return this.values
+    }
+}
+
+export class WhereExpression extends SqlExpression {
+    constructor(public column: string, public expression: SqlExpression, public boolean: BooleanOperator) {
+        super(`${boolean} ${column} ${expression.toSql()}`, expression.getValues())
+    }
+}
+
+export class Where extends WhereExpression {
+    constructor(column: string, operator: Operator, value: SqlValue, boolean: BooleanOperator) {
+        super(column, new SqlExpression(`${operator} ?`, [value]), boolean)
+    }
+}
+
+export class WhereNested {
+}
+
+export class WhereBetween extends WhereExpression {
+    constructor(column: string, values: [SqlValue, SqlValue], boolean: BooleanOperator, not = false) {
+        super(column, new SqlExpression(`${not ? 'NOT ' : ''}BETWEEN ? AND ?`, values), boolean)
+    }
+}
+
+export class WhereLike extends WhereExpression {
+    constructor(column: string, value: SqlValue, boolean: BooleanOperator, not = false) {
+        super(column, new SqlExpression(`${not ? 'NOT ' : ''}LIKE ?`, [value]), boolean)
+    }
+}
+
+export class WhereIn extends WhereExpression {
+    constructor(column: string, values: WhereValue[], boolean: BooleanOperator, not = false) {
+        const value = values.map(() => '?').join(', ')
+        if (values.length) {
+            super(column, new SqlExpression(`${not ? 'NOT ' : ''}IN (${value})`, values), boolean)
+        } else {
+            super('', new SqlExpression('1 = 0', values), boolean)
+        }
+    }
+}
+
+export class WhereNull extends WhereExpression {
+    constructor(column: string, boolean: BooleanOperator, not = false) {
+        super(column, new SqlExpression(`IS ${not ? 'NOT ' : ''}NULL`), boolean)
+    }
+}
+
+export class WhereSubSelect extends WhereExpression {
+    constructor(column: string, operator: Operator, public query: Query, boolean: BooleanOperator) {
+        super(column, new SqlExpression(`${operator} (${query.toSQL()})`, query.getBindings()), boolean)
+    }
+}
+
+// tslint:disable-next-line:no-any
+export type RelationsTreeQuery = (query: EntityQuery<any>) => void
+
+export interface RelationsTree {
+    [key: string]: RelationsTree | RelationsTreeQuery
+}

package/Database/index.ts

@@ -0,0 +1,23 @@
+import { ChildKeys, ChildObject, Constructor } from '@Typetron/Support'
+import { Entity } from './Entity'
+import { BaseRelationship } from './ORM/BaseRelationship'
+
+export type EntityKeys<T extends Entity> = ChildKeys<T, Entity>
+export type EntityColumns<T extends Entity> = { [P in EntityKeys<T>]: T[P] extends Function ? never : P }[ EntityKeys<T>]
+
+export type EntityObject<T extends Entity> = ChildObject<{
+    [P in keyof T]: T[P] extends BaseRelationship<infer U> ? U | number : T[P]
+}, Entity>
+export type EntityConstructor<T extends Entity> = typeof Entity & Constructor<T>
+// export type EntityConstructor<T extends Entity> = {[key in keyof typeof Entity]: (typeof Entity)[key]} & Constructor<T>;
+export type DotNotationProperties<T> = string
+
+export * from './Query'
+export * from './Entity'
+export * from './Decorators'
+export * from './StringExpression'
+export * from './Expression'
+export * from './Drivers'
+export * from './Fields'
+export * from './Connection'
+

package/Encryption/index.ts

@@ -0,0 +1,51 @@
+import { compare, hash } from 'bcryptjs'
+import * as jwt from 'jsonwebtoken'
+import { GetPublicKeyOrSecret, Secret, SignOptions, VerifyErrors, VerifyOptions } from 'jsonwebtoken'
+
+export class Crypt {
+    hash(value: string, saltRounds: number): Promise<string> {
+        return hash(value, saltRounds)
+    }
+
+    compare(value: string, encrypted: string): Promise<boolean> {
+        return compare(value, encrypted)
+    }
+}
+
+export interface JWToken<T> {
+    sub: T
+    iat: number
+    exp: number
+}
+
+export class JWT {
+    sign(payload: string | Buffer | object, secretOrPrivateKey: Secret, options?: SignOptions) {
+        return new Promise<string>((resolve, reject) => {
+            jwt.sign(
+                payload,
+                secretOrPrivateKey,
+                options ?? {},
+                (error: Error | null, encoded?: string) => {
+                    error ? reject(error) : resolve(encoded as string)
+                }
+            )
+        })
+    }
+
+    verify<T>(token: string, secretOrPrivateKey: Secret | GetPublicKeyOrSecret, options?: VerifyOptions) {
+        return new Promise<JWToken<T>>((resolve, reject) => {
+            jwt.verify(
+                token,
+                secretOrPrivateKey,
+                {
+                    ...options,
+                    complete: true
+                },
+                (error: VerifyErrors | null, decoded) => {
+                    error ? reject(error) : resolve(decoded?.payload as any as JWToken<T>)
+                }
+            )
+        })
+    }
+
+}

package/Forms/Decorators.ts

@@ -0,0 +1,29 @@
+import { RuleInterface } from '../Validation'
+import { Type } from '../Support'
+import { FormField } from './FormFields'
+import { Form } from './Form'
+
+export const FormMetadataKey = 'form:fields'
+
+export function Field<T extends Form>(name?: string) {
+    return function(target: T, property: string) {
+        const fields: {[key: string]: FormField} = Reflect.getMetadata(FormMetadataKey, target.constructor) || {}
+        const type = Reflect.getMetadata('design:type', target, property)
+        const field = fields[property] || new FormField(name || property, type)
+        field.name = name || property
+        fields[property] = field
+        Reflect.defineMetadata(FormMetadataKey, fields, target.constructor)
+    }
+}
+
+// tslint:disable-next-line:no-any
+export function Rules(...rules: (Type<RuleInterface> | ((...args: any[]) => Type<RuleInterface>))[]) {
+    return function(target: Object, property: string) {
+        const fields: {[key: string]: FormField} = Reflect.getMetadata(FormMetadataKey, target.constructor) || {}
+        const type = Reflect.getMetadata('design:type', target, property)
+        const field = fields[property] || new FormField(property, type)
+        field.rules = rules
+        fields[property] = field
+        Reflect.defineMetadata(FormMetadataKey, fields, target.constructor)
+    }
+}

package/Forms/Form.ts

@@ -0,0 +1,70 @@
+import { FormMetadataKey } from './Decorators'
+import { RuleValue } from '../Validation'
+import { ChildKeys, ChildObject, Constructor } from '../Support'
+import { FormField } from './FormFields'
+import { Injectable, Scope } from '../Container'
+
+export type FormFields<T> = ChildObject<T, Form>;
+
+@Injectable(Scope.TRANSIENT)
+export abstract class Form {
+
+    readonly errors: {[key: string]: Record<string, string>} = {}
+
+    static fields<T extends Form>(this: Constructor<T>): Record<ChildKeys<T, Form>, FormField> {
+        return Reflect.getMetadata(FormMetadataKey, this)
+    }
+
+    fields() {
+        return (this.constructor as (Constructor<Form> & typeof Form)).fields()
+    }
+
+    valid() {
+        const fields = Object.values(this.fields()) as FormField[]
+        fields.forEach(field => {
+            const errors = field.validate(this[field.name as keyof FormFields<this>])
+            if (errors) {
+                this.errors[field.name] = errors
+            }
+        })
+
+        return !Object.keys(this.errors).length
+    }
+
+    validated() {
+        const fields = Object.values(this.fields()) as FormField[]
+        return fields.filter(field => !this.errors[field.name])
+            .reduce((obj, field) => {
+                const value = this[field.name as keyof this]
+                if (value) {
+                    obj[field.name] = value
+                }
+                return obj
+            }, <{[key: string]: RuleValue}>{})
+    }
+
+    value() {
+        const fields = Object.values(this.fields()) as FormField[]
+        // tslint:disable-next-line:no-any
+        const value: Record<string, any> = {}
+        fields.forEach(field => {
+            value[field.name] = this[field.name as keyof FormFields<this>]
+        })
+
+        return value
+    }
+
+    fill(data: Partial<FormFields<this>>) {
+        const fields = Object.values(this.fields()) as FormField[]
+        fields.forEach(field => {
+            if (field.name in data) {
+                // @ts-ignore
+                this[field.name] = data[field.name]
+            }
+        })
+    }
+
+    toJSON() {
+        return this.value()
+    }
+}

package/Forms/FormFields.ts

@@ -0,0 +1,36 @@
+import { Constructor, Type } from '../Support'
+import { Optional, RuleInterface } from '../Validation'
+
+export class FormField {
+    constructor(
+        public name: string,
+        // tslint:disable-next-line:no-any
+        public type: any,
+        // tslint:disable-next-line:no-any
+        public rules: (Type<RuleInterface> | ((...args: any[]) => Type<RuleInterface>)) [] = []
+    ) {
+    }
+
+    // tslint:disable-next-line:no-any
+    validate(value: any): Record<string, string> | undefined {
+        const errors: Record<string, string> = {}
+        let hasErrors = false
+
+        if (this.rules.includes(Optional) && (value === undefined || value === null)) {
+            return
+        }
+
+        this.rules.forEach(rule => {
+            if (!rule.prototype.passes) {
+                rule = (rule as Function)()
+            }
+            const instance = new (rule as Constructor<RuleInterface>)
+            if (!instance.passes(this.name, value)) {
+                hasErrors = true
+                errors[instance.identifier] = instance.message(this.name, value)
+            }
+        })
+
+        return hasErrors ? errors : undefined
+    }
+}

package/Forms/index.ts

@@ -0,0 +1,3 @@
+export * from './Form'
+export * from './Decorators'
+export * from './FormFields'

package/Framework/App.ts

@@ -0,0 +1,10 @@
+import { Application } from './Application'
+import { ServiceIdentifier } from '../Container/Contracts'
+
+export class App {
+    static instance: Application
+
+    static get<T>(service: ServiceIdentifier<T> | string): T {
+        return App.instance.get(service)
+    }
+}

package/Framework/Application.ts

@@ -0,0 +1,118 @@
+import { Container } from '../Container'
+import { Type } from '../Support'
+import { App } from './App'
+import { Provider } from './Provider'
+import { AppConfig, AuthConfig, BaseConfig } from './Config'
+import { FormResolver } from './Resolvers/FormResolver'
+import { EntityResolver } from './Resolvers/EntityResolver'
+import { RootDir } from './RootDir'
+import { StaticAssetsMiddleware } from './Middleware/StaticAssetsMiddleware'
+import { ErrorHandler, ErrorHandlerInterface, Handler as HttpHandler, } from '../Router/Http'
+import { Storage } from '../Storage'
+import { AuthResolver } from './Resolvers/AuthResolver'
+import fileSystem from 'fs'
+import path from 'path'
+import { WebsocketsProvider } from './Providers/WebsocketsProvider'
+
+export class Application extends Container {
+    static defaultConfigDirectory = 'config'
+
+    constructor(
+        public directory: string,
+        public configDirectory = Application.defaultConfigDirectory
+    ) {
+        super()
+        Application.setInstance(this)
+        this.set(Application, (App.instance = this))
+        this.set(Container, this)
+        this.set(RootDir, directory)
+    }
+
+    static async create(
+        directory: string,
+        configDirectory = Application.defaultConfigDirectory
+    ) {
+        const app = new this(
+            fileSystem.realpathSync.native(directory),
+            configDirectory
+        )
+        await app.bootstrap()
+        return app
+    }
+
+    async startServer() {
+        const httpHandler = this.get(HttpHandler)
+
+        const appConfig = this.get(AppConfig)
+
+        if (appConfig.websocketsPort) {
+            await this.registerProviders([WebsocketsProvider])
+        }
+
+        return httpHandler.startServer(this)
+    }
+
+    public async registerProviders(providers: Type<Provider>[]) {
+        await Promise.all(
+            providers.map((provider) => {
+                const instance = this.get(provider)
+                return instance.register()
+            })
+        )
+    }
+
+    private async loadConfig(configDirectory: string) {
+        const configsPath = path.join(this.directory, configDirectory)
+
+        const storage = this.get(Storage)
+
+        if (!(await storage.exists(configsPath))) {
+            console.warn(
+                `Config path '${configsPath}' does not exist. Running with default config.`
+            )
+        }
+
+        storage
+            .files(configsPath)
+            .whereIn('extension', ['ts'])
+            .forEach((file) => {
+                const configItem = require(file.path).default as BaseConfig<{}>
+                if (configItem && configItem.constructor) {
+                    configItem.applyNewValues()
+                    this.set(configItem.constructor, configItem)
+                }
+            })
+    }
+
+    private registerResolvers() {
+        this.resolvers.unshift(new FormResolver(this))
+        this.resolvers.unshift(new EntityResolver(this))
+        this.resolvers.unshift(new AuthResolver(this))
+    }
+
+    private async bootstrap() {
+        await this.loadConfig(this.configDirectory)
+
+        this.set(ErrorHandlerInterface, this.get(ErrorHandler))
+
+        const appConfig = this.get(AppConfig)
+        await this.checkAppSecret()
+
+        if (appConfig.staticAssets) {
+            appConfig.middleware.http.unshift(StaticAssetsMiddleware)
+        }
+
+        this.registerResolvers()
+
+        const providers = appConfig.providers || []
+
+        await this.registerProviders(providers)
+    }
+
+    private async checkAppSecret() {
+        const authConfig = this.get(AuthConfig)
+        if (!authConfig.signature) {
+            throw new Error(`APP_SECRET is not setup in your '.env' file.`)
+        }
+    }
+}

package/Framework/Auth/Auth.ts

@@ -0,0 +1,122 @@
+import { Inject, Injectable, Scope } from '../../Container'
+import { User } from './User'
+import { AuthConfig } from '../Config'
+import { EntityKeys, ID } from '../../Database'
+import { Crypt, JWT, JWToken } from '@Typetron/Encryption'
+
+@Injectable(Scope.REQUEST)
+export class Auth {
+
+    @Inject()
+    authConfig: AuthConfig
+
+    @Inject()
+    jwt: JWT
+
+    @Inject()
+    crypt: Crypt
+
+    id?: ID
+
+    /**
+     * This is primarily used in websocket connections so we don't need to pass the auth token for each weboscket message
+     */
+    expiresAt = new Date()
+
+    private savedUser?: User
+
+    get authenticable(): typeof User {
+        return this.authConfig.entity
+    }
+
+    // @BeforeRequest() // TODO implement the container's '@BeforeRequest' decorator to do something before each request.
+    //  For example, load the authenticated user in memory again
+    // async before() {
+    //     if (!this.id) {
+    //         return undefined
+    //         throw new Error('You tried to use the Auth service without authenticating the user. ' +
+    //             'Please use the AuthMiddleware or authenticate the user before using this route')
+    //     }
+    //
+    //     const user = await this.authenticable.find(this.id)
+    //     if (!user) {
+    //         throw new Error(`Authenticated user with ID ${this.id} not found `)
+    //     }
+    //     this.savedUser = await this.authenticable.find(this.id)
+    // }
+
+    async user<T extends User>(): Promise<T> {
+        // if (this.savedUser) { // TODO this if statement should be removed using the @BeforeRequest decorator above
+        //     return this.savedUser as T
+        // }
+
+        if (!this.id) {
+            throw new Error('You tried to use the Auth service without authenticating the user. Please use the AuthMiddleware or authenticate the user before using this route')
+        }
+
+        const user = await this.authenticable.find(this.id)
+
+        if (!user) {
+            throw new Error(`Could not find a user with id '${this.id}'`)
+        }
+
+        return this.savedUser = user as T
+    }
+
+    async login(username: string, password: string): Promise<string> {
+        const user = await this.authenticable.where((new this.authenticable).getUsername() as EntityKeys<User>, username).first()
+        if (!user || !await this.crypt.compare(password, user.password)) {
+            throw new Error('Invalid credentials')
+        }
+
+        delete this.savedUser
+        return this.sign(this.id = user.id)
+    }
+
+    loginById(id: ID): Promise<string> {
+        return this.sign(id)
+    }
+
+    loginUser(authenticable: User): Promise<string> {
+        return this.loginById(authenticable[authenticable.getId()])
+    }
+
+    sign(id: ID, expiresAtTimestampInSeconds?: number): Promise<string> {
+        return this.jwt.sign(
+            {
+                sub: this.set(id, expiresAtTimestampInSeconds)
+            },
+            this.authConfig.signature,
+            {
+                expiresIn: this.authConfig.duration
+            }
+        )
+    }
+
+    async register<T extends User>(username: string, password: string): Promise<T> {
+        return await this.authenticable.create({
+            [(new this.authenticable).getUsername() as EntityKeys<T>]: username,
+            password: await this.crypt.hash(password, this.authConfig.saltRounds),
+        }) as T
+    }
+
+    async verify(token: string): Promise<JWToken<number>> {
+        const payload = await this.jwt.verify<number>(token, this.authConfig.signature)
+
+        this.set(payload.sub, payload.exp)
+
+        return payload
+    }
+
+    private set(id: ID, expiresAtTimestampInSeconds?: number): ID {
+        if (expiresAtTimestampInSeconds) {
+            this.expiresAt = new Date(expiresAtTimestampInSeconds * 1000)
+        } else {
+            this.expiresAt = new Date()
+            this.expiresAt.setSeconds(this.expiresAt.getSeconds() + this.authConfig.duration)
+        }
+
+        return this.id = id
+    }
+
+}

package/Framework/Auth/Authenticatable.ts

@@ -0,0 +1,9 @@
+import { Entity, EntityColumns } from '../../Database'
+
+export interface Authenticatable<T extends Entity> {
+    getId(): EntityColumns<T>;
+
+    getUsername(): EntityColumns<T>;
+
+    getPassword(): EntityColumns<T>;
+}

package/Framework/Auth/User.ts

@@ -0,0 +1,27 @@
+import { Column, Entity, EntityColumns, ID, PrimaryColumn } from '../../Database'
+import { Authenticatable } from './Authenticatable'
+
+export class User extends Entity implements Authenticatable<User> {
+
+    @PrimaryColumn()
+    id: ID
+
+    @Column()
+    email: string
+
+    @Column()
+    password: string
+
+    getId(): EntityColumns<User> {
+        return 'id'
+    }
+
+    getPassword(): EntityColumns<User> {
+        return 'password'
+    }
+
+    getUsername(): EntityColumns<User> {
+        return 'email'
+    }
+
+}