proca 2.2.1 → 2.5.0

package/src/commands/widget/external/index.mjs

@@ -0,0 +1,132 @@
+import { Flags } from "@oclif/core";
+import oPath from "object-path";
+import { updateCounter } from "#src/commands/widget/update/external.mjs";
+import Command from "#src/gitCommand.mjs";
+
+export const update = async (config) => {
+  const d = new CounterExternal([]);
+  //      const config = await d.getCounterConfig({id});
+  if (!config) {
+    console.warn("missing config");
+    return undefined;
+  }
+  const counter = await d.fetchCounter(config);
+  await updateCounter(config.id, counter);
+  return { name: config.name, counter, id: config.id };
+};
+
+export default class CounterExternal extends Command {
+  static description =
+    "Pull external counter and save it into a widget extra Supporter";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --url https://mitmachen.wwf.de/node/506/polling",
+  ];
+  static args = this.multiid();
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    url: Flags.string({
+      char: "u",
+      description: "API endpoint URL to pull from",
+      relationships: [{ type: "some", flags: ["path", "dry-run"] }],
+    }),
+    path: Flags.string({
+      helpValue: "object.sub-object.total",
+      description:
+        "dot notation path to the counter field in the json returned by the url",
+    }),
+    total: Flags.integer({
+      description: "number to add to the total",
+      relationships: [
+        // define complex relationships between flags
+        { type: "none", flags: ["url", "path"] },
+      ],
+    }),
+    timeout: Flags.integer({
+      description: "Request timeout in milliseconds",
+      default: 10000,
+    }),
+    "dry-run": Flags.boolean({
+      description: "just fetch, don't update",
+    }),
+  };
+
+  async fetchCounter({ url, path, timeout = 10000, "dry-run": verbose }) {
+    try {
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(timeout),
+        headers: {
+          "User-Agent": "proca/451.42",
+        },
+      });
+      if (!response.ok) {
+        this.error(`API request failed with status ${response.status}`, {
+          exit: 1,
+        });
+      }
+
+      const data = await response.json();
+      if (verbose) {
+        this.log(JSON.stringify(data, null, 2));
+      }
+      const counter = oPath.get(data, path);
+      if (
+        Number.isNaN(Number.parseFloat(counter)) ||
+        !Number.isFinite(counter)
+      ) {
+        this.error(`Could not extract value from ${counter} at ${path}`, {
+          exit: 1,
+        });
+      }
+      return Number.parseFloat(counter);
+    } catch (err) {
+      if (err.name === "TimeoutError") {
+        console.error("Request timed out after", timeout, "ms");
+      } else if (err.cause?.code === "ETIMEDOUT") {
+        console.error("Network timeout — server unreachable:", url);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  async getCounterConfig() {
+    const data = await this.read();
+    if (!data.component.counter)
+      this.error(
+        "missing config.component.counter {url, path} in ${this.getFile()}",
+      );
+    return data.component.counter;
+  }
+
+  async run() {
+    const { flags } = await this.parse(CounterExternal);
+    let counter = undefined;
+    if (!flags.url && !flags.total) {
+      const config = await this.getCounterConfig();
+      flags.url = config.url;
+      flags.path = config.path;
+    }
+
+    if (flags.url) {
+      counter = await this.fetchCounter(flags);
+    }
+    if (flags.total) {
+      counter = flags.total;
+    }
+    if (flags["dry-run"]) {
+      return this.output(
+        {
+          counter,
+          url: flags.url,
+          //            response: JSON.stringify(data, null, 2),
+        },
+        { single: true },
+      );
+    }
+
+    const updated = await updateCounter(flags.id, counter);
+    return this.output(updated, { single: true });
+  }
+}

package/src/gitCommand.mjs

@@ -0,0 +1,173 @@
+import fs from "node:fs";
+//import { load as loadConfig } from "proca/src/config.mjs";
+import path from "node:path";
+import chalk from "chalk";
+import simpleGit from "simple-git";
+import ProcaCommand from "#src/procaCommand.mjs";
+export { Args, Flags } from "#src/index.mjs";
+
+export class ProcaGitCommand extends ProcaCommand {
+  fileName = undefined;
+  newFile = undefined;
+
+  static extension = "json";
+
+  initGit = () => {
+    if (!fs.existsSync(path.join(this.config.procaConfig.folder, "/.git"))) {
+      this.warn("config not on git");
+    }
+    return simpleGit({ baseDir: this.config.procaConfig.folder });
+  };
+
+  commit = async () => this.git.commit(this.gitMessage(), [this.getFile()]);
+
+  checkFile = (fileName) => {
+    if (fileName.toString().includes("..")) {
+      this.error("invalid filename ", fileName);
+    }
+    return fileName;
+  };
+  // mkdir -p
+  mkdirp = () => {
+    fs.mkdirSync(this.getFile(), { recursive: true });
+  };
+
+  getFolder = () => {
+    const mapping = { widget: "./", campaign: "campaign/", org: "org/" };
+    const type = this.id.split(":")[0];
+    const folder = mapping[type];
+    if (!folder) this.error(`no folder defined for ${type}`);
+    return folder;
+  };
+
+  setFile = (name, ext = "json") => {
+    if (!name) {
+      const folder = this.getFolder();
+      if (folder === "./") {
+        //we are dealing with widgets
+        name = `${folder}${this._flags.id}`;
+      } else {
+        name = `${folder}${this._flags.name}`;
+      }
+    }
+    this.fileName = path.join(
+      this.config.procaConfig.folder,
+      `${this.checkFile(name)}.${ext}`,
+    );
+    return this.fileName;
+  };
+
+  getFile = () => {
+    if (!this.fileName) this.error("you need to setFile first");
+    return this.fileName;
+  };
+
+  gitMessage = (_obj) => `proca cli ${this.id}`;
+
+  fileExists = () => {
+    return fs.existsSync(this.getFile());
+  };
+
+  uncommited = async ({ file, commit = false, exit = true }) => {
+    if (!this.git) return false;
+    if (!file) file = this.getFile();
+    const status = await this.git.status();
+    const relative = path.relative(this.config.procaConfig.folder, file);
+
+    const hasChanges = status.modified.includes(relative);
+    if (!hasChanges) return false;
+    if (commit) {
+      this.git.commit(this.gitMessage(data, file));
+    }
+    if (exit) {
+      this.log(await this.diff(file));
+      this.error(`Your local changes to ${file} would be overwritten`, {
+        code: "git error",
+        exit: 1,
+        suggestions: ["run with --auto to commit the changes before pulling"],
+      });
+    }
+    return true;
+  };
+
+  read = async ({ file = this.getFile(), commit } = {}) => {
+    try {
+      let data;
+      if (!file) file = getFile();
+      const ext = this.constructor.extension;
+      console.log("read file", file, ext);
+      if (ext === "json") {
+        data = JSON.parse(fs.readFileSync(file, "utf8"));
+      } else {
+        data = fs.readFileSync(file, "utf8");
+      }
+      if (commit && this.git) {
+        const status = await this.git.status();
+        const hasChanges = status.modified.includes(file);
+        if (hasChanges) {
+          this.git.commit(this.gitMessage(data, file));
+        }
+      }
+      return data;
+    } catch (e) {
+      console.error(`no local copy of ${file}: ${e.message}`);
+      return null;
+    }
+  };
+
+  stringify = (obj) =>
+    `${JSON.stringify(
+      obj,
+      (_key, value) => (value === null ? undefined : value),
+      2,
+    )}\n`;
+
+  diff = async (file) => {
+    const diff = await this.git.diff([file || this.getFile()]);
+    const colorDiff = diff
+      .split("\n")
+      .map((line) => {
+        if (line.startsWith("+")) return chalk.green(line);
+        if (line.startsWith("-")) return chalk.red(line);
+        if (line.startsWith("@@")) return chalk.cyan(line);
+        return line;
+      })
+      .join("\n");
+    return colorDiff;
+  };
+
+  save = async (json) => {
+    let needToAdd = false;
+    const file = this.getFile();
+    if (this.git && !this.fileExists(file)) {
+      needToAdd = true;
+    }
+    this.uncommited({ file }); //exit if unsaved, better to always stash?
+    fs.writeFileSync(file, this.stringify(json));
+    if (this.git) {
+      if (needToAdd) {
+        await this.git.add(file);
+      }
+      const diff = await this.diff(file);
+      const r = await this.git.commit(this.gitMessage(json), file);
+      return { ...r, ...r.summary, diff };
+    }
+    return { file, git: false };
+  };
+
+  parse = async () => {
+    const r = await super.parse();
+    if (this._flags.git === false) {
+      this.git = undefined;
+    }
+    this._flags && this.setFile(null, this.constructor.extension);
+    return r;
+  };
+
+  async init() {
+    await super.init();
+    this.git = this.initGit();
+  }
+}
+
+export default ProcaGitCommand;

package/src/index.d.mts

@@ -0,0 +1 @@
+export { run, Args, Flags } from "@oclif/core";

package/src/procaCommand.mjs

@@ -10,7 +10,8 @@ class ProcaCommand extends Command {
   static enableJsonFlag = true;
   procaConfig = { url: "https://api.proca.app/api" };
   format = "human"; // the default formatting
-  flags = {};
+  flags = {}; // the definition
+  _flags = undefined; // the cli flags
 
   static baseFlags = {
     env: Flags.string({
@@ -50,16 +51,29 @@ class ProcaCommand extends Command {
     return args;
   }
 
-  static flagify({ multiid = false, name = false } = {}) {
+  static namearg() {
+    const args = {
+      name: Args.string({
+        ignoreStdin: true,
+        hidden: true,
+        description: "convenience, but try to use -n <name> instead",
+      }),
+    };
+    return args;
+  }
+
+  static flagify({ multiid = false, name = false, char } = {}) {
     const flags = Object.assign({}, ProcaCommand.baseFlags);
     if (name || multiid) {
       flags.name = Flags.string({
         char: "n",
+        charAliases: char ? ["n", char] : undefined,
         description: "name (technical short name, also called slug)",
         helpValue: typeof name === "string" ? `<${name}>` : "<the_short_name>",
         parse: (input) => ProcaCommand.safeName(input),
       });
     }
+
     if (multiid) {
       flags.id = Flags.string({
         char: "i",
@@ -84,9 +98,14 @@ class ProcaCommand extends Command {
 
   async parse() {
     const parsed = await super.parse();
+
+    if (parsed.args.name)
+      parsed.flags.name = ProcaCommand.safeName(parsed.args.name);
+
     if (this.ctor.args.id_name_dxid === undefined) {
       return parsed;
     }
+
     const maybe = parsed.args.id_name_dxid;
     if (maybe) {
       const identified = [
@@ -104,9 +123,11 @@ class ProcaCommand extends Command {
       if (d) parsed.flags.id = d;
       else parsed.flags.name = ProcaCommand.safeName(maybe);
     }
+
     if (parsed.flags.dxid) {
       parsed.flags.id = dxid(parsed.flags.dxid);
     }
+
     const identified = [
       parsed.flags.name,
       parsed.flags.id,
@@ -118,7 +139,7 @@ class ProcaCommand extends Command {
         code: 1,
       });
     }
-
+    this._flags = parsed.flags;
     return parsed;
   }
 
@@ -130,16 +151,16 @@ class ProcaCommand extends Command {
   };
   async init() {
     await super.init();
+    this.debug = debug("proca");
+    initHook({ config: this.config });
+    this.procaConfig = this.config.procaConfig; // set up from the hooks/init
+    //    await this.config.runHook('init', { config: this.config });
     const { flags } = await this.parse();
     this.flags = flags;
     if (flags.json) this.format = "json";
     if (flags.csv) this.format = "csv";
     if (flags.markdown) this.format = "markdown";
 
-    this.debug = debug("proca");
-    initHook({ config: this.config });
-    this.procaConfig = this.config.procaConfig; // set up from the hooks/init
-    //    await this.config.runHook('init', { config: this.config });
     createClient(this.procaConfig);
   }
 
@@ -157,6 +178,10 @@ class ProcaCommand extends Command {
     }
 
     if (err.networkError) {
+      if (err.response.status === 500) {
+        this.error("500 Internal Server Error", { exit: err.code || 1 });
+        return;
+      }
       this.info("Looks like there’s a problem with your internet connection");
       this.error(err.networkError.cause, { exit: err.code || 1 });
     }
@@ -186,7 +211,7 @@ class ProcaCommand extends Command {
     for (const [key, value] of Object.entries(d)) {
       if (key === "__typename") continue;
       if (key === "config" && typeof value === "string") continue; // it's just a giant mess if not processed, let's skipt
-      if (value === null) continue;
+      if (value === null || value === "") continue;
       if (typeof value === "string" || typeof value === "number") {
         r[key] = value;
         continue;
@@ -286,7 +311,7 @@ class ProcaCommand extends Command {
   table(data, transformRow, print = (table) => table.toString()) {
     if (!transformRow) {
       if (this.flags.simplify !== false) {
-        transformRow = (d, cell, idx) => {
+        transformRow = (d, cell) => {
           const r = this.simplify(d);
           if (r === null) return null;
           for (const [key, value] of Object.entries(r)) {
@@ -295,7 +320,7 @@ class ProcaCommand extends Command {
           return true;
         };
       } else {
-        transformRow = (d, cell, idx) => {
+        transformRow = (d, cell) => {
           for (const [key, value] of Object.entries(this.flatten(d))) {
             cell(key, value);
           }
@@ -316,15 +341,18 @@ class ProcaCommand extends Command {
       }, this);
       return this.newRow();
     };
-
     this.log(Table.print(data, transformRow, print));
   }
 
   single = (r) => {
-    this.table(r, null, null);
+    return this.table(r[0], null, null);
   };
 
   async output(data, { single = false } = {}) {
+    if (!Array.isArray(data)) {
+      data = [data];
+      single = true;
+    }
     if (this.format === "json") {
       if (this.flags.simplify)
         return data?.map(this.simplify) || this.simplify(data);

package/src/queries/campaign.mjs

@@ -1,6 +1,6 @@
 import { gql } from "#src/urql.mjs";
 
-export const FragmentSummary = gql`fragment Summary on Campaign {id name title externalId status}`;
+export const FragmentSummary = gql`fragment Summary on Campaign {id name title externalId status start end}`;
 
 export const FragmentMtt = gql`
       fragment Mtt on PrivateCampaign {

package/src/urql.mjs

@@ -51,7 +51,6 @@ export const query = async (query, payload) => {
 export const mutation = async (mutation, payload) => {
   const result = await client.mutation(mutation, payload).toPromise();
   if (result.error) {
-    console.log("error", result.error);
     throw result.error;
   }
   return result.data;