@terreno/admin-backend 0.10.0 → 0.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,540 @@
1
+ import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
2
+ import {PassThrough} from "node:stream";
3
+
4
+ // Mock @google-cloud/storage BEFORE importing anything that depends on it.
5
+ interface MockedFile {
6
+ save: ReturnType<typeof mock>;
7
+ getMetadata: ReturnType<typeof mock>;
8
+ createReadStream: ReturnType<typeof mock>;
9
+ delete: ReturnType<typeof mock>;
10
+ name: string;
11
+ metadata: Record<string, unknown>;
12
+ }
13
+
14
+ interface BucketBehavior {
15
+ getFiles?: ReturnType<typeof mock>;
16
+ fileFactory?: (name: string) => MockedFile;
17
+ }
18
+
19
+ const bucketBehavior: BucketBehavior = {};
20
+
21
+ mock.module("@google-cloud/storage", () => {
22
+ class Storage {
23
+ bucket(name: string) {
24
+ void name;
25
+ return {
26
+ file: (path: string) => {
27
+ if (bucketBehavior.fileFactory) {
28
+ return bucketBehavior.fileFactory(path);
29
+ }
30
+ return {
31
+ createReadStream: mock(() => {
32
+ const stream = new PassThrough();
33
+ setImmediate(() => {
34
+ stream.end("filecontent");
35
+ });
36
+ return stream;
37
+ }),
38
+ delete: mock(async () => [{}]),
39
+ getMetadata: mock(async () => [
40
+ {contentType: "application/pdf", etag: "etag", size: 11, updated: "now"},
41
+ ]),
42
+ metadata: {},
43
+ name: path,
44
+ save: mock(async () => undefined),
45
+ };
46
+ },
47
+ getFiles: bucketBehavior.getFiles ?? mock(async () => [[], null, {prefixes: []}]),
48
+ };
49
+ }
50
+ }
51
+ return {Storage};
52
+ });
53
+
54
+ import {
55
+ addAuthRoutes,
56
+ apiErrorMiddleware,
57
+ apiUnauthorizedMiddleware,
58
+ setupAuth,
59
+ type UserModel as UserModelType,
60
+ } from "@terreno/api";
61
+ import {authAsUser, getBaseServer, setupDb, UserModel} from "@terreno/api/src/tests";
62
+ import type express from "express";
63
+ import supertest from "supertest";
64
+ import type TestAgent from "supertest/lib/agent";
65
+
66
+ import type {DocumentStorageOptions} from "./documentStorageApp";
67
+ import {DocumentStorageApp} from "./documentStorageApp";
68
+
69
+ const buildApp = (options: DocumentStorageOptions): express.Application => {
70
+ const app = getBaseServer();
71
+ setupAuth(app, UserModel as unknown as UserModelType);
72
+ addAuthRoutes(app, UserModel as unknown as UserModelType);
73
+
74
+ new DocumentStorageApp(options).register(app);
75
+
76
+ app.use(apiUnauthorizedMiddleware);
77
+ app.use(apiErrorMiddleware);
78
+ return app;
79
+ };
80
+
81
+ describe("DocumentStorageApp", () => {
82
+ let app: express.Application;
83
+ let adminAgent: TestAgent;
84
+ let notAdminAgent: TestAgent;
85
+
86
+ beforeEach(async () => {
87
+ await setupDb();
88
+ bucketBehavior.getFiles = undefined;
89
+ bucketBehavior.fileFactory = undefined;
90
+ app = buildApp({bucketName: "test-bucket", folderPrefix: "tenant/"});
91
+ adminAgent = await authAsUser(app, "admin");
92
+ notAdminAgent = await authAsUser(app, "notAdmin");
93
+ });
94
+
95
+ afterEach(() => {
96
+ bucketBehavior.getFiles = undefined;
97
+ bucketBehavior.fileFactory = undefined;
98
+ });
99
+
100
+ describe("GET /documents/", () => {
101
+ it("lists files and folders", async () => {
102
+ bucketBehavior.getFiles = mock(async () => [
103
+ [
104
+ {
105
+ metadata: {contentType: "application/pdf", size: "2048", updated: "2024-01-01"},
106
+ name: "tenant/report.pdf",
107
+ },
108
+ {
109
+ metadata: {contentType: "image/png", size: "500", updated: "2024-01-02"},
110
+ name: "tenant/logo.png",
111
+ },
112
+ // Should be excluded because it equals fullPrefix
113
+ {metadata: {size: "0", updated: ""}, name: "tenant/"},
114
+ ],
115
+ null,
116
+ {prefixes: ["tenant/archive/", "tenant/photos/"]},
117
+ ]);
118
+
119
+ const res = await adminAgent.get("/documents/").expect(200);
120
+ expect(res.body.files).toHaveLength(2);
121
+ expect(res.body.files[0].name).toBe("report.pdf");
122
+ expect(res.body.files[0].fullPath).toBe("report.pdf");
123
+ expect(res.body.files[0].size).toBe(2048);
124
+ expect(res.body.folders).toEqual(["archive/", "photos/"]);
125
+ expect(res.body.prefix).toBe("");
126
+ });
127
+
128
+ it("supports a prefix query param", async () => {
129
+ bucketBehavior.getFiles = mock(async (opts: {prefix: string}) => {
130
+ expect(opts.prefix).toBe("tenant/archive/");
131
+ return [[], null, {prefixes: []}];
132
+ });
133
+ const res = await adminAgent.get("/documents/?prefix=archive/").expect(200);
134
+ expect(res.body.prefix).toBe("archive/");
135
+ });
136
+
137
+ it("returns empty folders array when no prefixes present", async () => {
138
+ bucketBehavior.getFiles = mock(async () => [[], null, undefined]);
139
+ const res = await adminAgent.get("/documents/").expect(200);
140
+ expect(res.body.folders).toEqual([]);
141
+ expect(res.body.files).toEqual([]);
142
+ });
143
+
144
+ it("returns 403 for non-admins", async () => {
145
+ await notAdminAgent.get("/documents/").expect(403);
146
+ });
147
+
148
+ it("returns 401 when unauthenticated", async () => {
149
+ await supertest(app).get("/documents/").expect(401);
150
+ });
151
+ });
152
+
153
+ describe("POST /documents/ (upload)", () => {
154
+ it("rejects when no file is provided", async () => {
155
+ const res = await adminAgent.post("/documents/").expect(400);
156
+ expect(res.body.title).toInclude("No file provided");
157
+ });
158
+
159
+ it("sanitizes filenames and uploads to the bucket", async () => {
160
+ const saved: {path?: string; body?: Buffer} = {};
161
+ bucketBehavior.fileFactory = (path: string) =>
162
+ ({
163
+ createReadStream: mock(() => new PassThrough()),
164
+ delete: mock(async () => [{}]),
165
+ getMetadata: mock(async () => [{}]),
166
+ metadata: {},
167
+ name: path,
168
+ save: mock(async (body: Buffer) => {
169
+ saved.path = path;
170
+ saved.body = body;
171
+ }),
172
+ }) as unknown as MockedFile;
173
+
174
+ const res = await adminAgent
175
+ .post("/documents/")
176
+ .attach("file", Buffer.from("hello"), {
177
+ contentType: "application/pdf",
178
+ filename: "my doc!.pdf",
179
+ })
180
+ .field("prefix", "archive/")
181
+ .expect(200);
182
+
183
+ expect(res.body.name).toBe("my_doc_.pdf");
184
+ expect(res.body.fullPath).toBe("archive/my_doc_.pdf");
185
+ expect(saved.path).toBe("tenant/archive/my_doc_.pdf");
186
+ expect(saved.body?.toString()).toBe("hello");
187
+ });
188
+
189
+ it("rejects disallowed mime types via multer fileFilter", async () => {
190
+ await adminAgent
191
+ .post("/documents/")
192
+ .attach("file", Buffer.from("exec"), {
193
+ contentType: "application/x-sh",
194
+ filename: "bad.sh",
195
+ })
196
+ .expect(400);
197
+ });
198
+
199
+ it("uses options.allowedMimeTypes when provided", async () => {
200
+ app = buildApp({
201
+ allowedMimeTypes: ["text/plain"],
202
+ bucketName: "test-bucket",
203
+ });
204
+ const agent = await authAsUser(app, "admin");
205
+
206
+ await agent
207
+ .post("/documents/")
208
+ .attach("file", Buffer.from("pdf"), {
209
+ contentType: "application/pdf",
210
+ filename: "x.pdf",
211
+ })
212
+ .expect(400);
213
+
214
+ await agent
215
+ .post("/documents/")
216
+ .attach("file", Buffer.from("text"), {
217
+ contentType: "text/plain",
218
+ filename: "x.txt",
219
+ })
220
+ .expect(200);
221
+ });
222
+
223
+ it("returns 403 for non-admins", async () => {
224
+ await notAdminAgent
225
+ .post("/documents/")
226
+ .attach("file", Buffer.from("x"), {contentType: "text/plain", filename: "x.txt"})
227
+ .expect(403);
228
+ });
229
+ });
230
+
231
+ describe("GET /documents/download/*filepath", () => {
232
+ it("handles a successful download request by invoking pipeline", async () => {
233
+ // Use Readable.from so pipeline() sees a well-behaved stream that emits
234
+ // a single buffer and ends cleanly, giving a deterministic 200.
235
+ bucketBehavior.fileFactory = (path: string) =>
236
+ ({
237
+ createReadStream: mock(() => {
238
+ const stream = new PassThrough();
239
+ setImmediate(() => {
240
+ stream.end(Buffer.from("DOWNLOADED"));
241
+ });
242
+ return stream;
243
+ }),
244
+ delete: mock(async () => [{}]),
245
+ getMetadata: mock(async () => [{contentType: "text/plain", size: 10, updated: "now"}]),
246
+ metadata: {},
247
+ name: path,
248
+ save: mock(async () => undefined),
249
+ }) as unknown as MockedFile;
250
+
251
+ const res = await adminAgent.get("/documents/download/readme.txt").expect(200);
252
+ expect(res.headers["content-type"]).toInclude("text/plain");
253
+ expect(res.headers["content-disposition"]).toInclude("readme.txt");
254
+ expect(res.headers["content-length"]).toBe("10");
255
+ expect(res.text).toBe("DOWNLOADED");
256
+ });
257
+
258
+ it("defaults content-type to application/octet-stream when not provided", async () => {
259
+ bucketBehavior.fileFactory = () =>
260
+ ({
261
+ createReadStream: mock(() => {
262
+ const stream = new PassThrough();
263
+ setImmediate(() => {
264
+ stream.end(Buffer.from("blob"));
265
+ });
266
+ return stream;
267
+ }),
268
+ delete: mock(async () => [{}]),
269
+ getMetadata: mock(async () => [{}]),
270
+ metadata: {},
271
+ name: "blob",
272
+ save: mock(async () => undefined),
273
+ }) as unknown as MockedFile;
274
+
275
+ const res = await adminAgent.get("/documents/download/some.bin").expect(200);
276
+ expect(res.headers["content-type"]).toInclude("application/octet-stream");
277
+ // No Content-Length header when size is missing from metadata
278
+ expect(res.headers["content-length"]).toBeUndefined();
279
+ });
280
+
281
+ it("returns 404 when metadata lookup fails with code 404", async () => {
282
+ bucketBehavior.fileFactory = () =>
283
+ ({
284
+ createReadStream: mock(() => new PassThrough()),
285
+ delete: mock(async () => [{}]),
286
+ getMetadata: mock(async () => {
287
+ const err: Error & {code?: number} = new Error("not found");
288
+ err.code = 404;
289
+ throw err;
290
+ }),
291
+ metadata: {},
292
+ name: "x",
293
+ save: mock(async () => undefined),
294
+ }) as unknown as MockedFile;
295
+
296
+ const res = await adminAgent.get("/documents/download/missing.pdf").expect(404);
297
+ expect(res.body.title).toInclude("File not found");
298
+ });
299
+
300
+ it("returns 500 for other metadata errors", async () => {
301
+ bucketBehavior.fileFactory = () =>
302
+ ({
303
+ createReadStream: mock(() => new PassThrough()),
304
+ delete: mock(async () => [{}]),
305
+ getMetadata: mock(async () => {
306
+ const err: Error & {code?: number} = new Error("broken");
307
+ err.code = 500;
308
+ throw err;
309
+ }),
310
+ metadata: {},
311
+ name: "x",
312
+ save: mock(async () => undefined),
313
+ }) as unknown as MockedFile;
314
+
315
+ const res = await adminAgent.get("/documents/download/boom.pdf").expect(500);
316
+ expect(res.body.title).toInclude("Failed to access file");
317
+ });
318
+
319
+ it("logs and swallows stream errors once headers have been flushed", async () => {
320
+ // When bytes have already started streaming, res.headersSent is true by
321
+ // the time pipeline() rejects and the route must NOT attempt to throw a
322
+ // new APIError. We exercise that branch by writing a chunk before
323
+ // destroying the source; the connection is forcibly closed mid-response
324
+ // so supertest may surface ECONNRESET — both a completed status and a
325
+ // socket error prove the pipeline-error catch ran without re-sending
326
+ // headers.
327
+ const createReadStreamMock = mock(() => {
328
+ const stream = new PassThrough();
329
+ setImmediate(() => {
330
+ stream.write(Buffer.from("partial"));
331
+ setImmediate(() => stream.destroy(new Error("pipe broken")));
332
+ });
333
+ return stream;
334
+ });
335
+ bucketBehavior.fileFactory = () =>
336
+ ({
337
+ createReadStream: createReadStreamMock,
338
+ delete: mock(async () => [{}]),
339
+ getMetadata: mock(async () => [{contentType: "text/plain", updated: "now"}]),
340
+ metadata: {},
341
+ name: "x",
342
+ save: mock(async () => undefined),
343
+ }) as unknown as MockedFile;
344
+
345
+ let status: number | undefined;
346
+ let caught: unknown;
347
+ try {
348
+ const res = await adminAgent.get("/documents/download/problem.txt");
349
+ status = res.status;
350
+ } catch (err: unknown) {
351
+ caught = err;
352
+ }
353
+
354
+ // Either supertest sees a completed response (200/500) or the socket is
355
+ // reset after partial data. Both outcomes prove we exercised the route
356
+ // and its pipeline-error catch branch without crashing the process.
357
+ if (caught) {
358
+ expect(String(caught)).toMatch(/ECONNRESET|socket|aborted/i);
359
+ } else {
360
+ expect(status).toBeDefined();
361
+ expect([200, 500]).toContain(status as number);
362
+ }
363
+ expect(createReadStreamMock).toHaveBeenCalled();
364
+ });
365
+
366
+ it("returns 403 for non-admins", async () => {
367
+ await notAdminAgent.get("/documents/download/doc.pdf").expect(403);
368
+ });
369
+ });
370
+
371
+ describe("POST /documents/folder", () => {
372
+ it("rejects missing folder name", async () => {
373
+ const res = await adminAgent.post("/documents/folder").send({}).expect(400);
374
+ expect(res.body.title).toInclude("Folder name is required");
375
+ });
376
+
377
+ it("sanitizes folder names and writes a placeholder blob", async () => {
378
+ const saved: {path?: string} = {};
379
+ bucketBehavior.fileFactory = (path: string) =>
380
+ ({
381
+ createReadStream: mock(() => new PassThrough()),
382
+ delete: mock(async () => [{}]),
383
+ getMetadata: mock(async () => [{}]),
384
+ metadata: {},
385
+ name: path,
386
+ save: mock(async () => {
387
+ saved.path = path;
388
+ }),
389
+ }) as unknown as MockedFile;
390
+
391
+ const res = await adminAgent
392
+ .post("/documents/folder")
393
+ .send({folderName: "My Folder!", prefix: "archive/"})
394
+ .expect(200);
395
+ expect(res.body.folder).toBe("archive/My_Folder_/");
396
+ expect(saved.path).toBe("tenant/archive/My_Folder_/");
397
+ });
398
+
399
+ it("treats prefix as optional", async () => {
400
+ const res = await adminAgent.post("/documents/folder").send({folderName: "Root"}).expect(200);
401
+ expect(res.body.folder).toBe("Root/");
402
+ });
403
+ });
404
+
405
+ describe("DELETE /documents/folder/*folderpath", () => {
406
+ it("deletes all files under the given folder", async () => {
407
+ const deleted: string[] = [];
408
+ bucketBehavior.getFiles = mock(async () => [
409
+ [
410
+ {
411
+ delete: mock(async () => {
412
+ deleted.push("tenant/archive/a.pdf");
413
+ return [{}];
414
+ }),
415
+ metadata: {},
416
+ name: "tenant/archive/a.pdf",
417
+ },
418
+ {
419
+ delete: mock(async () => {
420
+ deleted.push("tenant/archive/b.pdf");
421
+ return [{}];
422
+ }),
423
+ metadata: {},
424
+ name: "tenant/archive/b.pdf",
425
+ },
426
+ ],
427
+ null,
428
+ {prefixes: []},
429
+ ]);
430
+
431
+ const res = await adminAgent.delete("/documents/folder/archive").expect(200);
432
+ expect(res.body.success).toBe(true);
433
+ expect(deleted.sort()).toEqual(["tenant/archive/a.pdf", "tenant/archive/b.pdf"]);
434
+ });
435
+ });
436
+
437
+ describe("DELETE /documents/*filepath", () => {
438
+ it("deletes a single file", async () => {
439
+ let deletedPath: string | undefined;
440
+ bucketBehavior.fileFactory = (path: string) =>
441
+ ({
442
+ createReadStream: mock(() => new PassThrough()),
443
+ delete: mock(async () => {
444
+ deletedPath = path;
445
+ return [{}];
446
+ }),
447
+ getMetadata: mock(async () => [{}]),
448
+ metadata: {},
449
+ name: path,
450
+ save: mock(async () => undefined),
451
+ }) as unknown as MockedFile;
452
+
453
+ const res = await adminAgent.delete("/documents/report.pdf").expect(200);
454
+ expect(res.body.success).toBe(true);
455
+ expect(deletedPath).toBe("tenant/report.pdf");
456
+ });
457
+
458
+ it("returns 403 for non-admins", async () => {
459
+ await notAdminAgent.delete("/documents/x.pdf").expect(403);
460
+ });
461
+ });
462
+
463
+ describe("configuration edge cases", () => {
464
+ it("throws a 503 when no bucketName is configured", async () => {
465
+ const originalBucket = process.env.GCS_BUCKET;
466
+ process.env.GCS_BUCKET = "";
467
+ app = buildApp({bucketName: ""});
468
+ const agent = await authAsUser(app, "admin");
469
+ const res = await agent.get("/documents/").expect(503);
470
+ expect(res.body.title).toInclude("Storage not configured");
471
+ if (originalBucket !== undefined) {
472
+ process.env.GCS_BUCKET = originalBucket;
473
+ } else {
474
+ delete process.env.GCS_BUCKET;
475
+ }
476
+ });
477
+
478
+ it("falls back to GCS_BUCKET env var when bucketName is falsy", async () => {
479
+ const originalBucket = process.env.GCS_BUCKET;
480
+ process.env.GCS_BUCKET = "env-bucket";
481
+ app = buildApp({bucketName: ""});
482
+ const agent = await authAsUser(app, "admin");
483
+ bucketBehavior.getFiles = mock(async () => [[], null, {prefixes: []}]);
484
+ await agent.get("/documents/").expect(200);
485
+ if (originalBucket !== undefined) {
486
+ process.env.GCS_BUCKET = originalBucket;
487
+ } else {
488
+ delete process.env.GCS_BUCKET;
489
+ }
490
+ });
491
+
492
+ it("defaults folderPrefix to empty string", async () => {
493
+ app = buildApp({bucketName: "b"});
494
+ const agent = await authAsUser(app, "admin");
495
+ bucketBehavior.getFiles = mock(async (opts: {prefix: string}) => {
496
+ expect(opts.prefix).toBe("");
497
+ return [[], null, {prefixes: []}];
498
+ });
499
+ await agent.get("/documents/").expect(200);
500
+ });
501
+
502
+ it("defaults basePath to /documents when not provided", async () => {
503
+ app = buildApp({bucketName: "b"});
504
+ const agent = await authAsUser(app, "admin");
505
+ bucketBehavior.getFiles = mock(async () => [[], null, {prefixes: []}]);
506
+ await agent.get("/documents/").expect(200);
507
+ });
508
+
509
+ it("supports a custom basePath", async () => {
510
+ app = buildApp({basePath: "/files", bucketName: "b"});
511
+ const agent = await authAsUser(app, "admin");
512
+ bucketBehavior.getFiles = mock(async () => [[], null, {prefixes: []}]);
513
+ await agent.get("/files/").expect(200);
514
+ });
515
+
516
+ it("accepts a maxFileSize option without rejecting normal-sized files", async () => {
517
+ app = buildApp({bucketName: "b", maxFileSize: 1024});
518
+ const agent = await authAsUser(app, "admin");
519
+ const saved: {path?: string} = {};
520
+ bucketBehavior.fileFactory = (path: string) =>
521
+ ({
522
+ createReadStream: mock(() => new PassThrough()),
523
+ delete: mock(async () => [{}]),
524
+ getMetadata: mock(async () => [{}]),
525
+ metadata: {},
526
+ name: path,
527
+ save: mock(async () => {
528
+ saved.path = path;
529
+ }),
530
+ }) as unknown as MockedFile;
531
+
532
+ const res = await agent.post("/documents/").attach("file", Buffer.from("small"), {
533
+ contentType: "text/plain",
534
+ filename: "small.txt",
535
+ });
536
+ expect(res.status).toBe(200);
537
+ expect(saved.path).toBe("small.txt");
538
+ });
539
+ });
540
+ });