@typetron/framework 0.4.0-rc8 → 0.5.0-rc1

package/Container/Container.ts

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

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

package/Container/Decorators.ts

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

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

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

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

package/Database/Connection.ts

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

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

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

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

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

@@ -0,0 +1,47 @@
+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(' ')
+    }
+}