feat(utils): add buildEnumObject function and update imports

- Implement buildEnumObject to create an object from enum values.
- Update openapi and swagger handleJson to use buildEnumObject.
- Refactor inflection imports to use named imports instead of default import
- Small refactors
- Add TSDoc for the getTYpe util function

Signed-off-by: J3m5 <5523410+J3m5@users.noreply.github.com>

Author: J3m5

src/core/utils/buildEnumObject.ts

@@ -0,0 +1,25 @@
+import { humanize } from "inflection";
+
+/**
+ * Builds an object from an array of enum values.
+ * The keys of the object are the humanized versions of the enum values,
+ * and the values are the original enum values.
+ *
+ * @param enumArray - An array of enum values.
+ * @returns An object mapping humanized enum names to their original values, or null if the input is empty.
+ */
+export function buildEnumObject(
+  enumArray: any[] | undefined,
+): Record<string, string | number> | null {
+  if (!enumArray || enumArray.length === 0) {
+    return null;
+  }
+
+  return Object.fromEntries(
+    // Object.values is used because the array is annotated: it contains the __meta symbol used by jsonref.
+    Object.values(enumArray).map((enumValue: string | number) => [
+      typeof enumValue === "string" ? humanize(enumValue) : enumValue,
+      enumValue,
+    ]),
+  );
+}

src/core/utils/getType.ts

@@ -1,14 +1,24 @@
-import inflection from "inflection";
+import { camelize } from "inflection";
 import type { FieldType } from "../Field.js";
 
+/**
+ * Returns the corresponding FieldType for a given OpenAPI type and optional format.
+ *
+ * If a format is provided, it will map certain formats (e.g., "int32", "int64") to "integer".
+ * Otherwise, it will camelize the format string. If no format is provided, it returns the OpenAPI type.
+ *
+ * @param openApiType - The OpenAPI type string.
+ * @param format - An optional format string.
+ * @returns The mapped FieldType.
+ */
 export function getType(openApiType: string, format?: string): FieldType {
   if (format) {
     switch (format) {
       case "int32":
       case "int64":
         return "integer";
       default:
-        return inflection.camelize(format.replace("-", "_"), true);
+        return camelize(format.replace("-", "_"), true);
     }
   }
 

src/core/utils/index.ts

@@ -1,4 +1,5 @@
 export { assignSealed } from "./assignSealed.js";
+export { buildEnumObject } from "./buildEnumObject.js";
 export { getResourcePaths } from "./getResourcePaths.js";
 export { getType } from "./getType.js";
 export { parsedJsonReplacer } from "./parsedJsonReplacer.js";

src/openapi3/handleJson.ts

@@ -1,11 +1,12 @@
-import inflection from "inflection";
+import { camelize, classify, pluralize } from "inflection";
 import type { ParseOptions } from "jsonref";
 import { parse } from "jsonref";
 import type { OpenAPIV3 } from "openapi-types";
 import type { OperationType } from "../core/index.js";
 import { Field, Operation, Parameter, Resource } from "../core/index.js";
 import {
-getResourcePaths,
+  buildEnumObject,
+  getResourcePaths,
   getType,
   removeTrailingSlash,
 } from "../core/utils/index.js";
@@ -39,21 +40,6 @@ function mergeResources(resourceA: Resource, resourceB: Resource) {
   return resourceA;
 }
 
-function buildEnumObject(enumArray: SchemaObjectDereferenced["enum"]) {
-  if (!enumArray) {
-    return null;
-  }
-  return Object.fromEntries(
-    // Object.values is used because the array is annotated: it contains the __meta symbol used by jsonref.
-    Object.values(enumArray).map((enumValue) => [
-      typeof enumValue === "string"
-        ? inflection.humanize(enumValue)
-        : enumValue,
-      enumValue,
-    ]),
-  );
-}
-
 function getArrayType(property: SchemaObjectDereferenced) {
   if (property.type !== "array") {
     return null;
@@ -159,14 +145,14 @@ export default async function handleJson(
       throw new Error("Invalid path: " + path);
     }
 
-    const name = inflection.pluralize(baseName);
+    const name = pluralize(baseName);
     const url = `${removeTrailingSlash(serverUrl)}/${name}`;
     const pathItem = document.paths[path];
     if (!pathItem) {
       throw new Error();
     }
 
-    const title = inflection.classify(baseName);
+    const title = classify(baseName);
 
     const showOperation = pathItem.get;
     const editOperation = pathItem.put || pathItem.patch;
@@ -198,12 +184,15 @@ export default async function handleJson(
       resource = mergeResources(showResource, editResource);
     }
 
-    const putOperation = pathItem.put;
-    const patchOperation = pathItem.patch;
-    const deleteOperation = pathItem.delete;
+    const {
+      put: putOperation,
+      patch: patchOperation,
+      delete: deleteOperation,
+    } = pathItem;
     const pathCollection = document.paths[`/${name}`];
     const listOperation = pathCollection && pathCollection.get;
     const createOperation = pathCollection && pathCollection.post;
+
     resource.operations = [
       ...(showOperation
         ? [buildOperationFromPathItem("get", "show", showOperation)]
@@ -244,10 +233,10 @@ export default async function handleJson(
   // Guess embeddeds and references from property names
   for (const resource of resources) {
     for (const field of resource.fields ?? []) {
-      const name = inflection.camelize(field.name).replace(/Ids?$/, "");
+      const name = camelize(field.name).replace(/Ids?$/, "");
 
       const guessedResource = resources.find(
-        (res) => res.title === inflection.classify(name),
+        (res) => res.title === classify(name),
       );
       if (!guessedResource) {
         continue;

src/swagger/handleJson.ts

@@ -1,7 +1,8 @@
-import inflection from "inflection";
+import { classify, pluralize } from "inflection";
 import type { OpenAPIV2 } from "openapi-types";
 import { Field, Resource } from "../core/index.js";
 import {
+  buildEnumObject,
   getResourcePaths,
   getType,
   removeTrailingSlash,
@@ -20,10 +21,10 @@ export default function handleJson(
       throw new Error("Invalid path: " + path);
     }
 
-    const name = inflection.pluralize(baseName);
+    const name = pluralize(baseName);
     const url = `${removeTrailingSlash(entrypointUrl)}/${name}`;
 
-    const title = inflection.classify(baseName);
+    const title = classify(baseName);
 
     if (!response.definitions) {
       throw new Error(); // @TODO
@@ -52,16 +53,7 @@ export default function handleJson(
             typeof property?.type === "string" ? property.type : "",
             property?.["format"] ?? "",
           ),
-          enum: property.enum
-            ? Object.fromEntries(
-                property.enum.map((enumValue: string | number) => [
-                  typeof enumValue === "string"
-                    ? inflection.humanize(enumValue)
-                    : enumValue,
-                  enumValue,
-                ]),
-              )
-            : null,
+          enum: buildEnumObject(property.enum),
           reference: null,
           embedded: null,
           required: requiredFields.some((value) => value === fieldName),