@typetron/framework 0.4.0-rc8 → 0.5.0-rc1

package/Database/Helpers.ts

@@ -0,0 +1,12 @@
+export function wrap(strings: string | string[]) {
+    if (typeof strings === 'string') {
+        strings = [strings]
+    }
+    return strings.map(column => {
+        // // Only add backticks for columns that contain characters outside the following set
+        // if (/^[0-9,a-z,A-Z$_]+$/.test(column)) {
+        //     return column
+        // }
+        return '`' + column + '`'
+    }).join(', ')
+}

package/Database/List.ts

@@ -0,0 +1,71 @@
+import { Entity } from './Entity'
+import { EntityKeys } from './index'
+import { EntityQuery } from './EntityQuery'
+import { BooleanOperator, Operator, WhereValue } from './Types'
+import { BelongsToManyField, HasManyField } from './Fields'
+import { BaseRelationship as Relationship } from './ORM/BaseRelationship'
+
+export abstract class List<E extends Entity, P extends Entity = Entity> extends Relationship<E, P> implements Iterable<E>, ArrayLike<E> {
+
+    items: E[] = []
+
+    declare public relationship: HasManyField<P, E> | BelongsToManyField<P, E>
+
+    protected constructor(
+        relationship: HasManyField<P, E> | BelongsToManyField<P, E>,
+        parent: P
+    ) {
+        super(relationship, parent)
+        return new Proxy(this, new ListProxyHandler())
+    }
+
+    get length() {
+        return this.items.length
+    }
+
+    [Symbol.iterator]() {
+        return this.items[Symbol.iterator]()
+    }
+
+    readonly [n: number]: E;
+
+    async load() {
+        await this.parent.load(this.relationship.property)
+        return this
+    }
+
+    async get() {
+        await this.load()
+        return this.items
+    }
+
+    newQuery(): EntityQuery<E> {
+        return this.relationship.getQuery(this.parent)
+    }
+
+    where<K extends EntityKeys<E>>(
+        column: EntityKeys<E>,
+        operator: Operator | WhereValue | E[K],
+        value?: WhereValue | E[K],
+        boolean?: BooleanOperator
+    ): EntityQuery<E> {
+        return this.relationship.getQuery(this.parent).where(column, operator, value, boolean)
+    }
+
+    findWhere(name: string, value: string): E | undefined {
+        return undefined
+    }
+
+    toJSON() {
+        return this.items
+    }
+}
+
+export class ListProxyHandler<E extends Entity, P extends Entity> {
+    get(target: List<E, P>, property: string | symbol) {
+        if (Number.isInteger(Number(property.toString()))) {
+            return target.items[property as unknown as number]
+        }
+        return target[property as keyof List<E, P>]
+    }
+}

package/Database/Migrations/Migration.ts

@@ -0,0 +1,10 @@
+import { Connection } from '../Connection'
+
+export abstract class Migration {
+
+    constructor(protected connection: Connection) {}
+
+    abstract up(): void | Promise<void>;
+
+    abstract down(): void | Promise<void>;
+}

package/Database/Migrations/MigrationHistory.ts

@@ -0,0 +1,20 @@
+import { Column, CreatedAt, ID, Options, PrimaryColumn } from '../Decorators'
+import { Entity } from '../Entity'
+
+@Options({
+    table: 'migration_history'
+})
+export class MigrationHistory extends Entity {
+
+    @PrimaryColumn()
+    id: ID
+
+    @Column()
+    name: string
+
+    @Column()
+    batch: number
+
+    @CreatedAt()
+    createdAt: Date
+}

package/Database/Migrations/Migrator.ts

@@ -0,0 +1,122 @@
+import { MigrationHistory } from './MigrationHistory'
+import { Migration } from './Migration'
+import * as path from 'path'
+import { File, Storage } from '@Typetron/Storage'
+import { Connection } from '..'
+import { Constructor } from '@Typetron/Support'
+
+interface MigrateOptions {
+    fresh?: boolean;
+}
+
+export class Migrator {
+
+    constructor(
+        public storage: Storage,
+        public connection: Connection,
+        public directory: string
+    ) {}
+
+    async files(): Promise<File[]> {
+        return this.storage.files(this.directory, true).where('extension', 'ts')
+    }
+
+    public async migrate(options?: MigrateOptions): Promise<boolean> {
+        await this.createMigrationTable()
+
+        if (options?.fresh) {
+            await this.clearTable()
+        }
+
+        const files = await this.files()
+        const migrates = await MigrationHistory.whereIn('name', files.pluck('name')).get()
+        const filesToMigrate = files.filter(file => !migrates.findWhere('name', file.name))
+
+        if (!filesToMigrate.length) {
+            console.log('Nothing to migrate')
+            return true
+        }
+
+        const lastBatch = await this.getLastBatchId()
+        for await(const file of filesToMigrate) {
+            const migration = this.getMigration(file.path)
+            const migrationName = migration.constructor.name
+
+            console.log(`Migrating '${migrationName}'`)
+            try {
+                await migration.up()
+                await MigrationHistory.create({
+                    name: file,
+                    batch: lastBatch + 1,
+                    createdAt: new Date()
+                })
+                console.log(`Migrated '${migrationName}'`)
+            } catch (error) {
+                console.error(`Failed to run the migration from '${migrationName}'`, (error as Error).message)
+                return false
+            }
+        }
+        return true
+    }
+
+    public async rollback(steps = 0) {
+        await this.createMigrationTable()
+
+        const lastMigration = await MigrationHistory.newQuery().orderBy('batch', 'DESC').first()
+        if (!lastMigration) {
+            throw new Error('Can not find any migration to rollback.')
+        }
+        const migrations = await MigrationHistory
+            .where('batch', '>=', Math.max(0, lastMigration.batch - steps))
+            .orderBy('batch', 'DESC')
+            .get()
+
+        for (const migrationEntity of migrations) {
+            const migration = this.getMigration(path.join(this.directory, migrationEntity.name))
+            const migrationName = migration.constructor.name
+
+            console.log(`Rolling back the '${migrationName}' migration.`)
+            try {
+                await migration.down()
+                console.log(`Reverted '${migrationName}' migration.`)
+                await migrationEntity.delete()
+            } catch (error) {
+                console.error(`Failed to run the migration '${migrationName}'`, error)
+                return false
+            }
+        }
+
+        return true
+    }
+
+    protected async getLastBatchId(): Promise<number> {
+        const lastMigration = await MigrationHistory.orderBy('batch', 'DESC').first()
+        return lastMigration?.batch ?? 0
+    }
+
+    public async reset() {
+        await this.createMigrationTable()
+
+        const lastMigration = await MigrationHistory.newQuery().orderBy('batch', 'DESC').first()
+
+        if (!lastMigration) {
+            return true
+        }
+
+        return this.rollback(lastMigration?.batch)
+    }
+
+    private getMigration(migrationFilePath: string): Migration {
+        const migrationModule: Record<string, Constructor<Migration>> = require(migrationFilePath)
+        const MigrationClass = Object.values(migrationModule)[0]
+        return new MigrationClass(this.connection)
+    }
+
+    protected async createMigrationTable(): Promise<void> {
+        await this.connection.driver.schema.synchronize([MigrationHistory].pluck('metadata'))
+    }
+
+    protected async clearTable(): Promise<unknown> {
+        return MigrationHistory.truncate()
+    }
+}

package/Database/Migrations/index.ts

@@ -0,0 +1,3 @@
+export * from './Migrator'
+export * from './Migration'
+export * from './MigrationHistory'

package/Database/ORM/BaseRelationship.ts

@@ -0,0 +1,10 @@
+import { Entity } from '../Entity'
+import { InverseRelationship, RelationshipField } from '../Fields'
+
+export abstract class BaseRelationship<E extends Entity, P extends Entity = Entity> {
+    constructor(
+        public relationship: RelationshipField<P, E> | InverseRelationship<P, E>,
+        public parent: P
+    ) {
+    }
+}

package/Database/Query.ts

@@ -0,0 +1,374 @@
+import {
+    BooleanOperator,
+    Components,
+    Direction,
+    JoinType,
+    Operator,
+    SqlValue,
+    SqlValueMap,
+    Where,
+    WhereBetween,
+    WhereFunction,
+    WhereIn,
+    WhereLike,
+    WhereNull,
+    WhereSubSelect,
+    WhereValue
+} from './Types'
+import { Connection } from './Connection'
+import { StringExpression } from './StringExpression'
+import { Statement } from './Drivers/Statement'
+import { Constructor } from '@Typetron/Support'
+import { Expression } from './Expression'
+
+export class Query<T = {}> extends Expression {
+    static connection: Connection
+
+    private statementType: Constructor<Statement> = Query.connection.driver.statements.select
+
+    private useDistinct = false
+
+    private components: Components = {
+        table: '',
+        distinct: false,
+        columns: [],
+        joins: [],
+        wheres: [],
+        groups: [],
+        orders: [],
+        having: [],
+    }
+
+    get statement(): Statement {
+        return new this.statementType(this.components)
+    }
+
+    static table<T = object>(table: string): Query<T> {
+        return (new this() as Query<T>).table(table)
+    }
+
+    static from<T = {}>(table: string) {
+        return Query.table<T>(table)
+    }
+
+    static truncate(table: string) {
+        return Query.connection.truncate(table)
+    }
+
+    truncate() {
+        return Query.truncate(this.components.table)
+    }
+
+    getBindings() {
+        const statement = this.statement
+        statement.toSQL()
+        return statement.bindings
+    }
+
+    toSQL() {
+        return this.statement.toSQL().replace(/\s{2,}/g, ' ').trim()
+    }
+
+    async get<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T[]> {
+        return Query.connection.get(this.select(...(columns.length ? columns : this.components.columns)))
+    }
+
+    async run<K extends keyof T>(): Promise<void> {
+        await Query.connection.run(this as Query<{}>)
+    }
+
+    table(table: string) {
+        this.components.table = table
+
+        return this
+    }
+
+    from(table: string) {
+        return this.table(table)
+    }
+
+    async first<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T | undefined> {
+        return Query.connection.first(this.select(...(columns.length ? columns : this.components.columns)))
+    }
+
+    select<K extends keyof T>(...columns: (K | string | StringExpression)[]) {
+        this.statementType = Query.connection.driver.statements.select
+        this.components.columns = columns as string[]
+
+        return this
+    }
+
+    where<K extends keyof T>(
+        column: K | string,
+        operator: Operator | Query | WhereValue | WhereFunction | T[K],
+        value?: Query | WhereValue | WhereFunction | T[K],
+        boolean: BooleanOperator = 'AND'
+    ): this {
+        // if (column instanceof Function) {
+        //     const query = new WhereNested();
+        //     this.components.wheres = query;
+        //     column(query);
+        //     return this;
+        // }
+        if (value === undefined) {
+            value = operator
+            operator = '=' as Operator
+        }
+
+        if (value instanceof Query) {
+            this.components.wheres.push(new WhereSubSelect(column as string, operator as Operator, value, boolean))
+            return this
+        }
+
+        if (typeof value === 'function') {
+            const query = new Query()
+            // @ts-ignore
+            value(query)
+            this.components.wheres.push(new WhereSubSelect(column as string, operator as Operator, query, boolean))
+            return this
+        }
+
+        // this.bindings.push(value);
+        // const where = new Where();
+        // where.boolean = this.components.wheres.length ? boolean : 'WHERE';
+        // this.components.wheres.push({
+        //     column, operator, value, boolean
+        // });
+
+        if (typeof value === 'object') {
+            return this
+        }
+
+        this.components.wheres.push(new Where(column as string, operator as Operator, value as WhereValue, boolean))
+
+        return this
+    }
+
+    orWhere<K extends keyof T>(column: K | string, operator: Operator | WhereValue | T[K], value?: WhereValue | T[K]): this {
+        return this.where(column, operator, value, 'OR')
+    }
+
+    andWhere<K extends keyof T>(column: K | string, operator: Operator | WhereValue | T[K], value?: WhereValue | T[K]): this {
+        return this.where(column, operator, value)
+    }
+
+    whereIn<K extends keyof T>(
+        column: K | string,
+        values: Query | WhereFunction | WhereValue[] | T[K][],
+        boolean: BooleanOperator = 'AND',
+        not = false
+    ): this {
+        if (values instanceof Query) {
+            this.components.wheres.push(new WhereSubSelect(column as string, not ? 'NOT IN' : 'IN', values, boolean))
+            return this
+        }
+        if (typeof values === 'function') {
+            const query = new Query()
+            values(query)
+            this.components.wheres.push(new WhereSubSelect(column as string, not ? 'NOT IN' : 'IN', query, boolean))
+            return this
+        }
+        this.components.wheres.push(new WhereIn(column as string, values as WhereValue[], boolean, not))
+
+        return this
+    }
+
+    andWhereIn<K extends keyof T>(column: K | string, values: SqlValue[]): this {
+        return this.whereIn(column, values)
+    }
+
+    andWhereNotIn<K extends keyof T>(column: K | string, values: SqlValue[]): this {
+        return this.whereIn(column, values, 'AND', true)
+    }
+
+    whereLike<K extends keyof T>(column: K | string, value: SqlValue, boolean: BooleanOperator = 'AND', not = false): this {
+        this.components.wheres.push(new WhereLike(column as string, value, boolean, not))
+
+        return this
+    }
+
+    whereNotIn<K extends keyof T>(
+        column: K | string,
+        values: Query | WhereFunction | WhereValue[] | T[K][],
+        boolean: BooleanOperator = 'AND'
+    ): this {
+        return this.whereIn(column, values, boolean, true)
+    }
+
+    orWhereIn<K extends keyof T>(column: K | string, values: SqlValue[]): this {
+        return this.whereIn(column, values, 'OR')
+    }
+
+    orWhereNotIn<K extends keyof T>(column: K | string, values: SqlValue[]): this {
+        return this.whereIn(column, values, 'OR', true)
+    }
+
+    orWhereLike<K extends keyof T>(column: K | string, value: SqlValue, not = false): this {
+        return this.whereLike(column, value, 'OR', not)
+    }
+
+    orWhereNotLike<K extends keyof T>(column: K | string, value: SqlValue): this {
+        return this.whereLike(column, value, 'OR', true)
+    }
+
+    whereBetween<K extends keyof T>(column: K | string, values: [SqlValue, SqlValue], boolean: BooleanOperator = 'AND', not = false): this {
+        this.components.wheres.push(new WhereBetween(column as string, values, boolean, not))
+
+        return this
+    }
+
+    whereNotBetween<K extends keyof T>(column: K | string, values: [SqlValue, SqlValue], boolean: BooleanOperator = 'AND'): this {
+        return this.whereBetween(column, values, boolean, true)
+    }
+
+    orWhereBetween<K extends keyof T>(column: K | string, values: [SqlValue, SqlValue]): this {
+        return this.whereBetween(column, values, 'OR')
+    }
+
+    orWhereNotBetween<K extends keyof T>(column: K | string, values: [SqlValue, SqlValue]): this {
+        return this.whereBetween(column, values, 'OR', true)
+    }
+
+    whereNull<K extends keyof T>(column: K | string, boolean: BooleanOperator = 'AND', not = false): this {
+        this.components.wheres.push(new WhereNull(column as string, boolean, not))
+
+        return this
+    }
+
+    andWhereNull<K extends keyof T>(column: K | string): this {
+        return this.whereNull(column)
+    }
+
+    whereNotNull<K extends keyof T>(column: K | string, boolean: BooleanOperator = 'AND'): this {
+        return this.whereNull(column, boolean, true)
+    }
+
+    andWhereNotNull<K extends keyof T>(column: K | string, boolean: BooleanOperator = 'AND'): this {
+        return this.whereNotNull(column, boolean)
+    }
+
+    orWhereNull<K extends keyof T>(column: K | string): this {
+        return this.whereNull(column, 'OR')
+    }
+
+    orWhereNotNull<K extends keyof T>(column: K | string): this {
+        return this.whereNull(column, 'OR', true)
+    }
+
+    distinct(value = true) {
+        this.components.distinct = value
+
+        return this
+    }
+
+    join(table: string, first: string, operator: Operator, second: string, type: keyof typeof JoinType = JoinType.INNER) {
+        this.components.joins.push({type, table, first, operator, second})
+
+        return this
+    }
+
+    innerJoin(table: string, first: string, operator: Operator, second: string) {
+        return this.join(table, first, operator, second, JoinType.INNER)
+    }
+
+    leftJoin(table: string, first: string, operator: Operator, second: string) {
+        return this.join(table, first, operator, second, JoinType.LEFT)
+    }
+
+    rightJoin(table: string, first: string, operator: Operator, second: string) {
+        return this.join(table, first, operator, second, JoinType.RIGHT)
+    }
+
+    orderBy<K extends keyof T>(column: K | [string | K, Direction][], direction: Direction = 'DESC') {
+        if (typeof column === 'string') {
+            column = [[column, direction]]
+        }
+        this.components.orders = column as [string, Direction][]
+
+        return this
+    }
+
+    groupBy<K extends keyof T>(...columns: (K | string) []) {
+        this.components.groups = columns as string[]
+
+        return this
+    }
+
+    addSelect<K extends keyof T>(...columns: (K | string | StringExpression)[]) {
+        this.components.columns = this.components.columns.concat(columns as string[])
+
+        return this
+    }
+
+    async count<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<number> {
+        this.components.aggregate = {
+            function: 'COUNT',
+            columns: columns as string[],
+        }
+        const value = await Query.connection.first(this as unknown as Query<{aggregate: number}>)
+        return value?.aggregate || 0
+    }
+
+    selectCount<K extends keyof T>(...columns: (K | string | StringExpression)[]): this {
+        this.components.aggregate = {
+            function: 'COUNT',
+            columns: columns as string[],
+        }
+        return this
+    }
+
+    async max<K extends keyof T>(column: (K | string | StringExpression), ...columns: (K | string | StringExpression)[]): Promise<T[]> {
+        this.components.aggregate = {
+            function: 'MAX',
+            columns: [column].concat(columns) as string[],
+        }
+        return Query.connection.get(this)
+    }
+
+    async insert(data: SqlValueMap | SqlValueMap[]) {
+        this.statementType = Query.connection.driver.statements.insert
+
+        if (!Array.isArray(data)) {
+            data = [data]
+        }
+
+        this.components.insert = data
+
+        await this.run()
+    }
+
+    async insertOne(data: SqlValueMap): Promise<number> {
+        this.statementType = Query.connection.driver.statements.insert
+
+        this.components.insert = [data]
+
+        return await Query.connection.insertOne(this as Query<{}>)
+    }
+
+    async delete() {
+        this.statementType = Query.connection.driver.statements.delete
+
+        await this.run()
+    }
+
+    async update(name: string | keyof T | Record<keyof T, SqlValue> | SqlValueMap, value?: SqlValue) {
+        this.statementType = Query.connection.driver.statements.update
+
+        let data: SqlValueMap
+        if (typeof name === 'string') {
+            data = {[name]: value}
+        } else {
+            data = name as SqlValueMap
+        }
+
+        this.components.update = data
+
+        await this.run()
+    }
+
+    limit<K extends keyof T>(from: number, count?: number) {
+        this.components.limit = {from, count}
+
+        return this
+    }
+}

package/Database/Seeders/Seeder.ts

@@ -0,0 +1,3 @@
+export abstract class Seeder {
+    public abstract run():void
+}

package/Database/Seeders/SeederManager.ts

@@ -0,0 +1,27 @@
+import { Storage } from "@Typetron/Storage"
+import { Constructor } from "@Typetron/Support"
+import { Seeder } from "./Seeder"
+
+export class SeederManager {
+    constructor(
+        public storage: Storage,
+        public directory: string
+    ) {}
+
+    async seed() {
+        const files = await this.storage
+            .files(this.directory, true)
+            .where("extension", "ts")
+            .whenEmpty(() => console.log('Nothing to seed!'))
+
+        files.forEachAsync(async file => {
+            await this.getSeed(file.path).run()
+        })
+    }
+
+    private getSeed(path: string): Seeder {
+        const module: Record<string, Constructor<Seeder>> = require(path)
+        const Class = Object.values(module)[0]
+        return new Class()
+    }
+}

package/Database/Seeders/index.ts

@@ -0,0 +1,2 @@
+export * from './Seeder'
+export * from './SeederManager'

package/Database/StringExpression.ts

@@ -0,0 +1,9 @@
+import { Expression } from '@Typetron/Database/Expression'
+
+export class StringExpression extends Expression {
+    constructor(public value: string) {super()}
+
+    toSQL() {
+        return this.value
+    }
+}