@beiguancyc/parse-server 9.10.0-ruixiang.1 → 9.10.0-ruixiang.3

package/README.md

@@ -608,12 +608,13 @@ const parseServer = new ParseServer({
 
 | Parameter | Optional | Type | Default | Environment Variable |
 |---|---|---|---|---|
-| `fileUpload.allowedFileUrlDomains` | yes | `String[]` | `['*']` | `PARSE_SERVER_FILE_UPLOAD_ALLOWED_FILE_URL_DOMAINS` |
+| `fileUpload.allowedFileUrlDomains` | yes | `String[]` | hostnames of `publicServerURL` and `serverURL` | `PARSE_SERVER_FILE_UPLOAD_ALLOWED_FILE_URL_DOMAINS` |
 
-- `['*']` (default) allows file URLs with any domain.
+- Unset (default) allows file URLs whose hostname matches `publicServerURL` and/or `serverURL`.
 - `['cdn.example.com']` allows only exact hostname matches.
 - `['*.example.com']` allows any subdomain of `example.com`.
-- `[]` blocks all file URLs; only files referenced by name are allowed.
+- `['*']` allows file URLs with any domain.
+- `[]` blocks all file URLs; only files referenced by name are allowed. An empty array is not the same as leaving the option unset.
 
 ## Idempotency Enforcement
 

package/lib/Adapters/Files/setupFilesLink.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.setupFilesLink = setupFilesLink;
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * When filesAdapter.options.filesLinkTarget is set, create a symlink at
+ * files/{filesSubDirectory} -> filesLinkTarget before the FS adapter starts.
+ * This lets multiple Parse instances use distinct link names under files/
+ * without changing @parse/fs-files-adapter.
+ *
+ * @param {Object} filesAdapter parse-server filesAdapter config (module/class form with options)
+ */
+function setupFilesLink(filesAdapter) {
+  if (!filesAdapter || typeof filesAdapter !== 'object' || !filesAdapter.options) {
+    return;
+  }
+  const {
+    filesLinkTarget,
+    filesSubDirectory
+  } = filesAdapter.options;
+  if (filesLinkTarget === undefined || filesLinkTarget === null || filesLinkTarget === '') {
+    return;
+  }
+  if (!filesSubDirectory) {
+    throw new Error('filesAdapter.options.filesSubDirectory is required when filesLinkTarget is set.');
+  }
+  const targetPath = path.resolve(String(filesLinkTarget));
+  const linkPath = path.join('files', filesSubDirectory);
+  const linkParent = path.dirname(linkPath);
+  fs.mkdirSync(targetPath, {
+    recursive: true
+  });
+  fs.mkdirSync(linkParent, {
+    recursive: true
+  });
+  let linkStat;
+  try {
+    linkStat = fs.lstatSync(linkPath);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      createSymlink(targetPath, linkPath);
+      return;
+    }
+    throw err;
+  }
+  if (linkStat.isSymbolicLink() || isWindowsJunction(linkPath, linkStat)) {
+    const currentTarget = path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+    if (pathsEqual(currentTarget, targetPath)) {
+      return;
+    }
+    throw new Error(`files link "${linkPath}" already points to "${currentTarget}", expected "${targetPath}".`);
+  }
+  throw new Error(`Cannot create files link at "${linkPath}": path already exists and is not a symlink.`);
+}
+function createSymlink(targetPath, linkPath) {
+  // junction on Windows avoids elevated privileges required for directory symlinks
+  const type = process.platform === 'win32' ? 'junction' : 'dir';
+  fs.symlinkSync(targetPath, linkPath, type);
+}
+function isWindowsJunction(linkPath, linkStat) {
+  // Directory junctions may not always report as symbolic links; readlink is definitive.
+  if (process.platform !== 'win32' || !linkStat.isDirectory()) {
+    return false;
+  }
+  try {
+    fs.readlinkSync(linkPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pathsEqual(a, b) {
+  if (process.platform === 'win32') {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  return a === b;
+}
+var _default = exports.default = setupFilesLink;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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