1 files changed, 77 insertions, 80 deletions

diff --git a/deno/mail-relay/aws/app.ts b/deno/mail-relay/aws/app.ts
index 685d7a9..cb275ae 100644
--- a/deno/mail-relay/aws/app.ts
+++ b/deno/mail-relay/aws/app.ts
@@ -1,11 +1,12 @@
 import { join } from "@std/path";
-import { parseArgs } from "@std/cli";
 import { z } from "zod";
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
 import { FetchHttpHandler } from "@smithy/fetch-http-handler";
+// @ts-types="npm:@types/yargs"
+import yargs from "yargs";
 
-import { Logger } from "@crupest/base/log";
+import { LogFileProvider } from "@crupest/base/log";
 import { ConfigDefinition, ConfigProvider } from "@crupest/base/config";
 import { CronTask } from "@crupest/base/cron";
 
@@ -17,7 +18,7 @@ import {
 } from "./mail.ts";
 import { AwsMailDeliverer } from "./deliver.ts";
 import { AwsMailFetcher, AwsS3MailConsumer } from "./fetch.ts";
-import { createInbound, createHono, sendMail, createSmtp } from "../app.ts";
+import { createHono, createInbound, createSmtp, sendMail } from "../app.ts";
 
 const PREFIX = "crupest-mail-server";
 const CONFIG_DEFINITIONS = {
@@ -93,17 +94,16 @@ function createAwsOptions({
 }
 
 function createOutbound(
-  logger: Logger,
   awsOptions: ReturnType<typeof createAwsOptions>,
   db: DbService,
 ) {
-  const deliverer = new AwsMailDeliverer(logger, awsOptions);
+  const deliverer = new AwsMailDeliverer(awsOptions);
   deliverer.preHooks.push(
     new AwsMailMessageIdRewriteHook(db.messageIdToAws.bind(db)),
   );
   deliverer.postHooks.push(
     new AwsMailMessageIdSaveHook((original, aws) =>
-      db.addMessageIdMap({ message_id: original, aws_message_id: aws }).then(),
+      db.addMessageIdMap({ message_id: original, aws_message_id: aws }).then()
     ),
   );
   return deliverer;
@@ -155,80 +155,70 @@ function createCron(fetcher: AwsMailFetcher, consumer: AwsS3MailConsumer) {
 function createBaseServices() {
   const config = new ConfigProvider(PREFIX, CONFIG_DEFINITIONS);
   Deno.mkdirSync(config.get("dataPath"), { recursive: true });
-  const logger = new Logger();
-  logger.externalLogDir = join(config.get("dataPath"), "log");
-  return { config, logger };
+  const logFileProvider = new LogFileProvider(
+    join(config.get("dataPath"), "log"),
+  );
+  return { config, logFileProvider };
 }
 
 function createAwsFetchOnlyServices() {
-  const { config, logger } = createBaseServices();
+  const services = createBaseServices();
+  const { config } = services;
+
   const awsOptions = createAwsOptions({
     user: config.get("awsUser"),
     password: config.get("awsPassword"),
     region: config.get("awsRegion"),
   });
-  const fetcher = new AwsMailFetcher(
-    logger,
-    awsOptions,
-    config.get("awsMailBucket"),
-  );
-  return { config, logger, awsOptions, fetcher };
+  const fetcher = new AwsMailFetcher(awsOptions, config.get("awsMailBucket"));
+
+  return { ...services, awsOptions, fetcher };
 }
 
 function createAwsRecycleOnlyServices() {
-  const { config, logger, awsOptions, fetcher } = createAwsFetchOnlyServices();
+  const services = createAwsFetchOnlyServices();
+  const { config, logFileProvider } = services;
 
-  const inbound = createInbound(logger, {
+  const inbound = createInbound(logFileProvider, {
     fallback: config.getList("inboundFallback"),
     ldaPath: config.get("ldaPath"),
     aliasFile: join(config.get("dataPath"), "aliases.csv"),
     mailDomain: config.get("mailDomain"),
   });
-
   const recycler = (rawMail: string, _: unknown): Promise<void> =>
     inbound.deliver({ mail: new Mail(rawMail) }).then();
 
-  return { config, logger, awsOptions, fetcher, inbound, recycler };
+  return { ...services, inbound, recycler };
 }
 function createAwsServices() {
-  const { config, logger, inbound, awsOptions, fetcher, recycler } =
-    createAwsRecycleOnlyServices();
+  const services = createAwsRecycleOnlyServices();
+  const { config, awsOptions } = services;
+
   const dbService = new DbService(join(config.get("dataPath"), "db.sqlite"));
-  const outbound = createOutbound(logger, awsOptions, dbService);
+  const outbound = createOutbound(awsOptions, dbService);
 
-  return {
-    config,
-    logger,
-    inbound,
-    dbService,
-    awsOptions,
-    fetcher,
-    recycler,
-    outbound,
-  };
+  return { ...services, dbService, outbound };
 }
 
 function createServerServices() {
   const services = createAwsServices();
-  const { logger, config, outbound, inbound, fetcher } = services;
-  const smtp = createSmtp(logger, outbound);
+  const { config, outbound, inbound, fetcher } = services;
 
-  const hono = createHono(logger, outbound, inbound);
+  const smtp = createSmtp(outbound);
+  const hono = createHono(outbound, inbound);
   setupAwsHono(hono, {
     path: config.get("awsInboundPath"),
     auth: config.get("awsInboundKey"),
     callback: (s3Key, recipients) => {
-      return fetcher.consumeS3Mail(s3Key, (rawMail, _) =>
-        inbound.deliver({ mail: new Mail(rawMail), recipients }).then(),
+      return fetcher.consumeS3Mail(
+        s3Key,
+        (rawMail, _) =>
+          inbound.deliver({ mail: new Mail(rawMail), recipients }).then(),
       );
     },
   });
 
-  return {
-    ...services,
-    smtp,
-    hono,
-  };
+  return { ...services, smtp, hono };
 }
 
 function serve(cron: boolean = false) {
@@ -251,10 +241,12 @@ function serve(cron: boolean = false) {
 }
 
 async function listLives() {
-  const { logger, fetcher } = createAwsFetchOnlyServices();
+  const { fetcher } = createAwsFetchOnlyServices();
   const liveMails = await fetcher.listLiveMails();
-  logger.info(`Total ${liveMails.length}:`);
-  logger.info(liveMails.join("\n"));
+  console.info(`Total ${liveMails.length}:`);
+  if (liveMails.length !== 0) {
+    console.info(liveMails.join("\n"));
+  }
 }
 
 async function recycleLives() {
@@ -263,38 +255,43 @@ async function recycleLives() {
 }
 
 if (import.meta.main) {
-  const args = parseArgs(Deno.args);
-
-  if (args._.length === 0) {
-    throw new Error("You must specify a command.");
-  }
-
-  const command = String(args._[0]);
-
-  switch (command) {
-    case "sendmail": {
-      const { logger, config } = createBaseServices();
-      await sendMail(logger, config.getInt("httpPort"));
-      break;
-    }
-    case "list-lives": {
-      await listLives();
-      break;
-    }
-    case "recycle-lives": {
-      await recycleLives();
-      break;
-    }
-    case "serve": {
-      serve();
-      break;
-    }
-    case "real-serve": {
-      serve(true);
-      break;
-    }
-    default: {
-      throw new Error(command + " is not a valid command.");
-    }
-  }
+  await yargs(Deno.args)
+    .scriptName("mail-relay")
+    .command({
+      command: "sendmail",
+      describe: "send mail via this server's endpoint",
+      handler: async (_argv) => {
+        const { config } = createBaseServices();
+        await sendMail(config.getInt("httpPort"));
+      },
+    })
+    .command({
+      command: "live",
+      describe: "work with live mails",
+      builder: (builder) => {
+        return builder
+          .command({
+            command: "list",
+            describe: "list live mails",
+            handler: listLives,
+          })
+          .command({
+            command: "recycle",
+            describe: "recycle all live mails",
+            handler: recycleLives,
+          })
+          .demandCommand(1, "One command must be specified.");
+      },
+      handler: () => {},
+    })
+    .command({
+      command: "serve",
+      describe: "start the http and smtp servers",
+      builder: (builder) => builder.option("real", { type: "boolean" }),
+      handler: (argv) => serve(argv.real),
+    })
+    .demandCommand(1, "One command must be specified.")
+    .help()
+    .strict()
+    .parse();
 }