refactor: update parameter handling to use Promises in API routes and components

Author: OhKai

src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/aas-config-page-content.tsx

@@ -435,7 +435,7 @@ const AasConfigContent: React.FC<VariablesEditorProps> = ({
     data.forEach((item) => {
       keys.push(item.key);
       if (item.children && item.children.length > 0) {
-        const itemTitle = item.title as React.ReactElement;
+        const itemTitle = item.title as any;
         if (itemTitle?.props?.type != 'meta') {
           //console.log(itemTitle?.props?.element.name);
           keys = keys.concat(getAllKeys(item.children));

src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/aas-create-parameter-modal.tsx

@@ -33,7 +33,6 @@ import { buildLinkedInputParametersFromIds } from '../configuration-helper';
 import { getConfigurationCategories } from '@/lib/data/db/machine-config';
 import { useEnvironment } from '../../../../../components/auth-can';
 import { QuestionCircleOutlined } from '@ant-design/icons';
-import { IntegrityErrorModal } from '../../iam/users/create-users';
 export type CreateParameterModalReturnType = {
   name: string;
   value: string;
@@ -196,17 +195,6 @@ const AasCreateParameterModal = <T extends CreateParameterModalReturnType>({
       // Validate Failed
     }
   };
-  if (error) {
-    return (
-      <IntegrityErrorModal
-        open={open}
-        close={() => {
-          setError(null);
-          onCancel();
-        }}
-      />
-    );
-  }
 
   return (
     <Modal
@@ -274,6 +262,16 @@ const AasCreateParameterModal = <T extends CreateParameterModalReturnType>({
   );
 };
 
+// helper function to generate name from display name
+const generateNameFromDisplayName = (displayName: string): string => {
+  if (!displayName) return '';
+  return displayName
+    .replace(/\s+/g, '-')
+    .replace(/[^a-zA-Z0-9\-_+]/g, '')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-+/g, '-');
+};
+
 type CreateParameterInputsProps = {
   index: number;
   showKey?: boolean;
@@ -427,16 +425,6 @@ const ParameterInputs = ({
     setCurrentDescriptionLanguage(language);
   };
 
-  // helper function to generate name from display name
-  const generateNameFromDisplayName = (displayName: string): string => {
-    if (!displayName) return '';
-    return displayName
-      .replace(/\s+/g, '-')
-      .replace(/[^a-zA-Z0-9\-_+]/g, '')
-      .replace(/^-+|-+$/g, '')
-      .replace(/-+/g, '-');
-  };
-
   // validation rule for name field
   const validateName = (_: any, value: string) => {
     if (!value) return Promise.resolve();
@@ -706,16 +694,16 @@ const ParameterInputs = ({
                           other input parameter and is never changed automatically.
                         </div>
                         <div style={{ marginTop: '8px' }}>
-                          <strong>Manual:</strong> When the linked parameter's value is updated,
-                          this value will be cleared and can be manually set again.
+                          <strong>Manual:</strong> When the linked parameter&apos;s value is
+                          updated, this value will be cleared and can be manually set again.
                         </div>
                         <div style={{ marginTop: '8px' }}>
                           <strong>Linked:</strong> The value is always identical to the linked
-                          parameter's value. Any linked value change will be copied over.
+                          parameter&apos;s value. Any linked value change will be copied over.
                         </div>
                         <div style={{ marginTop: '8px' }}>
                           <strong>Formula:</strong> A JSONata formula can be used to automatically
-                          update this value whenever one of the linked parameter's values is
+                          update this value whenever one of the linked parameter&apos;s values is
                           updated.
                         </div>
                       </>

src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/[configId]/page.tsx

@@ -9,27 +9,26 @@ import MachineConfigViewClient from './page-client';
 import { getCurrentEnvironment } from '@/components/auth';
 
 type MachineConfigProps = {
-  params: { environmentId: string; configId: string };
-  searchParams: { [key: string]: string | string[] | undefined };
+  params: Promise<{ environmentId: string; configId: string }>;
+  searchParams: Promise<{ [key: string]: string | string[] | undefined }>;
 };
 
-const MachineConfigView: React.FC<MachineConfigProps> = async ({
-  params: { environmentId, configId },
-  searchParams,
-}) => {
+const MachineConfigView: React.FC<MachineConfigProps> = async ({ params, searchParams }) => {
+  const { environmentId, configId } = await params;
+  const searchParamsResolved = await searchParams;
   const { ability, activeEnvironment } = await getCurrentEnvironment(environmentId);
   if (activeEnvironment.isOrganization) {
     await syncOrganizationUsers(activeEnvironment.spaceId);
   }
-  const selectedVersionId = searchParams.version as string | undefined;
-  const source = searchParams.source as string | undefined;
+  const selectedVersionId = searchParamsResolved.version as string | undefined;
+  const source = searchParamsResolved.source as string | undefined;
 
   // collect all machine dataset version selections
   const machineDatasetVersions: Record<string, string> = {};
-  Object.keys(searchParams).forEach((key) => {
+  Object.keys(searchParamsResolved).forEach((key) => {
     if (key.startsWith('machineVersion_')) {
       const datasetId = key.replace('machineVersion_', '');
-      machineDatasetVersions[datasetId] = searchParams[key] as string;
+      machineDatasetVersions[datasetId] = searchParamsResolved[key] as string;
     }
   });
 

src/management-system-v2/app/(dashboard)/[environmentId]/machine-config/page.tsx

@@ -19,13 +19,14 @@ export type ListItem = Config;
 const MachineConfigPage = async ({
   params,
 }: {
-  params: { environmentId: string; folderId?: string };
+  params: Promise<{ environmentId: string; folderId?: string }>;
 }) => {
   if (!env.PROCEED_PUBLIC_CONFIG_SERVER_ACTIVE) {
     return notFound();
   }
+  const { environmentId } = await params;
 
-  const { ability, activeEnvironment } = await getCurrentEnvironment(params.environmentId);
+  const { ability, activeEnvironment } = await getCurrentEnvironment(environmentId);
 
   if (!ability.can('view', 'MachineConfig')) return <UnauthorizedFallback />;
 

src/management-system-v2/app/api/spaces/[spaceId]/configurations/[configSetId]/[versionId]/[parameterId]/route.ts

@@ -3,13 +3,12 @@ import { NextRequest, NextResponse } from 'next/server';
 
 export async function GET(
   request: NextRequest,
-  {
-    params: { configSetId, versionId, parameterId },
-  }: { params: { configSetId: string; versionId: string; parameterId: string } },
+  { params }: { params: Promise<{ configSetId: string; versionId: string; parameterId: string }> },
 ) {
   // Answer - Success: 200 OK, Body: one parameter of one configuration ({id, key, type, content[], parentId, parameters[], parentType, linkedParameters[]})
   // Answer - Error: 404 Not Found
   try {
+    const { configSetId, versionId, parameterId } = await params;
     const config = await nestedParametersFromStorage([parameterId]);
     return NextResponse.json(Object.values(config)[0]);
   } catch (error: any) {

src/management-system-v2/app/api/spaces/[spaceId]/configurations/[configSetId]/[versionId]/route.ts

@@ -5,13 +5,12 @@ import { validate as uuidValidate, v4 } from 'uuid';
 
 export async function GET(
   request: NextRequest,
-  {
-    params: { spaceId, configSetId, versionId },
-  }: { params: { spaceId: string; configSetId: string; versionId: string } },
+  { params }: { params: Promise<{ spaceId: string; configSetId: string; versionId: string }> },
 ) {
   // Answer - Success: 200 OK, Body: one version of one configuration, same as export
   // Answer - Error: 404 Not Found
   try {
+    const { spaceId, configSetId, versionId } = await params;
     if (versionId === 'latest') {
       const searchParams = request.nextUrl.searchParams;
       let queryId = uuidValidate(configSetId)

src/management-system-v2/app/api/spaces/[spaceId]/configurations/[configSetId]/latest-parameter/[parameterId]/route.ts

@@ -20,15 +20,14 @@ import { parameterToProp } from '@/app/(dashboard)/[environmentId]/machine-confi
 
 export async function GET(
   request: NextRequest,
-  {
-    params: { configSetId, parameterId },
-  }: { params: { configSetId: string; parameterId: string } },
+  { params }: { params: Promise<{ configSetId: string; parameterId: string }> },
 ) {
   // Answer - Success: 200 OK, Body: one parameter of one configuration ({id, key, type, content[], parentId, parameters[], parentType, linkedParameters[]})
   // Answer - Error: 404 Not Found
 
   const searchParams = request.nextUrl.searchParams;
   try {
+    const { configSetId, parameterId } = await params;
     const parameter = await nestedParametersFromStorage([parameterId]);
 
     if (searchParams.get('aas-format') === 'true') {
@@ -43,11 +42,10 @@ export async function GET(
 
 export async function PUT(
   request: NextRequest,
-  {
-    params: { spaceId, configSetId, parameterId },
-  }: { params: { spaceId: string; configSetId: string; parameterId: string } },
+  { params }: { params: Promise<{ spaceId: string; configSetId: string; parameterId: string }> },
 ) {
   try {
+    const { spaceId, configSetId, parameterId } = await params;
     let queryId = uuidValidate(configSetId)
       ? configSetId
       : await getConfigIdFromShortName(configSetId, spaceId);
@@ -111,11 +109,10 @@ export async function PUT(
 
 export async function DELETE(
   request: NextRequest,
-  {
-    params: { spaceId, configSetId, parameterId },
-  }: { params: { spaceId: string; configSetId: string; parameterId: string } },
+  { params }: { params: Promise<{ spaceId: string; configSetId: string; parameterId: string }> },
 ) {
   try {
+    const { spaceId, configSetId, parameterId } = await params;
     let queryId = uuidValidate(configSetId)
       ? configSetId
       : await getConfigIdFromShortName(configSetId, spaceId);

src/management-system-v2/app/api/spaces/[spaceId]/configurations/[configSetId]/latest-parameter/route.ts

@@ -25,9 +25,10 @@ import { validate as uuidValidate, v4 } from 'uuid';
 
 export async function POST(
   request: NextRequest,
-  { params: { spaceId, configSetId } }: { params: { spaceId: string; configSetId: string } },
+  { params }: { params: Promise<{ spaceId: string; configSetId: string }> },
 ) {
   try {
+    const { spaceId, configSetId } = await params;
     const searchParams = request.nextUrl.searchParams;
     const subParameterOf = searchParams.get('asSubParameterOf');
     const aasFormat = searchParams.get('aas-format');
@@ -47,7 +48,6 @@ export async function POST(
           changeableByUser: true,
           usedAsInputParameterIn: true,
           valueType: true,
-          subParameters: true,
         })
         .strict()
         .parse(body);
@@ -88,11 +88,12 @@ export async function POST(
 
 export async function GET(
   request: NextRequest,
-  { params: { spaceId, configSetId } }: { params: { spaceId: string; configSetId: string } },
+  { params }: { params: Promise<{ spaceId: string; configSetId: string }> },
 ) {
   // Answer - Success: 200 OK, Body: List of all versions of one configuration ({ id, shortname, name, versions: [ {id, name, createdOn, description, versionBasedOn }, ... ])
   // Answer - Error: 404 Not Found
   try {
+    const { spaceId, configSetId } = await params;
     // TODO embed versions
     let queryId = uuidValidate(configSetId)
       ? configSetId

src/management-system-v2/app/api/spaces/[spaceId]/configurations/[configSetId]/route.ts

@@ -13,11 +13,12 @@ import { validate as uuidValidate } from 'uuid';
 
 export async function GET(
   request: NextRequest,
-  { params: { spaceId, configSetId } }: { params: { spaceId: string; configSetId: string } },
+  { params }: { params: Promise<{ spaceId: string; configSetId: string }> },
 ) {
   // Answer - Success: 200 OK, Body: List of all versions of one configuration [ "1", "2", "latest"]
   // Answer - Error: 404 Not Found
   try {
+    const { spaceId, configSetId } = await params;
     //TODO: find and return versions
     let queryId = uuidValidate(configSetId)
       ? configSetId
@@ -31,11 +32,12 @@ export async function GET(
 
 export async function PUT(
   request: NextRequest,
-  { params: { spaceId, configSetId } }: { params: { spaceId: string; configSetId: string } },
+  { params }: { params: Promise<{ spaceId: string; configSetId: string }> },
 ) {
   // Answer - Success: 200 OK
   // Answer - Error: 409 Invalid input. Body contains the reason. For example, id was given, shortName already exists, syntax invalid, etc.
   try {
+    const { spaceId, configSetId } = await params;
     const body: Config = await request.json();
     ConfigZod.parse(body);
     let usingId = uuidValidate(configSetId);
@@ -75,12 +77,13 @@ export async function PUT(
 
 export async function DELETE(
   request: NextRequest,
-  { params: { configSetId } }: { params: { configSetId: string } },
+  { params }: { params: Promise<{ configSetId: string }> },
 ) {
   // Answer - Success: 200 OK
   // Answer - Error: 400 Bad Request, Body: contains the reason
 
   try {
+    const { configSetId } = await params;
     await removeParentConfiguration(configSetId, false);
     return NextResponse.json({ message: 'Success!' });
   } catch (error: any) {

src/management-system-v2/app/api/spaces/[spaceId]/configurations/route.ts

@@ -16,8 +16,9 @@ export type ListItem = Config;
 
 export async function GET(
   request: NextRequest,
-  { params: { spaceId } }: { params: { spaceId: string } },
+  { params }: { params: Promise<{ spaceId: string }> },
 ) {
+  const { spaceId } = await params;
   const searchParams = request.nextUrl.searchParams;
 
   // Answer - Success: 200 OK, Body: List of all existing configurations ([ {id, shortname, name, categories }, ... ])
@@ -42,8 +43,9 @@ export async function GET(
 
 export async function POST(
   request: NextRequest,
-  { params: { spaceId } }: { params: { spaceId: string } },
+  { params }: { params: Promise<{ spaceId: string }> },
 ) {
+  const { spaceId } = await params;
   //TODOs:
   //  - error if transformation of request body to json fails (but no check of content-type header is json)
   //  - error if id is inside body