@typetron/framework 0.5.21 → 0.5.22

package/Frontend/Websockets/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@typetron/websockets",
+	"description": "Typetron Websockets library",
+	"keywords": [
+		"websockets",
+		"typetron",
+		"nodejs",
+		"typescript",
+		"real-time",
+		"realtime"
+	],
+	"license": "MIT",
+	"version": "0.5.2",
+	"author": {
+		"email": "ionel@typetron.org",
+		"name": "Ionel Lupu"
+	},
+	"main": "build/index.js",
+	"types": "build/index.d.ts",
+	"scripts": {
+		"build": "tsc && tsc-alias",
+		"prepack": "npm run build"
+	},
+	"engines": {
+		"node": ">= 20.12.0"
+	},
+	"dependencies": {
+		"@typetron/framework": "0.5.20",
+		"rxjs": "~7.8.1"
+	},
+	"devDependencies": {
+		"tsc-alias": "^1.8.16",
+		"typescript": "5.8.3"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/typetron/websockets.git"
+	},
+	"files": [
+		"build/**/*.js",
+		"build/**/*.d.ts",
+		"build/**/*.js.map",
+		"Readme.md"
+	]
+}

package/Frontend/Websockets/tsc-alias.config.json

@@ -0,0 +1,7 @@
+{
+	"resolveFullPaths": true,
+	"configFile": "tsconfig.json",
+	"replacers": {
+		"@Typetron/*": "@typetron/framework/build/*"
+	}
+}

package/Frontend/Websockets/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"extends": "../../tsconfig.json",
+	"compilerOptions": {
+		"outDir": "build",
+		"baseUrl": ".",
+		"paths": {
+			"@Typetron/*": [
+				"node_modules/@typetron/framework/*",
+				"node_modules/@typetron/framework/build/*",
+			]
+		},
+		"lib": [
+			"dom"
+		]
+	},
+	"include": [
+		"./*.ts"
+	],
+	"exclude": []
+}

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
+}

package/Router/Decorators.ts

@@ -0,0 +1,224 @@
+import { App } from '../Framework'
+import { Abstract, Constructor, Type } from '../Support'
+import { GlobalMiddleware } from './Middleware'
+import { ActionMetadata, ControllerMetadata, ControllerOptions, MethodMetadata, RouteMetadata } from './Metadata'
+import { Guard } from './Guard'
+import { Handler as HttpHandler, Http, Request as HttpRequest } from './Http'
+import { Request } from './Request'
+import { Handler as WebsocketsHandler } from './Websockets'
+import { WebsocketRoute } from './Websockets/WebsocketRoute'
+import { Container } from '@Typetron/Container'
+
+export function Controller(path = '', options?: ControllerOptions) {
+    return (target: object) => {
+        const metadata = ControllerMetadata.get(target)
+        const prefix = options?.prefix || path ? path + '.' : ''
+
+        const httpHandler = Container.getInstance().get(HttpHandler)
+        const websocketHandler = Container.getInstance().get(WebsocketsHandler)
+
+        Object.keys(metadata.routes).forEach(action => {
+            const routeMetadata = metadata.routes[action]
+            const route = httpHandler.addRoute(
+                path + (path && routeMetadata.path ? '/' : '') + routeMetadata.path,
+                routeMetadata.method,
+                target as Constructor,
+                action,
+                prefix + (routeMetadata.name || action),
+                routeMetadata.parametersTypes,
+                metadata.middleware.concat(routeMetadata.middleware)
+            )
+            route.guards = routeMetadata.guards
+        })
+
+        Object.keys(metadata.actions).forEach(actionName => {
+            const actionMetadata = metadata.actions[actionName]
+            const name = prefix + (actionMetadata.name || actionName)
+            const action = websocketHandler.addAction(
+                name,
+                target as Constructor,
+                actionName,
+                actionMetadata.parametersTypes,
+                metadata.middleware.concat(actionMetadata.middleware)
+            )
+            action.guards = actionMetadata.guards
+        })
+    }
+}
+
+function addAction(controller: Constructor, methodName: string, name: string) {
+    const metadata = ControllerMetadata.get(controller)
+
+    const methodMetadata = metadata.methods[methodName]
+    const action = new ActionMetadata()
+    Object.assign(action, methodMetadata)
+
+    action.parametersTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, methodName)
+    action.name = name
+
+    metadata.actions[methodName] = action
+
+    ControllerMetadata.set(metadata, controller)
+}
+
+function addRoute(controller: Constructor, methodName: string, method: Http.Method, path: string, name: string) {
+    const metadata = ControllerMetadata.get(controller)
+
+    const methodMetadata = metadata.methods[methodName]
+    const route = new RouteMetadata()
+    Object.assign(route, methodMetadata)
+
+    route.parametersTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, methodName)
+    route.path = path
+    route.name = name
+    route.method = method
+
+    metadata.routes[methodName] = route
+
+    ControllerMetadata.set(metadata, controller)
+}
+
+export function Action(name = '') {
+    return (target: object, action: string) => {
+        addAction(target.constructor as Constructor, action, name)
+    }
+}
+
+export function OnOpen(target: object, action: string) {
+    const websocketHandler = App.get(WebsocketsHandler)
+
+    websocketHandler.onOpen = new WebsocketRoute(
+        '',
+        target.constructor as Constructor,
+        action,
+        Reflect.getMetadata('design:paramtypes', target, action),
+    )
+}
+
+export function OnClose(target: object, action: string) {
+    const websocketHandler = App.get(WebsocketsHandler)
+
+    websocketHandler.onClose = new WebsocketRoute(
+        '',
+        target.constructor as Constructor,
+        action,
+        Reflect.getMetadata('design:paramtypes', target, action),
+    )
+}
+
+export function Arg(name: string) {
+    return function(target: object, action: string, parameterIndex: number) {
+        // addAction(target.constructor as Constructor, action, name)
+    }
+}
+
+export function Get(path = '', name = '') {
+    return (target: object, action: string) => {
+        addRoute(target.constructor as Constructor, action, Http.Method.GET, path, name)
+    }
+}
+
+export function Post(path: string = '', name = '') {
+    return (target: object, action: string) => {
+        addRoute(target.constructor as Constructor, action, Http.Method.POST, path, name)
+    }
+}
+
+export function Put(path: string = '', name = '') {
+    return (target: object, action: string) => {
+        addRoute(target.constructor as Constructor, action, Http.Method.PUT, path, name)
+    }
+}
+
+export function Patch(path: string = '', name = '') {
+    return (target: object, action: string) => {
+        addRoute(target.constructor as Constructor, action, Http.Method.PATCH, path, name)
+    }
+}
+
+export function Delete(path: string = '', name = '') {
+    return (target: object, action: string) => {
+        addRoute(target.constructor as Constructor, action, Http.Method.DELETE, path, name)
+    }
+}
+
+export function Middleware(...middleware: Abstract<GlobalMiddleware>[]) {
+    return (target: object, action?: string) => {
+        if (action) {
+            target = target.constructor
+        }
+
+        const metadata = ControllerMetadata.get(target)
+
+        if (action) {
+            const route = metadata.methods[action] || new MethodMetadata()
+            route.middleware = route.middleware.concat(middleware)
+            metadata.methods[action] = route
+        } else {
+            metadata.middleware = metadata.middleware.concat(middleware)
+        }
+
+        ControllerMetadata.set(metadata, target)
+    }
+}
+
+export function AllowIf(...guards: Type<Guard>[]) {
+    return function(target: object, action: string) {
+        if (action) {
+            target = target.constructor
+        }
+
+        const metadata = ControllerMetadata.get(target)
+
+        if (action) {
+            const route = metadata.methods[action] || new MethodMetadata()
+            route.guards = route.guards.concat(guards)
+            metadata.methods[action] = route
+        } else {
+            metadata.guards = metadata.guards.concat(guards)
+        }
+
+        ControllerMetadata.set(metadata, target)
+    }
+}
+
+export function Query(name: string) {
+    return function(target: object, action: string, parameterIndex: number) {
+        const metadata = ControllerMetadata.get(target.constructor)
+        const parametersTypes = Reflect.getMetadata('design:paramtypes', target, action)
+
+        const route = metadata.methods[action] || new MethodMetadata()
+        route.parametersOverrides[parameterIndex] = function(container: Container) {
+            const request = container.get(HttpRequest)
+            const value = request.query[name]
+
+            if (parametersTypes[parameterIndex].name === 'Number') {
+                return value === undefined || value === 'undefined' ? undefined : Number(value)
+            }
+            return value
+        }
+
+        metadata.methods[action] = route
+        ControllerMetadata.set(metadata, target.constructor)
+    }
+}
+
+export function Body() {
+    return function(target: object, action: string, parameterIndex: number) {
+        const metadata = ControllerMetadata.get(target.constructor)
+        const route = metadata.methods[action] || new MethodMetadata()
+        route.parametersOverrides[parameterIndex] = function(container: Container) {
+            const request = container.get(Request)
+
+            // TODO: should the framework throw error or return undefined?
+            // if (!request.body) {
+            //     throw new Error(`There is no data in the 'body' of the request`)
+            // }
+
+            return request.body
+        }
+
+        metadata.methods[action] = route
+        ControllerMetadata.set(metadata, target.constructor)
+    }
+}

package/Router/Guard.ts

@@ -0,0 +1,10 @@
+import { Http, HttpError } from './Http'
+
+export abstract class Guard {
+    // tslint:disable-next-line:no-any
+    abstract condition(...args: any[]): Promise<boolean>
+
+    onFail(): void {
+        throw new HttpError('Unauthorized', Http.Status.UNAUTHORIZED)
+    }
+}

package/Router/Http/Contracts.ts

@@ -0,0 +1,4 @@
+export interface Parameters {
+    [key: string]: string | undefined;
+}
+