@zeegme/cli 0.4.1 → 0.6.0

package/README.md

@@ -47,6 +47,8 @@ Plain `http` is accepted for `localhost` only. Each origin keeps its own login.
 | Command | What it does |
 |---|---|
 | `zeeg event-types list` / `get <uuid>` | Your event types (scheduling pages) |
+| `zeeg event-types create --type --title [--language --data]` | Create an event type |
+| `zeeg event-types update <uuid> [--title --language --data]` | Change an event type, its language included (`de-du` is German addressing the invitee as du) |
 | `zeeg availability <eventTypeUuid> [--from --to --tz]` | Open start times, by day |
 | `zeeg schedules list [--email]` | Availability schedules |
 | `zeeg time-off add --start --end --title [--type]` | Block days as time off |

package/dist/commands/bookings.js

@@ -1,6 +1,7 @@
+import { Option } from 'commander';
 import { unwrap } from '../api/client.js';
 import { UsageError } from '../errors.js';
-import { asJson, clockTime, collect, isoDate, localTimeZone, positiveInt } from './util.js';
+import { asJson, clockTime, collect, isoDate, localTimeZone, overrideLevelOption, positiveInt } from './util.js';
 const inviteeNames = (row) => (row.invitees ?? []).map((invitee) => invitee.fullName ?? invitee.email);
 export function registerBookings(program, context) {
     const bookings = program.command('bookings').description('Scheduled events (bookings)');
@@ -67,6 +68,8 @@ export function registerBookings(program, context) {
         .option('--guest <email>', 'add a guest, repeatable', collect)
         .option('--location <type>', 'location type, when the event type offers several')
         .option('--location-key <key>', 'exact location key from the event type')
+        .option('--host <email>', 'book with this host (Round Robin event types only)')
+        .addOption(overrideLevelOption())
         .option('-y, --yes', 'book without asking')
         .action(async (uuid, options) => {
         const ctx = context();
@@ -85,6 +88,8 @@ export function registerBookings(program, context) {
                 guests: options.guest,
                 location: options.location,
                 locationKey: options.locationKey,
+                hostEmail: options.host,
+                overrideLevel: options.overrideLevel,
             },
         })));
         ctx.print.record(data, `Booked: ${data.title ?? 'meeting'} at ${data.startTime ?? `${options.date} ${options.time}`} (${data.uuid}).`);
@@ -111,13 +116,14 @@ export function registerBookings(program, context) {
         .option('--tz <zone>', 'IANA time zone of --date and --time (default: the invitee’s)')
         .option('--duration <minutes>', 'new length', positiveInt('--duration'))
         .option('--reason <text>', 'shown to the invitees')
+        .addOption(overrideLevelOption())
         .option('-y, --yes', 'reschedule without asking')
         .action(async (uuid, options) => {
         const ctx = context();
         await ctx.confirm(`Move booking ${uuid} to ${options.date} ${options.time}? The invitees are notified.`, options.yes);
         const data = asJson(await unwrap((await ctx.api()).PUT('/scheduled-events/{uuid}/reschedule', {
             params: { path: { uuid } },
-            body: { date: options.date, start: options.time, timeZone: options.tz, duration: options.duration, reason: options.reason },
+            body: { date: options.date, start: options.time, timeZone: options.tz, duration: options.duration, reason: options.reason, overrideLevel: options.overrideLevel },
         })));
         ctx.print.record(data.resource, `Rescheduled ${uuid} to ${options.date} ${options.time}.`);
     });
@@ -142,8 +148,9 @@ export function registerBookings(program, context) {
         .command('hand-over <uuid>')
         .description('Hand a round-robin booking to another host')
         .option('--to <email>', 'the new host (default: Zeeg picks the next available host)')
-        .option('--require-availability', 'only hand over to a host who is free then')
-        .option('--fallback-to-reschedule', 'offer the invitee a reschedule when nobody is free')
+        .addOption(new Option('--require-availability', 'accepted and ignored').hideHelp())
+        .option('--fallback-to-reschedule', 'when the booking cannot move in place, reschedule it to the new host at the same time; the booking gets a new uuid')
+        .addOption(overrideLevelOption())
         .option('-y, --yes', 'hand over without asking')
         .action(async (uuid, options) => {
         const ctx = context();
@@ -152,8 +159,8 @@ export function registerBookings(program, context) {
             params: { path: { uuid } },
             body: {
                 newHostEmail: options.to,
-                requireHostAvailability: options.requireAvailability,
                 fallbackToReschedule: options.fallbackToReschedule,
+                overrideLevel: options.overrideLevel,
             },
         }));
         ctx.print.record(asJson(data).resource, `Handed over ${uuid}.`);

package/dist/commands/eventTypes.js

@@ -1,6 +1,15 @@
 import { unwrap } from '../api/client.js';
+import { UsageError } from '../errors.js';
 import { renderTable } from '../output.js';
-import { addDays, asJson, isoDate, localTimeZone, positiveInt } from './util.js';
+import { addDays, asJson, isoDate, jsonArgument, localTimeZone, positiveInt } from './util.js';
+/** The API answers 422 to any other code, so the CLI passes the value through unchecked. */
+const LANGUAGE_HELP = 'language of the booking page and of invitee emails: en, de (German, formal), de-du (German, informal), nl, fi, es, fr, pl, da, sv or it';
+const DATA_HELP = 'any other field of the API body, as a JSON object inline or as @file.json; the other flags win over it';
+/** The `--data` object with the flags laid over it, leaving out the flags not given. */
+async function writeBody(options, flags) {
+    const given = Object.fromEntries(Object.entries({ title: options.title, language: options.language, ...flags }).filter(([, value]) => value !== undefined));
+    return { ...(options.data === undefined ? {} : await jsonArgument(options.data)), ...given };
+}
 export function registerEventTypes(program, context) {
     const eventTypes = program.command('event-types').description('Scheduling pages (event types)');
     eventTypes
@@ -31,6 +40,34 @@ export function registerEventTypes(program, context) {
         const data = asJson(await unwrap((await ctx.api()).GET('/event-types/{uuid}', { params: { path: { uuid } } })));
         ctx.print.record(data.resource);
     });
+    eventTypes
+        .command('create')
+        .description('Create an event type; it is bookable through its link at once')
+        .option('--type <type>', 'ONE_ON_ONE, GROUP, ROUND_ROBIN or COLLECTIVE')
+        .option('--title <title>', 'the name invitees see')
+        .option('--language <code>', `${LANGUAGE_HELP} (default: your own)`)
+        .option('--data <json>', DATA_HELP)
+        .action(async (options) => {
+        const ctx = context();
+        const body = await writeBody(options, { type: options.type });
+        const data = asJson(await unwrap((await ctx.api()).POST('/event-types', { body: body })));
+        ctx.print.record(data.resource);
+    });
+    eventTypes
+        .command('update <uuid>')
+        .description('Change an event type; a field left out keeps its value')
+        .option('--title <title>', 'the name invitees see')
+        .option('--language <code>', LANGUAGE_HELP)
+        .option('--data <json>', DATA_HELP)
+        .action(async (uuid, options) => {
+        const ctx = context();
+        const body = await writeBody(options, {});
+        if (Object.keys(body).length === 0) {
+            throw new UsageError('Pass what to change: --title, --language or --data.');
+        }
+        const data = asJson(await unwrap((await ctx.api()).PATCH('/event-types/{uuid}', { params: { path: { uuid } }, body: body })));
+        ctx.print.record(data.resource);
+    });
     program
         .command('availability <eventTypeUuid>')
         .description('Available start times for an event type (needs a paid plan)')

package/dist/commands/util.js

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { Option } from 'commander';
 import { UsageError } from '../errors.js';
 export function asJson(value) {
     return value !== null && typeof value === 'object' ? value : {};
@@ -12,6 +13,18 @@ export function positiveInt(name) {
         return value;
     };
 }
+export function overrideLevel(name) {
+    return (raw) => {
+        if (!/^[1-4]$/.test(raw)) {
+            throw new UsageError(`${name} must be 1, 2, 3 or 4, not "${raw}".`);
+        }
+        return Number(raw);
+    };
+}
+/** `--override-level`, shared by every command that can book outside availability. */
+export function overrideLevelOption() {
+    return new Option('--override-level <level>', 'book outside availability: 2 also outside working hours, 3 also over calendar entries, 4 also over other bookings (double-books the host)').argParser(overrideLevel('--override-level'));
+}
 export function isoDate(name) {
     return (raw) => {
         if (!/^\d{4}-\d{2}-\d{2}$/.test(raw) || Number.isNaN(Date.parse(raw))) {

package/dist/errors.js

@@ -45,7 +45,8 @@ export function exitCodeFor(error) {
 /**
  * The API answers errors in two shapes: controllers and validation send `{ message, errors? }`,
  * with validation messages listed per field, and the shared exception handler sends
- * `{ error: { type, message } }` for not found, forbidden and similar. A 401 means the token was
+ * `{ error: { type, message } }` for not found, forbidden and similar. A refused override carries
+ * `data.blockedReason`, the kind of entry that blocks the time (such as `calendar`). A 401 means the token was
  * revoked or expired server-side, so it asks for a new login.
  */
 export function apiErrorFrom(status, body) {
@@ -60,7 +61,9 @@ export function apiErrorFrom(status, body) {
         ? Object.values(record.errors).flat().filter((item) => typeof item === 'string')
         : [];
     const unique = details.filter((detail) => detail !== message);
-    return new ApiError(unique.length > 0 ? `${message}\n- ${unique.join('\n- ')}` : message);
+    const data = typeof record.data === 'object' && record.data !== null ? record.data : {};
+    const blocked = typeof data.blockedReason === 'string' && data.blockedReason !== '' ? `\nBlocked by: ${data.blockedReason}` : '';
+    return new ApiError((unique.length > 0 ? `${message}\n- ${unique.join('\n- ')}` : message) + blocked);
 }
 /** `fetch`, with a network failure reported as an ApiError that names the origin. */
 export async function fetchFrom(fetchImpl, baseUrl, input, init) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeegme/cli",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "The Zeeg command line: bookings, availability, notes, CRM, routing forms and AI phone calls from your terminal.",
   "license": "MIT",
   "type": "module",