arkos 1.4.0-canary.92 → 1.4.1-canary.2

package/dist/esm/modules/swagger/utils/helpers/get-authentication-json-schema-paths.js

@@ -14,8 +14,8 @@ export const getSchemaMode = (action, arkosConfig) => {
         return "prisma";
     return swaggerMode;
 };
-export default function getAuthenticationJsonSchemaPaths(arkosConfig) {
-    const paths = {};
+export default function getAuthenticationJsonSchemaPaths(arkosConfig, existingPaths) {
+    const paths = { ...existingPaths };
     if (!arkosConfig.swagger?.mode)
         return paths;
     const AuthModuleComponents = getModuleComponents("auth");
@@ -27,201 +27,239 @@ export default function getAuthenticationJsonSchemaPaths(arkosConfig) {
         return isEndpointDisabled(routerConfig, endpoint);
     };
     if (!isAuthEndpointDisabled("login")) {
+        const pathname = "/api/auth/login";
+        if (!paths[pathname])
+            paths[pathname] = {};
         const loginMode = getSchemaMode("login", arkosConfig);
-        paths["/api/auth/login"] = {
-            post: {
-                tags: ["Authentication"],
-                summary: "Login to the system",
-                description: "Authenticates a user and returns an access token",
-                operationId: "login",
-                requestBody: {
-                    description: "User credentials",
-                    required: true,
-                    content: {
-                        "application/json": {
-                            schema: {
-                                $ref: getSchemaRef("Login", loginMode),
-                            },
+        const currentPath = paths[pathname].post;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Login to the system"
+                : currentPath?.summary,
+            description: currentPath?.description ||
+                "Authenticates a user and returns an access token",
+            operationId: currentPath?.operationId || "login",
+            requestBody: currentPath?.requestBody || {
+                description: "User credentials",
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: getSchemaRef("Login", loginMode),
                         },
                     },
                 },
-                responses: {
-                    "200": {
-                        description: "Login successful",
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    type: "object",
-                                    properties: {
-                                        accessToken: {
-                                            type: "string",
-                                            description: "JWT access token",
-                                        },
+            },
+            responses: {
+                ...(currentPath?.responses || {}),
+                "200": currentPath?.responses?.["200"] || {
+                    description: "Login successful",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    accessToken: {
+                                        type: "string",
+                                        description: "JWT access token",
                                     },
                                 },
                             },
                         },
                     },
-                    "400": {
-                        description: "Invalid input data",
-                    },
-                    "401": {
-                        description: "Invalid credentials",
-                    },
+                },
+                "400": currentPath?.responses?.["400"] || {
+                    description: "Invalid input data",
+                },
+                "401": currentPath?.responses?.["401"] || {
+                    description: "Invalid credentials",
                 },
             },
         };
+        paths[pathname].post = { ...(currentPath || {}), ...defaultSpec };
     }
     if (!isAuthEndpointDisabled("logout")) {
-        paths["/api/auth/logout"] = {
-            delete: {
-                tags: ["Authentication"],
-                summary: "Logout from the system",
-                description: "Invalidates the current user's JWT token",
-                operationId: "logout",
-                security: [{ BearerAuth: [] }],
-                responses: {
-                    "204": {
-                        description: "Logout successful",
-                    },
-                    "401": {
-                        description: "Authentication required",
-                    },
+        const pathname = "/api/auth/logout";
+        if (!paths[pathname])
+            paths[pathname] = {};
+        const currentPath = paths[pathname].delete;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Logout from the system"
+                : currentPath?.summary,
+            description: currentPath?.description || "Invalidates the current user's JWT token",
+            operationId: currentPath?.operationId || "logout",
+            security: [{ BearerAuth: [] }],
+            responses: {
+                ...(currentPath?.responses || {}),
+                "204": currentPath?.responses?.["204"] || {
+                    description: "Logout successful",
+                },
+                "401": currentPath?.responses?.["401"] || {
+                    description: "Authentication required",
                 },
             },
         };
+        paths[pathname].delete = { ...(currentPath || {}), ...defaultSpec };
     }
     if (!isAuthEndpointDisabled("signup")) {
+        const pathname = "/api/auth/signup";
+        if (!paths[pathname])
+            paths[pathname] = {};
         const signupMode = getSchemaMode("signup", arkosConfig);
         const userMode = getSchemaMode("user", arkosConfig);
-        paths["/api/auth/signup"] = {
-            post: {
-                tags: ["Authentication"],
-                summary: "Register a new user",
-                description: "Creates a new user account",
-                operationId: "signup",
-                requestBody: {
-                    description: "User registration data",
-                    required: true,
+        const currentPath = paths[pathname].post;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Register a new user"
+                : currentPath?.summary,
+            description: currentPath?.description || "Creates a new user account",
+            operationId: currentPath?.operationId || "signup",
+            requestBody: currentPath?.requestBody || {
+                description: "User registration data",
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: getSchemaRef("Signup", signupMode),
+                        },
+                    },
+                },
+            },
+            responses: {
+                ...(currentPath?.responses || {}),
+                "201": currentPath?.responses?.["201"] || {
+                    description: "User created successfully",
                     content: {
                         "application/json": {
                             schema: {
-                                $ref: getSchemaRef("Signup", signupMode),
+                                $ref: getSchemaRef("User", userMode),
                             },
                         },
                     },
                 },
-                responses: {
-                    "201": {
-                        description: "User created successfully",
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: getSchemaRef("User", userMode),
-                                },
-                            },
-                        },
-                    },
-                    "400": {
-                        description: "Invalid input data",
-                    },
-                    "409": {
-                        description: "User already exists",
-                    },
+                "400": currentPath?.responses?.["400"] || {
+                    description: "Invalid input data",
+                },
+                "409": currentPath?.responses?.["409"] || {
+                    description: "User already exists",
                 },
             },
         };
+        paths[pathname].post = { ...(currentPath || {}), ...defaultSpec };
     }
     if (!isAuthEndpointDisabled("updatePassword")) {
+        const pathname = "/api/auth/update-password";
+        if (!paths[pathname])
+            paths[pathname] = {};
         const updatePasswordMode = getSchemaMode("updatePassword", arkosConfig);
-        paths["/api/auth/update-password"] = {
-            post: {
-                tags: ["Authentication"],
-                summary: "Update user password",
-                description: "Changes the password for the authenticated user",
-                operationId: "updatePassword",
-                security: [{ BearerAuth: [] }],
-                requestBody: {
-                    description: "Current and new password",
-                    required: true,
-                    content: {
-                        "application/json": {
-                            schema: {
-                                $ref: getSchemaRef("UpdatePassword", updatePasswordMode),
-                            },
+        const currentPath = paths[pathname].post;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Update user password"
+                : currentPath?.summary,
+            description: currentPath?.description ||
+                "Changes the password for the authenticated user",
+            operationId: currentPath?.operationId || "updatePassword",
+            security: [{ BearerAuth: [] }],
+            requestBody: currentPath?.requestBody || {
+                description: "Current and new password",
+                required: true,
+                content: {
+                    "application/json": {
+                        schema: {
+                            $ref: getSchemaRef("UpdatePassword", updatePasswordMode),
                         },
                     },
                 },
-                responses: {
-                    "200": {
-                        description: "Password updated successfully",
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    type: "object",
-                                    properties: {
-                                        status: {
-                                            type: "string",
-                                            example: "success",
-                                        },
-                                        message: {
-                                            type: "string",
-                                            example: "Password updated successfully!",
-                                        },
+            },
+            responses: {
+                ...(currentPath?.responses || {}),
+                "200": currentPath?.responses?.["200"] || {
+                    description: "Password updated successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    status: {
+                                        type: "string",
+                                        example: "success",
+                                    },
+                                    message: {
+                                        type: "string",
+                                        example: "Password updated successfully!",
                                     },
                                 },
                             },
                         },
                     },
-                    "400": {
-                        description: "Invalid input data or current password incorrect",
-                    },
-                    "401": {
-                        description: "Authentication required",
-                    },
+                },
+                "400": currentPath?.responses?.["400"] || {
+                    description: "Invalid input data or current password incorrect",
+                },
+                "401": currentPath?.responses?.["401"] || {
+                    description: "Authentication required",
                 },
             },
         };
+        paths[pathname].post = { ...(currentPath || {}), ...defaultSpec };
     }
     if (!isAuthEndpointDisabled("getMe")) {
+        const pathname = "/api/users/me";
+        if (!paths[pathname])
+            paths[pathname] = {};
         const findMeMode = getSchemaMode("getMe", arkosConfig);
-        paths["/api/users/me"] = {
-            get: {
-                tags: ["Authentication"],
-                summary: "Get current user information",
-                description: "Retrieves information about the currently authenticated user",
-                operationId: "getMe",
-                security: [{ BearerAuth: [] }],
-                responses: {
-                    "200": {
-                        description: "User information retrieved successfully",
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    $ref: getSchemaRef("GetMe", findMeMode),
-                                },
+        const currentPath = paths[pathname].get;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Get current user information"
+                : currentPath?.summary,
+            description: currentPath?.description ||
+                "Retrieves information about the currently authenticated user",
+            operationId: currentPath?.operationId || "getMe",
+            security: [{ BearerAuth: [] }],
+            responses: {
+                ...(currentPath?.responses || {}),
+                "200": currentPath?.responses?.["200"] || {
+                    description: "User information retrieved successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: getSchemaRef("GetMe", findMeMode),
                             },
                         },
                     },
-                    "401": {
-                        description: "Authentication required",
-                    },
+                },
+                "401": currentPath?.responses?.["401"] || {
+                    description: "Authentication required",
                 },
             },
         };
+        paths[pathname].get = { ...(currentPath || {}), ...defaultSpec };
     }
     if (!isAuthEndpointDisabled("updateMe")) {
+        const pathname = "/api/users/me";
+        if (!paths[pathname])
+            paths[pathname] = {};
         const updateMeMode = getSchemaMode("updateMe", arkosConfig);
         const userMode = getSchemaMode("user", arkosConfig);
-        if (!paths["/api/users/me"])
-            paths["/api/users/me"] = {};
-        paths["/api/users/me"].patch = {
-            tags: ["Authentication"],
-            summary: "Update current user information",
-            description: "Updates information for the currently authenticated user",
-            operationId: "updateMe",
+        const currentPath = paths[pathname].patch;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Update current user information"
+                : currentPath?.summary,
+            description: currentPath?.description ||
+                "Updates information for the currently authenticated user",
+            operationId: currentPath?.operationId || "updateMe",
             security: [{ BearerAuth: [] }],
-            requestBody: {
+            requestBody: currentPath?.requestBody || {
                 description: "User data to update",
                 required: true,
                 content: {
@@ -233,7 +271,8 @@ export default function getAuthenticationJsonSchemaPaths(arkosConfig) {
                 },
             },
             responses: {
-                "200": {
+                ...(currentPath?.responses || {}),
+                "200": currentPath?.responses?.["200"] || {
                     description: "User updated successfully",
                     content: {
                         "application/json": {
@@ -243,26 +282,33 @@ export default function getAuthenticationJsonSchemaPaths(arkosConfig) {
                         },
                     },
                 },
-                "400": {
+                "400": currentPath?.responses?.["400"] || {
                     description: "Invalid input data",
                 },
-                "401": {
+                "401": currentPath?.responses?.["401"] || {
                     description: "Authentication required",
                 },
             },
         };
+        paths[pathname].patch = { ...(currentPath || {}), ...defaultSpec };
     }
     if (!isAuthEndpointDisabled("deleteMe")) {
-        if (!paths["/api/users/me"])
-            paths["/api/users/me"] = {};
-        paths["/api/users/me"].delete = {
-            tags: ["Authentication"],
-            summary: "Delete current user account",
-            description: "Marks the current user's account as deleted",
-            operationId: "deleteMe",
+        const pathname = "/api/users/me";
+        if (!paths[pathname])
+            paths[pathname] = {};
+        const currentPath = paths[pathname].delete;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Delete current user account"
+                : currentPath?.summary,
+            description: currentPath?.description ||
+                "Marks the current user's account as deleted",
+            operationId: currentPath?.operationId || "deleteMe",
             security: [{ BearerAuth: [] }],
             responses: {
-                "200": {
+                ...(currentPath?.responses || {}),
+                "200": currentPath?.responses?.["200"] || {
                     description: "Account deleted successfully",
                     content: {
                         "application/json": {
@@ -278,56 +324,135 @@ export default function getAuthenticationJsonSchemaPaths(arkosConfig) {
                         },
                     },
                 },
-                "401": {
+                "401": currentPath?.responses?.["401"] || {
                     description: "Authentication required",
                 },
             },
         };
+        paths[pathname].delete = { ...(currentPath || {}), ...defaultSpec };
     }
     if (!isAuthEndpointDisabled("findManyAuthAction")) {
-        paths["/api/auth-actions"] = {
-            get: {
-                tags: ["Authentication"],
-                summary: "Get all authentication actions",
-                description: "Retrieves a list of all available authentication actions and permissions",
-                operationId: "findManyAuthAction",
-                security: [{ BearerAuth: [] }],
-                responses: {
-                    "200": {
-                        description: "Auth actions retrieved successfully",
-                        content: {
-                            "application/json": {
-                                schema: {
-                                    type: "object",
-                                    properties: {
-                                        total: {
-                                            type: "number",
-                                            description: "Total number of auth actions",
-                                        },
-                                        results: {
-                                            type: "number",
-                                            description: "Number of auth actions returned",
-                                        },
-                                        data: {
-                                            type: "array",
-                                            items: {
-                                                $ref: "#/components/schemas/FindManyAuthActionSystemSchema",
-                                            },
+        const pathname = "/api/auth-actions";
+        if (!paths[pathname])
+            paths[pathname] = {};
+        const currentPath = paths[pathname].get;
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Get all authentication actions"
+                : currentPath?.summary,
+            description: currentPath?.description ||
+                "Retrieves a list of all available authentication actions and permissions",
+            operationId: currentPath?.operationId || "findManyAuthAction",
+            security: [{ BearerAuth: [] }],
+            responses: {
+                ...(currentPath?.responses || {}),
+                "200": currentPath?.responses?.["200"] || {
+                    description: "Auth actions retrieved successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    total: {
+                                        type: "number",
+                                        description: "Total number of auth actions",
+                                    },
+                                    results: {
+                                        type: "number",
+                                        description: "Number of auth actions returned",
+                                    },
+                                    data: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/components/schemas/FindManyAuthActionSystemSchema",
                                         },
                                     },
                                 },
                             },
                         },
                     },
-                    "401": {
-                        description: "Authentication required",
-                    },
-                    "403": {
-                        description: "Insufficient permissions",
+                },
+                "401": currentPath?.responses?.["401"] || {
+                    description: "Authentication required",
+                },
+                "403": currentPath?.responses?.["403"] || {
+                    description: "Insufficient permissions",
+                },
+            },
+        };
+        paths[pathname].get = { ...(currentPath || {}), ...defaultSpec };
+    }
+    if (!isAuthEndpointDisabled("findOneAuthAction")) {
+        const pathname = "/api/auth-actions/{resourceName}";
+        if (!paths[pathname])
+            paths[pathname] = {};
+        const currentPath = paths[pathname].get;
+        const defaultParameters = [
+            {
+                name: "resourceName",
+                in: "path",
+                description: "Name of the resource to retrieve auth actions for",
+                required: true,
+                schema: { type: "string" },
+            },
+        ];
+        const existingParams = currentPath?.parameters || [];
+        const existingParamKeys = new Set(existingParams.map((p) => `${p.in}-${p.name}`));
+        const mergedParameters = [
+            ...existingParams,
+            ...defaultParameters.filter((p) => !existingParamKeys.has(`${p.in}-${p.name}`)),
+        ];
+        const defaultSpec = {
+            tags: ["Authentication", ...(currentPath?.tags || [])].filter((tag) => tag !== "Defaults"),
+            summary: currentPath?.summary === pathname || !currentPath?.summary
+                ? "Get authentication actions by resource"
+                : currentPath?.summary,
+            description: currentPath?.description ||
+                "Retrieves all authentication actions for a specific resource",
+            operationId: currentPath?.operationId || "findOneAuthAction",
+            security: [{ BearerAuth: [] }],
+            parameters: mergedParameters,
+            responses: {
+                ...(currentPath?.responses || {}),
+                "200": currentPath?.responses?.["200"] || {
+                    description: "Auth actions for resource retrieved successfully",
+                    content: {
+                        "application/json": {
+                            schema: {
+                                type: "object",
+                                properties: {
+                                    total: {
+                                        type: "number",
+                                        description: "Total number of auth actions for this resource",
+                                    },
+                                    results: {
+                                        type: "number",
+                                        description: "Number of auth actions returned",
+                                    },
+                                    data: {
+                                        type: "array",
+                                        items: {
+                                            $ref: "#/components/schemas/FindManyAuthActionSystemSchema",
+                                        },
+                                    },
+                                },
+                            },
+                        },
                     },
                 },
+                "401": currentPath?.responses?.["401"] || {
+                    description: "Authentication required",
+                },
+                "403": currentPath?.responses?.["403"] || {
+                    description: "Insufficient permissions",
+                },
+                "404": currentPath?.responses?.["404"] || {
+                    description: "Resource not found",
+                },
             },
         };
+        paths[pathname].get = { ...(currentPath || {}), ...defaultSpec };
     }
     return paths;
 }