proca 0.8.1 → 1.1.5

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,20 @@
+import oclif from "@oclif/core";
+import { config as dotenv } from "dotenv";
+import { getFilename, load } from "#src/config.mjs";
+import CustomHelp from "./help.mjs";
+
+const hook = async (opts) => {
+	const config = load(opts.config.configDir);
+	if (config) {
+		opts.config.procaConfig = config;
+	} else {
+		const file = getFilename(opts.config.configDir);
+		this.warn("missing config", file);
+	}
+
+	//console.log(opts);
+	//console.log(opts.config.helpClass, CustomHelp);
+	//	opts.config.helpClass = CustomHelp;
+};
+
+export default hook;

package/src/index.mjs

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

package/src/procaCommand.mjs

@@ -0,0 +1,242 @@
+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";
+import initHook from "#src/hooks/init.mjs";
+import { createClient } from "#src/urql.mjs";
+
+class ProcaCommand extends Command {
+	static enableJsonFlag = true;
+	procaConfig = { url: "https://api.proca.app/api" };
+	format = "human"; // the default formatting
+	flags = {};
+
+	static baseFlags = {
+		human: Flags.boolean({
+			helpGroup: "OUTPUT", // Optional, groups it under a specific help section if desired
+			description: "Format output to be read on screen by a human [default]",
+			default: true,
+		}),
+		json: Flags.boolean({
+			helpGroup: "OUTPUT", // Optional, groups it under a specific help section if desired
+			description: "Format output as json",
+			exclusive: ["human", "csv"],
+		}),
+		csv: Flags.boolean({
+			description: "Format output as csv",
+			helpGroup: "OUTPUT", // Optional, groups it under a specific help section if desired
+		}),
+		simplify: Flags.boolean({
+			helpGroup: "OUTPUT",
+			description:
+				"flatten and filter to output only the most important attributes, mostly relevant for json",
+			allowNo: true,
+		}),
+	};
+
+	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 = Object.assign({}, 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;
+	}
+
+	static hooks = {
+		init: async (options) => {
+			console.log("init hook called", options);
+			process.exit(1);
+		},
+	};
+	async init() {
+		await super.init();
+		const { argv, flags } = await this.parse();
+		this.flags = flags;
+		if (flags.json) this.format = "json";
+		if (flags.csv) this.format = "csv";
+
+		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);
+	}
+
+	async catch(err) {
+		// Check if the error was caused by a missing flag or wrong argument format
+		try {
+			this.error(err.toString());
+		} catch (e) {
+			console.log(e);
+		}
+	}
+
+	flatten = (obj, prefix = "", result = {}) => {
+		Object.entries(obj).forEach(([k, v]) => {
+			const newKey = Object.hasOwn(result, k) && prefix ? `${prefix}-${k}` : k;
+
+			if (v?.constructor === Object) {
+				this.flatten(v, newKey, result);
+			} else {
+				result[newKey] = v;
+			}
+		});
+		return result;
+	};
+
+	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") {
+				if (value?.name) r[key] = value.name;
+				continue;
+			}
+			r[key] = value;
+		}
+		return r;
+	};
+
+	tlog(color, ...msg) {
+		const coloredMsg = msg.map((d) => ux.colorize(this.config.theme[color], d));
+		this.log(...coloredMsg);
+	}
+
+	info(...msg) {
+		this.tlog("info", msg);
+	}
+
+	prettyJson(obj) {
+		if (typeof obj === "string") {
+			obj = JSON.parse(obj);
+		}
+		this.log(ux.colorizeJson(obj, { theme: this.config.theme.json }));
+	}
+
+	warn(...msg) {
+		this.tlog("warn", ...msg);
+	}
+	error(msg, options = {}) {
+		const colouredMessage = ux.colorize(this.config.theme.error, msg);
+		super.error(colouredMessage, options);
+	}
+
+	async csv(data) {
+		return new Promise((resolve, reject) => {
+			let d = null;
+			const format = this.flags.simplify
+				? this.simplify
+				: (d) => this.flatten(d, "");
+			if (Array.isArray(data)) {
+				d = data.map(format);
+			} else {
+				d = [format(data)];
+			}
+			const stream = fastcsv
+				.write(d, { headers: true })
+				.on("finish", () => {
+					console.log();
+					resolve();
+				})
+				.on("error", reject);
+
+			stream.pipe(process.stdout);
+		});
+	}
+
+	table(data, transformRow, print = (table) => table.toString()) {
+		if (!transformRow) {
+			if (this.flags.simplify !== false) {
+				transformRow = (d, cell) => {
+					for (const [key, value] of Object.entries(this.simplify(d))) {
+						cell(key, value);
+					}
+				};
+			} else {
+				transformRow = (d, cell) => {
+					for (const [key, value] of Object.entries(this.flatten(d))) {
+						cell(key, value);
+					}
+				};
+			}
+		}
+		const theme = this.config.theme;
+		Table.prototype.pushDelimeter = function (cols) {
+			// hack to change the formatting of the header
+			cols = cols || this.columns();
+			cols.forEach(function (col) {
+				this.cell(
+					col,
+					undefined,
+					Table.leftPadder(ux.colorize(theme.flagSeparator, "-")),
+				);
+			}, this);
+			return this.newRow();
+		};
+		this.log(Table.print(data, transformRow, print));
+	}
+
+	async output(data) {
+		if (this.format === "json") {
+			if (this.flags.simplify)
+				return data?.map(this.simplify) || this.simplify(data);
+			const isDirectCall = process.argv.join(":").includes(this.id);
+			return data;
+		}
+		if (this.format === "csv") {
+			return this.csv(data);
+		}
+		return this.table(data);
+	}
+}
+
+export { ProcaCommand as Command, Args, Flags };
+export default ProcaCommand;

package/src/queries/campaign.mjs

@@ -0,0 +1,21 @@
+import { gql } from "#src/urql.mjs";
+
+export const FragmentSummary = gql`fragment Summary on Campaign {id name title externalId status}`;
+
+export const FragmentOrg = gql`
+      fragment Org on Campaign {
+        org {
+          name
+          title
+        }
+      }
+    `;
+
+export const FragmentStats = gql`
+      fragment Stats on Campaign {
+        stats {
+          supporterCount
+          actionCount {actionType count}
+        }
+      }
+    `;

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

@@ -0,0 +1,60 @@
+import { authExchange } from "@urql/exchange-auth";
+import {
+	createClient as _createClient,
+	cacheExchange,
+	fetchExchange,
+	gql,
+} from "urql";
+
+import { GraphQLError, formatError } from "graphql";
+
+export let client = {
+	query: () => {
+		throw new Error("urql graphql not initialised, call init first");
+	},
+};
+
+// Create a URQL client with your GraphQL API endpoint
+export const createClient = (config) => {
+	if (!config) {
+		console.error("config missing on createClient");
+	}
+	client = _createClient({
+		url: config?.url || "https://api.proca.app/api",
+		exchanges: [
+			//		cacheExchange, // Handles caching
+			authExchange(async (utils) => {
+				const token = config.token;
+
+				return {
+					addAuthToOperation(operation) {
+						if (!token) return operation;
+						return utils.appendHeaders(operation, {
+							Authorization: `Bearer ${token}`,
+						});
+					},
+				};
+			}),
+			fetchExchange, // Handles fetching
+		],
+	});
+};
+
+export const query = async (query, payload) => {
+	const result = await client.query(query, payload).toPromise();
+	if (result.error) {
+		//console.log(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;
+};
+
+export { gql };

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);
+	}
+};

package/theme.json

@@ -0,0 +1,29 @@
+{
+	"info": "cyan",
+	"warn": "#FFAB40",
+	"error": "red",
+	"bin": "block",
+	"command": "cyan",
+	"commandSummary": "black",
+	"dollarSign": "white",
+	"flag": "blackBright",
+	"flagDefaultValue": "blue",
+	"flagOptions": "white",
+	"flagRequired": "red",
+	"flagSeparator": "white",
+	"json": {
+		"brace": "magenta",
+		"bracket": "magenta",
+		"colon": "dim",
+		"comma": "dim",
+		"key": "yellow",
+		"string": "green",
+		"number": "green",
+		"boolean": "green",
+		"null": "red"
+	},
+	"sectionDescription": "blackBright",
+	"sectionHeader": "underline",
+	"topic": "cyan",
+	"version": "white"
+}