proca 1.8.2 → 2.0.1

package/src/commands/widget/add.mjs

@@ -1,14 +1,11 @@
 import { Flags } from "@oclif/core";
-import CampaignGet from "#src/commands/campaign/get.mjs";
-import OrgGet from "#src/commands/org/get.mjs";
+import { getCampaign } from "#src/commands/campaign/get.mjs";
+import { getOrg } from "#src/commands/org/get.mjs";
 import Command from "#src/procaCommand.mjs";
 import { gql, mutation } from "#src/urql.mjs";
 
 export default class WidgetAdd extends Command {
-  //static args = { path: { description: "" } };
-
   static flags = {
-    // flag with no value (-f, --force)
     ...super.globalFlags,
     campaign: Flags.string({
       char: "c",
@@ -23,8 +20,8 @@ export default class WidgetAdd extends Command {
     }),
     lang: Flags.string({
       char: "l",
-      description: "language",
       default: "en",
+      description: "language",
       helpValue: "<en>",
     }),
     name: Flags.string({
@@ -35,90 +32,84 @@ export default class WidgetAdd extends Command {
   };
 
   create = async (flag) => {
-    const orgName = flag.org;
-    let campaign = { org: { name: orgName } }; // no need to fetch the campaign if the orgName is specified
-    let org = {}; // no need to fetch the campaign if the orgName is specified
+    let campaign = null;
+
+    if (!flag.org) {
+      campaign = await getCampaign({ name: flag.campaign });
+      if (!campaign) {
+        throw new Error(`campaign not found: ${flag.campaign}`);
+      }
+      flag.org = campaign.org.name;
+    }
+
+    const org = await getOrg({
+      name: flag.org,
+      campaigns: false,
+      keys: false,
+    });
+
+    const input = {
+      name: flag.name ?? `${flag.campaign}/${flag.org}/${flag.lang}`,
+      locale: flag.lang,
+    };
 
-    const addWidgetDocument = gql`
+    if (flag.config) {
+      input.config =
+        typeof flag.config === "string" ? JSON.parse(flag.config) : flag.config;
+    }
+
+    // else if (org?.config?.layout) {
+    //   input.config = { layout: org.config.layout };
+    // }
+
+    // Optional ActionPage fields
+    if (flag.journey) input.journey = flag.journey;
+    if (flag.thankYouTemplate) {
+      input.thank_you_template = flag.thankYouTemplate;
+    }
+
+    if (flag.live !== undefined) input.live = flag.live;
+
+    const Document = gql`
       mutation addPage(
-        $campaign: String!
-        $org: String!
-        $name: String!
-        $lang: String!
-        $config: Json
+        $campaignName: String!
+        $orgName: String!
+        $input: ActionPageInput!
       ) {
         addActionPage(
-          campaignName: $campaign
-          orgName: $org
-          input: { name: $name, locale: $lang, config: $config }
+          campaignName: $campaignName
+          orgName: $orgName
+          input: $input
         ) {
           id
         }
       }
     `;
 
-    if (!orgName) {
-      try {
-        const campapi = new CampaignGet();
-        campaign = await campapi.fetch({ name: flag.campaign });
-        flag.org = campaign.org.name;
-        if (!flag.name) {
-          flag.name = `${campaign.name}/${flag.lang}`;
-        }
-      } catch (e) {
-        console.log("error", e);
-        throw e;
-      }
-    }
-
-    if (!campaign) {
-      throw new Error(`campaign not found: ${flag.campaign}`);
-    }
-
     try {
-      const orgapi = new OrgGet();
-      org = await orgapi.fetch({
-        name: flag.org,
-        campaigns: false,
-        keys: false,
+      const r = await mutation(Document, {
+        campaignName: flag.campaign,
+        orgName: flag.org,
+        input,
       });
-      if (org.config.layout) {
-        flag.config = JSON.stringify({ layout: org.config.layout });
-      }
-    } catch (e) {
-      console.log("error", e);
-      throw e;
-    }
-
-    if (!flag.name) {
-      flag.name = `${flag.campaign}/${flag.org}/${flag.lang}`;
-    }
-    try {
-      const r = await mutation(addWidgetDocument, flag);
       return { id: r.addActionPage.id };
     } catch (e) {
-      const errors = e.graphQLErrors;
-      console.log(JSON.stringify(errors, null, 2), flag);
-      if (errors[0].path[1] === "name") {
-        this.error(`invalid name (already taken?): ${flag.name}`);
-        throw new Error(errors[0].message);
+      const err = e.graphQLErrors?.[0];
+
+      if (err?.path?.[1] === "name") {
+        this.error(`invalid name (already taken?): ${input.name}`);
       }
-      if (errors[0].extensions?.code === "permission_denied") {
-        console.error("permission denied to create", name, campaign?.org.name);
-        throw new Error(errors[0].message);
+
+      if (err?.extensions?.code === "permission_denied") {
+        this.error(`permission denied to create widget for org ${flag.org}`);
       }
-      console.log(flag);
-      //			const page = await fetchByName(name);
-      //			console.warn("duplicate of widget", page.id);
-      throw new Error(errors[0].message);
+
+      throw new Error(err?.message ?? "failed to create widget");
     }
   };
 
   async run() {
-    const { args, flags } = await this.parse();
-
-    //		const org = { name: flags.twitter || flags.name, config: {} };
-
+    const { flags } = await this.parse();
     const data = await this.create(flags);
     return this.output(data);
   }

package/src/commands/widget/delete.mjs

@@ -5,41 +5,41 @@ import Command from "#src/procaCommand.mjs";
 import { gql, mutation } from "#src/urql.mjs";
 
 export default class WidgetDelete extends Command {
-	static description = "Delete a widget";
+  static description = "Delete a widget";
 
-	static args = this.multiid();
+  static args = this.multiid();
 
-	static flags = {
-		...this.flagify({ multiid: true }),
-	};
+  static flags = {
+    ...this.flagify({ multiid: true }),
+  };
 
-	delete = async (flags) => {
-		const deletePageDocument = gql`
+  delete = async (flags) => {
+    const deletePageDocument = gql`
       mutation delete( $name:String!) {
         deleteActionPage(name: $name)
       }
     `;
 
-		const r = await mutation(deletePageDocument, { name: flags.name });
-		return { deleted: r.deleteActionPage };
-	};
+    const r = await mutation(deletePageDocument, { name: flags.name });
+    return { deleted: r.deleteActionPage };
+  };
 
-	table = (r) => {
-		super.table(r, null, null);
-	};
+  table = (r) => {
+    super.table(r, null, null);
+  };
 
-	async run() {
-		const { flags } = await this.parse(WidgetDelete);
-		const wg = new WidgetGet([], this.config);
-		const widget = await wg.fetch(flags);
-		try {
-			const data = await this.delete({ name: widget.name });
-			widget.status = data.deleted;
-		} catch (e) {
-			widget.status = "can't delete widgets with actions";
-			this.output(widget);
-			this.error("a widget with actions can't be deleted");
-		}
-		return this.output(widget);
-	}
+  async run() {
+    const { flags } = await this.parse(WidgetDelete);
+    const wg = new WidgetGet([], this.config);
+    const widget = await wg.fetch(flags);
+    try {
+      const data = await this.delete({ name: widget.name });
+      widget.status = data.deleted;
+    } catch (e) {
+      widget.status = "can't delete widgets with actions";
+      this.output(widget);
+      this.error("a widget with actions can't be deleted");
+    }
+    return this.output(widget);
+  }
 }

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

@@ -0,0 +1,52 @@
+import { Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class CounterUpdate extends Command {
+  static description =
+    "Update the global counter to add the actions collected elsewhere";
+
+  static examples = ["see also <%= config.bin %> contact count"];
+  static args = this.multiid();
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    total: Flags.string({
+      char: "t",
+      description: "new total to include",
+      required: true,
+      parse: (input) => Number.parseInt(input, 10),
+    }),
+  };
+
+  async updateCounter(id, counter) {
+    const PushWidgetDocument = gql`
+mutation updateActionPage($id: Int!, $counter: Int!) {
+  updateActionPage(id: $id, input: {extraSupporters:$counter}) {
+    id, name, locale
+    ...on PrivateActionPage { extraSupporters }
+  }
+}`;
+    const r = await mutation(PushWidgetDocument, {
+      id,
+      counter,
+    });
+    if (r.errors) {
+      console.log(r);
+      console.log("check your config $npx proca config user");
+      throw new Error(r.errors[0].message || "can't update on the server");
+    }
+    return r.updateActionPage;
+  }
+
+  async run() {
+    const { flags } = await this.parse(CounterUpdate);
+
+    try {
+      const updated = await this.updateCounter(flags.id, flags.total);
+      return this.output(updated, { single: true });
+    } catch (error) {
+      this.error(error.message, { exit: 1 });
+    }
+  }
+}

package/src/commands/widget/get.mjs

@@ -3,6 +3,11 @@ import Command from "#src/procaCommand.mjs";
 import { FragmentSummary } from "#src/queries/widget.mjs";
 import { gql, query } from "#src/urql.mjs";
 
+export const getWidget = (params) => {
+  const d = new WidgetGet([]);
+  return d.fetch(params);
+};
+
 export default class WidgetGet extends Command {
   static description = "view a widget";
 

package/src/commands/widget/list.mjs

@@ -4,6 +4,11 @@ import Command from "#src/procaCommand.mjs";
 import { FragmentSummary, FragmentSummaryOrg } from "#src/queries/widget.mjs";
 import { gql, query } from "#src/urql.mjs";
 
+export const getWidgetList = (params) => {
+  const d = new WidgetList([]);
+  return d.fetch(params);
+};
+
 export default class WidgetList extends Command {
   static description = "list all the widgets of an org or campaign";
 
@@ -19,6 +24,7 @@ export default class WidgetList extends Command {
       //      exactlyOne: ["campaign", "org"], actually, we can filter on both
       description: "widgets of the organisation (coordinator or partner)",
       helpValue: "<organisation name>",
+      exactlyOne: ["campaign", "org"],
       //      required: true,
     }),
     campaign: Flags.string({
@@ -120,12 +126,8 @@ ${FragmentSummaryOrg}
   };
 
   async run() {
-    const { flags, args } = await this.parse(WidgetList);
+    const { flags } = await this.parse(WidgetList);
     let data = [];
-    if (!flags.org && !flags.campaign) {
-      const help = new Help(this.config);
-      this.error("Must specify --org or --campaign or --help for more");
-    }
     if (flags.org) data = await this.fetchOrg(flags.org);
     if (flags.campaign) data = await this.fetchCampaign(flags.campaign);
     return this.output(data);

package/src/commands/widget/update.mjs

@@ -0,0 +1,174 @@
+import { Args, Flags } from "@oclif/core";
+import { merge } from "merge-anything";
+import WidgetGet from "#src/commands/widget/get.mjs";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class WidgetUpdate extends Command {
+  static description = "Update a widget's properties";
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> 4454 --name new_widget_name",
+    "<%= config.bin %> <%= command.id %> 4454 --locale fr",
+    "<%= config.bin %> <%= command.id %> 4454 --confirm-optin",
+    "<%= config.bin %> <%= command.id %> 4454 --confirm-optin --dry-run",
+  ];
+
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+    rename: Flags.string({
+      char: "n",
+      description: "new name for the widget",
+      helpValue: "<widget name>",
+    }),
+
+    locale: Flags.string({
+      char: "l",
+      description: "change the locale",
+      helpValue: "<locale>",
+    }),
+    color: Flags.string({
+      description: "update color (not yet implemented)",
+      helpValue: "<hex code>",
+    }),
+    "confirm-optin": Flags.boolean({
+      description:
+        "add confirmOptIn (check email snack) to consent.email component ",
+
+      default: false,
+    }),
+    "confirm-action": Flags.boolean({
+      description:
+        "add actionConfirm (check email snack) to consent.email component ",
+
+      default: false,
+    }),
+
+    "dry-run": Flags.boolean({
+      description: "Show changes without updating the widget",
+      default: false,
+    }),
+  };
+
+  fetchWidget = async (params) => {
+    const widgetGet = new WidgetGet([], this.config);
+    return widgetGet.fetch(params);
+  };
+
+  update = async (widgetId, input) => {
+    console.log("Updating widget with input:", input);
+    const Document = gql`
+      mutation UpdateActionPage($id: Int!, $input: ActionPageInput!) {
+        updateActionPage(id: $id, input: $input) {
+          id
+          name
+          locale
+          config
+          thankYouTemplate
+        }
+      }
+    `;
+
+    const payload = {
+      ...input,
+      ...(input.config && typeof input.config !== "string"
+        ? { config: JSON.stringify(input.config) }
+        : {}),
+    };
+
+    const r = await mutation(Document, {
+      id: widgetId,
+      input: payload,
+    });
+
+    return r.updateActionPage;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+    if (this.flags.config) {
+      this.prettyJson(r.config);
+    }
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const {
+      id,
+      rename,
+      locale,
+      color,
+      "confirm-optin": confirmOptIn,
+      "confirm-action": confirmAction,
+      "dry-run": dryRun,
+    } = flags;
+
+    // Fetch current widget
+    const widget = await this.fetchWidget({ id });
+
+    if (!widget) {
+      this.error("Widget not found");
+    }
+
+    // Validate name
+    if (rename) {
+      const nameParts = renname.split("/");
+      if (nameParts.length < 2) {
+        this.error(
+          "Widget name must follow format: campaign_name/org_name or campaign_name/locale or campaign_name/org_name/locale",
+        );
+      }
+    }
+
+    const input = {
+      name: rename ?? widget.name,
+      locale: locale ?? widget.locale,
+    };
+
+    if (color) {
+      this.error(`Color update requested: ${color} (not yet implemented)`);
+    }
+    if (confirmOptIn || confirmAction) {
+      const act = confirmOptIn ? "confirmOptIn" : "confirmAction";
+      const currentConfig =
+        typeof widget.config === "string"
+          ? JSON.parse(widget.config)
+          : (widget.config ?? {});
+
+      const nextConfig = merge(currentConfig, {
+        component: {
+          consent: {
+            email: {
+              [act]: true,
+            },
+          },
+        },
+      });
+
+      input.config = nextConfig;
+
+      this.log(`✓ Will set consent.email.${act} = true`);
+
+      if (dryRun) {
+        this.log("\n--- DRY RUN ---\n");
+        this.log("FROM:");
+        this.log(JSON.stringify(currentConfig, null, 2));
+        this.log("\nTO:");
+        this.log(JSON.stringify(nextConfig, null, 2));
+        this.log("\n(no mutation executed)");
+        return;
+      }
+    }
+
+    try {
+      const updated = await this.update(widget.id, input);
+      this.log("✓ Widget updated successfully");
+      return this.output(updated);
+    } catch (err) {
+      this.error(`Failed to update widget: ${err.message}`);
+    }
+  }
+}

package/src/config.mjs

@@ -3,47 +3,47 @@ import { join } from "node:path";
 import { config as dotenv } from "dotenv";
 
 export const getFilename = (folder, env = "default") =>
-	join(folder, `${env}.env`);
+  join(folder, `${env}.env`);
 
 export const load = (folder, env = "default") => {
-	const file = getFilename(folder, env);
-	const config = dotenv({ path: file });
+  const file = getFilename(folder, env);
+  const config = dotenv({ path: file });
 
-	return {
-		token: config.parsed.PROCA_TOKEN,
-		url: config.parsed.REACT_APP_API_URL,
-		folder: process.env.PROCA_CONFIG_FOLDER,
-	};
+  return {
+    token: config.parsed.PROCA_TOKEN,
+    url: config.parsed.REACT_APP_API_URL,
+    folder: process.env.PROCA_CONFIG_FOLDER,
+  };
 };
 
 export const get = (file, parsed = false) => {
-	try {
-		if (parsed) {
-			const config = dotenv({ path: file });
-			return config.parsed;
-		}
-		const userConfig = readFileSync(file, "utf8");
-		return userConfig;
-	} catch (e) {
-		if (e.code === "ENOENT") {
-			return undefined;
-		}
-		throw e;
-	}
+  try {
+    if (parsed) {
+      const config = dotenv({ path: file });
+      return config.parsed;
+    }
+    const userConfig = readFileSync(file, "utf8");
+    return userConfig;
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return undefined;
+    }
+    throw e;
+  }
 };
 
 export const write = (file, content) => {
-	writeFileSync(file, content);
+  writeFileSync(file, content);
 };
 
 export const format = (obj) => {
-	const content = ["# generated by proca-cli"];
-	for (const [key, value] of Object.entries(obj)) {
-		if (value) {
-			content.push(`${key}='${value.replace(/'/g, "''")}'`);
-		} else {
-			content.push(`#${key}= `);
-		}
-	}
-	return content.join("\n");
+  const content = ["# generated by proca-cli"];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value) {
+      content.push(`${key}='${value.replace(/'/g, "''")}'`);
+    } else {
+      content.push(`#${key}= `);
+    }
+  }
+  return content.join("\n");
 };