@ximatai/muyun-web-app 0.26.11 → 0.26.13

package/dist/types/views/metadataModelTree.d.ts

@@ -0,0 +1,40 @@
+import type { Metadata, MetadataField, ModuleMetadataRelation } from '../web-contracts/index';
+import type { UiTreeDropEvent, UiTreeNode } from '../vue-ui-antdv/index';
+export type MetadataModelTreeNodeKind = 'METADATA' | 'FIELD';
+export interface MetadataModelTreeNode extends UiTreeNode {
+    modelKind: MetadataModelTreeNodeKind;
+    relationId?: string;
+    fieldId?: string;
+    /** Parent relation, not the visual root. It makes the reorder boundary explicit. */
+    parentRelationId?: string;
+    /** Locked nodes are intentionally visible but never draggable. */
+    draggable?: boolean;
+}
+export interface MetadataModelTreeInput {
+    relations: ModuleMetadataRelation[];
+    metadataById: Record<string, Metadata>;
+    fieldsByRelation: Record<string, MetadataField[]>;
+    fieldLocked: (relation: ModuleMetadataRelation, field: MetadataField) => boolean;
+}
+/**
+ * The governance tree is a projection of the model, not a second persistence shape. Metadata
+ * branches and field leaves retain their relation/field identities so the page can route to
+ * strongly typed cards. The explorer title already states "元数据", so entity nodes are roots
+ * rather than being wrapped in a redundant virtual node.
+ */
+export declare function buildMetadataModelTree(input: MetadataModelTreeInput): MetadataModelTreeNode[];
+export declare function metadataNodeKey(relationId: string): string;
+export declare function fieldNodeKey(relationId: string, fieldId: string): string;
+export declare function parseMetadataModelTreeKey(key: string): {
+    kind: 'METADATA';
+    relationId: string;
+} | {
+    kind: 'FIELD';
+    relationId: string;
+    fieldId: string;
+} | undefined;
+/** Only same-parent gap drops are legal. Dropping "on" a node would imply changing model structure. */
+export declare function canReorderMetadataModelTree(event: UiTreeDropEvent): boolean;
+export declare function reorderedIds<T extends {
+    id?: string;
+}>(items: T[], sourceId: string, targetId: string, place: -1 | 1): string[];

package/dist/types/views/metadataNaming.d.ts

@@ -0,0 +1,7 @@
+import type { MetadataFieldPropertyKind } from './metadataOrchestrationState';
+export declare function physicalNameOf(fieldName?: string): string;
+export declare function generatedFieldName(title?: string): string;
+/** Default names for newly created business fields; runtime semantics remain metadata-driven. */
+export declare function generatedBusinessFieldName(title: string | undefined, kind: MetadataFieldPropertyKind): string;
+/** Metadata identifiers use lower snake case; they are stable after explicit editing. */
+export declare function generatedMetadataAlias(title: string, maxLength?: number): string;

package/dist/types/views/metadataOrchestrationState.d.ts

@@ -1,7 +1,7 @@
 import type { FieldSpec, Metadata, MetadataField, ModuleMetadataRelation } from '../web-contracts/index';
 import type { RecordExplorerItemDescriptor } from '../platform-components/recordExplorerItemModel';
 /** Editor lifecycle of the metadata orchestration workspace. */
-export type MetadataOrchestrationMode = 'view' | 'create-main' | 'create-field' | 'edit-field';
+export type MetadataOrchestrationMode = 'view' | 'create-main' | 'create-field' | 'create-reference-field' | 'create-dictionary-field' | 'edit-field';
 export interface MainMetadataDraft {
     alias: string;
     title: string;
@@ -10,6 +10,52 @@ export interface MainMetadataDraft {
     dataScopeEnabled: boolean;
 }
 export type MetadataFieldDraft = Partial<MetadataField>;
+/**
+ * A field's business property is distinct from its physical field specification.  For example,
+ * a reference can still use a short-text column to store a target key.
+ */
+export type MetadataFieldPropertyKind = 'BASIC' | 'MODULE_REFERENCE' | 'DICTIONARY' | 'LEGACY_LOCKED';
+export interface MetadataFieldReferencePropertyConfig {
+    targetModuleAlias?: string;
+    targetMetadataId?: string;
+    targetKeyField?: string;
+    targetLabelField?: string;
+    cardinality?: 'ONE' | 'MANY';
+    targetUnavailablePolicy?: 'PRESERVE_HISTORY' | 'RESTRICT' | 'CASCADE_DELETE';
+    projectionMappings?: string[];
+}
+export interface MetadataFieldDictionaryPropertyConfig {
+    dictionaryApplicationAlias?: string;
+    dictionaryCategoryAlias?: string;
+    selectionMode?: 'SINGLE' | 'MULTIPLE';
+}
+/**
+ * The platform field-spec catalog owns these stable storage shapes.  A property editor must
+ * select a legal shape rather than exposing every scalar type as a possible reference/dictionary
+ * backing store.
+ */
+export declare function storageFieldSpecAliasOf(kind: MetadataFieldPropertyKind, selectionMode?: MetadataFieldDictionaryPropertyConfig['selectionMode']): string | undefined;
+export interface MetadataFieldPropertyDraft {
+    kind: MetadataFieldPropertyKind;
+    expectedBindingVersion?: number;
+    referenceConfig?: MetadataFieldReferencePropertyConfig;
+    dictionaryConfig?: MetadataFieldDictionaryPropertyConfig;
+}
+/** Relation-scoped property facts supplied by the module-governance read model. */
+export interface MetadataFieldPropertySummary extends MetadataFieldPropertyDraft {
+    fieldId?: string;
+    fieldName?: string;
+    fieldSpecAlias?: string;
+    bindingVersion?: number;
+    legacyReason?: string;
+    /** Transport shape of the relation-scoped property summary. */
+    reference?: MetadataFieldReferencePropertyConfig;
+    dictionary?: {
+        applicationAlias?: string;
+        categoryAlias?: string;
+        selectionMode?: 'SINGLE' | 'MULTIPLE';
+    };
+}
 export interface FieldSpecOption {
     value: string;
     label: string;
@@ -19,7 +65,7 @@ export declare function createMetadataOrchestrationState(): {
         moduleAlias?: string | undefined;
         metadataId?: string | undefined;
         relationAlias?: string | undefined;
-        relationRole?: "MAIN" | "CHILD" | undefined;
+        relationRole?: "main" | "child" | "MAIN" | "CHILD" | undefined;
         parentMetadataId?: string | undefined;
         foreignKey?: string | undefined;
         autoPopulate?: boolean | undefined;
@@ -38,7 +84,7 @@ export declare function createMetadataOrchestrationState(): {
         moduleAlias?: string | undefined;
         metadataId?: string | undefined;
         relationAlias?: string | undefined;
-        relationRole?: "MAIN" | "CHILD" | undefined;
+        relationRole?: "main" | "child" | "MAIN" | "CHILD" | undefined;
         parentMetadataId?: string | undefined;
         foreignKey?: string | undefined;
         autoPopulate?: boolean | undefined;
@@ -111,6 +157,61 @@ export declare function createMetadataOrchestrationState(): {
         updatedBy?: string | undefined;
         updatedAt?: string | undefined;
     }[]>;
+    allFields: import("vue").Ref<{
+        metadataId?: string | undefined;
+        fieldName?: string | undefined;
+        columnName?: string | undefined;
+        fieldSpecAlias?: string | undefined;
+        fieldOwnership?: string | undefined;
+        fieldForm?: string | undefined;
+        ownerFieldId?: string | undefined;
+        fieldRole?: string | undefined;
+        systemManaged?: boolean | undefined;
+        required?: boolean | undefined;
+        uniqueField?: boolean | undefined;
+        indexed?: boolean | undefined;
+        sortableField?: boolean | undefined;
+        titleField?: boolean | undefined;
+        enabled?: boolean | undefined;
+        sortOrder?: number | undefined;
+        title?: string | undefined;
+        id?: string | undefined;
+        tenantId?: string | undefined;
+        version?: number | undefined;
+        deleted?: boolean | undefined;
+        deletedAt?: string | undefined;
+        createdBy?: string | undefined;
+        createdAt?: string | undefined;
+        updatedBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }[], MetadataField[] | {
+        metadataId?: string | undefined;
+        fieldName?: string | undefined;
+        columnName?: string | undefined;
+        fieldSpecAlias?: string | undefined;
+        fieldOwnership?: string | undefined;
+        fieldForm?: string | undefined;
+        ownerFieldId?: string | undefined;
+        fieldRole?: string | undefined;
+        systemManaged?: boolean | undefined;
+        required?: boolean | undefined;
+        uniqueField?: boolean | undefined;
+        indexed?: boolean | undefined;
+        sortableField?: boolean | undefined;
+        titleField?: boolean | undefined;
+        enabled?: boolean | undefined;
+        sortOrder?: number | undefined;
+        title?: string | undefined;
+        id?: string | undefined;
+        tenantId?: string | undefined;
+        version?: number | undefined;
+        deleted?: boolean | undefined;
+        deletedAt?: string | undefined;
+        createdBy?: string | undefined;
+        createdAt?: string | undefined;
+        updatedBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }[]>;
     fieldSpecs: import("vue").Ref<{
         alias?: string | undefined;
         fieldType?: string | undefined;
@@ -121,6 +222,7 @@ export declare function createMetadataOrchestrationState(): {
         queryOperators?: string[] | undefined;
         defaultUiControlAlias?: string | undefined;
         uiControlAliases?: string[] | undefined;
+        safeTargetFieldSpecAliases?: string[] | undefined;
         enabled?: boolean | undefined;
         sortOrder?: number | undefined;
         title?: string | undefined;
@@ -143,6 +245,7 @@ export declare function createMetadataOrchestrationState(): {
         queryOperators?: string[] | undefined;
         defaultUiControlAlias?: string | undefined;
         uiControlAliases?: string[] | undefined;
+        safeTargetFieldSpecAliases?: string[] | undefined;
         enabled?: boolean | undefined;
         sortOrder?: number | undefined;
         title?: string | undefined;
@@ -225,11 +328,46 @@ export declare function createMetadataOrchestrationState(): {
         updatedBy?: string | undefined;
         updatedAt?: string | undefined;
     }>;
+    fieldPropertyDraft: import("vue").Ref<{
+        kind: MetadataFieldPropertyKind;
+        expectedBindingVersion?: number | undefined;
+        referenceConfig?: {
+            targetModuleAlias?: string | undefined;
+            targetMetadataId?: string | undefined;
+            targetKeyField?: string | undefined;
+            targetLabelField?: string | undefined;
+            cardinality?: "ONE" | "MANY" | undefined;
+            targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            projectionMappings?: string[] | undefined;
+        } | undefined;
+        dictionaryConfig?: {
+            dictionaryApplicationAlias?: string | undefined;
+            dictionaryCategoryAlias?: string | undefined;
+            selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
+        } | undefined;
+    }, MetadataFieldPropertyDraft | {
+        kind: MetadataFieldPropertyKind;
+        expectedBindingVersion?: number | undefined;
+        referenceConfig?: {
+            targetModuleAlias?: string | undefined;
+            targetMetadataId?: string | undefined;
+            targetKeyField?: string | undefined;
+            targetLabelField?: string | undefined;
+            cardinality?: "ONE" | "MANY" | undefined;
+            targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            projectionMappings?: string[] | undefined;
+        } | undefined;
+        dictionaryConfig?: {
+            dictionaryApplicationAlias?: string | undefined;
+            dictionaryCategoryAlias?: string | undefined;
+            selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
+        } | undefined;
+    }>;
     selectedRelation: import("vue").ComputedRef<{
         moduleAlias?: string | undefined;
         metadataId?: string | undefined;
         relationAlias?: string | undefined;
-        relationRole?: "MAIN" | "CHILD" | undefined;
+        relationRole?: "main" | "child" | "MAIN" | "CHILD" | undefined;
         parentMetadataId?: string | undefined;
         foreignKey?: string | undefined;
         autoPopulate?: boolean | undefined;
@@ -257,8 +395,9 @@ export declare function createMetadataOrchestrationState(): {
     selectRelation: (relation: ModuleMetadataRelation) => boolean;
     focusRelation: (relationId: string | undefined) => void;
     startCreateMain: () => void;
-    startCreateField: () => void;
-    startEditField: (field: MetadataField) => void;
+    startCreateField: (kind?: MetadataFieldPropertyKind) => void;
+    startEditField: (field: MetadataField, property?: MetadataFieldPropertyDraft) => void;
+    startConfigureFieldProperty: (field: MetadataField, kind: Exclude<MetadataFieldPropertyKind, "BASIC" | "LEGACY_LOCKED">) => void;
     cancelEditor: () => void;
 };
 export type MetadataOrchestrationState = ReturnType<typeof createMetadataOrchestrationState>;
@@ -266,13 +405,29 @@ export declare function emptyMainMetadataDraft(): MainMetadataDraft;
 export declare function normalizeMainMetadataDraft(draft: MainMetadataDraft): MainMetadataDraft;
 export declare function isValidMainMetadataDraft(draft: MainMetadataDraft): boolean;
 export declare function emptyFieldDraft(): MetadataFieldDraft;
+export declare function emptyFieldPropertyDraft(kind: MetadataFieldPropertyKind): MetadataFieldPropertyDraft;
+export declare function copyFieldPropertyDraft(property: MetadataFieldPropertyDraft): MetadataFieldPropertyDraft;
+/** Converts the read-model's concise bindings into the draft contract accepted by change sets. */
+export declare function propertyDraftFromSummary(summary: MetadataFieldPropertySummary): MetadataFieldPropertyDraft;
 export declare function copyMetadataField(field: MetadataField): MetadataFieldDraft;
 export declare function isValidFieldDraft(draft: MetadataFieldDraft): boolean;
 export declare function normalizeFieldDraft(draft: MetadataFieldDraft): MetadataFieldDraft;
+export declare function normalizeFieldPropertyDraft(property: MetadataFieldPropertyDraft): MetadataFieldPropertyDraft;
+export declare function isValidFieldPropertyDraft(property: MetadataFieldPropertyDraft): boolean;
+export declare function metadataFieldPropertyLabel(kind: MetadataFieldPropertyKind): string;
+export declare function metadataFieldPropertySummary(property: MetadataFieldPropertyDraft): string;
 /** Only business-owned physical fields are orchestrated; platform-managed fields stay hidden. */
 export declare function orchestratableFields(fields: MetadataField[]): MetadataField[];
+/** Only these field facts may be changed through the metadata field editor. */
+export declare function isOrchestratableField(field: MetadataField): boolean;
 export declare function fieldSpecOptionListOf(specs: FieldSpec[]): FieldSpecOption[];
+/** Filters a populated entity to the source specification's server-declared safe targets. */
+export declare function dataSafeFieldSpecOptions(specs: FieldSpec[], currentAlias?: string): FieldSpecOption[];
+/** Use the catalog title for human-facing metadata surfaces; aliases remain stable machine identities. */
+export declare function fieldSpecDisplayLabel(fieldSpecAlias: string | undefined, specs: FieldSpec[]): string;
 export declare function entityTitleOf(relation: ModuleMetadataRelation, metadata: Metadata | undefined): string;
 export declare function relationRoleTag(role: ModuleMetadataRelation['relationRole']): string | undefined;
+/** Java code enums are serialized by their stable lower-case code in runtime responses. */
+export declare function isMainRelation(role: ModuleMetadataRelation['relationRole'] | undefined): boolean;
 export declare function entityExplorerItem(relation: ModuleMetadataRelation, metadata: Metadata | undefined): RecordExplorerItemDescriptor;
 export declare function metadataSubtitleOf(metadata: Metadata | undefined): string | undefined;

package/dist/types/views/metadataSourceTree.d.ts

@@ -0,0 +1,10 @@
+import type { UiTreeNode } from '../vue-ui-antdv/index';
+/** Shared metadata presentation; consumers supply actions and capability restrictions. */
+export declare function metadataSourceFieldNode(field: {
+    title: string;
+    fieldName: string;
+    platformReadOnly?: boolean;
+    referenceModuleAlias?: string;
+    expandable?: boolean;
+}, options: Pick<UiTreeNode, 'key'> & Partial<UiTreeNode>): UiTreeNode;
+export declare function metadataSourceRoot(title: string, children: UiTreeNode[]): UiTreeNode;

package/dist/types/views/moduleGovernanceWorkspaceView.d.ts

@@ -0,0 +1,9 @@
+export declare const moduleGovernanceTabs: readonly ["overview", "metadata", "actions", "rules", "ui", "preview"];
+export type ModuleGovernanceTab = (typeof moduleGovernanceTabs)[number];
+export interface ModuleGovernanceWorkspaceViewInput {
+    moduleAlias: string;
+    moduleTitle?: string;
+    governanceTab?: ModuleGovernanceTab;
+}
+/** The module-scoped home for configuration governance surfaces. */
+export declare const moduleGovernanceWorkspaceView: import("../platform-workbench/workspaceViewContract.ts").WorkspaceViewDefinition<ModuleGovernanceWorkspaceViewInput>;