@simplysm/orm-common 13.0.100 → 14.0.4

package/src/exec/search-parser.ts

@@ -1,16 +1,16 @@
 /**
- * Search query parsing result (LIKE pattern)
+ * 검색 쿼리 파싱 결과 (LIKE 패턴)
  */
 export interface ParsedSearchQuery {
-  /** General search terms (OR condition) - LIKE pattern */
+  /** 일반 검색어 (OR 조건) - LIKE 패턴 */
   or: string[];
-  /** Required search terms (AND condition, + prefix or quotes) - LIKE pattern */
+  /** 필수 검색어 (AND 조건, + 접두사 또는 따옴표) - LIKE 패턴 */
   must: string[];
-  /** Excluded search terms (NOT condition, - prefix) - LIKE pattern */
+  /** 제외 검색어 (NOT 조건, - 접두사) - LIKE 패턴 */
   not: string[];
 }
 
-// Replace escape sequences with placeholders
+// 이스케이프 시퀀스를 플레이스홀더로 치환
 const ESC = {
   BACKSLASH: "\x00BACKSLASH\x00",
   ASTERISK: "\x00ASTERISK\x00",
@@ -21,38 +21,38 @@ const ESC = {
 };
 
 /**
- * Parse search query string and convert to SQL LIKE pattern.
+ * 검색 쿼리 문자열을 파싱하여 SQL LIKE 패턴으로 변환한다.
  *
- * ## Search Syntax
+ * ## 검색 구문
  *
- * | Syntax | Meaning | Example |
+ * | 구문 | 의미 | 예시 |
  * |--------|---------|---------|
- * | `term1 term2` | OR (one of them) | `apple banana` |
- * | `+term` | Required (AND) | `+apple +banana` |
- * | `-term` | Excluded (NOT) | `apple -banana` |
- * | `"exact phrase"` | Exact match (required) | `"delicious fruit"` |
- * | `*` | Wildcard | `app*` → `app%` |
+ * | `term1 term2` | OR (하나 이상 일치) | `apple banana` |
+ * | `+term` | 필수 포함 (AND) | `+apple +banana` |
+ * | `-term` | 제외 (NOT) | `apple -banana` |
+ * | `"exact phrase"` | 정확한 구문 일치 (필수) | `"맛있는 과일"` |
+ * | `*` | 와일드카드 | `app*` → `app%` |
  *
- * ## Escape Sequences
+ * ## 이스케이프 시퀀스
  *
- * | Input | Meaning |
+ * | 입력 | 의미 |
  * |-------|---------|
- * | `\\` | Literal `\` |
- * | `\*` | Literal `*` |
- * | `\%` | Literal `%` |
- * | `\"` | Literal `"` |
- * | `\+` | Literal `+` |
- * | `\-` | Literal `-` |
+ * | `\\` | 리터럴 `\` |
+ * | `\*` | 리터럴 `*` |
+ * | `\%` | 리터럴 `%` |
+ * | `\"` | 리터럴 `"` |
+ * | `\+` | 리터럴 `+` |
+ * | `\-` | 리터럴 `-` |
  *
- * ## Special Cases
+ * ## 특수 케이스
  *
- * - Unclosed quotes (`"text`) are treated as regular text including the quote character.
+ * - 닫히지 않은 따옴표(`"text`)는 따옴표를 포함한 일반 텍스트로 처리된다.
  *
- * ## Examples
+ * ## 예시
  *
  * ```typescript
  * parseSearchQuery('apple "delicious fruit" -banana +strawberry')
- * // Result:
+ * // 결과:
  * // {
  * //   or: ["%apple%"],
  * //   must: ["%delicious fruit%", "%strawberry%"],
@@ -60,24 +60,24 @@ const ESC = {
  * // }
  *
  * parseSearchQuery('app* test')
- * // Result:
+ * // 결과:
  * // {
- * //   or: ["app%", "%test%"],  // app* starts with "app", test is substring match
+ * //   or: ["app%", "%test%"],  // app*는 "app"으로 시작, test는 부분 문자열 검색
  * //   must: [],
  * //   not: []
  * // }
  *
- * parseSearchQuery('app\\*test')  // escaped *
- * // Result:
+ * parseSearchQuery('app\\*test')  // 이스케이프된 *
+ * // 결과:
  * // {
- * //   or: ["%app*test%"],  // literal *
+ * //   or: ["%app*test%"],  // 리터럴 *
  * //   must: [],
  * //   not: []
  * // }
  * ```
  *
- * @param searchText Search query string
- * @returns Parsed search query object (LIKE pattern)
+ * @param searchText 검색 쿼리 문자열
+ * @returns 파싱된 검색 쿼리 객체 (LIKE 패턴)
  */
 export function parseSearchQuery(searchText: string): ParsedSearchQuery {
   const result: ParsedSearchQuery = {
@@ -98,7 +98,7 @@ export function parseSearchQuery(searchText: string): ParsedSearchQuery {
     .replace(/\\\+/g, ESC.PLUS)
     .replace(/\\-/g, ESC.MINUS);
 
-  // Extract quoted sections
+  // 따옴표 구간 추출
   const quotedRegex = /([+-]?)"([^"]*)"/g;
   let match: RegExpExecArray | null;
 
@@ -115,21 +115,21 @@ export function parseSearchQuery(searchText: string): ParsedSearchQuery {
     } else if (prefix === "-") {
       result.not.push(pattern);
     } else {
-      // Quoted text is treated as must (exact match = required)
+      // 따옴표 텍스트는 must로 처리 (정확한 일치 = 필수)
       result.must.push(pattern);
     }
   }
 
-  // Remove quoted sections
+  // 따옴표 구간 제거
   processed = processed.replace(/[+-]?"[^"]*"/g, " ");
 
-  // Split tokens by whitespace
+  // 공백으로 토큰 분리
   const tokens = processed.split(/\s+/).filter((t) => t.length > 0);
 
   for (let token of tokens) {
     let targetArray = result.or;
 
-    // Handle + or - prefix
+    // + 또는 - 접두사 처리
     if (token.startsWith("+")) {
       targetArray = result.must;
       token = token.slice(1);
@@ -148,32 +148,32 @@ export function parseSearchQuery(searchText: string): ParsedSearchQuery {
 }
 
 /**
- * Convert search term to SQL LIKE pattern (internal function)
+ * 검색어를 SQL LIKE 패턴으로 변환 (내부 함수)
  *
- * Wildcard rules:
- * - `apple` (no wildcard) → `%apple%` (substring match, default)
- * - `apple*` → `apple%` (starts with)
- * - `*apple` → `%apple` (ends with)
- * - `*apple*` → `%apple%` (explicit substring)
- * - `a*ple` → `a%ple` (in the middle)
+ * 와일드카드 규칙:
+ * - `apple` (와일드카드 없음) → `%apple%` (부분 문자열 검색, 기본값)
+ * - `apple*` → `apple%` (시작 일치)
+ * - `*apple` → `%apple` (끝 일치)
+ * - `*apple*` → `%apple%` (명시적 부분 문자열)
+ * - `a*ple` → `a%ple` (중간 일치)
  */
 function termToLikePattern(term: string): string {
-  // Convert wildcard * to temporary marker (escaped ones are already handled as ESC.ASTERISK)
+  // 와일드카드 *를 임시 마커로 변환 (이스케이프된 것은 이미 ESC.ASTERISK로 처리됨)
   const WILDCARD = "\x01WILDCARD\x01";
   const hasWildcard = term.includes("*");
   let pattern = term.replace(/\*/g, WILDCARD);
 
-  // Escape SQL LIKE special characters (\ → \\, % → \%, _ → \_, [ → \[)
+  // SQL LIKE 특수 문자 이스케이프 (\ → \\, % → \%, _ → \_, [ → \[)
   pattern = pattern
     .replace(/\\/g, "\\\\")
     .replace(/%/g, "\\%")
     .replace(/_/g, "\\_")
     .replace(/\[/g, "\\[");
 
-  // Convert wildcard marker → % (SQL wildcard)
+  // 와일드카드 마커 → % (SQL 와일드카드)로 변환
   pattern = pattern.replaceAll(WILDCARD, "%");
 
-  // Restore escape placeholders
+  // 이스케이프 플레이스홀더 복원
   pattern = pattern
     .replaceAll(ESC.BACKSLASH, "\\\\") // \\ → SQL \\
     .replaceAll(ESC.ASTERISK, "*") // \* → literal * (not special in SQL)
@@ -182,8 +182,8 @@ function termToLikePattern(term: string): string {
     .replaceAll(ESC.PLUS, "+")
     .replaceAll(ESC.MINUS, "-");
 
-  // If no wildcard, add % on both sides (default substring search)
-  // If wildcard exists, use the pattern as specified by the user
+  // 와일드카드가 없으면 양쪽에 % 추가 (기본 부분 문자열 검색)
+  // 와일드카드가 있으면 사용자가 지정한 패턴 그대로 사용
   if (hasWildcard) {
     return pattern;
   }

package/src/expr/expr-unit.ts

@@ -2,8 +2,8 @@ import type { ColumnPrimitive, ColumnPrimitiveStr } from "../types/column";
 import type { Expr, WhereExpr } from "../types/expr";
 
 /**
- * Type-safe expression wrapper
- * Tracks expression return type using TypeScript generics
+ * 타입 안전 표현식 래퍼
+ * TypeScript 제네릭을 사용하여 표현식 반환 타입을 추적한다
  */
 export class ExprUnit<TPrimitive extends ColumnPrimitive> {
   readonly $infer!: TPrimitive;
@@ -19,13 +19,13 @@ export class ExprUnit<TPrimitive extends ColumnPrimitive> {
 }
 
 /**
- * Expression wrapper for WHERE clause
+ * WHERE 절용 표현식 래퍼
  */
 export class WhereExprUnit {
   constructor(readonly expr: WhereExpr) {}
 }
 
 /**
- * Input type that accepts ExprUnit or literal values
+ * ExprUnit 또는 리터럴 값을 받는 입력 타입
  */
 export type ExprInput<TPrimitive extends ColumnPrimitive> = ExprUnit<TPrimitive> | TPrimitive;