sonamu 0.5.7 → 0.7.0

package/dist/utils/object-utils.js

@@ -0,0 +1,191 @@
+/**
+ * 값이 Vitest worker/process 간 전달 가능한지 검증합니다.
+ * Serializable하다는 것은 결국 message port와 process.send를 통해 전달 가능한 것을 의미합니다.
+ *
+ * @param value - 검증할 값
+ * @param path - 현재 경로 (에러 메시지용, 내부 재귀에서 사용)
+ * @param seen - 순환 참조 감지용 WeakSet (내부 재귀에서 사용)
+ * @returns 검증 결과 { valid: boolean, reason?: string }
+ *
+ * @example
+ * isSerializable({ a: 1, b: "hello" }) // { valid: true }
+ * isSerializable({ fn: () => {} }) // { valid: false, reason: "Function at fn" }
+ * isSerializable({ deep: { nested: Promise.resolve() } }) // { valid: false, reason: "Promise at deep.nested" }
+ */ export function isSerializable(value, path = [], seen = new WeakSet()) {
+    // typeof null === 'object'이므로 먼저 처리
+    if (value === null) {
+        return {
+            valid: true
+        };
+    }
+    const type = typeof value;
+    if (type === "string" || type === "number" || type === "boolean" || type === "undefined") {
+        return {
+            valid: true
+        };
+    }
+    if (type === "bigint") {
+        return {
+            valid: true
+        };
+    }
+    if (type === "function") {
+        return {
+            valid: false,
+            reason: `Function at ${formatPath(path)}`
+        };
+    }
+    if (type === "symbol") {
+        return {
+            valid: false,
+            reason: `Symbol at ${formatPath(path)}`
+        };
+    }
+    if (type === "object") {
+        const obj = value;
+        if (obj instanceof Promise) {
+            return {
+                valid: false,
+                reason: `Promise at ${formatPath(path)}`
+            };
+        }
+        if (obj instanceof RegExp) {
+            return {
+                valid: false,
+                reason: `RegExp at ${formatPath(path)}`
+            };
+        }
+        if (obj instanceof WeakMap) {
+            return {
+                valid: false,
+                reason: `WeakMap at ${formatPath(path)}`
+            };
+        }
+        if (obj instanceof WeakSet) {
+            return {
+                valid: false,
+                reason: `WeakSet at ${formatPath(path)}`
+            };
+        }
+        if (typeof WeakRef !== "undefined" && obj instanceof WeakRef) {
+            return {
+                valid: false,
+                reason: `WeakRef at ${formatPath(path)}`
+            };
+        }
+        // 순환 참조 허용하되 무한루프 방지
+        if (seen.has(obj)) {
+            return {
+                valid: true
+            };
+        }
+        seen.add(obj);
+        if (obj instanceof Date) {
+            return {
+                valid: true
+            };
+        }
+        if (obj instanceof ArrayBuffer) {
+            return {
+                valid: true
+            };
+        }
+        if (ArrayBuffer.isView(obj)) {
+            return {
+                valid: true
+            };
+        }
+        if (obj instanceof Map) {
+            let i = 0;
+            for (const [k, v] of obj){
+                const keyResult = isSerializable(k, [
+                    ...path,
+                    `Map.key[${i}]`
+                ], seen);
+                if (!keyResult.valid) return keyResult;
+                const valResult = isSerializable(v, [
+                    ...path,
+                    `Map.value[${i}]`
+                ], seen);
+                if (!valResult.valid) return valResult;
+                i++;
+            }
+            return {
+                valid: true
+            };
+        }
+        if (obj instanceof Set) {
+            let i = 0;
+            for (const item of obj){
+                const result = isSerializable(item, [
+                    ...path,
+                    `Set[${i}]`
+                ], seen);
+                if (!result.valid) return result;
+                i++;
+            }
+            return {
+                valid: true
+            };
+        }
+        if (Array.isArray(obj)) {
+            for(let i = 0; i < obj.length; i++){
+                const result = isSerializable(obj[i], [
+                    ...path,
+                    `[${i}]`
+                ], seen);
+                if (!result.valid) return result;
+            }
+            return {
+                valid: true
+            };
+        }
+        // Vitest는 Error를 허용하지만 속성은 직렬화 필요
+        if (obj instanceof Error) {
+            const errorProps = Object.keys(obj).filter((k)=>![
+                    "name",
+                    "message",
+                    "stack"
+                ].includes(k));
+            for (const key of errorProps){
+                const result = isSerializable(obj[key], [
+                    ...path,
+                    key
+                ], seen);
+                if (!result.valid) return result;
+            }
+            return {
+                valid: true
+            };
+        }
+        // Object.prototype 또는 null을 프로토타입으로 가지는 경우만 plain object
+        const proto = Object.getPrototypeOf(obj);
+        if (proto !== Object.prototype && proto !== null) {
+            const constructorName = obj.constructor?.name ?? "Unknown";
+            return {
+                valid: false,
+                reason: `Class instance (${constructorName}) at ${formatPath(path)}`
+            };
+        }
+        for (const key of Object.keys(obj)){
+            const result = isSerializable(obj[key], [
+                ...path,
+                key
+            ], seen);
+            if (!result.valid) return result;
+        }
+        return {
+            valid: true
+        };
+    }
+    return {
+        valid: false,
+        reason: `Unknown type (${type}) at ${formatPath(path)}`
+    };
+}
+function formatPath(path) {
+    if (path.length === 0) return "(root)";
+    return path.join(".");
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utils/object-utils.ts"],"sourcesContent":["type Primitive = string | number | boolean | null | undefined;\n\ntype TypedArray =\n  | Int8Array\n  | Uint8Array\n  | Uint8ClampedArray\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Uint32Array\n  | Float32Array\n  | Float64Array\n  | BigInt64Array\n  | BigUint64Array;\n\ntype StructuredCloneable = Date | ArrayBuffer | TypedArray;\n\n/** 직렬화 불가 타입 (명시적 제외용) */\ntype NonSerializable =\n  | Function\n  | Promise<unknown>\n  | RegExp\n  | symbol\n  // biome-ignore lint/suspicious/noExplicitAny: WeakMap의 제네릭 파라미터\n  | WeakMap<any, any>\n  // biome-ignore lint/suspicious/noExplicitAny: WeakSet의 제네릭 파라미터\n  | WeakSet<any>\n  // biome-ignore lint/suspicious/noExplicitAny: WeakRef의 제네릭 파라미터\n  | WeakRef<any>;\n\n/** 재귀적 직렬화 가능 타입 */\nexport type Serializable =\n  | Primitive\n  | StructuredCloneable\n  | SerializableArray\n  | SerializableMap\n  | SerializableSet\n  | SerializableObject;\n\ninterface SerializableArray extends Array<Serializable> {}\n\ninterface SerializableMap extends Map<Serializable, Serializable> {}\n\ninterface SerializableSet extends Set<Serializable> {}\n\ninterface SerializableObject {\n  [key: string]: Serializable;\n}\n\n/**\n * 주어진 타입 T가 직렬화 가능한지 검증하는 조건부 타입\n * 직렬화 불가한 값이 포함되어 있으면 never를 반환하여 타입 에러가 발생합니다\n */\nexport type AssertSerializable<T> = T extends NonSerializable\n  ? never\n  : T extends Primitive | StructuredCloneable\n    ? T\n    : T extends Map<infer K, infer V>\n      ? Map<AssertSerializable<K>, AssertSerializable<V>>\n      : T extends Set<infer U>\n        ? Set<AssertSerializable<U>>\n        : T extends Array<infer U>\n          ? AssertSerializable<U>[]\n          : T extends object\n            ? { [K in keyof T]: AssertSerializable<T[K]> }\n            : T;\n\nexport interface SerializableCheckResult {\n  valid: boolean;\n  reason?: string;\n}\n\n/**\n * 값이 Vitest worker/process 간 전달 가능한지 검증합니다.\n * Serializable하다는 것은 결국 message port와 process.send를 통해 전달 가능한 것을 의미합니다.\n *\n * @param value - 검증할 값\n * @param path - 현재 경로 (에러 메시지용, 내부 재귀에서 사용)\n * @param seen - 순환 참조 감지용 WeakSet (내부 재귀에서 사용)\n * @returns 검증 결과 { valid: boolean, reason?: string }\n *\n * @example\n * isSerializable({ a: 1, b: \"hello\" }) // { valid: true }\n * isSerializable({ fn: () => {} }) // { valid: false, reason: \"Function at fn\" }\n * isSerializable({ deep: { nested: Promise.resolve() } }) // { valid: false, reason: \"Promise at deep.nested\" }\n */\nexport function isSerializable(\n  value: unknown,\n  path: string[] = [],\n  seen: WeakSet<object> = new WeakSet(),\n): SerializableCheckResult {\n  // typeof null === 'object'이므로 먼저 처리\n  if (value === null) {\n    return { valid: true };\n  }\n\n  const type = typeof value;\n  if (type === \"string\" || type === \"number\" || type === \"boolean\" || type === \"undefined\") {\n    return { valid: true };\n  }\n  if (type === \"bigint\") {\n    return { valid: true };\n  }\n\n  if (type === \"function\") {\n    return { valid: false, reason: `Function at ${formatPath(path)}` };\n  }\n  if (type === \"symbol\") {\n    return { valid: false, reason: `Symbol at ${formatPath(path)}` };\n  }\n\n  if (type === \"object\") {\n    const obj = value as object;\n\n    if (obj instanceof Promise) {\n      return { valid: false, reason: `Promise at ${formatPath(path)}` };\n    }\n\n    if (obj instanceof RegExp) {\n      return { valid: false, reason: `RegExp at ${formatPath(path)}` };\n    }\n\n    if (obj instanceof WeakMap) {\n      return { valid: false, reason: `WeakMap at ${formatPath(path)}` };\n    }\n    if (obj instanceof WeakSet) {\n      return { valid: false, reason: `WeakSet at ${formatPath(path)}` };\n    }\n    if (typeof WeakRef !== \"undefined\" && obj instanceof WeakRef) {\n      return { valid: false, reason: `WeakRef at ${formatPath(path)}` };\n    }\n\n    // 순환 참조 허용하되 무한루프 방지\n    if (seen.has(obj)) {\n      return { valid: true };\n    }\n    seen.add(obj);\n\n    if (obj instanceof Date) {\n      return { valid: true };\n    }\n    if (obj instanceof ArrayBuffer) {\n      return { valid: true };\n    }\n    if (ArrayBuffer.isView(obj)) {\n      return { valid: true };\n    }\n\n    if (obj instanceof Map) {\n      let i = 0;\n      for (const [k, v] of obj) {\n        const keyResult = isSerializable(k, [...path, `Map.key[${i}]`], seen);\n        if (!keyResult.valid) return keyResult;\n\n        const valResult = isSerializable(v, [...path, `Map.value[${i}]`], seen);\n        if (!valResult.valid) return valResult;\n        i++;\n      }\n      return { valid: true };\n    }\n\n    if (obj instanceof Set) {\n      let i = 0;\n      for (const item of obj) {\n        const result = isSerializable(item, [...path, `Set[${i}]`], seen);\n        if (!result.valid) return result;\n        i++;\n      }\n      return { valid: true };\n    }\n\n    if (Array.isArray(obj)) {\n      for (let i = 0; i < obj.length; i++) {\n        const result = isSerializable(obj[i], [...path, `[${i}]`], seen);\n        if (!result.valid) return result;\n      }\n      return { valid: true };\n    }\n\n    // Vitest는 Error를 허용하지만 속성은 직렬화 필요\n    if (obj instanceof Error) {\n      const errorProps = Object.keys(obj).filter((k) => ![\"name\", \"message\", \"stack\"].includes(k));\n      for (const key of errorProps) {\n        const result = isSerializable(\n          (obj as unknown as Record<string, unknown>)[key],\n          [...path, key],\n          seen,\n        );\n        if (!result.valid) return result;\n      }\n      return { valid: true };\n    }\n\n    // Object.prototype 또는 null을 프로토타입으로 가지는 경우만 plain object\n    const proto = Object.getPrototypeOf(obj);\n    if (proto !== Object.prototype && proto !== null) {\n      const constructorName = obj.constructor?.name ?? \"Unknown\";\n      return {\n        valid: false,\n        reason: `Class instance (${constructorName}) at ${formatPath(path)}`,\n      };\n    }\n\n    for (const key of Object.keys(obj)) {\n      const result = isSerializable((obj as Record<string, unknown>)[key], [...path, key], seen);\n      if (!result.valid) return result;\n    }\n    return { valid: true };\n  }\n\n  return { valid: false, reason: `Unknown type (${type}) at ${formatPath(path)}` };\n}\n\nfunction formatPath(path: string[]): string {\n  if (path.length === 0) return \"(root)\";\n  return path.join(\".\");\n}\n"],"names":["isSerializable","value","path","seen","WeakSet","valid","type","reason","formatPath","obj","Promise","RegExp","WeakMap","WeakRef","has","add","Date","ArrayBuffer","isView","Map","i","k","v","keyResult","valResult","Set","item","result","Array","isArray","length","Error","errorProps","Object","keys","filter","includes","key","proto","getPrototypeOf","prototype","constructorName","name","join"],"mappings":"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"}

package/dist/utils/path-utils.d.ts

@@ -0,0 +1,89 @@
+/**
+ * API 패키지 내부 상대 경로 (src/ 또는 dist/로 시작)
+ *
+ * **사용 위치**: API 패키지 내부 파일 참조
+ * **예시**:
+ * - `"src/application/user/user.model.ts"`
+ * - `"dist/application/user/user.model.js"`
+ *
+ * **기준점**: `Sonamu.apiRootPath` (일반적으로 프로젝트의 `/api` 디렉토리)
+ */
+export type ApiRelativePath = `${"src" | "dist"}/${string}` | "sonamu.config.ts";
+/**
+ * 앱 루트 기준 상대 경로 (api/, web/ 등 타겟 디렉토리로 시작)
+ *
+ * **사용 위치**: 다른 타겟(api, web 등)의 파일 참조
+ * **예시**:
+ * - `"api/src/application/user/user.model.ts"`
+ * - `"web/src/pages/admin/users/index.tsx"`
+ * - `"app/dist/index.js"`
+ *
+ * **기준점**: `Sonamu.appRootPath` (일반적으로 모노레포 루트)
+ */
+export type AppRelativePath = `${string}/${"src" | "dist"}/${string}`;
+/**
+ * 시스템 절대 경로 (루트 / 부터 시작)
+ *
+ * **사용 위치**: 파일시스템 직접 접근, glob 패턴
+ * **예시**: `"/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"`
+ *
+ * **중요**:
+ * - import 시에는 로더가 알아서 src/dist 변환해주므로 어느 경로든 가능
+ * - fs 직접 접근 시에는 실제 존재하는 경로를 사용해야 함
+ *   - Dev: src/*.ts 경로 사용
+ *   - Prod: dist/*.js 경로 사용
+ */
+export type AbsolutePath = `/${string}`;
+/**
+ * 어떤 경로가 들어오든, 현재 실행 환경에 맞는 경로로 바꿔줍니다.
+ *
+ * "src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts"
+ * "src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js"
+ * "dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts"
+ * "dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js"
+ *
+ * "/src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "/src/application/user/user.model.ts"
+ * "/src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ * "/dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ * "/dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ *
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"
+ *
+ * "src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts?hot=1234567890"
+ * "src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js?hot=1234567890"
+ * "dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts?hot=1234567890"
+ * "dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js?hot=1234567890"
+ *
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"
+ *
+ * @param anyPath
+ * @returns
+ */
+export declare function runtimePath(anyPath: string, isDev?: boolean): string;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/utils/path-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../../src/utils/path-utils.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,GAAG,KAAK,GAAG,MAAM,IAAI,MAAM,EAAE,GAAG,kBAAkB,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG,GAAG,MAAM,IAAI,KAAK,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC;AAEtE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,MAAM,EAAE,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,OAAyC,GAAG,MAAM,CAMrG"}

package/dist/utils/path-utils.js

@@ -0,0 +1,60 @@
+import { isHotReloadServer, isTest } from "./controller.js";
+/**
+ * 어떤 경로가 들어오든, 현재 실행 환경에 맞는 경로로 바꿔줍니다.
+ *
+ * "src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts"
+ * "src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js"
+ * "dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts"
+ * "dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js"
+ *
+ * "/src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "/src/application/user/user.model.ts"
+ * "/src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ * "/dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ * "/dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "/dist/application/user/user.model.js"
+ *
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js"
+ *
+ * "src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts?hot=1234567890"
+ * "src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js?hot=1234567890"
+ * "dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "src/application/user/user.model.ts?hot=1234567890"
+ * "dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "dist/application/user/user.model.js?hot=1234567890"
+ *
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 개발 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/src/application/user/user.model.ts?hot=1234567890"
+ * "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"가 들어왔을 때 배포 모드라면?
+ * -> "/Users/potados/Projects/sonamu/api/dist/application/user/user.model.js?hot=1234567890"
+ *
+ * @param anyPath
+ * @returns
+ */ export function runtimePath(anyPath, isDev = isHotReloadServer() || isTest()) {
+    if (isDev) {
+        return anyPath.replace(/dist\//, "src/").replace(/\.js/, ".ts");
+    } else {
+        return anyPath.replace(/src\//, "dist/").replace(/\.ts/, ".js");
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/process-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 주어진 작업을 실행합니다.
+ * 주어진 프로세스 이벤트(=시그널)가 발생하였을 때에도 최대 한계(delayBeforeShutdown) 동안 작업을 기다린 후 종료합니다.
+ * @param {() => Promise<void>} job - 실행할 작업
+ * @param {event: NodeJS.Signals; delayBeforeShutdown: number} options - 옵션
+ * @param {NodeJS.Signals} options.event - 프로세스 이벤트
+ * @param {number} options.delayBeforeShutdown - 최대 한계 시간
+ */
+export declare function runWithGracefulShutdown(job: () => Promise<void>, { whenThisHappens: event, waitForUpTo: delayBeforeShutdown, }?: {
+    whenThisHappens: NodeJS.Signals;
+    waitForUpTo: number;
+}): Promise<void>;
+//# sourceMappingURL=process-utils.d.ts.map

package/dist/utils/process-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-utils.d.ts","sourceRoot":"","sources":["../../src/utils/process-utils.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACxB,EACE,eAAe,EAAE,KAAK,EACtB,WAAW,EAAE,mBAAmB,GACjC,GAAE;IAAE,eAAe,EAAE,MAAM,CAAC,OAAO,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAGxD,GACA,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/utils/process-utils.js

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { setTimeout as setTimeoutPromises } from "node:timers/promises";
+/**
+ * 주어진 작업을 실행합니다.
+ * 주어진 프로세스 이벤트(=시그널)가 발생하였을 때에도 최대 한계(delayBeforeShutdown) 동안 작업을 기다린 후 종료합니다.
+ * @param {() => Promise<void>} job - 실행할 작업
+ * @param {event: NodeJS.Signals; delayBeforeShutdown: number} options - 옵션
+ * @param {NodeJS.Signals} options.event - 프로세스 이벤트
+ * @param {number} options.delayBeforeShutdown - 최대 한계 시간
+ */ export async function runWithGracefulShutdown(job, { whenThisHappens: event, waitForUpTo: delayBeforeShutdown } = {
+    whenThisHappens: "SIGUSR2",
+    waitForUpTo: 20000
+}) {
+    let isRunning = true;
+    const abortController = new AbortController();
+    const onEvent = async ()=>{
+        if (!isRunning) {
+            process.exit(0);
+        }
+        console.log(chalk.magentaBright(`wait for syncing done....`));
+        try {
+            await setTimeoutPromises(delayBeforeShutdown, "waiting-sync", {
+                signal: abortController.signal
+            });
+        } catch  {}
+        console.log(chalk.magentaBright(`Syncing DONE!`));
+        process.exit(0);
+    };
+    process.on(event, onEvent);
+    await job();
+    isRunning = false;
+    abortController.abort();
+    process.off(event, onEvent);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/sql-parser.d.ts

@@ -1,4 +1,8 @@
-import { AST, ColumnRef } from "node-sql-parser";
+import type { AST, ColumnRef, Join } from "node-sql-parser";
 export declare function getTableName(expr: ColumnRef): string | null;
 export declare function getTableNamesFromWhere(ast: AST | AST[]): string[];
+/**
+ * 주의: table명이 아닌 alias를 반환함
+ */
+export declare function getJoinTables(ast: AST | AST[], joinTypes: Join["join"][]): string[];
 //# sourceMappingURL=sql-parser.d.ts.map

package/dist/utils/sql-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-parser.d.ts","sourceRoot":"","sources":["../../src/utils/sql-parser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,SAAS,EAAiC,MAAM,iBAAiB,CAAC;AAEhF,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,iBAO3C;AAGD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,MAAM,EAAE,CA0BjE"}
+{"version":3,"file":"sql-parser.d.ts","sourceRoot":"","sources":["../../src/utils/sql-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAA+B,IAAI,EAAU,MAAM,iBAAiB,CAAC;AAIjG,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,iBAO3C;AAGD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,MAAM,EAAE,CA0BjE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,EAAE,CAYnF"}

package/dist/utils/sql-parser.js

@@ -1,2 +1,46 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:Object.getOwnPropertyDescriptor(all,name).get})}_export(exports,{get getTableName(){return getTableName},get getTableNamesFromWhere(){return getTableNamesFromWhere}});var _lodash=/*#__PURE__*/_interop_require_default(require("lodash"));function _array_like_to_array(arr,len){if(len==null||len>arr.length)len=arr.length;for(var i=0,arr2=new Array(len);i<len;i++)arr2[i]=arr[i];return arr2}function _array_without_holes(arr){if(Array.isArray(arr))return _array_like_to_array(arr)}function _interop_require_default(obj){return obj&&obj.__esModule?obj:{default:obj}}function _iterable_to_array(iter){if(typeof Symbol!=="undefined"&&iter[Symbol.iterator]!=null||iter["@@iterator"]!=null)return Array.from(iter)}function _non_iterable_spread(){throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function _to_consumable_array(arr){return _array_without_holes(arr)||_iterable_to_array(arr)||_unsupported_iterable_to_array(arr)||_non_iterable_spread()}function _unsupported_iterable_to_array(o,minLen){if(!o)return;if(typeof o==="string")return _array_like_to_array(o,minLen);var n=Object.prototype.toString.call(o).slice(8,-1);if(n==="Object"&&o.constructor)n=o.constructor.name;if(n==="Map"||n==="Set")return Array.from(n);if(n==="Arguments"||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))return _array_like_to_array(o,minLen)}function getTableName(expr){if("table"in expr&&expr.table!==null){return typeof expr.table==="string"?expr.table:expr.table.value}return null}function getTableNamesFromWhere(ast){var extractTableNames=function(where){if(where===null||!(where.type==="binary_expr"&&"left"in where)){return[]}var extractTableName=function(expr){if(expr.type==="column_ref"){var table=getTableName(expr);return table?[table]:[]}else if(expr.type==="binary_expr"&&"left"in expr){return extractTableNames(expr)}return[]};return _to_consumable_array(extractTableName(where.left)).concat(_to_consumable_array(extractTableName(where.right)))};return _lodash.default.uniq((Array.isArray(ast)?ast:[ast]).flatMap(function(a){return a.type==="select"||a.type==="update"||a.type==="delete"?extractTableNames(a.where):[]}))}
-//# sourceMappingURL=sql-parser.js.map
+import { unique } from "radashi";
+import { nonNullable } from "./utils.js";
+export function getTableName(expr) {
+    if ("table" in expr && expr.table !== null) {
+        return typeof expr.table === "string" ? expr.table : expr.table.value;
+    }
+    return null;
+}
+// where 조건에 사용된 테이블명을 추출
+export function getTableNamesFromWhere(ast) {
+    const extractTableNames = (where)=>{
+        if (where === null || !(where.type === "binary_expr" && "left" in where)) {
+            return [];
+        }
+        const extractTableName = (expr)=>{
+            if (expr.type === "column_ref") {
+                const table = getTableName(expr);
+                return table ? [
+                    table
+                ] : [];
+            } else if (expr.type === "binary_expr" && "left" in expr) {
+                return extractTableNames(expr);
+            }
+            return [];
+        };
+        return [
+            ...extractTableName(where.left),
+            ...extractTableName(where.right)
+        ];
+    };
+    return unique((Array.isArray(ast) ? ast : [
+        ast
+    ]).flatMap((a)=>a.type === "select" || a.type === "update" || a.type === "delete" ? extractTableNames(a.where) : []));
+}
+/**
+ * 주의: table명이 아닌 alias를 반환함
+ */ export function getJoinTables(ast, joinTypes) {
+    const extractJoinTables = (froms)=>{
+        return froms.map((f)=>"join" in f && joinTypes.includes(f.join) ? f.as : null).filter(nonNullable);
+    };
+    return unique((Array.isArray(ast) ? ast : [
+        ast
+    ]).flatMap((a)=>a.type === "select" && Array.isArray(a.from) ? extractJoinTables(a.from) : []));
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/type-utils.d.ts

@@ -0,0 +1,23 @@
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type SetPath<T, P extends string, V> = T extends readonly (infer U)[] ? SetPath<U, P, V>[] : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? Expand<{
+    [Key in keyof T]: Key extends K ? SetPath<T[K], Rest, V> : T[Key];
+}> : Expand<T & {
+    [Key in K]: SetPath<{}, Rest, V>;
+}> : P extends keyof T ? Expand<{
+    [Key in keyof T]: Key extends P ? V : T[Key];
+}> : Expand<T & {
+    [Key in P]: V;
+}>;
+export declare function withProp<T extends object, P extends string, V>(obj: T, path: P, value: V): SetPath<T, P, V>;
+interface ChainWrapper<T> {
+    set<P extends string, V>(path: P, value: V): ChainWrapper<SetPath<T, P, V>>;
+    value(): T;
+}
+/**
+ * 객체를 감싸서 체이닝을 시작합니다.
+ */
+export declare function withProps<T extends object>(obj: T): ChainWrapper<T>;
+export {};
+//# sourceMappingURL=type-utils.d.ts.map

package/dist/utils/type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../../src/utils/type-utils.ts"],"names":[],"mappings":"AACA,KAAK,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,KAAK,CAAC;AAGtE,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,IAAI,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GACjE,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAElB,CAAC,SAAS,GAAG,MAAM,CAAC,IAAI,MAAM,IAAI,EAAE,GAClC,CAAC,SAAS,MAAM,CAAC,GAEf,MAAM,CAAC;KACJ,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,SAAS,CAAC,GAC3B,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,GACtB,CAAC,CAAC,GAAG,CAAC;CACX,CAAC,GAEF,MAAM,CAAC,CAAC,GAAG;KAAG,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;CAAE,CAAC,GAElD,CAAC,SAAS,MAAM,CAAC,GAEf,MAAM,CAAC;KAAG,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;CAAE,CAAC,GAExD,MAAM,CAAC,CAAC,GAAG;KAAG,GAAG,IAAI,CAAC,GAAG,CAAC;CAAE,CAAC,CAAC;AAEtC,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,EAC5D,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,CAAC,GACP,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAiClB;AAED,UAAU,YAAY,CAAC,CAAC;IAEtB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAG5E,KAAK,IAAI,CAAC,CAAC;CACZ;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQnE"}

package/dist/utils/type-utils.js

@@ -0,0 +1,45 @@
+// 타입을 펼쳐서 보여주는 유틸리티 (객체에만 사용해야 함)
+export function withProp(obj, path, value) {
+    const keys = path.split(".");
+    if (keys.length === 0) throw new Error("Path cannot be empty");
+    const result = structuredClone(obj);
+    const setDeep = (current, keys, value)=>{
+        if (keys.length === 0) return;
+        const [key, ...rest] = keys;
+        if (rest.length === 0) {
+            if (Array.isArray(current)) {
+                current.forEach((item)=>{
+                    item[key] = value;
+                });
+            } else {
+                current[key] = value;
+            }
+        } else {
+            if (!(key in current) || typeof current[key] !== "object") {
+                current[key] = {};
+            }
+            if (Array.isArray(current[key])) {
+                current[key].forEach((item)=>{
+                    setDeep(item, rest, value);
+                });
+            } else {
+                setDeep(current[key], rest, value);
+            }
+        }
+    };
+    setDeep(result, keys, value);
+    return result;
+}
+/**
+ * 객체를 감싸서 체이닝을 시작합니다.
+ */ export function withProps(obj) {
+    return {
+        set: (path, value)=>{
+            const nextObj = withProp(obj, path, value);
+            return withProps(nextObj);
+        },
+        value: ()=>obj
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/utils.d.ts

@@ -1,9 +1,12 @@
-export declare function globAsync(pathPattern: string): Promise<string[]>;
-export declare function importMultiple(filePaths: string[], doRefresh?: boolean): Promise<{
-    filePath: string;
-    imported: any;
-}[]>;
-export declare function findAppRootPath(): Promise<string>;
-export declare function findApiRootPath(): string;
+import type { AbsolutePath } from "./path-utils";
+export declare function findAppRootPath(): Promise<AbsolutePath>;
+export declare function findApiRootPath(): AbsolutePath;
 export declare function nonNullable<T>(value: T): value is NonNullable<T>;
+export declare function exhaustive(_param: never): void;
+export declare function assertExists<T>(value: T | null | undefined, message?: string): T;
+export declare function assertNotNull<T>(value: T | null, message?: string): T;
+export declare function assertDefined<T>(value: T | undefined, message?: string): T;
+export declare function chunk<T>(array: T[], size: number): T[][];
+export declare function intersectionBy<T, K>(arr1: readonly T[], arr2: readonly T[], iteratee: (item: T) => K): T[];
+export declare function differenceWith<T>(arr1: readonly T[], arr2: readonly T[], comparator: (a: T, b: T) => boolean): T[];
 //# sourceMappingURL=utils.d.ts.map