sonamu 0.8.13 → 0.8.14

package/dist/migration/postgresql-schema-reader.js

@@ -1,6 +1,13 @@
 import assert from "assert";
 import { group } from "radashi";
 class PostgreSQLSchemaReaderClass {
+    genericIndexTypes = new Set([
+        "btree",
+        "hash",
+        "gin",
+        "gist",
+        "pgroonga"
+    ]);
     /**
    * DB에서 테이블 정보를 읽어서 MigrationSet을 만들어옵니다.
    * @param compareDB Knex 인스턴스
@@ -72,22 +79,30 @@ class PostgreSQLSchemaReaderClass {
         const dbIndexesGroup = group(dbIndexes.filter((dbIndex)=>!dbIndex.is_primary && !dbForeigns.find((dbForeign)=>dbIndex.index_name.includes(dbForeign.constraint_name))), (dbIndex)=>dbIndex.index_name);
         // indexes 처리
         const indexes = Object.keys(dbIndexesGroup).map((indexName)=>{
-            const currentIndexes = dbIndexesGroup[indexName];
+            const currentIndexes = dbIndexesGroup[indexName]?.toSorted((left, right)=>left.column_order - right.column_order);
             assert(currentIndexes);
             const firstIndex = currentIndexes[0];
-            const type = firstIndex.is_unique ? "unique" : "index";
+            const parsedIndexDefinition = this.parseIndexDefinition(firstIndex.index_definition);
+            const restoredIndexType = this.restoreMigrationIndexType(firstIndex, parsedIndexDefinition.accessMethod);
+            const using = this.restoreGenericUsing(parsedIndexDefinition.accessMethod ?? firstIndex.index_type);
             return {
-                type,
+                type: restoredIndexType,
                 name: indexName,
                 columns: currentIndexes.map((idx)=>({
                         name: idx.column_name,
-                        ...firstIndex.index_type === "btree" ? {
+                        ...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
                         } : {}
                     })),
                 nullsNotDistinct: firstIndex.nulls_not_distinct,
-                using: firstIndex.index_type
+                ...using ? {
+                    using
+                } : {},
+                ...this.parseVectorIndexOptions(restoredIndexType, parsedIndexDefinition.withOptions)
             };
         });
         // foreigns 처리
@@ -185,7 +200,9 @@ class PostgreSQLSchemaReaderClass {
               WHEN (u.opt & 1) = 1 THEN 'DESC'
               ELSE 'ASC'
           END AS sort_order,
-          ix.indnullsnotdistinct AS nulls_not_distinct
+          ix.indnullsnotdistinct AS nulls_not_distinct,
+          u.ord AS column_order,
+          pg_get_indexdef(ix.indexrelid) AS index_definition
       FROM pg_class t
       JOIN pg_index ix ON t.oid = ix.indrelid
       JOIN pg_class i ON i.oid = ix.indexrelid
@@ -251,6 +268,263 @@ class PostgreSQLSchemaReaderClass {
             foreigns
         ];
     }
+    restoreMigrationIndexType(index, accessMethod) {
+        const resolvedAccessMethod = (accessMethod ?? index.index_type).toLowerCase();
+        if (resolvedAccessMethod === "hnsw" || resolvedAccessMethod === "ivfflat") {
+            return resolvedAccessMethod;
+        }
+        return index.is_unique ? "unique" : "index";
+    }
+    restoreGenericUsing(accessMethod) {
+        if (!accessMethod) {
+            return undefined;
+        }
+        const normalized = accessMethod.toLowerCase();
+        if (!this.genericIndexTypes.has(normalized)) {
+            return undefined;
+        }
+        return normalized;
+    }
+    parseVectorIndexOptions(type, withOptions) {
+        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)
+                } : {}
+            };
+        }
+        if (type === "ivfflat") {
+            return {
+                ...this.parseIntegerOption(withOptions.lists) !== undefined ? {
+                    lists: this.parseIntegerOption(withOptions.lists)
+                } : {}
+            };
+        }
+        return {};
+    }
+    parseIntegerOption(value) {
+        if (!value) {
+            return undefined;
+        }
+        const parsed = Number.parseInt(value, 10);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    extractIndexColumnOpclass(columnDefinition) {
+        if (!columnDefinition) {
+            return undefined;
+        }
+        const trimmed = columnDefinition.replace(/\s+NULLS\s+(FIRST|LAST)\s*$/i, "").replace(/\s+(ASC|DESC)\s*$/i, "").trim();
+        const tokens = this.tokenizeTopLevel(trimmed);
+        if (tokens.length < 2) {
+            return undefined;
+        }
+        if (tokens[tokens.length - 2]?.toUpperCase() === "COLLATE") {
+            return undefined;
+        }
+        return tokens.at(-1);
+    }
+    parseIndexDefinition(indexDefinition) {
+        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;
+        const columnsEnd = columnsStart >= 0 ? this.findMatchingParenthesis(indexDefinition, columnsStart) : -1;
+        const columnDefinitions = columnsStart >= 0 && columnsEnd > columnsStart ? this.splitTopLevel(indexDefinition.slice(columnsStart + 1, columnsEnd), ",") : [];
+        const withMatch = /\bWITH\s*\(/i.exec(indexDefinition);
+        const withStart = withMatch ? indexDefinition.indexOf("(", withMatch.index) : -1;
+        const withEnd = withStart >= 0 ? this.findMatchingParenthesis(indexDefinition, withStart) : -1;
+        const withOptions = withStart >= 0 && withEnd > withStart ? this.parseIndexOptionEntries(indexDefinition.slice(withStart + 1, withEnd)) : {};
+        return {
+            accessMethod,
+            columnDefinitions,
+            withOptions
+        };
+    }
+    parseIndexOptionEntries(optionSource) {
+        return this.splitTopLevel(optionSource, ",").reduce((result, entry)=>{
+            const matched = entry.trim().match(/^([a-z_][\w]*)\s*=\s*(.+)$/i);
+            if (!matched) {
+                return result;
+            }
+            const [, key, rawValue] = matched;
+            result[key.toLowerCase()] = rawValue.trim().replace(/^['"]|['"]$/g, "");
+            return result;
+        }, {});
+    }
+    splitTopLevel(source, delimiter) {
+        const items = [];
+        let start = 0;
+        let parenDepth = 0;
+        let bracketDepth = 0;
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        for(let index = 0; 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 === "(") {
+                parenDepth += 1;
+                continue;
+            }
+            if (char === ")") {
+                parenDepth -= 1;
+                continue;
+            }
+            if (char === "[") {
+                bracketDepth += 1;
+                continue;
+            }
+            if (char === "]") {
+                bracketDepth -= 1;
+                continue;
+            }
+            if (char === delimiter && parenDepth === 0 && bracketDepth === 0) {
+                items.push(source.slice(start, index).trim());
+                start = index + 1;
+            }
+        }
+        const tail = source.slice(start).trim();
+        if (tail.length > 0) {
+            items.push(tail);
+        }
+        return items;
+    }
+    tokenizeTopLevel(source) {
+        const tokens = [];
+        let start = -1;
+        let parenDepth = 0;
+        let bracketDepth = 0;
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        const pushToken = (endIndex)=>{
+            if (start < 0) {
+                return;
+            }
+            const token = source.slice(start, endIndex).trim();
+            if (token.length > 0) {
+                tokens.push(token);
+            }
+            start = -1;
+        };
+        for(let index = 0; index < source.length; index += 1){
+            const char = source[index];
+            const nextChar = source[index + 1];
+            if (char === "'" && !inDoubleQuote) {
+                if (start < 0) {
+                    start = index;
+                }
+                if (inSingleQuote && nextChar === "'") {
+                    index += 1;
+                    continue;
+                }
+                inSingleQuote = !inSingleQuote;
+                continue;
+            }
+            if (char === '"' && !inSingleQuote) {
+                if (start < 0) {
+                    start = index;
+                }
+                if (inDoubleQuote && nextChar === '"') {
+                    index += 1;
+                    continue;
+                }
+                inDoubleQuote = !inDoubleQuote;
+                continue;
+            }
+            if (!inSingleQuote && !inDoubleQuote) {
+                if (char === "(") {
+                    if (start < 0) {
+                        start = index;
+                    }
+                    parenDepth += 1;
+                    continue;
+                }
+                if (char === ")") {
+                    parenDepth -= 1;
+                    continue;
+                }
+                if (char === "[") {
+                    if (start < 0) {
+                        start = index;
+                    }
+                    bracketDepth += 1;
+                    continue;
+                }
+                if (char === "]") {
+                    bracketDepth -= 1;
+                    continue;
+                }
+                if (/\s/.test(char) && parenDepth === 0 && bracketDepth === 0) {
+                    pushToken(index);
+                    continue;
+                }
+            }
+            if (start < 0) {
+                start = index;
+            }
+        }
+        pushToken(source.length);
+        return tokens;
+    }
+    findMatchingParenthesis(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;
+    }
     /**
    * 특정 테이블의 PK를 참조하는 다른 테이블의 FK 목록을 조회합니다.
    * PK 타입 변경 시 관련 FK 제약조건을 삭제/복구하기 위해 사용됩니다.
@@ -427,4 +701,4 @@ class PostgreSQLSchemaReaderClass {
 }
 export const PostgreSQLSchemaReader = new PostgreSQLSchemaReaderClass();
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/migration/postgresql-schema-reader.ts"],"sourcesContent":["import assert from \"assert\";\nimport type { Knex } from \"knex\";\nimport { group } from \"radashi\";\nimport type {\n  MigrationColumn,\n  MigrationForeign,\n  MigrationIndex,\n  MigrationSet,\n  RelationOn,\n} from \"../types/types\";\n\n/**\n * 특정 테이블의 PK를 참조하는 다른 테이블의 FK 정보입니다.\n * PK 타입 변경 시 관련 FK 제약조건을 처리하기 위해 사용됩니다.\n */\nexport type ReferencingForeignKey = {\n  /** FK가 정의된 테이블명 */\n  tableName: string;\n  /** FK 제약조건 이름 */\n  constraintName: string;\n  /** FK 컬럼명 */\n  columnName: string;\n  /** 참조하는 테이블명 (PK가 있는 테이블) */\n  referencedTableName: string;\n  /** 참조하는 컬럼명 (보통 'id') */\n  referencedColumnName: string;\n  /** ON UPDATE 액션 */\n  onUpdate: RelationOn;\n  /** ON DELETE 액션 */\n  onDelete: RelationOn;\n};\n\nexport type PgColumn = {\n  column_name: string;\n  data_type: string;\n  udt_name: string;\n  character_maximum_length: number | null;\n  precision: number | null;\n  numeric_scale: number | null;\n  is_nullable: string;\n  column_default: string | null;\n  is_generated: string; // 's' = STORED, 'v' = VIRTUAL, '' = none\n  generation_expression: string | null;\n};\n\ntype PgIndex = {\n  index_name: string;\n  column_name: string;\n  is_unique: boolean;\n  is_primary: boolean;\n  index_type: string;\n  nulls_first: boolean;\n  sort_order: \"ASC\" | \"DESC\";\n  nulls_not_distinct: boolean;\n};\n\ntype PgForeign = {\n  constraint_name: string;\n  column_name: string;\n  foreign_table_name: string;\n  foreign_column_name: string;\n  update_rule: string;\n  delete_rule: string;\n};\n\nclass PostgreSQLSchemaReaderClass {\n  /**\n   * DB에서 테이블 정보를 읽어서 MigrationSet을 만들어옵니다.\n   * @param compareDB Knex 인스턴스\n   * @param table 테이블 이름\n   * @returns MigrationSet 객체\n   */\n  async getMigrationSetFromDB(compareDB: Knex, table: string): Promise<MigrationSet | null> {\n    let dbColumns: PgColumn[], dbIndexes: PgIndex[], dbForeigns: PgForeign[];\n    try {\n      [dbColumns, dbIndexes, dbForeigns] = await this.readTable(compareDB, table);\n    } catch (e: unknown) {\n      if (e instanceof Error && e.message.includes(\"Table not found\")) {\n        return null;\n      }\n      console.error(e);\n      return null;\n    }\n\n    // vector 컬럼의 dimensions 조회\n    const vectorDimensions = await this.getVectorDimensions(compareDB, table);\n\n    const columns: MigrationColumn[] = dbColumns.map((dbColumn) => {\n      const dbColType = this.resolveDBColType(dbColumn);\n\n      // vector 타입인 경우 dimensions 설정\n      if (dbColType.type === \"vector\") {\n        dbColType.dimensions = vectorDimensions[dbColumn.column_name] ?? 0;\n      }\n\n      return {\n        name: dbColumn.column_name,\n        nullable: dbColumn.is_nullable === \"YES\",\n        ...dbColType,\n        // Generated Column 처리\n        ...(() => {\n          if (dbColumn.is_generated === \"s\" || dbColumn.is_generated === \"v\") {\n            return {\n              generated: {\n                type: dbColumn.is_generated === \"s\" ? \"STORED\" : \"VIRTUAL\",\n                expression: dbColumn.generation_expression ?? \"\",\n              },\n            };\n          }\n          return {};\n        })(),\n        // Default 값 처리 (Generated Column이 아닌 경우만)\n        ...(() => {\n          // Generated Column은 default 값이 없음\n          if (dbColumn.is_generated === \"s\" || dbColumn.is_generated === \"v\") {\n            return {};\n          }\n\n          if (dbColumn.column_default !== null) {\n            // PostgreSQL default 값 정리 (nextval, CURRENT_TIMESTAMP 등)\n            let defaultValue = dbColumn.column_default;\n\n            // nextval 제거 (SERIAL 타입)\n            if (defaultValue.startsWith(\"nextval(\")) {\n              return {};\n            }\n\n            // 타입 캐스팅 제거 (예: '1'::integer → 1)\n            defaultValue = defaultValue.replace(/::[\\w\\s]+$/g, \"\");\n\n            // 따옴표가 single quote인 경우 double quote로 변환\n            if (defaultValue.startsWith(\"'\") && defaultValue.endsWith(\"'\")) {\n              defaultValue = defaultValue.replaceAll(\"'\", '\"');\n            }\n\n            return {\n              defaultTo: defaultValue,\n            };\n          }\n          return {};\n        })(),\n      };\n    });\n\n    // PRIMARY KEY와 foreign key용 인덱스 제외\n    const dbIndexesGroup = group(\n      dbIndexes.filter(\n        (dbIndex) =>\n          !dbIndex.is_primary &&\n          !dbForeigns.find((dbForeign) => dbIndex.index_name.includes(dbForeign.constraint_name)),\n      ),\n      (dbIndex) => dbIndex.index_name,\n    );\n\n    // indexes 처리\n    const indexes: MigrationIndex[] = Object.keys(dbIndexesGroup).map((indexName) => {\n      const currentIndexes = dbIndexesGroup[indexName];\n      assert(currentIndexes);\n\n      const firstIndex = currentIndexes[0];\n      const type = firstIndex.is_unique ? \"unique\" : \"index\";\n\n      return {\n        type,\n        name: indexName,\n        columns: currentIndexes.map((idx) => ({\n          name: idx.column_name,\n          ...(firstIndex.index_type === \"btree\"\n            ? {\n                sortOrder: idx.sort_order,\n                nullsFirst: idx.nulls_first,\n              }\n            : {}),\n        })),\n\n        nullsNotDistinct: firstIndex.nulls_not_distinct,\n        using: firstIndex.index_type as \"btree\" | \"hash\" | \"gin\" | \"gist\" | \"pgroonga\" | undefined,\n      };\n    });\n\n    // foreigns 처리\n    const foreigns: MigrationForeign[] = dbForeigns.map((dbForeign) => {\n      return {\n        columns: [dbForeign.column_name],\n        to: `${dbForeign.foreign_table_name}.${dbForeign.foreign_column_name}`,\n        onUpdate: this.mapConstraintAction(dbForeign.update_rule),\n        onDelete: this.mapConstraintAction(dbForeign.delete_rule),\n      };\n    });\n\n    return {\n      table,\n      columns,\n      indexes,\n      foreigns,\n    };\n  }\n\n  /**\n   * PostgreSQL의 constraint action을 Knex 형식으로 변환\n   */\n  private mapConstraintAction(action: string): RelationOn {\n    const actionMap: Record<string, RelationOn> = {\n      \"NO ACTION\": \"NO ACTION\",\n      RESTRICT: \"RESTRICT\",\n      CASCADE: \"CASCADE\",\n      \"SET NULL\": \"SET NULL\",\n      \"SET DEFAULT\": \"SET DEFAULT\",\n    };\n    return actionMap[action] ?? \"NO ACTION\";\n  }\n\n  /**\n   * 기존 테이블 읽어서 cols, indexes, foreigns 반환\n   */\n  async readTable(\n    compareDB: Knex,\n    tableName: string,\n  ): Promise<[PgColumn[], PgIndex[], PgForeign[]]> {\n    // Columns 조회 (Generated Column 정보 포함)\n    const columnsQuery = `\n      SELECT\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        COALESCE(\n          c.character_maximum_length,\n          CASE WHEN c.data_type = 'ARRAY' AND a.atttypmod > 0\n            THEN a.atttypmod - 4\n            ELSE NULL\n          END\n        ) AS character_maximum_length,\n        COALESCE(c.datetime_precision, c.numeric_precision) AS precision,\n        c.numeric_scale,\n        c.is_nullable,\n        c.column_default,\n        COALESCE(a.attgenerated, '') as is_generated,\n        c.generation_expression\n      FROM information_schema.columns c\n      LEFT JOIN pg_attribute a ON a.attname = c.column_name\n        AND a.attrelid = (\n          SELECT oid FROM pg_class WHERE relname = c.table_name\n          AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)\n        )\n      WHERE c.table_name = ?\n        AND c.table_schema = 'public'\n      ORDER BY c.ordinal_position\n    `;\n    const columns = (await compareDB.raw(columnsQuery, [tableName])).rows as PgColumn[];\n    if (columns.length === 0) {\n      throw new Error(`Table not found: ${tableName}`);\n    }\n\n    // Indexes 조회 (PGroonga 표현식 인덱스 포함)\n    const indexesQuery = `\n      SELECT\n          i.relname AS index_name,\n          CASE\n              WHEN am.amname = 'pgroonga' AND u.attnum = 0 THEN\n                  regexp_replace(\n                      regexp_replace(\n                          TRIM(pgroonga_col.column_expr),\n                          '::text',\n                          '',\n                          'g'\n                      ),\n                      '[()]',\n                      '',\n                      'g'\n                  )\n              ELSE a.attname\n          END AS column_name,\n          ix.indisunique AS is_unique,\n          ix.indisprimary AS is_primary,\n          am.amname AS index_type,\n          COALESCE((u.opt & 2) = 2, FALSE) AS nulls_first,\n          CASE \n              WHEN (u.opt & 1) = 1 THEN 'DESC'\n              ELSE 'ASC'\n          END AS sort_order,\n          ix.indnullsnotdistinct AS nulls_not_distinct\n      FROM pg_class t\n      JOIN pg_index ix ON t.oid = ix.indrelid\n      JOIN pg_class i ON i.oid = ix.indexrelid\n      JOIN pg_am am ON i.relam = am.oid\n      JOIN LATERAL unnest(ix.indkey, ix.indoption)\n          WITH ORDINALITY AS u(attnum, opt, ord) ON true\n      LEFT JOIN pg_attribute a ON a.attrelid = t.oid \n          AND a.attnum = u.attnum \n          AND u.attnum > 0\n      LEFT JOIN LATERAL (\n          SELECT \n              unnest(\n                  CASE \n                      WHEN pg_get_expr(ix.indexprs, ix.indrelid) ~ '^ARRAY\\\\[' THEN\n                          string_to_array(\n                              regexp_replace(\n                                  pg_get_expr(ix.indexprs, ix.indrelid),\n                                  '^ARRAY\\\\[(.*)\\\\]$',\n                                  '\\\\1'\n                              ),\n                              ', '\n                          )\n                      ELSE\n                          ARRAY[pg_get_expr(ix.indexprs, ix.indrelid)]\n                  END\n              ) as column_expr\n      ) pgroonga_col ON am.amname = 'pgroonga' AND u.attnum = 0\n      WHERE t.relname = ?\n          AND (u.attnum > 0 OR (am.amname = 'pgroonga' AND u.attnum = 0))\n      ORDER BY i.relname, u.ord;\n`;\n    const indexes = (await compareDB.raw(indexesQuery, [tableName])).rows;\n\n    // Foreign Keys 조회\n    const foreignsQuery = `\n      SELECT\n        tc.constraint_name,\n        kcu.column_name,\n        ccu.table_name AS foreign_table_name,\n        ccu.column_name AS foreign_column_name,\n        rc.update_rule,\n        rc.delete_rule\n      FROM information_schema.table_constraints AS tc\n      JOIN information_schema.key_column_usage AS kcu\n        ON tc.constraint_name = kcu.constraint_name\n        AND tc.table_schema = kcu.table_schema\n      JOIN information_schema.constraint_column_usage AS ccu\n        ON ccu.constraint_name = tc.constraint_name\n        AND ccu.table_schema = tc.table_schema\n      JOIN information_schema.referential_constraints AS rc\n        ON rc.constraint_name = tc.constraint_name\n        AND rc.constraint_schema = tc.table_schema\n      WHERE tc.constraint_type = 'FOREIGN KEY'\n        AND tc.table_name = ?\n    `;\n    const foreigns = (await compareDB.raw(foreignsQuery, [tableName])).rows;\n\n    return [columns, indexes, foreigns];\n  }\n\n  /**\n   * 특정 테이블의 PK를 참조하는 다른 테이블의 FK 목록을 조회합니다.\n   * PK 타입 변경 시 관련 FK 제약조건을 삭제/복구하기 위해 사용됩니다.\n   */\n  async getReferencingForeignKeys(db: Knex, tableName: string): Promise<ReferencingForeignKey[]> {\n    const query = `\n      SELECT\n        tc.table_name,\n        tc.constraint_name,\n        kcu.column_name,\n        ccu.table_name AS referenced_table_name,\n        ccu.column_name AS referenced_column_name,\n        rc.update_rule,\n        rc.delete_rule\n      FROM information_schema.table_constraints AS tc\n      JOIN information_schema.key_column_usage AS kcu\n        ON tc.constraint_name = kcu.constraint_name\n        AND tc.table_schema = kcu.table_schema\n      JOIN information_schema.constraint_column_usage AS ccu\n        ON ccu.constraint_name = tc.constraint_name\n        AND ccu.table_schema = tc.table_schema\n      JOIN information_schema.referential_constraints AS rc\n        ON rc.constraint_name = tc.constraint_name\n        AND rc.constraint_schema = tc.table_schema\n      WHERE tc.constraint_type = 'FOREIGN KEY'\n        AND ccu.table_name = ?\n        AND tc.table_schema = 'public'\n    `;\n\n    const result = await db.raw(query, [tableName]);\n    return result.rows.map(\n      (row: {\n        table_name: string;\n        constraint_name: string;\n        column_name: string;\n        referenced_table_name: string;\n        referenced_column_name: string;\n        update_rule: string;\n        delete_rule: string;\n      }) => ({\n        tableName: row.table_name,\n        constraintName: row.constraint_name,\n        columnName: row.column_name,\n        referencedTableName: row.referenced_table_name,\n        referencedColumnName: row.referenced_column_name,\n        onUpdate: this.mapConstraintAction(row.update_rule),\n        onDelete: this.mapConstraintAction(row.delete_rule),\n      }),\n    );\n  }\n\n  /**\n   * vector 컬럼의 dimensions를 조회합니다.\n   * pg_attribute의 atttypmod에서 차원 수를 추출합니다.\n   */\n  private async getVectorDimensions(\n    compareDB: Knex,\n    tableName: string,\n  ): Promise<Record<string, number>> {\n    const query = `\n      SELECT\n        a.attname as column_name,\n        a.atttypmod as dimensions\n      FROM pg_attribute a\n      JOIN pg_class c ON a.attrelid = c.oid\n      JOIN pg_type t ON a.atttypid = t.oid\n      WHERE c.relname = ?\n        AND t.typname = 'vector'\n        AND a.attnum > 0\n    `;\n    const result = await compareDB.raw(query, [tableName]);\n    const dimensions: Record<string, number> = {};\n    for (const row of result.rows) {\n      // atttypmod에서 실제 dimensions 값 추출\n      dimensions[row.column_name] = row.dimensions > 0 ? row.dimensions : 0;\n    }\n    return dimensions;\n  }\n\n  /**\n   * PostgreSQL 컬럼 타입을 분석하여 MigrationColumn 객체로 변환합니다.\n   */\n  resolveDBColType(\n    dbColumn: PgColumn,\n  ): Pick<\n    MigrationColumn,\n    \"type\" | \"length\" | \"precision\" | \"scale\" | \"numberType\" | \"dimensions\"\n  > {\n    const { udt_name: _udt_name, character_maximum_length, precision, numeric_scale } = dbColumn;\n\n    const { udt_name, singleOrArray } = (() => {\n      if (_udt_name.startsWith(\"_\")) {\n        return {\n          udt_name: _udt_name.substring(1),\n          singleOrArray: \"[]\" as const,\n        };\n      }\n      return {\n        udt_name: _udt_name,\n        singleOrArray: \"\" as const,\n      };\n    })();\n\n    // UUID\n    if (udt_name === \"uuid\") {\n      return { type: `uuid${singleOrArray}` };\n    }\n\n    // Integer types\n    if (udt_name === \"int4\") {\n      return { type: `integer${singleOrArray}` };\n    }\n    if (udt_name === \"int8\") {\n      return { type: `bigInteger${singleOrArray}` };\n    }\n\n    // String types\n    if (udt_name === \"varchar\") {\n      return {\n        type: `string${singleOrArray}`,\n        ...(character_maximum_length && {\n          length: character_maximum_length,\n        }),\n      };\n    }\n    if (udt_name === \"text\") {\n      return { type: `string${singleOrArray}` }; // StringProp without length\n    }\n\n    // NumberOrNumeric types\n    if (udt_name === \"numeric\") {\n      return {\n        type: `numberOrNumeric${singleOrArray}`,\n        numberType: \"numeric\",\n        ...(precision !== null &&\n          numeric_scale !== null && {\n            precision: precision,\n            scale: numeric_scale,\n          }),\n      };\n    }\n    if (udt_name === \"float4\") {\n      return { type: `numberOrNumeric${singleOrArray}`, numberType: \"real\" };\n    }\n    if (udt_name === \"float8\") {\n      return { type: `numberOrNumeric${singleOrArray}`, numberType: \"double precision\" };\n    }\n\n    // Boolean\n    if (udt_name === \"bool\") {\n      return { type: `boolean${singleOrArray}` };\n    }\n\n    // Timestampz types\n    if (udt_name === \"timestamptz\") {\n      return {\n        type: `date${singleOrArray}`,\n        ...(precision !== null && {\n          precision: precision,\n        }),\n      }; // DateProp → timestamptz\n    }\n\n    // JSON\n    if (udt_name === \"json\" || udt_name === \"jsonb\") {\n      return { type: \"json\" };\n    }\n\n    // Vector (pgvector)\n    if (udt_name === \"vector\") {\n      // vector 타입의 차원 수는 column_default나 별도 쿼리로 확인해야 함\n      // 현재는 기본값 0으로 설정 (실제 dimensions는 getMigrationSetFromDB에서 별도 쿼리로 확인)\n      return { type: `vector${singleOrArray}`, dimensions: 0 };\n    }\n\n    // tsvector (PostgreSQL 전문 검색용 타입)\n    if (udt_name === \"tsvector\") {\n      return { type: \"tsvector\" };\n    }\n\n    throw new Error(`resolve 불가능한 PostgreSQL 컬럼 타입: ${udt_name}`);\n  }\n}\n\nexport const PostgreSQLSchemaReader = new PostgreSQLSchemaReaderClass();\n"],"names":["assert","group","PostgreSQLSchemaReaderClass","getMigrationSetFromDB","compareDB","table","dbColumns","dbIndexes","dbForeigns","readTable","e","Error","message","includes","console","error","vectorDimensions","getVectorDimensions","columns","map","dbColumn","dbColType","resolveDBColType","type","dimensions","column_name","name","nullable","is_nullable","is_generated","generated","expression","generation_expression","column_default","defaultValue","startsWith","replace","endsWith","replaceAll","defaultTo","dbIndexesGroup","filter","dbIndex","is_primary","find","dbForeign","index_name","constraint_name","indexes","Object","keys","indexName","currentIndexes","firstIndex","is_unique","idx","index_type","sortOrder","sort_order","nullsFirst","nulls_first","nullsNotDistinct","nulls_not_distinct","using","foreigns","to","foreign_table_name","foreign_column_name","onUpdate","mapConstraintAction","update_rule","onDelete","delete_rule","action","actionMap","RESTRICT","CASCADE","tableName","columnsQuery","raw","rows","length","indexesQuery","foreignsQuery","getReferencingForeignKeys","db","query","result","row","table_name","constraintName","columnName","referencedTableName","referenced_table_name","referencedColumnName","referenced_column_name","udt_name","_udt_name","character_maximum_length","precision","numeric_scale","singleOrArray","substring","numberType","scale","PostgreSQLSchemaReader"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/migration/postgresql-schema-reader.ts"],"sourcesContent":["import assert from \"assert\";\nimport type { Knex } from \"knex\";\nimport { group } from \"radashi\";\nimport type {\n  MigrationColumn,\n  MigrationForeign,\n  MigrationIndex,\n  MigrationSet,\n  RelationOn,\n} from \"../types/types\";\n\n/**\n * 특정 테이블의 PK를 참조하는 다른 테이블의 FK 정보입니다.\n * PK 타입 변경 시 관련 FK 제약조건을 처리하기 위해 사용됩니다.\n */\nexport type ReferencingForeignKey = {\n  /** FK가 정의된 테이블명 */\n  tableName: string;\n  /** FK 제약조건 이름 */\n  constraintName: string;\n  /** FK 컬럼명 */\n  columnName: string;\n  /** 참조하는 테이블명 (PK가 있는 테이블) */\n  referencedTableName: string;\n  /** 참조하는 컬럼명 (보통 'id') */\n  referencedColumnName: string;\n  /** ON UPDATE 액션 */\n  onUpdate: RelationOn;\n  /** ON DELETE 액션 */\n  onDelete: RelationOn;\n};\n\nexport type PgColumn = {\n  column_name: string;\n  data_type: string;\n  udt_name: string;\n  character_maximum_length: number | null;\n  precision: number | null;\n  numeric_scale: number | null;\n  is_nullable: string;\n  column_default: string | null;\n  is_generated: string; // 's' = STORED, 'v' = VIRTUAL, '' = none\n  generation_expression: string | null;\n};\n\ntype PgIndex = {\n  index_name: string;\n  column_name: string;\n  is_unique: boolean;\n  is_primary: boolean;\n  index_type: string;\n  nulls_first: boolean;\n  sort_order: \"ASC\" | \"DESC\";\n  nulls_not_distinct: boolean;\n  column_order: number;\n  index_definition: string;\n};\n\ntype PgForeign = {\n  constraint_name: string;\n  column_name: string;\n  foreign_table_name: string;\n  foreign_column_name: string;\n  update_rule: string;\n  delete_rule: string;\n};\n\ntype RawCapableKnex = Pick<Knex, \"raw\">;\n\nclass PostgreSQLSchemaReaderClass {\n  private readonly genericIndexTypes = new Set([\"btree\", \"hash\", \"gin\", \"gist\", \"pgroonga\"]);\n\n  /**\n   * DB에서 테이블 정보를 읽어서 MigrationSet을 만들어옵니다.\n   * @param compareDB Knex 인스턴스\n   * @param table 테이블 이름\n   * @returns MigrationSet 객체\n   */\n  async getMigrationSetFromDB(\n    compareDB: RawCapableKnex,\n    table: string,\n  ): Promise<MigrationSet | null> {\n    let dbColumns: PgColumn[], dbIndexes: PgIndex[], dbForeigns: PgForeign[];\n    try {\n      [dbColumns, dbIndexes, dbForeigns] = await this.readTable(compareDB, table);\n    } catch (e: unknown) {\n      if (e instanceof Error && e.message.includes(\"Table not found\")) {\n        return null;\n      }\n      console.error(e);\n      return null;\n    }\n\n    // vector 컬럼의 dimensions 조회\n    const vectorDimensions = await this.getVectorDimensions(compareDB, table);\n\n    const columns: MigrationColumn[] = dbColumns.map((dbColumn) => {\n      const dbColType = this.resolveDBColType(dbColumn);\n\n      // vector 타입인 경우 dimensions 설정\n      if (dbColType.type === \"vector\") {\n        dbColType.dimensions = vectorDimensions[dbColumn.column_name] ?? 0;\n      }\n\n      return {\n        name: dbColumn.column_name,\n        nullable: dbColumn.is_nullable === \"YES\",\n        ...dbColType,\n        // Generated Column 처리\n        ...(() => {\n          if (dbColumn.is_generated === \"s\" || dbColumn.is_generated === \"v\") {\n            return {\n              generated: {\n                type: dbColumn.is_generated === \"s\" ? \"STORED\" : \"VIRTUAL\",\n                expression: dbColumn.generation_expression ?? \"\",\n              },\n            };\n          }\n          return {};\n        })(),\n        // Default 값 처리 (Generated Column이 아닌 경우만)\n        ...(() => {\n          // Generated Column은 default 값이 없음\n          if (dbColumn.is_generated === \"s\" || dbColumn.is_generated === \"v\") {\n            return {};\n          }\n\n          if (dbColumn.column_default !== null) {\n            // PostgreSQL default 값 정리 (nextval, CURRENT_TIMESTAMP 등)\n            let defaultValue = dbColumn.column_default;\n\n            // nextval 제거 (SERIAL 타입)\n            if (defaultValue.startsWith(\"nextval(\")) {\n              return {};\n            }\n\n            // 타입 캐스팅 제거 (예: '1'::integer → 1)\n            defaultValue = defaultValue.replace(/::[\\w\\s]+$/g, \"\");\n\n            // 따옴표가 single quote인 경우 double quote로 변환\n            if (defaultValue.startsWith(\"'\") && defaultValue.endsWith(\"'\")) {\n              defaultValue = defaultValue.replaceAll(\"'\", '\"');\n            }\n\n            return {\n              defaultTo: defaultValue,\n            };\n          }\n          return {};\n        })(),\n      };\n    });\n\n    // PRIMARY KEY와 foreign key용 인덱스 제외\n    const dbIndexesGroup = group(\n      dbIndexes.filter(\n        (dbIndex) =>\n          !dbIndex.is_primary &&\n          !dbForeigns.find((dbForeign) => dbIndex.index_name.includes(dbForeign.constraint_name)),\n      ),\n      (dbIndex) => dbIndex.index_name,\n    );\n\n    // indexes 처리\n    const indexes: MigrationIndex[] = Object.keys(dbIndexesGroup).map((indexName) => {\n      const currentIndexes = dbIndexesGroup[indexName]?.toSorted(\n        (left, right) => left.column_order - right.column_order,\n      );\n      assert(currentIndexes);\n\n      const firstIndex = currentIndexes[0];\n      const parsedIndexDefinition = this.parseIndexDefinition(firstIndex.index_definition);\n      const restoredIndexType = this.restoreMigrationIndexType(\n        firstIndex,\n        parsedIndexDefinition.accessMethod,\n      );\n      const using = this.restoreGenericUsing(\n        parsedIndexDefinition.accessMethod ?? firstIndex.index_type,\n      );\n\n      return {\n        type: restoredIndexType,\n        name: indexName,\n        columns: currentIndexes.map((idx) => ({\n          name: idx.column_name,\n          ...(this.extractIndexColumnOpclass(\n            parsedIndexDefinition.columnDefinitions[idx.column_order - 1],\n          )\n            ? {\n                opclass: this.extractIndexColumnOpclass(\n                  parsedIndexDefinition.columnDefinitions[idx.column_order - 1],\n                ),\n              }\n            : {}),\n          ...(using === \"btree\"\n            ? {\n                sortOrder: idx.sort_order,\n                nullsFirst: idx.nulls_first,\n              }\n            : {}),\n        })),\n\n        nullsNotDistinct: firstIndex.nulls_not_distinct,\n        ...(using ? { using } : {}),\n        ...this.parseVectorIndexOptions(restoredIndexType, parsedIndexDefinition.withOptions),\n      };\n    });\n\n    // foreigns 처리\n    const foreigns: MigrationForeign[] = dbForeigns.map((dbForeign) => {\n      return {\n        columns: [dbForeign.column_name],\n        to: `${dbForeign.foreign_table_name}.${dbForeign.foreign_column_name}`,\n        onUpdate: this.mapConstraintAction(dbForeign.update_rule),\n        onDelete: this.mapConstraintAction(dbForeign.delete_rule),\n      };\n    });\n\n    return {\n      table,\n      columns,\n      indexes,\n      foreigns,\n    };\n  }\n\n  /**\n   * PostgreSQL의 constraint action을 Knex 형식으로 변환\n   */\n  private mapConstraintAction(action: string): RelationOn {\n    const actionMap: Record<string, RelationOn> = {\n      \"NO ACTION\": \"NO ACTION\",\n      RESTRICT: \"RESTRICT\",\n      CASCADE: \"CASCADE\",\n      \"SET NULL\": \"SET NULL\",\n      \"SET DEFAULT\": \"SET DEFAULT\",\n    };\n    return actionMap[action] ?? \"NO ACTION\";\n  }\n\n  /**\n   * 기존 테이블 읽어서 cols, indexes, foreigns 반환\n   */\n  async readTable(\n    compareDB: RawCapableKnex,\n    tableName: string,\n  ): Promise<[PgColumn[], PgIndex[], PgForeign[]]> {\n    // Columns 조회 (Generated Column 정보 포함)\n    const columnsQuery = `\n      SELECT\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        COALESCE(\n          c.character_maximum_length,\n          CASE WHEN c.data_type = 'ARRAY' AND a.atttypmod > 0\n            THEN a.atttypmod - 4\n            ELSE NULL\n          END\n        ) AS character_maximum_length,\n        COALESCE(c.datetime_precision, c.numeric_precision) AS precision,\n        c.numeric_scale,\n        c.is_nullable,\n        c.column_default,\n        COALESCE(a.attgenerated, '') as is_generated,\n        c.generation_expression\n      FROM information_schema.columns c\n      LEFT JOIN pg_attribute a ON a.attname = c.column_name\n        AND a.attrelid = (\n          SELECT oid FROM pg_class WHERE relname = c.table_name\n          AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)\n        )\n      WHERE c.table_name = ?\n        AND c.table_schema = 'public'\n      ORDER BY c.ordinal_position\n    `;\n    const columns = (await compareDB.raw(columnsQuery, [tableName])).rows as PgColumn[];\n    if (columns.length === 0) {\n      throw new Error(`Table not found: ${tableName}`);\n    }\n\n    // Indexes 조회 (PGroonga 표현식 인덱스 포함)\n    const indexesQuery = `\n      SELECT\n          i.relname AS index_name,\n          CASE\n              WHEN am.amname = 'pgroonga' AND u.attnum = 0 THEN\n                  regexp_replace(\n                      regexp_replace(\n                          TRIM(pgroonga_col.column_expr),\n                          '::text',\n                          '',\n                          'g'\n                      ),\n                      '[()]',\n                      '',\n                      'g'\n                  )\n              ELSE a.attname\n          END AS column_name,\n          ix.indisunique AS is_unique,\n          ix.indisprimary AS is_primary,\n          am.amname AS index_type,\n          COALESCE((u.opt & 2) = 2, FALSE) AS nulls_first,\n          CASE \n              WHEN (u.opt & 1) = 1 THEN 'DESC'\n              ELSE 'ASC'\n          END AS sort_order,\n          ix.indnullsnotdistinct AS nulls_not_distinct,\n          u.ord AS column_order,\n          pg_get_indexdef(ix.indexrelid) AS index_definition\n      FROM pg_class t\n      JOIN pg_index ix ON t.oid = ix.indrelid\n      JOIN pg_class i ON i.oid = ix.indexrelid\n      JOIN pg_am am ON i.relam = am.oid\n      JOIN LATERAL unnest(ix.indkey, ix.indoption)\n          WITH ORDINALITY AS u(attnum, opt, ord) ON true\n      LEFT JOIN pg_attribute a ON a.attrelid = t.oid \n          AND a.attnum = u.attnum \n          AND u.attnum > 0\n      LEFT JOIN LATERAL (\n          SELECT \n              unnest(\n                  CASE \n                      WHEN pg_get_expr(ix.indexprs, ix.indrelid) ~ '^ARRAY\\\\[' THEN\n                          string_to_array(\n                              regexp_replace(\n                                  pg_get_expr(ix.indexprs, ix.indrelid),\n                                  '^ARRAY\\\\[(.*)\\\\]$',\n                                  '\\\\1'\n                              ),\n                              ', '\n                          )\n                      ELSE\n                          ARRAY[pg_get_expr(ix.indexprs, ix.indrelid)]\n                  END\n              ) as column_expr\n      ) pgroonga_col ON am.amname = 'pgroonga' AND u.attnum = 0\n      WHERE t.relname = ?\n          AND (u.attnum > 0 OR (am.amname = 'pgroonga' AND u.attnum = 0))\n      ORDER BY i.relname, u.ord;\n`;\n    const indexes = (await compareDB.raw(indexesQuery, [tableName])).rows;\n\n    // Foreign Keys 조회\n    const foreignsQuery = `\n      SELECT\n        tc.constraint_name,\n        kcu.column_name,\n        ccu.table_name AS foreign_table_name,\n        ccu.column_name AS foreign_column_name,\n        rc.update_rule,\n        rc.delete_rule\n      FROM information_schema.table_constraints AS tc\n      JOIN information_schema.key_column_usage AS kcu\n        ON tc.constraint_name = kcu.constraint_name\n        AND tc.table_schema = kcu.table_schema\n      JOIN information_schema.constraint_column_usage AS ccu\n        ON ccu.constraint_name = tc.constraint_name\n        AND ccu.table_schema = tc.table_schema\n      JOIN information_schema.referential_constraints AS rc\n        ON rc.constraint_name = tc.constraint_name\n        AND rc.constraint_schema = tc.table_schema\n      WHERE tc.constraint_type = 'FOREIGN KEY'\n        AND tc.table_name = ?\n    `;\n    const foreigns = (await compareDB.raw(foreignsQuery, [tableName])).rows;\n\n    return [columns, indexes, foreigns];\n  }\n\n  private restoreMigrationIndexType(\n    index: Pick<PgIndex, \"is_unique\" | \"index_type\">,\n    accessMethod?: string,\n  ): MigrationIndex[\"type\"] {\n    const resolvedAccessMethod = (accessMethod ?? index.index_type).toLowerCase();\n\n    if (resolvedAccessMethod === \"hnsw\" || resolvedAccessMethod === \"ivfflat\") {\n      return resolvedAccessMethod;\n    }\n\n    return index.is_unique ? \"unique\" : \"index\";\n  }\n\n  private restoreGenericUsing(\n    accessMethod: string | undefined,\n  ): MigrationIndex[\"using\"] | undefined {\n    if (!accessMethod) {\n      return undefined;\n    }\n\n    const normalized = accessMethod.toLowerCase();\n    if (!this.genericIndexTypes.has(normalized)) {\n      return undefined;\n    }\n\n    return normalized as MigrationIndex[\"using\"];\n  }\n\n  private parseVectorIndexOptions(\n    type: MigrationIndex[\"type\"],\n    withOptions: Record<string, string>,\n  ): Pick<MigrationIndex, \"m\" | \"efConstruction\" | \"lists\"> {\n    if (type === \"hnsw\") {\n      return {\n        ...(this.parseIntegerOption(withOptions.m) !== undefined\n          ? { m: this.parseIntegerOption(withOptions.m) }\n          : {}),\n        ...(this.parseIntegerOption(withOptions.ef_construction) !== undefined\n          ? { efConstruction: this.parseIntegerOption(withOptions.ef_construction) }\n          : {}),\n      };\n    }\n\n    if (type === \"ivfflat\") {\n      return {\n        ...(this.parseIntegerOption(withOptions.lists) !== undefined\n          ? { lists: this.parseIntegerOption(withOptions.lists) }\n          : {}),\n      };\n    }\n\n    return {};\n  }\n\n  private parseIntegerOption(value: string | undefined): number | undefined {\n    if (!value) {\n      return undefined;\n    }\n\n    const parsed = Number.parseInt(value, 10);\n    return Number.isNaN(parsed) ? undefined : parsed;\n  }\n\n  private extractIndexColumnOpclass(columnDefinition: string | undefined): string | undefined {\n    if (!columnDefinition) {\n      return undefined;\n    }\n\n    const trimmed = columnDefinition\n      .replace(/\\s+NULLS\\s+(FIRST|LAST)\\s*$/i, \"\")\n      .replace(/\\s+(ASC|DESC)\\s*$/i, \"\")\n      .trim();\n    const tokens = this.tokenizeTopLevel(trimmed);\n\n    if (tokens.length < 2) {\n      return undefined;\n    }\n\n    if (tokens[tokens.length - 2]?.toUpperCase() === \"COLLATE\") {\n      return undefined;\n    }\n\n    return tokens.at(-1);\n  }\n\n  private parseIndexDefinition(indexDefinition: string): {\n    accessMethod?: string;\n    columnDefinitions: string[];\n    withOptions: Record<string, string>;\n  } {\n    const accessMethod = indexDefinition.match(/\\bUSING\\s+([a-z_][\\w]*)/i)?.[1]?.toLowerCase();\n    const usingMatchIndex = indexDefinition.search(/\\bUSING\\b/i);\n    const columnsStart = usingMatchIndex >= 0 ? indexDefinition.indexOf(\"(\", usingMatchIndex) : -1;\n    const columnsEnd =\n      columnsStart >= 0 ? this.findMatchingParenthesis(indexDefinition, columnsStart) : -1;\n    const columnDefinitions =\n      columnsStart >= 0 && columnsEnd > columnsStart\n        ? this.splitTopLevel(indexDefinition.slice(columnsStart + 1, columnsEnd), \",\")\n        : [];\n\n    const withMatch = /\\bWITH\\s*\\(/i.exec(indexDefinition);\n    const withStart = withMatch ? indexDefinition.indexOf(\"(\", withMatch.index) : -1;\n    const withEnd = withStart >= 0 ? this.findMatchingParenthesis(indexDefinition, withStart) : -1;\n    const withOptions =\n      withStart >= 0 && withEnd > withStart\n        ? this.parseIndexOptionEntries(indexDefinition.slice(withStart + 1, withEnd))\n        : {};\n\n    return {\n      accessMethod,\n      columnDefinitions,\n      withOptions,\n    };\n  }\n\n  private parseIndexOptionEntries(optionSource: string): Record<string, string> {\n    return this.splitTopLevel(optionSource, \",\").reduce<Record<string, string>>((result, entry) => {\n      const matched = entry.trim().match(/^([a-z_][\\w]*)\\s*=\\s*(.+)$/i);\n      if (!matched) {\n        return result;\n      }\n\n      const [, key, rawValue] = matched;\n      result[key.toLowerCase()] = rawValue.trim().replace(/^['\"]|['\"]$/g, \"\");\n      return result;\n    }, {});\n  }\n\n  private splitTopLevel(source: string, delimiter: string): string[] {\n    const items: string[] = [];\n    let start = 0;\n    let parenDepth = 0;\n    let bracketDepth = 0;\n    let inSingleQuote = false;\n    let inDoubleQuote = false;\n\n    for (let index = 0; 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        parenDepth += 1;\n        continue;\n      }\n      if (char === \")\") {\n        parenDepth -= 1;\n        continue;\n      }\n      if (char === \"[\") {\n        bracketDepth += 1;\n        continue;\n      }\n      if (char === \"]\") {\n        bracketDepth -= 1;\n        continue;\n      }\n\n      if (char === delimiter && parenDepth === 0 && bracketDepth === 0) {\n        items.push(source.slice(start, index).trim());\n        start = index + 1;\n      }\n    }\n\n    const tail = source.slice(start).trim();\n    if (tail.length > 0) {\n      items.push(tail);\n    }\n\n    return items;\n  }\n\n  private tokenizeTopLevel(source: string): string[] {\n    const tokens: string[] = [];\n    let start = -1;\n    let parenDepth = 0;\n    let bracketDepth = 0;\n    let inSingleQuote = false;\n    let inDoubleQuote = false;\n\n    const pushToken = (endIndex: number) => {\n      if (start < 0) {\n        return;\n      }\n\n      const token = source.slice(start, endIndex).trim();\n      if (token.length > 0) {\n        tokens.push(token);\n      }\n      start = -1;\n    };\n\n    for (let index = 0; index < source.length; index += 1) {\n      const char = source[index];\n      const nextChar = source[index + 1];\n\n      if (char === \"'\" && !inDoubleQuote) {\n        if (start < 0) {\n          start = index;\n        }\n        if (inSingleQuote && nextChar === \"'\") {\n          index += 1;\n          continue;\n        }\n        inSingleQuote = !inSingleQuote;\n        continue;\n      }\n\n      if (char === '\"' && !inSingleQuote) {\n        if (start < 0) {\n          start = index;\n        }\n        if (inDoubleQuote && nextChar === '\"') {\n          index += 1;\n          continue;\n        }\n        inDoubleQuote = !inDoubleQuote;\n        continue;\n      }\n\n      if (!inSingleQuote && !inDoubleQuote) {\n        if (char === \"(\") {\n          if (start < 0) {\n            start = index;\n          }\n          parenDepth += 1;\n          continue;\n        }\n        if (char === \")\") {\n          parenDepth -= 1;\n          continue;\n        }\n        if (char === \"[\") {\n          if (start < 0) {\n            start = index;\n          }\n          bracketDepth += 1;\n          continue;\n        }\n        if (char === \"]\") {\n          bracketDepth -= 1;\n          continue;\n        }\n\n        if (/\\s/.test(char) && parenDepth === 0 && bracketDepth === 0) {\n          pushToken(index);\n          continue;\n        }\n      }\n\n      if (start < 0) {\n        start = index;\n      }\n    }\n\n    pushToken(source.length);\n    return tokens;\n  }\n\n  private findMatchingParenthesis(source: string, openIndex: number): number {\n    let depth = 0;\n    let inSingleQuote = false;\n    let inDoubleQuote = false;\n\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\n  /**\n   * 특정 테이블의 PK를 참조하는 다른 테이블의 FK 목록을 조회합니다.\n   * PK 타입 변경 시 관련 FK 제약조건을 삭제/복구하기 위해 사용됩니다.\n   */\n  async getReferencingForeignKeys(db: Knex, tableName: string): Promise<ReferencingForeignKey[]> {\n    const query = `\n      SELECT\n        tc.table_name,\n        tc.constraint_name,\n        kcu.column_name,\n        ccu.table_name AS referenced_table_name,\n        ccu.column_name AS referenced_column_name,\n        rc.update_rule,\n        rc.delete_rule\n      FROM information_schema.table_constraints AS tc\n      JOIN information_schema.key_column_usage AS kcu\n        ON tc.constraint_name = kcu.constraint_name\n        AND tc.table_schema = kcu.table_schema\n      JOIN information_schema.constraint_column_usage AS ccu\n        ON ccu.constraint_name = tc.constraint_name\n        AND ccu.table_schema = tc.table_schema\n      JOIN information_schema.referential_constraints AS rc\n        ON rc.constraint_name = tc.constraint_name\n        AND rc.constraint_schema = tc.table_schema\n      WHERE tc.constraint_type = 'FOREIGN KEY'\n        AND ccu.table_name = ?\n        AND tc.table_schema = 'public'\n    `;\n\n    const result = await db.raw(query, [tableName]);\n    return result.rows.map(\n      (row: {\n        table_name: string;\n        constraint_name: string;\n        column_name: string;\n        referenced_table_name: string;\n        referenced_column_name: string;\n        update_rule: string;\n        delete_rule: string;\n      }) => ({\n        tableName: row.table_name,\n        constraintName: row.constraint_name,\n        columnName: row.column_name,\n        referencedTableName: row.referenced_table_name,\n        referencedColumnName: row.referenced_column_name,\n        onUpdate: this.mapConstraintAction(row.update_rule),\n        onDelete: this.mapConstraintAction(row.delete_rule),\n      }),\n    );\n  }\n\n  /**\n   * vector 컬럼의 dimensions를 조회합니다.\n   * pg_attribute의 atttypmod에서 차원 수를 추출합니다.\n   */\n  private async getVectorDimensions(\n    compareDB: RawCapableKnex,\n    tableName: string,\n  ): Promise<Record<string, number>> {\n    const query = `\n      SELECT\n        a.attname as column_name,\n        a.atttypmod as dimensions\n      FROM pg_attribute a\n      JOIN pg_class c ON a.attrelid = c.oid\n      JOIN pg_type t ON a.atttypid = t.oid\n      WHERE c.relname = ?\n        AND t.typname = 'vector'\n        AND a.attnum > 0\n    `;\n    const result = await compareDB.raw(query, [tableName]);\n    const dimensions: Record<string, number> = {};\n    for (const row of result.rows) {\n      // atttypmod에서 실제 dimensions 값 추출\n      dimensions[row.column_name] = row.dimensions > 0 ? row.dimensions : 0;\n    }\n    return dimensions;\n  }\n\n  /**\n   * PostgreSQL 컬럼 타입을 분석하여 MigrationColumn 객체로 변환합니다.\n   */\n  resolveDBColType(\n    dbColumn: PgColumn,\n  ): Pick<\n    MigrationColumn,\n    \"type\" | \"length\" | \"precision\" | \"scale\" | \"numberType\" | \"dimensions\"\n  > {\n    const { udt_name: _udt_name, character_maximum_length, precision, numeric_scale } = dbColumn;\n\n    const { udt_name, singleOrArray } = (() => {\n      if (_udt_name.startsWith(\"_\")) {\n        return {\n          udt_name: _udt_name.substring(1),\n          singleOrArray: \"[]\" as const,\n        };\n      }\n      return {\n        udt_name: _udt_name,\n        singleOrArray: \"\" as const,\n      };\n    })();\n\n    // UUID\n    if (udt_name === \"uuid\") {\n      return { type: `uuid${singleOrArray}` };\n    }\n\n    // Integer types\n    if (udt_name === \"int4\") {\n      return { type: `integer${singleOrArray}` };\n    }\n    if (udt_name === \"int8\") {\n      return { type: `bigInteger${singleOrArray}` };\n    }\n\n    // String types\n    if (udt_name === \"varchar\") {\n      return {\n        type: `string${singleOrArray}`,\n        ...(character_maximum_length && {\n          length: character_maximum_length,\n        }),\n      };\n    }\n    if (udt_name === \"text\") {\n      return { type: `string${singleOrArray}` }; // StringProp without length\n    }\n\n    // NumberOrNumeric types\n    if (udt_name === \"numeric\") {\n      return {\n        type: `numberOrNumeric${singleOrArray}`,\n        numberType: \"numeric\",\n        ...(precision !== null &&\n          numeric_scale !== null && {\n            precision: precision,\n            scale: numeric_scale,\n          }),\n      };\n    }\n    if (udt_name === \"float4\") {\n      return { type: `numberOrNumeric${singleOrArray}`, numberType: \"real\" };\n    }\n    if (udt_name === \"float8\") {\n      return { type: `numberOrNumeric${singleOrArray}`, numberType: \"double precision\" };\n    }\n\n    // Boolean\n    if (udt_name === \"bool\") {\n      return { type: `boolean${singleOrArray}` };\n    }\n\n    // Timestampz types\n    if (udt_name === \"timestamptz\") {\n      return {\n        type: `date${singleOrArray}`,\n        ...(precision !== null && {\n          precision: precision,\n        }),\n      }; // DateProp → timestamptz\n    }\n\n    // JSON\n    if (udt_name === \"json\" || udt_name === \"jsonb\") {\n      return { type: \"json\" };\n    }\n\n    // Vector (pgvector)\n    if (udt_name === \"vector\") {\n      // vector 타입의 차원 수는 column_default나 별도 쿼리로 확인해야 함\n      // 현재는 기본값 0으로 설정 (실제 dimensions는 getMigrationSetFromDB에서 별도 쿼리로 확인)\n      return { type: `vector${singleOrArray}`, dimensions: 0 };\n    }\n\n    // tsvector (PostgreSQL 전문 검색용 타입)\n    if (udt_name === \"tsvector\") {\n      return { type: \"tsvector\" };\n    }\n\n    throw new Error(`resolve 불가능한 PostgreSQL 컬럼 타입: ${udt_name}`);\n  }\n}\n\nexport const PostgreSQLSchemaReader = new PostgreSQLSchemaReaderClass();\n"],"names":["assert","group","PostgreSQLSchemaReaderClass","genericIndexTypes","Set","getMigrationSetFromDB","compareDB","table","dbColumns","dbIndexes","dbForeigns","readTable","e","Error","message","includes","console","error","vectorDimensions","getVectorDimensions","columns","map","dbColumn","dbColType","resolveDBColType","type","dimensions","column_name","name","nullable","is_nullable","is_generated","generated","expression","generation_expression","column_default","defaultValue","startsWith","replace","endsWith","replaceAll","defaultTo","dbIndexesGroup","filter","dbIndex","is_primary","find","dbForeign","index_name","constraint_name","indexes","Object","keys","indexName","currentIndexes","toSorted","left","right","column_order","firstIndex","parsedIndexDefinition","parseIndexDefinition","index_definition","restoredIndexType","restoreMigrationIndexType","accessMethod","using","restoreGenericUsing","index_type","idx","extractIndexColumnOpclass","columnDefinitions","opclass","sortOrder","sort_order","nullsFirst","nulls_first","nullsNotDistinct","nulls_not_distinct","parseVectorIndexOptions","withOptions","foreigns","to","foreign_table_name","foreign_column_name","onUpdate","mapConstraintAction","update_rule","onDelete","delete_rule","action","actionMap","RESTRICT","CASCADE","tableName","columnsQuery","raw","rows","length","indexesQuery","foreignsQuery","index","resolvedAccessMethod","toLowerCase","is_unique","undefined","normalized","has","parseIntegerOption","m","ef_construction","efConstruction","lists","value","parsed","Number","parseInt","isNaN","columnDefinition","trimmed","trim","tokens","tokenizeTopLevel","toUpperCase","at","indexDefinition","match","usingMatchIndex","search","columnsStart","indexOf","columnsEnd","findMatchingParenthesis","splitTopLevel","slice","withMatch","exec","withStart","withEnd","parseIndexOptionEntries","optionSource","reduce","result","entry","matched","key","rawValue","source","delimiter","items","start","parenDepth","bracketDepth","inSingleQuote","inDoubleQuote","char","nextChar","push","tail","pushToken","endIndex","token","test","openIndex","depth","getReferencingForeignKeys","db","query","row","table_name","constraintName","columnName","referencedTableName","referenced_table_name","referencedColumnName","referenced_column_name","udt_name","_udt_name","character_maximum_length","precision","numeric_scale","singleOrArray","substring","numberType","scale","PostgreSQLSchemaReader"],"mappings":"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"}

package/dist/stream/sse.js

@@ -15,9 +15,11 @@ class SSEConnectionImpl {
     constructor(socket, reply){
         this.socket = socket;
         this.reply = reply;
-        this.socket.on("close", ()=>{
+        const markClosed = ()=>{
             this._closed = true;
-        });
+        };
+        this.socket.on("close", markClosed);
+        this.socket.on("error", markClosed);
     }
     publish(event, data) {
         if (this._closed) {
@@ -42,4 +44,4 @@ class SSEConnectionImpl {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdHJlYW0vc3NlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRmFzdGlmeVJlcGx5LCBGYXN0aWZ5UmVxdWVzdCB9IGZyb20gXCJmYXN0aWZ5XCI7XG5pbXBvcnQgdHlwZSB7IHogfSBmcm9tIFwiem9kXCI7XG5cbi8vIE5PVEUoSGF6ZSwgMjUxMTA2KTogY29udGV4dCBwcm92aWRlcuyXkOyEnCDsnbjsnpDrpbwg7LGE7JuM7KO866m0IGNyZWF0ZVNTRShldmVudHMp66eM7Jy866GcIOyCrOyaqSDqsIDriqVcbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVTU0VGYWN0b3J5PFQgZXh0ZW5kcyB6LlpvZE9iamVjdD4oXG4gIHNvY2tldDogRmFzdGlmeVJlcXVlc3RbXCJzb2NrZXRcIl0sXG4gIHJlcGx5OiBGYXN0aWZ5UmVwbHksXG4gIF9ldmVudHM6IFQsXG4pOiBTU0VDb25uZWN0aW9uPFQ+IHtcbiAgcmV0dXJuIG5ldyBTU0VDb25uZWN0aW9uSW1wbDxUPihzb2NrZXQsIHJlcGx5KTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZU1vY2tTU0VGYWN0b3J5PFQgZXh0ZW5kcyB6LlpvZE9iamVjdD4oX2V2ZW50czogVCk6IFNTRUNvbm5lY3Rpb248VD4ge1xuICByZXR1cm4ge1xuICAgIHB1Ymxpc2g6IChfZXZlbnQsIF9kYXRhKSA9PiB7fSxcbiAgICBlbmQ6ICgpID0+IFByb21pc2UucmVzb2x2ZSgpLFxuICB9O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNTRUNvbm5lY3Rpb248VCBleHRlbmRzIHouWm9kT2JqZWN0PiB7XG4gIHB1Ymxpc2g8SyBleHRlbmRzIGtleW9mIHouaW5mZXI8VD4+KGV2ZW50OiBLLCBkYXRhOiB6LmluZmVyPFQ+W0tdKTogdm9pZDtcbiAgZW5kKCk6IFByb21pc2U8dm9pZD47XG59XG5cbmNsYXNzIFNTRUNvbm5lY3Rpb25JbXBsPFQgZXh0ZW5kcyB6LlpvZE9iamVjdD4gaW1wbGVtZW50cyBTU0VDb25uZWN0aW9uPFQ+IHtcbiAgcHJpdmF0ZSBfY2xvc2VkID0gZmFsc2U7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSByZWFkb25seSBzb2NrZXQ6IEZhc3RpZnlSZXF1ZXN0W1wic29ja2V0XCJdLFxuICAgIHByaXZhdGUgcmVhZG9ubHkgcmVwbHk6IEZhc3RpZnlSZXBseSxcbiAgKSB7XG4gICAgY29uc3QgbWFya0Nsb3NlZCA9ICgpID0+IHtcbiAgICAgIHRoaXMuX2Nsb3NlZCA9IHRydWU7XG4gICAgfTtcbiAgICB0aGlzLnNvY2tldC5vbihcImNsb3NlXCIsIG1hcmtDbG9zZWQpO1xuICAgIHRoaXMuc29ja2V0Lm9uKFwiZXJyb3JcIiwgbWFya0Nsb3NlZCk7XG4gIH1cblxuICBwdWJsaXNoPEsgZXh0ZW5kcyBrZXlvZiB6LmluZmVyPFQ+PihldmVudDogSywgZGF0YTogei5pbmZlcjxUPltLXSk6IHZvaWQge1xuICAgIGlmICh0aGlzLl9jbG9zZWQpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICB0aGlzLnJlcGx5LnNzZSh7XG4gICAgICBldmVudDogZXZlbnQgYXMgc3RyaW5nLFxuICAgICAgZGF0YTogSlNPTi5zdHJpbmdpZnkoZGF0YSksXG4gICAgfSk7XG4gIH1cblxuICBhc3luYyBlbmQoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgaWYgKHRoaXMuX2Nsb3NlZCkge1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIHRoaXMuX2Nsb3NlZCA9IHRydWU7XG5cbiAgICB0aGlzLnJlcGx5LnNzZSh7XG4gICAgICBldmVudDogXCJlbmRcIixcbiAgICAgIGRhdGE6IFwiRU5EXCIsXG4gICAgfSk7XG5cbiAgICBhd2FpdCBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gc2V0VGltZW91dChyZXNvbHZlLCAyMDApKTtcbiAgICB0aGlzLnJlcGx5LnJhdy5lbmQoKTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbImNyZWF0ZVNTRUZhY3RvcnkiLCJzb2NrZXQiLCJyZXBseSIsIl9ldmVudHMiLCJTU0VDb25uZWN0aW9uSW1wbCIsImNyZWF0ZU1vY2tTU0VGYWN0b3J5IiwicHVibGlzaCIsIl9ldmVudCIsIl9kYXRhIiwiZW5kIiwiUHJvbWlzZSIsInJlc29sdmUiLCJfY2xvc2VkIiwibWFya0Nsb3NlZCIsIm9uIiwiZXZlbnQiLCJkYXRhIiwic3NlIiwiSlNPTiIsInN0cmluZ2lmeSIsInNldFRpbWVvdXQiLCJyYXciXSwibWFwcGluZ3MiOiJBQUdBLDZFQUE2RTtBQUM3RSxPQUFPLFNBQVNBLGlCQUNkQyxNQUFnQyxFQUNoQ0MsS0FBbUIsRUFDbkJDLE9BQVU7SUFFVixPQUFPLElBQUlDLGtCQUFxQkgsUUFBUUM7QUFDMUM7QUFFQSxPQUFPLFNBQVNHLHFCQUE0Q0YsT0FBVTtJQUNwRSxPQUFPO1FBQ0xHLFNBQVMsQ0FBQ0MsUUFBUUMsU0FBVztRQUM3QkMsS0FBSyxJQUFNQyxRQUFRQyxPQUFPO0lBQzVCO0FBQ0Y7QUFPQSxNQUFNUDs7O0lBQ0lRLFVBQVUsTUFBTTtJQUV4QixZQUNFLEFBQWlCWCxNQUFnQyxFQUNqRCxBQUFpQkMsS0FBbUIsQ0FDcEM7YUFGaUJELFNBQUFBO2FBQ0FDLFFBQUFBO1FBRWpCLE1BQU1XLGFBQWE7WUFDakIsSUFBSSxDQUFDRCxPQUFPLEdBQUc7UUFDakI7UUFDQSxJQUFJLENBQUNYLE1BQU0sQ0FBQ2EsRUFBRSxDQUFDLFNBQVNEO1FBQ3hCLElBQUksQ0FBQ1osTUFBTSxDQUFDYSxFQUFFLENBQUMsU0FBU0Q7SUFDMUI7SUFFQVAsUUFBb0NTLEtBQVEsRUFBRUMsSUFBbUIsRUFBUTtRQUN2RSxJQUFJLElBQUksQ0FBQ0osT0FBTyxFQUFFO1lBQ2hCO1FBQ0Y7UUFFQSxJQUFJLENBQUNWLEtBQUssQ0FBQ2UsR0FBRyxDQUFDO1lBQ2JGLE9BQU9BO1lBQ1BDLE1BQU1FLEtBQUtDLFNBQVMsQ0FBQ0g7UUFDdkI7SUFDRjtJQUVBLE1BQU1QLE1BQXFCO1FBQ3pCLElBQUksSUFBSSxDQUFDRyxPQUFPLEVBQUU7WUFDaEI7UUFDRjtRQUVBLElBQUksQ0FBQ0EsT0FBTyxHQUFHO1FBRWYsSUFBSSxDQUFDVixLQUFLLENBQUNlLEdBQUcsQ0FBQztZQUNiRixPQUFPO1lBQ1BDLE1BQU07UUFDUjtRQUVBLE1BQU0sSUFBSU4sUUFBUSxDQUFDQyxVQUFZUyxXQUFXVCxTQUFTO1FBQ25ELElBQUksQ0FBQ1QsS0FBSyxDQUFDbUIsR0FBRyxDQUFDWixHQUFHO0lBQ3BCO0FBQ0YifQ==