feat: adding polyfill for Storage API for local server

Author: jcbsfilho

lib/build/bundlers/esbuild/plugins/node-polyfills/index.js

@@ -49,7 +49,9 @@ const ESBuildNodeModulePlugin = (buildProd) => {
         options.external = options.external || [];
         [...polyfillManager.external].forEach(([key]) => {
           options.external.push(key);
-          options.external.push(`node:${key}`);
+          if (!key.includes('azion:')) {
+            options.external.push(`node:${key}`);
+          }
         });
       }
 

lib/build/bundlers/polyfills/polyfills-manager.js

@@ -150,6 +150,10 @@ class PolyfillsManager {
       'async_hooks',
       `${externalPolyfillsPath}/async_hooks/index.js`,
     );
+    this.setExternal(
+      'azion:storage',
+      `${externalPolyfillsPath}/azion/storage/index.js`,
+    );
 
     return {
       libs: this.libs,

lib/env/polyfills/azion/storage/context/index.js

@@ -0,0 +1,72 @@
+/* eslint-disable */
+import fs from 'fs';
+import path from 'path';
+import mime from 'mime-types';
+import { pipeline } from 'stream/promises';
+
+class StorageContext {
+  #pathBucket;
+  constructor(bucketName, storagePath) {
+    this.bucketName = bucketName;
+    const _storagePath = storagePath || '.edge/storage';
+    this.#pathBucket = `${_storagePath}/${bucketName}`;
+  }
+
+  async get(key, options) {
+    try {
+      const item = await fs.promises.readFile(`${this.#pathBucket}/${key}`);
+      return StorageContext.makeAsset(key, item);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async put(key, value, options) {
+    try {
+      const prefix = path.dirname(key);
+      await fs.promises.mkdir(`${this.#pathBucket}${prefix}`, {
+        recursive: true,
+      });
+
+      if (value instanceof ReadableStream) {
+        const writeStream = fs.createWriteStream(`${this.#pathBucket}${key}`);
+        await pipeline(value, writeStream);
+      } else {
+        await fs.promises.writeFile(`${this.#pathBucket}${key}`, value);
+      }
+      return StorageContext.makeAsset(key, value);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async delete(key) {
+    try {
+      return await fs.promises.rm(`${this.#pathBucket}/${key}`);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async list() {
+    const pathBucketRoot = `${this.#pathBucket}/`;
+    try {
+      const files = await fs.promises.readdir(pathBucketRoot);
+      const paths = files.map((file) => {
+        return { key: path.join(pathBucketRoot, file) };
+      });
+      return { key_list: paths };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  static makeAsset(key, file) {
+    const contentType = mime.lookup(key) || 'application/octet-stream';
+    const contentLength = file.length;
+    const metadata = {};
+    return { contentRid: file, contentType, contentLength, metadata };
+  }
+}
+
+export default StorageContext;

lib/env/polyfills/azion/storage/index.js

@@ -0,0 +1,85 @@
+/* eslint-disable */
+
+const PRIVATE_CONSTRUCTOR = Symbol('PRIVATE_CONSTRUCTOR');
+export default class Storage {
+  #bucketName;
+  constructor(bucketName) {
+    if (typeof bucketName !== 'string') {
+      throw new Error('bucketName must be a string');
+    }
+    this.#bucketName = bucketName;
+  }
+
+  async get(key, options) {
+    const asset = await new STORAGE_CONTEXT(this.#bucketName).get(key, options);
+    return new StorageObject(asset, PRIVATE_CONSTRUCTOR);
+  }
+
+  async put(key, value, options) {
+    const asset = await new STORAGE_CONTEXT(this.#bucketName).put(
+      key,
+      value,
+      options,
+    );
+    return new StorageObject(asset, PRIVATE_CONSTRUCTOR);
+  }
+
+  async delete(key) {
+    return await new STORAGE_CONTEXT(this.#bucketName).delete(key);
+  }
+
+  async list(path) {
+    let asset_list = await new STORAGE_CONTEXT(this.#bucketName).list();
+    return new StorageObjectList(asset_list?.key_list, PRIVATE_CONSTRUCTOR);
+  }
+}
+
+export class StorageObject {
+  #metadata;
+  #contentType;
+  #contentLength;
+  #content;
+  constructor(asset, privateConstructor) {
+    if (privateConstructor !== PRIVATE_CONSTRUCTOR) {
+      throw new Error('StorageObject constructor is private.');
+    }
+    let { contentRid, contentLength, contentType, metadata } = asset;
+
+    this.#content = contentRid;
+    this.#contentLength = contentLength;
+
+    if (metadata === null) {
+      // if metadata is null, set it to an empty Map.
+      this.#metadata = new Map();
+    } else {
+      this.#metadata = new Map(Object.entries(metadata));
+    }
+    this.#contentType = contentType;
+  }
+  get content() {
+    return this.#content.toString();
+  }
+  async arrayBuffer() {
+    return this.#content;
+  }
+  get metadata() {
+    return this.#metadata;
+  }
+  get contentType() {
+    return this.#contentType;
+  }
+  get contentLength() {
+    return this.#contentLength;
+  }
+}
+
+export class StorageObjectList {
+  entries;
+
+  constructor(list, privateConstructor) {
+    if (privateConstructor !== PRIVATE_CONSTRUCTOR) {
+      throw new Error('StorageObjectList constructor is private.');
+    }
+    this.entries = list;
+  }
+}

lib/env/polyfills/index.js

@@ -1,5 +1,6 @@
 import fetchPolyfill from './fetch/fetch.polyfills.js';
 import FetchEventPolyfill from './fetch/FetchEvent.polyfills.js';
 import AsyncHooks from './async_hooks/context/index.js';
+import StorageContext from './azion/storage/context/index.js';
 
-export { fetchPolyfill, FetchEventPolyfill, AsyncHooks };
+export { fetchPolyfill, FetchEventPolyfill, AsyncHooks, StorageContext };

lib/env/runtime.env.js

@@ -4,6 +4,7 @@ import {
   fetchPolyfill,
   FetchEventPolyfill,
   AsyncHooks,
+  StorageContext,
 } from './polyfills/index.js';
 
 /**
@@ -63,6 +64,9 @@ function runtime(code) {
     // Async Hooks
     context.ASYNC_LOCAL_STORAGE = AsyncHooks;
 
+    // Storage Context
+    context.STORAGE_CONTEXT = StorageContext;
+
     return context;
   };