feat(source-memory): support writing with metadata

packages/source-memory/src/__test__/source.memory.test.ts

@@ -17,6 +17,17 @@ o.spec('FsMemory', () => {
     o(b.toString()).equals('a');
   });
 
+  o('should write with metadata', async () => {
+    await memory.write('memory://foo.png', Buffer.from('a'), {
+      contentType: 'text/plain',
+      metadata: { 'X-LINZ-TEST': '123' },
+    });
+
+    const head = await memory.head('memory://foo.png');
+    o(head?.contentType).equals('text/plain');
+    o(head?.metadata).deepEquals({ 'X-LINZ-TEST': '123' });
+  });
+
   o('should stream files', async () => {
     await memory.write('memory://foo.png', Buffer.from('a'));
 

packages/source-memory/src/memory.fs.ts

@@ -1,11 +1,17 @@
-import { CompositeError, FileInfo, FileSystem, ListOptions, SourceMemory } from '@chunkd/core';
+import { CompositeError, FileInfo, FileSystem, ListOptions, SourceMemory, WriteOptions } from '@chunkd/core';
 import { Readable } from 'stream';
 
 export function toReadable(r: string | Buffer | Readable): Readable {
   if (typeof r === 'string') r = Buffer.from(r);
   return Readable.from(r);
 }
 
+async function getBuffer(buffer: string | Buffer | Readable): Promise<Buffer> {
+  if (typeof buffer === 'string') return Buffer.from(buffer);
+  if (Buffer.isBuffer(buffer)) return buffer;
+  return await toBuffer(buffer);
+}
+
 export async function toBuffer(stream: Readable): Promise<Buffer> {
   return new Promise<Buffer>((resolve, reject) => {
     const buf: Buffer[] = [];
@@ -19,31 +25,22 @@ export async function toBuffer(stream: Readable): Promise<Buffer> {
 export class FsMemory implements FileSystem<SourceMemory> {
   protocol = 'memory';
 
-  files: Map<string, Buffer> = new Map();
+  files: Map<string, { buffer: Buffer; opts?: WriteOptions }> = new Map();
 
   async read(filePath: string): Promise<Buffer> {
     const data = this.files.get(filePath);
     if (data == null) throw new CompositeError('Not found', 404, new Error());
-    return data;
+    return data.buffer;
   }
 
   stream(filePath: string): Readable {
     const buf = this.files.get(filePath);
     if (buf == null) throw new CompositeError('Not found', 404, new Error());
-    return toReadable(buf);
+    return toReadable(buf.buffer);
   }
 
-  async write(filePath: string, buffer: string | Buffer | Readable): Promise<void> {
-    if (typeof buffer === 'string') {
-      this.files.set(filePath, Buffer.from(buffer));
-      return;
-    }
-    if (Buffer.isBuffer(buffer)) {
-      this.files.set(filePath, buffer);
-      return;
-    }
-    const buf = await toBuffer(buffer);
-    this.files.set(filePath, buf);
+  async write(filePath: string, buffer: string | Buffer | Readable, opts?: WriteOptions): Promise<void> {
+    this.files.set(filePath, { opts: opts, buffer: await getBuffer(buffer) });
   }
 
   async *list(filePath: string, opt?: ListOptions): AsyncGenerator<string> {
@@ -84,19 +81,25 @@ export class FsMemory implements FileSystem<SourceMemory> {
   }
 
   async head(filePath: string): Promise<FileInfo | null> {
-    const buf = this.files.get(filePath);
-    if (buf == null) return null;
-    return { path: filePath, size: buf.length };
+    const obj = this.files.get(filePath);
+    if (obj == null) return null;
+    return {
+      path: filePath,
+      size: obj.buffer.length,
+      metadata: obj.opts?.metadata,
+      contentType: obj.opts?.contentType,
+      contentEncoding: obj.opts?.contentEncoding,
+    };
   }
 
   async delete(filePath: string): Promise<void> {
     this.files.delete(filePath);
   }
 
   source(filePath: string): SourceMemory {
-    const bytes = this.files.get(filePath);
-    if (bytes == null) throw new CompositeError('File not found', 404, new Error());
-    const source = new SourceMemory(filePath, bytes);
+    const obj = this.files.get(filePath);
+    if (obj == null) throw new CompositeError('File not found', 404, new Error());
+    const source = new SourceMemory(filePath, obj.buffer);
     return source;
   }
 }