@proca/cli 3.3.1 → 3.8.3

package/src/commands/user/list.mjs

@@ -0,0 +1,80 @@
+import { Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export default class UserList extends Command {
+  actionTypes = new Set();
+
+  static description = "list all the users";
+
+  static examples = ["<%= config.bin %> <%= command.id %> %pizza%"];
+  static aliases = ["org:user:get"];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "organisation",
+      required: true,
+    }),
+  };
+
+  fetch = async (org) => {
+    const SearchUsersDocument = gql`
+query ($org: String!) {
+  users(select: {orgName: $org}) {
+    apiToken {
+      expiresAt
+    }
+    email
+    id
+    isAdmin
+    jobTitle
+    phone
+    pictureUrl
+    roles {
+      role org {name}
+    }
+  }
+}
+    `;
+    const result = await query(SearchUsersDocument, { org: org });
+    return result.users;
+    //return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.id,
+      email: d.email,
+    };
+    result.role =
+      d.roles.filter((d) => d.org.name === this.flags.org)[0]?.role || "??";
+
+    if (d.roles.length <= 4)
+      result.other_orgs = d.roles
+        .filter((d) => d.org.name !== this.flags.org)
+        .map((d) => d.org.name)
+        .join(",");
+    else result.other_orgs = `${d.roles.length - 1}`;
+
+    if (d.isAdmin) {
+      result.superadmin = true;
+    }
+    if (d.apiToken) {
+      result.tokenExpire = d.apiToken.tokenExpire;
+    }
+
+    return result;
+  };
+
+  async run() {
+    const { flags } = await this.parse(UserList);
+    let data = [];
+
+    data = await this.fetch(flags.org);
+
+    return this.output(data);
+  }
+}

package/src/commands/user/reset.mjs

@@ -0,0 +1,83 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout } from "@oclif/core/ux";
+import prompts from "prompts";
+import { format, get as getConfig, getFilename, write } from "#src/config.mjs";
+import Command from "#src/procaCommand.mjs";
+
+export default class UserReset extends Command {
+  static description = "Reset user API token";
+
+  static args = {
+    user: Args.string({ description: "Username (email)" }),
+  };
+
+  static flags = {
+    ...super.globalFlags,
+    password: Flags.string({ description: "Password" }),
+    url: Flags.string({ description: "URL of the Proca server API" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(UserReset);
+
+    const file = getFilename(this.config.configDir, flags.env);
+    const userConfig = getConfig(file, true) || {};
+
+    if (!args.user) {
+      const response = await prompts({
+        type: "text",
+        name: "user",
+        message: "Username:",
+      });
+      args.user = response.user;
+    }
+
+    if (!flags.password) {
+      const response = await prompts({
+        type: "password",
+        name: "password",
+        message: "Password:",
+      });
+      flags.password = response.password;
+    }
+
+    const url =
+      flags.url || userConfig.REACT_APP_API_URL || "https://api.proca.app/api";
+
+    if (!args.user || !flags.password) {
+      return error("User and password are required.");
+    }
+
+    const query = `mutation {
+            resetApiToken
+        }`;
+
+    const auth = `Basic ${Buffer.from(`${args.user}:${flags.password}`).toString("base64")}`;
+
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: auth,
+        },
+        body: JSON.stringify({ query }),
+      });
+
+      const data = await response.json();
+
+      if (data.errors) {
+        return error(data.errors.map((e) => e.message).join("\n"));
+      }
+
+      const newToken = data.data.resetApiToken;
+      this.log(`New API token: ${newToken}`);
+
+      userConfig.PROCA_TOKEN = newToken;
+      write(file, format(userConfig));
+      this.log(`Token saved to ${file}`);
+    } catch (e) {
+      error(e.message);
+    }
+  }
+}

package/src/commands/widget/add.mjs

@@ -0,0 +1,116 @@
+import { Flags } from "@oclif/core";
+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 flags = {
+    ...super.globalFlags,
+    campaign: Flags.string({
+      char: "c",
+      required: true,
+      description: "name of the campaign",
+      helpValue: "<campaign name>",
+    }),
+    org: Flags.string({
+      char: "o",
+      description: "organisation",
+      helpValue: "<en>",
+    }),
+    lang: Flags.string({
+      char: "l",
+      default: "en",
+      description: "language",
+      helpValue: "<en>",
+    }),
+    name: Flags.string({
+      char: "n",
+      description: "url slug",
+      helpValue: "by default  <campaign>/<org>/<lang>",
+    }),
+  };
+
+  create = async (flag) => {
+    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,
+    };
+
+    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(
+        $campaignName: String!
+        $orgName: String!
+        $input: ActionPageInput!
+      ) {
+        addActionPage(
+          campaignName: $campaignName
+          orgName: $orgName
+          input: $input
+        ) {
+          id
+        }
+      }
+    `;
+
+    try {
+      const r = await mutation(Document, {
+        campaignName: flag.campaign,
+        orgName: flag.org,
+        input,
+      });
+      return { id: r.addActionPage.id };
+    } catch (e) {
+      const err = e.graphQLErrors?.[0];
+
+      if (err?.path?.[1] === "name") {
+        this.error(`invalid name (already taken?): ${input.name}`);
+      }
+
+      if (err?.extensions?.code === "permission_denied") {
+        this.error(`permission denied to create widget for org ${flag.org}`);
+      }
+
+      throw new Error(err?.message ?? "failed to create widget");
+    }
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const data = await this.create(flags);
+    return this.output(data);
+  }
+}

package/src/commands/widget/delete.mjs

@@ -0,0 +1,45 @@
+import { createInterface } from "node:readline";
+import { Flags } from "@oclif/core";
+import WidgetGet from "#src/commands/widget/get.mjs";
+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 args = this.multiid();
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+  };
+
+  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 };
+  };
+
+  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);
+  }
+}

package/src/commands/widget/get.mjs

@@ -0,0 +1,60 @@
+import { Flags } from "@oclif/core";
+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";
+
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+    config: Flags.boolean({
+      description: "display the config",
+      default: true,
+      allowNo: true,
+    }),
+  };
+
+  fetch = async (params) => {
+    const GetWidgetDocument = gql`
+      query GetWidget($name: String, $id: Int, $config: Boolean = true) {
+        actionPage(name: $name, id: $id) {
+          ...Summary
+          org {
+            name
+          }
+          campaign {
+            name
+          }
+          thankYouTemplate
+          config @include(if: $config)
+        }
+      }
+      ${FragmentSummary}
+    `;
+    const result = await query(GetWidgetDocument, params);
+    result.actionPage.config = JSON.parse(result.actionPage.config);
+    return result.actionPage;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+    if (this.flags.config) {
+      this.prettyJson(r.config);
+    }
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    const data = await this.fetch(flags);
+    return this.output(data);
+  }
+}

package/src/commands/widget/list.mjs

@@ -0,0 +1,135 @@
+import { Args, Flags, Help } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+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";
+
+  static examples = ["<%= config.bin %> <%= command.id %> -o <organisation>"];
+
+  //  static aliases = ["campaign:widget:get", "org:widget:get"]; let's rewrite them for better aliasing
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      //      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({
+      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,
+    });
+    if (this.flags.org) {
+      return result.campaign.actionPages.filter(
+        (d) => d.org.name === this.flags.org,
+      );
+    }
+    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
+      }
+    }
+  }
+${FragmentSummaryOrg}
+}`;
+    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 (d.org) {
+      result.org = d.org.name;
+      result.org_id = d.org.id;
+    }
+    if (d.campaign) {
+      result.campaign = d.campaign.name;
+    }
+    if (this.flags.config) {
+    }
+    return result;
+  };
+
+  table = (r) => {
+    super.table(r, null, (table) => table.sort(["id|des"]).toString());
+  };
+
+  async run() {
+    const { flags } = 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/commands/widget/rebuild.mjs

@@ -0,0 +1,64 @@
+import { Flags } from "@oclif/core";
+import { mergeAndConcat as 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 WidgetRebuild extends Command {
+  static description = "(re)build a widget";
+
+  static examples = [
+    "<%= config.bin %> widget rebuild 42",
+    "<%= config.bin %> widget rebuild climate-action/my-org/en",
+    "SEE ALSO:",
+    "<%= config.bin %> campaign widget rebuild   Rebuild all the widgets of a campaign",
+  ];
+
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+  };
+
+  rebuild = async ({ widget, timestamp = new Date().toISOString() }) => {
+    //
+    const data = merge(widget, { config: { layout: { update: timestamp } } });
+
+    const PushWidgetDocument = gql`
+mutation updateActionPage($id: Int!, $config: Json!) {
+  updateActionPage(id: $id, input: {config:$config}) {
+    id, name, locale, config
+    ...on PrivateActionPage {
+      status
+      location
+      org {name}
+    }
+  }
+}
+    `;
+    const r = await mutation(PushWidgetDocument, {
+      id: data.id,
+      config: JSON.stringify(data.config),
+    });
+    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");
+    }
+    r.updateActionPage.update = data.config.layout.update;
+    return r.updateActionPage;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const wapi = new WidgetGet();
+    const widget = await wapi.fetch(flags);
+    const r = await this.rebuild({ widget });
+    return this.output(r);
+  }
+}