sonamu 0.5.7 → 0.7.0

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

@@ -0,0 +1,245 @@
+import assert from "assert";
+import { group } from "radashi";
+class PostgreSQLSchemaReaderClass {
+    /**
+   * DB에서 테이블 정보를 읽어서 MigrationSet을 만들어옵니다.
+   * @param compareDB Knex 인스턴스
+   * @param table 테이블 이름
+   * @returns MigrationSet 객체
+   */ async getMigrationSetFromDB(compareDB, table) {
+        let dbColumns, dbIndexes, dbForeigns;
+        try {
+            [dbColumns, dbIndexes, dbForeigns] = await this.readTable(compareDB, table);
+        } catch (e) {
+            if (e instanceof Error && e.message.includes("Table not found")) {
+                return null;
+            }
+            console.error(e);
+            return null;
+        }
+        const columns = dbColumns.map((dbColumn)=>{
+            const dbColType = this.resolveDBColType(dbColumn);
+            return {
+                name: dbColumn.column_name,
+                nullable: dbColumn.is_nullable === "YES",
+                ...dbColType,
+                ...(()=>{
+                    if (dbColumn.column_default !== null) {
+                        // PostgreSQL default 값 정리 (nextval, CURRENT_TIMESTAMP 등)
+                        let defaultValue = dbColumn.column_default;
+                        // nextval 제거 (SERIAL 타입)
+                        if (defaultValue.startsWith("nextval(")) {
+                            return {};
+                        }
+                        // 타입 캐스팅 제거 (예: '1'::integer → 1)
+                        defaultValue = defaultValue.replace(/::[\w\s]+$/g, "");
+                        // 따옴표 제거가 필요한 경우
+                        if (defaultValue.startsWith("'") && defaultValue.endsWith("'")) {
+                            defaultValue = defaultValue.slice(1, -1);
+                        }
+                        return {
+                            defaultTo: defaultValue
+                        };
+                    }
+                    return {};
+                })()
+            };
+        });
+        // PRIMARY KEY와 foreign key용 인덱스 제외
+        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];
+            assert(currentIndexes);
+            const firstIndex = currentIndexes[0];
+            const type = firstIndex.is_unique ? "unique" : "index";
+            return {
+                type,
+                columns: currentIndexes.map((idx)=>idx.column_name)
+            };
+        });
+        // foreigns 처리
+        const foreigns = dbForeigns.map((dbForeign)=>{
+            return {
+                columns: [
+                    dbForeign.column_name
+                ],
+                to: `${dbForeign.foreign_table_name}.${dbForeign.foreign_column_name}`,
+                onUpdate: this.mapConstraintAction(dbForeign.update_rule),
+                onDelete: this.mapConstraintAction(dbForeign.delete_rule)
+            };
+        });
+        return {
+            table,
+            columns,
+            indexes,
+            foreigns
+        };
+    }
+    /**
+   * PostgreSQL의 constraint action을 Knex 형식으로 변환
+   */ mapConstraintAction(action) {
+        const actionMap = {
+            "NO ACTION": "NO ACTION",
+            RESTRICT: "RESTRICT",
+            CASCADE: "CASCADE",
+            "SET NULL": "SET NULL",
+            "SET DEFAULT": "SET DEFAULT"
+        };
+        return actionMap[action] ?? "NO ACTION";
+    }
+    /**
+   * 기존 테이블 읽어서 cols, indexes, foreigns 반환
+   */ async readTable(compareDB, tableName) {
+        // Columns 조회
+        const columns = await compareDB.select("column_name", "data_type", "udt_name", "character_maximum_length", "numeric_precision", "numeric_scale", "is_nullable", "column_default").from("information_schema.columns").where({
+            table_name: tableName
+        }).orderBy("ordinal_position");
+        if (columns.length === 0) {
+            throw new Error(`Table not found: ${tableName}`);
+        }
+        // Indexes 조회
+        const indexesQuery = `
+      SELECT
+        i.relname as index_name,
+        a.attname as column_name,
+        ix.indisunique as is_unique,
+        ix.indisprimary as is_primary,
+        am.amname as index_type
+      FROM pg_class t
+      JOIN pg_index ix ON t.oid = ix.indrelid
+      JOIN pg_class i ON i.oid = ix.indexrelid
+      JOIN pg_attribute a ON a.attrelid = t.oid
+      JOIN pg_am am ON i.relam = am.oid
+      WHERE t.relname = ?
+        AND a.attnum = ANY(ix.indkey)
+      ORDER BY i.relname, array_position(ix.indkey, a.attnum)
+    `;
+        const indexes = (await compareDB.raw(indexesQuery, [
+            tableName
+        ])).rows;
+        // Foreign Keys 조회
+        const foreignsQuery = `
+      SELECT
+        tc.constraint_name,
+        kcu.column_name,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.update_rule,
+        rc.delete_rule
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name
+        AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints AS rc
+        ON rc.constraint_name = tc.constraint_name
+        AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = ?
+    `;
+        const foreigns = (await compareDB.raw(foreignsQuery, [
+            tableName
+        ])).rows;
+        return [
+            columns,
+            indexes,
+            foreigns
+        ];
+    }
+    /**
+   * PostgreSQL 컬럼 타입을 분석하여 MigrationColumn 객체로 변환합니다.
+   */ resolveDBColType(dbColumn) {
+        const { udt_name: _udt_name, character_maximum_length, numeric_precision, numeric_scale } = dbColumn;
+        const { udt_name, singleOrArray } = (()=>{
+            if (_udt_name.startsWith("_")) {
+                return {
+                    udt_name: _udt_name.substring(1),
+                    singleOrArray: "[]"
+                };
+            }
+            return {
+                udt_name: _udt_name,
+                singleOrArray: ""
+            };
+        })();
+        // UUID
+        if (udt_name === "uuid") {
+            return {
+                type: `uuid${singleOrArray}`
+            };
+        }
+        // Integer types
+        if (udt_name === "int4") {
+            return {
+                type: `integer${singleOrArray}`
+            };
+        }
+        if (udt_name === "int8") {
+            return {
+                type: `bigInteger${singleOrArray}`
+            };
+        }
+        // String types
+        if (udt_name === "varchar") {
+            return {
+                type: `string${singleOrArray}`,
+                ...character_maximum_length && {
+                    length: character_maximum_length
+                }
+            };
+        }
+        if (udt_name === "text") {
+            return {
+                type: `string${singleOrArray}`
+            }; // StringProp without length
+        }
+        // NumberOrNumeric types
+        if (udt_name === "numeric") {
+            return {
+                type: `numberOrNumeric${singleOrArray}`,
+                numberType: "numeric",
+                ...numeric_precision !== null && numeric_scale !== null && {
+                    precision: numeric_precision,
+                    scale: numeric_scale
+                }
+            };
+        }
+        if (udt_name === "float4") {
+            return {
+                type: `numberOrNumeric${singleOrArray}`,
+                numberType: "real"
+            };
+        }
+        if (udt_name === "float8") {
+            return {
+                type: `numberOrNumeric${singleOrArray}`,
+                numberType: "double precision"
+            };
+        }
+        // Boolean
+        if (udt_name === "bool") {
+            return {
+                type: `boolean${singleOrArray}`
+            };
+        }
+        // Timestampz types
+        if (udt_name === "timestamptz") {
+            return {
+                type: `date${singleOrArray}`
+            }; // DateProp → timestamptz
+        }
+        // JSON
+        if (udt_name === "json" || udt_name === "jsonb") {
+            return {
+                type: "json"
+            };
+        }
+        throw new Error(`resolve 불가능한 PostgreSQL 컬럼 타입: ${udt_name}`);
+    }
+}
+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\nexport type PgColumn = {\n  column_name: string;\n  data_type: string;\n  udt_name: string;\n  character_maximum_length: number | null;\n  numeric_precision: number | null;\n  numeric_scale: number | null;\n  is_nullable: string;\n  column_default: 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};\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    const columns: MigrationColumn[] = dbColumns.map((dbColumn) => {\n      const dbColType = this.resolveDBColType(dbColumn);\n      return {\n        name: dbColumn.column_name,\n        nullable: dbColumn.is_nullable === \"YES\",\n        ...dbColType,\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            // 따옴표 제거가 필요한 경우\n            if (defaultValue.startsWith(\"'\") && defaultValue.endsWith(\"'\")) {\n              defaultValue = defaultValue.slice(1, -1);\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        columns: currentIndexes.map((idx) => idx.column_name),\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 조회\n    const columns = await compareDB\n      .select(\n        \"column_name\",\n        \"data_type\",\n        \"udt_name\",\n        \"character_maximum_length\",\n        \"numeric_precision\",\n        \"numeric_scale\",\n        \"is_nullable\",\n        \"column_default\",\n      )\n      .from(\"information_schema.columns\")\n      .where({ table_name: tableName })\n      .orderBy(\"ordinal_position\");\n    if (columns.length === 0) {\n      throw new Error(`Table not found: ${tableName}`);\n    }\n\n    // Indexes 조회\n    const indexesQuery = `\n      SELECT\n        i.relname as index_name,\n        a.attname as column_name,\n        ix.indisunique as is_unique,\n        ix.indisprimary as is_primary,\n        am.amname as index_type\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_attribute a ON a.attrelid = t.oid\n      JOIN pg_am am ON i.relam = am.oid\n      WHERE t.relname = ?\n        AND a.attnum = ANY(ix.indkey)\n      ORDER BY i.relname, array_position(ix.indkey, a.attnum)\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   * PostgreSQL 컬럼 타입을 분석하여 MigrationColumn 객체로 변환합니다.\n   */\n  resolveDBColType(\n    dbColumn: PgColumn,\n  ): Pick<MigrationColumn, \"type\" | \"length\" | \"precision\" | \"scale\" | \"numberType\"> {\n    const {\n      udt_name: _udt_name,\n      character_maximum_length,\n      numeric_precision,\n      numeric_scale,\n    } = 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        ...(numeric_precision !== null &&\n          numeric_scale !== null && {\n            precision: numeric_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 { type: `date${singleOrArray}` }; // DateProp → timestamptz\n    }\n\n    // JSON\n    if (udt_name === \"json\" || udt_name === \"jsonb\") {\n      return { type: \"json\" };\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","columns","map","dbColumn","dbColType","resolveDBColType","name","column_name","nullable","is_nullable","column_default","defaultValue","startsWith","replace","endsWith","slice","defaultTo","dbIndexesGroup","filter","dbIndex","is_primary","find","dbForeign","index_name","constraint_name","indexes","Object","keys","indexName","currentIndexes","firstIndex","type","is_unique","idx","foreigns","to","foreign_table_name","foreign_column_name","onUpdate","mapConstraintAction","update_rule","onDelete","delete_rule","action","actionMap","RESTRICT","CASCADE","tableName","select","from","where","table_name","orderBy","length","indexesQuery","raw","rows","foreignsQuery","udt_name","_udt_name","character_maximum_length","numeric_precision","numeric_scale","singleOrArray","substring","numberType","precision","scale","PostgreSQLSchemaReader"],"mappings":"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"}

package/dist/migration/types.d.ts

@@ -1,53 +1,21 @@
-import { SonamuDBConfig } from "../database/db";
-import { GenMigrationCode } from "../types/types";
+import type { SonamuDBConfig } from "../database/db";
+import type { GenMigrationCode } from "../types/types";
 export type MigrationCode = {
     name: string;
     path: string;
 };
-export type ConnString = `${"mysql2"}://${string}@${string}:${number}/${string}`;
+export type ConnString = `${"pg"}://${string}@${string}:${number}/${string}`;
 export type MigrationStatus = {
     codes: MigrationCode[];
     conns: {
         name: string;
         connKey: keyof SonamuDBConfig;
         connString: ConnString;
-        currentVersion: string;
-        status: string | number;
+        currentVersion: string | "error";
+        status: number | "error";
         pending: string[];
     }[];
     preparedCodes: GenMigrationCode[];
-};
-export type DBColumn = {
-    Field: string;
-    Type: string;
-    Null: string;
-    Key: string;
-    Default: string | null;
-    Extra: string;
-};
-export type DBIndex = {
-    Table: string;
-    Non_unique: number;
-    Key_name: string;
-    Seq_in_index: number;
-    Column_name: string;
-    Collation: string | null;
-    Cardinality: number | null;
-    Sub_part: number | null;
-    Packed: string | null;
-    Null: string;
-    Index_type: string;
-    Comment: string;
-    Index_comment: string;
-    Visible: string;
-    Expression: string | null;
-};
-export type DBForeign = {
-    keyName: string;
-    from: string;
-    referencesTable: string;
-    referencesField: string;
-    onDelete: string;
-    onUpdate: string;
+    error?: string;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/migration/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/migration/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AACF,MAAM,MAAM,UAAU,GACpB,GAAG,QAAQ,MAAM,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,cAAc,CAAC;QAC9B,UAAU,EAAE,UAAU,CAAC;QACvB,cAAc,EAAE,MAAM,CAAC;QACvB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;QACxB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,EAAE,CAAC;IACJ,aAAa,EAAE,gBAAgB,EAAE,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AACF,MAAM,MAAM,OAAO,GAAG;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AACF,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/migration/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,GAAG,IAAI,MAAM,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;AAC7E,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,cAAc,CAAC;QAC9B,UAAU,EAAE,UAAU,CAAC;QACvB,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC;QACjC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;QACzB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,EAAE,CAAC;IACJ,aAAa,EAAE,gBAAgB,EAAE,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/dist/migration/types.js

@@ -1,2 +1,3 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});
-//# sourceMappingURL=types.js.map
+export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9taWdyYXRpb24vdHlwZXMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTb25hbXVEQkNvbmZpZyB9IGZyb20gXCIuLi9kYXRhYmFzZS9kYlwiO1xuaW1wb3J0IHR5cGUgeyBHZW5NaWdyYXRpb25Db2RlIH0gZnJvbSBcIi4uL3R5cGVzL3R5cGVzXCI7XG5cbmV4cG9ydCB0eXBlIE1pZ3JhdGlvbkNvZGUgPSB7XG4gIG5hbWU6IHN0cmluZztcbiAgcGF0aDogc3RyaW5nO1xufTtcbmV4cG9ydCB0eXBlIENvbm5TdHJpbmcgPSBgJHtcInBnXCJ9Oi8vJHtzdHJpbmd9QCR7c3RyaW5nfToke251bWJlcn0vJHtzdHJpbmd9YDsgLy8gcGc6Ly9hY2NvdW50QGhvc3Q6cG9ydC9kYXRhYmFzZVxuZXhwb3J0IHR5cGUgTWlncmF0aW9uU3RhdHVzID0ge1xuICBjb2RlczogTWlncmF0aW9uQ29kZVtdO1xuICBjb25uczoge1xuICAgIG5hbWU6IHN0cmluZztcbiAgICBjb25uS2V5OiBrZXlvZiBTb25hbXVEQkNvbmZpZztcbiAgICBjb25uU3RyaW5nOiBDb25uU3RyaW5nO1xuICAgIGN1cnJlbnRWZXJzaW9uOiBzdHJpbmcgfCBcImVycm9yXCI7XG4gICAgc3RhdHVzOiBudW1iZXIgfCBcImVycm9yXCI7XG4gICAgcGVuZGluZzogc3RyaW5nW107XG4gIH1bXTtcbiAgcHJlcGFyZWRDb2RlczogR2VuTWlncmF0aW9uQ29kZVtdO1xuICBlcnJvcj86IHN0cmluZztcbn07XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsV0FZRSJ9

package/dist/naite/messaging-types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Sonamu extension과 공유하는 Naite 메시징 관련 타입 정의들입니다.
+ * 이 파일은 cartanova-ai/sonamu와 cartanova-ai/vscode-sonamu에서 공통으로 사용됩니다.
+ */
+export declare namespace NaiteMessagingTypes {
+    type NaiteRunStartMessage = {
+        type: "run/start";
+        startedAt: string;
+    };
+    type NaiteTestResultMessage = {
+        type: "test/result";
+        receivedAt: string;
+    } & TestResult;
+    type NaiteRunEndMessage = {
+        type: "run/end";
+        endedAt: string;
+    };
+    type NaiteMessage = NaiteRunStartMessage | NaiteTestResultMessage | NaiteRunEndMessage;
+    type NaiteTrace = {
+        key: string;
+        value: any;
+        filePath: string;
+        lineNumber: number;
+        at: string;
+    };
+    type TestError = {
+        message: string;
+        stack?: string;
+    };
+    type TestResult = {
+        suiteName: string;
+        suiteFilePath?: string;
+        testName: string;
+        testFilePath: string;
+        testLine: number;
+        status: string;
+        duration: number;
+        error?: TestError;
+        traces: NaiteTrace[];
+        receivedAt: string;
+    };
+}
+//# sourceMappingURL=messaging-types.d.ts.map

package/dist/naite/messaging-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messaging-types.d.ts","sourceRoot":"","sources":["../../src/naite/messaging-types.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,yBAAiB,mBAAmB,CAAC;IACjC,KAAY,oBAAoB,GAAG;QACjC,IAAI,EAAE,WAAW,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IAEF,KAAY,sBAAsB,GAAG;QACnC,IAAI,EAAE,aAAa,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;KACpB,GAAG,UAAU,CAAC;IAEf,KAAY,kBAAkB,GAAG;QAC/B,IAAI,EAAE,SAAS,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAEF,KAAY,YAAY,GAAG,oBAAoB,GAAG,sBAAsB,GAAG,kBAAkB,CAAC;IAE9F,KAAY,UAAU,GAAG;QACvB,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,GAAG,CAAC;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,EAAE,EAAE,MAAM,CAAC;KACZ,CAAC;IAEF,KAAY,SAAS,GAAG;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IAEF,KAAY,UAAU,GAAG;QACvB,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,SAAS,CAAC;QAClB,MAAM,EAAE,UAAU,EAAE,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH"}

package/dist/naite/messaging-types.js

@@ -0,0 +1,7 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함
+/**
+ * Sonamu extension과 공유하는 Naite 메시징 관련 타입 정의들입니다.
+ * 이 파일은 cartanova-ai/sonamu와 cartanova-ai/vscode-sonamu에서 공통으로 사용됩니다.
+ */ export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9uYWl0ZS9tZXNzYWdpbmctdHlwZXMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gYmlvbWUtaWdub3JlLWFsbCBsaW50L3N1c3BpY2lvdXMvbm9FeHBsaWNpdEFueTogTmFpdGXripQgZXhwZWN07JmAIO2YuOydke2VmOuPhOuhnSBhbnnrpbwg7ZeI7Jqp7ZWoXG5cbi8qKlxuICogU29uYW11IGV4dGVuc2lvbuqzvCDqs7XsnKDtlZjripQgTmFpdGUg66mU7Iuc7KeVIOq0gOugqCDtg4DsnoUg7KCV7J2Y65Ok7J6F64uI64ukLlxuICog7J20IO2MjOydvOydgCBjYXJ0YW5vdmEtYWkvc29uYW117JmAIGNhcnRhbm92YS1haS92c2NvZGUtc29uYW117JeQ7IScIOqzte2GteycvOuhnCDsgqzsmqnrkKnri4jri6QuXG4gKi9cbmV4cG9ydCBuYW1lc3BhY2UgTmFpdGVNZXNzYWdpbmdUeXBlcyB7XG4gICAgZXhwb3J0IHR5cGUgTmFpdGVSdW5TdGFydE1lc3NhZ2UgPSB7XG4gICAgICB0eXBlOiBcInJ1bi9zdGFydFwiO1xuICAgICAgc3RhcnRlZEF0OiBzdHJpbmc7XG4gICAgfTtcbiAgXG4gICAgZXhwb3J0IHR5cGUgTmFpdGVUZXN0UmVzdWx0TWVzc2FnZSA9IHtcbiAgICAgIHR5cGU6IFwidGVzdC9yZXN1bHRcIjtcbiAgICAgIHJlY2VpdmVkQXQ6IHN0cmluZztcbiAgICB9ICYgVGVzdFJlc3VsdDtcbiAgXG4gICAgZXhwb3J0IHR5cGUgTmFpdGVSdW5FbmRNZXNzYWdlID0ge1xuICAgICAgdHlwZTogXCJydW4vZW5kXCI7XG4gICAgICBlbmRlZEF0OiBzdHJpbmc7XG4gICAgfTtcbiAgXG4gICAgZXhwb3J0IHR5cGUgTmFpdGVNZXNzYWdlID0gTmFpdGVSdW5TdGFydE1lc3NhZ2UgfCBOYWl0ZVRlc3RSZXN1bHRNZXNzYWdlIHwgTmFpdGVSdW5FbmRNZXNzYWdlO1xuICBcbiAgICBleHBvcnQgdHlwZSBOYWl0ZVRyYWNlID0ge1xuICAgICAga2V5OiBzdHJpbmc7XG4gICAgICB2YWx1ZTogYW55O1xuICAgICAgZmlsZVBhdGg6IHN0cmluZztcbiAgICAgIGxpbmVOdW1iZXI6IG51bWJlcjtcbiAgICAgIGF0OiBzdHJpbmc7XG4gICAgfTtcbiAgXG4gICAgZXhwb3J0IHR5cGUgVGVzdEVycm9yID0ge1xuICAgICAgbWVzc2FnZTogc3RyaW5nO1xuICAgICAgc3RhY2s/OiBzdHJpbmc7XG4gICAgfTtcbiAgXG4gICAgZXhwb3J0IHR5cGUgVGVzdFJlc3VsdCA9IHtcbiAgICAgIHN1aXRlTmFtZTogc3RyaW5nO1xuICAgICAgc3VpdGVGaWxlUGF0aD86IHN0cmluZztcbiAgICAgIHRlc3ROYW1lOiBzdHJpbmc7XG4gICAgICB0ZXN0RmlsZVBhdGg6IHN0cmluZztcbiAgICAgIHRlc3RMaW5lOiBudW1iZXI7XG4gICAgICBzdGF0dXM6IHN0cmluZztcbiAgICAgIGR1cmF0aW9uOiBudW1iZXI7XG4gICAgICBlcnJvcj86IFRlc3RFcnJvcjtcbiAgICAgIHRyYWNlczogTmFpdGVUcmFjZVtdO1xuICAgICAgcmVjZWl2ZWRBdDogc3RyaW5nO1xuICAgIH07XG4gIH1cbiAgIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGdGQUFnRjtBQUVoRjs7O0NBR0MsR0FDRCxXQTJDRyJ9

package/dist/naite/naite-reporter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * NaiteReporter
+ *
+ * 테스트 결과와 Trace 정보를 Unix Socket으로 VS Code extension에 전달합니다.
+ * extension이 ~/.sonamu/naite.sock에 소켓 서버를 열어둡니다.
+ *
+ * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.
+ */
+/** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */
+import type { NaiteMessagingTypes } from "./messaging-types";
+declare class NaiteReporterClass {
+    private socket;
+    private connected;
+    private buffer;
+    /**
+     * 소켓 연결 시도
+     */
+    private ensureConnection;
+    /**
+     * 메시지 전송 (줄바꿈으로 구분)
+     */
+    private send;
+    /**
+     * beforeAll에서 호출합니다.
+     * 테스트 run 시작을 알립니다 (데이터 클리어 신호).
+     */
+    startTestRun(): void;
+    /**
+     * afterEach에서 호출합니다.
+     * 테스트 케이스 결과를 traces와 함께 전송합니다.
+     */
+    reportTestResult(result: Omit<NaiteMessagingTypes.TestResult, "receivedAt">): void;
+    /**
+     * afterAll에서 호출합니다.
+     * 테스트 run 종료를 알립니다.
+     */
+    endTestRun(): void;
+}
+export declare const NaiteReporter: NaiteReporterClass;
+export {};
+//# sourceMappingURL=naite-reporter.d.ts.map

package/dist/naite/naite-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naite-reporter.d.ts","sourceRoot":"","sources":["../../src/naite/naite-reporter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,oFAAoF;AAKpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAM7D,cAAM,kBAAkB;IACtB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,MAAM,CAAgB;IAE9B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA8BxB;;OAEG;IACH,OAAO,CAAC,IAAI;IAaZ;;;OAGG;IACH,YAAY,IAAI,IAAI;IAWpB;;;OAGG;IACH,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,GAAG,IAAI;IAYlF;;;OAGG;IACH,UAAU,IAAI,IAAI;CAiBnB;AAED,eAAO,MAAM,aAAa,oBAA2B,CAAC"}

package/dist/naite/naite-reporter.js

@@ -0,0 +1,102 @@
+/**
+ * NaiteReporter
+ *
+ * 테스트 결과와 Trace 정보를 Unix Socket으로 VS Code extension에 전달합니다.
+ * extension이 ~/.sonamu/naite.sock에 소켓 서버를 열어둡니다.
+ *
+ * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.
+ */ /** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */ import { connect } from "net";
+import { homedir } from "os";
+import { join } from "path";
+// 소켓 경로
+const SOCKET_PATH = process.platform === "win32" ? "\\\\.\\pipe\\naite" : join(homedir(), ".sonamu", "naite.sock");
+class NaiteReporterClass {
+    socket = null;
+    connected = false;
+    buffer = [];
+    /**
+   * 소켓 연결 시도
+   */ ensureConnection() {
+        if (this.connected || this.socket) return;
+        try {
+            this.socket = connect(SOCKET_PATH);
+            this.socket.on("connect", ()=>{
+                this.connected = true;
+                // 버퍼에 쌓인 메시지 전송
+                for (const msg of this.buffer){
+                    this.socket?.write(msg);
+                }
+                this.buffer = [];
+            });
+            this.socket.on("error", ()=>{
+                // 연결 실패 무시 (extension이 꺼져있을 수 있음)
+                this.connected = false;
+                this.socket = null;
+            });
+            this.socket.on("close", ()=>{
+                this.connected = false;
+                this.socket = null;
+            });
+        } catch  {
+        // 연결 실패 무시
+        }
+    }
+    /**
+   * 메시지 전송 (줄바꿈으로 구분)
+   */ send(data) {
+        const msg = `${JSON.stringify(data)}\n`;
+        this.ensureConnection();
+        if (this.connected && this.socket) {
+            this.socket.write(msg);
+        } else {
+            // 연결 대기 중이면 버퍼에 저장
+            this.buffer.push(msg);
+        }
+    }
+    /**
+   * beforeAll에서 호출합니다.
+   * 테스트 run 시작을 알립니다 (데이터 클리어 신호).
+   */ startTestRun() {
+        if (process.env.CI) {
+            return;
+        }
+        this.send({
+            type: "run/start",
+            startedAt: new Date().toISOString()
+        });
+    }
+    /**
+   * afterEach에서 호출합니다.
+   * 테스트 케이스 결과를 traces와 함께 전송합니다.
+   */ reportTestResult(result) {
+        if (process.env.CI) {
+            return;
+        }
+        this.send({
+            type: "test/result",
+            receivedAt: new Date().toISOString(),
+            ...result
+        });
+    }
+    /**
+   * afterAll에서 호출합니다.
+   * 테스트 run 종료를 알립니다.
+   */ endTestRun() {
+        if (process.env.CI) {
+            return;
+        }
+        this.send({
+            type: "run/end",
+            endedAt: new Date().toISOString()
+        });
+        // 연결 종료
+        if (this.socket) {
+            this.socket.end();
+            this.socket = null;
+            this.connected = false;
+        }
+    }
+}
+export const NaiteReporter = new NaiteReporterClass();
+
+//# sourceMappingURL=data:application/json;base64,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