comfy-pr 0.2.24 → 0.2.26

package/src/updateCNReposRelatedPulls.ts

@@ -1,25 +1,25 @@
-import DIE from "@snomiao/die";
-import pMap from "p-map";
-import { match } from "ts-pattern";
-import { $OK, TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
-import { CNRepos } from "./CNRepos";
-import { $filaten, $stale } from "./db";
-import { matchRelatedPulls } from "./matchRelatedPulls";
-import { tLog } from "./utils/tLog";
-if (import.meta.main) {
-  await tLog("updateCNReposRelatedPulls", updateCNReposRelatedPulls);
-}
-export async function updateCNReposRelatedPulls() {
-  await CNRepos.createIndex({ "pulls.state": 1, "crPulls.mtime": 1 });
-  return await pMap(
-    CNRepos.find($filaten({ pulls: { state: "ok" }, crPulls: { mtime: $stale("1d") } })),
-    async (repo, i) => {
-      const { repository } = repo;
-      const pulls = match(repo.pulls)
-        .with($OK, (e) => e.data)
-        .otherwise(() => DIE("Pulls not found"));
-      const crPulls = await matchRelatedPulls(pulls).then(TaskOK).catch(TaskError);
-      return await CNRepos.updateOne({ repository }, { $set: { crPulls } });
-    },
-  );
-}
+import DIE from "@snomiao/die";
+import pMap from "p-map";
+import { match } from "ts-pattern";
+import { $OK, TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
+import { CNRepos } from "./CNRepos";
+import { $filaten, $stale } from "./db";
+import { matchRelatedPulls } from "./matchRelatedPulls";
+import { tLog } from "./utils/tLog";
+if (import.meta.main) {
+  await tLog("updateCNReposRelatedPulls", updateCNReposRelatedPulls);
+}
+export async function updateCNReposRelatedPulls() {
+  await CNRepos.createIndex({ "pulls.state": 1, "crPulls.mtime": 1 });
+  return await pMap(
+    CNRepos.find($filaten({ pulls: { state: "ok" }, crPulls: { mtime: $stale("1d") } })),
+    async (repo, i) => {
+      const { repository } = repo;
+      const pulls = match(repo.pulls)
+        .with($OK, (e) => e.data)
+        .otherwise(() => DIE("Pulls not found"));
+      const crPulls = await matchRelatedPulls(pulls).then(TaskOK).catch(TaskError);
+      return await CNRepos.updateOne({ repository }, { $set: { crPulls } });
+    },
+  );
+}

package/src/updateCRNodes.ts

@@ -1,50 +1,50 @@
-import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
-import { peekYaml } from "peek-log";
-import { filter, groupBy, values } from "rambda";
-import YAML from "yaml";
-import { TaskOK } from "../packages/mongodb-pipeline-ts/Task";
-import { CNRepos } from "./CNRepos";
-import { CRNodes } from "./CRNodes";
-import { fetchCRNodes } from "./fetchComfyRegistryNodes";
-import { notifySlack } from "./slack/notifySlack";
-import { tLog } from "./utils/tLog";
-
-if (import.meta.main) {
-  peekYaml(await tLog(updateCRNodes));
-  console.log("CRNodes updated");
-
-  peekYaml(
-    await $pipeline(CNRepos).project({ repository: 1, on_registry: 1 }).sample({ size: 8 }).aggregate().toArray(),
-  );
-}
-export async function updateCRNodes() {
-  const nodes = await fetchCRNodes();
-
-  // check src duplicated
-  const group = groupBy((e) => e.repository, nodes);
-  const duplicates = filter((e) => e.length > 1, group);
-  if (values(duplicates).length) {
-    const msg =
-      "[WARN] Same repo but different ids found in comfyregistry:\n" + "```\n" + YAML.stringify(duplicates) + "\n```";
-    await notifySlack(msg, { unique: true });
-  }
-
-  return [
-    await $pipeline(CNRepos)
-      .project({ repository: 1 })
-      .set({ on_registry: TaskOK({ $in: ["$repository", nodes.map(({ repository }) => repository).filter(Boolean)] }) })
-      .merge({ into: "CNRepos", on: "repository", whenMatched: "merge", whenNotMatched: "insert" })
-      .aggregate()
-      .next(),
-    await CRNodes.bulkWrite(
-      nodes.map((node) => ({
-        updateOne: {
-          filter: { id: node.id },
-          update: { $set: node },
-          upsert: true,
-        },
-      })),
-      { ordered: false },
-    ),
-  ];
-}
+import { $pipeline } from "@/packages/mongodb-pipeline-ts/$pipeline";
+import { peekYaml } from "peek-log";
+import { filter, groupBy, values } from "rambda";
+import YAML from "yaml";
+import { TaskOK } from "../packages/mongodb-pipeline-ts/Task";
+import { CNRepos } from "./CNRepos";
+import { CRNodes } from "./CRNodes";
+import { fetchCRNodes } from "./fetchComfyRegistryNodes";
+import { notifySlack } from "./slack/notifySlack";
+import { tLog } from "./utils/tLog";
+
+if (import.meta.main) {
+  peekYaml(await tLog(updateCRNodes));
+  console.log("CRNodes updated");
+
+  peekYaml(
+    await $pipeline(CNRepos).project({ repository: 1, on_registry: 1 }).sample({ size: 8 }).aggregate().toArray(),
+  );
+}
+export async function updateCRNodes() {
+  const nodes = await fetchCRNodes();
+
+  // check src duplicated
+  const group = groupBy((e) => e.repository, nodes);
+  const duplicates = filter((e) => e.length > 1, group);
+  if (values(duplicates).length) {
+    const msg =
+      "[WARN] Same repo but different ids found in comfyregistry:\n" + "```\n" + YAML.stringify(duplicates) + "\n```";
+    await notifySlack(msg, { unique: true });
+  }
+
+  return [
+    await $pipeline(CNRepos)
+      .project({ repository: 1 })
+      .set({ on_registry: TaskOK({ $in: ["$repository", nodes.map(({ repository }) => repository).filter(Boolean)] }) })
+      .merge({ into: "CNRepos", on: "repository", whenMatched: "merge", whenNotMatched: "insert" })
+      .aggregate()
+      .next(),
+    await CRNodes.bulkWrite(
+      nodes.map((node) => ({
+        updateOne: {
+          filter: { id: node.id },
+          update: { $set: node },
+          upsert: true,
+        },
+      })),
+      { ordered: false },
+    ),
+  ];
+}

package/src/updateCRRepos.ts

@@ -1,26 +1,26 @@
-import pMap from "p-map";
-import { CNRepos } from "./CNRepos";
-import { CRNodes } from "./CRNodes";
-import { tLog } from "./utils/tLog";
-if (import.meta.main) {
-  await tLog("updateCRRepos", updateCRRepos);
-}
-export async function updateCRRepos() {
-  await CRNodes.createIndex({ repo_id: 1 });
-  return await pMap(CRNodes.find({ repo_id: { $exists: false } }), async (cr, i) => {
-    const { repository, _id } = cr;
-    await CNRepos.updateOne(
-      { repository },
-      {
-        $set: {
-          cr: (await CRNodes.findOneAndUpdate(
-            { _id },
-            { $set: { repo_id: cr._id } },
-            { upsert: true, returnDocument: "after" },
-          ))!,
-        },
-      },
-      { upsert: true },
-    );
-  });
-}
+import pMap from "p-map";
+import { CNRepos } from "./CNRepos";
+import { CRNodes } from "./CRNodes";
+import { tLog } from "./utils/tLog";
+if (import.meta.main) {
+  await tLog("updateCRRepos", updateCRRepos);
+}
+export async function updateCRRepos() {
+  await CRNodes.createIndex({ repo_id: 1 });
+  return await pMap(CRNodes.find({ repo_id: { $exists: false } }), async (cr, i) => {
+    const { repository, _id } = cr;
+    await CNRepos.updateOne(
+      { repository },
+      {
+        $set: {
+          cr: (await CRNodes.findOneAndUpdate(
+            { _id },
+            { $set: { repo_id: cr._id } },
+            { upsert: true, returnDocument: "after" },
+          ))!,
+        },
+      },
+      { upsert: true },
+    );
+  });
+}

package/src/updateComfyTotals.ts

@@ -1,43 +1,43 @@
-import { match } from "ts-pattern";
-import YAML from "yaml";
-import { $OK, TaskError, TaskOK, tsmatch } from "../packages/mongodb-pipeline-ts/Task";
-import { Totals } from "./Totals";
-import { analyzeTotals } from "./analyzeTotals";
-import { $filaten, $fresh } from "./db";
-import { notifySlack } from "./slack/notifySlack";
-
-if (import.meta.main) {
-  await updateComfyTotals();
-}
-
-export async function updateComfyTotals({ notify = true, fresh = "30m" } = {}) {
-  await Totals.createIndex({ today: 1, "totals.mtime": 1, "totals.state": 1 });
-  const today = new Date().toISOString().split("T")[0];
-  const cached = await Totals.findOne($filaten({ today, totals: { mtime: $fresh(fresh), ...$OK } }));
-  if (cached?.totals?.state === "ok")
-    return [
-      tsmatch(cached.totals)
-        .with($OK, ({ data }) => data)
-        .otherwise(() => null),
-    ].flatMap((e) => (e ? [e] : []));
-  const totals = await analyzeTotals().then(TaskOK).catch(TaskError);
-
-  // notify if today is not already notify
-  if (notify) {
-    if (!(await Totals.findOne($filaten({ today, totals: { mtime: $fresh("1d"), ...$OK } }))))
-      // ignore today
-      await match(totals)
-        .with($OK, async (totals) => {
-          const msg = `Totals: \n${"```"}\n${YAML.stringify(totals)}\n${"```"}`;
-          await notifySlack(msg, { unique: true });
-        })
-        .otherwise(() => null);
-  }
-
-  const insertResult = await Totals.insertOne({ totals });
-  return [
-    tsmatch(totals)
-      .with($OK, ({ data }) => data)
-      .otherwise(() => null),
-  ].flatMap((e) => (e ? [e] : []));
-}
+import { match } from "ts-pattern";
+import YAML from "yaml";
+import { $OK, TaskError, TaskOK, tsmatch } from "../packages/mongodb-pipeline-ts/Task";
+import { Totals } from "./Totals";
+import { analyzeTotals } from "./analyzeTotals";
+import { $filaten, $fresh } from "./db";
+import { notifySlack } from "./slack/notifySlack";
+
+if (import.meta.main) {
+  await updateComfyTotals();
+}
+
+export async function updateComfyTotals({ notify = true, fresh = "30m" } = {}) {
+  await Totals.createIndex({ today: 1, "totals.mtime": 1, "totals.state": 1 });
+  const today = new Date().toISOString().split("T")[0];
+  const cached = await Totals.findOne($filaten({ today, totals: { mtime: $fresh(fresh), ...$OK } }));
+  if (cached?.totals?.state === "ok")
+    return [
+      tsmatch(cached.totals)
+        .with($OK, ({ data }) => data)
+        .otherwise(() => null),
+    ].flatMap((e) => (e ? [e] : []));
+  const totals = await analyzeTotals().then(TaskOK).catch(TaskError);
+
+  // notify if today is not already notify
+  if (notify) {
+    if (!(await Totals.findOne($filaten({ today, totals: { mtime: $fresh("1d"), ...$OK } }))))
+      // ignore today
+      await match(totals)
+        .with($OK, async (totals) => {
+          const msg = `Totals: \n${"```"}\n${YAML.stringify(totals)}\n${"```"}`;
+          await notifySlack(msg, { unique: true });
+        })
+        .otherwise(() => null);
+  }
+
+  const insertResult = await Totals.insertOne({ totals });
+  return [
+    tsmatch(totals)
+      .with($OK, ({ data }) => data)
+      .otherwise(() => null),
+  ].flatMap((e) => (e ? [e] : []));
+}

package/src/updateFollowRuleSet.ts

@@ -1,127 +1,136 @@
-"use server";
-import { TaskDataOrNull } from "@/packages/mongodb-pipeline-ts/Task";
-import DIE from "@snomiao/die";
-import pMap from "p-map";
-import { peekYaml } from "peek-log";
-import { TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
-import { CNRepos } from "./CNRepos";
-import { FollowRuleSets } from "./FollowRules";
-import { addCommentAction } from "./addCommentAction";
-import { analyzePullsStatus, analyzePullsStatusPipeline } from "./analyzePullsStatus";
-import { $filaten } from "./db";
-import { zAddCommentAction, zFollowUpRules } from "./followRuleSchema";
-import { fetchIssueComments } from "./gh/fetchIssueComments";
-import { initializeFollowRules } from "./initializeFollowRules";
-import { stringifyGithubRepoUrl } from "./parseOwnerRepo";
-import { parsePullUrl } from "./parsePullUrl";
-import { yaml } from "./utils/yaml";
-
-if (import.meta.main) {
-  // updateFollowRuleSet({yaml: 'default'})
-  await FollowRuleSets.drop();
-  const defaultRuleSet = await initializeFollowRules();
-
-  await updateFollowRuleSet({ name: "default", enable: true, yaml: defaultRuleSet.yaml });
-  await runFollowRuleSet();
-}
-
-export async function runFollowRuleSet({ name = "default" } = {}) {
-  const ruleset = (await FollowRuleSets.findOne({ name })) ?? DIE("default ruleset not found");
-  return peekYaml(
-    await updateFollowRuleSet({
-      name: ruleset.name,
-      enable: ruleset.enabled ?? DIE("Ruleset is not enabled"),
-      yaml: ruleset.yamlWhenEnabled ?? DIE("Enabled yaml is not found"),
-      runAction: true,
-    }),
-  );
-}
-export type updateFollowRuleSet = typeof updateFollowRuleSet;
-export async function updateFollowRuleSet({
-  name,
-  yaml: code,
-  enable,
-  runAction = false,
-}: {
-  /** 'default' */
-  name: string;
-  /** update yaml if provided, unchange if undefined */
-  yaml?: string;
-  /** update enable if provided, unchange if undefined */
-  enable?: boolean | undefined;
-  /** run action if true */
-  runAction?: boolean;
-}) {
-  "use server";
-  return await (async function () {
-    if (enable === false) {
-      await FollowRuleSets.updateOne({ name }, { $set: { enabled: false, yamlWhenEnabled: "" } });
-      DIE`ruleset is disabled, no need to run`;
-    }
-
-    // must parse while run, because the date in code is dynamic generated
-    const rules = zFollowUpRules.parse(yaml.parse(code || DIE`yaml is empty`));
-    // save if parse succ
-    // await FollowRuleSets.updateOne({ name }, { $set: { yaml: code, rules } });
-    const parseResult = await pMap(
-      rules,
-      async (rule) => {
-        if (runAction) {
-          // pre-fetch comments before run a rule -> match -> action, to prevent comment on a outdated pull state
-          const preMatched = await analyzePullsStatus({ pipeline: analyzePullsStatusPipeline().match(rule.$match) })
-            .then(TaskOK)
-            .catch(TaskError);
-
-          // update comments before run action
-          const matchedData = TaskDataOrNull(preMatched) ?? DIE("NO-PAYLOAD-AVAILABLE");
-          await pMap(matchedData, async (payload) => {
-            const html_url = payload.url;
-            const { owner, repo, pull_number } = parsePullUrl(payload.url);
-            const repository = stringifyGithubRepoUrl({ owner, repo });
-
-            const comments = await fetchIssueComments(repository, { number: pull_number })
-              .then(TaskOK)
-              .catch(TaskError);
-            (
-              await CNRepos.updateOne($filaten({ repository, crPulls: { data: { pull: { html_url } } } }), {
-                $set: { "crPulls.data.$.comments": comments },
-              })
-            ).matchedCount ?? DIE("pre-matched comments is not found");
-          });
-        }
-
-        const matched = await analyzePullsStatus({ pipeline: analyzePullsStatusPipeline().match(rule.$match) })
-          .then(TaskOK)
-          .catch(TaskError);
-
-        const actions = await (async function () {
-          return await pMap(
-            Object.entries(rule.action),
-            async ([name, _action]) => {
-              if (name === "add-comment") {
-                const action = zAddCommentAction.parse(_action);
-                return await addCommentAction({ matched, action, runAction, rule });
-              }
-            },
-            { concurrency: 1 },
-          );
-        })()
-          .then(TaskOK)
-          .catch(TaskError);
-
-        return { name: rule.name, matched, actions };
-      },
-      { concurrency: 1 },
-    );
-
-    if (enable === true) {
-      await FollowRuleSets.updateOne({ name }, { $set: { enabled: true, yamlWhenEnabled: code, yaml: code } });
-    } else {
-      await FollowRuleSets.updateOne({ name }, { $set: { yaml: code } });
-    }
-    return parseResult;
-  })()
-    .then(TaskOK)
-    .catch(TaskError);
-}
-
+"use server";
+import { TaskDataOrNull } from "@/packages/mongodb-pipeline-ts/Task";
+import DIE from "@snomiao/die";
+import pMap from "p-map";
+import { peekYaml } from "peek-log";
+import { TaskError, TaskOK } from "../packages/mongodb-pipeline-ts/Task";
+import { CNRepos } from "./CNRepos";
+import { FollowRuleSets } from "./FollowRules";
+import { addCommentAction } from "./addCommentAction";
+import { analyzePullsStatus, analyzePullsStatusPipeline } from "./analyzePullsStatus";
+import { $filaten } from "./db";
+import { zAddCommentAction, zFollowUpRules, zSendEmailAction } from "./followRuleSchema";
+import { fetchIssueComments } from "./gh/fetchIssueComments";
+import { stringifyGithubRepoUrl } from "./parseOwnerRepo";
+import { parsePullUrl } from "./parsePullUrl";
+import { sendEmailAction } from "./sendEmailAction";
+import { yaml } from "./utils/yaml";
+
+if (import.meta.main) {
+  // const defaultRuleSet = await initializeFollowRules();
+  // await updateFollowRuleSet({ name: "default", enable: true, yaml: defaultRuleSet.yaml });
+  // await runFollowRuleSet();
+}
+
+export async function runFollowRuleSet({ name = "default" } = {}) {
+  const ruleset = (await FollowRuleSets.findOne({ name })) ?? DIE("default ruleset not found");
+
+  console.log("RUNNING ruleset:");
+  console.log(ruleset.yamlWhenEnabled);
+  return peekYaml(
+    await updateFollowRuleSet({
+      name: ruleset.name,
+      enable: ruleset.enabled || DIE(new Error("Ruleset is not enabled")),
+      yaml: ruleset.yamlWhenEnabled || DIE("Enabled yaml is not found"),
+      runAction: true,
+    }),
+  );
+}
+export type updateFollowRuleSet = typeof updateFollowRuleSet;
+export async function updateFollowRuleSet({
+  name,
+  yaml: code,
+  enable,
+  runAction = false,
+}: {
+  /** 'default' */
+  name: string;
+  /** update yaml if provided, unchange if undefined */
+  yaml?: string;
+  /** update enable if provided, unchange if undefined */
+  enable?: boolean | undefined;
+  /** run action if true */
+  runAction?: boolean;
+}) {
+  "use server";
+  return await (async function () {
+    if (enable === false) {
+      await FollowRuleSets.updateOne({ name }, { $set: { enabled: false, yamlWhenEnabled: "" } });
+      DIE`ruleset is disabled, no need to run`;
+    }
+
+    // must parse while run, because the date in code is dynamic generated
+    const rules = zFollowUpRules.parse(yaml.parse(code || DIE`yaml is empty`));
+    // save if parse succ
+    // await FollowRuleSets.updateOne({ name }, { $set: { yaml: code, rules } });
+    const parseResult = await pMap(
+      rules,
+      async (rule) => {
+        if (runAction) {
+          // pre-fetch comments before run a rule -> match -> action, to prevent comment on a outdated pull state
+          const preMatched = await analyzePullsStatus({ pipeline: analyzePullsStatusPipeline().match(rule.$match) })
+            .then(TaskOK)
+            .catch(TaskError);
+
+          // update comments before run action
+          const matchedData = TaskDataOrNull(preMatched) ?? DIE("NO-PAYLOAD-AVAILABLE");
+          await pMap(matchedData, async (payload) => {
+            const html_url = payload.url;
+            const { owner, repo, pull_number } = parsePullUrl(payload.url);
+            const repository = stringifyGithubRepoUrl({ owner, repo });
+
+            const comments = await fetchIssueComments(repository, { number: pull_number })
+              .then(TaskOK)
+              .catch(TaskError);
+            (
+              await CNRepos.updateOne($filaten({ repository, crPulls: { data: { pull: { html_url } } } }), {
+                $set: { "crPulls.data.$.comments": comments },
+              })
+            ).matchedCount ?? DIE("pre-matched comments is not found");
+          });
+        }
+
+        const matched = await analyzePullsStatus({ pipeline: analyzePullsStatusPipeline().match(rule.$match) })
+          .then(TaskOK)
+          .catch(TaskError);
+
+        const actions = await (async function () {
+          return await pMap(
+            Object.entries(rule.action),
+            async ([name, _action]) => {
+              if (name === "add-comment") {
+                const action = zAddCommentAction.parse(_action);
+                return await addCommentAction({ matched, action, runAction, rule });
+              }
+              if (name === "send-email") {
+                const action = zSendEmailAction.parse(_action);
+                return await sendEmailAction({ matched, action, runAction, rule });
+              }
+            },
+            { concurrency: 1 },
+          );
+        })()
+          .then(TaskOK)
+          .catch(TaskError);
+
+        return { name: rule.name, matched, actions };
+      },
+      { concurrency: 1 },
+    );
+
+    if (enable === true) {
+      await FollowRuleSets.updateOne(
+        { name },
+        {
+          $set: { enabled: true, yamlWhenEnabled: code, yaml: code },
+          $push: { enableHistory: { mtime: new Date(), yaml: code } },
+        },
+      );
+    } else {
+      await FollowRuleSets.updateOne({ name }, { $set: { yaml: code } });
+    }
+    return parseResult;
+  })()
+    .then(TaskOK)
+    .catch(TaskError);
+}