@s-hirano-ist/s-scripts 1.26.8 → 4.0.0

package/dist/chunk-AZF2R2BF.js

@@ -0,0 +1,85 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+import {
+  makeExportedAt,
+  withTransactionRetry
+} from "./chunk-IWNZQXDG.js";
+
+// ../application/dist/batch/books-batch-service.js
+var BooksBatchApplicationService = class {
+  commandRepository;
+  constructor(commandRepository) {
+    this.commandRepository = commandRepository;
+  }
+  /**
+   * Resets books for a new batch export.
+   *
+   * @remarks
+   * Delegates to repository's resetStatus which performs two operations
+   * atomically within a single transaction.
+   */
+  async resetBooks(userId) {
+    return this.commandRepository.resetStatus(userId, makeExportedAt());
+  }
+  /**
+   * Reverts books from LAST_UPDATED back to UNEXPORTED.
+   */
+  async revertBooks(userId) {
+    return this.commandRepository.bulkUpdateStatus({
+      userId,
+      fromStatus: "LAST_UPDATED",
+      toStatus: "UNEXPORTED"
+    });
+  }
+};
+
+// ../infrastructure/dist/batch/books-command-repository.js
+function createBooksCommandRepository(prisma) {
+  return {
+    async bulkUpdateStatus(params) {
+      const { userId, fromStatus, toStatus, exportedAt } = params;
+      const result = await prisma.book.updateMany({
+        where: {
+          userId,
+          status: fromStatus
+        },
+        data: {
+          status: toStatus,
+          ...exportedAt && { exportedAt }
+        }
+      });
+      return { count: result.count };
+    },
+    async resetStatus(userId, exportedAt) {
+      const [finalized, marked] = await withTransactionRetry(() => prisma.$transaction([
+        prisma.book.updateMany({
+          where: {
+            userId,
+            status: "LAST_UPDATED"
+          },
+          data: {
+            status: "EXPORTED",
+            exportedAt
+          }
+        }),
+        prisma.book.updateMany({
+          where: {
+            userId,
+            status: "UNEXPORTED"
+          },
+          data: {
+            status: "LAST_UPDATED"
+          }
+        })
+      ]));
+      return {
+        finalized: { count: finalized.count },
+        marked: { count: marked.count }
+      };
+    }
+  };
+}
+
+export {
+  BooksBatchApplicationService,
+  createBooksCommandRepository
+};

package/dist/chunk-F4J6JBR4.js

@@ -0,0 +1,115 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// ../storage/dist/src/client.js
+import { Client } from "minio";
+
+// ../storage/dist/src/cf-access-transport.js
+import * as https from "node:https";
+function createCfAccessTransport(config) {
+  if (!config?.clientId || !config.clientSecret) {
+    return void 0;
+  }
+  return {
+    request(options, ...rest) {
+      if (typeof options === "object" && !(options instanceof URL)) {
+        const headers = options.headers ?? {};
+        headers["CF-Access-Client-Id"] = config.clientId;
+        headers["CF-Access-Client-Secret"] = config.clientSecret;
+        options.headers = headers;
+      }
+      const request2 = https.request;
+      return request2(options, ...rest);
+    }
+  };
+}
+
+// ../storage/dist/src/client.js
+function createMinioClient(config, cfAccess) {
+  const resolved = config ?? {
+    endPoint: process.env.MINIO_HOST ?? "",
+    port: Number(process.env.MINIO_PORT),
+    useSSL: process.env.MINIO_USE_SSL === void 0 ? !["localhost", "127.0.0.1"].includes(process.env.MINIO_HOST ?? "") : process.env.MINIO_USE_SSL === "true",
+    accessKey: process.env.MINIO_ACCESS_KEY ?? "",
+    secretKey: process.env.MINIO_SECRET_KEY ?? ""
+  };
+  const resolvedCfAccess = cfAccess ?? {
+    clientId: process.env.CF_ACCESS_CLIENT_ID ?? "",
+    clientSecret: process.env.CF_ACCESS_CLIENT_SECRET ?? ""
+  };
+  const transport = resolved.useSSL ? createCfAccessTransport(resolvedCfAccess) : void 0;
+  if (resolved.useSSL && !transport) {
+    throw new Error("CF_ACCESS_CLIENT_ID and CF_ACCESS_CLIENT_SECRET are required when useSSL is true.");
+  }
+  return new Client({
+    endPoint: resolved.endPoint,
+    port: resolved.port,
+    useSSL: resolved.useSSL,
+    accessKey: resolved.accessKey,
+    secretKey: resolved.secretKey,
+    ...transport && { transport }
+  });
+}
+
+// ../storage/dist/index.js
+import { S3Error } from "minio";
+
+// ../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 {
+  createMinioClient,
+  createStorageService
+};

package/dist/chunk-HDYQV2Y2.js

@@ -0,0 +1,58 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+
+// ../search/dist/frontmatter.js
+import { load } from "js-yaml";
+var BYTE_ORDER_MARK = "\uFEFF";
+var OPENING_DELIMITER_REGEX = /^---[\t ]*\r?\n/u;
+var CLOSING_DELIMITER_REGEX = /^---[\t ]*\r?$/gmu;
+function stripByteOrderMark(source) {
+  return source.startsWith(BYTE_ORDER_MARK) ? source.slice(1) : source;
+}
+function getContentStart(source, delimiterEnd) {
+  if (source.startsWith("\r\n", delimiterEnd)) {
+    return delimiterEnd + 2;
+  }
+  if (source.startsWith("\n", delimiterEnd)) {
+    return delimiterEnd + 1;
+  }
+  return delimiterEnd;
+}
+function parseYamlObject(source) {
+  if (source.trim() === "") {
+    return {};
+  }
+  const parsed = load(source);
+  if (parsed === void 0) {
+    return {};
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("Markdown frontmatter must be a YAML object.");
+  }
+  return parsed;
+}
+function parseMarkdownFrontmatter(source) {
+  const normalizedSource = stripByteOrderMark(source);
+  const openingDelimiter = OPENING_DELIMITER_REGEX.exec(normalizedSource);
+  if (!openingDelimiter) {
+    if (/^---[\t ]*$/u.test(normalizedSource)) {
+      throw new Error("Markdown frontmatter is missing a closing delimiter.");
+    }
+    return { content: normalizedSource, data: {} };
+  }
+  CLOSING_DELIMITER_REGEX.lastIndex = openingDelimiter[0].length;
+  const closingDelimiter = CLOSING_DELIMITER_REGEX.exec(normalizedSource);
+  CLOSING_DELIMITER_REGEX.lastIndex = 0;
+  if (!closingDelimiter) {
+    throw new Error("Markdown frontmatter is missing a closing delimiter.");
+  }
+  const yamlSource = normalizedSource.slice(openingDelimiter[0].length, closingDelimiter.index);
+  const contentStart = getContentStart(normalizedSource, closingDelimiter.index + closingDelimiter[0].length);
+  return {
+    content: normalizedSource.slice(contentStart),
+    data: parseYamlObject(yamlSource)
+  };
+}
+
+export {
+  parseMarkdownFrontmatter
+};

package/dist/chunk-HIK7SX34.js

@@ -0,0 +1,85 @@
+import { createRequire as __cliCreateRequire } from "node:module"; const require = __cliCreateRequire(import.meta.url);
+import {
+  makeExportedAt,
+  withTransactionRetry
+} from "./chunk-IWNZQXDG.js";
+
+// ../application/dist/batch/images-batch-service.js
+var ImagesBatchApplicationService = class {
+  commandRepository;
+  constructor(commandRepository) {
+    this.commandRepository = commandRepository;
+  }
+  /**
+   * Resets images for a new batch export.
+   *
+   * @remarks
+   * Delegates to repository's resetStatus which performs two operations
+   * atomically within a single transaction.
+   */
+  async resetImages(userId) {
+    return this.commandRepository.resetStatus(userId, makeExportedAt());
+  }
+  /**
+   * Reverts images from LAST_UPDATED back to UNEXPORTED.
+   */
+  async revertImages(userId) {
+    return this.commandRepository.bulkUpdateStatus({
+      userId,
+      fromStatus: "LAST_UPDATED",
+      toStatus: "UNEXPORTED"
+    });
+  }
+};
+
+// ../infrastructure/dist/batch/images-command-repository.js
+function createImagesCommandRepository(prisma) {
+  return {
+    async bulkUpdateStatus(params) {
+      const { userId, fromStatus, toStatus, exportedAt } = params;
+      const result = await prisma.image.updateMany({
+        where: {
+          userId,
+          status: fromStatus
+        },
+        data: {
+          status: toStatus,
+          ...exportedAt && { exportedAt }
+        }
+      });
+      return { count: result.count };
+    },
+    async resetStatus(userId, exportedAt) {
+      const [finalized, marked] = await withTransactionRetry(() => prisma.$transaction([
+        prisma.image.updateMany({
+          where: {
+            userId,
+            status: "LAST_UPDATED"
+          },
+          data: {
+            status: "EXPORTED",
+            exportedAt
+          }
+        }),
+        prisma.image.updateMany({
+          where: {
+            userId,
+            status: "UNEXPORTED"
+          },
+          data: {
+            status: "LAST_UPDATED"
+          }
+        })
+      ]));
+      return {
+        finalized: { count: finalized.count },
+        marked: { count: marked.count }
+      };
+    }
+  };
+}
+
+export {
+  ImagesBatchApplicationService,
+  createImagesCommandRepository
+};