sonamu 0.9.17 → 0.9.19

package/src/ai/providers/rtzr/error.ts

@@ -1,22 +1,135 @@
-import { AISDKError } from "@ai-sdk/provider";
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+import { AISDKError, APICallError } from "@ai-sdk/provider";
+import { extractResponseHeaders, safeParseJSON, zodSchema } from "@ai-sdk/provider-utils";
+import { type ResponseHandler } from "@ai-sdk/provider-utils";
 import { z } from "zod";
 
-export const rtzrErrorDataSchema = z.object({
+const rtzrFlatErrorDataSchema = z.object({
+  code: z.union([z.string(), z.number()]).nullish(),
+  msg: z.string().nullish(),
+  type: z.string().nullish(),
+  param: z.unknown().nullish(),
+});
+
+const rtzrNestedErrorDataSchema = z.object({
   error: z.object({
-    msg: z.string(),
+    msg: z.string().nullish(),
+    message: z.string().nullish(),
     type: z.string().nullish(),
-    param: z.any().nullish(),
+    param: z.unknown().nullish(),
     code: z.union([z.string(), z.number()]).nullish(),
   }),
 });
 
+// RTZR returns flat HTTP errors, but async transcription failures wrap details in error.
+export const rtzrErrorDataSchema = z.union([rtzrFlatErrorDataSchema, rtzrNestedErrorDataSchema]);
+
 export type RtzrErrorData = z.infer<typeof rtzrErrorDataSchema>;
 
-export const rtzrFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: rtzrErrorDataSchema,
-  errorToMessage: (data) => data.error.msg,
-});
+type NormalizedRtzrError = {
+  code?: string | number | null;
+  message?: string | null;
+  msg?: string | null;
+  type?: string | null;
+  param?: unknown;
+};
+
+function isNullish(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}
+
+function normalizeRtzrErrorData(data: RtzrErrorData): NormalizedRtzrError {
+  if ("error" in data) {
+    return data.error;
+  }
+
+  return data;
+}
+
+function formatParam(param: unknown): string | undefined {
+  if (isNullish(param)) {
+    return undefined;
+  }
+
+  if (typeof param === "string") {
+    return param;
+  }
+
+  try {
+    return JSON.stringify(param);
+  } catch {
+    return String(param);
+  }
+}
+
+export function formatRtzrErrorData(data: RtzrErrorData): string {
+  const error = normalizeRtzrErrorData(data);
+  const param = formatParam(error.param);
+  const parts = [
+    isNullish(error.code) ? undefined : `code ${error.code}`,
+    isNullish(error.type) ? undefined : `type ${error.type}`,
+    isNullish(param) ? undefined : `param ${param}`,
+  ].filter((item): item is string => !isNullish(item) && item.length > 0);
+  const message = error.msg ?? error.message;
+
+  if (!isNullish(message) && message.length > 0) {
+    return [...parts, message].join(": ");
+  }
+
+  if (parts.length > 0) {
+    return parts.join(": ");
+  }
+
+  return "unknown RTZR error";
+}
+
+export async function formatRtzrErrorResponseBody(
+  responseBody: string,
+): Promise<string | undefined> {
+  if (responseBody.trim().length === 0) {
+    return undefined;
+  }
+
+  const parsedError = await safeParseJSON({
+    text: responseBody,
+    schema: zodSchema(rtzrErrorDataSchema),
+  });
+
+  if (!parsedError.success) {
+    return undefined;
+  }
+
+  return formatRtzrErrorData(parsedError.value);
+}
+
+export const rtzrFailedResponseHandler: ResponseHandler<APICallError> = async ({
+  response,
+  url,
+  requestBodyValues,
+}) => {
+  const responseBody = await response.text();
+  const responseHeaders = extractResponseHeaders(response);
+  const detail =
+    (await formatRtzrErrorResponseBody(responseBody)) ??
+    response.statusText ??
+    "unparseable RTZR error response";
+  const parsedError = await safeParseJSON({
+    text: responseBody,
+    schema: zodSchema(rtzrErrorDataSchema),
+  });
+
+  return {
+    responseHeaders,
+    value: new APICallError({
+      message: `HTTP ${response.status}: ${detail}`,
+      url,
+      requestBodyValues,
+      statusCode: response.status,
+      responseHeaders,
+      responseBody,
+      data: parsedError.success ? parsedError.value : undefined,
+    }),
+  };
+};
 
 export class RtzrClientError extends AISDKError {
   constructor(

package/src/ai/providers/rtzr/model.ts

@@ -11,6 +11,8 @@ import {
   mediaTypeToExtension,
   parseProviderOptions,
   postFormDataToApi,
+  safeParseJSON,
+  zodSchema,
 } from "@ai-sdk/provider-utils";
 import { type FetchFunction } from "@ai-sdk/provider-utils";
 import { isEmpty } from "radashi";
@@ -20,10 +22,19 @@ import {
   rtzrTranscriptionResponseSchema,
   rtzrTranscriptionResultResponseSchema,
 } from "./api";
-import { RtzrClientError, rtzrFailedResponseHandler } from "./error";
+import {
+  formatRtzrErrorData,
+  formatRtzrErrorResponseBody,
+  RtzrClientError,
+  rtzrFailedResponseHandler,
+} from "./error";
 import { rtzrTranscriptionProviderOptions } from "./options";
 import { type RtzrTranscriptionModelId, type RtzrTranscriptionProviderOptions } from "./options";
 
+function isNullish(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}
+
 export type RtzrTranscriptionCallOptions = Omit<
   TranscriptionModelV3CallOptions,
   "providerOptions"
@@ -78,17 +89,25 @@ export class RtzrTranscriptionModel implements TranscriptionModelV3 {
       },
     );
 
+    const responseBody = await response.text();
     if (!response.ok) {
-      throw new RtzrClientError(`Failed to authorize: ${response.status}`);
+      const detail = await formatRtzrErrorResponseBody(responseBody);
+      throw new RtzrClientError(
+        `Failed to authorize RTZR: HTTP ${response.status}${
+          isNullish(detail) ? "" : `: ${detail}`
+        }`,
+      );
     }
 
-    const data = await response.json();
-    const parsedData = rtzrAuthResponseSchema.safeParse(data);
+    const parsedData = await safeParseJSON({
+      text: responseBody,
+      schema: zodSchema(rtzrAuthResponseSchema),
+    });
     if (!parsedData.success) {
-      throw new RtzrClientError(`Validation failed: ${parsedData.error.message}`);
+      throw new RtzrClientError(`Invalid RTZR auth response: ${parsedData.error.message}`);
     }
 
-    return parsedData.data.access_token;
+    return parsedData.value.access_token;
   }
 
   private async getArgs({ audio, mediaType, providerOptions }: RtzrTranscriptionCallOptions) {
@@ -144,10 +163,10 @@ export class RtzrTranscriptionModel implements TranscriptionModelV3 {
     });
 
     const { value: response, rawValue } = await (async () => {
-      // transcription이 끝날 떄까지 0.5초마다 체크.
+      // transcription이 끝날 때까지 RTZR 권장 간격인 5초마다 체크.
       // timeout을 따로 지정하지 않는 이유는 애초에 AbortSignal을 사용하고 있음.
       while (true) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise((resolve) => setTimeout(resolve, 5000));
         const data = await getFromApi({
           url: this.config.url({
             path: `/transcribe/${transcriptionId}`,
@@ -167,6 +186,18 @@ export class RtzrTranscriptionModel implements TranscriptionModelV3 {
       }
     })();
 
+    if (response.status === "failed") {
+      const detail = isNullish(response.error)
+        ? "unknown RTZR transcription error"
+        : formatRtzrErrorData({
+            error: response.error,
+          });
+      throw new RtzrClientError(
+        `RTZR transcription failed for id ${response.id}: status ${response.status}: ` +
+          `provider ${this.provider}: model ${this.modelId}: ${detail}`,
+      );
+    }
+
     const segments = response.results?.utterances ?? [];
 
     const languages = new Set(segments.map((item) => item.lang).filter((item) => !isEmpty(item)));

package/src/migration/__tests__/code-generation.search-text.test.ts

@@ -488,6 +488,46 @@ describe("code-generation partial index DDL", () => {
     expect(alterIndexesTo.drop).toHaveLength(0);
   });
 
+  test("partial index predicate의 text cast 위치 차이는 alter diff에서 no-op이어야 한다", () => {
+    const entityIndex: MigrationIndex = {
+      type: "index",
+      name: "file_descriptions_idx_context_created_at",
+      using: "btree",
+      columns: [{ name: "context" }, { name: "created_at" }],
+      where:
+        "(context)::text = ANY ((ARRAY['ast_result'::character varying, 'culture_result'::character varying])::text[])",
+    };
+    const dbIndex: MigrationIndex = {
+      ...setMigrationIndexDefaults(entityIndex),
+      where:
+        "context = ANY (ARRAY[('ast_result'::character varying)::text, ('culture_result'::character varying)::text])",
+    };
+
+    const alterIndexesTo = getAlterIndexesTo([entityIndex], [dbIndex]);
+
+    expect(alterIndexesTo.add).toHaveLength(0);
+    expect(alterIndexesTo.drop).toHaveLength(0);
+  });
+
+  test("partial index predicate의 IN과 ANY 동치 표현은 alter diff에서 no-op이어야 한다", () => {
+    const entityIndex: MigrationIndex = {
+      type: "index",
+      name: "file_descriptions_idx_context_created_at",
+      columns: [{ name: "context" }, { name: "created_at" }],
+      where: "context IN ('ast_result', 'culture_result')",
+    };
+    const dbIndex: MigrationIndex = {
+      ...setMigrationIndexDefaults(entityIndex),
+      where:
+        "context = ANY (ARRAY[('ast_result'::character varying)::text, ('culture_result'::character varying)::text])",
+    };
+
+    const alterIndexesTo = getAlterIndexesTo([entityIndex], [dbIndex]);
+
+    expect(alterIndexesTo.add).toHaveLength(0);
+    expect(alterIndexesTo.drop).toHaveLength(0);
+  });
+
   test("partial index predicate 변경은 alter diff에서 drop/add 대상이어야 한다", async () => {
     const previousIndex: MigrationIndex = {
       type: "index",

package/src/migration/code-generation.ts

@@ -15,6 +15,10 @@ import {
 import { isSearchTextProp } from "../types/types";
 import { formatCode } from "../utils/formatter";
 import { differenceWith, intersectionBy } from "../utils/utils";
+import {
+  normalizeIndexWherePredicate,
+  normalizeIndexWherePredicateForComparison,
+} from "./index-where-predicate";
 import { PostgreSQLSchemaReader } from "./postgresql-schema-reader";
 
 /**
@@ -1612,15 +1616,28 @@ export function getAlterIndexesTo(entityIndexes: MigrationIndex[], dbIndexes: Mi
 
   const normalizedEntityIndexes = entityIndexes.map(setMigrationIndexDefaults);
   const normalizedDbIndexes = dbIndexes.map(setMigrationIndexDefaults);
+  // 비교에는 정규화된 predicate를 쓰되, 실제 migration 출력은 원본 SQL을 보존한다.
+  const comparisonEntityIndexes = entityIndexes.map(setMigrationIndexComparisonDefaults);
+  const comparisonDbIndexes = dbIndexes.map(setMigrationIndexComparisonDefaults);
   const extraIndexes = {
-    db: diff(normalizedDbIndexes, normalizedEntityIndexes, identity),
-    entity: diff(normalizedEntityIndexes, normalizedDbIndexes, identity),
+    db: diff(comparisonDbIndexes, comparisonEntityIndexes, identity),
+    entity: diff(comparisonEntityIndexes, comparisonDbIndexes, identity),
   };
   if (extraIndexes.entity.length > 0) {
-    indexesTo.add = indexesTo.add.concat(extraIndexes.entity);
+    const addIdentities = new Set(extraIndexes.entity.map(identity));
+    indexesTo.add = indexesTo.add.concat(
+      normalizedEntityIndexes.filter((_, index) =>
+        addIdentities.has(identity(comparisonEntityIndexes[index])),
+      ),
+    );
   }
   if (extraIndexes.db.length > 0) {
-    indexesTo.drop = indexesTo.drop.concat(extraIndexes.db);
+    const dropIdentities = new Set(extraIndexes.db.map(identity));
+    indexesTo.drop = indexesTo.drop.concat(
+      normalizedDbIndexes.filter((_, index) =>
+        dropIdentities.has(identity(comparisonDbIndexes[index])),
+      ),
+    );
   }
 
   return indexesTo;
@@ -1639,10 +1656,24 @@ function genIndexDropDefinition(index: MigrationIndex) {
  * DB 조회 결과와 비교하기 위한 인덱스 기본값 설정
  */
 export function setMigrationIndexDefaults(index: MigrationIndex): MigrationIndex {
+  return setMigrationIndexDefaultsBase(index, false);
+}
+
+function setMigrationIndexComparisonDefaults(index: MigrationIndex): MigrationIndex {
+  // DB canonical SQL과 entity SQL의 표현 차이를 diff identity에서만 흡수한다.
+  return setMigrationIndexDefaultsBase(index, true);
+}
+
+function setMigrationIndexDefaultsBase(
+  index: MigrationIndex,
+  normalizeWhereForComparison: boolean,
+): MigrationIndex {
   const isVectorIndex = index.type === "hnsw" || index.type === "ivfflat";
   const supportsOrdering = !isVectorIndex && (!index.using || index.using === "btree");
   const normalizedUsing = isVectorIndex ? index.using : (index.using ?? "btree");
-  const normalizedWhere = normalizeIndexWherePredicate(index.where);
+  const normalizedWhere = normalizeWhereForComparison
+    ? normalizeIndexWherePredicateForComparison(index.where)
+    : normalizeIndexWherePredicate(index.where);
 
   return {
     ...index,
@@ -1662,73 +1693,6 @@ export function setMigrationIndexDefaults(index: MigrationIndex): MigrationIndex
   };
 }
 
-function normalizeIndexWherePredicate(where: string | undefined): string | undefined {
-  if (!where) {
-    return undefined;
-  }
-
-  const trimmed = where.trim();
-  if (trimmed.length === 0) {
-    return undefined;
-  }
-
-  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
-    const closeIndex = findMatchingParenthesisInSql(trimmed, 0);
-    if (closeIndex === trimmed.length - 1) {
-      return trimmed.slice(1, -1).trim();
-    }
-  }
-
-  return trimmed;
-}
-
-function findMatchingParenthesisInSql(source: string, openIndex: number): number {
-  let depth = 0;
-  let inSingleQuote = false;
-  let inDoubleQuote = false;
-
-  for (let index = openIndex; index < source.length; index += 1) {
-    const char = source[index];
-    const nextChar = source[index + 1];
-
-    if (char === "'" && !inDoubleQuote) {
-      if (inSingleQuote && nextChar === "'") {
-        index += 1;
-        continue;
-      }
-      inSingleQuote = !inSingleQuote;
-      continue;
-    }
-
-    if (char === '"' && !inSingleQuote) {
-      if (inDoubleQuote && nextChar === '"') {
-        index += 1;
-        continue;
-      }
-      inDoubleQuote = !inDoubleQuote;
-      continue;
-    }
-
-    if (inSingleQuote || inDoubleQuote) {
-      continue;
-    }
-
-    if (char === "(") {
-      depth += 1;
-      continue;
-    }
-
-    if (char === ")") {
-      depth -= 1;
-      if (depth === 0) {
-        return index;
-      }
-    }
-  }
-
-  return -1;
-}
-
 /**
  * 테이블 변경 케이스 - Foreign Key 변경
  */