@nocobase/plugin-field-sort 1.5.0-alpha.1

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/lib/wrap-middleware.js

@@ -0,0 +1,63 @@
+/**
+ * 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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 wrap_middleware_exports = {};
+__export(wrap_middleware_exports, {
+  wrapMiddlewareWithLogging: () => wrapMiddlewareWithLogging
+});
+module.exports = __toCommonJS(wrap_middleware_exports);
+function wrapMiddlewareWithLogging(fn, logger) {
+  if (process.env["LOGGER_LEVEL"] !== "trace") {
+    return fn;
+  }
+  const name = fn.name || fn.toString().slice(0, 100);
+  return async (ctx, next) => {
+    const reqId = ctx.reqId;
+    if (!logger && !ctx.logger) {
+      return await fn(ctx, next);
+    }
+    if (!logger && ctx.logger) {
+      logger = ctx.logger;
+    }
+    logger.trace(`--> Entering middleware: ${name}`, { reqId });
+    const start = Date.now();
+    await fn(ctx, async () => {
+      const beforeNext = Date.now();
+      logger.trace(`--> Before next middleware: ${name} - ${beforeNext - start}ms`, { reqId });
+      await next();
+      const afterNext = Date.now();
+      logger.trace(`<-- After next middleware: ${name} - ${afterNext - beforeNext}ms`, { reqId });
+    });
+    const ms = Date.now() - start;
+    logger.trace(`<-- Exiting middleware: ${name} - ${ms}ms`, { reqId });
+  };
+}
+__name(wrapMiddlewareWithLogging, "wrapMiddlewareWithLogging");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wrapMiddlewareWithLogging
+});

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@nocobase/utils",
+  "version": "1.4.0-alpha.11",
+  "main": "lib/index.js",
+  "types": "./lib/index.d.ts",
+  "license": "AGPL-3.0",
+  "dependencies": {
+    "@budibase/handlebars-helpers": "^0.14.0",
+    "@hapi/topo": "^6.0.0",
+    "@rc-component/mini-decimal": "^1.1.0",
+    "dayjs": "^1.11.9",
+    "deepmerge": "^4.2.2",
+    "flat-to-nested": "^1.1.1",
+    "graphlib": "^2.1.8",
+    "handlebars": "^4.7.8",
+    "multer": "^1.4.5-lts.1",
+    "object-path": "^0.11.8"
+  },
+  "gitHead": "621ac1788ae0622813b98c2f82f5f524067a792c"
+}

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/plugin-symlink.d.ts

@@ -0,0 +1,6 @@
+export declare function getStoragePluginNames(target: any): Promise<any[]>;
+export declare function fsExists(path: any): Promise<boolean>;
+export declare function createStoragePluginSymLink(pluginName: any): Promise<void>;
+export declare function createStoragePluginsSymlink(): Promise<void>;
+export declare function createDevPluginSymLink(pluginName: any): Promise<void>;
+export declare function createDevPluginsSymlink(): Promise<void>;

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/plugin-symlink.js

@@ -0,0 +1,102 @@
+const { dirname, resolve } = require('path');
+const { realpath, readFile, writeFile, readdir, symlink, unlink, mkdir, stat } = require('fs').promises;
+
+async function getStoragePluginNames(target) {
+  const plugins = [];
+  const items = await readdir(target);
+  for (const item of items) {
+    if (item.startsWith('@')) {
+      const children = await getStoragePluginNames(resolve(target, item));
+      plugins.push(
+        ...children.map((child) => {
+          return `${item}/${child}`;
+        }),
+      );
+    } else if (await fsExists(resolve(target, item, 'package.json'))) {
+      plugins.push(item);
+    }
+  }
+  return plugins;
+}
+
+async function fsExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+exports.fsExists = fsExists;
+
+async function createStoragePluginSymLink(pluginName) {
+  const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
+  const nodeModulesPath = process.env.NODE_MODULES_PATH; // resolve(dirname(require.resolve('@nocobase/server/package.json')), 'node_modules');
+  // const nodeModulesPath = resolve(process.cwd(), 'node_modules');
+  try {
+    if (pluginName.startsWith('@')) {
+      const [orgName] = pluginName.split('/');
+      if (!(await fsExists(resolve(nodeModulesPath, orgName)))) {
+        await mkdir(resolve(nodeModulesPath, orgName), { recursive: true });
+      }
+    }
+    const link = resolve(nodeModulesPath, pluginName);
+    if (await fsExists(link)) {
+      await unlink(link);
+    }
+    await symlink(resolve(storagePluginsPath, pluginName), link, 'dir');
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+exports.createStoragePluginSymLink = createStoragePluginSymLink;
+
+async function createStoragePluginsSymlink() {
+  const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
+  if (!(await fsExists(storagePluginsPath))) {
+    return;
+  }
+  const pluginNames = await getStoragePluginNames(storagePluginsPath);
+  await Promise.all(pluginNames.map((pluginName) => createStoragePluginSymLink(pluginName)));
+}
+
+exports.createStoragePluginsSymlink = createStoragePluginsSymlink;
+
+async function createDevPluginSymLink(pluginName) {
+  const packagePluginsPath = resolve(process.cwd(), 'packages/plugins');
+  const nodeModulesPath = process.env.NODE_MODULES_PATH; // resolve(dirname(require.resolve('@nocobase/server/package.json')), 'node_modules');
+  try {
+    if (pluginName.startsWith('@')) {
+      const [orgName] = pluginName.split('/');
+      if (!(await fsExists(resolve(nodeModulesPath, orgName)))) {
+        await mkdir(resolve(nodeModulesPath, orgName), { recursive: true });
+      }
+    }
+    const link = resolve(nodeModulesPath, pluginName);
+    if (await fsExists(link)) {
+      const real = await realpath(link);
+      if (real === resolve(packagePluginsPath, pluginName)) {
+        return;
+      }
+      await unlink(link);
+    }
+    await symlink(resolve(packagePluginsPath, pluginName), link, 'dir');
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+exports.createDevPluginSymLink = createDevPluginSymLink;
+
+async function createDevPluginsSymlink() {
+  const storagePluginsPath = resolve(process.cwd(), 'packages/plugins');
+  if (!(await fsExists(storagePluginsPath))) {
+    return;
+  }
+  const pluginNames = await getStoragePluginNames(storagePluginsPath);
+  await Promise.all(pluginNames.map((pluginName) => createDevPluginSymLink(pluginName)));
+}
+
+exports.createDevPluginsSymlink = createDevPluginsSymlink;

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/server.d.ts

@@ -0,0 +1,2 @@
+// @ts-nocheck
+export * from './lib/server';

package/dist/node_modules/@nocobase/lock-manager/node_modules/@nocobase/utils/server.js

@@ -0,0 +1,12 @@
+var _useExportServer = require("./lib/server");
+
+Object.keys(_useExportServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _useExportServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useExportServer[key];
+    }
+  });
+});

package/dist/node_modules/@nocobase/lock-manager/node_modules/busboy/.eslintrc.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  extends: '@mscdex/eslint-config',
+};

package/dist/node_modules/@nocobase/lock-manager/node_modules/busboy/.github/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+
+jobs:
+  tests-linux:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [10.16.0, 10.x, 12.x, 14.x, 16.x]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install module
+        run: npm install
+      - name: Run tests
+        run: npm test

package/dist/node_modules/@nocobase/lock-manager/node_modules/busboy/.github/workflows/lint.yml

@@ -0,0 +1,23 @@
+name: lint
+
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+
+env:
+  NODE_VERSION: 16.x
+
+jobs:
+  lint-js:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ env.NODE_VERSION }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+      - name: Install ESLint + ESLint configs/plugins
+        run: npm install --only=dev
+      - name: Lint files
+        run: npm run lint

package/dist/node_modules/@nocobase/lock-manager/node_modules/busboy/bench/bench-multipart-fields-100mb-big.js

@@ -0,0 +1,149 @@
+'use strict';
+
+function createMultipartBuffers(boundary, sizes) {
+  const bufs = [];
+  for (let i = 0; i < sizes.length; ++i) {
+    const mb = sizes[i] * 1024 * 1024;
+    bufs.push(Buffer.from([
+      `--${boundary}`,
+      `content-disposition: form-data; name="field${i + 1}"`,
+      '',
+      '0'.repeat(mb),
+      '',
+    ].join('\r\n')));
+  }
+  bufs.push(Buffer.from([
+    `--${boundary}--`,
+    '',
+  ].join('\r\n')));
+  return bufs;
+}
+
+const boundary = '-----------------------------168072824752491622650073';
+const buffers = createMultipartBuffers(boundary, [
+  10,
+  10,
+  10,
+  20,
+  50,
+]);
+const calls = {
+  partBegin: 0,
+  headerField: 0,
+  headerValue: 0,
+  headerEnd: 0,
+  headersEnd: 0,
+  partData: 0,
+  partEnd: 0,
+  end: 0,
+};
+
+const moduleName = process.argv[2];
+switch (moduleName) {
+  case 'busboy': {
+    const busboy = require('busboy');
+
+    const parser = busboy({
+      limits: {
+        fieldSizeLimit: Infinity,
+      },
+      headers: {
+        'content-type': `multipart/form-data; boundary=${boundary}`,
+      },
+    });
+    parser.on('field', (name, val, info) => {
+      ++calls.partBegin;
+      ++calls.partData;
+      ++calls.partEnd;
+    }).on('close', () => {
+      ++calls.end;
+      console.timeEnd(moduleName);
+    });
+
+    console.time(moduleName);
+    for (const buf of buffers)
+      parser.write(buf);
+    break;
+  }
+
+  case 'formidable': {
+    const { MultipartParser } = require('formidable');
+
+    const parser = new MultipartParser();
+    parser.initWithBoundary(boundary);
+    parser.on('data', ({ name }) => {
+      ++calls[name];
+      if (name === 'end')
+        console.timeEnd(moduleName);
+    });
+
+    console.time(moduleName);
+    for (const buf of buffers)
+      parser.write(buf);
+
+    break;
+  }
+
+  case 'multiparty': {
+    const { Readable } = require('stream');
+
+    const { Form } = require('multiparty');
+
+    const form = new Form({
+      maxFieldsSize: Infinity,
+      maxFields: Infinity,
+      maxFilesSize: Infinity,
+      autoFields: false,
+      autoFiles: false,
+    });
+
+    const req = new Readable({ read: () => {} });
+    req.headers = {
+      'content-type': `multipart/form-data; boundary=${boundary}`,
+    };
+
+    function hijack(name, fn) {
+      const oldFn = form[name];
+      form[name] = function() {
+        fn();
+        return oldFn.apply(this, arguments);
+      };
+    }
+
+    hijack('onParseHeaderField', () => {
+      ++calls.headerField;
+    });
+    hijack('onParseHeaderValue', () => {
+      ++calls.headerValue;
+    });
+    hijack('onParsePartBegin', () => {
+      ++calls.partBegin;
+    });
+    hijack('onParsePartData', () => {
+      ++calls.partData;
+    });
+    hijack('onParsePartEnd', () => {
+      ++calls.partEnd;
+    });
+
+    form.on('close', () => {
+      ++calls.end;
+      console.timeEnd(moduleName);
+    }).on('part', (p) => p.resume());
+
+    console.time(moduleName);
+    form.parse(req);
+    for (const buf of buffers)
+      req.push(buf);
+    req.push(null);
+
+    break;
+  }
+
+  default:
+    if (moduleName === undefined)
+      console.error('Missing parser module name');
+    else
+      console.error(`Invalid parser module name: ${moduleName}`);
+    process.exit(1);
+}

package/dist/node_modules/@nocobase/lock-manager/node_modules/busboy/bench/bench-multipart-fields-100mb-small.js

@@ -0,0 +1,143 @@
+'use strict';
+
+function createMultipartBuffers(boundary, sizes) {
+  const bufs = [];
+  for (let i = 0; i < sizes.length; ++i) {
+    const mb = sizes[i] * 1024 * 1024;
+    bufs.push(Buffer.from([
+      `--${boundary}`,
+      `content-disposition: form-data; name="field${i + 1}"`,
+      '',
+      '0'.repeat(mb),
+      '',
+    ].join('\r\n')));
+  }
+  bufs.push(Buffer.from([
+    `--${boundary}--`,
+    '',
+  ].join('\r\n')));
+  return bufs;
+}
+
+const boundary = '-----------------------------168072824752491622650073';
+const buffers = createMultipartBuffers(boundary, (new Array(100)).fill(1));
+const calls = {
+  partBegin: 0,
+  headerField: 0,
+  headerValue: 0,
+  headerEnd: 0,
+  headersEnd: 0,
+  partData: 0,
+  partEnd: 0,
+  end: 0,
+};
+
+const moduleName = process.argv[2];
+switch (moduleName) {
+  case 'busboy': {
+    const busboy = require('busboy');
+
+    const parser = busboy({
+      limits: {
+        fieldSizeLimit: Infinity,
+      },
+      headers: {
+        'content-type': `multipart/form-data; boundary=${boundary}`,
+      },
+    });
+    parser.on('field', (name, val, info) => {
+      ++calls.partBegin;
+      ++calls.partData;
+      ++calls.partEnd;
+    }).on('close', () => {
+      ++calls.end;
+      console.timeEnd(moduleName);
+    });
+
+    console.time(moduleName);
+    for (const buf of buffers)
+      parser.write(buf);
+    break;
+  }
+
+  case 'formidable': {
+    const { MultipartParser } = require('formidable');
+
+    const parser = new MultipartParser();
+    parser.initWithBoundary(boundary);
+    parser.on('data', ({ name }) => {
+      ++calls[name];
+      if (name === 'end')
+        console.timeEnd(moduleName);
+    });
+
+    console.time(moduleName);
+    for (const buf of buffers)
+      parser.write(buf);
+
+    break;
+  }
+
+  case 'multiparty': {
+    const { Readable } = require('stream');
+
+    const { Form } = require('multiparty');
+
+    const form = new Form({
+      maxFieldsSize: Infinity,
+      maxFields: Infinity,
+      maxFilesSize: Infinity,
+      autoFields: false,
+      autoFiles: false,
+    });
+
+    const req = new Readable({ read: () => {} });
+    req.headers = {
+      'content-type': `multipart/form-data; boundary=${boundary}`,
+    };
+
+    function hijack(name, fn) {
+      const oldFn = form[name];
+      form[name] = function() {
+        fn();
+        return oldFn.apply(this, arguments);
+      };
+    }
+
+    hijack('onParseHeaderField', () => {
+      ++calls.headerField;
+    });
+    hijack('onParseHeaderValue', () => {
+      ++calls.headerValue;
+    });
+    hijack('onParsePartBegin', () => {
+      ++calls.partBegin;
+    });
+    hijack('onParsePartData', () => {
+      ++calls.partData;
+    });
+    hijack('onParsePartEnd', () => {
+      ++calls.partEnd;
+    });
+
+    form.on('close', () => {
+      ++calls.end;
+      console.timeEnd(moduleName);
+    }).on('part', (p) => p.resume());
+
+    console.time(moduleName);
+    form.parse(req);
+    for (const buf of buffers)
+      req.push(buf);
+    req.push(null);
+
+    break;
+  }
+
+  default:
+    if (moduleName === undefined)
+      console.error('Missing parser module name');
+    else
+      console.error(`Invalid parser module name: ${moduleName}`);
+    process.exit(1);
+}