Add support for jobs & queueables, migrations

- Create migration directives & migrators
- Modify Cache classes to support array manipulation
- Create Redis unit and RedisCache implementation
- Create Queueable base class and Queue class that uses Cache backend

src/orm/model/Model.ts

@@ -635,6 +635,30 @@ export abstract class Model<T extends Model<T>> extends AppClass implements Bus
         return this
     }
 
+    /**
+     * Delete the current model from the database, if it exists.
+     */
+    async delete(): Promise<void> {
+        if ( !this.exists() ) {
+            return
+        }
+
+        await this.query()
+            .where(this.qualifyKey(), '=', this.key())
+            .delete()
+
+        const ctor = this.constructor as typeof Model
+        const field = getFieldsMeta(this)
+            .firstWhere('databaseKey', '=', ctor.key)
+
+        if ( field ) {
+            delete (this as any)[field.modelKey]
+            return
+        }
+
+        delete (this as any)[ctor.key]
+    }
+
     /**
      * Cast this model to a simple object mapping model fields to their values.
      *

src/orm/model/ModelBuilder.ts

@@ -1,8 +1,11 @@
 import {Model} from './Model'
 import {AbstractBuilder} from '../builder/AbstractBuilder'
 import {AbstractResultIterable} from '../builder/result/AbstractResultIterable'
-import {Instantiable} from '../../di'
+import {Instantiable, StaticClass} from '../../di'
 import {ModelResultIterable} from './ModelResultIterable'
+import {Collection} from '../../util'
+import {ConstraintOperator, ModelKey, ModelKeys} from '../types'
+import {EscapeValue} from '../dialect/SQLDialect'
 
 /**
  * Implementation of the abstract builder whose results yield instances of a given Model, `T`.
@@ -10,7 +13,7 @@ import {ModelResultIterable} from './ModelResultIterable'
 export class ModelBuilder<T extends Model<T>> extends AbstractBuilder<T> {
     constructor(
         /** The model class that is created for results of this query. */
-        protected readonly ModelClass: Instantiable<T>,
+        protected readonly ModelClass: StaticClass<T, typeof Model> & Instantiable<T>,
     ) {
         super()
     }
@@ -22,4 +25,45 @@ export class ModelBuilder<T extends Model<T>> extends AbstractBuilder<T> {
     public getResultIterable(): AbstractResultIterable<T> {
         return this.app().make<ModelResultIterable<T>>(ModelResultIterable, this, this.registeredConnection, this.ModelClass)
     }
+
+    /**
+     * Apply a WHERE...IN... constraint on the primary key of the model.
+     * @param keys
+     */
+    public whereKey(keys: ModelKeys): this {
+        return this.whereIn(
+            this.ModelClass.qualifyKey(),
+            this.normalizeModelKeys(keys),
+        )
+    }
+
+    /**
+     * Apply a where constraint on the column corresponding the the specified
+     * property on the model.
+     * @param propertyName
+     * @param operator
+     * @param operand
+     */
+    public whereProperty(propertyName: string, operator: ConstraintOperator, operand?: EscapeValue): this {
+        return this.where(
+            this.ModelClass.propertyToColumn(propertyName),
+            operator,
+            operand,
+        )
+    }
+
+    /**
+     * Given some format of keys of the model, try to normalize them to a flat array.
+     * @param keys
+     * @protected
+     */
+    protected normalizeModelKeys(keys: ModelKeys): ModelKey[] {
+        if ( Array.isArray(keys) ) {
+            return keys
+        } else if ( keys instanceof Collection ) {
+            return keys.all()
+        }
+
+        return [keys]
+    }
 }