@ximatai/muyun-web-app 0.26.13 → 0.26.15

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

@@ -0,0 +1,220 @@
+import type { MetadataField } from '../web-contracts/index';
+import type { OperationProposal } from '../web-core/index';
+import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
+import type { MetadataChangeSetPreview } from './metadataModelChangeSetClient';
+import type { MetadataFieldReferencePropertyConfig } from './metadataOrchestrationState';
+export interface MetadataGovernanceSummary {
+    moduleAlias: string;
+    moduleTitle?: string;
+    factsAvailable?: boolean;
+    submissionStatus?: 'idle' | 'unknown' | 'current-read';
+    committedNeedsReload?: boolean;
+    relationCount: number;
+    selectedRelation?: {
+        relationId: string;
+        title?: string;
+        fieldCount: number;
+        fieldsSource?: 'SAVED_CONFIGURATION' | 'UNSAVED_CANDIDATE';
+        fields: Array<Pick<MetadataField, 'required' | 'uniqueField' | 'indexed' | 'sortableField' | 'titleField' | 'enabled'> & {
+            fieldName: string;
+            columnName?: string;
+            title?: string;
+            fieldSpecAlias?: string;
+            defaultValue?: string | null;
+            propertyKind: string;
+            governance: string;
+            reference?: MetadataFieldReferencePropertyConfig;
+        }>;
+        capabilities?: Array<{
+            capability: string;
+            title: string;
+            enabled: boolean;
+            configurable: boolean;
+            selected: boolean;
+            reason: string;
+            fieldContributions: string[];
+            defaultDescription: string;
+        }>;
+        truncated: boolean;
+    };
+    mainCandidate?: {
+        alias: string;
+        title: string;
+        schemaName: string;
+        tableName: string;
+        storageDefaultsOnSave: Array<'schemaName' | 'tableName'>;
+        saved: false;
+        nextStep: 'REVIEW_AND_SAVE_STRUCTURE_BEFORE_FIELDS';
+    };
+    childCandidate?: {
+        alias: string;
+        title: string;
+        parentRelationId: string;
+        parentTitle?: string;
+        saved: false;
+    };
+    draft: {
+        active: boolean;
+        dirty: boolean;
+        editorOpen: boolean;
+        fieldPlanOpen?: boolean;
+        fieldPlanEditing?: boolean;
+    };
+    fieldSpecs: Array<{
+        alias: string;
+        title?: string;
+    }>;
+}
+export interface AddMetadataFieldDraftInput {
+    defaultValue?: string | null;
+    title: string;
+    fieldName?: string;
+    fieldSpecAlias: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    sortable?: boolean;
+    titleField?: boolean;
+}
+export interface UpdateMetadataFieldDraftInput {
+    defaultValue?: string | null;
+    fieldName: string;
+    title?: string;
+    fieldSpecAlias?: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    sortable?: boolean;
+    titleField?: boolean;
+    enabled?: boolean;
+}
+export interface UpdateMetadataReferenceDraftInput {
+    fieldName: string;
+    requireEnabled?: boolean;
+    affectMappings?: string[];
+}
+export type MetadataPropertyFieldKind = 'MODULE_REFERENCE' | 'DICTIONARY';
+export interface FindMetadataFieldTargetsInput {
+    kind: MetadataPropertyFieldKind;
+    keyword?: string;
+}
+export interface AddMetadataPropertyFieldDraftInput {
+    defaultValue?: string | null;
+    kind: MetadataPropertyFieldKind;
+    title: string;
+    fieldName?: string;
+    target: string;
+    selectionMode?: 'SINGLE' | 'MULTIPLE';
+    affectMappings?: string[];
+    required?: boolean;
+}
+export interface PreparedMetadataPropertyFieldDraft {
+    defaultValue?: string | null;
+    relationId: string;
+    kind: MetadataPropertyFieldKind;
+    title: string;
+    fieldName: string;
+    columnName: string;
+    fieldSpecAlias: string;
+    required: boolean;
+    reference?: {
+        targetModuleAlias: string;
+        targetMetadataId?: string;
+        targetKeyField: string;
+        targetLabelField: string;
+        affectMappings?: string[];
+    };
+    dictionary?: {
+        applicationAlias: string;
+        categoryAlias: string;
+        selectionMode: 'SINGLE' | 'MULTIPLE';
+    };
+}
+export interface MetadataFieldCandidate {
+    fieldName: string;
+    kind: string;
+    editable: boolean;
+    operation: 'ADD' | 'UPDATE';
+    saved: false;
+    expectedMetadataVersion: number;
+    changes: Array<{
+        property: string;
+        before?: string | boolean;
+        after?: string | boolean;
+    }>;
+}
+export type MetadataFieldPlanInput = Array<(AddMetadataFieldDraftInput & {
+    kind: 'BASIC';
+}) | AddMetadataPropertyFieldDraftInput>;
+/** Preparation validates without changing the editor; returned callbacks commit synchronously inside applyEffect. */
+export interface MetadataGovernanceEditor {
+    prepareMainDraft?(input: {
+        title: string;
+    }): () => unknown;
+    prepareChildDraft?(input: {
+        alias: string;
+        title: string;
+    }): () => unknown;
+    discardCandidate?(): void;
+    prepareConfirmation?(signal: AbortSignal): Promise<OperationProposal>;
+    readCurrent?(signal?: AbortSignal, commit?: (accept: () => void) => void): Promise<void>;
+    prepareFieldPlan?(fields: MetadataFieldPlanInput, signal: AbortSignal): Promise<() => unknown>;
+    plan?(): unknown;
+    prepareCapabilityDraft?(input: {
+        capability: string;
+        selected: boolean;
+    }): () => unknown;
+    prepareRetainFieldDraft?(): () => unknown;
+    removableNewFieldNames?(): string[];
+    prepareRemoveNewFieldDraft?(input: {
+        fieldName: string;
+    }): () => unknown;
+    summary(): MetadataGovernanceSummary;
+    candidate?(): MetadataFieldCandidate | undefined;
+    proposal(): MetadataModelChangeSetProposal | undefined;
+    preview(proposal: MetadataModelChangeSetProposal, signal: AbortSignal): Promise<MetadataChangeSetPreview>;
+    fieldSpecAliases(): string[];
+    editableBasicFieldNames(): string[];
+    editableReferenceFieldNames?(): string[];
+    prepareReferenceUpdate?(input: UpdateMetadataReferenceDraftInput, signal: AbortSignal): Promise<() => unknown>;
+    prepareNewFieldDraft?(input: AddMetadataFieldDraftInput): () => {
+        relationId: string;
+        fieldName: string;
+        columnName: string;
+        title: string;
+        fieldSpecAlias: string;
+    };
+    prepareFieldUpdate?(input: UpdateMetadataFieldDraftInput): () => {
+        relationId: string;
+        fieldName: string;
+        title?: string;
+        fieldSpecAlias?: string;
+    };
+    findFieldTargets?(input: FindMetadataFieldTargetsInput, signal: AbortSignal): Promise<{
+        targets: Array<{
+            target: string;
+            title?: string;
+        }>;
+        truncated: boolean;
+    }>;
+    referenceAffectDirectory?(target: string, signal: AbortSignal): Promise<{
+        sources: Array<{
+            fieldName: string;
+            title: string;
+        }>;
+        destinations: Array<{
+            fieldName: string;
+            title: string;
+        }>;
+    }>;
+    preparePropertyFieldDraft?(input: AddMetadataPropertyFieldDraftInput, signal: AbortSignal): Promise<PreparedMetadataPropertyFieldDraft>;
+    preparePropertyFieldCommit?(prepared: PreparedMetadataPropertyFieldDraft): () => {
+        relationId: string;
+        kind: MetadataPropertyFieldKind;
+        fieldName: string;
+        columnName: string;
+        title: string;
+        fieldSpecAlias: string;
+        target: string;
+    };
+}

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

@@ -0,0 +1,36 @@
+import type { HttpClient } from '../web-core/index';
+import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
+export type MetadataChangeSetIssue = {
+    severity: 'WARNING' | 'ERROR' | string;
+    code: string;
+    subject: string;
+    message: string;
+};
+export type MetadataChangeSetPreview = {
+    proposalFingerprint: string;
+    fieldImpacts: Array<{
+        operation: string;
+        fieldName: string;
+        columnName: string;
+        platformManaged: boolean;
+        description: string;
+    }>;
+    schemaImpacts: Array<{
+        operation: string;
+        schemaName: string;
+        tableName: string;
+        columnName: string;
+        description: string;
+    }>;
+    orderImpacts: Array<{
+        operation: string;
+        relationId?: string;
+        parentMetadataId?: string;
+        orderedIds: string[];
+        description: string;
+    }>;
+    warnings: MetadataChangeSetIssue[];
+    errors: MetadataChangeSetIssue[];
+};
+export declare function previewMetadataModelChangeSet(http: HttpClient, moduleAlias: string, proposal: MetadataModelChangeSetProposal, signal?: AbortSignal): Promise<MetadataChangeSetPreview>;
+export declare function applyMetadataModelChangeSet(http: HttpClient, moduleAlias: string, proposal: MetadataModelChangeSetProposal, proposalFingerprint: string): Promise<unknown>;

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

@@ -23,6 +23,7 @@ export declare function toFieldPropertyChangeSetPayload(property: MetadataFieldP
 export interface MetadataRelationChangeSetProposal {
     expectedMetadataVersion: number;
     fieldDrafts: MetadataFieldChangeSetDraft[];
+    capabilitySelections?: Record<string, boolean>;
 }
 /** Input facts are loaded for every node before a module-wide edit session begins. */
 export interface MetadataModelRelationDraftSource {
@@ -40,6 +41,7 @@ export interface MetadataModelRelationDraft {
     metadataId: string;
     relationId: string;
     expectedMetadataVersion: number;
+    capabilitySelections: Record<string, boolean>;
     fields: Record<string, MetadataField>;
     fieldProperties: Record<string, MetadataFieldPropertyDraft>;
     parentMetadataId?: string;
@@ -70,14 +72,37 @@ export declare function createMetadataModelWorkspaceEditSession(): {
     editing: import("vue").ComputedRef<boolean>;
     isDirty: import("vue").ComputedRef<boolean>;
     begin: (sources: MetadataModelRelationDraftSource[]) => void;
+    prepareRebase: (sources: MetadataModelRelationDraftSource[], proposal: MetadataModelChangeSetProposal, enabledCapabilities?: Readonly<Record<string, string[]>>, baseline?: Readonly<Record<string, MetadataModelRelationDraft>>) => () => void;
+    captureBaseline: () => {
+        [k: string]: {
+            capabilitySelections: {
+                [x: string]: boolean;
+            };
+            fields: Record<string, MetadataField>;
+            fieldProperties: Record<string, MetadataFieldPropertyDraft>;
+            fieldOrder: string[];
+            sortableFieldIds: string[];
+            metadataId: string;
+            relationId: string;
+            expectedMetadataVersion: number;
+            parentMetadataId?: string;
+        };
+    };
     cancel: () => void;
     relation: (relationId: string) => MetadataModelRelationDraft | undefined;
     fieldsForDisplay: (relationId: string, fallback: MetadataField[]) => MetadataField[];
     propertyForField: (relationId: string, field: MetadataField) => MetadataFieldPropertyDraft;
     stageField: (relationId: string, field: MetadataField, property?: MetadataFieldPropertyDraft, replaceNewFieldKey?: string) => void;
+    stageFields: (relationId: string, entries: Array<{
+        field: MetadataField;
+        property: MetadataFieldPropertyDraft;
+    }>) => void;
+    discardNewField: (relationId: string, fieldName: string) => void;
+    stageCapability: (relationId: string, capability: string, selected: boolean) => void;
     stageFieldOrder: (relationId: string, fieldIds: string[]) => void;
     stageRelationOrder: (parentMetadataId: string | undefined, relationIds: string[]) => void;
-    buildProposal: () => MetadataModelChangeSetProposal | undefined;
+    buildProposal: (currentDraft?: Record<string, MetadataModelRelationDraft> | undefined) => MetadataModelChangeSetProposal | undefined;
+    proposalWithField: (relationId: string, field: MetadataField, property: MetadataFieldPropertyDraft, replaceNewFieldKey?: string) => MetadataModelChangeSetProposal | undefined;
 };
 export declare function metadataFieldGovernanceKind(field: MetadataField, relation: ModuleMetadataRelation | undefined, capabilityFieldNames: ReadonlySet<string>): MetadataFieldGovernanceKind;
 export declare function metadataFieldGovernanceLabel(kind: MetadataFieldGovernanceKind): string;

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

@@ -1,7 +1,17 @@
 import type { MetadataFieldPropertyKind } from './metadataOrchestrationState';
+export declare const PLATFORM_FIELD_NAME_PATTERN = "^[a-z][A-Za-z0-9]{0,62}$";
+export declare const DYNAMIC_RECORD_RESERVED_FIELD_NAMES: Set<string>;
+export declare function isPlatformFieldName(value: string): boolean;
+export declare function isDynamicRecordReservedFieldName(value: string): boolean;
 export declare function physicalNameOf(fieldName?: string): string;
+/** Match the platform record-name contract before a shared candidate is staged. */
+export declare function recordNameFieldProblem(field: {
+    titleField?: boolean | null;
+    fieldName?: string | null;
+    columnName?: string | null;
+}): string | undefined;
 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;
+export declare function generatedBusinessFieldName(title: string | undefined, kind: MetadataFieldPropertyKind, titleField?: boolean): 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

@@ -22,7 +22,9 @@ export interface MetadataFieldReferencePropertyConfig {
     targetLabelField?: string;
     cardinality?: 'ONE' | 'MANY';
     targetUnavailablePolicy?: 'PRESERVE_HISTORY' | 'RESTRICT' | 'CASCADE_DELETE';
+    requireEnabled?: boolean;
     projectionMappings?: string[];
+    affectMappings?: string[];
 }
 export interface MetadataFieldDictionaryPropertyConfig {
     dictionaryApplicationAlias?: string;
@@ -40,9 +42,17 @@ export interface MetadataFieldPropertyDraft {
     expectedBindingVersion?: number;
     referenceConfig?: MetadataFieldReferencePropertyConfig;
     dictionaryConfig?: MetadataFieldDictionaryPropertyConfig;
+    fixedDefault?: {
+        value: string | null;
+        expectedConfigVersion?: number;
+    };
 }
 /** Relation-scoped property facts supplied by the module-governance read model. */
 export interface MetadataFieldPropertySummary extends MetadataFieldPropertyDraft {
+    fixedDefault?: NonNullable<MetadataFieldPropertyDraft['fixedDefault']> & {
+        configVersion?: number;
+        editable?: boolean;
+    };
     fieldId?: string;
     fieldName?: string;
     fieldSpecAlias?: string;
@@ -338,13 +348,19 @@ export declare function createMetadataOrchestrationState(): {
             targetLabelField?: string | undefined;
             cardinality?: "ONE" | "MANY" | undefined;
             targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            requireEnabled?: boolean | undefined;
             projectionMappings?: string[] | undefined;
+            affectMappings?: string[] | undefined;
         } | undefined;
         dictionaryConfig?: {
             dictionaryApplicationAlias?: string | undefined;
             dictionaryCategoryAlias?: string | undefined;
             selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
         } | undefined;
+        fixedDefault?: {
+            value: string | null;
+            expectedConfigVersion?: number | undefined;
+        } | undefined;
     }, MetadataFieldPropertyDraft | {
         kind: MetadataFieldPropertyKind;
         expectedBindingVersion?: number | undefined;
@@ -355,13 +371,19 @@ export declare function createMetadataOrchestrationState(): {
             targetLabelField?: string | undefined;
             cardinality?: "ONE" | "MANY" | undefined;
             targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            requireEnabled?: boolean | undefined;
             projectionMappings?: string[] | undefined;
+            affectMappings?: string[] | undefined;
         } | undefined;
         dictionaryConfig?: {
             dictionaryApplicationAlias?: string | undefined;
             dictionaryCategoryAlias?: string | undefined;
             selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
         } | undefined;
+        fixedDefault?: {
+            value: string | null;
+            expectedConfigVersion?: number | undefined;
+        } | undefined;
     }>;
     selectedRelation: import("vue").ComputedRef<{
         moduleAlias?: string | undefined;