feat: 実行時にレスポンスの型チェックを行うように

package.json

@@ -55,6 +55,7 @@
     "@quasar/extras": "1.16.17",
     "@sevenc-nanashi/utaformatix-ts": "npm:@jsr/sevenc-nanashi__utaformatix-ts@0.4.0",
     "@std/path": "npm:@jsr/std__path@1.0.8",
+    "ajv": "8.17.1",
     "async-lock": "1.4.1",
     "dayjs": "1.11.13",
     "electron-log": "5.3.1",

src/store/proxy.ts → src/store/proxy/index.ts

@@ -1,5 +1,6 @@
-import { ProxyStoreState, ProxyStoreTypes, EditorAudioQuery } from "./type";
-import { createPartialStore } from "./vuex";
+import { ProxyStoreState, ProxyStoreTypes, EditorAudioQuery } from "../type";
+import { createPartialStore } from "../vuex";
+import { validateOpenApiResponse } from "./openapi";
 import { createEngineUrl } from "@/domain/url";
 import { isElectron, isProduction } from "@/helpers/platform";
 import {
@@ -35,11 +36,11 @@ const proxyStoreCreator = (_engineFactory: IEngineConnectorFactory) => {
         );
         return Promise.resolve({
           invoke: (v) => (arg) =>
-            // FIXME: anyを使わないようにする
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
-            instance[v](arg) as any,
+            validateOpenApiResponse(
+              v,
+              // @ts-expect-error 動いているので無視
+              instance[v](arg),
+            ),
         });
       },
     },

src/store/proxy/openapi.ts

@@ -0,0 +1,108 @@
+import Ajv, { JSONSchemaType, ValidateFunction } from "ajv";
+import openapi from "../../../openapi.json";
+import { cloneWithUnwrapProxy } from "@/helpers/cloneWithUnwrapProxy";
+import { DefaultApiInterface } from "@/openapi";
+
+export const validateOpenApiResponse = createValidateOpenApiResponse();
+
+function toCamelCase(str: string) {
+  return str.replace(/_./g, (s) => s.charAt(1).toUpperCase());
+}
+
+/** OpenAPIのレスポンスを検証する */
+function createValidateOpenApiResponse() {
+  const ajv = new Ajv().addSchema({
+    $id: "openapi.json",
+    definitions: patchOpenApiJson(openapi).components.schemas,
+  });
+  const validatorCache = new Map<string, ValidateFunction>();
+
+  for (const path of Object.values(openapi.paths)) {
+    for (const rawMethod of Object.values(path)) {
+      const method = rawMethod as {
+        operationId: string;
+        responses: Record<
+          string,
+          { content?: Record<string, { schema?: unknown }> }
+        >;
+      };
+      const schema = method.responses["200"]?.content?.["application/json"]
+        ?.schema as JSONSchemaType<unknown>;
+      if (schema == null) {
+        continue;
+      }
+      validatorCache.set(
+        toCamelCase(method.operationId),
+        ajv.compile(patchOpenApiJson(schema)),
+      );
+    }
+  }
+
+  return <K extends keyof DefaultApiInterface>(
+    key: K,
+    response: ReturnType<DefaultApiInterface[K]>,
+  ): ReturnType<DefaultApiInterface[K]> => {
+    return response.then((res) => {
+      const maybeValidator = validatorCache.get(key);
+      if (maybeValidator == null) {
+        return res;
+      }
+
+      if (!maybeValidator(res)) {
+        throw new Error(
+          `Response validation error in ${key}: ${ajv.errorsText(maybeValidator.errors)}`,
+        );
+      }
+
+      return res;
+    }) as ReturnType<DefaultApiInterface[K]>;
+  };
+}
+
+/**
+ * OpenAPIのスキーマを修正する。
+ *
+ * 具体的には以下の変更を行う：
+ * - `$ref`の参照先を`#/components/schemas/`から`openapi.json#/definitions/`に変更する
+ * - オブジェクトのプロパティ名をキャメルケースに変換する
+ */
+function patchOpenApiJson<T extends Record<string, unknown>>(schema: T): T {
+  return inner(cloneWithUnwrapProxy(schema)) as T;
+
+  function inner(schema: Record<string, unknown>): Record<string, unknown> {
+    if (schema["$ref"] != null) {
+      const ref = schema["$ref"];
+      if (typeof ref === "string") {
+        schema["$ref"] = ref.replace(
+          "#/components/schemas/",
+          "openapi.json#/definitions/",
+        );
+      }
+    }
+
+    if (
+      schema["type"] === "object" &&
+      typeof schema["properties"] === "object" &&
+      schema["properties"] != null &&
+      Array.isArray(schema["required"])
+    ) {
+      schema["properties"] = Object.fromEntries(
+        Object.entries(schema["properties"]).map(([key, value]) => [
+          toCamelCase(key),
+          inner(value as Record<string, unknown>),
+        ]),
+      );
+
+      schema["required"] = schema["required"].map((key: string) =>
+        toCamelCase(key),
+      );
+    }
+
+    for (const key in schema) {
+      if (typeof schema[key] === "object" && schema[key] != null) {
+        inner(schema[key] as Record<string, unknown>);
+      }
+    }
+    return schema;
+  }
+}