@typetron/framework 0.5.5 → 0.5.7

package/Database/Types.ts

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

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

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

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

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

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

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

package/Framework/App.ts

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

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

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

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

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