sonamu 0.9.13 → 0.9.15

package/dist/utils/utils.js

@@ -93,4 +93,4 @@ var init_utils = __esmMin((() => {}));
 //#endregion
 init_utils();
 export { assertDefined, assertExists, assertNotNull, convertFastifyHeadersToStandard, differenceWith, exhaustive, findApiRootPath, findAppRootPath, init_utils, intersectionBy, isPlainObject, merge, nonNullable };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","names":[],"sources":["../../src/utils/utils.ts"],"sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\n\nimport { type FastifyRequest } from \"fastify\";\n\nimport { type AbsolutePath } from \"./path-utils\";\n\nexport function findAppRootPath(): AbsolutePath {\n  const apiRootPath = findApiRootPath();\n  return path.dirname(apiRootPath) as AbsolutePath;\n}\n\nexport function findApiRootPath(): AbsolutePath {\n  // NOTE: for support npm / yarn / pnpm workspaces\n  // 하지만 workspace 쓰면 process.cwd() 하면 되는데... 이건 나중에 협의 후 수정하는걸로\n  const workspacePath = process.env.PNPM_SCRIPT_SRC_DIR ?? process.env.INIT_CWD;\n  if (nonNullable(workspacePath)) {\n    return workspacePath as AbsolutePath;\n  }\n\n  if (nonNullable(process.env.PNPM_PACKAGE_NAME)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const cwdPackagePath = path.join(process.cwd(), \"package.json\");\n  if (fs.existsSync(cwdPackagePath)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const basePath = import.meta.filename;\n  let dir = path.dirname(basePath);\n  if (dir.includes(\"/.yarn/\")) {\n    dir = dir.split(\"/.yarn/\")[0];\n  }\n\n  do {\n    if (fs.existsSync(path.join(dir, \"/package.json\"))) {\n      return dir.split(path.sep).join(path.sep) as AbsolutePath;\n    }\n    dir = dir.split(path.sep).slice(0, -1).join(path.sep);\n  } while (dir.split(path.sep).length > 1);\n  throw new Error(\"Cannot find AppRoot using Sonamu -2\");\n}\n\nexport function nonNullable<T>(value: T): value is NonNullable<T> {\n  return value !== null && value !== undefined;\n}\n\nexport function exhaustive(_param: never) {\n  throw new Error(`exhaustive`);\n}\n\n// 일반 버전\nexport function assertExists<T>(value: T | null | undefined, message?: string): T {\n  if (value === null || value === undefined) {\n    throw new Error(message ?? \"Value must exist\");\n  }\n  return value;\n}\n\n// null만 체크\nexport function assertNotNull<T>(value: T | null, message?: string): T {\n  if (value === null) {\n    throw new Error(message ?? \"Value must not be null\");\n  }\n  return value;\n}\n// undefined만 체크\nexport function assertDefined<T>(value: T | undefined, message?: string): T {\n  if (value === undefined) {\n    throw new Error(message ?? \"Value must be defined\");\n  }\n  return value;\n}\n\n// lodash intersectionBy 대체\nexport function intersectionBy<T, K>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  iteratee: (item: T) => K,\n): T[] {\n  const arr2Keys = new Set(arr2.map(iteratee));\n  return arr1.filter((item) => arr2Keys.has(iteratee(item)));\n}\n// lodash differenceWith 대체\nexport function differenceWith<T>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  comparator: (a: T, b: T) => boolean,\n): T[] {\n  return arr1.filter((itemA) => !arr2.some((itemB) => comparator(itemA, itemB)));\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: dynamic property access\nexport function merge<T extends Record<string, any>>(defaultObj: T, userObj: T): T {\n  // 원본 보존을 위해 defaultObj 복사\n  const result = { ...defaultObj };\n\n  // userObj의 각 속성을 순회\n  for (const key in userObj) {\n    // userObj의 own property만 처리 (프로토타입 체인 제외)\n    if (Object.hasOwn(userObj, key)) {\n      const userValue = userObj[key];\n      const defaultValue = result[key];\n\n      // 두 값이 모두 객체이고, 배열이 아닌 경우 재귀적으로 병합\n      if (isPlainObject(userValue) && isPlainObject(defaultValue)) {\n        result[key] = merge(defaultValue, userValue);\n      } else {\n        // 그 외의 경우 userObj의 값으로 덮어쓰기\n        result[key] = userValue;\n      }\n    }\n  }\n\n  return result;\n}\n\n// plain object 판별 헬퍼 함수\n// (배열, null, Date 등을 제외한 순수 객체만 true)\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    !Array.isArray(value) &&\n    Object.prototype.toString.call(value) === \"[object Object]\"\n  );\n}\n\n// Convert Fastify headers to standard Headers object\nexport function convertFastifyHeadersToStandard(headers: FastifyRequest[\"headers\"]): Headers {\n  const headersObj = new Headers();\n  Object.entries(headers).forEach(([key, value]) => {\n    if (value) headersObj.append(key, value.toString());\n  });\n  return headersObj;\n}\n"],"mappings":";;;;;AAOA,SAAgB,kBAAgC;CAC9C,MAAM,cAAc,iBAAiB;AACrC,QAAO,KAAK,QAAQ,YAAY;;AAGlC,SAAgB,kBAAgC;CAG9C,MAAM,gBAAgB,QAAQ,IAAI,uBAAuB,QAAQ,IAAI;AACrE,KAAI,YAAY,cAAc,EAAE;AAC9B,SAAO;;AAGT,KAAI,YAAY,QAAQ,IAAI,kBAAkB,EAAE;AAC9C,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,iBAAiB,KAAK,KAAK,QAAQ,KAAK,EAAE,eAAe;AAC/D,KAAI,GAAG,WAAW,eAAe,EAAE;AACjC,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,WAAW,OAAO,KAAK;CAC7B,IAAI,MAAM,KAAK,QAAQ,SAAS;AAChC,KAAI,IAAI,SAAS,UAAU,EAAE;AAC3B,QAAM,IAAI,MAAM,UAAU,CAAC;;AAG7B,IAAG;AACD,MAAI,GAAG,WAAW,KAAK,KAAK,KAAK,gBAAgB,CAAC,EAAE;AAClD,UAAO,IAAI,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;AAE3C,QAAM,IAAI,MAAM,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI;UAC9C,IAAI,MAAM,KAAK,IAAI,CAAC,SAAS;AACtC,OAAM,IAAI,MAAM,sCAAsC;;AAGxD,SAAgB,YAAe,OAAmC;AAChE,QAAO,UAAU,QAAQ,UAAU;;AAGrC,SAAgB,WAAW,QAAe;AACxC,OAAM,IAAI,MAAM,aAAa;;AAI/B,SAAgB,aAAgB,OAA6B,SAAqB;AAChF,KAAI,UAAU,QAAQ,UAAU,WAAW;AACzC,QAAM,IAAI,MAAM,WAAW,mBAAmB;;AAEhD,QAAO;;AAIT,SAAgB,cAAiB,OAAiB,SAAqB;AACrE,KAAI,UAAU,MAAM;AAClB,QAAM,IAAI,MAAM,WAAW,yBAAyB;;AAEtD,QAAO;;AAGT,SAAgB,cAAiB,OAAsB,SAAqB;AAC1E,KAAI,UAAU,WAAW;AACvB,QAAM,IAAI,MAAM,WAAW,wBAAwB;;AAErD,QAAO;;AAIT,SAAgB,eACd,MACA,MACA,UACK;CACL,MAAM,WAAW,IAAI,IAAI,KAAK,IAAI,SAAS,CAAC;AAC5C,QAAO,KAAK,QAAQ,SAAS,SAAS,IAAI,SAAS,KAAK,CAAC,CAAC;;AAG5D,SAAgB,eACd,MACA,MACA,YACK;AACL,QAAO,KAAK,QAAQ,UAAU,CAAC,KAAK,MAAM,UAAU,WAAW,OAAO,MAAM,CAAC,CAAC;;AAIhF,SAAgB,MAAqC,YAAe,SAAe;CAEjF,MAAM,SAAS,EAAE,GAAG,YAAY;AAGhC,MAAK,MAAM,OAAO,SAAS;AAEzB,MAAI,OAAO,OAAO,SAAS,IAAI,EAAE;GAC/B,MAAM,YAAY,QAAQ;GAC1B,MAAM,eAAe,OAAO;AAG5B,OAAI,cAAc,UAAU,IAAI,cAAc,aAAa,EAAE;AAC3D,WAAO,OAAO,MAAM,cAAc,UAAU;UACvC;AAEL,WAAO,OAAO;;;;AAKpB,QAAO;;AAKT,SAAgB,cAAc,OAAkD;AAC9E,QACE,UAAU,QACV,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,MAAM,IACrB,OAAO,UAAU,SAAS,KAAK,MAAM,KAAK;;AAK9C,SAAgB,gCAAgC,SAA6C;CAC3F,MAAM,aAAa,IAAI,SAAS;AAChC,QAAO,QAAQ,QAAQ,CAAC,SAAS,CAAC,KAAK,WAAW;AAChD,MAAI,MAAO,YAAW,OAAO,KAAK,MAAM,UAAU,CAAC;GACnD;AACF,QAAO"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils.js","names":[],"sources":["../../src/utils/utils.ts"],"sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\n\nimport { type FastifyRequest } from \"fastify\";\n\nimport { type AbsolutePath } from \"./path-utils\";\n\nexport function findAppRootPath(): AbsolutePath {\n  const apiRootPath = findApiRootPath();\n  return path.dirname(apiRootPath) as AbsolutePath;\n}\n\nexport function findApiRootPath(): AbsolutePath {\n  // NOTE: for support npm / yarn / pnpm workspaces\n  // 하지만 workspace 쓰면 process.cwd() 하면 되는데... 이건 나중에 협의 후 수정하는걸로\n  const workspacePath = process.env.PNPM_SCRIPT_SRC_DIR ?? process.env.INIT_CWD;\n  if (nonNullable(workspacePath)) {\n    return workspacePath as AbsolutePath;\n  }\n\n  if (nonNullable(process.env.PNPM_PACKAGE_NAME)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const cwdPackagePath = path.join(process.cwd(), \"package.json\");\n  if (fs.existsSync(cwdPackagePath)) {\n    return process.cwd().split(path.sep).join(path.sep) as AbsolutePath;\n  }\n\n  const basePath = import.meta.filename;\n  let dir = path.dirname(basePath);\n  if (dir.includes(\"/.yarn/\")) {\n    dir = dir.split(\"/.yarn/\")[0];\n  }\n\n  do {\n    if (fs.existsSync(path.join(dir, \"/package.json\"))) {\n      return dir.split(path.sep).join(path.sep) as AbsolutePath;\n    }\n    dir = dir.split(path.sep).slice(0, -1).join(path.sep);\n  } while (dir.split(path.sep).length > 1);\n  throw new Error(\"Cannot find AppRoot using Sonamu -2\");\n}\n\nexport function nonNullable<T>(value: T): value is NonNullable<T> {\n  return value !== null && value !== undefined;\n}\n\nexport function exhaustive(_param: never): never {\n  throw new Error(`exhaustive`);\n}\n\n// 일반 버전\nexport function assertExists<T>(value: T | null | undefined, message?: string): T {\n  if (value === null || value === undefined) {\n    throw new Error(message ?? \"Value must exist\");\n  }\n  return value;\n}\n\n// null만 체크\nexport function assertNotNull<T>(value: T | null, message?: string): T {\n  if (value === null) {\n    throw new Error(message ?? \"Value must not be null\");\n  }\n  return value;\n}\n// undefined만 체크\nexport function assertDefined<T>(value: T | undefined, message?: string): T {\n  if (value === undefined) {\n    throw new Error(message ?? \"Value must be defined\");\n  }\n  return value;\n}\n\n// lodash intersectionBy 대체\nexport function intersectionBy<T, K>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  iteratee: (item: T) => K,\n): T[] {\n  const arr2Keys = new Set(arr2.map(iteratee));\n  return arr1.filter((item) => arr2Keys.has(iteratee(item)));\n}\n// lodash differenceWith 대체\nexport function differenceWith<T>(\n  arr1: readonly T[],\n  arr2: readonly T[],\n  comparator: (a: T, b: T) => boolean,\n): T[] {\n  return arr1.filter((itemA) => !arr2.some((itemB) => comparator(itemA, itemB)));\n}\n\n// biome-ignore lint/suspicious/noExplicitAny: dynamic property access\nexport function merge<T extends Record<string, any>>(defaultObj: T, userObj: T): T {\n  // 원본 보존을 위해 defaultObj 복사\n  const result = { ...defaultObj };\n\n  // userObj의 각 속성을 순회\n  for (const key in userObj) {\n    // userObj의 own property만 처리 (프로토타입 체인 제외)\n    if (Object.hasOwn(userObj, key)) {\n      const userValue = userObj[key];\n      const defaultValue = result[key];\n\n      // 두 값이 모두 객체이고, 배열이 아닌 경우 재귀적으로 병합\n      if (isPlainObject(userValue) && isPlainObject(defaultValue)) {\n        result[key] = merge(defaultValue, userValue);\n      } else {\n        // 그 외의 경우 userObj의 값으로 덮어쓰기\n        result[key] = userValue;\n      }\n    }\n  }\n\n  return result;\n}\n\n// plain object 판별 헬퍼 함수\n// (배열, null, Date 등을 제외한 순수 객체만 true)\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  return (\n    value !== null &&\n    typeof value === \"object\" &&\n    !Array.isArray(value) &&\n    Object.prototype.toString.call(value) === \"[object Object]\"\n  );\n}\n\n// Convert Fastify headers to standard Headers object\nexport function convertFastifyHeadersToStandard(headers: FastifyRequest[\"headers\"]): Headers {\n  const headersObj = new Headers();\n  Object.entries(headers).forEach(([key, value]) => {\n    if (value) headersObj.append(key, value.toString());\n  });\n  return headersObj;\n}\n"],"mappings":";;;;;AAOA,SAAgB,kBAAgC;CAC9C,MAAM,cAAc,iBAAiB;AACrC,QAAO,KAAK,QAAQ,YAAY;;AAGlC,SAAgB,kBAAgC;CAG9C,MAAM,gBAAgB,QAAQ,IAAI,uBAAuB,QAAQ,IAAI;AACrE,KAAI,YAAY,cAAc,EAAE;AAC9B,SAAO;;AAGT,KAAI,YAAY,QAAQ,IAAI,kBAAkB,EAAE;AAC9C,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,iBAAiB,KAAK,KAAK,QAAQ,KAAK,EAAE,eAAe;AAC/D,KAAI,GAAG,WAAW,eAAe,EAAE;AACjC,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;CAGrD,MAAM,WAAW,OAAO,KAAK;CAC7B,IAAI,MAAM,KAAK,QAAQ,SAAS;AAChC,KAAI,IAAI,SAAS,UAAU,EAAE;AAC3B,QAAM,IAAI,MAAM,UAAU,CAAC;;AAG7B,IAAG;AACD,MAAI,GAAG,WAAW,KAAK,KAAK,KAAK,gBAAgB,CAAC,EAAE;AAClD,UAAO,IAAI,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,IAAI;;AAE3C,QAAM,IAAI,MAAM,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK,IAAI;UAC9C,IAAI,MAAM,KAAK,IAAI,CAAC,SAAS;AACtC,OAAM,IAAI,MAAM,sCAAsC;;AAGxD,SAAgB,YAAe,OAAmC;AAChE,QAAO,UAAU,QAAQ,UAAU;;AAGrC,SAAgB,WAAW,QAAsB;AAC/C,OAAM,IAAI,MAAM,aAAa;;AAI/B,SAAgB,aAAgB,OAA6B,SAAqB;AAChF,KAAI,UAAU,QAAQ,UAAU,WAAW;AACzC,QAAM,IAAI,MAAM,WAAW,mBAAmB;;AAEhD,QAAO;;AAIT,SAAgB,cAAiB,OAAiB,SAAqB;AACrE,KAAI,UAAU,MAAM;AAClB,QAAM,IAAI,MAAM,WAAW,yBAAyB;;AAEtD,QAAO;;AAGT,SAAgB,cAAiB,OAAsB,SAAqB;AAC1E,KAAI,UAAU,WAAW;AACvB,QAAM,IAAI,MAAM,WAAW,wBAAwB;;AAErD,QAAO;;AAIT,SAAgB,eACd,MACA,MACA,UACK;CACL,MAAM,WAAW,IAAI,IAAI,KAAK,IAAI,SAAS,CAAC;AAC5C,QAAO,KAAK,QAAQ,SAAS,SAAS,IAAI,SAAS,KAAK,CAAC,CAAC;;AAG5D,SAAgB,eACd,MACA,MACA,YACK;AACL,QAAO,KAAK,QAAQ,UAAU,CAAC,KAAK,MAAM,UAAU,WAAW,OAAO,MAAM,CAAC,CAAC;;AAIhF,SAAgB,MAAqC,YAAe,SAAe;CAEjF,MAAM,SAAS,EAAE,GAAG,YAAY;AAGhC,MAAK,MAAM,OAAO,SAAS;AAEzB,MAAI,OAAO,OAAO,SAAS,IAAI,EAAE;GAC/B,MAAM,YAAY,QAAQ;GAC1B,MAAM,eAAe,OAAO;AAG5B,OAAI,cAAc,UAAU,IAAI,cAAc,aAAa,EAAE;AAC3D,WAAO,OAAO,MAAM,cAAc,UAAU;UACvC;AAEL,WAAO,OAAO;;;;AAKpB,QAAO;;AAKT,SAAgB,cAAc,OAAkD;AAC9E,QACE,UAAU,QACV,OAAO,UAAU,YACjB,CAAC,MAAM,QAAQ,MAAM,IACrB,OAAO,UAAU,SAAS,KAAK,MAAM,KAAK;;AAK9C,SAAgB,gCAAgC,SAA6C;CAC3F,MAAM,aAAa,IAAI,SAAS;AAChC,QAAO,QAAQ,QAAQ,CAAC,SAAS,CAAC,KAAK,WAAW;AAChD,MAAI,MAAO,YAAW,OAAO,KAAK,MAAM,UAAU,CAAC;GACnD;AACF,QAAO"}

package/package.json

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

package/src/database/puri.ts

@@ -40,6 +40,25 @@ import {
 } from "./puri.types";
 import { FUZZY_OPERATORS } from "./puri.types";
 
+type PuriOrderByDirection = "asc" | "desc";
+type PuriOrderByNulls = "first" | "last";
+type PuriOrderByExpression = SqlExpression<"number"> | SqlExpression<"string">;
+type PuriOrderByItem<TColumn extends string> = {
+  column: TColumn | PuriOrderByExpression;
+  order?: PuriOrderByDirection;
+  nulls?: PuriOrderByNulls;
+};
+type PuriOrderByEntry<TColumn extends string> =
+  | TColumn
+  | PuriOrderByExpression
+  | PuriOrderByItem<TColumn>;
+type PuriOrderByRuntimeItem = {
+  column: string | PuriOrderByExpression;
+  order?: PuriOrderByDirection;
+  nulls?: PuriOrderByNulls;
+};
+type PuriOrderByRuntimeEntry = string | PuriOrderByExpression | PuriOrderByRuntimeItem;
+
 function normalizeFuzzyOperator(operator?: string): FuzzyOperator {
   const normalized = operator?.trim() ?? "<%";
   const fuzzyOperator = FUZZY_OPERATORS.find((candidate) => candidate === normalized);
@@ -51,6 +70,42 @@ function normalizeFuzzyOperator(operator?: string): FuzzyOperator {
   return fuzzyOperator;
 }
 
+function normalizeOrderByDirection(direction: PuriOrderByDirection = "asc"): PuriOrderByDirection {
+  if (direction !== "asc" && direction !== "desc") {
+    throw new Error(`Invalid order direction: ${direction}`);
+  }
+
+  return direction;
+}
+
+function normalizeOrderByNulls(nulls?: PuriOrderByNulls): PuriOrderByNulls | undefined {
+  if (nulls === undefined) {
+    return undefined;
+  }
+
+  if (nulls !== "first" && nulls !== "last") {
+    throw new Error(`Invalid order nulls: ${nulls}`);
+  }
+
+  return nulls;
+}
+
+function formatNullsSuffix(nulls?: PuriOrderByNulls): string {
+  if (!nulls) {
+    return "";
+  }
+
+  return ` NULLS ${nulls.toUpperCase()}`;
+}
+
+function isOrderByEntries(value: unknown): value is readonly PuriOrderByRuntimeEntry[] {
+  return Array.isArray(value);
+}
+
+function isSqlExpression(value: PuriOrderByRuntimeEntry): value is PuriOrderByExpression {
+  return typeof value === "object" && "_type" in value && value._type === "sql_expression";
+}
+
 export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
   private knexQuery: Knex.QueryBuilder;
   private tableSpec: TableSpec | null = null;
@@ -837,19 +892,49 @@ export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
 
   // ORDER BY (SqlExpression으로도 할 수 있어야 함)
   orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(
-    column: TColumn | SqlExpression<"number"> | SqlExpression<"string">,
-    direction: "asc" | "desc",
+    column: TColumn | PuriOrderByExpression,
+    direction?: PuriOrderByDirection,
+    nulls?: PuriOrderByNulls,
+  ): this;
+  orderBy<TColumn extends ResultAvailableColumns<TTables, TResult>>(
+    columns: readonly PuriOrderByEntry<TColumn>[],
   ): this;
   orderBy(
-    column: string | SqlExpression<"number"> | SqlExpression<"string">,
-    direction: "asc" | "desc" = "asc",
+    columnOrColumns: string | PuriOrderByExpression | readonly PuriOrderByRuntimeEntry[],
+    direction: PuriOrderByDirection = "asc",
+    nulls?: PuriOrderByNulls,
   ): this {
+    if (isOrderByEntries(columnOrColumns)) {
+      for (const entry of columnOrColumns) {
+        if (typeof entry === "string" || isSqlExpression(entry)) {
+          this.applyOrderBy(entry);
+        } else {
+          this.applyOrderBy(entry.column, entry.order, entry.nulls);
+        }
+      }
+      return this;
+    }
+
+    this.applyOrderBy(columnOrColumns, direction, nulls);
+    return this;
+  }
+
+  private applyOrderBy(
+    column: string | PuriOrderByExpression,
+    direction?: PuriOrderByDirection,
+    nulls?: PuriOrderByNulls,
+  ): void {
+    const normalizedDirection = normalizeOrderByDirection(direction);
+    const normalizedNulls = normalizeOrderByNulls(nulls);
+
     if (typeof column === "object") {
-      this.knexQuery.orderByRaw(`${column._sql} ${direction}`, column._params);
+      this.knexQuery.orderByRaw(
+        `${column._sql} ${normalizedDirection}${formatNullsSuffix(normalizedNulls)}`,
+        column._params,
+      );
     } else {
-      this.knexQuery.orderBy(column, direction);
+      this.knexQuery.orderBy(column, normalizedDirection, normalizedNulls);
     }
-    return this;
   }
 
   forUpdate(): this {

package/src/database/puri.types.test-d.ts

@@ -477,3 +477,73 @@ describe("Puri locking methods", () => {
     expectTypeOf(result).resolves.toEqualTypeOf<MockSchema["users"]>();
   });
 });
+
+describe("Puri orderBy methods", () => {
+  it("단일 컬럼 null ordering과 체이닝 타입을 지원한다", () => {
+    type Query = Puri<MockSchema, { users: MockSchema["users"] }, MockSchema["users"]>;
+    const query = {} as Query;
+
+    expectTypeOf(query.orderBy("id")).toEqualTypeOf<Query>();
+    expectTypeOf(query.orderBy("id", "asc")).toEqualTypeOf<Query>();
+    expectTypeOf(query.orderBy("id", "desc", "last")).toEqualTypeOf<Query>();
+    expectTypeOf(query.orderBy("users.department_id", "asc", "first")).toEqualTypeOf<Query>();
+  });
+
+  it("여러 컬럼 orderBy item 배열을 지원한다", () => {
+    type Query = Puri<MockSchema, { users: MockSchema["users"] }, MockSchema["users"]>;
+    const query = {} as Query;
+
+    expectTypeOf(query.orderBy(["name", "email"])).toEqualTypeOf<Query>();
+    expectTypeOf(
+      query.orderBy([
+        { column: "name" },
+        { column: "email", order: "asc" },
+        { column: "users.department_id", order: "desc", nulls: "last" },
+      ]),
+    ).toEqualTypeOf<Query>();
+  });
+
+  it("select 결과 컬럼을 orderBy에 사용할 수 있다", () => {
+    type Result = { post_count: number };
+    type Query = Puri<MockSchema, { users: MockSchema["users"] }, Result>;
+    const query = {} as Query;
+
+    expectTypeOf(query.orderBy("post_count", "desc", "last")).toEqualTypeOf<Query>();
+    expectTypeOf(query.orderBy(["post_count"])).toEqualTypeOf<Query>();
+    expectTypeOf(
+      query.orderBy([{ column: "post_count", order: "desc", nulls: "last" }]),
+    ).toEqualTypeOf<Query>();
+  });
+
+  it("SqlExpression orderBy를 지원한다", () => {
+    type Query = Puri<MockSchema, { users: MockSchema["users"] }, MockSchema["users"]>;
+    const query = {} as Query;
+    const expression = Puri.rawNumber("COUNT(*)");
+
+    expectTypeOf(query.orderBy(expression, "desc", "last")).toEqualTypeOf<Query>();
+    expectTypeOf(query.orderBy([expression])).toEqualTypeOf<Query>();
+    expectTypeOf(
+      query.orderBy([{ column: expression, order: "desc", nulls: "first" }]),
+    ).toEqualTypeOf<Query>();
+  });
+
+  it("잘못된 direction, nulls, column은 거부한다", () => {
+    type Query = Puri<MockSchema, { users: MockSchema["users"] }, MockSchema["users"]>;
+    const query = {} as Query;
+
+    // @ts-expect-error direction은 asc/desc만 허용한다.
+    query.orderBy("id", "ascending");
+
+    // @ts-expect-error nulls는 first/last만 허용한다.
+    query.orderBy("id", "asc", "middle");
+
+    // @ts-expect-error typed Puri에서는 존재하지 않는 컬럼을 허용하지 않는다.
+    query.orderBy("missing_column", "asc");
+
+    // @ts-expect-error 배열 item의 column도 typed Puri 컬럼 제약을 따른다.
+    query.orderBy([{ column: "missing_column", order: "asc" }]);
+
+    // @ts-expect-error string 배열도 typed Puri 컬럼 제약을 따른다.
+    query.orderBy(["name", "missing_column"]);
+  });
+});

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

@@ -3,10 +3,11 @@ import { describe, expect, test } from "vitest";
 import { Sonamu } from "../../api";
 import { Entity } from "../../entity/entity";
 import { EntityManager } from "../../entity/entity-manager";
-import { type MigrationSet } from "../../types/types";
+import { type MigrationIndex, type MigrationSet } from "../../types/types";
 import {
   generateAlterCode,
   generateCreateCode,
+  getAlterIndexesTo,
   setMigrationIndexDefaults,
 } from "../code-generation";
 import { getMigrationSetFromEntity } from "../migration-set";
@@ -387,3 +388,147 @@ describe("code-generation searchText/opclass DDL", () => {
     expect(migration.formatted).toContain("USING gin(search_text gin_trgm_ops);");
   });
 });
+
+describe("code-generation partial index DDL", () => {
+  test("unique partial index WHERE predicate를 출력해야 한다", async () => {
+    const migrationSet: MigrationSet = {
+      table: "partial_index_users",
+      columns: [
+        { name: "id", type: "integer", nullable: false },
+        { name: "email", type: "string", nullable: false },
+        { name: "deleted_at", type: "date", nullable: true },
+      ],
+      indexes: [
+        {
+          type: "unique",
+          name: "partial_index_users_email_active_unique",
+          columns: [{ name: "email" }],
+          nullsNotDistinct: true,
+          where: "deleted_at IS NULL",
+        },
+      ],
+      foreigns: [],
+    };
+
+    const [migration] = await generateCreateCode(migrationSet);
+
+    expect(migration.formatted).toContain(
+      "CREATE UNIQUE INDEX partial_index_users_email_active_unique ON",
+    );
+    expect(migration.formatted).toContain("NULLS NOT DISTINCT WHERE deleted_at IS NULL;");
+  });
+
+  test("vector partial index WHERE predicate를 출력해야 한다", async () => {
+    const migrationSet: MigrationSet = {
+      table: "partial_index_vectors",
+      columns: [
+        { name: "id", type: "integer", nullable: false },
+        { name: "embedding", type: "vector", dimensions: 1536, nullable: true },
+      ],
+      indexes: [
+        {
+          type: "hnsw",
+          name: "partial_index_vectors_embedding_hnsw",
+          columns: [{ name: "embedding", vectorOps: "vector_cosine_ops" }],
+          where: "embedding IS NOT NULL",
+        },
+      ],
+      foreigns: [],
+    };
+
+    const [migration] = await generateCreateCode(migrationSet);
+
+    expect(migration.formatted).toContain(
+      "USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 64) WHERE embedding IS NOT NULL",
+    );
+  });
+
+  test("pgroonga partial index WHERE predicate를 출력해야 한다", async () => {
+    const entity = await registerEntity({
+      id: "CodeGenerationPgroongaPartial",
+      table: "code_generation_pgroonga_partial",
+      props: [
+        { name: "id", type: "integer" },
+        { name: "title", type: "string" },
+        { name: "deleted_at", type: "date", nullable: true },
+      ],
+      indexes: [
+        {
+          type: "index",
+          name: "code_generation_pgroonga_partial_title_index",
+          using: "pgroonga",
+          columns: [{ name: "title" }],
+          where: "deleted_at IS NULL",
+        },
+      ],
+    });
+
+    const [migration] = await generateCreateCode(getMigrationSetFromEntity(entity));
+
+    expect(migration.formatted).toContain(
+      "USING pgroonga (title) WITH (tokenizer='TokenMecab') WHERE deleted_at IS NULL;",
+    );
+  });
+
+  test("partial index predicate의 바깥 괄호 차이는 alter diff에서 no-op이어야 한다", () => {
+    const entityIndex: MigrationIndex = {
+      type: "index",
+      name: "partial_index_users_email_active_index",
+      columns: [{ name: "email" }],
+      where: "deleted_at IS NULL",
+    };
+    const dbIndex: MigrationIndex = {
+      ...setMigrationIndexDefaults(entityIndex),
+      where: "(deleted_at IS NULL)",
+    };
+
+    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",
+      name: "partial_index_users_email_active_index",
+      columns: [{ name: "email" }],
+      where: "deleted_at IS NULL",
+    };
+    const nextIndex: MigrationIndex = {
+      ...previousIndex,
+      where: "archived_at IS NULL",
+    };
+
+    const alterIndexesTo = getAlterIndexesTo(
+      [nextIndex],
+      [setMigrationIndexDefaults(previousIndex)],
+    );
+
+    expect(alterIndexesTo.add).toHaveLength(1);
+    expect(alterIndexesTo.drop).toHaveLength(1);
+
+    const entitySet: MigrationSet = {
+      table: "partial_index_users",
+      columns: [
+        { name: "id", type: "integer", nullable: false },
+        { name: "email", type: "string", nullable: false },
+        { name: "deleted_at", type: "date", nullable: true },
+        { name: "archived_at", type: "date", nullable: true },
+      ],
+      indexes: [nextIndex],
+      foreigns: [],
+    };
+    const dbSet: MigrationSet = {
+      ...entitySet,
+      indexes: [setMigrationIndexDefaults(previousIndex)],
+    };
+
+    const [migration] = await generateAlterCode(entitySet, dbSet);
+
+    expect(migration.formatted).toContain(
+      'table.dropIndex(["email"], "partial_index_users_email_active_index")',
+    );
+    expect(migration.formatted).toContain("WHERE archived_at IS NULL;");
+  });
+});

package/src/migration/code-generation.ts

@@ -963,6 +963,7 @@ function genIndexDefinition(index: MigrationIndex, table: string): string {
       : "";
 
   const usingClause = index.using === undefined ? "" : `USING ${index.using}`;
+  const whereClause = getIndexWhereClause(index);
 
   return `await knex.raw(
   \`CREATE ${methodMap[index.type]} ${index.name} ON ${table} ${usingClause}(${index.columns
@@ -982,12 +983,13 @@ function genIndexDefinition(index: MigrationIndex, table: string): string {
         col.nullsFirst === undefined ? "" : ` NULLS ${col.nullsFirst ? "FIRST" : "LAST"}`;
       return `${col.name}${opclassClause}${sortOrderClause}${nullsFirstClause}`;
     })
-    .join(", ")})${nullsNotDistinctClause};\`
+    .join(", ")})${nullsNotDistinctClause}${whereClause};\`
   );`;
 }
 
 function genPgroongaIndexDefinition(index: MigrationIndex, table: string) {
   const entity = EntityManager.getByTable(table);
+  const whereClause = getIndexWhereClause(index);
 
   // 복합 인덱스인 경우 ARRAY 사용
   const columnClause = (() => {
@@ -1001,7 +1003,7 @@ function genPgroongaIndexDefinition(index: MigrationIndex, table: string) {
   })();
 
   return `await knex.raw(
-  \`CREATE INDEX ${index.name} ON ${table} USING pgroonga (${columnClause}) WITH (tokenizer='TokenMecab');\`
+  \`CREATE INDEX ${index.name} ON ${table} USING pgroonga (${columnClause}) WITH (tokenizer='TokenMecab')${whereClause};\`
   )`;
 }
 
@@ -1035,23 +1037,29 @@ function getPgroongaColumnOption(column: EntityProp) {
 function genVectorIndexDefinition(index: MigrationIndex, table: string): string {
   const column = index.columns[0];
   const vectorOps = getIndexColumnOpclass(column) ?? "vector_cosine_ops";
+  const whereClause = getIndexWhereClause(index);
 
   // HNSW (Hierarchical Navigable Small World) - 권장: 빠른 검색, 높은 정확도
   if (index.type === "hnsw") {
     const m = index.m ?? 16;
     const efConstruction = index.efConstruction ?? 64;
-    return `await knex.raw(\`CREATE INDEX ${index.name} ON ${table} USING hnsw (${column.name} ${vectorOps}) WITH (m = ${m}, ef_construction = ${efConstruction})\`);`;
+    return `await knex.raw(\`CREATE INDEX ${index.name} ON ${table} USING hnsw (${column.name} ${vectorOps}) WITH (m = ${m}, ef_construction = ${efConstruction})${whereClause}\`);`;
   }
 
   // IVFFlat (Inverted File with Flat Compression) - 대용량, 비용 중요 시
   if (index.type === "ivfflat") {
     const lists = index.lists ?? 100;
-    return `await knex.raw(\`CREATE INDEX ${index.name} ON ${table} USING ivfflat (${column.name} ${vectorOps}) WITH (lists = ${lists})\`);`;
+    return `await knex.raw(\`CREATE INDEX ${index.name} ON ${table} USING ivfflat (${column.name} ${vectorOps}) WITH (lists = ${lists})${whereClause}\`);`;
   }
 
   throw new Error(`Unknown raw SQL index type: ${index.type}`);
 }
 
+function getIndexWhereClause(index: MigrationIndex): string {
+  const where = normalizeIndexWherePredicate(index.where);
+  return where ? ` WHERE ${where}` : "";
+}
+
 /**
  * 테이블 생성하는 케이스 - FK 생성
  */
@@ -1602,9 +1610,11 @@ export function getAlterIndexesTo(entityIndexes: MigrationIndex[], dbIndexes: Mi
       .join("//");
   };
 
+  const normalizedEntityIndexes = entityIndexes.map(setMigrationIndexDefaults);
+  const normalizedDbIndexes = dbIndexes.map(setMigrationIndexDefaults);
   const extraIndexes = {
-    db: diff(dbIndexes, entityIndexes.map(setMigrationIndexDefaults), identity),
-    entity: diff(entityIndexes.map(setMigrationIndexDefaults), dbIndexes, identity),
+    db: diff(normalizedDbIndexes, normalizedEntityIndexes, identity),
+    entity: diff(normalizedEntityIndexes, normalizedDbIndexes, identity),
   };
   if (extraIndexes.entity.length > 0) {
     indexesTo.add = indexesTo.add.concat(extraIndexes.entity);
@@ -1632,6 +1642,7 @@ export function setMigrationIndexDefaults(index: MigrationIndex): 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);
 
   return {
     ...index,
@@ -1647,9 +1658,77 @@ export function setMigrationIndexDefaults(index: MigrationIndex): MigrationIndex
     })),
     nullsNotDistinct: index.nullsNotDistinct ?? false,
     ...(normalizedUsing ? { using: normalizedUsing } : {}),
+    ...(normalizedWhere ? { where: normalizedWhere } : {}),
   };
 }
 
+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 변경
  */

package/src/migration/postgresql-schema-reader.ts

@@ -56,6 +56,7 @@ type PgIndex = {
   nulls_not_distinct: boolean;
   column_order: number;
   index_definition: string;
+  predicate?: string | null;
 };
 
 type PgForeign = {
@@ -203,6 +204,7 @@ class PostgreSQLSchemaReaderClass {
         })),
 
         nullsNotDistinct: firstIndex.nulls_not_distinct,
+        ...(firstIndex.predicate ? { where: firstIndex.predicate } : {}),
         ...(using ? { using } : {}),
         ...this.parseVectorIndexOptions(restoredIndexType, parsedIndexDefinition.withOptions),
       };
@@ -310,7 +312,8 @@ class PostgreSQLSchemaReaderClass {
           END AS sort_order,
           ix.indnullsnotdistinct AS nulls_not_distinct,
           u.ord AS column_order,
-          pg_get_indexdef(ix.indexrelid) AS index_definition
+          pg_get_indexdef(ix.indexrelid) AS index_definition,
+          pg_get_expr(ix.indpred, ix.indrelid) AS predicate
       FROM pg_class t
       JOIN pg_index ix ON t.oid = ix.indrelid
       JOIN pg_class i ON i.oid = ix.indexrelid

package/src/skills/sonamu/i18n.md

@@ -147,15 +147,23 @@ SD("enum.UserRole.admin"); // → "관리자"
 
 ## localizedColumn
 
-Returns the value for the current locale when locale-specific columns exist in the DB:
+Returns the value for the current locale when locale-specific columns or locale maps exist in the DB:
 
 ```typescript
 import { localizedColumn } from "@/i18n/sd.generated";
 
 // DB: { name: "태그", name_ko: "태그", name_en: "Tag" }
 localizedColumn(tag, "name"); // → "태그" (ko) / "Tag" (en)
+
+// DB: { name: { ko: ["태그"], en: ["Tag"] } }
+localizedColumn(tag, "name"); // → ["태그"] (ko) / ["Tag"] (en)
 ```
 
+- `string[]` values are returned as arrays instead of being stringified.
+- Unsupported Context locales use `defaultLocale` before lookup.
+- Direct suffix/base scalar values such as numbers are stringified for compatibility.
+- Locale map values support only `string` and `string[]`.
+
 ## Sonamu UI Management
 
 `http://localhost:34900/sonamu-ui` → i18n tab: