@gadmin2n/schematics 0.0.150 → 0.0.151

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflow/workflow.service.ts

@@ -34,6 +34,7 @@ import {
   NodeOutputsMap,
   validateWorkflowHandles,
 } from './workflow-handle-validator';
+import { WorkflowLifecycleService } from './workflow-lifecycle.service';
 
 export interface EventCatalogDeliveryRow {
   registrationCode: string;
@@ -407,6 +408,7 @@ export class WorkflowService {
     private temporalService: TemporalService,
     private humanApprovalService: HumanApprovalService,
     private workflowCompiler: WorkflowCompilerService,
+    private workflowLifecycle: WorkflowLifecycleService,
   ) {}
 
   /**
@@ -2012,15 +2014,13 @@ export class WorkflowService {
         retryCheckpoint: readRetryCheckpoint(instance.context),
       });
     } catch (error) {
-      await this.prisma.workflowInstance.updateMany({
-        where: { id: instance.id, status: 'PENDING', temporalRunId },
-        data: {
-          status: 'FAILED',
-          result: {
-            code: 'TEMPORAL_START_FAILED',
-            message: error instanceof Error ? error.message : String(error),
-          },
-          finishedAt: new Date(),
+      await this.workflowLifecycle.markFailed({
+        instanceId: instance.id,
+        expectedStatuses: ['PENDING'],
+        temporalRunId,
+        result: {
+          code: 'TEMPORAL_START_FAILED',
+          message: error instanceof Error ? error.message : String(error),
         },
       });
       throw error;
@@ -2486,21 +2486,27 @@ export class WorkflowService {
   @Interval(60_000)
   async reconcileUnstartedInstances(): Promise<void> {
     const cutoff = new Date(Date.now() - 60_000);
-    await this.prisma.workflowInstance.updateMany({
+    const unreservedInstances = await this.prisma.workflowInstance.findMany({
       where: {
         status: 'PENDING',
         temporalRunId: null,
         createdAt: { lte: cutoff },
       },
-      data: {
-        status: 'FAILED',
+      orderBy: { id: 'asc' },
+      take: 100,
+      select: { id: true },
+    });
+    for (const instance of unreservedInstances) {
+      await this.workflowLifecycle.markFailed({
+        instanceId: instance.id,
+        expectedStatuses: ['PENDING'],
+        temporalRunId: null,
         result: {
           code: 'TEMPORAL_START_NOT_RESERVED',
           message: 'Workflow failed before Temporal execution was reserved',
         },
-        finishedAt: new Date(),
-      },
-    });
+      });
+    }
 
     const reservedInstances = await this.prisma.workflowInstance.findMany({
       where: {
@@ -2542,13 +2548,30 @@ export class WorkflowService {
             );
             continue;
           }
-          await this.temporalService.startWorkflow({
-            instanceId: Number(instance.id),
-            workflowId: Number(instance.workflowId),
-            versionId: Number(instance.versionId),
-            dsl: version.dsl,
-            context: (instance.context ?? {}) as Record<string, any>,
-            retryCheckpoint: readRetryCheckpoint(instance.context),
+          try {
+            await this.temporalService.startWorkflow({
+              instanceId: Number(instance.id),
+              workflowId: Number(instance.workflowId),
+              versionId: Number(instance.versionId),
+              dsl: version.dsl,
+              context: (instance.context ?? {}) as Record<string, any>,
+              retryCheckpoint: readRetryCheckpoint(instance.context),
+            });
+          } catch (error) {
+            await this.failUnstartedInstance(
+              instance.id,
+              instance.temporalRunId!,
+              error instanceof Error ? error.message : String(error),
+            );
+            continue;
+          }
+          await this.prisma.workflowEventDelivery.updateMany({
+            where: { workflowInstanceId: instance.id, status: 'FAILED' },
+            data: {
+              status: 'DISPATCHED',
+              dispatchedAt: new Date(),
+              lastError: null,
+            },
           });
           temporalState = await this.temporalService.inspectWorkflow(
             instance.temporalRunId!,
@@ -2574,15 +2597,13 @@ export class WorkflowService {
     instanceId: bigint,
     temporalRunId: string,
   ): Promise<void> {
-    await this.prisma.workflowInstance.updateMany({
-      where: { id: instanceId, status: 'RUNNING', temporalRunId },
-      data: {
-        status: 'FAILED',
-        result: {
-          code: 'TEMPORAL_EXECUTION_MISSING',
-          message: 'Temporal execution disappeared while Workflow was running',
-        },
-        finishedAt: new Date(),
+    await this.workflowLifecycle.markFailed({
+      instanceId,
+      expectedStatuses: ['RUNNING'],
+      temporalRunId,
+      result: {
+        code: 'TEMPORAL_EXECUTION_MISSING',
+        message: 'Temporal execution disappeared while Workflow was running',
       },
     });
   }
@@ -2592,13 +2613,11 @@ export class WorkflowService {
     temporalRunId: string,
     message: string,
   ): Promise<void> {
-    await this.prisma.workflowInstance.updateMany({
-      where: { id: instanceId, status: 'PENDING', temporalRunId },
-      data: {
-        status: 'FAILED',
-        result: { code: 'TEMPORAL_START_RECONCILIATION_FAILED', message },
-        finishedAt: new Date(),
-      },
+    await this.workflowLifecycle.markFailed({
+      instanceId,
+      expectedStatuses: ['PENDING'],
+      temporalRunId,
+      result: { code: 'TEMPORAL_START_RECONCILIATION_FAILED', message },
     });
   }
 
@@ -2663,12 +2682,23 @@ export class WorkflowService {
       }
       return;
     }
-    const status =
-      state.status === 'COMPLETED'
-        ? 'COMPLETED'
-        : state.status === 'CANCELLED'
-        ? 'CANCELLED'
-        : 'FAILED';
+    if (state.status !== 'COMPLETED' && state.status !== 'CANCELLED') {
+      await this.workflowLifecycle.markFailed({
+        instanceId,
+        expectedStatuses: ['PENDING', 'RUNNING'],
+        temporalRunId,
+        result:
+          state.result === undefined
+            ? {
+                code: 'TEMPORAL_TERMINAL_STATUS_RECONCILED',
+                temporalStatus: state.status,
+              }
+            : normalizeTemporalCompletedResult(state.result),
+        startedAt: state.startedAt,
+        finishedAt: state.finishedAt,
+      });
+      return;
+    }
     await this.prisma.workflowInstance.updateMany({
       where: {
         id: instanceId,
@@ -2676,7 +2706,7 @@ export class WorkflowService {
         temporalRunId,
       },
       data: {
-        status,
+        status: state.status,
         result:
           state.result === undefined
             ? {

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/workflowConfig/node-config-validator.service.spec.ts

@@ -409,4 +409,29 @@ describe('event trigger operation rules schema', () => {
       ]),
     ).toThrow(BadRequestException);
   });
+  it('accepts a configured failure callback and rejects a non-relative path', () => {
+    const base = {
+      registrationCode: 'request-changes',
+      processingMode: 'PARALLEL',
+      operationRules: [{ operation: 'INSERT' }],
+    };
+    expect(() =>
+      service.validateOrThrow('event:6', schema, {
+        ...base,
+        failureCallback: {
+          connectionRef: 'hardware-service',
+          path: '/api/hardware-disposal/workflow-failed',
+        },
+      }),
+    ).not.toThrow();
+    expect(() =>
+      service.validateOrThrow('event:6', schema, {
+        ...base,
+        failureCallback: {
+          connectionRef: 'hardware-service',
+          path: 'https://unexpected.example.com/callback',
+        },
+      }),
+    ).toThrow(BadRequestException);
+  });
 });

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/components/TransferExportModal.tsx

@@ -0,0 +1,115 @@
+import { CopyOutlined, LoadingOutlined } from '@ant-design/icons';
+import { Alert, Button, Input, Modal, Space, message } from 'antd';
+import { customRequest } from 'helpers/http';
+import React, { useCallback, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+export type TransferEntity = 'user' | 'role' | 'page' | 'resource';
+
+interface TransferExportModalProps {
+  open: boolean;
+  onClose: () => void;
+  /** e.g. `role/SYSTEM_ADMIN/export-token`; null disables fetching */
+  exportTokenEndpoint: string | null;
+  /** drives the "what this export contains" hint */
+  entity: TransferEntity;
+  title?: string;
+}
+
+/**
+ * Generic "export via signed URL" modal (workflow ExportModal pattern).
+ * Asks the backend for a 30-minute export URL and lets the user copy it
+ * into the target environment's TransferImportModal.
+ */
+export function TransferExportModal({
+  open,
+  onClose,
+  exportTokenEndpoint,
+  entity,
+  title,
+}: TransferExportModalProps) {
+  const { t } = useTranslation();
+  const [url, setUrl] = useState<string>('');
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (open && exportTokenEndpoint) {
+      setUrl('');
+      setLoading(true);
+      customRequest<{ url: string }>(exportTokenEndpoint, 'POST')
+        .then((res) => setUrl(res.url))
+        .catch((e: any) =>
+          message.error(e?.message ?? t('transfer.export.failed')),
+        )
+        .finally(() => setLoading(false));
+    }
+  }, [open, exportTokenEndpoint]);
+
+  const handleCopy = useCallback(async () => {
+    try {
+      await navigator.clipboard.writeText(url);
+      message.success(t('transfer.export.copied'));
+    } catch {
+      // Fallback for older browsers
+      const textarea = document.getElementById(
+        'transfer-export-url-input',
+      ) as HTMLTextAreaElement;
+      textarea?.select();
+      document.execCommand('copy');
+      message.success(t('transfer.export.copied'));
+    }
+  }, [url]);
+
+  return (
+    <Modal
+      title={title ?? t('transfer.export.title')}
+      open={open}
+      onCancel={onClose}
+      footer={
+        <Space>
+          <Button onClick={onClose}>{t('buttons.cancel')}</Button>
+          <Button
+            type="primary"
+            icon={<CopyOutlined />}
+            onClick={handleCopy}
+            disabled={!url}
+          >
+            {t('transfer.export.copyUrl')}
+          </Button>
+        </Space>
+      }
+    >
+      <Alert
+        type="info"
+        showIcon
+        style={{ marginBottom: 16 }}
+        message={t('transfer.export.scopeTitle')}
+        description={t(`transfer.export.scope.${entity}`)}
+      />
+      {loading ? (
+        <div style={{ textAlign: 'center', padding: 24 }}>
+          <LoadingOutlined style={{ fontSize: 24 }} />
+          <p>{t('transfer.export.generating')}</p>
+        </div>
+      ) : (
+        <>
+          <p
+            style={{
+              marginBottom: 8,
+              color: 'var(--ant-color-text-secondary)',
+            }}
+          >
+            {t('transfer.export.urlHint')}
+          </p>
+          <Input.TextArea
+            id="transfer-export-url-input"
+            value={url}
+            readOnly
+            autoSize={{ minRows: 3, maxRows: 5 }}
+            onFocus={(e) => e.target.select()}
+          />
+        </>
+      )}
+    </Modal>
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/components/TransferImportModal.tsx

@@ -0,0 +1,257 @@
+import { CheckOutlined, CloudDownloadOutlined } from '@ant-design/icons';
+import { Alert, Button, Input, Modal, Space, Spin, message } from 'antd';
+import { customRequest } from 'helpers/http';
+import React, { useCallback, useState } from 'react';
+import ReactDiffViewer, { DiffMethod } from 'react-diff-viewer-continued';
+import { useTranslation } from 'react-i18next';
+
+interface MissingRef {
+  type: 'page' | 'resource' | 'parentPage';
+  code: string;
+}
+
+interface PreviewResponse {
+  current: any;
+  incoming: any;
+  missingRefs: MissingRef[];
+  conflicts: string[];
+}
+
+interface TransferImportModalProps {
+  open: boolean;
+  onClose: () => void;
+  onSuccess: () => void;
+  /** e.g. 'role/import-preview' */
+  previewEndpoint: string;
+  /** e.g. 'role/import-confirm' */
+  confirmEndpoint: string;
+  /** extra follow-up note shown after a successful import (e.g. "grant the
+   *  page to a role, otherwise the menu stays hidden") */
+  successHint?: string;
+  title?: string;
+}
+
+type Phase = 'input' | 'preview' | 'confirming';
+
+/**
+ * Generic "import from a source-environment export URL" modal
+ * (workflow ImportModal pattern): paste URL → diff preview → confirm.
+ * Import is blocked when the preview reports missing referenced
+ * pages/resources or conflicts.
+ */
+export function TransferImportModal({
+  open,
+  onClose,
+  onSuccess,
+  previewEndpoint,
+  confirmEndpoint,
+  successHint,
+  title,
+}: TransferImportModalProps) {
+  const { t } = useTranslation();
+  const [sourceUrl, setSourceUrl] = useState('');
+  const [phase, setPhase] = useState<Phase>('input');
+  const [loading, setLoading] = useState(false);
+  const [currentJson, setCurrentJson] = useState('');
+  const [incomingJson, setIncomingJson] = useState('');
+  const [missingRefs, setMissingRefs] = useState<MissingRef[]>([]);
+  const [conflicts, setConflicts] = useState<string[]>([]);
+  const [payload, setPayload] = useState<any>(null);
+
+  const reset = useCallback(() => {
+    setSourceUrl('');
+    setPhase('input');
+    setLoading(false);
+    setCurrentJson('');
+    setIncomingJson('');
+    setMissingRefs([]);
+    setConflicts([]);
+    setPayload(null);
+  }, []);
+
+  const handleClose = useCallback(() => {
+    reset();
+    onClose();
+  }, [reset, onClose]);
+
+  const blocked = missingRefs.length > 0 || conflicts.length > 0;
+
+  const handleFetchPreview = useCallback(async () => {
+    if (!sourceUrl.trim()) {
+      message.warning(t('transfer.import.pasteUrl'));
+      return;
+    }
+
+    setLoading(true);
+    try {
+      // Step 1: Fetch from source URL (cross-origin)
+      const response = await fetch(sourceUrl.trim());
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => null);
+        throw new Error(
+          errorData?.message ||
+            t('transfer.import.fetchFailed', { status: response.status }),
+        );
+      }
+      const exportData = await response.json();
+
+      // Step 2: Send to our import-preview endpoint
+      const preview = await customRequest<PreviewResponse>(
+        previewEndpoint,
+        'POST',
+        { payload: exportData },
+      );
+
+      // Step 3: Format for diff viewer
+      setCurrentJson(
+        preview.current ? JSON.stringify(preview.current, null, 2) : '',
+      );
+      setIncomingJson(JSON.stringify(preview.incoming, null, 2));
+      setMissingRefs(preview.missingRefs ?? []);
+      setConflicts(preview.conflicts ?? []);
+      setPayload(exportData);
+      setPhase('preview');
+    } catch (e: any) {
+      if (e.message?.includes('expired') || e.message?.includes('invalid')) {
+        message.error(t('transfer.import.expired'));
+      } else {
+        message.error(e?.message || t('transfer.import.unreachable'));
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [sourceUrl, previewEndpoint]);
+
+  const handleConfirm = useCallback(async () => {
+    if (!payload || blocked) return;
+    setPhase('confirming');
+    try {
+      const result = await customRequest<{ success: boolean; key: string }>(
+        confirmEndpoint,
+        'POST',
+        { payload },
+      );
+
+      message.success(t('transfer.import.success', { name: result.key }));
+      if (successHint) {
+        // longer duration: this is an actionable follow-up, not a status blip
+        message.info(successHint, 10);
+      }
+      reset();
+      onClose();
+      onSuccess();
+    } catch (e: any) {
+      message.error(e?.message ?? t('transfer.import.failed'));
+      setPhase('preview');
+    }
+  }, [
+    payload,
+    blocked,
+    confirmEndpoint,
+    successHint,
+    reset,
+    onClose,
+    onSuccess,
+  ]);
+
+  return (
+    <Modal
+      title={title ?? t('transfer.import.title')}
+      open={open}
+      onCancel={handleClose}
+      width={phase === 'preview' ? '90vw' : 520}
+      footer={
+        phase === 'input' ? (
+          <Space>
+            <Button onClick={handleClose}>{t('buttons.cancel')}</Button>
+            <Button
+              type="primary"
+              icon={<CloudDownloadOutlined />}
+              onClick={handleFetchPreview}
+              loading={loading}
+            >
+              {t('transfer.import.fetchPreview')}
+            </Button>
+          </Space>
+        ) : (
+          <Space>
+            <Button onClick={handleClose}>{t('buttons.cancel')}</Button>
+            <Button
+              type="primary"
+              icon={<CheckOutlined />}
+              onClick={handleConfirm}
+              loading={phase === 'confirming'}
+              disabled={blocked}
+            >
+              {t('transfer.import.confirm')}
+            </Button>
+          </Space>
+        )
+      }
+    >
+      {phase === 'input' && (
+        <>
+          <p style={{ marginBottom: 8 }}>{t('transfer.import.urlHint')}</p>
+          <Input.TextArea
+            value={sourceUrl}
+            onChange={(e) => setSourceUrl(e.target.value)}
+            placeholder="https://dev.example.com/api/role/export/SYSTEM_ADMIN?token=..."
+            autoSize={{ minRows: 3, maxRows: 5 }}
+          />
+        </>
+      )}
+
+      {phase === 'preview' && (
+        <div style={{ maxHeight: '70vh', overflow: 'auto' }}>
+          {missingRefs.length > 0 && (
+            <Alert
+              type="warning"
+              showIcon
+              style={{ marginBottom: 12 }}
+              message={t('transfer.import.missingRefsTitle')}
+              description={
+                <ul style={{ margin: 0, paddingInlineStart: 20 }}>
+                  {missingRefs.map((m) => (
+                    <li key={`${m.type}:${m.code}`}>
+                      {t(`transfer.import.missingRefType.${m.type}`)}: {m.code}
+                    </li>
+                  ))}
+                </ul>
+              }
+            />
+          )}
+          {conflicts.length > 0 && (
+            <Alert
+              type="error"
+              showIcon
+              style={{ marginBottom: 12 }}
+              message={t('transfer.import.conflictsTitle')}
+              description={
+                <ul style={{ margin: 0, paddingInlineStart: 20 }}>
+                  {conflicts.map((c) => (
+                    <li key={c}>{c}</li>
+                  ))}
+                </ul>
+              }
+            />
+          )}
+          <ReactDiffViewer
+            oldValue={currentJson}
+            newValue={incomingJson}
+            splitView
+            compareMethod={DiffMethod.LINES}
+            leftTitle={t('transfer.import.current')}
+            rightTitle={t('transfer.import.incoming')}
+          />
+        </div>
+      )}
+
+      {phase === 'confirming' && (
+        <div style={{ textAlign: 'center', padding: 40 }}>
+          <Spin size="large" />
+          <p style={{ marginTop: 16 }}>{t('transfer.import.importing')}</p>
+        </div>
+      )}
+    </Modal>
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useDynamicResources.tsx

@@ -6,7 +6,6 @@ import {
   BgColorsOutlined,
   ScheduleOutlined,
   ApartmentOutlined,
-  SafetyCertificateOutlined,
   TeamOutlined,
   UserOutlined,
 } from '@ant-design/icons';
@@ -50,7 +49,6 @@ export const iconMapping: Record<string, React.ReactNode> = {
   agenda: <ScheduleOutlined />,
   workflow: <ApartmentOutlined />,
   person_directory: <UserOutlined />,
-  user: <SafetyCertificateOutlined />,
   people_group: <TeamOutlined />,
 };
 

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/locales/en/common.json

@@ -371,5 +371,45 @@
       "renameDuplicate": "Name already exists",
       "renameFailed": "Rename failed"
     }
+  },
+  "transfer": {
+    "import": {
+      "title": "Import",
+      "fetchPreview": "Fetch & Preview",
+      "confirm": "Confirm Import",
+      "urlHint": "Paste the export URL generated by the source environment:",
+      "current": "Current env",
+      "incoming": "Source env",
+      "importing": "Importing…",
+      "pasteUrl": "Please paste an export URL",
+      "fetchFailed": "Failed to fetch data: {{status}}",
+      "expired": "Export link expired or invalid. Please regenerate it in the source environment.",
+      "unreachable": "Cannot reach the source environment. Check the URL and retry.",
+      "success": "\"{{name}}\" imported successfully!",
+      "failed": "Import failed",
+      "missingRefsTitle": "The target environment is missing these references. Import them first:",
+      "missingRefType": {
+        "page": "Page",
+        "resource": "Resource",
+        "parentPage": "Parent page"
+      },
+      "conflictsTitle": "Conflicts detected, import blocked:",
+      "pageRoleHint": "The page was imported but is not granted to any role yet, so it will not appear in the menu. Import the matching role, or grant the page to a role under Role Management."
+    },
+    "export": {
+      "title": "Export",
+      "copyUrl": "Copy URL",
+      "generating": "Generating export URL…",
+      "urlHint": "Export URL (valid for 30 minutes). Paste it into the target environment's import dialog:",
+      "failed": "Failed to generate export URL",
+      "copied": "URL copied to clipboard",
+      "scopeTitle": "What this export contains",
+      "scope": {
+        "user": "Includes: userid, name, roles, active status. Excludes: API keys and other credentials (never transferred across environments).",
+        "role": "Includes: role details, accessible pages (rolePages) and resource permissions (roleResource). Note: referenced pages and resources must already exist in the target environment.",
+        "page": "Includes: this page with all its descendants and their resource bindings (pageResource). Excludes: role grants (rolePages) — after importing, also import the matching role or grant it under Role Management, otherwise the menu stays hidden.",
+        "resource": "Includes: resource code, name, description and the common-resource flag."
+      }
+    }
   }
 }