@yrpri/api 9.0.220 → 9.0.222

package/tests/requestCompat.test.cjs

@@ -0,0 +1,288 @@
+"use strict";
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const Module = require("node:module");
+const { once } = require("node:events");
+const { PassThrough } = require("node:stream");
+const axiosPath = require.resolve("axios");
+const requestCompatPath = require.resolve("../utils/requestCompat.cjs");
+const injectMockModule = (modulePath, moduleExports) => {
+    const mockModule = new Module(modulePath);
+    mockModule.filename = modulePath;
+    mockModule.loaded = true;
+    mockModule.exports = moduleExports;
+    require.cache[modulePath] = mockModule;
+};
+const loadRequestCompat = (mockAxios) => {
+    const originalAxiosModule = require.cache[axiosPath];
+    const originalRequestCompatModule = require.cache[requestCompatPath];
+    injectMockModule(axiosPath, mockAxios);
+    delete require.cache[requestCompatPath];
+    const request = require(requestCompatPath);
+    return {
+        request,
+        restore() {
+            delete require.cache[requestCompatPath];
+            if (originalAxiosModule) {
+                require.cache[axiosPath] = originalAxiosModule;
+            }
+            else {
+                delete require.cache[axiosPath];
+            }
+            if (originalRequestCompatModule) {
+                require.cache[requestCompatPath] = originalRequestCompatModule;
+            }
+        },
+    };
+};
+const runCallbackRequest = (requestFn, options) => {
+    return new Promise((resolve) => {
+        requestFn(options, (error, response, body) => {
+            resolve({ error, response, body });
+        });
+    });
+};
+test("request.get maps query params and returns text bodies", async (t) => {
+    let seenConfig;
+    const mockAxios = async (config) => {
+        seenConfig = config;
+        return {
+            status: 200,
+            statusText: "OK",
+            headers: { "x-test": "1" },
+            data: "hello world",
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await runCallbackRequest(request.get, {
+        url: "https://example.com/items",
+        qs: { page: "2", sort: "asc" },
+        headers: { Authorization: "Bearer token" },
+    });
+    assert.equal(result.error, null);
+    assert.equal(result.response.statusCode, 200);
+    assert.equal(result.response.headers["x-test"], "1");
+    assert.equal(result.body, "hello world");
+    assert.equal(seenConfig.method, "get");
+    assert.deepEqual(seenConfig.params, { page: "2", sort: "asc" });
+    assert.equal(seenConfig.headers.Authorization, "Bearer token");
+    assert.equal(seenConfig.responseType, "text");
+});
+test("request.post sends json payloads and preserves parsed response objects", async (t) => {
+    let seenConfig;
+    const mockAxios = async (config) => {
+        seenConfig = config;
+        return {
+            status: 202,
+            statusText: "Accepted",
+            headers: { "content-type": "application/json" },
+            data: { ok: true, id: 123 },
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await runCallbackRequest(request.post, {
+        url: "https://example.com/events",
+        json: { name: "test-event" },
+    });
+    assert.equal(result.error, null);
+    assert.equal(result.response.statusCode, 202);
+    assert.deepEqual(result.body, { ok: true, id: 123 });
+    assert.equal(seenConfig.method, "post");
+    assert.deepEqual(seenConfig.data, { name: "test-event" });
+    assert.equal(seenConfig.headers["Content-Type"], "application/json");
+});
+test("request(options, callback) respects explicit method overrides", async (t) => {
+    let seenConfig;
+    const mockAxios = async (config) => {
+        seenConfig = config;
+        return {
+            status: 200,
+            statusText: "OK",
+            headers: {},
+            data: "method-ok",
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await runCallbackRequest(request, {
+        url: "https://example.com/plausible",
+        method: "PUT",
+        formData: {
+            site_id: "yrpri",
+            goal_type: "event",
+        },
+    });
+    assert.equal(result.error, null);
+    assert.equal(result.body, "method-ok");
+    assert.equal(seenConfig.method, "put");
+    assert.equal(typeof seenConfig.data.getHeaders, "function");
+});
+test("request.defaults can force binary responses", async (t) => {
+    let seenConfig;
+    const mockAxios = async (config) => {
+        seenConfig = config;
+        return {
+            status: 200,
+            statusText: "OK",
+            headers: { "content-type": "application/octet-stream" },
+            data: Buffer.from([1, 2, 3, 4]),
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const binaryRequest = request.defaults({ encoding: null });
+    const result = await runCallbackRequest(binaryRequest.get, {
+        url: "https://example.com/file.bin",
+    });
+    assert.equal(result.error, null);
+    assert.equal(seenConfig.responseType, "arraybuffer");
+    assert.equal(Buffer.isBuffer(result.body), true);
+    assert.deepEqual([...result.body], [1, 2, 3, 4]);
+});
+test("request supports error-only callbacks used by fire-and-forget call sites", async (t) => {
+    const mockAxios = async () => {
+        return {
+            status: 204,
+            statusText: "No Content",
+            headers: {},
+            data: "",
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const error = await new Promise((resolve) => {
+        request.post({
+            url: "https://example.com/track",
+            json: { ok: true },
+        }, (requestError) => resolve(requestError));
+    });
+    assert.equal(error, null);
+});
+test("request supports two-argument callbacks used by existing get callers", async (t) => {
+    const mockAxios = async () => {
+        return {
+            status: 200,
+            statusText: "OK",
+            headers: {},
+            data: "done",
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await new Promise((resolve) => {
+        request.get({ url: "https://example.com/goal" }, (first, second) => {
+            resolve({ first, second });
+        });
+    });
+    assert.equal(result.first, null);
+    assert.equal(result.second.statusCode, 200);
+    assert.equal(result.second.body, "done");
+});
+test("request.put builds multipart form data payloads", async (t) => {
+    let seenConfig;
+    const mockAxios = async (config) => {
+        seenConfig = config;
+        return {
+            status: 200,
+            statusText: "OK",
+            headers: {},
+            data: "uploaded",
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await runCallbackRequest(request.put, {
+        url: "https://example.com/upload",
+        formData: {
+            file: {
+                value: Buffer.from("hello"),
+                options: { filename: "hello.txt" },
+            },
+            tag: "demo",
+        },
+    });
+    assert.equal(result.error, null);
+    assert.equal(result.response.statusCode, 200);
+    assert.equal(result.body, "uploaded");
+    assert.equal(seenConfig.method, "put");
+    assert.equal(typeof seenConfig.data.getHeaders, "function");
+    assert.match(seenConfig.headers["content-type"], /^multipart\/form-data; boundary=/);
+});
+test("request(url).pipe(...) streams response bodies", async (t) => {
+    let seenConfig;
+    const mockAxios = async (config) => {
+        seenConfig = config;
+        const source = new PassThrough();
+        process.nextTick(() => source.end("stream-ok"));
+        return {
+            status: 200,
+            statusText: "OK",
+            headers: { "content-type": "text/plain" },
+            data: source,
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const output = request("https://example.com/report.txt");
+    const chunks = [];
+    output.on("data", (chunk) => {
+        chunks.push(chunk);
+    });
+    const [response] = await once(output, "response");
+    await once(output, "end");
+    assert.equal(seenConfig.method, "get");
+    assert.equal(seenConfig.responseType, "stream");
+    assert.equal(response.statusCode, 200);
+    assert.equal(Buffer.concat(chunks).toString("utf8"), "stream-ok");
+});
+test("request surfaces axios errors to callbacks", async (t) => {
+    const transportError = new Error("boom");
+    const mockAxios = async () => {
+        throw transportError;
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await runCallbackRequest(request.head, {
+        url: "https://example.com/head",
+    });
+    assert.equal(result.error, transportError);
+    assert.equal(result.response, null);
+    assert.equal(result.body, undefined);
+});
+test("request.head supports string urls and returns response metadata", async (t) => {
+    let seenConfig;
+    const mockAxios = async (config) => {
+        seenConfig = config;
+        return {
+            status: 204,
+            statusText: "No Content",
+            headers: { etag: "abc123" },
+            data: "",
+        };
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await runCallbackRequest(request.head, "https://example.com/head");
+    assert.equal(result.error, null);
+    assert.equal(seenConfig.method, "head");
+    assert.equal(result.response.statusCode, 204);
+    assert.equal(result.response.headers.etag, "abc123");
+});
+test("request surfaces request-style errno on transport errors", async (t) => {
+    const transportError = new Error("dns fail");
+    transportError.code = "ENOTFOUND";
+    const mockAxios = async () => {
+        throw transportError;
+    };
+    const { request, restore } = loadRequestCompat(mockAxios);
+    t.after(restore);
+    const result = await runCallbackRequest(request.get, {
+        url: "https://example.com/unreachable",
+    });
+    assert.equal(result.error, transportError);
+    assert.equal(result.error.errno, "ENOTFOUND");
+    assert.equal(result.response, null);
+    assert.equal(result.body, undefined);
+});

package/tests/requestCompat.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/multerSharpS3Compat.cjs

@@ -0,0 +1,230 @@
+"use strict";
+const crypto = require("crypto");
+const fs = require("fs");
+const sharp = require("sharp");
+const mime = require("mime-types");
+const os = require("os");
+const path = require("path");
+const { PassThrough } = require("stream");
+const { pipeline } = require("stream/promises");
+const buildVariantKey = (baseKey, size) => {
+    const suffix = size?.suffix || "";
+    const directory = size?.directory;
+    const dotIndex = baseKey.lastIndexOf(".");
+    let variantKey;
+    if (suffix && dotIndex > -1) {
+        variantKey = `${baseKey.slice(0, dotIndex)}${suffix}${baseKey.slice(dotIndex)}`;
+    }
+    else if (suffix) {
+        variantKey = `${baseKey}${suffix}`;
+    }
+    else {
+        variantKey = baseKey;
+    }
+    return directory ? `${directory}/${variantKey}` : variantKey;
+};
+const createTempUploadPath = (originalName) => {
+    const extension = path.extname(originalName || "");
+    const randomSuffix = crypto.randomBytes(6).toString("hex");
+    return path.join(os.tmpdir(), `multer-sharp-s3-${process.pid}-${Date.now()}-${randomSuffix}${extension}`);
+};
+const getUploadedObjects = (file) => {
+    const uploads = [];
+    const seen = new Set();
+    const addUpload = (value) => {
+        if (!value?.Bucket || !value?.Key) {
+            return;
+        }
+        const key = `${value.Bucket}/${value.Key}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            uploads.push({ Bucket: value.Bucket, Key: value.Key });
+        }
+    };
+    addUpload(file);
+    Object.values(file || {}).forEach(addUpload);
+    return uploads;
+};
+class MulterSharpS3Compat {
+    constructor(options) {
+        if (!options?.s3) {
+            throw new Error("You have to specify s3 for AWS S3 to work.");
+        }
+        if (!options?.Bucket) {
+            throw new Error("You have to specify Bucket for AWS S3 to work.");
+        }
+        this.opts = {
+            ACL: process.env.AWS_ACL || "public-read",
+            multiple: false,
+            ...options,
+        };
+    }
+    _removeFile(req, file, cb) {
+        const uploads = getUploadedObjects(file);
+        if (!uploads.length) {
+            cb(null);
+            return;
+        }
+        Promise.allSettled(uploads.map(({ Bucket, Key }) => this.opts.s3.deleteObject({ Bucket, Key }).promise()))
+            .then((results) => {
+            const failed = results.find((result) => result.status === "rejected");
+            cb(failed ? failed.reason : null);
+        })
+            .catch(cb);
+    }
+    _handleFile(req, file, cb) {
+        const baseParams = {
+            Bucket: this.opts.Bucket,
+            ACL: this.opts.ACL,
+            CacheControl: this.opts.CacheControl,
+            ContentDisposition: this.opts.ContentDisposition,
+            ContentType: this.opts.ContentType,
+            Metadata: this.opts.Metadata,
+            StorageClass: this.opts.StorageClass,
+            ServerSideEncryption: this.opts.ServerSideEncryption,
+            SSEKMSKeyId: this.opts.SSEKMSKeyId,
+        };
+        const finalize = async (key) => {
+            try {
+                const params = { ...baseParams, Key: key };
+                const result = file.mimetype?.includes("image")
+                    ? await this._uploadImageVariants(params, file)
+                    : await this._uploadNonImage(params, file);
+                cb(null, JSON.parse(JSON.stringify(result)));
+            }
+            catch (error) {
+                cb(error);
+            }
+        };
+        if (typeof this.opts.Key === "function") {
+            this.opts.Key(req, file, (error, key) => {
+                if (error) {
+                    cb(error);
+                }
+                else {
+                    finalize(key);
+                }
+            });
+        }
+        else {
+            finalize(this.opts.Key);
+        }
+    }
+    async _deleteUploadedObjects(uploads) {
+        if (!uploads.length) {
+            return;
+        }
+        await Promise.allSettled(uploads.map(({ Bucket, Key }) => this.opts.s3.deleteObject({ Bucket, Key }).promise()));
+    }
+    async _uploadStreamToS3(params, readable) {
+        let uploadedSize = 0;
+        const body = new PassThrough();
+        const upload = this.opts.s3.upload({ ...params, Body: body });
+        const uploadPromise = upload.promise().catch((error) => {
+            if (typeof upload.abort === "function") {
+                try {
+                    upload.abort();
+                }
+                catch (abortError) {
+                    // Ignore abort cleanup failures and preserve the original error.
+                }
+            }
+            readable.destroy(error);
+            body.destroy(error);
+            throw error;
+        });
+        body.on("data", (chunk) => {
+            uploadedSize += chunk.length;
+        });
+        readable.on("error", (error) => {
+            body.destroy(error);
+        });
+        readable.pipe(body);
+        const uploadResult = await uploadPromise;
+        return { uploadResult, size: uploadedSize };
+    }
+    async _uploadImageVariant(tempFilePath, params, file, size) {
+        let transformer = sharp(tempFilePath, { animated: true, failOn: "none" });
+        const outputFormat = file.outputFormat || this.opts.toFormat;
+        if (size?.width || size?.height || size?.options) {
+            transformer = transformer.resize(size.width, size.height, size.options);
+        }
+        if (outputFormat) {
+            transformer = transformer.toFormat(outputFormat);
+        }
+        const contentType = this.opts.ContentType ||
+            mime.contentType(outputFormat || file.mimetype) ||
+            file.mimetype;
+        const { uploadResult, size: uploadedSize } = await this._uploadStreamToS3({
+            ...params,
+            ContentType: contentType,
+        }, transformer);
+        return { uploadResult, uploadedSize, contentType };
+    }
+    async _uploadImageVariants(params, file) {
+        const tempFilePath = createTempUploadPath(file.originalname || params.Key);
+        const sizes = this.opts.multiple &&
+            Array.isArray(this.opts.resize) &&
+            this.opts.resize.length
+            ? this.opts.resize
+            : [this.opts.resize || {}];
+        const uploads = {};
+        const uploadedObjects = [];
+        try {
+            await pipeline(file.stream, fs.createWriteStream(tempFilePath));
+            for (const size of sizes) {
+                const variantKey = buildVariantKey(params.Key, size);
+                const { uploadResult, uploadedSize, contentType } = await this._uploadImageVariant(tempFilePath, { ...params, Key: variantKey }, file, size);
+                uploadedObjects.push({
+                    Bucket: uploadResult.Bucket || params.Bucket,
+                    Key: uploadResult.Key || variantKey,
+                });
+                uploads[size?.suffix || "default"] = {
+                    ACL: this.opts.ACL,
+                    ContentDisposition: this.opts.ContentDisposition,
+                    StorageClass: this.opts.StorageClass,
+                    ServerSideEncryption: this.opts.ServerSideEncryption,
+                    Metadata: this.opts.Metadata,
+                    ...uploadResult,
+                    Bucket: uploadResult.Bucket || params.Bucket,
+                    Key: uploadResult.Key || variantKey,
+                    size: uploadedSize,
+                    ContentType: contentType,
+                };
+            }
+            uploads.mimetype =
+                this.opts.ContentType ||
+                    mime.contentType(file.outputFormat || this.opts.toFormat || "png") ||
+                    file.mimetype;
+            return uploads;
+        }
+        catch (error) {
+            await this._deleteUploadedObjects(uploadedObjects);
+            throw error;
+        }
+        finally {
+            await fs.promises.unlink(tempFilePath).catch(() => { });
+        }
+    }
+    async _uploadNonImage(params, file) {
+        const contentType = params.ContentType || file.mimetype;
+        const { uploadResult, size } = await this._uploadStreamToS3({
+            ...params,
+            ContentType: contentType,
+        }, file.stream);
+        return {
+            size,
+            ACL: this.opts.ACL,
+            ContentDisposition: this.opts.ContentDisposition,
+            StorageClass: this.opts.StorageClass,
+            ServerSideEncryption: this.opts.ServerSideEncryption,
+            Metadata: this.opts.Metadata,
+            ContentType: contentType,
+            mimetype: contentType,
+            ...uploadResult,
+        };
+    }
+}
+module.exports = function multerSharpS3Compat(options) {
+    return new MulterSharpS3Compat(options);
+};

package/utils/multerSharpS3Compat.d.cts

@@ -0,0 +1,22 @@
+declare function _exports(options: any): MulterSharpS3Compat;
+export = _exports;
+declare class MulterSharpS3Compat {
+    constructor(options: any);
+    opts: any;
+    _removeFile(req: any, file: any, cb: any): void;
+    _handleFile(req: any, file: any, cb: any): void;
+    _deleteUploadedObjects(uploads: any): Promise<void>;
+    _uploadStreamToS3(params: any, readable: any): Promise<{
+        uploadResult: any;
+        size: number;
+    }>;
+    _uploadImageVariant(tempFilePath: any, params: any, file: any, size: any): Promise<{
+        uploadResult: any;
+        uploadedSize: number;
+        contentType: any;
+    }>;
+    _uploadImageVariants(params: any, file: any): Promise<{
+        mimetype: any;
+    }>;
+    _uploadNonImage(params: any, file: any): Promise<any>;
+}

package/utils/passportSsoCompat.cjs

@@ -0,0 +1,15 @@
+"use strict";
+const path = require("path");
+const rootPassportPath = require.resolve("passport");
+const rootPassportModule = require.cache[rootPassportPath] || require.cache[rootPassportPath] || (() => {
+    require(rootPassportPath);
+    return require.cache[rootPassportPath];
+})();
+const passportSsoPath = require.resolve("passport-sso");
+const nestedPassportPath = require.resolve("passport", {
+    paths: [path.dirname(passportSsoPath)],
+});
+if (nestedPassportPath !== rootPassportPath) {
+    require.cache[nestedPassportPath] = rootPassportModule;
+}
+module.exports = require("passport-sso");

package/utils/passportSsoCompat.d.cts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/utils/recount_utils.cjs

@@ -3,7 +3,7 @@ const async = require('async');
 const models = require('../models/index.cjs');
 const _ = require('lodash');
 const fs = require('fs');
-const request = require('request');
+const request = require("./requestCompat.cjs");
 const log = require('./logger.cjs');
 const recountPosts = (postIds, done) => {
     async.forEachSeries(postIds, (postId, forEachPostCallback) => {