@typetron/framework 0.5.3 → 0.5.4

package/Frontend/Angular/index.ts

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

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

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

package/Mail/MailTransport.ts

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

package/Mail/Mailable.ts

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

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

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

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

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

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

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

package/Models/Model.ts

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

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

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