@proteinjs/db-file 1.8.4 → 1.9.0

package/dist/test/FileCopyForOthers.test.js

@@ -0,0 +1,1143 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var db_1 = require("@proteinjs/db");
+var logger_1 = require("@proteinjs/logger");
+var reflection_1 = require("@proteinjs/reflection");
+var serializer_1 = require("@proteinjs/serializer");
+var user_1 = require("@proteinjs/user");
+var tables_1 = require("../src/tables/tables");
+var FileStorage_1 = require("../src/FileStorage");
+var service_1 = require("@proteinjs/service");
+// The router and executor every browser-facing service call runs through (ServiceRouter →
+// ServiceExecutor), not part of the package's entry: what they log and answer for this door — the
+// status and the body the browser reads — is the outcome under test.
+var ServiceExecutor_1 = require("@proteinjs/service/dist/src/ServiceExecutor");
+var ServiceRouter_1 = require("@proteinjs/service/dist/src/ServiceRouter");
+var getFile_1 = require("../src/routes/getFile");
+var FileTestEnvironment_1 = require("./FileTestEnvironment");
+/**
+ * A file's bytes are the owner's, kept as they arrived; what anyone ELSE is served is a copy the
+ * registered maker derives — made once, stored as its own File in the owner's scope, named on the
+ * original's row, dropped when the bytes change, deleted with the original. This suite proves the
+ * seam contract with a stub maker (the real one — a picture without its location — lives in the
+ * package that knows media): who gets which bytes, through the service door and both shapes of
+ * the route; that the copy is cached and its cache never crosses to the owner; how it dies.
+ *
+ * The stub maker marks the bytes it makes: the original carries `LOCATION-MARKER` (what a phone
+ * photo's GPS block is to the real maker), the copy does not.
+ */
+var LOCATION_MARKER = Buffer.from('LOCATION-MARKER');
+/** Every byte value once, then the marker — a payload the copy must be seen to differ from. */
+var originalBytes = Buffer.concat([Buffer.from(Array.from({ length: 256 }, function (_, i) { return i; })), LOCATION_MARKER]);
+var copyOf = function (bytes) { return Buffer.from(bytes.subarray(0, bytes.length - LOCATION_MARKER.length)); };
+/** In-memory proxy-shape driver (no signed URLs) — the DbFileStorageDriver serving shape. */
+var ProxyDriver = /** @class */ (function () {
+    function ProxyDriver() {
+        this.store = new Map();
+    }
+    ProxyDriver.prototype.createFile = function (file, fileData) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.store.set(file.id, Buffer.from(fileData, 'base64'));
+                        return [4 /*yield*/, atBarrier()];
+                    case 1:
+                        _a.sent(); // the racing case: every copy's bytes are stored before any row is asked its word
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ProxyDriver.prototype.getFileData = function (fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                data = this.store.get(fileId);
+                if (data === undefined) {
+                    throw new Error("No such object: ".concat(fileId));
+                }
+                return [2 /*return*/, data.toString('base64')];
+            });
+        });
+    };
+    ProxyDriver.prototype.updateFileData = function (fileId, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.store.set(fileId, Buffer.from(data, 'base64'));
+                return [2 /*return*/];
+            });
+        });
+    };
+    ProxyDriver.prototype.deleteFile = function (fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.store.delete(fileId);
+                return [2 /*return*/];
+            });
+        });
+    };
+    return ProxyDriver;
+}());
+/** Proxy driver plus a signed-URL mint that names the object it signs — the GCS serving shape. */
+var SignedUrlDriver = /** @class */ (function (_super) {
+    __extends(SignedUrlDriver, _super);
+    function SignedUrlDriver() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SignedUrlDriver.prototype.getSignedUrl = function (fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, "https://signed.test/blob/".concat(fileId, "?sig=test")];
+            });
+        });
+    };
+    return SignedUrlDriver;
+}(ProxyDriver));
+var ResponseRecorder = /** @class */ (function () {
+    function ResponseRecorder() {
+        this.headers = {};
+    }
+    ResponseRecorder.prototype.status = function (code) {
+        this.statusCode = code;
+        return this;
+    };
+    ResponseRecorder.prototype.send = function (body) {
+        this.body = body;
+        return this;
+    };
+    ResponseRecorder.prototype.setHeader = function (name, value) {
+        this.headers[name.toLowerCase()] = value;
+    };
+    ResponseRecorder.prototype.redirect = function (status, url) {
+        this.statusCode = status;
+        this.redirectUrl = url;
+    };
+    return ResponseRecorder;
+}());
+var invokeRoute = function (fileId) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                response = new ResponseRecorder();
+                return [4 /*yield*/, getFile_1.getFile.onRequest({ params: { id: fileId }, headers: {} }, response)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/, response];
+        }
+    });
+}); };
+/** A logger that writes into `entries` — what a door logged, read back as the outcome. */
+var loggerInto = function (name, entries) {
+    return new logger_1.Logger({ name: name, logWriter: { write: function (log) { return entries.push(log); } } });
+};
+var SERVICE_PATH = '/service/@proteinjs/db-file/FileStorageService/getFileData';
+/**
+ * One call of the browser's door — `FileStorageService.getFileData` — through the REAL service
+ * router (its executor seeded by path, the way the router builds it from the source graph): the
+ * status and the body the browser reads, every entry the executor logged (`entries`) and every
+ * entry the file storage itself logged (`storageEntries`).
+ */
+var invokeServiceDoor = function (fileId) { return __awaiter(void 0, void 0, void 0, function () {
+    var returnType, method, storage, storageEntries, executor, entries, router, response;
+    var _a;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                returnType = { name: 'Promise<string>' };
+                method = new reflection_1.Method('getFileData', returnType, true, false, false, false, 'public', []);
+                storage = new FileStorage_1.FileStorage();
+                storageEntries = [];
+                storage.logger = loggerInto('FileStorage', storageEntries);
+                executor = new ServiceExecutor_1.ServiceExecutor(storage, new reflection_1.Interface('@proteinjs/db-file', 'FileStorageService', [], [method]), method);
+                entries = [];
+                executor.logger = loggerInto('FileStorageService.getFileData', entries);
+                router = new ServiceRouter_1.ServiceRouter();
+                router.serviceExecutorMap = (_a = {},
+                    _a[SERVICE_PATH] = executor,
+                    _a);
+                response = new ResponseRecorder();
+                return [4 /*yield*/, router.onRequest({ path: SERVICE_PATH, body: serializer_1.Serializer.serialize([fileId]) }, response)];
+            case 1:
+                _c.sent();
+                return [2 /*return*/, { status: (_b = response.statusCode) !== null && _b !== void 0 ? _b : 200, body: response.body, entries: entries, storageEntries: storageEntries }];
+        }
+    });
+}); };
+/** The status the service router answers a thrown error with: a refusal's own, else 400. */
+var routerStatus = function (thrown) { return (service_1.ServiceRefusal.is(thrown) ? thrown.status : 400); };
+var testEnv = new FileTestEnvironment_1.FileTestEnvironment();
+var objectCache = function () { return reflection_1.SourceRepository.get().objectCache; };
+var owner;
+var recipient;
+var reachableFileIds = new Set();
+/** Every call the maker took: which file, and the bytes it was handed. */
+var makerCalls = [];
+/** What the stub maker applies to — the suite's own rule (the real maker's is "pictures and clips"). */
+var makerAppliesTo = function (file) { return file.type.startsWith('image/'); };
+var makerFails = false;
+/** What the stub maker throws when it fails — its own internal words, the server's to keep. */
+var MAKER_REASON = 'no copy can be made of this file';
+/**
+ * A barrier for the racing case: with `makerBarrier = n`, the stub maker holds every call until n
+ * calls are inside it, then answers them all on the same tick — so the reads that follow (the
+ * copy's row, its bytes, the row's word) run in lockstep, the tightest race the seam can meet.
+ */
+var makerBarrier = 0;
+var makerWaiting = [];
+/** Hold until `makerBarrier` callers are here, then release them all on one tick (no-op when 0). */
+var atBarrier = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (makerBarrier <= 0) {
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, new Promise(function (resolve) {
+                        makerWaiting.push(resolve);
+                        if (makerWaiting.length >= makerBarrier) {
+                            var release = makerWaiting;
+                            makerWaiting = [];
+                            release.forEach(function (go) { return go(); });
+                        }
+                    })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+var registerMaker = function () {
+    objectCache()['@proteinjs/db-file/FileCopyForOthers'] = [
+        {
+            appliesTo: function (file) { return makerAppliesTo(file); },
+            make: function (file, bytes) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            makerCalls.push({ fileId: file.id, bytes: Buffer.from(bytes) });
+                            return [4 /*yield*/, atBarrier()];
+                        case 1:
+                            _a.sent();
+                            if (makerFails) {
+                                throw new Error(MAKER_REASON);
+                            }
+                            return [2 /*return*/, copyOf(bytes)];
+                    }
+                });
+            }); },
+        },
+    ];
+};
+beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, testEnv.beforeAll()];
+            case 1:
+                _a.sent();
+                objectCache()['@proteinjs/user-auth/AuthenticatedUserRepo'] = [new user_1.UserRepo()];
+                user_1.UserAuth.userRepo = undefined;
+                objectCache()['@proteinjs/db-file/FileReachabilityResolver'] = [
+                    { canReadViaReference: function (fileId) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, reachableFileIds.has(fileId)];
+                        }); }); } },
+                ];
+                registerMaker();
+                return [4 /*yield*/, testEnv.createUser({ name: 'File owner', email: 'copy-owner@test.local' })];
+            case 2:
+                owner = _a.sent();
+                return [4 /*yield*/, testEnv.createUser({ name: 'Share recipient', email: 'copy-recipient@test.local' })];
+            case 3:
+                recipient = _a.sent();
+                testEnv.actAs(owner);
+                return [2 /*return*/];
+        }
+    });
+}); });
+afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                delete objectCache()['@proteinjs/db-file/FileReachabilityResolver'];
+                delete objectCache()['@proteinjs/db-file/FileCopyForOthers'];
+                user_1.UserAuth.userRepo = undefined;
+                return [4 /*yield*/, testEnv.afterAll()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+beforeEach(function () {
+    reachableFileIds.clear();
+    makerCalls = [];
+    makerAppliesTo = function (file) { return file.type.startsWith('image/'); };
+    makerFails = false;
+    makerBarrier = 0;
+    makerWaiting = [];
+    registerMaker();
+    testEnv.actAs(owner);
+});
+var createOwnerFile = function (name, type, bytes) {
+    if (bytes === void 0) { bytes = originalBytes; }
+    return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, new FileStorage_1.FileStorage().createFile({ name: name, type: type, size: bytes.length }, bytes.toString('base64'))];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    }); });
+};
+var rowAsSystem = function (fileId) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, (0, db_1.getDbAsSystem)().get(tables_1.tables.File, { id: fileId })];
+        case 1: return [2 /*return*/, (_a.sent())];
+    }
+}); }); };
+var bytesAs = function (user, fileId) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                testEnv.actAs(user);
+                _b = (_a = Buffer).from;
+                return [4 /*yield*/, new FileStorage_1.FileStorage().getFileData(fileId)];
+            case 1: return [2 /*return*/, _b.apply(_a, [_c.sent(), 'base64'])];
+        }
+    });
+}); };
+var fileRowsInScope = function (scope) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, db_1.getDbAsSystem)().query(tables_1.tables.File, new db_1.QueryBuilderFactory().getQueryBuilder(tables_1.tables.File).condition({ field: 'scope', operator: '=', value: scope }))];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+describe('the copy for others — the service door (proxy serving)', function () {
+    var driver = new ProxyDriver();
+    beforeAll(function () {
+        testEnv.setDriver(driver);
+    });
+    it('the owner is served the original, and no copy is made for them', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, served, _a;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('mine.jpg', 'image/jpeg')];
+                case 1:
+                    file = _d.sent();
+                    return [4 /*yield*/, bytesAs(owner, file.id)];
+                case 2:
+                    served = _d.sent();
+                    expect(served.equals(originalBytes)).toBe(true);
+                    expect(makerCalls).toEqual([]);
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _a.apply(void 0, [(_c = (_b = (_d.sent()).copyForOthers) === null || _b === void 0 ? void 0 : _b._id) !== null && _c !== void 0 ? _c : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("a recipient the content reaches is served the maker's copy — the original's bytes never leave to them", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, served;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('shared.jpg', 'image/jpeg')];
+                case 1:
+                    file = _a.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 2:
+                    served = _a.sent();
+                    expect(served.includes(LOCATION_MARKER)).toBe(false);
+                    expect(served.equals(copyOf(originalBytes))).toBe(true);
+                    expect(makerCalls.map(function (call) { return call.fileId; })).toEqual([file.id]);
+                    expect(makerCalls[0].bytes.equals(originalBytes)).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("the copy is a File of the OWNER's, named on the original's row, with the original's name, type and dimensions", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, row, copyId, copy;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('framed.jpg', 'image/jpeg')];
+                case 1:
+                    file = _b.sent();
+                    return [4 /*yield*/, (0, db_1.getDbAsSystem)().update(tables_1.tables.File, { id: file.id, width: 640, height: 480 })];
+                case 2:
+                    _b.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 4:
+                    row = (_b.sent());
+                    copyId = (_a = row.copyForOthers) === null || _a === void 0 ? void 0 : _a._id;
+                    expect(copyId).toBeTruthy();
+                    return [4 /*yield*/, rowAsSystem(copyId)];
+                case 5:
+                    copy = (_b.sent());
+                    expect(copy.scope).toEqual(owner.id);
+                    expect([copy.name, copy.type, copy.size, copy.width, copy.height]).toEqual([
+                        'framed.jpg',
+                        'image/jpeg',
+                        copyOf(originalBytes).length,
+                        640,
+                        480,
+                    ]);
+                    expect(driver.store.get(copyId).equals(copyOf(originalBytes))).toBe(true);
+                    // The original is untouched: its bytes, its size.
+                    expect(driver.store.get(file.id).equals(originalBytes)).toBe(true);
+                    expect(row.size).toEqual(originalBytes.length);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('the copy is made ONCE: every later non-owner read serves the same copy without the maker', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, copyId, again, onceMore, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('popular.jpg', 'image/jpeg')];
+                case 1:
+                    file = _b.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    copyId = (_b.sent()).copyForOthers._id;
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 4:
+                    again = _b.sent();
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 5:
+                    onceMore = _b.sent();
+                    expect(again.equals(copyOf(originalBytes))).toBe(true);
+                    expect(onceMore.equals(copyOf(originalBytes))).toBe(true);
+                    expect(makerCalls).toHaveLength(1);
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 6:
+                    _a.apply(void 0, [(_b.sent()).copyForOthers._id]).toEqual(copyId);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("TWO NON-OWNERS RACING: both are served the copy, ONE copy row survives in the owner's scope, the row names it, the loser's object is gone", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, readers, served, _i, served_1, bytes, named, copies, liveIds, _a, _b, again;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('raced.jpg', 'image/jpeg')];
+                case 1:
+                    file = _c.sent();
+                    reachableFileIds.add(file.id);
+                    readers = 4;
+                    makerBarrier = readers;
+                    // Warm the driver's session pool so the readers' round trips really overlap (a cold pool serializes them).
+                    return [4 /*yield*/, Promise.all(Array.from({ length: readers * 2 }, function () { return rowAsSystem(file.id); }))];
+                case 2:
+                    // Warm the driver's session pool so the readers' round trips really overlap (a cold pool serializes them).
+                    _c.sent();
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, Promise.all(Array.from({ length: readers }, function () { return new FileStorage_1.FileStorage().getFileData(file.id); }))];
+                case 3:
+                    served = _c.sent();
+                    for (_i = 0, served_1 = served; _i < served_1.length; _i++) {
+                        bytes = served_1[_i];
+                        expect(Buffer.from(bytes, 'base64').equals(copyOf(originalBytes))).toBe(true);
+                    }
+                    expect(makerCalls).toHaveLength(readers); // all raced into the maker; the contract is about what SURVIVES
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 4:
+                    named = (_c.sent()).copyForOthers._id;
+                    return [4 /*yield*/, fileRowsInScope(owner.id)];
+                case 5:
+                    copies = (_c.sent()).filter(function (row) { return row.id !== file.id && row.name === 'raced.jpg'; });
+                    expect(copies.map(function (row) { return row.id; })).toEqual([named]);
+                    _a = Set.bind;
+                    return [4 /*yield*/, (0, db_1.getDbAsSystem)().query(tables_1.tables.File, new db_1.QueryBuilderFactory().getQueryBuilder(tables_1.tables.File))];
+                case 6:
+                    liveIds = new (_a.apply(Set, [void 0, (_c.sent()).map(function (row) { return row.id; })]))();
+                    expect(Array.from(driver.store.keys()).filter(function (id) { return !liveIds.has(id); })).toEqual([]);
+                    _b = expect;
+                    return [4 /*yield*/, fileRowsInScope(recipient.id)];
+                case 7:
+                    _b.apply(void 0, [_c.sent()]).toEqual([]);
+                    makerBarrier = 0;
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 8:
+                    again = _c.sent();
+                    expect(again.equals(copyOf(originalBytes))).toBe(true);
+                    expect(makerCalls).toHaveLength(readers);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("THE CACHE NEVER CROSSES TO THE OWNER: once a copy exists, the owner's read still serves the original", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, _a, served;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('still-mine.jpg', 'image/jpeg')];
+                case 1:
+                    file = _c.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 2:
+                    _c.sent();
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _a.apply(void 0, [(_b = (_c.sent()).copyForOthers) === null || _b === void 0 ? void 0 : _b._id]).toBeTruthy();
+                    return [4 /*yield*/, bytesAs(owner, file.id)];
+                case 4:
+                    served = _c.sent();
+                    expect(served.equals(originalBytes)).toBe(true);
+                    expect(served.includes(LOCATION_MARKER)).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('a file the maker does not apply to serves as itself to a recipient — no bytes read, no copy made', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, rowsBefore, served, _a, _b;
+        var _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('notes.pdf', 'application/pdf')];
+                case 1:
+                    file = _e.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, fileRowsInScope(owner.id)];
+                case 2:
+                    rowsBefore = (_e.sent()).length;
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 3:
+                    served = _e.sent();
+                    expect(served.equals(originalBytes)).toBe(true);
+                    expect(makerCalls).toEqual([]);
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 4:
+                    _a.apply(void 0, [(_d = (_c = (_e.sent()).copyForOthers) === null || _c === void 0 ? void 0 : _c._id) !== null && _d !== void 0 ? _d : null]).toBeNull();
+                    _b = expect;
+                    return [4 /*yield*/, fileRowsInScope(owner.id)];
+                case 5:
+                    _b.apply(void 0, [(_e.sent()).length]).toEqual(rowsBefore);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("the copy's own id is the owner's alone: a recipient cannot reach it, the owner can", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, copyId, _a, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('guarded.jpg', 'image/jpeg')];
+                case 1:
+                    file = _d.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 2:
+                    _d.sent();
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    copyId = (_d.sent()).copyForOthers._id;
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, expect(new FileStorage_1.FileStorage().getFileData(copyId)).rejects.toThrow('File not found')];
+                case 4:
+                    _d.sent();
+                    testEnv.actAs(owner);
+                    _a = expect;
+                    _c = (_b = Buffer).from;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFileData(copyId)];
+                case 5:
+                    _a.apply(void 0, [_c.apply(_b, [_d.sent(), 'base64']).equals(copyOf(originalBytes))]).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('when no copy can be made, the recipient is served NOTHING — never the original', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, refusal, _a, _b;
+        var _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('unrewritable.jpg', 'image/jpeg')];
+                case 1:
+                    file = _e.sent();
+                    reachableFileIds.add(file.id);
+                    makerFails = true;
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFileData(file.id).then(function () { return undefined; }, function (error) { return error; })];
+                case 2:
+                    refusal = _e.sent();
+                    // Not there for this caller — a 404 refusal in the words a missing file gets, the same at every door.
+                    expect(service_1.ServiceRefusal.is(refusal)).toBe(true);
+                    expect(refusal.status).toBe(404);
+                    expect(refusal.message).toEqual('File not found');
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _a.apply(void 0, [(_d = (_c = (_e.sent()).copyForOthers) === null || _c === void 0 ? void 0 : _c._id) !== null && _d !== void 0 ? _d : null]).toBeNull();
+                    expect(Array.from(driver.store.keys())).toContain(file.id);
+                    _b = expect;
+                    return [4 /*yield*/, fileRowsInScope(owner.id)];
+                case 4:
+                    _b.apply(void 0, [(_e.sent()).find(function (row) { return row.id !== file.id && row.name === 'unrewritable.jpg'; })]).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('with no maker registered at all, a recipient is served the original (the seam is opt-in)', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, served, _a;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    objectCache()['@proteinjs/db-file/FileCopyForOthers'] = [];
+                    return [4 /*yield*/, createOwnerFile('unguarded.jpg', 'image/jpeg')];
+                case 1:
+                    file = _d.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 2:
+                    served = _d.sent();
+                    expect(served.equals(originalBytes)).toBe(true);
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _a.apply(void 0, [(_c = (_b = (_d.sent()).copyForOthers) === null || _b === void 0 ? void 0 : _b._id) !== null && _c !== void 0 ? _c : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("NEW BYTES DROP THE COPY: after the owner rewrites the file, the recipient's next read is a fresh copy of the new bytes, the old copy's row and bytes gone", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, staleCopyId, newBytes, _a, _b, served;
+        var _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('edited.jpg', 'image/jpeg')];
+                case 1:
+                    file = _e.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 2:
+                    _e.sent();
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    staleCopyId = (_e.sent()).copyForOthers._id;
+                    newBytes = Buffer.concat([Buffer.from('v2-'), originalBytes]);
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().updateFileData(file.id, newBytes.toString('base64'))];
+                case 4:
+                    _e.sent();
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 5:
+                    _a.apply(void 0, [(_d = (_c = (_e.sent()).copyForOthers) === null || _c === void 0 ? void 0 : _c._id) !== null && _d !== void 0 ? _d : null]).toBeNull();
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(staleCopyId)];
+                case 6:
+                    _b.apply(void 0, [_e.sent()]).toBeUndefined();
+                    expect(driver.store.has(staleCopyId)).toBe(false);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 7:
+                    served = _e.sent();
+                    expect(served.equals(copyOf(newBytes))).toBe(true);
+                    expect(makerCalls).toHaveLength(2);
+                    expect(makerCalls[1].bytes.equals(newBytes)).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("DELETING THE ORIGINAL DELETES THE COPY: the copy's row and bytes go with the file", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, copyId, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('gone.jpg', 'image/jpeg')];
+                case 1:
+                    file = _c.sent();
+                    reachableFileIds.add(file.id);
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 2:
+                    _c.sent();
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    copyId = (_c.sent()).copyForOthers._id;
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deleteFile(file.id)];
+                case 4:
+                    _c.sent();
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 5:
+                    _a.apply(void 0, [_c.sent()]).toBeUndefined();
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(copyId)];
+                case 6:
+                    _b.apply(void 0, [_c.sent()]).toBeUndefined();
+                    expect(driver.store.has(file.id)).toBe(false);
+                    expect(driver.store.has(copyId)).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('the copy for others — the route, both serving shapes', function () {
+    it("proxy shape: a recipient's GET /file/:id serves the copy's bytes under the ORIGINAL's name and type; the owner's serves the original", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var driver, file, theirs, mine;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    driver = new ProxyDriver();
+                    testEnv.setDriver(driver);
+                    return [4 /*yield*/, createOwnerFile('route-shot.jpg', 'image/jpeg')];
+                case 1:
+                    file = _b.sent();
+                    reachableFileIds.add(file.id);
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 2:
+                    theirs = _b.sent();
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 3:
+                    mine = _b.sent();
+                    expect((_a = theirs.statusCode) !== null && _a !== void 0 ? _a : 200).toEqual(200);
+                    expect(theirs.headers['content-type']).toEqual('image/jpeg');
+                    expect(theirs.headers['content-disposition']).toEqual('inline; filename="route-shot.jpg"');
+                    expect(theirs.body.equals(copyOf(originalBytes))).toBe(true);
+                    expect(mine.body.equals(originalBytes)).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("signed-URL shape (the production store): a recipient is redirected to the COPY's object, the owner to the original's", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var driver, file, theirs, copyId, mine;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    driver = new SignedUrlDriver();
+                    testEnv.setDriver(driver);
+                    return [4 /*yield*/, createOwnerFile('route-clip-poster.jpg', 'image/jpeg')];
+                case 1:
+                    file = _a.sent();
+                    reachableFileIds.add(file.id);
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 2:
+                    theirs = _a.sent();
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    copyId = (_a.sent()).copyForOthers._id;
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 4:
+                    mine = _a.sent();
+                    expect(theirs.statusCode).toEqual(302);
+                    expect(theirs.redirectUrl).toEqual("https://signed.test/blob/".concat(copyId, "?sig=test"));
+                    expect(copyId).not.toEqual(file.id);
+                    expect(mine.statusCode).toEqual(302);
+                    expect(mine.redirectUrl).toEqual("https://signed.test/blob/".concat(file.id, "?sig=test"));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it.each([
+        ['signed-URL', function () { return new SignedUrlDriver(); }],
+        ['proxy', function () { return new ProxyDriver(); }],
+    ])("a file no copy can be made of (%s shape): a recipient's GET /file/:id is a quiet 404 File not found — not a 500, no error printed; the owner's still serves", function (_shape, makeDriver) { return __awaiter(void 0, void 0, void 0, function () {
+        var driver, file, consoleError, theirs, mine;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    driver = makeDriver();
+                    testEnv.setDriver(driver);
+                    return [4 /*yield*/, createOwnerFile('unrewritable-route.jpg', 'image/jpeg')];
+                case 1:
+                    file = _a.sent();
+                    reachableFileIds.add(file.id);
+                    makerFails = true;
+                    consoleError = jest.spyOn(console, 'error').mockImplementation(function () { return undefined; });
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, , 5, 6]);
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 3:
+                    theirs = _a.sent();
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 4:
+                    mine = _a.sent();
+                    expect([theirs.statusCode, theirs.body]).toEqual([404, 'File not found']);
+                    expect(theirs.redirectUrl).toBeUndefined();
+                    expect(consoleError).not.toHaveBeenCalled();
+                    if (driver instanceof SignedUrlDriver) {
+                        expect(mine.statusCode).toEqual(302);
+                        expect(mine.redirectUrl).toEqual("https://signed.test/blob/".concat(file.id, "?sig=test"));
+                    }
+                    else {
+                        expect(mine.body.equals(originalBytes)).toBe(true);
+                    }
+                    return [3 /*break*/, 6];
+                case 5:
+                    consoleError.mockRestore();
+                    return [7 /*endfinally*/];
+                case 6: return [2 /*return*/];
+            }
+        });
+    }); });
+    it("a signed URL for a file the maker does not apply to still names the original's object", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var driver, file, theirs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    driver = new SignedUrlDriver();
+                    testEnv.setDriver(driver);
+                    return [4 /*yield*/, createOwnerFile('route-notes.pdf', 'application/pdf')];
+                case 1:
+                    file = _a.sent();
+                    reachableFileIds.add(file.id);
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 2:
+                    theirs = _a.sent();
+                    expect(theirs.redirectUrl).toEqual("https://signed.test/blob/".concat(file.id, "?sig=test"));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('the copy for others — a server-side door that made its own access decision', function () {
+    var driver = new ProxyDriver();
+    /** What such a door does: reads the row as system (its own rule opened it), then asks which bytes this caller is served. */
+    var throughTheDoor = function (user, fileId) { return __awaiter(void 0, void 0, void 0, function () {
+        var row, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, rowAsSystem(fileId)];
+                case 1:
+                    row = (_c.sent());
+                    testEnv.actAs(user);
+                    _b = (_a = Buffer).from;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getAuthorizedFileData(row)];
+                case 2: return [2 /*return*/, _b.apply(_a, [_c.sent(), 'base64'])];
+            }
+        });
+    }); };
+    beforeAll(function () {
+        testEnv.setDriver(driver);
+    });
+    it("a caller neither scope nor a resolver opens, whom the door vouches for, is served the maker's copy — the same copy the row names for every other non-owner", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, served, copyId, _a;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('attached.jpg', 'image/jpeg')];
+                case 1:
+                    file = _c.sent();
+                    return [4 /*yield*/, throughTheDoor(recipient, file.id)];
+                case 2:
+                    served = _c.sent();
+                    expect(served.includes(LOCATION_MARKER)).toBe(false);
+                    expect(served.equals(copyOf(originalBytes))).toBe(true);
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    copyId = (_b = (_c.sent()).copyForOthers) === null || _b === void 0 ? void 0 : _b._id;
+                    expect(copyId).toBeTruthy();
+                    expect(driver.store.get(copyId).equals(served)).toBe(true);
+                    // A share recipient later reaching the same file is served that same copy, never a second one.
+                    reachableFileIds.add(file.id);
+                    _a = expect;
+                    return [4 /*yield*/, bytesAs(recipient, file.id)];
+                case 4:
+                    _a.apply(void 0, [(_c.sent()).equals(served)]).toBe(true);
+                    expect(makerCalls.map(function (call) { return call.fileId; })).toEqual([file.id]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('the owner through the same door is served the original, byte for byte, and no copy is made', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, served, _a;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('own-attachment.jpg', 'image/jpeg')];
+                case 1:
+                    file = _d.sent();
+                    return [4 /*yield*/, throughTheDoor(owner, file.id)];
+                case 2:
+                    served = _d.sent();
+                    expect(served.equals(originalBytes)).toBe(true);
+                    expect(makerCalls).toEqual([]);
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _a.apply(void 0, [(_c = (_b = (_d.sent()).copyForOthers) === null || _b === void 0 ? void 0 : _b._id) !== null && _c !== void 0 ? _c : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("when no copy can be made, the door's caller is refused as NOT FOUND — a 404 ServiceRefusal in a missing file's words, a refusal and never a failure — and never served the original", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, refusal, _a;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createOwnerFile('raw-attachment.jpg', 'image/jpeg')];
+                case 1:
+                    file = _d.sent();
+                    makerFails = true;
+                    return [4 /*yield*/, throughTheDoor(recipient, file.id).then(function () { return undefined; }, function (error) { return error; })];
+                case 2:
+                    refusal = _d.sent();
+                    // The status the service router answers with and the executor logs at WARN: 404 leaks nothing
+                    // about the file's existence to a caller who may not read it.
+                    expect(service_1.ServiceRefusal.is(refusal)).toBe(true);
+                    expect(refusal.status).toBe(404);
+                    expect(refusal.message).toEqual('File not found');
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _a.apply(void 0, [(_c = (_b = (_d.sent()).copyForOthers) === null || _b === void 0 ? void 0 : _b._id) !== null && _c !== void 0 ? _c : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('ONE REFUSAL AT EVERY DOOR — a file no copy can be made of is not found for anyone but its owner (404), whichever door asks', function () {
+    /** A file the recipient reaches whose copy the maker refuses — both serving shapes hold its bytes. */
+    var refusedFile = function (name) { return __awaiter(void 0, void 0, void 0, function () {
+        var proxy, signed, file;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    proxy = new ProxyDriver();
+                    signed = new SignedUrlDriver();
+                    testEnv.setDriver(proxy);
+                    return [4 /*yield*/, createOwnerFile(name, 'image/jpeg')];
+                case 1:
+                    file = _a.sent();
+                    signed.store.set(file.id, proxy.store.get(file.id));
+                    reachableFileIds.add(file.id);
+                    makerFails = true;
+                    return [2 /*return*/, { file: file, proxy: proxy, signed: signed }];
+            }
+        });
+    }); };
+    /** Every door a recipient can ask, in one order: the browser service, the route (proxy, then signed-URL), the server-side door. */
+    var askEveryDoor = function (file, signed) { return __awaiter(void 0, void 0, void 0, function () {
+        var service, proxyRoute, serverSide, _a, _b, signedRoute;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, invokeServiceDoor(file.id)];
+                case 1:
+                    service = _c.sent();
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 2:
+                    proxyRoute = _c.sent();
+                    _b = (_a = new FileStorage_1.FileStorage()).getAuthorizedFileData;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3: return [4 /*yield*/, _b.apply(_a, [(_c.sent())]).then(function () { return undefined; }, function (error) { return error; })];
+                case 4:
+                    serverSide = _c.sent();
+                    testEnv.setDriver(signed);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 5:
+                    signedRoute = _c.sent();
+                    return [2 /*return*/, { service: service, proxyRoute: proxyRoute, serverSide: serverSide, signedRoute: signedRoute }];
+            }
+        });
+    }); };
+    it('the browser service (through the router), GET /file/:id in both shapes and the server-side door answer one status, 404 — the browser door logs one WARN with its status and no ERROR', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, file, signed, consoleError, _b, service, proxyRoute, serverSide, signedRoute, warnings;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, refusedFile('one-answer.jpg')];
+                case 1:
+                    _a = _c.sent(), file = _a.file, signed = _a.signed;
+                    consoleError = jest.spyOn(console, 'error').mockImplementation(function () { return undefined; });
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, , 4, 5]);
+                    return [4 /*yield*/, askEveryDoor(file, signed)];
+                case 3:
+                    _b = _c.sent(), service = _b.service, proxyRoute = _b.proxyRoute, serverSide = _b.serverSide, signedRoute = _b.signedRoute;
+                    expect([service.status, signedRoute.statusCode, proxyRoute.statusCode, routerStatus(serverSide)]).toEqual([
+                        404, 404, 404, 404,
+                    ]);
+                    // The browser door's log: one WARN naming the status and the operation — a refusal, never a failure.
+                    expect(service.entries.filter(function (entry) { return entry.logLevel === 'error'; })).toEqual([]);
+                    warnings = service.entries.filter(function (entry) { return entry.logLevel === 'warn'; });
+                    expect(warnings).toHaveLength(1);
+                    expect(warnings[0].obj).toMatchObject({ status: 404, functionName: 'FileStorageService.getFileData' });
+                    expect(consoleError).not.toHaveBeenCalled();
+                    // And never the original, at any door.
+                    expect([signedRoute.redirectUrl, proxyRoute.body]).toEqual([undefined, 'File not found']);
+                    return [3 /*break*/, 5];
+                case 4:
+                    consoleError.mockRestore();
+                    return [7 /*endfinally*/];
+                case 5: return [2 /*return*/];
+            }
+        });
+    }); });
+    it("ONE BODY TOO: every door answers the words a missing file gets — \"File not found\" — never the maker's reason, the file's id or its owner; the reason stays on the server, in the storage's one WARN", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, file, signed, _b, service, proxyRoute, serverSide, signedRoute, read, _i, _c, words, storageWarnings;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, refusedFile('one-body.jpg')];
+                case 1:
+                    _a = _d.sent(), file = _a.file, signed = _a.signed;
+                    return [4 /*yield*/, askEveryDoor(file, signed)];
+                case 2:
+                    _b = _d.sent(), service = _b.service, proxyRoute = _b.proxyRoute, serverSide = _b.serverSide, signedRoute = _b.signedRoute;
+                    read = [service.body, signedRoute.body, proxyRoute.body, serverSide === null || serverSide === void 0 ? void 0 : serverSide.message];
+                    expect(read).toEqual([{ error: 'File not found' }, 'File not found', 'File not found', 'File not found']);
+                    for (_i = 0, _c = read.map(function (answer) { return JSON.stringify(answer); }); _i < _c.length; _i++) {
+                        words = _c[_i];
+                        expect(words).not.toContain(MAKER_REASON);
+                        expect(words).not.toContain(file.id);
+                        expect(words).not.toContain('owner');
+                    }
+                    storageWarnings = service.storageEntries.filter(function (entry) { return entry.logLevel === 'warn'; });
+                    expect(storageWarnings).toHaveLength(1);
+                    expect(storageWarnings[0].obj).toEqual({ fileId: file.id, reason: MAKER_REASON });
+                    expect(__spreadArray(__spreadArray([], service.entries, true), service.storageEntries, true).filter(function (entry) { return entry.logLevel === 'error'; })).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("A MISS ANSWERS WHAT A REFUSAL ANSWERS: a file that is not there, and one the caller cannot reach, get the refused copy's status and body at every door — the browser service, the route in both shapes, the signed-URL mint — never the id", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, refused, proxy, signed, unreachable, notRoutine, answersFor, refusal, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, refusedFile('refused-beside-a-miss.jpg')];
+                case 1:
+                    _a = _d.sent(), refused = _a.file, proxy = _a.proxy, signed = _a.signed;
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, createOwnerFile('not-theirs.jpg', 'image/jpeg')];
+                case 2:
+                    unreachable = _d.sent();
+                    signed.store.set(unreachable.id, proxy.store.get(unreachable.id));
+                    notRoutine = function (level) { return level === 'warn' || level === 'error'; };
+                    answersFor = function (fileId) { return __awaiter(void 0, void 0, void 0, function () {
+                        var service, proxyRoute, signedRoute, mint;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    testEnv.actAs(recipient);
+                                    testEnv.setDriver(proxy);
+                                    return [4 /*yield*/, invokeServiceDoor(fileId)];
+                                case 1:
+                                    service = _a.sent();
+                                    return [4 /*yield*/, invokeRoute(fileId)];
+                                case 2:
+                                    proxyRoute = _a.sent();
+                                    testEnv.setDriver(signed);
+                                    return [4 /*yield*/, invokeRoute(fileId)];
+                                case 3:
+                                    signedRoute = _a.sent();
+                                    return [4 /*yield*/, new FileStorage_1.FileStorage().getSignedUrl(fileId).then(function () { return undefined; }, function (error) { return error; })];
+                                case 4:
+                                    mint = _a.sent();
+                                    return [2 /*return*/, [
+                                            [service.status, service.body, service.entries.map(function (entry) { return entry.logLevel; }).filter(notRoutine)],
+                                            [proxyRoute.statusCode, proxyRoute.body, proxyRoute.redirectUrl],
+                                            [signedRoute.statusCode, signedRoute.body, signedRoute.redirectUrl],
+                                            [service_1.ServiceRefusal.is(mint) ? mint.status : 'not a refusal', mint === null || mint === void 0 ? void 0 : mint.message],
+                                        ]];
+                            }
+                        });
+                    }); };
+                    return [4 /*yield*/, answersFor(refused.id)];
+                case 3:
+                    refusal = _d.sent();
+                    expect(refusal).toEqual([
+                        [404, { error: 'File not found' }, ['warn']],
+                        [404, 'File not found', undefined],
+                        [404, 'File not found', undefined],
+                        [404, 'File not found'],
+                    ]);
+                    _b = expect;
+                    return [4 /*yield*/, answersFor(unreachable.id)];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toEqual(refusal);
+                    _c = expect;
+                    return [4 /*yield*/, answersFor('no-such-file')];
+                case 5:
+                    _c.apply(void 0, [_d.sent()]).toEqual(refusal);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+//# sourceMappingURL=FileCopyForOthers.test.js.map