proca 0.1.3 → 0.4.1

package/src/commands/widget/list.mjs

@@ -0,0 +1,116 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { FragmentSummary } from "#src/queries/widget.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class WidgetList extends Command {
+	static description = "list all the widgets of an org or campaign";
+
+	static examples = ["<%= config.bin %> <%= command.id %> -o <organisation>"];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		org: Flags.string({
+			char: "o",
+			exactlyOne: ["campaign", "org"],
+			description: "widgets of the organisation (coordinator or partner)",
+			helpValue: "<organisation name>",
+			//      required: true,
+		}),
+		campaign: Flags.string({
+			char: "c",
+			description: "widgets of the campaign (coordinator or partner)",
+			helpValue: "<campaign name>",
+			//      required: true,
+		}),
+		config: Flags.boolean({
+			description: "get the config",
+			default: false,
+			allowNo: true,
+		}),
+	};
+	fetchCampaign = async (name) => {
+		const Document = gql`
+query SearchWidgets($campaign: String!, $withConfig: Boolean!) {
+  campaign (name:$campaign) { ...on PrivateCampaign {
+    actionPages {
+      ...Summary
+      config @include(if: $withConfig)
+      thankYouTemplate
+      thankYouTemplateRef
+      ...on PrivateActionPage {
+        supporterConfirmTemplate
+      }
+    }}
+  }
+${FragmentSummary}
+}`;
+		const result = await query(Document, {
+			campaign: name,
+			withConfig: this.flags.config,
+		});
+		return result.campaign.actionPages;
+	};
+
+	fetchOrg = async (name) => {
+		const Document = gql`
+query SearchWidgets($org: String!, $withConfig: Boolean!) {
+  org (name:$org) {
+    actionPages {
+      ...Summary
+      config @include(if: $withConfig)
+      thankYouTemplate
+      thankYouTemplateRef
+      ...on PrivateActionPage {
+        supporterConfirmTemplate
+      }
+    }
+  }
+${FragmentSummary}
+}`;
+		const result = await query(Document, {
+			org: name,
+			withConfig: this.flags.config,
+		});
+		return result.org.actionPages;
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			name: d.name,
+			locale: d.locale,
+			status: d.status.toLowerCase(),
+			location: d.location?.startsWith("https://widget.proca.app")
+				? undefined
+				: d.location || undefined,
+			//			live: d.live,
+
+			//      thankYouTemplate: d.thankYouTemplate || undefined,
+			//      thankYouTemplateRef: d.thankYouTemplateRef || undefined,
+			// supporterConfirmTemplate: d.supporterConfirmTemplate || undefined,
+		};
+		if (d.extraSupporters > 0) {
+			result.extra = d.extraSupporters;
+		}
+		if (d.journey) result.journey = d.journey.join(" → ");
+
+		if (this.flags.config) {
+		}
+		return result;
+	};
+
+	table = (r) => {
+		super.table(r, null, (table) => table.sort(["id|des"]).toString());
+	};
+
+	async run() {
+		const { flags, args } = await this.parse(WidgetList);
+		let data = [];
+		if (flags.org) data = await this.fetchOrg(flags.org);
+		if (flags.campaign) data = await this.fetchCampaign(flags.campaign);
+		return this.output(data);
+	}
+}

package/src/config.mjs

@@ -19,7 +19,7 @@ export const get = (file) => {
 		const userConfig = readFileSync(file, "utf8");
 		return userConfig;
 	} catch (e) {
-		if (e.code === "ENOENT" && onMissing) {
+		if (e.code === "ENOENT") {
 			return undefined;
 		}
 		throw e;

package/src/hooks/help.mjs

@@ -0,0 +1,14 @@
+import { Config, Help } from "@oclif/core";
+
+export default class CustomHelp extends Help {
+	showCommandHelp(command) {
+		//		console.log("This will be displayed in single-command CLIs");
+		super.showCommandHelp(command);
+	}
+
+	async showHelp(argv) {
+		//    console.log('This will be displayed in multi-command CLIs')
+		// Always include --all flag to show all commands
+		await super.showHelp([...argv, "--all"]);
+	}
+}

package/src/hooks/init.mjs

@@ -0,0 +1,12 @@
+import oclif from "@oclif/core";
+import CustomHelp from "./help.mjs";
+
+//console.log("hook init");
+
+const hook = async (opts) => {
+	//console.log(opts);
+	//console.log(opts.config.helpClass, CustomHelp);
+	//	opts.config.helpClass = CustomHelp;
+};
+
+export default hook;

package/src/procaCommand.mjs

@@ -1,5 +1,6 @@
-import { Command, Flags, ux } from "@oclif/core";
+import { Args, Command, Flags, ux } from "@oclif/core";
 import debug from "debug";
+import { parse as dxid, id } from "dxid";
 import Table from "easy-table";
 import fastcsv from "fast-csv";
 
@@ -9,37 +10,82 @@ import { createClient } from "#src/urql.mjs";
 export class ProcaCommand extends Command {
 	static enableJsonFlag = true;
 	procaConfig = { url: "https://api.proca.app/api" };
-	format = "table"; // the default formatting
+	format = "human"; // the default formatting
 	flags = {};
 
 	static baseFlags = {
-		table: Flags.boolean({
+		human: Flags.boolean({
 			helpGroup: "OUTPUT", // Optional, groups it under a specific help section if desired
-			description: "Format output as table [default]",
+			description: "Format output to be read on screen by a human [default]",
 			default: true,
-			exclusive: ["csv", "json"],
 		}),
 		json: Flags.boolean({
 			helpGroup: "OUTPUT", // Optional, groups it under a specific help section if desired
 			description: "Format output as json",
-			exclusive: ["csv", "table"],
+			exclusive: ["human", "json"],
 		}),
 		csv: Flags.boolean({
 			description: "Format output as csv",
 			helpGroup: "OUTPUT", // Optional, groups it under a specific help section if desired
-			exclusive: ["json", "table"],
 		}),
 		simplify: Flags.boolean({
 			helpGroup: "OUTPUT",
 			description:
-				"flatten and filter to output only the most important attributes",
+				"flatten and filter to output only the most important attributes, mostly relevant for json",
 			dependsOn: ["json"],
 		}),
 	};
 
+	static multiid() {
+		const args = {
+			id_name_dxid: Args.string({
+				ignoreStdin: true,
+				hidden: true,
+				description:
+					"it's better to use -i <id> or -x <dxid> or -n <name>, but you can for convenience",
+			}),
+		};
+		return args;
+	}
+
+	static flagify(params = {}) {
+		const flags = ProcaCommand.baseFlags;
+		if (params.multiid) {
+			flags.id = Flags.string({
+				char: "i",
+				parse: (input) => Number.parseInt(input, 10),
+				exclusive: ["name", "dxid"],
+			});
+			flags.dxid = Flags.string({
+				char: "x",
+				description: "dxid",
+			});
+			flags.name = Flags.string({
+				char: "n",
+				charAliases: ["o"],
+				description: "name",
+				helpValue: "<the_short_name>",
+			});
+		}
+		return flags;
+	}
+
+	async parse() {
+		const parsed = await super.parse();
+		const maybe = parsed.args.id_name_dxid;
+		if (maybe) {
+			const d = dxid(maybe, false);
+			if (d) parsed.flags.id = d;
+			else parsed.flags.name = maybe;
+		}
+		if (parsed.flags.dxid) {
+			parsed.flags.id = dxid(parsed.flags.dxid);
+		}
+		return parsed;
+	}
 	async init() {
 		await super.init();
-		const { flags } = await this.parse();
+		const { argv, flags } = await this.parse();
 		this.flags = flags;
 		if (flags.json) this.format = "json";
 		if (flags.csv) this.format = "csv";
@@ -55,21 +101,45 @@ export class ProcaCommand extends Command {
 		createClient(userConfig);
 	}
 
+	async catch(err) {
+		// Check if the error was caused by a missing flag or wrong argument format
+
+		if (
+			err.message.includes("Unexpected argument") ||
+			err.message.includes("flag")
+		) {
+			// Try to adjust the argument as a flag
+			const argv = process.argv;
+			console.log(argv);
+			if (argv.includes("param")) {
+				// Adjusting the argument 'param' to be a flag `-id`
+				const paramIndex = argv.indexOf("param");
+				argv.splice(paramIndex, 0, "-id"); // Insert the flag `-id` before 'param'
+			}
+
+			// Re-run the command with modified arguments
+			await this.parse();
+		} else {
+			throw err;
+		}
+	}
+
 	simplify = (d) => {
 		const r = {};
 		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 (typeof value === "string" || typeof value === "number") {
 				r[key] = value;
 				continue;
 			}
 
-			if (typeof value === "object" && value.name) {
-				r[key] = value.name;
+			if (typeof value === "object") {
+				if (value?.name) r[key] = value.name;
 				continue;
 			}
+			r[key] = value;
 		}
 		return r;
 	};
@@ -118,15 +188,14 @@ export class ProcaCommand extends Command {
 		});
 	}
 
-	table(
-		data,
-		transformRow = (d, cell) => {
-			for (const [key, value] of Object.entries(this.simplify(d))) {
-				cell(key, value);
-			}
-		},
-		print = (table) => table.toString(),
-	) {
+	table(data, transformRow, print = (table) => table.toString()) {
+		if (!transformRow) {
+			transformRow = (d, cell) => {
+				for (const [key, value] of Object.entries(this.simplify(d))) {
+					cell(key, value);
+				}
+			};
+		}
 		const theme = this.config.theme;
 		Table.prototype.pushDelimeter = function (cols) {
 			// hack to change the formatting of the header

package/src/queries/widget.mjs

@@ -0,0 +1,12 @@
+import { gql } from "#src/urql.mjs";
+
+export const FragmentSummary = gql`fragment Summary on PrivateActionPage {
+id
+locale
+name
+journey
+extraSupporters
+status,
+location
+}
+`;

package/src/urql.mjs

@@ -6,6 +6,8 @@ import {
 	gql,
 } from "urql";
 
+import { GraphQLError, formatError } from "graphql";
+
 export let client = {
 	query: () => {
 		throw new Error("urql graphql not initialised, call init first");
@@ -38,7 +40,16 @@ export const createClient = (config) => {
 export const query = async (query, payload) => {
 	const result = await client.query(query, payload).toPromise();
 	if (result.error) {
-		throw new Error(result.error);
+		console.log(formatError(result.error));
+		throw result.error;
+	}
+	return result.data;
+};
+
+export const mutation = async (mutation, payload) => {
+	const result = await client.mutation(mutation, payload).toPromise();
+	if (result.error) {
+		throw result.error;
 	}
 	return result.data;
 };

package/src/util/flags.mjs

@@ -12,28 +12,22 @@
 // instrumentation.
 // -------------------------------------------------------------------------------
 
-export type ProcessLike = {
-  argv: string[];
-  env: { [key: string]: string | undefined };
-};
+export function _preprocessCliFlags(process) {
+	process.argv.map((arg) => {
+		if (arg === "--dev-debug") {
+			let debug = "*";
+			const filterIndex = process.argv.indexOf("--debug-filter");
+			if (filterIndex > 0) {
+				debug = process.argv[filterIndex + 1];
 
-export function preprocessCliFlags(process: ProcessLike): void {
-  process.argv.map((arg) => {
-    if (arg === '--dev-debug') {
-      let debug = '*';
-      const filterIndex = process.argv.indexOf('--debug-filter');
-      if (filterIndex > 0) {
-        debug = process.argv[filterIndex + 1];
+				process.argv.splice(filterIndex, 2);
+			}
+			// convert --dev-debug into a set of environment variables
+			process.env.DEBUG = debug;
+			process.env.PROCA_ENV = "development";
 
-        process.argv.splice(filterIndex, 2);
-      }
-      // convert --dev-debug into a set of environment variables
-      process.env.DEBUG = debug;
-      process.env.PROCA_ENV = 'development';
-
-
-      // need to calculate indexOf --dev-debug here because it might've changed based on --debug-filter
-      process.argv.splice(process.argv.indexOf('--dev-debug'), 1);
-    }
-  });
+			// need to calculate indexOf --dev-debug here because it might've changed based on --debug-filter
+			process.argv.splice(process.argv.indexOf("--dev-debug"), 1);
+		}
+	});
 }

package/src/util/twitter.mjs

@@ -0,0 +1,23 @@
+export const getTwitter = async (org) => {
+	const orgName = org.config.twitter?.screen_name || org.name;
+	try {
+		const res = await fetch(
+			`https://twitter.proca.app/?screen_name=${orgName}`,
+		);
+
+		if (res.status >= 400) {
+			throw new Error("Bad response from twitter.proca.app");
+		}
+
+		const twitter = await res.json();
+		twitter.picture = twitter.profile_image_url_https;
+		twitter.profile_image_url_https = undefined;
+		if (twitter) org.config.twitter = twitter;
+		if (!org.config.description) org.config.description = twitter.description;
+		if (!org.config.location) org.config.location = twitter.location;
+		if (!org.config.url) org.config.url = twitter.url;
+		if (!org.title) org.title = twitter.name;
+	} catch (err) {
+		console.error(err);
+	}
+};