@nocobase/plugin-flow-engine 2.0.0-alpha.2

package/dist/node_modules/ses/src/error/tame-error-constructor.js

@@ -0,0 +1,284 @@
+import {
+  FERAL_ERROR,
+  apply,
+  construct,
+  defineProperties,
+  setPrototypeOf,
+  getOwnPropertyDescriptor,
+  defineProperty,
+  getOwnPropertyDescriptors,
+} from '../commons.js';
+import { NativeErrors } from '../permits.js';
+import { tameV8ErrorConstructor } from './tame-v8-error-constructor.js';
+
+// Present on at least FF and XS. Proposed by Error-proposal. The original
+// is dangerous, so tameErrorConstructor replaces it with a safe one.
+// We grab the original here before it gets replaced.
+const stackDesc = getOwnPropertyDescriptor(FERAL_ERROR.prototype, 'stack');
+const stackGetter = stackDesc && stackDesc.get;
+
+// Use concise methods to obtain named functions without constructors.
+const tamedMethods = {
+  getStackString(error) {
+    if (typeof stackGetter === 'function') {
+      return apply(stackGetter, error, []);
+    } else if ('stack' in error) {
+      // The fallback is to just use the de facto `error.stack` if present
+      return `${error.stack}`;
+    }
+    return '';
+  },
+};
+let initialGetStackString = tamedMethods.getStackString;
+
+export default function tameErrorConstructor(
+  errorTaming = 'safe',
+  stackFiltering = 'concise',
+) {
+  const ErrorPrototype = FERAL_ERROR.prototype;
+
+  const { captureStackTrace: originalCaptureStackTrace } = FERAL_ERROR;
+  const platform =
+    typeof originalCaptureStackTrace === 'function' ? 'v8' : 'unknown';
+
+  const makeErrorConstructor = (_ = {}) => {
+    // eslint-disable-next-line no-shadow
+    const ResultError = function Error(...rest) {
+      let error;
+      if (new.target === undefined) {
+        error = apply(FERAL_ERROR, this, rest);
+      } else {
+        error = construct(FERAL_ERROR, rest, new.target);
+      }
+      if (platform === 'v8') {
+        // TODO Likely expensive!
+        apply(originalCaptureStackTrace, FERAL_ERROR, [error, ResultError]);
+      }
+      return error;
+    };
+    defineProperties(ResultError, {
+      length: { value: 1 },
+      prototype: {
+        value: ErrorPrototype,
+        writable: false,
+        enumerable: false,
+        configurable: false,
+      },
+    });
+    return ResultError;
+  };
+  const InitialError = makeErrorConstructor({ powers: 'original' });
+  const SharedError = makeErrorConstructor({ powers: 'none' });
+  defineProperties(ErrorPrototype, {
+    constructor: { value: SharedError },
+  });
+
+  for (const NativeError of NativeErrors) {
+    setPrototypeOf(NativeError, SharedError);
+  }
+
+  // https://v8.dev/docs/stack-trace-api#compatibility advises that
+  // programmers can "always" set `Error.stackTraceLimit`
+  // even on non-v8 platforms. On non-v8
+  // it will have no effect, but this advice only makes sense
+  // if the assignment itself does not fail, which it would
+  // if `Error` were naively frozen. Hence, we add setters that
+  // accept but ignore the assignment on non-v8 platforms.
+  defineProperties(InitialError, {
+    stackTraceLimit: {
+      get() {
+        if (typeof FERAL_ERROR.stackTraceLimit === 'number') {
+          // FERAL_ERROR.stackTraceLimit is only on v8
+          return FERAL_ERROR.stackTraceLimit;
+        }
+        return undefined;
+      },
+      set(newLimit) {
+        if (typeof newLimit !== 'number') {
+          // silently do nothing. This behavior doesn't precisely
+          // emulate v8 edge-case behavior. But given the purpose
+          // of this emulation, having edge cases err towards
+          // harmless seems the safer option.
+          return;
+        }
+        if (typeof FERAL_ERROR.stackTraceLimit === 'number') {
+          // FERAL_ERROR.stackTraceLimit is only on v8
+          FERAL_ERROR.stackTraceLimit = newLimit;
+          // We place the useless return on the next line to ensure
+          // that anything we place after the if in the future only
+          // happens if the then-case does not.
+          // eslint-disable-next-line no-useless-return
+          return;
+        }
+      },
+      // WTF on v8 stackTraceLimit is enumerable
+      enumerable: false,
+      configurable: true,
+    },
+  });
+
+  if (errorTaming === 'unsafe-debug' && platform === 'v8') {
+    // This case is a kludge to work around
+    // https://github.com/endojs/endo/issues/1798
+    // https://github.com/endojs/endo/issues/2348
+    // https://github.com/Agoric/agoric-sdk/issues/8662
+
+    defineProperties(InitialError, {
+      prepareStackTrace: {
+        get() {
+          return FERAL_ERROR.prepareStackTrace;
+        },
+        set(newPrepareStackTrace) {
+          FERAL_ERROR.prepareStackTrace = newPrepareStackTrace;
+        },
+        enumerable: false,
+        configurable: true,
+      },
+      captureStackTrace: {
+        value: FERAL_ERROR.captureStackTrace,
+        writable: true,
+        enumerable: false,
+        configurable: true,
+      },
+    });
+
+    const descs = getOwnPropertyDescriptors(InitialError);
+    defineProperties(SharedError, {
+      stackTraceLimit: descs.stackTraceLimit,
+      prepareStackTrace: descs.prepareStackTrace,
+      captureStackTrace: descs.captureStackTrace,
+    });
+
+    return {
+      '%InitialGetStackString%': initialGetStackString,
+      '%InitialError%': InitialError,
+      '%SharedError%': SharedError,
+    };
+  }
+
+  // The default SharedError much be completely powerless even on v8,
+  // so the lenient `stackTraceLimit` accessor does nothing on all
+  // platforms.
+  defineProperties(SharedError, {
+    stackTraceLimit: {
+      get() {
+        return undefined;
+      },
+      set(_newLimit) {
+        // do nothing
+      },
+      enumerable: false,
+      configurable: true,
+    },
+  });
+
+  if (platform === 'v8') {
+    // `SharedError.prepareStackTrace`, if it exists, must also be
+    // powerless. However, from what we've heard, depd expects to be able to
+    // assign to it without the assignment throwing. It is normally a function
+    // that returns a stack string to be magically added to error objects.
+    // However, as long as we're adding a lenient standin, we may as well
+    // accommodate any who expect to get a function they can call and get
+    // a string back. This prepareStackTrace is a do-nothing function that
+    // always returns the empty string.
+    defineProperties(SharedError, {
+      prepareStackTrace: {
+        get() {
+          return () => '';
+        },
+        set(_prepareFn) {
+          // do nothing
+        },
+        enumerable: false,
+        configurable: true,
+      },
+      captureStackTrace: {
+        value: (errorish, _constructorOpt) => {
+          defineProperty(errorish, 'stack', {
+            value: '',
+          });
+        },
+        writable: false,
+        enumerable: false,
+        configurable: true,
+      },
+    });
+  }
+
+  if (platform === 'v8') {
+    initialGetStackString = tameV8ErrorConstructor(
+      FERAL_ERROR,
+      InitialError,
+      errorTaming,
+      stackFiltering,
+    );
+  } else if (errorTaming === 'unsafe' || errorTaming === 'unsafe-debug') {
+    // v8 has too much magic around their 'stack' own property for it to
+    // coexist cleanly with this accessor. So only install it on non-v8
+
+    // Error.prototype.stack property as proposed at
+    // https://tc39.es/proposal-error-stacks/
+    // with the fix proposed at
+    // https://github.com/tc39/proposal-error-stacks/issues/46
+    // On others, this still protects from the override mistake,
+    // essentially like enable-property-overrides.js would
+    // once this accessor property itself is frozen, as will happen
+    // later during lockdown.
+    //
+    // However, there is here a change from the intent in the current
+    // state of the proposal. If experience tells us whether this change
+    // is a good idea, we should modify the proposal accordingly. There is
+    // much code in the world that assumes `error.stack` is a string. So
+    // where the proposal accommodates secure operation by making the
+    // property optional, we instead accommodate secure operation by
+    // having the secure form always return only the stable part, the
+    // stringified error instance, and omitting all the frame information
+    // rather than omitting the property.
+    defineProperties(ErrorPrototype, {
+      stack: {
+        get() {
+          return initialGetStackString(this);
+        },
+        set(newValue) {
+          defineProperties(this, {
+            stack: {
+              value: newValue,
+              writable: true,
+              enumerable: true,
+              configurable: true,
+            },
+          });
+        },
+      },
+    });
+  } else {
+    // v8 has too much magic around their 'stack' own property for it to
+    // coexist cleanly with this accessor. So only install it on non-v8
+    defineProperties(ErrorPrototype, {
+      stack: {
+        get() {
+          // https://github.com/tc39/proposal-error-stacks/issues/46
+          // allows this to not add an unpleasant newline. Otherwise
+          // we should fix this.
+          return `${this}`;
+        },
+        set(newValue) {
+          defineProperties(this, {
+            stack: {
+              value: newValue,
+              writable: true,
+              enumerable: true,
+              configurable: true,
+            },
+          });
+        },
+      },
+    });
+  }
+
+  return {
+    '%InitialGetStackString%': initialGetStackString,
+    '%InitialError%': InitialError,
+    '%SharedError%': SharedError,
+  };
+}

package/dist/node_modules/ses/src/error/tame-v8-error-constructor.js

@@ -0,0 +1,386 @@
+import {
+  WeakMap,
+  WeakSet,
+  apply,
+  arrayFilter,
+  arrayJoin,
+  arrayMap,
+  arraySlice,
+  create,
+  defineProperties,
+  fromEntries,
+  reflectSet,
+  regexpExec,
+  regexpTest,
+  weakmapGet,
+  weakmapSet,
+  weaksetAdd,
+  weaksetHas,
+  TypeError,
+} from '../commons.js';
+
+// Permit names from https://v8.dev/docs/stack-trace-api
+// Permiting only the names used by error-stack-shim/src/v8StackFrames
+// callSiteToFrame to shim the error stack proposal.
+const safeV8CallSiteMethodNames = [
+  // suppress 'getThis' definitely
+  'getTypeName',
+  // suppress 'getFunction' definitely
+  'getFunctionName',
+  'getMethodName',
+  'getFileName',
+  'getLineNumber',
+  'getColumnNumber',
+  'getEvalOrigin',
+  'isToplevel',
+  'isEval',
+  'isNative',
+  'isConstructor',
+  'isAsync',
+  // suppress 'isPromiseAll' for now
+  // suppress 'getPromiseIndex' for now
+
+  // Additional names found by experiment, absent from
+  // https://v8.dev/docs/stack-trace-api
+  'getPosition',
+  'getScriptNameOrSourceURL',
+
+  'toString', // TODO replace to use only permitted info
+];
+
+// TODO this is a ridiculously expensive way to attenuate callsites.
+// Before that matters, we should switch to a reasonable representation.
+const safeV8CallSiteFacet = callSite => {
+  const methodEntry = name => {
+    const method = callSite[name];
+    return [name, () => apply(method, callSite, [])];
+  };
+  const o = fromEntries(arrayMap(safeV8CallSiteMethodNames, methodEntry));
+  return create(o, {});
+};
+
+const safeV8SST = sst => arrayMap(sst, safeV8CallSiteFacet);
+
+// If it has `/node_modules/` anywhere in it, on Node it is likely
+// to be a dependent package of the current package, and so to
+// be an infrastructure frame to be dropped from concise stack traces.
+const FILENAME_NODE_DEPENDENTS_CENSOR = /\/node_modules\//;
+
+// If it begins with `internal/` or `node:internal` then it is likely
+// part of the node infrustructre itself, to be dropped from concise
+// stack traces.
+const FILENAME_NODE_INTERNALS_CENSOR = /^(?:node:)?internal\//;
+
+// Frames within SES `assert.js` should be dropped from concise stack traces, as
+// these are just steps towards creating the error object in question.
+const FILENAME_ASSERT_CENSOR = /\/packages\/ses\/src\/error\/assert\.js$/;
+
+// Frames within the `eventual-send` shim should be dropped so that concise
+// deep stacks omit the internals of the eventual-sending mechanism causing
+// asynchronous messages to be sent.
+// Note that the eventual-send package will move from agoric-sdk to
+// Endo, so this rule will be of general interest.
+const FILENAME_EVENTUAL_SEND_CENSOR = /\/packages\/eventual-send\/src\//;
+
+// Frames within the `ses-ava` package should be dropped from concise stack
+// traces, as they just support exposing error details to AVA.
+const FILENAME_SES_AVA_CENSOR = /\/packages\/ses-ava\/src\/ses-ava-test\.js$/;
+
+// Any stack frame whose `fileName` matches any of these censor patterns
+// will be omitted from concise stacks.
+// TODO Enable users to configure FILENAME_CENSORS via `lockdown` options.
+const FILENAME_CENSORS = [
+  FILENAME_NODE_DEPENDENTS_CENSOR,
+  FILENAME_NODE_INTERNALS_CENSOR,
+  FILENAME_ASSERT_CENSOR,
+  FILENAME_EVENTUAL_SEND_CENSOR,
+  FILENAME_SES_AVA_CENSOR,
+];
+
+// Should a stack frame with this as its fileName be included in a concise
+// stack trace?
+// Exported only so it can be unit tested.
+// TODO Move so that it applies not just to v8.
+export const filterFileName = fileName => {
+  if (!fileName) {
+    // Stack frames with no fileName should appear in concise stack traces.
+    return true;
+  }
+  for (const filter of FILENAME_CENSORS) {
+    if (regexpTest(filter, fileName)) {
+      return false;
+    }
+  }
+  return true;
+};
+
+// The ad-hoc rule of the current pattern is that any likely-file-path or
+// likely url-path prefix, ending in a `/.../` should get dropped.
+// Anything to the left of the likely path text is kept.
+// Everything to the right of `/.../` is kept. Thus
+// `'Object.bar (/vat-v1/.../eventual-send/test/deep-send.test.js:13:21)'`
+// simplifies to
+// `'Object.bar (eventual-send/test/deep-send.test.js:13:21)'`.
+//
+// See thread starting at
+// https://github.com/Agoric/agoric-sdk/issues/2326#issuecomment-773020389
+const CALLSITE_ELLIPSIS_PATTERN1 = /^((?:.*[( ])?)[:/\w_-]*\/\.\.\.\/(.+)$/;
+
+// The ad-hoc rule of the current pattern is that any likely-file-path or
+// likely url-path prefix consisting of `.../` should get dropped.
+// Anything to the left of the likely path text is kept.
+// Everything to the right of `.../` is kept. Thus
+// `'Object.bar (.../eventual-send/test/deep-send.test.js:13:21)'`
+// simplifies to
+// `'Object.bar (eventual-send/test/deep-send.test.js:13:21)'`.
+//
+// See thread starting at
+// https://github.com/Agoric/agoric-sdk/issues/2326#issuecomment-773020389
+const CALLSITE_ELLIPSIS_PATTERN2 = /^((?:.*[( ])?)\.\.\.\/(.+)$/;
+
+// The ad-hoc rule of the current pattern is that any likely-file-path or
+// likely url-path prefix, ending in a `/` and prior to `package/` should get
+// dropped.
+// Anything to the left of the likely path prefix text is kept. `package/` and
+// everything to its right is kept. Thus
+// `'Object.bar (/Users/markmiller/src/ongithub/agoric/agoric-sdk/packages/eventual-send/test/deep-send.test.js:13:21)'`
+// simplifies to
+// `'Object.bar (packages/eventual-send/test/deep-send.test.js:13:21)'`.
+// Note that `/packages/` is a convention for monorepos encouraged by
+// lerna.
+const CALLSITE_PACKAGES_PATTERN = /^((?:.*[( ])?)[:/\w_-]*\/(packages\/.+)$/;
+
+// The ad-hoc rule of the current pattern is that any likely-file-path or
+// likely url-path prefix of the form `file://` but not `file:///` gets
+// dropped.
+// Anything to the left of the likely path prefix text is kept. Everything to
+// the right of `file://` is kept. Thus
+// `'Object.bar (file:///Users/markmiller/src/ongithub/endojs/endo/packages/eventual-send/test/deep-send.test.js:13:21)'` is unchanged but
+// `'Object.bar (file://test/deep-send.test.js:13:21)'`
+
+// simplifies to
+// `'Object.bar (test/deep-send.test.js:13:21)'`.
+// The reason is that `file:///` usually precedes an absolute path which is
+// clickable without removing the `file:///`, whereas `file://` usually precedes
+// a relative path which, for whatever vscode reason, is not clickable until the
+// `file://` is removed.
+const CALLSITE_FILE_2SLASH_PATTERN = /^((?:.*[( ])?)file:\/\/([^/].*)$/;
+
+// The use of these callSite patterns below assumes that any match will bind
+// capture groups containing the parts of the original string we want
+// to keep. The parts outside those capture groups will be dropped from concise
+// stacks.
+// TODO Enable users to configure CALLSITE_PATTERNS via `lockdown` options.
+const CALLSITE_PATTERNS = [
+  CALLSITE_ELLIPSIS_PATTERN1,
+  CALLSITE_ELLIPSIS_PATTERN2,
+  CALLSITE_PACKAGES_PATTERN,
+  CALLSITE_FILE_2SLASH_PATTERN,
+];
+
+// For a stack frame that should be included in a concise stack trace, if
+// `callSiteString` is the original stringified stack frame, return the
+// possibly-shorter stringified stack frame that should be shown instead.
+// Exported only so it can be unit tested.
+// TODO Move so that it applies not just to v8.
+/**
+ * @param {string} callSiteString
+ */
+export const shortenCallSiteString = callSiteString => {
+  for (const filter of CALLSITE_PATTERNS) {
+    const match = regexpExec(filter, callSiteString);
+    if (match) {
+      return arrayJoin(arraySlice(match, 1), '');
+    }
+  }
+  return callSiteString;
+};
+
+export const tameV8ErrorConstructor = (
+  OriginalError,
+  InitialError,
+  errorTaming,
+  stackFiltering,
+) => {
+  if (errorTaming === 'unsafe-debug') {
+    throw TypeError(
+      'internal: v8+unsafe-debug special case should already be done',
+    );
+  }
+  // TODO: Proper CallSite types
+  /** @typedef {{}} CallSite */
+
+  const originalCaptureStackTrace = OriginalError.captureStackTrace;
+
+  const omitFrames =
+    stackFiltering === 'concise' || stackFiltering === 'omit-frames';
+
+  const shortenPaths =
+    stackFiltering === 'concise' || stackFiltering === 'shorten-paths';
+
+  // const callSiteFilter = _callSite => true;
+  const callSiteFilter = callSite => {
+    if (omitFrames) {
+      // eslint-disable-next-line @endo/no-polymorphic-call
+      return filterFileName(callSite.getFileName());
+    }
+    return true;
+  };
+
+  const callSiteStringifier = callSite => {
+    let callSiteString = `${callSite}`;
+    if (shortenPaths) {
+      callSiteString = shortenCallSiteString(callSiteString);
+    }
+    return `\n  at ${callSiteString}`;
+  };
+
+  const stackStringFromSST = (_error, sst) =>
+    arrayJoin(
+      arrayMap(arrayFilter(sst, callSiteFilter), callSiteStringifier),
+      '',
+    );
+
+  /**
+   * @typedef {object} StructuredStackInfo
+   * @property {CallSite[]} callSites
+   * @property {undefined} [stackString]
+   */
+
+  /**
+   * @typedef {object} ParsedStackInfo
+   * @property {undefined} [callSites]
+   * @property {string} stackString
+   */
+
+  // Mapping from error instance to the stack for that instance.
+  // The stack info is either the structured stack trace
+  // or the generated tamed stack string
+  /** @type {WeakMap<Error, ParsedStackInfo | StructuredStackInfo>} */
+  const stackInfos = new WeakMap();
+
+  // Use concise methods to obtain named functions without constructors.
+  const tamedMethods = {
+    // The optional `optFn` argument is for cutting off the bottom of
+    // the stack --- for capturing the stack only above the topmost
+    // call to that function. Since this isn't the "real" captureStackTrace
+    // but instead calls the real one, if no other cutoff is provided,
+    // we cut this one off.
+    captureStackTrace(error, optFn = tamedMethods.captureStackTrace) {
+      if (typeof originalCaptureStackTrace === 'function') {
+        // OriginalError.captureStackTrace is only on v8
+        apply(originalCaptureStackTrace, OriginalError, [error, optFn]);
+        return;
+      }
+      reflectSet(error, 'stack', '');
+    },
+    // Shim of proposed special power, to reside by default only
+    // in the start compartment, for getting the stack traceback
+    // string associated with an error.
+    // See https://tc39.es/proposal-error-stacks/
+    getStackString(error) {
+      let stackInfo = weakmapGet(stackInfos, error);
+
+      if (stackInfo === undefined) {
+        // The following will call `prepareStackTrace()` synchronously
+        // which will populate stackInfos
+        // eslint-disable-next-line no-void
+        void error.stack;
+        stackInfo = weakmapGet(stackInfos, error);
+        if (!stackInfo) {
+          stackInfo = { stackString: '' };
+          weakmapSet(stackInfos, error, stackInfo);
+        }
+      }
+
+      // prepareStackTrace() may generate the stackString
+      // if errorTaming === 'unsafe'
+
+      if (stackInfo.stackString !== undefined) {
+        return stackInfo.stackString;
+      }
+
+      const stackString = stackStringFromSST(error, stackInfo.callSites);
+      weakmapSet(stackInfos, error, { stackString });
+
+      return stackString;
+    },
+    prepareStackTrace(error, sst) {
+      if (errorTaming === 'unsafe') {
+        const stackString = stackStringFromSST(error, sst);
+        weakmapSet(stackInfos, error, { stackString });
+        return `${error}${stackString}`;
+      } else {
+        weakmapSet(stackInfos, error, { callSites: sst });
+        return '';
+      }
+    },
+  };
+
+  // A prepareFn is a prepareStackTrace function.
+  // An sst is a `structuredStackTrace`, which is an array of
+  // callsites.
+  // A user prepareFn is a prepareFn defined by a client of this API,
+  // and provided by assigning to `Error.prepareStackTrace`.
+  // A user prepareFn should only receive an attenuated sst, which
+  // is an array of attenuated callsites.
+  // A system prepareFn is the prepareFn created by this module to
+  // be installed on the real `Error` constructor, to receive
+  // an original sst, i.e., an array of unattenuated callsites.
+  // An input prepareFn is a function the user assigns to
+  // `Error.prepareStackTrace`, which might be a user prepareFn or
+  // a system prepareFn previously obtained by reading
+  // `Error.prepareStackTrace`.
+
+  const defaultPrepareFn = tamedMethods.prepareStackTrace;
+
+  OriginalError.prepareStackTrace = defaultPrepareFn;
+
+  // A weakset branding some functions as system prepareFns, all of which
+  // must be defined by this module, since they can receive an
+  // unattenuated sst.
+  const systemPrepareFnSet = new WeakSet([defaultPrepareFn]);
+
+  const systemPrepareFnFor = inputPrepareFn => {
+    if (weaksetHas(systemPrepareFnSet, inputPrepareFn)) {
+      return inputPrepareFn;
+    }
+    // Use concise methods to obtain named functions without constructors.
+    const systemMethods = {
+      prepareStackTrace(error, sst) {
+        weakmapSet(stackInfos, error, { callSites: sst });
+        return inputPrepareFn(error, safeV8SST(sst));
+      },
+    };
+    weaksetAdd(systemPrepareFnSet, systemMethods.prepareStackTrace);
+    return systemMethods.prepareStackTrace;
+  };
+
+  // Note `stackTraceLimit` accessor already defined by
+  // tame-error-constructor.js
+  defineProperties(InitialError, {
+    captureStackTrace: {
+      value: tamedMethods.captureStackTrace,
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    },
+    prepareStackTrace: {
+      get() {
+        return OriginalError.prepareStackTrace;
+      },
+      set(inputPrepareStackTraceFn) {
+        if (typeof inputPrepareStackTraceFn === 'function') {
+          const systemPrepareFn = systemPrepareFnFor(inputPrepareStackTraceFn);
+          OriginalError.prepareStackTrace = systemPrepareFn;
+        } else {
+          OriginalError.prepareStackTrace = defaultPrepareFn;
+        }
+      },
+      enumerable: false,
+      configurable: true,
+    },
+  });
+
+  return tamedMethods.getStackString;
+};