sonamu 0.10.12 → 0.10.13

package/src/migration/index-where-predicate.ts

@@ -1,7 +1,32 @@
 import SqlParser from "node-sql-parser";
 
+import { isBooleanValue } from "../runtime-type";
+import { isNumberValue, isObjectValue, isStringValue } from "../utils/runtime-value";
+
 const INDEX_WHERE_SQL_PARSER = new SqlParser.Parser();
 
+type SqlAstValue = null | undefined | boolean | number | string | SqlAstValue[] | SqlAstRecord;
+interface SqlAstRecord {
+  [key: string]: SqlAstValue;
+}
+
+function parseSqlAstValue<Value>(value: Value): SqlAstValue {
+  if (value === null) return null;
+  if (value === undefined) return undefined;
+  if (isBooleanValue(value)) return value;
+  if (isNumberValue(value)) return value;
+  if (isStringValue(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map(parseSqlAstValue);
+  }
+  if (isObjectValue(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [key, parseSqlAstValue(child)]),
+    );
+  }
+  throw new Error("지원하지 않는 SQL AST 값입니다");
+}
+
 /**
  * Migration DDL 출력에 사용할 index predicate를 정리한다.
  * 원본 SQL 표현은 보존하고, 빈 문자열과 전체를 감싼 괄호만 제거한다.
@@ -56,9 +81,11 @@ function removeOuterSqlParentheses(source: string): string {
 function normalizeIndexWherePredicateByAst(where: string): string | undefined {
   try {
     // node-sql-parser는 raw predicate를 직접 파싱하지 않으므로 임시 SELECT WHERE로 감싼다.
-    const parsed = INDEX_WHERE_SQL_PARSER.astify(
-      `SELECT * FROM __sonamu_index_predicate_source WHERE ${where}`,
-      { database: "postgresql" },
+    const parsed = parseSqlAstValue(
+      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)) {
@@ -71,7 +98,7 @@ function normalizeIndexWherePredicateByAst(where: string): string | undefined {
   }
 }
 
-function serializeIndexWhereAst(node: unknown): string {
+function serializeIndexWhereAst(node: SqlAstValue): string {
   // PostgreSQL이 IN을 ANY(ARRAY[...])로 재작성하므로 membership은 먼저 특수 처리한다.
   const membership = serializeSqlMembershipPredicate(node);
   if (membership) {
@@ -139,7 +166,7 @@ function serializeIndexWhereAst(node: unknown): string {
   }
 }
 
-function serializeSqlMembershipPredicate(node: unknown): string | undefined {
+function serializeSqlMembershipPredicate(node: SqlAstValue): string | undefined {
   if (!isSqlAstRecord(node) || getSqlAstString(node, "type") !== "binary_expr") {
     return undefined;
   }
@@ -166,7 +193,7 @@ function serializeSqlMembershipPredicate(node: unknown): string | undefined {
   return `membership:${left}:in:[${values.join(",")}]`;
 }
 
-function serializeSqlMembershipValues(values: unknown[] | undefined): string[] | undefined {
+function serializeSqlMembershipValues(values: SqlAstValue[] | undefined): string[] | undefined {
   if (!values) {
     return undefined;
   }
@@ -176,7 +203,7 @@ function serializeSqlMembershipValues(values: unknown[] | undefined): string[] |
   return [...new Set(serialized)].toSorted();
 }
 
-function getSqlAnyArrayElements(node: unknown): unknown[] | undefined {
+function getSqlAnyArrayElements(node: SqlAstValue): SqlAstValue[] | undefined {
   if (!isSqlAstRecord(node) || getSqlAstString(node, "type") !== "function") {
     return undefined;
   }
@@ -193,7 +220,7 @@ function getSqlAnyArrayElements(node: unknown): unknown[] | undefined {
   return serializeSqlArrayElements(stripTextLikeSqlCast(arg));
 }
 
-function serializeSqlArrayElements(node: unknown): unknown[] {
+function serializeSqlArrayElements(node: SqlAstValue): SqlAstValue[] {
   if (!isSqlAstRecord(node)) {
     return [];
   }
@@ -206,7 +233,7 @@ function serializeSqlArrayElements(node: unknown): unknown[] {
   return serializeSqlExprList(node);
 }
 
-function serializeSqlExprList(node: unknown): unknown[] {
+function serializeSqlExprList(node: SqlAstValue): SqlAstValue[] {
   if (!isSqlAstRecord(node)) {
     return [];
   }
@@ -219,7 +246,7 @@ function serializeSqlExprList(node: unknown): unknown[] {
   return [node];
 }
 
-function stripTextLikeSqlCast(node: unknown): unknown {
+function stripTextLikeSqlCast(node: SqlAstValue): SqlAstValue {
   if (!isSqlAstRecord(node) || getSqlAstString(node, "type") !== "cast") {
     return node;
   }
@@ -233,13 +260,13 @@ function stripTextLikeSqlCast(node: unknown): unknown {
   return stripTextLikeSqlCast(node.expr);
 }
 
-function isSqlStringLiteralLike(node: unknown): boolean {
+function isSqlStringLiteralLike(node: SqlAstValue): boolean {
   // 문자열 literal에 붙은 text 계열 cast는 membership 비교에서 의미가 같다.
   const stripped = stripTextLikeSqlCast(node);
   return isSqlAstRecord(stripped) && getSqlAstString(stripped, "type") === "single_quote_string";
 }
 
-function getSqlCastTargetType(node: Record<string, unknown>): string | undefined {
+function getSqlCastTargetType(node: SqlAstRecord): string | undefined {
   if (!Array.isArray(node.target)) {
     return undefined;
   }
@@ -270,24 +297,24 @@ function normalizeSqlDataType(type: string): string {
     .replace(/^character varying$/, "varchar");
 }
 
-function serializeSqlColumnRef(node: Record<string, unknown>): string {
+function serializeSqlColumnRef(node: SqlAstRecord): string {
   const table = serializeSqlIdentifierNode(node.table);
   const column = serializeSqlIdentifierNode(node.column);
   return `column:${table ? `${table}.` : ""}${column}`;
 }
 
-function serializeSqlIdentifierNode(node: unknown): string {
-  if (typeof node === "string") {
+function serializeSqlIdentifierNode(node: SqlAstValue): string {
+  if (isStringValue(node)) {
     return normalizeSqlIdentifier(node);
   }
 
   // quoted identifier와 function name의 AST shape 차이를 같은 identifier 문자열로 흡수한다.
   if (isSqlAstRecord(node)) {
-    if (typeof node.value === "string") {
+    if (isStringValue(node.value)) {
       return normalizeSqlIdentifier(node.value);
     }
 
-    if (isSqlAstRecord(node.expr) && typeof node.expr.value === "string") {
+    if (isSqlAstRecord(node.expr) && isStringValue(node.expr.value)) {
       return normalizeSqlIdentifier(node.expr.value);
     }
   }
@@ -295,9 +322,9 @@ function serializeSqlIdentifierNode(node: unknown): string {
   return "";
 }
 
-function getSqlFunctionName(node: Record<string, unknown>): string {
+function getSqlFunctionName(node: SqlAstRecord): string {
   const name = node.name;
-  if (typeof name === "string") {
+  if (isStringValue(name)) {
     return normalizeSqlIdentifier(name);
   }
 
@@ -324,7 +351,7 @@ function normalizeSqlOperator(operator: string | undefined): string {
   return (operator ?? "").trim().toUpperCase().replace(/\s+/g, " ");
 }
 
-function serializeUnknownSqlAstRecord(node: Record<string, unknown>): string {
+function serializeUnknownSqlAstRecord(node: SqlAstRecord): string {
   // 아직 명시적으로 다루지 않는 AST 노드는 key 정렬로 최소한 안정적인 비교값을 만든다.
   const entries = Object.entries(node)
     .filter(([key]) => key !== "parentheses")
@@ -334,13 +361,13 @@ function serializeUnknownSqlAstRecord(node: Record<string, unknown>): string {
   return `record:{${entries.join(",")}}`;
 }
 
-function isSqlAstRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isSqlAstRecord(value: SqlAstValue): value is SqlAstRecord {
+  return isObjectValue(value) && value !== null && !Array.isArray(value);
 }
 
-function getSqlAstString(node: Record<string, unknown>, key: string): string | undefined {
+function getSqlAstString(node: SqlAstRecord, key: string): string | undefined {
   const value = node[key];
-  return typeof value === "string" ? value : undefined;
+  return isStringValue(value) ? value : undefined;
 }
 
 function findMatchingParenthesisInSql(source: string, openIndex: number): number {

package/src/migration/migration-set.ts

@@ -199,10 +199,14 @@ export function getMigrationSetFromEntity(entity: Entity): MigrationSetAndJoinTa
     },
     {
       table: entity.table,
-      columns: [] as MigrationColumn[],
-      indexes: [] as MigrationIndex[],
-      foreigns: [] as MigrationForeign[],
-      joinTables: [] as MigrationJoinTable[],
+      columns:
+        /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ [] as MigrationColumn[],
+      indexes:
+        /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ [] as MigrationIndex[],
+      foreigns:
+        /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ [] as MigrationForeign[],
+      joinTables:
+        /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ [] as MigrationJoinTable[],
     },
   );
 
@@ -268,6 +272,8 @@ function resolveEntityPropTypeToMigrationColumnType(prop: EntityProp): Migration
       return "tsvector";
     default:
       exhaustive(prop);
-      throw new Error(`Unknown entity prop type: ${(prop as { type: string }).type}`);
+      throw new Error(
+        `Unknown entity prop type: ${/* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ (prop as { type: string }).type}`,
+      );
   }
 }

package/src/migration/migrator.ts

@@ -18,6 +18,7 @@ import { Naite } from "../naite/naite";
 import { type GenMigrationCode, type MigrationSet } from "../types/types";
 import { isLocal, isTest } from "../utils/controller";
 import { exists } from "../utils/fs-utils";
+import { isObjectValue, isStringValue } from "../utils/runtime-value";
 import { generateAlterCode, generateCreateCode } from "./code-generation";
 import { getMigrationSetFromEntity } from "./migration-set";
 import { PostgreSQLSchemaReader } from "./postgresql-schema-reader";
@@ -40,12 +41,16 @@ export type MigrationResult = {
   applied: string[];
 }[];
 
+function padDatePart(number: number, size: number = 2): string {
+  return number.toString().padStart(size, "0");
+}
+
 export class MigrationTargetExecutionError extends Error {
   constructor(
     public readonly connKey: MigrationTarget | "shadow",
-    caught: unknown,
+    cause: unknown,
   ) {
-    super(caught instanceof Error ? caught.message : String(caught));
+    super(cause instanceof Error ? cause.message : String(cause));
     this.name = "MigrationTargetExecutionError";
   }
 }
@@ -82,23 +87,29 @@ function withTimeout<T>(promise: Promise<T>, ms: number, onTimeout: () => Error)
  * CLI 리팩토링 시점에서 제거해주셔도 무방합니다.
  */
 export class Migrator {
-  private isMissingMigrationTableError(error: unknown): boolean {
-    if (typeof error !== "object" || error === null) {
+  private isMissingMigrationTableError<Value>(error: Value): boolean {
+    if (!isObjectValue(error) || error === null) {
       return false;
     }
 
-    const maybePostgresError = error as { code?: unknown; message?: unknown };
+    const maybePostgresError =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ error as {
+        code?: unknown;
+        message?: unknown;
+      };
     return (
       maybePostgresError.code === "42P01" &&
-      typeof maybePostgresError.message === "string" &&
+      isStringValue(maybePostgresError.message) &&
       maybePostgresError.message.includes("knex_migrations")
     );
   }
 
-  private getMigrationTargetKeys(): MigrationTarget[] {
-    const connKeys = Object.keys(Sonamu.dbConfig).filter(
-      (key) => !key.endsWith("_readonly"),
-    ) as (keyof SonamuDBConfig)[];
+  /** 현재 실행 환경에서 허용된 마이그레이션 대상 키를 반환합니다. */
+  getMigrationTargetKeys(): MigrationTarget[] {
+    const connKeys =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ Object.keys(
+        Sonamu.dbConfig,
+      ).filter((key) => !key.endsWith("_readonly")) as (keyof SonamuDBConfig)[];
 
     if (isLocal()) {
       return connKeys;
@@ -146,16 +157,20 @@ export class Migrator {
     return results;
   }
 
-  private migrationName(migration: unknown): string {
-    if (typeof migration === "string") {
+  private migrationName<Value>(migration: Value): string {
+    if (isStringValue(migration)) {
       return path.basename(migration);
     }
-    if (typeof migration === "object" && migration !== null) {
-      const candidate = migration as { file?: unknown; name?: unknown };
-      if (typeof candidate.file === "string") {
+    if (isObjectValue(migration) && migration !== null) {
+      const candidate =
+        /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ migration as {
+          file?: unknown;
+          name?: unknown;
+        };
+      if (isStringValue(candidate.file)) {
         return path.basename(candidate.file);
       }
-      if (typeof candidate.name === "string") {
+      if (isStringValue(candidate.name)) {
         return path.basename(candidate.name);
       }
     }
@@ -177,7 +192,7 @@ export class Migrator {
     options?: MigrationRunOptions,
   ): Knex.MigratorConfigWithLifecycleHooks {
     let files: string[] = [];
-    const emitFile = (type: "file-start" | "file-executed", migration: unknown) => {
+    const emitFile = <Value>(type: "file-start" | "file-executed", migration: Value) => {
       const file = this.migrationName(migration);
       const index = Math.max(files.indexOf(file), 0);
       this.emitProgress(options, {
@@ -221,7 +236,10 @@ export class Migrator {
   getConnections(): MigrationConnectionMeta[] {
     const slackConfirm = new SlackConfirm();
     return this.getMigrationTargetKeys().map((connKey) => {
-      const connection = Sonamu.dbConfig[connKey].connection as Knex.PgConnectionConfig;
+      const connection =
+        /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ Sonamu.dbConfig[
+          connKey
+        ].connection as Knex.PgConnectionConfig;
       const host = connection.host ?? "localhost";
       return {
         connKey,
@@ -272,11 +290,13 @@ export class Migrator {
     const startedAt = performance.now();
     const codes = await this.getMigrationCodes();
     const knexOptions = Sonamu.dbConfig[connKey];
-    const connection = knexOptions.connection as Knex.PgConnectionConfig;
+    const connection =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ knexOptions.connection as Knex.PgConnectionConfig;
+    // SAFETY: Knex가 제공한 PostgreSQL 연결 구성을 복사해 timeout 필드만 덮어쓴다.
     const tConn = createKnexInstance({
       ...knexOptions,
       connection: {
-        ...(connection as Record<string, unknown>),
+        ...connection,
         connectionTimeoutMillis: MIGRATION_CONN_TIMEOUT_MS,
       },
       pool: {
@@ -306,32 +326,33 @@ export class Migrator {
       const pending: string[] = await tConn.migrate.list().then(
         ([, files]: [unknown[], { file: string }[]]) =>
           files.map(({ file }) => file.replace(/\.ts$/, "")),
-        (caught: unknown) => {
-          if (this.isMissingMigrationTableError(caught)) {
+        (cause: unknown) => {
+          if (this.isMissingMigrationTableError(cause)) {
             return codes.map(({ name }) => name);
           }
-          error ??= caught instanceof Error ? caught.message : String(caught);
+          error ??= cause instanceof Error ? cause.message : String(cause);
           return [];
         },
       );
       const currentVersion: string | "none" | "error" = await tConn.migrate
         .currentVersion()
-        .catch((caught: unknown) => {
-          if (this.isMissingMigrationTableError(caught)) {
+        .catch((cause: unknown) => {
+          if (this.isMissingMigrationTableError(cause)) {
             return "none" as const;
           }
-          error ??= caught instanceof Error ? caught.message : String(caught);
+          error ??= cause instanceof Error ? cause.message : String(cause);
           return "error" as const;
         });
       Naite.t("migrator:getStatus:status", status);
-      return {
+      const connectionStatus: MigrationConnectionStatus = {
         connKey,
         currentVersion,
         status,
         pending,
         latencyMs: performance.now() - startedAt,
-        ...(error === undefined ? {} : { error }),
       };
+      if (error !== undefined) connectionStatus.error = error;
+      return connectionStatus;
     } catch (caught) {
       const error = caught instanceof Error ? caught.message : String(caught);
       console.warn(
@@ -397,12 +418,15 @@ export class Migrator {
     const conns = connections.map((connection, index) => {
       const status = connectionStatuses[index];
       assert(status !== undefined);
-      const configured = Sonamu.dbConfig[connection.connKey].connection as Knex.PgConnectionConfig;
+      const configured =
+        /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ Sonamu.dbConfig[
+          connection.connKey
+        ].connection as Knex.PgConnectionConfig;
       return {
         name: connection.name,
         connKey: connection.connKey,
         connString:
-          `pg://${configured.user ?? ""}@${configured.host}:${configured.port}/${configured.database}` as ConnString,
+          /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ `pg://${configured.user ?? ""}@${configured.host}:${configured.port}/${configured.database}` as ConnString,
         currentVersion: status.currentVersion,
         status: status.status,
         pending: status.pending,
@@ -484,10 +508,12 @@ export class Migrator {
           options: Sonamu.dbConfig[target],
         }))
         .filter((c) => c.options !== undefined),
-      ({ options }) =>
-        `${(options.connection as Knex.PgConnectionConfig).host}:${
-          (options.connection as Knex.PgConnectionConfig).port ?? 5432
-        }/${(options.connection as Knex.PgConnectionConfig).database}`,
+      ({ options: dbOptions }) =>
+        `${/* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ (dbOptions.connection as Knex.PgConnectionConfig).host}:${
+          /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ (
+            dbOptions.connection as Knex.PgConnectionConfig
+          ).port ?? 5432
+        }/${/* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ (dbOptions.connection as Knex.PgConnectionConfig).database}`,
     );
 
     // get connections
@@ -515,14 +541,13 @@ export class Migrator {
 
   private genDateTag(index: number, baseDate: Date = new Date()): string {
     const date = new Date(baseDate.getTime() + index * 1000);
-    const pad = (num: number, size: number = 2) => num.toString().padStart(size, "0");
     return (
       date.getFullYear().toString() +
-      pad(date.getMonth() + 1) +
-      pad(date.getDate()) +
-      pad(date.getHours()) +
-      pad(date.getMinutes()) +
-      pad(date.getSeconds())
+      padDatePart(date.getMonth() + 1) +
+      padDatePart(date.getDate()) +
+      padDatePart(date.getHours()) +
+      padDatePart(date.getMinutes()) +
+      padDatePart(date.getSeconds())
     );
   }
 
@@ -635,7 +660,9 @@ export class Migrator {
    * @category 분리형 마이그레이션 API
    */
   async runShadowTest(options?: MigrationRunOptions): Promise<MigrationResult> {
-    const baseTestConn = Sonamu.dbConfig.test.connection as Knex.PgConnectionConfig;
+    const baseTestConn =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ Sonamu.dbConfig
+        .test.connection as Knex.PgConnectionConfig;
     const workerId = process.env.SONAMU_WORKER_DB === "true" ? process.env.VITEST_POOL_ID : null;
     const templateDatabase =
       workerId !== null ? `${baseTestConn.database}_${workerId ?? "1"}` : baseTestConn.database;

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

@@ -164,7 +164,8 @@ class PostgreSQLSchemaReaderClass {
     );
 
     // indexes 처리
-    const indexes: MigrationIndex[] = Object.keys(dbIndexesGroup).map((indexName) => {
+    const indexes: MigrationIndex[] = [];
+    for (const indexName of Object.keys(dbIndexesGroup)) {
       const currentIndexes = dbIndexesGroup[indexName]?.toSorted(
         (left, right) => left.column_order - right.column_order,
       );
@@ -180,34 +181,42 @@ class PostgreSQLSchemaReaderClass {
         parsedIndexDefinition.accessMethod ?? firstIndex.index_type,
       );
 
-      return {
+      const indexColumns: MigrationIndex["columns"] = [];
+      for (const currentIndex of currentIndexes) {
+        const opclass = this.extractIndexColumnOpclass(
+          parsedIndexDefinition.columnDefinitions[currentIndex.column_order - 1],
+        );
+        const column: MigrationIndex["columns"][number] = {
+          name: currentIndex.column_name,
+        };
+        if (opclass) {
+          Object.assign(column, { opclass });
+        }
+        switch (using) {
+          case "btree":
+            Object.assign(column, {
+              sortOrder: currentIndex.sort_order,
+              nullsFirst: currentIndex.nulls_first,
+            });
+            break;
+        }
+        indexColumns.push(column);
+      }
+      const index: MigrationIndex = {
         type: restoredIndexType,
         name: indexName,
-        columns: currentIndexes.map((idx) => ({
-          name: idx.column_name,
-          ...(this.extractIndexColumnOpclass(
-            parsedIndexDefinition.columnDefinitions[idx.column_order - 1],
-          )
-            ? {
-                opclass: this.extractIndexColumnOpclass(
-                  parsedIndexDefinition.columnDefinitions[idx.column_order - 1],
-                ),
-              }
-            : {}),
-          ...(using === "btree"
-            ? {
-                sortOrder: idx.sort_order,
-                nullsFirst: idx.nulls_first,
-              }
-            : {}),
-        })),
-
+        columns: indexColumns,
         nullsNotDistinct: firstIndex.nulls_not_distinct,
-        ...(firstIndex.predicate ? { where: firstIndex.predicate } : {}),
-        ...(using ? { using } : {}),
         ...this.parseVectorIndexOptions(restoredIndexType, parsedIndexDefinition.withOptions),
       };
-    });
+      if (firstIndex.predicate) {
+        index.where = firstIndex.predicate;
+      }
+      if (using) {
+        index.using = using;
+      }
+      indexes.push(index);
+    }
 
     // foreigns 처리
     const foreigns: MigrationForeign[] = dbForeigns.map((dbForeign) => {
@@ -231,14 +240,14 @@ class PostgreSQLSchemaReaderClass {
    * PostgreSQL의 constraint action을 Knex 형식으로 변환
    */
   private mapConstraintAction(action: string): RelationOn {
-    const actionMap: Record<string, RelationOn> = {
-      "NO ACTION": "NO ACTION",
-      RESTRICT: "RESTRICT",
-      CASCADE: "CASCADE",
-      "SET NULL": "SET NULL",
-      "SET DEFAULT": "SET DEFAULT",
-    };
-    return actionMap[action] ?? "NO ACTION";
+    const actionMap = new Map<string, RelationOn>([
+      ["NO ACTION", "NO ACTION"],
+      ["RESTRICT", "RESTRICT"],
+      ["CASCADE", "CASCADE"],
+      ["SET NULL", "SET NULL"],
+      ["SET DEFAULT", "SET DEFAULT"],
+    ]);
+    return actionMap.get(action) ?? "NO ACTION";
   }
 
   /**
@@ -277,7 +286,9 @@ class PostgreSQLSchemaReaderClass {
         AND c.table_schema = 'public'
       ORDER BY c.ordinal_position
     `;
-    const columns = (await compareDB.raw(columnsQuery, [tableName])).rows as PgColumn[];
+    const columns = /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ (
+      await compareDB.raw(columnsQuery, [tableName])
+    ).rows as PgColumn[];
     if (columns.length === 0) {
       throw new Error(`Table not found: ${tableName}`);
     }
@@ -398,7 +409,7 @@ class PostgreSQLSchemaReaderClass {
       return undefined;
     }
 
-    return normalized as MigrationIndex["using"];
+    return /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ normalized as MigrationIndex["using"];
   }
 
   private parseVectorIndexOptions(
@@ -406,14 +417,12 @@ class PostgreSQLSchemaReaderClass {
     withOptions: Record<string, string>,
   ): Pick<MigrationIndex, "m" | "efConstruction" | "lists"> {
     if (type === "hnsw") {
-      return {
-        ...(this.parseIntegerOption(withOptions.m) !== undefined
-          ? { m: this.parseIntegerOption(withOptions.m) }
-          : {}),
-        ...(this.parseIntegerOption(withOptions.ef_construction) !== undefined
-          ? { efConstruction: this.parseIntegerOption(withOptions.ef_construction) }
-          : {}),
-      };
+      const options: Pick<MigrationIndex, "m" | "efConstruction"> = {};
+      const m = this.parseIntegerOption(withOptions.m);
+      const efConstruction = this.parseIntegerOption(withOptions.ef_construction);
+      if (m !== undefined) options.m = m;
+      if (efConstruction !== undefined) options.efConstruction = efConstruction;
+      return options;
     }
 
     if (type === "ivfflat") {
@@ -456,11 +465,7 @@ class PostgreSQLSchemaReaderClass {
     return tokens.at(-1);
   }
 
-  private parseIndexDefinition(indexDefinition: string): {
-    accessMethod?: string;
-    columnDefinitions: string[];
-    withOptions: Record<string, string>;
-  } {
+  private parseIndexDefinition(indexDefinition: string) {
     const accessMethod = indexDefinition.match(/\bUSING\s+([a-z_][\w]*)/i)?.[1]?.toLowerCase();
     const usingMatchIndex = indexDefinition.search(/\bUSING\b/i);
     const columnsStart = usingMatchIndex >= 0 ? indexDefinition.indexOf("(", usingMatchIndex) : -1;

package/src/migration/slack-confirm.ts

@@ -138,12 +138,13 @@ export class SlackConfirm {
       throw new Error(`Slack API HTTP error: ${response.status}`);
     }
 
-    const data = (await response.json()) as {
-      ok: boolean;
-      error?: string;
-      channel: string;
-      ts: string;
-    };
+    const data =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ (await response.json()) as {
+        ok: boolean;
+        error?: string;
+        channel: string;
+        ts: string;
+      };
     if (!data.ok) {
       throw new Error(`Slack API error: ${data.error}`);
     }
@@ -202,16 +203,17 @@ ${migrationsText}`;
       throw new Error(`Slack API HTTP error: ${response.status}`);
     }
 
-    const data = (await response.json()) as {
-      ok: boolean;
-      error?: string;
-      message?: {
-        reactions?: Array<{
-          name: string;
-          users?: string[];
-        }>;
+    const data =
+      /* SAFETY: Knex와 PostgreSQL 스키마 조회 계약이 이 값의 타입을 보장한다. */ (await response.json()) as {
+        ok: boolean;
+        error?: string;
+        message?: {
+          reactions?: Array<{
+            name: string;
+            users?: string[];
+          }>;
+        };
       };
-    };
     if (!data.ok) {
       throw new Error(`Slack API error: ${data.error}`);
     }

package/src/naite/naite-reporter.ts

@@ -103,7 +103,7 @@ class NaiteReporterClass {
   private async send(data: NaiteMessagingTypes.NaiteMessage): Promise<void> {
     const msg = `${JSON.stringify(data)}\n`;
 
-    await this.ensureConnection().catch((_) => {});
+    await this.ensureConnection().catch(() => {});
 
     if (this.connected && this.socket) {
       this.socket.write(msg);