mock-fried 1.0.0

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

@@ -0,0 +1,8 @@
+/**
+ * Pagination 모듈 진입점
+ */
+export type { CursorPayload, PaginationSnapshot, PagePaginationOptions, PagePaginationResult, CursorPaginationOptions, CursorPaginationResult, PaginationConfig, CursorConfig, } from './types.js';
+export { DEFAULT_PAGINATION_CONFIG, DEFAULT_CURSOR_CONFIG, } from './types.js';
+export { SnapshotStore, getSnapshotStore, resetSnapshotStore, } from './snapshot-store.js';
+export { CursorPaginationManager, encodeCursor, decodeCursor, isCursorExpired, } from './cursor-manager.js';
+export { PagePaginationManager, } from './page-manager.js';

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

@@ -0,0 +1,18 @@
+export {
+  DEFAULT_PAGINATION_CONFIG,
+  DEFAULT_CURSOR_CONFIG
+} from "./types.js";
+export {
+  SnapshotStore,
+  getSnapshotStore,
+  resetSnapshotStore
+} from "./snapshot-store.js";
+export {
+  CursorPaginationManager,
+  encodeCursor,
+  decodeCursor,
+  isCursorExpired
+} from "./cursor-manager.js";
+export {
+  PagePaginationManager
+} from "./page-manager.js";

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

@@ -0,0 +1,41 @@
+/**
+ * Page/Limit 기반 Pagination 관리자
+ * 스냅샷 기반의 일관된 페이지네이션을 제공
+ */
+import type { PagePaginationOptions, PagePaginationResult, PaginationConfig } from './types.js';
+import type { SnapshotStore } from './snapshot-store.js';
+import type { SchemaMockGenerator } from '../client-generator.js';
+/**
+ * Page 기반 Pagination 관리자 클래스
+ */
+export declare class PagePaginationManager {
+    private generator;
+    private snapshotStore;
+    private config;
+    constructor(generator: SchemaMockGenerator, options?: {
+        snapshotStore?: SnapshotStore;
+        config?: PaginationConfig;
+    });
+    /**
+     * Page 기반 페이지 조회
+     */
+    getPagedResponse(modelName: string, options?: PagePaginationOptions): PagePaginationResult<Record<string, unknown>>;
+    /**
+     * Offset 기반 페이지 조회
+     */
+    getOffsetResponse(modelName: string, options?: {
+        offset?: number;
+        limit?: number;
+        total?: number;
+        seed?: string;
+        snapshotId?: string;
+        cache?: boolean;
+        ttl?: number;
+    }): {
+        items: Record<string, unknown>[];
+        offset: number;
+        limit: number;
+        total: number;
+        _snapshotId?: string;
+    };
+}

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

@@ -0,0 +1,96 @@
+import { DEFAULT_PAGINATION_CONFIG } from "./types.js";
+import { getSnapshotStore } from "./snapshot-store.js";
+export class PagePaginationManager {
+  generator;
+  snapshotStore;
+  config;
+  constructor(generator, options) {
+    this.generator = generator;
+    this.snapshotStore = options?.snapshotStore ?? getSnapshotStore();
+    this.config = { ...DEFAULT_PAGINATION_CONFIG, ...options?.config };
+  }
+  /**
+   * Page 기반 페이지 조회
+   */
+  getPagedResponse(modelName, options = {}) {
+    const {
+      page = 1,
+      limit = this.config.defaultLimit,
+      total = this.config.defaultTotal,
+      seed = modelName,
+      snapshotId,
+      cache = this.config.cache,
+      ttl = this.config.cacheTTL
+    } = 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 });
+    }
+    const startIndex = (page - 1) * limit;
+    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 result = {
+      items,
+      pagination: {
+        page,
+        limit,
+        total: snapshot.total,
+        totalPages: Math.ceil(snapshot.total / limit)
+      }
+    };
+    if (this.config.includeSnapshotId) {
+      result._snapshotId = snapshot.id;
+    }
+    return result;
+  }
+  /**
+   * Offset 기반 페이지 조회
+   */
+  getOffsetResponse(modelName, options = {}) {
+    const {
+      offset = 0,
+      limit = this.config.defaultLimit,
+      total = this.config.defaultTotal,
+      seed = modelName,
+      snapshotId,
+      cache = this.config.cache,
+      ttl = this.config.cacheTTL
+    } = 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 });
+    }
+    const endIndex = Math.min(offset + limit, snapshot.total);
+    const pageItemIds = snapshot.itemIds.slice(offset, endIndex);
+    const items = pageItemIds.map(
+      (itemId, i) => this.generator.generateOneWithId(modelName, itemId, `${seed}-${itemId}`, offset + i)
+    );
+    const result = {
+      items,
+      offset,
+      limit,
+      total: snapshot.total
+    };
+    if (this.config.includeSnapshotId) {
+      result._snapshotId = snapshot.id;
+    }
+    return result;
+  }
+}

package/dist/runtime/server/utils/mock/pagination/snapshot-store.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Pagination 스냅샷 저장소
+ * 일관된 페이지네이션을 위한 데이터 스냅샷 관리
+ */
+import type { MockIdConfig } from '../../../../../types.js';
+import type { PaginationSnapshot, PaginationConfig } from './types.js';
+/**
+ * 스냅샷 저장소 클래스
+ */
+export declare class SnapshotStore {
+    private snapshots;
+    private config;
+    private idConfig;
+    private cleanupInterval;
+    constructor(config?: PaginationConfig, idConfig?: MockIdConfig);
+    /**
+     * 스냅샷 키 생성
+     */
+    private getKey;
+    /**
+     * 아이템 ID 목록 생성 (MockIdConfig 기반)
+     * 실제 응답에서 사용될 ID와 동일한 값을 생성
+     */
+    private generateItemIds;
+    /**
+     * 스냅샷 가져오기 또는 생성
+     */
+    getOrCreate(modelName: string, seed: string, total: number, options?: {
+        ttl?: number;
+        cache?: boolean;
+    }): PaginationSnapshot;
+    /**
+     * 스냅샷 ID로 조회
+     */
+    getById(snapshotId: string): PaginationSnapshot | undefined;
+    /**
+     * 스냅샷 만료 여부 확인
+     */
+    private isExpired;
+    /**
+     * 만료된 스냅샷 정리
+     */
+    cleanup(): number;
+    /**
+     * 모든 스냅샷 삭제
+     */
+    clear(): void;
+    /**
+     * 스냅샷 수 조회
+     */
+    size(): number;
+    /**
+     * 정리 인터벌 중지
+     */
+    destroy(): void;
+}
+/**
+ * 기본 스냅샷 저장소 가져오기
+ */
+export declare function getSnapshotStore(config?: PaginationConfig, idConfig?: MockIdConfig): SnapshotStore;
+/**
+ * 기본 스냅샷 저장소 초기화
+ */
+export declare function resetSnapshotStore(): void;

package/dist/runtime/server/utils/mock/pagination/snapshot-store.js

@@ -0,0 +1,125 @@
+import { DEFAULT_PAGINATION_CONFIG } from "./types.js";
+import { generateSnapshotId, generateIdValue, DEFAULT_ID_CONFIG } from "../shared.js";
+export class SnapshotStore {
+  snapshots = /* @__PURE__ */ new Map();
+  config;
+  idConfig;
+  cleanupInterval = null;
+  constructor(config, idConfig) {
+    this.config = { ...DEFAULT_PAGINATION_CONFIG, ...config };
+    this.idConfig = idConfig ?? DEFAULT_ID_CONFIG;
+    if (typeof setInterval !== "undefined") {
+      this.cleanupInterval = setInterval(() => this.cleanup(), 5 * 60 * 1e3);
+    }
+  }
+  /**
+   * 스냅샷 키 생성
+   */
+  getKey(modelName, seed) {
+    return `${modelName}:${seed}`;
+  }
+  /**
+   * 아이템 ID 목록 생성 (MockIdConfig 기반)
+   * 실제 응답에서 사용될 ID와 동일한 값을 생성
+   */
+  generateItemIds(total, seed, modelName) {
+    return Array.from({ length: total }, (_, i) => {
+      const id = generateIdValue("id", i, `${seed}-${modelName}-${i}`, this.idConfig);
+      return String(id);
+    });
+  }
+  /**
+   * 스냅샷 가져오기 또는 생성
+   */
+  getOrCreate(modelName, seed, total, options) {
+    const key = this.getKey(modelName, seed);
+    const shouldCache = options?.cache ?? this.config.cache;
+    const existing = this.snapshots.get(key);
+    if (existing && !this.isExpired(existing)) {
+      existing.accessedAt = Date.now();
+      return existing;
+    }
+    const now = Date.now();
+    const ttl = options?.ttl ?? this.config.cacheTTL;
+    const snapshot = {
+      id: generateSnapshotId(),
+      modelName,
+      seed,
+      total,
+      itemIds: this.generateItemIds(total, seed, modelName),
+      createdAt: now,
+      expiresAt: shouldCache ? now + ttl : void 0,
+      accessedAt: now
+    };
+    if (shouldCache) {
+      this.snapshots.set(key, snapshot);
+    }
+    return snapshot;
+  }
+  /**
+   * 스냅샷 ID로 조회
+   */
+  getById(snapshotId) {
+    for (const snapshot of this.snapshots.values()) {
+      if (snapshot.id === snapshotId && !this.isExpired(snapshot)) {
+        snapshot.accessedAt = Date.now();
+        return snapshot;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 스냅샷 만료 여부 확인
+   */
+  isExpired(snapshot) {
+    return snapshot.expiresAt !== void 0 && Date.now() > snapshot.expiresAt;
+  }
+  /**
+   * 만료된 스냅샷 정리
+   */
+  cleanup() {
+    let cleaned = 0;
+    for (const [key, snapshot] of this.snapshots) {
+      if (this.isExpired(snapshot)) {
+        this.snapshots.delete(key);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  /**
+   * 모든 스냅샷 삭제
+   */
+  clear() {
+    this.snapshots.clear();
+  }
+  /**
+   * 스냅샷 수 조회
+   */
+  size() {
+    return this.snapshots.size;
+  }
+  /**
+   * 정리 인터벌 중지
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.clear();
+  }
+}
+let defaultStore = null;
+export function getSnapshotStore(config, idConfig) {
+  if (!defaultStore) {
+    defaultStore = new SnapshotStore(config, idConfig);
+  }
+  return defaultStore;
+}
+export function resetSnapshotStore() {
+  if (defaultStore) {
+    defaultStore.destroy();
+    defaultStore = null;
+  }
+}

package/dist/runtime/server/utils/mock/pagination/types.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Pagination 관련 타입 정의
+ */
+/**
+ * Cursor 페이로드 - 연결성 있는 cursor 데이터
+ */
+export interface CursorPayload {
+    /** 마지막 아이템 ID (anchor) */
+    lastId: string;
+    /** 방향: forward (다음) | backward (이전) */
+    direction: 'forward' | 'backward';
+    /** 스냅샷 ID (옵션) */
+    snapshotId?: string;
+    /** 생성 시간 (만료 체크용) */
+    timestamp: number;
+    /** 정렬 필드 (옵션) */
+    sortField?: string;
+    /** 정렬 순서 (옵션) */
+    sortOrder?: 'asc' | 'desc';
+}
+/**
+ * Pagination 스냅샷 - 일관된 페이지네이션을 위한 데이터 스냅샷
+ */
+export interface PaginationSnapshot {
+    /** 스냅샷 고유 ID */
+    id: string;
+    /** 모델명 */
+    modelName: string;
+    /** 생성 seed */
+    seed: string;
+    /** 총 아이템 수 */
+    total: number;
+    /** 아이템 ID 목록 (순서 보장) */
+    itemIds: string[];
+    /** 생성 시간 */
+    createdAt: number;
+    /** 만료 시간 (옵션) */
+    expiresAt?: number;
+    /** 마지막 접근 시간 */
+    accessedAt: number;
+}
+/**
+ * Page 기반 Pagination 옵션
+ */
+export interface PagePaginationOptions {
+    /** 페이지 번호 (1-based) */
+    page?: number;
+    /** 페이지 크기 */
+    limit?: number;
+    /** 총 아이템 수 */
+    total?: number;
+    /** 생성 seed */
+    seed?: string;
+    /** 스냅샷 ID (일관성 유지용) */
+    snapshotId?: string;
+    /** 캐싱 활성화 */
+    cache?: boolean;
+    /** 캐시 TTL (ms) */
+    ttl?: number;
+}
+/**
+ * Page 기반 Pagination 결과
+ */
+export interface PagePaginationResult<T> {
+    /** 아이템 목록 */
+    items: T[];
+    /** Pagination 메타데이터 */
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+    /** 스냅샷 ID (클라이언트 전달용) */
+    _snapshotId?: string;
+}
+/**
+ * Cursor 기반 Pagination 옵션
+ */
+export interface CursorPaginationOptions {
+    /** Cursor 문자열 */
+    cursor?: string;
+    /** 페이지 크기 */
+    limit?: number;
+    /** 총 아이템 수 */
+    total?: number;
+    /** 생성 seed */
+    seed?: string;
+    /** 스냅샷 ID (일관성 유지용) */
+    snapshotId?: string;
+    /** 캐싱 활성화 */
+    cache?: boolean;
+    /** 캐시 TTL (ms) */
+    ttl?: number;
+}
+/**
+ * Cursor 기반 Pagination 결과
+ */
+export interface CursorPaginationResult<T> {
+    /** 아이템 목록 */
+    items: T[];
+    /** 다음 페이지 cursor */
+    nextCursor?: string;
+    /** 이전 페이지 cursor */
+    prevCursor?: string;
+    /** 더 많은 데이터 존재 여부 */
+    hasMore: boolean;
+    /** 스냅샷 ID (클라이언트 전달용) */
+    _snapshotId?: string;
+}
+/**
+ * Pagination 설정
+ */
+export interface PaginationConfig {
+    /** 캐싱 활성화 (기본: true) */
+    cache?: boolean;
+    /** 캐시 TTL ms (기본: 1800000 = 30분) */
+    cacheTTL?: number;
+    /** 기본 총 아이템 수 (기본: 100) */
+    defaultTotal?: number;
+    /** 기본 페이지 크기 (기본: 20) */
+    defaultLimit?: number;
+    /** 응답에 snapshotId 포함 (기본: false) */
+    includeSnapshotId?: boolean;
+}
+/**
+ * Cursor 설정
+ */
+export interface CursorConfig {
+    /** 만료 활성화 (기본: true) */
+    enableExpiry?: boolean;
+    /** Cursor TTL ms (기본: 3600000 = 1시간) */
+    cursorTTL?: number;
+    /** 정렬 정보 포함 (기본: false) */
+    includeSortInfo?: boolean;
+}
+/**
+ * 기본 설정값
+ */
+export declare const DEFAULT_PAGINATION_CONFIG: Required<PaginationConfig>;
+export declare const DEFAULT_CURSOR_CONFIG: Required<CursorConfig>;

package/dist/runtime/server/utils/mock/pagination/types.js

@@ -0,0 +1,14 @@
+export const DEFAULT_PAGINATION_CONFIG = {
+  cache: true,
+  cacheTTL: 30 * 60 * 1e3,
+  // 30분
+  defaultTotal: 100,
+  defaultLimit: 20,
+  includeSnapshotId: false
+};
+export const DEFAULT_CURSOR_CONFIG = {
+  enableExpiry: true,
+  cursorTTL: 60 * 60 * 1e3,
+  // 1시간
+  includeSortInfo: false
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Proto 필드 타입에 따른 mock 값 생성
+ */
+export declare function generateMockValueForProtoField(fieldName: string, fieldType: string, seed?: number): unknown;
+/**
+ * Proto 메시지 타입에서 mock 객체 생성
+ */
+export declare function generateMockMessage(messageType: Record<string, unknown>, seed?: number): Record<string, unknown>;
+/**
+ * 요청 객체에서 seed 추출
+ */
+export declare function deriveSeedFromRequest(request: unknown): number;

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

@@ -0,0 +1,67 @@
+import { hashString, seededRandom } from "./shared.js";
+export function generateMockValueForProtoField(fieldName, fieldType, seed = 1) {
+  const fieldSeed = hashString(fieldName) + seed;
+  const random = seededRandom(fieldSeed);
+  switch (fieldType.toLowerCase()) {
+    case "string":
+      return `${fieldName}_${Math.floor(random() * 1e3)}`;
+    case "int32":
+    case "sint32":
+    case "sfixed32":
+      return Math.floor(random() * 1e4);
+    case "int64":
+    case "sint64":
+    case "sfixed64":
+      return String(Math.floor(random() * 1e7));
+    case "uint32":
+    case "fixed32":
+      return Math.floor(random() * 1e4);
+    case "uint64":
+    case "fixed64":
+      return String(Math.floor(random() * 1e7));
+    case "float":
+    case "double":
+      return Math.round(random() * 1e4) / 100;
+    case "bool":
+      return random() > 0.5;
+    case "bytes":
+      return Buffer.from(`mock_bytes_${fieldSeed}`).toString("base64");
+    default:
+      return null;
+  }
+}
+export function generateMockMessage(messageType, seed = 1) {
+  const result = {};
+  const fields = messageType.fields || {};
+  let currentSeed = seed;
+  for (const [fieldName, fieldDef] of Object.entries(fields)) {
+    const field = fieldDef;
+    let value;
+    if (field.resolvedType && typeof field.resolvedType === "object") {
+      const resolvedType = field.resolvedType;
+      if (resolvedType.values) {
+        const enumValues = Object.keys(resolvedType.values);
+        value = enumValues[0] || "UNKNOWN";
+      } else if (resolvedType.fields) {
+        value = generateMockMessage(resolvedType, currentSeed);
+      }
+    } else {
+      value = generateMockValueForProtoField(fieldName, field.type || "string", currentSeed);
+    }
+    if (field.rule === "repeated") {
+      value = [value];
+    }
+    if (field.keyType) {
+      const keyValue = field.keyType === "string" ? `key_${currentSeed}` : currentSeed;
+      value = { [keyValue]: value };
+    }
+    result[fieldName] = value;
+    currentSeed++;
+  }
+  return result;
+}
+export function deriveSeedFromRequest(request) {
+  if (!request) return 42;
+  const str = JSON.stringify(request);
+  return hashString(str) || 42;
+}

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

@@ -0,0 +1,69 @@
+/**
+ * 공통 Mock 생성 유틸리티
+ * Proto와 OpenAPI 모두에서 사용하는 기본 함수들
+ */
+import type { MockIdConfig, MockIdFormat } from '../../../../types.js';
+/**
+ * 문자열에서 해시값 생성
+ */
+export declare function hashString(str: string): number;
+/**
+ * seed 기반으로 결정론적 난수 생성 (간단한 LCG)
+ */
+export declare function seededRandom(seed: number): () => number;
+/**
+ * 시드 기반 난수 생성기 클래스
+ * OOP 스타일로 사용할 수 있는 래퍼
+ */
+export declare class SeededRandom {
+    private seed;
+    constructor(seed: number | string);
+    next(): number;
+    nextInt(min: number, max: number): number;
+    pick<T>(array: T[]): T;
+    /**
+     * 주어진 확률로 true 반환
+     */
+    chance(probability: number): boolean;
+    /**
+     * UUID v4 형식 문자열 생성 (결정론적)
+     */
+    uuid(): string;
+    /**
+     * ULID 형식 문자열 생성 (결정론적)
+     * 26자리 Base32 인코딩 (Crockford's Base32)
+     */
+    ulid(): string;
+    /**
+     * NanoID 형식 문자열 생성 (결정론적, 21자리)
+     */
+    nanoid(size?: number): string;
+    /**
+     * 짧은 해시 ID 생성 (결정론적, 8자리)
+     */
+    hashId(size?: number): string;
+}
+/**
+ * 고유 ID 생성 (결정론적)
+ */
+export declare function generateId(prefix: string, seed: number | string): string;
+/**
+ * 스냅샷 ID 생성
+ */
+export declare function generateSnapshotId(): string;
+/**
+ * 기본 ID 설정
+ */
+export declare const DEFAULT_ID_CONFIG: MockIdConfig;
+/**
+ * ID 필드 여부 확인
+ */
+export declare function isIdField(fieldName: string, config?: MockIdConfig): boolean;
+/**
+ * ID 값 생성
+ */
+export declare function generateIdValue(fieldName: string, index: number, seed: string, config?: MockIdConfig): string | number;
+/**
+ * 포맷별 ID 생성
+ */
+export declare function generateByFormat(format: MockIdFormat, index: number, rng: SeededRandom, prefix?: string): string | number;