@aneuhold/be-ts-db-lib 1.0.114 → 2.0.0

package/lib/services/RepoSubscriptionService.ts

@@ -0,0 +1,63 @@
+import { BaseDocument } from '@aneuhold/core-ts-db-lib';
+import { ObjectId } from 'bson';
+
+export type RepoSubscribers<TDocType extends BaseDocument> = {
+  insertNew: InsertNewSubscriber<TDocType>[];
+  insertMany: InsertManySubscriber<TDocType>[];
+  updateOne: UpdateOneSubscriber<TDocType>[];
+  updateMany: UpdateManySubscriber<TDocType>[];
+  deleteOne: DeleteOneSubscriber[];
+  deleteList: DeleteListSubscriber[];
+};
+
+export type RepoListeners<TDocType extends BaseDocument> = {
+  insertNew?: InsertNewSubscriber<TDocType>;
+  insertMany?: InsertManySubscriber<TDocType>;
+  updateOne?: UpdateOneSubscriber<TDocType>;
+  updateMany?: UpdateManySubscriber<TDocType>;
+  deleteOne?: DeleteOneSubscriber;
+  deleteList?: DeleteListSubscriber;
+};
+
+export type InsertNewSubscriber<TDocType extends BaseDocument> = (
+  doc: TDocType
+) => Promise<void>;
+
+export type InsertManySubscriber<TDocType extends BaseDocument> = (
+  docs: TDocType[]
+) => Promise<void>;
+
+export type UpdateOneSubscriber<TDocType extends BaseDocument> = (
+  doc: Partial<TDocType>
+) => Promise<void>;
+
+export type UpdateManySubscriber<TDocType extends BaseDocument> = (
+  docs: Partial<TDocType>[]
+) => Promise<void>;
+
+export type DeleteOneSubscriber = (docId: ObjectId) => Promise<void>;
+
+export type DeleteListSubscriber = (docIds: ObjectId[]) => Promise<void>;
+
+/**
+ * A subscription service that allows repositories to subscribe to events
+ * that happen in other repositories.
+ */
+export default class RepoSubscriptionService {
+  /**
+   * A utility method to get a default empty set of subscribers for a
+   * repository.
+   */
+  static getDefaultSubscribers<
+    TDocType extends BaseDocument
+  >(): RepoSubscribers<TDocType> {
+    return {
+      insertNew: [],
+      insertMany: [],
+      updateOne: [],
+      updateMany: [],
+      deleteOne: [],
+      deleteList: []
+    };
+  }
+}

package/lib/tests/globalTestVariables.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A random series of characters for tests to help identify test users.
+ */
+export declare const TEST_USER_NAME_PREFIX = "lkahwsetpiohweat";
+//# sourceMappingURL=globalTestVariables.d.ts.map

package/lib/tests/globalTestVariables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalTestVariables.d.ts","sourceRoot":"./src/","sources":["tests/globalTestVariables.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,qBAAqB,qBAAqB,CAAC"}

package/lib/tests/globalTestVariables.js

@@ -0,0 +1,5 @@
+/**
+ * A random series of characters for tests to help identify test users.
+ */
+export const TEST_USER_NAME_PREFIX = 'lkahwsetpiohweat';
+//# sourceMappingURL=globalTestVariables.js.map

package/lib/tests/globalTestVariables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalTestVariables.js","sourceRoot":"./src/","sources":["tests/globalTestVariables.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC"}

package/lib/tests/globalTestVariables.ts

@@ -0,0 +1,4 @@
+/**
+ * A random series of characters for tests to help identify test users.
+ */
+export const TEST_USER_NAME_PREFIX = 'lkahwsetpiohweat';

package/lib/tests/repositories/BaseRepository.spec.ts

@@ -0,0 +1,61 @@
+import {
+  DashboardTask,
+  DashboardUserConfig,
+  User
+} from '@aneuhold/core-ts-db-lib';
+import crypto from 'crypto';
+import { afterAll, expect, it } from 'vitest';
+import UserRepository from '../../repositories/common/UserRepository.js';
+import DashboardTaskRepository from '../../repositories/dashboard/DashboardTaskRepository.js';
+import DashboardUserConfigRepository from '../../repositories/dashboard/DashboardUserConfigRepository.js';
+import DocumentDb from '../../util/DocumentDb.js';
+import { cleanupDoc, getTestUserName } from '../testsUtil.js';
+
+it('can create a new document and delete it', async () => {
+  const userRepository = UserRepository.getRepo();
+  const newUser = new User(getTestUserName());
+  const createResult = await userRepository.insertNew(newUser);
+  expect(createResult).toBeTruthy();
+
+  await cleanupDoc(userRepository, newUser);
+}, 10000);
+
+// -- Manual Database Operations Section -- //
+
+it.skip('can add a new test user', async () => {
+  const userRepository = UserRepository.getRepo();
+  const newUser = new User('someUser');
+  newUser.auth.password = crypto.randomUUID();
+  const createResult = await userRepository.insertNew(newUser);
+  expect(createResult).toBeTruthy();
+});
+
+it.skip('can create a dashboard config for a user', async () => {
+  const userRepo = UserRepository.getRepo();
+  const user = await userRepo.get({ userName: 'usernameHere' });
+  expect(user).toBeTruthy();
+
+  if (user) {
+    const configRepo = DashboardUserConfigRepository.getRepo();
+    const newConfig = new DashboardUserConfig(user._id);
+    newConfig.enableDevMode = true;
+    await configRepo.insertNew(newConfig);
+  }
+});
+
+it.skip(`can create a new task for a user`, async () => {
+  const userRepo = UserRepository.getRepo();
+  const user = await userRepo.get({ userName: 'usernameHere' });
+  expect(user).toBeTruthy();
+
+  if (user) {
+    const taskRepo = DashboardTaskRepository.getRepo();
+    const newTask = new DashboardTask(user._id);
+    newTask.title = 'Test Task';
+    await taskRepo.insertNew(newTask);
+  }
+});
+
+afterAll(async () => {
+  return DocumentDb.closeDbConnection();
+});

package/lib/tests/repositories/common/UserRepository.spec.ts

@@ -0,0 +1,113 @@
+import { User } from '@aneuhold/core-ts-db-lib';
+import { afterAll, describe, expect, it } from 'vitest';
+import ApiKeyRepository from '../../../repositories/common/ApiKeyRepository.js';
+import UserRepository from '../../../repositories/common/UserRepository.js';
+import DocumentDb from '../../../util/DocumentDb.js';
+import { cleanupDoc, expectToThrow, getTestUserName } from '../../testsUtil.js';
+
+const userRepo = UserRepository.getRepo();
+
+describe('Create operations', () => {
+  it('can create a new user', async () => {
+    const newUser = new User(getTestUserName());
+    const insertResult = await userRepo.insertNew(newUser);
+    expect(insertResult).toBeTruthy();
+
+    await cleanupDoc(userRepo, newUser);
+  });
+
+  it('can create a new user and the new user gets an API key', async () => {
+    const newUser = new User(getTestUserName());
+    const insertResult = await userRepo.insertNew(newUser);
+    expect(insertResult).toBeTruthy();
+    const apiKey = await ApiKeyRepository.getRepo().get({
+      userId: newUser._id
+    });
+    expect(apiKey).toBeTruthy();
+
+    await cleanupDoc(userRepo, newUser);
+    const apiKeyThatShouldNotExist = await ApiKeyRepository.getRepo().get({
+      userId: newUser._id
+    });
+    expect(apiKeyThatShouldNotExist).toBeFalsy();
+  });
+
+  it('throws if the username is a duplicate username', async () => {
+    const duplicateUserName = getTestUserName();
+    const newUser1 = new User(duplicateUserName);
+    const newUser2 = new User(duplicateUserName);
+
+    const insertResult = await userRepo.insertNew(newUser1);
+    expect(insertResult).toBeTruthy();
+
+    await expectToThrow(async () => {
+      await userRepo.insertNew(newUser2);
+    });
+
+    await cleanupDoc(userRepo, newUser1);
+  });
+});
+
+describe('Update operations', () => {
+  it('succeeds in updating the username if the username doesnt already exist', async () => {
+    const userName1 = getTestUserName();
+    const userName2 = getTestUserName();
+    const newUser = new User(userName1);
+
+    // Insert the user
+    const insertResult = await userRepo.insertNew(newUser);
+    expect(insertResult).toBeTruthy();
+
+    // Try to update the user
+    newUser.userName = userName2;
+    const updateResult = await userRepo.update(newUser);
+    expect(updateResult.acknowledged).toBeTruthy();
+
+    await cleanupDoc(userRepo, newUser);
+  });
+
+  it('throws if no id is defined', async () => {
+    const newUser = new User(getTestUserName()) as Partial<User>;
+    delete newUser._id;
+    await expectToThrow(async () => {
+      await userRepo.update(newUser);
+    });
+  });
+
+  it('throws if the username is updated and already exists', async () => {
+    const userName1 = getTestUserName();
+    const userName2 = getTestUserName();
+    const newUser = new User(userName1);
+    const userWithOtherUserName = new User(userName2);
+
+    // Insert the users
+    const insertResult1 = await userRepo.insertNew(newUser);
+    expect(insertResult1).toBeTruthy();
+    const insertResult2 = await userRepo.insertNew(userWithOtherUserName);
+    expect(insertResult2).toBeTruthy();
+
+    // Try to update the first user
+    newUser.userName = userName2;
+    await expectToThrow(async () => {
+      await userRepo.update(newUser);
+    });
+
+    await Promise.all([
+      cleanupDoc(userRepo, newUser),
+      cleanupDoc(userRepo, userWithOtherUserName)
+    ]);
+  });
+
+  it('throws if the user doesnt exist', async () => {
+    const newUser = new User(getTestUserName());
+
+    // Try to update the user
+    await expectToThrow(async () => {
+      await userRepo.update(newUser);
+    });
+  });
+});
+
+afterAll(async () => {
+  await DocumentDb.closeDbConnection();
+});

package/lib/tests/repositories/dashboard/NonogramKatanaItemRepository.spec.ts

@@ -0,0 +1,55 @@
+import {
+  NonogramKatanaItem,
+  NonogramKatanaItemName,
+  User
+} from '@aneuhold/core-ts-db-lib';
+import crypto from 'crypto';
+import { describe, expect, it } from 'vitest';
+import UserRepository from '../../../repositories/common/UserRepository.js';
+import DashboardNonogramKatanaItemRepository from '../../../repositories/dashboard/DashboardNonogramKatanaItemRepository.js';
+import { cleanupDoc, getTestUserName } from '../../testsUtil.js';
+
+const userRepo = UserRepository.getRepo();
+const itemRepo = DashboardNonogramKatanaItemRepository.getRepo();
+
+describe('Create operations', () => {
+  it('can create a new nonogram katana item', async () => {
+    const newUser = await createNewTestUser();
+    const newItem = new NonogramKatanaItem(
+      newUser._id,
+      NonogramKatanaItemName.Anchor
+    );
+    const insertResult = await itemRepo.insertNew(newItem);
+    expect(insertResult).toBeTruthy();
+
+    const newItemFromDb = await itemRepo.get({ _id: newItem._id });
+    expect(newItemFromDb).toBeTruthy();
+
+    await cleanupDoc(userRepo, newUser);
+  });
+});
+
+/**
+ * Deletes all Nonogram Katana Items!
+ *
+ * To just do a cleanup, put `only` after `it`. So `it.only('can delete all items'`
+ */
+it.skip('can delete all items', async () => {
+  const result = await itemRepo.deleteAll();
+  expect(result.acknowledged).toBeTruthy();
+});
+
+/**
+ * Create a new test user
+ *
+ * @returns The new user
+ */
+async function createNewTestUser() {
+  const newUser = new User(
+    getTestUserName(`${crypto.randomUUID()}nonogramKatanaItemTest`)
+  );
+  newUser.projectAccess.dashboard = true;
+  const insertResult = await userRepo.insertNew(newUser);
+  expect(insertResult).toBeTruthy();
+  return newUser;
+}

package/lib/tests/repositories/dashboard/NonogramKatanaUpgradeRepository.spec.ts

@@ -0,0 +1,14 @@
+import { expect, it } from 'vitest';
+import DashboardNonogramKatanaUpgradeRepository from '../../../repositories/dashboard/DashboardNonogramKatanaUpgradeRepository.js';
+
+const upgradeRepo = DashboardNonogramKatanaUpgradeRepository.getRepo();
+
+/**
+ * Deletes all Nonogram Katana Upgrades!
+ *
+ * To just do a cleanup, put `only` after `it`. So `it.only('can delete all upgrades'`
+ */
+it.skip('can delete all upgrades', async () => {
+  const result = await upgradeRepo.deleteAll();
+  expect(result.acknowledged).toBeTruthy();
+});

package/lib/tests/repositories/dashboard/TaskRepository.spec.ts

@@ -0,0 +1,101 @@
+import { DashboardTask, User } from '@aneuhold/core-ts-db-lib';
+import crypto from 'crypto';
+import { afterAll, describe, expect, it } from 'vitest';
+import UserRepository from '../../../repositories/common/UserRepository.js';
+import DashboardTaskRepository from '../../../repositories/dashboard/DashboardTaskRepository.js';
+import DashboardUserConfigRepository from '../../../repositories/dashboard/DashboardUserConfigRepository.js';
+import DocumentDb from '../../../util/DocumentDb.js';
+import { cleanupDoc, getTestUserName } from '../../testsUtil.js';
+
+const userRepo = UserRepository.getRepo();
+const taskRepo = DashboardTaskRepository.getRepo();
+
+describe('Create operations', () => {
+  it('can create a new task', async () => {
+    const newUser = await createNewTestUser();
+    const newTask = new DashboardTask(newUser._id);
+    const insertResult = await taskRepo.insertNew(newTask);
+    expect(insertResult).toBeTruthy();
+    const insertedTask = await taskRepo.get({ _id: newTask._id });
+    expect(insertedTask).toBeTruthy();
+    expect(typeof insertedTask?.createdDate).toBe('object');
+    if (!insertedTask) {
+      return;
+    }
+
+    await cleanupDoc(userRepo, newUser);
+    // Task should be deleted
+    const deletedTask = await taskRepo.get({ _id: newTask._id });
+    expect(deletedTask).toBeFalsy();
+  });
+});
+
+describe('Get operations', () => {
+  it('can get a set of tasks for a user, without any tasks from other users', async () => {
+    const newUser = await createNewTestUser();
+    const newTask = new DashboardTask(newUser._id);
+    const insertResult = await taskRepo.insertNew(newTask);
+    expect(insertResult).toBeTruthy();
+
+    const otherUser = await createNewTestUser();
+    const otherUserTask = new DashboardTask(otherUser._id);
+    const insertResult2 = await taskRepo.insertNew(otherUserTask);
+    expect(insertResult2).toBeTruthy();
+
+    const tasks = await taskRepo.getAllForUser(newUser._id);
+    expect(tasks.length).toBe(1);
+    expect(tasks[0]._id.toString()).toEqual(newTask._id.toString());
+
+    await cleanupDoc(userRepo, newUser);
+    await cleanupDoc(userRepo, otherUser);
+  });
+
+  it('can get a set of tasks for a user, including tasks shared with that user', async () => {
+    const configRepo = DashboardUserConfigRepository.getRepo();
+    const newUser = await createNewTestUser();
+    const newTask = new DashboardTask(newUser._id);
+    const insertResult = await taskRepo.insertNew(newTask);
+    expect(insertResult).toBeTruthy();
+
+    const otherUser = await createNewTestUser();
+    const otherUserTask = new DashboardTask(otherUser._id);
+
+    // Add other user as collaborator
+    const otherUserConfig = await configRepo.get({ userId: otherUser._id });
+    expect(otherUserConfig).toBeTruthy();
+    if (!otherUserConfig) {
+      return;
+    }
+    otherUserConfig.collaborators.push(newUser._id);
+    await configRepo.update(otherUserConfig);
+    otherUserTask.sharedWith.push(newUser._id);
+    const insertResult2 = await taskRepo.insertNew(otherUserTask);
+    expect(insertResult2).toBeTruthy();
+
+    const tasks = await taskRepo.getAllForUser(newUser._id);
+    expect(tasks.length).toBe(2);
+    expect(tasks[0]._id.toString()).toEqual(newTask._id.toString());
+    expect(tasks[1]._id.toString()).toEqual(otherUserTask._id.toString());
+
+    await cleanupDoc(userRepo, newUser);
+    await cleanupDoc(userRepo, otherUser);
+  });
+});
+
+afterAll(async () => {
+  return DocumentDb.closeDbConnection();
+});
+
+/**
+ * Create a new test user
+ *
+ * @returns The new user
+ */
+async function createNewTestUser(): Promise<User> {
+  const newUser = new User(
+    getTestUserName(`${crypto.randomUUID()}dashboardTaskTest`)
+  );
+  const insertResult = await userRepo.insertNew(newUser);
+  expect(insertResult).toBeTruthy();
+  return newUser;
+}

package/lib/tests/repositories/dashboard/UserConfigRepository.spec.ts

@@ -0,0 +1,155 @@
+import { User } from '@aneuhold/core-ts-db-lib';
+import crypto from 'crypto';
+import { afterAll, describe, expect, it } from 'vitest';
+import UserRepository from '../../../repositories/common/UserRepository.js';
+import DashboardUserConfigRepository from '../../../repositories/dashboard/DashboardUserConfigRepository.js';
+import DocumentDb from '../../../util/DocumentDb.js';
+import { cleanupDoc, getTestUserName } from '../../testsUtil.js';
+
+const userRepo = UserRepository.getRepo();
+const configRepo = DashboardUserConfigRepository.getRepo();
+
+describe('Create operations', () => {
+  it('can create a new user config', async () => {
+    // User configs are created automatically when a new user is created
+    const newUser = await createNewTestUser();
+    const newConfig = await configRepo.get({ userId: newUser._id });
+    expect(newConfig).toBeTruthy();
+    if (!newConfig) {
+      return;
+    }
+
+    await cleanupDoc(userRepo, newUser);
+  });
+});
+
+describe('Update operations', () => {
+  it('can update an existing user config', async () => {
+    const newUser = await createNewTestUser();
+    const newConfig = await configRepo.get({ userId: newUser._id });
+    expect(newConfig).toBeTruthy();
+    if (!newConfig) {
+      return;
+    }
+
+    newConfig.enableDevMode = true;
+    await configRepo.update(newConfig);
+    const updatedConfig = await configRepo.get({ _id: newConfig._id });
+    expect(updatedConfig?.enableDevMode).toBe(true);
+
+    await cleanupDoc(userRepo, newUser);
+  });
+
+  it('can add collaborators to an existing user config', async () => {
+    const newUser = await createNewTestUser();
+    const newConfig = await configRepo.get({ userId: newUser._id });
+    expect(newConfig).toBeTruthy();
+    if (!newConfig) {
+      return;
+    }
+
+    const newCollaborator = await createNewTestUser();
+    newConfig.collaborators.push(newCollaborator._id);
+    await configRepo.update(newConfig);
+    let updatedConfig = await configRepo.get({ _id: newConfig._id });
+    expect(updatedConfig?.collaborators.map((x) => x.toString())).toContain(
+      newCollaborator._id.toString()
+    );
+
+    await cleanupDoc(userRepo, newCollaborator);
+    // Ensure the collaborator is deleted automatically when the user is deleted
+    updatedConfig = await configRepo.get({ _id: newConfig._id });
+    expect(updatedConfig?.collaborators.map((x) => x.toString())).not.toContain(
+      newCollaborator._id.toString()
+    );
+
+    await cleanupDoc(userRepo, newUser);
+  });
+
+  /**
+   * Pretty huge test that ensures the full range of functionality is there
+   * for collaborators.
+   */
+  it('correctly updates the collaborators for groups of users', async () => {
+    const newUser1 = await createNewTestUser();
+    const newConfig1 = await configRepo.get({ userId: newUser1._id });
+    expect(newConfig1).toBeTruthy();
+    if (!newConfig1) {
+      return;
+    }
+
+    const newUser2 = await createNewTestUser();
+    const newConfig2 = await configRepo.get({ userId: newUser2._id });
+    expect(newConfig2).toBeTruthy();
+    if (!newConfig2) {
+      return;
+    }
+
+    const newUser3 = await createNewTestUser();
+    const newConfig3 = await configRepo.get({ userId: newUser3._id });
+    expect(newConfig3).toBeTruthy();
+    if (!newConfig3) {
+      return;
+    }
+
+    newConfig1.collaborators.push(newUser2._id);
+    const updateResult1 = await configRepo.update(newConfig1);
+    expect(updateResult1).toBeTruthy();
+    let updatedConfig2 = await configRepo.get({ _id: newConfig2._id });
+    expect(updatedConfig2?.collaborators.map((x) => x.toString())).toContain(
+      newUser1._id.toString()
+    );
+
+    newConfig3.collaborators.push(newUser1._id, newUser2._id);
+    let updateResult3 = await configRepo.update(newConfig3);
+    expect(updateResult3).toBeTruthy();
+    let updatedConfig1 = await configRepo.get({ _id: newConfig1._id });
+    expect(updatedConfig1?.collaborators.map((x) => x.toString())).toContain(
+      newUser3._id.toString()
+    );
+    expect(updatedConfig1?.collaborators.map((x) => x.toString())).toContain(
+      newUser2._id.toString()
+    );
+
+    newConfig3.collaborators = [];
+    updateResult3 = await configRepo.update(newConfig3);
+    expect(updateResult3).toBeTruthy();
+    updatedConfig1 = await configRepo.get({ _id: newConfig1._id });
+    expect(
+      updatedConfig1?.collaborators.map((x) => x.toString())
+    ).toContainEqual(newUser2._id.toString());
+    expect(
+      updatedConfig1?.collaborators.map((x) => x.toString())
+    ).not.toContain(newUser3._id.toString());
+    updatedConfig2 = await configRepo.get({ _id: newConfig2._id });
+    expect(
+      updatedConfig2?.collaborators.map((x) => x.toString())
+    ).toContainEqual(newUser1._id.toString());
+    expect(
+      updatedConfig2?.collaborators.map((x) => x.toString())
+    ).not.toContain(newUser3._id.toString());
+
+    await cleanupDoc(userRepo, newUser1);
+    await cleanupDoc(userRepo, newUser2);
+    await cleanupDoc(userRepo, newUser3);
+  }, 10000);
+});
+
+afterAll(async () => {
+  return DocumentDb.closeDbConnection();
+});
+
+/**
+ * Create a new test user
+ *
+ * @returns The new user
+ */
+async function createNewTestUser() {
+  const newUser = new User(
+    getTestUserName(`${crypto.randomUUID()}userconfigtest`)
+  );
+  newUser.projectAccess.dashboard = true;
+  const insertResult = await userRepo.insertNew(newUser);
+  expect(insertResult).toBeTruthy();
+  return newUser;
+}

package/lib/tests/testsUtil.d.ts

@@ -1,18 +1,34 @@
 import { BaseDocument } from '@aneuhold/core-ts-db-lib';
-import BaseRepository from '../repositories/BaseRepository';
+import BaseRepository from '../repositories/BaseRepository.js';
 /**
- * A random series of characters for tests to help identify test users.
+ * Asserts that the provided asynchronous function throws an error.
+ *
+ * @param func - The asynchronous function expected to throw an error.
  */
-export declare const TEST_USER_NAME_PREFIX = "lkahwsetpiohweat";
 export declare function expectToThrow(func: () => Promise<void>): Promise<void>;
 /**
  * Gets a test user name with a standardized prefix so that they can all be
  * identified and deleted if anything goes wrong in the tests.
+ *
+ * @param username - The username to use as a base for the test user name.
+ * @returns The test user name.
  */
 export declare function getTestUserName(username?: string): string;
 /**
- * Removes the provided doc from the DB
+ * Cleans up a document by deleting it from the repository and verifying its deletion.
+ *
+ * @template TDocType - The type of the document extending {@link BaseDocument}.
+ * @param repo - The repository from which the document will be deleted.
+ * @param doc - The document to be deleted.
  */
 export declare function cleanupDoc<TDocType extends BaseDocument>(repo: BaseRepository<TDocType>, doc: TDocType): Promise<void>;
+/**
+ * Cleans up the specified documents from the repository.
+ *
+ * @template TDocType - The type of the documents.
+ * @param repo - The repository from which to delete the documents.
+ * @param docs - The documents to be deleted.
+ * @returns A promise that resolves when the cleanup is complete.
+ */
 export declare function cleanupDocs<TDocType extends BaseDocument>(repo: BaseRepository<TDocType>, docs: TDocType[]): Promise<void>;
 //# sourceMappingURL=testsUtil.d.ts.map

package/lib/tests/testsUtil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testsUtil.d.ts","sourceRoot":"","sources":["../../src/tests/testsUtil.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,OAAO,cAAc,MAAM,gCAAgC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,iBAQ5D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,UAGhD;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,QAAQ,SAAS,YAAY,EAC5D,IAAI,EAAE,cAAc,CAAC,QAAQ,CAAC,EAC9B,GAAG,EAAE,QAAQ,iBAMd;AAED,wBAAsB,WAAW,CAAC,QAAQ,SAAS,YAAY,EAC7D,IAAI,EAAE,cAAc,CAAC,QAAQ,CAAC,EAC9B,IAAI,EAAE,QAAQ,EAAE,iBAOjB"}
+{"version":3,"file":"testsUtil.d.ts","sourceRoot":"./src/","sources":["tests/testsUtil.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGxD,OAAO,cAAc,MAAM,mCAAmC,CAAC;AAG/D;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,iBAQ5D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;;;;;GAMG;AACH,wBAAsB,UAAU,CAAC,QAAQ,SAAS,YAAY,EAC5D,IAAI,EAAE,cAAc,CAAC,QAAQ,CAAC,EAC9B,GAAG,EAAE,QAAQ,iBAMd;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,QAAQ,SAAS,YAAY,EAC7D,IAAI,EAAE,cAAc,CAAC,QAAQ,CAAC,EAC9B,IAAI,EAAE,QAAQ,EAAE,iBAOjB"}