appflare 0.2.24 → 0.2.26

package/cli/templates/handlers/generators/types/query-runtime/runtime-write.ts

@@ -1,676 +1,676 @@
-export function generateQueryRuntimeWriteSection(): string {
-	return `				insert: async <TArgs extends QueryInsertArgs<TableName>>(args: TArgs) => {
-					const transaction = ($db as any).transaction;
-
-					const valuesArray = Array.isArray(args.values)
-						? args.values
-						: [args.values];
-					const baseValuesArray: Array<Record<string, unknown>> = [];
-					const postInsertRelations: Array<
-						Array<{
-							relationName: string;
-							relation: RuntimeRelation;
-							value: unknown;
-						}>
-					> = [];
-
-					const toRelationItems = (
-						relation: RuntimeRelation,
-						relationName: string,
-						value: unknown,
-					): unknown[] => {
-						if (value === undefined || value === null) {
-							return [];
-						}
-
-						if (relation.kind === "one") {
-							if (Array.isArray(value)) {
-								throw new Error(
-									"Relation '" +
-										tableName +
-										"." +
-										relationName +
-										"' expects a single value.",
-								);
-							}
-							return [value];
-						}
-
-						return Array.isArray(value) ? value : [value];
-					};
-
-					const resolveRelationIdentifier = async (
-						tx: any,
-						relation: RuntimeRelation,
-						relationName: string,
-						input: unknown,
-					): Promise<unknown> => {
-						if (
-							typeof input === "string" ||
-							typeof input === "number" ||
-							typeof input === "bigint"
-						) {
-							return input;
-						}
-
-						if (!isRecord(input)) {
-							throw new Error(
-								"Relation '" +
-									tableName +
-									"." +
-									relationName +
-									"' expects an id or object payload.",
-							);
-						}
-
-						const referenceField =
-							relation.kind === "manyToMany"
-								? (relation.targetReferenceField ?? "id")
-								: (relation.referenceField ?? "id");
-						const existingId = input[referenceField];
-						if (existingId !== undefined && existingId !== null) {
-							return existingId;
-						}
-
-						const targetTable = (mergedSchema as Record<string, unknown>)[
-							relation.targetTable
-						];
-						if (!targetTable) {
-							throw new Error(
-								"Unknown target table '" +
-									relation.targetTable +
-									"' for relation '" +
-									tableName +
-									"." +
-									relationName +
-									"'.",
-							);
-						}
-
-						let createQuery: any = tx.insert(targetTable as any).values(input as any);
-						if (typeof createQuery.returning === "function") {
-							createQuery = createQuery.returning();
-						}
-						const createdRows = (await createQuery) as Array<Record<string, unknown>>;
-						const created = createdRows[0];
-						if (!created) {
-							throw new Error(
-								"Failed to create relation target for '" +
-									tableName +
-									"." +
-									relationName +
-									"'.",
-							);
-						}
-
-						const createdId = created[referenceField];
-						if (createdId === undefined || createdId === null) {
-							throw new Error(
-								"Created relation target for '" +
-									tableName +
-									"." +
-									relationName +
-									"' is missing '" +
-									referenceField +
-									"'.",
-							);
-						}
-
-						return createdId;
-					};
-
-					const getRelationTargetTable = (
-						relation: RuntimeRelation,
-						relationName: string,
-					): any => {
-						const targetTable = (mergedSchema as Record<string, unknown>)[
-							relation.targetTable
-						];
-						if (!targetTable) {
-							throw new Error(
-								"Unknown target table '" +
-									relation.targetTable +
-									"' for relation '" +
-									tableName +
-									"." +
-									relationName +
-									"'.",
-							);
-						}
-						return targetTable;
-					};
-
-					const getRelationReferenceField = (relation: RuntimeRelation): string => {
-						if (relation.kind === "manyToMany") {
-							return relation.targetReferenceField ?? "id";
-						}
-						return relation.referenceField ?? "id";
-					};
-
-					const fetchRelatedRowByIdentifier = async (
-						tx: any,
-						relation: RuntimeRelation,
-						relationName: string,
-						identifier: unknown,
-					): Promise<Record<string, unknown> | null> => {
-						if (identifier === undefined || identifier === null) {
-							return null;
-						}
-
-						const targetTable = getRelationTargetTable(relation, relationName);
-						const referenceField = getRelationReferenceField(relation);
-						const referenceColumn = (targetTable as Record<string, unknown>)[
-							referenceField
-						];
-						if (!referenceColumn) {
-							throw new Error(
-								"Target table '" +
-									relation.targetTable +
-									"' is missing column '" +
-									referenceField +
-									"' required by relation '" +
-									tableName +
-									"." +
-									relationName +
-									"'.",
-							);
-						}
-
-						let query: any = tx
-							.select()
-							.from(targetTable as any)
-							.where(eq(referenceColumn as any, identifier as any));
-						if (typeof query.limit === "function") {
-							query = query.limit(1);
-						}
-						const rows = (await query) as Array<Record<string, unknown>>;
-						return rows[0] ?? null;
-					};
-
-					for (const inputValue of valuesArray) {
-						const scalarValues: Record<string, unknown> = {};
-						const relationInputs: Array<{
-							relationName: string;
-							relation: RuntimeRelation;
-							value: unknown;
-						}> = [];
-
-						const valueRecord = (inputValue ?? {}) as Record<string, unknown>;
-						for (const [fieldName, fieldValue] of Object.entries(valueRecord)) {
-							const runtimeRelation = getRuntimeRelation(tableName, fieldName);
-							if (runtimeRelation) {
-								relationInputs.push({
-									relationName: fieldName,
-									relation: runtimeRelation,
-									value: fieldValue,
-								});
-								continue;
-							}
-							scalarValues[fieldName] = fieldValue;
-						}
-
-						baseValuesArray.push(scalarValues);
-						postInsertRelations.push(relationInputs);
-					}
-
-					const executeInsertGraph = async (
-						tx: any,
-					): Promise<Array<QueryInsertResultRow<TableName, TArgs>>> => {
-						for (let index = 0; index < baseValuesArray.length; index += 1) {
-							const relationInputs = postInsertRelations[index] ?? [];
-							for (const relationInput of relationInputs) {
-								if (relationInput.relation.kind !== "one") {
-									continue;
-								}
-
-								const sourceField = relationInput.relation.sourceField;
-								if (!sourceField) {
-									throw new Error(
-										"Relation '" +
-											tableName +
-											"." +
-											relationInput.relationName +
-											"' is missing sourceField metadata.",
-									);
-								}
-
-								const oneItems = toRelationItems(
-									relationInput.relation,
-									relationInput.relationName,
-									relationInput.value,
-								);
-								if (oneItems.length === 0) {
-									continue;
-								}
-
-								const relationId = await resolveRelationIdentifier(
-									tx,
-									relationInput.relation,
-									relationInput.relationName,
-									oneItems[0],
-								);
-								const existingValue = baseValuesArray[index][sourceField];
-								if (
-									existingValue !== undefined &&
-									existingValue !== relationId
-								) {
-									throw new Error(
-										"Insert payload for '" +
-											tableName +
-											"' has conflicting values for '" +
-											sourceField +
-											"'.",
-									);
-								}
-								baseValuesArray[index][sourceField] = relationId;
-							}
-						}
-
-						let insertQuery: any = tx.insert(table as any).values(baseValuesArray as any);
-						if (typeof insertQuery.returning === "function") {
-							insertQuery = insertQuery.returning();
-						}
-						const insertedRows = (await insertQuery) as Array<TableModel<TableName>>;
-						const hydratedRows: Array<Record<string, unknown>> = [];
-
-						for (let index = 0; index < insertedRows.length; index += 1) {
-							const parentRow = insertedRows[index] as unknown as Record<string, unknown>;
-							const hydratedRow: Record<string, unknown> = {
-								...parentRow,
-							};
-							const relationInputs = postInsertRelations[index] ?? [];
-
-							for (const relationInput of relationInputs) {
-								if (relationInput.relation.kind === "one") {
-									const sourceField = relationInput.relation.sourceField;
-									if (!sourceField) {
-										throw new Error(
-											"Relation '" +
-												tableName +
-												"." +
-												relationInput.relationName +
-												"' is missing sourceField metadata.",
-										);
-									}
-
-									const relationItems = toRelationItems(
-										relationInput.relation,
-										relationInput.relationName,
-										relationInput.value,
-									);
-									if (relationItems.length === 0) {
-										hydratedRow[relationInput.relationName] = null;
-										continue;
-									}
-
-									const sourceIdentifier = parentRow[sourceField];
-									hydratedRow[relationInput.relationName] =
-										(await fetchRelatedRowByIdentifier(
-											tx,
-											relationInput.relation,
-											relationInput.relationName,
-											sourceIdentifier,
-										)) ?? null;
-									continue;
-								}
-
-								const sourceReferenceField = relationInput.relation.referenceField ?? "id";
-								const parentReferenceValue = parentRow[sourceReferenceField];
-								if (
-									parentReferenceValue === undefined ||
-									parentReferenceValue === null
-								) {
-									throw new Error(
-										"Inserted row for '" +
-											tableName +
-											"' is missing '" +
-											sourceReferenceField +
-											"' required by relation '" +
-											relationInput.relationName +
-											"'.",
-									);
-								}
-
-								const relatedRows: Array<Record<string, unknown>> = [];
-								hydratedRow[relationInput.relationName] = relatedRows;
-
-								const relationItems = toRelationItems(
-									relationInput.relation,
-									relationInput.relationName,
-									relationInput.value,
-								);
-								if (relationItems.length === 0) {
-									continue;
-								}
-
-								if (relationInput.relation.kind === "many") {
-									const targetTable = getRelationTargetTable(
-										relationInput.relation,
-										relationInput.relationName,
-									);
-
-									const sourceField = relationInput.relation.sourceField;
-									const targetReferenceField =
-										relationInput.relation.referenceField ?? "id";
-									const targetReferenceColumn =
-										(targetTable as Record<string, unknown>)[targetReferenceField];
-									if (!sourceField) {
-										throw new Error(
-											"Relation '" +
-												tableName +
-												"." +
-												relationInput.relationName +
-												"' is missing sourceField metadata.",
-										);
-									}
-									if (!targetReferenceColumn) {
-										throw new Error(
-											"Target table '" +
-												relationInput.relation.targetTable +
-												"' is missing column '" +
-												targetReferenceField +
-												"' required by relation '" +
-												tableName +
-												"." +
-												relationInput.relationName +
-												"'.",
-										);
-									}
-
-									for (const relationItem of relationItems) {
-										if (
-											typeof relationItem === "string" ||
-											typeof relationItem === "number" ||
-											typeof relationItem === "bigint"
-										) {
-											await tx
-												.update(targetTable as any)
-												.set({ [sourceField]: parentReferenceValue } as any)
-												.where(
-													eq(targetReferenceColumn as any, relationItem as any),
-												);
-											const linkedRow = await fetchRelatedRowByIdentifier(
-												tx,
-												relationInput.relation,
-												relationInput.relationName,
-												relationItem,
-											);
-											if (linkedRow) {
-												relatedRows.push(linkedRow);
-											}
-											continue;
-										}
-
-										if (!isRecord(relationItem)) {
-											throw new Error(
-												"Relation '" +
-													tableName +
-													"." +
-													relationInput.relationName +
-													"' expects id or object payloads.",
-											);
-										}
-
-										const existingId = relationItem[targetReferenceField];
-										const payload = {
-											...relationItem,
-											[sourceField]: parentReferenceValue,
-										};
-
-										if (existingId !== undefined && existingId !== null) {
-											const setPayload: Record<string, unknown> = {
-												...payload,
-											};
-											delete setPayload[targetReferenceField];
-											await tx
-												.update(targetTable as any)
-												.set(setPayload as any)
-												.where(
-													eq(targetReferenceColumn as any, existingId as any),
-												);
-											const linkedRow = await fetchRelatedRowByIdentifier(
-												tx,
-												relationInput.relation,
-												relationInput.relationName,
-												existingId,
-											);
-											if (linkedRow) {
-												relatedRows.push(linkedRow);
-											}
-											continue;
-										}
-
-										let createQuery: any = tx
-											.insert(targetTable as any)
-											.values(payload as any);
-										if (typeof createQuery.returning === "function") {
-											createQuery = createQuery.returning();
-										}
-										const createdRows = (await createQuery) as Array<
-											Record<string, unknown>
-										>;
-										const createdRow = createdRows[0];
-										if (createdRow) {
-											relatedRows.push(createdRow);
-										}
-									}
-									continue;
-								}
-
-								const junctionTable = (mergedSchema as Record<string, unknown>)[
-									relationInput.relation.junctionTable
-								];
-								if (!junctionTable) {
-									throw new Error(
-										"Unknown junction table '" +
-											relationInput.relation.junctionTable +
-											"' for relation '" +
-											tableName +
-											"." +
-											relationInput.relationName +
-											"'.",
-									);
-								}
-
-								const sourceField = relationInput.relation.sourceField;
-								const targetField = relationInput.relation.targetField;
-								if (!sourceField || !targetField) {
-									throw new Error(
-										"Relation '" +
-											tableName +
-											"." +
-											relationInput.relationName +
-											"' is missing junction metadata fields.",
-									);
-								}
-
-								const linkValues: Array<Record<string, unknown>> = [];
-								const targetIdentifiers: unknown[] = [];
-								for (const relationItem of relationItems) {
-									const targetId = await resolveRelationIdentifier(
-										tx,
-										relationInput.relation,
-										relationInput.relationName,
-										relationItem,
-									);
-									targetIdentifiers.push(targetId);
-
-									linkValues.push({
-										[sourceField]: parentReferenceValue,
-										[targetField]: targetId,
-									});
-								}
-
-								if (linkValues.length > 0) {
-									await tx.insert(junctionTable as any).values(linkValues as any);
-								}
-
-								for (const targetId of targetIdentifiers) {
-									const linkedRow = await fetchRelatedRowByIdentifier(
-										tx,
-										relationInput.relation,
-										relationInput.relationName,
-										targetId,
-									);
-									if (linkedRow) {
-										relatedRows.push(linkedRow);
-									}
-								}
-							}
-
-							hydratedRows.push(hydratedRow);
-						}
-
-						return hydratedRows as Array<QueryInsertResultRow<TableName, TArgs>>;
-					};
-
-					let rows: Array<QueryInsertResultRow<TableName, TArgs>>;
-					if (typeof transaction === "function") {
-						try {
-							rows = await transaction.call($db, (tx: any) =>
-								executeInsertGraph(tx),
-							);
-						} catch (error) {
-							const message =
-								error instanceof Error ? error.message : String(error);
-							const lowered = message.toLowerCase();
-							if (
-								lowered.includes("failed query: begin") ||
-								lowered.includes('near "begin"') ||
-								lowered.includes("cannot start a transaction")
-							) {
-								rows = await executeInsertGraph($db as any);
-							} else {
-								throw error;
-							}
-						}
-					} else {
-						rows = await executeInsertGraph($db as any);
-					}
-
-					emitMutation(
-						"insert",
-						{ values: args.values as unknown as Record<string, unknown> },
-						rows,
-					);
-					return rows;
-				},
-				update: async (args: QueryUpdateArgs<TableName>) => {
-					const whereFilter = buildWhereFilter(
-						table,
-						args.where as Record<string, unknown> | undefined,
-						tableName,
-					);
-					let updateQuery: any = ($db as any)
-						.update(table as any)
-						.set(args.set as any);
-
-					if (whereFilter) {
-						updateQuery = updateQuery.where(whereFilter);
-					}
-					if (typeof args.limit === "number" && typeof updateQuery.limit === "function") {
-						updateQuery = updateQuery.limit(args.limit);
-					}
-					if (typeof updateQuery.returning === "function") {
-						updateQuery = updateQuery.returning();
-					}
-
-					const rows = (await updateQuery) as Array<TableModel<TableName>>;
-					emitMutation(
-						"update",
-						{
-							set: args.set as unknown as Record<string, unknown>,
-							where: (args.where ?? undefined) as unknown as Record<string, unknown>,
-							limit: args.limit,
-						},
-						rows,
-					);
-					return rows;
-				},
-				upsert: async (args: QueryUpsertArgs<TableName>) => {
-					const valuesArray = Array.isArray(args.values)
-						? args.values
-						: [args.values];
-					const values = Array.isArray(args.values)
-						? args.values
-						: args.values;
-
-					const targets = args.target
-						? Array.isArray(args.target)
-							? args.target
-							: [args.target]
-						: inferConflictTarget(table);
-
-					if (targets.length === 0) {
-						throw new Error(
-							"Unable to infer conflict target for table " + tableName + ". Provide target explicitly.",
-						);
-					}
-
-					const tableColumns = getTableColumns(table as never) as Record<string, unknown>;
-					const targetColumns = targets
-						.map((target) => tableColumns[target])
-						.filter(Boolean);
-
-					if (targetColumns.length === 0) {
-						throw new Error(
-							"Invalid conflict target for table " + tableName + ".",
-						);
-					}
-
-					const setPayload = args.set ?? valuesArray[0] ?? {};
-					let upsertQuery: any = ($db as any)
-						.insert(table as any)
-						.values(values as any)
-						.onConflictDoUpdate({
-							target: targetColumns as any,
-							set: setPayload as any,
-						});
-
-					if (typeof upsertQuery.returning === "function") {
-						upsertQuery = upsertQuery.returning();
-					}
-
-					const rows = (await upsertQuery) as Array<TableModel<TableName>>;
-					emitMutation(
-						"upsert",
-						{
-							values: args.values as unknown as Record<string, unknown>,
-							target: targets as unknown as Record<string, unknown>,
-							set: (args.set ?? undefined) as unknown as Record<string, unknown>,
-						},
-						rows,
-					);
-					return rows;
-				},
-				delete: async (args?: QueryDeleteArgs<TableName>) => {
-					const whereFilter = buildWhereFilter(
-						table,
-						args?.where as Record<string, unknown> | undefined,
-						tableName,
-					);
-					let deleteQuery: any = ($db as any).delete(table as any);
-
-					if (whereFilter) {
-						deleteQuery = deleteQuery.where(whereFilter);
-					}
-					if (typeof args?.limit === "number" && typeof deleteQuery.limit === "function") {
-						deleteQuery = deleteQuery.limit(args.limit);
-					}
-					if (typeof deleteQuery.returning === "function") {
-						deleteQuery = deleteQuery.returning();
-					}
-
-					const rows = (await deleteQuery) as Array<TableModel<TableName>>;
-					emitMutation(
-						"delete",
-						{
-							where: (args?.where ?? undefined) as unknown as Record<string, unknown>,
-							limit: args?.limit,
-						},
-						rows,
-					);
-					return rows;
-				},
-`;
-}
+export function generateQueryRuntimeWriteSection(): string {
+	return `				insert: async <TArgs extends QueryInsertArgs<TableName>>(args: TArgs) => {
+					const transaction = ($db as any).transaction;
+
+					const valuesArray = Array.isArray(args.values)
+						? args.values
+						: [args.values];
+					const baseValuesArray: Array<Record<string, unknown>> = [];
+					const postInsertRelations: Array<
+						Array<{
+							relationName: string;
+							relation: RuntimeRelation;
+							value: unknown;
+						}>
+					> = [];
+
+					const toRelationItems = (
+						relation: RuntimeRelation,
+						relationName: string,
+						value: unknown,
+					): unknown[] => {
+						if (value === undefined || value === null) {
+							return [];
+						}
+
+						if (relation.kind === "one") {
+							if (Array.isArray(value)) {
+								throw new Error(
+									"Relation '" +
+										tableName +
+										"." +
+										relationName +
+										"' expects a single value.",
+								);
+							}
+							return [value];
+						}
+
+						return Array.isArray(value) ? value : [value];
+					};
+
+					const resolveRelationIdentifier = async (
+						tx: any,
+						relation: RuntimeRelation,
+						relationName: string,
+						input: unknown,
+					): Promise<unknown> => {
+						if (
+							typeof input === "string" ||
+							typeof input === "number" ||
+							typeof input === "bigint"
+						) {
+							return input;
+						}
+
+						if (!isRecord(input)) {
+							throw new Error(
+								"Relation '" +
+									tableName +
+									"." +
+									relationName +
+									"' expects an id or object payload.",
+							);
+						}
+
+						const referenceField =
+							relation.kind === "manyToMany"
+								? (relation.targetReferenceField ?? "id")
+								: (relation.referenceField ?? "id");
+						const existingId = input[referenceField];
+						if (existingId !== undefined && existingId !== null) {
+							return existingId;
+						}
+
+						const targetTable = (mergedSchema as Record<string, unknown>)[
+							relation.targetTable
+						];
+						if (!targetTable) {
+							throw new Error(
+								"Unknown target table '" +
+									relation.targetTable +
+									"' for relation '" +
+									tableName +
+									"." +
+									relationName +
+									"'.",
+							);
+						}
+
+						let createQuery: any = tx.insert(targetTable as any).values(input as any);
+						if (typeof createQuery.returning === "function") {
+							createQuery = createQuery.returning();
+						}
+						const createdRows = (await createQuery) as Array<Record<string, unknown>>;
+						const created = createdRows[0];
+						if (!created) {
+							throw new Error(
+								"Failed to create relation target for '" +
+									tableName +
+									"." +
+									relationName +
+									"'.",
+							);
+						}
+
+						const createdId = created[referenceField];
+						if (createdId === undefined || createdId === null) {
+							throw new Error(
+								"Created relation target for '" +
+									tableName +
+									"." +
+									relationName +
+									"' is missing '" +
+									referenceField +
+									"'.",
+							);
+						}
+
+						return createdId;
+					};
+
+					const getRelationTargetTable = (
+						relation: RuntimeRelation,
+						relationName: string,
+					): any => {
+						const targetTable = (mergedSchema as Record<string, unknown>)[
+							relation.targetTable
+						];
+						if (!targetTable) {
+							throw new Error(
+								"Unknown target table '" +
+									relation.targetTable +
+									"' for relation '" +
+									tableName +
+									"." +
+									relationName +
+									"'.",
+							);
+						}
+						return targetTable;
+					};
+
+					const getRelationReferenceField = (relation: RuntimeRelation): string => {
+						if (relation.kind === "manyToMany") {
+							return relation.targetReferenceField ?? "id";
+						}
+						return relation.referenceField ?? "id";
+					};
+
+					const fetchRelatedRowByIdentifier = async (
+						tx: any,
+						relation: RuntimeRelation,
+						relationName: string,
+						identifier: unknown,
+					): Promise<Record<string, unknown> | null> => {
+						if (identifier === undefined || identifier === null) {
+							return null;
+						}
+
+						const targetTable = getRelationTargetTable(relation, relationName);
+						const referenceField = getRelationReferenceField(relation);
+						const referenceColumn = (targetTable as Record<string, unknown>)[
+							referenceField
+						];
+						if (!referenceColumn) {
+							throw new Error(
+								"Target table '" +
+									relation.targetTable +
+									"' is missing column '" +
+									referenceField +
+									"' required by relation '" +
+									tableName +
+									"." +
+									relationName +
+									"'.",
+							);
+						}
+
+						let query: any = tx
+							.select()
+							.from(targetTable as any)
+							.where(eq(referenceColumn as any, identifier as any));
+						if (typeof query.limit === "function") {
+							query = query.limit(1);
+						}
+						const rows = (await query) as Array<Record<string, unknown>>;
+						return rows[0] ?? null;
+					};
+
+					for (const inputValue of valuesArray) {
+						const scalarValues: Record<string, unknown> = {};
+						const relationInputs: Array<{
+							relationName: string;
+							relation: RuntimeRelation;
+							value: unknown;
+						}> = [];
+
+						const valueRecord = (inputValue ?? {}) as Record<string, unknown>;
+						for (const [fieldName, fieldValue] of Object.entries(valueRecord)) {
+							const runtimeRelation = getRuntimeRelation(tableName, fieldName);
+							if (runtimeRelation) {
+								relationInputs.push({
+									relationName: fieldName,
+									relation: runtimeRelation,
+									value: fieldValue,
+								});
+								continue;
+							}
+							scalarValues[fieldName] = fieldValue;
+						}
+
+						baseValuesArray.push(scalarValues);
+						postInsertRelations.push(relationInputs);
+					}
+
+					const executeInsertGraph = async (
+						tx: any,
+					): Promise<Array<QueryInsertResultRow<TableName, TArgs>>> => {
+						for (let index = 0; index < baseValuesArray.length; index += 1) {
+							const relationInputs = postInsertRelations[index] ?? [];
+							for (const relationInput of relationInputs) {
+								if (relationInput.relation.kind !== "one") {
+									continue;
+								}
+
+								const sourceField = relationInput.relation.sourceField;
+								if (!sourceField) {
+									throw new Error(
+										"Relation '" +
+											tableName +
+											"." +
+											relationInput.relationName +
+											"' is missing sourceField metadata.",
+									);
+								}
+
+								const oneItems = toRelationItems(
+									relationInput.relation,
+									relationInput.relationName,
+									relationInput.value,
+								);
+								if (oneItems.length === 0) {
+									continue;
+								}
+
+								const relationId = await resolveRelationIdentifier(
+									tx,
+									relationInput.relation,
+									relationInput.relationName,
+									oneItems[0],
+								);
+								const existingValue = baseValuesArray[index][sourceField];
+								if (
+									existingValue !== undefined &&
+									existingValue !== relationId
+								) {
+									throw new Error(
+										"Insert payload for '" +
+											tableName +
+											"' has conflicting values for '" +
+											sourceField +
+											"'.",
+									);
+								}
+								baseValuesArray[index][sourceField] = relationId;
+							}
+						}
+
+						let insertQuery: any = tx.insert(table as any).values(baseValuesArray as any);
+						if (typeof insertQuery.returning === "function") {
+							insertQuery = insertQuery.returning();
+						}
+						const insertedRows = (await insertQuery) as Array<TableModel<TableName>>;
+						const hydratedRows: Array<Record<string, unknown>> = [];
+
+						for (let index = 0; index < insertedRows.length; index += 1) {
+							const parentRow = insertedRows[index] as unknown as Record<string, unknown>;
+							const hydratedRow: Record<string, unknown> = {
+								...parentRow,
+							};
+							const relationInputs = postInsertRelations[index] ?? [];
+
+							for (const relationInput of relationInputs) {
+								if (relationInput.relation.kind === "one") {
+									const sourceField = relationInput.relation.sourceField;
+									if (!sourceField) {
+										throw new Error(
+											"Relation '" +
+												tableName +
+												"." +
+												relationInput.relationName +
+												"' is missing sourceField metadata.",
+										);
+									}
+
+									const relationItems = toRelationItems(
+										relationInput.relation,
+										relationInput.relationName,
+										relationInput.value,
+									);
+									if (relationItems.length === 0) {
+										hydratedRow[relationInput.relationName] = null;
+										continue;
+									}
+
+									const sourceIdentifier = parentRow[sourceField];
+									hydratedRow[relationInput.relationName] =
+										(await fetchRelatedRowByIdentifier(
+											tx,
+											relationInput.relation,
+											relationInput.relationName,
+											sourceIdentifier,
+										)) ?? null;
+									continue;
+								}
+
+								const sourceReferenceField = relationInput.relation.referenceField ?? "id";
+								const parentReferenceValue = parentRow[sourceReferenceField];
+								if (
+									parentReferenceValue === undefined ||
+									parentReferenceValue === null
+								) {
+									throw new Error(
+										"Inserted row for '" +
+											tableName +
+											"' is missing '" +
+											sourceReferenceField +
+											"' required by relation '" +
+											relationInput.relationName +
+											"'.",
+									);
+								}
+
+								const relatedRows: Array<Record<string, unknown>> = [];
+								hydratedRow[relationInput.relationName] = relatedRows;
+
+								const relationItems = toRelationItems(
+									relationInput.relation,
+									relationInput.relationName,
+									relationInput.value,
+								);
+								if (relationItems.length === 0) {
+									continue;
+								}
+
+								if (relationInput.relation.kind === "many") {
+									const targetTable = getRelationTargetTable(
+										relationInput.relation,
+										relationInput.relationName,
+									);
+
+									const sourceField = relationInput.relation.sourceField;
+									const targetReferenceField =
+										relationInput.relation.referenceField ?? "id";
+									const targetReferenceColumn =
+										(targetTable as Record<string, unknown>)[targetReferenceField];
+									if (!sourceField) {
+										throw new Error(
+											"Relation '" +
+												tableName +
+												"." +
+												relationInput.relationName +
+												"' is missing sourceField metadata.",
+										);
+									}
+									if (!targetReferenceColumn) {
+										throw new Error(
+											"Target table '" +
+												relationInput.relation.targetTable +
+												"' is missing column '" +
+												targetReferenceField +
+												"' required by relation '" +
+												tableName +
+												"." +
+												relationInput.relationName +
+												"'.",
+										);
+									}
+
+									for (const relationItem of relationItems) {
+										if (
+											typeof relationItem === "string" ||
+											typeof relationItem === "number" ||
+											typeof relationItem === "bigint"
+										) {
+											await tx
+												.update(targetTable as any)
+												.set({ [sourceField]: parentReferenceValue } as any)
+												.where(
+													eq(targetReferenceColumn as any, relationItem as any),
+												);
+											const linkedRow = await fetchRelatedRowByIdentifier(
+												tx,
+												relationInput.relation,
+												relationInput.relationName,
+												relationItem,
+											);
+											if (linkedRow) {
+												relatedRows.push(linkedRow);
+											}
+											continue;
+										}
+
+										if (!isRecord(relationItem)) {
+											throw new Error(
+												"Relation '" +
+													tableName +
+													"." +
+													relationInput.relationName +
+													"' expects id or object payloads.",
+											);
+										}
+
+										const existingId = relationItem[targetReferenceField];
+										const payload = {
+											...relationItem,
+											[sourceField]: parentReferenceValue,
+										};
+
+										if (existingId !== undefined && existingId !== null) {
+											const setPayload: Record<string, unknown> = {
+												...payload,
+											};
+											delete setPayload[targetReferenceField];
+											await tx
+												.update(targetTable as any)
+												.set(setPayload as any)
+												.where(
+													eq(targetReferenceColumn as any, existingId as any),
+												);
+											const linkedRow = await fetchRelatedRowByIdentifier(
+												tx,
+												relationInput.relation,
+												relationInput.relationName,
+												existingId,
+											);
+											if (linkedRow) {
+												relatedRows.push(linkedRow);
+											}
+											continue;
+										}
+
+										let createQuery: any = tx
+											.insert(targetTable as any)
+											.values(payload as any);
+										if (typeof createQuery.returning === "function") {
+											createQuery = createQuery.returning();
+										}
+										const createdRows = (await createQuery) as Array<
+											Record<string, unknown>
+										>;
+										const createdRow = createdRows[0];
+										if (createdRow) {
+											relatedRows.push(createdRow);
+										}
+									}
+									continue;
+								}
+
+								const junctionTable = (mergedSchema as Record<string, unknown>)[
+									relationInput.relation.junctionTable
+								];
+								if (!junctionTable) {
+									throw new Error(
+										"Unknown junction table '" +
+											relationInput.relation.junctionTable +
+											"' for relation '" +
+											tableName +
+											"." +
+											relationInput.relationName +
+											"'.",
+									);
+								}
+
+								const sourceField = relationInput.relation.sourceField;
+								const targetField = relationInput.relation.targetField;
+								if (!sourceField || !targetField) {
+									throw new Error(
+										"Relation '" +
+											tableName +
+											"." +
+											relationInput.relationName +
+											"' is missing junction metadata fields.",
+									);
+								}
+
+								const linkValues: Array<Record<string, unknown>> = [];
+								const targetIdentifiers: unknown[] = [];
+								for (const relationItem of relationItems) {
+									const targetId = await resolveRelationIdentifier(
+										tx,
+										relationInput.relation,
+										relationInput.relationName,
+										relationItem,
+									);
+									targetIdentifiers.push(targetId);
+
+									linkValues.push({
+										[sourceField]: parentReferenceValue,
+										[targetField]: targetId,
+									});
+								}
+
+								if (linkValues.length > 0) {
+									await tx.insert(junctionTable as any).values(linkValues as any);
+								}
+
+								for (const targetId of targetIdentifiers) {
+									const linkedRow = await fetchRelatedRowByIdentifier(
+										tx,
+										relationInput.relation,
+										relationInput.relationName,
+										targetId,
+									);
+									if (linkedRow) {
+										relatedRows.push(linkedRow);
+									}
+								}
+							}
+
+							hydratedRows.push(hydratedRow);
+						}
+
+						return hydratedRows as Array<QueryInsertResultRow<TableName, TArgs>>;
+					};
+
+					let rows: Array<QueryInsertResultRow<TableName, TArgs>>;
+					if (typeof transaction === "function") {
+						try {
+							rows = await transaction.call($db, (tx: any) =>
+								executeInsertGraph(tx),
+							);
+						} catch (error) {
+							const message =
+								error instanceof Error ? error.message : String(error);
+							const lowered = message.toLowerCase();
+							if (
+								lowered.includes("failed query: begin") ||
+								lowered.includes('near "begin"') ||
+								lowered.includes("cannot start a transaction")
+							) {
+								rows = await executeInsertGraph($db as any);
+							} else {
+								throw error;
+							}
+						}
+					} else {
+						rows = await executeInsertGraph($db as any);
+					}
+
+					emitMutation(
+						"insert",
+						{ values: args.values as unknown as Record<string, unknown> },
+						rows,
+					);
+					return rows;
+				},
+				update: async (args: QueryUpdateArgs<TableName>) => {
+					const whereFilter = buildWhereFilter(
+						table,
+						args.where as Record<string, unknown> | undefined,
+						tableName,
+					);
+					let updateQuery: any = ($db as any)
+						.update(table as any)
+						.set(args.set as any);
+
+					if (whereFilter) {
+						updateQuery = updateQuery.where(whereFilter);
+					}
+					if (typeof args.limit === "number" && typeof updateQuery.limit === "function") {
+						updateQuery = updateQuery.limit(args.limit);
+					}
+					if (typeof updateQuery.returning === "function") {
+						updateQuery = updateQuery.returning();
+					}
+
+					const rows = (await updateQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"update",
+						{
+							set: args.set as unknown as Record<string, unknown>,
+							where: (args.where ?? undefined) as unknown as Record<string, unknown>,
+							limit: args.limit,
+						},
+						rows,
+					);
+					return rows;
+				},
+				upsert: async (args: QueryUpsertArgs<TableName>) => {
+					const valuesArray = Array.isArray(args.values)
+						? args.values
+						: [args.values];
+					const values = Array.isArray(args.values)
+						? args.values
+						: args.values;
+
+					const targets = args.target
+						? Array.isArray(args.target)
+							? args.target
+							: [args.target]
+						: inferConflictTarget(table);
+
+					if (targets.length === 0) {
+						throw new Error(
+							"Unable to infer conflict target for table " + tableName + ". Provide target explicitly.",
+						);
+					}
+
+					const tableColumns = getTableColumns(table as never) as Record<string, unknown>;
+					const targetColumns = targets
+						.map((target) => tableColumns[target])
+						.filter(Boolean);
+
+					if (targetColumns.length === 0) {
+						throw new Error(
+							"Invalid conflict target for table " + tableName + ".",
+						);
+					}
+
+					const setPayload = args.set ?? valuesArray[0] ?? {};
+					let upsertQuery: any = ($db as any)
+						.insert(table as any)
+						.values(values as any)
+						.onConflictDoUpdate({
+							target: targetColumns as any,
+							set: setPayload as any,
+						});
+
+					if (typeof upsertQuery.returning === "function") {
+						upsertQuery = upsertQuery.returning();
+					}
+
+					const rows = (await upsertQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"upsert",
+						{
+							values: args.values as unknown as Record<string, unknown>,
+							target: targets as unknown as Record<string, unknown>,
+							set: (args.set ?? undefined) as unknown as Record<string, unknown>,
+						},
+						rows,
+					);
+					return rows;
+				},
+				delete: async (args?: QueryDeleteArgs<TableName>) => {
+					const whereFilter = buildWhereFilter(
+						table,
+						args?.where as Record<string, unknown> | undefined,
+						tableName,
+					);
+					let deleteQuery: any = ($db as any).delete(table as any);
+
+					if (whereFilter) {
+						deleteQuery = deleteQuery.where(whereFilter);
+					}
+					if (typeof args?.limit === "number" && typeof deleteQuery.limit === "function") {
+						deleteQuery = deleteQuery.limit(args.limit);
+					}
+					if (typeof deleteQuery.returning === "function") {
+						deleteQuery = deleteQuery.returning();
+					}
+
+					const rows = (await deleteQuery) as Array<TableModel<TableName>>;
+					emitMutation(
+						"delete",
+						{
+							where: (args?.where ?? undefined) as unknown as Record<string, unknown>,
+							limit: args?.limit,
+						},
+						rows,
+					);
+					return rows;
+				},
+`;
+}