@zakodium/adonis-mongodb 0.10.4 → 0.13.0

package/src/Migration.ts

@@ -4,6 +4,7 @@ import {
   ClientSession,
   Db,
   IndexSpecification,
+  DropIndexesOptions,
 } from 'mongodb';
 
 import type {
@@ -13,18 +14,26 @@ import type {
 
 enum MigrationType {
   CreateCollection = 'CreateCollection',
+  DropIndex = 'DropIndex',
   CreateIndex = 'CreateIndex',
   Custom = 'Custom',
 }
 
 interface CreateCollectionOperation {
   type: MigrationType.CreateCollection;
-  name: string;
+  collectionName: string;
+}
+
+interface DropIndexOperation {
+  type: MigrationType.DropIndex;
+  collectionName: string;
+  indexName: string;
+  options?: DropIndexesOptions;
 }
 
 interface CreateIndexOperation {
   type: MigrationType.CreateIndex;
-  name: string;
+  collectionName: string;
   index: IndexSpecification;
   options?: CreateIndexesOptions;
 }
@@ -36,6 +45,7 @@ interface CustomOperation {
 
 type MigrationOperation =
   | CreateCollectionOperation
+  | DropIndexOperation
   | CreateIndexOperation
   | CustomOperation;
 
@@ -67,7 +77,20 @@ export default function createMigration(Database: DatabaseContract): any {
     public createCollection(collectionName: string): void {
       this.$operations.push({
         type: MigrationType.CreateCollection,
-        name: collectionName,
+        collectionName,
+      });
+    }
+
+    public dropIndex(
+      collectionName: string,
+      indexName: string,
+      options?: DropIndexesOptions,
+    ): void {
+      this.$operations.push({
+        type: MigrationType.DropIndex,
+        collectionName,
+        indexName,
+        options,
       });
     }
 
@@ -78,7 +101,7 @@ export default function createMigration(Database: DatabaseContract): any {
     ): void {
       this.$operations.push({
         type: MigrationType.CreateIndex,
-        name: collectionName,
+        collectionName,
         index,
         options,
       });
@@ -94,6 +117,7 @@ export default function createMigration(Database: DatabaseContract): any {
     public async execUp(): Promise<void> {
       this.up();
       await this._createCollections();
+      await this._dropIndexes();
       await this._createIndexes();
       await this._executeDeferred();
     }
@@ -113,8 +137,10 @@ export default function createMigration(Database: DatabaseContract): any {
     private async _createCollections(): Promise<void> {
       const db = await this.$connection.database();
       for (const op of this.$operations.filter(isCreateCollection)) {
-        this.$logger.info(`Creating collection ${op.name}`);
-        await db.createCollection(op.name, { session: this.$session });
+        this.$logger.info(`Creating collection ${op.collectionName}`);
+        await db.createCollection(op.collectionName, {
+          session: this.$session,
+        });
       }
     }
 
@@ -125,15 +151,29 @@ export default function createMigration(Database: DatabaseContract): any {
       }
     }
 
+    private async _dropIndexes(): Promise<void> {
+      const db = await this.$connection.database();
+      for (const op of this.$operations.filter(isDropIndex)) {
+        this.$logger.info(
+          `Dropping index ${op.indexName} on ${op.collectionName}`,
+        );
+        const collection = db.collection(op.collectionName);
+        // Index deletion cannot be done in a transaction.
+        await collection.dropIndex(op.indexName, { ...op.options });
+      }
+    }
+
     private async _createIndexes(): Promise<void> {
       const db = await this.$connection.database();
       const collections = await this._listCollections();
       for (const op of this.$operations.filter(isCreateIndex)) {
-        this.$logger.info(`Creating index on ${op.name}`);
-        await db.createIndex(op.name, op.index, {
+        this.$logger.info(`Creating index on ${op.collectionName}`);
+        await db.createIndex(op.collectionName, op.index, {
           ...op.options,
-          // index creation will fail if collection pre-exists the transaction
-          session: collections.includes(op.name) ? undefined : this.$session,
+          // Index creation will fail if collection pre-exists the transaction.
+          session: collections.includes(op.collectionName)
+            ? undefined
+            : this.$session,
         });
       }
     }
@@ -154,6 +194,10 @@ function isCreateIndex(op: MigrationOperation): op is CreateIndexOperation {
   return op.type === MigrationType.CreateIndex;
 }
 
+function isDropIndex(op: MigrationOperation): op is DropIndexOperation {
+  return op.type === MigrationType.DropIndex;
+}
+
 function isCustom(op: MigrationOperation): op is CustomOperation {
   return op.type === MigrationType.Custom;
 }

package/src/Model/Model.ts

@@ -1,3 +1,5 @@
+import assert from 'assert';
+
 import { defineStaticProperty, Exception } from '@poppinss/utils';
 import { cloneDeep, isEqual, pickBy, snakeCase } from 'lodash';
 import {
@@ -8,9 +10,13 @@ import {
   CountOptions,
   DeleteOptions,
   DistinctOptions,
+  Document,
+  ExplainVerbosityLike,
   Filter,
   FindOptions,
   InsertOneOptions,
+  SortDirection,
+  WithId,
 } from 'mongodb';
 import pluralize from 'pluralize';
 
@@ -23,6 +29,8 @@ import {
   ModelAdapterOptions,
   ModelDocumentOptions,
   FieldOptions,
+  QuerySortObject,
+  ForbiddenQueryOptions,
 } from '@ioc:Zakodium/Mongodb/Odm';
 
 import { proxyHandler } from './proxyHandler';
@@ -37,32 +45,97 @@ function mergeDriverOptions<
   } as DriverOptionType;
 }
 
-function ensureSort(options?: FindOptions): void {
-  if (!options || options.sort) return;
-  options.sort = {
-    _id: -1,
-  };
+interface QueryLocalOptions {
+  sort: QuerySortObject;
+  skip?: number;
+  limit?: number;
 }
 
+const forbiddenQueryOptions: ForbiddenQueryOptions[] = [
+  'sort',
+  'skip',
+  'limit',
+  'explain',
+];
+
 class Query<ModelType extends typeof BaseModel>
   implements QueryContract<InstanceType<ModelType>>
 {
+  private localCustomSort = false;
+  private localOptions: QueryLocalOptions = {
+    sort: {
+      _id: 'descending',
+    },
+  };
+
+  private getDriverOptions(): FindOptions<
+    ModelAttributes<InstanceType<ModelType>>
+  > {
+    return { ...mergeDriverOptions(this.options), ...this.localOptions };
+  }
+
   public constructor(
     private filter: Filter<ModelAttributes<InstanceType<ModelType>>>,
     private options:
       | ModelAdapterOptions<
-          FindOptions<ModelAttributes<InstanceType<ModelType>>>
+          Omit<
+            FindOptions<ModelAttributes<InstanceType<ModelType>>>,
+            ForbiddenQueryOptions
+          >
         >
       | undefined,
     private modelConstructor: ModelType,
-  ) {}
+  ) {
+    if (options?.driverOptions) {
+      for (const key of forbiddenQueryOptions) {
+        if (key in options.driverOptions) {
+          throw new TypeError(`${key} is not allowed in query's driverOptions`);
+        }
+      }
+    }
+  }
+
+  public sort(sort: QuerySortObject): this {
+    if (!this.localCustomSort) {
+      this.localCustomSort = true;
+      this.localOptions.sort = sort;
+    } else {
+      Object.assign(this.localOptions.sort, sort);
+    }
+    return this;
+  }
+
+  public sortBy(field: string, direction: SortDirection = 'ascending'): this {
+    return this.sort({ [field]: direction });
+  }
+
+  public skip(skip: number): this {
+    if (!Number.isInteger(skip)) {
+      throw new TypeError(`skip must be an integer`);
+    }
+    if (skip < 0) {
+      throw new TypeError(`skip must be at least zero`);
+    }
+    this.localOptions.skip = skip;
+    return this;
+  }
+
+  public limit(limit: number): this {
+    if (!Number.isInteger(limit)) {
+      throw new TypeError(`limit must be an integer`);
+    }
+    if (limit < 1) {
+      throw new TypeError(`limit must be at least one`);
+    }
+    this.localOptions.limit = limit;
+    return this;
+  }
 
   public async first(): Promise<InstanceType<ModelType> | null> {
     const collection = await this.modelConstructor.getCollection();
-    const driverOptions = mergeDriverOptions(this.options);
-    ensureSort(driverOptions);
+    const driverOptions = this.getDriverOptions();
     const result = await collection.findOne(this.filter, driverOptions);
-    if (result === undefined) {
+    if (result === null) {
       return null;
     }
     const instance = new this.modelConstructor(
@@ -87,9 +160,13 @@ class Query<ModelType extends typeof BaseModel>
 
   public async all(): Promise<Array<InstanceType<ModelType>>> {
     const collection = await this.modelConstructor.getCollection();
-    const driverOptions = mergeDriverOptions(this.options);
-    ensureSort(driverOptions);
-    const result = await collection.find(this.filter, driverOptions).toArray();
+    const driverOptions = this.getDriverOptions();
+    const result = await collection
+      .find(
+        this.filter as Filter<WithId<ModelAttributes<InstanceType<ModelType>>>>,
+        driverOptions,
+      )
+      .toArray();
     return result.map(
       (value) =>
         new this.modelConstructor(
@@ -106,7 +183,7 @@ class Query<ModelType extends typeof BaseModel>
 
   public async count(): Promise<number> {
     const collection = await this.modelConstructor.getCollection();
-    const driverOptions = mergeDriverOptions(this.options);
+    const driverOptions = this.getDriverOptions();
     return collection.countDocuments(
       this.filter,
       driverOptions as CountOptions,
@@ -115,7 +192,7 @@ class Query<ModelType extends typeof BaseModel>
 
   public async distinct<T = unknown>(key: string): Promise<T[]> {
     const collection = await this.modelConstructor.getCollection();
-    const driverOptions = mergeDriverOptions(this.options);
+    const driverOptions = this.getDriverOptions();
     return collection.distinct(
       key,
       this.filter,
@@ -123,13 +200,26 @@ class Query<ModelType extends typeof BaseModel>
     );
   }
 
+  public async explain(verbosity?: ExplainVerbosityLike): Promise<Document> {
+    const collection = await this.modelConstructor.getCollection();
+    const driverOptions = this.getDriverOptions();
+    return collection
+      .find(
+        this.filter as Filter<WithId<ModelAttributes<InstanceType<ModelType>>>>,
+        driverOptions,
+      )
+      .explain(verbosity);
+  }
+
   public async *[Symbol.asyncIterator](): AsyncIterableIterator<
     InstanceType<ModelType>
   > {
     const collection = await this.modelConstructor.getCollection();
-    const driverOptions = mergeDriverOptions(this.options);
-    ensureSort(driverOptions);
-    for await (const value of collection.find(this.filter, driverOptions)) {
+    const driverOptions = this.getDriverOptions();
+    for await (const value of collection.find(
+      this.filter as Filter<WithId<ModelAttributes<InstanceType<ModelType>>>>,
+      driverOptions,
+    )) {
       if (value === null) continue;
       yield new this.modelConstructor(
         value,
@@ -153,6 +243,13 @@ interface InternalModelConstructorOptions {
   session?: ClientSession;
 }
 
+function ensureSort(options?: FindOptions): void {
+  if (!options || options.sort) return;
+  options.sort = {
+    _id: -1,
+  };
+}
+
 function hasOwn(object: unknown, key: string): boolean {
   return Object.prototype.hasOwnProperty.call(object, key);
 }
@@ -173,15 +270,17 @@ export class BaseModel {
   public readonly createdAt: Date;
   public readonly updatedAt: Date;
 
-  public $isDeleted: boolean;
+  public $original: Record<string, unknown>;
+  public $attributes: Record<string, unknown>;
+
+  public $isPersisted = false;
+  public $isLocal = true;
+  public $isDeleted = false;
 
   protected $collection: Collection<
     ModelAttributes<MongodbDocument<unknown>>
   > | null = null;
-  protected $originalData: Record<string, unknown>;
-  protected $currentData: Record<string, unknown>;
   protected $options: InternalModelConstructorOptions;
-  protected $alreadySaved: boolean;
 
   public constructor(
     dbObj?: Record<string, unknown>,
@@ -189,11 +288,11 @@ export class BaseModel {
     alreadyExists = false,
   ) {
     if (dbObj) {
-      this.$originalData = alreadyExists === true ? cloneDeep(dbObj) : {};
-      this.$currentData = dbObj;
+      this.$original = alreadyExists === true ? cloneDeep(dbObj) : {};
+      this.$attributes = dbObj;
     } else {
-      this.$originalData = {};
-      this.$currentData = {};
+      this.$original = {};
+      this.$attributes = {};
     }
 
     if (options !== undefined) {
@@ -201,8 +300,11 @@ export class BaseModel {
       this.$collection = options.collection;
     }
 
-    this.$alreadySaved = alreadyExists;
-    this.$isDeleted = false;
+    if (alreadyExists) {
+      this.$isPersisted = true;
+      this.$isLocal = false;
+    }
+
     // eslint-disable-next-line no-constructor-return
     return new Proxy(this, proxyHandler);
   }
@@ -319,7 +421,7 @@ export class BaseModel {
       ModelAttributes<InstanceType<ModelType>>
     >;
     const result = await collection.findOne(filter, driverOptions);
-    if (result === undefined) return null;
+    if (result === null) return null;
     const instance = new this(
       result,
       // @ts-expect-error Unavoidable error.
@@ -357,7 +459,7 @@ export class BaseModel {
       ModelAttributes<InstanceType<ModelType>>
     >;
     const result = await collection.findOne(filter, driverOptions);
-    if (result === undefined) return null;
+    if (result === null) return null;
     const instance = new this(
       result,
       // @ts-expect-error Unavoidable error.
@@ -431,7 +533,10 @@ export class BaseModel {
     this: ModelType,
     filter: Filter<ModelAttributes<InstanceType<ModelType>>> = {},
     options?: ModelAdapterOptions<
-      FindOptions<ModelAttributes<InstanceType<ModelType>>>
+      Omit<
+        FindOptions<ModelAttributes<InstanceType<ModelType>>>,
+        ForbiddenQueryOptions
+      >
     >,
   ): Query<ModelType> {
     return new Query(filter, options, this);
@@ -441,27 +546,34 @@ export class BaseModel {
     this: ModelType,
     connection = this.connection,
   ): Promise<Collection<ModelAttributes<InstanceType<ModelType>>>> {
-    if (!this.$database) {
-      throw new Error('Model should only be accessed from IoC container');
-    }
+    assert(this.$database, 'Model should only be accessed from IoC container');
     const connectionInstance = this.$database.connection(connection);
     return connectionInstance.collection(this.collectionName);
   }
 
   public [Symbol.for('nodejs.util.inspect.custom')](): unknown {
     return {
-      model: this.constructor.name,
-      originalData: this.$originalData,
-      currentData: this.$currentData,
-      isDirty: this.$isDirty,
+      Model: this.constructor.name,
+      $original: this.$original,
+      $attributes: this.$attributes,
+      $isPersisted: this.$isPersisted,
+      $isNew: this.$isNew,
+      $isLocal: this.$isLocal,
+      $isDeleted: this.$isDeleted,
+      $dirty: this.$dirty,
+      $isDirty: this.$isDirty,
     };
   }
 
+  public get $isNew(): boolean {
+    return !this.$isPersisted;
+  }
+
   public get $dirty(): Partial<ModelAttributes<this>> {
-    return pickBy(this.$currentData, (value, key) => {
+    return pickBy(this.$attributes, (value, key) => {
       return (
-        this.$originalData[key] === undefined ||
-        !isEqual(this.$originalData[key], value)
+        this.$original[key] === undefined ||
+        !isEqual(this.$original[key], value)
       );
     }) as Partial<ModelAttributes<this>>;
   }
@@ -490,7 +602,7 @@ export class BaseModel {
   public $prepareToSet() {
     const dirty = this.$dirty;
     const dirtyEntries = Object.entries(dirty);
-    if (dirtyEntries.length === 0) {
+    if (dirtyEntries.length === 0 && this.$isPersisted) {
       return null;
     }
 
@@ -499,11 +611,11 @@ export class BaseModel {
     // which shouldn't reset the createdAt field.
     const toSet = {} as DataToSet;
     const now = new Date();
-    if (this.$currentData.createdAt === undefined) {
-      this.$currentData.createdAt = now;
+    if (this.$attributes.createdAt === undefined) {
+      this.$attributes.createdAt = now;
       toSet.createdAt = now;
     }
-    this.$currentData.updatedAt = now;
+    this.$attributes.updatedAt = now;
     toSet.updatedAt = now;
 
     for (const [dirtyKey, dirtyValue] of dirtyEntries) {
@@ -513,7 +625,7 @@ export class BaseModel {
   }
 
   public get id() {
-    return this.$currentData._id;
+    return this.$attributes._id;
   }
 
   public get $isDirty(): boolean {
@@ -521,7 +633,7 @@ export class BaseModel {
   }
 
   public toJSON(): unknown {
-    return this.$currentData;
+    return this.$attributes;
   }
 
   public async save(
@@ -536,18 +648,18 @@ export class BaseModel {
       ...options?.driverOptions,
       session: this.$options?.session,
     };
-    if (this.$alreadySaved === false) {
+    if (!this.$isPersisted) {
       const result = await collection.insertOne(toSet, driverOptions);
-      this.$currentData._id = result.insertedId;
+      this.$attributes._id = result.insertedId;
+      this.$isPersisted = true;
     } else {
       await collection.updateOne(
-        { _id: this.$currentData._id },
+        { _id: this.$attributes._id },
         { $set: toSet },
         driverOptions,
       );
     }
-    this.$originalData = cloneDeep(this.$currentData);
-    this.$alreadySaved = true;
+    this.$original = cloneDeep(this.$attributes);
     return true;
   }
 
@@ -562,7 +674,7 @@ export class BaseModel {
     };
     const result = await collection.deleteOne(
       {
-        _id: this.$currentData._id,
+        _id: this.$attributes._id,
       },
       driverOptions,
     );
@@ -574,7 +686,7 @@ export class BaseModel {
     values: NoExtraProperties<Partial<Omit<ModelAttributes<this>, '_id'>>, T>,
   ): this {
     Object.entries(values).forEach(([key, value]) => {
-      this.$currentData[key] = value;
+      this.$attributes[key] = value;
     });
     return this;
   }
@@ -582,11 +694,11 @@ export class BaseModel {
   public fill<T extends Partial<Omit<ModelAttributes<this>, '_id'>>>(
     values: NoExtraProperties<Partial<Omit<ModelAttributes<this>, '_id'>>, T>,
   ) {
-    const createdAt = this.$currentData.createdAt;
-    this.$currentData = {
+    const createdAt = this.$attributes.createdAt;
+    this.$attributes = {
       _id: this.id,
     };
-    if (createdAt) this.$currentData.createdAt = createdAt;
+    if (createdAt) this.$attributes.createdAt = createdAt;
     return this.merge(values);
   }
 }
@@ -602,7 +714,6 @@ export class BaseAutoIncrementModel extends BaseModel {
 
     const toSet = this.$prepareToSet();
     if (toSet === null) return false;
-
     const driverOptions = {
       ...options?.driverOptions,
       session: this.$options?.session,
@@ -615,22 +726,23 @@ export class BaseAutoIncrementModel extends BaseModel {
       );
 
       const doc = await counterCollection.findOneAndUpdate(
-        { _id: computeCollectionName(this.constructor.name) },
+        { _id: (this.constructor as typeof BaseModel).collectionName },
         { $inc: { count: 1 } },
-        { ...driverOptions, upsert: true },
+        { ...driverOptions, upsert: true, returnDocument: 'after' },
       );
-      const newCount = doc.value ? doc.value.count + 1 : 1;
-      toSet._id = newCount;
+      assert(doc.value, 'upsert should always create a document');
+      toSet._id = doc.value.count;
       await collection.insertOne(toSet, driverOptions);
-      this.$currentData._id = newCount;
+      this.$attributes._id = doc.value.count;
+      this.$isPersisted = true;
     } else {
       await collection.updateOne(
-        { _id: this.$currentData._id },
+        { _id: this.$attributes._id },
         { $set: toSet },
         driverOptions,
       );
     }
-    this.$originalData = cloneDeep(this.$currentData);
+    this.$original = cloneDeep(this.$attributes);
     return true;
   }
 }

package/src/Model/proxyHandler.ts

@@ -1,16 +1,21 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-export const proxyHandler = {
-  get(target: any, prop: string) {
+export const proxyHandler: ProxyHandler<any> = {
+  get(target: any, prop: string | symbol) {
     if (typeof target[prop] !== 'undefined') {
       return Reflect.get(target, prop);
     }
-    return Reflect.get(target.$currentData, prop);
+    return Reflect.get(target.$attributes, prop);
   },
-  set(target: any, prop: string, value: any) {
+  set(target: any, prop: string | symbol, value: any) {
     if (typeof target[prop] !== 'undefined') {
       return Reflect.set(target, prop, value);
     }
-    return Reflect.set(target.$currentData, prop, value);
+    return Reflect.set(target.$attributes, prop, value);
+  },
+  ownKeys() {
+    throw new Error(
+      'Getting model keys is disallowed. If you want to use object spread on the current data, do { ...model.$attributes }',
+    );
   },
 };