joist-graphql-resolver-utils 2.3.0-next.7 → 2.3.0-next.70

package/build/limitPagination.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./paginationUtils.cjs");
+require("joist-core");
+//#region src/limitPagination.ts
+/** Returns a limit/offset page shape for a generated query resolver. */
+async function paginateLimit(ctx, type, args) {
+	const limit = args.limit ?? 100;
+	const offset = args.offset ?? 0;
+	const filter = args.filter ?? {};
+	return {
+		entities: await ctx.em.findGql(type, filter, {
+			limit,
+			offset
+		}),
+		pageInfo: new LimitPageInfo(ctx, type, filter, {
+			limit,
+			offset
+		})
+	};
+}
+/** Lazily computes limit/offset page fields. */
+var LimitPageInfo = class {
+	#ctx;
+	#filter;
+	#page;
+	#totalCountPromise;
+	#type;
+	constructor(ctx, type, filter, page) {
+		this.#ctx = ctx;
+		this.#type = type;
+		this.#filter = filter;
+		this.#page = page;
+	}
+	get hasNextPage() {
+		return this.#hasNextPage();
+	}
+	get hasPreviousPage() {
+		return this.#page.offset > 0;
+	}
+	get totalCount() {
+		return this.#totalCountPromise ??= this.#ctx.em.findCount(this.#type, this.#filter);
+	}
+	get nextPage() {
+		return this.#nextPage();
+	}
+	get currentPage() {
+		return Math.floor(this.#page.offset / this.#page.limit) + 1;
+	}
+	/** Returns whether another page exists after this page. */
+	async #hasNextPage() {
+		const total = await this.totalCount;
+		const { offset, limit } = this.#page;
+		return offset + limit < total;
+	}
+	/** Returns the next limit/offset page if there is one. */
+	async #nextPage() {
+		if (!await this.hasNextPage) return void 0;
+		return this.currentPage + 1;
+	}
+};
+//#endregion
+exports.LimitPageInfo = LimitPageInfo;
+exports.paginateLimit = paginateLimit;
+
+//# sourceMappingURL=limitPagination.cjs.map

package/build/limitPagination.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitPagination.cjs","names":["#ctx","#type","#filter","#page","#hasNextPage","#totalCountPromise","#nextPage"],"sources":["../src/limitPagination.ts"],"sourcesContent":["import { type Entity, type MaybeAbstractEntityConstructor } from \"joist-core\";\n\nimport { type ContextWithEm, type PaginationFilter, defaultLimit } from \"./paginationUtils.ts\";\n\ntype LimitArgs<T extends Entity, F extends object = PaginationFilter<T>> = {\n  filter?: F | null;\n  limit?: number | null;\n  offset?: number | null;\n};\ntype Page = { offset: number; limit: number };\n\n/** Returns a limit/offset page shape for a generated query resolver. */\nexport async function paginateLimit<T extends Entity, F extends object = PaginationFilter<T>>(\n  ctx: ContextWithEm,\n  type: MaybeAbstractEntityConstructor<T>,\n  args: LimitArgs<T, F>,\n): Promise<{ entities: T[]; pageInfo: LimitPageInfo<T> }> {\n  const limit = args.limit ?? defaultLimit;\n  const offset = args.offset ?? 0;\n  const filter = (args.filter ?? {}) as PaginationFilter<T>;\n  const entities = await ctx.em.findGql(type, filter, { limit, offset });\n  return { entities, pageInfo: new LimitPageInfo(ctx, type, filter, { limit, offset }) };\n}\n\n/** Lazily computes limit/offset page fields. */\nexport class LimitPageInfo<T extends Entity = Entity> {\n  #ctx: ContextWithEm;\n  #filter: PaginationFilter<T>;\n  #page: Page;\n  #totalCountPromise: Promise<number> | undefined;\n  #type: MaybeAbstractEntityConstructor<T>;\n\n  constructor(ctx: ContextWithEm, type: MaybeAbstractEntityConstructor<T>, filter: PaginationFilter<T>, page: Page) {\n    this.#ctx = ctx;\n    this.#type = type;\n    this.#filter = filter;\n    this.#page = page;\n  }\n\n  get hasNextPage(): Promise<boolean> {\n    return this.#hasNextPage();\n  }\n\n  get hasPreviousPage(): boolean {\n    return this.#page.offset > 0;\n  }\n\n  get totalCount(): Promise<number> {\n    return (this.#totalCountPromise ??= this.#ctx.em.findCount(this.#type, this.#filter));\n  }\n\n  get nextPage(): Promise<number | undefined> {\n    return this.#nextPage();\n  }\n\n  get currentPage(): number {\n    return Math.floor(this.#page.offset / this.#page.limit) + 1;\n  }\n\n  /** Returns whether another page exists after this page. */\n  async #hasNextPage(): Promise<boolean> {\n    const total = await this.totalCount;\n    const { offset, limit } = this.#page;\n    return offset + limit < total;\n  }\n\n  /** Returns the next limit/offset page if there is one. */\n  async #nextPage(): Promise<number | undefined> {\n    if (!(await this.hasNextPage)) return undefined;\n    return this.currentPage + 1;\n  }\n}\n"],"mappings":";;;;;AAYA,eAAsB,cACpB,KACA,MACA,MACwD;CACxD,MAAM,QAAQ,KAAK,SAAA;CACnB,MAAM,SAAS,KAAK,UAAU;CAC9B,MAAM,SAAU,KAAK,UAAU,CAAC;CAEhC,OAAO;EAAE,UAAA,MADc,IAAI,GAAG,QAAQ,MAAM,QAAQ;GAAE;GAAO;EAAO,CAAC;EAClD,UAAU,IAAI,cAAc,KAAK,MAAM,QAAQ;GAAE;GAAO;EAAO,CAAC;CAAE;AACvF;;AAGA,IAAa,gBAAb,MAAsD;CACpD;CACA;CACA;CACA;CACA;CAEA,YAAY,KAAoB,MAAyC,QAA6B,MAAY;EAChH,KAAKA,OAAO;EACZ,KAAKC,QAAQ;EACb,KAAKC,UAAU;EACf,KAAKC,QAAQ;CACf;CAEA,IAAI,cAAgC;EAClC,OAAO,KAAKC,aAAa;CAC3B;CAEA,IAAI,kBAA2B;EAC7B,OAAO,KAAKD,MAAM,SAAS;CAC7B;CAEA,IAAI,aAA8B;EAChC,OAAQ,KAAKE,uBAAuB,KAAKL,KAAK,GAAG,UAAU,KAAKC,OAAO,KAAKC,OAAO;CACrF;CAEA,IAAI,WAAwC;EAC1C,OAAO,KAAKI,UAAU;CACxB;CAEA,IAAI,cAAsB;EACxB,OAAO,KAAK,MAAM,KAAKH,MAAM,SAAS,KAAKA,MAAM,KAAK,IAAI;CAC5D;;CAGA,MAAMC,eAAiC;EACrC,MAAM,QAAQ,MAAM,KAAK;EACzB,MAAM,EAAE,QAAQ,UAAU,KAAKD;EAC/B,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAMG,YAAyC;EAC7C,IAAI,CAAE,MAAM,KAAK,aAAc,OAAO,KAAA;EACtC,OAAO,KAAK,cAAc;CAC5B;AACF"}

package/build/limitPagination.d.cts

@@ -0,0 +1,30 @@
+import { ContextWithEm, PaginationFilter } from "./paginationUtils.cjs";
+import { Entity, MaybeAbstractEntityConstructor } from "joist-core";
+//#region src/limitPagination.d.ts
+type LimitArgs<T extends Entity, F extends object = PaginationFilter<T>> = {
+  filter?: F | null;
+  limit?: number | null;
+  offset?: number | null;
+};
+type Page = {
+  offset: number;
+  limit: number;
+};
+/** Returns a limit/offset page shape for a generated query resolver. */
+declare function paginateLimit<T extends Entity, F extends object = PaginationFilter<T>>(ctx: ContextWithEm, type: MaybeAbstractEntityConstructor<T>, args: LimitArgs<T, F>): Promise<{
+  entities: T[];
+  pageInfo: LimitPageInfo<T>;
+}>;
+/** Lazily computes limit/offset page fields. */
+declare class LimitPageInfo<T extends Entity = Entity> {
+  #private;
+  constructor(ctx: ContextWithEm, type: MaybeAbstractEntityConstructor<T>, filter: PaginationFilter<T>, page: Page);
+  get hasNextPage(): Promise<boolean>;
+  get hasPreviousPage(): boolean;
+  get totalCount(): Promise<number>;
+  get nextPage(): Promise<number | undefined>;
+  get currentPage(): number;
+}
+//#endregion
+export { LimitPageInfo, paginateLimit };
+//# sourceMappingURL=limitPagination.d.cts.map

package/build/limitPagination.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitPagination.d.cts","names":[],"sources":["../src/limitPagination.ts"],"mappings":";;;KAIK,UAAU,UAAU,QAAQ,mBAAmB,iBAAiB;EACnE,SAAS;EACT;EACA;;KAEG;EAAS;EAAgB;;;iBAGR,cAAc,UAAU,QAAQ,mBAAmB,iBAAiB,IACxF,KAAK,eACL,MAAM,+BAA+B,IACrC,MAAM,UAAU,GAAG,KAClB;EAAU,UAAU;EAAK,UAAU,cAAc;;;cASvC,cAAc,UAAU,SAAS;;EAO5C,YAAY,KAAK,eAAe,MAAM,+BAA+B,IAAI,QAAQ,iBAAiB,IAAI,MAAM;MAOxG,eAAe;MAIf;MAIA,cAAc;MAId,YAAY;MAIZ"}

package/build/limitPagination.d.mts

@@ -0,0 +1,30 @@
+import { ContextWithEm, PaginationFilter } from "./paginationUtils.mjs";
+import { Entity, MaybeAbstractEntityConstructor } from "joist-core";
+//#region src/limitPagination.d.ts
+type LimitArgs<T extends Entity, F extends object = PaginationFilter<T>> = {
+  filter?: F | null;
+  limit?: number | null;
+  offset?: number | null;
+};
+type Page = {
+  offset: number;
+  limit: number;
+};
+/** Returns a limit/offset page shape for a generated query resolver. */
+declare function paginateLimit<T extends Entity, F extends object = PaginationFilter<T>>(ctx: ContextWithEm, type: MaybeAbstractEntityConstructor<T>, args: LimitArgs<T, F>): Promise<{
+  entities: T[];
+  pageInfo: LimitPageInfo<T>;
+}>;
+/** Lazily computes limit/offset page fields. */
+declare class LimitPageInfo<T extends Entity = Entity> {
+  #private;
+  constructor(ctx: ContextWithEm, type: MaybeAbstractEntityConstructor<T>, filter: PaginationFilter<T>, page: Page);
+  get hasNextPage(): Promise<boolean>;
+  get hasPreviousPage(): boolean;
+  get totalCount(): Promise<number>;
+  get nextPage(): Promise<number | undefined>;
+  get currentPage(): number;
+}
+//#endregion
+export { LimitPageInfo, paginateLimit };
+//# sourceMappingURL=limitPagination.d.mts.map

package/build/limitPagination.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limitPagination.d.mts","names":[],"sources":["../src/limitPagination.ts"],"mappings":";;;KAIK,UAAU,UAAU,QAAQ,mBAAmB,iBAAiB;EACnE,SAAS;EACT;EACA;;KAEG;EAAS;EAAgB;;;iBAGR,cAAc,UAAU,QAAQ,mBAAmB,iBAAiB,IACxF,KAAK,eACL,MAAM,+BAA+B,IACrC,MAAM,UAAU,GAAG,KAClB;EAAU,UAAU;EAAK,UAAU,cAAc;;;cASvC,cAAc,UAAU,SAAS;;EAO5C,YAAY,KAAK,eAAe,MAAM,+BAA+B,IAAI,QAAQ,iBAAiB,IAAI,MAAM;MAOxG,eAAe;MAIf;MAIA,cAAc;MAId,YAAY;MAIZ"}

package/build/limitPagination.js

@@ -1,56 +1,63 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LimitPageInfo = void 0;
-exports.paginateLimit = paginateLimit;
-const paginationUtils_1 = require("./paginationUtils");
+import "./paginationUtils.js";
+import "joist-core";
+//#region src/limitPagination.ts
 /** Returns a limit/offset page shape for a generated query resolver. */
 async function paginateLimit(ctx, type, args) {
-    const limit = args.limit ?? paginationUtils_1.defaultLimit;
-    const offset = args.offset ?? 0;
-    const filter = (args.filter ?? {});
-    const entities = await ctx.em.findGql(type, filter, { limit, offset });
-    return { entities, pageInfo: new LimitPageInfo(ctx, type, filter, { limit, offset }) };
+	const limit = args.limit ?? 100;
+	const offset = args.offset ?? 0;
+	const filter = args.filter ?? {};
+	return {
+		entities: await ctx.em.findGql(type, filter, {
+			limit,
+			offset
+		}),
+		pageInfo: new LimitPageInfo(ctx, type, filter, {
+			limit,
+			offset
+		})
+	};
 }
 /** Lazily computes limit/offset page fields. */
-class LimitPageInfo {
-    #ctx;
-    #filter;
-    #page;
-    #totalCountPromise;
-    #type;
-    constructor(ctx, type, filter, page) {
-        this.#ctx = ctx;
-        this.#type = type;
-        this.#filter = filter;
-        this.#page = page;
-    }
-    get hasNextPage() {
-        return this.#hasNextPage();
-    }
-    get hasPreviousPage() {
-        return this.#page.offset > 0;
-    }
-    get totalCount() {
-        return (this.#totalCountPromise ??= this.#ctx.em.findCount(this.#type, this.#filter));
-    }
-    get nextPage() {
-        return this.#nextPage();
-    }
-    get currentPage() {
-        return Math.floor(this.#page.offset / this.#page.limit) + 1;
-    }
-    /** Returns whether another page exists after this page. */
-    async #hasNextPage() {
-        const total = await this.totalCount;
-        const { offset, limit } = this.#page;
-        return offset + limit < total;
-    }
-    /** Returns the next limit/offset page if there is one. */
-    async #nextPage() {
-        if (!(await this.hasNextPage))
-            return undefined;
-        return this.currentPage + 1;
-    }
-}
-exports.LimitPageInfo = LimitPageInfo;
+var LimitPageInfo = class {
+	#ctx;
+	#filter;
+	#page;
+	#totalCountPromise;
+	#type;
+	constructor(ctx, type, filter, page) {
+		this.#ctx = ctx;
+		this.#type = type;
+		this.#filter = filter;
+		this.#page = page;
+	}
+	get hasNextPage() {
+		return this.#hasNextPage();
+	}
+	get hasPreviousPage() {
+		return this.#page.offset > 0;
+	}
+	get totalCount() {
+		return this.#totalCountPromise ??= this.#ctx.em.findCount(this.#type, this.#filter);
+	}
+	get nextPage() {
+		return this.#nextPage();
+	}
+	get currentPage() {
+		return Math.floor(this.#page.offset / this.#page.limit) + 1;
+	}
+	/** Returns whether another page exists after this page. */
+	async #hasNextPage() {
+		const total = await this.totalCount;
+		const { offset, limit } = this.#page;
+		return offset + limit < total;
+	}
+	/** Returns the next limit/offset page if there is one. */
+	async #nextPage() {
+		if (!await this.hasNextPage) return void 0;
+		return this.currentPage + 1;
+	}
+};
+//#endregion
+export { LimitPageInfo, paginateLimit };
+
 //# sourceMappingURL=limitPagination.js.map

package/build/limitPagination.js.map

@@ -1 +1 @@
-{"version":3,"file":"limitPagination.js","sourceRoot":"","sources":["../src/limitPagination.ts"],"names":[],"mappings":";;;AAWA,sCAUC;AApBD,uDAA4F;AAS5F,wEAAwE;AACjE,KAAK,UAAU,aAAa,CACjC,GAAkB,EAClB,IAAuC,EACvC,IAAqB;IAErB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,8BAAY,CAAC;IACzC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;IAChC,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAwB,CAAC;IAC1D,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;IACvE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;AACzF,CAAC;AAED,gDAAgD;AAChD,MAAa,aAAa;IACxB,IAAI,CAAgB;IACpB,OAAO,CAAsB;IAC7B,KAAK,CAAO;IACZ,kBAAkB,CAA8B;IAChD,KAAK,CAAoC;IAEzC,YAAY,GAAkB,EAAE,IAAuC,EAAE,MAA2B,EAAE,IAAU;QAC9G,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC;IAC7B,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI,UAAU;QACZ,OAAO,CAAC,IAAI,CAAC,kBAAkB,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACxF,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;IAC1B,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC9D,CAAC;IAED,2DAA2D;IAC3D,KAAK,CAAC,YAAY;QAChB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC;QACpC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QACrC,OAAO,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAChC,CAAC;IAED,0DAA0D;IAC1D,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC;YAAE,OAAO,SAAS,CAAC;QAChD,OAAO,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;IAC9B,CAAC;CACF;AA9CD,sCA8CC"}
+{"version":3,"file":"limitPagination.js","names":["#ctx","#type","#filter","#page","#hasNextPage","#totalCountPromise","#nextPage"],"sources":["../src/limitPagination.ts"],"sourcesContent":["import { type Entity, type MaybeAbstractEntityConstructor } from \"joist-core\";\n\nimport { type ContextWithEm, type PaginationFilter, defaultLimit } from \"./paginationUtils.ts\";\n\ntype LimitArgs<T extends Entity, F extends object = PaginationFilter<T>> = {\n  filter?: F | null;\n  limit?: number | null;\n  offset?: number | null;\n};\ntype Page = { offset: number; limit: number };\n\n/** Returns a limit/offset page shape for a generated query resolver. */\nexport async function paginateLimit<T extends Entity, F extends object = PaginationFilter<T>>(\n  ctx: ContextWithEm,\n  type: MaybeAbstractEntityConstructor<T>,\n  args: LimitArgs<T, F>,\n): Promise<{ entities: T[]; pageInfo: LimitPageInfo<T> }> {\n  const limit = args.limit ?? defaultLimit;\n  const offset = args.offset ?? 0;\n  const filter = (args.filter ?? {}) as PaginationFilter<T>;\n  const entities = await ctx.em.findGql(type, filter, { limit, offset });\n  return { entities, pageInfo: new LimitPageInfo(ctx, type, filter, { limit, offset }) };\n}\n\n/** Lazily computes limit/offset page fields. */\nexport class LimitPageInfo<T extends Entity = Entity> {\n  #ctx: ContextWithEm;\n  #filter: PaginationFilter<T>;\n  #page: Page;\n  #totalCountPromise: Promise<number> | undefined;\n  #type: MaybeAbstractEntityConstructor<T>;\n\n  constructor(ctx: ContextWithEm, type: MaybeAbstractEntityConstructor<T>, filter: PaginationFilter<T>, page: Page) {\n    this.#ctx = ctx;\n    this.#type = type;\n    this.#filter = filter;\n    this.#page = page;\n  }\n\n  get hasNextPage(): Promise<boolean> {\n    return this.#hasNextPage();\n  }\n\n  get hasPreviousPage(): boolean {\n    return this.#page.offset > 0;\n  }\n\n  get totalCount(): Promise<number> {\n    return (this.#totalCountPromise ??= this.#ctx.em.findCount(this.#type, this.#filter));\n  }\n\n  get nextPage(): Promise<number | undefined> {\n    return this.#nextPage();\n  }\n\n  get currentPage(): number {\n    return Math.floor(this.#page.offset / this.#page.limit) + 1;\n  }\n\n  /** Returns whether another page exists after this page. */\n  async #hasNextPage(): Promise<boolean> {\n    const total = await this.totalCount;\n    const { offset, limit } = this.#page;\n    return offset + limit < total;\n  }\n\n  /** Returns the next limit/offset page if there is one. */\n  async #nextPage(): Promise<number | undefined> {\n    if (!(await this.hasNextPage)) return undefined;\n    return this.currentPage + 1;\n  }\n}\n"],"mappings":";;;;AAYA,eAAsB,cACpB,KACA,MACA,MACwD;CACxD,MAAM,QAAQ,KAAK,SAAA;CACnB,MAAM,SAAS,KAAK,UAAU;CAC9B,MAAM,SAAU,KAAK,UAAU,CAAC;CAEhC,OAAO;EAAE,UAAA,MADc,IAAI,GAAG,QAAQ,MAAM,QAAQ;GAAE;GAAO;EAAO,CAAC;EAClD,UAAU,IAAI,cAAc,KAAK,MAAM,QAAQ;GAAE;GAAO;EAAO,CAAC;CAAE;AACvF;;AAGA,IAAa,gBAAb,MAAsD;CACpD;CACA;CACA;CACA;CACA;CAEA,YAAY,KAAoB,MAAyC,QAA6B,MAAY;EAChH,KAAKA,OAAO;EACZ,KAAKC,QAAQ;EACb,KAAKC,UAAU;EACf,KAAKC,QAAQ;CACf;CAEA,IAAI,cAAgC;EAClC,OAAO,KAAKC,aAAa;CAC3B;CAEA,IAAI,kBAA2B;EAC7B,OAAO,KAAKD,MAAM,SAAS;CAC7B;CAEA,IAAI,aAA8B;EAChC,OAAQ,KAAKE,uBAAuB,KAAKL,KAAK,GAAG,UAAU,KAAKC,OAAO,KAAKC,OAAO;CACrF;CAEA,IAAI,WAAwC;EAC1C,OAAO,KAAKI,UAAU;CACxB;CAEA,IAAI,cAAsB;EACxB,OAAO,KAAK,MAAM,KAAKH,MAAM,SAAS,KAAKA,MAAM,KAAK,IAAI;CAC5D;;CAGA,MAAMC,eAAiC;EACrC,MAAM,QAAQ,MAAM,KAAK;EACzB,MAAM,EAAE,QAAQ,UAAU,KAAKD;EAC/B,OAAO,SAAS,QAAQ;CAC1B;;CAGA,MAAMG,YAAyC;EAC7C,IAAI,CAAE,MAAM,KAAK,aAAc,OAAO,KAAA;EACtC,OAAO,KAAK,cAAc;CAC5B;AACF"}

package/build/makeRunInputMutation.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./context.cjs");
+require("./typeUtils.cjs");
+//#region src/makeRunInputMutation.ts
+/**
+* Creates a `makeRunInputMutation` function for each project's `testUtils` file.
+*
+* This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
+* that is customized (basically curried) to their own `newContext` function.
+*/
+function makeMakeRunInputMutation(runFn) {
+	return (resolver) => {
+		return (ctx, args) => runFn(ctx, (ctx) => {
+			return resolver[Object.keys(resolver)[0]]({}, { input: args instanceof Function ? args() : args ?? {} }, ctx, void 0);
+		});
+	};
+}
+//#endregion
+exports.makeMakeRunInputMutation = makeMakeRunInputMutation;
+
+//# sourceMappingURL=makeRunInputMutation.cjs.map

package/build/makeRunInputMutation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunInputMutation.cjs","names":[],"sources":["../src/makeRunInputMutation.ts"],"sourcesContent":["import { type Resolver } from \"./context.ts\";\nimport { type ResolverResult, type RunFn } from \"./typeUtils.ts\";\n\n/**\n * Creates a `makeRunInputMutation` function for each project's `testUtils` file.\n *\n * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory\n * that is customized (basically curried) to their own `newContext` function.\n */\nexport function makeMakeRunInputMutation<C>(runFn: RunFn<C>): MakeRunInputMutation<C> {\n  return (resolver) => {\n    return (ctx, args) =>\n      runFn(ctx, (ctx) => {\n        const key = Object.keys(resolver)[0];\n        return ((resolver as any)[key] as any)(\n          {},\n          { input: args instanceof Function ? args() : (args ?? {}) },\n          ctx,\n          undefined!,\n        );\n      });\n  };\n}\n\n/**\n * Creates a `run` method to invoke a mutation resolver that uses the `input` convention.\n *\n * Following our `mutation / foo` conventions, `resolver` will have a single `fooResolver.foo` method.\n */\nexport type MakeRunInputMutation<C> = <T extends object>(resolver: T) => RunInputMutationMethod<C, T>;\n\ntype RunInputMutationMethod<C, T> = <I extends MutationInput<T>, R = ResolverResult<T, keyof T>>(\n  ctx: C,\n  input: I | (() => I),\n) => Promise<R>;\n\n/** Matches a mutation resolver that has a single `input` field. */\ntype MutationInput<T> = T[keyof T] extends Resolver<any, { input: infer I }, any> ? I : never;\n"],"mappings":";;;;;;;;;;AASA,SAAgB,yBAA4B,OAA0C;CACpF,QAAQ,aAAa;EACnB,QAAQ,KAAK,SACX,MAAM,MAAM,QAAQ;GAElB,OAAS,SADG,OAAO,KAAK,QAAQ,CAAC,CAAC,GACJ,CAC5B,CAAC,GACD,EAAE,OAAO,gBAAgB,WAAW,KAAK,IAAK,QAAQ,CAAC,EAAG,GAC1D,KACA,KAAA,CACF;EACF,CAAC;CACL;AACF"}

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

@@ -1,22 +1,24 @@
-import { Resolver } from "./context";
-import { ResolverResult, RunFn } from "./typeUtils";
+import { Resolver } from "./context.cjs";
+import { ResolverResult, RunFn } from "./typeUtils.cjs";
+//#region src/makeRunInputMutation.d.ts
 /**
  * Creates a `makeRunInputMutation` function for each project's `testUtils` file.
  *
  * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
  * that is customized (basically curried) to their own `newContext` function.
  */
-export declare function makeMakeRunInputMutation<C>(runFn: RunFn<C>): MakeRunInputMutation<C>;
+declare function makeMakeRunInputMutation<C>(runFn: RunFn<C>): MakeRunInputMutation<C>;
 /**
  * Creates a `run` method to invoke a mutation resolver that uses the `input` convention.
  *
  * Following our `mutation / foo` conventions, `resolver` will have a single `fooResolver.foo` method.
  */
-export type MakeRunInputMutation<C> = <T extends object>(resolver: T) => RunInputMutationMethod<C, T>;
+type MakeRunInputMutation<C> = <T extends object>(resolver: T) => RunInputMutationMethod<C, T>;
 type RunInputMutationMethod<C, T> = <I extends MutationInput<T>, R = ResolverResult<T, keyof T>>(ctx: C, input: I | (() => I)) => Promise<R>;
 /** Matches a mutation resolver that has a single `input` field. */
 type MutationInput<T> = T[keyof T] extends Resolver<any, {
-    input: infer I;
+  input: infer I;
 }, any> ? I : never;
-export {};
-//# sourceMappingURL=makeRunInputMutation.d.ts.map
+//#endregion
+export { MakeRunInputMutation, makeMakeRunInputMutation };
+//# sourceMappingURL=makeRunInputMutation.d.cts.map

package/build/makeRunInputMutation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunInputMutation.d.cts","names":[],"sources":["../src/makeRunInputMutation.ts"],"mappings":";;;;;;;;;iBASgB,yBAAyB,GAAG,OAAO,MAAM,KAAK,qBAAqB;;;;;;KAoBvE,qBAAqB,MAAM,kBAAkB,UAAU,MAAM,uBAAuB,GAAG;KAE9F,uBAAuB,GAAG,MAAM,UAAU,cAAc,IAAI,IAAI,eAAe,SAAS,IAC3F,KAAK,GACL,OAAO,WAAW,OACf,QAAQ;;KAGR,cAAc,KAAK,QAAQ,WAAW;EAAgB,aAAa;UAAY"}

package/build/makeRunInputMutation.d.mts

@@ -0,0 +1,24 @@
+import { Resolver } from "./context.mjs";
+import { ResolverResult, RunFn } from "./typeUtils.mjs";
+//#region src/makeRunInputMutation.d.ts
+/**
+ * Creates a `makeRunInputMutation` function for each project's `testUtils` file.
+ *
+ * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
+ * that is customized (basically curried) to their own `newContext` function.
+ */
+declare function makeMakeRunInputMutation<C>(runFn: RunFn<C>): MakeRunInputMutation<C>;
+/**
+ * Creates a `run` method to invoke a mutation resolver that uses the `input` convention.
+ *
+ * Following our `mutation / foo` conventions, `resolver` will have a single `fooResolver.foo` method.
+ */
+type MakeRunInputMutation<C> = <T extends object>(resolver: T) => RunInputMutationMethod<C, T>;
+type RunInputMutationMethod<C, T> = <I extends MutationInput<T>, R = ResolverResult<T, keyof T>>(ctx: C, input: I | (() => I)) => Promise<R>;
+/** Matches a mutation resolver that has a single `input` field. */
+type MutationInput<T> = T[keyof T] extends Resolver<any, {
+  input: infer I;
+}, any> ? I : never;
+//#endregion
+export { MakeRunInputMutation, makeMakeRunInputMutation };
+//# sourceMappingURL=makeRunInputMutation.d.mts.map

package/build/makeRunInputMutation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunInputMutation.d.mts","names":[],"sources":["../src/makeRunInputMutation.ts"],"mappings":";;;;;;;;;iBASgB,yBAAyB,GAAG,OAAO,MAAM,KAAK,qBAAqB;;;;;;KAoBvE,qBAAqB,MAAM,kBAAkB,UAAU,MAAM,uBAAuB,GAAG;KAE9F,uBAAuB,GAAG,MAAM,UAAU,cAAc,IAAI,IAAI,eAAe,SAAS,IAC3F,KAAK,GACL,OAAO,WAAW,OACf,QAAQ;;KAGR,cAAc,KAAK,QAAQ,WAAW;EAAgB,aAAa;UAAY"}

package/build/makeRunInputMutation.js

@@ -1,18 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMakeRunInputMutation = makeMakeRunInputMutation;
+import "./context.js";
+import "./typeUtils.js";
+//#region src/makeRunInputMutation.ts
 /**
- * Creates a `makeRunInputMutation` function for each project's `testUtils` file.
- *
- * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
- * that is customized (basically curried) to their own `newContext` function.
- */
+* Creates a `makeRunInputMutation` function for each project's `testUtils` file.
+*
+* This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
+* that is customized (basically curried) to their own `newContext` function.
+*/
 function makeMakeRunInputMutation(runFn) {
-    return (resolver) => {
-        return (ctx, args) => runFn(ctx, (ctx) => {
-            const key = Object.keys(resolver)[0];
-            return resolver[key]({}, { input: args instanceof Function ? args() : (args ?? {}) }, ctx, undefined);
-        });
-    };
+	return (resolver) => {
+		return (ctx, args) => runFn(ctx, (ctx) => {
+			return resolver[Object.keys(resolver)[0]]({}, { input: args instanceof Function ? args() : args ?? {} }, ctx, void 0);
+		});
+	};
 }
+//#endregion
+export { makeMakeRunInputMutation };
+
 //# sourceMappingURL=makeRunInputMutation.js.map

package/build/makeRunInputMutation.js.map

@@ -1 +1 @@
-{"version":3,"file":"makeRunInputMutation.js","sourceRoot":"","sources":["../src/makeRunInputMutation.ts"],"names":[],"mappings":";;AASA,4DAaC;AAnBD;;;;;GAKG;AACH,SAAgB,wBAAwB,CAAI,KAAe;IACzD,OAAO,CAAC,QAAQ,EAAE,EAAE;QAClB,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CACnB,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE;YACjB,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACrC,OAAS,QAAgB,CAAC,GAAG,CAAS,CACpC,EAAE,EACF,EAAE,KAAK,EAAE,IAAI,YAAY,QAAQ,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EAC3D,GAAG,EACH,SAAU,CACX,CAAC;QACJ,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"makeRunInputMutation.js","names":[],"sources":["../src/makeRunInputMutation.ts"],"sourcesContent":["import { type Resolver } from \"./context.ts\";\nimport { type ResolverResult, type RunFn } from \"./typeUtils.ts\";\n\n/**\n * Creates a `makeRunInputMutation` function for each project's `testUtils` file.\n *\n * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory\n * that is customized (basically curried) to their own `newContext` function.\n */\nexport function makeMakeRunInputMutation<C>(runFn: RunFn<C>): MakeRunInputMutation<C> {\n  return (resolver) => {\n    return (ctx, args) =>\n      runFn(ctx, (ctx) => {\n        const key = Object.keys(resolver)[0];\n        return ((resolver as any)[key] as any)(\n          {},\n          { input: args instanceof Function ? args() : (args ?? {}) },\n          ctx,\n          undefined!,\n        );\n      });\n  };\n}\n\n/**\n * Creates a `run` method to invoke a mutation resolver that uses the `input` convention.\n *\n * Following our `mutation / foo` conventions, `resolver` will have a single `fooResolver.foo` method.\n */\nexport type MakeRunInputMutation<C> = <T extends object>(resolver: T) => RunInputMutationMethod<C, T>;\n\ntype RunInputMutationMethod<C, T> = <I extends MutationInput<T>, R = ResolverResult<T, keyof T>>(\n  ctx: C,\n  input: I | (() => I),\n) => Promise<R>;\n\n/** Matches a mutation resolver that has a single `input` field. */\ntype MutationInput<T> = T[keyof T] extends Resolver<any, { input: infer I }, any> ? I : never;\n"],"mappings":";;;;;;;;;AASA,SAAgB,yBAA4B,OAA0C;CACpF,QAAQ,aAAa;EACnB,QAAQ,KAAK,SACX,MAAM,MAAM,QAAQ;GAElB,OAAS,SADG,OAAO,KAAK,QAAQ,CAAC,CAAC,GACJ,CAC5B,CAAC,GACD,EAAE,OAAO,gBAAgB,WAAW,KAAK,IAAK,QAAQ,CAAC,EAAG,GAC1D,KACA,KAAA,CACF;EACF,CAAC;CACL;AACF"}

package/build/makeRunObjectField.cjs

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./typeUtils.cjs");
+let joist_core = require("joist-core");
+//#region src/makeRunObjectField.ts
+/**
+* Creates a `makeRunObjectField` function for each project's `testUtils` file.
+*
+* This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
+* that is customized (basically curried) to their own `newContext` function.
+*/
+function makeMakeRunObjectField(runFn) {
+	return (resolvers) => {
+		return (ctx, root, key, args) => runFn(ctx, async (ctx) => {
+			const _root = (0, joist_core.isEntity)(root) ? await ctx.em.load(root.id) : root;
+			return resolvers[key](_root, args instanceof Function ? args(_root) : args ?? {}, ctx, void 0);
+		});
+	};
+}
+//#endregion
+exports.makeMakeRunObjectField = makeMakeRunObjectField;
+
+//# sourceMappingURL=makeRunObjectField.cjs.map

package/build/makeRunObjectField.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunObjectField.cjs","names":["isEntity"],"sources":["../src/makeRunObjectField.ts"],"sourcesContent":["import { isEntity } from \"joist-core\";\n\nimport { type ResolverArgs, type ResolverResult, type ResolverRoot, type RunFn } from \"./typeUtils.ts\";\n\n/**\n * Creates a `makeRunObjectField` function for each project's `testUtils` file.\n *\n * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory\n * that is customized (basically curried) to their own `newContext` function.\n */\nexport function makeMakeRunObjectField<C>(runFn: RunFn<C>): MakeRunObjectField<C> {\n  return (resolvers) => {\n    return (ctx, root, key, args) =>\n      runFn(ctx, async (ctx) => {\n        // Sneak in a Joist-ism that will load the entity in the new em\n        const _root = isEntity(root) ? await (ctx as any).em.load((root as any).id) : root;\n        return (resolvers[key] as any)(_root, args instanceof Function ? args(_root) : (args ?? {}), ctx, undefined!);\n      });\n  };\n}\n\n/** Creates a `run` method to invoke a single field resolver with that field's args. */\nexport type MakeRunObjectField<C> = <T extends object, R extends ResolverRoot<T>>(\n  resolvers: T,\n) => RunObjectFieldMethod<C, T, R>;\n\n/** The return type of `makeRunObject`. */\ntype RunObjectFieldMethod<C, T, R> = <K extends keyof T, A extends ResolverArgs<T, K>>(\n  ctx: C,\n  root: R,\n  key: K,\n  // Support either the resolver arg directly or a lambda to create the args post-flush\n  args?: A | ((root: R) => A),\n) => Promise<ResolverResult<T, K>>;\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,uBAA0B,OAAwC;CAChF,QAAQ,cAAc;EACpB,QAAQ,KAAK,MAAM,KAAK,SACtB,MAAM,KAAK,OAAO,QAAQ;GAExB,MAAM,SAAA,GAAQA,WAAAA,SAAAA,CAAS,IAAI,IAAI,MAAO,IAAY,GAAG,KAAM,KAAa,EAAE,IAAI;GAC9E,OAAQ,UAAU,IAAI,CAAS,OAAO,gBAAgB,WAAW,KAAK,KAAK,IAAK,QAAQ,CAAC,GAAI,KAAK,KAAA,CAAU;EAC9G,CAAC;CACL;AACF"}

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

@@ -1,14 +1,16 @@
-import { ResolverArgs, ResolverResult, ResolverRoot, RunFn } from "./typeUtils";
+import { ResolverArgs, ResolverResult, ResolverRoot, RunFn } from "./typeUtils.cjs";
+//#region src/makeRunObjectField.d.ts
 /**
  * Creates a `makeRunObjectField` function for each project's `testUtils` file.
  *
  * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
  * that is customized (basically curried) to their own `newContext` function.
  */
-export declare function makeMakeRunObjectField<C>(runFn: RunFn<C>): MakeRunObjectField<C>;
+declare function makeMakeRunObjectField<C>(runFn: RunFn<C>): MakeRunObjectField<C>;
 /** Creates a `run` method to invoke a single field resolver with that field's args. */
-export type MakeRunObjectField<C> = <T extends object, R extends ResolverRoot<T>>(resolvers: T) => RunObjectFieldMethod<C, T, R>;
+type MakeRunObjectField<C> = <T extends object, R extends ResolverRoot<T>>(resolvers: T) => RunObjectFieldMethod<C, T, R>;
 /** The return type of `makeRunObject`. */
 type RunObjectFieldMethod<C, T, R> = <K extends keyof T, A extends ResolverArgs<T, K>>(ctx: C, root: R, key: K, args?: A | ((root: R) => A)) => Promise<ResolverResult<T, K>>;
-export {};
-//# sourceMappingURL=makeRunObjectField.d.ts.map
+//#endregion
+export { MakeRunObjectField, makeMakeRunObjectField };
+//# sourceMappingURL=makeRunObjectField.d.cts.map

package/build/makeRunObjectField.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunObjectField.d.cts","names":[],"sources":["../src/makeRunObjectField.ts"],"mappings":";;;;;;;;iBAUgB,uBAAuB,GAAG,OAAO,MAAM,KAAK,mBAAmB;;KAYnE,mBAAmB,MAAM,kBAAkB,UAAU,aAAa,IAC5E,WAAW,MACR,qBAAqB,GAAG,GAAG;;KAG3B,qBAAqB,GAAG,GAAG,MAAM,gBAAgB,GAAG,UAAU,aAAa,GAAG,IACjF,KAAK,GACL,MAAM,GACN,KAAK,GAEL,OAAO,MAAM,MAAM,MAAM,OACtB,QAAQ,eAAe,GAAG"}

package/build/makeRunObjectField.d.mts

@@ -0,0 +1,16 @@
+import { ResolverArgs, ResolverResult, ResolverRoot, RunFn } from "./typeUtils.mjs";
+//#region src/makeRunObjectField.d.ts
+/**
+ * Creates a `makeRunObjectField` function for each project's `testUtils` file.
+ *
+ * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
+ * that is customized (basically curried) to their own `newContext` function.
+ */
+declare function makeMakeRunObjectField<C>(runFn: RunFn<C>): MakeRunObjectField<C>;
+/** Creates a `run` method to invoke a single field resolver with that field's args. */
+type MakeRunObjectField<C> = <T extends object, R extends ResolverRoot<T>>(resolvers: T) => RunObjectFieldMethod<C, T, R>;
+/** The return type of `makeRunObject`. */
+type RunObjectFieldMethod<C, T, R> = <K extends keyof T, A extends ResolverArgs<T, K>>(ctx: C, root: R, key: K, args?: A | ((root: R) => A)) => Promise<ResolverResult<T, K>>;
+//#endregion
+export { MakeRunObjectField, makeMakeRunObjectField };
+//# sourceMappingURL=makeRunObjectField.d.mts.map

package/build/makeRunObjectField.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunObjectField.d.mts","names":[],"sources":["../src/makeRunObjectField.ts"],"mappings":";;;;;;;;iBAUgB,uBAAuB,GAAG,OAAO,MAAM,KAAK,mBAAmB;;KAYnE,mBAAmB,MAAM,kBAAkB,UAAU,aAAa,IAC5E,WAAW,MACR,qBAAqB,GAAG,GAAG;;KAG3B,qBAAqB,GAAG,GAAG,MAAM,gBAAgB,GAAG,UAAU,aAAa,GAAG,IACjF,KAAK,GACL,MAAM,GACN,KAAK,GAEL,OAAO,MAAM,MAAM,MAAM,OACtB,QAAQ,eAAe,GAAG"}

package/build/makeRunObjectField.js

@@ -1,20 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMakeRunObjectField = makeMakeRunObjectField;
-const joist_core_1 = require("joist-core");
+import "./typeUtils.js";
+import { isEntity } from "joist-core";
+//#region src/makeRunObjectField.ts
 /**
- * Creates a `makeRunObjectField` function for each project's `testUtils` file.
- *
- * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
- * that is customized (basically curried) to their own `newContext` function.
- */
+* Creates a `makeRunObjectField` function for each project's `testUtils` file.
+*
+* This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
+* that is customized (basically curried) to their own `newContext` function.
+*/
 function makeMakeRunObjectField(runFn) {
-    return (resolvers) => {
-        return (ctx, root, key, args) => runFn(ctx, async (ctx) => {
-            // Sneak in a Joist-ism that will load the entity in the new em
-            const _root = (0, joist_core_1.isEntity)(root) ? await ctx.em.load(root.id) : root;
-            return resolvers[key](_root, args instanceof Function ? args(_root) : (args ?? {}), ctx, undefined);
-        });
-    };
+	return (resolvers) => {
+		return (ctx, root, key, args) => runFn(ctx, async (ctx) => {
+			const _root = isEntity(root) ? await ctx.em.load(root.id) : root;
+			return resolvers[key](_root, args instanceof Function ? args(_root) : args ?? {}, ctx, void 0);
+		});
+	};
 }
+//#endregion
+export { makeMakeRunObjectField };
+
 //# sourceMappingURL=makeRunObjectField.js.map

package/build/makeRunObjectField.js.map

@@ -1 +1 @@
-{"version":3,"file":"makeRunObjectField.js","sourceRoot":"","sources":["../src/makeRunObjectField.ts"],"names":[],"mappings":";;AASA,wDASC;AAlBD,2CAAsC;AAGtC;;;;;GAKG;AACH,SAAgB,sBAAsB,CAAI,KAAe;IACvD,OAAO,CAAC,SAAS,EAAE,EAAE;QACnB,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,CAC9B,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;YACvB,+DAA+D;YAC/D,MAAM,KAAK,GAAG,IAAA,qBAAQ,EAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAO,GAAW,CAAC,EAAE,CAAC,IAAI,CAAE,IAAY,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YACnF,OAAQ,SAAS,CAAC,GAAG,CAAS,CAAC,KAAK,EAAE,IAAI,YAAY,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,SAAU,CAAC,CAAC;QAChH,CAAC,CAAC,CAAC;IACP,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"makeRunObjectField.js","names":[],"sources":["../src/makeRunObjectField.ts"],"sourcesContent":["import { isEntity } from \"joist-core\";\n\nimport { type ResolverArgs, type ResolverResult, type ResolverRoot, type RunFn } from \"./typeUtils.ts\";\n\n/**\n * Creates a `makeRunObjectField` function for each project's `testUtils` file.\n *\n * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory\n * that is customized (basically curried) to their own `newContext` function.\n */\nexport function makeMakeRunObjectField<C>(runFn: RunFn<C>): MakeRunObjectField<C> {\n  return (resolvers) => {\n    return (ctx, root, key, args) =>\n      runFn(ctx, async (ctx) => {\n        // Sneak in a Joist-ism that will load the entity in the new em\n        const _root = isEntity(root) ? await (ctx as any).em.load((root as any).id) : root;\n        return (resolvers[key] as any)(_root, args instanceof Function ? args(_root) : (args ?? {}), ctx, undefined!);\n      });\n  };\n}\n\n/** Creates a `run` method to invoke a single field resolver with that field's args. */\nexport type MakeRunObjectField<C> = <T extends object, R extends ResolverRoot<T>>(\n  resolvers: T,\n) => RunObjectFieldMethod<C, T, R>;\n\n/** The return type of `makeRunObject`. */\ntype RunObjectFieldMethod<C, T, R> = <K extends keyof T, A extends ResolverArgs<T, K>>(\n  ctx: C,\n  root: R,\n  key: K,\n  // Support either the resolver arg directly or a lambda to create the args post-flush\n  args?: A | ((root: R) => A),\n) => Promise<ResolverResult<T, K>>;\n"],"mappings":";;;;;;;;;AAUA,SAAgB,uBAA0B,OAAwC;CAChF,QAAQ,cAAc;EACpB,QAAQ,KAAK,MAAM,KAAK,SACtB,MAAM,KAAK,OAAO,QAAQ;GAExB,MAAM,QAAQ,SAAS,IAAI,IAAI,MAAO,IAAY,GAAG,KAAM,KAAa,EAAE,IAAI;GAC9E,OAAQ,UAAU,IAAI,CAAS,OAAO,gBAAgB,WAAW,KAAK,KAAK,IAAK,QAAQ,CAAC,GAAI,KAAK,KAAA,CAAU;EAC9G,CAAC;CACL;AACF"}

package/build/makeRunObjectFields.cjs

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./typeUtils.cjs");
+let joist_core = require("joist-core");
+//#region src/makeRunObjectFields.ts
+/**
+* Creates a `makeRunObjectFields` function for each project's `testUtils` file.
+*
+* This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
+* that is customized (basically curried) to their own `newContext` function.
+*/
+function makeMakeRunObjectFields(runFn) {
+	return (resolver) => {
+		return (ctx, root, fields) => {
+			return runFn(ctx, async (ctx) => {
+				const _root = (0, joist_core.isEntity)(root) ? await ctx.em.load(root.id) : root;
+				return Object.fromEntries(await Promise.all(fields.map(async (key) => [key, await resolver[key](_root, {}, ctx, void 0)])));
+			});
+		};
+	};
+}
+//#endregion
+exports.makeMakeRunObjectFields = makeMakeRunObjectFields;
+
+//# sourceMappingURL=makeRunObjectFields.cjs.map

package/build/makeRunObjectFields.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunObjectFields.cjs","names":["isEntity"],"sources":["../src/makeRunObjectFields.ts"],"sourcesContent":["import { isEntity } from \"joist-core\";\n\nimport { type ResolverResult, type ResolverRoot, type RunFn } from \"./typeUtils.ts\";\n\n/**\n * Creates a `makeRunObjectFields` function for each project's `testUtils` file.\n *\n * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory\n * that is customized (basically curried) to their own `newContext` function.\n */\nexport function makeMakeRunObjectFields<C, T>(runFn: RunFn<C>): MakeRunObjectFields<C> {\n  return (resolver) => {\n    return (ctx, root, fields) => {\n      return runFn(ctx, async (ctx) => {\n        // Sneak in a Joist-ism that will load the entity in the new em\n        const _root = isEntity(root) ? await (ctx as any).em.load((root as any).id) : root;\n        // Build a result with each key, where fields might return a promise, so we `await` to make assertions easier\n        return Object.fromEntries(\n          await Promise.all(fields.map(async (key) => [key, await (resolver[key] as any)(_root, {}, ctx, undefined!)])),\n        );\n      });\n    };\n  };\n}\n\n/** Creates a `run` method that can invoke multiple fields against an object resolver. */\nexport type MakeRunObjectFields<C> = <T, R extends ResolverRoot<T>>(resolvers: T) => RunFieldsResolverMethod<C, T, R>;\n\n// The return type for makeRunResolverKeys\ntype RunFieldsResolverMethod<C, T, R extends ResolverRoot<T>> = <K extends (keyof T)[]>(\n  ctx: C,\n  root: R,\n  keys: K,\n) => Promise<{ [k in K[number]]: ResolverResult<T, k> }>;\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,wBAA8B,OAAyC;CACrF,QAAQ,aAAa;EACnB,QAAQ,KAAK,MAAM,WAAW;GAC5B,OAAO,MAAM,KAAK,OAAO,QAAQ;IAE/B,MAAM,SAAA,GAAQA,WAAAA,SAAAA,CAAS,IAAI,IAAI,MAAO,IAAY,GAAG,KAAM,KAAa,EAAE,IAAI;IAE9E,OAAO,OAAO,YACZ,MAAM,QAAQ,IAAI,OAAO,IAAI,OAAO,QAAQ,CAAC,KAAK,MAAO,SAAS,IAAI,CAAS,OAAO,CAAC,GAAG,KAAK,KAAA,CAAU,CAAC,CAAC,CAAC,CAC9G;GACF,CAAC;EACH;CACF;AACF"}

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

@@ -1,15 +1,15 @@
-import { ResolverResult, ResolverRoot, RunFn } from "./typeUtils";
+import { ResolverResult, ResolverRoot, RunFn } from "./typeUtils.cjs";
+//#region src/makeRunObjectFields.d.ts
 /**
  * Creates a `makeRunObjectFields` function for each project's `testUtils` file.
  *
  * This is called `makeMake` because it's a factory for each project's `testUtils` to make its own factory
  * that is customized (basically curried) to their own `newContext` function.
  */
-export declare function makeMakeRunObjectFields<C, T>(runFn: RunFn<C>): MakeRunObjectFields<C>;
+declare function makeMakeRunObjectFields<C, T>(runFn: RunFn<C>): MakeRunObjectFields<C>;
 /** Creates a `run` method that can invoke multiple fields against an object resolver. */
-export type MakeRunObjectFields<C> = <T, R extends ResolverRoot<T>>(resolvers: T) => RunFieldsResolverMethod<C, T, R>;
-type RunFieldsResolverMethod<C, T, R extends ResolverRoot<T>> = <K extends (keyof T)[]>(ctx: C, root: R, keys: K) => Promise<{
-    [k in K[number]]: ResolverResult<T, k>;
-}>;
-export {};
-//# sourceMappingURL=makeRunObjectFields.d.ts.map
+type MakeRunObjectFields<C> = <T, R extends ResolverRoot<T>>(resolvers: T) => RunFieldsResolverMethod<C, T, R>;
+type RunFieldsResolverMethod<C, T, R extends ResolverRoot<T>> = <K extends (keyof T)[]>(ctx: C, root: R, keys: K) => Promise<{ [k in K[number]]: ResolverResult<T, k>; }>;
+//#endregion
+export { MakeRunObjectFields, makeMakeRunObjectFields };
+//# sourceMappingURL=makeRunObjectFields.d.cts.map

package/build/makeRunObjectFields.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeRunObjectFields.d.cts","names":[],"sources":["../src/makeRunObjectFields.ts"],"mappings":";;;;;;;;iBAUgB,wBAAwB,GAAG,GAAG,OAAO,MAAM,KAAK,oBAAoB;;KAgBxE,oBAAoB,MAAM,GAAG,UAAU,aAAa,IAAI,WAAW,MAAM,wBAAwB,GAAG,GAAG;KAG9G,wBAAwB,GAAG,GAAG,UAAU,aAAa,OAAO,iBAAiB,MAChF,KAAK,GACL,MAAM,GACN,MAAM,MACH,WAAW,KAAK,YAAY,eAAe,GAAG"}