@typetron/framework 0.5.2 → 0.5.3

package/Container/Container.ts

@@ -1,144 +0,0 @@
-import { Constructor, Type } from '../Support'
-import { ClassResolver } from './ClassResolver'
-import { ServiceIdentifier } from './Contracts'
-import { InjectableMetadata, Scope } from './Metadata'
-import { Resolver } from './Resolver'
-
-export class Container {
-    protected static instance: Container
-
-    // TODO performance: get rid of this
-    public resolvers: Resolver[] = [
-        new ClassResolver(this)
-    ]
-
-    // tslint:disable-next-line:no-any
-    protected instances = new Map<ServiceIdentifier<any>, any>()
-
-    public parent?: Container
-
-    static getInstance() {
-        if (!Container.instance) {
-            Container.instance = new Container()
-        }
-
-        return Container.instance
-    }
-
-    static setInstance(container: Container) {
-        return Container.instance = container
-    }
-
-    getInstances() {
-        return this.instances
-    }
-
-    set<T>(abstract: ServiceIdentifier<T>, concrete: T | Type<T> | (() => void)) {
-        this.instances.set(abstract, concrete)
-    }
-
-    /**
-     * @deprecated
-     */
-    forceSet<T>(abstract: ServiceIdentifier<T>, concrete: T | Type<T> | (() => any)) {
-        this.set(abstract, concrete)
-    }
-
-    // tslint:disable-next-line:no-any
-    get<T>(abstract: ServiceIdentifier<T>, parameters: any[] = []): T {
-        const metadata = this.getMetadata(abstract)
-
-        if (metadata.scope === Scope.TRANSIENT) {
-            return this.getResolver(abstract, metadata).resolve(abstract, parameters) as T
-        }
-
-        let concrete = this.getInstance(abstract)
-        if (concrete) {
-            return concrete
-        }
-
-        // if (this.parent && metadata.scope !== Scope.REQUEST
-        //     && (concrete = this.parent.getInstance(abstract) ?? this.parent.get(abstract))
-        // ) {
-        //     return concrete
-        // }
-
-        if (this.parent && metadata.scope !== Scope.REQUEST && (concrete = this.parent.getInstance(abstract))) {
-            return concrete
-        }
-
-        if (typeof abstract === 'string') {
-            const instance = this.getInstance<T>(abstract) as T
-            if (!instance) {
-                throw new Error(`No instance found for '${this.getAbstractName(abstract)}'`)
-            }
-        }
-
-        const resolver = this.getResolver(abstract, metadata)
-        concrete = resolver.resolve(abstract, parameters) as T
-        this.set(abstract, concrete)
-        return concrete
-    }
-
-    createChildContainer(): Container {
-        const childContainer = new Container()
-        childContainer.parent = this
-        childContainer.set(Container, childContainer)
-        // TODO performance: get rid of this
-        childContainer.resolvers = this.resolvers.map(resolver => {
-            return new (resolver.constructor as Constructor<Resolver>)(childContainer)
-        })
-        return childContainer
-    }
-
-    private getMetadata<T>(abstract: ServiceIdentifier<T>) {
-        if (abstract instanceof Object) {
-            return InjectableMetadata.get(abstract)
-        }
-        return new InjectableMetadata
-    }
-
-    private getAbstractName<T>(abstract: ServiceIdentifier<T>): string {
-        if (typeof abstract === 'string') {
-            return abstract
-        }
-        if (abstract === undefined) {
-            throw new Error(`
-                Cannot resolve a parameter having the value undefined.
-                This might be due to circular dependencies in your app
-            `)
-        }
-        if (typeof abstract === 'symbol') {
-            return abstract.toString()
-        }
-        if ('name' in abstract) {
-            return abstract.name
-        }
-        throw new Error(`Cannot get abstract name for ${abstract}`)
-    }
-
-    private getResolver<T>(abstract: ServiceIdentifier<T>, metadata: InjectableMetadata) {
-        let resolver = metadata.resolver
-        if (!resolver) {
-            resolver = this.resolvers.find(item => item.canResolve(abstract))
-        }
-        if (!resolver) {
-            throw new Error(`Resolver not found for '${this.getAbstractName(abstract)}'`)
-        }
-        this.setResolverForAbstract(abstract, resolver, metadata)
-        resolver.container = this
-        return resolver
-    }
-
-    private setResolverForAbstract<T>(abstract: ServiceIdentifier<T>, resolver: Resolver, metadata: InjectableMetadata) {
-        if (typeof abstract === 'symbol') {
-            return
-        }
-        metadata.resolver = resolver
-        InjectableMetadata.set(metadata, abstract)
-    }
-
-    private getInstance<T>(abstract: ServiceIdentifier<T>): T | undefined {
-        return this.instances.get(abstract) || this.parent?.getInstance(abstract)
-    }
-}

package/Container/Contracts.ts

@@ -1,3 +0,0 @@
-import { Abstract, Constructor } from '../Support'
-
-export type ServiceIdentifier<T> = string | Constructor<T> | Abstract<T> | symbol;

package/Container/Decorators.ts

@@ -1,20 +0,0 @@
-import { ServiceIdentifier } from './Contracts'
-import { InjectableMetadata, Scope } from './Metadata'
-
-export function Injectable(scope: Scope = Scope.SINGLETON) {
-    return function <T extends Function>(target: T) {
-        const metadata = InjectableMetadata.get(target)
-        metadata.scope = scope
-        InjectableMetadata.set(metadata, target)
-    }
-}
-
-export function Inject<T extends Object>(abstract?: ServiceIdentifier<T>) {
-    return function (target: T, targetKey: string, index?: number) {
-        const fieldType = Reflect.getMetadata('design:type', target, targetKey) as ServiceIdentifier<T>
-        const metadata = InjectableMetadata.get(target.constructor)
-        metadata.dependencies[targetKey] = abstract ?? fieldType
-        InjectableMetadata.set(metadata, target.constructor)
-    }
-}
-

package/Container/Metadata.ts

@@ -1,16 +0,0 @@
-import { Resolver } from './Resolver'
-import { ServiceIdentifier } from './Contracts'
-import { MetadataKey } from '../Support/Metadata'
-
-export enum Scope {
-    TRANSIENT = 'TRANSIENT',
-    SINGLETON = 'SINGLETON',
-    REQUEST = 'REQUEST',
-}
-
-export class InjectableMetadata extends MetadataKey('injectable') {
-    resolver?: Resolver
-
-    scope: Scope = Scope.SINGLETON
-    dependencies: {[key: string]: ServiceIdentifier<{}>} = {}
-}

package/Container/Resolver.ts

@@ -1,27 +0,0 @@
-import { Container } from './Container'
-import { ServiceIdentifier } from './Contracts'
-
-export interface Resolver {
-    container: Container;
-
-    canResolve<T>(abstract: ServiceIdentifier<T>): boolean;
-
-    resolve<T>(abstract: ServiceIdentifier<T>, parameters: object[]): T | Promise<T>;
-
-    reload<T>(abstract: ServiceIdentifier<T>, concrete: T, container?: Container): T;
-}
-
-export abstract class BaseResolver implements Resolver {
-    constructor(public container: Container) {}
-
-    abstract canResolve<T>(abstract: ServiceIdentifier<T>): boolean;
-
-    abstract resolve<T>(abstract: ServiceIdentifier<T>, parameters: object[]): T | Promise<T>;
-
-    /**
-     * Used to update the dependencies that have the REQUEST scope
-     */
-    reload<T>(abstract: ServiceIdentifier<T>, concrete: T, container?: Container): T {
-        return concrete
-    }
-}

package/Container/index.ts

@@ -1,5 +0,0 @@
-export * from './Decorators'
-export * from './Container'
-export * from './ClassResolver'
-export * from './Resolver'
-export * from './Metadata'

package/Database/Connection.ts

@@ -1,52 +0,0 @@
-import { Query } from './Query'
-import { DatabaseDriver } from './Drivers/DatabaseDriver'
-import { SqlValue } from './Types'
-
-export class Connection {
-
-    constructor(public driver: DatabaseDriver) {}
-
-    async run(query: Query): Promise<void> {
-        return this.driver.run(query.toSQL(), query.getBindings())
-    }
-
-    async insertOne(query: Query): Promise<number> {
-        return this.driver.insertOne(query.toSQL(), query.getBindings())
-    }
-
-    truncate(table: string) {
-        return this.driver.truncate(table)
-    }
-
-    async get<T>(query: Query<T>): Promise<T[]> {
-        return await this.driver.get<T>(query.toSQL(), query.getBindings()) as T[]
-    }
-
-    async first<T>(query: Query<T>): Promise<T | undefined> {
-        return await this.driver.first(query.toSQL(), query.getBindings()) as T
-    }
-
-    async getRaw<T>(rawQuery: string, params: SqlValue[] = []): Promise<T[]> {
-        return await this.driver.get(rawQuery, params) as T[]
-    }
-
-    async firstRaw<T>(rawQuery: string, params: SqlValue[] = []): Promise<T> {
-        return await this.driver.first(rawQuery, params) as T
-    }
-
-    async runRaw(rawQuery: string, params: SqlValue[] = []): Promise<void> {
-        return this.driver.run(rawQuery, params)
-    }
-
-    async tables() {
-        return this.driver.tables()
-    }
-
-    async tableExists(table: string) {
-        return this.driver.tableExists(table)
-    }
-
-    async tableColumns(table: string) {
-        return this.driver.tableColumns(table)
-    }
-}

package/Database/Decorators.ts

@@ -1,142 +0,0 @@
-import { ChildObject, Constructor, KeysOfType } from '@Typetron/Support'
-import { Entity } from './Entity'
-import {
-    BelongsTo,
-    BelongsToMany,
-    BelongsToManyField,
-    BelongsToManyFieldOptions,
-    ColumnField,
-    HasMany,
-    HasManyField,
-    HasOne,
-    HasOneField,
-    JSONField,
-    PrimaryField,
-    RelationshipField
-} from './Fields'
-import { EntityConstructor } from './index'
-import { List } from './List'
-import { BaseRelationship } from './ORM/BaseRelationship'
-
-export const EntityMetadataKey = 'framework:entity'
-
-export type ID = number | string;
-
-export class EntityOptions<T extends Entity> {
-    table?: string
-    touch?: KeysOfType<T, Entity | List<T, Entity>>[]
-}
-
-export class EntityMetadata<T extends Entity, R extends Entity> extends EntityOptions<T> {
-    columns: Record<string, ColumnField<T>> = {}
-    relationships: Record<string, RelationshipField<T, R>> = {}
-    inverseRelationships: Record<string, BelongsToManyField<T, R> | HasManyField<T, R> | HasOneField<T, R>> = {}
-    createdAtColumn?: string
-    updatedAtColumn?: string
-
-    get allRelationships() {
-        return {...this.relationships, ...this.inverseRelationships}
-    }
-
-    static get<T extends Entity, R extends Entity>(entity: T) {
-        const metadata: EntityMetadata<T, R> = Reflect.getMetadata(EntityMetadataKey, entity) || new this()
-        metadata.table = metadata?.table || entity.constructor.name.toLowerCase()
-        return metadata
-    }
-}
-
-export function Options<T extends Entity>(options: EntityOptions<T> = {}) {
-    return (entity: object) => {
-        const entityClass = entity as unknown as EntityConstructor<T>
-        const metadata = EntityMetadata.get(entityClass.prototype)
-        options.table = options.table || entityClass.name.toLowerCase()
-        Object.assign(metadata, options)
-        Reflect.defineMetadata(EntityMetadataKey, metadata, entityClass.prototype)
-    }
-}
-
-function setField<T extends Entity>(entity: T, field: ColumnField<T>) {
-    const entityMetadata = EntityMetadata.get(entity)
-    entityMetadata.columns[field.property] = field
-    Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
-}
-
-export function Column<T extends Entity>(column?: string | {type: any}, options?: {type: any}): PropertyDecorator {
-    return function(entity: Object, name: string | symbol) {
-        const actualColumn: string | undefined = typeof column === 'string' ? column : undefined
-        const type = options?.type ?? Reflect.getMetadata('design:type', entity, name)
-        const field = new ColumnField(entity.constructor as EntityConstructor<T>, String(name), () => type, actualColumn || String(name))
-        setField(entity as T, field)
-    }
-}
-
-export function JSONColumn<T extends Entity>(column?: string) {
-    return function(entity: object, name: string) {
-        const field = new JSONField(entity.constructor as EntityConstructor<T>, name, () => String, column || name)
-        setField(entity as T, field)
-    }
-}
-
-export function Enum<T extends Entity>(...values: string[]) {
-    return function(entity: object, name: string) {
-    }
-}
-
-export function PrimaryColumn<T extends Entity>(column?: string) {
-    return function(entity: object, name: string) {
-        const type = Reflect.getMetadata('design:type', entity, name)
-        const field = new PrimaryField(entity.constructor as EntityConstructor<T>, name, () => type, column || name)
-        setField(entity as T, field)
-    }
-}
-
-export function CreatedAt<T extends Entity>(column?: string) {
-    return function(entity: object, name: string) {
-        Column(column)(entity as T, name)
-        const entityMetadata = EntityMetadata.get(entity as T)
-        entityMetadata.createdAtColumn = column || name
-        Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
-    }
-}
-
-export function UpdatedAt<T extends Entity>(column?: string) {
-    return function(entity: object, name: string) {
-        Column(column)(entity as T, name)
-        const entityMetadata = EntityMetadata.get(entity as T)
-        entityMetadata.updatedAtColumn = column || name
-        Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
-    }
-}
-
-type RelationshipsList = typeof BelongsTo | typeof HasOne | typeof HasMany | typeof BelongsToMany;
-const entityOptionsCache = new Map<Entity, Record<string, object>>()
-
-export function Relation<T extends Entity, R extends Entity>(
-    type: () => Constructor<R>,
-    // tslint:disable-next-line:no-any
-    // inverseBy: KeysOfType<Omit<R, keyof Entity>, Entity | HasOne<any> | BelongsTo<any> | HasMany<any> | BelongsToMany<any>>,
-    // tslint:disable-next-line:no-any
-    // inverseBy: KeysOfType<R, Entity | HasOne<any> | BelongsTo<any> | HasMany<any> | BelongsToMany<any>>,
-    // tslint:disable-next-line:no-any
-    inverseBy: KeysOfType<ChildObject<R, Entity>, BaseRelationship<T>>,
-    // options: Partial<RelationshipOptions> = {}
-) {
-    return function(entity: object, property: string) {
-        let entityMetadata = EntityMetadata.get(entity as T)
-        const fieldClass = Reflect.getMetadata('design:type', entity, property) as RelationshipsList
-        const entityClass = entity.constructor as EntityConstructor<T>
-
-        const options = entityOptionsCache.get(entity as T) || {}
-        // @ts-ignore
-        entityMetadata = fieldClass.relationship(entityMetadata, entityClass, property, type, inverseBy as string, options[property])
-        Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
-    }
-}
-
-export function BelongsToManyOptions<T extends Entity>(options: BelongsToManyFieldOptions) {
-    return function(entity: object, property: string) {
-        const entityOptions = entityOptionsCache.get(entity as T) || {}
-        entityOptions[property] = options
-        entityOptionsCache.set(entity as T, entityOptions)
-    }
-}

package/Database/Drivers/DatabaseDriver.ts

@@ -1,37 +0,0 @@
-import { SqlValue } from '../Types'
-import { Statement } from './Statement'
-import { Constructor } from '@Typetron/Support'
-import { SchemaContract } from './SchemaContract'
-import { ColumnDefinitionOptions } from '@Typetron/Database/Drivers/SQL'
-
-interface StatementsList {
-    create: Constructor<Statement>,
-    select: Constructor<Statement>,
-    insert: Constructor<Statement>,
-    delete: Constructor<Statement>,
-    update: Constructor<Statement>,
-    alter: Constructor<Statement>,
-}
-
-export abstract class DatabaseDriver {
-
-    abstract statements: StatementsList
-
-    abstract schema: SchemaContract
-
-    abstract run(query: string, params?: SqlValue[]): Promise<void>
-
-    abstract truncate(table: string): Promise<void>
-
-    abstract insertOne(query: string, params: SqlValue[]): Promise<number>
-
-    abstract get<T>(query: string, params: SqlValue[]): Promise<T | T[]>
-
-    abstract first<T>(query: string, params: SqlValue[]): Promise<T | undefined>
-
-    abstract tables(): Promise<{name: string}[]>
-
-    abstract tableExists(table: string): Promise<boolean>
-
-    abstract tableColumns(table: string): Promise<ColumnDefinitionOptions[]>
-}

package/Database/Drivers/MySQL/Alter/index.ts

@@ -1,55 +0,0 @@
-import { ColumnDefinitionOptions } from '../../../Drivers/SQL'
-import { wrap } from '../../../Helpers'
-import { ColumnDefinition } from '@Typetron/Database/Drivers/MySQL/ColumnDefinition'
-import { Expression } from '@Typetron/Database'
-
-export enum Constraints {
-    PrimaryKey = 'PRIMARY KEY',
-    ForeignKey = 'FOREIGN KEY',
-}
-
-export abstract class AlterOption extends Expression {
-    constructor(public column: ColumnDefinitionOptions) {super()}
-
-    abstract toSQL(): string
-}
-
-export class AddColumn extends AlterOption {
-    toSQL(): string {
-        return `ADD ${new ColumnDefinition(this.column).toSQL()}`
-    }
-}
-
-export class AddConstraint extends AlterOption {
-
-    constructor(column: ColumnDefinitionOptions, public type: Constraints) {super(column)}
-
-    toSQL(): string {
-        return `ADD CONSTRAINT ${this.type} (${this.column.name})`
-    }
-}
-
-export class ModifyColumn extends AlterOption {
-    toSQL(): string {
-        return `MODIFY ${new ColumnDefinition(this.column).toSQL()}`
-    }
-}
-
-export class DropColumn extends Expression {
-    constructor(public column: string) {super()}
-
-    toSQL(): string {
-        return `DROP COLUMN ${wrap(this.column)}`
-    }
-}
-
-export class Alter extends Expression {
-    constructor(public table: string, public alterOptions: Expression[]) {super()}
-
-    toSQL() {
-        return `
-            ALTER TABLE ${wrap(this.table)}
-                ${this.alterOptions.map(option => option.toSQL()).join(', \n')}
-        `
-    }
-}

package/Database/Drivers/MySQL/ColumnDefinition.ts

@@ -1,16 +0,0 @@
-import { ColumnDefinitionOptions } from '../../Drivers/SQL'
-import { wrap } from '../../Helpers'
-
-export class ColumnDefinition {
-    constructor(public options: ColumnDefinitionOptions) {}
-
-    toSQL() {
-        const sqlParts = [wrap(this.options.name), this.options.type]
-
-        if (this.options.autoIncrement) {
-            sqlParts.push('AUTO_INCREMENT')
-        }
-
-        return sqlParts.join(' ')
-    }
-}

package/Database/Drivers/MySQL/Create.ts

@@ -1,47 +0,0 @@
-import { BaseStatement } from '../SQL/Statements/BaseStatement'
-import { ColumnDefinitionOptions } from '../SQL'
-import { wrap } from '../../Helpers'
-
-export class Create extends BaseStatement {
-
-    constructor(table: string, public columns: ColumnDefinitionOptions[] = []) {
-        super({
-            table,
-            columns: [],
-            joins: [],
-            wheres: [],
-            groups: [],
-            orders: [],
-            having: []
-        })
-    }
-
-    toSQL() {
-        const definitions: string[] = this.getColumnsSQL(this.columns)
-
-        this.columns.where('primaryKey').whenNotEmpty(primaryColumns => {
-            definitions.push(`PRIMARY KEY (${primaryColumns.pluck('name').join(', ')})`)
-        })
-
-        return `
-            CREATE TABLE ${this.table}
-            (
-                ${definitions.join(', \n')}
-            )
-        `
-    }
-
-    private getColumnsSQL(columns: ColumnDefinitionOptions[]) {
-        return columns.map(this.getColumnSQL)
-    }
-
-    private getColumnSQL(column: ColumnDefinitionOptions) {
-        const sqlParts = [wrap(column.name), column.type]
-
-        if (column.autoIncrement) {
-            sqlParts.push('AUTO_INCREMENT')
-        }
-
-        return sqlParts.join(' ')
-    }
-}