@proca/cli 3.3.1 → 3.8.3

package/src/commands/service/add.mjs

@@ -0,0 +1,78 @@
+import { Flags } from "@oclif/core";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation, query } from "#src/urql.mjs";
+
+const SERVICE_NAMES = [
+  "MAILJET",
+  "SES",
+  "STRIPE",
+  "TEST_STRIPE",
+  "PREVIEW",
+  //	"SYSTEM", not an external service type, just an alias
+  "WEBHOOK",
+  "SUPABASE",
+  "SMTP",
+].map((d) => d.toLowerCase());
+
+export default class OrgEmail extends Command {
+  static description =
+    "Set service, usually email backend for an org, the specific meaning of each param is dependant on the service";
+
+  static flags = {
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "organisation running the service",
+      required: true,
+    }),
+    type: Flags.string({
+      description: "type of the service",
+      options: SERVICE_NAMES,
+      required: true,
+      default: "system",
+    }),
+    user: Flags.string({
+      description: "credential of the account on the service",
+    }),
+    password: Flags.string({
+      description: "credential of the account on the service",
+    }),
+    host: Flags.string({
+      description: "server of the service",
+    }),
+    path: Flags.string({
+      description: "path on the service",
+    }),
+  };
+
+  async mutate(flags) {
+    const Document = gql`
+ mutation ($id: Int, $input: ServiceInput!, $orgName: String!) {
+  upsertService(id: $id, input: $input, orgName: $orgName) {    host    id    name    path    user  }
+}
+  `;
+
+    const variables = {
+      //      id: flags.id || null
+      orgName: flags.org,
+      input: {
+        name: flags.type.toUpperCase(),
+        host: flags.host || "",
+        path: flags.path || "",
+        user: flags.user || "",
+        password: flags.password || "",
+      },
+    };
+
+    const result = await mutation(Document, variables);
+    return result.upsertService;
+  }
+
+  table = (r) => super.table(r, null, null);
+
+  async run() {
+    const { flags } = await this.parse();
+    const result = await this.mutate(flags);
+    this.output(result);
+  }
+}

package/src/commands/service/list.mjs

@@ -0,0 +1,24 @@
+import { Flags } from "@oclif/core";
+import Org from "#src/commands/org/get.mjs";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation, query } from "#src/urql.mjs";
+
+export default class OrgServices extends Command {
+  static description = "list services set for an organisation";
+
+  static flags = {
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "organisation running the service",
+      required: true,
+    }),
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const orgCmd = new Org({}, this.config);
+    const org = await orgCmd.fetch({ name: flags.org });
+    this.output(org.services);
+  }
+}

package/src/commands/target/add.mjs

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation, query } from "#src/urql.mjs";
+
+export default class TargetAdd extends Command {
+  static flags = {
+    // flag with no value (-f, --force)
+    ...this.flagify({ multiid: false }),
+    campaign: Flags.string({
+      char: "c",
+      description: "mtt campaign to add the target",
+      required: true,
+    }),
+    name: Flags.string({
+      description: "name of the target",
+      required: true,
+    }),
+    email: Flags.string({
+      description: "email of the target",
+      required: true,
+    }),
+    external_id: Flags.string({
+      description: "external id of the target",
+    }),
+  };
+
+  getCampaignId = async (name) => {
+    const Document = gql`
+query getCampaignId($campaign: String!) {
+  campaign (name:$campaign) { id 
+  }
+}`;
+
+    const result = await query(Document, {
+      campaign: name,
+    });
+    return result.campaign.id;
+  };
+
+  create = async (flags) => {
+    const id = await this.getCampaignId(flags.campaign);
+
+    const Document = gql`
+      mutation (
+        $campaignId: Int!
+        $outdatedTargets: OutdatedTargets
+        $targets: [TargetInput!]!
+      ) {
+        upsertTargets(
+          campaignId: $campaignId
+          outdatedTargets: $outdatedTargets
+          targets: $targets
+        ) {
+          area
+          emails {
+            email
+            emailStatus
+            error
+          }
+          externalId
+          fields
+          id
+          locale
+          name
+        }
+      }
+    `;
+    const result = await mutation(Document, {
+      campaignId: id,
+      outdatedTargets: "KEEP",
+      targets: [
+        {
+          name: flags.name,
+          externalId: flags.external_id,
+          emails: [{ email: flags.email }],
+        },
+      ],
+    });
+    return result.upsertTargets;
+  };
+
+  async run() {
+    //const { args, flags } = await this.parse(CampaignAdd);
+    const { args, flags } = await this.parse();
+    if (!flags.external_id) {
+      flags.external_id = `${flags.campaign}_${flags.email}`;
+    }
+
+    const data = await this.create(flags);
+    return this.output(data);
+  }
+}

package/src/commands/template/add.mjs

@@ -0,0 +1,97 @@
+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 TemplateAdd extends Command {
+  //static args = { path: { description: "" } };
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "organisation",
+      required: true,
+    }),
+    type: Flags.string({
+      options: ["thankyou", "doi", "confirm", "doi_thankyou", "doi_confirm"],
+      default: "thankyou",
+    }),
+    lang: Flags.string({
+      char: "l",
+      description: "language",
+      default: "en",
+      helpValue: "<locale>",
+    }),
+    name: Flags.string({
+      char: "n",
+      description: "name",
+      helpValue: "by default  type@language",
+    }),
+    subject: Flags.string({
+      char: "s",
+      description: "subject",
+      helpValue: "'template:' + type",
+    }),
+  };
+
+  create = async (flag) => {
+    const orgName = flag.org;
+
+    const addTemplateDocument = gql`
+      mutation (
+        $org: String!
+        $name: String!
+        $lang: String!
+        $subject: String!
+        $text: String
+        $html: String
+      ) {
+        upsertTemplate(
+          orgName: $org
+          input: { name: $name, locale: $lang, subject:$subject,text: $text, html: $html }
+        ) 
+      }
+    `;
+
+    if (!flag.name) {
+      flag.name = flag.type; // +'@'+flag.lang;
+    }
+
+    if (!flag.subject) {
+      flag.subject = `template ${flag.type} in ${flag.lang}`;
+    }
+
+    if (!flag.text) {
+      flag.text = "This is the email body";
+    }
+    if (!flag.html) {
+      flag.html = "This is the email html body";
+    }
+    try {
+      const r = await mutation(addTemplateDocument, flag);
+    } catch (e) {
+      const errors = e.graphQLErrors;
+      console.log(JSON.stringify(e.graphQLErrors, null, 2));
+      if (errors[0].path[1] === "name") {
+        this.error(`invalid name (already taken?): ${flag.name}`);
+        throw new Error(errors[0].message);
+      }
+      if (errors[0].extensions?.code === "permission_denied") {
+        console.error("permission denied to create", flag.name, flag.org);
+        throw new Error(errors[0].message);
+      }
+      throw new Error(errors[0].message);
+    }
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+
+    //		const org = { name: flags.twitter || flags.name, config: {} };
+
+    const data = await this.create(flags);
+    return this.output(data);
+  }
+}

package/src/commands/template/list.mjs

@@ -0,0 +1,61 @@
+import { Flags } from "@oclif/core";
+import Org from "#src/commands/org/get.mjs";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation, query } from "#src/urql.mjs";
+
+export default class OrgTemplate extends Command {
+  static description = "list services set for an organisation";
+
+  static flags = {
+    ...super.globalFlags,
+    org: Flags.string({
+      char: "o",
+      description: "organisation having the templates",
+      required: true,
+    }),
+  };
+
+  fetch = async (org) => {
+    const GetOrgDocument = gql`
+      query GetOrg($name: String!) {
+        org (name: $name) {
+          id name title
+   personalData {
+      supporterConfirm
+      supporterConfirmTemplate
+    }
+    processing {
+      emailFrom
+      emailTemplates
+      supporterConfirm
+      supporterConfirmTemplate
+    }
+
+        }
+      }
+    `;
+
+    const result = await query(GetOrgDocument, {
+      name: org,
+    });
+    const supporterConfirm = (tplName) => {
+      if (
+        tplName.split("@")[0] === result.org.processing.supporterConfirmTemplate
+      ) {
+        return result.org.processing.supporterConfirm ? "enabled" : "disabled";
+      }
+      return "";
+    };
+    const tpl = result.org.processing?.emailTemplates?.map((d) => ({
+      name: d,
+      actionConfirm: supporterConfirm(d),
+    }));
+    return tpl;
+  };
+
+  async run() {
+    const { flags } = await this.parse();
+    const tpl = await this.fetch(flags.org);
+    this.output(tpl);
+  }
+}

package/src/commands/user/get.mjs

@@ -0,0 +1,91 @@
+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 a user";
+
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+
+  static flags = {
+    ...super.globalFlags,
+    email: Flags.string({ description: "user email" }),
+    org: Flags.string({
+      char: "o",
+      description: "name of the org",
+      exactlyOne: ["email", "id", "org"],
+      helpValue: "<org name>",
+    }),
+    id: Flags.string({
+      char: "i",
+      parse: (input) => {
+        return Number.parseInt(input, 10);
+      },
+      description: "id of the user",
+    }),
+  };
+
+  fetch = async (params) => {
+    const Document = gql`
+query ($email: String, $org: String, $id: Int) {
+  users (select: {email: $email, orgName: $org, id: $id}) {
+    apiToken {
+      expiresAt
+    }
+    email
+    id
+    isAdmin
+    jobTitle
+    phone
+    pictureUrl
+    roles {
+      role org {name}
+    }
+  }
+}
+    `;
+    const result = await query(Document, {
+      org: params.org,
+      id: params.id,
+      email: params.email,
+    });
+    return result.users[0];
+  };
+
+  simplify = (d) => {
+    const result = {
+      id: d.id,
+      email: d.email,
+    };
+    if (d.apiToken) {
+      result.tokenExpire = d.apiToken.expire;
+    }
+    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(flags);
+    return this.output(data);
+  }
+}

package/src/commands/user/invite.mjs

@@ -0,0 +1,56 @@
+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 UserInviteOrg extends Command {
+  static description = "invite a user to join an organisation with a role";
+
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+
+  static flags = {
+    ...super.globalFlags,
+    role: Flags.string({
+      description: "permission level in that org",
+      default: "campaigner",
+      options: ["owner", "campaigner", "coordinator", "translator"],
+    }),
+    org: Flags.string({
+      char: "o",
+      required: true,
+      description: "name of the org",
+      helpValue: "<org name>",
+    }),
+    user: Flags.string({
+      char: "u",
+      required: true,
+      description: "email",
+      helpValue: "<user email>",
+    }),
+  };
+
+  invite = async (params) => {
+    const Document = gql`
+mutation ($user: String!, $role: String!, $org: String!, $message: String) {
+  inviteOrgUser(orgName: $org,  message: $message, input: { email: $user, role: $role}) {
+      objectId
+      code
+  }
+}
+    `;
+    const result = await mutation(Document, params);
+    //return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+    console.log(result);
+    return result.inviteOrgUser;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    const data = await this.invite(flags);
+    this.output(data);
+  }
+}

package/src/commands/user/join.mjs

@@ -0,0 +1,81 @@
+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 UserJoinOrg extends Command {
+  static description = "let a user join an organisation with a role";
+
+  static examples = ["<%= config.bin %> <%= command.id %>"];
+
+  static flags = {
+    ...super.globalFlags,
+    role: Flags.string({
+      description: "permission level in that org",
+      default: "campaigner",
+      options: ["owner", "campaigner", "coordinator", "translator"],
+    }),
+    org: Flags.string({
+      char: "o",
+      required: true,
+      description: "name of the org",
+      helpValue: "<org name>",
+    }),
+    user: Flags.string({
+      char: "u",
+      description: "email",
+      helpValue: "<user email>",
+    }),
+  };
+
+  join = async (org) => {
+    const Document = gql`
+mutation ($name: String!) {
+  joinOrg(name: $name) {
+    org {
+      config
+      name
+      title
+    }
+    status
+  }
+}
+    `;
+    const result = await mutation(Document, {
+      name: org,
+    });
+    //return result.users.map (d => {d.config = JSON.parse(d.config); return d});
+    return { ...result.joinOrg.org, status: result.joinOrg.status };
+  };
+
+  mutate = async (params) => {
+    const Document = gql`
+mutation ($org: String!, $user: String!, $role: String = "campaigner") {
+  addOrgUser (orgName: $org, input : { email: $user, role: $role }) {
+    status
+  }
+}
+    `;
+    const result = await mutation(Document, {
+      user: params.user,
+      org: params.org,
+      role: params.role,
+    });
+    return result.addOrgUser;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    let data = undefined;
+    if (!flags.user) {
+      data = await this.join(flags.org);
+    } else {
+      data = await this.mutate(flags);
+    }
+    this.output(data);
+  }
+}

package/src/commands/user/leave.mjs

@@ -0,0 +1,57 @@
+import { Args, Flags } from "@oclif/core";
+import { error, stdout, ux } from "@oclif/core/ux";
+import { getCurrentUser } from "#src/commands/config/user.mjs";
+import Command from "#src/procaCommand.mjs";
+import { gql, mutation } from "#src/urql.mjs";
+
+export default class OrgLeave extends Command {
+  actionTypes = new Set();
+
+  static args = {};
+
+  static description = "leave a org";
+
+  static examples = ["<%= config.bin %> <%= command.id %> -i 42"];
+
+  static flags = {
+    // flag with no value (-f, --force)
+    ...super.globalFlags,
+    user: Flags.string({
+      char: "u",
+      description: "email",
+      helpValue: "<user email>",
+    }),
+    org: Flags.string({
+      char: "o",
+      description: "name of the org",
+      required: true,
+      helpValue: "<org name>",
+    }),
+  };
+
+  mutate = async ({ user, org }) => {
+    const Document = gql`
+mutation ($email: String!, $org: String!) {
+  deleteOrgUser(email: $email, orgName: $org) { status }
+}`;
+    const result = await mutation(Document, {
+      email: user,
+      org: org,
+    });
+    return result.deleteOrgUser;
+  };
+
+  table = (r) => {
+    super.table(r, null, null);
+  };
+
+  async run() {
+    const { args, flags } = await this.parse();
+    if (!flags.user) {
+      const me = await getCurrentUser();
+      flags.user = me.email;
+    }
+    const data = await this.mutate(flags);
+    this.output(data);
+  }
+}