openxiangda-cli 2.0.0-alpha.100

package/template/apps/web/playwright.config.ts

@@ -0,0 +1,44 @@
+import { defineConfig } from '@playwright/test';
+
+const e2ePort = resolveE2ePort();
+const baseURL =
+  process.env.OPENXIANGDA_E2E_BASE_URL || `http://127.0.0.1:${e2ePort}`;
+
+export default defineConfig({
+  testDir: './e2e',
+  workers: 2,
+  use: { baseURL, trace: 'retain-on-failure' },
+  webServer: process.env.OPENXIANGDA_E2E_BASE_URL
+    ? undefined
+    : {
+        command: 'pnpm dev',
+        url: baseURL,
+        reuseExistingServer: false,
+        env: {
+          OPENXIANGDA_WEB_PORT: String(e2ePort),
+          OPENXIANGDA_ENVIRONMENT_KEY: 'production',
+          OPENXIANGDA_DEV_PROXY:
+            process.env.OPENXIANGDA_E2E_PLATFORM_URL ||
+            'http://127.0.0.1:7001',
+        },
+      },
+});
+
+function resolveE2ePort() {
+  const configured = process.env.OPENXIANGDA_E2E_PORT;
+  if (configured !== undefined) {
+    const port = Number(configured);
+    if (!Number.isInteger(port) || port < 1024 || port > 65535) {
+      throw new Error(
+        'OPENXIANGDA_E2E_PORT must be an integer between 1024 and 65535'
+      );
+    }
+    return port;
+  }
+
+  let hash = 2166136261;
+  for (const character of process.cwd()) {
+    hash = Math.imul(hash ^ character.charCodeAt(0), 16777619);
+  }
+  return 30_000 + ((hash >>> 0) % 30_000);
+}

package/template/apps/web/scripts/check.mjs

@@ -0,0 +1,43 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+const root = resolve(import.meta.dirname, '..');
+const files = [];
+function visit(directory) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory() && !['.umi', '.umi-production', '.turbopack'].includes(entry.name)) visit(path);
+    else if (/\.(?:ts|tsx)$/.test(entry.name)) files.push(path);
+  }
+}
+visit(join(root, 'src'));
+const lines = files.reduce((total, file) => total + readFileSync(file, 'utf8').split(/\r?\n/).length, 0);
+// The shared Surface renderer is deliberately counted as application source;
+// keep its small budget explicit instead of hiding it in generated output.
+// Field Kit families are separate modules so a semantic field does not add a
+// branch to one universal renderer. Keep explicit ceilings while allowing the
+// complete 30-field standard kit to remain decomposed.
+if (files.length > 36) throw new Error(`WEB_SOURCE_FILE_BUDGET_EXCEEDED:${files.length}>36`);
+if (lines > 10_000) throw new Error(`WEB_BUSINESS_LOC_BUDGET_EXCEEDED:${lines}>10000`);
+const source = files.map((file) => readFileSync(file, 'utf8')).join('\n');
+for (const marker of [
+  '@umijs/',
+  'openxiangda-' + 'admin',
+  'openxiangda-' + 'user',
+  'instrument_query',
+  'instrument_save',
+  'function.invoke',
+  'authorization' + '-mode',
+  'focused' + '_role',
+  '/native/current' + '-user',
+  'college-' + 'am',
+  'user-' + 'wang',
+  'dept-' + 'am-test',
+]) {
+  if (source.includes(marker)) throw new Error(`WEB_FORBIDDEN_MARKER:${marker}`);
+}
+const playwright = readFileSync(join(root, 'playwright.config.ts'), 'utf8');
+if (!playwright.includes('reuseExistingServer: false')) {
+  throw new Error('WEB_E2E_MUST_NOT_REUSE_UNKNOWN_SERVER');
+}
+process.stdout.write(`Verified Vite/Refine web source: ${files.length} files, ${lines} LOC.\n`);

package/template/apps/web/scripts/verify-build.mjs

@@ -0,0 +1,6 @@
+import { verifyOpenXiangdaWebBuild } from 'openxiangda/testing';
+
+const result = verifyOpenXiangdaWebBuild(new URL('../dist', import.meta.url));
+process.stdout.write(
+  `Verified Vite build: ${result.totalBytes} bytes, ${result.totalJavaScriptGzipBytes} total gzip bytes, ${result.initialJavaScriptGzipBytes} initial gzip bytes.\n`
+);

package/template/apps/web/src/main.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import { OpenXiangdaApplication } from 'openxiangda/react';
+import {
+  appCode,
+  appName,
+  resourceDefinitions,
+  workflowCodes,
+} from '../../../packages/contracts/src/generated.js';
+import 'openxiangda/react/styles.css';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <OpenXiangdaApplication
+      appCode={appCode}
+      appName={appName}
+      resourceDefinitions={resourceDefinitions}
+      workflows={workflowCodes}
+    />
+  </React.StrictMode>,
+);

package/template/apps/web/test/contracts.test.ts

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync } from 'node:fs';
+import test from 'node:test';
+import { readRuntimeMount, resolveApplicationBasename } from 'openxiangda/core';
+import {
+  resourceCodes,
+  resourceDefinitions,
+} from '../../../packages/contracts/src/generated.js';
+
+test('clean template contains only application declarations and one React entry', () => {
+  const config = readFileSync(
+    new URL('../../../openxiangda.config.ts', import.meta.url),
+    'utf8'
+  );
+  const source = readFileSync(new URL('../src/main.tsx', import.meta.url), 'utf8');
+  const productionSources = readdirSync(new URL('../src', import.meta.url), {
+    withFileTypes: true,
+  })
+    .filter(entry => entry.isFile())
+    .map(entry => entry.name)
+    .sort();
+  assert.deepEqual(productionSources, ['main.tsx']);
+  assert.deepEqual(Object.keys(resourceDefinitions).sort(), [...resourceCodes].sort());
+  assert.match(config, /data:\s*\{\s*resources:/);
+  assert.match(source, /OpenXiangdaApplication/);
+  assert.match(source, /from 'openxiangda\/react'/);
+  assert.match(source, /openxiangda\/react\/styles\.css/);
+  const legacyMarkers = [
+    'instruments',
+    'colleges',
+    '仪器' + '资源管理',
+    '学院' + '字典',
+    'HGY',
+    'Instrument',
+  ];
+  assert.doesNotMatch(`${config}\n${source}`, new RegExp(legacyMarkers.join('|')));
+});
+
+test('application manifests expose one direct OpenXiangda dependency', () => {
+  for (const relative of [
+    '../../../package.json',
+    '../package.json',
+    '../../server/package.json',
+  ]) {
+    const manifest = JSON.parse(
+      readFileSync(new URL(relative, import.meta.url), 'utf8')
+    ) as Record<string, Record<string, string>>;
+    const dependencies = Object.entries({
+      ...(manifest.dependencies || {}),
+      ...(manifest.devDependencies || {}),
+      ...(manifest.peerDependencies || {}),
+    }).filter(([name]) =>
+      name === 'openxiangda' || name.startsWith('openxiangda-')
+    );
+    assert.deepEqual(
+      dependencies.map(([name]) => name),
+      dependencies.length ? ['openxiangda'] : []
+    );
+  }
+});
+
+test('runtime metadata stays mount-scoped', () => {
+  const mount = readRuntimeMount(
+    name =>
+      ({
+        'openxiangda-runtime-base': '/view/example-app/',
+        'openxiangda-app-code': 'example-app',
+        'openxiangda-environment': 'preproduction',
+      })[name]
+  );
+  assert.equal(resolveApplicationBasename(mount), '/view/example-app');
+});
+
+test('resource E2E harness owns the standard export download response', () => {
+  const source = readFileSync(
+    new URL('../e2e/resources.spec.ts', import.meta.url),
+    'utf8'
+  );
+  assert.match(source, /\/native\\\/data\\\/\(\[\^\/\]\+\)\\\/export\$/);
+  assert.match(source, /content-disposition/);
+  assert.match(source, /text\/csv/);
+});
+
+test('published E2E harnesses do not write evidence into the platform source repository', () => {
+  const workflowSource = readFileSync(
+    new URL('../e2e/workflow.spec.ts', import.meta.url),
+    'utf8'
+  );
+  assert.doesNotMatch(workflowSource, /docs\/architecture|evidenceDirectory/);
+});
+
+test('the platform package owns Web build verification policy', () => {
+  const verifier = readFileSync(
+    new URL('../scripts/verify-build.mjs', import.meta.url),
+    'utf8'
+  );
+  assert.match(verifier, /verifyOpenXiangdaWebBuild/);
+  assert.doesNotMatch(verifier, /2_650_000|800_000|600_000/);
+});

package/template/apps/web/test/loopback.test.ts

@@ -0,0 +1,62 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import { networkInterfaces } from 'node:os';
+import { resolve } from 'node:path';
+import test from 'node:test';
+
+test('Vite is reachable on loopback and not on a LAN interface', async t => {
+  const port = await freePort();
+  const root = resolve(import.meta.dirname, '..');
+  const child = spawn('pnpm', ['exec', 'vite', '--port', String(port), '--strictPort'], {
+    cwd: root,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      OPENXIANGDA_WEB_PORT: String(port),
+      OPENXIANGDA_DEV_PROXY: 'http://127.0.0.1:7001',
+    },
+  });
+  try {
+    await waitFor(`http://127.0.0.1:${port}`);
+    const lan = Object.values(networkInterfaces())
+      .flat()
+      .find(address => address?.family === 'IPv4' && !address.internal)?.address;
+    if (!lan) {
+      t.diagnostic('No non-loopback IPv4 interface; loopback reachability verified.');
+      return;
+    }
+    await assert.rejects(
+      fetch(`http://${lan}:${port}`, {
+        signal: AbortSignal.timeout(500),
+      })
+    );
+  } finally {
+    child.kill('SIGTERM');
+    await new Promise(resolve => child.once('exit', resolve));
+  }
+});
+
+async function freePort() {
+  return await new Promise<number>((resolve, reject) => {
+    const server = createServer();
+    server.once('error', reject);
+    server.listen({ host: '127.0.0.1', port: 0 }, () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close(error => (error ? reject(error) : resolve(port)));
+    });
+  });
+}
+
+async function waitFor(url: string) {
+  const deadline = Date.now() + 10_000;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) return;
+    } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error(`VITE_READINESS_TIMEOUT:${url}`);
+}

package/template/apps/web/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "noEmit": true,
+    "exactOptionalPropertyTypes": false,
+    "types": ["vite/client", "node"]
+  },
+  "include": ["src", "test", "vite.config.ts", "playwright.config.ts"]
+}

package/template/apps/web/vite.config.ts

@@ -0,0 +1,31 @@
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+
+const connectedProxy =
+  process.env.OPENXIANGDA_DEV_PROXY?.trim() || 'http://127.0.0.1:7001';
+const port = Number(process.env.OPENXIANGDA_WEB_PORT || 5173);
+
+export default defineConfig({
+  plugins: [react()],
+  base: './',
+  server: {
+    host: '127.0.0.1',
+    port,
+    strictPort: true,
+    proxy: {
+      '/service': { target: connectedProxy, changeOrigin: false },
+      '/api': { target: connectedProxy, changeOrigin: false },
+    },
+  },
+  build: {
+    sourcemap: false,
+    rollupOptions: {
+      output: {
+        manualChunks: {
+          react: ['react', 'react-dom', 'react-router-dom'],
+          refine: ['@refinedev/core'],
+        },
+      },
+    },
+  },
+});

package/template/openxiangda.config.ts

@@ -0,0 +1,30 @@
+import { defineOpenXiangdaApp } from 'openxiangda/config';
+
+/** Clean application scaffold: declare resources and fields, then generate CRUD. */
+export default defineOpenXiangdaApp({
+  schemaVersion: 3,
+  app: { code: 'openxiangda-application', name: 'OpenXiangda 应用' },
+  frontend: { root: 'apps/web', routes: [] },
+  backend: {
+    root: 'apps/server',
+    runtime: 'node',
+    framework: 'nestjs',
+    enabled: false,
+    isolation: 'shared',
+    resourceProfile: 'light',
+    secrets: [],
+    operations: [],
+  },
+  platform: { root: 'platform' },
+  authz: {
+    capabilities: [],
+    roles: [],
+    scopeDimensions: [],
+    scopeSources: [],
+    dataPolicies: [],
+    authorizationTransitions: [],
+  },
+  data: { resources: [] },
+  events: { schemas: [], subscriptions: [], timers: [], dateTriggers: [] },
+  workflows: { definitions: [], bindings: [], activations: [], providers: [], editableParameters: [] },
+});

package/template/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "openxiangda-application",
+  "version": "0.1.0",
+  "private": true,
+  "packageManager": "pnpm@10.15.1",
+  "engines": {
+    "node": ">=22.12"
+  },
+  "scripts": {
+    "openxiangda": "openxiangda",
+    "prepare": "pnpm workspace:build",
+    "workspace:build": "pnpm --filter @app/contracts build",
+    "predev": "pnpm workspace:build",
+    "dev": "pnpm --parallel --filter './apps/*' dev",
+    "dev:web": "pnpm --filter @app/web dev",
+    "dev:server": "pnpm --filter @app/server dev",
+    "precheck": "pnpm workspace:build",
+    "check": "pnpm --recursive check && node scripts/verify-template-budget.mjs",
+    "pretest": "pnpm workspace:build",
+    "test": "pnpm --recursive test",
+    "test:e2e": "pnpm --filter @app/web test:e2e",
+    "build": "pnpm --recursive build"
+  },
+  "devDependencies": {
+    "openxiangda": "2.0.0-alpha.12",
+    "typescript": "5.9.3"
+  }
+}

package/template/packages/contracts/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@app/contracts",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "openxiangda-source": "./src/index.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "node -e \"process.stdout.write('generated contracts checked by TypeScript\\n')\"",
+    "build": "tsc -p tsconfig.json"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3"
+  }
+}

package/template/packages/contracts/src/generated.ts

@@ -0,0 +1,124 @@
+// Generated by OpenXiangda 2.0 Native compiler. Do not edit by hand.
+export const compilerContractVersion = "native-2" as const;
+export const appCode = "openxiangda-application" as const;
+export const appName = "OpenXiangda 应用" as const;
+export const resourceCodes = [] as const;
+export const resourceSurfaces = {} as const;
+export const resourceDefinitions = {} as const;
+export const capabilities = [
+  "app:openxiangda-application:directory:read",
+  "app:role:assign",
+  "app:role:define",
+  "app:role:grant-capability",
+  "app:role:read",
+  "app:scope-grant:manage",
+  "app:super-admin:manage"
+] as const;
+export const appOperations = {} as const;
+export const appRoutes = {} as const;
+export const eventTypes = [] as const;
+export const eventSubscriptionCodes = [] as const;
+export const eventHandlerManifest = {
+  "schemaVersion": "openxiangda.event-handler-manifest/v2",
+  "appCode": "openxiangda-application",
+  "handlers": []
+} as const;
+export const eventHandlers = {} as const;
+export const eventSchemas = [] as const;
+export const workflowCodes = [] as const;
+
+export type ResourceCode = (typeof resourceCodes)[number];
+export type Capability = (typeof capabilities)[number];
+export type AppOperation = (typeof appOperations)[keyof typeof appOperations];
+export type AppRoute = (typeof appRoutes)[keyof typeof appRoutes];
+export type EventType = (typeof eventTypes)[number];
+export type EventSubscriptionCode = (typeof eventSubscriptionCodes)[number];
+export type EventTypesForSubscription<TCode extends EventSubscriptionCode> = never;
+export type WorkflowCode = (typeof workflowCodes)[number];
+
+export interface OpenXiangdaCloudEvent<TType extends EventType = EventType, TData extends Record<string, unknown> = Record<string, unknown>> {
+  specversion: "1.0";
+  id: string;
+  source: string;
+  type: TType;
+  subject?: string;
+  time: string;
+  datacontenttype: "application/json";
+  dataschema?: string;
+  data: TData;
+  tenantid: string;
+  appcode: typeof appCode;
+  environment: string;
+  traceid?: string;
+  schemaversion: string;
+}
+export type EventHandlerInput<TCode extends EventSubscriptionCode> = OpenXiangdaCloudEvent<EventTypesForSubscription<TCode>>;
+
+export interface LabeledValue {
+  label: string;
+  value: string;
+  description?: string;
+  color?: string;
+}
+export interface ResourceReferenceValue extends LabeledValue {
+  resourceCode: string;
+  snapshot?: Record<string, unknown>;
+}
+export interface DepartmentReferenceValue extends LabeledValue {
+  fullPath?: string;
+  path?: LabeledValue[];
+  parent?: LabeledValue;
+}
+export interface UserReferenceValue extends LabeledValue {
+  avatarUrl?: string;
+  employeeNo?: string;
+  title?: string;
+  mobile?: string;
+  email?: string;
+  departments?: DepartmentReferenceValue[];
+}
+export interface DateRangeValue { start: string; end: string; }
+export type CascadePathValue = LabeledValue[];
+export interface DataFileRef {
+  schemaVersion: 'openxiangda.data-file-ref/v2';
+  id: string;
+  name: string;
+  size: number;
+  contentType: string;
+}
+export interface DataImageRef extends DataFileRef {
+  width: number;
+  height: number;
+  thumbnailUrl: string;
+  previewUrl: string;
+}
+export interface StableSignatureValue {
+  file: Omit<DataFileRef, 'schemaVersion'>;
+  signer?: UserReferenceValue;
+  signedAt: string;
+  points?: Array<{ x: number; y: number; t: number }>;
+  hash: string;
+}
+export interface StableAddressValue {
+  country?: LabeledValue;
+  province?: LabeledValue;
+  city?: LabeledValue;
+  district?: LabeledValue;
+  street?: LabeledValue;
+  detail?: string;
+  fullAddress?: string;
+}
+export interface StableLocationSnapshot {
+  address?: string;
+  name?: string;
+  province?: string;
+  city?: string;
+  district?: string;
+  accuracy?: number;
+  capturedAt?: string;
+}
+export type StableLocationValue = StableLocationSnapshot & {
+  source: 'browser' | 'dingTalk';
+  longitude: number;
+  latitude: number;
+};

package/template/packages/contracts/src/index.ts

@@ -0,0 +1 @@
+export * from './generated.js';

package/template/packages/contracts/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/template/pnpm-workspace.yaml

@@ -0,0 +1,7 @@
+packages:
+  - apps/*
+  - packages/*
+
+strictDepBuilds: true
+onlyBuiltDependencies:
+  - esbuild

package/template/scripts/verify-template-budget.mjs

@@ -0,0 +1,49 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+
+const root = resolve(import.meta.dirname, '..');
+const generated = /(?:^|\/)(?:node_modules|dist|coverage|playwright-report|test-results|\.openxiangda|\.turbo|\.turbopack|\.umi|\.umi-production)(?:\/|$)/;
+const sourceExtensions = /\.(?:[cm]?[jt]sx?|css|html|json|md|ya?ml)$/;
+const files = [];
+function visit(directory) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    const name = relative(root, path).replaceAll('\\', '/');
+    if (
+      generated.test(name) ||
+      name === 'pnpm-lock.yaml' ||
+      name === 'packages/contracts/src/generated.ts'
+    ) continue;
+    if (entry.isDirectory()) visit(path);
+    else if (entry.isFile() && sourceExtensions.test(name)) files.push(path);
+  }
+}
+visit(root);
+const bytes = files.reduce((total, file) => total + statSync(file).size, 0);
+if (files.length > 50) throw new Error(`TEMPLATE_SOURCE_FILE_BUDGET_EXCEEDED:${files.length}>50`);
+if (bytes > 500_000) throw new Error(`TEMPLATE_SOURCE_BYTE_BUDGET_EXCEEDED:${bytes}>500000`);
+const productionFiles = files.filter(file => {
+  const name = relative(root, file).replaceAll('\\', '/');
+  return (
+    name === 'package.json' ||
+    name === 'openxiangda.config.ts' ||
+    name.startsWith('platform/') ||
+    (name.startsWith('apps/') &&
+      !name.includes('/test/') &&
+      !name.includes('/e2e/') &&
+      !name.includes('/scripts/'))
+  );
+});
+const source = productionFiles.map(file => readFileSync(file, 'utf8')).join('\n');
+const agents = readFileSync(resolve(root, 'AGENTS.md'), 'utf8');
+if (!agents.includes('pnpm openxiangda')) throw new Error('TEMPLATE_AGENT_PINNED_CLI_MISSING');
+if (
+  !agents.includes("union of that user's application roles") ||
+  !agents.includes('does not transmit a RoleSession header')
+) {
+  throw new Error('TEMPLATE_AGENT_ROLE_UNION_BOUNDARY_MISSING');
+}
+for (const marker of ['@umijs/', 'openxiangda-' + 'admin', 'openxiangda-' + 'user', 'instrument_query', 'instrument_save', 'function.invoke', 'departmentScopeKey', 'instrumentScopeKey', 'adminUserIds', 'college-' + 'am', 'user-' + 'wang', 'dept-' + 'am-test']) {
+  if (source.includes(marker)) throw new Error(`TEMPLATE_FORBIDDEN_MARKER:${marker}`);
+}
+process.stdout.write(`Verified compact template: ${files.length} source files, ${bytes} bytes.\n`);

package/template/tsconfig.base.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  }
+}