@typetron/framework 0.5.2 → 0.5.3

package/Database/Helpers.ts

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

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

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

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

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

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

package/Database/ORM/BaseRelationship.ts

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

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

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

package/Database/Seeders/SeederManager.ts

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

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

package/Database/StringExpression.ts

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