@bedrockio/model 0.1.32 → 0.2.0

package/src/soft-delete.js

@@ -1,6 +1,11 @@
+import { isEqual } from 'lodash';
+
+import { wrapQuery } from './query';
+
 export function applySoftDelete(schema) {
   applyQueries(schema);
   applyUniqueConstraints(schema);
+  applyHookPatch(schema);
 }
 
 // Soft Delete Querying
@@ -40,63 +45,84 @@ function applyQueries(schema) {
 
   // Static Methods
 
-  schema.static('deleteOne', async function deleteOne(filter, ...rest) {
+  schema.static('deleteOne', function deleteOne(filter, ...rest) {
     const update = getDelete();
-    const res = await this.updateOne(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      deletedCount: res.modifiedCount,
-    };
+    const query = this.updateOne(filter, update, ...omitCallback(rest));
+    return wrapQuery(query, async (promise) => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        deletedCount: res.modifiedCount,
+      };
+    });
   });
 
-  schema.static('deleteMany', async function deleteMany(filter, ...rest) {
+  schema.static('deleteMany', function deleteMany(filter, ...rest) {
     const update = getDelete();
-    const res = await this.updateMany(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      deletedCount: res.modifiedCount,
-    };
+    const query = this.updateMany(filter, update, ...omitCallback(rest));
+    return wrapQuery(query, async (promise) => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        deletedCount: res.modifiedCount,
+      };
+    });
   });
 
-  schema.static(
-    'findOneAndDelete',
-    async function findOneAndDelete(filter, ...args) {
-      return await this.findOneAndUpdate(filter, getDelete(), ...args);
-    }
-  );
+  schema.static('findOneAndDelete', function findOneAndDelete(filter, ...rest) {
+    return this.findOneAndUpdate(filter, getDelete(), ...omitCallback(rest));
+  });
 
-  schema.static('restoreOne', async function restoreOne(filter, ...rest) {
-    const update = getRestore();
-    const res = await this.updateOne(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      restoredCount: res.modifiedCount,
-    };
+  schema.static('restoreOne', function restoreOne(filter, ...rest) {
+    const query = this.updateOne(filter, getRestore(), ...omitCallback(rest));
+    return wrapQuery(query, async (promise) => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        restoredCount: res.modifiedCount,
+      };
+    });
   });
 
-  schema.static('restoreMany', async function restoreMany(filter, ...rest) {
-    const update = getRestore();
-    const res = await this.updateMany(filter, update, ...rest);
-    return {
-      acknowledged: res.acknowledged,
-      restoredCount: res.modifiedCount,
-    };
+  schema.static('restoreMany', function restoreMany(filter, ...rest) {
+    const query = this.updateMany(filter, getRestore(), ...omitCallback(rest));
+    return wrapQuery(query, async (promise) => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        restoredCount: res.modifiedCount,
+      };
+    });
   });
 
-  schema.static('destroyOne', async function destroyOne(...args) {
-    const res = await this.collection.deleteOne(...args);
-    return {
-      acknowledged: res.acknowledged,
-      destroyedCount: res.deletedCount,
-    };
+  schema.static('destroyOne', function destroyOne(conditions, ...rest) {
+    // Following Mongoose patterns here
+    const query = new this.Query({}, {}, this, this.collection).deleteOne(
+      conditions,
+      ...omitCallback(rest)
+    );
+    return wrapQuery(query, async (promise) => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        destroyedCount: res.deletedCount,
+      };
+    });
   });
 
-  schema.static('destroyMany', async function destroyMany(...args) {
-    const res = await this.collection.deleteMany(...args);
-    return {
-      acknowledged: res.acknowledged,
-      destroyedCount: res.deletedCount,
-    };
+  schema.static('destroyMany', function destroyMany(conditions, ...rest) {
+    // Following Mongoose patterns here
+    const query = new this.Query({}, {}, this, this.collection).deleteMany(
+      conditions,
+      ...omitCallback(rest)
+    );
+    return wrapQuery(query, async (promise) => {
+      const res = await promise;
+      return {
+        acknowledged: res.acknowledged,
+        destroyedCount: res.deletedCount,
+      };
+    });
   });
 
   schema.static('findDeleted', function findDeleted(filter, ...rest) {
@@ -104,7 +130,7 @@ function applyQueries(schema) {
       ...filter,
       deleted: true,
     };
-    return this.find(filter, ...rest);
+    return this.find(filter, ...omitCallback(rest));
   });
 
   schema.static('findOneDeleted', function findOneDeleted(filter, ...rest) {
@@ -112,7 +138,7 @@ function applyQueries(schema) {
       ...filter,
       deleted: true,
     };
-    return this.findOne(filter, ...rest);
+    return this.findOne(filter, ...omitCallback(rest));
   });
 
   schema.static('findByIdDeleted', function findByIdDeleted(id, ...rest) {
@@ -120,7 +146,7 @@ function applyQueries(schema) {
       _id: id,
       deleted: true,
     };
-    return this.findOne(filter, ...rest);
+    return this.findOne(filter, ...omitCallback(rest));
   });
 
   schema.static('existsDeleted', function existsDeleted(filter, ...rest) {
@@ -128,7 +154,7 @@ function applyQueries(schema) {
       ...filter,
       deleted: true,
     };
-    return this.exists(filter, ...rest);
+    return this.exists(filter, ...omitCallback(rest));
   });
 
   schema.static(
@@ -138,7 +164,7 @@ function applyQueries(schema) {
         ...filter,
         deleted: true,
       };
-      return this.countDocuments(filter, ...rest);
+      return this.countDocuments(filter, ...omitCallback(rest));
     }
   );
 
@@ -147,7 +173,7 @@ function applyQueries(schema) {
       ...filter,
       ...getWithDeletedQuery(),
     };
-    return this.find(filter, ...rest);
+    return this.find(filter, ...omitCallback(rest));
   });
 
   schema.static(
@@ -157,7 +183,7 @@ function applyQueries(schema) {
         ...filter,
         ...getWithDeletedQuery(),
       };
-      return this.findOne(filter, ...rest);
+      return this.findOne(filter, ...omitCallback(rest));
     }
   );
 
@@ -168,7 +194,7 @@ function applyQueries(schema) {
         _id: id,
         ...getWithDeletedQuery(),
       };
-      return this.findOne(filter, ...rest);
+      return this.findOne(filter, ...omitCallback(rest));
     }
   );
 
@@ -179,7 +205,7 @@ function applyQueries(schema) {
         ...filter,
         ...getWithDeletedQuery(),
       };
-      return this.exists(filter, ...rest);
+      return this.exists(filter, ...omitCallback(rest));
     }
   );
 
@@ -190,7 +216,7 @@ function applyQueries(schema) {
         ...filter,
         ...getWithDeletedQuery(),
       };
-      return this.countDocuments(filter, ...rest);
+      return this.countDocuments(filter, ...omitCallback(rest));
     }
   );
 }
@@ -384,4 +410,171 @@ function getCollisions(obj1, obj2) {
   return collisions;
 }
 
-// Disallowed Methods
+// Hook Patch
+
+function applyHookPatch(schema) {
+  const schemaPre = schema.pre;
+  const schemaPost = schema.post;
+
+  schema.pre = function (name, fn) {
+    if (name === 'restore') {
+      // Document hooks
+      schemaPre.call(this, 'save', getPreDocRestore(fn));
+    } else if (name === 'deleteOne') {
+      // Query Hooks
+      schemaPre.call(this, 'updateOne', getPreDelete(fn));
+    } else if (name === 'deleteMany') {
+      schemaPre.call(this, 'updateMany', getPreDelete(fn));
+    } else if (name === 'findOneAndDelete') {
+      schemaPre.call(this, 'findOneAndUpdate', getPreDelete(fn));
+    } else if (name === 'restoreOne') {
+      schemaPre.call(this, 'updateOne', getPreRestore(fn));
+    } else if (name === 'restoreMany') {
+      schemaPre.call(this, 'updateMany', getPreRestore(fn));
+    } else if (name === 'destroyOne') {
+      schemaPre.call(this, 'deleteOne', getPre(fn));
+    } else if (name === 'destroyMany') {
+      schemaPre.call(this, 'deleteMany', getPre(fn));
+    } else if (name === 'findDeleted') {
+      schemaPre.call(this, 'find', getPreDeleted(fn));
+    } else if (name === 'findOneDeleted') {
+      schemaPre.call(this, 'findOne', getPreDeleted(fn));
+    } else if (name === 'countDocumentsDeleted') {
+      schemaPre.call(this, 'countDocuments', getPreDeleted(fn));
+    } else if (name === 'findWithDeleted') {
+      schemaPre.call(this, 'find', getPreWithDeleted(fn));
+    } else if (name === 'findOneWithDeleted') {
+      schemaPre.call(this, 'findOne', getPreWithDeleted(fn));
+    } else if (name === 'countDocumentsWithDeleted') {
+      schemaPre.call(this, 'countDocuments', getPreWithDeleted(fn));
+    } else {
+      schemaPre.apply(this, arguments);
+    }
+    return this;
+  };
+
+  schema.post = function (name, fn) {
+    if (name === 'deleteOne') {
+      schemaPost.call(this, 'updateOne', getPostDelete(fn));
+    } else if (name === 'deleteMany') {
+      schemaPost.call(this, 'updateMany', getPostDelete(fn));
+    } else if (name === 'findOneAndDelete') {
+      schemaPost.call(this, 'findOneAndUpdate', getPostDelete(fn));
+    } else if (name === 'restoreOne') {
+      schemaPost.call(this, 'updateOne', getPostRestore(fn));
+    } else if (name === 'restoreMany') {
+      schemaPost.call(this, 'updateMany', getPostRestore(fn));
+    } else if (name === 'destroyOne') {
+      schemaPost.call(this, 'deleteOne', getPost(fn));
+    } else if (name === 'destroyMany') {
+      schemaPost.call(this, 'deleteMany', getPost(fn));
+    } else if (name === 'findDeleted') {
+      schemaPost.call(this, 'find', getPostDeleted(fn));
+    } else if (name === 'findOneDeleted') {
+      schemaPost.call(this, 'findOne', getPostDeleted(fn));
+    } else if (name === 'countDocumentsDeleted') {
+      schemaPost.call(this, 'countDocuments', getPostDeleted(fn));
+    } else if (name === 'findWithDeleted') {
+      schemaPost.call(this, 'find', getPostWithDeleted(fn));
+    } else if (name === 'findOneWithDeleted') {
+      schemaPost.call(this, 'findOne', getPostWithDeleted(fn));
+    } else if (name === 'countDocumentsWithDeleted') {
+      schemaPost.call(this, 'countDocuments', getPostWithDeleted(fn));
+    } else {
+      schemaPost.apply(this, arguments);
+    }
+    return this;
+  };
+}
+
+// Needs to be separated as hooks check arity to
+// determine the arguments to pass.
+
+function getPre(fn, check) {
+  return function (next) {
+    runHook(this, fn, check, next, arguments);
+  };
+}
+
+function getPost(fn, check) {
+  return function (res, next) {
+    runHook(this, fn, check, next, arguments);
+  };
+}
+
+function runHook(query, fn, check, next, args) {
+  if (!check || check(query)) {
+    const ret = fn.apply(query, args);
+    if (ret instanceof Promise) {
+      ret.finally(next);
+    }
+  } else {
+    next();
+  }
+}
+
+function getPreDelete(fn) {
+  return getPre(fn, (query) => {
+    return query.get('deleted') === true;
+  });
+}
+
+function getPreRestore(fn) {
+  return getPre(fn, (query) => {
+    return query.get('deleted') === false;
+  });
+}
+
+function getPreDeleted(fn) {
+  return getPre(fn, (query) => {
+    return query.getFilter().deleted === true;
+  });
+}
+
+function getPreWithDeleted(fn) {
+  return getPre(fn, (query) => {
+    return isEqual(query.getFilter().deleted, getWithDeletedQuery().deleted);
+  });
+}
+
+function getPreDocRestore(fn) {
+  return getPre(fn, (doc) => {
+    return doc.isModified('deleted') && doc.deleted === false;
+  });
+}
+
+function getPostDelete(fn) {
+  return getPost(fn, (query) => {
+    return query.get('deleted') === true;
+  });
+}
+
+function getPostRestore(fn) {
+  return getPost(fn, (query) => {
+    return query.get('deleted') === false;
+  });
+}
+
+function getPostDeleted(fn) {
+  return getPost(fn, (query) => {
+    return query.getFilter().deleted === true;
+  });
+}
+
+function getPostWithDeleted(fn) {
+  return getPost(fn, (query) => {
+    return isEqual(query.getFilter().deleted, getWithDeletedQuery().deleted);
+  });
+}
+
+// Utils
+
+// Mongoose >= v7 no longer accepts a callback for queries,
+// however it still passes post hooks to static methods for
+// some reason (this appears to be a bug), so omit functions
+// here to allow projectsion/options to still be passed.
+function omitCallback(args) {
+  return args.filter((arg) => {
+    return typeof arg !== 'function';
+  });
+}

package/types/delete-hooks.d.ts

@@ -0,0 +1,2 @@
+export function applyDeleteHooks(schema: any, definition: any): void;
+//# sourceMappingURL=delete-hooks.d.ts.map

package/types/delete-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,qEAkDC"}

package/types/disallowed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"disallowed.d.ts","sourceRoot":"","sources":["../src/disallowed.js"],"names":[],"mappings":"AAEA,mDA4DC"}
+{"version":3,"file":"disallowed.d.ts","sourceRoot":"","sources":["../src/disallowed.js"],"names":[],"mappings":"AAEA,mDA+BC"}

package/types/load.d.ts

@@ -4,7 +4,73 @@
  * @param {string} name
  * @returns mongoose.Model
  */
-export function loadModel(definition: object, name: string): any;
+export function loadModel(definition: object, name: string): mongoose.Model<any, any, any, any, any, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
+    [x: string]: any;
+}, {
+    autoIndex?: boolean;
+    autoCreate?: boolean;
+    bufferCommands?: boolean;
+    bufferTimeoutMS?: number;
+    capped?: number | boolean | {
+        size?: number;
+        max?: number;
+        autoIndexId?: boolean;
+    };
+    collation?: mongoose.mongo.CollationOptions;
+    collectionOptions?: mongoose.mongo.CreateCollectionOptions;
+    timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
+    expireAfterSeconds?: number;
+    expires?: string | number;
+    collection?: string;
+    discriminatorKey?: string;
+    excludeIndexes?: boolean;
+    id?: boolean;
+    _id?: boolean;
+    minimize?: boolean;
+    optimisticConcurrency?: boolean;
+    pluginTags?: string[];
+    read?: string;
+    writeConcern?: mongoose.mongo.WriteConcern;
+    safe?: boolean | {
+        w?: string | number;
+        wtimeout?: number;
+        j?: boolean;
+    };
+    shardKey?: Record<string, unknown>;
+    strict?: boolean | "throw";
+    strictQuery?: boolean | "throw";
+    toJSON: {
+        getters: boolean;
+        versionKey: boolean;
+        transform: (doc: any, ret: any, options: any) => void;
+    } | mongoose.ToObjectOptions<any>;
+    toObject: {
+        getters: boolean;
+        versionKey: boolean;
+        transform: (doc: any, ret: any, options: any) => void;
+    } | mongoose.ToObjectOptions<any>;
+    typeKey?: string;
+    validateBeforeSave?: boolean;
+    validateModifiedOnly?: boolean;
+    versionKey?: string | boolean;
+    selectPopulatedPaths?: boolean;
+    skipVersioning?: {
+        [key: string]: boolean;
+    };
+    storeSubdocValidationError?: boolean;
+    timestamps: boolean | mongoose.SchemaTimestampsConfig;
+    suppressReservedKeysWarning?: boolean;
+    statics?: {
+        [x: string]: any;
+    };
+    methods?: any;
+    query?: any;
+    castNonArrays?: boolean;
+    virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
+    overwriteModels?: boolean;
+}, any, any>> & {
+    [x: string]: any;
+};
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.

package/types/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}

package/types/query.d.ts

@@ -0,0 +1,2 @@
+export function wrapQuery(query: any, fn: any): any;
+//# sourceMappingURL=query.d.ts.map

package/types/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.js"],"names":[],"mappings":"AAIA,oDAUC"}

package/types/schema.d.ts

@@ -6,7 +6,9 @@
  * @param {mongoose.SchemaOptions} options
  * @returns mongoose.Schema
  */
-export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any>, any, any, any, any, {
+export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
+    [x: string]: any;
+}, {
     autoIndex?: boolean;
     autoCreate?: boolean;
     bufferCommands?: boolean;
@@ -16,8 +18,9 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         max?: number;
         autoIndexId?: boolean;
     };
-    collation?: import("mongoose/node_modules/mongodb").CollationOptions;
-    timeseries?: import("mongoose/node_modules/mongodb").TimeSeriesCollectionOptions;
+    collation?: mongoose.mongo.CollationOptions;
+    collectionOptions?: mongoose.mongo.CreateCollectionOptions;
+    timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
     expireAfterSeconds?: number;
     expires?: string | number;
     collection?: string;
@@ -29,7 +32,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     optimisticConcurrency?: boolean;
     pluginTags?: string[];
     read?: string;
-    writeConcern?: import("mongoose/node_modules/mongodb").WriteConcern;
+    writeConcern?: mongoose.mongo.WriteConcern;
     safe?: boolean | {
         w?: string | number;
         wtimeout?: number;
@@ -42,14 +45,15 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions;
+    } | mongoose.ToObjectOptions<any>;
     toObject: {
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions;
+    } | mongoose.ToObjectOptions<any>;
     typeKey?: string;
     validateBeforeSave?: boolean;
+    validateModifiedOnly?: boolean;
     versionKey?: string | boolean;
     selectPopulatedPaths?: boolean;
     skipVersioning?: {
@@ -57,14 +61,16 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     };
     storeSubdocValidationError?: boolean;
     timestamps: boolean | mongoose.SchemaTimestampsConfig;
-    supressReservedKeysWarning?: boolean;
-    statics?: any;
+    suppressReservedKeysWarning?: boolean;
+    statics?: {
+        [x: string]: any;
+    };
     methods?: any;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
     overwriteModels?: boolean;
-}, any>;
+}, any, any>;
 export function normalizeAttributes(arg: any, path?: any[]): any;
 import mongoose from "mongoose";
 //# sourceMappingURL=schema.d.ts.map

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkChC;AAED,iEAsBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuChC;AAED,iEAsBC"}

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAcA,gEAgEC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAeA,gEAmDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}

package/types/serialization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.js"],"names":[],"mappings":";;;IASa,2DAIV"}
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../src/serialization.js"],"names":[],"mappings":";;;IAWa,2DAIV"}

package/types/soft-delete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAAA,mDAGC;AA4PD,oEAsBC;AAgDD,2DAKC"}
+{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAIA,mDAIC;AAiRD,oEAsBC;AAgDD,2DAKC"}

package/types/testing.d.ts

@@ -5,7 +5,7 @@
  * [Link](https://github.com/bedrockio/model#testing)
  * @returns mongoose.Model
  */
-export function createTestModel(...args: any[]): mongoose.Model<any, unknown, unknown, unknown, any>;
+export function createTestModel(...args: any[]): mongoose.Model<any, unknown, unknown, unknown, any, any>;
 export function getTestModelName(): string;
 import mongoose from "mongoose";
 //# sourceMappingURL=testing.d.ts.map

package/types/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,qGAiBC;AAED,2CAEC"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,0GAiBC;AAED,2CAEC"}