@nocobase/plugin-flow-engine 2.1.0-alpha.23 → 2.1.0-alpha.25

package/dist/server/flow-surfaces/field-type-resolver.js

@@ -0,0 +1,322 @@
+/**
+ * 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.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var field_type_resolver_exports = {};
+__export(field_type_resolver_exports, {
+  FLOW_SURFACE_INTERNAL_FIELD_KEYS: () => FLOW_SURFACE_INTERNAL_FIELD_KEYS,
+  FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET: () => FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET,
+  FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES: () => FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES,
+  FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES: () => FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES,
+  assertNoInternalFieldKeys: () => assertNoInternalFieldKeys,
+  getPublicFieldTypeForUse: () => getPublicFieldTypeForUse,
+  normalizePublicFieldNameList: () => normalizePublicFieldNameList,
+  normalizePublicFieldType: () => normalizePublicFieldType,
+  resolveRelationFieldType: () => resolveRelationFieldType,
+  usesNestedRelationFields: () => usesNestedRelationFields
+});
+module.exports = __toCommonJS(field_type_resolver_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_errors = require("./errors");
+var import_association_interfaces = require("./association-interfaces");
+var import_field_semantics = require("./field-semantics");
+var import_service_helpers = require("./service-helpers");
+var import_association_title_field = require("./association-title-field");
+const FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES = [
+  "text",
+  "select",
+  "picker",
+  "subForm",
+  "subFormList",
+  "subDetails",
+  "subDetailsList",
+  "subTable",
+  "popupSubTable"
+];
+const FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES = ["cascade", "upload", "preview"];
+const FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET = /* @__PURE__ */ new Set([
+  ...FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES,
+  ...FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES
+]);
+const FLOW_SURFACE_INTERNAL_FIELD_KEYS = [
+  "fieldComponent",
+  "fieldModel",
+  "componentFields",
+  "use",
+  "fieldUse",
+  "subModels",
+  "props",
+  "stepParams"
+];
+const FIELD_USE_TO_PUBLIC_FIELD_TYPE = {
+  DisplayTextFieldModel: "text",
+  RecordSelectFieldModel: "select",
+  RecordPickerFieldModel: "picker",
+  SubFormFieldModel: "subForm",
+  SubFormListFieldModel: "subFormList",
+  DisplaySubItemFieldModel: "subDetails",
+  DisplaySubListFieldModel: "subDetailsList",
+  DisplaySubTableFieldModel: "subTable",
+  SubTableFieldModel: "subTable",
+  PopupSubTableFieldModel: "popupSubTable"
+};
+const FIELD_TYPES_WITH_FIELDS = /* @__PURE__ */ new Set([
+  "subForm",
+  "subFormList",
+  "subDetails",
+  "subDetailsList",
+  "subTable",
+  "popupSubTable"
+]);
+const FIELD_TYPES_WITH_SELECTOR_FIELDS = /* @__PURE__ */ new Set(["picker"]);
+const FIELD_TYPES_WITH_TABLE_PROPS = /* @__PURE__ */ new Set(["subTable", "popupSubTable"]);
+function assertNoInternalFieldKeys(input, context) {
+  if (!import_lodash.default.isPlainObject(input)) {
+    return;
+  }
+  const forbidden = FLOW_SURFACE_INTERNAL_FIELD_KEYS.filter((key) => Object.prototype.hasOwnProperty.call(input, key));
+  if (forbidden.length) {
+    (0, import_errors.throwBadRequest)(`${context} does not accept internal field keys: ${forbidden.join(", ")}`);
+  }
+}
+function normalizePublicFieldType(value, context) {
+  if (import_lodash.default.isUndefined(value) || import_lodash.default.isNull(value) || value === "") {
+    return void 0;
+  }
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    return void 0;
+  }
+  if (FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES.includes(normalized)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${context} fieldType '${normalized}' is reserved for plugin-specific field types`);
+  }
+  if (!FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES.includes(normalized)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${context} fieldType '${normalized}' is not supported; supported fieldTypes: ${FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES.join(
+        ", "
+      )}`
+    );
+  }
+  return normalized;
+}
+function normalizePublicFieldNameList(value, context) {
+  if (import_lodash.default.isUndefined(value)) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${context} must be an array of field names`);
+  }
+  return value.map((item, index) => {
+    const normalized = String(item || "").trim();
+    if (!normalized) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${context}[${index + 1}] cannot be empty`);
+    }
+    return normalized;
+  });
+}
+function getPublicFieldTypeForUse(use) {
+  return FIELD_USE_TO_PUBLIC_FIELD_TYPE[String(use || "").trim()];
+}
+function getAssociationCardinality(field) {
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim();
+  if (import_association_interfaces.SINGLE_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface)) {
+    return "single";
+  }
+  if (import_association_interfaces.MULTI_VALUE_ASSOCIATION_INTERFACES.has(fieldInterface)) {
+    return "multi";
+  }
+  return null;
+}
+function pickCollectionFallbackFieldName(collection) {
+  var _a;
+  const safeTitleFieldName = (_a = (0, import_association_title_field.resolveCollectionSafeTitleField)(collection)) == null ? void 0 : _a.fieldName;
+  if (safeTitleFieldName && (0, import_service_helpers.resolveFieldFromCollection)(collection, safeTitleFieldName)) {
+    return safeTitleFieldName;
+  }
+  const primaryField = (0, import_service_helpers.getCollectionFields)(collection).find(
+    (field) => {
+      var _a2;
+      return !!(field == null ? void 0 : field.primaryKey) || !!((_a2 = field == null ? void 0 : field.options) == null ? void 0 : _a2.primaryKey);
+    }
+  );
+  return (0, import_service_helpers.getFieldName)(primaryField) || "id";
+}
+function assertTargetFieldNamesExist(targetCollection, fields, context) {
+  fields.forEach((fieldName) => {
+    if (!(0, import_service_helpers.resolveFieldFromCollection)(targetCollection, fieldName)) {
+      (0, import_errors.throwBadRequest)(`flowSurfaces ${context} field '${fieldName}' does not exist on relation target collection`);
+    }
+  });
+}
+function resolveRelationFieldType(input) {
+  const fieldType = normalizePublicFieldType(input.fieldType, input.context);
+  if (!fieldType) {
+    return void 0;
+  }
+  if (!(0, import_service_helpers.isAssociationField)(input.field)) {
+    throw new import_errors.FlowSurfaceBadRequestError("flowSurfaces fieldType is only supported for relation fields");
+  }
+  const targetCollection = (0, import_service_helpers.resolveFieldTargetCollection)(
+    input.field,
+    input.dataSourceKey || "main",
+    input.getCollection
+  );
+  if (!targetCollection) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' cannot resolve relation target collection`);
+  }
+  const cardinality = getAssociationCardinality(input.field);
+  if (!cardinality) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' is not supported for this relation field`);
+  }
+  const containerKind = (0, import_field_semantics.normalizeFieldContainerKind)(input.containerUse);
+  let fieldUse;
+  switch (fieldType) {
+    case "text":
+      fieldUse = containerKind === "form" ? "RecordSelectFieldModel" : "DisplayTextFieldModel";
+      break;
+    case "select":
+      fieldUse = "RecordSelectFieldModel";
+      break;
+    case "picker":
+      fieldUse = "RecordPickerFieldModel";
+      break;
+    case "subForm":
+      if (cardinality !== "single") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subForm' only supports single relation fields`);
+      }
+      fieldUse = "SubFormFieldModel";
+      break;
+    case "subFormList":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subFormList' only supports multi relation fields`);
+      }
+      fieldUse = "SubFormListFieldModel";
+      break;
+    case "subDetails":
+      if (cardinality !== "single") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subDetails' only supports single relation fields`);
+      }
+      fieldUse = "DisplaySubItemFieldModel";
+      break;
+    case "subDetailsList":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subDetailsList' only supports multi relation fields`);
+      }
+      fieldUse = "DisplaySubListFieldModel";
+      break;
+    case "subTable":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'subTable' only supports multi relation fields`);
+      }
+      fieldUse = containerKind === "form" ? "SubTableFieldModel" : "DisplaySubTableFieldModel";
+      break;
+    case "popupSubTable":
+      if (cardinality !== "multi") {
+        (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType 'popupSubTable' only supports multi relation fields`);
+      }
+      fieldUse = "PopupSubTableFieldModel";
+      break;
+  }
+  const explicitFields = normalizePublicFieldNameList(input.fields, `${input.context}.fields`);
+  const explicitSelectorFields = normalizePublicFieldNameList(input.selectorFields, `${input.context}.selectorFields`);
+  if (explicitFields && explicitSelectorFields) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} cannot mix fields and selectorFields on the same field`);
+  }
+  if (explicitFields && !FIELD_TYPES_WITH_FIELDS.has(fieldType)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support fields`);
+  }
+  if (explicitSelectorFields && !FIELD_TYPES_WITH_SELECTOR_FIELDS.has(fieldType)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support selectorFields`);
+  }
+  if ((!import_lodash.default.isUndefined(input.openMode) || !import_lodash.default.isUndefined(input.popupSize)) && fieldType !== "picker") {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support openMode or popupSize`);
+  }
+  if ((!import_lodash.default.isUndefined(input.pageSize) || !import_lodash.default.isUndefined(input.showIndex)) && !FIELD_TYPES_WITH_TABLE_PROPS.has(fieldType)) {
+    (0, import_errors.throwBadRequest)(`flowSurfaces ${input.context} fieldType '${fieldType}' does not support pageSize or showIndex`);
+  }
+  const shouldApplyDefaults = input.applyDefaults !== false;
+  const defaultTargetField = shouldApplyDefaults ? pickCollectionFallbackFieldName(targetCollection) : void 0;
+  const fields = explicitFields ?? (shouldApplyDefaults && usesNestedRelationFields(fieldUse) ? [defaultTargetField] : void 0);
+  const selectorFields = explicitSelectorFields ?? (shouldApplyDefaults && fieldType === "picker" && import_lodash.default.isUndefined(input.selectorFields) ? [defaultTargetField] : void 0);
+  const titleField = import_lodash.default.isUndefined(input.titleField) ? defaultTargetField : String(input.titleField || "").trim() || void 0;
+  if (fields == null ? void 0 : fields.length) {
+    assertTargetFieldNamesExist(targetCollection, fields, `${input.context}.fields`);
+  }
+  if (selectorFields == null ? void 0 : selectorFields.length) {
+    assertTargetFieldNamesExist(targetCollection, selectorFields, `${input.context}.selectorFields`);
+  }
+  if (titleField && !(0, import_service_helpers.resolveFieldFromCollection)(targetCollection, titleField)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${input.context}.titleField '${titleField}' does not exist on relation target collection`
+    );
+  }
+  return {
+    fieldType,
+    fieldUse,
+    cardinality,
+    targetCollection,
+    fields,
+    selectorFields,
+    titleField,
+    openMode: input.openMode,
+    popupSize: input.popupSize,
+    pageSize: input.pageSize,
+    showIndex: input.showIndex
+  };
+}
+function usesNestedRelationFields(fieldUse) {
+  return [
+    "SubTableFieldModel",
+    "PopupSubTableFieldModel",
+    "DisplaySubTableFieldModel",
+    "SubFormFieldModel",
+    "SubFormListFieldModel",
+    "DisplaySubItemFieldModel",
+    "DisplaySubListFieldModel"
+  ].includes(String(fieldUse || "").trim());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FLOW_SURFACE_INTERNAL_FIELD_KEYS,
+  FLOW_SURFACE_PUBLIC_FIELD_TYPE_SET,
+  FLOW_SURFACE_PUBLIC_RELATION_FIELD_TYPES,
+  FLOW_SURFACE_RESERVED_RELATION_FIELD_TYPES,
+  assertNoInternalFieldKeys,
+  getPublicFieldTypeForUse,
+  normalizePublicFieldNameList,
+  normalizePublicFieldType,
+  resolveRelationFieldType,
+  usesNestedRelationFields
+});

package/dist/server/flow-surfaces/index.js

@@ -51,8 +51,13 @@ const FLOW_SURFACE_LOCAL_TRANSLATIONS = {
   }
 };
 function getValues(ctx) {
-  var _a, _b, _c;
-  return ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) ?? ((_c = ctx.action) == null ? void 0 : _c.params) ?? {};
+  var _a, _b, _c, _d, _e;
+  const values = ((_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) ?? ((_c = ctx.action) == null ? void 0 : _c.params) ?? {};
+  const actionName = (_d = ctx.action) == null ? void 0 : _d.actionName;
+  if (isInvalidFlowSurfaceWritePayload(values) && actionName && !((_e = import_constants.FLOW_SURFACE_ACTION_DEFINITIONS[actionName]) == null ? void 0 : _e.read)) {
+    throw new import_errors.FlowSurfaceBadRequestError(getFlowSurfaceWritePayloadMessage(actionName));
+  }
+  return values;
 }
 function isImplicitEmptyValuesBag(value) {
   return !!value && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && Object.keys(value).length === 0;
@@ -119,6 +124,56 @@ function writeFlowSurfaceErrorResponse(ctx, error) {
   ctx.status = normalized.status;
   ctx.body = normalized.toResponseBody();
 }
+function isFlowSurfaceWriteActionName(value) {
+  return Object.prototype.hasOwnProperty.call(import_constants.FLOW_SURFACE_ACTION_DEFINITIONS, value);
+}
+function getFlowSurfaceRequestActionName(ctx) {
+  var _a, _b;
+  const actionName = String(((_a = ctx.action) == null ? void 0 : _a.actionName) || "").trim();
+  if (isFlowSurfaceWriteActionName(actionName)) {
+    return actionName;
+  }
+  const path = String(ctx.path || ((_b = ctx.request) == null ? void 0 : _b.path) || "").trim();
+  const match = path.match(/(?:^|\/)flowSurfaces:([^/?#]+)$/);
+  const rawActionName = String((match == null ? void 0 : match[1]) || "").trim();
+  return isFlowSurfaceWriteActionName(rawActionName) ? rawActionName : void 0;
+}
+function isFlowSurfaceWriteRequest(ctx) {
+  var _a;
+  if (String(((_a = ctx.request) == null ? void 0 : _a.method) || "").toUpperCase() !== "POST") {
+    return false;
+  }
+  const actionName = getFlowSurfaceRequestActionName(ctx);
+  return !!actionName && import_constants.FLOW_SURFACE_ACTION_DEFINITIONS[actionName].read === false;
+}
+function isInvalidFlowSurfaceWritePayload(value) {
+  if (!value || typeof value !== "object") {
+    return true;
+  }
+  return Array.isArray(value);
+}
+function getFlowSurfaceWritePayloadMessage(actionName) {
+  const noun = actionName === "applyBlueprint" || actionName === "applyApprovalBlueprint" ? "payload" : "values";
+  return `flowSurfaces ${actionName} ${noun} must be an object`;
+}
+function isFlowSurfaceWriteBodyParserShapeError(error) {
+  const parserError = error;
+  return error instanceof SyntaxError && parserError.status === 400 && parserError.message === "invalid JSON, only supports object and array";
+}
+async function runFlowSurfaceWriteBodyParserErrorWrapper(ctx, next) {
+  try {
+    await next();
+  } catch (error) {
+    if (!isFlowSurfaceWriteRequest(ctx) || !isFlowSurfaceWriteBodyParserShapeError(error)) {
+      throw error;
+    }
+    const actionName = getFlowSurfaceRequestActionName(ctx);
+    if (!actionName) {
+      throw error;
+    }
+    writeFlowSurfaceErrorResponse(ctx, new import_errors.FlowSurfaceBadRequestError(getFlowSurfaceWritePayloadMessage(actionName)));
+  }
+}
 function isAclPermissionDeniedForFlowSurfaces(ctx, error) {
   var _a, _b;
   const resourceName = ((_a = ctx.action) == null ? void 0 : _a.resourceName) ?? ((_b = ctx.permission) == null ? void 0 : _b.resourceName);
@@ -231,6 +286,10 @@ function registerFlowSurfacesResource(plugin) {
     after: "allow-manager",
     before: "core"
   });
+  plugin.app.use(runFlowSurfaceWriteBodyParserErrorWrapper, {
+    tag: "flow-surfaces-write-body-errors",
+    before: "bodyParser"
+  });
   plugin.app.resourceManager.define({
     name: "flowSurfaces",
     actions

package/dist/server/flow-surfaces/node-use-sets.js

@@ -39,6 +39,8 @@ var import_approval = require("./approval");
 const COLLECTION_BLOCK_USES = /* @__PURE__ */ new Set([
   "TableBlockModel",
   "CalendarBlockModel",
+  "TreeBlockModel",
+  "KanbanBlockModel",
   "CreateFormModel",
   "EditFormModel",
   "FormBlockModel",
@@ -109,6 +111,8 @@ const ACTION_BUTTON_USES = /* @__PURE__ */ new Set([
   "CalendarNavActionModel",
   "CalendarTitleActionModel",
   "CalendarViewSelectActionModel",
+  "KanbanQuickCreateActionModel",
+  "KanbanCardViewActionModel",
   "ApplyFormSubmitModel",
   "ApplyFormSaveDraftModel",
   "ApplyFormWithdrawModel",

package/dist/server/flow-surfaces/placement.js

@@ -58,6 +58,8 @@ const FLOW_SURFACE_POPUP_HOST_USES = /* @__PURE__ */ new Set([
   "PopupCollectionActionModel",
   "CalendarQuickCreateActionModel",
   "CalendarEventViewActionModel",
+  "KanbanQuickCreateActionModel",
+  "KanbanCardViewActionModel",
   "ClickableFieldModel",
   "DisplayTextFieldModel",
   "DisplayEnumFieldModel",
@@ -161,6 +163,7 @@ function isActionContainerUse(parentUse) {
   return [
     "TableBlockModel",
     "CalendarBlockModel",
+    "KanbanBlockModel",
     "TableActionsColumnModel",
     "ListBlockModel",
     "GridCardBlockModel",

package/dist/server/flow-surfaces/public-data-surface-default-filter.d.ts

@@ -7,12 +7,16 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 export declare const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES: Set<string>;
+export declare const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL = "table/list/gridCard/calendar/kanban";
 export declare function isFlowSurfacePublicDataSurfaceBlockType(blockType?: string): boolean;
 export declare function normalizeFlowSurfacePublicBlockDefaultFilter(actionName: string, defaultFilter: any, options: {
     blockType?: string;
     template?: unknown;
     path?: string;
 }): any;
+export declare function assertFlowSurfaceConcreteDefaultFilterItem(actionName: string, defaultFilter: any, options?: {
+    path?: string;
+}): void;
 export declare function backfillFlowSurfaceDefaultFilterSetting(settings: any, defaultFilter: any): any;
 export declare function backfillFlowSurfaceFilterActionDefaultFilter<T extends {
     type?: string;

package/dist/server/flow-surfaces/public-data-surface-default-filter.js

@@ -37,6 +37,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var public_data_surface_default_filter_exports = {};
 __export(public_data_surface_default_filter_exports, {
   FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES: () => FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES,
+  FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL: () => FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL,
+  assertFlowSurfaceConcreteDefaultFilterItem: () => assertFlowSurfaceConcreteDefaultFilterItem,
   backfillFlowSurfaceDefaultFilterSetting: () => backfillFlowSurfaceDefaultFilterSetting,
   backfillFlowSurfaceFilterActionDefaultFilter: () => backfillFlowSurfaceFilterActionDefaultFilter,
   isFlowSurfacePublicDataSurfaceBlockType: () => isFlowSurfacePublicDataSurfaceBlockType,
@@ -46,7 +48,14 @@ module.exports = __toCommonJS(public_data_surface_default_filter_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_errors = require("./errors");
 var import_filter_group = require("./filter-group");
-const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES = /* @__PURE__ */ new Set(["table", "list", "gridCard"]);
+const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "table",
+  "list",
+  "gridCard",
+  "calendar",
+  "kanban"
+]);
+const FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL = "table/list/gridCard/calendar/kanban";
 function isFlowSurfacePublicDataSurfaceBlockType(blockType) {
   return FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES.has(String(blockType || "").trim());
 }
@@ -54,14 +63,44 @@ function normalizeFlowSurfacePublicBlockDefaultFilter(actionName, defaultFilter,
   if (import_lodash.default.isUndefined(defaultFilter)) {
     return void 0;
   }
-  const fieldPath = options.path ? `${options.path}.defaultFilter` : "defaultFilter";
+  const fieldPath = buildFlowSurfaceDefaultFilterFieldPath(actionName, options.path);
   if (!isFlowSurfacePublicDataSurfaceBlockType(options.blockType) || !import_lodash.default.isUndefined(options.template)) {
-    (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldPath} is only supported on direct table/list/gridCard blocks`);
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} ${fieldPath} is only supported on direct ${FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL} blocks`
+    );
   }
-  return (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
+  const normalized = (0, import_filter_group.normalizeFlowSurfaceFilterGroupValue)(
     defaultFilter,
     `flowSurfaces ${actionName} ${fieldPath} expects FilterGroup like ${import_filter_group.FLOW_SURFACE_FILTER_GROUP_EXAMPLE}`
   );
+  return normalized;
+}
+function assertFlowSurfaceConcreteDefaultFilterItem(actionName, defaultFilter, options = {}) {
+  const fieldPath = buildFlowSurfaceDefaultFilterFieldPath(actionName, options.path);
+  if (!hasConcreteFlowSurfaceFilterItem(defaultFilter)) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${actionName} ${fieldPath} must include at least one concrete filter item; empty defaultFilter groups such as {}, null, or { logic, items: [] } are not allowed`
+    );
+  }
+}
+function buildFlowSurfaceDefaultFilterFieldPath(actionName, path) {
+  if (!path) {
+    return "defaultFilter";
+  }
+  const prefix = `flowSurfaces ${actionName} `;
+  const normalizedPath = path.startsWith(prefix) ? path.slice(prefix.length) : path;
+  return normalizedPath.endsWith(".defaultFilter") ? normalizedPath : `${normalizedPath}.defaultFilter`;
+}
+function hasConcreteFlowSurfaceFilterItem(filter) {
+  if (!import_lodash.default.isPlainObject(filter) || !Array.isArray(filter.items)) {
+    return false;
+  }
+  return filter.items.some((item) => {
+    if (import_lodash.default.isPlainObject(item) && "logic" in item && "items" in item) {
+      return hasConcreteFlowSurfaceFilterItem(item);
+    }
+    return import_lodash.default.isPlainObject(item) && typeof item.path === "string" && typeof item.operator === "string";
+  });
 }
 function backfillFlowSurfaceDefaultFilterSetting(settings, defaultFilter) {
   if (import_lodash.default.isUndefined(defaultFilter)) {
@@ -104,6 +143,8 @@ function backfillFlowSurfaceFilterActionDefaultFilter(actions, defaultFilter) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPES,
+  FLOW_SURFACE_PUBLIC_DATA_SURFACE_BLOCK_TYPE_LABEL,
+  assertFlowSurfaceConcreteDefaultFilterItem,
   backfillFlowSurfaceDefaultFilterSetting,
   backfillFlowSurfaceFilterActionDefaultFilter,
   isFlowSurfacePublicDataSurfaceBlockType,

package/dist/server/flow-surfaces/service-helpers.js

@@ -66,6 +66,7 @@ __export(service_helpers_exports, {
 });
 module.exports = __toCommonJS(service_helpers_exports);
 var import_lodash = __toESM(require("lodash"));
+var import_core_field_default_bindings = require("./core-field-default-bindings");
 const FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE = 1;
 const FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE_SIZE = 50;
 function toTemplatePlainRow(row) {
@@ -206,82 +207,14 @@ function getFieldFilterable(field) {
   return (_a = field == null ? void 0 : field.options) == null ? void 0 : _a.filterable;
 }
 function inferAssociationLeafDisplayFieldUse(fieldInterface) {
-  const normalized = String(fieldInterface || "").trim();
-  const map = {
-    richText: "DisplayHtmlFieldModel",
-    number: "DisplayNumberFieldModel",
-    integer: "DisplayNumberFieldModel",
-    id: "DisplayNumberFieldModel",
-    snowflakeId: "DisplayNumberFieldModel",
-    json: "DisplayJSONFieldModel",
-    select: "DisplayTextFieldModel",
-    multipleSelect: "DisplayTextFieldModel",
-    radioGroup: "DisplayTextFieldModel",
-    checkboxGroup: "DisplayTextFieldModel",
-    collection: "DisplayTextFieldModel",
-    tableoid: "DisplayTextFieldModel",
-    icon: "DisplayIconFieldModel",
-    checkbox: "DisplayCheckboxFieldModel",
-    password: "DisplayPasswordFieldModel",
-    percent: "DisplayPercentFieldModel",
-    date: "DisplayDateTimeFieldModel",
-    datetimeNoTz: "DisplayDateTimeFieldModel",
-    createdAt: "DisplayDateTimeFieldModel",
-    datetime: "DisplayDateTimeFieldModel",
-    updatedAt: "DisplayDateTimeFieldModel",
-    unixTimestamp: "DisplayDateTimeFieldModel",
-    formula: "DisplayDateTimeFieldModel",
-    input: "DisplayTextFieldModel",
-    email: "DisplayTextFieldModel",
-    phone: "DisplayTextFieldModel",
-    uuid: "DisplayTextFieldModel",
-    textarea: "DisplayTextFieldModel",
-    nanoid: "DisplayTextFieldModel",
-    url: "DisplayURLFieldModel",
-    color: "DisplayColorFieldModel",
-    time: "DisplayTimeFieldModel"
-  };
-  return map[normalized];
+  return (0, import_core_field_default_bindings.getSharedFieldDefaultBindingUse)("display", fieldInterface);
 }
 function inferFieldMenuEditableFieldUse(fieldInterface) {
   const normalized = String(fieldInterface || "").trim();
   if (["m2m", "m2o", "o2o", "o2m", "oho", "obo", "updatedBy", "createdBy", "mbm"].includes(normalized)) {
     return "RecordSelectFieldModel";
   }
-  const map = {
-    json: "JsonFieldModel",
-    textarea: "TextareaFieldModel",
-    icon: "IconFieldModel",
-    radioGroup: "SelectFieldModel",
-    color: "ColorFieldModel",
-    select: "SelectFieldModel",
-    multipleSelect: "SelectFieldModel",
-    checkboxGroup: "SelectFieldModel",
-    checkbox: "CheckboxFieldModel",
-    password: "PasswordFieldModel",
-    number: "NumberFieldModel",
-    integer: "NumberFieldModel",
-    id: "NumberFieldModel",
-    snowflakeId: "NumberFieldModel",
-    percent: "PercentFieldModel",
-    datetimeNoTz: "DateTimeNoTzFieldModel",
-    date: "DateOnlyFieldModel",
-    datetime: "DateTimeTzFieldModel",
-    createdAt: "DateTimeTzFieldModel",
-    updatedAt: "DateTimeTzFieldModel",
-    unixTimestamp: "DateTimeTzFieldModel",
-    time: "TimeFieldModel",
-    collection: "CollectionSelectorFieldModel",
-    tableoid: "CollectionSelectorFieldModel",
-    richText: "RichTextFieldModel",
-    input: "InputFieldModel",
-    email: "InputFieldModel",
-    phone: "InputFieldModel",
-    uuid: "InputFieldModel",
-    url: "InputFieldModel",
-    nanoid: "InputFieldModel"
-  };
-  return map[normalized];
+  return (0, import_core_field_default_bindings.getSharedFieldDefaultBindingUse)("editable", normalized);
 }
 function isAssociationField(field) {
   if (typeof (field == null ? void 0 : field.isAssociationField) === "function") {

package/dist/server/flow-surfaces/service-utils.d.ts

@@ -9,6 +9,7 @@
 import _ from 'lodash';
 import { FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY, type FlowSurfaceApplyBlueprintPopupDefaultsMetadata } from './blueprint/defaults';
 import type { FlowSurfaceNodeSpec, FlowSurfaceNodeSubModel } from './types';
+import { type FlowSurfacePublicRelationFieldType } from './field-type-resolver';
 export declare function buildDefinedPayload(payload: Record<string, any>): _.Dictionary<any>;
 export declare function normalizeFlowSurfaceComposeKey(key: any, context: string): string;
 export declare function assertFlowSurfaceComposeUniqueKeys(items: Array<{
@@ -65,6 +66,14 @@ export type NormalizedComposeFieldSpec = {
     associationPathName?: string;
     renderer?: string;
     type?: string;
+    fieldType?: FlowSurfacePublicRelationFieldType;
+    fields?: string[];
+    selectorFields?: string[];
+    titleField?: string;
+    openMode?: string;
+    popupSize?: string;
+    pageSize?: number;
+    showIndex?: boolean;
     target?: string;
     settings: Record<string, any>;
     popup?: Record<string, any>;
@@ -72,6 +81,9 @@ export type NormalizedComposeFieldSpec = {
     [FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]?: FlowSurfaceApplyBlueprintPopupDefaultsMetadata;
 };
 export declare function normalizeComposeFieldSpec(input: any, index: number): NormalizedComposeFieldSpec;
+export declare function resolveRequestedFieldComponent(values: Record<string, any> | undefined): any;
+export declare function resolveRequestedFieldUse(values: Record<string, any> | undefined): any;
+export declare function resolveRequestedFieldUseAlias(values: Record<string, any> | undefined): string;
 export declare function normalizeComposeActionSpec(input: any, index: number): {
     popup?: any;
     key: string;
@@ -99,7 +111,7 @@ export declare function splitComposeFieldChanges(changes: Record<string, any>, w
     wrapperChanges: _.Dictionary<any>;
     fieldChanges: _.Dictionary<any>;
 };
-export declare function getCatalogRecordActionContainerUse(use?: string): "DetailsBlockModel" | "TableActionsColumnModel" | "ListItemModel" | "GridCardItemModel";
+export declare function getCatalogRecordActionContainerUse(use?: string): "DetailsBlockModel" | "ListItemModel" | "GridCardItemModel" | "TableActionsColumnModel";
 export declare function normalizeRowSpans(spans?: Array<number | undefined>): number[];
 export declare function normalizePublicBlockHeightMode(input: any): string;
 export declare function normalizeStoredChartCardHeightMode(input: any): string;