zupost 0.2.0 → 0.6.0

package/dist/index.js

@@ -73,12 +73,13 @@ var __async = (__this, __arguments, generator) => {
 var index_exports = {};
 __export(index_exports, {
   Zupost: () => Zupost,
-  ZupostError: () => ZupostError
+  ZupostError: () => ZupostError,
+  defineSequence: () => defineSequence
 });
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "0.2.0";
+var version = "0.6.0";
 
 // src/errors.ts
 var ZupostError = class _ZupostError extends Error {
@@ -139,7 +140,7 @@ var HttpClient = class {
     __privateAdd(this, _baseUrl);
     __privateSet(this, _baseUrl, baseUrl.replace(/\/$/, ""));
     __privateSet(this, _defaultHeaders, {
-      Authorization: `Bearer ${apiKey}`,
+      "Authorization": `Bearer ${apiKey}`,
       "Content-Type": "application/json",
       "User-Agent": userAgent
     });
@@ -187,6 +188,16 @@ var HttpClient = class {
       return this.request(path, "POST", body);
     });
   }
+  patch(path, body) {
+    return __async(this, null, function* () {
+      return this.request(path, "PATCH", body);
+    });
+  }
+  delete(path, body) {
+    return __async(this, null, function* () {
+      return this.request(path, "DELETE", body);
+    });
+  }
 };
 _defaultHeaders = new WeakMap();
 _baseUrl = new WeakMap();
@@ -302,6 +313,324 @@ var Campaigns = class {
   }
 };
 
+// src/contact/contacts.ts
+function buildQuery(params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) search.append(key, String(v));
+    } else {
+      search.set(key, String(value));
+    }
+  }
+  const query = search.toString();
+  return query ? `?${query}` : "";
+}
+var Contacts = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create or upsert a contact by email. Idempotent on (project, email).
+   *
+   * @example
+   * ```typescript
+   * const contact = await zupost.contacts.create({
+   *   email: 'user@example.com',
+   *   name: 'Jane Doe',
+   *   marketingConsent: true,
+   *   marketingConsentSource: 'signup-form',
+   *   tags: ['vip', 'beta'],
+   * });
+   * ```
+   */
+  create(options) {
+    return __async(this, null, function* () {
+      return this.http.post("/contact", options);
+    });
+  }
+  /**
+   * Get a contact by ID.
+   */
+  get(id) {
+    return __async(this, null, function* () {
+      return this.http.get(`/contact/${encodeURIComponent(id)}`);
+    });
+  }
+  /**
+   * List contacts with optional search, consent and tag filters.
+   */
+  list() {
+    return __async(this, arguments, function* (options = {}) {
+      const query = buildQuery({
+        skip: options.skip,
+        take: options.take,
+        search: options.search,
+        marketingConsent: options.marketingConsent === void 0 ? void 0 : String(options.marketingConsent),
+        tag: options.tag
+      });
+      return this.http.get(`/contact${query}`);
+    });
+  }
+  /**
+   * Update a contact. Pass only the fields that should change.
+   *
+   * Toggling `marketingConsent` or `trackingConsent` automatically records
+   * a corresponding ContactEvent for the audit trail.
+   */
+  update(id, patch) {
+    return __async(this, null, function* () {
+      return this.http.patch(`/contact/${encodeURIComponent(id)}`, patch);
+    });
+  }
+  /**
+   * GDPR right-to-be-forgotten. Anonymises the contact, sets `forgottenAt`
+   * and disables consent. Existing email events are anonymised in a
+   * follow-up cascade.
+   */
+  forget(id) {
+    return __async(this, null, function* () {
+      return this.http.delete(`/contact/${encodeURIComponent(id)}`);
+    });
+  }
+  /**
+   * Get the chronological event timeline for a contact.
+   */
+  events(_0) {
+    return __async(this, arguments, function* (id, options = {}) {
+      const query = buildQuery({
+        skip: options.skip,
+        take: options.take,
+        type: options.type
+      });
+      return this.http.get(`/contact/${encodeURIComponent(id)}/events${query}`);
+    });
+  }
+  /**
+   * GDPR data access export. Returns the complete record for a contact
+   * including all emails, events, subscriptions and tags.
+   */
+  export(id) {
+    return __async(this, null, function* () {
+      return this.http.get(`/contact/${encodeURIComponent(id)}/export`);
+    });
+  }
+  /**
+   * Add a tag to a contact (idempotent).
+   */
+  addTag(id, name) {
+    return __async(this, null, function* () {
+      return this.http.post(`/contact/${encodeURIComponent(id)}/tags`, { name });
+    });
+  }
+  /**
+   * Remove a tag from a contact.
+   */
+  removeTag(id, name) {
+    return __async(this, null, function* () {
+      return this.http.delete(
+        `/contact/${encodeURIComponent(id)}/tags/${encodeURIComponent(name)}`
+      );
+    });
+  }
+};
+
+// src/sequence/sequences.ts
+function buildQuery2(params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    search.set(key, String(value));
+  }
+  const q = search.toString();
+  return q ? `?${q}` : "";
+}
+var Sequences = class {
+  constructor(http) {
+    this.http = http;
+    this.runs = {
+      list: (_0, ..._1) => __async(this, [_0, ..._1], function* (sequenceId, options = {}) {
+        const query = buildQuery2({
+          skip: options.skip,
+          take: options.take,
+          status: options.status,
+          contactId: options.contactId
+        });
+        return this.http.get(
+          `/sequence/${encodeURIComponent(sequenceId)}/runs${query}`
+        );
+      })
+    };
+  }
+  /**
+   * Create a new sequence (always starts in DRAFT). Pass `definition` to
+   * seed the first version, or omit it to create an empty placeholder you
+   * can later push versions into.
+   */
+  create(options) {
+    return __async(this, null, function* () {
+      return this.http.post("/sequence", options);
+    });
+  }
+  /**
+   * Get a sequence by ID.
+   */
+  get(id) {
+    return __async(this, null, function* () {
+      return this.http.get(`/sequence/${encodeURIComponent(id)}`);
+    });
+  }
+  /**
+   * List sequences with filters.
+   */
+  list() {
+    return __async(this, arguments, function* (options = {}) {
+      const query = buildQuery2({
+        skip: options.skip,
+        take: options.take,
+        type: options.type,
+        status: options.status,
+        search: options.search
+      });
+      return this.http.get(`/sequence${query}`);
+    });
+  }
+  /**
+   * Delete a sequence and all its versions and runs.
+   */
+  delete(id) {
+    return __async(this, null, function* () {
+      return this.http.delete(`/sequence/${encodeURIComponent(id)}`);
+    });
+  }
+  /**
+   * Change the lifecycle status: DRAFT, ACTIVE, PAUSED, ARCHIVED.
+   */
+  setStatus(id, status) {
+    return __async(this, null, function* () {
+      return this.http.post(`/sequence/${encodeURIComponent(id)}/status`, { status });
+    });
+  }
+  /**
+   * Save a new immutable version of the sequence definition. If `activate`
+   * is true (default), the new version becomes the active one for future
+   * triggered runs. Existing in-flight runs keep their pinned version.
+   */
+  saveVersion(id, options) {
+    return __async(this, null, function* () {
+      return this.http.post(`/sequence/${encodeURIComponent(id)}/versions`, options);
+    });
+  }
+  /**
+   * Trigger a sequence run for a contact or ad-hoc email. The sequence
+   * must be ACTIVE.
+   */
+  trigger(id, options) {
+    return __async(this, null, function* () {
+      if (!options.contactId && !options.email) {
+        throw new Error("trigger requires contactId or email");
+      }
+      return this.http.post(`/sequence/${encodeURIComponent(id)}/runs`, options);
+    });
+  }
+};
+
+// src/domain/domains.ts
+var DEFAULT_REGION = "eu-central-1";
+var Domains = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Register a new sending domain. The response contains the `dnsRecords` you
+   * need to add at your DNS provider before calling {@link verify}.
+   *
+   * @example
+   * ```typescript
+   * const domain = await zupost.domains.create({ name: 'example.com' });
+   * for (const record of domain.dnsRecords) {
+   *   console.log(record.type, record.name, record.value);
+   * }
+   * ```
+   */
+  create(options) {
+    return __async(this, null, function* () {
+      var _a;
+      return this.http.post("/domain", {
+        name: options.name,
+        region: (_a = options.region) != null ? _a : DEFAULT_REGION
+      });
+    });
+  }
+  /**
+   * Get a domain by ID, including its current verification status and DNS
+   * records.
+   */
+  get(id) {
+    return __async(this, null, function* () {
+      return this.http.get(`/domain/${encodeURIComponent(id)}`);
+    });
+  }
+  /**
+   * List all domains in the project.
+   */
+  list() {
+    return __async(this, null, function* () {
+      return this.http.get("/domain");
+    });
+  }
+  /**
+   * Start the verification process for a domain. Add the DNS records returned
+   * by {@link create} or {@link get} first; Zupost then checks them and
+   * updates the domain's `status`.
+   */
+  verify(id) {
+    return __async(this, null, function* () {
+      return this.http.post(
+        `/domain/${encodeURIComponent(id)}/verify`,
+        void 0
+      );
+    });
+  }
+  /**
+   * Schedule a domain for deletion.
+   */
+  delete(id) {
+    return __async(this, null, function* () {
+      return this.http.delete(`/domain/${encodeURIComponent(id)}`);
+    });
+  }
+};
+
+// src/inbound/inbound.ts
+var Inbound = class {
+  constructor(http) {
+    this.http = http;
+    /**
+     * Inbound channels route mail received on a domain to a webhook.
+     */
+    this.channels = {
+      /**
+       * Create an inbound channel for a verified domain.
+       *
+       * @example
+       * ```typescript
+       * const channel = await zupost.inbound.channels.create({
+       *   name: 'Support inbox',
+       *   domainId: 'dom_123',
+       *   webhookUrl: 'https://example.com/zupost/inbound',
+       *   webhookSecret: process.env.ZUPOST_INBOUND_SECRET!,
+       * });
+       * ```
+       */
+      create: (options) => __async(this, null, function* () {
+        return this.http.post("/inbound-channel", options);
+      })
+    };
+  }
+};
+
 // src/zupost.ts
 var _client;
 var Zupost = class {
@@ -315,11 +644,55 @@ var Zupost = class {
     __privateSet(this, _client, new HttpClient(apiKey, baseUrl, `node-sdk@${version}`));
     this.emails = new Emails(__privateGet(this, _client));
     this.campaigns = new Campaigns(__privateGet(this, _client));
+    this.contacts = new Contacts(__privateGet(this, _client));
+    this.sequences = new Sequences(__privateGet(this, _client));
+    this.domains = new Domains(__privateGet(this, _client));
+    this.inbound = new Inbound(__privateGet(this, _client));
   }
 };
 _client = new WeakMap();
+
+// src/sequence/define.ts
+function defineSequence(definition) {
+  const issues = [];
+  const stepKeys = Object.keys(definition.steps);
+  if (!definition.steps[definition.entry]) {
+    issues.push(`entry "${String(definition.entry)}" is not a defined step`);
+  }
+  if (stepKeys.length === 0) issues.push("steps must contain at least one step");
+  for (const key of stepKeys) {
+    const step = definition.steps[key];
+    if (step.key !== key) issues.push(`step.key "${step.key}" does not match object key "${key}"`);
+    const checkRef = (ref, where) => {
+      if (ref && !definition.steps[ref]) {
+        issues.push(`step "${key}" ${where} points at unknown step "${ref}"`);
+      }
+    };
+    switch (step.type) {
+      case "send_email":
+      case "wait":
+      case "tag_add":
+      case "tag_remove":
+      case "update_contact":
+      case "webhook":
+        checkRef(step.next, "next");
+        break;
+      case "branch":
+        checkRef(step.thenNext, "thenNext");
+        checkRef(step.elseNext, "elseNext");
+        break;
+      case "end":
+        break;
+    }
+  }
+  if (issues.length > 0) {
+    throw new Error(`Invalid sequence definition: ${issues.join("; ")}`);
+  }
+  return definition;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Zupost,
-  ZupostError
+  ZupostError,
+  defineSequence
 });