{"version":3,"file":"denormalizer.mjs","sources":["../../../../src/lib/data/normalization/denormalizer.ts"],"sourcesContent":["/**\n * @file Entity Denormalizer\n * @description Transform normalized data back to nested structures\n * with selective denormalization and caching support.\n *\n * Features:\n * - Reconstruct nested objects from normalized state\n * - Selective field denormalization\n * - Circular reference handling\n * - Memoization for performance\n * - Partial denormalization\n *\n * @example\n * ```typescript\n * import { denormalize, schema } from '@/lib/data/normalization';\n *\n * const post = denormalize('101', postSchema, entities);\n * // Reconstructs: { id: '101', author: { id: '1', name: 'John' }, ... }\n * ```\n */\n\nimport type {\n  Entity,\n  // EntityMap,\n  NormalizedEntities,\n  EntitySchema,\n  ArraySchema,\n  ObjectSchema,\n  UnionSchema,\n  Schema,\n} from './normalizer';\n\n// =============================================================================\n// TYPES\n// =============================================================================\n\n/**\n * Denormalization options\n */\nexport interface DenormalizeOptions {\n  /** Maximum depth to denormalize (default: Infinity) */\n  maxDepth?: number;\n  /** Fields to include in denormalization */\n  includeFields?: string[];\n  /** Fields to exclude from denormalization */\n  excludeFields?: string[];\n  /** Enable memoization */\n  memoize?: boolean;\n  /** Circular reference handling */\n  circularBehavior?: 'skip' | 'id-only' | 'shallow';\n}\n\n/**\n * Denormalization context\n */\ninterface DenormalizeContext {\n  entities: NormalizedEntities;\n  visited: Set<string>;\n  depth: number;\n  options: Required<DenormalizeOptions>;\n  cache: Map<string, Entity>;\n}\n\n// =============================================================================\n// DEFAULT OPTIONS\n// =============================================================================\n\nconst DEFAULT_OPTIONS: Required<DenormalizeOptions> = {\n  maxDepth: Infinity,\n  includeFields: [],\n  excludeFields: [],\n  memoize: true,\n  circularBehavior: 'id-only',\n};\n\n// =============================================================================\n// DENORMALIZER\n// =============================================================================\n\n/**\n * Create denormalization context\n */\nfunction createContext(\n  entities: NormalizedEntities,\n  options: DenormalizeOptions\n): DenormalizeContext {\n  return {\n    entities,\n    visited: new Set(),\n    depth: 0,\n    options: { ...DEFAULT_OPTIONS, ...options },\n    cache: new Map(),\n  };\n}\n\n/**\n * Get cache key for entity\n */\nfunction getCacheKey(entityType: string, id: string, depth: number): string {\n  return `${entityType}:${id}:${depth}`;\n}\n\n/**\n * Check if field should be included\n */\nfunction shouldIncludeField(field: string, options: Required<DenormalizeOptions>): boolean {\n  if (options.excludeFields.includes(field)) {\n    return false;\n  }\n  if (options.includeFields.length > 0) {\n    return options.includeFields.includes(field);\n  }\n  return true;\n}\n\n/**\n * Denormalize a value with schema\n */\nfunction denormalizeValue(value: unknown, schema: Schema, context: DenormalizeContext): unknown {\n  if (value === null || value === undefined) {\n    return value;\n  }\n\n  switch (schema._type) {\n    case 'entity':\n      return denormalizeEntityInternal(value as string, schema, context);\n\n    case 'array':\n      return denormalizeArray(value as unknown[], schema, context);\n\n    case 'object':\n      return denormalizeObject(value as Record<string, unknown>, schema, context);\n\n    case 'union':\n      return denormalizeUnion(value as string, schema, context);\n\n    case 'value':\n      return value;\n\n    default:\n      return value;\n  }\n}\n\n/**\n * Denormalize an entity (internal helper)\n */\nfunction denormalizeEntityInternal(\n  id: string | Entity,\n  entitySchema: EntitySchema,\n  context: DenormalizeContext\n): Entity | string | null {\n  // Handle already denormalized entity\n  if (typeof id === 'object' && id !== null) {\n    return id;\n  }\n\n  const entityId = String(id);\n  const entityType = entitySchema.name;\n  const visitKey = `${entityType}:${entityId}`;\n\n  // Check max depth\n  if (context.depth > context.options.maxDepth) {\n    return entityId;\n  }\n\n  // Check for circular reference\n  if (context.visited.has(visitKey)) {\n    switch (context.options.circularBehavior) {\n      case 'skip':\n        return null;\n      case 'id-only':\n        return entityId;\n      case 'shallow': {\n        // Return entity without relations\n        const entity = context.entities[entityType]?.[entityId];\n        return entity ? { ...entity } : entityId;\n      }\n    }\n  }\n\n  // Check cache\n  if (context.options.memoize) {\n    const cacheKey = getCacheKey(entityType, entityId, context.depth);\n    const cached = context.cache.get(cacheKey);\n    if (cached) {\n      return cached;\n    }\n  }\n\n  // Get normalized entity\n  const normalizedEntity = context.entities[entityType]?.[entityId];\n  if (!normalizedEntity) {\n    return entityId;\n  }\n\n  // Mark as visited\n  context.visited.add(visitKey);\n\n  // Create denormalized entity\n  const denormalized: Entity = { id: entityId };\n\n  // Increment depth\n  const childContext: DenormalizeContext = {\n    ...context,\n    depth: context.depth + 1,\n    visited: new Set(context.visited),\n  };\n\n  // Process fields\n  for (const [key, value] of Object.entries(normalizedEntity)) {\n    if (!shouldIncludeField(key, context.options)) {\n      continue;\n    }\n\n    if (key in entitySchema.relations) {\n      // Denormalize relationship\n      const relationSchema = entitySchema.relations[key];\n      if (relationSchema) {\n        denormalized[key] = denormalizeValue(value, relationSchema, childContext);\n      }\n    } else {\n      // Copy value\n      denormalized[key] = value;\n    }\n  }\n\n  // Cache result\n  if (context.options.memoize) {\n    const cacheKey = getCacheKey(entityType, entityId, context.depth);\n    context.cache.set(cacheKey, denormalized);\n  }\n\n  // Unmark as visited\n  context.visited.delete(visitKey);\n\n  return denormalized;\n}\n\n/**\n * Denormalize an array\n */\nfunction denormalizeArray(\n  items: unknown[],\n  arraySchema: ArraySchema,\n  context: DenormalizeContext\n): unknown[] {\n  return items\n    .map((item) => denormalizeValue(item, arraySchema.schema, context))\n    .filter((item) => item !== null);\n}\n\n/**\n * Denormalize an object\n */\nfunction denormalizeObject(\n  obj: Record<string, unknown>,\n  objectSchema: ObjectSchema,\n  context: DenormalizeContext\n): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (!shouldIncludeField(key, context.options)) {\n      continue;\n    }\n\n    if (key in objectSchema.schema) {\n      const fieldSchema = objectSchema.schema[key];\n      if (fieldSchema) {\n        result[key] = denormalizeValue(value, fieldSchema, context);\n      }\n    } else {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Denormalize a union type\n */\nfunction denormalizeUnion(\n  id: string,\n  unionSchema: UnionSchema,\n  context: DenormalizeContext\n): Entity | string | null {\n  // Try each schema in the union\n  for (const entitySchema of Object.values(unionSchema.schemas)) {\n    const entity = context.entities[entitySchema.name]?.[id];\n    if (entity) {\n      return denormalizeEntityInternal(id, entitySchema, context);\n    }\n  }\n\n  return id;\n}\n\n// =============================================================================\n// PUBLIC API\n// =============================================================================\n\n/**\n * Denormalize data from normalized state\n *\n * @param input - ID(s) or normalized reference\n * @param inputSchema\n * @param entities - Normalized entities\n * @param options - Denormalization options\n * @returns Denormalized data\n *\n * @example\n * ```typescript\n * // Single entity\n * const user = denormalize('1', userSchema, entities);\n *\n * // Multiple entities\n * const users = denormalize(['1', '2'], schema.array(userSchema), entities);\n *\n * // With options\n * const user = denormalize('1', userSchema, entities, {\n *   maxDepth: 2,\n *   excludeFields: ['password'],\n * });\n * ```\n */\nexport function denormalize<T = unknown>(\n  input: unknown,\n  inputSchema: Schema,\n  entities: NormalizedEntities,\n  options: DenormalizeOptions = {}\n): T | null {\n  if (input === null || input === undefined) {\n    return null;\n  }\n\n  const context = createContext(entities, options);\n  return denormalizeValue(input, inputSchema, context) as T;\n}\n\n/**\n * Denormalize a single entity by type and ID\n *\n * @param entityType - Entity type name\n * @param id - Entity ID\n * @param schema - Entity schema\n * @param entities - Normalized entities\n * @param options - Denormalization options\n * @returns Denormalized entity\n */\nexport function denormalizeEntity<T extends Entity>(\n  entityType: string,\n  id: string,\n  schema: EntitySchema,\n  entities: NormalizedEntities,\n  options: DenormalizeOptions = {}\n): T | null {\n  if (schema.name !== entityType) {\n    console.warn(`[Denormalizer] Schema name mismatch: ${schema.name} !== ${entityType}`);\n  }\n\n  return denormalize<T>(id, schema, entities, options);\n}\n\n/**\n * Denormalize multiple entities\n *\n * @param ids - Array of entity IDs\n * @param schema - Entity schema\n * @param entities - Normalized entities\n * @param options - Denormalization options\n * @returns Array of denormalized entities\n */\nexport function denormalizeMany<T extends Entity>(\n  ids: string[],\n  schema: EntitySchema,\n  entities: NormalizedEntities,\n  options: DenormalizeOptions = {}\n): T[] {\n  const context = createContext(entities, options);\n  return ids\n    .map((id) => denormalizeEntity<T>(id, schema, context))\n    .filter((entity): entity is T => entity !== null);\n\n  function denormalizeEntity<U extends Entity>(\n    id: string,\n    entitySchema: EntitySchema,\n    ctx: DenormalizeContext\n  ): U | null {\n    return denormalizeValue(id, entitySchema, ctx) as U | null;\n  }\n}\n\n/**\n * Create a memoized denormalizer for a specific schema\n *\n * @param defaultOptions\n * @param inputSchema\n * @param defaultOptions\n */\nexport function createDenormalizer<T = unknown>(\n  inputSchema: Schema,\n  defaultOptions: DenormalizeOptions = {}\n): (input: unknown, entities: NormalizedEntities, options?: DenormalizeOptions) => T | null {\n  const cache = new Map<string, T>();\n\n  return (input, entities, options = {}) => {\n    const mergedOptions = { ...defaultOptions, ...options };\n\n    // Generate cache key\n    const cacheKey = JSON.stringify({ input, options: mergedOptions });\n\n    if (mergedOptions.memoize !== false && cache.has(cacheKey)) {\n      return cache.get(cacheKey) as T;\n    }\n\n    const result = denormalize<T>(input, inputSchema, entities, mergedOptions);\n\n    if (mergedOptions.memoize !== false && result !== null) {\n      cache.set(cacheKey, result);\n    }\n\n    return result;\n  };\n}\n\n/**\n * Denormalize with field selection (GraphQL-like)\n *\n * @param input - ID(s) or normalized reference\n * @param inputSchema\n * @param entities - Normalized entities\n * @param fields - Fields to include\n * @returns Denormalized data with selected fields\n */\nexport function denormalizeSelect<T = unknown>(\n  input: unknown,\n  inputSchema: Schema,\n  entities: NormalizedEntities,\n  fields: string[]\n): T | null {\n  return denormalize<T>(input, inputSchema, entities, {\n    includeFields: fields,\n  });\n}\n\n/**\n * Shallow denormalize (only first level)\n *\n * @param input - ID(s) or normalized reference\n * @param inputSchema\n * @param entities - Normalized entities\n * @returns Shallowly denormalized data\n */\nexport function denormalizeShallow<T = unknown>(\n  input: unknown,\n  inputSchema: Schema,\n  entities: NormalizedEntities\n): T | null {\n  return denormalize<T>(input, inputSchema, entities, {\n    maxDepth: 1,\n  });\n}\n\n/**\n * Check if entities contain all required data for denormalization\n *\n * @param input - ID(s) to check\n * @param inputSchema\n * @param entities - Normalized entities\n * @returns Whether all required entities exist\n */\nexport function canDenormalize(\n  input: unknown,\n  inputSchema: Schema,\n  entities: NormalizedEntities\n): boolean {\n  if (input === null || input === undefined) {\n    return true;\n  }\n\n  function checkValue(value: unknown, schema: Schema): boolean {\n    switch (schema._type) {\n      case 'entity': {\n        const entitySchema = schema;\n        const id = String(value);\n        return !!entities[entitySchema.name]?.[id];\n      }\n\n      case 'array': {\n        const arraySchema = schema;\n        return (value as unknown[]).every((item) => checkValue(item, arraySchema.schema));\n      }\n\n      case 'object': {\n        const objectSchema = schema;\n        const obj = value as Record<string, unknown>;\n        return Object.entries(objectSchema.schema).every(([key, fieldSchema]) =>\n          checkValue(obj[key], fieldSchema)\n        );\n      }\n\n      case 'union': {\n        const unionSchema = schema;\n        const id = String(value);\n        return Object.values(unionSchema.schemas).some(\n          (entitySchema) => !!entities[entitySchema.name]?.[id]\n        );\n      }\n\n      case 'value':\n        return true;\n\n      default:\n        return true;\n    }\n  }\n\n  return checkValue(input, inputSchema);\n}\n"],"names":["DEFAULT_OPTIONS","createContext","entities","options","getCacheKey","entityType","id","depth","shouldIncludeField","field","denormalizeValue","value","schema","context","denormalizeEntityInternal","denormalizeArray","denormalizeObject","denormalizeUnion","entitySchema","entityId","visitKey","entity","cacheKey","cached","normalizedEntity","denormalized","childContext","key","relationSchema","items","arraySchema","item","obj","objectSchema","result","fieldSchema","unionSchema","denormalize","input","inputSchema","denormalizeEntity","denormalizeMany","ids","ctx","createDenormalizer","defaultOptions","cache","mergedOptions","denormalizeSelect","fields","denormalizeShallow","canDenormalize","checkValue"],"mappings":"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"}