sonamu 0.9.13 → 0.9.15

package/src/template/implementations/sd.template.ts

@@ -202,27 +202,83 @@ type LocalizedBaseColumn<T> = {
  * @example
  * localizedColumn(tag, "name")
  */
+type LocalizedColumnScalarValue = string | number | boolean | bigint;
+type LocalizedColumnValue = string | string[];
+type NestedLocalizedColumnValueFrom<V> = V extends string
+  ? string
+  : V extends readonly string[]
+    ? string[]
+    : never;
+type LocalizedColumnValueFrom<V> = V extends string
+  ? string
+  : V extends readonly string[]
+    ? string[]
+    : V extends number | boolean | bigint
+      ? string
+      : V extends Partial<Record<(typeof SUPPORTED_LOCALES)[number], infer LV>>
+        ? NestedLocalizedColumnValueFrom<LV>
+      : never;
+type LocalizedColumnCandidate<T, K extends string> =
+  | (K extends keyof T ? T[K] : never)
+  | {
+      [L in (typeof SUPPORTED_LOCALES)[number]]: \`\${K}_\${L}\` extends keyof T ? T[\`\${K}_\${L}\`] : never;
+    }[(typeof SUPPORTED_LOCALES)[number]];
+type LocalizedColumnReturn<T, K extends string> =
+  | LocalizedColumnValueFrom<LocalizedColumnCandidate<T, K>>
+  | undefined;
+type LocaleValueMap = Partial<Record<(typeof SUPPORTED_LOCALES)[number], unknown>>;
+
+function isLocalizedColumnValue(value: unknown): value is LocalizedColumnValue {
+  return typeof value === "string" || (Array.isArray(value) && value.every((item) => typeof item === "string"));
+}
+
+function isLocalizedColumnScalarValue(value: unknown): value is LocalizedColumnScalarValue {
+  return ["string", "number", "boolean", "bigint"].includes(typeof value);
+}
+
+function isEmptyLocalizedColumnValue(value: unknown): value is null | undefined | "" {
+  return value === null || value === undefined || value === "";
+}
+
+function getNestedLocaleValue<T extends Record<string, unknown>, K extends LocalizedBaseColumn<T>>(
+  row: T,
+  column: K,
+  locale: (typeof SUPPORTED_LOCALES)[number],
+): unknown {
+  const columnValue = row[column];
+  if (columnValue === null || typeof columnValue !== "object" || Array.isArray(columnValue)) {
+    return undefined;
+  }
+
+  return (columnValue as LocaleValueMap)[locale];
+}
+
 export function localizedColumn<T extends Record<string, unknown>, K extends LocalizedBaseColumn<T>>(
   row: T,
   column: K,
-): string | undefined {
-  const locale = getCurrentLocale();
+): LocalizedColumnReturn<T, K> {
+  const currentLocale = getCurrentLocale();
+  const locale = SUPPORTED_LOCALES.includes(currentLocale) ? currentLocale : DEFAULT_LOCALE;
   const otherLocales = SUPPORTED_LOCALES.filter((l: string) => l !== locale && l !== DEFAULT_LOCALE);
   const localizedKey = (column: K, locale: (typeof SUPPORTED_LOCALES)[number]) => \`\${column}_\${locale}\`;
-  const keys = [
-    localizedKey(column, locale),
-    column,
-    localizedKey(column, DEFAULT_LOCALE),
-    ...otherLocales.map((l) => localizedKey(column, l)),
+  const values = [
+    { value: row[localizedKey(column, locale)], source: "direct" },
+    { value: getNestedLocaleValue(row, column, locale), source: "nested" },
+    { value: row[column], source: "direct" },
+    { value: row[localizedKey(column, DEFAULT_LOCALE)], source: "direct" },
+    { value: getNestedLocaleValue(row, column, DEFAULT_LOCALE), source: "nested" },
+    ...otherLocales.flatMap((l) => [
+      { value: row[localizedKey(column, l)], source: "direct" },
+      { value: getNestedLocaleValue(row, column, l), source: "nested" },
+    ]),
   ];
 
-  for (const key of keys) {
-    if (!(key in row)) {
-      continue;
+  for (const { value, source } of values) {
+    if (!isEmptyLocalizedColumnValue(value) && isLocalizedColumnValue(value)) {
+      return value as LocalizedColumnReturn<T, K>;
     }
-
-    if (row[key] !== null && row[key] !== undefined && row[key] !== "") {
-      return String(row[key]);
+    if (source === "direct" && !isEmptyLocalizedColumnValue(value) && isLocalizedColumnScalarValue(value)) {
+      return String(value) as LocalizedColumnReturn<T, K>;
     }
   }
 

package/src/types/__tests__/entity-json-schema-search-text.test.ts

@@ -60,6 +60,45 @@ describe("EntityJsonSchema searchText/opclass validation", () => {
     expect(legacyResult.success).toBe(true);
   });
 
+  test("index where predicate는 raw SQL 문자열로 허용하되 빈 문자열은 거부해야 한다", () => {
+    const baseEntity = createBaseEntity();
+    const partialIndex = {
+      ...baseEntity,
+      indexes: [
+        {
+          ...baseEntity.indexes[0],
+          where: "deleted_at IS NULL",
+        },
+      ],
+    };
+    const partialResult = EntityJsonSchema.safeParse(partialIndex);
+    expect(partialResult.success).toBe(true);
+
+    const emptyPredicate = {
+      ...baseEntity,
+      indexes: [
+        {
+          ...baseEntity.indexes[0],
+          where: "",
+        },
+      ],
+    };
+    const emptyResult = EntityJsonSchema.safeParse(emptyPredicate);
+    expect(emptyResult.success).toBe(false);
+
+    const blankPredicate = {
+      ...baseEntity,
+      indexes: [
+        {
+          ...baseEntity.indexes[0],
+          where: "   ",
+        },
+      ],
+    };
+    const blankResult = EntityJsonSchema.safeParse(blankPredicate);
+    expect(blankResult.success).toBe(false);
+  });
+
   test("searchText source column 존재/타입 검증이 동작해야 한다", () => {
     const unknownSource = createBaseEntity();
     unknownSource.props[4] = {

package/src/types/types.ts

@@ -410,6 +410,8 @@ export type EntityIndex = {
   name: string;
   using?: "btree" | "hash" | "gin" | "gist" | "pgroonga";
   nullsNotDistinct?: boolean; // unique index only
+  /** PostgreSQL partial index predicate. Raw SQL WHERE expression without the WHERE keyword. */
+  where?: string;
   /**
    * HNSW (Hierarchical Navigable Small World) 인덱스: 각 노드의 최대 연결 수
    *
@@ -832,6 +834,8 @@ export type MigrationIndex = {
   name: string;
   using?: "btree" | "hash" | "gin" | "gist" | "pgroonga";
   nullsNotDistinct?: boolean;
+  /** PostgreSQL partial index predicate. Raw SQL WHERE expression without the WHERE keyword. */
+  where?: string;
   /** HNSW (Hierarchical Navigable Small World): 각 노드의 최대 연결 수 */
   m?: number;
   /** HNSW (Hierarchical Navigable Small World): 구성 시 탐색 범위 */
@@ -1495,6 +1499,7 @@ const EntityIndexSchema = z
     name: z.string().min(1).max(63),
     using: z.enum(["btree", "hash", "gin", "gist", "pgroonga"]).optional(),
     nullsNotDistinct: z.boolean().optional(),
+    where: z.string().trim().min(1).optional(),
     m: z.number().optional(),
     efConstruction: z.number().optional(),
     lists: z.number().optional(),

package/src/ui/entity.instructions.md

@@ -336,8 +336,11 @@
 2. 모든 엔티티는 `EntityNameOrderBy`, `EntityNameSearchField` Enum을 필수로 포함해야 합니다.
 3. 엔티티 내에서 사용하는 Enum ID는 엔티티 이름을 접두어로 사용합니다. (예: UserStatus, ProductType)
 4. indexes가 지정되지 않으면 빈 배열로 반환합니다.
-5. subsets이 지정되지 않으면 `{ "A": ["id"] }`로 반환합니다.
-6. relation 필드명은 `_id` 접미어 대신 관련 엔티티를 나타내는 이름을 사용합니다. (예: "user", "author", "category")
+5. partial index가 필요하면 index에 `where`를 raw SQL predicate로 지정합니다. (예:
+   `"where": "deleted_at IS NULL"`)
+6. `where`는 PostgreSQL partial index predicate로 그대로 사용되므로 사용자 입력을 조합하지 않습니다.
+7. subsets이 지정되지 않으면 `{ "A": ["id"] }`로 반환합니다.
+8. relation 필드명은 `_id` 접미어 대신 관련 엔티티를 나타내는 이름을 사용합니다. (예: "user", "author", "category")
 
 ### Property Rules
 
@@ -511,7 +514,8 @@
     {
       "name": "products_status_index",
       "type": "index",
-      "columns": [{ "name": "status" }]
+      "columns": [{ "name": "status" }],
+      "where": "status = 'active'"
     }
   ],
   "subsets": {

package/src/utils/utils.ts

@@ -46,7 +46,7 @@ export function nonNullable<T>(value: T): value is NonNullable<T> {
   return value !== null && value !== undefined;
 }
 
-export function exhaustive(_param: never) {
+export function exhaustive(_param: never): never {
   throw new Error(`exhaustive`);
 }