sonamu 0.9.17 → 0.9.19

package/dist/migration/index-where-predicate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Migration DDL 출력에 사용할 index predicate를 정리한다.
+ * 원본 SQL 표현은 보존하고, 빈 문자열과 전체를 감싼 괄호만 제거한다.
+ */
+export declare function normalizeIndexWherePredicate(where: string | undefined): string | undefined;
+/**
+ * Index diff 비교에 사용할 predicate identity를 만든다.
+ * PostgreSQL canonical 표현 차이는 AST 기반 정규화로 흡수한다.
+ */
+export declare function normalizeIndexWherePredicateForComparison(where: string | undefined): string | undefined;
+//# sourceMappingURL=index-where-predicate.d.ts.map

package/dist/migration/index-where-predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-where-predicate.d.ts","sourceRoot":"","sources":["../../src/migration/index-where-predicate.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAY1F;AAED;;;GAGG;AACH,wBAAgB,yCAAyC,CACvD,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,MAAM,GAAG,SAAS,CAQpB"}

package/dist/migration/index-where-predicate.js

@@ -0,0 +1,305 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import SqlParser from "node-sql-parser";
+
+//#region src/migration/index-where-predicate.ts
+/**
+* Migration DDL 출력에 사용할 index predicate를 정리한다.
+* 원본 SQL 표현은 보존하고, 빈 문자열과 전체를 감싼 괄호만 제거한다.
+*/
+function normalizeIndexWherePredicate(where) {
+	if (!where) {
+		return undefined;
+	}
+	const trimmed = removeOuterSqlParentheses(where.trim());
+	if (trimmed.length === 0) {
+		return undefined;
+	}
+	return trimmed;
+}
+/**
+* Index diff 비교에 사용할 predicate identity를 만든다.
+* PostgreSQL canonical 표현 차이는 AST 기반 정규화로 흡수한다.
+*/
+function normalizeIndexWherePredicateForComparison(where) {
+	const normalized = normalizeIndexWherePredicate(where);
+	if (!normalized) {
+		return undefined;
+	}
+	return normalizeIndexWherePredicateByAst(normalized) ?? normalized;
+}
+function removeOuterSqlParentheses(source) {
+	let trimmed = source.trim();
+	while (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+		const closeIndex = findMatchingParenthesisInSql(trimmed, 0);
+		if (closeIndex === trimmed.length - 1) {
+			trimmed = trimmed.slice(1, -1).trim();
+			continue;
+		}
+		break;
+	}
+	return trimmed;
+}
+function normalizeIndexWherePredicateByAst(where) {
+	try {
+		const parsed = INDEX_WHERE_SQL_PARSER.astify(`SELECT * FROM __sonamu_index_predicate_source WHERE ${where}`, { database: "postgresql" });
+		const statement = Array.isArray(parsed) ? parsed[0] : parsed;
+		if (!isSqlAstRecord(statement)) {
+			return undefined;
+		}
+		return serializeIndexWhereAst(statement.where);
+	} catch {
+		return undefined;
+	}
+}
+function serializeIndexWhereAst(node) {
+	const membership = serializeSqlMembershipPredicate(node);
+	if (membership) {
+		return membership;
+	}
+	if (!isSqlAstRecord(node)) {
+		return JSON.stringify(node);
+	}
+	const type = getSqlAstString(node, "type");
+	switch (type) {
+		case "binary_expr": {
+			const operator = normalizeSqlOperator(getSqlAstString(node, "operator"));
+			const left = serializeIndexWhereAst(node.left);
+			const right = serializeIndexWhereAst(node.right);
+			if (operator === "AND" || operator === "OR") {
+				return `(${[left, right].toSorted().join(` ${operator} `)})`;
+			}
+			return `(${left} ${operator} ${right})`;
+		}
+		case "unary_expr": {
+			const operator = normalizeSqlOperator(getSqlAstString(node, "operator"));
+			return `(${operator} ${serializeIndexWhereAst(node.expr)})`;
+		}
+		case "column_ref": {
+			return serializeSqlColumnRef(node);
+		}
+		case "single_quote_string": {
+			return `string:${JSON.stringify(getSqlAstString(node, "value"))}`;
+		}
+		case "number": {
+			return `number:${String(node.value)}`;
+		}
+		case "bool": {
+			return `bool:${String(node.value).toLowerCase()}`;
+		}
+		case "null": {
+			return "null";
+		}
+		case "cast": {
+			const targetType = getSqlCastTargetType(node);
+			const expr = node.expr;
+			if (targetType && isTextLikeSqlType(targetType) && isSqlStringLiteralLike(expr)) {
+				return serializeIndexWhereAst(stripTextLikeSqlCast(expr));
+			}
+			return `cast(${serializeIndexWhereAst(expr)} as ${targetType ?? "unknown"})`;
+		}
+		case "function": {
+			return `fn:${getSqlFunctionName(node)}(${serializeSqlExprList(node.args).join(",")})`;
+		}
+		case "array": {
+			return `array:[${serializeSqlArrayElements(node).map(serializeIndexWhereAst).join(",")}]`;
+		}
+		case "expr_list": {
+			return `list:[${serializeSqlExprList(node).map(serializeIndexWhereAst).join(",")}]`;
+		}
+		case "default": {
+			return `ident:${normalizeSqlIdentifier(getSqlAstString(node, "value") ?? "")}`;
+		}
+		default: {
+			return serializeUnknownSqlAstRecord(node);
+		}
+	}
+}
+function serializeSqlMembershipPredicate(node) {
+	if (!isSqlAstRecord(node) || getSqlAstString(node, "type") !== "binary_expr") {
+		return undefined;
+	}
+	const operator = normalizeSqlOperator(getSqlAstString(node, "operator"));
+	const left = serializeIndexWhereAst(stripTextLikeSqlCast(node.left));
+	const values = (() => {
+		if (operator === "IN") {
+			return serializeSqlMembershipValues(serializeSqlExprList(node.right));
+		}
+		if (operator === "=") {
+			return serializeSqlMembershipValues(getSqlAnyArrayElements(node.right));
+		}
+		return undefined;
+	})();
+	if (!values) {
+		return undefined;
+	}
+	return `membership:${left}:in:[${values.join(",")}]`;
+}
+function serializeSqlMembershipValues(values) {
+	if (!values) {
+		return undefined;
+	}
+	const serialized = values.map((value) => serializeIndexWhereAst(stripTextLikeSqlCast(value)));
+	return [...new Set(serialized)].toSorted();
+}
+function getSqlAnyArrayElements(node) {
+	if (!isSqlAstRecord(node) || getSqlAstString(node, "type") !== "function") {
+		return undefined;
+	}
+	if (getSqlFunctionName(node) !== "any") {
+		return undefined;
+	}
+	const [arg] = serializeSqlExprList(node.args);
+	if (!arg) {
+		return undefined;
+	}
+	return serializeSqlArrayElements(stripTextLikeSqlCast(arg));
+}
+function serializeSqlArrayElements(node) {
+	if (!isSqlAstRecord(node)) {
+		return [];
+	}
+	if (getSqlAstString(node, "type") === "array") {
+		return serializeSqlExprList(node.expr_list);
+	}
+	return serializeSqlExprList(node);
+}
+function serializeSqlExprList(node) {
+	if (!isSqlAstRecord(node)) {
+		return [];
+	}
+	if (getSqlAstString(node, "type") === "expr_list" && Array.isArray(node.value)) {
+		return node.value;
+	}
+	return [node];
+}
+function stripTextLikeSqlCast(node) {
+	if (!isSqlAstRecord(node) || getSqlAstString(node, "type") !== "cast") {
+		return node;
+	}
+	const targetType = getSqlCastTargetType(node);
+	if (!targetType || !isTextLikeSqlType(targetType)) {
+		return node;
+	}
+	return stripTextLikeSqlCast(node.expr);
+}
+function isSqlStringLiteralLike(node) {
+	const stripped = stripTextLikeSqlCast(node);
+	return isSqlAstRecord(stripped) && getSqlAstString(stripped, "type") === "single_quote_string";
+}
+function getSqlCastTargetType(node) {
+	if (!Array.isArray(node.target)) {
+		return undefined;
+	}
+	const dataTypes = node.target.map((target) => isSqlAstRecord(target) ? getSqlAstString(target, "dataType") : undefined).filter((dataType) => dataType !== undefined);
+	if (dataTypes.length === 0) {
+		return undefined;
+	}
+	return normalizeSqlDataType(dataTypes.join(" "));
+}
+function isTextLikeSqlType(type) {
+	const normalized = normalizeSqlDataType(type).replace(/\[\]$/g, "");
+	return normalized === "text" || normalized === "varchar";
+}
+function normalizeSqlDataType(type) {
+	return type.trim().toLowerCase().replace(/\s+/g, " ").replace(/^character varying$/, "varchar");
+}
+function serializeSqlColumnRef(node) {
+	const table = serializeSqlIdentifierNode(node.table);
+	const column = serializeSqlIdentifierNode(node.column);
+	return `column:${table ? `${table}.` : ""}${column}`;
+}
+function serializeSqlIdentifierNode(node) {
+	if (typeof node === "string") {
+		return normalizeSqlIdentifier(node);
+	}
+	if (isSqlAstRecord(node)) {
+		if (typeof node.value === "string") {
+			return normalizeSqlIdentifier(node.value);
+		}
+		if (isSqlAstRecord(node.expr) && typeof node.expr.value === "string") {
+			return normalizeSqlIdentifier(node.expr.value);
+		}
+	}
+	return "";
+}
+function getSqlFunctionName(node) {
+	const name = node.name;
+	if (typeof name === "string") {
+		return normalizeSqlIdentifier(name);
+	}
+	if (isSqlAstRecord(name)) {
+		if (Array.isArray(name.name)) {
+			return name.name.map(serializeSqlIdentifierNode).join(".");
+		}
+		const nameParts = serializeSqlExprList(name);
+		if (nameParts.length > 0) {
+			return nameParts.map(serializeSqlIdentifierNode).join(".");
+		}
+	}
+	return "";
+}
+function normalizeSqlIdentifier(identifier) {
+	return identifier.trim().toLowerCase();
+}
+function normalizeSqlOperator(operator) {
+	return (operator ?? "").trim().toUpperCase().replace(/\s+/g, " ");
+}
+function serializeUnknownSqlAstRecord(node) {
+	const entries = Object.entries(node).filter(([key]) => key !== "parentheses").toSorted(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}:${serializeIndexWhereAst(value)}`);
+	return `record:{${entries.join(",")}}`;
+}
+function isSqlAstRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getSqlAstString(node, key) {
+	const value = node[key];
+	return typeof value === "string" ? value : undefined;
+}
+function findMatchingParenthesisInSql(source, openIndex) {
+	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;
+}
+var INDEX_WHERE_SQL_PARSER;
+var init_index_where_predicate = __esmMin((() => {
+	INDEX_WHERE_SQL_PARSER = new SqlParser.Parser();
+}));
+
+//#endregion
+init_index_where_predicate();
+export { init_index_where_predicate, normalizeIndexWherePredicate, normalizeIndexWherePredicateForComparison };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index-where-predicate.js","names":[],"sources":["../../src/migration/index-where-predicate.ts"],"sourcesContent":["import SqlParser from \"node-sql-parser\";\n\nconst INDEX_WHERE_SQL_PARSER = new SqlParser.Parser();\n\n/**\n * Migration DDL 출력에 사용할 index predicate를 정리한다.\n * 원본 SQL 표현은 보존하고, 빈 문자열과 전체를 감싼 괄호만 제거한다.\n */\nexport function normalizeIndexWherePredicate(where: string | undefined): string | undefined {\n  if (!where) {\n    return undefined;\n  }\n\n  // 출력 경로에서는 사용자가 작성한 predicate를 최대한 그대로 유지한다.\n  const trimmed = removeOuterSqlParentheses(where.trim());\n  if (trimmed.length === 0) {\n    return undefined;\n  }\n\n  return trimmed;\n}\n\n/**\n * Index diff 비교에 사용할 predicate identity를 만든다.\n * PostgreSQL canonical 표현 차이는 AST 기반 정규화로 흡수한다.\n */\nexport function normalizeIndexWherePredicateForComparison(\n  where: string | undefined,\n): string | undefined {\n  const normalized = normalizeIndexWherePredicate(where);\n  if (!normalized) {\n    return undefined;\n  }\n\n  // 파싱 가능한 predicate만 canonical form으로 바꾸고, 실패하면 기존 strict 비교를 유지한다.\n  return normalizeIndexWherePredicateByAst(normalized) ?? normalized;\n}\n\nfunction removeOuterSqlParentheses(source: string): string {\n  let trimmed = source.trim();\n\n  // 전체 predicate를 감싼 괄호만 제거하고 내부 grouping은 건드리지 않는다.\n  while (trimmed.startsWith(\"(\") && trimmed.endsWith(\")\")) {\n    const closeIndex = findMatchingParenthesisInSql(trimmed, 0);\n    if (closeIndex === trimmed.length - 1) {\n      trimmed = trimmed.slice(1, -1).trim();\n      continue;\n    }\n\n    break;\n  }\n\n  return trimmed;\n}\n\nfunction normalizeIndexWherePredicateByAst(where: string): string | undefined {\n  try {\n    // node-sql-parser는 raw predicate를 직접 파싱하지 않으므로 임시 SELECT WHERE로 감싼다.\n    const parsed = INDEX_WHERE_SQL_PARSER.astify(\n      `SELECT * FROM __sonamu_index_predicate_source WHERE ${where}`,\n      { database: \"postgresql\" },\n    );\n    const statement = Array.isArray(parsed) ? parsed[0] : parsed;\n    if (!isSqlAstRecord(statement)) {\n      return undefined;\n    }\n\n    return serializeIndexWhereAst(statement.where);\n  } catch {\n    return undefined;\n  }\n}\n\nfunction serializeIndexWhereAst(node: unknown): string {\n  // PostgreSQL이 IN을 ANY(ARRAY[...])로 재작성하므로 membership은 먼저 특수 처리한다.\n  const membership = serializeSqlMembershipPredicate(node);\n  if (membership) {\n    return membership;\n  }\n\n  if (!isSqlAstRecord(node)) {\n    return JSON.stringify(node);\n  }\n\n  const type = getSqlAstString(node, \"type\");\n  switch (type) {\n    case \"binary_expr\": {\n      const operator = normalizeSqlOperator(getSqlAstString(node, \"operator\"));\n      const left = serializeIndexWhereAst(node.left);\n      const right = serializeIndexWhereAst(node.right);\n      if (operator === \"AND\" || operator === \"OR\") {\n        // AND/OR는 순서가 diff 의미를 바꾸지 않으므로 stable identity로 정렬한다.\n        return `(${[left, right].toSorted().join(` ${operator} `)})`;\n      }\n      return `(${left} ${operator} ${right})`;\n    }\n    case \"unary_expr\": {\n      const operator = normalizeSqlOperator(getSqlAstString(node, \"operator\"));\n      return `(${operator} ${serializeIndexWhereAst(node.expr)})`;\n    }\n    case \"column_ref\": {\n      return serializeSqlColumnRef(node);\n    }\n    case \"single_quote_string\": {\n      return `string:${JSON.stringify(getSqlAstString(node, \"value\"))}`;\n    }\n    case \"number\": {\n      return `number:${String(node.value)}`;\n    }\n    case \"bool\": {\n      return `bool:${String(node.value).toLowerCase()}`;\n    }\n    case \"null\": {\n      return \"null\";\n    }\n    case \"cast\": {\n      const targetType = getSqlCastTargetType(node);\n      const expr = node.expr;\n      if (targetType && isTextLikeSqlType(targetType) && isSqlStringLiteralLike(expr)) {\n        return serializeIndexWhereAst(stripTextLikeSqlCast(expr));\n      }\n      return `cast(${serializeIndexWhereAst(expr)} as ${targetType ?? \"unknown\"})`;\n    }\n    case \"function\": {\n      return `fn:${getSqlFunctionName(node)}(${serializeSqlExprList(node.args).join(\",\")})`;\n    }\n    case \"array\": {\n      return `array:[${serializeSqlArrayElements(node).map(serializeIndexWhereAst).join(\",\")}]`;\n    }\n    case \"expr_list\": {\n      return `list:[${serializeSqlExprList(node).map(serializeIndexWhereAst).join(\",\")}]`;\n    }\n    case \"default\": {\n      return `ident:${normalizeSqlIdentifier(getSqlAstString(node, \"value\") ?? \"\")}`;\n    }\n    default: {\n      return serializeUnknownSqlAstRecord(node);\n    }\n  }\n}\n\nfunction serializeSqlMembershipPredicate(node: unknown): string | undefined {\n  if (!isSqlAstRecord(node) || getSqlAstString(node, \"type\") !== \"binary_expr\") {\n    return undefined;\n  }\n\n  // IN (...)과 = ANY(ARRAY[...])를 동일한 unordered membership 표현으로 맞춘다.\n  const operator = normalizeSqlOperator(getSqlAstString(node, \"operator\"));\n  const left = serializeIndexWhereAst(stripTextLikeSqlCast(node.left));\n  const values = (() => {\n    if (operator === \"IN\") {\n      return serializeSqlMembershipValues(serializeSqlExprList(node.right));\n    }\n\n    if (operator === \"=\") {\n      return serializeSqlMembershipValues(getSqlAnyArrayElements(node.right));\n    }\n\n    return undefined;\n  })();\n\n  if (!values) {\n    return undefined;\n  }\n\n  return `membership:${left}:in:[${values.join(\",\")}]`;\n}\n\nfunction serializeSqlMembershipValues(values: unknown[] | undefined): string[] | undefined {\n  if (!values) {\n    return undefined;\n  }\n\n  // membership 값의 순서와 중복은 의미가 없으므로 안정적인 identity로 정렬한다.\n  const serialized = values.map((value) => serializeIndexWhereAst(stripTextLikeSqlCast(value)));\n  return [...new Set(serialized)].toSorted();\n}\n\nfunction getSqlAnyArrayElements(node: unknown): unknown[] | undefined {\n  if (!isSqlAstRecord(node) || getSqlAstString(node, \"type\") !== \"function\") {\n    return undefined;\n  }\n  if (getSqlFunctionName(node) !== \"any\") {\n    return undefined;\n  }\n\n  // ANY()의 첫 번째 인자만 PostgreSQL 배열 membership 대상으로 해석한다.\n  const [arg] = serializeSqlExprList(node.args);\n  if (!arg) {\n    return undefined;\n  }\n\n  return serializeSqlArrayElements(stripTextLikeSqlCast(arg));\n}\n\nfunction serializeSqlArrayElements(node: unknown): unknown[] {\n  if (!isSqlAstRecord(node)) {\n    return [];\n  }\n\n  // parser 버전에 따라 배열 원소가 array.expr_list 또는 expr_list로 들어온다.\n  if (getSqlAstString(node, \"type\") === \"array\") {\n    return serializeSqlExprList(node.expr_list);\n  }\n\n  return serializeSqlExprList(node);\n}\n\nfunction serializeSqlExprList(node: unknown): unknown[] {\n  if (!isSqlAstRecord(node)) {\n    return [];\n  }\n\n  // expr_list는 실제 AST 노드 배열이고, 단일 표현식은 배열 하나로 감싸 통일한다.\n  if (getSqlAstString(node, \"type\") === \"expr_list\" && Array.isArray(node.value)) {\n    return node.value;\n  }\n\n  return [node];\n}\n\nfunction stripTextLikeSqlCast(node: unknown): unknown {\n  if (!isSqlAstRecord(node) || getSqlAstString(node, \"type\") !== \"cast\") {\n    return node;\n  }\n\n  // PostgreSQL은 varchar/text cast를 배열 또는 원소 쪽으로 옮길 수 있어 비교에서 제거한다.\n  const targetType = getSqlCastTargetType(node);\n  if (!targetType || !isTextLikeSqlType(targetType)) {\n    return node;\n  }\n\n  return stripTextLikeSqlCast(node.expr);\n}\n\nfunction isSqlStringLiteralLike(node: unknown): boolean {\n  // 문자열 literal에 붙은 text 계열 cast는 membership 비교에서 의미가 같다.\n  const stripped = stripTextLikeSqlCast(node);\n  return isSqlAstRecord(stripped) && getSqlAstString(stripped, \"type\") === \"single_quote_string\";\n}\n\nfunction getSqlCastTargetType(node: Record<string, unknown>): string | undefined {\n  if (!Array.isArray(node.target)) {\n    return undefined;\n  }\n\n  // character varying처럼 여러 token으로 오는 타입명을 하나의 정규화 문자열로 합친다.\n  const dataTypes = node.target\n    .map((target) => (isSqlAstRecord(target) ? getSqlAstString(target, \"dataType\") : undefined))\n    .filter((dataType): dataType is string => dataType !== undefined);\n\n  if (dataTypes.length === 0) {\n    return undefined;\n  }\n\n  return normalizeSqlDataType(dataTypes.join(\" \"));\n}\n\nfunction isTextLikeSqlType(type: string): boolean {\n  // 배열 cast(text[])도 원소 membership 비교에서는 text 계열 cast로 취급한다.\n  const normalized = normalizeSqlDataType(type).replace(/\\[\\]$/g, \"\");\n  return normalized === \"text\" || normalized === \"varchar\";\n}\n\nfunction normalizeSqlDataType(type: string): string {\n  return type\n    .trim()\n    .toLowerCase()\n    .replace(/\\s+/g, \" \")\n    .replace(/^character varying$/, \"varchar\");\n}\n\nfunction serializeSqlColumnRef(node: Record<string, unknown>): string {\n  const table = serializeSqlIdentifierNode(node.table);\n  const column = serializeSqlIdentifierNode(node.column);\n  return `column:${table ? `${table}.` : \"\"}${column}`;\n}\n\nfunction serializeSqlIdentifierNode(node: unknown): string {\n  if (typeof node === \"string\") {\n    return normalizeSqlIdentifier(node);\n  }\n\n  // quoted identifier와 function name의 AST shape 차이를 같은 identifier 문자열로 흡수한다.\n  if (isSqlAstRecord(node)) {\n    if (typeof node.value === \"string\") {\n      return normalizeSqlIdentifier(node.value);\n    }\n\n    if (isSqlAstRecord(node.expr) && typeof node.expr.value === \"string\") {\n      return normalizeSqlIdentifier(node.expr.value);\n    }\n  }\n\n  return \"\";\n}\n\nfunction getSqlFunctionName(node: Record<string, unknown>): string {\n  const name = node.name;\n  if (typeof name === \"string\") {\n    return normalizeSqlIdentifier(name);\n  }\n\n  // ANY처럼 name.name 배열로 오는 function AST를 schema-qualified 이름까지 지원한다.\n  if (isSqlAstRecord(name)) {\n    if (Array.isArray(name.name)) {\n      return name.name.map(serializeSqlIdentifierNode).join(\".\");\n    }\n\n    const nameParts = serializeSqlExprList(name);\n    if (nameParts.length > 0) {\n      return nameParts.map(serializeSqlIdentifierNode).join(\".\");\n    }\n  }\n\n  return \"\";\n}\n\nfunction normalizeSqlIdentifier(identifier: string): string {\n  return identifier.trim().toLowerCase();\n}\n\nfunction normalizeSqlOperator(operator: string | undefined): string {\n  return (operator ?? \"\").trim().toUpperCase().replace(/\\s+/g, \" \");\n}\n\nfunction serializeUnknownSqlAstRecord(node: Record<string, unknown>): string {\n  // 아직 명시적으로 다루지 않는 AST 노드는 key 정렬로 최소한 안정적인 비교값을 만든다.\n  const entries = Object.entries(node)\n    .filter(([key]) => key !== \"parentheses\")\n    .toSorted(([left], [right]) => left.localeCompare(right))\n    .map(([key, value]) => `${key}:${serializeIndexWhereAst(value)}`);\n\n  return `record:{${entries.join(\",\")}}`;\n}\n\nfunction isSqlAstRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction getSqlAstString(node: Record<string, unknown>, key: string): string | undefined {\n  const value = node[key];\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction findMatchingParenthesisInSql(source: string, openIndex: number): number {\n  let depth = 0;\n  let inSingleQuote = false;\n  let inDoubleQuote = false;\n\n  // SQL 문자열과 quoted identifier 내부 괄호는 grouping 괄호로 세지 않는다.\n  for (let index = openIndex; index < source.length; index += 1) {\n    const char = source[index];\n    const nextChar = source[index + 1];\n\n    if (char === \"'\" && !inDoubleQuote) {\n      if (inSingleQuote && nextChar === \"'\") {\n        index += 1;\n        continue;\n      }\n      inSingleQuote = !inSingleQuote;\n      continue;\n    }\n\n    if (char === '\"' && !inSingleQuote) {\n      if (inDoubleQuote && nextChar === '\"') {\n        index += 1;\n        continue;\n      }\n      inDoubleQuote = !inDoubleQuote;\n      continue;\n    }\n\n    if (inSingleQuote || inDoubleQuote) {\n      continue;\n    }\n\n    if (char === \"(\") {\n      depth += 1;\n      continue;\n    }\n\n    if (char === \")\") {\n      depth -= 1;\n      if (depth === 0) {\n        return index;\n      }\n    }\n  }\n\n  return -1;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.9.17",
+  "version": "0.9.19",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "framework",
@@ -129,10 +129,10 @@
     "tsicli": "^1.0.5",
     "vite": "8.0.5",
     "vitest": "^4.1.2",
-    "@sonamu-kit/hmr-hook": "^0.5.1",
-    "@sonamu-kit/tasks": "^0.3.0",
+    "@sonamu-kit/hmr-runner": "^0.2.0",
     "@sonamu-kit/ts-loader": "^2.2.0",
-    "@sonamu-kit/hmr-runner": "^0.2.0"
+    "@sonamu-kit/tasks": "^0.3.0",
+    "@sonamu-kit/hmr-hook": "^0.5.1"
   },
   "devDependencies": {
     "@types/bcrypt": "^6",

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

@@ -0,0 +1,284 @@
+import { APICallError } from "@ai-sdk/provider";
+import { type FetchFunction } from "@ai-sdk/provider-utils";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { RtzrClientError } from "../error";
+import { RtzrTranscriptionModel } from "../model";
+
+type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+
+type MockResponse = {
+  body: JsonValue;
+  status?: number;
+};
+
+const audio = new Uint8Array([1, 2, 3]);
+
+function jsonResponse({ body, status = 200 }: MockResponse): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+}
+
+function createFetchMock(responses: MockResponse[]): FetchFunction {
+  return async () => {
+    const response = responses.shift();
+    if (response === undefined) {
+      throw new Error("Unexpected RTZR request");
+    }
+
+    return jsonResponse(response);
+  };
+}
+
+function createModel(fetchMock: FetchFunction) {
+  return new RtzrTranscriptionModel("sommers", {
+    _internal: {
+      currentDate: () => new Date("2026-06-17T00:00:00.000Z"),
+    },
+    provider: "rtzr.transcription",
+    auth: {
+      clientId: "client-id",
+      clientSecret: "client-secret",
+    },
+    url: ({ path }) => `https://rtzr.test/v1${path}`,
+    headers: () => ({
+      "x-test": "1",
+    }),
+    fetch: fetchMock,
+  });
+}
+
+describe("RtzrTranscriptionModel", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("returns completed transcription text, segments, and language", async () => {
+    vi.useFakeTimers();
+    const model = createModel(
+      createFetchMock([
+        {
+          body: {
+            access_token: "token",
+            expire_at: 1_797_000_000,
+          },
+        },
+        {
+          body: {
+            id: "transcribe-1",
+          },
+        },
+        {
+          body: {
+            id: "transcribe-1",
+            status: "completed",
+            results: {
+              utterances: [
+                {
+                  start_at: 1000,
+                  duration: 2500,
+                  msg: "hello",
+                  spk: 0,
+                  lang: "en",
+                },
+                {
+                  start_at: 3500,
+                  duration: 1200,
+                  msg: "world",
+                  spk: 0,
+                  lang: "en",
+                },
+              ],
+            },
+          },
+        },
+      ]),
+    );
+
+    const resultPromise = model.doGenerate({
+      audio,
+      mediaType: "audio/wav",
+      headers: {},
+    });
+    await vi.advanceTimersByTimeAsync(5000);
+    const result = await resultPromise;
+
+    expect(result.text).toBe("hello\nworld");
+    expect(result.language).toBe("en");
+    expect(result.segments).toEqual([
+      {
+        text: "hello",
+        startSecond: 1,
+        endSecond: 3,
+      },
+      {
+        text: "world",
+        startSecond: 3,
+        endSecond: 4,
+      },
+    ]);
+  });
+
+  it("throws a detailed RTZR error when polling returns failed", async () => {
+    vi.useFakeTimers();
+    const model = createModel(
+      createFetchMock([
+        {
+          body: {
+            access_token: "token",
+            expire_at: 1_797_000_000,
+          },
+        },
+        {
+          body: {
+            id: "transcribe-2",
+          },
+        },
+        {
+          body: {
+            id: "transcribe-2",
+            status: "failed",
+            error: {
+              code: "E500",
+              message: "internal server error",
+            },
+          },
+        },
+      ]),
+    );
+
+    const resultPromise = model.doGenerate({
+      audio,
+      mediaType: "audio/wav",
+      headers: {},
+    });
+    const errorPromise = resultPromise.catch((error: unknown) => error);
+    await vi.advanceTimersByTimeAsync(5000);
+    const error = await errorPromise;
+
+    expect(error).toBeInstanceOf(RtzrClientError);
+    expect(error).toMatchObject({
+      message: expect.stringContaining("RTZR transcription failed for id transcribe-2"),
+    });
+    expect(error).toMatchObject({
+      message: expect.stringContaining("code E500"),
+    });
+    expect(error).toMatchObject({
+      message: expect.stringContaining("internal server error"),
+    });
+  });
+
+  it("converts flat RTZR HTTP errors to useful API messages", async () => {
+    const model = createModel(
+      createFetchMock([
+        {
+          body: {
+            access_token: "token",
+            expire_at: 1_797_000_000,
+          },
+        },
+        {
+          status: 400,
+          body: {
+            code: "H0001",
+            msg: "unexpected end of JSON input",
+          },
+        },
+      ]),
+    );
+
+    await expect(
+      model.doGenerate({
+        audio,
+        mediaType: "audio/wav",
+        headers: {},
+      }),
+    ).rejects.toMatchObject({
+      name: "AI_APICallError",
+      message: expect.stringContaining("HTTP 400: code H0001: unexpected end of JSON input"),
+    });
+  });
+
+  it("includes auth response details without secrets", async () => {
+    const model = createModel(
+      createFetchMock([
+        {
+          status: 401,
+          body: {
+            code: "H401",
+            msg: "invalid client credentials",
+          },
+        },
+      ]),
+    );
+
+    const resultPromise = model.doGenerate({
+      audio,
+      mediaType: "audio/wav",
+      headers: {},
+    });
+    const error = await resultPromise.catch((caughtError: unknown) => caughtError);
+
+    expect(error).toBeInstanceOf(RtzrClientError);
+    expect(error).toMatchObject({
+      message: expect.stringContaining(
+        "Failed to authorize RTZR: HTTP 401: code H401: invalid client credentials",
+      ),
+    });
+    expect(error).toMatchObject({
+      message: expect.not.stringContaining("client-secret"),
+    });
+  });
+
+  it("includes auth schema details for invalid auth payloads", async () => {
+    const model = createModel(
+      createFetchMock([
+        {
+          body: {
+            token: "wrong-field",
+          },
+        },
+      ]),
+    );
+
+    await expect(
+      model.doGenerate({
+        audio,
+        mediaType: "audio/wav",
+        headers: {},
+      }),
+    ).rejects.toThrow("Invalid RTZR auth response");
+  });
+
+  it("keeps RTZR HTTP errors as API call errors", async () => {
+    const model = createModel(
+      createFetchMock([
+        {
+          body: {
+            access_token: "token",
+            expire_at: 1_797_000_000,
+          },
+        },
+        {
+          status: 404,
+          body: {
+            code: "H0004",
+            msg: "not found",
+          },
+        },
+      ]),
+    );
+
+    await expect(
+      model.doGenerate({
+        audio,
+        mediaType: "audio/wav",
+        headers: {},
+      }),
+    ).rejects.toThrow(APICallError);
+  });
+});

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

@@ -19,6 +19,12 @@ export const rtzrTranscriptionResultResponseSchema = lazySchema(() =>
     z.object({
       id: z.string(),
       status: z.enum(["transcribing", "completed", "failed"]),
+      error: z
+        .object({
+          code: z.union([z.string(), z.number()]).nullish(),
+          message: z.string().nullish(),
+        })
+        .nullish(),
       results: z
         .object({
           utterances: z.array(