mock-fried 1.0.0

package/dist/runtime/server/utils/mock/client-generator.js

@@ -0,0 +1,346 @@
+import { hashString, SeededRandom, isIdField, generateIdValue, DEFAULT_ID_CONFIG } from "./shared.js";
+export function inferValueByFieldName(fieldName, rng, index = 0, idConfig = DEFAULT_ID_CONFIG) {
+  const name = fieldName.toLowerCase();
+  if (isIdField(fieldName, idConfig)) {
+    return generateIdValue(fieldName, index, rng.hashId(16), idConfig);
+  }
+  if (name.includes("email") || name.includes("mail")) {
+    const domains = ["example.com", "test.com", "mock.io"];
+    const names = ["user", "test", "mock", "admin"];
+    return `${rng.pick(names)}${rng.nextInt(1, 999)}@${rng.pick(domains)}`;
+  }
+  if (name === "name" || name.includes("username") || name.includes("firstname") || name.includes("lastname")) {
+    const firstNames = ["\uAE40\uCCA0\uC218", "\uC774\uC601\uD76C", "\uBC15\uBBFC\uC218", "John", "Jane", "Mike", "Sarah", "Alex"];
+    return rng.pick(firstNames);
+  }
+  if (name.includes("phone") || name.includes("mobile") || name.includes("tel")) {
+    return `010-${rng.nextInt(1e3, 9999)}-${rng.nextInt(1e3, 9999)}`;
+  }
+  if (name.includes("url") || name.includes("link") || name.includes("href")) {
+    return `https://example.com/${fieldName}/${rng.nextInt(1, 1e3)}`;
+  }
+  if (name.includes("image") || name.includes("avatar") || name.includes("photo") || name.includes("thumbnail") || name.includes("picture")) {
+    return `https://picsum.photos/seed/${rng.nextInt(1, 1e3)}/200/200`;
+  }
+  if (name.includes("date") || name.endsWith("at") || name.includes("time") || name.includes("created") || name.includes("updated")) {
+    const now = Date.now();
+    const offset = rng.nextInt(-365, 30) * 24 * 60 * 60 * 1e3;
+    return new Date(now + offset).toISOString();
+  }
+  if (name.includes("description") || name.includes("content") || name.includes("body") || name.includes("text")) {
+    return `Mock ${fieldName} \uB370\uC774\uD130 #${rng.nextInt(1, 100)}`;
+  }
+  if (name.includes("title") || name.includes("subject") || name.includes("headline")) {
+    return `\uC0D8\uD50C ${fieldName} #${rng.nextInt(1, 100)}`;
+  }
+  if (name.includes("status")) {
+    return rng.pick(["ACTIVE", "INACTIVE", "PENDING", "COMPLETED"]);
+  }
+  if (name.includes("count") || name.includes("quantity") || name.includes("amount") || name.includes("num")) {
+    return rng.nextInt(0, 100);
+  }
+  if (name.includes("price") || name.includes("cost") || name.includes("fee") || name.includes("amount")) {
+    return rng.nextInt(1e3, 1e5);
+  }
+  if (name === "page") return 1;
+  if (name === "limit" || name === "size" || name === "pagesize") return 20;
+  if (name === "total" || name === "totalcount" || name === "totalitems") return rng.nextInt(50, 500);
+  if (name === "totalpages") return rng.nextInt(3, 25);
+  if (name.startsWith("is") || name.startsWith("has") || name.startsWith("can") || name.startsWith("should") || name.startsWith("will")) {
+    return rng.next() > 0.5;
+  }
+  if (name.includes("address") || name.includes("street")) {
+    return `\uC11C\uC6B8\uC2DC \uAC15\uB0A8\uAD6C \uD14C\uD5E4\uB780\uB85C ${rng.nextInt(1, 500)}\uBC88\uAE38`;
+  }
+  if (name.includes("city")) {
+    return rng.pick(["\uC11C\uC6B8", "\uBD80\uC0B0", "\uB300\uAD6C", "\uC778\uCC9C", "\uAD11\uC8FC", "\uB300\uC804"]);
+  }
+  if (name.includes("country")) {
+    return rng.pick(["KR", "US", "JP", "CN"]);
+  }
+  if (name.includes("zipcode") || name.includes("postal")) {
+    return `${rng.nextInt(1e4, 99999)}`;
+  }
+  if (name.includes("code")) {
+    return `CODE-${rng.nextInt(1e3, 9999)}`;
+  }
+  if (name.includes("type") || name.includes("category")) {
+    return rng.pick(["TYPE_A", "TYPE_B", "TYPE_C"]);
+  }
+  if (name.includes("version")) {
+    return `${rng.nextInt(1, 10)}.${rng.nextInt(0, 9)}.${rng.nextInt(0, 99)}`;
+  }
+  if (name.includes("token") || name.includes("key") || name.includes("secret")) {
+    return rng.uuid();
+  }
+  return null;
+}
+export function generateValueByType(type, fieldName, rng, index = 0, idConfig = DEFAULT_ID_CONFIG) {
+  const inferred = inferValueByFieldName(fieldName, rng, index, idConfig);
+  if (inferred !== null) return inferred;
+  switch (type.toLowerCase()) {
+    case "string":
+      return `mock-${fieldName}-${rng.nextInt(1, 1e3)}`;
+    case "number":
+    case "int":
+    case "integer":
+      return rng.nextInt(1, 1e3);
+    case "boolean":
+    case "bool":
+      return rng.next() > 0.5;
+    case "date":
+      return (/* @__PURE__ */ new Date()).toISOString();
+    case "unknown":
+    case "any":
+    case "object":
+      return inferTypeFromFieldName(fieldName, rng, index, idConfig);
+    default:
+      return `mock-${fieldName}-${rng.nextInt(1, 1e3)}`;
+  }
+}
+export function inferTypeFromFieldName(fieldName, rng, index, idConfig = DEFAULT_ID_CONFIG) {
+  const name = fieldName.toLowerCase();
+  if (isIdField(fieldName, idConfig)) {
+    return generateIdValue(fieldName, index, rng.hashId(16), idConfig);
+  }
+  if (name.includes("count") || name.includes("num") || name.includes("amount") || name.includes("size") || name.includes("total") || name.includes("views") || name.includes("likes") || name.includes("price") || name.includes("age") || name.includes("quantity") || name.includes("index") || name.includes("order")) {
+    return rng.nextInt(0, 1e3);
+  }
+  if (name.startsWith("is") || name.startsWith("has") || name.startsWith("can") || name.startsWith("should") || name.startsWith("will") || name.includes("enabled") || name.includes("active") || name.includes("visible") || name.includes("valid")) {
+    return rng.next() > 0.5;
+  }
+  if (name.includes("date") || name.endsWith("at") || name.includes("time") || name.includes("created") || name.includes("updated") || name.includes("modified")) {
+    const now = Date.now();
+    const offset = rng.nextInt(-365, 30) * 24 * 60 * 60 * 1e3;
+    return new Date(now + offset).toISOString();
+  }
+  if (name.includes("url") || name.includes("link") || name.includes("href")) {
+    return `https://example.com/${fieldName}/${rng.nextInt(1, 1e3)}`;
+  }
+  if (name.includes("image") || name.includes("thumbnail") || name.includes("avatar") || name.includes("photo") || name.includes("picture")) {
+    return `https://picsum.photos/seed/${rng.nextInt(1, 1e3)}/200/200`;
+  }
+  return `mock-${fieldName}-${rng.nextInt(1, 1e3)}`;
+}
+export function extractDataModelName(responseType, models) {
+  const arrayMatch = responseType.match(/^Array<(.+)>$/) || responseType.match(/^(.+)\[\]$/);
+  if (arrayMatch) {
+    const innerType = arrayMatch[1].trim();
+    return {
+      modelName: innerType,
+      isList: true,
+      // listFieldName이 없으면 직접 배열 반환 (wrapper 없음)
+      listFieldName: void 0,
+      wrapperType: void 0
+    };
+  }
+  const schema = models.get(responseType);
+  if (schema) {
+    const priorityFields = ["items", "data", "posts", "comments", "results", "records", "list"];
+    for (const fieldName of priorityFields) {
+      const field = schema.fields.find((f) => f.name === fieldName && f.isArray);
+      if (field && field.refType) {
+        return {
+          modelName: field.refType,
+          isList: true,
+          listFieldName: fieldName,
+          wrapperType: responseType
+        };
+      }
+    }
+    const arrayField = schema.fields.find((f) => f.isArray && f.refType);
+    if (arrayField && arrayField.refType) {
+      return {
+        modelName: arrayField.refType,
+        isList: true,
+        listFieldName: arrayField.name,
+        wrapperType: responseType
+      };
+    }
+    const dataField = schema.fields.find((f) => f.name === "data" && !f.isArray);
+    if (dataField?.refType) {
+      return {
+        modelName: dataField.refType,
+        isList: false,
+        wrapperType: responseType
+      };
+    }
+  }
+  return { modelName: responseType, isList: false };
+}
+export class SchemaMockGenerator {
+  models;
+  dataStore = /* @__PURE__ */ new Map();
+  idConfig;
+  constructor(models, idConfig = DEFAULT_ID_CONFIG) {
+    this.models = models;
+    this.idConfig = idConfig;
+  }
+  /**
+   * 모델 스키마 기반 단일 객체 생성
+   */
+  generateOne(modelName, seed, index = 0) {
+    const schema = this.models.get(modelName);
+    if (!schema) {
+      return {};
+    }
+    if (schema.enumValues && schema.enumValues.length > 0) {
+      const rng2 = new SeededRandom(seed ?? modelName);
+      return { value: rng2.pick(schema.enumValues) };
+    }
+    const rng = new SeededRandom(seed ?? `${modelName}-${index}`);
+    const result = {};
+    for (const field of schema.fields) {
+      const value = this.generateField(field, rng, index);
+      if (value !== void 0) {
+        const outputKey = field.jsonKey || field.name;
+        result[outputKey] = value;
+      }
+    }
+    return result;
+  }
+  /**
+   * ID 부여된 단일 객체 생성 (Pagination용)
+   * 주어진 ID를 모델의 ID 필드에 설정하여 cursor와 응답 ID가 일치하도록 함
+   */
+  generateOneWithId(modelName, itemId, seed, index = 0) {
+    const item = this.generateOne(modelName, seed ?? `${modelName}-${itemId}`, index);
+    const idFieldName = this.findIdFieldName(modelName);
+    if (idFieldName) {
+      const outputKey = this.getOutputKey(modelName, idFieldName);
+      item[outputKey] = itemId;
+    } else if (!("id" in item)) {
+      item.id = itemId;
+    } else {
+      item.id = itemId;
+    }
+    return item;
+  }
+  /**
+   * 모델의 ID 필드명 찾기 (MockIdConfig 기반)
+   */
+  findIdFieldName(modelName) {
+    const schema = this.models.get(modelName);
+    if (!schema) return null;
+    for (const field of schema.fields) {
+      if (isIdField(field.name, this.idConfig)) {
+        return field.name;
+      }
+    }
+    return null;
+  }
+  /**
+   * 필드의 출력 키 가져오기 (jsonKey 또는 name)
+   */
+  getOutputKey(modelName, fieldName) {
+    const schema = this.models.get(modelName);
+    if (!schema) return fieldName;
+    const field = schema.fields.find((f) => f.name === fieldName);
+    return field?.jsonKey || fieldName;
+  }
+  /**
+   * 필드 값 생성
+   */
+  generateField(field, rng, index) {
+    if (!field.required && rng.next() > 0.7) {
+      return void 0;
+    }
+    if (field.refType) {
+      const refSchema = this.models.get(field.refType);
+      if (refSchema?.enumValues) {
+        const value = rng.pick(refSchema.enumValues);
+        return field.isArray ? [value] : value;
+      }
+      if (field.isArray) {
+        const count = rng.nextInt(1, 3);
+        return Array.from(
+          { length: count },
+          (_, i) => this.generateOne(field.refType, `${field.refType}-${index}-${i}`, i)
+        );
+      }
+      return this.generateOne(field.refType, `${field.refType}-${index}`, index);
+    }
+    if (field.isArray) {
+      const count = rng.nextInt(1, 5);
+      return Array.from(
+        { length: count },
+        (_, i) => generateValueByType(field.type, field.name, rng, i, this.idConfig)
+      );
+    }
+    return generateValueByType(field.type, field.name, rng, index, this.idConfig);
+  }
+  /**
+   * 리스트 데이터 생성 (캐시 지원 - Pagination)
+   * @deprecated Use pagination/page-manager.ts instead for enhanced pagination
+   */
+  generateList(modelName, options = {}) {
+    const { page = 1, limit = 20, total = 100, seed = modelName } = options;
+    const cacheKey = `${modelName}-${seed}`;
+    let allItems = this.dataStore.get(cacheKey);
+    if (!allItems || allItems.length < total) {
+      allItems = Array.from(
+        { length: total },
+        (_, i) => this.generateOne(modelName, `${seed}-${i}`, i)
+      );
+      this.dataStore.set(cacheKey, allItems);
+    }
+    const startIndex = (page - 1) * limit;
+    const endIndex = Math.min(startIndex + limit, total);
+    const items = allItems.slice(startIndex, endIndex);
+    return {
+      items,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages: Math.ceil(total / limit)
+      }
+    };
+  }
+  /**
+   * 커서 기반 리스트 생성 (무한 스크롤용)
+   * @deprecated Use pagination/cursor-manager.ts instead for enhanced pagination
+   */
+  generateCursorList(modelName, options = {}) {
+    const { cursor, limit = 20, total = 100, seed = modelName } = options;
+    const cacheKey = `${modelName}-${seed}`;
+    let allItems = this.dataStore.get(cacheKey);
+    if (!allItems || allItems.length < total) {
+      allItems = Array.from(
+        { length: total },
+        (_, i) => this.generateOne(modelName, `${seed}-${i}`, i)
+      );
+      this.dataStore.set(cacheKey, allItems);
+    }
+    let startIndex = 0;
+    if (cursor) {
+      try {
+        startIndex = Number.parseInt(Buffer.from(cursor, "base64").toString("utf-8"), 10);
+      } catch {
+        startIndex = 0;
+      }
+    }
+    const endIndex = Math.min(startIndex + limit, total);
+    const items = allItems.slice(startIndex, endIndex);
+    const hasMore = endIndex < total;
+    return {
+      items,
+      nextCursor: hasMore ? Buffer.from(String(endIndex)).toString("base64") : void 0,
+      prevCursor: startIndex > 0 ? Buffer.from(String(Math.max(0, startIndex - limit))).toString("base64") : void 0,
+      hasMore
+    };
+  }
+  /**
+   * 모델 가져오기
+   */
+  getModels() {
+    return this.models;
+  }
+  /**
+   * 캐시 초기화
+   */
+  clearCache() {
+    this.dataStore.clear();
+  }
+}
+export { SeededRandom, hashString };

package/dist/runtime/server/utils/mock/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Mock 생성기 모듈 진입점
+ * 하위 호환성을 위해 모든 기존 export를 유지
+ */
+export { hashString, seededRandom, SeededRandom, generateId, generateSnapshotId, DEFAULT_ID_CONFIG, isIdField, generateIdValue, generateByFormat, } from './shared.js';
+export { generateMockValueForProtoField, generateMockMessage, deriveSeedFromRequest, } from './proto-generator.js';
+export { generateMockFromSchema, } from './openapi-generator.js';
+export { inferValueByFieldName, generateValueByType, inferTypeFromFieldName, SchemaMockGenerator, extractDataModelName, type ResponseTypeInfo, } from './client-generator.js';
+export { type CursorPayload, type PaginationSnapshot, type PagePaginationOptions, type PagePaginationResult, type CursorPaginationOptions, type CursorPaginationResult, type PaginationConfig, type CursorConfig, DEFAULT_PAGINATION_CONFIG, DEFAULT_CURSOR_CONFIG, SnapshotStore, getSnapshotStore, resetSnapshotStore, CursorPaginationManager, encodeCursor, decodeCursor, isCursorExpired, PagePaginationManager, } from './pagination/index.js';

package/dist/runtime/server/utils/mock/index.js

@@ -0,0 +1,38 @@
+export {
+  hashString,
+  seededRandom,
+  SeededRandom,
+  generateId,
+  generateSnapshotId,
+  DEFAULT_ID_CONFIG,
+  isIdField,
+  generateIdValue,
+  generateByFormat
+} from "./shared.js";
+export {
+  generateMockValueForProtoField,
+  generateMockMessage,
+  deriveSeedFromRequest
+} from "./proto-generator.js";
+export {
+  generateMockFromSchema
+} from "./openapi-generator.js";
+export {
+  inferValueByFieldName,
+  generateValueByType,
+  inferTypeFromFieldName,
+  SchemaMockGenerator,
+  extractDataModelName
+} from "./client-generator.js";
+export {
+  DEFAULT_PAGINATION_CONFIG,
+  DEFAULT_CURSOR_CONFIG,
+  SnapshotStore,
+  getSnapshotStore,
+  resetSnapshotStore,
+  CursorPaginationManager,
+  encodeCursor,
+  decodeCursor,
+  isCursorExpired,
+  PagePaginationManager
+} from "./pagination/index.js";

package/dist/runtime/server/utils/mock/openapi-generator.d.ts

@@ -0,0 +1,4 @@
+/**
+ * OpenAPI 스키마에서 mock 값 생성
+ */
+export declare function generateMockFromSchema(schema: Record<string, unknown>, seed?: number): unknown;

package/dist/runtime/server/utils/mock/openapi-generator.js

@@ -0,0 +1,118 @@
+import { seededRandom } from "./shared.js";
+export function generateMockFromSchema(schema, seed = 1) {
+  const random = seededRandom(seed);
+  const schemaType = schema.type;
+  if (schema.example !== void 0) {
+    return schema.example;
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    return schema.enum[0];
+  }
+  switch (schemaType) {
+    case "string": {
+      const format = schema.format;
+      if (format === "date") {
+        return "2024-01-15";
+      }
+      if (format === "date-time") {
+        return "2024-01-15T10:30:00Z";
+      }
+      if (format === "email") {
+        return `user${Math.floor(random() * 1e3)}@example.com`;
+      }
+      if (format === "uuid") {
+        return "550e8400-e29b-41d4-a716-446655440000";
+      }
+      if (format === "uri" || format === "url") {
+        return `https://example.com/resource/${Math.floor(random() * 1e3)}`;
+      }
+      if (format === "hostname") {
+        return "example.com";
+      }
+      if (format === "ipv4") {
+        return `192.168.${Math.floor(random() * 256)}.${Math.floor(random() * 256)}`;
+      }
+      if (format === "ipv6") {
+        return "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
+      }
+      if (format === "byte") {
+        return Buffer.from(`mock_${seed}`).toString("base64");
+      }
+      if (format === "binary") {
+        return `binary_data_${seed}`;
+      }
+      if (format === "password") {
+        return "********";
+      }
+      return `mock_string_${Math.floor(random() * 1e3)}`;
+    }
+    case "integer":
+    case "number": {
+      const min = schema.minimum ?? 0;
+      const max = schema.maximum ?? 1e3;
+      const value = min + random() * (max - min);
+      return schemaType === "integer" ? Math.floor(value) : Math.round(value * 100) / 100;
+    }
+    case "boolean":
+      return random() > 0.5;
+    case "array": {
+      const items = schema.items;
+      if (items) {
+        const minItems = schema.minItems ?? 1;
+        const maxItems = schema.maxItems ?? 3;
+        const count = Math.floor(random() * (maxItems - minItems + 1)) + minItems;
+        return Array.from(
+          { length: count },
+          (_, i) => generateMockFromSchema(items, seed + i + 1)
+        );
+      }
+      return [];
+    }
+    case "object": {
+      const properties = schema.properties;
+      if (properties) {
+        const result = {};
+        const required = schema.required ?? [];
+        let propSeed = seed;
+        for (const [propName, propSchema] of Object.entries(properties)) {
+          if (!required.includes(propName) && random() < 0.5) {
+            continue;
+          }
+          result[propName] = generateMockFromSchema(propSchema, propSeed++);
+        }
+        return result;
+      }
+      if (schema.additionalProperties) {
+        const additionalProps = schema.additionalProperties;
+        if (typeof additionalProps === "object") {
+          return {
+            [`key_${seed}`]: generateMockFromSchema(additionalProps, seed + 1)
+          };
+        }
+      }
+      return {};
+    }
+    // oneOf, anyOf, allOf 처리
+    default: {
+      if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+        const index = Math.floor(random() * schema.oneOf.length);
+        return generateMockFromSchema(schema.oneOf[index], seed);
+      }
+      if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+        const index = Math.floor(random() * schema.anyOf.length);
+        return generateMockFromSchema(schema.anyOf[index], seed);
+      }
+      if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+        const merged = {};
+        for (const subSchema of schema.allOf) {
+          const generated = generateMockFromSchema(subSchema, seed);
+          if (typeof generated === "object" && generated !== null) {
+            Object.assign(merged, generated);
+          }
+        }
+        return merged;
+      }
+      return null;
+    }
+  }
+}

package/dist/runtime/server/utils/mock/pagination/cursor-manager.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cursor 기반 Pagination 관리자
+ * ID 기반의 연결성 있는 cursor를 제공
+ */
+import type { CursorPayload, CursorPaginationOptions, CursorPaginationResult, CursorConfig } from './types.js';
+import type { SnapshotStore } from './snapshot-store.js';
+import type { SchemaMockGenerator } from '../client-generator.js';
+/**
+ * Cursor 인코딩
+ */
+export declare function encodeCursor(payload: CursorPayload): string;
+/**
+ * Cursor 디코딩
+ * - base64url 인코딩된 CursorPayload JSON
+ * - Legacy base64 인코딩된 인덱스 번호
+ * - Raw UUID/ID 문자열 (직접 ID로 사용)
+ */
+export declare function decodeCursor(cursor: string): CursorPayload | null;
+/**
+ * Cursor 만료 여부 확인
+ */
+export declare function isCursorExpired(payload: CursorPayload, config?: CursorConfig): boolean;
+/**
+ * Cursor 기반 Pagination 관리자 클래스
+ */
+export declare class CursorPaginationManager {
+    private generator;
+    private snapshotStore;
+    private cursorConfig;
+    constructor(generator: SchemaMockGenerator, options?: {
+        snapshotStore?: SnapshotStore;
+        cursorConfig?: CursorConfig;
+    });
+    /**
+     * Cursor 기반 페이지 조회
+     */
+    getCursorPage(modelName: string, options?: CursorPaginationOptions): CursorPaginationResult<Record<string, unknown>>;
+}

package/dist/runtime/server/utils/mock/pagination/cursor-manager.js

@@ -0,0 +1,129 @@
+import { DEFAULT_CURSOR_CONFIG, DEFAULT_PAGINATION_CONFIG } from "./types.js";
+import { getSnapshotStore } from "./snapshot-store.js";
+export function encodeCursor(payload) {
+  const json = JSON.stringify(payload);
+  return Buffer.from(json).toString("base64url");
+}
+export function decodeCursor(cursor) {
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf-8");
+    const parsed = JSON.parse(json);
+    if (parsed && typeof parsed.lastId === "string" && parsed.direction) {
+      return parsed;
+    }
+  } catch {
+  }
+  try {
+    const decoded = Buffer.from(cursor, "base64").toString("utf-8");
+    const index = Number.parseInt(decoded, 10);
+    if (!Number.isNaN(index) && decoded === String(index)) {
+      return {
+        lastId: `legacy-${index}`,
+        direction: "forward",
+        timestamp: Date.now()
+      };
+    }
+  } catch {
+  }
+  if (cursor && cursor.length >= 8 && !cursor.includes(" ")) {
+    return {
+      lastId: cursor,
+      direction: "forward",
+      timestamp: Date.now()
+    };
+  }
+  return null;
+}
+export function isCursorExpired(payload, config = {}) {
+  const { enableExpiry = DEFAULT_CURSOR_CONFIG.enableExpiry, cursorTTL = DEFAULT_CURSOR_CONFIG.cursorTTL } = config;
+  if (!enableExpiry) return false;
+  return Date.now() - payload.timestamp > cursorTTL;
+}
+export class CursorPaginationManager {
+  generator;
+  snapshotStore;
+  cursorConfig;
+  constructor(generator, options) {
+    this.generator = generator;
+    this.snapshotStore = options?.snapshotStore ?? getSnapshotStore();
+    this.cursorConfig = { ...DEFAULT_CURSOR_CONFIG, ...options?.cursorConfig };
+  }
+  /**
+   * Cursor 기반 페이지 조회
+   */
+  getCursorPage(modelName, options = {}) {
+    const {
+      cursor,
+      limit = DEFAULT_PAGINATION_CONFIG.defaultLimit,
+      total = DEFAULT_PAGINATION_CONFIG.defaultTotal,
+      seed = modelName,
+      snapshotId,
+      cache = true,
+      ttl
+    } = options;
+    let snapshot;
+    if (snapshotId) {
+      const existing = this.snapshotStore.getById(snapshotId);
+      if (existing) {
+        snapshot = existing;
+      } else {
+        snapshot = this.snapshotStore.getOrCreate(modelName, seed, total, { cache, ttl });
+      }
+    } else {
+      snapshot = this.snapshotStore.getOrCreate(modelName, seed, total, { cache, ttl });
+    }
+    let startIndex = 0;
+    let cursorPayload = null;
+    if (cursor) {
+      cursorPayload = decodeCursor(cursor);
+      if (cursorPayload) {
+        if (isCursorExpired(cursorPayload, this.cursorConfig)) {
+          startIndex = 0;
+        } else if (cursorPayload.lastId.startsWith("legacy-")) {
+          startIndex = Number.parseInt(cursorPayload.lastId.replace("legacy-", ""), 10);
+        } else {
+          const anchorIndex = snapshot.itemIds.findIndex((id) => id === cursorPayload.lastId);
+          if (anchorIndex !== -1) {
+            startIndex = cursorPayload.direction === "forward" ? anchorIndex + 1 : Math.max(0, anchorIndex - limit);
+          } else {
+            const elapsedRatio = Math.min(1, (cursorPayload.timestamp - snapshot.createdAt) / (snapshot.expiresAt || Date.now() - snapshot.createdAt));
+            startIndex = Math.floor(elapsedRatio * snapshot.total);
+          }
+        }
+      }
+    }
+    const endIndex = Math.min(startIndex + limit, snapshot.total);
+    const pageItemIds = snapshot.itemIds.slice(startIndex, endIndex);
+    const items = pageItemIds.map(
+      (itemId, i) => this.generator.generateOneWithId(modelName, itemId, `${seed}-${itemId}`, startIndex + i)
+    );
+    const hasMore = endIndex < snapshot.total;
+    const hasPrev = startIndex > 0;
+    const result = {
+      items,
+      hasMore
+    };
+    if (hasMore && pageItemIds.length > 0) {
+      result.nextCursor = encodeCursor({
+        lastId: pageItemIds[pageItemIds.length - 1],
+        direction: "forward",
+        snapshotId: snapshot.id,
+        timestamp: Date.now(),
+        sortField: this.cursorConfig.includeSortInfo ? "id" : void 0,
+        sortOrder: this.cursorConfig.includeSortInfo ? "asc" : void 0
+      });
+    }
+    if (hasPrev && pageItemIds.length > 0) {
+      result.prevCursor = encodeCursor({
+        lastId: pageItemIds[0],
+        direction: "backward",
+        snapshotId: snapshot.id,
+        timestamp: Date.now(),
+        sortField: this.cursorConfig.includeSortInfo ? "id" : void 0,
+        sortOrder: this.cursorConfig.includeSortInfo ? "asc" : void 0
+      });
+    }
+    result._snapshotId = snapshot.id;
+    return result;
+  }
+}