sonamu 0.5.6 → 0.6.0

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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9taWdyYXRpb24vdHlwZXMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU29uYW11REJDb25maWcgfSBmcm9tIFwiLi4vZGF0YWJhc2UvZGJcIjtcbmltcG9ydCB7IEdlbk1pZ3JhdGlvbkNvZGUgfSBmcm9tIFwiLi4vdHlwZXMvdHlwZXNcIjtcblxuZXhwb3J0IHR5cGUgTWlncmF0aW9uQ29kZSA9IHtcbiAgbmFtZTogc3RyaW5nO1xuICBwYXRoOiBzdHJpbmc7XG59O1xuZXhwb3J0IHR5cGUgQ29ublN0cmluZyA9XG4gIGAke1wibXlzcWwyXCJ9Oi8vJHtzdHJpbmd9QCR7c3RyaW5nfToke251bWJlcn0vJHtzdHJpbmd9YDsgLy8gbXlzcWwyOi8vYWNjb3VudEBob3N0OnBvcnQvZGF0YWJhc2VcbmV4cG9ydCB0eXBlIE1pZ3JhdGlvblN0YXR1cyA9IHtcbiAgY29kZXM6IE1pZ3JhdGlvbkNvZGVbXTtcbiAgY29ubnM6IHtcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgY29ubktleToga2V5b2YgU29uYW11REJDb25maWc7XG4gICAgY29ublN0cmluZzogQ29ublN0cmluZztcbiAgICBjdXJyZW50VmVyc2lvbjogc3RyaW5nO1xuICAgIHN0YXR1czogc3RyaW5nIHwgbnVtYmVyO1xuICAgIHBlbmRpbmc6IHN0cmluZ1tdO1xuICB9W107XG4gIHByZXBhcmVkQ29kZXM6IEdlbk1pZ3JhdGlvbkNvZGVbXTtcbn07XG5leHBvcnQgdHlwZSBEQkNvbHVtbiA9IHtcbiAgRmllbGQ6IHN0cmluZztcbiAgVHlwZTogc3RyaW5nO1xuICBOdWxsOiBzdHJpbmc7XG4gIEtleTogc3RyaW5nO1xuICBEZWZhdWx0OiBzdHJpbmcgfCBudWxsO1xuICBFeHRyYTogc3RyaW5nO1xufTtcbmV4cG9ydCB0eXBlIERCSW5kZXggPSB7XG4gIFRhYmxlOiBzdHJpbmc7XG4gIE5vbl91bmlxdWU6IG51bWJlcjtcbiAgS2V5X25hbWU6IHN0cmluZztcbiAgU2VxX2luX2luZGV4OiBudW1iZXI7XG4gIENvbHVtbl9uYW1lOiBzdHJpbmc7XG4gIENvbGxhdGlvbjogc3RyaW5nIHwgbnVsbDtcbiAgQ2FyZGluYWxpdHk6IG51bWJlciB8IG51bGw7XG4gIFN1Yl9wYXJ0OiBudW1iZXIgfCBudWxsO1xuICBQYWNrZWQ6IHN0cmluZyB8IG51bGw7XG4gIE51bGw6IHN0cmluZztcbiAgSW5kZXhfdHlwZTogc3RyaW5nO1xuICBDb21tZW50OiBzdHJpbmc7XG4gIEluZGV4X2NvbW1lbnQ6IHN0cmluZztcbiAgVmlzaWJsZTogc3RyaW5nO1xuICBFeHByZXNzaW9uOiBzdHJpbmcgfCBudWxsO1xufTtcbmV4cG9ydCB0eXBlIERCRm9yZWlnbiA9IHtcbiAga2V5TmFtZTogc3RyaW5nO1xuICBmcm9tOiBzdHJpbmc7XG4gIHJlZmVyZW5jZXNUYWJsZTogc3RyaW5nO1xuICByZWZlcmVuY2VzRmllbGQ6IHN0cmluZztcbiAgb25EZWxldGU6IHN0cmluZztcbiAgb25VcGRhdGU6IHN0cmluZztcbn07XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBOENBLFdBT0UifQ==

package/dist/naite/naite.d.ts

@@ -0,0 +1,12 @@
+export declare class Naite {
+    static t(name: string, value: any): void;
+    static get(name: string): any;
+    static getAll(): {
+        [key: string]: any;
+    };
+    static d(_message: string): void;
+    static i(_message: string): void;
+    static w(_message: string): void;
+    static e(_message: string): void;
+}
+//# sourceMappingURL=naite.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"naite.d.ts","sourceRoot":"","sources":["../../src/naite/naite.ts"],"names":[],"mappings":"AAEA,qBAAa,KAAK;IAEhB,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;IAuBjC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;IAS7B,MAAM,CAAC,MAAM,IAAI;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;IAiBvC,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIzB,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIzB,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;IAIzB,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM;CAI1B"}

package/dist/naite/naite.js

@@ -0,0 +1,72 @@
+import { Sonamu } from "../api/sonamu.js";
+export class Naite {
+    // 테스트 로그 기록
+    static t(name, value) {
+        const context = Sonamu.getContext();
+        const store = context?.naiteStore;
+        if (!store) {
+            return;
+        }
+        if (store.has(name)) {
+            // 이미 값이 있는 경우
+            if (Array.isArray(store.get(name))) {
+                // 배열에 추가
+                store.set(name, [
+                    ...store.get(name),
+                    value
+                ]);
+            } else {
+                // 배열이 아닌 경우 배열로 변환
+                store.set(name, [
+                    store.get(name),
+                    value
+                ]);
+            }
+        } else {
+            // 값이 없는 경우 추가
+            store.set(name, value);
+        }
+    }
+    // 테스트에서 값 가져오기
+    static get(name) {
+        const context = Sonamu.getContext();
+        if (!context?.naiteStore || !context.naiteStore.has(name)) {
+            throw new Error(`Naite.get: \`${name}\` not found`);
+        }
+        return context?.naiteStore?.get(name);
+    }
+    // 전체 리스트 가져오기
+    static getAll() {
+        const context = Sonamu.getContext();
+        if (!context?.naiteStore) {
+            return {};
+        }
+        return Object.fromEntries(context.naiteStore.entries());
+    }
+    // expect 래퍼 (CJS-ESM 이슈로 현재 사용불가)
+    // static expect(name: string) {
+    //   if (!this.vitestExpect) {
+    //     throw new Error("Vitest is not initialized");
+    //   }
+    //   return this.vitestExpect(this.get(name));
+    // }
+    // 일반 로그 레벨
+    static d(_message) {
+        // TODO: Logger 연결
+        console.log(`[DEBUG] ${_message}`);
+    }
+    static i(_message) {
+        // TODO: Logger 연결
+        console.log(`[INFO] ${_message}`);
+    }
+    static w(_message) {
+        // TODO: Logger 연결
+        console.log(`[WARN] ${_message}`);
+    }
+    static e(_message) {
+        // TODO: Logger 연결
+        console.log(`[ERROR] ${_message}`);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/stream/index.js

@@ -1,2 +1,3 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});_export_star(require("./sse"),exports);function _export_star(from,to){Object.keys(from).forEach(function(k){if(k!=="default"&&!Object.prototype.hasOwnProperty.call(to,k)){Object.defineProperty(to,k,{enumerable:true,get:function(){return from[k]}})}});return from}
-//# sourceMappingURL=index.js.map
+export * from "./sse.js";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdHJlYW0vaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vc3NlXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFRIn0=

package/dist/stream/sse.js

@@ -1,2 +1,38 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"createSSEFactory",{enumerable:true,get:function(){return createSSEFactory}});function asyncGeneratorStep(gen,resolve,reject,_next,_throw,key,arg){try{var info=gen[key](arg);var value=info.value}catch(error){reject(error);return}if(info.done){resolve(value)}else{Promise.resolve(value).then(_next,_throw)}}function _async_to_generator(fn){return function(){var self=this,args=arguments;return new Promise(function(resolve,reject){var gen=fn.apply(self,args);function _next(value){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"next",value)}function _throw(err){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"throw",err)}_next(undefined)})}}function _class_call_check(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError("Cannot call a class as a function")}}function _defineProperties(target,props){for(var i=0;i<props.length;i++){var descriptor=props[i];descriptor.enumerable=descriptor.enumerable||false;descriptor.configurable=true;if("value"in descriptor)descriptor.writable=true;Object.defineProperty(target,descriptor.key,descriptor)}}function _create_class(Constructor,protoProps,staticProps){if(protoProps)_defineProperties(Constructor.prototype,protoProps);if(staticProps)_defineProperties(Constructor,staticProps);return Constructor}function _define_property(obj,key,value){if(key in obj){Object.defineProperty(obj,key,{value:value,enumerable:true,configurable:true,writable:true})}else{obj[key]=value}return obj}function _ts_generator(thisArg,body){var f,y,t,_={label:0,sent:function(){if(t[0]&1)throw t[1];return t[1]},trys:[],ops:[]},g=Object.create((typeof Iterator==="function"?Iterator:Object).prototype);return g.next=verb(0),g["throw"]=verb(1),g["return"]=verb(2),typeof Symbol==="function"&&(g[Symbol.iterator]=function(){return this}),g;function verb(n){return function(v){return step([n,v])}}function step(op){if(f)throw new TypeError("Generator is already executing.");while(g&&(g=0,op[0]&&(_=0)),_)try{if(f=1,y&&(t=op[0]&2?y["return"]:op[0]?y["throw"]||((t=y["return"])&&t.call(y),0):y.next)&&!(t=t.call(y,op[1])).done)return t;if(y=0,t)op=[op[0]&2,t.value];switch(op[0]){case 0:case 1:t=op;break;case 4:_.label++;return{value:op[1],done:false};case 5:_.label++;y=op[1];op=[0];continue;case 7:op=_.ops.pop();_.trys.pop();continue;default:if(!(t=_.trys,t=t.length>0&&t[t.length-1])&&(op[0]===6||op[0]===2)){_=0;continue}if(op[0]===3&&(!t||op[1]>t[0]&&op[1]<t[3])){_.label=op[1];break}if(op[0]===6&&_.label<t[1]){_.label=t[1];t=op;break}if(t&&_.label<t[2]){_.label=t[2];_.ops.push(op);break}if(t[2])_.ops.pop();_.trys.pop();continue}op=body.call(thisArg,_)}catch(e){op=[6,e];y=0}finally{f=t=0}if(op[0]&5)throw op[1];return{value:op[0]?op[1]:void 0,done:true}}}function createSSEFactory(socket,reply,_events){return new SSEConnection(socket,reply)}var SSEConnection=/*#__PURE__*/function(){"use strict";function SSEConnection(socket,reply){var _this=this;_class_call_check(this,SSEConnection);_define_property(this,"socket",void 0);_define_property(this,"reply",void 0);_define_property(this,"_closed",void 0);this.socket=socket;this.reply=reply;this._closed=false;this.socket.on("close",function(){_this._closed=true})}_create_class(SSEConnection,[{key:"publish",value:function publish(event,data){if(this._closed){return}this.reply.sse({event:event,data:JSON.stringify(data)})}},{key:"end",value:function end(){return _async_to_generator(function(){return _ts_generator(this,function(_state){switch(_state.label){case 0:if(this._closed){return[2]}this.reply.sse({event:"end",data:"END"});return[4,new Promise(function(resolve){return setTimeout(resolve,200)})];case 1:_state.sent();this.reply.raw.end();return[2]}})}).call(this)}}]);return SSEConnection}();
-//# sourceMappingURL=sse.js.map
+// NOTE(Haze, 251106): context provider에서 인자를 채워주면 createSSE(events)만으로 사용 가능
+export function createSSEFactory(socket, reply, _events) {
+    return new SSEConnection(socket, reply);
+}
+class SSEConnection {
+    socket;
+    reply;
+    _closed = false;
+    constructor(socket, reply){
+        this.socket = socket;
+        this.reply = reply;
+        this.socket.on("close", ()=>{
+            this._closed = true;
+        });
+    }
+    publish(event, data) {
+        if (this._closed) {
+            return;
+        }
+        this.reply.sse({
+            event: event,
+            data: JSON.stringify(data)
+        });
+    }
+    async end() {
+        if (this._closed) {
+            return;
+        }
+        this.reply.sse({
+            event: "end",
+            data: "END"
+        });
+        await new Promise((resolve)=>setTimeout(resolve, 200));
+        this.reply.raw.end();
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdHJlYW0vc3NlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHogfSBmcm9tIFwiem9kXCI7XG5pbXBvcnQgdHlwZSB7IEZhc3RpZnlSZXF1ZXN0LCBGYXN0aWZ5UmVwbHkgfSBmcm9tIFwiZmFzdGlmeVwiO1xuXG4vLyBOT1RFKEhhemUsIDI1MTEwNik6IGNvbnRleHQgcHJvdmlkZXLsl5DshJwg7J247J6Q66W8IOyxhOybjOyjvOuptCBjcmVhdGVTU0UoZXZlbnRzKeunjOycvOuhnCDsgqzsmqkg6rCA64qlXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlU1NFRmFjdG9yeTxUIGV4dGVuZHMgei5ab2RPYmplY3Q+KFxuICBzb2NrZXQ6IEZhc3RpZnlSZXF1ZXN0W1wic29ja2V0XCJdLFxuICByZXBseTogRmFzdGlmeVJlcGx5LFxuICBfZXZlbnRzOiBUXG4pIHtcbiAgcmV0dXJuIG5ldyBTU0VDb25uZWN0aW9uPFQ+KHNvY2tldCwgcmVwbHkpO1xufVxuXG5jbGFzcyBTU0VDb25uZWN0aW9uPFQgZXh0ZW5kcyB6LlpvZE9iamVjdD4ge1xuICBwcml2YXRlIF9jbG9zZWQgPSBmYWxzZTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIHJlYWRvbmx5IHNvY2tldDogRmFzdGlmeVJlcXVlc3RbXCJzb2NrZXRcIl0sXG4gICAgcHJpdmF0ZSByZWFkb25seSByZXBseTogRmFzdGlmeVJlcGx5XG4gICkge1xuICAgIHRoaXMuc29ja2V0Lm9uKFwiY2xvc2VcIiwgKCkgPT4ge1xuICAgICAgdGhpcy5fY2xvc2VkID0gdHJ1ZTtcbiAgICB9KTtcbiAgfVxuXG4gIHB1Ymxpc2g8SyBleHRlbmRzIGtleW9mIHouaW5mZXI8VD4+KGV2ZW50OiBLLCBkYXRhOiB6LmluZmVyPFQ+W0tdKTogdm9pZCB7XG4gICAgaWYgKHRoaXMuX2Nsb3NlZCkge1xuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICAgIHRoaXMucmVwbHkuc3NlKHtcbiAgICAgIGV2ZW50OiBldmVudCBhcyBzdHJpbmcsXG4gICAgICBkYXRhOiBKU09OLnN0cmluZ2lmeShkYXRhKSxcbiAgICB9KTtcbiAgfVxuXG4gIGFzeW5jIGVuZCgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBpZiAodGhpcy5fY2xvc2VkKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgdGhpcy5yZXBseS5zc2Uoe1xuICAgICAgZXZlbnQ6IFwiZW5kXCIsXG4gICAgICBkYXRhOiBcIkVORFwiLFxuICAgIH0pO1xuICAgIFxuICAgIGF3YWl0IG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiBzZXRUaW1lb3V0KHJlc29sdmUsIDIwMCkpO1xuICAgIHRoaXMucmVwbHkucmF3LmVuZCgpO1xuICB9XG59XG4iXSwibmFtZXMiOlsiY3JlYXRlU1NFRmFjdG9yeSIsInNvY2tldCIsInJlcGx5IiwiX2V2ZW50cyIsIlNTRUNvbm5lY3Rpb24iLCJfY2xvc2VkIiwib24iLCJwdWJsaXNoIiwiZXZlbnQiLCJkYXRhIiwic3NlIiwiSlNPTiIsInN0cmluZ2lmeSIsImVuZCIsIlByb21pc2UiLCJyZXNvbHZlIiwic2V0VGltZW91dCIsInJhdyJdLCJtYXBwaW5ncyI6IkFBR0EsNkVBQTZFO0FBQzdFLE9BQU8sU0FBU0EsaUJBQ2RDLE1BQWdDLEVBQ2hDQyxLQUFtQixFQUNuQkMsT0FBVTtJQUVWLE9BQU8sSUFBSUMsY0FBaUJILFFBQVFDO0FBQ3RDO0FBRUEsTUFBTUU7OztJQUNJQyxVQUFVLE1BQU07SUFFeEIsWUFDRSxBQUFpQkosTUFBZ0MsRUFDakQsQUFBaUJDLEtBQW1CLENBQ3BDO2FBRmlCRCxTQUFBQTthQUNBQyxRQUFBQTtRQUVqQixJQUFJLENBQUNELE1BQU0sQ0FBQ0ssRUFBRSxDQUFDLFNBQVM7WUFDdEIsSUFBSSxDQUFDRCxPQUFPLEdBQUc7UUFDakI7SUFDRjtJQUVBRSxRQUFvQ0MsS0FBUSxFQUFFQyxJQUFtQixFQUFRO1FBQ3ZFLElBQUksSUFBSSxDQUFDSixPQUFPLEVBQUU7WUFDaEI7UUFDRjtRQUVBLElBQUksQ0FBQ0gsS0FBSyxDQUFDUSxHQUFHLENBQUM7WUFDYkYsT0FBT0E7WUFDUEMsTUFBTUUsS0FBS0MsU0FBUyxDQUFDSDtRQUN2QjtJQUNGO0lBRUEsTUFBTUksTUFBcUI7UUFDekIsSUFBSSxJQUFJLENBQUNSLE9BQU8sRUFBRTtZQUNoQjtRQUNGO1FBRUEsSUFBSSxDQUFDSCxLQUFLLENBQUNRLEdBQUcsQ0FBQztZQUNiRixPQUFPO1lBQ1BDLE1BQU07UUFDUjtRQUVBLE1BQU0sSUFBSUssUUFBUSxDQUFDQyxVQUFZQyxXQUFXRCxTQUFTO1FBQ25ELElBQUksQ0FBQ2IsS0FBSyxDQUFDZSxHQUFHLENBQUNKLEdBQUc7SUFDcEI7QUFDRiJ9

package/dist/syncer/api-parser.d.ts

@@ -0,0 +1,20 @@
+import { ApiParam, ApiParamType } from "../types/types";
+import { AbsolutePath } from "../utils/path-utils";
+/**
+ * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
+ * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
+ * @param filePath - 파싱할 TypeScript 파일의 절대 경로
+ * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
+ */
+export declare function readApisFromFile(filePath: AbsolutePath): Promise<{
+    typeParameters: ApiParamType.TypeParam[];
+    parameters: ApiParam[];
+    returnType: ApiParamType;
+    modelName: string;
+    methodName: string;
+    path: string;
+    options: import("..").ApiDecoratorOptions;
+    streamOptions?: import("..").StreamDecoratorOptions;
+    uploadOptions?: import("..").UploadDecoratorOptions;
+}[]>;
+//# sourceMappingURL=api-parser.d.ts.map

package/dist/syncer/api-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-parser.d.ts","sourceRoot":"","sources":["../../src/syncer/api-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAOxD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,YAAY;;;;;;;;;;KA4G5D"}

package/dist/syncer/api-parser.js

@@ -0,0 +1,229 @@
+import { readFile } from "node:fs/promises";
+import ts from "typescript";
+import { registeredApis } from "../api/decorators.js";
+import inflection from "inflection";
+import assert from "assert";
+/**
+ * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.
+ * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.
+ * @param filePath - 파싱할 TypeScript 파일의 절대 경로
+ * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)
+ */ export async function readApisFromFile(filePath) {
+    if (!filePath.endsWith(".ts")) {
+        throw new Error(`${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`);
+    }
+    const sourceFile = ts.createSourceFile(filePath, (await readFile(filePath)).toString(), ts.ScriptTarget.Latest);
+    const methods = [];
+    let modelName = "UnknownModel";
+    let methodName = "unknownMethod";
+    const visitor = (node)=>{
+        if (ts.isClassDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                modelName = node.name.escapedText.toString().replace(/Class$/, "");
+            }
+        }
+        if (ts.isMethodDeclaration(node)) {
+            if (ts.isIdentifier(node.name)) {
+                methodName = node.name.escapedText.toString();
+            }
+            const typeParameters = (node.typeParameters ?? []).map((typeParam)=>{
+                const tp = typeParam;
+                return {
+                    t: "type-param",
+                    id: tp.name.escapedText.toString(),
+                    constraint: tp.constraint ? resolveTypeNode(tp.constraint) : undefined
+                };
+            });
+            const parameters = node.parameters.map((paramDec, index)=>{
+                const defaultDef = printNode(paramDec.initializer, sourceFile);
+                // 기본값이 있는 경우 paramDec.type가 undefined로 나옴
+                return resolveParamDec({
+                    name: paramDec.name,
+                    type: paramDec.type,
+                    optional: paramDec.questionToken !== undefined || paramDec.initializer !== undefined,
+                    defaultDef
+                }, index);
+            });
+            if (node.type === undefined) {
+                throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);
+            }
+            const returnType = resolveTypeNode(node.type);
+            methods.push({
+                modelName,
+                methodName,
+                typeParameters,
+                parameters,
+                returnType
+            });
+        }
+        ts.forEachChild(node, visitor);
+    };
+    visitor(sourceFile);
+    if (methods.length === 0) {
+        return [];
+    }
+    // 현재 파일의 등록된 API 필터
+    const currentModelApis = registeredApis.filter((api)=>{
+        return methods.find((method)=>method.modelName === api.modelName && method.methodName === api.methodName);
+    });
+    if (currentModelApis.length === 0) {
+        // const p = path.join(tmpdir(), "sonamu-syncer-error.json");
+        // writeFileSync(p, JSON.stringify(registeredApis, null, 2));
+        // execSync(`open ${p}`);
+        throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);
+    }
+    // 등록된 API에 현재 메소드 타입 정보 확장
+    const extendedApis = currentModelApis.map((api)=>{
+        const foundMethod = methods.find((method)=>method.modelName === api.modelName && method.methodName === api.methodName);
+        return {
+            ...api,
+            typeParameters: foundMethod.typeParameters,
+            parameters: foundMethod.parameters,
+            returnType: foundMethod.returnType
+        };
+    });
+    return extendedApis;
+}
+function resolveTypeNode(typeNode) {
+    switch(typeNode?.kind){
+        case ts.SyntaxKind.AnyKeyword:
+            return "any";
+        case ts.SyntaxKind.UnknownKeyword:
+            return "unknown";
+        case ts.SyntaxKind.StringKeyword:
+            return "string";
+        case ts.SyntaxKind.NumberKeyword:
+            return "number";
+        case ts.SyntaxKind.BooleanKeyword:
+            return "boolean";
+        case ts.SyntaxKind.UndefinedKeyword:
+            return "undefined";
+        case ts.SyntaxKind.NullKeyword:
+            return "null";
+        case ts.SyntaxKind.VoidKeyword:
+            return "void";
+        case ts.SyntaxKind.LiteralType:
+            const literal = typeNode.literal;
+            if (ts.isStringLiteral(literal)) {
+                return {
+                    t: "string-literal",
+                    value: literal.text
+                };
+            } else if (ts.isNumericLiteral(literal)) {
+                return {
+                    t: "numeric-literal",
+                    value: Number(literal.text)
+                };
+            } else {
+                if (literal.kind === ts.SyntaxKind.NullKeyword) {
+                    return "null";
+                } else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {
+                    return "undefined";
+                } else if (literal.kind === ts.SyntaxKind.TrueKeyword) {
+                    return "true";
+                } else if (literal.kind === ts.SyntaxKind.FalseKeyword) {
+                    return "false";
+                }
+                throw new Error("알 수 없는 리터럴");
+            }
+        case ts.SyntaxKind.ArrayType:
+            const arrNode = typeNode;
+            return {
+                t: "array",
+                elementsType: resolveTypeNode(arrNode.elementType)
+            };
+        case ts.SyntaxKind.TypeLiteral:
+            const literalNode = typeNode;
+            return {
+                t: "object",
+                props: literalNode.members.map((member)=>{
+                    if (ts.isIndexSignatureDeclaration(member)) {
+                        assert(member.parameters[0]);
+                        const res = resolveParamDec({
+                            name: member.parameters[0].name,
+                            type: member.parameters[0].type
+                        });
+                        return resolveParamDec({
+                            name: {
+                                escapedText: `[${res.name}${res.optional ? "?" : ""}: ${res.type}]`
+                            },
+                            type: member.type
+                        });
+                    } else {
+                        return resolveParamDec({
+                            name: member.name,
+                            type: member.type,
+                            optional: member.questionToken !== undefined
+                        });
+                    }
+                })
+            };
+        case ts.SyntaxKind.TypeReference:
+            return {
+                t: "ref",
+                id: typeNode.typeName.escapedText.toString(),
+                args: typeNode.typeArguments?.map((typeArg)=>resolveTypeNode(typeArg))
+            };
+        case ts.SyntaxKind.UnionType:
+            return {
+                t: "union",
+                types: typeNode.types.map((type)=>resolveTypeNode(type))
+            };
+        case ts.SyntaxKind.IntersectionType:
+            return {
+                t: "intersection",
+                types: typeNode.types.map((type)=>resolveTypeNode(type))
+            };
+        case ts.SyntaxKind.IndexedAccessType:
+            return {
+                t: "indexed-access",
+                object: resolveTypeNode(typeNode.objectType),
+                index: resolveTypeNode(typeNode.indexType)
+            };
+        case ts.SyntaxKind.TupleType:
+            if (ts.isTupleTypeNode(typeNode)) {
+                return {
+                    t: "tuple-type",
+                    elements: typeNode.elements.map((elem)=>resolveTypeNode(elem))
+                };
+            }
+            break;
+        case undefined:
+            throw new Error(`typeNode undefined`);
+    }
+    console.debug(typeNode);
+    throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);
+}
+function resolveParamDec(paramDec, index = 0) {
+    const name = paramDec.name;
+    const type = resolveTypeNode(paramDec.type);
+    if (name === undefined) {
+        console.debug({
+            name,
+            type,
+            paramDec
+        });
+    }
+    const result = {
+        name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,
+        type,
+        optional: paramDec.optional === true,
+        defaultDef: paramDec?.defaultDef
+    };
+    // 구조분해할당의 경우 타입이름 사용
+    if (ts.isObjectBindingPattern(name) && ts.isTypeReferenceNode(paramDec.type) && ts.isIdentifier(paramDec.type.typeName)) {
+        result.name = inflection.camelize(paramDec.type.typeName.text, true);
+    }
+    return result;
+}
+function printNode(node, sourceFile) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const printer = ts.createPrinter({
+        newLine: ts.NewLineKind.LineFeed
+    });
+    return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/api-parser.ts"],"sourcesContent":["import { ApiParam, ApiParamType } from \"../types/types\";\nimport { readFile } from \"fs/promises\";\nimport * as _ from \"lodash-es\";\nimport ts from \"typescript\";\nimport { ExtendedApi, registeredApis } from \"../api/decorators\";\nimport inflection from \"inflection\";\nimport assert from \"assert\";\nimport { AbsolutePath } from \"../utils/path-utils\";\n\n/**\n * TypeScript 파일을 파싱하여 API 메소드 정보를 추출합니다.\n * @api 데코레이터가 붙은 메소드들의 타입 정보를 분석합니다.\n * @param filePath - 파싱할 TypeScript 파일의 절대 경로\n * @returns API 메소드 정보 배열 (타입 파라미터, 파라미터, 리턴 타입 등)\n */\nexport async function readApisFromFile(filePath: AbsolutePath) {\n  if (!filePath.endsWith(\".ts\")) { \n    throw new Error(`${filePath} does not seem to be a TypeScript file. Please check the file path. We only support parsing TypeScript files.`);\n  }\n  \n  const sourceFile = ts.createSourceFile(\n    filePath,\n    (await readFile(filePath)).toString(),\n    ts.ScriptTarget.Latest\n  );\n\n  const methods: Omit<ExtendedApi, \"path\" | \"options\">[] = [];\n  let modelName: string = \"UnknownModel\";\n  let methodName: string = \"unknownMethod\";\n  const visitor = (node: ts.Node) => {\n    if (ts.isClassDeclaration(node)) {\n      if (node.name && ts.isIdentifier(node.name)) {\n        modelName = node.name.escapedText.toString().replace(/Class$/, \"\");\n      }\n    }\n    if (ts.isMethodDeclaration(node)) {\n      if (ts.isIdentifier(node.name)) {\n        methodName = node.name.escapedText.toString();\n      }\n\n      const typeParameters: ApiParamType.TypeParam[] = (\n        node.typeParameters ?? []\n      ).map((typeParam) => {\n        const tp = typeParam as ts.TypeParameterDeclaration;\n\n        return {\n          t: \"type-param\",\n          id: tp.name.escapedText.toString(),\n          constraint: tp.constraint\n            ? resolveTypeNode(tp.constraint)\n            : undefined,\n        };\n      });\n      const parameters: ApiParam[] = node.parameters.map((paramDec, index) => {\n        const defaultDef = printNode(paramDec.initializer, sourceFile);\n\n        // 기본값이 있는 경우 paramDec.type가 undefined로 나옴\n\n        return resolveParamDec(\n          {\n            name: paramDec.name,\n            type: paramDec.type as ts.TypeNode,\n            optional:\n              paramDec.questionToken !== undefined ||\n              paramDec.initializer !== undefined,\n            defaultDef,\n          },\n          index\n        );\n      });\n      if (node.type === undefined) {\n        throw new Error(\n          `리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`\n        );\n      }\n      const returnType = resolveTypeNode(node.type!);\n\n      methods.push({\n        modelName,\n        methodName,\n        typeParameters,\n        parameters,\n        returnType,\n      });\n    }\n    ts.forEachChild(node, visitor);\n  };\n  visitor(sourceFile);\n\n  if (methods.length === 0) {\n    return [];\n  }\n\n  // 현재 파일의 등록된 API 필터\n  const currentModelApis = registeredApis.filter((api) => {\n    return methods.find(\n      (method) =>\n        method.modelName === api.modelName &&\n        method.methodName === api.methodName\n    );\n  });\n  if (currentModelApis.length === 0) {\n    // const p = path.join(tmpdir(), \"sonamu-syncer-error.json\");\n    // writeFileSync(p, JSON.stringify(registeredApis, null, 2));\n    // execSync(`open ${p}`);\n    throw new Error(`현재 파일에 사전 등록된 API가 없습니다. ${filePath}`);\n  }\n\n  // 등록된 API에 현재 메소드 타입 정보 확장\n  const extendedApis = currentModelApis.map((api) => {\n    const foundMethod = methods.find(\n      (method) =>\n        method.modelName === api.modelName &&\n        method.methodName === api.methodName\n    );\n    return {\n      ...api,\n      typeParameters: foundMethod!.typeParameters,\n      parameters: foundMethod!.parameters,\n      returnType: foundMethod!.returnType,\n    };\n  });\n  return extendedApis;\n}\n\nfunction resolveTypeNode(typeNode: ts.TypeNode): ApiParamType {\n  switch (typeNode?.kind) {\n    case ts.SyntaxKind.AnyKeyword:\n      return \"any\";\n    case ts.SyntaxKind.UnknownKeyword:\n      return \"unknown\";\n    case ts.SyntaxKind.StringKeyword:\n      return \"string\";\n    case ts.SyntaxKind.NumberKeyword:\n      return \"number\";\n    case ts.SyntaxKind.BooleanKeyword:\n      return \"boolean\";\n    case ts.SyntaxKind.UndefinedKeyword:\n      return \"undefined\";\n    case ts.SyntaxKind.NullKeyword:\n      return \"null\";\n    case ts.SyntaxKind.VoidKeyword:\n      return \"void\";\n    case ts.SyntaxKind.LiteralType:\n      const literal = (typeNode as ts.LiteralTypeNode).literal;\n      if (ts.isStringLiteral(literal)) {\n        return {\n          t: \"string-literal\",\n          value: literal.text,\n        };\n      } else if (ts.isNumericLiteral(literal)) {\n        return {\n          t: \"numeric-literal\",\n          value: Number(literal.text),\n        };\n      } else {\n        if (literal.kind === ts.SyntaxKind.NullKeyword) {\n          return \"null\";\n        } else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {\n          return \"undefined\";\n        } else if (literal.kind === ts.SyntaxKind.TrueKeyword) {\n          return \"true\";\n        } else if (literal.kind === ts.SyntaxKind.FalseKeyword) {\n          return \"false\";\n        }\n        throw new Error(\"알 수 없는 리터럴\");\n      }\n    case ts.SyntaxKind.ArrayType:\n      const arrNode = typeNode as ts.ArrayTypeNode;\n      return {\n        t: \"array\",\n        elementsType: resolveTypeNode(arrNode.elementType),\n      };\n    case ts.SyntaxKind.TypeLiteral:\n      const literalNode = typeNode as ts.TypeLiteralNode;\n      return {\n        t: \"object\",\n        props: literalNode.members.map((member) => {\n          if (ts.isIndexSignatureDeclaration(member)) {\n            assert(member.parameters[0]);\n            const res = resolveParamDec({\n              name: member.parameters[0].name as ts.Identifier,\n              type: member.parameters[0].type as ts.TypeNode,\n            });\n\n            return resolveParamDec({\n              name: {\n                escapedText: `[${res.name}${res.optional ? \"?\" : \"\"}: ${\n                  res.type\n                }]`,\n              } as ts.Identifier,\n              type: member.type as ts.TypeNode,\n            });\n          } else {\n            return resolveParamDec({\n              name: (member as ts.PropertySignature).name as ts.Identifier,\n              type: (member as ts.PropertySignature).type as ts.TypeNode,\n              optional:\n                (member as ts.PropertySignature).questionToken !== undefined,\n            });\n          }\n        }),\n      };\n    case ts.SyntaxKind.TypeReference:\n      return {\n        t: \"ref\",\n        id: (\n          (typeNode as ts.TypeReferenceNode).typeName as ts.Identifier\n        ).escapedText.toString(),\n        args: (typeNode as ts.TypeReferenceNode).typeArguments?.map((typeArg) =>\n          resolveTypeNode(typeArg)\n        ),\n      };\n    case ts.SyntaxKind.UnionType:\n      return {\n        t: \"union\",\n        types: (typeNode as ts.UnionTypeNode).types.map((type) =>\n          resolveTypeNode(type)\n        ),\n      };\n    case ts.SyntaxKind.IntersectionType:\n      return {\n        t: \"intersection\",\n        types: (typeNode as ts.IntersectionTypeNode).types.map((type) =>\n          resolveTypeNode(type)\n        ),\n      };\n    case ts.SyntaxKind.IndexedAccessType:\n      return {\n        t: \"indexed-access\",\n        object: resolveTypeNode(\n          (typeNode as ts.IndexedAccessTypeNode).objectType\n        ),\n        index: resolveTypeNode(\n          (typeNode as ts.IndexedAccessTypeNode).indexType\n        ),\n      };\n    case ts.SyntaxKind.TupleType:\n      if (ts.isTupleTypeNode(typeNode)) {\n        return {\n          t: \"tuple-type\",\n          elements: typeNode.elements.map((elem) => resolveTypeNode(elem)),\n        };\n      }\n      break;\n    case undefined:\n      throw new Error(`typeNode undefined`);\n  }\n\n  console.debug(typeNode);\n  throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);\n}\n\nfunction resolveParamDec(\n  paramDec: {\n    name: ts.BindingName;\n    type: ts.TypeNode;\n    optional?: boolean;\n    defaultDef?: string;\n  },\n  index: number = 0\n): ApiParam {\n  const name = paramDec.name as ts.Identifier;\n  const type = resolveTypeNode(paramDec.type);\n\n  if (name === undefined) {\n    console.debug({ name, type, paramDec });\n  }\n\n  const result: ApiParam = {\n    name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,\n    type,\n    optional: paramDec.optional === true,\n    defaultDef: paramDec?.defaultDef,\n  };\n\n  // 구조분해할당의 경우 타입이름 사용\n  if (\n    ts.isObjectBindingPattern(name) &&\n    ts.isTypeReferenceNode(paramDec.type) &&\n    ts.isIdentifier(paramDec.type.typeName)\n  ) {\n    result.name = inflection.camelize(paramDec.type.typeName.text, true);\n  }\n\n  return result;\n}\n\nfunction printNode(\n  node: ts.Node | undefined,\n  sourceFile: ts.SourceFile\n): string | undefined {\n  if (node === undefined) {\n    return undefined;\n  }\n\n  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });\n  return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);\n}\n"],"names":["readFile","ts","registeredApis","inflection","assert","readApisFromFile","filePath","endsWith","Error","sourceFile","createSourceFile","toString","ScriptTarget","Latest","methods","modelName","methodName","visitor","node","isClassDeclaration","name","isIdentifier","escapedText","replace","isMethodDeclaration","typeParameters","map","typeParam","tp","t","id","constraint","resolveTypeNode","undefined","parameters","paramDec","index","defaultDef","printNode","initializer","resolveParamDec","type","optional","questionToken","returnType","push","forEachChild","length","currentModelApis","filter","api","find","method","extendedApis","foundMethod","typeNode","kind","SyntaxKind","AnyKeyword","UnknownKeyword","StringKeyword","NumberKeyword","BooleanKeyword","UndefinedKeyword","NullKeyword","VoidKeyword","LiteralType","literal","isStringLiteral","value","text","isNumericLiteral","Number","TrueKeyword","FalseKeyword","ArrayType","arrNode","elementsType","elementType","TypeLiteral","literalNode","props","members","member","isIndexSignatureDeclaration","res","TypeReference","typeName","args","typeArguments","typeArg","UnionType","types","IntersectionType","IndexedAccessType","object","objectType","indexType","TupleType","isTupleTypeNode","elements","elem","console","debug","result","isObjectBindingPattern","isTypeReferenceNode","camelize","printer","createPrinter","newLine","NewLineKind","LineFeed","EmitHint","Unspecified"],"mappings":"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"}

package/dist/syncer/checksum.d.ts

@@ -0,0 +1,21 @@
+import { PathLike } from "fs";
+import { AbsolutePath } from "../utils/path-utils";
+/**
+ * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.
+ * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: "/src/application/user/user.model.ts"
+ */
+export declare function findChangedFilesUsingChecksums(): Promise<AbsolutePath[]>;
+/**
+ * 체크섬을 갱신합니다.
+ * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.
+ */
+export declare function renewChecksums(): Promise<void>;
+/**
+ * 두 파일의 내용이 같은지 체크섬으로 비교합니다.
+ * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.
+ * @param one 파일 경로
+ * @param two 파일 경로
+ * @returns boolean
+ */
+export declare function areFilesSame(one: PathLike, two: PathLike): Promise<boolean>;
+//# sourceMappingURL=checksum.d.ts.map

package/dist/syncer/checksum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksum.d.ts","sourceRoot":"","sources":["../../src/syncer/checksum.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoB,QAAQ,EAAE,MAAM,IAAI,CAAC;AAQhD,OAAO,EACL,YAAY,EAEb,MAAM,qBAAqB,CAAC;AAQ7B;;;GAGG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAC7D,YAAY,EAAE,CACf,CAYA;AAED;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAUpD;AAED;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,QAAQ,EACb,GAAG,EAAE,QAAQ,GACZ,OAAO,CAAC,OAAO,CAAC,CASlB"}

package/dist/syncer/checksum.js

@@ -0,0 +1,98 @@
+import path from "path";
+import { globAsync } from "../utils/async-utils.js";
+import { createReadStream } from "fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { exists } from "../utils/fs-utils.js";
+import crypto from "crypto";
+import equal from "fast-deep-equal";
+import * as _ from "lodash-es";
+import { Sonamu } from "../api/sonamu.js";
+import { getChecksumPatternGroupInAbsolutePath } from "./file-patterns.js";
+/**
+ * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.
+ * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: "/src/application/user/user.model.ts"
+ */ export async function findChangedFilesUsingChecksums() {
+    const calculatedChecksums = await getCurrentChecksums();
+    const savedChecksums = await getPreviousChecksums();
+    const isSame = equal(calculatedChecksums, savedChecksums);
+    if (isSame) {
+        return [];
+    }
+    const diff = _.differenceWith(calculatedChecksums, savedChecksums, _.isEqual);
+    return diff.map((r)=>r.path);
+}
+/**
+ * 체크섬을 갱신합니다.
+ * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.
+ */ export async function renewChecksums() {
+    const calculatedChecksums = await getCurrentChecksums();
+    const savedChecksums = await getPreviousChecksums();
+    const isSame = equal(calculatedChecksums, savedChecksums);
+    if (isSame) {
+        return;
+    }
+    await saveChecksums(calculatedChecksums);
+}
+/**
+ * 두 파일의 내용이 같은지 체크섬으로 비교합니다.
+ * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.
+ * @param one 파일 경로
+ * @param two 파일 경로
+ * @returns boolean
+ */ export async function areFilesSame(one, two) {
+    if (!await exists(one) || !await exists(two)) {
+        return false;
+    }
+    const oneChecksum = await getChecksumOfFile(one);
+    const twoChecksum = await getChecksumOfFile(two);
+    return oneChecksum === twoChecksum;
+}
+async function getCurrentChecksums() {
+    const filePaths = (await Promise.all(Object.entries(getChecksumPatternGroupInAbsolutePath()).map(async ([_fileType, pattern])=>{
+        return globAsync(pattern);
+    }))).flat().sort();
+    const fileChecksums = await Promise.all(filePaths.map(async (filePath)=>{
+        return {
+            path: filePath,
+            checksum: await getChecksumOfFile(filePath)
+        };
+    }));
+    return fileChecksums;
+}
+async function getPreviousChecksums() {
+    const checksumFilePath = getChecksumFilePath();
+    if (!await exists(checksumFilePath)) {
+        return [];
+    }
+    const previousChecksums = JSON.parse(await readFile(checksumFilePath, "utf-8")).map((r)=>({
+            path: path.join(Sonamu.apiRootPath, r.path),
+            checksum: r.checksum
+        }));
+    return previousChecksums;
+}
+function getChecksumFilePath() {
+    return path.join(Sonamu.apiRootPath, "sonamu.lock");
+}
+async function saveChecksums(checksums) {
+    const checksumFilePath = getChecksumFilePath();
+    await writeFile(checksumFilePath, JSON.stringify(checksums.map((r)=>({
+            path: path.relative(Sonamu.apiRootPath, r.path),
+            checksum: r.checksum
+        })), null, 2), "utf-8");
+    console.log("checksum saved", checksumFilePath);
+}
+async function getChecksumOfFile(filePath) {
+    return new Promise((resolve, reject)=>{
+        const hash = crypto.createHash("sha1");
+        const input = createReadStream(filePath);
+        input.on("error", reject);
+        input.on("data", function(chunk) {
+            hash.update(chunk);
+        });
+        input.on("close", function() {
+            resolve(hash.digest("hex"));
+        });
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/syncer/checksum.ts"],"sourcesContent":["import path from \"path\";\nimport { globAsync } from \"../utils/async-utils\";\nimport { createReadStream, PathLike } from \"fs\";\nimport { readFile, writeFile } from \"fs/promises\";\nimport { exists } from \"../utils/fs-utils\";\n\nimport crypto from \"crypto\";\nimport equal from \"fast-deep-equal\";\nimport * as _ from \"lodash-es\";\nimport { Sonamu } from \"../api/sonamu\";\nimport {\n  AbsolutePath,\n  ApiRelativePath,\n} from \"../utils/path-utils\";\nimport { getChecksumPatternGroupInAbsolutePath } from \"./file-patterns\";\n\ntype PathAndChecksum = {\n  path: AbsolutePath;\n  checksum: string;\n};\n\n/**\n * 체크섬 파일에 저장된 내용과 현재 실제 파일의 체크섬을 비교하여 변경된 파일을 찾습니다.\n * @returns 변경된 파일 경로 배열. 프로젝트 루트부터 슬래시로 시작합니다. 예시: \"/src/application/user/user.model.ts\"\n */\nexport async function findChangedFilesUsingChecksums(): Promise<\n  AbsolutePath[]\n> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return [];\n  }\n\n  const diff = _.differenceWith(calculatedChecksums, savedChecksums, _.isEqual);\n\n  return diff.map((r) => r.path);\n}\n\n/**\n * 체크섬을 갱신합니다.\n * 현재 파일들의 체크섬을 계산해서 구한 다음, 체크섬 파일에 저장된 내용과 다르면 체크섬 파일을 갱신합니다.\n */\nexport async function renewChecksums(): Promise<void> {\n  const calculatedChecksums = await getCurrentChecksums();\n  const savedChecksums = await getPreviousChecksums();\n\n  const isSame = equal(calculatedChecksums, savedChecksums);\n  if (isSame) {\n    return;\n  }\n\n  await saveChecksums(calculatedChecksums);\n}\n\n/**\n * 두 파일의 내용이 같은지 체크섬으로 비교합니다.\n * 만약 파일이 둘 중 하나라도 없다면 비교 불가로 false 반환합니다.\n * @param one 파일 경로\n * @param two 파일 경로\n * @returns boolean\n */\nexport async function areFilesSame(\n  one: PathLike,\n  two: PathLike\n): Promise<boolean> {\n  if (!(await exists(one)) || !(await exists(two))) {\n    return false;\n  }\n\n  const oneChecksum = await getChecksumOfFile(one);\n  const twoChecksum = await getChecksumOfFile(two);\n\n  return oneChecksum === twoChecksum;\n}\n\nasync function getCurrentChecksums(): Promise<PathAndChecksum[]> {\n  const filePaths = (\n    await Promise.all(\n      Object.entries(getChecksumPatternGroupInAbsolutePath()).map(\n        async ([_fileType, pattern]) => {\n          return globAsync(pattern) as Promise<AbsolutePath[]>;\n        }\n      )\n    )\n  )\n    .flat()\n    .sort();\n\n  const fileChecksums = await Promise.all(\n    filePaths.map(async (filePath) => {\n      return {\n        path: filePath,\n        checksum: await getChecksumOfFile(filePath),\n      };\n    })\n  );\n\n  return fileChecksums;\n}\n\nasync function getPreviousChecksums(): Promise<PathAndChecksum[]> {\n  const checksumFilePath = getChecksumFilePath();\n  if (!(await exists(checksumFilePath))) {\n    return [];\n  }\n\n  const previousChecksums = JSON.parse(\n    await readFile(checksumFilePath, \"utf-8\")\n  ).map((r: { path: ApiRelativePath; checksum: string }) => ({\n    path: path.join(Sonamu.apiRootPath, r.path), // 체크섬 파일에서 읽을 때: API 상대 경로 → 절대 경로\n    checksum: r.checksum,\n  })) as PathAndChecksum[];\n  return previousChecksums;\n}\n\nfunction getChecksumFilePath(): AbsolutePath {\n  return path.join(Sonamu.apiRootPath, \"sonamu.lock\") as AbsolutePath;\n}\n\nasync function saveChecksums(checksums: PathAndChecksum[]): Promise<void> {\n  const checksumFilePath = getChecksumFilePath();\n  await writeFile(\n    checksumFilePath,\n    JSON.stringify(\n      checksums.map((r) => ({\n        path: path.relative(Sonamu.apiRootPath, r.path), // 체크섬 파일에 저장할 때: 절대 경로 → API 상대 경로\n        checksum: r.checksum,\n      })),\n      null,\n      2\n    ),\n    \"utf-8\"\n  );\n  console.log(\"checksum saved\", checksumFilePath);\n}\n\nasync function getChecksumOfFile(filePath: PathLike): Promise<string> {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"sha1\");\n    const input = createReadStream(filePath);\n    input.on(\"error\", reject);\n    input.on(\"data\", function (chunk: any) {\n      hash.update(chunk);\n    });\n    input.on(\"close\", function () {\n      resolve(hash.digest(\"hex\"));\n    });\n  });\n}\n"],"names":["path","globAsync","createReadStream","readFile","writeFile","exists","crypto","equal","_","Sonamu","getChecksumPatternGroupInAbsolutePath","findChangedFilesUsingChecksums","calculatedChecksums","getCurrentChecksums","savedChecksums","getPreviousChecksums","isSame","diff","differenceWith","isEqual","map","r","renewChecksums","saveChecksums","areFilesSame","one","two","oneChecksum","getChecksumOfFile","twoChecksum","filePaths","Promise","all","Object","entries","_fileType","pattern","flat","sort","fileChecksums","filePath","checksum","checksumFilePath","getChecksumFilePath","previousChecksums","JSON","parse","join","apiRootPath","checksums","stringify","relative","console","log","resolve","reject","hash","createHash","input","on","chunk","update","digest"],"mappings":"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"}

package/dist/syncer/code-generator.d.ts

@@ -0,0 +1,20 @@
+import { GenerateOptions, PathAndCode, TemplateKey, TemplateOptions } from "../types/types";
+import { AbsolutePath } from "../utils/path-utils";
+/**
+ * 템플릿을 렌더링하고 파일로 생성합니다.
+ * overwrite 옵션이 false인 경우, 이미 존재하는 파일은 건너뜁니다.
+ * @param key - 템플릿 키 (예: "entity", "model", "service" 등)
+ * @param templateOptions - 템플릿 렌더링에 필요한 옵션
+ * @param _generateOptions - 생성 옵션 (overwrite 여부)
+ * @returns 생성된 파일 경로 배열
+ */
+export declare function generateTemplate(key: TemplateKey, templateOptions: any, _generateOptions?: GenerateOptions): Promise<AbsolutePath[]>;
+/**
+ * 템플릿을 렌더링하여 PathAndCode 객체를 반환합니다.
+ * 파일로 쓰지 않고 메모리상에서만 렌더링합니다.
+ * @param key - 템플릿 키
+ * @param options - 템플릿 렌더링 옵션
+ * @returns 경로와 코드 쌍의 배열
+ */
+export declare function renderTemplate<T extends keyof TemplateOptions>(key: T, options: TemplateOptions[T]): Promise<PathAndCode[]>;
+//# sourceMappingURL=code-generator.d.ts.map

package/dist/syncer/code-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-generator.d.ts","sourceRoot":"","sources":["../../src/syncer/code-generator.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,WAAW,EACX,WAAW,EACX,eAAe,EAChB,MAAM,gBAAgB,CAAC;AAWxB,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,WAAW,EAChB,eAAe,EAAE,GAAG,EACpB,gBAAgB,CAAC,EAAE,eAAe,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC,CA2CzB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,CAAC,SAAS,MAAM,eAAe,EAClE,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC,WAAW,EAAE,CAAC,CAkBxB"}