joist-test-utils 2.3.0 → 2.4.0-next.2

package/build/run.js

@@ -1,96 +1,72 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = run;
-exports.makeRun = makeRun;
-exports.runEach = runEach;
-exports.makeRunEach = makeRunEach;
-exports.newContext = newContext;
-const joist_core_1 = require("joist-core");
-const joist_utils_1 = require("joist-utils");
-const RunPlugin_1 = require("./RunPlugin");
-// Used to allow non-mutating run... calls to be run in parallel.
+import { RunPlugin } from "./RunPlugin.js";
+import "./context.js";
+import { EntityManager, isEntity } from "joist-core";
+import { fail } from "joist-utils";
+//#region src/run.ts
 let flushPromise;
 let flushEm;
 /** Runs the `fn` in a dedicated / non-test Unit of Work . */
 async function run(ctx, fn, contextFn = newContext) {
-    const { em } = ctx;
-    // Ensure any test data we've set up is flushed.  If another invocation of `run` is already flushing, then we can just
-    // wait on its promise.  Otherwise, we will get flushLock errors.
-    try {
-        flushPromise ??= em.flush();
-        flushEm ??= em;
-        if (flushEm !== em)
-            (0, joist_utils_1.fail)("cannot use run in parallel with multiple entity managers");
-        await flushPromise;
-    }
-    finally {
-        flushPromise = undefined;
-        flushEm = undefined;
-    }
-    const newCtx = await contextFn(ctx);
-    const plugin = new RunPlugin_1.RunPlugin(em);
-    newCtx.em.addPlugin(plugin);
-    const result = await fn(newCtx);
-    // We expect `fn` (i.e. a resolver) to do its own UoW management, so don't flush.
-    return mapResultToOriginalEm(em, result);
+	const { em } = ctx;
+	try {
+		flushPromise ??= em.flush();
+		flushEm ??= em;
+		if (flushEm !== em) fail("cannot use run in parallel with multiple entity managers");
+		await flushPromise;
+	} finally {
+		flushPromise = void 0;
+		flushEm = void 0;
+	}
+	const newCtx = await contextFn(ctx);
+	const plugin = new RunPlugin(em);
+	newCtx.em.addPlugin(plugin);
+	return mapResultToOriginalEm(em, await fn(newCtx));
 }
 /** Creates a `run` with a custom `newContext` method. */
 function makeRun(contextFn) {
-    return (ctx, fn) => run(ctx, fn, contextFn);
+	return (ctx, fn) => run(ctx, fn, contextFn);
 }
 /** Runs the `fn` in a dedicated / non-test Unit of Work for each value in `values */
 async function runEach(ctx, valuesFn, fn, contextFn = newContext) {
-    const { em } = ctx;
-    // Ensure any test data we've setup is flushed
-    await em.flush();
-    const plugin = new RunPlugin_1.RunPlugin(em);
-    const results = await Promise.all(valuesFn().map(async (value) => {
-        const newCtx = await contextFn(ctx);
-        newCtx.em.addPlugin(plugin);
-        return fn(newCtx, value);
-    }));
-    return mapResultToOriginalEm(em, results);
+	const { em } = ctx;
+	await em.flush();
+	const plugin = new RunPlugin(em);
+	return mapResultToOriginalEm(em, await Promise.all(valuesFn().map(async (value) => {
+		const newCtx = await contextFn(ctx);
+		newCtx.em.addPlugin(plugin);
+		return fn(newCtx, value);
+	})));
 }
 /** Creates a `runEach` with a custom `newContext` method. */
 function makeRunEach(contextFn) {
-    return (ctx, valuesFn, fn) => runEach(ctx, valuesFn, fn, contextFn);
+	return (ctx, valuesFn, fn) => runEach(ctx, valuesFn, fn, contextFn);
 }
 /** A default `newContext` that assumes `ctx.em` is where the `EntityManager` lives. */
 function newContext(ctx) {
-    const { em } = ctx;
-    const newCtx = { ...ctx };
-    const newEm = new joist_core_1.EntityManager(newCtx, em.driver);
-    Object.assign(newCtx, { em: newEm });
-    return newCtx;
+	const { em } = ctx;
+	const newCtx = { ...ctx };
+	const newEm = new EntityManager(newCtx, em.driver);
+	Object.assign(newCtx, { em: newEm });
+	return newCtx;
 }
-/* Returns a copy of `result` with all entities replaced with their instance from the original `em`.  We assume that
- * RunPlugin has been installed prior to this call, so any entities we encounter should be present in both ems. */
 function mapResultToOriginalEm(em, result) {
-    if ((0, joist_core_1.isEntity)(result)) {
-        return (em.findExistingInstance(result.idTagged) ?? (0, joist_utils_1.fail)(`Could not find entity ${result.idTagged}`));
-    }
-    else if (Array.isArray(result)) {
-        return result.map((r) => mapResultToOriginalEm(em, r));
-    }
-    else if (result instanceof Map) {
-        const map = new Map();
-        result
-            .entries()
-            .forEach(([key, value]) => map.set(mapResultToOriginalEm(em, key), mapResultToOriginalEm(em, value)));
-        return map;
-    }
-    else if (result instanceof Set) {
-        const set = new Set();
-        result.forEach((r) => set.add(mapResultToOriginalEm(em, r)));
-        return set;
-    }
-    else if (typeof result === "object" && result?.constructor === Object) {
-        const obj = {};
-        Object.entries(result).forEach(([key, value]) => (obj[key] = mapResultToOriginalEm(em, value)));
-        return obj;
-    }
-    else {
-        return result;
-    }
+	if (isEntity(result)) return em.findExistingInstance(result.idTagged) ?? fail(`Could not find entity ${result.idTagged}`);
+	else if (Array.isArray(result)) return result.map((r) => mapResultToOriginalEm(em, r));
+	else if (result instanceof Map) {
+		const map = /* @__PURE__ */ new Map();
+		result.entries().forEach(([key, value]) => map.set(mapResultToOriginalEm(em, key), mapResultToOriginalEm(em, value)));
+		return map;
+	} else if (result instanceof Set) {
+		const set = /* @__PURE__ */ new Set();
+		result.forEach((r) => set.add(mapResultToOriginalEm(em, r)));
+		return set;
+	} else if (typeof result === "object" && result?.constructor === Object) {
+		const obj = {};
+		Object.entries(result).forEach(([key, value]) => obj[key] = mapResultToOriginalEm(em, value));
+		return obj;
+	} else return result;
 }
+//#endregion
+export { makeRun, makeRunEach, newContext, run, runEach };
+
 //# sourceMappingURL=run.js.map

package/build/run.js.map

@@ -1 +1 @@
-{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"run.js","names":[],"sources":["../src/run.ts"],"sourcesContent":["import { EntityManager, isEntity } from \"joist-core\";\nimport { fail } from \"joist-utils\";\n\nimport { type Context } from \"./context.ts\";\nimport { RunPlugin } from \"./RunPlugin.ts\";\n\ntype MaybePromise<T> = T | Promise<T>;\n\nexport type ContextFn<C> = (ctx: C) => MaybePromise<C>;\n\n// Used to allow non-mutating run... calls to be run in parallel.\nlet flushPromise: Promise<any> | undefined;\nlet flushEm: EntityManager | undefined;\n\n/** Runs the `fn` in a dedicated / non-test Unit of Work . */\nexport async function run<C extends Context, T>(\n  ctx: C,\n  fn: (ctx: C) => MaybePromise<T>,\n  contextFn: ContextFn<C> = newContext,\n): Promise<T> {\n  const { em } = ctx;\n  // Ensure any test data we've set up is flushed.  If another invocation of `run` is already flushing, then we can just\n  // wait on its promise.  Otherwise, we will get flushLock errors.\n  try {\n    flushPromise ??= em.flush();\n    flushEm ??= em;\n    if (flushEm !== em) fail(\"cannot use run in parallel with multiple entity managers\");\n    await flushPromise;\n  } finally {\n    flushPromise = undefined;\n    flushEm = undefined;\n  }\n  const newCtx = await contextFn(ctx);\n  const plugin = new RunPlugin(em);\n  newCtx.em.addPlugin(plugin);\n  const result = await fn(newCtx);\n  // We expect `fn` (i.e. a resolver) to do its own UoW management, so don't flush.\n  return mapResultToOriginalEm(em, result);\n}\n\n/** Creates a `run` with a custom `newContext` method. */\nexport function makeRun<C extends Context>(\n  contextFn: ContextFn<C>,\n): <T>(ctx: C, fn: (ctx: C) => MaybePromise<T>) => Promise<T> {\n  return (ctx, fn) => run(ctx, fn, contextFn);\n}\n\n/** Runs the `fn` in a dedicated / non-test Unit of Work for each value in `values */\nexport async function runEach<C extends Context, T, U>(\n  ctx: C,\n  valuesFn: () => U[],\n  fn: (ctx: C, value: U) => MaybePromise<T>,\n  contextFn: ContextFn<C> = newContext,\n): Promise<T[]> {\n  const { em } = ctx;\n  // Ensure any test data we've setup is flushed\n  await em.flush();\n  const plugin = new RunPlugin(em);\n  const results = await Promise.all(\n    valuesFn().map(async (value) => {\n      const newCtx = await contextFn(ctx);\n      newCtx.em.addPlugin(plugin);\n      return fn(newCtx, value);\n    }),\n  );\n  return mapResultToOriginalEm(em, results);\n}\n\n/** Creates a `runEach` with a custom `newContext` method. */\nexport function makeRunEach<C extends Context>(\n  contextFn: ContextFn<C>,\n): <T, U>(ctx: C, valuesFn: () => U[], fn: (ctx: C, value: U) => MaybePromise<T>) => Promise<T[]> {\n  return (ctx, valuesFn, fn) => runEach(ctx, valuesFn, fn, contextFn);\n}\n\n/** A default `newContext` that assumes `ctx.em` is where the `EntityManager` lives. */\nexport function newContext<C extends Context>(ctx: C): C {\n  const { em } = ctx;\n  const newCtx = { ...ctx };\n  const newEm = new EntityManager(newCtx, em.driver);\n  Object.assign(newCtx, { em: newEm });\n  return newCtx;\n}\n\n/* Returns a copy of `result` with all entities replaced with their instance from the original `em`.  We assume that\n * RunPlugin has been installed prior to this call, so any entities we encounter should be present in both ems. */\nfunction mapResultToOriginalEm<R>(em: EntityManager, result: R): R {\n  if (isEntity(result)) {\n    return (em.findExistingInstance(result.idTagged) ?? fail(`Could not find entity ${result.idTagged}`)) as R;\n  } else if (Array.isArray(result)) {\n    return result.map((r) => mapResultToOriginalEm(em, r)) as any;\n  } else if (result instanceof Map) {\n    const map = new Map<any, any>();\n    result\n      .entries()\n      .forEach(([key, value]) => map.set(mapResultToOriginalEm(em, key), mapResultToOriginalEm(em, value)));\n    return map as R;\n  } else if (result instanceof Set) {\n    const set = new Set<any>();\n    result.forEach((r) => set.add(mapResultToOriginalEm(em, r)));\n    return set as R;\n  } else if (typeof result === \"object\" && result?.constructor === Object) {\n    const obj = {} as any;\n    Object.entries(result).forEach(([key, value]: [string, any]) => (obj[key] = mapResultToOriginalEm(em, value)));\n    return obj;\n  } else {\n    return result;\n  }\n}\n"],"mappings":";;;;;AAWA,IAAI;AACJ,IAAI;;AAGJ,eAAsB,IACpB,KACA,IACA,YAA0B,YACd;CACZ,MAAM,EAAE,OAAO;CAGf,IAAI;EACF,iBAAiB,GAAG,MAAM;EAC1B,YAAY;EACZ,IAAI,YAAY,IAAI,KAAK,0DAA0D;EACnF,MAAM;CACR,UAAU;EACR,eAAe,KAAA;EACf,UAAU,KAAA;CACZ;CACA,MAAM,SAAS,MAAM,UAAU,GAAG;CAClC,MAAM,SAAS,IAAI,UAAU,EAAE;CAC/B,OAAO,GAAG,UAAU,MAAM;CAG1B,OAAO,sBAAsB,IAAI,MAFZ,GAAG,MAAM,CAES;AACzC;;AAGA,SAAgB,QACd,WAC4D;CAC5D,QAAQ,KAAK,OAAO,IAAI,KAAK,IAAI,SAAS;AAC5C;;AAGA,eAAsB,QACpB,KACA,UACA,IACA,YAA0B,YACZ;CACd,MAAM,EAAE,OAAO;CAEf,MAAM,GAAG,MAAM;CACf,MAAM,SAAS,IAAI,UAAU,EAAE;CAQ/B,OAAO,sBAAsB,IAAI,MAPX,QAAQ,IAC5B,SAAS,CAAC,CAAC,IAAI,OAAO,UAAU;EAC9B,MAAM,SAAS,MAAM,UAAU,GAAG;EAClC,OAAO,GAAG,UAAU,MAAM;EAC1B,OAAO,GAAG,QAAQ,KAAK;CACzB,CAAC,CACH,CACwC;AAC1C;;AAGA,SAAgB,YACd,WACgG;CAChG,QAAQ,KAAK,UAAU,OAAO,QAAQ,KAAK,UAAU,IAAI,SAAS;AACpE;;AAGA,SAAgB,WAA8B,KAAW;CACvD,MAAM,EAAE,OAAO;CACf,MAAM,SAAS,EAAE,GAAG,IAAI;CACxB,MAAM,QAAQ,IAAI,cAAc,QAAQ,GAAG,MAAM;CACjD,OAAO,OAAO,QAAQ,EAAE,IAAI,MAAM,CAAC;CACnC,OAAO;AACT;AAIA,SAAS,sBAAyB,IAAmB,QAAc;CACjE,IAAI,SAAS,MAAM,GACjB,OAAQ,GAAG,qBAAqB,OAAO,QAAQ,KAAK,KAAK,yBAAyB,OAAO,UAAU;MAC9F,IAAI,MAAM,QAAQ,MAAM,GAC7B,OAAO,OAAO,KAAK,MAAM,sBAAsB,IAAI,CAAC,CAAC;MAChD,IAAI,kBAAkB,KAAK;EAChC,MAAM,sBAAM,IAAI,IAAc;EAC9B,OACG,QAAQ,CAAC,CACT,SAAS,CAAC,KAAK,WAAW,IAAI,IAAI,sBAAsB,IAAI,GAAG,GAAG,sBAAsB,IAAI,KAAK,CAAC,CAAC;EACtG,OAAO;CACT,OAAO,IAAI,kBAAkB,KAAK;EAChC,MAAM,sBAAM,IAAI,IAAS;EACzB,OAAO,SAAS,MAAM,IAAI,IAAI,sBAAsB,IAAI,CAAC,CAAC,CAAC;EAC3D,OAAO;CACT,OAAO,IAAI,OAAO,WAAW,YAAY,QAAQ,gBAAgB,QAAQ;EACvE,MAAM,MAAM,CAAC;EACb,OAAO,QAAQ,MAAM,CAAC,CAAC,SAAS,CAAC,KAAK,WAA2B,IAAI,OAAO,sBAAsB,IAAI,KAAK,CAAE;EAC7G,OAAO;CACT,OACE,OAAO;AAEX"}

package/build/seed.cjs

@@ -0,0 +1,54 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let joist_core = require("joist-core");
+require("dotenv/config");
+let pg = require("pg");
+pg = require_runtime.__toESM(pg, 1);
+//#region src/seed.ts
+/**
+* Allows easily seeding your local database with test data from the factories.
+*
+* This will delete all data in the database, so is restricted to only `local` and
+* `test` `NODE_ENV`s.
+*
+* We currently make a lot of assumptions:
+*
+* - That the project is using postgres (all Joist projects do atm)
+* - That the project does not have a context, or at least does not require a context to seed
+*
+* If any of these assumptions are not true, you can copy this code into your project.
+*
+* @example
+* ```ts
+* import { seed } from "joist-test-utils";
+* import { PostgresDriver } from "joist-orm";
+*
+* seed({ createDriver: (pool) => new PostgresDriver(pool) }, async (em) => {
+*   // seed your data here
+* });
+* ```
+*/
+function seed(config, fn) {
+	const env = process.env.NODE_ENV;
+	if (env !== "local" && env !== "test") throw new Error("seed will only run with NODE_ENV=local or NODE_ENV=test because it resets the database");
+	const pool = new pg.default.Pool((0, joist_core.newPgConnectionConfig)());
+	async function seed() {
+		await pool.query("SELECT flush_database()");
+		const driver = config.createDriver(pool);
+		const em = new joist_core.EntityManager({}, { driver });
+		await fn(em);
+		await em.flush();
+	}
+	seed().then(async () => {
+		console.log("Seeded!");
+		await pool.end();
+	}).catch(async (err) => {
+		console.error(err);
+		await pool.end();
+		process.exit(1);
+	});
+}
+//#endregion
+exports.seed = seed;
+
+//# sourceMappingURL=seed.cjs.map

package/build/seed.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.cjs","names":["newPgConnectionConfig","EntityManager"],"sources":["../src/seed.ts"],"sourcesContent":["import \"dotenv/config\";\nimport { type Driver, EntityManager, newPgConnectionConfig } from \"joist-core\";\nimport pg from \"pg\";\n\nexport interface SeedConfig {\n  /** A factory function to create a Driver from a pg Pool. */\n  createDriver: (pool: pg.Pool) => Driver;\n}\n\n/**\n * Allows easily seeding your local database with test data from the factories.\n *\n * This will delete all data in the database, so is restricted to only `local` and\n * `test` `NODE_ENV`s.\n *\n * We currently make a lot of assumptions:\n *\n * - That the project is using postgres (all Joist projects do atm)\n * - That the project does not have a context, or at least does not require a context to seed\n *\n * If any of these assumptions are not true, you can copy this code into your project.\n *\n * @example\n * ```ts\n * import { seed } from \"joist-test-utils\";\n * import { PostgresDriver } from \"joist-orm\";\n *\n * seed({ createDriver: (pool) => new PostgresDriver(pool) }, async (em) => {\n *   // seed your data here\n * });\n * ```\n */\nexport function seed<E extends EntityManager = EntityManager>(config: SeedConfig, fn: (em: E) => Promise<void>): void {\n  const env = process.env.NODE_ENV;\n  if (env !== \"local\" && env !== \"test\") {\n    throw new Error(\"seed will only run with NODE_ENV=local or NODE_ENV=test because it resets the database\");\n  }\n\n  const pool = new pg.Pool(newPgConnectionConfig());\n\n  async function seed() {\n    await pool.query(\"SELECT flush_database()\");\n    const driver = config.createDriver(pool);\n    const em = new EntityManager({}, { driver }) as E;\n    await fn(em);\n    await em.flush();\n  }\n\n  seed()\n    .then(async () => {\n      console.log(\"Seeded!\");\n      await pool.end();\n    })\n    .catch(async (err) => {\n      console.error(err);\n      await pool.end();\n      process.exit(1);\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,KAA8C,QAAoB,IAAoC;CACpH,MAAM,MAAM,QAAQ,IAAI;CACxB,IAAI,QAAQ,WAAW,QAAQ,QAC7B,MAAM,IAAI,MAAM,wFAAwF;CAG1G,MAAM,OAAO,IAAI,GAAA,QAAG,MAAA,GAAKA,WAAAA,sBAAAA,CAAsB,CAAC;CAEhD,eAAe,OAAO;EACpB,MAAM,KAAK,MAAM,yBAAyB;EAC1C,MAAM,SAAS,OAAO,aAAa,IAAI;EACvC,MAAM,KAAK,IAAIC,WAAAA,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC;EAC3C,MAAM,GAAG,EAAE;EACX,MAAM,GAAG,MAAM;CACjB;CAEA,KAAK,CAAC,CACH,KAAK,YAAY;EAChB,QAAQ,IAAI,SAAS;EACrB,MAAM,KAAK,IAAI;CACjB,CAAC,CAAC,CACD,MAAM,OAAO,QAAQ;EACpB,QAAQ,MAAM,GAAG;EACjB,MAAM,KAAK,IAAI;EACf,QAAQ,KAAK,CAAC;CAChB,CAAC;AACL"}

package/build/{seed.d.ts → seed.d.cts}

@@ -1,9 +1,10 @@
-import "dotenv/config";
 import { Driver, EntityManager } from "joist-core";
+import "dotenv/config";
 import pg from "pg";
-export interface SeedConfig {
-    /** A factory function to create a Driver from a pg Pool. */
-    createDriver: (pool: pg.Pool) => Driver;
+//#region src/seed.d.ts
+interface SeedConfig {
+  /** A factory function to create a Driver from a pg Pool. */
+  createDriver: (pool: pg.Pool) => Driver;
 }
 /**
  * Allows easily seeding your local database with test data from the factories.
@@ -28,5 +29,7 @@ export interface SeedConfig {
  * });
  * ```
  */
-export declare function seed<E extends EntityManager = EntityManager>(config: SeedConfig, fn: (em: E) => Promise<void>): void;
-//# sourceMappingURL=seed.d.ts.map
+declare function seed<E extends EntityManager = EntityManager>(config: SeedConfig, fn: (em: E) => Promise<void>): void;
+//#endregion
+export { SeedConfig, seed };
+//# sourceMappingURL=seed.d.cts.map

package/build/seed.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.cts","names":[],"sources":["../src/seed.ts"],"mappings":";;;;UAIiB;;EAEf,eAAe,MAAM,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BnB,KAAK,UAAU,gBAAgB,eAAe,QAAQ,YAAY,KAAK,IAAI,MAAM"}

package/build/seed.d.mts

@@ -0,0 +1,35 @@
+import { Driver, EntityManager } from "joist-core";
+import "dotenv/config";
+import pg from "pg";
+//#region src/seed.d.ts
+interface SeedConfig {
+  /** A factory function to create a Driver from a pg Pool. */
+  createDriver: (pool: pg.Pool) => Driver;
+}
+/**
+ * Allows easily seeding your local database with test data from the factories.
+ *
+ * This will delete all data in the database, so is restricted to only `local` and
+ * `test` `NODE_ENV`s.
+ *
+ * We currently make a lot of assumptions:
+ *
+ * - That the project is using postgres (all Joist projects do atm)
+ * - That the project does not have a context, or at least does not require a context to seed
+ *
+ * If any of these assumptions are not true, you can copy this code into your project.
+ *
+ * @example
+ * ```ts
+ * import { seed } from "joist-test-utils";
+ * import { PostgresDriver } from "joist-orm";
+ *
+ * seed({ createDriver: (pool) => new PostgresDriver(pool) }, async (em) => {
+ *   // seed your data here
+ * });
+ * ```
+ */
+declare function seed<E extends EntityManager = EntityManager>(config: SeedConfig, fn: (em: E) => Promise<void>): void;
+//#endregion
+export { SeedConfig, seed };
+//# sourceMappingURL=seed.d.mts.map

package/build/seed.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.mts","names":[],"sources":["../src/seed.ts"],"mappings":";;;;UAIiB;;EAEf,eAAe,MAAM,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BnB,KAAK,UAAU,gBAAgB,eAAe,QAAQ,YAAY,KAAK,IAAI,MAAM"}

package/build/seed.js

@@ -1,57 +1,51 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.seed = seed;
-require("dotenv/config");
-const joist_core_1 = require("joist-core");
-const pg_1 = __importDefault(require("pg"));
+import { EntityManager, newPgConnectionConfig } from "joist-core";
+import "dotenv/config";
+import pg from "pg";
+//#region src/seed.ts
 /**
- * Allows easily seeding your local database with test data from the factories.
- *
- * This will delete all data in the database, so is restricted to only `local` and
- * `test` `NODE_ENV`s.
- *
- * We currently make a lot of assumptions:
- *
- * - That the project is using postgres (all Joist projects do atm)
- * - That the project does not have a context, or at least does not require a context to seed
- *
- * If any of these assumptions are not true, you can copy this code into your project.
- *
- * @example
- * ```ts
- * import { seed } from "joist-test-utils";
- * import { PostgresDriver } from "joist-orm";
- *
- * seed({ createDriver: (pool) => new PostgresDriver(pool) }, async (em) => {
- *   // seed your data here
- * });
- * ```
- */
+* Allows easily seeding your local database with test data from the factories.
+*
+* This will delete all data in the database, so is restricted to only `local` and
+* `test` `NODE_ENV`s.
+*
+* We currently make a lot of assumptions:
+*
+* - That the project is using postgres (all Joist projects do atm)
+* - That the project does not have a context, or at least does not require a context to seed
+*
+* If any of these assumptions are not true, you can copy this code into your project.
+*
+* @example
+* ```ts
+* import { seed } from "joist-test-utils";
+* import { PostgresDriver } from "joist-orm";
+*
+* seed({ createDriver: (pool) => new PostgresDriver(pool) }, async (em) => {
+*   // seed your data here
+* });
+* ```
+*/
 function seed(config, fn) {
-    const env = process.env.NODE_ENV;
-    if (env !== "local" && env !== "test") {
-        throw new Error("seed will only run with NODE_ENV=local or NODE_ENV=test because it resets the database");
-    }
-    const pool = new pg_1.default.Pool((0, joist_core_1.newPgConnectionConfig)());
-    async function seed() {
-        await pool.query("SELECT flush_database()");
-        const driver = config.createDriver(pool);
-        const em = new joist_core_1.EntityManager({}, { driver });
-        await fn(em);
-        await em.flush();
-    }
-    seed()
-        .then(async () => {
-        console.log("Seeded!");
-        await pool.end();
-    })
-        .catch(async (err) => {
-        console.error(err);
-        await pool.end();
-        process.exit(1);
-    });
+	const env = process.env.NODE_ENV;
+	if (env !== "local" && env !== "test") throw new Error("seed will only run with NODE_ENV=local or NODE_ENV=test because it resets the database");
+	const pool = new pg.Pool(newPgConnectionConfig());
+	async function seed() {
+		await pool.query("SELECT flush_database()");
+		const driver = config.createDriver(pool);
+		const em = new EntityManager({}, { driver });
+		await fn(em);
+		await em.flush();
+	}
+	seed().then(async () => {
+		console.log("Seeded!");
+		await pool.end();
+	}).catch(async (err) => {
+		console.error(err);
+		await pool.end();
+		process.exit(1);
+	});
 }
+//#endregion
+export { seed };
+
 //# sourceMappingURL=seed.js.map

package/build/seed.js.map

@@ -1 +1 @@
-{"version":3,"file":"seed.js","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":";;;;;AAgCA,oBA0BC;AA1DD,yBAAuB;AACvB,2CAA0E;AAC1E,4CAAoB;AAOpB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAgB,IAAI,CAA0C,MAAkB,EAAE,EAA4B;IAC5G,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;IACjC,IAAI,GAAG,KAAK,OAAO,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,wFAAwF,CAAC,CAAC;IAC5G,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,YAAE,CAAC,IAAI,CAAC,IAAA,kCAAqB,GAAE,CAAC,CAAC;IAElD,KAAK,UAAU,IAAI;QACjB,MAAM,IAAI,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACzC,MAAM,EAAE,GAAG,IAAI,0BAAa,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,CAAM,CAAC;QAClD,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACb,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC;IAED,IAAI,EAAE;SACH,IAAI,CAAC,KAAK,IAAI,EAAE;QACf,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACvB,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;IACnB,CAAC,CAAC;SACD,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;QACnB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnB,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;QACjB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC,CAAC,CAAC;AACP,CAAC"}
+{"version":3,"file":"seed.js","names":[],"sources":["../src/seed.ts"],"sourcesContent":["import \"dotenv/config\";\nimport { type Driver, EntityManager, newPgConnectionConfig } from \"joist-core\";\nimport pg from \"pg\";\n\nexport interface SeedConfig {\n  /** A factory function to create a Driver from a pg Pool. */\n  createDriver: (pool: pg.Pool) => Driver;\n}\n\n/**\n * Allows easily seeding your local database with test data from the factories.\n *\n * This will delete all data in the database, so is restricted to only `local` and\n * `test` `NODE_ENV`s.\n *\n * We currently make a lot of assumptions:\n *\n * - That the project is using postgres (all Joist projects do atm)\n * - That the project does not have a context, or at least does not require a context to seed\n *\n * If any of these assumptions are not true, you can copy this code into your project.\n *\n * @example\n * ```ts\n * import { seed } from \"joist-test-utils\";\n * import { PostgresDriver } from \"joist-orm\";\n *\n * seed({ createDriver: (pool) => new PostgresDriver(pool) }, async (em) => {\n *   // seed your data here\n * });\n * ```\n */\nexport function seed<E extends EntityManager = EntityManager>(config: SeedConfig, fn: (em: E) => Promise<void>): void {\n  const env = process.env.NODE_ENV;\n  if (env !== \"local\" && env !== \"test\") {\n    throw new Error(\"seed will only run with NODE_ENV=local or NODE_ENV=test because it resets the database\");\n  }\n\n  const pool = new pg.Pool(newPgConnectionConfig());\n\n  async function seed() {\n    await pool.query(\"SELECT flush_database()\");\n    const driver = config.createDriver(pool);\n    const em = new EntityManager({}, { driver }) as E;\n    await fn(em);\n    await em.flush();\n  }\n\n  seed()\n    .then(async () => {\n      console.log(\"Seeded!\");\n      await pool.end();\n    })\n    .catch(async (err) => {\n      console.error(err);\n      await pool.end();\n      process.exit(1);\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,KAA8C,QAAoB,IAAoC;CACpH,MAAM,MAAM,QAAQ,IAAI;CACxB,IAAI,QAAQ,WAAW,QAAQ,QAC7B,MAAM,IAAI,MAAM,wFAAwF;CAG1G,MAAM,OAAO,IAAI,GAAG,KAAK,sBAAsB,CAAC;CAEhD,eAAe,OAAO;EACpB,MAAM,KAAK,MAAM,yBAAyB;EAC1C,MAAM,SAAS,OAAO,aAAa,IAAI;EACvC,MAAM,KAAK,IAAI,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC;EAC3C,MAAM,GAAG,EAAE;EACX,MAAM,GAAG,MAAM;CACjB;CAEA,KAAK,CAAC,CACH,KAAK,YAAY;EAChB,QAAQ,IAAI,SAAS;EACrB,MAAM,KAAK,IAAI;CACjB,CAAC,CAAC,CACD,MAAM,OAAO,QAAQ;EACpB,QAAQ,MAAM,GAAG;EACjB,MAAM,KAAK,IAAI;EACf,QAAQ,KAAK,CAAC;CAChB,CAAC;AACL"}

package/build/toMatchEntity.cjs

@@ -0,0 +1,94 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./index.cjs");
+let joist_core = require("joist-core");
+let joist_utils = require("joist-utils");
+//#region src/toMatchEntity.ts
+const isVitest = typeof process !== "undefined" && process.env?.VITEST === "true";
+/**
+* Provides convenient `toMatchObject`-style matching for Joist entities.
+*
+* The biggest differences over `toMatchObject` are:
+*
+* - We un-wrap relations like m2o/o2m to just the underlying object/arrays, to make
+*   asserting against the entities look like asserting against POJOs
+* - We prune the expected/actual values to be as minimal as possible, to avoid Jest
+*   recursively crawling into connection pools or other misc non-useful things in the diffs
+*/
+function toMatchEntity(actual, expected) {
+	const matchers = isVitest ? void 0 : globalThis[Symbol.for("$$jest-matchers-object")]?.matchers;
+	const cleanExpected = deepClone(expected);
+	const cleanActual = deepClone(deepMirror(cleanExpected, actual));
+	if (matchers) {
+		if (typeof cleanActual !== "object") return matchers.toEqual.call(this, cleanActual, cleanExpected);
+		else return matchers.toMatchObject.call(this, cleanActual, cleanExpected);
+	} else if (isVitest) return {
+		pass: this.equals(cleanActual, cleanExpected, this.customTesters),
+		message: () => {
+			const hint = this.utils.matcherHint("toMatchEntity", void 0, void 0, { isNot: this.isNot });
+			const diff = this.utils.diff(cleanExpected, cleanActual);
+			return diff ? `${hint}\n\n${diff}` : hint;
+		}
+	};
+	else return {
+		pass: this.equals(cleanActual, cleanExpected),
+		message: () => this.utils.matcherHint("toMatchEntity", cleanActual, cleanExpected)
+	};
+}
+function maybeTestId(maybeEntity) {
+	return (0, joist_core.isEntity)(maybeEntity) ? getTestId(maybeEntity.em, maybeEntity) : maybeEntity;
+}
+/** Returns either the persisted id or `tag#<offset-in-EntityManager>`. */
+function getTestId(_, entity) {
+	return entity.toTaggedString();
+}
+/**
+* Make a "new actual" based on the subset shape of expected.
+*
+* We don't have cycle detection, but that should be fine b/c the user types
+* out the expected as an object literal, so it shouldn't have cycles
+*/
+function deepMirror(expected, actual) {
+	if (!(0, joist_utils.isPlainObject)(expected) && !Array.isArray(expected)) return actual;
+	if (!(0, joist_core.isDefined)(actual)) return actual;
+	const subset = Array.isArray(expected) ? [] : {};
+	const keys = Array.isArray(actual) ? Object.keys(actual) : Object.keys(expected);
+	for (const key of keys) if (key in actual) subset[key] = deepMirror(expected[key], maybeGetRelation(actual[key]));
+	return subset;
+}
+/** Make a clone of `obj`, but only recurse into POJOs and Arrays, and replace entities if we find them. */
+function deepClone(obj, map = /* @__PURE__ */ new WeakMap()) {
+	if (obj instanceof joist_core.BaseEntity) return maybeTestId(obj);
+	else if (obj && typeof obj === "object" && ((0, joist_utils.isPlainObject)(obj) || Array.isArray(obj))) {
+		if (map.has(obj)) return map.get(obj);
+		const result = Array.isArray(obj) ? [] : {};
+		map.set(obj, result);
+		Object.assign(result, ...Object.keys(obj).map((key) => ({ [key]: deepClone(obj[key], map) })));
+		return result;
+	} else return obj;
+}
+/** Flattens/simplifies relations into their actual value, i.e. "calls get". */
+function maybeGetRelation(actualValue) {
+	if ((0, joist_core.isReference)(actualValue) || (0, joist_core.isCollection)(actualValue) || (0, joist_core.isProperty)(actualValue) || (0, joist_core.isReactiveField)(actualValue) || (0, joist_core.isAsyncProperty)(actualValue)) return getWithSoftDeleted(actualValue);
+	return actualValue;
+}
+/**
+* Adds back soft-deleted to `.get`.
+*
+* In Joist, `.get` filters both soft and hard deleted entities, because `.get`
+* is likely used by real business logic that doesn't want to see either.
+*
+* However, in tests with `toMatchEntity`, we take a stronger stance that the
+* developer needs to know "this is _soft_ deleted and not hard deleted", so
+* we add-back soft deleted entities.
+*
+* We do this by calling `getWithDeleted`, which returns all hard and soft
+* deleted entities, and then filtering out the hard deletes.
+*/
+function getWithSoftDeleted(relation) {
+	const r = "getWithDeleted" in relation ? relation.getWithDeleted : relation.get;
+	return Array.isArray(r) ? r.filter((e) => !e.isDeletedEntity) : r;
+}
+//#endregion
+exports.toMatchEntity = toMatchEntity;
+
+//# sourceMappingURL=toMatchEntity.cjs.map

package/build/toMatchEntity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMatchEntity.cjs","names":["isEntity","isPlainObject","isDefined","BaseEntity","isReference","isCollection","isProperty","isReactiveField","isAsyncProperty"],"sources":["../src/toMatchEntity.ts"],"sourcesContent":["import {\n  BaseEntity,\n  type Entity,\n  type EntityManager,\n  type Property,\n  type ReadOnlyCollection,\n  type Reference,\n  isAsyncProperty,\n  isCollection,\n  isDefined,\n  isEntity,\n  isProperty,\n  isReactiveField,\n  isReference,\n} from \"joist-core\";\nimport { isPlainObject } from \"joist-utils\";\n\nimport { type CustomMatcherResult } from \"./index.ts\";\n\n// Vitest also populates the `$$jest-matchers-object` symbol, but the matchers it stores there are\n// chai-based and assume `this` is a chai Assertion (with a `this.assert` method), which our custom\n// matcher's `this` context is not--so calling them throws `this.assert is not a function`. Only take\n// the Jest fast-path under actual Jest, and route Vitest through the `this.equals` path below (like Bun).\nconst isVitest = typeof process !== \"undefined\" && process.env?.VITEST === \"true\";\n\n/**\n * Provides convenient `toMatchObject`-style matching for Joist entities.\n *\n * The biggest differences over `toMatchObject` are:\n *\n * - We un-wrap relations like m2o/o2m to just the underlying object/arrays, to make\n *   asserting against the entities look like asserting against POJOs\n * - We prune the expected/actual values to be as minimal as possible, to avoid Jest\n *   recursively crawling into connection pools or other misc non-useful things in the diffs\n */\nexport function toMatchEntity<T>(this: any, actual: unknown, expected: MatchedEntity<T>): CustomMatcherResult {\n  // This module can load before Jest initializes its matcher state, so read the global when invoked.\n  const matchers = isVitest ? undefined : (globalThis as any)[Symbol.for(\"$$jest-matchers-object\")]?.matchers;\n  // We're given expected, which is an object literal of what the user wants to match\n  // against (some intermixed POJOs & entities) and actual (which similarly could be\n  // intermixed POJOs & entities, but will likely be more sprawling because it's the\n  // full result, and not the subset we're asserting against).\n  //\n  // Given this, first make a safe clone of `expected`, i.e. turn entities into strings.\n  // After that, use `expected` as a template to pick keys out of actual. Finally, do the\n  // same \"clean clone\" of actual, and compare the two.\n  const cleanExpected = deepClone(expected);\n  const cleanActual = deepClone(deepMirror(cleanExpected, actual));\n\n  // Watch for `expect(someAuthor).toMatchEntity(a1)` as we'll turn `someAuthor` into \"a:1\",\n  // so can't use toMatchObject anymore.\n  if (matchers) {\n    // this is jest\n    if (typeof cleanActual !== \"object\") {\n      // @ts-ignore\n      return matchers.toEqual.call(this, cleanActual, cleanExpected);\n    } else {\n      // @ts-ignore\n      return matchers.toMatchObject.call(this, cleanActual, cleanExpected);\n    }\n  } else if (isVitest) {\n    // `deepMirror` already pruned `cleanActual` down to the subset of keys that `cleanExpected`\n    // declares, so a full `this.equals` deep-equality behaves like Jest's `toMatchObject`. We pass\n    // `this.customTesters` so `areEntitiesEqual` still applies. Building the diff into `message`\n    // (like Jest's `toMatchObject`) keeps the failure output readable both in the terminal and in\n    // `toThrowErrorMatchingInlineSnapshot`, instead of the default `expect([object Object])...`.\n    const pass = this.equals(cleanActual, cleanExpected, this.customTesters);\n    return {\n      pass,\n      message: () => {\n        const hint = this.utils.matcherHint(\"toMatchEntity\", undefined, undefined, { isNot: this.isNot });\n        const diff = this.utils.diff(cleanExpected, cleanActual);\n        return diff ? `${hint}\\n\\n${diff}` : hint;\n      },\n    };\n  } else {\n    // This is Bun, whose matcher `this.utils` only exposes `matcherHint`.\n    return {\n      pass: this.equals(cleanActual, cleanExpected),\n      message: () => this.utils.matcherHint(\"toMatchEntity\", cleanActual, cleanExpected),\n    };\n  }\n}\n\nfunction maybeTestId(maybeEntity: any): any {\n  return isEntity(maybeEntity) ? getTestId(maybeEntity.em, maybeEntity) : maybeEntity;\n}\n\n/** Returns either the persisted id or `tag#<offset-in-EntityManager>`. */\nfunction getTestId(_: EntityManager, entity: Entity): string {\n  return entity.toTaggedString();\n}\n\n/**\n * Given a Joist entity `T`, \"flattens out\" the Reference/Collections.\n *\n * I.e. so that you can `toMatchEntity({ otherEntity: { name: \"foo\" } })` even though\n * `otherEntity` is technically a joist `Reference` or `Collection`.\n *\n * We allow `| null` so that `toMatchEntity` can work against optional fields\n * that are returned from GraphQL object resolvers.\n */\nexport type MatchedEntity<T> =\n  T extends ReadonlyArray<infer U>\n    ? ReadonlyArray<MatchedEntity<U>>\n    :\n        | undefined\n        | T\n        | {\n            [K in keyof T]?: T[K] extends Reference<any, infer U, any>\n              ? MatchedEntity<U> | U\n              : T[K] extends ReadOnlyCollection<any, infer U>\n                ? Array<MatchedEntity<U> | U>\n                : T[K] extends Property<any, infer V>\n                  ? V\n                  : T[K] extends Entity | null | undefined\n                    ? MatchedEntity<T[K]> | T[K] | null | undefined\n                    : T[K] extends ReadonlyArray<(infer U) | undefined>\n                      ? readonly (MatchedEntity<U> | U | undefined)[]\n                      : T[K] extends ReadonlyArray<infer U> | null\n                        ? readonly (MatchedEntity<U> | U | null)[]\n                        : // We recurse similar to a DeepPartial\n                          MatchedEntity<T[K]> | null;\n          };\n\n/**\n * Make a \"new actual\" based on the subset shape of expected.\n *\n * We don't have cycle detection, but that should be fine b/c the user types\n * out the expected as an object literal, so it shouldn't have cycles\n */\nfunction deepMirror(expected: any, actual: any): any {\n  // If we've hit a point where the `expected` input is not a POJO object literal/array\n  // declaring the subset of the shape to assert against, just return actual as-is.\n  // This might be a Date (safe) or an Entity (unsafe) or something else, but if so it will\n  // get cleaned up by the `deepClone` pass.\n  if (!isPlainObject(expected) && !Array.isArray(expected)) return actual;\n  if (!isDefined(actual)) return actual;\n  // Make a new actual that is a subset that matches expected\n  const subset: any = Array.isArray(expected) ? [] : ({} as any);\n  // If both are arrays, fill out the whole array\n  const keys = Array.isArray(actual) ? Object.keys(actual) : Object.keys(expected);\n  for (const key of keys) {\n    if (key in actual) {\n      // Even if actualValue is an Entity, if expected has a key drilling in to it, we want to object literal-ize it\n      subset[key] = deepMirror((expected as any)[key], maybeGetRelation(actual[key]));\n    }\n  }\n  return subset;\n}\n\n/** Make a clone of `obj`, but only recurse into POJOs and Arrays, and replace entities if we find them. */\nfunction deepClone(obj: unknown, map = new WeakMap()): unknown {\n  if (obj instanceof BaseEntity) {\n    return maybeTestId(obj);\n  } else if (obj && typeof obj === \"object\" && (isPlainObject(obj) || Array.isArray(obj))) {\n    if (map.has(obj)) return map.get(obj);\n    const result = Array.isArray(obj) ? [] : {};\n    map.set(obj, result);\n    Object.assign(result, ...Object.keys(obj).map((key) => ({ [key]: deepClone((obj as any)[key], map) })));\n    return result;\n  } else {\n    return obj;\n  }\n}\n\n/** Flattens/simplifies relations into their actual value, i.e. \"calls get\". */\nfunction maybeGetRelation(actualValue: unknown): unknown {\n  if (\n    isReference(actualValue) ||\n    isCollection(actualValue) ||\n    isProperty(actualValue) ||\n    isReactiveField(actualValue) ||\n    // hasAsyncPropertys will work if they've been already loaded, so let the user try it\n    isAsyncProperty(actualValue)\n  ) {\n    return getWithSoftDeleted(actualValue);\n  }\n  return actualValue;\n}\n\n/**\n * Adds back soft-deleted to `.get`.\n *\n * In Joist, `.get` filters both soft and hard deleted entities, because `.get`\n * is likely used by real business logic that doesn't want to see either.\n *\n * However, in tests with `toMatchEntity`, we take a stronger stance that the\n * developer needs to know \"this is _soft_ deleted and not hard deleted\", so\n * we add-back soft deleted entities.\n *\n * We do this by calling `getWithDeleted`, which returns all hard and soft\n * deleted entities, and then filtering out the hard deletes.\n */\nfunction getWithSoftDeleted(relation: any): any {\n  const r = \"getWithDeleted\" in relation ? relation.getWithDeleted : relation.get;\n  return Array.isArray(r) ? r.filter((e: any) => !e.isDeletedEntity) : r;\n}\n"],"mappings":"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"}

package/build/toMatchEntity.d.cts

@@ -0,0 +1,28 @@
+import { CustomMatcherResult } from "./index.cjs";
+import { Entity, Property, ReadOnlyCollection, Reference } from "joist-core";
+//#region src/toMatchEntity.d.ts
+/**
+ * Provides convenient `toMatchObject`-style matching for Joist entities.
+ *
+ * The biggest differences over `toMatchObject` are:
+ *
+ * - We un-wrap relations like m2o/o2m to just the underlying object/arrays, to make
+ *   asserting against the entities look like asserting against POJOs
+ * - We prune the expected/actual values to be as minimal as possible, to avoid Jest
+ *   recursively crawling into connection pools or other misc non-useful things in the diffs
+ */
+declare function toMatchEntity<T>(this: any, actual: unknown, expected: MatchedEntity<T>): CustomMatcherResult;
+/**
+ * Given a Joist entity `T`, "flattens out" the Reference/Collections.
+ *
+ * I.e. so that you can `toMatchEntity({ otherEntity: { name: "foo" } })` even though
+ * `otherEntity` is technically a joist `Reference` or `Collection`.
+ *
+ * We allow `| null` so that `toMatchEntity` can work against optional fields
+ * that are returned from GraphQL object resolvers.
+ */
+type MatchedEntity<T> = T extends ReadonlyArray<infer U> ? ReadonlyArray<MatchedEntity<U>> : undefined | T | { [K in keyof T]?: T[K] extends Reference<any, infer U, any> ? MatchedEntity<U> | U : T[K] extends ReadOnlyCollection<any, infer U> ? Array<MatchedEntity<U> | U> : T[K] extends Property<any, infer V> ? V : T[K] extends Entity | null | undefined ? MatchedEntity<T[K]> | T[K] | null | undefined : T[K] extends ReadonlyArray<(infer U) | undefined> ? readonly (MatchedEntity<U> | U | undefined)[] : T[K] extends ReadonlyArray<infer U> | null ? readonly (MatchedEntity<U> | U | null)[] // We recurse similar to a DeepPartial
+ : MatchedEntity<T[K]> | null; };
+//#endregion
+export { MatchedEntity, toMatchEntity };
+//# sourceMappingURL=toMatchEntity.d.cts.map

package/build/toMatchEntity.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMatchEntity.d.cts","names":[],"sources":["../src/toMatchEntity.ts"],"mappings":";;;;;;;;;;;;;iBAmCgB,cAAc,GAAG,WAAW,iBAAiB,UAAU,cAAc,KAAK;;;;;;;;;;KAmE9E,cAAc,KACxB,UAAU,oBAAoB,KAC1B,cAAc,cAAc,kBAGxB,OAEG,WAAW,KAAK,EAAE,WAAW,qBAAqB,UAC/C,cAAc,KAAK,IACnB,EAAE,WAAW,8BAA8B,KACzC,MAAM,cAAc,KAAK,KACzB,EAAE,WAAW,oBAAoB,KAC/B,IACA,EAAE,WAAW,4BACX,cAAc,EAAE,MAAM,EAAE,wBACxB,EAAE,WAAW,qBAAqB,4BACtB,cAAc,KAAK,mBAC7B,EAAE,WAAW,oBAAoB,sBACrB,cAAc,KAAK;GAE7B,cAAc,EAAE"}

package/build/toMatchEntity.d.mts

@@ -0,0 +1,28 @@
+import { CustomMatcherResult } from "./index.mjs";
+import { Entity, Property, ReadOnlyCollection, Reference } from "joist-core";
+//#region src/toMatchEntity.d.ts
+/**
+ * Provides convenient `toMatchObject`-style matching for Joist entities.
+ *
+ * The biggest differences over `toMatchObject` are:
+ *
+ * - We un-wrap relations like m2o/o2m to just the underlying object/arrays, to make
+ *   asserting against the entities look like asserting against POJOs
+ * - We prune the expected/actual values to be as minimal as possible, to avoid Jest
+ *   recursively crawling into connection pools or other misc non-useful things in the diffs
+ */
+declare function toMatchEntity<T>(this: any, actual: unknown, expected: MatchedEntity<T>): CustomMatcherResult;
+/**
+ * Given a Joist entity `T`, "flattens out" the Reference/Collections.
+ *
+ * I.e. so that you can `toMatchEntity({ otherEntity: { name: "foo" } })` even though
+ * `otherEntity` is technically a joist `Reference` or `Collection`.
+ *
+ * We allow `| null` so that `toMatchEntity` can work against optional fields
+ * that are returned from GraphQL object resolvers.
+ */
+type MatchedEntity<T> = T extends ReadonlyArray<infer U> ? ReadonlyArray<MatchedEntity<U>> : undefined | T | { [K in keyof T]?: T[K] extends Reference<any, infer U, any> ? MatchedEntity<U> | U : T[K] extends ReadOnlyCollection<any, infer U> ? Array<MatchedEntity<U> | U> : T[K] extends Property<any, infer V> ? V : T[K] extends Entity | null | undefined ? MatchedEntity<T[K]> | T[K] | null | undefined : T[K] extends ReadonlyArray<(infer U) | undefined> ? readonly (MatchedEntity<U> | U | undefined)[] : T[K] extends ReadonlyArray<infer U> | null ? readonly (MatchedEntity<U> | U | null)[] // We recurse similar to a DeepPartial
+ : MatchedEntity<T[K]> | null; };
+//#endregion
+export { MatchedEntity, toMatchEntity };
+//# sourceMappingURL=toMatchEntity.d.mts.map

package/build/toMatchEntity.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMatchEntity.d.mts","names":[],"sources":["../src/toMatchEntity.ts"],"mappings":";;;;;;;;;;;;;iBAmCgB,cAAc,GAAG,WAAW,iBAAiB,UAAU,cAAc,KAAK;;;;;;;;;;KAmE9E,cAAc,KACxB,UAAU,oBAAoB,KAC1B,cAAc,cAAc,kBAGxB,OAEG,WAAW,KAAK,EAAE,WAAW,qBAAqB,UAC/C,cAAc,KAAK,IACnB,EAAE,WAAW,8BAA8B,KACzC,MAAM,cAAc,KAAK,KACzB,EAAE,WAAW,oBAAoB,KAC/B,IACA,EAAE,WAAW,4BACX,cAAc,EAAE,MAAM,EAAE,wBACxB,EAAE,WAAW,qBAAqB,4BACtB,cAAc,KAAK,mBAC7B,EAAE,WAAW,oBAAoB,sBACrB,cAAc,KAAK;GAE7B,cAAc,EAAE"}