proca 0.1.1

package/src/index.mjs

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

package/src/procaCommand.mjs

@@ -0,0 +1,158 @@
+import { Command, Flags, ux } from "@oclif/core";
+import debug from "debug";
+import Table from "easy-table";
+import fastcsv from "fast-csv";
+
+import { getFilename as fileConfig, load as loadConfig } from "#src/config.mjs";
+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
+	flags = {};
+
+	static baseFlags = {
+		table: Flags.boolean({
+			helpGroup: "OUTPUT", // Optional, groups it under a specific help section if desired
+			description: "Format output as table [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"],
+		}),
+		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",
+			dependsOn: ["json"],
+		}),
+	};
+
+	async init() {
+		await super.init();
+		const { flags } = await this.parse();
+		this.flags = flags;
+		if (flags.json) this.format = "json";
+		if (flags.csv) this.format = "csv";
+
+		this.debug = debug("proca");
+		const userConfig = loadConfig(this.config.configDir);
+		if (userConfig) {
+			this.procaConfig = userConfig;
+		} else {
+			const file = fileConfig(this.config.configDir);
+			this.warn("missing config", file);
+		}
+		createClient(userConfig);
+	}
+
+	simplify = (d) => {
+		const r = {};
+		for (const [key, value] of Object.entries(d)) {
+			if (key === "__typename") continue;
+			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;
+				continue;
+			}
+		}
+		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;
+			if (Array.isArray(data)) {
+				d = data.map(this.simplify);
+			} else {
+				d = [this.simplify(data)];
+			}
+			const stream = fastcsv
+				.write(d, { headers: true })
+				.on("finish", () => {
+					console.log();
+					resolve();
+				})
+				.on("error", reject);
+
+			stream.pipe(process.stdout);
+		});
+	}
+
+	table(
+		data,
+		transformRow = (d, cell) => {
+			for (const [key, value] of Object.entries(this.simplify(d))) {
+				cell(key, value);
+			}
+		},
+		print = (table) => table.toString(),
+	) {
+		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);
+			return data;
+		}
+		if (this.format === "csv") {
+			return this.csv(data);
+		}
+		return this.table(data);
+	}
+}
+
+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/urql.mjs

@@ -0,0 +1,46 @@
+import { authExchange } from "@urql/exchange-auth";
+import {
+	createClient as _createClient,
+	cacheExchange,
+	fetchExchange,
+	gql,
+} from "urql";
+
+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) => {
+	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) {
+		throw new Error(result.error);
+	}
+	return result.data;
+};
+
+export { gql };

package/src/util/flags.mjs

@@ -0,0 +1,39 @@
+/*
+ * inspired by https://github.com/salesforcecli/cli/blob/main/src/flags.ts
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+// -------------------------------------------------------------------------------
+// No requires or imports since this is loaded early in the cli lifecycle and we
+// want to minimize the number of packages that load before enabling require
+// instrumentation.
+// -------------------------------------------------------------------------------
+
+export type ProcessLike = {
+  argv: string[];
+  env: { [key: string]: string | undefined };
+};
+
+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';
+
+
+      // 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/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"
+}