@typetron/framework 0.5.2 → 0.5.3

package/Frontend/Angular/index.ts

@@ -1,24 +0,0 @@
-import type { AbstractControl, ValidatorFn } from '@angular/forms'
-import { FormControl, FormGroup } from '@angular/forms'
-import type { Form, FormField } from '@Typetron/Forms'
-import { Constructor } from '@Typetron/Support'
-
-export class FormBuilder {
-    static build<T extends Form>(form: typeof Form & Constructor<T>): FormGroup {
-        const controls: Record<string, AbstractControl> = {}
-        const formFields = Object.values(form.fields()) as FormField[]
-        const instance = new (form as unknown as Constructor<T>)()
-        Object.values(formFields).forEach(field => {
-            controls[field.name] = new FormControl(
-                instance[field.name as keyof Form],
-                {validators: this.getValidators(field)}
-            )
-        })
-        return new FormGroup(controls)
-    }
-
-    private static getValidators(field: FormField): ValidatorFn {
-        return control => field.validate(control.value) as unknown as ValidatorFn
-    }
-}
-

package/Frontend/Websockets/index.ts

@@ -1,86 +0,0 @@
-import { Observable, of, ReplaySubject, Subject, throwError } from 'rxjs'
-import { filter, map, switchMap, take } from 'rxjs/operators'
-import { ActionErrorResponse, ActionRequest, ActionResponse, WebsocketMessageStatus } from '@typetron/framework/Router/Websockets/types'
-
-export class Websocket {
-    socket?: WebSocket
-
-    actionMessages$ = new Subject<ActionResponse<unknown>>()
-    queuedActions$ = new ReplaySubject<ActionRequest>()
-    errors$ = new Subject<ActionErrorResponse>()
-    onConnectCallback: () => void
-
-    constructor(public url: string, public protocols?: string | string[]) {
-        this.connect(url, protocols)
-    }
-
-    get isConnected() {
-        return this.socket?.readyState === WebSocket.OPEN
-    }
-
-    connect(url?: string, protocols?: string | string[]): void {
-        const socket = new WebSocket(url ?? this.url, protocols ?? this.protocols)
-        this.socket = socket
-
-        socket.onmessage = (action) => {
-            const message = JSON.parse(action.data)
-            this.actionMessages$.next(message)
-        }
-        socket.onopen = () => {
-            this.onConnectCallback?.()
-            this.queuedActions$.subscribe(message => {
-                socket.send(JSON.stringify(message))
-            })
-        }
-
-        socket.onclose = (action) => {
-            this.queuedActions$ = new ReplaySubject<ActionRequest>()
-            this.reconnect()
-        }
-    }
-
-    onConnect(callback: () => void) {
-        this.onConnectCallback = callback
-    }
-
-    reconnect(): void {
-        if (this.socket?.readyState === WebSocket.CLOSED) {
-            window.setTimeout(() => {
-                this.connect(this.url, this.protocols)
-            }, 1000)
-        }
-    }
-
-    emit<T>(action: string, request?: ActionRequest['message']): void {
-        const actionMessage: ActionRequest = {action, message: request}
-        this.queuedActions$.next(actionMessage)
-    }
-
-    on<T>(action: string): Observable<T> {
-        return this.actionMessages$.pipe(
-            filter(actionMessage => actionMessage.action === action),
-            switchMap(actionMessage => {
-                if (actionMessage.status === WebsocketMessageStatus.Error) {
-                    this.errors$.next(actionMessage as ActionErrorResponse)
-                    return throwError(actionMessage)
-                }
-                return of(actionMessage)
-            }),
-            map(actionMessage => actionMessage.message)
-        ) as Observable<T>
-    }
-
-    onError({except}: {except?: string[]}): Observable<ActionResponse<unknown>> {
-        return this.errors$.pipe(filter(actionMessage => !(except || []).includes(actionMessage.action)))
-    }
-
-    async request<T>(action: string, message?: ActionRequest['message']): Promise<T> {
-        this.emit(action, message)
-        return new Promise((resolve, reject) => {
-            this.on<T>(action).pipe(take(1)).subscribe({
-                next: resolve,
-                error: reject
-            })
-        })
-    }
-}

package/Mail/MailAddress.ts

@@ -1,4 +0,0 @@
-export interface MailAddress {
-    email: string
-    name?: string
-}

package/Mail/MailTransport.ts

@@ -1,6 +0,0 @@
-import { Mailable } from './Mailable'
-import { SentMessage } from './SentMessage'
-
-export abstract class MailTransport {
-    abstract send(message: Mailable): Promise<SentMessage>
-}

package/Mail/Mailable.ts

@@ -1,16 +0,0 @@
-import { MailAddress } from '@Typetron/Mail/MailAddress'
-
-export class Mailable {
-
-    from: string | MailAddress
-    subject?: string
-    body?: string | {html: string, text: string}
-    to?: string | MailAddress | (string | MailAddress)[]
-    replyTo?: string | MailAddress | (string | MailAddress)[]
-    cc?: string | MailAddress | (string | MailAddress)[]
-    bcc?: string | MailAddress | (string | MailAddress)[]
-
-    content(): string | {html: string, text: string} | undefined {
-        return
-    }
-}

package/Mail/Mailer.ts

@@ -1,27 +0,0 @@
-import { MailTransport } from './MailTransport'
-import { PendingMail } from './PendingMail'
-import { Mailable } from './Mailable'
-import { MailAddress } from '@Typetron/Mail/MailAddress'
-
-export class Mailer {
-    transport: MailTransport
-
-    constructor(public from: MailAddress, transport?: MailTransport) {
-        if (!transport) {
-            throw new Error('Please add the MailProvider in your app in order to use the Mailing feature, ' +
-                'or manually add a Mailer instance in the app container ')
-        }
-        this.transport = transport
-    }
-
-    to(email: string) {
-        const mail = new PendingMail(this)
-        mail.from(this.from)
-        mail.to(email)
-        return mail
-    }
-
-    async send(message: Mailable) {
-        return await this.transport.send(message)
-    }
-}

package/Mail/PendingMail.ts

@@ -1,68 +0,0 @@
-import { Mailer } from './index'
-import { Mailable } from './Mailable'
-import { MailAddress } from '@Typetron/Mail/MailAddress'
-
-export class PendingMail {
-
-    details: {
-        subject?: string
-        from: string | MailAddress
-        to?: string | MailAddress
-        replyTo?: string | MailAddress
-        cc?: string | MailAddress
-        bcc?: string | MailAddress
-        body?: string | {html: string, text: string}
-    } = {from: ''}
-
-    constructor(private mailer: Mailer) {
-    }
-
-    subject(subject: string) {
-        this.details.subject = subject
-        return this
-    }
-
-    from(email: string | MailAddress) {
-        this.details.from = email
-        return this
-    }
-
-    to(email: string | MailAddress) {
-        this.details.to = email
-        return this
-    }
-
-    replyTo(email: string | MailAddress) {
-        this.details.replyTo = email
-        return this
-    }
-
-    cc(email: string | MailAddress) {
-        this.details.cc = email
-        return this
-    }
-
-    bcc(email: string | MailAddress) {
-        this.details.bcc = email
-        return this
-    }
-
-    async send(body: string | {html: string, text: string} | Mailable) {
-        let mail
-        if (body instanceof Mailable) {
-            mail = body
-        } else {
-            mail = new Mailable()
-            mail.body = body
-        }
-
-        mail.subject = this.details.subject
-        mail.from = this.details.from
-        mail.to = this.details.to
-        mail.replyTo = this.details.replyTo
-        mail.cc = this.details.cc
-        mail.bcc = this.details.bcc
-
-        return this.mailer.send(mail)
-    }
-}

package/Mail/SentMessage.ts

@@ -1,20 +0,0 @@
-import { MailAddress } from './MailAddress'
-import { Mailable } from '@Typetron/Mail/Mailable'
-
-export class SentMessage {
-    readonly from: string | MailAddress
-    readonly subject?: string
-    readonly body?: string | {html: string, text: string}
-    readonly to?: string | MailAddress | (string | MailAddress)[]
-    readonly replyTo?: string | MailAddress | (string | MailAddress)[]
-    readonly cc?: string | MailAddress | (string | MailAddress)[]
-    readonly bcc?: string | MailAddress | (string | MailAddress)[]
-
-    constructor(mail: Mailable) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const {content, ...mailDetails} = mail
-        Object.assign(this, mailDetails)
-        this.body = mail.content() ?? mail.body
-    }
-
-}

package/Mail/Transports/MemoryTransport.ts

@@ -1,13 +0,0 @@
-import { MailTransport } from '../MailTransport'
-import { SentMessage } from '../SentMessage'
-import { Mailable } from '../Mailable'
-
-export class MemoryTransport extends MailTransport {
-    messages: SentMessage[] = []
-
-    async send(message: Mailable) {
-        const sentMessage = new SentMessage(message)
-        this.messages.push(sentMessage)
-        return sentMessage
-    }
-}

package/Mail/Transports/SendGridTransport.ts

@@ -1,95 +0,0 @@
-import { MailTransport } from '../MailTransport'
-import { SentMessage } from '../SentMessage'
-import { Mailable } from '../Mailable'
-import { Inject } from '../../Container'
-import { MailConfig } from '../../Framework'
-import client from '@sendgrid/mail'
-import { HttpError } from '@Typetron/Router/Http'
-
-export class SendGridTransport extends MailTransport {
-    messages: SentMessage[] = []
-
-    @Inject()
-    config: MailConfig
-
-    constructor(key: string) {
-        super()
-
-        client.setApiKey(key)
-    }
-
-    async send(message: Mailable) {
-        const sentMessage = new SentMessage(message)
-
-        const sendGridMessage = {
-            personalizations: [
-                {
-                    to: sentMessage.to,
-                    cc: sentMessage.cc,
-                    bcc: sentMessage.bcc
-                },
-            ],
-            from: sentMessage.from,
-            replyTo: sentMessage.replyTo,
-            subject: sentMessage.subject,
-            content: [
-                {
-                    type: 'text/html',
-                    value: sentMessage.body
-                }
-            ],
-            // attachments: [
-            //     {
-            //         content: 'PCFET0NUdGxlPkRvY3VtZW50PC90aXRsZT4KICAgIDwvaGVhZD4KCiAgICA8Ym9keT4KCiAgICA8L2JvZHk+Cgo8L2h0bWw+Cg==',
-            //         filename: 'index.html',
-            //         type: 'text/html',
-            //         disposition: 'attachment'
-            //     }
-            // ],
-            // categories: [
-            //     'cake',
-            //     'pie',
-            //     'baking'
-            // ],
-            // sendAt: 1617260400,
-            // batchId: 'AsdFgHjklQweRTYuIopzXcVBNm0aSDfGHjklmZcVbNMqWert1znmOP2asDFjkl',
-            // asm: {
-            //     groupId: 12345,
-            //     groupsToDisplay: [
-            //         12345
-            //     ]
-            // },
-            // ipPoolName: 'transactional email',
-            // mailSettings: {
-            //     bypassListManagement: {
-            //         enable: false
-            //     },
-            //     footer: {
-            //         enable: false
-            //     },
-            //     sandboxMode: {
-            //         enable: false
-            //     }
-            // },
-            // trackingSettings: {
-            //     clickTracking: {
-            //         enable: true,
-            //         enableText: false
-            //     },
-            //     openTracking: {
-            //         enable: true,
-            //         substitutionTag: '%open-track%'
-            //     },
-            //     subscriptionTracking: {
-            //         enable: false
-            //     }
-            // }
-        }
-
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        /* @ts-ignore */ // SendGrid has TS issues
-        await client.send(sendGridMessage).catch(error => {throw new HttpError(error.response.body.errors, error.code)})
-
-        return sentMessage
-    }
-}

package/Mail/index.ts

@@ -1,3 +0,0 @@
-export * from './Transports/MemoryTransport'
-export * from './Mailer'
-export * from './Mailable'

package/Models/Model.ts

@@ -1,41 +0,0 @@
-import { Constructor } from '../Support'
-import { ModelField, ModelMetadataKey, ModelTypeInterface } from './index'
-
-export class Model {
-    static async from<T extends Model, Q extends object>(this: Constructor<T> & typeof Model, entity: Promise<Iterable<Q>>): Promise<T[]>;
-    static async from<T extends Model, Q extends object>(this: Constructor<T> & typeof Model, entity: Promise<Q>): Promise<T>;
-    static from<T extends Model, Q extends object>(this: Constructor<T> & typeof Model, entity: Iterable<Q>): T[];
-    static from<T extends Model, Q extends object>(this: Constructor<T> & typeof Model, entity: Q): T;
-    static from<T extends Model, Q extends object>(
-        this: Constructor<T> & typeof Model,
-        entity: Q | Iterable<Q> | Promise<Q | Iterable<Q>>
-    ): T | T[] | Promise<T | T[]> {
-        if (entity instanceof Promise) {
-            return entity.then(value => this.from(value))
-        }
-        if (Symbol.iterator in Object(entity)) {
-            return Array.from(entity as Iterable<Q>).map(item => this.from<T, Q>(item))
-        }
-        const fields: Record<string, ModelField> = Reflect.getMetadata(ModelMetadataKey, this) || {}
-
-        return this.transform<T, Q>(fields, entity as Q)
-    }
-
-    protected static transform<T, Q extends object>(fields: Record<string, ModelField>, entity: Q): T {
-        const data: Partial<Record<keyof T, Q[keyof Q]>> = new this
-        Object.values(fields).forEach(field => {
-            if (!entity || !entity.hasOwnProperty(field.name)) {
-                return
-            }
-            const value = entity[field.name as keyof Q]
-            if (field.type instanceof ModelTypeInterface && value) {
-                // @ts-ignore
-                const jsonValue = value['toJSON' as keyof object] ? value?.toJSON() : value
-                data[field.name as keyof T] = jsonValue ? field.type.transform(jsonValue) as Q[keyof Q] : undefined
-            } else {
-                data[field.name as keyof T] = value
-            }
-        })
-        return data as T
-    }
-}

package/Models/index.ts

@@ -1,54 +0,0 @@
-import { Model } from './Model'
-import { Constructor } from '../Support'
-
-export const ModelMetadataKey = 'model:fields'
-
-export interface ModelField {
-    name: string;
-    type: Function | ModelTypeInterface<{}>;
-}
-
-export function Field(name?: string) {
-    return function(target: Object, property: string) {
-        const fields: Record<string, ModelField> = Reflect.getMetadata(ModelMetadataKey, target.constructor) || {}
-        let type = Reflect.getMetadata('design:type', target, property)
-        if (type.prototype instanceof Model) {
-            type = new ModelType(type)
-        }
-        fields[property] = fields[property] || {name: name || property, type} as ModelField
-        Reflect.defineMetadata(ModelMetadataKey, fields, target.constructor)
-    }
-}
-
-export abstract class ModelTypeInterface<T extends Model, Q = T> {
-    constructor(public model: Constructor<T> & typeof Model) {}
-
-    abstract transform(value: Q): Q;
-}
-
-export class ModelType<T extends Model> extends ModelTypeInterface<T> {
-
-    transform(value: T) {
-        return this.model.from(value)
-    }
-}
-
-export class ArrayType<T extends Model> extends ModelTypeInterface<T, T[]> {
-    transform(value: T[]) {
-        return Array.from(value).map(item => {
-            return this.model.from(item)
-        })
-    }
-}
-
-export function FieldMany(type: typeof Model) {
-    return function(target: Object, property: string) {
-        const fields: Record<string, ModelField> = Reflect.getMetadata(ModelMetadataKey, target.constructor) || {}
-        const field = fields[property] || {name: property, type: new ArrayType(type)} as ModelField
-        field.type = new ArrayType(type)
-        fields[property] = field
-        Reflect.defineMetadata(ModelMetadataKey, fields, target.constructor)
-    }
-}
-
-export * from './Model'

package/Router/BaseController.ts

@@ -1,7 +0,0 @@
-import { Container, Inject } from '../Container'
-
-export class BaseController {
-
-    @Inject()
-    protected app: Container
-}