@proteinjs/db-file 1.8.3 → 1.9.0

package/test/FileMediaMetadata.test.ts

@@ -60,6 +60,49 @@ describe('File media metadata columns', () => {
     expect(row.durationMs).toEqual(24_500);
   });
 
+  it('round-trips the producer attribution — how the bytes came to exist (`origin`)', async () => {
+    const file = await new FileStorage().createFile(
+      { name: 'frame.png', type: 'image/png', size: 4, width: 1440, height: 900, origin: 'mockup' } as File,
+      Buffer.from('png!').toString('base64')
+    );
+
+    const row = await getDbAsSystem().get(tables.File, { id: file.id });
+    expect(row.origin).toEqual('mockup');
+    // Absent for everything that does not state its producer (a NULL column reads back empty).
+    const plain = await new FileStorage().createFile(
+      { name: 'note.txt', type: 'text/plain', size: 2 } as File,
+      Buffer.from('hi').toString('base64')
+    );
+    expect((await getDbAsSystem().get(tables.File, { id: plain.id })).origin).toBeFalsy();
+  });
+
+  it('round-trips the model beside the producer — which model made the bytes (`originModel`), only where one did', async () => {
+    const made = await new FileStorage().createFile(
+      {
+        name: 'mark.png',
+        type: 'image/png',
+        size: 4,
+        width: 1024,
+        height: 1024,
+        origin: 'generation',
+        originModel: 'example-image-model-1',
+      } as File,
+      Buffer.from('mark').toString('base64')
+    );
+    const madeRow = await getDbAsSystem().get(tables.File, { id: made.id });
+    expect(madeRow.origin).toEqual('generation');
+    expect(madeRow.originModel).toEqual('example-image-model-1');
+
+    // A producer that is not a model states its kind and no model: the two columns are independent.
+    const uploaded = await new FileStorage().createFile(
+      { name: 'photo.jpg', type: 'image/jpeg', size: 5, origin: 'upload' } as File,
+      Buffer.from('photo').toString('base64')
+    );
+    const uploadedRow = await getDbAsSystem().get(tables.File, { id: uploaded.id });
+    expect(uploadedRow.origin).toEqual('upload');
+    expect(uploadedRow.originModel).toBeFalsy();
+  });
+
   it('round-trips the rights record on a web-saved copy — licence name, deed URL and the credit sentence', async () => {
     const file = await new FileStorage().createFile(
       {
@@ -97,5 +140,6 @@ describe('File media metadata columns', () => {
     expect(row.durationMs ?? undefined).toBeUndefined();
     expect(row.license ?? undefined).toBeUndefined();
     expect(row.attribution ?? undefined).toBeUndefined();
+    expect(row.originModel ?? undefined).toBeUndefined();
   });
 });

package/test/FileStorageError.test.ts

@@ -0,0 +1,79 @@
+import util from 'util';
+import { FileStorageError } from '../src/FileStorageError';
+
+/** An obviously fake credential — what a store client's error carries in its request headers. */
+const MARKER = 'FAKE-TOKEN-MARKER';
+
+/**
+ * What a driver's error carries is the driver's to own: a code, a plain message, the HTTP status.
+ * Whatever a caller does with one — print it, serialise it, inspect it — reads those three facts.
+ */
+describe('FileStorageError', () => {
+  it('carries the code, a plain message and the status — and nothing else', () => {
+    const error = new FileStorageError('not-found', 'getFileData failed for file file-1', {
+      status: 404,
+      detail: 'No such object: a-bucket/file-1',
+    });
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error.code).toEqual('not-found');
+    expect(error.status).toEqual(404);
+    expect(error.message).toEqual(
+      'getFileData failed for file file-1: not-found (HTTP 404) — No such object: a-bucket/file-1'
+    );
+    expect(Object.keys(error).sort()).toEqual(['code', 'name', 'status']);
+    expect(Object.getOwnPropertyNames(error).sort()).toEqual(['code', 'message', 'name', 'stack', 'status']);
+  });
+
+  it('never reads an object into its message — only text is kept as the store’s detail', () => {
+    const vendorError = { message: 'boom', config: { headers: { Authorization: `Bearer ${MARKER}` } } };
+
+    const error = new FileStorageError('unknown', 'createFile failed for file file-2', { detail: vendorError });
+
+    expect(error.message).toEqual('createFile failed for file file-2: unknown');
+    expect(util.inspect(error, { depth: null, showHidden: true })).not.toContain(MARKER);
+  });
+
+  it('keeps a store’s text plain: one line, bounded, no URL query string, no bearer credential', () => {
+    const detail =
+      `Request to https://storage.example/b/a-bucket/o/file-3?X-Goog-Signature=${MARKER}&X-Goog-Expires=900 failed\n` +
+      `with headers Authorization: Bearer ${MARKER} ` +
+      'x'.repeat(1000);
+
+    const error = new FileStorageError('unavailable', 'getSignedUrl failed for file file-3', { status: 503, detail });
+
+    expect(error.message).not.toContain(MARKER);
+    expect(error.message).not.toContain('\n');
+    expect(error.message).toContain('https://storage.example/b/a-bucket/o/file-3 failed');
+    expect(error.message).toContain('Bearer [masked]');
+    expect(error.message.length).toBeLessThan(400);
+  });
+
+  it('is recognised by its shape, so a copy from a duplicate package still reads as not-found', () => {
+    const fromAnotherCopy = Object.assign(new Error('getFileData failed'), {
+      name: 'FileStorageError',
+      code: 'not-found',
+    });
+
+    expect(FileStorageError.is(fromAnotherCopy)).toBe(true);
+    expect(FileStorageError.isNotFound(fromAnotherCopy)).toBe(true);
+    expect(FileStorageError.isNotFound(new FileStorageError('forbidden', 'getFileData failed'))).toBe(false);
+    expect(FileStorageError.is(Object.assign(new Error('a vendor error'), { code: 404 }))).toBe(false);
+    expect(FileStorageError.is(Object.assign(new Error('x'), { name: 'FileStorageError', code: 'made-up' }))).toBe(
+      false
+    );
+    expect(FileStorageError.is(undefined)).toBe(false);
+  });
+
+  it('reads one HTTP status one way', () => {
+    expect(FileStorageError.codeForStatus(404)).toEqual('not-found');
+    expect(FileStorageError.codeForStatus(412)).toEqual('precondition-failed');
+    expect(FileStorageError.codeForStatus(401)).toEqual('forbidden');
+    expect(FileStorageError.codeForStatus(403)).toEqual('forbidden');
+    expect(FileStorageError.codeForStatus(408)).toEqual('unavailable');
+    expect(FileStorageError.codeForStatus(429)).toEqual('unavailable');
+    expect(FileStorageError.codeForStatus(503)).toEqual('unavailable');
+    expect(FileStorageError.codeForStatus(400)).toEqual('unknown');
+    expect(FileStorageError.codeForStatus(undefined)).toEqual('unknown');
+  });
+});

package/test/FileTestEnvironment.ts

@@ -62,6 +62,9 @@ export class FileTestEnvironment {
     // implementations from the generated source graph; a graph-less harness lookup THROWS).
     // Default: no registered resolvers. Suites exercising the seam overwrite this entry.
     objectCache['@proteinjs/db-file/FileReachabilityResolver'] = [];
+    // The copy-for-others seam a non-owner read consults (same graph-less rule). Default: no
+    // maker — everyone is served the original. Suites exercising the seam overwrite this entry.
+    objectCache['@proteinjs/db-file/FileCopyForOthers'] = [];
     Session.setData({
       sessionId: 'test-session',
       user: 'guest',