@nocobase/flow-engine 2.1.0-alpha.10 → 2.1.0-alpha.12

package/lib/FlowDefinition.d.ts

@@ -240,6 +240,8 @@ export declare class FlowStep {
         use?: string;
         sort?: number;
         preset?: boolean;
+        paramsSchemaOverride?: import("./types").FlowJsonSchema;
+        schemaDocs?: import("./types").FlowSchemaDocs;
         uiMode?: import("./types").StepUIMode | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => import("./types").StepUIMode | Promise<import("./types").StepUIMode>);
         title?: string;
         uiSchema?: Record<string, import("@formily/json-schema").Stringify<{
@@ -413,6 +415,8 @@ export declare class FlowStep {
         }>>>);
         defaultParams?: Record<string, any> | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => Record<string, any> | Promise<Record<string, any>>);
         handler?: (ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>, params: any) => any;
+        paramsSchema?: import("./types").FlowJsonSchema;
+        paramsSchemaPatch?: import("./types").FlowJsonSchema;
         beforeParamsSave?: (ctx: import("./flowContext").FlowSettingsContext<import(".").FlowModel<import("./types").DefaultStructure>>, params: any, previousParams: any) => void | Promise<void>;
         afterParamsSave?: (ctx: import("./flowContext").FlowSettingsContext<import(".").FlowModel<import("./types").DefaultStructure>>, params: any, previousParams: any) => void | Promise<void>;
         useRawParams?: boolean | ((ctx: import("./flowContext").FlowRuntimeContext<import(".").FlowModel<import("./types").DefaultStructure>, any>) => boolean | Promise<boolean>);

package/lib/FlowSchemaRegistry.d.ts

@@ -0,0 +1,154 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { ActionDefinition, FlowActionSchemaContribution, FlowFieldBindingContextContribution, FlowFieldBindingContribution, FlowFieldModelCompatibility, FlowSchemaBundleDocument, FlowSchemaContextEdge, FlowSchemaDocs, FlowDynamicHint, FlowSchemaInventoryContribution, FlowJsonSchema, FlowModelSchemaContribution, FlowSchemaCoverage, FlowSchemaDetail, FlowSchemaDocument, FlowModelSchemaExposure, FlowSchemaPublicDocument, FlowSubModelSlotSchema, ModelConstructor, StepDefinition } from './types';
+import { type StepSchemaResolution } from './flow-schema-registry/schemaInference';
+export type RegisteredActionSchema = {
+    name: string;
+    title?: string;
+    definition?: ActionDefinition;
+    schema?: FlowJsonSchema;
+    docs: FlowSchemaDocs;
+    coverage: FlowSchemaCoverage;
+    dynamicHints: FlowDynamicHint[];
+};
+export type RegisteredModelSchema = {
+    use: string;
+    modelClass?: ModelConstructor;
+    stepParamsSchema?: FlowJsonSchema;
+    flowRegistrySchema?: FlowJsonSchema;
+    subModelSlots?: Record<string, FlowSubModelSlotSchema>;
+    flowRegistrySchemaPatch?: FlowJsonSchema;
+    title?: string;
+    examples: any[];
+    docs: FlowSchemaDocs;
+    skeleton?: any;
+    dynamicHints: FlowDynamicHint[];
+    coverage: FlowSchemaCoverage;
+    exposure: FlowModelSchemaExposure;
+    abstract: boolean;
+    allowDirectUse: boolean;
+    suggestedUses: string[];
+};
+export declare class FlowSchemaRegistry {
+    private readonly modelSchemas;
+    private readonly actionSchemas;
+    private readonly fieldBindingContexts;
+    private readonly fieldBindings;
+    private readonly resolvedModelCache;
+    private readonly modelSnapshotSchemaCache;
+    private readonly compactModelSnapshotSchemaCache;
+    private readonly modelSchemaHashCache;
+    private readonly compactModelSchemaHashCache;
+    private readonly modelDocumentCache;
+    private readonly modelLocalDynamicHintsCache;
+    private readonly publicModelDocumentCache;
+    private readonly publicTreeRoots;
+    private readonly slotUseExpansions;
+    private invalidateDerivedCaches;
+    registerAction(action: ActionDefinition | ({
+        name: string;
+    } & Partial<ActionDefinition>)): void;
+    registerActions(actions: Record<string, ActionDefinition>): void;
+    registerActionContribution(contribution: FlowActionSchemaContribution): void;
+    registerActionContributions(contributions: FlowActionSchemaContribution[] | Record<string, FlowActionSchemaContribution>): void;
+    registerFieldBindingContext(contribution: FlowFieldBindingContextContribution, fallbackName?: string): void;
+    registerFieldBindingContexts(contributions: FlowFieldBindingContextContribution[] | Record<string, FlowFieldBindingContextContribution> | undefined): void;
+    registerFieldBinding(contribution: FlowFieldBindingContribution, source?: FlowSchemaCoverage['source']): void;
+    registerFieldBindings(contributions: FlowFieldBindingContribution[] | Record<string, FlowFieldBindingContribution | FlowFieldBindingContribution[]> | undefined, source?: FlowSchemaCoverage['source']): void;
+    registerModel(use: string, options: Partial<RegisteredModelSchema>): void;
+    registerModelContribution(contribution: FlowModelSchemaContribution): void;
+    registerModelContributions(contributions: FlowModelSchemaContribution[] | Record<string, FlowModelSchemaContribution>): void;
+    registerModelClass(use: string, modelClass: ModelConstructor): void;
+    registerModels(models: Record<string, ModelConstructor | undefined>): void;
+    registerInventory(inventory: FlowSchemaInventoryContribution | undefined, _source: FlowSchemaCoverage['source']): void;
+    resolveFieldBindingCandidates(context: string, options?: {
+        interface?: string;
+        fieldType?: string;
+        association?: boolean;
+        targetCollectionTemplate?: string;
+    }): {
+        use: string;
+        defaultProps: any;
+        compatibility: FlowFieldModelCompatibility;
+    }[];
+    getAction(name: string): RegisteredActionSchema | undefined;
+    listActionNames(): string[];
+    getModel(use: string): RegisteredModelSchema | undefined;
+    private resolveFieldBindingContextChain;
+    private resolveModelSchemaRef;
+    resolveModelSchema(use: string, contextChain?: FlowSchemaContextEdge[]): RegisteredModelSchema;
+    private isPublicModel;
+    private isQueryableModel;
+    getSuggestedUses(use: string): string[];
+    hasQueryableModel(use: string): boolean;
+    isDirectUseAllowed(use: string): boolean;
+    listPublicTreeRoots(): string[];
+    listModelUses(options?: {
+        publicOnly?: boolean;
+        directUseOnly?: boolean;
+        queryableOnly?: boolean;
+    }): string[];
+    getSchemaBundle(uses?: string[]): FlowSchemaBundleDocument;
+    getModelDocument(use: string, contextChain?: FlowSchemaContextEdge[]): FlowSchemaDocument;
+    getModelDocumentRef(use: string, contextChain?: FlowSchemaContextEdge[]): Readonly<FlowSchemaDocument>;
+    getPublicModelDocument(use: string, options?: {
+        detail?: FlowSchemaDetail;
+        contextChain?: FlowSchemaContextEdge[];
+    }): FlowSchemaPublicDocument;
+    getPublicModelDocumentRef(use: string, options?: {
+        detail?: FlowSchemaDetail;
+        contextChain?: FlowSchemaContextEdge[];
+    }): Readonly<FlowSchemaPublicDocument>;
+    private buildFullPublicModelDocument;
+    private buildCompactPublicModelDocument;
+    private getModelLocalDynamicHintsRef;
+    private buildModelLocalDynamicHints;
+    getModelSchemaHash(use: string, contextChain?: FlowSchemaContextEdge[]): string;
+    getCompactModelSchemaHash(use: string, contextChain?: FlowSchemaContextEdge[]): string;
+    private createSlotUseExpansionKey;
+    private getSlotUseExpansionUses;
+    resolveSlotAllowedUses(parentUse: string, slotKey: string, slot?: FlowSubModelSlotSchema): string[];
+    private buildModelDocument;
+    private buildBundleNode;
+    private buildBundleSubModelCatalog;
+    private createContextVisitKey;
+    private isContextCycle;
+    buildModelSnapshotSchema(use: string, contextChain?: FlowSchemaContextEdge[]): FlowJsonSchema;
+    buildCompactModelSnapshotSchema(use: string, contextChain?: FlowSchemaContextEdge[]): FlowJsonSchema;
+    private buildModelSnapshotSchemaRef;
+    private buildCompactModelSnapshotSchemaRef;
+    private buildCompactModelSnapshotSchemaInternal;
+    private buildModelSnapshotSchemaInternal;
+    private buildSnapshotSchemaFromResolved;
+    private buildSnapshotShellSchema;
+    private buildTruncatedSnapshotSchema;
+    buildStaticFlowRegistrySchema(use: string, contextChain?: FlowSchemaContextEdge[]): FlowJsonSchema;
+    buildStaticStepParamsSchema(use: string, contextChain?: FlowSchemaContextEdge[]): FlowJsonSchema;
+    buildSubModelsSchema(use: string, contextChain?: FlowSchemaContextEdge[]): FlowJsonSchema;
+    private buildCompactSubModelsSchemaFromSlots;
+    private buildSubModelsSchemaFromSlots;
+    private buildInferredFlowRegistrySchema;
+    private buildInferredStepParamsSchema;
+    buildFlowOnSchema(): FlowJsonSchema;
+    buildStepDefinitionSchema(step: StepDefinition): FlowJsonSchema;
+    resolveStepParamsSchema(step: StepDefinition, path: string): StepSchemaResolution;
+    private buildSlotTargetSchema;
+    private buildCompactSlotTargetSchema;
+    private buildCompactSlotCandidateSchema;
+    private buildCompactAnonymousSlotSnapshotSchema;
+    private buildAnonymousSlotSnapshotSchema;
+    private createAnonymousResolvedSchema;
+    private collectNestedDocumentHints;
+    private prefixNestedHint;
+    private collectContextPatches;
+    private collectModelDynamicHints;
+    private collectFlowSchemaDiagnostics;
+    private buildDocumentCoverage;
+    private inferSubModelSlotsFromModelClass;
+}