@revolugo/common 6.14.6-beta.0 → 6.14.6

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

@@ -1,118 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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
-}