@nkzw/fate 0.1.2 → 1.0.0-rc.0

package/lib/server/prisma.d.mts

@@ -0,0 +1,309 @@
+import { q as QueryProcedure, t as AnyRecord } from "../types-Dz46PXr3.mjs";
+import { S as ConnectionResult, c as SourceConfig, f as SourcePlan, k as DataView, l as SourceDefinition, o as DataViewModule, p as SourcePlanNode, s as OrderDirection, t as SourceRegistry } from "../executor-BqwHdN3n.mjs";
+import * as _$zod from "zod";
+import * as _$zod_v4_core0 from "zod/v4/core";
+
+//#region src/server/prisma.d.ts
+type PrismaDelegate = {
+  findMany?: (args: any) => Promise<Array<AnyRecord>>;
+  findUnique?: (args: any) => Promise<AnyRecord | null>;
+  groupBy?: (args: any) => Promise<Array<AnyRecord>>;
+};
+type PrismaQueryExtra = AnyRecord;
+type PrismaViewConfig<Context, Item extends AnyRecord = AnyRecord> = {
+  delegate: (ctx: Context) => unknown;
+} & SourceConfig<Item, unknown>;
+type PrismaViewsInput<Context> = Array<DataView<AnyRecord> | PrismaViewConfig<Context, AnyRecord>> | DataViewModule;
+type PrismaSourceAdapterOptions<Context> = {
+  prisma?: (ctx: Context) => unknown;
+  views: PrismaViewsInput<Context>;
+};
+type SourceTarget<Item extends AnyRecord = AnyRecord> = DataView<Item> | SourceDefinition<Item, unknown>;
+type ViewTarget<Item extends AnyRecord = AnyRecord> = DataView<Item>;
+type ListConfig = {
+  defaultSize?: number;
+};
+type ViewProcedureInput<Item extends AnyRecord, ById extends boolean | undefined, List extends boolean | ListConfig | undefined> = ViewTarget<Item> | {
+  byId?: ById;
+  list?: List;
+  view: ViewTarget<Item>;
+};
+type PrismaSourceAdapter<Context> = {
+  fetchById: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    extra,
+    id,
+    plan
+  }: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    id: string;
+    plan: SourcePlan<Item, Context>;
+  }) => Promise<Item | null>;
+  fetchByIds: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    extra,
+    ids,
+    plan
+  }: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    ids: Array<string>;
+    plan: SourcePlan<Item, Context>;
+  }) => Promise<Array<Item>>;
+  fetchConnection: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    cursor,
+    direction,
+    extra,
+    plan,
+    skip,
+    take
+  }: {
+    ctx: Context;
+    cursor?: string;
+    direction: 'backward' | 'forward';
+    extra?: PrismaQueryExtra;
+    plan: SourcePlan<Item, Context>;
+    skip?: number;
+    take: number;
+  }) => Promise<Array<Item>>;
+  getSource: <Item extends AnyRecord = AnyRecord>(target: SourceTarget<Item>) => SourceDefinition<Item, unknown>;
+  registry: SourceRegistry<Context>;
+  resolveById: <Item extends AnyRecord = AnyRecord>(options: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    id: string;
+    input: SourceInput;
+    view: ViewTarget<Item>;
+  }) => Promise<AnyRecord | null>;
+  resolveByIds: <Item extends AnyRecord = AnyRecord>(options: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    ids: Array<string>;
+    input: SourceInput;
+    view: ViewTarget<Item>;
+  }) => Promise<Array<AnyRecord>>;
+  resolveConnection: <Item extends AnyRecord = AnyRecord>(options: {
+    ctx: Context;
+    cursor?: string;
+    direction: 'backward' | 'forward';
+    extra?: PrismaQueryExtra;
+    input: SourceInput;
+    skip?: number;
+    take: number;
+    view: ViewTarget<Item>;
+  }) => Promise<Array<AnyRecord>>;
+};
+type ProcedureLike = {
+  input: (schema: any) => {
+    query: (resolver: (options: any) => unknown) => any;
+  };
+};
+type SourceInput = {
+  args?: Record<string, unknown>;
+  select: Iterable<string>;
+};
+declare const prismaConnectionArgs: ({
+  cursor,
+  direction,
+  node,
+  skip,
+  take
+}: {
+  cursor?: string;
+  direction: "backward" | "forward";
+  node: SourcePlanNode<any, any>;
+  skip?: number;
+  take: number;
+}) => {
+  orderBy: {
+    [x: string]: OrderDirection;
+  }[];
+  take: number;
+  cursor?: {
+    id: string;
+  } | undefined;
+  skip?: number | undefined;
+};
+declare function createPrismaSourceAdapter<Context>({
+  prisma,
+  views
+}: PrismaSourceAdapterOptions<Context>): PrismaSourceAdapter<Context>;
+declare const createPrismaSourceRegistry: <Context>(options: Parameters<typeof createPrismaSourceAdapter<Context>>[0]) => SourceRegistry<Context>;
+declare function createPrismaFate<Context, Procedure extends ProcedureLike>({
+  procedure,
+  ...options
+}: Parameters<typeof createPrismaSourceAdapter<Context>>[0] & {
+  procedure: Procedure;
+}): {
+  connection: <TItem, TNode = TItem, TAdditionalInput extends _$zod.ZodObject<Record<string, _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>, _$zod_v4_core0.$strip> | undefined = undefined>(options: {
+    defaultSize?: number;
+    getCursor?: ((node: TNode) => string) | undefined;
+    input?: TAdditionalInput | undefined;
+    map?: ((options: {
+      ctx: Procedure extends {
+        input: (schema: any) => {
+          query: (resolver: (options: {
+            ctx: infer TContext;
+          }) => unknown) => unknown;
+        };
+      } ? TContext : unknown;
+      input: {
+        select: string[];
+        args?: Record<string, unknown> | undefined;
+      } & {
+        args?: ((Record<string, unknown> | undefined) & (TAdditionalInput extends _$zod.ZodObject<Record<string, _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>, _$zod_v4_core0.$strip> ? _$zod.infer<TAdditionalInput> : object)) | undefined;
+      };
+      items: TItem[];
+    }) => TNode[] | Promise<TNode[]>) | undefined;
+    query: (options: {
+      ctx: Procedure extends {
+        input: (schema: any) => {
+          query: (resolver: (options: {
+            ctx: infer TContext;
+          }) => unknown) => unknown;
+        };
+      } ? TContext : unknown;
+      cursor?: string;
+      direction: "forward" | "backward";
+      input: {
+        select: string[];
+        args?: Record<string, unknown> | undefined;
+      } & {
+        args?: ((Record<string, unknown> | undefined) & (TAdditionalInput extends _$zod.ZodObject<Record<string, _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>, _$zod_v4_core0.$strip> ? _$zod.infer<TAdditionalInput> : object)) | undefined;
+      };
+      skip?: number;
+      take: number;
+    }) => Promise<TItem[]>;
+  }) => QueryProcedure<{
+    input: {
+      select: string[];
+      args?: Record<string, unknown> | undefined;
+    } & {
+      args?: ((Record<string, unknown> | undefined) & (TAdditionalInput extends _$zod.ZodObject<Record<string, _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>, _$zod_v4_core0.$strip> ? _$zod.infer<TAdditionalInput> : object)) | undefined;
+    };
+    meta: unknown;
+    output: ConnectionResult<TNode>;
+  }>;
+  createPlan: <Item extends AnyRecord = AnyRecord>({
+    args,
+    ctx,
+    select,
+    view
+  }: SourceInput & {
+    ctx?: Context;
+    view: ViewTarget<Item>;
+  }) => {
+    root: SourcePlanNode<unknown, unknown>;
+    source: SourceDefinition<Item, unknown>;
+    args: AnyRecord | undefined;
+    ctx: Context | undefined;
+    resolve: (item: Item) => Promise<AnyRecord>;
+    resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
+    selectedPaths: Set<string>;
+    view: DataView<Item>;
+  };
+  procedures: <Item extends AnyRecord, ById extends boolean | undefined = undefined, List extends boolean | ListConfig | undefined = undefined>(input: ViewProcedureInput<Item, ById, List>) => (ById extends false ? Record<never, never> : {
+    byId: ReturnType<ReturnType<Procedure["input"]>["query"]>;
+  }) & (List extends false ? Record<never, never> : {
+    list: QueryProcedure<{
+      input: {
+        select: string[];
+        args?: Record<string, unknown> | undefined;
+      } & {
+        args?: Record<string, unknown> | (Record<string, unknown> & object) | undefined;
+      };
+      meta: unknown;
+      output: ConnectionResult<unknown>;
+    }>;
+  });
+  resolveById: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    extra,
+    id,
+    input,
+    view
+  }: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    id: string;
+    input: SourceInput;
+    view: ViewTarget<Item>;
+  }) => Promise<AnyRecord | null>;
+  resolveByIds: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    extra,
+    ids,
+    input,
+    view
+  }: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    ids: Array<string>;
+    input: SourceInput;
+    view: ViewTarget<Item>;
+  }) => Promise<AnyRecord[]>;
+  resolveConnection: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    cursor,
+    direction,
+    extra,
+    input,
+    skip,
+    take,
+    view
+  }: {
+    ctx: Context;
+    cursor?: string;
+    direction: "backward" | "forward";
+    extra?: PrismaQueryExtra;
+    input: SourceInput;
+    skip?: number;
+    take: number;
+    view: ViewTarget<Item>;
+  }) => Promise<AnyRecord[]>;
+  fetchById: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    extra,
+    id,
+    plan
+  }: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    id: string;
+    plan: SourcePlan<Item, Context>;
+  }) => Promise<Item | null>;
+  fetchByIds: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    extra,
+    ids,
+    plan
+  }: {
+    ctx: Context;
+    extra?: PrismaQueryExtra;
+    ids: Array<string>;
+    plan: SourcePlan<Item, Context>;
+  }) => Promise<Item[]>;
+  fetchConnection: <Item extends AnyRecord = AnyRecord>({
+    ctx,
+    cursor,
+    direction,
+    extra,
+    plan,
+    skip,
+    take
+  }: {
+    ctx: Context;
+    cursor?: string;
+    direction: "backward" | "forward";
+    extra?: PrismaQueryExtra;
+    plan: SourcePlan<Item, Context>;
+    skip?: number;
+    take: number;
+  }) => Promise<Item[]>;
+  getSource: <Item extends AnyRecord = AnyRecord>(target: SourceTarget<Item>) => SourceDefinition<Item, unknown>;
+  registry: SourceRegistry<Context>;
+};
+//#endregion
+export { PrismaDelegate, PrismaQueryExtra, PrismaSourceAdapter, PrismaViewConfig, createPrismaFate, createPrismaSourceAdapter, createPrismaSourceRegistry, prismaConnectionArgs };

package/lib/server/prisma.mjs

@@ -0,0 +1,345 @@
+import { t as isRecord } from "../record-AeZJC9fd.mjs";
+import { O as withConnection, S as isDataView, T as toPrismaSelect, c as resolveSourceConnection, d as createSourceDefinitions, f as createSourcePlan, g as attachComputedState, i as createSourceRegistry, l as collectDataViewConfigs, o as resolveSourceById, p as getDataViewSourceConfig, s as resolveSourceByIds, t as bindSourceProcedures } from "../sourceRouter-Bwpkr062.mjs";
+//#region src/server/prisma.ts
+/**
+* Fate's Prisma integration.
+*
+* @example
+* import { createPrismaFate } from '@nkzw/fate/server/prisma';
+*
+* @module @nkzw/fate/server/prisma
+*/
+const lowerFirst = (value) => `${value.slice(0, 1).toLowerCase()}${value.slice(1)}`;
+const isPrismaViewConfig = (value) => isRecord(value) && isDataView(value.view) && typeof value.delegate === "function";
+const getPrismaClient = ({ ctx, prisma }) => {
+	if (prisma) return prisma(ctx);
+	return isRecord(ctx) && isRecord(ctx.prisma) ? ctx.prisma : ctx;
+};
+const createPrismaDelegate = (view, prisma) => {
+	const delegateName = lowerFirst(view.typeName);
+	return (ctx) => {
+		const client = getPrismaClient({
+			ctx,
+			prisma
+		});
+		if (!isRecord(client)) throw new Error(`Prisma client for ${view.typeName} could not be inferred. Pass 'prisma' to createPrismaFate.`);
+		const delegate = client[delegateName];
+		if (!delegate) throw new Error(`Prisma delegate '${delegateName}' for ${view.typeName} was not found.`);
+		return delegate;
+	};
+};
+const createPrismaViewConfigs = ({ prisma, views }) => Array.isArray(views) ? views.map((view) => {
+	if (isPrismaViewConfig(view)) return view;
+	if (!isDataView(view)) throw new Error(`Expected a data view or Prisma view config.`);
+	const config = getDataViewSourceConfig(view);
+	return {
+		...config,
+		delegate: createPrismaDelegate(config.view, prisma)
+	};
+}) : collectDataViewConfigs(views).map((config) => ({
+	...config,
+	delegate: createPrismaDelegate(config.view, prisma)
+}));
+const inferPrismaRelation = ({ field, kind, source, target }) => {
+	if (kind === "one") return {
+		foreignKey: target.id,
+		localKey: `${field}Id`
+	};
+	return {
+		foreignKey: `${lowerFirst(source.view.typeName)}Id`,
+		localKey: source.id
+	};
+};
+const stableStringify = (value) => {
+	if (Array.isArray(value)) return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+	if (isRecord(value)) return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
+	return JSON.stringify(value);
+};
+const resolveSourceReference = (source) => typeof source === "function" ? source() : source;
+const isSourceDefinition = (target) => "view" in target && "id" in target;
+const toPrismaOrderBy = (orderBy) => orderBy.map((entry) => ({ [entry.field]: entry.direction }));
+const prismaConnectionArgs = ({ cursor, direction, node, skip, take }) => ({
+	...cursor ? {
+		cursor: { id: cursor },
+		skip
+	} : null,
+	orderBy: toPrismaOrderBy(node.orderBy),
+	take: direction === "forward" ? take : -take
+});
+const getConflictingCountRequests = (node) => {
+	const signaturesByRelation = /* @__PURE__ */ new Map();
+	const requestsByRelation = /* @__PURE__ */ new Map();
+	for (const [field, computed] of node.computeds) {
+		if (!computed.select) continue;
+		for (const [selectionName, selection] of Object.entries(computed.select)) {
+			if (selection.kind !== "count") continue;
+			const signature = stableStringify(selection.where ?? null);
+			const signatures = signaturesByRelation.get(selection.relation) ?? /* @__PURE__ */ new Set();
+			signatures.add(signature);
+			signaturesByRelation.set(selection.relation, signatures);
+			const requests = requestsByRelation.get(selection.relation) ?? [];
+			requests.push({
+				field,
+				needName: selectionName,
+				relation: selection.relation,
+				where: selection.where
+			});
+			requestsByRelation.set(selection.relation, requests);
+		}
+	}
+	return new Map([...requestsByRelation.entries()].filter(([relation]) => (signaturesByRelation.get(relation)?.size ?? 0) > 1));
+};
+function createPrismaSourceAdapter({ prisma, views }) {
+	const viewConfigs = createPrismaViewConfigs({
+		prisma,
+		views
+	});
+	const sourceDefinitions = createSourceDefinitions(viewConfigs, { resolveRelation: inferPrismaRelation });
+	const sourcesByView = new Map(sourceDefinitions.map((source) => [source.view, source]));
+	const sourcesByFields = new Map(sourceDefinitions.map((source) => [source.view.fields, source]));
+	const delegates = new Map(viewConfigs.map((config, index) => [sourceDefinitions[index], (ctx) => config.delegate(ctx)]));
+	const getSource = (target) => {
+		if (isSourceDefinition(target)) return target;
+		const source = sourcesByView.get(target) ?? sourcesByFields.get(target.fields);
+		if (!source) throw new Error(`No source registered for view ${target.typeName}.`);
+		return source;
+	};
+	const getDelegate = (ctx, source) => {
+		const getSourceDelegate = delegates.get(source);
+		if (!getSourceDelegate) throw new Error(`No Prisma delegate registered for source ${source.view.typeName}.`);
+		return getSourceDelegate(ctx);
+	};
+	const countChildrenByParentKey = async ({ ctx, foreignKey, parentKeys, source, where }) => {
+		const delegate = getDelegate(ctx, source);
+		if (!delegate.groupBy) throw new Error(`Source ${source.view.typeName} does not support grouped count hydration.`);
+		const rows = await delegate.groupBy({
+			_count: { _all: true },
+			by: [foreignKey],
+			where: {
+				[foreignKey]: { in: parentKeys },
+				...where ?? {}
+			}
+		});
+		return new Map(rows.map((row) => [row[foreignKey], row._count?._all ?? 0]));
+	};
+	const attachConflictingComputedCounts = async ({ ctx, items, node, source }) => {
+		if (items.length === 0) return items;
+		const conflictingRequests = getConflictingCountRequests(node);
+		for (const [relationName, requests] of conflictingRequests) {
+			const relation = source.relations?.[relationName];
+			if (!relation || relation.kind !== "many") throw new Error(`Conflicting computed counts on ${source.view.typeName}.${relationName} require a 'many' relation in the Prisma executor.`);
+			const childSource = resolveSourceReference(relation.source);
+			const parentKeys = [...new Set(items.map((item) => item[relation.localKey]).filter((value) => value !== null && value !== void 0))];
+			const assignmentsBySignature = /* @__PURE__ */ new Map();
+			for (const request of requests) {
+				const signature = stableStringify(request.where ?? null);
+				const assignment = assignmentsBySignature.get(signature) ?? {
+					requests: [],
+					where: request.where
+				};
+				assignment.requests.push(request);
+				assignmentsBySignature.set(signature, assignment);
+			}
+			for (const { requests: signatureRequests, where } of assignmentsBySignature.values()) {
+				const counts = await countChildrenByParentKey({
+					ctx,
+					foreignKey: relation.foreignKey,
+					parentKeys,
+					source: childSource,
+					where
+				});
+				for (const item of items) {
+					const parentKey = item[relation.localKey];
+					const count = counts.get(parentKey) ?? 0;
+					for (const request of signatureRequests) attachComputedState(item, request.field, { [request.needName]: count });
+				}
+			}
+		}
+		for (const [relationName, relationNode] of node.relations) {
+			const relation = source.relations?.[relationName];
+			if (!relation) continue;
+			const childSource = resolveSourceReference(relation.source);
+			await attachConflictingComputedCounts({
+				ctx,
+				items: items.flatMap((item) => {
+					const value = item[relationName];
+					if (Array.isArray(value)) return value.filter(isRecord);
+					return isRecord(value) ? [value] : [];
+				}),
+				node: relationNode,
+				source: childSource
+			});
+		}
+		return items;
+	};
+	const hydrateComputedCounts = async ({ ctx, items, plan }) => attachConflictingComputedCounts({
+		ctx,
+		items,
+		node: plan.root,
+		source: plan.source
+	});
+	const fetchByIds = async ({ ctx, extra, ids, plan }) => {
+		const delegate = getDelegate(ctx, plan.source);
+		if (!delegate.findMany) throw new Error(`Source ${plan.source.view.typeName} does not support byIds execution.`);
+		return hydrateComputedCounts({
+			ctx,
+			items: await delegate.findMany({
+				...extra,
+				select: toPrismaSelect(plan),
+				where: { id: { in: ids } }
+			}),
+			plan
+		});
+	};
+	const fetchById = async ({ ctx, extra, id, plan }) => {
+		const delegate = getDelegate(ctx, plan.source);
+		if (delegate.findUnique) return (await hydrateComputedCounts({
+			ctx,
+			items: (await Promise.all([delegate.findUnique({
+				...extra,
+				select: toPrismaSelect(plan),
+				where: { id }
+			})])).flatMap((item) => item ? [item] : []),
+			plan
+		}))[0] ?? null;
+		return (await fetchByIds({
+			ctx,
+			extra,
+			ids: [id],
+			plan
+		}))[0] ?? null;
+	};
+	const fetchConnection = async ({ ctx, cursor, direction, extra, plan, skip, take }) => {
+		const delegate = getDelegate(ctx, plan.source);
+		if (!delegate.findMany) throw new Error(`Source ${plan.source.view.typeName} does not support connection execution.`);
+		const hydrated = await hydrateComputedCounts({
+			ctx,
+			items: await delegate.findMany({
+				...extra,
+				...prismaConnectionArgs({
+					cursor,
+					direction,
+					node: plan.root,
+					skip,
+					take
+				}),
+				select: toPrismaSelect(plan)
+			}),
+			plan
+		});
+		return direction === "backward" ? [...hydrated].reverse() : hydrated;
+	};
+	const registry = createSourceRegistry(sourceDefinitions.map((source) => [source, {
+		byId: ({ ctx, extra, id, plan }) => fetchById({
+			ctx,
+			extra,
+			id,
+			plan
+		}),
+		byIds: ({ ctx, extra, ids, plan }) => fetchByIds({
+			ctx,
+			extra,
+			ids,
+			plan
+		}),
+		connection: ({ ctx, cursor, direction, extra, plan, skip, take }) => fetchConnection({
+			ctx,
+			cursor,
+			direction,
+			extra,
+			plan,
+			skip,
+			take
+		})
+	}]));
+	return {
+		fetchById,
+		fetchByIds,
+		fetchConnection,
+		getSource,
+		registry,
+		resolveById: ({ ctx, extra, id, input, view }) => resolveSourceById({
+			ctx,
+			extra,
+			id,
+			input,
+			registry,
+			source: getSource(view)
+		}),
+		resolveByIds: ({ ctx, extra, ids, input, view }) => resolveSourceByIds({
+			ctx,
+			extra,
+			ids,
+			input,
+			registry,
+			source: getSource(view)
+		}),
+		resolveConnection: ({ ctx, cursor, direction, extra, input, skip, take, view }) => resolveSourceConnection({
+			ctx,
+			cursor,
+			direction,
+			extra,
+			input,
+			registry,
+			skip,
+			source: getSource(view),
+			take
+		})
+	};
+}
+const createPrismaSourceRegistry = (options) => createPrismaSourceAdapter(options).registry;
+function createPrismaFate({ procedure, ...options }) {
+	const adapter = createPrismaSourceAdapter(options);
+	const connection = withConnection(procedure);
+	const procedures = bindSourceProcedures({
+		createConnectionProcedure: connection,
+		procedure,
+		registry: adapter.registry
+	});
+	return {
+		...adapter,
+		connection,
+		createPlan: ({ args, ctx, select, view }) => createSourcePlan({
+			args,
+			ctx,
+			select,
+			source: adapter.getSource(view)
+		}),
+		procedures: (input) => {
+			const procedureInput = input;
+			return procedures(procedureInput && typeof procedureInput === "object" && "view" in procedureInput ? {
+				...procedureInput,
+				source: adapter.getSource(procedureInput.view)
+			} : adapter.getSource(input));
+		},
+		resolveById: ({ ctx, extra, id, input, view }) => resolveSourceById({
+			ctx,
+			extra,
+			id,
+			input,
+			registry: adapter.registry,
+			source: adapter.getSource(view)
+		}),
+		resolveByIds: ({ ctx, extra, ids, input, view }) => resolveSourceByIds({
+			ctx,
+			extra,
+			ids,
+			input,
+			registry: adapter.registry,
+			source: adapter.getSource(view)
+		}),
+		resolveConnection: ({ ctx, cursor, direction, extra, input, skip, take, view }) => resolveSourceConnection({
+			ctx,
+			cursor,
+			direction,
+			extra,
+			input,
+			registry: adapter.registry,
+			skip,
+			source: adapter.getSource(view),
+			take
+		})
+	};
+}
+//#endregion
+export { createPrismaFate, createPrismaSourceAdapter, createPrismaSourceRegistry, prismaConnectionArgs };