@nocobase/plugin-flow-engine 2.2.0-beta.1 → 2.2.0-beta.11

package/dist/server/flow-surfaces/planning/step-link.d.ts

@@ -11,4 +11,4 @@ import type { FlowSurfacePlanStepLink } from '../types';
 export declare const isFlowSurfacePlanStepLink: typeof isFlowSurfacePlanStepValue;
 export declare function normalizeFlowSurfacePlanStepLink(actionName: string, input: any, fieldName: string): FlowSurfacePlanStepLink;
 export declare function assertFlowSurfaceKnownPlanStepLink(actionName: string, stepLink: FlowSurfacePlanStepLink, fieldName: string, knownStepIds?: Set<string>): void;
-export declare function replaceFlowSurfacePlanStepLinks(actionName: string, input: any, path: string, knownStepIds?: Set<string>, knownRuntimeKeys?: Set<string>): any;
+export declare function replaceFlowSurfacePlanStepLinks(actionName: string, input: any, path: string, knownStepIds?: Set<string>, knownRuntimeKeys?: Set<string>, blockedRuntimeKeys?: Set<string>): any;

package/dist/server/flow-surfaces/planning/step-link.js

@@ -56,10 +56,17 @@ function assertFlowSurfaceKnownPlanStepLink(actionName, stepLink, fieldName, kno
   }
   (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${fieldName}.step '${stepLink.step}' is not a previous step id`);
 }
-function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds, knownRuntimeKeys) {
+function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds, knownRuntimeKeys, blockedRuntimeKeys) {
   if (Array.isArray(input)) {
     return input.map(
-      (item, index) => replaceFlowSurfacePlanStepLinks(actionName, item, `${path}[${index}]`, knownStepIds, knownRuntimeKeys)
+      (item, index) => replaceFlowSurfacePlanStepLinks(
+        actionName,
+        item,
+        `${path}[${index}]`,
+        knownStepIds,
+        knownRuntimeKeys,
+        blockedRuntimeKeys
+      )
     );
   }
   if (!import_lodash.default.isPlainObject(input)) {
@@ -81,6 +88,11 @@ function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds,
     if (!runtimeKey) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key cannot be empty`);
     }
+    if (blockedRuntimeKeys == null ? void 0 : blockedRuntimeKeys.has(runtimeKey)) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} ${path}.key '${runtimeKey}' belongs to the current replace scope; replace-step key links cannot resolve to old replace subtree nodes`
+      );
+    }
     if (!(knownRuntimeKeys == null ? void 0 : knownRuntimeKeys.has(runtimeKey))) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.key '${runtimeKey}' is not defined`);
     }
@@ -91,7 +103,14 @@ function replaceFlowSurfacePlanStepLinks(actionName, input, path, knownStepIds,
   return Object.fromEntries(
     Object.entries(input).map(([key, value]) => [
       key,
-      replaceFlowSurfacePlanStepLinks(actionName, value, `${path}.${key}`, knownStepIds, knownRuntimeKeys)
+      replaceFlowSurfacePlanStepLinks(
+        actionName,
+        value,
+        `${path}.${key}`,
+        knownStepIds,
+        knownRuntimeKeys,
+        blockedRuntimeKeys
+      )
     ])
   );
 }

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

@@ -299,9 +299,7 @@ function backfillFlowSurfaceDefaultFilterSetting(settings, defaultFilter) {
   if (import_lodash.default.isUndefined(defaultFilter)) {
     return settings;
   }
-  const filterableFieldNames = resolveFlowSurfaceDefaultFilterFieldNames(defaultFilter);
   const defaults = {
-    ...filterableFieldNames.length ? { filterableFieldNames } : {},
     defaultFilter: import_lodash.default.cloneDeep(defaultFilter)
   };
   if (import_lodash.default.isUndefined(settings)) {
@@ -311,13 +309,6 @@ function backfillFlowSurfaceDefaultFilterSetting(settings, defaultFilter) {
     return settings;
   }
   if (Object.prototype.hasOwnProperty.call(settings, "defaultFilter")) {
-    const explicitFilterableFieldNames = resolveFlowSurfaceDefaultFilterFieldNames(settings.defaultFilter);
-    if (!Object.prototype.hasOwnProperty.call(settings, "filterableFieldNames") && explicitFilterableFieldNames.length) {
-      return {
-        ...import_lodash.default.cloneDeep(settings),
-        filterableFieldNames: explicitFilterableFieldNames
-      };
-    }
     return settings;
   }
   return {

package/dist/server/flow-surfaces/reaction/field-value.d.ts

@@ -17,6 +17,15 @@ export type FlowSurfaceFieldValueCompileResult = FlowSurfaceReactionWriteResult<
 export declare function isFieldValueTargetUseSupported(use?: string | null): boolean;
 export declare function assertFieldValueTargetSupported(target: FlowSurfaceFieldValueTarget): void;
 export declare function normalizeFieldValueRules(rules: FlowSurfaceFieldValueRule[] | undefined): FlowSurfaceFieldValueRule[];
+export declare function validateFieldValueRulesAgainstCapability(rules: FlowSurfaceFieldValueRule[], capability: {
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
+    };
+}): void;
 export declare function compileFieldValueRulesToCanonical(rules: FlowSurfaceFieldValueRule[] | undefined): {
     key: string;
     enable: boolean;

package/dist/server/flow-surfaces/reaction/field-value.js

@@ -41,11 +41,13 @@ __export(field_value_exports, {
   collectUpdateAssociationValuesFromFieldValueRules: () => collectUpdateAssociationValuesFromFieldValueRules,
   compileFieldValueRulesToCanonical: () => compileFieldValueRulesToCanonical,
   isFieldValueTargetUseSupported: () => isFieldValueTargetUseSupported,
-  normalizeFieldValueRules: () => normalizeFieldValueRules
+  normalizeFieldValueRules: () => normalizeFieldValueRules,
+  validateFieldValueRulesAgainstCapability: () => validateFieldValueRulesAgainstCapability
 });
 module.exports = __toCommonJS(field_value_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_errors = require("../errors");
+var import_filter_group = require("../filter-group");
 var import_errors2 = require("./errors");
 var import_fingerprint = require("./fingerprint");
 var import_registry = require("./registry");
@@ -85,6 +87,52 @@ function normalizeFieldValueRules(rules) {
   const list = Array.isArray(rules) ? rules : [];
   return list.map((rule, index) => normalizeFieldValueRule(rule, index));
 }
+function validateFieldValueRulesAgainstCapability(rules, capability) {
+  for (const [ruleIndex, rule] of (rules || []).entries()) {
+    validateFieldValueDateConditionFilter(rule.when, capability, `rules[${ruleIndex}].when`);
+  }
+}
+function validateFieldValueDateConditionFilter(filter, capability, prefix) {
+  const visit = (node, currentPrefix) => {
+    var _a;
+    if (!import_lodash.default.isPlainObject(node)) {
+      return;
+    }
+    if (Array.isArray(node.items)) {
+      node.items.forEach((item, index) => visit(item, `${currentPrefix}.items[${index}]`));
+      return;
+    }
+    const operator = typeof node.operator === "string" ? node.operator.trim() : "";
+    const path = typeof node.path === "string" ? node.path.trim() : "";
+    if (!operator || !path || !Object.prototype.hasOwnProperty.call(node, "value")) {
+      return;
+    }
+    const fieldMeta = resolveFieldValueConditionFieldMeta(path, (_a = capability.conditionMeta) == null ? void 0 : _a.fieldMetaByPath);
+    if (!import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator) && !(0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+      return;
+    }
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, node.value, `${currentPrefix}.value`, {
+      fieldPath: path,
+      fieldType: fieldMeta == null ? void 0 : fieldMeta.type,
+      fieldInterface: fieldMeta == null ? void 0 : fieldMeta.interface,
+      allowContextPathValue: true
+    });
+  };
+  visit(filter, prefix);
+}
+function resolveFieldValueConditionFieldMeta(path, fieldMetaByPath) {
+  if (!fieldMetaByPath) {
+    return void 0;
+  }
+  if (fieldMetaByPath[path]) {
+    return fieldMetaByPath[path];
+  }
+  const wildcardPath = Object.keys(fieldMetaByPath).filter((candidate) => candidate.endsWith(".*")).sort((a, b) => b.length - a.length).find((candidate) => {
+    const prefix = candidate.slice(0, -2);
+    return path.startsWith(`${prefix}.`) && path.length > prefix.length + 1;
+  });
+  return wildcardPath ? fieldMetaByPath[wildcardPath] : void 0;
+}
 function compileFieldValueRulesToCanonical(rules) {
   return normalizeFieldValueRules(rules).map((rule) => ({
     key: rule.key,
@@ -177,5 +225,6 @@ function buildFieldValueWriteResult(params) {
   collectUpdateAssociationValuesFromFieldValueRules,
   compileFieldValueRulesToCanonical,
   isFieldValueTargetUseSupported,
-  normalizeFieldValueRules
+  normalizeFieldValueRules,
+  validateFieldValueRulesAgainstCapability
 });

package/dist/server/flow-surfaces/reaction/linkage.d.ts

@@ -6,7 +6,7 @@
  * 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 { FlowSurfaceActionLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldLinkageScene, FlowSurfaceFieldOption, FlowSurfaceFieldPathToUidResolver, FlowSurfaceFieldUidToPathResolver, FlowSurfaceBlockLinkageRule } from './types';
+import type { FlowSurfaceActionLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldLinkageScene, FlowSurfaceFieldOption, FlowSurfaceFieldPathToUidResolver, FlowSurfaceFieldUidToPathResolver, FlowSurfaceReactionFilter, FlowSurfaceBlockLinkageRule } from './types';
 type NormalizeFieldRuleOptions = {
     scene: FlowSurfaceFieldLinkageScene;
     resolveFieldPath?: FlowSurfaceFieldUidToPathResolver;
@@ -18,6 +18,10 @@ type CompileFieldRuleOptions = {
 type FlowSurfaceLinkageValidationCapability = {
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 };
 type FlowSurfaceFieldLinkageValidationCapability = FlowSurfaceLinkageValidationCapability & {
@@ -26,6 +30,7 @@ type FlowSurfaceFieldLinkageValidationCapability = FlowSurfaceLinkageValidationC
         supportedSources: Array<'literal' | 'path' | 'runjs'>;
     };
 };
+export declare function validateReactionFilterAgainstCapability(filter: FlowSurfaceReactionFilter | undefined, capability: FlowSurfaceLinkageValidationCapability, prefix: string): void;
 export declare function buildReactionFingerprint(value: any): string;
 export declare function normalizeBlockLinkageRules(rawRules: unknown): FlowSurfaceBlockLinkageRule[];
 export declare function normalizeActionLinkageRules(rawRules: unknown): FlowSurfaceActionLinkageRule[];

package/dist/server/flow-surfaces/reaction/linkage.js

@@ -48,7 +48,8 @@ __export(linkage_exports, {
   validateBlockLinkageRulesAgainstCapability: () => validateBlockLinkageRulesAgainstCapability,
   validateBlockLinkageSceneSupport: () => validateBlockLinkageSceneSupport,
   validateFieldLinkageRulesAgainstCapability: () => validateFieldLinkageRulesAgainstCapability,
-  validateFieldLinkageSceneSupport: () => validateFieldLinkageSceneSupport
+  validateFieldLinkageSceneSupport: () => validateFieldLinkageSceneSupport,
+  validateReactionFilterAgainstCapability: () => validateReactionFilterAgainstCapability
 });
 module.exports = __toCommonJS(linkage_exports);
 var import_node_crypto = require("node:crypto");
@@ -148,7 +149,10 @@ function normalizeReactionFilter(rawFilter) {
   }
   const normalizedFilter = (0, import_filter_group.normalizeFlowSurfaceCompatibleFilterGroupValue)(
     rawFilter,
-    "flowSurfaces linkage rule condition"
+    "flowSurfaces linkage rule condition",
+    {
+      allowContextPathValue: true
+    }
   );
   const visit = (node) => {
     if (!import_lodash.default.isPlainObject(node)) {
@@ -639,6 +643,7 @@ function validateReactionFilterAgainstCapability(filter, capability, prefix) {
   var _a;
   const operatorsByPath = ((_a = capability.conditionMeta) == null ? void 0 : _a.operatorsByPath) || {};
   const visit = (node, currentPrefix) => {
+    var _a2, _b;
     if (!import_lodash.default.isPlainObject(node)) {
       return;
     }
@@ -683,6 +688,15 @@ function validateReactionFilterAgainstCapability(filter, capability, prefix) {
       );
     }
     if (hasValue) {
+      const fieldMeta = (_b = (_a2 = capability.conditionMeta) == null ? void 0 : _a2.fieldMetaByPath) == null ? void 0 : _b[operatorPath];
+      if (import_filter_group.FLOW_SURFACE_DATE_FILTER_OPERATORS.has(operator) || (0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)(fieldMeta)) {
+        (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, node.value, `${currentPrefix}.value`, {
+          fieldPath: path,
+          fieldType: fieldMeta == null ? void 0 : fieldMeta.type,
+          fieldInterface: fieldMeta == null ? void 0 : fieldMeta.interface,
+          allowContextPathValue: true
+        });
+      }
       validateContextBoundValue(node.value, capability, `${currentPrefix}.value`);
     }
   };
@@ -895,5 +909,6 @@ function compileFieldLinkageCanonicalRules(rules, options) {
   validateBlockLinkageRulesAgainstCapability,
   validateBlockLinkageSceneSupport,
   validateFieldLinkageRulesAgainstCapability,
-  validateFieldLinkageSceneSupport
+  validateFieldLinkageSceneSupport,
+  validateReactionFilterAgainstCapability
 });

package/dist/server/flow-surfaces/reaction/meta.js

@@ -114,6 +114,19 @@ function buildConditionOperatorsByPath(context) {
   }
   return operatorsByPath;
 }
+function buildConditionFieldMetaByPath(context) {
+  const fieldMetaByPath = {};
+  for (const [path, info] of collectContextPathEntries(context)) {
+    if (!isAuthorableLinkageContextPath(path)) {
+      continue;
+    }
+    fieldMetaByPath[path] = {
+      ...(info == null ? void 0 : info.type) ? { type: info.type } : {},
+      ...(info == null ? void 0 : info.interface) ? { interface: info.interface } : {}
+    };
+  }
+  return fieldMetaByPath;
+}
 function isAuthorableLinkageContextPath(path) {
   const segments = String(path || "").split(".").filter(Boolean);
   const root = segments[0];
@@ -395,6 +408,10 @@ function buildFieldValueCapability(input, capability) {
     canonicalRules,
     context: input.context,
     targetFields: collectFieldOptions(input.resolvedTarget.node, input.context, capability.resolvedScene),
+    conditionMeta: {
+      operatorsByPath: buildConditionOperatorsByPath(input.context),
+      fieldMetaByPath: buildConditionFieldMetaByPath(input.context)
+    },
     valueExprMeta: {
       supportedSources: ["literal", "path", "runjs"],
       runjsScene: "fieldValue"
@@ -412,7 +429,8 @@ function buildLinkageCapability(input, capability) {
     context: input.context,
     supportedActions: buildSupportedActions(capability),
     conditionMeta: {
-      operatorsByPath: buildConditionOperatorsByPath(input.context)
+      operatorsByPath: buildConditionOperatorsByPath(input.context),
+      fieldMetaByPath: buildConditionFieldMetaByPath(input.context)
     }
   };
   if (capability.kind === "fieldLinkage") {

package/dist/server/flow-surfaces/reaction/types.d.ts

@@ -163,6 +163,13 @@ export type FlowSurfaceReactionCapabilityBase<TKind extends FlowSurfaceReactionK
 };
 export type FlowSurfaceFieldValueCapability = FlowSurfaceReactionCapabilityBase<'fieldValue', FlowSurfaceFieldValueRule> & {
     targetFields: FlowSurfaceFieldOption[];
+    conditionMeta: {
+        operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
+    };
     valueExprMeta: {
         supportedSources: Array<'literal' | 'path' | 'runjs'>;
         runjsScene: 'fieldValue';
@@ -172,17 +179,29 @@ export type FlowSurfaceLinkageCapability = (FlowSurfaceReactionCapabilityBase<'b
     supportedActions: Array<Record<string, any>>;
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 }) | (FlowSurfaceReactionCapabilityBase<'actionLinkage', FlowSurfaceActionLinkageRule> & {
     supportedActions: Array<Record<string, any>>;
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
 }) | (FlowSurfaceReactionCapabilityBase<'fieldLinkage', FlowSurfaceFieldLinkageRule> & {
     supportedActions: Array<Record<string, any>>;
     targetFields: FlowSurfaceFieldOption[];
     conditionMeta: {
         operatorsByPath: Record<string, string[]>;
+        fieldMetaByPath?: Record<string, {
+            type?: string;
+            interface?: string;
+        }>;
     };
     valueExprMeta?: {
         supportedSources: Array<'literal' | 'path' | 'runjs'>;

package/dist/server/flow-surfaces/relation-backing-foreign-key.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 declare function collectRelationBackingForeignKeyNames(collection: any): Set<string>;
+export declare function isRelationBackingForeignKeyField(collection: any, fieldOrFieldName: any): boolean;

package/dist/server/flow-surfaces/relation-backing-foreign-key.js

@@ -0,0 +1,79 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var relation_backing_foreign_key_exports = {};
+__export(relation_backing_foreign_key_exports, {
+  collectRelationBackingForeignKeyNames: () => collectRelationBackingForeignKeyNames,
+  isRelationBackingForeignKeyField: () => isRelationBackingForeignKeyField
+});
+module.exports = __toCommonJS(relation_backing_foreign_key_exports);
+var import_service_helpers = require("./service-helpers");
+const CURRENT_COLLECTION_FOREIGN_KEY_RELATION_TYPES = /* @__PURE__ */ new Set(["belongsto"]);
+const CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES = /* @__PURE__ */ new Set(["m2o"]);
+const CONDITIONAL_CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES = /* @__PURE__ */ new Set(["o2o"]);
+const RELATION_INTERFACES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION = /* @__PURE__ */ new Set(["o2m", "m2m", "mbm"]);
+const RELATION_TYPES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION = /* @__PURE__ */ new Set(["hasone", "hasmany", "belongstomany"]);
+function collectRelationBackingForeignKeyNames(collection) {
+  const fields = (0, import_service_helpers.getCollectionFields)(collection);
+  const scalarFieldNames = new Set(
+    fields.filter((field) => !(0, import_service_helpers.isAssociationField)(field)).map((field) => String((0, import_service_helpers.getFieldName)(field) || "").trim()).filter(Boolean)
+  );
+  const names = /* @__PURE__ */ new Set();
+  fields.forEach((field) => {
+    const foreignKey = getCurrentCollectionRelationForeignKey(field);
+    if (foreignKey && scalarFieldNames.has(foreignKey)) {
+      names.add(foreignKey);
+    }
+  });
+  return names;
+}
+function isRelationBackingForeignKeyField(collection, fieldOrFieldName) {
+  const fieldName = typeof fieldOrFieldName === "string" ? fieldOrFieldName.trim() : String((0, import_service_helpers.getFieldName)(fieldOrFieldName) || "").trim();
+  return !!fieldName && collectRelationBackingForeignKeyNames(collection).has(fieldName);
+}
+function getCurrentCollectionRelationForeignKey(field) {
+  var _a;
+  if (!(0, import_service_helpers.isAssociationField)(field)) {
+    return "";
+  }
+  if (!relationCanStoreForeignKeyInCurrentCollection(field)) {
+    return "";
+  }
+  return String((field == null ? void 0 : field.foreignKey) || ((_a = field == null ? void 0 : field.options) == null ? void 0 : _a.foreignKey) || "").trim();
+}
+function relationCanStoreForeignKeyInCurrentCollection(field) {
+  const type = String((0, import_service_helpers.getFieldType)(field) || "").trim().toLowerCase();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(field) || "").trim().toLowerCase();
+  if (RELATION_TYPES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION.has(type) || RELATION_INTERFACES_WITH_FOREIGN_KEYS_OUTSIDE_CURRENT_COLLECTION.has(fieldInterface)) {
+    return false;
+  }
+  return CURRENT_COLLECTION_FOREIGN_KEY_RELATION_TYPES.has(type) || CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES.has(fieldInterface) || CONDITIONAL_CURRENT_COLLECTION_FOREIGN_KEY_RELATION_INTERFACES.has(fieldInterface);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectRelationBackingForeignKeyNames,
+  isRelationBackingForeignKeyField
+});

package/dist/server/flow-surfaces/runjs-authoring/ast/source.d.ts

@@ -23,6 +23,7 @@ export declare function getPreviousSignificantTokenInfo(sourceLike: string | str
 export declare function skipQuotedLiteral(source: string, start: number, quote: string): number;
 export declare function skipTemplateLiteral(source: string, start: number): number;
 export declare function findFunctionRanges(masked: string): SourceRange[];
+export declare function collectAstFunctionBodyRanges(ast: unknown): SourceRange[];
 export declare function collectFunctionRanges(masked: string, pattern: RegExp, ranges: SourceRange[]): void;
 export declare function collectArrowExpressionRanges(masked: string, ranges: SourceRange[]): void;
 export declare function collectMethodFunctionRanges(masked: string, ranges: SourceRange[]): void;

package/dist/server/flow-surfaces/runjs-authoring/ast/source.js

@@ -27,6 +27,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var source_exports = {};
 __export(source_exports, {
   collectArrowExpressionRanges: () => collectArrowExpressionRanges,
+  collectAstFunctionBodyRanges: () => collectAstFunctionBodyRanges,
   collectBraceRanges: () => collectBraceRanges,
   collectComputedMethodCandidates: () => collectComputedMethodCandidates,
   collectFunctionRanges: () => collectFunctionRanges,
@@ -69,6 +70,7 @@ __export(source_exports, {
 });
 module.exports = __toCommonJS(source_exports);
 var import_constants = require("../runtime/constants");
+var import_walk = require("./walk");
 function maskJavaScriptSource(source) {
   const chars = source.split("");
   const maskRange = (start, end) => {
@@ -406,6 +408,23 @@ function findFunctionRanges(masked) {
   collectMethodFunctionRanges(masked, ranges);
   return mergeRanges(ranges);
 }
+function collectAstFunctionBodyRanges(ast) {
+  const ranges = [];
+  const addBodyRange = (node) => {
+    var _a, _b;
+    const start = (_a = node.body) == null ? void 0 : _a.start;
+    const end = (_b = node.body) == null ? void 0 : _b.end;
+    if (typeof start === "number" && typeof end === "number" && end > start) {
+      ranges.push({ start, end });
+    }
+  };
+  (0, import_walk.walkAstSimple)(ast, {
+    FunctionDeclaration: addBodyRange,
+    FunctionExpression: addBodyRange,
+    ArrowFunctionExpression: addBodyRange
+  });
+  return mergeRanges(ranges);
+}
 function collectFunctionRanges(masked, pattern, ranges) {
   for (const match of masked.matchAll(pattern)) {
     const openBrace = masked.indexOf("{", match.index || 0);
@@ -853,6 +872,7 @@ function getAstSource(node, source) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   collectArrowExpressionRanges,
+  collectAstFunctionBodyRanges,
   collectBraceRanges,
   collectComputedMethodCandidates,
   collectFunctionRanges,

package/dist/server/flow-surfaces/runjs-authoring/rules.js

@@ -32,7 +32,6 @@ __export(rules_exports, {
 });
 module.exports = __toCommonJS(rules_exports);
 var import_blocked_capability_reroute = require("./blocked-capability-reroute");
-var import_blocked_global_stop = require("./blocked-global-stop");
 var import_ctx_libs_member_mismatch_stop = require("./ctx-libs-member-mismatch-stop");
 var import_ctx_root_mismatch_stop = require("./ctx-root-mismatch-stop");
 var import_missing_top_level_return = require("./missing-top-level-return");
@@ -61,7 +60,6 @@ const RUNJS_AUTHORING_RULES = [
   import_replace_innerhtml_with_render.replaceInnerHtmlWithRenderRule,
   import_render_top_level_function_wrapper.renderTopLevelFunctionWrapperRule,
   import_render_unreachable_render_call.renderUnreachableRenderCallRule,
-  import_blocked_global_stop.blockedGlobalStopRule,
   import_unknown_global_stop.unknownGlobalStopRule,
   import_blocked_capability_reroute.blockedCapabilityRerouteRule,
   import_react_runtime_contract_stop.reactRuntimeContractStopRule,

package/dist/server/flow-surfaces/runjs-authoring/runtime/constants.d.ts

@@ -21,7 +21,6 @@ export declare const BLOCKED_CTX_CAPABILITIES: Record<string, {
     capability: string;
     reroute: string;
 }>;
-export declare const FORBIDDEN_BARE_GLOBALS: Set<string>;
 export declare const RUNJS_ALLOWED_BARE_GLOBALS: Set<string>;
 export declare const RUNJS_ALLOWED_BARE_GLOBALS_BY_MODEL_USE: Record<string, Set<string>>;
 export declare const NON_METHOD_CALL_KEYWORDS: Set<string>;

package/dist/server/flow-surfaces/runjs-authoring/runtime/constants.js

@@ -50,7 +50,6 @@ __export(constants_exports, {
   FLOW_RESOURCE_CLASS_NAMES: () => FLOW_RESOURCE_CLASS_NAMES,
   FLOW_RESOURCE_METHODS_BY_TYPE: () => FLOW_RESOURCE_METHODS_BY_TYPE,
   FLOW_RESOURCE_METHOD_SUGGESTIONS: () => FLOW_RESOURCE_METHOD_SUGGESTIONS,
-  FORBIDDEN_BARE_GLOBALS: () => FORBIDDEN_BARE_GLOBALS,
   INIT_RESOURCE_CLASS_NAMES: () => INIT_RESOURCE_CLASS_NAMES,
   KNOWN_MODEL_USES: () => KNOWN_MODEL_USES,
   MAX_RUNJS_ERRORS_PER_SOURCE: () => MAX_RUNJS_ERRORS_PER_SOURCE,
@@ -224,7 +223,12 @@ const ALLOWED_CTX_ROOTS = /* @__PURE__ */ new Set([
 ]);
 const CHART_CTX_ROOTS = /* @__PURE__ */ new Set(["data"]);
 const BLOCKED_CTX_CAPABILITIES = {};
-const FORBIDDEN_BARE_GLOBALS = /* @__PURE__ */ new Set([
+const RUNJS_ALLOWED_BARE_GLOBALS = /* @__PURE__ */ new Set([
+  "ctx",
+  "console",
+  "window",
+  "document",
+  "navigator",
   "fetch",
   "localStorage",
   "sessionStorage",
@@ -237,22 +241,6 @@ const FORBIDDEN_BARE_GLOBALS = /* @__PURE__ */ new Set([
   "EventSource",
   "indexedDB",
   "caches",
-  "Function",
-  "eval",
-  "globalThis",
-  "Intl",
-  "process",
-  "require",
-  "module",
-  "exports",
-  "location"
-]);
-const RUNJS_ALLOWED_BARE_GLOBALS = /* @__PURE__ */ new Set([
-  "ctx",
-  "console",
-  "window",
-  "document",
-  "navigator",
   "setTimeout",
   "clearTimeout",
   "setInterval",
@@ -296,9 +284,14 @@ const RUNJS_ALLOWED_BARE_GLOBALS = /* @__PURE__ */ new Set([
   "WeakMap",
   "WeakRef",
   "WeakSet",
+  "Function",
+  "eval",
+  "globalThis",
+  "Intl",
   "JSON",
   "Blob",
   "URL",
+  "location",
   "decodeURI",
   "decodeURIComponent",
   "encodeURI",
@@ -714,7 +707,6 @@ function escapeRegExp(value) {
   FLOW_RESOURCE_CLASS_NAMES,
   FLOW_RESOURCE_METHODS_BY_TYPE,
   FLOW_RESOURCE_METHOD_SUGGESTIONS,
-  FORBIDDEN_BARE_GLOBALS,
   INIT_RESOURCE_CLASS_NAMES,
   KNOWN_MODEL_USES,
   MAX_RUNJS_ERRORS_PER_SOURCE,

package/dist/server/flow-surfaces/runjs-authoring/runtime/types.d.ts

@@ -40,9 +40,6 @@ export type RunJsScanResult = RunJsAstInspection & {
         match: string;
     }>;
     dynamicCtxAccesses: IndexedEntry[];
-    forbiddenBareGlobals: Array<IndexedEntry & {
-        name: string;
-    }>;
     functionRanges: SourceRange[];
     invalidCtxLibMemberAccesses: InvalidCtxLibMemberAccess[];
     invalidReactRuntimeBindings: InvalidReactRuntimeBinding[];
@@ -65,15 +62,6 @@ export type RunJsScanResult = RunJsAstInspection & {
     }>;
     topLevelReturns: IndexedEntry[];
     unboundReactCreateElementCalls: IndexedEntry[];
-    windowDocumentNavigatorAliases: Array<{
-        alias: string;
-        index: number;
-        root: string;
-    }>;
-    windowDocumentNavigatorUses: Array<IndexedEntry & {
-        member: string;
-        root: string;
-    }>;
 };
 export type RunJsInspectionRuntime = {
     context: RunJsAuthoringContext;

package/dist/server/flow-surfaces/runjs-authoring/scan/filter.js

@@ -900,7 +900,13 @@ function buildRunJsResourceFilterOperatorError(operator, index, input) {
   };
 }
 function buildRunJsResourceDateFilterValueError(operator, index, valueNode, input) {
-  if (!isRunJsDateFilterOperator(operator)) {
+  const fieldType = String((0, import_service_helpers.getFieldType)(input.field) || "").trim();
+  const fieldInterface = String((0, import_service_helpers.getFieldInterface)(input.field) || "").trim();
+  const shouldValidateDateValue = isRunJsDateFilterOperator(operator) || (0, import_filter_group.isFlowSurfaceDateLikeFieldMeta)({
+    type: fieldType,
+    interface: fieldInterface
+  });
+  if (!shouldValidateDateValue) {
     return null;
   }
   const valueObject = resolveRunJsStaticFilterObjectNode(
@@ -924,7 +930,11 @@ function buildRunJsResourceDateFilterValueError(operator, index, valueNode, inpu
     return null;
   }
   try {
-    (0, import_filter_group.normalizeFlowSurfaceStrictFilterDateValue)(operator, resolvedValue.value, `${input.fieldPath}.${operator}`);
+    (0, import_filter_group.normalizeFlowSurfaceDateConditionValue)(operator, resolvedValue.value, `${input.fieldPath}.${operator}`, {
+      fieldPath: input.fieldPath,
+      fieldType,
+      fieldInterface
+    });
     return null;
   } catch (error) {
     return buildRunJsStrictDateFilterValueError(operator, index, resolvedValue.value, input, error);

package/dist/server/flow-surfaces/runjs-authoring/scan/index.d.ts

@@ -149,16 +149,6 @@ export declare function scanJavaScriptSource(source: string, ast?: any, context?
         alias: string;
         index: number;
     }[];
-    windowDocumentNavigatorUses: {
-        root: string;
-        member: string;
-        index: number;
-    }[];
-    windowDocumentNavigatorAliases: {
-        alias: string;
-        root: string;
-        index: number;
-    }[];
     ctxAliases: {
         alias: string;
         index: number;
@@ -179,10 +169,6 @@ export declare function scanJavaScriptSource(source: string, ast?: any, context?
         ruleId: "runjs-ctx-member-not-callable";
     }[];
     invalidCtxLibMemberAccesses: import("../internal-types").InvalidCtxLibMemberAccess[];
-    forbiddenBareGlobals: {
-        name: string;
-        index: number;
-    }[];
     ctxMemberAccesses: {
         member: string;
         index: number;