@revolugo/common 6.14.6 → 6.15.0-beta.1

package/src/utils/case-transformers.ts

@@ -7,7 +7,7 @@ import {
 } from 'change-case'
 import slugify from 'slugify'
 
-function slugCase(input: string) {
+function slugCase(input: string): string {
   return slugify(kebabCase(input), {
     lower: true,
     strict: true,
@@ -23,7 +23,7 @@ export enum CaseTransformer {
   Snake = 'snakeCase',
 }
 
-const CASE_TRANSORMERS_MAPPING = {
+export const CASE_TRANSFORMERS_MAPPING = {
   [CaseTransformer.Camel]: camelCase,
   [CaseTransformer.Capital]: capitalCase,
   [CaseTransformer.Param]: kebabCase,
@@ -38,11 +38,11 @@ export function changeCase<T extends string | string[]>(
 ): T extends string ? string : string[] {
   if (Array.isArray(input)) {
     return input.map(item =>
-      CASE_TRANSORMERS_MAPPING[toCase](item),
+      CASE_TRANSFORMERS_MAPPING[toCase](item),
     ) as T extends string ? string : string[]
   }
 
-  return CASE_TRANSORMERS_MAPPING[toCase](input) as T extends string
+  return CASE_TRANSFORMERS_MAPPING[toCase](input) as T extends string
     ? string
     : string[]
 }
@@ -85,7 +85,7 @@ export function keysChangeCase<T>(
       const transformedKey =
         options?.exclude && matches(options.exclude, key)
           ? key
-          : CASE_TRANSORMERS_MAPPING[toCase](key)
+          : CASE_TRANSFORMERS_MAPPING[toCase](key)
 
       result[transformedKey] = options.deep
         ? keysChangeCase(obj[key], toCase, options)

package/src/utils/get-sanitized-room-count.ts

@@ -0,0 +1,29 @@
+const MAX_ADULTS_PER_ROOM = 2
+
+export function getSanitizedRoomCount({
+  adultCount,
+  maxAdultsPerRoom = MAX_ADULTS_PER_ROOM,
+  roomCount,
+}: {
+  adultCount: number
+  roomCount: number
+  maxAdultsPerRoom?: number
+}): number {
+  // Ensure at least enough rooms for each adult and at most MAX_ADULTS_PER_ROOM per room
+  if (!Number.isFinite(roomCount) || roomCount < 1) {
+    return adultCount
+  }
+
+  const minRooms = Math.ceil(adultCount / maxAdultsPerRoom)
+  const maxRooms = adultCount
+
+  if (roomCount <= minRooms) {
+    return minRooms
+  }
+
+  if (roomCount >= maxRooms) {
+    return maxRooms
+  }
+
+  return roomCount
+}

package/src/utils/images.ts

@@ -26,7 +26,7 @@ export function generateImageUrls(
   )
 }
 
-type ImageSize = 'm' | 'l' | 'xl'
+type ImageSize = 'xs' | 's' | 'm' | 'l' | 'xl'
 
 function selectBestSize(
   hotelImage: HotelImage,
@@ -46,10 +46,10 @@ export const mapImagesUrls = (
         selectBestSize(hotelImage, ['xl', 'l', 'm']),
       ),
       lowres: hotelImages.map(hotelImage =>
-        selectBestSize(hotelImage, ['l', 'xl', 'm']),
+        selectBestSize(hotelImage, ['l', 'm', 's']),
       ),
       thumbnails: hotelImages.map(hotelImage =>
-        selectBestSize(hotelImage, ['m', 'l', 'xl']),
+        selectBestSize(hotelImage, ['m', 's', 'xs']),
       ),
     }
   }

package/src/utils/index.ts

@@ -1,6 +1,7 @@
 export * from './add-classes.ts'
 export * from './amount-from-percentage.ts'
 export * from './case-transformers.ts'
+export * from './keys-case-transformer.ts'
 export * from './chunk.ts'
 export * from './colors.ts'
 export * from './compact-object.ts'
@@ -20,11 +21,13 @@ export * from './get-guest-count.ts'
 export * from './get-random-element-from-array.ts'
 export * from './get-random-hex-color.ts'
 export * from './get-random-int.ts'
+export * from './get-sanitized-room-count.ts'
 export * from './group-by.ts'
 export * from './images.ts'
 export * from './is-empty.ts'
 export * from './is-equal.ts'
 export * from './is-nil.ts'
+export * from './is-object.ts'
 export * from './key-by.ts'
 export * from './lang-default-fallbacks.ts'
 export * from './map-keys.ts'
@@ -45,6 +48,7 @@ export * from './sort-by.ts'
 export * from './sum-by.ts'
 export * from './sum.ts'
 export * from './to-boolean.ts'
+export * from './transform-schema-keys.ts'
 export * from './uniq.ts'
 export * from './uniq-by.ts'
 export * from './uniq-with.ts'

package/src/utils/is-object.ts

@@ -0,0 +1,2 @@
+export const isObject = (value: unknown): value is object =>
+  !!value && value.constructor === Object

package/src/utils/keys-case-transformer.ts

@@ -0,0 +1,118 @@
+import { type CaseTransformer, changeCase } from './case-transformers.ts'
+import { isObject } from './is-object.ts'
+import { mapKeys } from './map-keys.ts'
+
+import type {
+  CamelCasedProperties,
+  CamelCasedPropertiesDeep,
+  KebabCasedProperties,
+  KebabCasedPropertiesDeep,
+  PascalCasedProperties,
+  PascalCasedPropertiesDeep,
+  SnakeCasedProperties,
+  SnakeCasedPropertiesDeep,
+} from 'type-fest'
+
+/**
+ * Maps CaseTransformer enum to the corresponding type-fest property transformation (shallow).
+ * Capital and Slug cases don't have type-fest equivalents, so they preserve the original type.
+ */
+type TransformProperties<
+  T,
+  C extends CaseTransformer,
+> = C extends CaseTransformer.Camel
+  ? CamelCasedProperties<T>
+  : C extends CaseTransformer.Snake
+    ? SnakeCasedProperties<T>
+    : C extends CaseTransformer.Pascal
+      ? PascalCasedProperties<T>
+      : C extends CaseTransformer.Param
+        ? KebabCasedProperties<T>
+        : T
+
+/**
+ * Maps CaseTransformer enum to the corresponding type-fest deep property transformation.
+ * Capital and Slug cases don't have type-fest equivalents, so they preserve the original type.
+ */
+type TransformPropertiesDeep<
+  T,
+  C extends CaseTransformer,
+> = C extends CaseTransformer.Camel
+  ? CamelCasedPropertiesDeep<T>
+  : C extends CaseTransformer.Snake
+    ? SnakeCasedPropertiesDeep<T>
+    : C extends CaseTransformer.Pascal
+      ? PascalCasedPropertiesDeep<T>
+      : C extends CaseTransformer.Param
+        ? KebabCasedPropertiesDeep<T>
+        : T
+
+/**
+ * Transforms object keys based on the specified case transformer.
+ * - Arrays: recursively applies transformation to each element
+ * - Objects: applies property transformation (shallow by default, deep if Deep=true)
+ * - Primitives: returns as-is
+ */
+export type KeysCaseTransformed<
+  T,
+  C extends CaseTransformer,
+  Deep extends boolean = false,
+> = Deep extends true
+  ? T extends readonly (infer U)[]
+    ? KeysCaseTransformed<U, C, true>[]
+    : T extends object
+      ? TransformPropertiesDeep<T, C>
+      : T
+  : T extends readonly (infer U)[]
+    ? KeysCaseTransformed<U, C>[]
+    : T extends object
+      ? TransformProperties<T, C>
+      : T
+
+export interface KeysCaseTransformerOptions {
+  deep?: boolean
+}
+
+// Overload: deep transformation
+export function keysCaseTransformer<T, C extends CaseTransformer>(
+  obj: T,
+  toCase: C,
+  options: { deep: true },
+): KeysCaseTransformed<T, C, true>
+
+// Overload: shallow transformation (default)
+export function keysCaseTransformer<T, C extends CaseTransformer>(
+  obj: T,
+  toCase: C,
+  options?: { deep?: false },
+): KeysCaseTransformed<T, C>
+
+// Implementation
+export function keysCaseTransformer<T, C extends CaseTransformer>(
+  obj: T,
+  toCase: C,
+  options?: KeysCaseTransformerOptions,
+): KeysCaseTransformed<T, C, boolean> {
+  if (Array.isArray(obj)) {
+    return obj.map(item =>
+      keysCaseTransformer(item, toCase, options as { deep: true }),
+    ) as KeysCaseTransformed<T, C, boolean>
+  }
+
+  if (isObject(obj)) {
+    const transformed = mapKeys(obj, key => changeCase(key, toCase))
+    if (options?.deep) {
+      // Recursively transform nested values
+      return Object.fromEntries(
+        Object.entries(transformed).map(([k, v]) => [
+          k,
+          keysCaseTransformer(v, toCase, options as { deep: true }),
+        ]),
+      ) as KeysCaseTransformed<T, C, boolean>
+    }
+
+    return transformed as KeysCaseTransformed<T, C, boolean>
+  }
+
+  return obj as KeysCaseTransformed<T, C, boolean>
+}

package/src/utils/transform-schema-keys.ts

@@ -0,0 +1,143 @@
+import { type ZodTypeAny, z } from 'zod'
+
+import {
+  CASE_TRANSFORMERS_MAPPING,
+  type CaseTransformer,
+} from './case-transformers.ts'
+
+/* eslint-disable no-underscore-dangle, max-statements */
+
+function transformSchemaKeysWithTransformer(
+  schema: ZodTypeAny,
+  transformer: (str: string) => string,
+): ZodTypeAny {
+  let result: ZodTypeAny = schema
+
+  // Handle ZodObject
+  if (schema instanceof z.ZodObject) {
+    const shape = schema._def.shape()
+    const transformedShape: Record<string, ZodTypeAny> = {}
+
+    for (const key in shape) {
+      if (Object.hasOwn(shape, key)) {
+        const transformedKey = transformer(key)
+        transformedShape[transformedKey] = transformSchemaKeysWithTransformer(
+          shape[key],
+          transformer,
+        )
+      }
+    }
+
+    result = z.object(transformedShape) as ZodTypeAny
+  }
+
+  // Handle ZodArray
+  else if (schema instanceof z.ZodArray) {
+    const { type: elementSchema } = schema._def
+    result = z.array(
+      transformSchemaKeysWithTransformer(elementSchema, transformer),
+    )
+  }
+
+  // Handle ZodOptional
+  else if (schema instanceof z.ZodOptional) {
+    const { innerType: innerSchema } = schema._def
+    result = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    ).optional()
+  }
+
+  // Handle ZodNullable
+  else if (schema instanceof z.ZodNullable) {
+    const { innerType: innerSchema } = schema._def
+    result = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    ).nullable()
+  }
+
+  // Handle ZodDefault
+  else if (schema instanceof z.ZodDefault) {
+    const { defaultValue, innerType: innerSchema } = schema._def
+    result = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    ).default(defaultValue())
+  }
+
+  // Handle ZodEffects (includes .refine(), .transform(), etc.)
+  else if (schema instanceof z.ZodEffects) {
+    const { schema: innerSchema } = schema._def
+    const transformedInner = transformSchemaKeysWithTransformer(
+      innerSchema,
+      transformer,
+    )
+
+    // We need to reconstruct the effects
+    // This is a simplified version - effects are not transformed, just passed through
+    result = transformedInner
+  }
+
+  // Handle ZodUnion
+  else if (schema instanceof z.ZodUnion) {
+    const { options } = schema._def
+    const transformedOptions = options.map((option: ZodTypeAny) =>
+      transformSchemaKeysWithTransformer(option, transformer),
+    )
+    result = z.union(
+      transformedOptions as [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]],
+    )
+  }
+
+  // Handle ZodIntersection
+  else if (schema instanceof z.ZodIntersection) {
+    const { left, right } = schema._def
+    result = z.intersection(
+      transformSchemaKeysWithTransformer(left, transformer),
+      transformSchemaKeysWithTransformer(right, transformer),
+    )
+  }
+
+  // Propagate openapi metadata
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const { openapi } = schema._def as any
+  if (openapi && result !== schema) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(result._def as any).openapi = openapi
+  }
+
+  return result
+}
+
+/**
+ * Transforms all keys in a Zod schema from one case to another (e.g., snake_case to camelCase).
+ * This function recursively transforms all nested schemas as well.
+ *
+ * @param schema - The Zod schema to transform
+ * @param toCase - The target case (e.g., CaseTransformer.Camel)
+ * @returns A new Zod schema with transformed keys
+ *
+ * @example
+ * ```ts
+ * const snakeSchema = z.object({
+ *   first_name: z.string(),
+ *   last_name: z.string(),
+ * })
+ *
+ * const camelSchema = transformSchemaKeys(snakeSchema, CaseTransformer.Camel)
+ * // Results in: { firstName: z.string(), lastName: z.string() }
+ * ```
+ */
+export function transformSchemaKeys<T extends ZodTypeAny>(
+  schema: T,
+  toCase: CaseTransformer,
+): T {
+  const transformer = CASE_TRANSFORMERS_MAPPING[toCase]
+
+  if (!transformer) {
+    throw new Error(`Unsupported case transformer: ${toCase}`)
+  }
+
+  return transformSchemaKeysWithTransformer(schema, transformer) as T
+}