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

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

@@ -0,0 +1,210 @@
+/**
+ * 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',
+  };
+}

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

@@ -0,0 +1,268 @@
+/**
+ * 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 { FlowDynamicHint, FlowJsonSchema, FlowSchemaDocs, FlowSubModelSlotSchema } from '../types';
+
+export const JSON_SCHEMA_DRAFT_07 = 'http://json-schema.org/draft-07/schema#';
+
+export function stableStringify(input: any): string {
+  if (Array.isArray(input)) {
+    return `[${input.map((item) => stableStringify(item)).join(',')}]`;
+  }
+  if (_.isPlainObject(input)) {
+    const entries = Object.entries(input)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([key, value]) => `${JSON.stringify(key)}:${stableStringify(value)}`);
+    return `{${entries.join(',')}}`;
+  }
+  return JSON.stringify(input) ?? 'null';
+}
+
+export function deepFreezePlainGraph<T>(input: T, seen = new WeakSet<object>()): T {
+  if (Array.isArray(input)) {
+    if (seen.has(input)) {
+      return input;
+    }
+    seen.add(input);
+    for (const item of input) {
+      deepFreezePlainGraph(item, seen);
+    }
+    return Object.freeze(input);
+  }
+
+  if (!_.isPlainObject(input)) {
+    return input;
+  }
+
+  const objectValue = input as Record<string, any>;
+  if (seen.has(objectValue)) {
+    return input;
+  }
+
+  seen.add(objectValue);
+  for (const value of Object.values(objectValue)) {
+    deepFreezePlainGraph(value, seen);
+  }
+  return Object.freeze(objectValue) as T;
+}
+
+export function hashString(input: string): string {
+  let hash = 0;
+  for (let index = 0; index < input.length; index++) {
+    hash = (hash * 31 + input.charCodeAt(index)) >>> 0;
+  }
+  return hash.toString(16).padStart(8, '0');
+}
+
+export function deepMergeReplaceArrays<T>(base: T, patch: any): T {
+  if (typeof patch === 'undefined') {
+    return _.cloneDeep(base);
+  }
+  if (typeof base === 'undefined') {
+    return _.cloneDeep(patch);
+  }
+  return _.mergeWith({}, _.cloneDeep(base), _.cloneDeep(patch), (_objValue, srcValue) => {
+    if (Array.isArray(srcValue)) {
+      return _.cloneDeep(srcValue);
+    }
+    return undefined;
+  });
+}
+
+export function mergeSchemas(base?: FlowJsonSchema, patch?: FlowJsonSchema): FlowJsonSchema | undefined {
+  if (!base && !patch) return undefined;
+  if (!base) return _.cloneDeep(patch);
+  if (!patch) return _.cloneDeep(base);
+  return deepMergeReplaceArrays(base, patch);
+}
+
+function normalizeFlowHintMetadata(metadata?: FlowDynamicHint['x-flow']): FlowDynamicHint['x-flow'] | undefined {
+  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+    return undefined;
+  }
+
+  const slotRules =
+    metadata.slotRules && typeof metadata.slotRules === 'object' && !Array.isArray(metadata.slotRules)
+      ? _.pickBy(
+          {
+            slotKey: metadata.slotRules.slotKey,
+            type: metadata.slotRules.type,
+            allowedUses: Array.isArray(metadata.slotRules.allowedUses)
+              ? metadata.slotRules.allowedUses.filter(Boolean)
+              : metadata.slotRules.allowedUses,
+          },
+          (value) => value !== undefined,
+        )
+      : undefined;
+
+  const normalized = _.pickBy(
+    {
+      slotRules: slotRules && Object.keys(slotRules).length > 0 ? slotRules : undefined,
+      contextRequirements: Array.isArray(metadata.contextRequirements)
+        ? metadata.contextRequirements.filter(Boolean)
+        : metadata.contextRequirements,
+      unresolvedReason: metadata.unresolvedReason,
+      recommendedFallback: metadata.recommendedFallback,
+    },
+    (value) => value !== undefined,
+  ) as FlowDynamicHint['x-flow'];
+
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function normalizeFlowHint(hint: FlowDynamicHint): FlowDynamicHint {
+  const normalizedHint = { ...hint };
+  const flowMetadata = normalizeFlowHintMetadata(hint['x-flow']);
+  if (flowMetadata) {
+    normalizedHint['x-flow'] = flowMetadata;
+  } else {
+    delete normalizedHint['x-flow'];
+  }
+  return normalizedHint;
+}
+
+export function normalizeSchemaHints(hints?: FlowDynamicHint[]): FlowDynamicHint[] {
+  return Array.isArray(hints)
+    ? _.uniqBy(
+        hints.map((item) => normalizeFlowHint(item)),
+        (item) => `${item.kind}:${item.path || ''}:${item.message}`,
+      )
+    : [];
+}
+
+export function normalizeSchemaDocs(docs?: FlowSchemaDocs): FlowSchemaDocs {
+  return {
+    description: docs?.description,
+    examples: Array.isArray(docs?.examples) ? _.cloneDeep(docs.examples) : [],
+    minimalExample: docs?.minimalExample === undefined ? undefined : _.cloneDeep(docs.minimalExample),
+    commonPatterns: Array.isArray(docs?.commonPatterns) ? _.cloneDeep(docs.commonPatterns) : [],
+    antiPatterns: Array.isArray(docs?.antiPatterns) ? _.cloneDeep(docs.antiPatterns) : [],
+    dynamicHints: normalizeSchemaHints(docs?.dynamicHints),
+  };
+}
+
+export function normalizeStringArray(values?: string[]): string[] {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  return _.uniq(values.map((item) => String(item || '').trim()).filter(Boolean));
+}
+
+export function createFlowHint(hint: FlowDynamicHint, metadata?: FlowDynamicHint['x-flow']): FlowDynamicHint {
+  const result = { ...hint };
+  const flowMetadata = normalizeFlowHintMetadata({
+    ...(hint['x-flow'] || {}),
+    ...(metadata || {}),
+  });
+  if (flowMetadata) {
+    result['x-flow'] = flowMetadata;
+  } else {
+    delete result['x-flow'];
+  }
+  return result;
+}
+
+export function collectAllowedUses(slot?: FlowSubModelSlotSchema): string[] {
+  if (!slot) {
+    return [];
+  }
+  if (Array.isArray(slot.uses)) {
+    return slot.uses.filter(Boolean);
+  }
+  return slot.use ? [slot.use] : [];
+}
+
+export function buildSkeletonFromSchema(
+  schema?: FlowJsonSchema,
+  options: {
+    propertyName?: string;
+    depth?: number;
+  } = {},
+): any {
+  if (!schema) return undefined;
+  if (schema.default !== undefined) return _.cloneDeep(schema.default);
+  if (schema.const !== undefined) return _.cloneDeep(schema.const);
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return _.cloneDeep(schema.enum[0]);
+
+  const depth = options.depth || 0;
+  if (depth > 4) {
+    return undefined;
+  }
+
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (type === 'object' || (!type && _.isPlainObject(schema.properties))) {
+    const result: Record<string, any> = {};
+    const properties = (schema.properties || {}) as Record<string, FlowJsonSchema>;
+    const required = new Set<string>(schema.required || []);
+    for (const [key, value] of Object.entries(properties)) {
+      const child = buildSkeletonFromSchema(value, {
+        propertyName: key,
+        depth: depth + 1,
+      });
+      const includeOptionalTopLevelShell =
+        depth === 0 &&
+        ['stepParams', 'subModels', 'flowRegistry'].includes(key) &&
+        child !== undefined &&
+        ((_.isPlainObject(child) && Object.keys(child).length > 0) || Array.isArray(child));
+      if (
+        !includeOptionalTopLevelShell &&
+        !required.has(key) &&
+        value.default === undefined &&
+        value.const === undefined
+      ) {
+        continue;
+      }
+      if (child !== undefined) {
+        result[key] = child;
+      }
+    }
+    return result;
+  }
+
+  if (type === 'array') {
+    return [];
+  }
+  if (type === 'boolean') {
+    return false;
+  }
+  if (type === 'integer' || type === 'number') {
+    return 0;
+  }
+  if (type === 'string') {
+    const propertyName = options.propertyName || 'value';
+    if (propertyName === 'uid') {
+      return 'todo-uid';
+    }
+    return '';
+  }
+  if (schema.oneOf?.length) {
+    return buildSkeletonFromSchema(schema.oneOf[0], {
+      propertyName: options.propertyName,
+      depth: depth + 1,
+    });
+  }
+  if (schema.anyOf?.length) {
+    return buildSkeletonFromSchema(schema.anyOf[0], {
+      propertyName: options.propertyName,
+      depth: depth + 1,
+    });
+  }
+  return undefined;
+}
+
+export function toSchemaTitle(input: any, fallback: string): string {
+  if (typeof input === 'string') {
+    return input;
+  }
+  if (typeof input === 'number' || typeof input === 'boolean') {
+    return String(input);
+  }
+  return fallback;
+}

package/src/flowEngine.ts

@@ -1336,7 +1336,13 @@ export class FlowEngine {
       return hydrated;
     }
 
-    const data = await this._modelRepository.findOne(options);
+    const shouldUseEnsure = !extra?.skipSave && !uid && !!parentId && !!subKey && options?.subType === 'object';
+    const data = shouldUseEnsure
+      ? (await this._modelRepository.ensure(options, {
+          includeAsyncNode: !!(options?.includeAsyncNode || options?.async),
+        })) ?? (await this._modelRepository.findOne(options))
+      : await this._modelRepository.findOne(options);
+
     let model: T | null = null;
     if (data?.uid) {
       model = await this.createModelAsync<T>(data as any, extra);

package/src/index.ts

@@ -57,5 +57,6 @@ export {
 } from './views/viewEvents';
 
 export * from './FlowDefinition';
+export * from './FlowSchemaRegistry';
 export { createViewScopedEngine } from './ViewScopedFlowEngine';
 export { createBlockScopedEngine } from './BlockScopedFlowEngine';

package/src/models/DisplayItemModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DefaultStructure } from '@nocobase/flow-engine';
+import { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 
 export class DisplayItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {}

package/src/models/EditableItemModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DefaultStructure } from '@nocobase/flow-engine';
+import { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 
 export class EditableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {}

package/src/models/FilterableItemModel.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { DefaultStructure } from '@nocobase/flow-engine';
+import { DefaultStructure } from '../types';
 import { CollectionFieldModel } from './CollectionFieldModel';
 
 export class FilterableItemModel<T extends DefaultStructure = DefaultStructure> extends CollectionFieldModel<T> {}

package/src/runjs-context/setup.ts

@@ -47,6 +47,7 @@ export async function setupRunJSContexts() {
     RunJSContextRegistry.register(version, 'JSFieldModel', JSFieldRunJSContext, { scenes: ['detail'] });
     RunJSContextRegistry.register(version, 'JSEditableFieldModel', JSEditableFieldRunJSContext, { scenes: ['form'] });
     RunJSContextRegistry.register(version, 'JSItemModel', JSItemRunJSContext, { scenes: ['form'] });
+    RunJSContextRegistry.register(version, 'JSItemActionModel', JSItemRunJSContext, { scenes: ['table'] });
     RunJSContextRegistry.register(version, 'JSColumnModel', JSColumnRunJSContext, { scenes: ['table'] });
     RunJSContextRegistry.register(version, 'FormJSFieldItemModel', FormJSFieldItemRunJSContext, { scenes: ['form'] });
     RunJSContextRegistry.register(version, 'JSRecordActionModel', JSRecordActionRunJSContext, { scenes: ['table'] });

package/src/server.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ */
+
+export * from './types';
+export * from './FlowSchemaRegistry';