Merge pull request #120 from samchon/feat/length

`IHttpLlmFunction.name`'s maximum length limit.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samchon/openapi",
-  "version": "2.3.2",
+  "version": "2.3.3",
   "description": "OpenAPI definitions and converters for 'typia' and 'nestia'.",
   "main": "./lib/index.js",
   "module": "./lib/index.mjs",

src/HttpLlm.ts

@@ -98,7 +98,8 @@ export namespace HttpLlm {
       options: {
         ...LlmSchemaComposer.defaultConfig(props.model),
         separate: props.options?.separate ?? null,
-      },
+        maxLength: props.options?.maxLength ?? null,
+      } as any as IHttpLlmApplication.IOptions<Model>,
     });
   };
 

src/composers/HttpLlmApplicationComposer.ts

@@ -71,12 +71,15 @@ export namespace HttpLlmComposer {
         return func;
       })
       .filter((v): v is IHttpLlmFunction<Model> => v !== null);
-    return {
+
+    const app: IHttpLlmApplication<Model> = {
       model: props.model,
       options: props.options,
       functions,
       errors,
     };
+    shorten(app, props.options?.maxLength ?? 64);
+    return app;
   };
 
   const composeFunction = <Model extends ILlmSchema.Model>(props: {
@@ -230,10 +233,57 @@ export namespace HttpLlmComposer {
       operation: () => props.route.operation(),
     };
   };
+
+  export const shorten = <Model extends ILlmSchema.Model>(
+    app: IHttpLlmApplication<Model>,
+    limit: number = 64,
+  ): void => {
+    const dictionary: Set<string> = new Set();
+    const longFunctions: IHttpLlmFunction<Model>[] = [];
+    for (const func of app.functions) {
+      dictionary.add(func.name);
+      if (func.name.length > limit) {
+        longFunctions.push(func);
+      }
+    }
+    if (longFunctions.length === 0) return;
+
+    let index: number = 0;
+    for (const func of longFunctions) {
+      let success: boolean = false;
+      let rename = (str: string) => {
+        dictionary.delete(func.name);
+        dictionary.add(str);
+        func.name = str;
+        success = true;
+      };
+      for (let i: number = 1; i < func.route().accessor.length; ++i) {
+        const shortName: string = func.route().accessor.slice(i).join("_");
+        if (shortName.length > limit - 8) continue;
+        else if (dictionary.has(shortName) === false) rename(shortName);
+        else {
+          const newName: string = `_${index}_${shortName}`;
+          if (dictionary.has(newName) === true) continue;
+          rename(newName);
+          ++index;
+        }
+        break;
+      }
+      if (success === false) rename(randomFormatUuid());
+    }
+  };
 }
 
+const randomFormatUuid = (): string =>
+  "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+
 const emend = (str: string): string => {
   for (const ch of FORBIDDEN) str = str.split(ch).join("_");
   return str;
 };
+
 const FORBIDDEN = ["$", "%", "."];

src/structures/IHttpLlmApplication.ts

@@ -95,7 +95,23 @@ export interface IHttpLlmApplication<Model extends ILlmSchema.Model> {
   options: IHttpLlmApplication.IOptions<Model>;
 }
 export namespace IHttpLlmApplication {
-  export import IOptions = ILlmApplication.IOptions;
+  /**
+   * Options for the HTTP LLM application schema composition.
+   */
+  export type IOptions<Model extends ILlmSchema.Model> =
+    ILlmApplication.IOptions<Model> & {
+      /**
+       * Maximum length of function name.
+       *
+       * When a function name is longer than this value, it will be truncated.
+       *
+       * If not possible to truncate due to the duplication, the function name
+       * would be modified to randomly generated (UUID v4).
+       *
+       * @default 64
+       */
+      maxLength?: number;
+    };
 
   /**
    * Error occurred in the composition.

src/structures/IHttpLlmFunction.ts

@@ -96,6 +96,8 @@ export interface IHttpLlmFunction<Model extends ILlmSchema.Model> {
    * > - Example 2
    * >   - endpoint: `GET /shoppings/sellers/sales/:saleId/reviews/:reviewId/comments/:id
    * >   - accessor: `shoppings.sellers.sales.reviews.getBySaleIdAndReviewIdAndCommentId`
+   *
+   * @maxLength 64
    */
   name: string;
 

src/structures/ILlmFunction.ts

@@ -25,6 +25,8 @@ import { ILlmSchema } from "./ILlmSchema";
 export interface ILlmFunction<Model extends ILlmSchema.Model> {
   /**
    * Representative name of the function.
+   *
+   * @maxLength 64
    */
   name: string;
 

test/features/llm/test_http_llm_application_funtion_name_length.ts

@@ -0,0 +1,25 @@
+import { TestValidator } from "@nestia/e2e";
+import { HttpLlm, IHttpLlmApplication, OpenApi } from "@samchon/openapi";
+
+export const test_http_llm_application_funtion_name_length =
+  async (): Promise<void> => {
+    const document: OpenApi.IDocument = OpenApi.convert(
+      await fetch(
+        "https://wrtnio.github.io/connectors/swagger/swagger.json",
+      ).then((res) => res.json()),
+    );
+    const application: IHttpLlmApplication<"chatgpt"> = HttpLlm.application({
+      model: "chatgpt",
+      document,
+    });
+
+    TestValidator.predicate("overflow")(() =>
+      application.functions.some(
+        (f) => f.route().accessor.join("_").length > 64,
+      ),
+    );
+
+    const names: string[] = application.functions.map((f) => f.name);
+    TestValidator.predicate("length")(() => names.every((s) => s.length <= 64));
+    TestValidator.equals("unique")(true)(new Set(names).size === names.length);
+  };