@twin.org/ts-to-openapi 0.0.1 → 0.0.2-next.10

package/dist/cjs/index.cjs

@@ -5,6 +5,7 @@ var node_url = require('node:url');
 var cliCore = require('@twin.org/cli-core');
 var promises = require('node:fs/promises');
 var core = require('@twin.org/core');
+var toolsCore = require('@twin.org/tools-core');
 var web = require('@twin.org/web');
 var tsJsonSchemaGenerator = require('ts-json-schema-generator');
 
@@ -31,7 +32,7 @@ const HTTP_STATUS_CODE_MAP = {
         responseType: "IBadRequestResponse",
         example: {
             name: "GeneralError",
-            message: "component.error",
+            message: "errorMessage",
             properties: {
                 foo: "bar"
             }
@@ -42,7 +43,7 @@ const HTTP_STATUS_CODE_MAP = {
         responseType: "IUnauthorizedResponse",
         example: {
             name: "UnauthorizedError",
-            message: "component.error"
+            message: "errorMessage"
         }
     },
     forbidden: {
@@ -50,7 +51,7 @@ const HTTP_STATUS_CODE_MAP = {
         responseType: "IForbiddenResponse",
         example: {
             name: "NotImplementedError",
-            message: "component.error",
+            message: "errorMessage",
             properties: {
                 method: "aMethod"
             }
@@ -61,7 +62,7 @@ const HTTP_STATUS_CODE_MAP = {
         responseType: "INotFoundResponse",
         example: {
             name: "NotFoundError",
-            message: "component.error",
+            message: "errorMessage",
             properties: {
                 notFoundId: "1"
             }
@@ -72,7 +73,7 @@ const HTTP_STATUS_CODE_MAP = {
         responseType: "IConflictResponse",
         example: {
             name: "ConflictError",
-            message: "component.error",
+            message: "errorMessage",
             properties: {
                 conflicts: ["1"]
             }
@@ -83,7 +84,7 @@ const HTTP_STATUS_CODE_MAP = {
         responseType: "IInternalServerErrorResponse",
         example: {
             name: "InternalServerError",
-            message: "component.error"
+            message: "errorMessage"
         }
     },
     unprocessableEntity: {
@@ -91,7 +92,7 @@ const HTTP_STATUS_CODE_MAP = {
         responseType: "IUnprocessableEntityResponse",
         example: {
             name: "UnprocessableError",
-            message: "component.error"
+            message: "errorMessage"
         }
     }
 };
@@ -195,7 +196,7 @@ async function tsToOpenApi(config, outputFile, workingDirectory) {
         compilerOptions: {}
     }, undefined, "\t"));
     const openApi = {
-        openapi: "3.1.0",
+        openapi: toolsCore.OpenApiHelper.API_VERSION,
         info: {
             title: config.title,
             description: config.description,
@@ -239,7 +240,20 @@ async function tsToOpenApi(config, outputFile, workingDirectory) {
         }
     }
     cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.ts-to-openapi.progress.generatingSchemas"));
-    const schemas = await generateSchemas(typeRoots, types, workingDirectory);
+    const autoExpandTypes = config.autoExpandTypes ?? [];
+    const defaultExpandTypes = ["/ObjectOrArray<.*>/"];
+    for (const defaultType of defaultExpandTypes) {
+        if (!autoExpandTypes.includes(defaultType)) {
+            autoExpandTypes.push(defaultType);
+        }
+    }
+    const schemas = await generateSchemas(typeRoots, types, autoExpandTypes, workingDirectory);
+    for (const type in schemas) {
+        if (core.Is.object(config.overrides?.[type])) {
+            cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.ts-to-openapi.progress.overridingSchema"));
+            schemas[type] = config.overrides?.[type];
+        }
+    }
     const usedCommonResponseTypes = [];
     for (let i = 0; i < inputResults.length; i++) {
         const result = inputResults[i];
@@ -424,12 +438,13 @@ async function tsToOpenApi(config, outputFile, workingDirectory) {
             if (requestObject?.properties) {
                 // If there are any properties other than body, query, pathParams and headers
                 // we should throw an error as we don't know what to do with them
-                const otherKeys = Object.keys(requestObject.properties).filter(k => !["body", "query", "pathParams", "headers"].includes(k));
+                const otherKeys = Object.keys(requestObject.properties).filter(k => !["body", "query", "pathParams", "headers", "authentication"].includes(k));
                 if (otherKeys.length > 0) {
                     throw new core.GeneralError("commands", "commands.ts-to-openapi.unsupportedProperties", {
                         keys: otherKeys.join(", ")
                     });
                 }
+                delete requestObject.properties.authentication;
                 // If there is a path params object convert these to params
                 if (core.Is.object(requestObject.properties.pathParams)) {
                     for (const pathParam of pathQueryHeaderParams) {
@@ -586,7 +601,7 @@ async function tsToOpenApi(config, outputFile, workingDirectory) {
             }
         }
     }
-    await finaliseOutput(usedCommonResponseTypes, schemas, openApi, securitySchemes, config.externalReferences, outputFile);
+    await finaliseOutput(usedCommonResponseTypes, schemas, openApi, securitySchemes, config.externalReferences, autoExpandTypes, outputFile);
 }
 /**
  * Finalise the schemas and output the spec.
@@ -595,9 +610,10 @@ async function tsToOpenApi(config, outputFile, workingDirectory) {
  * @param openApi The OpenAPI spec.
  * @param securitySchemes The security schemes.
  * @param externalReferences The external references.
+ * @param autoExpandTypes The auto expand types.
  * @param outputFile The output file.
  */
-async function finaliseOutput(usedCommonResponseTypes, schemas, openApi, securitySchemes, externalReferences, outputFile) {
+async function finaliseOutput(usedCommonResponseTypes, schemas, openApi, securitySchemes, externalReferences, autoExpandTypes, outputFile) {
     cliCore.CLIDisplay.break();
     cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.ts-to-openapi.progress.finalisingSchemas"));
     // Remove the response codes that we haven't used
@@ -638,6 +654,15 @@ async function finaliseOutput(usedCommonResponseTypes, schemas, openApi, securit
                 }
             }
         }
+        // We can remove any auto expand types from the final schema as they
+        // will have been expanded inline so no need to keep them
+        for (const autoExpandType of autoExpandTypes) {
+            const regExp = toolsCore.JsonSchemaHelper.stringToRegEx(autoExpandType);
+            if (regExp.test(schema)) {
+                skipSchema = true;
+                break;
+            }
+        }
         if (!skipSchema) {
             // If the final schema has no properties and is just a ref to another object type
             // then replace the references with that of the referenced type
@@ -651,7 +676,6 @@ async function finaliseOutput(usedCommonResponseTypes, schemas, openApi, securit
                 if (/I[A-Z]/.test(finalName)) {
                     finalName = finalName.slice(1);
                 }
-                finalName = finalName.replace("<", "_").replace(">", "_");
                 if (finalName.endsWith("[]")) {
                     finalName = `ListOf${finalName.slice(0, -2)}`;
                 }
@@ -665,7 +689,7 @@ async function finaliseOutput(usedCommonResponseTypes, schemas, openApi, securit
         delete finalSchemas[type];
     }
     for (const type in finalSchemas) {
-        processArrays(finalSchemas[type]);
+        toolsCore.JsonSchemaHelper.processArrays(finalSchemas[type]);
     }
     const schemaKeys = Object.keys(finalSchemas);
     schemaKeys.sort();
@@ -698,7 +722,7 @@ async function finaliseOutput(usedCommonResponseTypes, schemas, openApi, securit
     // Remove the array [] from the type names
     // eslint-disable-next-line unicorn/better-regex
     json = json.replace(/#\/components\/schemas\/(.*)\[\]/g, "#/components/schemas/ListOf$1");
-    json = normaliseTypeName(json);
+    json = toolsCore.JsonSchemaHelper.normaliseTypeName(json);
     // Remove external references
     for (const finalExternal in finalExternals) {
         json = json.replace(new RegExp(`"#/components/schemas/${core.StringHelper.stripPrefix(finalExternal)}"`, "g"), `"${finalExternals[finalExternal]}"`);
@@ -828,7 +852,7 @@ async function processPackageRestDetails(restRoutes) {
  * @returns Nothing.
  * @internal
  */
-async function generateSchemas(modelDirWildcards, types, outputWorkingDir) {
+async function generateSchemas(modelDirWildcards, types, autoExpandTypes, outputWorkingDir) {
     const allSchemas = {};
     const arraySingularTypes = [];
     for (const type of types) {
@@ -852,13 +876,14 @@ async function generateSchemas(modelDirWildcards, types, outputWorkingDir) {
         const schema = generator.createSchema("*");
         if (schema.definitions) {
             for (const def in schema.definitions) {
-                const defSub = normaliseTypeName(def);
+                const defSub = toolsCore.JsonSchemaHelper.normaliseTypeName(def);
                 allSchemas[defSub] = schema.definitions[def];
             }
         }
     }
     const referencedSchemas = {};
-    extractTypes(allSchemas, types, referencedSchemas);
+    toolsCore.JsonSchemaHelper.extractTypes(allSchemas, [...types, ...autoExpandTypes], referencedSchemas);
+    toolsCore.JsonSchemaHelper.expandTypes(referencedSchemas, autoExpandTypes);
     for (const arraySingularType of arraySingularTypes) {
         referencedSchemas[`${arraySingularType}[]`] = {
             type: "array",
@@ -869,74 +894,6 @@ async function generateSchemas(modelDirWildcards, types, outputWorkingDir) {
     }
     return referencedSchemas;
 }
-/**
- * Extract the required types from all the known schemas.
- * @param allSchemas All the known schemas.
- * @param requiredTypes The required types.
- * @param referencedSchemas The references schemas.
- * @internal
- */
-function extractTypes(allSchemas, requiredTypes, referencedSchemas) {
-    for (const type of requiredTypes) {
-        if (allSchemas[type] && !referencedSchemas[type]) {
-            referencedSchemas[type] = allSchemas[type];
-            extractTypesFromSchema(allSchemas, allSchemas[type], referencedSchemas);
-        }
-    }
-}
-/**
- * Extract type from properties definition.
- * @param allTypes All the known types.
- * @param schema The schema to extract from.
- * @param output The output types.
- * @internal
- */
-function extractTypesFromSchema(allTypes, schema, output) {
-    const additionalTypes = [];
-    if (core.Is.stringValue(schema.$ref)) {
-        additionalTypes.push(normaliseTypeName(schema.$ref).replace("#/definitions/", ""));
-    }
-    else if (core.Is.object(schema.items)) {
-        if (core.Is.arrayValue(schema.items)) {
-            for (const itemSchema of schema.items) {
-                extractTypesFromSchema(allTypes, itemSchema, output);
-            }
-        }
-        else {
-            extractTypesFromSchema(allTypes, schema.items, output);
-        }
-    }
-    else if (core.Is.object(schema.properties) || core.Is.object(schema.additionalProperties)) {
-        if (core.Is.object(schema.properties)) {
-            for (const prop in schema.properties) {
-                const p = schema.properties[prop];
-                if (core.Is.object(p)) {
-                    extractTypesFromSchema(allTypes, p, output);
-                }
-            }
-        }
-        if (core.Is.object(schema.additionalProperties)) {
-            extractTypesFromSchema(allTypes, schema.additionalProperties, output);
-        }
-    }
-    else if (core.Is.arrayValue(schema.anyOf)) {
-        for (const prop of schema.anyOf) {
-            if (core.Is.object(prop)) {
-                extractTypesFromSchema(allTypes, prop, output);
-            }
-        }
-    }
-    else if (core.Is.arrayValue(schema.oneOf)) {
-        for (const prop of schema.oneOf) {
-            if (core.Is.object(prop)) {
-                extractTypesFromSchema(allTypes, prop, output);
-            }
-        }
-    }
-    if (additionalTypes.length > 0) {
-        extractTypes(allTypes, additionalTypes, output);
-    }
-}
 /**
  * Tidy up the schemas for use in OpenAPI context.
  * @param props The properties to tidy up.
@@ -1087,79 +1044,6 @@ async function loadPackages(tsToOpenApiConfig, outputWorkingDir, typeRoots) {
     }
     return restRoutes;
 }
-/**
- * Process arrays in the schema object.
- * @param schemaObject The schema object to process.
- */
-function processArrays(schemaObject) {
-    if (core.Is.object(schemaObject)) {
-        // latest specs have singular items in `items` property
-        // and multiple items in prefixItems, so update the schema accordingly
-        // https://www.learnjsonschema.com/2020-12/applicator/items/
-        // https://www.learnjsonschema.com/2020-12/applicator/prefixitems/
-        const schemaItems = schemaObject.items;
-        if (core.Is.array(schemaItems) || core.Is.object(schemaItems)) {
-            schemaObject.prefixItems = core.ArrayHelper.fromObjectOrArray(schemaItems);
-            delete schemaObject.items;
-        }
-        const additionalItems = schemaObject.additionalItems;
-        if (core.Is.array(additionalItems) || core.Is.object(additionalItems)) {
-            schemaObject.items = core.ArrayHelper.fromObjectOrArray(additionalItems)[0];
-            delete schemaObject.additionalItems;
-        }
-        processSchemaDictionary(schemaObject.properties);
-        processArrays(schemaObject.additionalProperties);
-        processSchemaArray(schemaObject.allOf);
-        processSchemaArray(schemaObject.anyOf);
-        processSchemaArray(schemaObject.oneOf);
-    }
-}
-/**
- * Process arrays in the schema object.
- * @param schemaDictionary The schema object to process.
- */
-function processSchemaDictionary(schemaDictionary) {
-    if (core.Is.object(schemaDictionary)) {
-        for (const item of Object.values(schemaDictionary)) {
-            if (core.Is.object(item)) {
-                processArrays(item);
-            }
-        }
-    }
-}
-/**
- * Process arrays in the schema object.
- * @param schemaArray The schema object to process.
- */
-function processSchemaArray(schemaArray) {
-    if (core.Is.arrayValue(schemaArray)) {
-        for (const item of schemaArray) {
-            if (core.Is.object(item)) {
-                processArrays(item);
-            }
-        }
-    }
-}
-/**
- * Cleanup TypeScript markers from the type name.
- * @param typeName The definition string to clean up.
- * @returns The cleaned up definition string.
- */
-function normaliseTypeName(typeName) {
-    // Remove the partial markers
-    let sTypeName = typeName.replace(/^Partial<(.*?)>/g, "$1");
-    sTypeName = sTypeName.replace(/Partial%3CI(.*?)%3E/g, "$1");
-    // Remove the omit markers
-    sTypeName = sTypeName.replace(/^Omit<(.*?),.*>/g, "$1");
-    sTypeName = sTypeName.replace(/Omit%3CI(.*?)%2C.*%3E/g, "$1");
-    // Remove the pick markers
-    sTypeName = sTypeName.replace(/^Pick<(.*?),.*>/g, "$1");
-    sTypeName = sTypeName.replace(/Pick%3CI(.*?)%2C.*%3E/g, "$1");
-    // Cleanup the generic markers
-    sTypeName = sTypeName.replace(/</g, "%3C").replace(/>/g, "%3E");
-    sTypeName = sTypeName.replace(/%3Cunknown%3E/g, "");
-    return sTypeName;
-}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -1179,7 +1063,7 @@ class CLI extends cliCore.CLIBase {
         return this.execute({
             title: "TWIN TypeScript To OpenAPI",
             appName: "ts-to-openapi",
-            version: "0.0.1", // x-release-please-version
+            version: "0.0.2-next.10", // x-release-please-version
             icon: "⚙️ ",
             supportsEnvFiles: false,
             overrideOutputWidth: options?.overrideOutputWidth