@typetron/framework 0.5.21 → 0.5.22

package/Router/Websockets/index.ts

@@ -0,0 +1,59 @@
+import { WebSocket as uWebSocket } from 'uWebSockets.js'
+import { ActionResponse, WebsocketMessageStatus } from './types'
+import { Container } from '@Typetron/Container'
+
+export * from './Handler'
+export * from './types'
+
+export class WebSocket {
+
+    public connection: uWebSocket<any> & {container: Container}
+    id?: number | string
+
+    constructor(connection: uWebSocket<any>, public container: Container) {
+        this.connection = Object.assign(connection, {container})
+        this.reset(container)
+    }
+
+    subscribe(topic: string) {
+        this.connection.subscribe(topic)
+    }
+
+    unsubscribe(topic: string) {
+        this.connection.unsubscribe(topic)
+    }
+
+    reset(container?: Container) {
+        this.connection.container = container || this.connection.container.parent?.createChildContainer() || new Container()
+        this.connection.container.set(WebSocket, this)
+    }
+
+    // tslint:disable-next-line:no-any
+    publish(topic: string, action: string, body?: unknown) {
+        const sentResponse: ActionResponse<unknown> = {
+            '$id': 'todo',
+            action,
+            message: body,
+            status: WebsocketMessageStatus.OK,
+        }
+        this.connection.publish(topic, JSON.stringify(sentResponse), false, true)
+    }
+
+    // tslint:disable-next-line:no-any
+    publishAndSend(topic: string, action: string, body?: unknown) {
+        this.publish(topic, action, body)
+        this.send(action, body)
+    }
+
+    // tslint:disable-next-line:no-any
+    send(action: string, body?: unknown) {
+        const sentResponse: ActionResponse<unknown> = {
+            '$id': 'todo',
+            action,
+            message: body,
+            status: WebsocketMessageStatus.OK,
+        }
+        this.connection.send(JSON.stringify(sentResponse), false, true)
+    }
+}
+

package/Router/Websockets/types.ts

@@ -0,0 +1,24 @@
+export enum WebsocketMessageStatus {
+    OK = 'OK',
+    Error = 'Error',
+}
+
+export interface Action<T> {
+    '$id': string,
+    action: string
+    message?: T
+}
+
+export interface ActionRequestMessage {
+    parameters?: (string | number)[]
+    // tslint:disable-next-line:no-any
+    body?: any
+}
+
+export type ActionRequest = Action<ActionRequestMessage>
+
+export interface ActionResponse<T> extends Action<T> {
+    status: WebsocketMessageStatus
+}
+
+export type ActionErrorResponse<T extends string = string> = ActionResponse<{message: T, stack: string[]}>

package/Router/index.ts

@@ -0,0 +1,6 @@
+export * from './Route'
+export * from './Router'
+export * from './Middleware'
+export * from './Decorators'
+export * from './RouteNotFoundError'
+export * from './BaseController'

package/Storage/File.ts

@@ -0,0 +1,30 @@
+import * as path from 'path'
+
+export class File {
+    // content?: string | Buffer
+    originalName?: string
+
+    saved = false
+
+    constructor(public name: string, public directory?: string) {
+    }
+
+    get extension() {
+        return this.guessExtension()
+    }
+
+    get path() {
+        return path.join(this.directory || '', this.name)
+    }
+
+    guessExtension() {
+        const fileParts = this.name.split('.')
+        if (fileParts.length >= 1) {
+            return fileParts.pop()
+        }
+    }
+
+    toString() {
+        return this.name
+    }
+}

package/Storage/Image.ts

@@ -0,0 +1,19 @@
+import { File } from './File'
+
+export class Image extends File {
+    // static fromBase64(base64: string): Image {
+    //     const matches = base64.match(/data:image\/([a-zA-Z]*);base64,([^\\"]*)/)
+    //     if (!matches) {
+    //         throw new InvalidImage()
+    //     }
+    //     if (matches.length !== 3) {
+    //         throw InvalidImage
+    //     }
+    //     const extension = matches[1]
+    //     const data = matches[2]
+    //
+    //     const image = new this('.' + extension)
+    //     image.content = Buffer.from(data, 'base64')
+    //     return image
+    // }
+}

package/Storage/InvalidImage.ts

@@ -0,0 +1,3 @@
+export class InvalidImage extends Error {
+    constructor() {super('The image has an invalid data format') }
+}

package/Storage/Storage.ts

@@ -0,0 +1,98 @@
+import * as fileSystemDeprecated from 'fs'
+import { File } from './File'
+import * as path from 'path'
+import * as fileSystem from 'node:fs/promises'
+
+export class Storage {
+    files(directory: string, recursively = false): File[] {
+        return fileSystemDeprecated
+            .readdirSync(directory) // TODO make this async
+            .reduce((files, name) => {
+                const filePath = path.join(directory, name)
+                const stats = fileSystemDeprecated.statSync(filePath)
+                if (stats.isFile()) {
+                    const file = new File(name)
+                    file.directory = directory
+                    files.push(file)
+                }
+
+                if (recursively && stats.isDirectory()) {
+                    files = files.concat(this.files(filePath))
+                }
+                return files
+            }, [] as File[])
+    }
+
+    async read(filePath: string): Promise<Buffer> {
+        return fileSystem.readFile(filePath)
+    }
+
+    async exists(filePath: string): Promise<boolean> {
+        try {
+            await fileSystem.access(filePath)
+            return true
+        } catch (error) {
+            return false
+        }
+    }
+
+    async save(file: File, directory: string = '', name?: string | number): Promise<File> {
+        const newPath = path.join(directory, file.name)
+        if (!file.name) {
+            file.name = String(name || this.generateRandomFileName() + '.' + file.extension)
+        }
+        if (directory && !(await this.exists(directory))) {
+            await this.makeDirectory(directory)
+        }
+        return new Promise(async (resolve, reject) => {
+            fileSystemDeprecated
+                .createReadStream(file.path)
+                .on('error', reject)
+                .pipe(fileSystemDeprecated.createWriteStream(newPath))
+                .on('finish', () => resolve(file))
+                .on('error', reject)
+        })
+    }
+
+    async put(filePath: string, content: string | Buffer, options?: any): Promise<File> {
+        const file = new File(path.basename(filePath))
+        file.directory = path.dirname(filePath)
+
+        if (file.directory && !(await this.exists(file.directory))) {
+            await this.makeDirectory(file.directory)
+        }
+
+        await fileSystem.writeFile(filePath, content, options)
+        return file
+    }
+
+    async makeDirectory(directory: string): Promise<void> {
+        await fileSystem.mkdir(directory, {recursive: true})
+    }
+
+    async deleteDirectory(directory: string): Promise<void> {
+        if (await this.exists(directory)) {
+            await fileSystem.rm(directory, {recursive: true})
+        }
+    }
+
+    async delete(filePath: string): Promise<void> {
+        if (!(await this.exists(filePath))) {
+            return
+        }
+
+        if ((await fileSystem.stat(filePath)).isDirectory()) {
+            throw new Error('Can not delete because this path leads to a directory and not a file.')
+        }
+
+        await fileSystem.unlink(filePath)
+    }
+
+    private generateRandomFileName(): string {
+        const stringDomain =
+            'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
+        return (
+            String.random(13, stringDomain) + '-' + new Date().getTime().toString()
+        )
+    }
+}

package/Storage/index.ts

@@ -0,0 +1,4 @@
+export * from './File'
+export * from './Storage'
+export * from './Image'
+export * from './utils'

package/Storage/utils.ts

@@ -0,0 +1,18 @@
+import { InvalidImage } from '@Typetron/Storage/InvalidImage'
+
+export function fromBase64(base64: string): {extension: string, content: Buffer} {
+    const matches = base64.match(/data:image\/([a-zA-Z]*);base64,([^\\"]*)/)
+    if (!matches) {
+        throw new InvalidImage()
+    }
+    if (matches.length !== 3) {
+        throw InvalidImage
+    }
+    const extension = matches[1]
+    const data = matches[2]
+
+    return {
+        content: Buffer.from(data, 'base64'),
+        extension: extension
+    }
+}

package/Support/Array.ts

@@ -0,0 +1,184 @@
+export {}
+
+type ArrayItemCallback<T, R = T> = (item: T, index: number, array: T[]) => R;
+
+declare global {
+    interface Array<T> {
+        empty(): boolean;
+
+        random(): T;
+
+        randomIndex(): number;
+
+        pluck<K extends keyof T>(this: T[], property: K): T[K][];
+
+        mapAsync<U>(callback: ArrayItemCallback<T, Promise<U>>, thisArg?: this): Promise<U[]>;
+
+        forEachAsync(callback: ArrayItemCallback<T, void>, thisArg?: this): Promise<void>;
+
+        // tslint:disable-next-line:no-any
+        findWhere<K extends keyof T>(this: T[], property: K, value: T[K] | ArrayItemCallback<T, unknown>): T | undefined;
+
+        first(this: T[], defaultValue?: T): T | undefined;
+
+        last(this: T[], defaultValue?: T): T | undefined;
+
+        remove<T>(this: T[], ...items: T[]): void;
+
+        where<K extends keyof T>(this: T[], property: K, value?: T[K]): T[];
+
+        whereNot<K extends keyof T>(this: T[], property: K, value?: T[K]): T[];
+
+        whereIn<K extends keyof T>(this: T[], property: K, value: T[K][]): T[];
+
+        whereNotIn<K extends keyof T>(this: T[], property: K, value: T[K][]): T[];
+
+        groupBy<K extends keyof T>(this: T[], property: K): Record<K, T[]>;
+
+        sortBy<K extends keyof T>(this: T[], key: K, order?: 'ASC' | 'DESC' | 1 | -1): T[]
+
+        groupBy<U extends string | number | symbol>(this: T[], callback: ArrayItemCallback<T, U>): Record<U, T[]>;
+
+        unique<K extends keyof T>(this: T[], key?: K | ((item: T, index: number) => unknown)): T[];
+
+        sum<T extends number>(this: T[]): number;
+
+        sum<K extends keyof T, U extends number>(key: K | ArrayItemCallback<T, U>): U;
+
+        whenNotEmpty(this: T[], callback: (values: T[]) => void): this;
+
+        whenEmpty(callback: () => void): this;
+    }
+}
+
+Array.prototype.empty = function() {
+    return !this.length
+}
+
+Array.prototype.random = function() {
+    return this[Math.randomInt(0, this.length - 1)]
+}
+
+Array.prototype.randomIndex = function() {
+    return Math.randomInt(0, this.length - 1)
+}
+
+// tslint:disable-next-line:no-any
+Array.prototype.findWhere = function <T, K extends keyof T>(property: K, value: T[K] | ArrayItemCallback<T, unknown>) {
+    return this.find(item => item[property] === value)
+}
+
+Array.prototype.pluck = function <T, K extends keyof T, U>(property: K) {
+    return this.map((item: T) => item[property] as unknown as U)
+}
+
+Array.prototype.remove = function <T>(...items: T[]) {
+    return items.map(item => {
+        const index = this.indexOf(item)
+        if (index === -1) {
+            return
+        }
+        this.splice(this.indexOf(item), 1)
+    })
+}
+
+Array.prototype.where = function <T, K extends keyof T>(property: K, value?: T[K]) {
+    return this.filter(item => value !== undefined ? item[property] === value : item[property])
+}
+
+Array.prototype.whereNot = function <T, K extends keyof T>(property: K, value?: T[K]) {
+    return this.filter(item => value !== undefined ? item[property] !== value : !item[property])
+}
+
+Array.prototype.whereIn = function <T, K extends keyof T>(property: K, values: (T[K])[]) {
+    return this.filter(item => values.includes(item[property]))
+}
+
+Array.prototype.whereNotIn = function <T, K extends keyof T>(property: K, values: (T[K])[]) {
+    return this.filter(item => !values.includes(item[property]))
+}
+
+Array.prototype.first = function(defaultValue = undefined) {
+    const [first] = this
+    return first || defaultValue
+}
+
+Array.prototype.last = function(defaultValue = undefined) {
+    return this[this.length - 1] || defaultValue
+}
+
+Array.prototype.groupBy = function <T, K extends keyof T, U>(property: K | ArrayItemCallback<T, U>) {
+    const callback = property instanceof Function ? property : (item: T) => item[property]
+    return this.reduce((accumulator, item, index, array) => {
+        const key = callback(item, index, array);
+        (accumulator[key] = accumulator[key] || []).push(item)
+        return accumulator
+    }, {})
+}
+
+Array.prototype.sortBy = function <T, K extends keyof T>(this: T[], key: K, order?: 'ASC' | 'DESC' | 1 | -1): T[] {
+    const o = (order === 'ASC' ? 1 : order === 'DESC' ? -1 : order) || 1
+    return this.sort((a, b) => a[key] > b[key] ? 1 * o : b[key] > a[key] ? -1 * o : 0)
+}
+
+Array.prototype.forEachAsync = async function <T>(callback: ArrayItemCallback<T, void>, thisArg: T[]) {
+    for (let index = 0; index < this.length; index++) {
+        await callback.call(thisArg, this[index], index, this)
+    }
+}
+
+Array.prototype.mapAsync = async function <T, U>(callback: ArrayItemCallback<T, Promise<U>>, thisArg: T[]) {
+    if (!this.length) {
+        return []
+    }
+    const promises = []
+    for (let index = 0; index < this.length; index++) {
+        promises.push(callback.call(thisArg, this[index], index, this))
+    }
+    return Promise.all(promises)
+}
+
+Array.prototype.unique = function <T, K extends keyof T>(property?: K | ((item: T, index: number) => unknown)): T[] {
+    if (!property) {
+        return [...new Set(this)] as T[]
+    }
+
+    let callback: (item: T, index: number, list: T[]) => unknown
+    if (typeof property === 'function') {
+        callback = property
+    } else {
+        callback = (item) => item[property]
+    }
+
+    const exists = new Set
+    return this.filter((item, index) => {
+        let id: unknown
+        if (!exists.has(id = callback(item, index, this))) {
+            exists.add(id)
+            return true
+        }
+    })
+}
+
+Array.prototype.sum = function <T, K extends keyof T, U extends number>(property?: K | ArrayItemCallback<T, U>) {
+    const callback = property instanceof Function ? property : (item: T) => property ? item[property] : item
+    return this.reduce((accumulator, item, index, array) => {
+        return accumulator + callback(item, index, array)
+    }, 0)
+}
+
+Array.prototype.whenNotEmpty = function <T>(callback: (values: T[]) => void) {
+    if (!this.empty()) {
+        callback(this)
+    }
+
+    return this
+}
+
+Array.prototype.whenEmpty = function(callback: () => void) {
+    if (this.empty()) {
+        callback()
+    }
+
+    return this
+}

package/Support/Math.ts

@@ -0,0 +1,12 @@
+export {}
+declare global {
+    interface Math {
+        randomInt(min?: number, max?: number): number;
+    }
+}
+
+Math.randomInt = function (min: number = Number.MIN_SAFE_INTEGER, max: number = Number.MAX_SAFE_INTEGER) {
+    min = Math.ceil(min)
+    max = Math.floor(max)
+    return Math.floor(Math.random() * (max - min + 1)) + min
+}

package/Support/Metadata.ts

@@ -0,0 +1,31 @@
+import { Constructor } from './index'
+
+export function MetadataKey(key: string) {
+    return class Metadata {
+        // tslint:disable-next-line:no-any
+        static get<T extends Metadata>(this: typeof Metadata & Constructor<T>, target: any, defaultValue?: T): T {
+            // This handles the copy of dependencies from the parent to the child.
+            // It's hacky because `newInjectable.dependencies` is a property of InjectableMetadata
+            if (target.__proto__._metadata_?.['injectable'] && target.__proto__._metadata_ === target._metadata_) {
+                const newInjectable = new this
+                Object.assign(newInjectable, target.__proto__._metadata_['injectable'])
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                newInjectable.dependencies = {...target.__proto__._metadata_['injectable'].dependencies}
+                target['_metadata_'] = {injectable: newInjectable}
+                return newInjectable
+            }
+            return (target['_metadata_'] || (target['_metadata_'] = {[key]: new this}))[key]
+                || (target['_metadata_'][key] = defaultValue ?? new this)
+        }
+
+        static set<T extends Metadata>(this: typeof Metadata & Constructor<T>, metadata: T, target: any) {
+            const metadataBag = target['_metadata_'] || (target['_metadata_'] = {})
+            return metadataBag[key] = metadata
+        }
+    }
+}
+
+export class ParametersTypesMetadata<T> extends MetadataKey('design:paramtypes') {
+    parameters: T
+}

package/Support/String.ts

@@ -0,0 +1,38 @@
+export {}
+declare global {
+    interface StringConstructor {
+        random(length?: number, stringDomain?: string): string;
+
+        randomAlphaNum(length?: number): string;
+    }
+
+    interface String {
+        capitalize(): this;
+
+        limit(length: number, end?: string): this;
+    }
+}
+
+const string = '!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~'
+String.random = function(length = Math.randomInt(1, 15), stringDomain = string) {
+    const characters = stringDomain.split('')
+    let word = ''
+    for (let i = 0; i < length; i++) {
+        word += characters.random()
+    }
+    return word
+}
+String.randomAlphaNum = function(length: number) {
+    return this.random(length, 'abcdefghijklmnopqrstuvwxyz1234567890')
+}
+
+String.prototype.capitalize = function () {
+    return this.charAt(0).toUpperCase() + this.slice(1)
+}
+
+String.prototype.limit = function (limit: number, end = '...') {
+    if (limit < this.length) {
+        return this.substring(0, limit - end.length) + end
+    }
+    return this
+}

package/Support/index.ts

@@ -0,0 +1,19 @@
+import './Array'
+import './String'
+import './Math'
+import './utils'
+
+export type KeysOfType<T, Condition> = { [P in keyof T]: T[P] extends Condition ? P : never }[keyof T]
+export type ChildKeys<Child, Parent> = Exclude<keyof Child, keyof Parent>
+export type ChildObject<Child, Parent> = Omit<Child, keyof Parent>
+
+// tslint:disable-next-line:no-any
+export type Type<T> = new(...args: any[]) => T
+export type AnyFunction<T = any> = (...args: any[]) => T
+
+export interface Abstract<T> {
+    prototype: T;
+}
+
+// tslint:disable-next-line:no-any
+export type Constructor<T = object> = new(...args: any[]) => T

package/Support/utils.ts

@@ -0,0 +1,7 @@
+export function JSONSafeParse<T>(text?: string) {
+    try {
+        return text ? JSON.parse(text) as T : undefined
+    } catch (error) {
+        return undefined
+    }
+}