@hot-updater/aws 0.0.1 → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,184 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  aws: () => aws
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/aws.ts
+var import_path = __toESM(require("path"), 1);
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_lib_storage = require("@aws-sdk/lib-storage");
+var import_plugin_core = require("@hot-updater/plugin-core");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_mime = __toESM(require("mime"), 1);
+
+// src/utils/streamToString.ts
+var streamToString = (stream) => {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+};
+
+// src/aws.ts
+var aws = (config) => (_) => {
+  const { bucketName, ...s3Config } = config;
+  const client = new import_client_s3.S3Client(s3Config);
+  let updateSources = [];
+  return {
+    async commitUpdateSource() {
+      try {
+        const command = new import_client_s3.GetObjectCommand({
+          Bucket: bucketName,
+          Key: "update.json"
+        });
+        await client.send(command);
+      } catch (e) {
+        if (e instanceof import_client_s3.NoSuchKey) {
+          import_plugin_core.log.info("Creating new update.json");
+        } else {
+          throw e;
+        }
+      }
+      import_plugin_core.log.info("Uploading update.json");
+      const Key = "update.json";
+      const Body = JSON.stringify(updateSources);
+      const ContentType = import_mime.default.getType(Key) ?? void 0;
+      const upload = new import_lib_storage.Upload({
+        client,
+        params: {
+          ContentType,
+          Bucket: bucketName,
+          Key,
+          Body
+        }
+      });
+      await upload.done();
+    },
+    async updateUpdateSource(targetBundleVersion, newSource) {
+      updateSources = await this.getUpdateSources();
+      const targetIndex = updateSources.findIndex(
+        (u) => u.bundleVersion === targetBundleVersion
+      );
+      if (targetIndex === -1) {
+        throw new Error("target bundle version not found");
+      }
+      Object.assign(updateSources[targetIndex], newSource);
+    },
+    async appendUpdateSource(source) {
+      updateSources = await this.getUpdateSources();
+      updateSources.unshift(source);
+    },
+    async setUpdateSources(sources) {
+      updateSources = sources;
+    },
+    async getUpdateSources(refresh = false) {
+      if (updateSources.length > 0 && !refresh) {
+        return updateSources;
+      }
+      import_plugin_core.log.info("Getting update.json");
+      try {
+        const command = new import_client_s3.GetObjectCommand({
+          Bucket: bucketName,
+          Key: "update.json"
+        });
+        const { Body: UpdateJsonBody } = await client.send(command);
+        const bodyContents = await streamToString(UpdateJsonBody);
+        const _updateSource = JSON.parse(bodyContents);
+        updateSources = _updateSource;
+        return _updateSource;
+      } catch (e) {
+        if (e instanceof import_client_s3.NoSuchKey) {
+          return [];
+        }
+        throw e;
+      }
+    },
+    async deleteBundle(platform, bundleVersion) {
+      const Key = [bundleVersion, platform].join("/");
+      const listCommand = new import_client_s3.ListObjectsV2Command({
+        Bucket: bucketName,
+        Prefix: `${bundleVersion}/${platform}`
+      });
+      const listResponse = await client.send(listCommand);
+      if (listResponse.Contents && listResponse.Contents.length > 0) {
+        const objectsToDelete = listResponse.Contents.map((obj) => ({
+          Key: obj.Key
+        }));
+        const deleteParams = {
+          Bucket: bucketName,
+          Delete: {
+            Objects: objectsToDelete,
+            Quiet: true
+          }
+        };
+        const deleteCommand = new import_client_s3.DeleteObjectsCommand(deleteParams);
+        await client.send(deleteCommand);
+        return Key;
+      }
+      import_plugin_core.log.error("Bundle Not Found");
+      throw new Error("Bundle Not Found");
+    },
+    async uploadBundle(platform, bundleVersion, bundlePath) {
+      import_plugin_core.log.info("Uploading Bundle");
+      const Body = await import_promises.default.readFile(bundlePath);
+      const ContentType = import_mime.default.getType(bundlePath) ?? void 0;
+      const filename = import_path.default.basename(bundlePath);
+      const Key = [bundleVersion, platform, filename].join("/");
+      const upload = new import_lib_storage.Upload({
+        client,
+        params: {
+          ContentType,
+          Bucket: bucketName,
+          Key,
+          Body
+        }
+      });
+      const response = await upload.done();
+      if (!response.Location) {
+        import_plugin_core.log.error("Upload Failed");
+        throw new Error("Upload Failed");
+      }
+      import_plugin_core.log?.info(`Uploaded: ${Key}`);
+      return {
+        file: response.Location
+      };
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aws
+});

package/dist/index.d.cts

@@ -0,0 +1,9 @@
+import { S3ClientConfig } from '@aws-sdk/client-s3';
+import { BasePluginArgs, DeployPlugin } from '@hot-updater/plugin-core';
+
+interface AwsConfig extends Pick<S3ClientConfig, "credentials" | "region"> {
+    bucketName: string;
+}
+declare const aws: (config: AwsConfig) => (_: BasePluginArgs) => DeployPlugin;
+
+export { type AwsConfig, aws };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { S3ClientConfig } from '@aws-sdk/client-s3';
+import { BasePluginArgs, DeployPlugin } from '@hot-updater/plugin-core';
+
+interface AwsConfig extends Pick<S3ClientConfig, "credentials" | "region"> {
+    bucketName: string;
+}
+declare const aws: (config: AwsConfig) => (_: BasePluginArgs) => DeployPlugin;
+
+export { type AwsConfig, aws };

package/dist/index.js

@@ -0,0 +1,155 @@
+// src/aws.ts
+import path from "path";
+import {
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  ListObjectsV2Command,
+  NoSuchKey,
+  S3Client
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import {
+  log
+} from "@hot-updater/plugin-core";
+import fs from "fs/promises";
+import mime from "mime";
+
+// src/utils/streamToString.ts
+var streamToString = (stream) => {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+};
+
+// src/aws.ts
+var aws = (config) => (_) => {
+  const { bucketName, ...s3Config } = config;
+  const client = new S3Client(s3Config);
+  let updateSources = [];
+  return {
+    async commitUpdateSource() {
+      try {
+        const command = new GetObjectCommand({
+          Bucket: bucketName,
+          Key: "update.json"
+        });
+        await client.send(command);
+      } catch (e) {
+        if (e instanceof NoSuchKey) {
+          log.info("Creating new update.json");
+        } else {
+          throw e;
+        }
+      }
+      log.info("Uploading update.json");
+      const Key = "update.json";
+      const Body = JSON.stringify(updateSources);
+      const ContentType = mime.getType(Key) ?? void 0;
+      const upload = new Upload({
+        client,
+        params: {
+          ContentType,
+          Bucket: bucketName,
+          Key,
+          Body
+        }
+      });
+      await upload.done();
+    },
+    async updateUpdateSource(targetBundleVersion, newSource) {
+      updateSources = await this.getUpdateSources();
+      const targetIndex = updateSources.findIndex(
+        (u) => u.bundleVersion === targetBundleVersion
+      );
+      if (targetIndex === -1) {
+        throw new Error("target bundle version not found");
+      }
+      Object.assign(updateSources[targetIndex], newSource);
+    },
+    async appendUpdateSource(source) {
+      updateSources = await this.getUpdateSources();
+      updateSources.unshift(source);
+    },
+    async setUpdateSources(sources) {
+      updateSources = sources;
+    },
+    async getUpdateSources(refresh = false) {
+      if (updateSources.length > 0 && !refresh) {
+        return updateSources;
+      }
+      log.info("Getting update.json");
+      try {
+        const command = new GetObjectCommand({
+          Bucket: bucketName,
+          Key: "update.json"
+        });
+        const { Body: UpdateJsonBody } = await client.send(command);
+        const bodyContents = await streamToString(UpdateJsonBody);
+        const _updateSource = JSON.parse(bodyContents);
+        updateSources = _updateSource;
+        return _updateSource;
+      } catch (e) {
+        if (e instanceof NoSuchKey) {
+          return [];
+        }
+        throw e;
+      }
+    },
+    async deleteBundle(platform, bundleVersion) {
+      const Key = [bundleVersion, platform].join("/");
+      const listCommand = new ListObjectsV2Command({
+        Bucket: bucketName,
+        Prefix: `${bundleVersion}/${platform}`
+      });
+      const listResponse = await client.send(listCommand);
+      if (listResponse.Contents && listResponse.Contents.length > 0) {
+        const objectsToDelete = listResponse.Contents.map((obj) => ({
+          Key: obj.Key
+        }));
+        const deleteParams = {
+          Bucket: bucketName,
+          Delete: {
+            Objects: objectsToDelete,
+            Quiet: true
+          }
+        };
+        const deleteCommand = new DeleteObjectsCommand(deleteParams);
+        await client.send(deleteCommand);
+        return Key;
+      }
+      log.error("Bundle Not Found");
+      throw new Error("Bundle Not Found");
+    },
+    async uploadBundle(platform, bundleVersion, bundlePath) {
+      log.info("Uploading Bundle");
+      const Body = await fs.readFile(bundlePath);
+      const ContentType = mime.getType(bundlePath) ?? void 0;
+      const filename = path.basename(bundlePath);
+      const Key = [bundleVersion, platform, filename].join("/");
+      const upload = new Upload({
+        client,
+        params: {
+          ContentType,
+          Bucket: bucketName,
+          Key,
+          Body
+        }
+      });
+      const response = await upload.done();
+      if (!response.Location) {
+        log.error("Upload Failed");
+        throw new Error("Upload Failed");
+      }
+      log?.info(`Uploaded: ${Key}`);
+      return {
+        file: response.Location
+      };
+    }
+  };
+};
+export {
+  aws
+};

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@hot-updater/aws",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "React Native OTA solution for self-hosted",
-  "main": "index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "license": "MIT",
   "repository": "https://github.com/gronxb/hot-updater",
   "author": "gronxb <gron1gh1@gmail.com> (https://github.com/gronxb)",
@@ -15,9 +17,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.441.0"
+    "@hot-updater/plugin-core": "0.1.0",
+    "@aws-sdk/client-s3": "^3.685.0",
+    "@aws-sdk/lib-storage": "^3.685.0",
+    "mime": "^4.0.4"
   },
   "scripts": {
-    "build": "tsc"
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test:type": "tsc --noEmit"
   }
 }

package/src/aws.ts

@@ -0,0 +1,173 @@
+import path from "path";
+import {
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  ListObjectsV2Command,
+  NoSuchKey,
+  S3Client,
+  type S3ClientConfig,
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+import {
+  type BasePluginArgs,
+  type DeployPlugin,
+  type UpdateSource,
+  log,
+} from "@hot-updater/plugin-core";
+import fs from "fs/promises";
+import mime from "mime";
+import { streamToString } from "./utils/streamToString";
+
+export interface AwsConfig
+  extends Pick<S3ClientConfig, "credentials" | "region"> {
+  bucketName: string;
+}
+
+export const aws =
+  (config: AwsConfig) =>
+  (_: BasePluginArgs): DeployPlugin => {
+    const { bucketName, ...s3Config } = config;
+    const client = new S3Client(s3Config);
+
+    let updateSources: UpdateSource[] = [];
+
+    return {
+      async commitUpdateSource() {
+        try {
+          const command = new GetObjectCommand({
+            Bucket: bucketName,
+            Key: "update.json",
+          });
+          await client.send(command);
+        } catch (e) {
+          if (e instanceof NoSuchKey) {
+            log.info("Creating new update.json");
+          } else {
+            throw e;
+          }
+        }
+
+        log.info("Uploading update.json");
+        const Key = "update.json";
+        const Body = JSON.stringify(updateSources);
+        const ContentType = mime.getType(Key) ?? void 0;
+
+        const upload = new Upload({
+          client,
+          params: {
+            ContentType,
+            Bucket: bucketName,
+            Key,
+            Body,
+          },
+        });
+        await upload.done();
+      },
+      async updateUpdateSource(
+        targetBundleVersion: number,
+        newSource: Partial<UpdateSource>,
+      ) {
+        updateSources = await this.getUpdateSources();
+
+        const targetIndex = updateSources.findIndex(
+          (u) => u.bundleVersion === targetBundleVersion,
+        );
+        if (targetIndex === -1) {
+          throw new Error("target bundle version not found");
+        }
+
+        Object.assign(updateSources[targetIndex], newSource);
+      },
+      async appendUpdateSource(source) {
+        updateSources = await this.getUpdateSources();
+        updateSources.unshift(source);
+      },
+      async setUpdateSources(sources) {
+        updateSources = sources;
+      },
+
+      async getUpdateSources(refresh = false) {
+        if (updateSources.length > 0 && !refresh) {
+          return updateSources;
+        }
+
+        log.info("Getting update.json");
+
+        try {
+          const command = new GetObjectCommand({
+            Bucket: bucketName,
+            Key: "update.json",
+          });
+          const { Body: UpdateJsonBody } = await client.send(command);
+          const bodyContents = await streamToString(UpdateJsonBody);
+          const _updateSource = JSON.parse(bodyContents);
+          updateSources = _updateSource;
+          return _updateSource as UpdateSource[];
+        } catch (e) {
+          if (e instanceof NoSuchKey) {
+            return [];
+          }
+          throw e;
+        }
+      },
+      async deleteBundle(platform, bundleVersion) {
+        const Key = [bundleVersion, platform].join("/");
+
+        const listCommand = new ListObjectsV2Command({
+          Bucket: bucketName,
+          Prefix: `${bundleVersion}/${platform}`,
+        });
+        const listResponse = await client.send(listCommand);
+
+        if (listResponse.Contents && listResponse.Contents.length > 0) {
+          const objectsToDelete = listResponse.Contents.map((obj) => ({
+            Key: obj.Key,
+          }));
+
+          const deleteParams = {
+            Bucket: bucketName,
+            Delete: {
+              Objects: objectsToDelete,
+              Quiet: true,
+            },
+          };
+
+          const deleteCommand = new DeleteObjectsCommand(deleteParams);
+          await client.send(deleteCommand);
+          return Key;
+        }
+
+        log.error("Bundle Not Found");
+        throw new Error("Bundle Not Found");
+      },
+      async uploadBundle(platform, bundleVersion, bundlePath) {
+        log.info("Uploading Bundle");
+
+        const Body = await fs.readFile(bundlePath);
+        const ContentType = mime.getType(bundlePath) ?? void 0;
+
+        const filename = path.basename(bundlePath);
+
+        const Key = [bundleVersion, platform, filename].join("/");
+        const upload = new Upload({
+          client,
+          params: {
+            ContentType,
+            Bucket: bucketName,
+            Key,
+            Body,
+          },
+        });
+        const response = await upload.done();
+        if (!response.Location) {
+          log.error("Upload Failed");
+          throw new Error("Upload Failed");
+        }
+
+        log?.info(`Uploaded: ${Key}`);
+        return {
+          file: response.Location,
+        };
+      },
+    };
+  };

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./aws";

package/src/utils/readDir.ts

@@ -0,0 +1,11 @@
+import { lstatSync } from "fs";
+import path from "path";
+import { readdir } from "fs/promises";
+
+export const readDir = async (dir: string) => {
+  const files = await readdir(dir, {
+    recursive: true,
+  });
+
+  return files.filter((file) => !lstatSync(path.join(dir, file)).isDirectory());
+};

package/src/utils/streamToString.ts

@@ -0,0 +1,8 @@
+export const streamToString = (stream: any): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const chunks: Uint8Array[] = [];
+    stream.on("data", (chunk: Uint8Array) => chunks.push(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+};

package/tsconfig.json

@@ -1,19 +1,5 @@
 {
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "commonjs",
-    "outDir": "./lib",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "baseUrl": ".",
-    "paths": {
-      "@/package.json": ["package.json"],
-      "@/*": ["src/*"]
-    }
-  },
-  "include": ["src", "global.d.ts"]
+  "extends": "../../tsconfig.base.json",
+  "include": ["src"],
+  "exclude": ["lib"]
 }

package/global.d.ts

@@ -1 +0,0 @@
-/// <reference path="../types/strategy.d.ts" />

package/lib/read.d.ts

@@ -1,3 +0,0 @@
-import { S3Client } from "@aws-sdk/client-s3";
-export declare const aws: (s3Client: S3Client, bucketName: string, baseUrl: string) => HotUpdaterReadStrategy;
-export { S3Client };

package/lib/read.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3Client = exports.aws = void 0;
-const client_s3_1 = require("@aws-sdk/client-s3");
-Object.defineProperty(exports, "S3Client", { enumerable: true, get: function () { return client_s3_1.S3Client; } });
-const aws = (s3Client, bucketName, baseUrl) => {
-    return {
-        async getListObjects(prefix) {
-            /**
-             * Uses ListObjectsV2Command to fetch a list of objects from an S3 bucket.
-             * Note: A single invocation of ListObjectsV2Command can retrieve a maximum of 1,000 objects.
-             */
-            const command = new client_s3_1.ListObjectsV2Command({
-                Bucket: bucketName,
-                Prefix: prefix,
-            });
-            const data = await s3Client.send(command);
-            const files = data.Contents?.filter(({ Key }) => Key !== prefix).map((content) => [baseUrl, content.Key].join("/"));
-            return files ?? [];
-        },
-    };
-};
-exports.aws = aws;

package/src/read.ts

@@ -1,28 +0,0 @@
-import { S3Client, ListObjectsV2Command } from "@aws-sdk/client-s3";
-
-export const aws = (
-  s3Client: S3Client,
-  bucketName: string,
-  baseUrl: string
-): HotUpdaterReadStrategy => {
-  return {
-    async getListObjects(prefix?: string) {
-      /**
-       * Uses ListObjectsV2Command to fetch a list of objects from an S3 bucket.
-       * Note: A single invocation of ListObjectsV2Command can retrieve a maximum of 1,000 objects.
-       */
-      const command = new ListObjectsV2Command({
-        Bucket: bucketName,
-        Prefix: prefix,
-      });
-
-      const data = await s3Client.send(command);
-      const files = data.Contents?.filter(({ Key }) => Key !== prefix).map(
-        (content) => [baseUrl, content.Key].join("/")
-      );
-      return files ?? [];
-    },
-  };
-};
-
-export { S3Client };