sonamu 0.5.7 → 0.7.0

package/src/typings/knex.d.ts

@@ -1,19 +1,17 @@
-import { Knex } from "knex";
+/** biome-ignore-all lint/correctness/noUnusedImports: d.ts */
+/** biome-ignore-all lint/suspicious/noExplicitAny: d.ts */
+/** biome-ignore-all lint/correctness/noUnusedVariables: d.ts */
+
+import type { Knex } from "knex";
 
 declare module "knex" {
   namespace Knex {
     interface QueryBuilder {
-      onDuplicateUpdate<TRecord extends {}, TResult>(
-        ...columns: string[]
-      ): Knex.QueryBuilder<TRecord, TResult>;
-
-      columnInfo<TRecord>(
-        column?: keyof TRecord
-      ): Promise<Knex.ColumnInfo | ColumnInfosObj>;
+      columnInfo<TRecord>(column?: keyof TRecord): Promise<Knex.ColumnInfo | ColumnInfosObj>;
 
       whereBetween<TRecord, TResult>(
         columnName: string,
-        range: readonly [any, any]
+        range: readonly [any, any],
       ): Knex.QueryBuilder;
     }
 

package/src/utils/async-utils.ts

@@ -1,3 +1,6 @@
+import { glob } from "fs/promises";
+import path from "path";
+
 /**
  * 비동기 조건으로 배열을 필터링합니다
  * @example
@@ -5,12 +8,10 @@
  */
 export async function filterAsync<T>(
   arr: T[],
-  predicate: (item: T, index: number, array: T[]) => Promise<boolean>
+  predicate: (item: T, index: number, array: T[]) => Promise<boolean>,
 ): Promise<T[]> {
   const results = await Promise.all(
-    arr.map((item, index) =>
-      predicate(item, index, arr).then((keep) => ({ item, keep }))
-    )
+    arr.map((item, index) => predicate(item, index, arr).then((keep) => ({ item, keep }))),
   );
   return results.filter((r) => r.keep).map((r) => r.item);
 }
@@ -22,7 +23,7 @@ export async function filterAsync<T>(
  */
 export async function everyAsync<T>(
   arr: T[],
-  predicate: (item: T, index: number, array: T[]) => Promise<boolean>
+  predicate: (item: T, index: number, array: T[]) => Promise<boolean>,
 ): Promise<boolean> {
   for (let i = 0; i < arr.length; i++) {
     if (!(await predicate(arr[i], i, arr))) {
@@ -39,11 +40,9 @@ export async function everyAsync<T>(
  */
 export async function mapAsync<T, U>(
   arr: T[],
-  mapper: (item: T, index: number, array: T[]) => Promise<U>
+  mapper: (item: T, index: number, array: T[]) => Promise<U>,
 ): Promise<U[]> {
-  return Promise.all(
-    arr.map((item, index) => mapper(item, index, arr))
-  );
+  return Promise.all(arr.map((item, index) => mapper(item, index, arr)));
 }
 
 /**
@@ -54,7 +53,7 @@ export async function mapAsync<T, U>(
 export async function reduceAsync<T, U>(
   arr: T[],
   reducer: (accumulator: U, currentValue: T, index: number, array: T[]) => Promise<U>,
-  initialValue: U
+  initialValue: U,
 ): Promise<U> {
   let accumulator = initialValue;
   for (let i = 0; i < arr.length; i++) {
@@ -62,3 +61,17 @@ export async function reduceAsync<T, U>(
   }
   return accumulator;
 }
+
+/**
+ * 비동기 glob 함수입니다.
+ * AsyncIterableIterator로 날아오는 glob의 반환을 받아 끝까지 돌아서 배열로 반환합니다.
+ * @param pathPattern
+ * @returns
+ */
+export async function globAsync(pathPattern: string): Promise<string[]> {
+  const files: string[] = [];
+  for await (const file of glob(path.resolve(pathPattern))) {
+    files.push(file);
+  }
+  return files;
+}

package/src/utils/console-util.ts

@@ -0,0 +1,4 @@
+export function centerText(text: string): string {
+  const margin = (process.stdout.columns - text.length) / 2;
+  return " ".repeat(margin) + text + " ".repeat(margin);
+}

package/src/utils/controller.ts

@@ -22,3 +22,6 @@ export function isProduction(): boolean {
 export function isTest(): boolean {
   return isLocal() && process.env.NODE_ENV === "test";
 }
+export function isHotReloadServer(): boolean {
+  return process.env.HOT === "yes";
+}

package/src/utils/esm-utils.ts

@@ -0,0 +1,59 @@
+import { dirname } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+/**
+ * import.meta.url로부터 __filename 생성
+ *
+ * @example
+ * const __filename = getFilename(import.meta.url);
+ */
+export function getFilename(metaUrl: string): string {
+  return fileURLToPath(metaUrl);
+}
+
+/**
+ * import.meta.url로부터 __dirname 생성
+ *
+ * @example
+ * const __dirname = getDirname(import.meta.url);
+ */
+export function getDirname(metaUrl: string): string {
+  return dirname(fileURLToPath(metaUrl));
+}
+
+/**
+ * 절대 경로를 file:// URL로 변환 (동적 임포트용)
+ *
+ * @param absolutePath - 절대 파일 경로
+ * @returns file:// URL 문자열
+ *
+ * @example
+ * const url = createImportUrl('/path/to/file.js');
+ * await import(url);
+ */
+export function createImportUrl(absolutePath: string): string {
+  const fileUrl = pathToFileURL(absolutePath).href;
+  return fileUrl;
+}
+
+/**
+ * 캐시를 무시하고 새로 임포트(cache busting)하는데, 이때 가져온 모듈의 exported members들을 배열로 가져옵니다.
+ *
+ * 가령 모듈에서 `export const user = { id: number; name: string; }` 이렇게 정의했다면,
+ * 이 함수는 `[{ name: "user", value: { id: number; name: string; } }]` 이렇게 반환합니다.
+ *
+ * @param filePath
+ * @returns { name: string; value: ExportedMemberT }[]
+ */
+export async function importMembers<ExportedMemberT>(
+  filePath: string,
+): Promise<{ name: string; value: ExportedMemberT }[]> {
+  const imported = await import(createImportUrl(filePath));
+
+  const allExportedMembers = Object.entries<ExportedMemberT>(imported).map(([name, value]) => ({
+    name,
+    value,
+  }));
+
+  return allExportedMembers;
+}

package/src/utils/formatter.ts

@@ -0,0 +1,109 @@
+import { Biome } from "@biomejs/js-api/nodejs";
+import { Naite } from "../naite/naite";
+import { isTest } from "./controller";
+
+const biome = new Biome();
+let projectKey: number = -1;
+
+export function setupBiome(path: string) {
+  if (projectKey !== -1) {
+    return;
+  }
+
+  projectKey = biome.openProject(path).projectKey;
+  biome.applyConfiguration(projectKey, {
+    formatter: {
+      enabled: true,
+      formatWithErrors: false,
+      indentStyle: "space",
+      indentWidth: 2,
+      lineEnding: "lf",
+      lineWidth: 100,
+      attributePosition: "auto",
+    },
+    linter: {
+      enabled: true,
+      rules: {
+        recommended: true,
+        style: {
+          useNodejsImportProtocol: "off",
+        },
+        correctness: {
+          useParseIntRadix: "off",
+          noEmptyPattern: "off",
+          noUnusedImports: {
+            level: "warn",
+            fix: "safe",
+          },
+        },
+        a11y: {
+          noLabelWithoutControl: "off",
+        },
+        complexity: {
+          noBannedTypes: "off",
+        },
+        suspicious: {
+          noArrayIndexKey: "off",
+        },
+      },
+    },
+    javascript: {
+      formatter: {
+        jsxQuoteStyle: "double",
+        quoteProperties: "asNeeded",
+        trailingCommas: "all",
+        semicolons: "always",
+        arrowParentheses: "always",
+        bracketSpacing: true,
+        bracketSameLine: false,
+        quoteStyle: "double",
+        attributePosition: "auto",
+      },
+    },
+    json: {
+      formatter: {
+        indentWidth: 2,
+      },
+    },
+    assist: {
+      enabled: true,
+      actions: {
+        source: {
+          organizeImports: "on",
+        },
+      },
+    },
+  });
+}
+
+export function formatCode(code: string, parser: "typescript" | "json", filePath: string) {
+  Naite.t("formatCode", { code, parser });
+
+  if (projectKey === -1) {
+    console.warn("Biome is not setup. Please call setupBiome first.");
+    return code;
+  }
+
+  // 포맷팅을 먼저 해야함
+  const formatted = biome.formatContent(projectKey, code, { filePath });
+  Naite.t("formatCode:formatted", formatted);
+  if (formatted.diagnostics.filter((d) => d.severity === "error").length > 0) {
+    console.error(formatted.diagnostics);
+    throw new Error("Biome format error");
+  }
+
+  // 린팅을 그 다음에
+  const linted = biome.lintContent(projectKey, formatted.content, {
+    filePath,
+    fixFileMode: "safeAndUnsafeFixes",
+  });
+  if (linted.diagnostics.filter((d) => d.severity === "error").length > 0) {
+    Naite.t("formatCode:linted:content", linted.content);
+    Naite.t("formatCode:linted:diagnostics", linted.diagnostics);
+    !isTest() && console.dir(linted.diagnostics, { depth: null });
+    throw new Error("Biome lint error");
+  }
+  Naite.t("formatCode:linted", linted);
+
+  return linted.content;
+}

package/src/utils/fs-utils.ts

@@ -1,4 +1,4 @@
-import { PathLike, constants } from "fs";
+import { constants, type PathLike } from "fs";
 import { access } from "fs/promises";
 
 /**

package/src/utils/lodash-able.ts

@@ -1,7 +1,4 @@
-export function wrapIf(
-  source: string,
-  predicate: (str: string) => [boolean, string]
-): string {
+export function wrapIf(source: string, predicate: (str: string) => [boolean, string]): string {
   const [ok, wrapped] = predicate(source);
   return ok ? wrapped : source;
 }

package/src/utils/object-utils.ts

@@ -0,0 +1,217 @@
+type Primitive = string | number | boolean | null | undefined;
+
+type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | BigInt64Array
+  | BigUint64Array;
+
+type StructuredCloneable = Date | ArrayBuffer | TypedArray;
+
+/** 직렬화 불가 타입 (명시적 제외용) */
+type NonSerializable =
+  | Function
+  | Promise<unknown>
+  | RegExp
+  | symbol
+  // biome-ignore lint/suspicious/noExplicitAny: WeakMap의 제네릭 파라미터
+  | WeakMap<any, any>
+  // biome-ignore lint/suspicious/noExplicitAny: WeakSet의 제네릭 파라미터
+  | WeakSet<any>
+  // biome-ignore lint/suspicious/noExplicitAny: WeakRef의 제네릭 파라미터
+  | WeakRef<any>;
+
+/** 재귀적 직렬화 가능 타입 */
+export type Serializable =
+  | Primitive
+  | StructuredCloneable
+  | SerializableArray
+  | SerializableMap
+  | SerializableSet
+  | SerializableObject;
+
+interface SerializableArray extends Array<Serializable> {}
+
+interface SerializableMap extends Map<Serializable, Serializable> {}
+
+interface SerializableSet extends Set<Serializable> {}
+
+interface SerializableObject {
+  [key: string]: Serializable;
+}
+
+/**
+ * 주어진 타입 T가 직렬화 가능한지 검증하는 조건부 타입
+ * 직렬화 불가한 값이 포함되어 있으면 never를 반환하여 타입 에러가 발생합니다
+ */
+export type AssertSerializable<T> = T extends NonSerializable
+  ? never
+  : T extends Primitive | StructuredCloneable
+    ? T
+    : T extends Map<infer K, infer V>
+      ? Map<AssertSerializable<K>, AssertSerializable<V>>
+      : T extends Set<infer U>
+        ? Set<AssertSerializable<U>>
+        : T extends Array<infer U>
+          ? AssertSerializable<U>[]
+          : T extends object
+            ? { [K in keyof T]: AssertSerializable<T[K]> }
+            : T;
+
+export interface SerializableCheckResult {
+  valid: boolean;
+  reason?: string;
+}
+
+/**
+ * 값이 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: unknown,
+  path: string[] = [],
+  seen: WeakSet<object> = new WeakSet(),
+): SerializableCheckResult {
+  // 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 as object;
+
+    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 as unknown as Record<string, unknown>)[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 as Record<string, unknown>)[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: string[]): string {
+  if (path.length === 0) return "(root)";
+  return path.join(".");
+}

package/src/utils/path-utils.ts

@@ -0,0 +1,99 @@
+import { isHotReloadServer, isTest } from "./controller.js";
+
+/**
+ * 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 function runtimePath(anyPath: string, isDev: boolean = isHotReloadServer() || isTest()): string {
+  if (isDev) {
+    return anyPath.replace(/dist\//, "src/").replace(/\.js/, ".ts");
+  } else {
+    return anyPath.replace(/src\//, "dist/").replace(/\.ts/, ".js");
+  }
+}

package/src/utils/process-utils.ts

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import { setTimeout as setTimeoutPromises } from "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: () => Promise<void>,
+  {
+    whenThisHappens: event,
+    waitForUpTo: delayBeforeShutdown,
+  }: { whenThisHappens: NodeJS.Signals; waitForUpTo: number } = {
+    whenThisHappens: "SIGUSR2",
+    waitForUpTo: 20000,
+  },
+): Promise<void> {
+  let isRunning = true as boolean;
+
+  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);
+}