proca 0.8.1 → 1.1.5

package/src/commands/campaign/delete.mjs

@@ -0,0 +1,61 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import {
+	FragmentOrg,
+	FragmentStats,
+	FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class CampaignDelete extends Command {
+	actionTypes = new Set();
+
+	static args = {};
+
+	static description = "delete a campaign";
+
+	static examples = ["<%= config.bin %> <%= command.id %> -i 42"];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		id: Flags.string({
+			char: "i",
+			parse: (input) => {
+				return Number.parseInt(input, 10);
+			},
+			description: "id of the campaign",
+			exactlyOne: ["id", "name"],
+			helpValue: "<organisation name>",
+		}),
+		name: Flags.string({
+			char: "n",
+			description: "name of the campaign",
+			helpValue: "<campaign name>",
+		}),
+	};
+
+	mutate = async ({ id, name }) => {
+		const Document = gql`
+mutation ($id: Int, $name: String) {
+  deleteCampaign(id: $id, name: $name)
+}`;
+		const result = await mutation(Document, {
+			id: id,
+			name: name,
+		});
+		return result.deleteCampaign;
+	};
+
+	table = (r) => {
+		super.table(r, null, null);
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+
+		const data = await this.mutate({ id: flags.id, name: flags.name });
+		return this.output(data);
+	}
+}

package/src/commands/campaign/get.mjs

@@ -0,0 +1,107 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import {
+	FragmentOrg,
+	FragmentStats,
+	FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class CampaignGet extends Command {
+	actionTypes = new Set();
+
+	static args = this.multiid();
+
+	static description = "view a campaign";
+
+	static examples = ["<%= config.bin %> <%= command.id %> -i 42"];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...this.flagify({ multiid: true }),
+		config: Flags.boolean({
+			description: "display the config",
+			default: false,
+			allowNo: true,
+		}),
+		stats: Flags.boolean({
+			description: "display the stats",
+			default: true,
+			allowNo: true,
+		}),
+		locale: Flags.string({
+			description: "display a locale",
+		}),
+	};
+
+	fetch = async ({ id, name }) => {
+		const GetCampaignDocument = gql`
+      query GetCampaign($id: Int, $name: String, $withStats: Boolean = false) {
+        campaign (name: $name, id: $id) {
+          ...Summary
+          ...Org
+          config
+          ...Stats @include(if: $withStats)
+        }
+      }
+      ${FragmentStats}
+      ${FragmentSummary}
+      ${FragmentOrg}
+    `;
+		const result = await query(GetCampaignDocument, {
+			id: id,
+			name: name,
+			withStats: this.flags.stats,
+		});
+		return result.campaign;
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			Name: d.name,
+			Title: d.title,
+			Org: d.org.name,
+			Status: d.status,
+			locales: d.config.locales && Object.keys(d.config.locales).join(" "),
+			journey: d.config.journey?.join(" → "),
+		};
+		if (this.flags.stats) {
+			result["#Supporters"] = d.stats.supporterCount;
+
+			this.actionTypes.forEach((type) => {
+				const action = d.stats.actionCount.find(
+					(action) => action.actionType === type,
+				);
+				if (action) result[`#${type}`] = action.count;
+			});
+		}
+		return result;
+	};
+
+	table = (r) => {
+		r.config = JSON.parse(r.config);
+		super.table(r, null, null);
+		if (this.flags.locale) {
+			this.prettyJson(r.config?.locales[this.flags.locale]);
+		}
+		if (this.flags.config) {
+			r.config.locales = undefined;
+			this.prettyJson(r.config);
+		}
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+
+		const data = await this.fetch({ id: flags.id, name: flags.name });
+		if (this.flags.stats) {
+			data.stats.actionCount.forEach((d) => {
+				//skip share_confirmed?
+				this.actionTypes.add(d.actionType);
+			});
+		}
+		return this.output(data);
+	}
+}

package/src/commands/campaign/list.mjs

@@ -0,0 +1,156 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import {
+	FragmentOrg,
+	FragmentStats,
+	FragmentSummary,
+} from "#src/queries/campaign.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class CampaignList extends Command {
+	actionTypes = new Set();
+
+	static args = {
+		title: Args.string({ description: "name of the campaign, % for wildchar" }),
+	};
+
+	static description = "list all the campaigns";
+
+	static examples = ["<%= config.bin %> <%= command.id %> %pizza%"];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		org: Flags.string({
+			char: "o",
+			description: "campaigns of the organisation (coordinator or partner)",
+			exactlyOne: ["org", "title"],
+			helpValue: "<organisation name>",
+		}),
+		title: Flags.string({
+			char: "t",
+			description: "name of the campaign, % for wildchar",
+			helpValue: "<campaign title>",
+		}),
+		stats: Flags.boolean({
+			description: "display the stats",
+			default: true,
+			allowNo: true,
+		}),
+	};
+
+	OrgSearch = async (name) => {
+		const SearchCampaignsDocument = gql`
+      query SearchCampaigns($org: String!, $withStats: Boolean = false) {
+        org (name:$org) {
+        campaigns {
+          ...Summary
+          ...Org
+          ...Stats @include(if: $withStats)
+        }
+        }
+      }
+      ${FragmentStats}
+      ${FragmentOrg}
+      ${FragmentSummary}
+    `;
+		const result = await query(SearchCampaignsDocument, {
+			org: name,
+			withStats: this.flags.stats,
+		});
+		return result.org.campaigns;
+		//return result.campaigns.map (d => {d.config = JSON.parse(d.config); return d});
+	};
+
+	Search = async (title) => {
+		const SearchCampaignsDocument = gql`
+      query SearchCampaigns($title: String!, $withStats: Boolean = false) {
+        campaigns(title: $title) {
+          ...Summary
+          ...Org
+          ...Stats @include(if: $withStats)
+        }
+      }
+      ${FragmentStats}
+      ${FragmentOrg}
+      ${FragmentSummary}
+    `;
+		const result = await query(SearchCampaignsDocument, {
+			title: title,
+			withStats: this.flags.stats,
+		});
+		return result.campaigns;
+		//return result.campaigns.map (d => {d.config = JSON.parse(d.config); return d});
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			Name: d.name,
+			Title: d.title,
+			Org: d.org.name,
+			Status: d.status,
+		};
+		if (this.flags.stats) {
+			result["#Supporters"] = d.stats.supporterCount;
+
+			this.actionTypes.forEach((type) => {
+				const action = d.stats.actionCount.find(
+					(action) => action.actionType === type,
+				);
+				if (action) result[`#${type}`] = action.count;
+			});
+		}
+		return result;
+	};
+
+	table = (r) => {
+		super.table(r, null, (table) => table.sort(["id|des"]).toString());
+	};
+
+	async run() {
+		const { args, flags } = await this.parse(CampaignList);
+		let data = [];
+
+		if (args.title && flags.title) {
+			throw new Error(
+				`${this.id} EITHER [title of the campaign] OR --title [title of the campaign]`,
+			);
+		}
+		if (args.title) {
+			flags.title = args.title;
+		}
+
+		if (!flags.title && !flags.org) {
+			throw new Error(
+				`${this.id} -t [title of the campaign] or -o [organisation]`,
+			);
+		}
+
+		if (flags.title) {
+			data = await this.Search(flags.title);
+			if (this.flags.stats) {
+				data.forEach((d) => {
+					d.stats.actionCount.forEach((d) => {
+						//skip share_confirmed?
+						this.actionTypes.add(d.actionType);
+					});
+				});
+			}
+		}
+
+		if (flags.org) {
+			data = await this.OrgSearch(flags.org);
+			if (this.flags.stats) {
+				data.forEach((d) => {
+					d.stats.actionCount.forEach((d) => {
+						//skip share_confirmed?
+						this.actionTypes.add(d.actionType);
+					});
+				});
+			}
+		}
+		return this.output(data);
+	}
+}

package/src/commands/campaign/queries.graphql

@@ -0,0 +1,19 @@
+query SearchCampaigns($name: String!) {
+	campaigns(name: $name) {
+		id
+		name
+		title
+		config
+	}
+}
+
+query GetOrgCampaigns($org: String!) {
+	org(name: $org) {
+		campaigns {
+			id
+			name
+			title
+			config
+		}
+	}
+}

package/src/commands/config/add.mjs

@@ -0,0 +1,101 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import { get as getConfig, getFilename, write } from "#src/config.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignList extends Command {
+	static enableJsonFlag = true;
+	static aliases = ["config:setup"];
+	static deprecateAliases = true;
+
+	static args = {
+		environment: Args.string({
+			description: "environment",
+			default: "default",
+		}),
+	};
+
+	static description = "create setting to access the server authentication";
+
+	static examples = [
+		"<%= config.bin %> <%= command.id %> --user=xavier@example.org --token=API-12345789",
+	];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		force: Flags.boolean({
+			description: "write over an existing configuration",
+			default: false,
+			helpValue: "(default false)",
+		}),
+		url: Flags.string({
+			description: "url of the proca server api",
+			default: "https://api.proca.app/api",
+			helpValue: "<url>",
+		}),
+		token: Flags.string({
+			description: "user token on proca server",
+			helpValue: "<API-token>",
+			required: true,
+		}),
+		n8n: Flags.string({
+			description: "api access on the n8n server",
+			helpValue: "<n8n api>",
+		}),
+		supabase: Flags.string({
+			description: "url of the supabase",
+			helpValue: "<url>",
+		}),
+		"supabase-anon-key": Flags.string({
+			description: "anonymous key",
+		}),
+		"supabase-secrey-key": Flags.string({
+			description: "secret service key",
+		}),
+	};
+
+	format = (obj) => {
+		const content = ["# generated by proca-api"];
+		for (const [key, value] of Object.entries(obj)) {
+			if (value) {
+				content.push(`${key}='${value.replace(/'/g, "''")}'`);
+			} else {
+				content.push(`#${key}= `);
+			}
+		}
+		return content.join("\n");
+	};
+
+	generate = function () {
+		const mapping = {
+			REACT_APP_NAME: "proca",
+			REACT_APP_API_URL: this.flags.url,
+			PROCA_TOKEN: this.flags.token,
+			N8N_TOKEN: this.flags.n8n,
+			REACT_APP_SUPABASE_URL: this.flags.supabase,
+			REACT_APP_SUPABASE_ANON_KEY: this.flags.supabase_anon_key,
+			SUPABASE_SECRET_KEY: this.flags.supabase_secret_key,
+		};
+
+		return this.format(mapping);
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		const file = getFilename(this.config.configDir);
+
+		const userConfig = getConfig(file);
+		if (userConfig && !this.flags.force) {
+			this.error("config file exists already", {
+				code: "CONFIG_ERR",
+				_ref: "README.md#",
+				suggestions: [
+					`edit ${file}`,
+					"add --force flag\nWARNING, it will delete the existing file",
+				],
+			});
+		}
+		write(file, this.generate());
+	}
+}

package/src/commands/config/get.mjs

@@ -0,0 +1,33 @@
+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 ConfigServer extends Command {
+	static description = "get the server config";
+
+	fetch = async () => {
+		const Document = gql`
+query {
+  application {
+    logLevel
+    name
+    version
+  }
+}`;
+		const result = await query(Document, {});
+		return result.application;
+	};
+
+	table = (r) => {
+		super.table(r, null, null);
+	};
+
+	async run() {
+		//		const { args, flags } = await this.parse();
+
+		const data = await this.fetch();
+		return this.output(data);
+	}
+}

package/src/commands/config/set.mjs

@@ -0,0 +1,103 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import { get as getConfig, getFilename, load, write } from "#src/config.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class CampaignList extends Command {
+	static enableJsonFlag = true;
+	static aliases = ["config:setup"];
+	static deprecateAliases = true;
+
+	static args = {
+		key: Args.string({
+			description: "variable name",
+			multiple: false,
+		}),
+		value: Args.string({
+			description: "value",
+			multiple: true,
+		}),
+	};
+
+	static description =
+		"update the setting used to authenticate to the servers and services";
+
+	static examples = [
+		"<%= config.bin %> <%= command.id %> --user=xavier@example.org --token=API-12345789",
+		"<%= config.bin %> <%= command.id %> VAR1 VALUE",
+	];
+
+	static flags = {
+		// flag with no value (-f, --force)
+		...super.globalFlags,
+		environment: Flags.string({
+			description: "environment",
+			default: "default",
+		}),
+		url: Flags.string({
+			description: "url of the proca server api",
+			default: "https://api.proca.app/api",
+			helpValue: "<url>",
+		}),
+		token: Flags.string({
+			description: "user token on proca server",
+			helpValue: "<API-token>",
+		}),
+	};
+
+	format = (obj) => {
+		const content = ["# generated by proca-api"];
+		for (const [key, value] of Object.entries(obj)) {
+			if (value) {
+				content.push(`${key}='${value.replace(/'/g, "''")}'`);
+			} else {
+				content.push(`#${key}= `);
+			}
+		}
+		return content.join("\n");
+	};
+
+	generate = function () {
+		const mapping = {
+			...args,
+			REACT_APP_NAME: "proca",
+			REACT_APP_API_URL: this.flags.url,
+			PROCA_TOKEN: this.flags.token,
+		};
+
+		return this.format(mapping);
+	};
+
+	regenerate = function (config, args) {
+		config[args.key] = args.value;
+		console.log(this.format(config));
+		process.exit(1);
+		return this.format(config);
+	};
+	async run() {
+		const config = this.config;
+		const { args, flags, raw } = await this.parse();
+		const rawf = raw.filter((d) => d.type === "flag").map((d) => d.flag);
+
+		const file = getFilename(this.config.configDir);
+
+		const userConfig = getConfig(file, true);
+
+		this.info("config file", file);
+
+		if (userConfig) {
+			if (args.key && args.value) {
+				write(file, this.regenerate(userConfig, args));
+			} else {
+				console.log(userConfig);
+				this.error("config file exists already", {
+					code: "CONFIG_ERR",
+					_ref: "README.md#",
+					suggestions: ["add KEY VALUE to update or add new variables"],
+				});
+			}
+		} else {
+			write(file, this.generate());
+		}
+	}
+}

package/src/commands/config/token.mjs

@@ -0,0 +1,34 @@
+import crypto from "node:crypto";
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+
+export default class UserList extends Command {
+	static description = "convert between token and sql value";
+
+	static flags = {
+		token: Flags.string({
+			exactlyOne: ["token"],
+			description: "the token in your config",
+			helpValue: "API-xxx",
+		}),
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		if (flags.token) {
+			const token = flags.token
+				.replace("API-", "")
+				.replace(/-/g, "+")
+				.replace(/_/g, "/");
+			const decoded = Buffer.from(token, "base64").toString("utf-8");
+			const hexa = crypto.createHash("sha256").update(decoded).digest("hex");
+			console.log(token, decoded, hexa);
+
+			return this.output({ hexa: `\\x${hexa}` });
+		}
+		const data = flags;
+
+		return this.output(data);
+	}
+}

package/src/commands/config/user.mjs

@@ -0,0 +1,76 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class UserList extends Command {
+	static description =
+		"fetch the information about the current user (based on the token)";
+
+	static examples = ["<%= config.bin %> <%= command.id %>"];
+
+	static flags = {
+		...super.globalFlags,
+	};
+
+	fetch = async (params) => {
+		const Document = gql`
+query  {
+  currentUser {
+    apiToken {
+      expiresAt
+    }
+    email
+    id
+    isAdmin
+    jobTitle
+    phone
+    pictureUrl
+    roles {
+      role org {name}
+    }
+  }
+}
+    `;
+		const result = await query(Document);
+		return result.currentUser;
+		//return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+	};
+
+	simplify = (d) => {
+		const result = {
+			id: d.id,
+			email: d.email,
+		};
+		if (d.apiToken) {
+			result.tokenExpire = d.apiToken.expiresAt;
+		}
+		if (d.isAdmin) {
+			result.admin = true;
+		}
+		const roles = d.roles.reduce((acc, item) => {
+			if (!acc[item.role]) {
+				acc[item.role] = [];
+			}
+			acc[item.role].push(item.org.name);
+			return acc;
+		}, {});
+		for (const role in roles) {
+			result[role] = roles[role].join(",");
+		}
+		return result;
+	};
+
+	table = (r) => {
+		super.table(r, null, null);
+	};
+
+	async run() {
+		const { args, flags } = await this.parse();
+		let data = [];
+
+		data = await this.fetch();
+
+		return this.output(data);
+	}
+}