@s-hirano-ist/s-scripts 4.1.0 → 4.2.0

package/dist/{chunk-7XX57D7G.js → chunk-3INTMHPH.js}

@@ -2,7 +2,7 @@ import { createRequire as __cliCreateRequire } from "node:module"; const require
 import {
   makeExportedAt,
   withTransactionRetry
-} from "./chunk-DIG75T3J.js";
+} from "./chunk-RLAYINCA.js";
 
 // ../application/dist/batch/notes-batch-service.js
 var NotesBatchApplicationService = class {

package/dist/{chunk-OCEV2QX3.js → chunk-BYEEIQ7O.js}

@@ -2,7 +2,7 @@ import { createRequire as __cliCreateRequire } from "node:module"; const require
 import {
   makeExportedAt,
   withTransactionRetry
-} from "./chunk-DIG75T3J.js";
+} from "./chunk-RLAYINCA.js";
 
 // ../application/dist/batch/articles-batch-service.js
 var ArticlesBatchApplicationService = class {

package/dist/chunk-M6LFKOUH.js

@@ -0,0 +1,160 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// ../storage/dist/src/client.js
+import { S3Client, CreateBucketCommand, DeleteBucketCommand, PutObjectCommand, GetObjectCommand, HeadObjectCommand, DeleteObjectCommand, paginateListObjectsV2 } from "@aws-sdk/client-s3";
+import { createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+function loadStorageConfig(env = process.env) {
+  const required = (key) => {
+    const value = env[key];
+    if (!value)
+      throw new Error(`${key} is required`);
+    return value;
+  };
+  const endpoint = required("S3_ENDPOINT");
+  const url = new URL(endpoint);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash || url.pathname !== "/")
+    throw new Error("S3_ENDPOINT must be an HTTP(S) origin");
+  const pathStyle = env.S3_FORCE_PATH_STYLE ?? "false";
+  if (pathStyle !== "true" && pathStyle !== "false")
+    throw new Error("S3_FORCE_PATH_STYLE must be true or false");
+  return {
+    endpoint,
+    region: required("S3_REGION"),
+    accessKeyId: required("S3_ACCESS_KEY_ID"),
+    secretAccessKey: required("S3_SECRET_ACCESS_KEY"),
+    forcePathStyle: pathStyle === "true"
+  };
+}
+function isObjectNotFound(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const value = error;
+  return value.$metadata?.httpStatusCode === 404 && (value.name === "NotFound" || value.name === "NoSuchKey");
+}
+function createObjectStorageClient(config = loadStorageConfig()) {
+  const client = new S3Client({
+    endpoint: config.endpoint,
+    region: config.region,
+    credentials: {
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey
+    },
+    forcePathStyle: config.forcePathStyle
+  });
+  return {
+    async createBucket(bucket) {
+      await client.send(new CreateBucketCommand({ Bucket: bucket }));
+    },
+    async deleteBucket(bucket) {
+      await client.send(new DeleteBucketCommand({ Bucket: bucket }));
+    },
+    async putObject(bucket, key, body) {
+      const result = await client.send(new PutObjectCommand({ Bucket: bucket, Key: key, Body: body }));
+      return { etag: result.ETag, versionId: result.VersionId };
+    },
+    async getObject(bucket, key) {
+      const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+      if (!(result.Body instanceof Readable))
+        throw new Error("Object storage returned no Node readable body");
+      return result.Body;
+    },
+    async downloadObject(bucket, key, destination) {
+      const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+      if (!(result.Body instanceof Readable))
+        throw new Error("Object storage returned no Node readable body");
+      await pipeline(result.Body, createWriteStream(destination));
+    },
+    async statObject(bucket, key) {
+      const result = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+      return {
+        size: result.ContentLength,
+        etag: result.ETag,
+        lastModified: result.LastModified,
+        metaData: result.Metadata ?? {}
+      };
+    },
+    async removeObject(bucket, key) {
+      await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+    },
+    async listObjects(bucket, prefix) {
+      const keys = [];
+      for await (const page of paginateListObjectsV2({ client }, { Bucket: bucket, Prefix: prefix })) {
+        for (const object of page.Contents ?? [])
+          if (object.Key)
+            keys.push(object.Key);
+      }
+      return keys;
+    },
+    destroy() {
+      client.destroy();
+    }
+  };
+}
+
+// ../storage/dist/index.js
+import { S3ServiceException } from "@aws-sdk/client-s3";
+
+// ../storage/dist/src/errors.js
+var StorageOperationError = class extends Error {
+  context;
+  constructor(context, cause) {
+    super(`Storage ${context.operation} failed for ${context.objectKey}`, {
+      cause
+    });
+    this.name = "StorageOperationError";
+    this.context = context;
+  }
+};
+
+// ../storage/dist/src/storage-service.js
+function createStorageService(client, bucketName, pathConfig) {
+  function buildObjectKey(path, isThumbnail) {
+    return `${isThumbnail ? pathConfig.thumbnailPrefix : pathConfig.originalPrefix}/${path}`;
+  }
+  function wrapStorageError(operation, objectKey, isThumbnail, error) {
+    throw new StorageOperationError({ operation, objectKey, bucketName, isThumbnail }, error);
+  }
+  return {
+    async uploadImage(path, bytes, isThumbnail) {
+      const objKey = buildObjectKey(path, isThumbnail);
+      try {
+        await client.putObject(bucketName, objKey, Buffer.from(bytes));
+      } catch (error) {
+        wrapStorageError("uploadImage", objKey, isThumbnail, error);
+      }
+    },
+    async getImage(path, isThumbnail) {
+      const objKey = buildObjectKey(path, isThumbnail);
+      try {
+        return await client.getObject(bucketName, objKey);
+      } catch (error) {
+        return wrapStorageError("getImage", objKey, isThumbnail, error);
+      }
+    },
+    async getImageOrThrow(path, isThumbnail) {
+      const objKey = buildObjectKey(path, isThumbnail);
+      try {
+        await client.statObject(bucketName, objKey);
+      } catch (error) {
+        wrapStorageError("getImageOrThrow", objKey, isThumbnail, error);
+      }
+    },
+    async deleteImage(path, isThumbnail) {
+      const objKey = buildObjectKey(path, isThumbnail);
+      try {
+        await client.removeObject(bucketName, objKey);
+      } catch (error) {
+        wrapStorageError("deleteImage", objKey, isThumbnail, error);
+      }
+    }
+  };
+}
+
+export {
+  isObjectNotFound,
+  createObjectStorageClient,
+  StorageOperationError,
+  createStorageService
+};

package/dist/{chunk-2PZXXOYG.js → chunk-R5EI7JXR.js}

@@ -4,9 +4,11 @@ import {
   readImageMetadata
 } from "./chunk-KKZP7ZF3.js";
 import {
-  createMinioClient,
-  createStorageService
-} from "./chunk-F4J6JBR4.js";
+  StorageOperationError,
+  createObjectStorageClient,
+  createStorageService,
+  isObjectNotFound
+} from "./chunk-M6LFKOUH.js";
 import {
   CreatedAt,
   ExportedStatus,
@@ -18,7 +20,7 @@ import {
   import_generated,
   makeId,
   withTransactionRetry
-} from "./chunk-DIG75T3J.js";
+} from "./chunk-RLAYINCA.js";
 import {
   createPushoverService
 } from "./chunk-7PVU2Z32.js";
@@ -497,7 +499,9 @@ function createImportMediaStore(storage, processor) {
       const target = storage[domain];
       try {
         await target.getImageOrThrow(path, false);
-      } catch {
+      } catch (error) {
+        if (!isObjectNotFound(error instanceof StorageOperationError ? error.cause : error))
+          throw error;
         await target.uploadImage(path, bytes, false);
       }
       await target.uploadImage(path, await processor.createThumbnail(bytes, 192, 192), true);
@@ -512,16 +516,16 @@ function createImportMediaStore(storage, processor) {
 // ../infrastructure/dist/shared/books-storage-service.js
 var ORIGINAL_BOOK_IMAGE_PATH = "books/original";
 var THUMBNAIL_BOOK_IMAGE_PATH = "books/thumbnail";
-function createBooksStorageService(minioClient, bucketName) {
-  return createStorageService(minioClient, bucketName, {
+function createBooksStorageService(storageClient, bucketName) {
+  return createStorageService(storageClient, bucketName, {
     originalPrefix: ORIGINAL_BOOK_IMAGE_PATH,
     thumbnailPrefix: THUMBNAIL_BOOK_IMAGE_PATH
   });
 }
 
-// ../infrastructure/dist/shared/minio-storage-service.js
-function createImagesStorageService(minioClient, bucketName) {
-  return createStorageService(minioClient, bucketName, {
+// ../infrastructure/dist/shared/images-storage-service.js
+function createImagesStorageService(storageClient, bucketName) {
+  return createStorageService(storageClient, bucketName, {
     originalPrefix: "images/original",
     thumbnailPrefix: "images/thumbnail"
   });
@@ -545,10 +549,10 @@ async function runContentImport(domain, source) {
   });
   try {
     const mediaDomain = domain === "images" || domain === "books";
-    const bucket = process.env.MINIO_BUCKET_NAME;
+    const bucket = process.env.S3_BUCKET_NAME;
     if (mediaDomain && !dryRun && !bucket)
-      throw new Error("MINIO_BUCKET_NAME is required.");
-    const client = mediaDomain && !dryRun ? createMinioClient() : void 0;
+      throw new Error("S3_BUCKET_NAME is required.");
+    const client = mediaDomain && !dryRun ? createObjectStorageClient() : void 0;
     const media = client && bucket ? createImportMediaStore(
       {
         images: createImagesStorageService(client, bucket),
@@ -573,11 +577,17 @@ async function runContentImport(domain, source) {
       }
     );
     console.log(summary);
-    await notification.notifyInfo(`ingest-${domain} completed`, { caller: `ingest-${domain}` }).catch((error) => console.error("\u901A\u77E5\u5931\u6557:", error));
+    if (!dryRun)
+      await notification.notifyInfo(`ingest-${domain} completed`, {
+        caller: `ingest-${domain}`
+      }).catch((error) => console.error("\u901A\u77E5\u5931\u6557:", error));
   } catch (error) {
     console.error(error);
     process.exitCode = 1;
-    await notification.notifyError(`ingest-${domain} failed`, { caller: `ingest-${domain}` }).catch((notifyError) => console.error("\u901A\u77E5\u5931\u6557:", notifyError));
+    if (!dryRun)
+      await notification.notifyError(`ingest-${domain} failed`, { caller: `ingest-${domain}` }).catch(
+        (notifyError) => console.error("\u901A\u77E5\u5931\u6557:", notifyError)
+      );
   } finally {
     await prisma.$disconnect();
   }