@proca/cli 3.4.5 → 3.8.3

package/src/commands/contact/list.mjs

@@ -0,0 +1,207 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import { formatDistanceToNowStrict } from "date-fns";
+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 List extends Command {
+  actionTypes = new Set();
+
+  static args = {
+    title: Args.string({ description: "name of the campaign, % for wildchar" }),
+  };
+
+  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)",
+      required: true,
+      //			exactlyOne: ["org", "title"],
+      helpValue: "<organisation name>",
+    }),
+    campaign: Flags.string({
+      char: "c",
+      description: "name of the campaign, % for wildchar",
+      helpValue: "<campaign title>",
+    }),
+    limit: Flags.string({
+      char: "n",
+      description: "max number of actions",
+      parse: (input) => Number.parseInt(input, 10),
+    }),
+    after: Flags.string({
+      description: "only actions after a date",
+      helpValue: "2025-04-09",
+      parse: (input) => new Date(input).toISOString(),
+    }),
+    today: Flags.boolean({
+      description: "only actions today",
+      exclusive: ["after"],
+      parse: (input) => `${new Date().toISOString().split("T")[0]}T00:00:00Z`,
+    }),
+    optin: Flags.boolean({
+      description: "only export the optin actions",
+      default: false,
+    }),
+    testing: Flags.boolean({
+      description: "also export the test actions",
+      default: false,
+    }),
+    doi: Flags.boolean({
+      description: "only export the double optin actions",
+      default: false,
+    }),
+    utm: Flags.boolean({
+      description: "display the utm tracking parameters",
+      default: true,
+      allowNo: true,
+      exclusive: ["simplify"],
+    }),
+    comment: Flags.boolean({
+      description: "display the comment",
+      default: true,
+      allowNo: true,
+      exclusive: ["simplify"],
+    }),
+  };
+
+  fetch = async (flags) => {
+    const Document = gql`
+      query (
+        $after: DateTime
+        $campaignId: Int
+        $campaignName: String
+        $includeTesting: Boolean
+        $limit: Int
+        $onlyDoubleOptIn: Boolean
+        $onlyOptIn: Boolean
+        $orgName: String!
+        $start: Int
+      ) {
+        contacts(
+          after: $after
+          campaignId: $campaignId
+          campaignName: $campaignName
+          includeTesting: $includeTesting
+          limit: $limit
+          onlyDoubleOptIn: $onlyDoubleOptIn
+          onlyOptIn: $onlyOptIn
+          orgName: $orgName
+          start: $start
+        ) {
+          actionId
+          actionPage {
+            id
+            locale
+            name
+          }
+          actionType
+          campaign {
+            name
+          }
+          contact {
+            contactRef
+            payload
+            nonce
+            publicKey {
+              public
+            }
+          }
+          createdAt
+          customFields
+          privacy {
+            emailStatus
+            emailStatusChanged
+            givenAt
+            optIn
+            withConsent
+          }
+          tracking {
+            campaign
+            content
+            medium
+            source
+          }
+        }
+      }
+    `;
+    const result = await query(Document, {
+      after: flags.after,
+      //  "campaignId": 42,
+      campaignName: flags.campaign,
+      includeTesting: flags.testing,
+      limit: flags.limit,
+      onlyDoubleOptIn: flags.doi,
+      onlyOptIn: flags.optin,
+      orgName: flags.org,
+      start: flags.start,
+    });
+    return result.contacts.map((d) => {
+      d.customFields = JSON.parse(d.customFields);
+      if (!d.contact.publicKey) {
+        const ref = d.contactRef;
+        d.contact = JSON.parse(d.contact.payload);
+        d.contact.contactRef = ref;
+      } else {
+        this.error(
+          `encrypted contact we need the private key for ${d.contact.publicKey.public}`,
+        );
+      }
+      return d;
+    });
+    //		return result.exportActions;
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.actionId,
+      firstname: d.contact.firstName,
+      country: d.contact.country,
+      email: d.contact.email,
+      type: d.actionType,
+      date: formatDistanceToNowStrict(d.createdAt),
+      campaign: !this.flags.campaign && d.campaign.name,
+      widget_id: d.actionPage.id,
+      widget: d.actionPage.name,
+      //            customFields
+    };
+    if (this.flags.comment && d.customFields?.comment)
+      result.comment = d.customFields.comment;
+    if (this.flags.utm && d.tracking) {
+      result.utm_medium =
+        d.tracking.medium === "unknown" ? undefined : d.tracking.medium;
+      result.utm_source =
+        d.tracking.source === "unknown" ? undefined : d.tracking.source;
+      result.utm_campaign =
+        d.tracking.campaign === "unknown" ? undefined : d.tracking.campaign;
+      if (d.tracking.content)
+        result.utm_content =
+          d.tracking.content === "unknown" ? undefined : d.tracking.content;
+    }
+    if (d.customFields?.emailProvider)
+      result.provider = d.customFields.emailProvider;
+    return result;
+  };
+
+  _table = (r) => {
+    super.table(r, null, (table) => table.sort(["id|des"]).toString());
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    if (flags.today) flags.after = flags.today;
+    let data = [];
+
+    data = await this.fetch(flags);
+    return this.output(data);
+  }
+}

package/src/commands/org/add.mjs

@@ -0,0 +1,75 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+import { getTwitter } from "#src/util/twitter.mjs";
+
+export default class OrgAdd extends Command {
+  static args = {};
+
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --name <twitter of the organisation> --title='this is an organisation'",
+    "<%= config.bin %> <%= command.id %> --twitter <twitter of the organisation>",
+  ];
+
+  static flags = {
+    ...super.globalFlags,
+    twitter: Flags.string({
+      description: "twitter account",
+      helpValue: "<screen name>",
+    }),
+    name: Flags.string({
+      char: "n",
+      description: "short name of the org",
+      helpValue: "<org acronym/name>",
+    }),
+    title: Flags.string({
+      char: "t",
+      description: "title/full name of the org",
+      helpValue: "<org full name>",
+    }),
+  };
+
+  create = async (_org) => {
+    const org = { ..._org, config: JSON.stringify(_org.config) };
+    console.log(org);
+
+    const AddOrgDocument = gql`
+mutation ($org: OrgInput!) {
+  addOrg(input: $org) {
+    config
+    name
+    title
+  }
+}
+    `;
+    const result = await mutation(AddOrgDocument, {
+      org,
+    });
+    if (!result.addOrg) {
+      console.log(result);
+      return result;
+    }
+    return result?.addOrg;
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    if (!flags.name && !flags.twitter) {
+      this.error("You must provide either --name or --twitter");
+    }
+
+    const org = {
+      name: flags.twitter || flags.name,
+      title: flags.title || flags.name,
+      config: {},
+    };
+
+    if (flags.twitter) {
+      await getTwitter(org);
+    }
+
+    const data = await this.create(org);
+    return this.output(data);
+  }
+}

package/src/commands/org/crm.mjs

@@ -0,0 +1,88 @@
+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/org.mjs";
+import { gql, mutation, query } from "#src/urql.mjs";
+
+export default class OrgCRM extends Command {
+  static description = "view a org crm synchroniser";
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    name: Flags.string({
+      char: "n",
+      charAliases: ["o"],
+      required: true,
+      description: "name of the org",
+      helpValue: "<org name>",
+    }),
+    synchronize: Flags.boolean({
+      //     default: undefined,
+      aliases: ["deliver", "enable"],
+      description: "enable or disable the synchronisation queue",
+      allowNo: true,
+    }),
+  };
+
+  fetch = async (params) => {
+    const GetOrgDocument = gql`
+      query GetOrg($name: String!) {
+        org (name: $name) {
+          id name title
+          processing { customActionDeliver }
+        }
+      }
+    `;
+    const result = await query(GetOrgDocument, {
+      name: params.name,
+    });
+    return result.org;
+  };
+
+  mutate = async (name, deliver) => {
+    const Document = gql`
+mutation ($name: String!, $deliver: Boolean!) {
+  updateOrgProcessing (name: $name,customActionDeliver: $deliver) {
+    id, name, title, processing {customActionDeliver}
+  }
+}
+    `;
+    console.log("deliver", deliver);
+    const result = await mutation(Document, {
+      name: name,
+      deliver: deliver,
+    });
+    console.log("deliver", deliver);
+    return result.updateOrgProcessing;
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.id,
+      name: d.name,
+      title: d.title,
+      deliver: d.processing.customActionDeliver,
+      queue: d.processing.customActionDeliver
+        ? `cus.${d.id}.deliver`
+        : "call with --synchronize to enable",
+    };
+    return result;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    if (typeof flags.synchronize === "boolean") {
+      const data = await this.mutate(flags.name, flags.synchronize);
+      return this.output(data);
+    }
+    const data = await this.fetch(flags);
+    if (!data.processing.customActionDeliver)
+      this.info("actions aren't delivered, call with --synchronize to enable");
+    return this.output(data);
+  }
+}

package/src/commands/org/delete.mjs

@@ -0,0 +1,48 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class OrgDelete extends Command {
+  static examples = [
+    "<%= config.bin %> <%= command.id %>  <organisation_name>",
+  ];
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: true }),
+    name: Flags.string({
+      char: "n",
+      description: "name of the org",
+      helpValue: "<org name>",
+    }),
+  };
+
+  delete = async (org) => {
+    console.log(org);
+
+    const DeleteOrgDocument = gql`
+mutation ($org: String!) {
+  deleteOrg(name: $org) 
+  
+}
+    `;
+    const result = await mutation(DeleteOrgDocument, {
+      org,
+    });
+    console.log(result);
+    if (!result.deleteOrg) {
+      console.log(result);
+      return result;
+    }
+    return result?.deleteOrg;
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+
+    const data = await this.delete(flags.name);
+    return data;
+  }
+}

package/src/commands/org/email.mjs

@@ -0,0 +1,111 @@
+import { Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+const SERVICE_NAMES = [
+  "MAILJET",
+  "SES",
+  "STRIPE",
+  "TEST_STRIPE",
+  "SYSTEM",
+  "PREVIEW",
+  "WEBHOOK",
+  "SUPABASE",
+  "SMTP",
+].map((d) => d.toLowerCase());
+
+export default class OrgEmail extends Command {
+  static description =
+    "Set email service and supporter confirmation for an org";
+
+  static args = this.multiid();
+
+  static flags = {
+    ...this.flagify({ multiid: true }),
+    mailer: Flags.string({
+      description: "service to send emails",
+      options: SERVICE_NAMES,
+      helpValue: SERVICE_NAMES,
+      default: "system",
+    }),
+    from: Flags.string({
+      description: "Email address to send from",
+      helpValue: "default <org>@proca.app",
+    }),
+    "supporter-confirm": Flags.boolean({
+      description: "enable/disable action confirmation emails",
+      allowNo: true,
+    }),
+    "supporter-confirm-template": Flags.string({
+      description: "add confirmation template",
+    }),
+  };
+
+  async mutate(flags) {
+    flags.from = flags.from || `${flags.org}@proca.app`;
+
+    const Document = gql`
+      mutation UpdateOrgProcessing(
+        $name: String!
+        $emailBackend: ServiceName!
+        $emailFrom: String!
+        $supporterConfirm: Boolean
+        $supporterConfirmTemplate: String
+      ) {
+        updateOrgProcessing(
+          name: $name
+          emailBackend: $emailBackend
+          emailFrom: $emailFrom
+          supporterConfirm: $supporterConfirm
+          supporterConfirmTemplate: $supporterConfirmTemplate
+        ) {
+          id
+          name
+          processing {
+            emailBackend
+            emailFrom
+            supporterConfirm
+            supporterConfirmTemplate
+          }
+          personalData {
+            supporterConfirm
+            supporterConfirmTemplate
+          }
+        }
+      }
+    `;
+
+    const variables = {
+      name: flags.name,
+      emailBackend: flags.mailer.toUpperCase(),
+      emailFrom: flags.from,
+    };
+
+    if (flags["supporter-confirm"] !== undefined) {
+      variables.supporterConfirm = flags["supporter-confirm"];
+      console.log("supporter-confirm", variables.supporterConfirm);
+    }
+
+    if (flags["supporter-confirm-template"]) {
+      variables.supporterConfirmTemplate = flags["supporter-confirm-template"];
+    }
+
+    const result = await mutation(Document, variables);
+    return result.updateOrgProcessing;
+  }
+
+  simplify = (d) => ({
+    id: d.id,
+    name: d.name,
+    mailer: d.processing.emailBackend,
+    from: d.processing.emailFrom,
+    supporterConfirm: d.personalData?.supporterConfirm,
+    supporterConfirmTemplate: d.personalData?.supporterConfirmTemplate,
+  });
+
+  async run() {
+    const { flags } = await this.parse();
+    const result = await this.mutate(flags);
+    this.output(result);
+  }
+}

package/src/commands/org/get.mjs

@@ -0,0 +1,152 @@
+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/org.mjs";
+import { gql, query } from "#src/urql.mjs";
+
+export const getOrg = (params) => {
+  const d = new OrgGet([]);
+  return d.fetch(params);
+};
+
+export default class OrgGet extends Command {
+  static description = "view a org";
+
+  static examples = ["<%= config.bin %> <%= command.id %> <name of the ngo>"];
+
+  static args = this.multiid();
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: false }),
+    name: Flags.string({
+      char: "n",
+      charAliases: ["o"],
+      description: "name of the org",
+      helpValue: "<org name>",
+    }),
+    config: Flags.boolean({
+      description: "display the config",
+      default: false,
+      allowNo: true,
+    }),
+    personaldata: Flags.boolean({
+      description: "how are the personal data of the supporter processed",
+      default: true,
+      allowNo: true,
+    }),
+    processing: Flags.boolean({
+      description: "additional processing workflows on the actions",
+      default: true,
+      allowNo: true,
+    }),
+    keys: Flags.boolean({
+      default: true,
+      allowNo: true,
+    }),
+    campaigns: Flags.boolean({
+      default: false,
+      allowNo: true,
+    }),
+    users: Flags.boolean({
+      default: true,
+      allowNo: true,
+    }),
+  };
+
+  fetch = async (params) => {
+    const GetOrgDocument = gql`
+      query GetOrg($name: String!, $withCampaigns: Boolean = true, $withKeys: Boolean = true, $withPersonalData: Boolean = false, $withProcessing: Boolean= false ) {
+        org (name: $name) {
+          id name title
+          config
+          keys @include(if: $withKeys) {id, name, expired, expiredAt, public}
+ 
+          campaigns @include(if: $withCampaigns) {id, name, title, org {name}}
+   personalData @include(if: $withPersonalData) {
+      contactSchema
+      doiThankYou
+      highSecurity
+      replyEnabled
+      supporterConfirm
+      supporterConfirmTemplate
+    }
+    processing @include(if: $withProcessing) {
+      customActionConfirm
+      customActionDeliver
+      customEventDeliver
+      customSupporterConfirm
+      detailBackend
+      doiThankYou
+      emailBackend
+      emailFrom
+      emailTemplates
+      eventBackend
+      pushBackend
+      storageBackend
+      supporterConfirm
+      supporterConfirmTemplate
+    }
+
+    services {
+      host
+      id
+      name
+      path
+      user
+    }
+        }
+      }
+    `;
+
+    const result = await query(GetOrgDocument, {
+      name: params.name,
+      withCampaigns: params.campaigns,
+      withKeys: params.keys || true,
+      withPersonalData: params.personaldata,
+      $withProcessing: params.processing,
+    });
+    result.org.config = JSON.parse(result.org.config);
+    return result.org;
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.id,
+      Name: d.name,
+      Title: d.title,
+      "can targets reply?": d.replyEnabled ? true : undefined,
+      "confirm actions?": d.supporterConfirm
+        ? d.supporterConfirmTemplate
+        : undefined,
+    };
+    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, null);
+    if (this.flags.config) {
+      r.config.locales = undefined;
+      this.prettyJson(r.config);
+    }
+  };
+
+  async run() {
+    console.log("starting");
+    const { flags } = await this.parse();
+    console.log("flags", this.Flags);
+
+    const data = await this.fetch(flags);
+    return this.output(data);
+  }
+}