sonamu 0.10.12 → 0.10.13

package/src/database/db.ts

@@ -5,41 +5,46 @@ import { type Knex } from "knex";
 
 import { type DatabaseConfig, type SonamuConfig } from "../api/config";
 import { getSonamuEnvironment, type EnvironmentSnapshots, type SonamuEnvironment } from "../env";
+import { isObjectValue } from "../utils/runtime-value";
 import { createKnexInstance } from "./knex";
 import { type PuriTransactionWrapper } from "./puri-wrapper";
 import { TransactionContext } from "./transaction-context";
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isPlainObject<Value>(value: Value): value is Value & object {
+  return isObjectValue(value) && !Array.isArray(value);
 }
 
-function mergeRecord(
-  target: Record<string, unknown>,
-  source: Record<string, unknown>,
-): Record<string, unknown> {
-  for (const [key, value] of Object.entries(source)) {
-    const currentValue = target[key];
+function mergeRecord<Target extends object, Source extends object>(
+  target: Target,
+  source: Source,
+): Target {
+  const targetEntries = new Map(Object.entries(target));
 
-    if (isPlainObject(currentValue) && isPlainObject(value)) {
-      target[key] = mergeRecord({ ...currentValue }, value);
-    } else {
-      target[key] = value;
-    }
+  for (const [key, value] of Object.entries(source)) {
+    const currentValue = targetEntries.get(key);
+    const mergedValue =
+      isPlainObject(currentValue) && isPlainObject(value)
+        ? mergeRecord({ ...currentValue }, value)
+        : value;
+    Object.assign(target, { [key]: mergedValue });
   }
 
   return target;
 }
 
-function mergeConfigs<T extends object>(...configs: (Partial<T> | undefined | null)[]): T {
-  const merged: Record<string, unknown> = {};
+function mergeConfigs<T extends object>(
+  baseConfig: T,
+  ...configs: (Partial<T> | undefined | null)[]
+): T {
+  const merged = { ...baseConfig };
 
   for (const config of configs) {
     if (config !== undefined && config !== null) {
-      mergeRecord(merged, config as Record<string, unknown>);
+      mergeRecord(merged, config);
     }
   }
 
-  return merged as T;
+  return merged;
 }
 
 export type SonamuMainDBPreset = "test" | "fixture" | SonamuEnvironment;
@@ -58,6 +63,7 @@ function isConcretePreset(value: DBPreset): value is SonamuDBPreset {
 }
 
 function getReadonlyPreset(environment: SonamuEnvironment): SonamuReadonlyDBPreset {
+  // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
   return `${environment}_readonly` as SonamuReadonlyDBPreset;
 }
 
@@ -135,6 +141,7 @@ function neutralizeEnvironmentConnectionFields(
 }
 
 function assertNoLegacyDatabaseConfig(config: SonamuConfig["database"]): void {
+  // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
   const legacyConfig = config as SonamuConfig["database"] & {
     name?: unknown;
     environments?: unknown;
@@ -243,6 +250,7 @@ export class DBClass {
 
     if (!this.workerDBs.has(workerId)) {
       const baseTestConfig = dbConfig.test;
+      // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
       const connection = baseTestConfig.connection as { database: string };
       const workerDbName = `${connection.database}_${workerId}`;
 
@@ -308,7 +316,7 @@ export class DBClass {
     config: SonamuConfig["database"],
     projectName?: string,
     snapshots?: EnvironmentSnapshots,
-  ): SonamuDBConfig {
+  ) {
     assertNoLegacyDatabaseConfig(config);
 
     const baseName = getProjectDatabaseBaseName(projectName);
@@ -325,6 +333,7 @@ export class DBClass {
       },
       config.defaultOptions,
     );
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     const baseConnection = defaultKnexConfig.connection as Knex.PgConnectionConfig | undefined;
     const environmentFallbackConnection = snapshots
       ? neutralizeEnvironmentConnectionFields(baseConnection)
@@ -354,6 +363,7 @@ export class DBClass {
         connection: connectionFromEnv({
           baseName,
           suffix: environment,
+          // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
           baseConnection: mainConfig(environment).connection as Knex.PgConnectionConfig,
           prefix: "SONAMU_DB_READONLY",
           env: envForPreset(environment),
@@ -380,7 +390,7 @@ export class DBClass {
       staging_readonly: readonlyConfig("staging"),
       production: mainConfig("production"),
       production_readonly: readonlyConfig("production"),
-    };
+    } satisfies SonamuDBConfig;
   }
 
   public testTransaction: Knex.Transaction | null = null;

package/src/database/knex.ts

@@ -1,13 +1,29 @@
 import { type Knex } from "knex";
 import knex from "knex";
 
+import { isObjectValue } from "../utils/runtime-value";
+
+type KnexClientWithConnection = Knex.Client & {
+  connection?: {
+    stream?: {
+      setKeepAlive?: (enable: boolean, initialDelay: number) => void;
+    };
+  };
+};
+
 export function createKnexInstance(config: Knex.Config): Knex {
-  if (config.connection && typeof config.connection === "object") {
-    const conn = config.connection as Record<string, unknown>;
+  if (config.connection && isObjectValue(config.connection)) {
+    const keepAlive = "keepAlive" in config.connection ? config.connection.keepAlive : undefined;
+    const initialDelay =
+      "keepAliveInitialDelayMillis" in config.connection
+        ? config.connection.keepAliveInitialDelayMillis
+        : undefined;
 
-    if (conn.keepAlive === undefined) {
-      conn.keepAlive = true;
-      conn.keepAliveInitialDelayMillis = conn.keepAliveInitialDelayMillis ?? 10000;
+    if (keepAlive === undefined) {
+      Object.assign(config.connection, {
+        keepAlive: true,
+        keepAliveInitialDelayMillis: initialDelay ?? 10000,
+      });
     }
   }
 
@@ -23,22 +39,19 @@ export function createKnexInstance(config: Knex.Config): Knex {
     createTimeoutMillis: 30000,
     ...config.pool,
     // validate/afterCreate는 항상 프레임워크 기본값을 사용한다.
-    validate: (connection: unknown) => {
-      if (typeof connection !== "object" || connection === null) return false;
-      const conn = connection as Record<string, unknown>;
-      if (conn._ending === true || conn._closed === true) return false;
-      return true;
+    validate: <Connection>(connection: Connection) => {
+      if (!isObjectValue(connection)) return false;
+      const isEnding = "_ending" in connection && connection["_ending"] === true;
+      const isClosed = "_closed" in connection && connection["_closed"] === true;
+      return !isEnding && !isClosed;
     },
     afterCreate: ((
-      conn: Knex.Client & Record<string, unknown>,
+      conn: KnexClientWithConnection,
       done: (err: Error | null, conn: Knex.Client) => void,
     ) => {
-      // pg driver: 소켓 레벨 keepAlive 설정
-      const stream = (conn as Record<string, unknown>).connection as
-        | { stream?: { setKeepAlive?: (enable: boolean, initialDelay: number) => void } }
-        | undefined;
-      if (stream?.stream?.setKeepAlive) {
-        stream.stream.setKeepAlive(true, 10000);
+      // pg driver 소켓에 keepAlive를 적용해 유휴 연결 단절을 줄입니다.
+      if (conn.connection?.stream?.setKeepAlive) {
+        conn.connection.stream.setKeepAlive(true, 10000);
       }
 
       done(null, conn);

package/src/database/puri-subset.test-d.ts

@@ -13,6 +13,7 @@ describe("Hydrate", () => {
     type Input = { id: number; name: string };
     type Result = Hydrate<Input>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<Hydrate<Input>>();
   });
@@ -21,6 +22,7 @@ describe("Hydrate", () => {
     type Input = { id: number; user__name: string; user__email: string };
     type Result = Hydrate<Input>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<{
       id: number;
@@ -37,6 +39,7 @@ describe("Hydrate", () => {
     };
     type Result = Hydrate<Input>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<{
       id: number;
@@ -57,6 +60,7 @@ describe("Hydrate", () => {
     };
     type Result = Hydrate<Input>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<{
       id: number;
@@ -69,6 +73,7 @@ describe("Hydrate", () => {
     type Input = {};
     type Result = Hydrate<Input>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<{}>();
   });
@@ -81,6 +86,7 @@ describe("Hydrate", () => {
     };
     type Result = Hydrate<Input>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<{
       id: number;
@@ -97,6 +103,7 @@ describe("Hydrate", () => {
     };
     type Result = Hydrate<Input>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<{
       id: number;
@@ -122,6 +129,7 @@ describe("LoadersResult", () => {
     ];
     type Result = LoadersResult<Loaders>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toHaveProperty("posts");
     expectTypeOf(result).toEqualTypeOf<{ posts: { id: number; title: string }[] }>();
@@ -154,6 +162,7 @@ describe("LoadersResult", () => {
     ];
     type Result = LoadersResult<Loaders>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toHaveProperty("posts");
     expectTypeOf(result).toEqualTypeOf<{
@@ -193,6 +202,7 @@ describe("LoadersResult", () => {
     ];
     type Result = LoadersResult<Loaders>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toEqualTypeOf<{
       items: {
@@ -245,6 +255,7 @@ describe("LoadersResult", () => {
     type Loaders = [ProjectLoader, DepartmentLoader, EmployeeLoader];
     type Result = LoadersResult<Loaders>;
 
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const result = {} as Result;
     expectTypeOf(result).toHaveProperty("projects");
     expectTypeOf(result).toHaveProperty("employees");
@@ -284,6 +295,7 @@ describe("InferAllSubsets", () => {
       // Result
       type Result = InferAllSubsets<SubsetQueries, LoaderQueries>;
 
+      // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
       const result = {} as Result;
       expectTypeOf(result).toHaveProperty("A");
       expectTypeOf(result.A).toEqualTypeOf<{
@@ -331,6 +343,7 @@ describe("InferAllSubsets", () => {
       // Result
       type Result = InferAllSubsets<SubsetQueries, LoaderQueries>;
 
+      // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
       const result = {} as Result;
       expectTypeOf(result).toHaveProperty("A");
       expectTypeOf(result).toEqualTypeOf<{
@@ -382,6 +395,7 @@ describe("InferAllSubsets", () => {
       // Result
       type Result = InferAllSubsets<SubsetQueries, LoaderQueries>;
 
+      // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
       const result = {} as Result;
       expectTypeOf(result).toEqualTypeOf<{
         A: {
@@ -436,6 +450,7 @@ describe("InferAllSubsets", () => {
 
       type Result = InferAllSubsets<SubsetQueries, LoaderQueries>;
 
+      // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
       const result = {} as Result;
       expectTypeOf(result).toEqualTypeOf<{
         A: {
@@ -492,6 +507,7 @@ describe("InferAllSubsets", () => {
       // Result
       type Result = InferAllSubsets<SubsetQueries, LoaderQueries>;
 
+      // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
       const result = {} as Result;
       expectTypeOf(result).toEqualTypeOf<{
         A: { id: number; name: string; email: string; department: { name: string } };
@@ -553,6 +569,7 @@ describe("InferAllSubsets", () => {
       // Result
       type Result = InferAllSubsets<SubsetQueries, LoaderQueries>;
 
+      // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
       const result = {} as Result;
       expectTypeOf(result).toEqualTypeOf<{
         A: {