@gadmin2n/schematics 0.0.136 → 0.0.138

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/temporal-tenant/index.tsx

@@ -0,0 +1,225 @@
+import React, { useEffect, useState } from 'react';
+import {
+  Alert,
+  Button,
+  Card,
+  Form,
+  Input,
+  Spin,
+  Typography,
+  message,
+} from 'antd';
+import { ArrowLeftOutlined } from '@ant-design/icons';
+import { useNavigate } from 'react-router-dom';
+import { useGetIdentity } from '@refinedev/core';
+import { customRequest } from 'helpers/http';
+
+const { Title, Text } = Typography;
+
+interface TenantConfig {
+  id: number;
+  adminUrl: string;
+  adminToken: string;
+  namespace: string;
+  dbUrl: string;
+  displayName: string;
+}
+
+export default function TemporalTenantPage() {
+  const navigate = useNavigate();
+  const [form] = Form.useForm();
+  const { data: identity } = useGetIdentity<any>();
+  const isAdmin = (identity?.configPerms?.roles || []).includes('SYSTEM_ADMIN');
+
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [existing, setExisting] = useState<TenantConfig | null>(null);
+
+  useEffect(() => {
+    customRequest('temporalTenantConfig/findMany', 'POST', {
+      take: 1,
+      skip: 0,
+      select: {
+        id: true,
+        adminUrl: true,
+        adminToken: true,
+        namespace: true,
+        dbUrl: true,
+        displayName: true,
+      },
+    })
+      .then((res: any) => {
+        const item = res?.data?.data?.[0] ?? null;
+        setExisting(item);
+        if (item) form.setFieldsValue(item);
+      })
+      .catch(() => message.error('加载配置失败'))
+      .finally(() => setLoading(false));
+  }, [form]);
+
+  const handleSave = async (values: Omit<TenantConfig, 'id'>) => {
+    setSaving(true);
+    try {
+      if (existing) {
+        await customRequest(
+          `temporalTenantConfig/updateUnique/${existing.id}`,
+          'PATCH',
+          values,
+        );
+        message.success('更新成功，Temporal worker 已热重载连接');
+      } else {
+        await customRequest('temporalTenantConfig/createOne', 'POST', values);
+        message.success('注册成功');
+      }
+      const res: any = await customRequest(
+        'temporalTenantConfig/findMany',
+        'POST',
+        {
+          take: 1,
+          skip: 0,
+          select: {
+            id: true,
+            adminUrl: true,
+            adminToken: true,
+            namespace: true,
+            dbUrl: true,
+            displayName: true,
+          },
+        },
+      );
+      setExisting(res?.data?.data?.[0] ?? null);
+    } catch (e: any) {
+      message.error(e?.response?.data?.message || '操作失败');
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  if (!isAdmin) {
+    return (
+      <div style={{ padding: 24 }}>
+        <Alert type="error" message="无权限访问此页面" />
+      </div>
+    );
+  }
+
+  if (loading) {
+    return (
+      <div
+        style={{ display: 'flex', justifyContent: 'center', paddingTop: 80 }}
+      >
+        <Spin size="large" />
+      </div>
+    );
+  }
+
+  return (
+    <div
+      style={{
+        background: '#f0f2f5',
+        minHeight: 'calc(100vh - 64px)',
+      }}
+    >
+      <Card
+        style={{ marginBottom: 16 }}
+        styles={{ body: { padding: '16px 24px' } }}
+      >
+        <div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
+          <Button
+            type="text"
+            icon={<ArrowLeftOutlined />}
+            onClick={() => navigate(-1)}
+          />
+          <div>
+            <Title level={4} style={{ margin: 0 }}>
+              服务注册
+            </Title>
+          </div>
+        </div>
+      </Card>
+
+      <Card styles={{ body: { padding: '24px 32px' } }}>
+        {existing && (
+          <Alert
+            type="info"
+            showIcon
+            message="修改 dbUrl 后，Temporal worker 会立即重载数据库连接"
+            style={{ marginBottom: 24 }}
+          />
+        )}
+        <Form
+          form={form}
+          layout="vertical"
+          onFinish={handleSave}
+          style={{ maxWidth: 600 }}
+        >
+          <Title level={5} style={{ color: '#595959' }}>
+            Admin API 连接
+          </Title>
+          <div
+            style={{
+              display: 'grid',
+              gridTemplateColumns: '1fr 1fr',
+              gap: '0 16px',
+            }}
+          >
+            <Form.Item
+              label="Admin URL"
+              name="adminUrl"
+              rules={[{ required: true, message: '请输入 Admin URL' }]}
+            >
+              <Input placeholder="http://localhost:8081" />
+            </Form.Item>
+            <Form.Item
+              label="Admin Token"
+              name="adminToken"
+              rules={[{ required: true, message: '请输入 Admin Token' }]}
+            >
+              <Input.Password placeholder="32 位 hex token" />
+            </Form.Item>
+          </div>
+
+          <Title level={5} style={{ color: '#595959', marginTop: 8 }}>
+            租户信息
+          </Title>
+          <div
+            style={{
+              display: 'grid',
+              gridTemplateColumns: '1fr 1fr',
+              gap: '0 16px',
+            }}
+          >
+            <Form.Item
+              label="Namespace"
+              name="namespace"
+              rules={[{ required: true, message: '请输入 namespace' }]}
+            >
+              <Input placeholder="gadmin-test" />
+            </Form.Item>
+            <Form.Item
+              label="Display Name"
+              name="displayName"
+              rules={[{ required: true, message: '请输入展示名' }]}
+            >
+              <Input placeholder="Gadmin Test" />
+            </Form.Item>
+          </div>
+
+          <Form.Item
+            label="DB URL（Temporal worker 视角）"
+            name="dbUrl"
+            rules={[{ required: true, message: '请输入 DB URL' }]}
+          >
+            <Input placeholder="postgresql://user:pw@host.containers.internal:5432/gadmin_demo" />
+          </Form.Item>
+
+          <Form.Item style={{ marginTop: 8 }}>
+            <Button type="primary" htmlType="submit" loading={saving}>
+              {existing ? '更新并同步到 Temporal' : '注册到 Temporal'}
+            </Button>
+          </Form.Item>
+        </Form>
+      </Card>
+    </div>
+  );
+}

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/utilities/lazy-with-reload.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+
+function isChunkLoadError(error: unknown): boolean {
+  const msg = String((error as Error)?.message ?? '');
+  return (
+    msg.includes('Failed to fetch dynamically imported module') ||
+    msg.includes('Importing a module script failed') ||
+    msg.includes('error loading dynamically imported module') ||
+    msg.includes('Unable to preload CSS for')
+  );
+}
+
+// Detects stale-chunk errors (old hash URLs 404 after a new deploy) and
+// auto-reloads once, so users don't see the "Application Error" screen.
+export function lazyWithReload<T extends React.ComponentType<any>>(
+  factory: () => Promise<{ default: T }>,
+): React.LazyExoticComponent<T> {
+  return React.lazy(() =>
+    factory().catch((error: unknown) => {
+      if (isChunkLoadError(error) && !import.meta.env.DEV) {
+        const key = `chunk_reload_${window.location.pathname}`;
+        if (!sessionStorage.getItem(key)) {
+          sessionStorage.setItem(key, '1');
+          window.location.reload();
+          return new Promise<{ default: T }>(() => {});
+        }
+      }
+      throw error;
+    }),
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gadmin2n/schematics",
-  "version": "0.0.136",
+  "version": "0.0.138",
   "description": "Gadmin - modern, fast, powerful node.js web framework (@schematics)",
   "main": "dist/index.js",
   "files": [

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

@@ -1,220 +0,0 @@
-import {
-  validateDslHandles,
-  type NodeOutputsMap,
-  type WorkflowDsl,
-} from './workflow-dsl-validate';
-
-// Test fixture: a small NodeOutputsMap mirroring the live DB seed for the
-// node types we exercise here. Mirrors NODE_TYPE_META used in the worker test.
-const OUTPUTS_MAP: NodeOutputsMap = {
-  if_else: ['true', 'false'],
-  switch: null,
-  cron_trigger: [],
-  manual_trigger: [],
-  webhook_trigger: [],
-  http_request: [],
-};
-
-// ─── helpers ─────────────────────────────────────────────────────────────────
-
-function makeNode(
-  id: string,
-  type: string,
-  config: Record<string, any> = {},
-): WorkflowDsl['nodes'][number] {
-  return { id, type, config };
-}
-
-function makeEdge(
-  id: string,
-  source: string,
-  target: string,
-  sourceHandle?: string,
-): WorkflowDsl['edges'][number] {
-  return sourceHandle === undefined
-    ? { id, source, target }
-    : { id, source, target, sourceHandle };
-}
-
-// ─── if_else (enumerated outputs) ────────────────────────────────────────────
-
-describe('validateDslHandles — if_else', () => {
-  it('accepts sourceHandle "true"', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', 'true')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-
-  it('accepts sourceHandle "false"', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', 'false')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-
-  it('rejects unknown sourceHandle "maybe"', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', 'maybe')],
-    };
-    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
-    expect(errors[0].reason).toMatch(/not in declared outputs/);
-  });
-
-  it('rejects missing sourceHandle', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b')],
-    };
-    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('MISSING_HANDLE');
-    expect(errors[0].reason).toMatch(/requires a sourceHandle/);
-  });
-
-  it('rejects empty-string sourceHandle as missing', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('a', 'if_else'), makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'a', 'b', '')],
-    };
-    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('MISSING_HANDLE');
-  });
-});
-
-// ─── cron_trigger (no named outputs) ─────────────────────────────────────────
-
-describe('validateDslHandles — cron_trigger (no named outputs)', () => {
-  it('rejects sourceHandle "foo" on a node with no named handles', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
-      edges: [makeEdge('e1', 't', 'a', 'foo')],
-    };
-    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('EXTRA_HANDLE');
-    expect(errors[0].reason).toMatch(/no named output handles/);
-  });
-
-  it('accepts no sourceHandle', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
-      edges: [makeEdge('e1', 't', 'a')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-
-  it('accepts empty-string sourceHandle (treated as absent for [] nodes)', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('t', 'cron_trigger'), makeNode('a', 'http_request')],
-      edges: [makeEdge('e1', 't', 'a', '')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-});
-
-// ─── switch (dynamic outputs) ────────────────────────────────────────────────
-
-describe('validateDslHandles — switch (dynamic outputs)', () => {
-  it('accepts sourceHandle matching a case value', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [
-        makeNode('s', 'switch', { cases: [{ value: 'a' }, { value: 'b' }] }),
-        makeNode('x', 'http_request'),
-      ],
-      edges: [makeEdge('e1', 's', 'x', 'a')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-
-  it('rejects sourceHandle not in case values', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [
-        makeNode('s', 'switch', { cases: [{ value: 'a' }] }),
-        makeNode('x', 'http_request'),
-      ],
-      edges: [makeEdge('e1', 's', 'x', 'c')],
-    };
-    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
-    expect(errors).toHaveLength(1);
-    expect(errors[0].edgeId).toBe('e1');
-    expect(errors[0].code).toBe('UNKNOWN_HANDLE');
-  });
-
-  it('skips validation when switch config has no cases (in-progress editor)', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('s', 'switch'), makeNode('x', 'http_request')],
-      edges: [makeEdge('e1', 's', 'x', 'anything')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-});
-
-// ─── out-of-scope (orphan / unknown) ────────────────────────────────────────
-
-describe('validateDslHandles — out-of-scope', () => {
-  it('ignores edge referencing missing source node', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [makeNode('b', 'http_request')],
-      edges: [makeEdge('e1', 'ghost', 'b', 'true')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-
-  it('ignores edges from unknown node types', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [
-        makeNode('u', 'wholly_made_up_type'),
-        makeNode('b', 'http_request'),
-      ],
-      edges: [makeEdge('e1', 'u', 'b', 'whatever')],
-    };
-    expect(validateDslHandles(dsl, OUTPUTS_MAP)).toEqual([]);
-  });
-});
-
-// ─── multiple errors collected ──────────────────────────────────────────────
-
-describe('validateDslHandles — multiple errors', () => {
-  it('collects every error in one pass', () => {
-    const dsl: WorkflowDsl = {
-      nodes: [
-        makeNode('if', 'if_else'),
-        makeNode('cron', 'cron_trigger'),
-        makeNode('sw', 'switch', { cases: [{ value: 'a' }] }),
-        makeNode('x', 'http_request'),
-      ],
-      edges: [
-        makeEdge('e1', 'if', 'x', 'maybe'), // bad enumerated
-        makeEdge('e2', 'if', 'x'), // missing required
-        makeEdge('e3', 'cron', 'x', 'foo'), // forbidden handle
-        makeEdge('e4', 'sw', 'x', 'c'), // bad dynamic
-      ],
-    };
-    const errors = validateDslHandles(dsl, OUTPUTS_MAP);
-    expect(errors).toHaveLength(4);
-    expect(errors.map((e) => e.edgeId).sort()).toEqual([
-      'e1',
-      'e2',
-      'e3',
-      'e4',
-    ]);
-    const byEdge = Object.fromEntries(errors.map((e) => [e.edgeId, e.code]));
-    expect(byEdge).toEqual({
-      e1: 'UNKNOWN_HANDLE',
-      e2: 'MISSING_HANDLE',
-      e3: 'EXTRA_HANDLE',
-      e4: 'UNKNOWN_HANDLE',
-    });
-  });
-});

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

@@ -1,132 +0,0 @@
-/**
- * DSL handle validator (server-side).
- *
- * Mirrors temporal/worker/src/dsl/validate.ts but is independent:
- * - reads node-type outputs from a passed-in map (caller fetches from DB)
- * - returns the same DslValidationCode discriminator for FE compatibility
- *
- * Why duplicated rather than imported from worker: server and worker are
- * separate projects without a shared package; cross-project imports would
- * break tsc paths and Docker build.
- */
-
-export type DslValidationCode =
-  | 'EXTRA_HANDLE' // node has [] outputs, but edge set sourceHandle
-  | 'MISSING_HANDLE' // node has named outputs, but edge has no sourceHandle (or empty string)
-  | 'UNKNOWN_HANDLE'; // edge sourceHandle is set but ∉ declared outputs
-
-export interface DslValidationError {
-  edgeId: string;
-  source: string;
-  target: string;
-  code: DslValidationCode;
-  reason: string;
-}
-
-export interface DslNode {
-  id: string;
-  type: string;
-  config?: Record<string, any>;
-}
-
-export interface DslEdge {
-  id: string;
-  source: string;
-  target: string;
-  sourceHandle?: string;
-}
-
-export interface WorkflowDsl {
-  nodes: DslNode[];
-  edges: DslEdge[];
-}
-
-/**
- * Map from node type name -> outputs declaration.
- *
- *  - null:        dynamic (e.g. switch — derived from node.config)
- *  - []:          single anonymous output, no sourceHandle allowed
- *  - ['a','b',…]: enumerated named outputs; sourceHandle MUST be one of them
- *  - undefined:   unknown type; validator skips edges from such nodes
- */
-export type NodeOutputsMap = Record<string, string[] | null>;
-
-/**
- * Validate every edge's sourceHandle against the source node's outputs metadata.
- * Returns an array of errors (empty if DSL is valid).
- */
-export function validateDslHandles(
-  dsl: WorkflowDsl,
-  outputsMap: NodeOutputsMap,
-): DslValidationError[] {
-  const errors: DslValidationError[] = [];
-  const nodeMap = new Map<string, DslNode>(dsl.nodes.map((n) => [n.id, n]));
-
-  for (const edge of dsl.edges) {
-    const src = nodeMap.get(edge.source);
-    if (!src) continue; // separate concern: orphan edge — not this validator's job
-    if (!(src.type in outputsMap)) continue; // unknown node type — out of scope
-
-    const declared = outputsMap[src.type];
-    const handles = declared === null ? deriveDynamicOutputs(src) : declared;
-
-    // Empty named-handle list AND declared-non-null => no sourceHandle allowed
-    if (declared !== null && handles.length === 0) {
-      if (edge.sourceHandle != null && edge.sourceHandle !== '') {
-        errors.push({
-          edgeId: edge.id,
-          source: edge.source,
-          target: edge.target,
-          code: 'EXTRA_HANDLE',
-          reason: `Node "${src.type}" has no named output handles; edge must not set sourceHandle (got "${edge.sourceHandle}").`,
-        });
-      }
-      continue;
-    }
-
-    // Dynamic + still-empty (e.g. switch with no cases): in-progress, skip
-    if (handles.length === 0) continue;
-
-    if (edge.sourceHandle == null || edge.sourceHandle === '') {
-      errors.push({
-        edgeId: edge.id,
-        source: edge.source,
-        target: edge.target,
-        code: 'MISSING_HANDLE',
-        reason: `Node "${
-          src.type
-        }" requires a sourceHandle; choose one of: ${handles.join(', ')}.`,
-      });
-      continue;
-    }
-
-    if (!handles.includes(edge.sourceHandle)) {
-      errors.push({
-        edgeId: edge.id,
-        source: edge.source,
-        target: edge.target,
-        code: 'UNKNOWN_HANDLE',
-        reason: `Node "${src.type}" sourceHandle "${
-          edge.sourceHandle
-        }" is not in declared outputs: ${handles.join(', ')}.`,
-      });
-    }
-  }
-
-  return errors;
-}
-
-/**
- * For dynamic-output nodes (currently just `switch`), derive the list of
- * handle ids from the node's config.
- */
-function deriveDynamicOutputs(node: DslNode): string[] {
-  if (node.type === 'switch') {
-    const cases = node.config?.cases as Array<{ value?: string }> | undefined;
-    if (!Array.isArray(cases)) return [];
-    return cases
-      .map((c) => c?.value)
-      .filter((v): v is string => typeof v === 'string' && v.length > 0);
-  }
-  return [];
-}