sonamu 0.10.12 → 0.10.13

package/src/compress/compress.ts

@@ -10,22 +10,35 @@ export const CompressPresets = {
   /** 기본 설정 (threshold: 1024, br > gzip > deflate) */
   default: {
     threshold: 1024,
-    encodings: ["br", "gzip", "deflate"] as ("br" | "gzip" | "deflate")[],
+    encodings: /* SAFETY: 호출 경계의 선행 검증과 소유 타입 계약이 이 값의 타입을 보장한다. */ [
+      "br",
+      "gzip",
+      "deflate",
+    ] as ("br" | "gzip" | "deflate")[],
   },
   /** 적극적 압축 (threshold: 256) */
   aggressive: {
     threshold: 256,
-    encodings: ["br", "gzip", "deflate"] as ("br" | "gzip" | "deflate")[],
+    encodings: /* SAFETY: 호출 경계의 선행 검증과 소유 타입 계약이 이 값의 타입을 보장한다. */ [
+      "br",
+      "gzip",
+      "deflate",
+    ] as ("br" | "gzip" | "deflate")[],
   },
   /** 보수적 압축 (threshold: 4096, gzip만) */
   conservative: {
     threshold: 4096,
-    encodings: ["gzip", "deflate"] as ("gzip" | "deflate")[],
+    encodings: /* SAFETY: 호출 경계의 선행 검증과 소유 타입 계약이 이 값의 타입을 보장한다. */ [
+      "gzip",
+      "deflate",
+    ] as ("gzip" | "deflate")[],
   },
   /** gzip만 사용 */
   gzipOnly: {
     threshold: 1024,
-    encodings: ["gzip"] as ["gzip"],
+    encodings: /* SAFETY: 호출 경계의 선행 검증과 소유 타입 계약이 이 값의 타입을 보장한다. */ [
+      "gzip",
+    ] as ["gzip"],
   },
 } as const;
 

package/src/cone/cone-generator.ts

@@ -1,7 +1,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+import { type LanguageModel } from "ai";
+
 import { type Cone, type EntityJson } from "../types/types";
+import { isObjectValue } from "../utils/runtime-value";
 
 /**
  * Cone 생성 컨텍스트
@@ -29,16 +32,32 @@ export type ConeGenerationResult = {
   tokensUsed: number;
 };
 
+export type ConeTextGenerator = (request: {
+  model: LanguageModel;
+  prompt: string;
+}) => Promise<{ text: string; usage?: { totalTokens?: number } }>;
+
+export type ConeGeneratorDependencies = {
+  generateText?: ConeTextGenerator;
+};
+
 /**
  * LLM을 사용하여 Entity의 cone 메타데이터를 생성합니다.
  *
  * @param context - Entity 정보와 생성 옵션
  * @returns 생성된 cone 메타데이터
  */
-export async function generateCones(context: ConeGenerationContext): Promise<ConeGenerationResult> {
+export async function generateCones(
+  context: ConeGenerationContext,
+  dependencies: ConeGeneratorDependencies = {},
+): Promise<ConeGenerationResult> {
   const apiKey = getApiKey();
   const prompt = buildPrompt(context);
-  const { text: responseText, tokensUsed } = await callAnthropicAPI(prompt, apiKey);
+  const { text: responseText, tokensUsed } = await callAnthropicAPI(
+    prompt,
+    apiKey,
+    dependencies.generateText,
+  );
   const result = parseConeResponse(responseText);
   result.tokensUsed = tokensUsed;
 
@@ -269,11 +288,17 @@ IMPORTANT: Return pure JSON only. Do NOT wrap in markdown code blocks.`;
 async function callAnthropicAPI(
   prompt: string,
   apiKey: string,
+  injectedGenerateText?: ConeTextGenerator,
 ): Promise<{ text: string; tokensUsed: number }> {
   try {
     // @ai-sdk/anthropic과 ai 패키지는 optional dependency이므로 동적 import
     const { createAnthropic } = await import("@ai-sdk/anthropic");
-    const { generateText } = await import("ai");
+    const generateText: ConeTextGenerator =
+      injectedGenerateText ??
+      (async (request) => {
+        const ai = await import("ai");
+        return ai.generateText(request);
+      });
 
     const anthropic = createAnthropic({
       apiKey,
@@ -291,8 +316,11 @@ async function callAnthropicAPI(
 
     return { text, tokensUsed };
   } catch (error: unknown) {
-    if (error && typeof error === "object" && "statusCode" in error) {
-      const statusCode = (error as { statusCode: number }).statusCode;
+    if (error && isObjectValue(error) && "statusCode" in error) {
+      const statusCode =
+        /* SAFETY: 호출 경계의 선행 검증과 소유 타입 계약이 이 값의 타입을 보장한다. */ (
+          error as { statusCode: number }
+        ).statusCode;
       if (statusCode === 429) {
         throw new Error("Rate limit exceeded. Please try again later.", { cause: error });
       }
@@ -317,7 +345,7 @@ function parseConeResponse(text: string): ConeGenerationResult {
   try {
     const parsed = JSON.parse(jsonText);
 
-    if (!parsed.propCones || typeof parsed.propCones !== "object") {
+    if (!parsed.propCones || !isObjectValue(parsed.propCones)) {
       throw new Error("Invalid response: propCones is required and must be an object");
     }
 

package/src/database/__tests__/db.test.ts

@@ -75,6 +75,7 @@ describe("DBClass.generateDBConfig", () => {
   });
 
   it("fails fast when legacy database.name or database.environments keys are present", () => {
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const legacyConfig = {
       database: "pg",
       name: "miomock",

package/src/database/__tests__/puri.test.ts

@@ -37,6 +37,20 @@ function usersQuery(): Puri<TestSchema, { users: TestSchema["users"] }, TestSche
   return new Puri(db, "users");
 }
 
+function withJsonTableSpec<T>(jsonColumns: string[], callback: () => T): T {
+  const tableSpecSpy = vi.spyOn(EntityManager, "getTableSpec").mockReturnValue({
+    name: "users",
+    uniqueIndexes: [],
+    jsonColumns,
+  });
+
+  try {
+    return callback();
+  } finally {
+    tableSpecSpy.mockRestore();
+  }
+}
+
 afterAll(async () => {
   await db.destroy();
 });
@@ -104,7 +118,8 @@ describe("Puri JSONB containment", () => {
     ]);
 
     const query = usersQuery();
-    expect(() => Reflect.apply(query.whereJsonSupersetOf, query, ["payload", undefined])).toThrow(
+    // SAFETY: 직렬화 실패 경로를 검증하기 위해 타입 계약 밖의 값을 의도적으로 전달합니다.
+    expect(() => query.whereJsonSupersetOf("payload", undefined as never)).toThrow(
       "Puri JSONB containment value must be JSON-serializable; JSON.stringify returned undefined.",
     );
     expect(query.rawQuery().toSQL().sql).toBe('select * from "users"');
@@ -112,20 +127,6 @@ describe("Puri JSONB containment", () => {
 });
 
 describe("Puri onConflict JSON 직렬화", () => {
-  function withJsonTableSpec<T>(jsonColumns: string[], callback: () => T): T {
-    const tableSpecSpy = vi.spyOn(EntityManager, "getTableSpec").mockReturnValue({
-      name: "users",
-      uniqueIndexes: [],
-      jsonColumns,
-    });
-
-    try {
-      return callback();
-    } finally {
-      tableSpecSpy.mockRestore();
-    }
-  }
-
   it("객체 update의 배열을 JSON 문자열 binding으로 변환한다", () => {
     const binding = withJsonTableSpec(["tags"], () =>
       usersQuery()

package/src/database/__tests__/transaction-scope.test.ts

@@ -14,6 +14,7 @@ type TransactionScopeDB = DBClass & {
 };
 
 function createTransactionWrapper(): PuriTransactionWrapper {
+  // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
   return new PuriTransactionWrapper({} as Knex.Transaction, new UpsertBuilder());
 }
 
@@ -32,6 +33,7 @@ function expectScopeRunner(db: TransactionScopeDB) {
 
 describe("DB.runWithTransactionScope", () => {
   it("저장소가 없어도 루트 scope를 설치하고 콜백 결과를 반환한 뒤 정리한다", async () => {
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const db = new DBClass() as TransactionScopeDB;
     const transaction = createTransactionWrapper();
     const runScope = expectScopeRunner(db);
@@ -53,6 +55,7 @@ describe("DB.runWithTransactionScope", () => {
   });
 
   it("scope 안에서 생성된 detached descendant가 완료된 자식 트랜잭션을 다시 사용하지 않는다", async () => {
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const db = new DBClass() as TransactionScopeDB;
     const parentTransaction = createTransactionWrapper();
     const childTransaction = createTransactionWrapper();
@@ -119,6 +122,7 @@ describe("DB.runWithTransactionScope", () => {
   });
 
   it("같거나 다른 preset의 중첩 범위를 복원하고 같은 오류를 다시 던진다", async () => {
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const db = new DBClass() as TransactionScopeDB;
     const outer = createTransactionWrapper();
     const samePresetInner = createTransactionWrapper();
@@ -157,6 +161,7 @@ describe("DB.runWithTransactionScope", () => {
   });
 
   it("겹치는 sibling 범위가 완료 순서와 무관하게 서로의 활성 트랜잭션을 보지 않는다", async () => {
+    // SAFETY: 테스트 입력은 선언된 타입 검증 시나리오에 맞게 고정됩니다.
     const db = new DBClass() as TransactionScopeDB;
     const parentTransaction = createTransactionWrapper();
     const firstTransaction = createTransactionWrapper();

package/src/database/_batch_update.ts

@@ -97,6 +97,7 @@ function generateBatchUpdateSQL<Id extends string>(
   const cases: string[] = [];
 
   for (const key of keySet) {
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     if (identifiers.includes(key as Id)) continue;
 
     const caseBindings: (string | number | boolean | null)[] = [];

package/src/database/base-model.ts

@@ -11,6 +11,7 @@ import { normalizeFilterQuery, validateSonamuFilters } from "../filter/utils";
 import { convertDomainToCategory } from "../logger/category";
 import { type DatabaseSchemaExtend, type SonamuQueryMode } from "../types/types";
 import { type ListResult } from "../utils/model";
+import { isObjectValue } from "../utils/runtime-value";
 import { getJoinTables, getTableNamesFromWhere } from "../utils/sql-parser";
 import { type EnhancerMap, type ResolveSubsetIntersection } from "./base-model.types";
 import { type DBPreset } from "./db";
@@ -25,7 +26,18 @@ import { PuriWrapper } from "./puri-wrapper";
 import { type UnionExtractedTTables } from "./puri.types";
 import { UpsertBuilder } from "./upsert-builder";
 
-type UnknownDBRecord = Record<string, unknown>;
+type DatabaseRecordValue =
+  | string
+  | number
+  | boolean
+  | bigint
+  | Date
+  | Buffer
+  | Knex.Raw
+  | null
+  | DatabaseRecordValue[]
+  | { [key: string]: DatabaseRecordValue };
+type DatabaseRecord = Record<string, DatabaseRecordValue | undefined>;
 
 /**
  * 모든 Model 클래스의 기본 클래스
@@ -37,7 +49,7 @@ type UnknownDBRecord = Record<string, unknown>;
  */
 export class BaseModelClass<
   TSubsetKey extends string = never,
-  TSubsetMapping extends Record<string, any> = never,
+  TSubsetMapping extends { [K in TSubsetKey]: TSubsetMapping[K] } = never,
   TSubsetQueries extends Record<TSubsetKey, PuriSubsetFn> = never,
   TLoaderQueries extends PuriLoaderQueries<TSubsetKey> = never,
 > {
@@ -82,7 +94,7 @@ export class BaseModelClass<
 
   async getInsertedIds(
     wdb: Knex,
-    rows: UnknownDBRecord[],
+    rows: DatabaseRecord[],
     tableName: string,
     unqKeyFields: string[],
     chunkSize: number = 500,
@@ -102,6 +114,7 @@ export class BaseModelClass<
     } else {
       whereInField = unqKeyFields[0];
       selectField = unqKeyFields[0];
+      // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
       unqKeys = rows.map((row) => row[unqKeyFields[0]] as string);
     }
 
@@ -109,9 +122,14 @@ export class BaseModelClass<
     for (const items of cluster(unqKeys, chunkSize)) {
       const dbRows = await wdb(tableName)
         .select("id", wdb.raw(selectField))
-        .whereIn(whereInField as string, items);
+        // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
+        .whereIn(
+          /* SAFETY: Knex 런타임은 컬럼 위치의 Raw 표현식을 지원하지만 선언 타입에는 누락되어 있습니다. */
+          whereInField as string,
+          items,
+        );
       resultIds = resultIds.concat(
-        dbRows.map((dbRow: UnknownDBRecord) => parseInt(String(dbRow.id))),
+        dbRows.map((dbRow: DatabaseRecord) => parseInt(String(dbRow.id))),
       );
     }
 
@@ -137,16 +155,18 @@ export class BaseModelClass<
       NonAllowedAsSingleTable: { __fulltext__: true };
     };
 
+    function onSubset<S extends TSubsetKey>(subset: S): ReturnType<TSubsetQueries[S]>;
+    function onSubset<Arr extends readonly TSubsetKey[]>(
+      subsets: [...Arr],
+    ): ResolveSubsetIntersection<Arr, TSubsetQueries>;
+    function onSubset(_subset: TSubsetKey | readonly TSubsetKey[]) {
+      return qb;
+    }
+
     return {
-      qb: qb as unknown as Puri<DatabaseSchemaExtend, QBTables, {}>,
-      onSubset: ((_subset: TSubsetKey | readonly TSubsetKey[]) => qb) as {
-        // 단일 키
-        <S extends TSubsetKey>(subset: S): ReturnType<TSubsetQueries[S]>;
-        // 키 배열 -> 교집합 반환
-        <Arr extends readonly TSubsetKey[]>(
-          subsets: [...Arr],
-        ): ResolveSubsetIntersection<Arr, TSubsetQueries>;
-      },
+      // SAFETY: 같은 Puri 인스턴스에 단일 테이블 접근 제한용 타입 마커만 추가합니다.
+      qb: qb as Puri<DatabaseSchemaExtend, QBTables, {}>,
+      onSubset,
     };
   }
 
@@ -177,11 +197,11 @@ export class BaseModelClass<
   async executeSubsetQuery<
     T extends TSubsetKey,
     TComputedResults extends InferAllSubsets<TSubsetQueries, TLoaderQueries>,
+    TFilter extends object,
     LP extends {
       num?: number;
       page?: number;
       queryMode?: SonamuQueryMode;
-      sonamuFilter?: Record<string, unknown>;
     },
   >(
     params: {
@@ -191,7 +211,7 @@ export class BaseModelClass<
         num: number;
         page: number;
         queryMode?: SonamuQueryMode;
-        sonamuFilter?: Record<string, unknown>;
+        sonamuFilter?: TFilter;
       };
       debug?: boolean;
       optimizeCountQuery?: boolean;
@@ -217,6 +237,7 @@ export class BaseModelClass<
     const total = await this.executeCountQuery(qb, queryParams, debug, optimizeCountQuery);
 
     if (queryParams?.queryMode === "count") {
+      // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
       return { total } as ListResult<LP, TSubsetMapping[T]>;
     }
 
@@ -232,7 +253,9 @@ export class BaseModelClass<
     );
 
     // Enhancer 적용
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     const enhancer = (params as any).enhancers?.[subset];
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     const enhancedRows = (await Promise.all(
       computedRows.map((row) => enhancer?.(row) ?? row),
     )) as TSubsetMapping[T][];
@@ -247,9 +270,11 @@ export class BaseModelClass<
 
     if (queryParams.queryMode === "list") {
       // 리스트만 리턴
+      // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
       return { rows } as ListResult<LP, TSubsetMapping[T]>;
     } else {
       // 둘다 리턴
+      // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
       return { rows, total } as ListResult<LP, TSubsetMapping[T]>;
     }
   }
@@ -272,7 +297,7 @@ export class BaseModelClass<
    * @param qb Puri QueryBuilder 인스턴스
    * @param filters FilterQuery 객체
    */
-  protected applySonamuFilters<TEntity = Record<string, unknown>>(
+  protected applySonamuFilters<TEntity>(
     qb: Puri<any, any, any>,
     filters?: FilterQuery<TEntity>,
   ): void {
@@ -284,6 +309,7 @@ export class BaseModelClass<
     validateSonamuFilters(filters, entity);
 
     // 2. 검증된 필터 적용
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     const puri = qb as any;
 
     for (const [field, condition] of Object.entries(filters)) {
@@ -293,13 +319,14 @@ export class BaseModelClass<
       const fullField = entity.getFullFieldName(field);
 
       // 직접 값 (eq와 동일)
-      if (typeof condition !== "object" || Array.isArray(condition)) {
+      if (!isObjectValue(condition) || Array.isArray(condition)) {
         puri.where(fullField, condition);
         continue;
       }
 
       // 연산자 객체
       for (const [operator, value] of Object.entries(condition)) {
+        // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
         this.applyOperator(qb, fullField, operator as FilterOperator, value);
       }
     }
@@ -308,12 +335,13 @@ export class BaseModelClass<
   /**
    * 단일 연산자를 QueryBuilder에 적용
    */
-  private applyOperator(
+  private applyOperator<Value>(
     qb: Puri<any, any, any>,
     field: string,
     operator: FilterOperator,
-    value: unknown,
+    value: Value,
   ): void {
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     const puri = qb as any;
 
     switch (operator) {
@@ -394,14 +422,14 @@ export class BaseModelClass<
    * 중첩 필드 삭제 (배열 내 객체도 처리)
    */
   deleteField(obj: any, parts: string[]): void {
-    if (!obj || typeof obj !== "object") {
+    if (!obj || !isObjectValue(obj)) {
       return;
     }
 
     if (parts.length === 1) {
       if (Array.isArray(obj)) {
         obj.forEach((item) => {
-          if (item && typeof item === "object") {
+          if (item && isObjectValue(item)) {
             delete item[parts[0]];
           }
         });
@@ -416,7 +444,7 @@ export class BaseModelClass<
 
     if (Array.isArray(next)) {
       next.map((item) => this.deleteField(item, rest));
-    } else if (next && typeof next === "object") {
+    } else if (next && isObjectValue(next)) {
       this.deleteField(next, rest);
     }
   }
@@ -496,6 +524,7 @@ export class BaseModelClass<
     }
 
     // 로더 처리
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     const loaders = (this.loaderQueries as any)[subset];
     if (loaders && Array.isArray(loaders)) {
       unloadedRows = await this.processLoaders(unloadedRows, loaders, debug, puriWrapper);
@@ -525,6 +554,7 @@ export class BaseModelClass<
         resolveLoaderQb.debug();
       }
 
+      // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
       let loadedRows = (await resolveLoaderQb) as any[];
 
       // 중첩 loaders가 있으면 재귀 처리
@@ -549,8 +579,10 @@ export class BaseModelClass<
    * - `user__name` → `{ user: { name } }`
    * - nullable relation의 경우 id 필드가 null이면 객체 자체를 null로
    */
-  hydrate<T extends UnknownDBRecord>(rows: T[]): T[] {
+  hydrate<T extends object>(rows: T[]): T[] {
+    // SAFETY: 쿼리 빌더의 제네릭 계약과 선행 검증이 이 타입을 보장합니다.
     return rows.map((row: T) => {
+      const rowValues = new Map(Object.entries(row));
       // nullable relation 처리: 그룹의 id 필드가 null이면 객체 전체를 null로
       const nestedKeys = Object.keys(row).filter((key) => key.includes("__"));
       const groups = Object.groupBy(nestedKeys, (key) => key.split("__")[0]);
@@ -564,26 +596,27 @@ export class BaseModelClass<
           const idField = `${groupKey}__id`;
           if (idField in row) {
             // id 필드가 null이면 객체 전체가 null
-            return row[idField] === null;
+            return rowValues.get(idField) === null;
           }
 
           // id 필드가 없으면 기존 로직: 모든 필드가 null인지 확인
-          return fields.every(
-            (field) =>
-              row[field] === null || (Array.isArray(row[field]) && row[field].length === 0),
-          );
+          return fields.every((field) => {
+            const fieldValue = rowValues.get(field);
+            return fieldValue === null || (Array.isArray(fieldValue) && fieldValue.length === 0);
+          });
         })
         .map(([key]) => key);
 
-      const hydrated = Object.keys(row).reduce((r, field) => {
+      let hydrated: DatabaseRecord = Object.fromEntries([]);
+      for (const field of Object.keys(row)) {
+        const fieldValue = rowValues.get(field);
         if (!field.includes("__")) {
-          // 일반 필드: 배열 내 객체면 재귀 hydrate
-          if (Array.isArray(row[field]) && isObject(row[field][0])) {
-            r[field] = this.hydrate(row[field]);
-          } else {
-            r[field] = row[field];
-          }
-          return r;
+          const hydratedValue =
+            Array.isArray(fieldValue) && isObject(fieldValue[0])
+              ? this.hydrate(fieldValue)
+              : fieldValue;
+          Object.assign(hydrated, { [field]: hydratedValue });
+          continue;
         }
 
         // 중첩 필드 처리: user__name → user[name]
@@ -595,20 +628,18 @@ export class BaseModelClass<
             .map((part) => `[${part}]`)
             .join("");
 
-        r = set(
-          r,
+        hydrated = set(
+          hydrated,
           objPath,
-          row[field] && Array.isArray(row[field]) && isObject(row[field][0])
-            ? this.hydrate(row[field])
-            : row[field],
+          fieldValue && Array.isArray(fieldValue) && isObject(fieldValue[0])
+            ? this.hydrate(fieldValue)
+            : fieldValue,
         );
-
-        return r;
-      }, {} as UnknownDBRecord);
+      }
 
       // null relation 처리
       nullKeys.forEach((nullKey) => {
-        hydrated[nullKey] = null;
+        Object.assign(hydrated, { [nullKey]: null });
       });
 
       return hydrated;
@@ -622,8 +653,8 @@ export class BaseModelClass<
  */
 type EnhancerParam<
   TSubsetKey extends string,
-  TComputedResults extends Record<TSubsetKey, any>,
-  TSubsetMapping extends Record<TSubsetKey, any>,
+  TComputedResults extends { [K in TSubsetKey]: TComputedResults[K] },
+  TSubsetMapping extends { [K in TSubsetKey]: TSubsetMapping[K] },
   TSubsetQueries extends Record<TSubsetKey, PuriSubsetFn>,
 > = [RequiredEnhancerKeys<TSubsetKey, TComputedResults, TSubsetMapping>] extends [never]
   ? { enhancers?: EnhancerMap<TSubsetKey, TComputedResults, TSubsetMapping, TSubsetQueries> }
@@ -631,8 +662,8 @@ type EnhancerParam<
 
 type RequiredEnhancerKeys<
   TSubsetKey extends string,
-  TComputedResults extends Record<TSubsetKey, any>,
-  TSubsetMapping extends Record<TSubsetKey, any>,
+  TComputedResults extends { [K in TSubsetKey]: TComputedResults[K] },
+  TSubsetMapping extends { [K in TSubsetKey]: TSubsetMapping[K] },
 > = {
   [K in TSubsetKey]: TComputedResults[K] extends TSubsetMapping[K] ? never : K;
 }[TSubsetKey];

package/src/database/base-model.types.ts

@@ -77,8 +77,8 @@ type OmitVirtualQueryFromMapping<TMapping, TVirtualQueryKeys> = Omit<
  */
 type IsEnhancerOptional<
   TSubsetKey extends string,
-  TComputedResults extends Record<TSubsetKey, any>,
-  TSubsetMapping extends Record<TSubsetKey, any>,
+  TComputedResults extends { [K in TSubsetKey]: TComputedResults[K] },
+  TSubsetMapping extends { [K in TSubsetKey]: TSubsetMapping[K] },
   TSubsetQueries extends Record<TSubsetKey, PuriSubsetFn>,
   K extends TSubsetKey,
 > =
@@ -106,8 +106,8 @@ type EnhancerFnWithVirtualQuery<TComputed, TMapping, TVirtualQueryKeys> = (
  */
 export type RequiredEnhancerKeys<
   TSubsetKey extends string,
-  TComputedResults extends Record<TSubsetKey, any>,
-  TSubsetMapping extends Record<TSubsetKey, any>,
+  TComputedResults extends { [K in TSubsetKey]: TComputedResults[K] },
+  TSubsetMapping extends { [K in TSubsetKey]: TSubsetMapping[K] },
   TSubsetQueries extends Record<TSubsetKey, PuriSubsetFn>,
 > = {
   [K in TSubsetKey]: IsEnhancerOptional<
@@ -136,8 +136,8 @@ export type RequiredEnhancerKeys<
  */
 export type EnhancerMap<
   TSubsetKey extends string,
-  TComputedResults extends Record<TSubsetKey, any>,
-  TSubsetMapping extends Record<TSubsetKey, any>,
+  TComputedResults extends { [K in TSubsetKey]: TComputedResults[K] },
+  TSubsetMapping extends { [K in TSubsetKey]: TSubsetMapping[K] },
   TSubsetQueries extends Record<TSubsetKey, PuriSubsetFn>,
   TRequiredKeys extends TSubsetKey = RequiredEnhancerKeys<
     TSubsetKey,