fix: correct spelling of 'azureFunctionRoutePrefix' in multiple files and update package versions

Author: fabiofranzini

package-lock.json

@@ -1,56 +1,42 @@
 # @apvee/azure-functions-openapi
 
 ## Overview
-
 `@apvee/azure-functions-openapi` is an extension for Azure Functions V4 that simplifies the process of integrating OpenAPI documentation. It automatically generates and serves OpenAPI 2.0, 3.0.3, and 3.1.0 definitions and provides a Swagger UI for your Azure Functions. Built on top of `@asteasolutions/zod-to-openapi`, it uses **Zod Schemas** for type-safe request validation and response handling, ensuring that your API is well-documented and easy to explore.
 
 ## Benefits of Documenting APIs with OpenAPI
-
 Documenting your APIs with OpenAPI offers several significant advantages:
-
 - **Always Up-to-Date Documentation**: By integrating OpenAPI documentation directly into your codebase, you ensure that your API documentation is always in sync with the implementation. This reduces the risk of discrepancies between the documentation and the actual API behavior, leading to a more reliable and trustworthy API.
-
 - **Auto-Generated Client Libraries**: OpenAPI specifications can be used to automatically generate client libraries for various programming languages. Tools like [Kiota](https://github.com/microsoft/kiota) and [OpenAPI Generator](https://openapi-generator.tech/) can create client SDKs that developers can use to interact with your API. This saves time and effort, as developers do not need to manually write and maintain client code.
-
 - **Improved Developer Experience**: Comprehensive and accurate API documentation makes it easier for developers to understand and use your API. With tools like Swagger UI, developers can interact with your API directly from the documentation, making it easier to test and explore the available endpoints.
-
 - **Enhanced API Testing**: OpenAPI documentation can be used to generate test cases and validate API responses. This helps ensure that your API behaves as expected and meets the defined specifications.
-
 - **Standardization and Consistency**: Using OpenAPI promotes standardization and consistency across your API endpoints. This makes it easier for developers to work with your API and reduces the learning curve for new users.
-
 - **Interoperability**: OpenAPI is a widely adopted standard, and many tools and platforms support it. By documenting your API with OpenAPI, you ensure that it can be easily integrated with other systems and tools that support the OpenAPI standard.
 
 By leveraging the benefits of OpenAPI documentation, you can create a more robust, user-friendly, and maintainable API that meets the needs of both developers and end-users.
 
 ## Key Features
-
 - **Automatic OpenAPI Specification Generation**: Generate OpenAPI 2.0, 3.0.3, and 3.1.0 definitions for your Azure Functions based on registered schemas and handlers.
 - **Integrated Swagger UI**: Serve a Swagger UI interface that dynamically loads and visualizes the OpenAPI definitions.
 - **Type-Safe Request and Response Validation**: Leverage Zod schemas to validate request bodies, query parameters, headers, and more.
 - **Flexible API Configuration**: Customize security schemas, routes, authentication levels, and request/response handling through simple utility functions.
 - **Native Azure Functions Support**: Seamlessly integrates with Azure Functions V4 to enhance your serverless applications with robust API documentation.
 
 ## Installation
-
 To install the package and its dependencies, run:
-
 ```bash
 npm install @apvee/azure-functions-openapi
 ```
-
 You'll also need the following peer dependencies:
 ```bash
 npm install @azure/functions zod
 ```
-
 ## Exposing OpenAPI and Swagger UI
 You can expose OpenAPI documentation and serve a Swagger UI interface using two key functions: registerOpenAPIHandler and registerSwaggerUIHandler. These functions can be invoked from the index.ts file in the src directory of your Azure Functions project, making it easy to configure global behaviors for your functions.
 
 ### Expose OpenAPI Documentation
 The registerOpenAPIHandler function registers an HTTP GET handler that serves the OpenAPI definition.
 
 Example (index.ts):
-
 ```typescript
 import { OpenAPIObjectConfig, registerOpenAPIHandler, registerSwaggerUIHandler } from '@apvee/azure-functions-openapi';
 import { app } from '@azure/functions';
@@ -95,7 +81,6 @@ const documents = [
 
 registerSwaggerUIHandler("anonymous", 'api', documents);
 ```
-
 #### ```registerOpenAPIHandler```
 This function registers an OpenAPI handler for an Azure Function.
 
@@ -110,7 +95,6 @@ This function registers an OpenAPI handler for an Azure Function.
 - An object containing the title and URL of the registered OpenAPI document.
 
 **Example**:
-
 ```typescript
 const documentInfo = registerOpenAPIHandler('anonymous', openAPIConfig, '3.1.0', 'json');
 ```
@@ -124,24 +108,20 @@ This function registers a Swagger UI handler for an Azure Function.
 - **documents**: An array of OpenAPI document information objects.
 
 **Example**:
-
 ```typescript
 registerSwaggerUIHandler('anonymous', 'api', documents);
 ```
 
 #### ```registerApiKeySecuritySchema```
 This function registers an API key security schema in the OpenAPI registry.
-
 **Parameters**:
 - **name**: The name of the API key (e.g., **X-API-KEY**).
 - **input**: The location of the API key in the request (**'header'**, **'query'**, or **'cookie'**).
 
 **Example**:
-
 ```typescript
 const securityRequirement = registerApiKeySecuritySchema('X-API-KEY', 'header');
 ```
-
 #### ```registerTypeSchema```
 This function registers Zod schemas as named types in the OpenAPI registry.
 
@@ -150,7 +130,6 @@ This function registers Zod schemas as named types in the OpenAPI registry.
 - **schema**: The Zod schema defining the structure.
 
 **Example**:
-
 ```typescript
 const UserSchema = z.object({
     id: z.string(),
@@ -169,7 +148,6 @@ This function registers an Azure Function with OpenAPI documentation, including
 - **options**: Configuration for the handler, HTTP methods, request validation, and responses.
 
 **Example**:
-
 ```typescript
 registerFunction("myFunction", "Processes user data", {
     handler: async (req, ctx) => {
@@ -201,7 +179,6 @@ In the context of integrating OpenAPI documentation with Azure Functions, it is
 - **Enhanced Configuration**: Provides additional configuration options for request validation, response handling, and security schemas.
 
 ## Utility Functions for Handling Parameters with Zod
-
 This library provides two utility functions to convert parameters from HttpRequestParams and URLSearchParams into plain JavaScript objects. These functions are useful for validating and processing parameters using Zod schemas.
 
 ```convertHttpRequestParamsToObject```:
@@ -219,7 +196,6 @@ export function convertHttpRequestParamsToObject(params: HttpRequestParams): { [
 - A plain object where keys and values are strings.
 
 **Example**:
-
 ```typescript
 import { z } from 'zod';
 import { convertHttpRequestParamsToObject } from './utils';
@@ -250,7 +226,6 @@ export function convertURLSearchParamsToObject(params: URLSearchParams): { [key:
 - A plain object where keys are strings and values are either strings or arrays of strings.
 
 **Example**:
-
 ```typescript
 import { z } from 'zod';
 import { convertURLSearchParamsToObject } from './utils';
@@ -277,5 +252,4 @@ https://github.com/apvee/azure-functions-nodejs-monorepo/tree/main/packages/test
 By exploring the ```test-functions``` project, you can gain a better understanding of how to leverage the features provided by ```@apvee/azure-functions-openapi``` to enhance your Azure Functions with comprehensive OpenAPI documentation.
 
 ## License
-
 This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for more details.

packages/azure-functions-openapi/README.md

@@ -112,7 +112,7 @@ function registerPath(
             summary: summary,
             method: mapHttpMethod(method),
             // Add the route to the OpenAPI registry, with the route prefix if it exists
-            path: (options.azureFuntionRoutePrefix) ? `/${options.azureFuntionRoutePrefix}/${options.route}` : options.route,
+            path: (options.azureFunctionRoutePrefix) ? `/${options.azureFunctionRoutePrefix}/${options.route}` : options.route,
             security: options.security,
             request: options.request,
             responses: options.responses,

packages/azure-functions-openapi/core/registerFunction.ts

@@ -50,14 +50,14 @@ export type OpenAPIObjectConfig = Omit<OpenAPIObject, 'paths' | 'components' | '
  * @property {HttpHandler} handler - The handler function for the route.
  * @property {HttpMethod[]} methods - An array of HTTP methods supported by the route.
  * @property {'anonymous' | 'function' | 'admin'} authLevel - The authorization level required for the route.
- * @property {string} azureFuntionRoutePrefix - The prefix for the Azure Function route.
+ * @property {string} azureFunctionRoutePrefix - The prefix for the Azure Function route.
  * @property {string} route - The route path.
  */
 export type FunctionRouteConfig = Omit<RouteConfig, 'method' | 'path' | 'summary'> & {
     handler: HttpHandler,
     methods: HttpMethod[];
     authLevel: 'anonymous' | 'function' | 'admin',
-    azureFuntionRoutePrefix: string,
+    azureFunctionRoutePrefix: string,
     route: string
 };
 

packages/azure-functions-openapi/core/types.ts

@@ -5,19 +5,19 @@ import { OpenAPIDocumentInfo } from "../core/types";
  * Registers a Swagger UI handler for an Azure Function.
  *
  * @param {'anonymous' | 'function' | 'admin'} authLevel - The authorization level required to access the Swagger UI.
- * @param {string} azureFuntionRoutePrefix - The route prefix for the Azure Function. Defaults to 'api'.
+ * @param {string} azureFunctionRoutePrefix - The route prefix for the Azure Function. Defaults to 'api'.
  * @param {OpenAPIDocumentInfo[]} openAPIDocuments - An array of OpenAPI document information objects to be included in the Swagger UI.
  * 
  * This function sets up an HTTP GET handler that serves a Swagger UI page, which lists the provided OpenAPI documents.
  * The Swagger UI is configured to use the provided URLs and titles for the OpenAPI documents.
  */
-export function registerSwaggerUIHandler(authLevel: 'anonymous' | 'function' | 'admin' = 'anonymous', azureFuntionRoutePrefix: string | null = 'api', openAPIDocuments: OpenAPIDocumentInfo[]): void {
+export function registerSwaggerUIHandler(authLevel: 'anonymous' | 'function' | 'admin' = 'anonymous', azureFunctionRoutePrefix: string | null = 'api', openAPIDocuments: OpenAPIDocumentInfo[]): void {
     const fxHandler = async (request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> => {
         context.log(`Invoking SwaggerUI handler for url "${request.url}"`);
 
         const urls = openAPIDocuments.map(doc => {
             return {
-                url: `/${azureFuntionRoutePrefix}/${doc.url}`,
+                url: `/${azureFunctionRoutePrefix}/${doc.url}`,
                 name: doc.title
             };
         });

packages/azure-functions-openapi/handlers/swaggerUI.ts

@@ -1,6 +1,6 @@
 {
   "name": "@apvee/azure-functions-openapi",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/apvee/azure-functions-nodejs-monorepo.git"

packages/azure-functions-openapi/package.json

@@ -37,7 +37,7 @@ registerFunction(
         methods: ['POST'],
         authLevel: 'anonymous',
         security: [apiKeySecurity],
-        azureFuntionRoutePrefix: 'api',
+        azureFunctionRoutePrefix: 'api',
         route: 'todos',
         request: {
             body: {

packages/test-functions/src/functions/AddTodo.ts

@@ -35,7 +35,7 @@ registerFunction(
         methods: ['DELETE'],
         authLevel: 'anonymous',
         security: [apiKeySecurity],
-        azureFuntionRoutePrefix: 'api',
+        azureFunctionRoutePrefix: 'api',
         route: 'todos/{id}',
         request: {
             params: TodoParamIDSchema

packages/test-functions/src/functions/DeleteTodo.ts

@@ -52,7 +52,7 @@ registerFunction(
         methods: ['GET'],
         authLevel: 'anonymous',
         security: [apiKeySecurity],
-        azureFuntionRoutePrefix: 'api',
+        azureFunctionRoutePrefix: 'api',
         route: 'todos',
         request: {
             query: FilterParamsSchema

packages/test-functions/src/functions/GetAllTodos.ts

@@ -42,7 +42,7 @@ registerFunction(
         methods: ['GET'],
         authLevel: 'anonymous',
         security: [apiKeySecurity],
-        azureFuntionRoutePrefix: 'api',
+        azureFunctionRoutePrefix: 'api',
         route: 'todos/{id}',
         request: {
             params: TodoParamIDSchema