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

package/src/flow-schema-registry/fieldBinding.ts

@@ -1,171 +0,0 @@
-/**
- * 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 _ from 'lodash';
-import type {
-  FlowFieldBindingConditions,
-  FlowFieldBindingContextContribution,
-  FlowFieldBindingContribution,
-  FlowFieldModelCompatibility,
-  FlowSchemaCoverage,
-} from '../types';
-import { normalizeStringArray } from './utils';
-
-export type RegisteredFieldBindingContext = {
-  name: string;
-  inherits: string[];
-};
-
-export type RegisteredFieldBinding = {
-  context: string;
-  use: string;
-  interfaces: string[];
-  isDefault: boolean;
-  order?: number;
-  conditions?: FlowFieldBindingConditions;
-  defaultProps?: any;
-  source: FlowSchemaCoverage['source'];
-};
-
-function normalizeFieldBindingConditions(
-  conditions?: FlowFieldBindingConditions,
-): FlowFieldBindingConditions | undefined {
-  if (!conditions || typeof conditions !== 'object' || Array.isArray(conditions)) {
-    return undefined;
-  }
-
-  const normalized = _.pickBy(
-    {
-      association: typeof conditions.association === 'boolean' ? conditions.association : undefined,
-      fieldTypes: normalizeStringArray(conditions.fieldTypes),
-      targetCollectionTemplateIn: normalizeStringArray(conditions.targetCollectionTemplateIn),
-      targetCollectionTemplateNotIn: normalizeStringArray(conditions.targetCollectionTemplateNotIn),
-    },
-    (value) => {
-      if (Array.isArray(value)) {
-        return value.length > 0;
-      }
-      return value !== undefined;
-    },
-  ) as FlowFieldBindingConditions;
-
-  return Object.keys(normalized).length > 0 ? normalized : undefined;
-}
-
-export function normalizeFieldBindingContextContribution(
-  contribution?: FlowFieldBindingContextContribution,
-  fallbackName?: string,
-): RegisteredFieldBindingContext | undefined {
-  const name = String(contribution?.name || fallbackName || '').trim();
-  if (!name) {
-    return undefined;
-  }
-
-  return {
-    name,
-    inherits: normalizeStringArray(contribution?.inherits),
-  };
-}
-
-export function normalizeFieldBindingContribution(
-  contribution?: FlowFieldBindingContribution,
-  source: FlowSchemaCoverage['source'] = 'official',
-): RegisteredFieldBinding | undefined {
-  const context = String(contribution?.context || '').trim();
-  const use = String(contribution?.use || '').trim();
-  const interfaces = normalizeStringArray(contribution?.interfaces);
-  if (!context || !use || interfaces.length === 0) {
-    return undefined;
-  }
-
-  return {
-    context,
-    use,
-    interfaces,
-    isDefault: contribution?.isDefault === true,
-    order: typeof contribution?.order === 'number' ? contribution.order : undefined,
-    conditions: normalizeFieldBindingConditions(contribution?.conditions),
-    defaultProps: contribution?.defaultProps === undefined ? undefined : _.cloneDeep(contribution.defaultProps),
-    source,
-  };
-}
-
-export function matchesFieldBinding(
-  binding: RegisteredFieldBinding,
-  options: {
-    interface?: string;
-    fieldType?: string;
-    association?: boolean;
-    targetCollectionTemplate?: string;
-  },
-) {
-  if (options.interface && !binding.interfaces.includes('*') && !binding.interfaces.includes(options.interface)) {
-    return false;
-  }
-
-  const conditions = binding.conditions;
-  if (!conditions) {
-    return true;
-  }
-
-  if (typeof conditions.association === 'boolean' && options.association !== undefined) {
-    if (conditions.association !== options.association) {
-      return false;
-    }
-  }
-
-  if (conditions.fieldTypes?.length && options.fieldType) {
-    if (!conditions.fieldTypes.includes(options.fieldType)) {
-      return false;
-    }
-  }
-
-  if (conditions.targetCollectionTemplateIn?.length && options.targetCollectionTemplate) {
-    if (!conditions.targetCollectionTemplateIn.includes(options.targetCollectionTemplate)) {
-      return false;
-    }
-  }
-
-  if (conditions.targetCollectionTemplateNotIn?.length && options.targetCollectionTemplate) {
-    if (conditions.targetCollectionTemplateNotIn.includes(options.targetCollectionTemplate)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function buildFieldModelCompatibility(binding: RegisteredFieldBinding): FlowFieldModelCompatibility {
-  const compatibility: FlowFieldModelCompatibility = {
-    context: binding.context,
-    interfaces: _.cloneDeep(binding.interfaces),
-    inheritParentFieldBinding: true,
-  };
-
-  if (binding.isDefault) {
-    compatibility.isDefault = true;
-  }
-  if (typeof binding.order === 'number') {
-    compatibility.order = binding.order;
-  }
-  if (typeof binding.conditions?.association === 'boolean') {
-    compatibility.association = binding.conditions.association;
-  }
-  if (binding.conditions?.fieldTypes?.length) {
-    compatibility.fieldTypes = _.cloneDeep(binding.conditions.fieldTypes);
-  }
-  if (binding.conditions?.targetCollectionTemplateIn?.length) {
-    compatibility.targetCollectionTemplateIn = _.cloneDeep(binding.conditions.targetCollectionTemplateIn);
-  }
-  if (binding.conditions?.targetCollectionTemplateNotIn?.length) {
-    compatibility.targetCollectionTemplateNotIn = _.cloneDeep(binding.conditions.targetCollectionTemplateNotIn);
-  }
-
-  return compatibility;
-}

package/src/flow-schema-registry/modelPatches.ts

@@ -1,260 +0,0 @@
-/**
- * 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 _ from 'lodash';
-import type {
-  FlowDescendantSchemaPatch,
-  FlowJsonSchema,
-  FlowModelSchemaPatch,
-  FlowSchemaContextEdge,
-  FlowSchemaCoverage,
-  FlowSubModelContextPathStep,
-  FlowSubModelSlotSchema,
-} from '../types';
-import type { RegisteredModelSchema } from '../FlowSchemaRegistry';
-import { deepMergeReplaceArrays, mergeSchemas, normalizeSchemaDocs, normalizeSchemaHints } from './utils';
-
-export function normalizeSubModelContextPath(path?: FlowSubModelContextPathStep[]): FlowSubModelContextPathStep[] {
-  if (!Array.isArray(path)) {
-    return [];
-  }
-
-  return path
-    .map((step) => ({
-      slotKey: String(step?.slotKey || '').trim(),
-      ...(typeof step?.use === 'string'
-        ? { use: step.use.trim() }
-        : Array.isArray(step?.use)
-          ? { use: step.use.map((item) => String(item || '').trim()).filter(Boolean) }
-          : {}),
-    }))
-    .filter((step) => !!step.slotKey);
-}
-
-export function normalizeModelSchemaPatch(patch?: FlowModelSchemaPatch): FlowModelSchemaPatch | undefined {
-  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
-    return undefined;
-  }
-
-  const normalized = _.pickBy(
-    {
-      stepParamsSchema: patch.stepParamsSchema ? _.cloneDeep(patch.stepParamsSchema) : undefined,
-      flowRegistrySchema: patch.flowRegistrySchema ? _.cloneDeep(patch.flowRegistrySchema) : undefined,
-      flowRegistrySchemaPatch: patch.flowRegistrySchemaPatch ? _.cloneDeep(patch.flowRegistrySchemaPatch) : undefined,
-      subModelSlots: normalizeSubModelSlots(patch.subModelSlots),
-      docs: patch.docs ? normalizeSchemaDocs(patch.docs) : undefined,
-      examples: Array.isArray(patch.examples) ? _.cloneDeep(patch.examples) : undefined,
-      skeleton: patch.skeleton === undefined ? undefined : _.cloneDeep(patch.skeleton),
-      dynamicHints: Array.isArray(patch.dynamicHints) ? normalizeSchemaHints(patch.dynamicHints) : undefined,
-    },
-    (value) => value !== undefined && (!Array.isArray(value) || value.length > 0),
-  ) as FlowModelSchemaPatch;
-
-  return Object.keys(normalized).length > 0 ? normalized : undefined;
-}
-
-function normalizeDescendantSchemaPatches(
-  patches?: FlowDescendantSchemaPatch[],
-): FlowDescendantSchemaPatch[] | undefined {
-  if (!Array.isArray(patches)) {
-    return undefined;
-  }
-
-  const normalized = patches
-    .map((item) => {
-      const path = normalizeSubModelContextPath(item?.path);
-      const patch = normalizeModelSchemaPatch(item?.patch);
-      if (!patch) {
-        return undefined;
-      }
-      return { path, patch };
-    })
-    .filter(Boolean) as FlowDescendantSchemaPatch[];
-
-  return normalized.length > 0 ? normalized : undefined;
-}
-
-function normalizeChildSchemaPatch(
-  patch?: FlowSubModelSlotSchema['childSchemaPatch'],
-): FlowSubModelSlotSchema['childSchemaPatch'] | undefined {
-  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
-    return undefined;
-  }
-
-  const directPatch = normalizeModelSchemaPatch(patch as FlowModelSchemaPatch);
-  if (directPatch) {
-    return directPatch;
-  }
-
-  const entries = Object.entries(patch as Record<string, FlowModelSchemaPatch>)
-    .map(([childUse, childPatch]) => [String(childUse || '').trim(), normalizeModelSchemaPatch(childPatch)] as const)
-    .filter(([childUse, childPatch]) => !!childUse && !!childPatch);
-
-  if (!entries.length) {
-    return undefined;
-  }
-
-  return Object.fromEntries(entries);
-}
-
-export function normalizeSubModelSlots(
-  slots?: Record<string, FlowSubModelSlotSchema>,
-): Record<string, FlowSubModelSlotSchema> | undefined {
-  if (!slots || typeof slots !== 'object' || Array.isArray(slots)) {
-    return undefined;
-  }
-
-  const normalizedEntries = Object.entries(slots)
-    .map(([slotKey, slot]) => {
-      if (!slot?.type) {
-        return undefined;
-      }
-
-      const normalizedSlot: FlowSubModelSlotSchema = {
-        type: slot.type,
-      };
-
-      const normalizedUse = typeof slot.use === 'string' ? slot.use.trim() : undefined;
-      if (normalizedUse) {
-        normalizedSlot.use = normalizedUse;
-      }
-
-      const normalizedUses = Array.isArray(slot.uses)
-        ? slot.uses.map((item) => String(item || '').trim()).filter(Boolean)
-        : undefined;
-      if (normalizedUses?.length) {
-        normalizedSlot.uses = normalizedUses;
-      }
-
-      if (slot.required !== undefined) {
-        normalizedSlot.required = slot.required;
-      }
-      if (slot.type === 'array' && typeof slot.minItems === 'number' && Number.isFinite(slot.minItems)) {
-        normalizedSlot.minItems = Math.max(0, Math.trunc(slot.minItems));
-      }
-      if (slot.dynamic !== undefined) {
-        normalizedSlot.dynamic = slot.dynamic;
-      }
-      if (slot.schema) {
-        normalizedSlot.schema = _.cloneDeep(slot.schema);
-      }
-      if (typeof slot.fieldBindingContext === 'string' && slot.fieldBindingContext.trim()) {
-        normalizedSlot.fieldBindingContext = slot.fieldBindingContext.trim();
-      }
-
-      const childSchemaPatch = normalizeChildSchemaPatch(slot.childSchemaPatch);
-      if (childSchemaPatch) {
-        normalizedSlot.childSchemaPatch = childSchemaPatch;
-      }
-
-      const descendantSchemaPatches = normalizeDescendantSchemaPatches(slot.descendantSchemaPatches);
-      if (descendantSchemaPatches?.length) {
-        normalizedSlot.descendantSchemaPatches = descendantSchemaPatches;
-      }
-
-      if (slot.description !== undefined) {
-        normalizedSlot.description = slot.description;
-      }
-
-      return [slotKey, normalizedSlot] as const;
-    })
-    .filter(Boolean) as Array<readonly [string, FlowSubModelSlotSchema]>;
-
-  return normalizedEntries.length > 0 ? Object.fromEntries(normalizedEntries) : undefined;
-}
-
-export function matchesDescendantSchemaPatch(
-  patch: FlowDescendantSchemaPatch,
-  remainingEdges: FlowSchemaContextEdge[],
-): boolean {
-  const path = normalizeSubModelContextPath(patch.path);
-  if (path.length !== remainingEdges.length) {
-    return false;
-  }
-
-  return path.every((step, index) => {
-    const edge = remainingEdges[index];
-    if (step.slotKey !== edge.slotKey) {
-      return false;
-    }
-    if (typeof step.use === 'undefined') {
-      return true;
-    }
-    if (typeof step.use === 'string') {
-      return step.use === edge.childUse;
-    }
-    return step.use.includes(edge.childUse);
-  });
-}
-
-export function resolveChildSchemaPatch(
-  slot: FlowSubModelSlotSchema,
-  childUse: string,
-): FlowModelSchemaPatch | undefined {
-  const childSchemaPatch = slot.childSchemaPatch;
-  if (!childSchemaPatch || typeof childSchemaPatch !== 'object' || Array.isArray(childSchemaPatch)) {
-    return undefined;
-  }
-
-  const directPatch = normalizeModelSchemaPatch(childSchemaPatch as FlowModelSchemaPatch);
-  if (directPatch) {
-    return directPatch;
-  }
-
-  return normalizeModelSchemaPatch((childSchemaPatch as Record<string, FlowModelSchemaPatch>)[childUse]);
-}
-
-export function applyModelSchemaPatch(
-  target: RegisteredModelSchema,
-  patch: FlowModelSchemaPatch,
-  source: FlowSchemaCoverage['source'],
-  strict?: boolean,
-) {
-  target.stepParamsSchema = mergeSchemas(target.stepParamsSchema, patch.stepParamsSchema);
-  target.flowRegistrySchema = mergeSchemas(target.flowRegistrySchema, patch.flowRegistrySchema);
-  target.flowRegistrySchemaPatch = mergeSchemas(target.flowRegistrySchemaPatch, patch.flowRegistrySchemaPatch);
-  target.subModelSlots = normalizeSubModelSlots(
-    patch.subModelSlots
-      ? deepMergeReplaceArrays(target.subModelSlots || {}, patch.subModelSlots)
-      : target.subModelSlots,
-  );
-  target.docs = normalizeSchemaDocs({
-    ...target.docs,
-    ...patch.docs,
-    examples: patch.docs?.examples || target.docs?.examples,
-    dynamicHints: [...(target.docs?.dynamicHints || []), ...(patch.docs?.dynamicHints || [])],
-    commonPatterns: patch.docs?.commonPatterns || target.docs?.commonPatterns,
-    antiPatterns: patch.docs?.antiPatterns || target.docs?.antiPatterns,
-    minimalExample: patch.docs?.minimalExample !== undefined ? patch.docs.minimalExample : target.docs?.minimalExample,
-  });
-  target.examples = Array.isArray(patch.examples) ? _.cloneDeep(patch.examples) : target.examples;
-  target.skeleton =
-    patch.skeleton !== undefined ? deepMergeReplaceArrays(target.skeleton, patch.skeleton) : target.skeleton;
-  target.dynamicHints = normalizeSchemaHints([
-    ...(target.dynamicHints || []),
-    ...(patch.dynamicHints || []),
-    ...(patch.docs?.dynamicHints || []),
-  ]);
-
-  const hasSchemaPatch =
-    !!patch.stepParamsSchema || !!patch.flowRegistrySchema || !!patch.flowRegistrySchemaPatch || !!patch.subModelSlots;
-  if (hasSchemaPatch) {
-    target.coverage = {
-      ...target.coverage,
-      status:
-        target.coverage.status === 'unresolved'
-          ? 'manual'
-          : target.coverage.status === 'auto'
-            ? 'mixed'
-            : target.coverage.status,
-      source: target.coverage.source === 'third-party' ? source : target.coverage.source,
-      strict: target.coverage.strict ?? strict,
-    };
-  }
-}

package/src/flow-schema-registry/schemaInference.ts

@@ -1,210 +0,0 @@
-/**
- * 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 _ from 'lodash';
-import type { ISchema } from '@formily/json-schema';
-import type { FlowDynamicHint, FlowJsonSchema, FlowSchemaCoverage } from '../types';
-import { createFlowHint } from './utils';
-
-export type StepSchemaResolution = {
-  schema?: FlowJsonSchema;
-  hints: FlowDynamicHint[];
-  coverage: FlowSchemaCoverage['status'];
-};
-
-export type UiSchemaLike =
-  | Record<string, ISchema>
-  | ((...args: any[]) => Record<string, ISchema> | Promise<Record<string, ISchema>>)
-  | undefined;
-
-function inferSchemaFromUiSchemaValue(
-  name: string,
-  uiSchema: ISchema,
-  path: string,
-  hints: FlowDynamicHint[],
-): FlowJsonSchema {
-  if (!uiSchema || typeof uiSchema !== 'object' || Array.isArray(uiSchema)) {
-    return { type: 'object', additionalProperties: true };
-  }
-
-  const xComponent = (uiSchema as any)['x-component'];
-  if (typeof xComponent === 'function') {
-    hints.push(
-      createFlowHint(
-        {
-          kind: 'custom-component',
-          path,
-          message: `${name} uses a custom component and needs manual schema review.`,
-        },
-        {
-          unresolvedReason: 'function-x-component',
-          recommendedFallback: { type: 'object', additionalProperties: true },
-        },
-      ),
-    );
-  }
-
-  const reactions = (uiSchema as any)['x-reactions'];
-  if (
-    reactions &&
-    ((Array.isArray(reactions) && reactions.some((item) => typeof item === 'function')) ||
-      typeof reactions === 'function')
-  ) {
-    hints.push(
-      createFlowHint(
-        {
-          kind: 'x-reactions',
-          path,
-          message: `${name} contains function-based x-reactions and only static schema is generated.`,
-        },
-        {
-          unresolvedReason: 'function-x-reactions',
-        },
-      ),
-    );
-  }
-
-  const schema: FlowJsonSchema = {};
-  const type = (uiSchema as any).type;
-  if (type) {
-    schema.type = type;
-  }
-  if ((uiSchema as any).description) {
-    schema.description = (uiSchema as any).description;
-  }
-  if ((uiSchema as any).default !== undefined) {
-    schema.default = _.cloneDeep((uiSchema as any).default);
-  }
-  if ((uiSchema as any).enum) {
-    if (
-      Array.isArray((uiSchema as any).enum) &&
-      (uiSchema as any).enum.every((item) => _.isPlainObject(item) && 'value' in item)
-    ) {
-      schema.enum = (uiSchema as any).enum.map((item) => item.value);
-    } else {
-      schema.enum = _.cloneDeep((uiSchema as any).enum);
-    }
-  }
-  if ((uiSchema as any).const !== undefined) {
-    schema.const = _.cloneDeep((uiSchema as any).const);
-  }
-  if ((uiSchema as any).required === true) {
-    schema.__required = true;
-  }
-
-  const validator = (uiSchema as any)['x-validator'];
-  if (_.isPlainObject(validator)) {
-    if (validator.minimum !== undefined) schema.minimum = validator.minimum;
-    if (validator.maximum !== undefined) schema.maximum = validator.maximum;
-    if (validator.minLength !== undefined) schema.minLength = validator.minLength;
-    if (validator.maxLength !== undefined) schema.maxLength = validator.maxLength;
-    if (validator.pattern !== undefined) schema.pattern = validator.pattern;
-  } else if (Array.isArray(validator)) {
-    for (const item of validator) {
-      if (_.isPlainObject(item)) {
-        Object.assign(schema, _.pick(item, ['minimum', 'maximum', 'minLength', 'maxLength', 'pattern']));
-      }
-    }
-  } else if (typeof validator === 'string') {
-    if (validator === 'integer') schema.type = 'integer';
-    if (validator === 'email') schema.format = 'email';
-    if (validator === 'url') schema.format = 'uri';
-    if (validator === 'uid') schema.pattern = '^[A-Za-z0-9_-]+$';
-  }
-
-  if ((uiSchema as any).properties && _.isPlainObject((uiSchema as any).properties)) {
-    schema.type = schema.type || 'object';
-    schema.properties = {};
-    const required: string[] = [];
-    for (const [propName, propValue] of Object.entries((uiSchema as any).properties)) {
-      const childSchema = inferSchemaFromUiSchemaValue(propName, propValue as ISchema, `${path}.${propName}`, hints);
-      if ((childSchema as any).__required) {
-        required.push(propName);
-        delete (childSchema as any).__required;
-      }
-      (schema.properties as any)[propName] = childSchema;
-    }
-    if (required.length) {
-      schema.required = required;
-    }
-    schema.additionalProperties = false;
-  }
-
-  if ((uiSchema as any).items) {
-    schema.type = schema.type || 'array';
-    if (_.isPlainObject((uiSchema as any).items)) {
-      schema.items = inferSchemaFromUiSchemaValue(`${name}.items`, (uiSchema as any).items, `${path}.items`, hints);
-    } else if (Array.isArray((uiSchema as any).items)) {
-      schema.items = (uiSchema as any).items.map((item, index) =>
-        inferSchemaFromUiSchemaValue(`${name}.items[${index}]`, item, `${path}.items[${index}]`, hints),
-      );
-    }
-  }
-
-  if (!schema.type) {
-    schema.type = 'object';
-    schema.additionalProperties = true;
-  }
-
-  return schema;
-}
-
-export function inferParamsSchemaFromUiSchema(
-  name: string,
-  uiSchema: UiSchemaLike,
-  path: string,
-): StepSchemaResolution {
-  const hints: FlowDynamicHint[] = [];
-  if (!uiSchema) {
-    return { schema: undefined, hints, coverage: 'unresolved' };
-  }
-
-  if (typeof uiSchema === 'function') {
-    hints.push(
-      createFlowHint(
-        {
-          kind: 'dynamic-ui-schema',
-          path,
-          message: `${name} uses function-based uiSchema and requires manual schema patch.`,
-        },
-        {
-          unresolvedReason: 'function-ui-schema',
-          recommendedFallback: { type: 'object', additionalProperties: true },
-        },
-      ),
-    );
-    return {
-      schema: { type: 'object', additionalProperties: true },
-      hints,
-      coverage: 'unresolved',
-    };
-  }
-
-  const properties: Record<string, FlowJsonSchema> = {};
-  const required: string[] = [];
-  for (const [key, value] of Object.entries(uiSchema)) {
-    const childSchema = inferSchemaFromUiSchemaValue(key, value, `${path}.${key}`, hints);
-    if ((childSchema as any).__required) {
-      required.push(key);
-      delete (childSchema as any).__required;
-    }
-    properties[key] = childSchema;
-  }
-
-  return {
-    schema: {
-      type: 'object',
-      properties,
-      ...(required.length ? { required } : {}),
-      additionalProperties: false,
-    },
-    hints,
-    coverage: hints.length ? 'mixed' : 'auto',
-  };
-}