Reorganize GraphQL files and rename queries

src/api/use-continuous-enabled-subscription.ts

@@ -1,23 +1,23 @@
 import { computed } from "vue";
 import type { ComputedRef } from "vue";
 import {
-  useQContinuousEnabledQuery,
-  useContinuousEnabledSubscription,
+  useCtrlContinuousEnabledQuery,
+  useCtrlContinuousEnabledSSubscription,
 } from "@/graphql/codegen/generated";
 
 interface _ContinuousEnabledSubscription {
   continuousEnabled: ComputedRef<boolean | undefined>;
   error: ComputedRef<Error | undefined>;
-  subscription: ReturnType<typeof useContinuousEnabledSubscription>;
-  query: ReturnType<typeof useQContinuousEnabledQuery>;
+  subscription: ReturnType<typeof useCtrlContinuousEnabledSSubscription>;
+  query: ReturnType<typeof useCtrlContinuousEnabledQuery>;
 }
 
 type ContinuousEnabledSubscription = _ContinuousEnabledSubscription &
   PromiseLike<_ContinuousEnabledSubscription>;
 
 export function useSubscribeContinuousEnabled(): ContinuousEnabledSubscription {
-  const query = useQContinuousEnabledQuery({ requestPolicy: "network-only" });
-  const subscription = useContinuousEnabledSubscription({});
+  const query = useCtrlContinuousEnabledQuery({ requestPolicy: "network-only" });
+  const subscription = useCtrlContinuousEnabledSSubscription({});
 
   const error = computed(() => subscription.error?.value || query.error?.value);
 

src/api/use-run-no-subscription.ts

@@ -1,19 +1,19 @@
 import { computed } from "vue";
 import type { ComputedRef } from "vue";
-import { useQRunNoQuery, useRunNoSubscription } from "@/graphql/codegen/generated";
+import { useCtrlRunNoQuery, useCtrlRunNoSSubscription } from "@/graphql/codegen/generated";
 
 interface _RunNoSubscription {
   runNo: ComputedRef<number | undefined>;
   error: ComputedRef<Error | undefined>;
-  subscription: ReturnType<typeof useRunNoSubscription>;
-  query: ReturnType<typeof useQRunNoQuery>;
+  subscription: ReturnType<typeof useCtrlRunNoSSubscription>;
+  query: ReturnType<typeof useCtrlRunNoQuery>;
 }
 
 type RunNoSubscription = _RunNoSubscription & PromiseLike<_RunNoSubscription>;
 
 export function useSubscribeRunNo(): RunNoSubscription {
-  const query = useQRunNoQuery({ requestPolicy: "network-only" });
-  const subscription = useRunNoSubscription({});
+  const query = useCtrlRunNoQuery({ requestPolicy: "network-only" });
+  const subscription = useCtrlRunNoSSubscription({});
 
   const error = computed(() => subscription.error?.value || query.error?.value);
 

src/api/use-schedule-auto-mode-mode-subscription.ts

@@ -1,25 +1,25 @@
 import { computed } from "vue";
 import type { ComputedRef } from "vue";
 import {
-  useQScheduleAutoModeModeQuery,
-  useScheduleAutoModeModeSubscription,
+  useScheduleAutoModeModeQuery,
+  useScheduleAutoModeModeSSubscription,
 } from "@/graphql/codegen/generated";
 
 // type AutoMode = "off" | "scheduler" | "queue";
 
 interface _ScheduleAutoModeModeSubscription {
   autoModeMode: ComputedRef<string | undefined>;
   error: ComputedRef<Error | undefined>;
-  subscription: ReturnType<typeof useScheduleAutoModeModeSubscription>;
-  query: ReturnType<typeof useQScheduleAutoModeModeQuery>;
+  subscription: ReturnType<typeof useScheduleAutoModeModeSSubscription>;
+  query: ReturnType<typeof useScheduleAutoModeModeQuery>;
 }
 
 type ScheduleAutoModeModeSubscription = _ScheduleAutoModeModeSubscription &
   PromiseLike<_ScheduleAutoModeModeSubscription>;
 
 export function useSubscribeScheduleAutoModeMode(): ScheduleAutoModeModeSubscription {
-  const query = useQScheduleAutoModeModeQuery({ requestPolicy: "network-only" });
-  const subscription = useScheduleAutoModeModeSubscription();
+  const query = useScheduleAutoModeModeQuery({ requestPolicy: "network-only" });
+  const subscription = useScheduleAutoModeModeSSubscription();
 
   const error = computed(() => subscription.error?.value || query.error?.value);
 

src/api/use-schedule-auto-mode-state-subscription.ts

@@ -2,13 +2,13 @@ import { computed } from "vue";
 import type { ComputedRef } from "vue";
 import {
   useQScheduleAutoModeStateQuery,
-  useScheduleAutoModeStateSubscription,
+  useScheduleAutoModeStateSSubscription,
 } from "@/graphql/codegen/generated";
 
 interface _ScheduleAutoModeStateSubscription {
   autoModeState: ComputedRef<string | undefined>;
   error: ComputedRef<Error | undefined>;
-  subscription: ReturnType<typeof useScheduleAutoModeStateSubscription>;
+  subscription: ReturnType<typeof useScheduleAutoModeStateSSubscription>;
   query: ReturnType<typeof useQScheduleAutoModeStateQuery>;
 }
 
@@ -17,7 +17,7 @@ type ScheduleAutoModeStateSubscription = _ScheduleAutoModeStateSubscription &
 
 export function useSubscribeScheduleAutoModeState(): ScheduleAutoModeStateSubscription {
   const query = useQScheduleAutoModeStateQuery({ requestPolicy: "network-only" });
-  const subscription = useScheduleAutoModeStateSubscription();
+  const subscription = useScheduleAutoModeStateSSubscription();
 
   const error = computed(() => subscription.error?.value || query.error?.value);
 

src/api/use-schedule-queue-items-subscription.ts

@@ -1,25 +1,25 @@
 import { computed } from "vue";
 import type { ComputedRef } from "vue";
 import {
-  useQScheduleQueueItemsQuery,
-  useSScheduleQueueItemsSubscription,
+  useScheduleQueueItemsQuery,
+  useScheduleQueueItemsSSubscription,
 } from "@/graphql/codegen/generated";
 import type { ScheduleQueueItem } from "@/graphql/codegen/generated";
 
 interface _ScheduleQueueItemsSubscription {
   items: ComputedRef<ScheduleQueueItem[] | undefined>;
   loading: ComputedRef<boolean>;
   error: ComputedRef<Error | undefined>;
-  subscription: ReturnType<typeof useSScheduleQueueItemsSubscription>;
-  query: ReturnType<typeof useQScheduleQueueItemsQuery>;
+  subscription: ReturnType<typeof useScheduleQueueItemsSSubscription>;
+  query: ReturnType<typeof useScheduleQueueItemsQuery>;
 }
 
 type ScheduleQueueItemsSubscription = _ScheduleQueueItemsSubscription &
   PromiseLike<_ScheduleQueueItemsSubscription>;
 
 export function useSubscribeScheduleQueueItems(): ScheduleQueueItemsSubscription {
-  const query = useQScheduleQueueItemsQuery({ requestPolicy: "network-only" });
-  const subscription = useSScheduleQueueItemsSubscription();
+  const query = useScheduleQueueItemsQuery({ requestPolicy: "network-only" });
+  const subscription = useScheduleQueueItemsSSubscription();
 
   const loading = computed(() => query.fetching?.value);
   const error = computed(() => subscription.error?.value || query.error?.value);

src/api/use-state-subscription.ts

@@ -1,19 +1,19 @@
 import { computed } from "vue";
 import type { ComputedRef } from "vue";
-import { useQStateQuery, useStateSubscription } from "@/graphql/codegen/generated";
+import { useCtrlStateQuery, useCtrlStateSSubscription } from "@/graphql/codegen/generated";
 
 interface _StateSubscription {
   state: ComputedRef<string | undefined>;
   error: ComputedRef<Error | undefined>;
-  subscription: ReturnType<typeof useStateSubscription>;
-  query: ReturnType<typeof useQStateQuery>;
+  subscription: ReturnType<typeof useCtrlStateSSubscription>;
+  query: ReturnType<typeof useCtrlStateQuery>;
 }
 
 type StateSubscription = _StateSubscription & PromiseLike<_StateSubscription>;
 
 export function useSubscribeState(): StateSubscription {
-  const query = useQStateQuery({ requestPolicy: "network-only" });
-  const subscription = useStateSubscription({});
+  const query = useCtrlStateQuery({ requestPolicy: "network-only" });
+  const subscription = useCtrlStateSSubscription({});
 
   const error = computed(() => subscription.error?.value || query.error?.value);
 

src/api/use-trace_ids-subscription.ts

@@ -1,22 +1,22 @@
 import { computed } from "vue";
 import type { ComputedRef } from "vue";
 import {
-  useQTraceIdsQuery,
-  useTraceIdsSubscription,
+  useCtrlTraceIdsQuery,
+  useCtrlTraceIdsSSubscription,
 } from "@/graphql/codegen/generated";
 
 interface _TraceIdsSubscription {
   traceIds: ComputedRef<number[] | undefined>;
   error: ComputedRef<Error | undefined>;
-  subscription: ReturnType<typeof useTraceIdsSubscription>;
-  query: ReturnType<typeof useQTraceIdsQuery>;
+  subscription: ReturnType<typeof useCtrlTraceIdsSSubscription>;
+  query: ReturnType<typeof useCtrlTraceIdsQuery>;
 }
 
 type TraceIdsSubscription = _TraceIdsSubscription & PromiseLike<_TraceIdsSubscription>;
 
 export function useSubscribeTraceIds(): TraceIdsSubscription {
-  const query = useQTraceIdsQuery({ requestPolicy: "network-only" });
-  const subscription = useTraceIdsSubscription({});
+  const query = useCtrlTraceIdsQuery({ requestPolicy: "network-only" });
+  const subscription = useCtrlTraceIdsSSubscription({});
 
   const error = computed(() => subscription.error?.value || query.error?.value);
 

src/components/exception/Exception.vue

@@ -10,7 +10,7 @@
 <script setup lang="ts">
 import { ref, watch } from "vue";
 
-import { useExceptionQuery } from "@/graphql/codegen/generated";
+import { useCtrlExceptionQuery } from "@/graphql/codegen/generated";
 
 import { useSubscribeState } from "@/api";
 
@@ -30,7 +30,7 @@ const { state } = stateSubscription;
 
 const pause = ref(true);
 
-const query = useExceptionQuery({ pause: pause.value });
+const query = useCtrlExceptionQuery({ pause: pause.value });
 
 watch(state, (val) => {
   pause.value = val !== "finished";

src/components/main/console-frame/ConsoleFrame.vue

@@ -25,7 +25,7 @@
 <script setup lang="ts">
 import { ref, nextTick } from "vue";
 
-import { useStdoutSubscription } from "@/graphql/codegen/generated";
+import { useCtrlStdoutSSubscription } from "@/graphql/codegen/generated";
 
 const handleSubscription = (
   messages = { ctrlStdout: "" },
@@ -38,7 +38,7 @@ const handleSubscription = (
   });
   return { ctrlStdout: messages.ctrlStdout + response.ctrlStdout };
 };
-const subscription = useStdoutSubscription({}, handleSubscription);
+const subscription = useCtrlStdoutSSubscription({}, handleSubscription);
 const bottom = ref(null as HTMLElement | null);
 const data = ref(subscription.data);
 

src/components/main/run-frame/top-bar/ActionFinished.vue

@@ -12,9 +12,9 @@
 
 <script setup lang="ts">
 import { useStore } from "@/plugins/pinia/stores/main";
-import { useResetMutation } from "@/graphql/codegen/generated";
+import { useCtrlResetMutation } from "@/graphql/codegen/generated";
 import { storeToRefs } from "pinia";
 const store = useStore();
 const { modified: editing } = storeToRefs(store);
-const { executeMutation: executeReset } = useResetMutation();
+const { executeMutation: executeReset } = useCtrlResetMutation();
 </script>

src/components/main/run-frame/top-bar/ActionInitialized.vue

@@ -31,8 +31,8 @@ import { storeToRefs } from "pinia";
 import { useStore } from "@/plugins/pinia/stores/main";
 
 import {
-  useExecMutation,
-  useRunAndContinueMutation,
+  useCtrlExecMutation,
+  useCtrlRunAndContinueMutation,
 } from "@/graphql/codegen/generated";
 
 import RunInterConfirmationDialog from "./RunInterConfirmationDialog.vue";
@@ -41,8 +41,8 @@ import RunConfirmationDialog from "./RunConfirmationDialog.vue";
 const store = useStore();
 const { modified: editing } = storeToRefs(store);
 
-const { executeMutation: executeExec } = useExecMutation();
-const { executeMutation: executeRunAndContinue } = useRunAndContinueMutation();
+const { executeMutation: executeExec } = useCtrlExecMutation();
+const { executeMutation: executeRunAndContinue } = useCtrlRunAndContinueMutation();
 
 const dialogRun = ref(false);
 const dialogRunInter = ref(false);

src/components/main/run-frame/top-bar/ActionRunning.vue

@@ -32,12 +32,12 @@
 
 <script setup lang="ts">
 import {
-  useInterruptMutation,
-  useTerminateMutation,
-  useKillMutation,
+  useCtrlInterruptMutation,
+  useCtrlTerminateMutation,
+  useCtrlKillMutation,
 } from "@/graphql/codegen/generated";
 
-const { executeMutation: executeInterrupt } = useInterruptMutation();
-const { executeMutation: executeTerminate } = useTerminateMutation();
-const { executeMutation: executeKill } = useKillMutation();
+const { executeMutation: executeInterrupt } = useCtrlInterruptMutation();
+const { executeMutation: executeTerminate } = useCtrlTerminateMutation();
+const { executeMutation: executeKill } = useCtrlKillMutation();
 </script>

src/components/main/trace-frame/TraceAction.vue

@@ -41,7 +41,7 @@
 
 <script setup lang="ts">
 import { withDefaults } from "vue";
-import { useSendPdbCommandMutation } from "@/graphql/codegen/generated";
+import { useCtrlSendPdbCommandMutation } from "@/graphql/codegen/generated";
 
 interface Props {
   traceNo: number;
@@ -53,7 +53,7 @@ const props = withDefaults(defineProps<Props>(), {
   disabled: false,
 });
 
-const { executeMutation } = useSendPdbCommandMutation();
+const { executeMutation } = useCtrlSendPdbCommandMutation();
 
 async function pdbCommand(command: string) {
   await executeMutation({

src/components/main/trace-frame/TraceFrame.vue

@@ -40,7 +40,7 @@
 import { computed, ref, toRefs } from "vue";
 import path from "path";
 
-import { usePromptingSubscription } from "@/graphql/codegen/generated";
+import { useCtrlPromptingSSubscription } from "@/graphql/codegen/generated";
 import { useKeyboardShortcuts } from "./keyboard-shortcuts";
 import TraceAction from "./TraceAction.vue";
 import CodeEditor from "./code-editor/CodeEditor.vue";
@@ -53,7 +53,7 @@ const props = defineProps<Props>();
 
 const keyboardEvent = ref<KeyboardEvent | null>(null);
 
-const subscription = usePromptingSubscription({
+const subscription = useCtrlPromptingSSubscription({
   variables: { traceId: props.traceId },
 });
 

src/components/main/trace-frame/code-editor/source.ts

@@ -1,11 +1,11 @@
 import { computed } from "vue";
 import type { MaybeRef } from "vue";
 
-import { useSourceQuery } from "@/graphql/codegen/generated";
+import { useCtrlSourceQuery } from "@/graphql/codegen/generated";
 
 export async function useSource(fileName: MaybeRef<string>) {
   // @ts-ignore
-  const query = useSourceQuery({ variables: { fileName } });
+  const query = useCtrlSourceQuery({ variables: { fileName } });
   const sourceLines = computed(() => query.data.value?.ctrl.source);
   const source = computed(() => sourceLines.value?.join("\n"));
   await query;

src/components/main/trace-frame/keyboard-shortcuts.ts

@@ -1,6 +1,6 @@
 import { watch, MaybeRefOrGetter, toValue } from "vue";
 
-import { useSendPdbCommandMutation } from "@/graphql/codegen/generated";
+import { useCtrlSendPdbCommandMutation } from "@/graphql/codegen/generated";
 
 const keyboardShortcuts = new Map([
   ["n", "next"],
@@ -15,7 +15,7 @@ function useKeyboardShortcuts(
   disabled: MaybeRefOrGetter<boolean>,
   keyboardEvent: MaybeRefOrGetter<KeyboardEvent | undefined | null>
 ) {
-  const { executeMutation } = useSendPdbCommandMutation();
+  const { executeMutation } = useCtrlSendPdbCommandMutation();
   watch(
     () => toValue(keyboardEvent),
     async (event) => {