@gadmin2n/schematics 0.0.149 → 0.0.151

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/DbExecuteConfigEditor.tsx

@@ -1,51 +1,46 @@
-import { InputNumber, Space, Switch, Tag, Typography } from 'antd';
+import { Alert, Button, InputNumber, Select, Space, Typography } from 'antd';
+import { customRequest } from 'helpers/http';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { WorkflowCodeEditor } from '../../components/WorkflowCodeEditor';
+import { ParameterBindingEditor } from '../../components/ParameterBindingEditor';
 import type { ParameterBinding } from '../../types/parameter-binding';
 import type { WidgetProps } from '../schema-form/widget-registry';
-import { ParameterBindingListEditor } from './ParameterBindingListEditor';
+
+export interface DatabaseFunctionArgument {
+  position: number;
+  name: string;
+  type: string;
+}
+
+export interface DatabaseFunctionOption {
+  schema: string;
+  name: string;
+  identityArguments: string;
+  returnType: string;
+  arguments: DatabaseFunctionArgument[];
+}
+
+type DatabaseFunctionRef = Pick<
+  DatabaseFunctionOption,
+  'schema' | 'name' | 'identityArguments'
+>;
 
 type DbExecuteConfig = {
-  allowWrite?: boolean;
-  sql?: string;
-  parameters?: ParameterBinding[];
+  functionRef?: DatabaseFunctionRef;
+  argumentBindings?: ParameterBinding[];
   timeoutSeconds?: number | null;
 };
 
-function normalizeSql(sql: string): string {
-  const withoutContent = sql
-    .replace(/\$(\w*)\$[\s\S]*?\$\1\$/g, ' ')
-    .replace(/'(?:''|[^'])*'/g, ' ')
-    .replace(/"(?:""|[^"])*"/g, ' ')
-    .replace(/\/\*[\s\S]*?\*\//g, ' ')
-    .replace(/--[^\r\n]*/g, ' ')
-    .trim();
-  const withoutTrailingSemicolon = withoutContent.replace(/;\s*$/, '').trim();
-  return withoutTrailingSemicolon.includes(';') ? '' : withoutTrailingSemicolon;
+function functionKey(value: DatabaseFunctionRef): string {
+  return `${value.schema}.${value.name}(${value.identityArguments})`;
 }
 
-export function isDatabaseSqlAllowed(
-  sql: string,
-  allowWrite: boolean,
-): boolean {
-  const normalized = normalizeSql(sql);
-  if (!normalized) return false;
-  const readOnly =
-    /^(select|with)\b/i.test(normalized) &&
-    !/\b(insert|update|delete|merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
-      normalized,
-    );
-  const writableCte =
-    /^with\b/i.test(normalized) &&
-    /\b(insert|update|delete)\b/i.test(normalized) &&
-    !/\b(merge|call|copy|create|alter|drop|truncate|grant|revoke|vacuum|refresh)\b/i.test(
-      normalized,
-    );
-  return (
-    readOnly ||
-    (allowWrite &&
-      (/^(insert|update|delete)\b/i.test(normalized) || writableCte))
-  );
+function defaultArgumentPath(name: string): string {
+  return name.replace(/^p_/, '') || name;
+}
+
+function defaultBinding(argument: DatabaseFunctionArgument): ParameterBinding {
+  return { source: 'INPUT', path: defaultArgumentPath(argument.name) };
 }
 
 export function DbExecuteConfigEditor({
@@ -55,71 +50,149 @@ export function DbExecuteConfigEditor({
 }: WidgetProps<DbExecuteConfig | undefined>) {
   const { t } = useTranslation('workflow');
   const config = value ?? {};
-  const allowWrite = config.allowWrite === true;
+  const [functions, setFunctions] = useState<DatabaseFunctionOption[]>([]);
+  const [catalogStatus, setCatalogStatus] = useState<
+    'loading' | 'ready' | 'error'
+  >('loading');
+
+  const loadFunctions = useCallback(async () => {
+    setCatalogStatus('loading');
+    try {
+      const items = await customRequest<DatabaseFunctionOption[]>(
+        'workflow/database-functions',
+        'GET',
+      );
+      setFunctions(Array.isArray(items) ? items : []);
+      setCatalogStatus('ready');
+    } catch {
+      setCatalogStatus('error');
+    }
+  }, []);
+
+  useEffect(() => {
+    void loadFunctions();
+  }, [loadFunctions]);
+
+  const selected = useMemo(
+    () =>
+      config.functionRef
+        ? functions.find(
+            (item) => functionKey(item) === functionKey(config.functionRef!),
+          )
+        : undefined,
+    [config.functionRef, functions],
+  );
+  const selectedKey = config.functionRef
+    ? functionKey(config.functionRef)
+    : undefined;
 
   return (
     <Space direction="vertical" size={14} style={{ width: '100%' }}>
-      <div className="db-execute-config__permission">
-        <div>
-          <Typography.Text strong>
-            {t('nodeEditors.database.allowWrite')}
-          </Typography.Text>
-          <Typography.Text type="secondary" className="db-execute-config__hint">
-            {t(
-              allowWrite
-                ? 'nodeEditors.database.readWriteDescription'
-                : 'nodeEditors.database.readOnlyDescription',
-            )}
-          </Typography.Text>
-        </div>
-        <Switch
-          aria-label={t('nodeEditors.database.allowWrite')}
-          checked={allowWrite}
-          disabled={disabled}
-          onChange={(nextAllowWrite) =>
-            onChange({ ...config, allowWrite: nextAllowWrite })
-          }
-        />
-      </div>
-
       <Space direction="vertical" size={6} style={{ width: '100%' }}>
-        <div className="db-execute-config__sql-head">
-          <Typography.Text strong>
-            {t('nodeEditors.database.sql')}
+        <Typography.Text>{t('nodeEditors.database.function')}</Typography.Text>
+        <Typography.Text type="secondary">
+          {t('nodeEditors.database.functionHint')}
+        </Typography.Text>
+        {catalogStatus === 'error' && (
+          <Typography.Text type="danger">
+            {t('nodeEditors.database.loadFailed')}{' '}
+            <Button type="link" size="small" onClick={loadFunctions}>
+              {t('common.retry')}
+            </Button>
           </Typography.Text>
-          <Tag bordered={false} color={allowWrite ? 'orange' : 'green'}>
-            {t(
-              allowWrite
-                ? 'nodeEditors.database.writeEnabled'
-                : 'nodeEditors.database.readOnly',
-            )}
-          </Tag>
-        </div>
-        <WorkflowCodeEditor
-          language="sql"
-          value={config.sql ?? ''}
-          readOnly={disabled}
-          height={280}
-          wordWrap="off"
-          ariaLabel={t('nodeEditors.database.sql')}
-          onChange={(sql) => onChange({ ...config, sql })}
+        )}
+        <Select
+          aria-label={t('nodeEditors.database.function')}
+          value={selectedKey}
+          disabled={disabled || catalogStatus !== 'ready'}
+          loading={catalogStatus === 'loading'}
+          placeholder={t('nodeEditors.database.selectFunction')}
+          showSearch
+          optionFilterProp="label"
+          options={functions.map((item) => ({
+            value: functionKey(item),
+            label: functionKey(item),
+          }))}
+          onChange={(key) => {
+            const databaseFunction = functions.find(
+              (item) => functionKey(item) === key,
+            );
+            if (!databaseFunction) return;
+            const keepExistingBindings = selectedKey === key;
+            onChange({
+              functionRef: {
+                schema: databaseFunction.schema,
+                name: databaseFunction.name,
+                identityArguments: databaseFunction.identityArguments,
+              },
+              argumentBindings: databaseFunction.arguments.map(
+                (argument, index) =>
+                  (keepExistingBindings
+                    ? config.argumentBindings?.[index]
+                    : undefined) ?? defaultBinding(argument),
+              ),
+              timeoutSeconds: config.timeoutSeconds ?? 30,
+            });
+          }}
+          style={{ width: '100%' }}
         />
       </Space>
 
-      <Space direction="vertical" size={6} style={{ width: '100%' }}>
-        <Typography.Text>
-          {t('nodeEditors.database.parameters')}
-        </Typography.Text>
-        <Typography.Text type="secondary" className="db-execute-config__hint">
-          {t('nodeEditors.database.parametersHint')}
-        </Typography.Text>
-        <ParameterBindingListEditor
-          value={config.parameters}
-          disabled={disabled}
-          addLabel={t('nodeEditors.database.addParameter')}
-          onChange={(parameters) => onChange({ ...config, parameters })}
+      {catalogStatus === 'ready' && config.functionRef && !selected && (
+        <Alert
+          type="warning"
+          showIcon
+          message={t('nodeEditors.database.functionMissing')}
         />
-      </Space>
+      )}
+
+      {selected && (
+        <>
+          <Typography.Text type="secondary">
+            {t('nodeEditors.database.returnType', {
+              type: selected.returnType,
+            })}
+          </Typography.Text>
+          {selected.arguments.length === 0 ? (
+            <Typography.Text type="secondary">
+              {t('nodeEditors.database.noArguments')}
+            </Typography.Text>
+          ) : (
+            selected.arguments.map((argument, index) => (
+              <Space
+                key={`${argument.position}:${argument.name}`}
+                direction="vertical"
+                size={6}
+                style={{ width: '100%' }}
+              >
+                <Typography.Text>
+                  {argument.name}{' '}
+                  <Typography.Text type="secondary">
+                    ({argument.type})
+                  </Typography.Text>
+                </Typography.Text>
+                <ParameterBindingEditor
+                  name={argument.name}
+                  defaultPath={defaultArgumentPath(argument.name)}
+                  value={
+                    config.argumentBindings?.[index] ?? defaultBinding(argument)
+                  }
+                  disabled={disabled}
+                  onChange={(binding) => {
+                    const argumentBindings = selected.arguments.map(
+                      (item, bindingIndex) =>
+                        config.argumentBindings?.[bindingIndex] ??
+                        defaultBinding(item),
+                    );
+                    argumentBindings[index] = binding;
+                    onChange({ ...config, argumentBindings });
+                  }}
+                />
+              </Space>
+            ))
+          )}
+        </>
+      )}
 
       <Space direction="vertical" size={6} style={{ width: '100%' }}>
         <Typography.Text>{t('nodeEditors.database.timeout')}</Typography.Text>

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/EventTriggerConfigEditor.tsx

@@ -396,7 +396,7 @@ export function EventTriggerConfigEditor({
                                 },
                           });
                         }}
-                        style={{ width: '45%' }}
+                        style={{ width: '50%' }}
                       />
                       <Select<EventMatchOperator>
                         aria-label={t('nodeEditors.event.conditionOperator', {
@@ -425,103 +425,103 @@ export function EventTriggerConfigEditor({
                                 },
                           })
                         }
-                        style={{ width: '30%' }}
+                        style={{ width: '50%' }}
                       />
-                      {!UNARY_MATCH_OPERATORS.has(condition.operator) &&
-                        (condition.operator === 'IN' ? (
-                          <Select
-                            mode="tags"
-                            aria-label={t('nodeEditors.event.conditionValue', {
-                              number: index + 1,
-                            })}
-                            value={parseValueList(condition.right?.value)}
-                            disabled={disabled}
-                            placeholder={t('nodeEditors.event.valueListHint')}
-                            onChange={(values) =>
-                              updateMatchCondition(index, {
-                                ...condition,
-                                right: {
-                                  source: 'FIXED',
-                                  valueType: fixedValueType(selectedField),
-                                  value: JSON.stringify(values),
-                                },
-                              })
-                            }
-                            style={{ width: '25%' }}
-                          />
-                        ) : selectedField?.type === 'boolean' ? (
-                          <Select
-                            aria-label={t('nodeEditors.event.conditionValue', {
-                              number: index + 1,
-                            })}
-                            value={condition.right?.value || undefined}
-                            disabled={disabled}
-                            options={[
-                              {
-                                value: 'true',
-                                label: t('nodeEditors.event.booleanTrue'),
+                    </Space.Compact>
+                    {!UNARY_MATCH_OPERATORS.has(condition.operator) &&
+                      (condition.operator === 'IN' ? (
+                        <Select
+                          mode="tags"
+                          aria-label={t('nodeEditors.event.conditionValue', {
+                            number: index + 1,
+                          })}
+                          value={parseValueList(condition.right?.value)}
+                          disabled={disabled}
+                          placeholder={t('nodeEditors.event.valueListHint')}
+                          onChange={(values) =>
+                            updateMatchCondition(index, {
+                              ...condition,
+                              right: {
+                                source: 'FIXED',
+                                valueType: fixedValueType(selectedField),
+                                value: JSON.stringify(values),
                               },
-                              {
-                                value: 'false',
-                                label: t('nodeEditors.event.booleanFalse'),
+                            })
+                          }
+                          style={{ width: '100%' }}
+                        />
+                      ) : selectedField?.type === 'boolean' ? (
+                        <Select
+                          aria-label={t('nodeEditors.event.conditionValue', {
+                            number: index + 1,
+                          })}
+                          value={condition.right?.value || undefined}
+                          disabled={disabled}
+                          options={[
+                            {
+                              value: 'true',
+                              label: t('nodeEditors.event.booleanTrue'),
+                            },
+                            {
+                              value: 'false',
+                              label: t('nodeEditors.event.booleanFalse'),
+                            },
+                          ]}
+                          onChange={(value) =>
+                            updateMatchCondition(index, {
+                              ...condition,
+                              right: {
+                                source: 'FIXED',
+                                valueType: 'BOOLEAN',
+                                value,
                               },
-                            ]}
-                            onChange={(value) =>
-                              updateMatchCondition(index, {
-                                ...condition,
-                                right: {
-                                  source: 'FIXED',
-                                  valueType: 'BOOLEAN',
-                                  value,
-                                },
-                              })
-                            }
-                            style={{ width: '25%' }}
-                          />
-                        ) : selectedField?.type === 'number' ? (
-                          <InputNumber
-                            aria-label={t('nodeEditors.event.conditionValue', {
-                              number: index + 1,
-                            })}
-                            value={
-                              condition.right?.value
-                                ? Number(condition.right.value)
-                                : null
-                            }
-                            disabled={disabled}
-                            onChange={(value) =>
-                              updateMatchCondition(index, {
-                                ...condition,
-                                right: {
-                                  source: 'FIXED',
-                                  valueType: 'NUMBER',
-                                  value: value === null ? '' : String(value),
-                                },
-                              })
-                            }
-                            style={{ width: '25%' }}
-                          />
-                        ) : (
-                          <Input
-                            aria-label={t('nodeEditors.event.conditionValue', {
-                              number: index + 1,
-                            })}
-                            value={condition.right?.value ?? ''}
-                            disabled={disabled}
-                            onChange={(event) =>
-                              updateMatchCondition(index, {
-                                ...condition,
-                                right: {
-                                  source: 'FIXED',
-                                  valueType: 'STRING',
-                                  value: event.target.value,
-                                },
-                              })
-                            }
-                            style={{ width: '25%' }}
-                          />
-                        ))}
-                    </Space.Compact>
+                            })
+                          }
+                          style={{ width: '100%' }}
+                        />
+                      ) : selectedField?.type === 'number' ? (
+                        <InputNumber
+                          aria-label={t('nodeEditors.event.conditionValue', {
+                            number: index + 1,
+                          })}
+                          value={
+                            condition.right?.value
+                              ? Number(condition.right.value)
+                              : null
+                          }
+                          disabled={disabled}
+                          onChange={(value) =>
+                            updateMatchCondition(index, {
+                              ...condition,
+                              right: {
+                                source: 'FIXED',
+                                valueType: 'NUMBER',
+                                value: value === null ? '' : String(value),
+                              },
+                            })
+                          }
+                          style={{ width: '100%' }}
+                        />
+                      ) : (
+                        <Input
+                          aria-label={t('nodeEditors.event.conditionValue', {
+                            number: index + 1,
+                          })}
+                          value={condition.right?.value ?? ''}
+                          disabled={disabled}
+                          onChange={(event) =>
+                            updateMatchCondition(index, {
+                              ...condition,
+                              right: {
+                                source: 'FIXED',
+                                valueType: 'STRING',
+                                value: event.target.value,
+                              },
+                            })
+                          }
+                          style={{ width: '100%' }}
+                        />
+                      ))}
                     <Button
                       type="text"
                       danger

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/EventTriggerLifecycleConfigEditor.test.tsx

@@ -0,0 +1,81 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { useState } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import i18n from '../../../../i18n';
+import { EventTriggerLifecycleConfigEditor } from './EventTriggerLifecycleConfigEditor';
+
+vi.mock('../../connections/connectionsApi', () => ({
+  fetchConnections: vi.fn(() => new Promise(() => undefined)),
+}));
+
+vi.mock('./EventTriggerConfigEditor', () => ({
+  EventTriggerConfigEditor: ({ onChange }: any) => (
+    <button
+      type="button"
+      onClick={() =>
+        onChange({
+          registrationCode: 'request',
+          operationRules: [{ operation: 'INSERT' }],
+          processingMode: 'PARALLEL',
+        })
+      }
+    >
+      change trigger
+    </button>
+  ),
+}));
+
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: () => ({
+    matches: false,
+    addListener() {},
+    removeListener() {},
+    addEventListener() {},
+    removeEventListener() {},
+    dispatchEvent: () => false,
+  }),
+});
+
+function Editor() {
+  const [value, setValue] = useState<Record<string, unknown>>({
+    registrationCode: 'request',
+    operationRules: [{ operation: 'INSERT' }],
+    processingMode: 'PARALLEL',
+    failureCallback: {
+      connectionRef: 'hardware-service',
+      path: '/api/hardware-disposal/workflow-failed',
+    },
+  });
+  return (
+    <>
+      <EventTriggerLifecycleConfigEditor
+        value={value}
+        onChange={(next) => setValue(next ?? {})}
+        schema={{ type: 'object' }}
+      />
+      <output data-testid="config">{JSON.stringify(value)}</output>
+    </>
+  );
+}
+
+describe('EventTriggerLifecycleConfigEditor', () => {
+  it('preserves the failure callback when the trigger editor updates its config', async () => {
+    await i18n.changeLanguage('zh_CN');
+    render(<Editor />);
+    await waitFor(() =>
+      expect(screen.getByText('Workflow 失败通知')).toBeInTheDocument(),
+    );
+
+    fireEvent.click(screen.getByText('change trigger'));
+
+    expect(JSON.parse(screen.getByTestId('config').textContent!)).toMatchObject(
+      {
+        failureCallback: {
+          connectionRef: 'hardware-service',
+          path: '/api/hardware-disposal/workflow-failed',
+        },
+      },
+    );
+  });
+});