@cowliss/cli 0.6.0 → 0.8.0

package/README.md

@@ -44,7 +44,7 @@ import { defineJourney } from "@cowliss/cli/journeys";
 
 export default defineJourney({
   trigger: { event: "checkout_started" },
-  purpose: "emailMarketing",
+  purpose: "marketing",
   run: async (event, api) => {
     const purchased = await api.waitForEvent("purchase_completed", {
       timeout: "24h",

package/dist/guest/{driver-DBt5l1Z5.js → driver-BXuYP007.js}

@@ -1,4 +1,4 @@
-import { a as manifestOutputSchema, i as journeyStepOutputSchema, o as templateRenderOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-BrcKEXz0.js";
+import { a as manifestOutputSchema, i as journeyStepOutputSchema, o as templateRenderOutputSchema, r as guestInputSchema, t as CapabilityError } from "./journeys-F8Yk8s1P.js";
 import { z } from "zod";
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server.browser";
@@ -5573,6 +5573,8 @@ function readManifest(module) {
 			kind: "journey",
 			trigger: journey.trigger,
 			purpose: journey.purpose,
+			enrollment: journey.enrollment,
+			description: journey.description,
 			from: journey.from,
 			tags: journey.tags
 		});
@@ -5583,6 +5585,7 @@ function readManifest(module) {
 		tags: template.tags,
 		sendClass: template.sendClass ?? "marketing",
 		verifyLink: template.verifyLink ?? false,
+		unsubscribeLink: template.unsubscribeLink ?? false,
 		propsSchema: z.toJSONSchema(template.props, { target: "draft-2020-12" })
 	});
 }

package/dist/guest/driver.d.ts

@@ -1,4 +1,4 @@
-import { a as ManifestOutput, i as JourneyStepOutput, o as TemplateRenderOutput } from "./index-CXcCEcAg.js";
+import { a as JourneyStepOutput, o as ManifestOutput, s as TemplateRenderOutput } from "./index-EqBCZnpq.js";
 //#region src/guest/driver.d.ts
 /**
  * The in-process driver: JSON in, JSON out (spec: Guest protocol). One

package/dist/guest/driver.js

@@ -1,3 +1,3 @@
-import { t as runGuest } from "./driver-DBt5l1Z5.js";
+import { t as runGuest } from "./driver-BXuYP007.js";
 
 export { runGuest };

package/dist/guest/emails.d.ts

@@ -36,6 +36,12 @@ type Template<Schema extends z.ZodType = z.ZodType> = {
   tags?: string[];
   /** True asks the host to mint a signed `verifyUrl` prop at send time. */
   verifyLink?: boolean;
+  /**
+   * True asks the host to mint a signed `unsubscribeUrl` prop at send time,
+   * for the author's own footer link. Leave it off and a marketing template
+   * still gets a platform footer with the link appended at send time.
+   */
+  unsubscribeLink?: boolean;
 };
 //#endregion
 export { type SendClass, Subject, Template };

package/dist/guest/{index-CXcCEcAg.d.ts → index-EqBCZnpq.d.ts}

@@ -6,9 +6,6 @@ import { z } from "zod";
  * a guest returns with these schemas before anything acts on it; the guest
  * SDK and the Node simulator produce and consume the same shapes.
  */
-/** A duration as journey code writes it: an ms-style string ("2d") or milliseconds. */
-declare const durationSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
-type Duration = z.infer<typeof durationSchema>;
 /** The event a journey runs for, or waits on: name, properties, and when. */
 declare const guestEventSchema: z.ZodObject<{
   name: z.ZodString;
@@ -255,11 +252,44 @@ declare const manifestOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   tags: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[]>>;
   trigger: z.ZodUnion<readonly [z.ZodObject<{
     event: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    appId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
   }, z.core.$strict>, z.ZodObject<{
-    segment: z.ZodString;
+    segment: z.ZodObject<{
+      match: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        any: "any";
+      }>>;
+      predicates: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"trait">;
+        name: z.ZodString;
+        op: z.ZodEnum<{
+          contains: "contains";
+          eq: "eq";
+          exists: "exists";
+          gt: "gt";
+          gte: "gte";
+          lt: "lt";
+          lte: "lte";
+          neq: "neq";
+          notExists: "notExists";
+        }>;
+        value: z.ZodOptional<z.ZodUnknown>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"event">;
+        name: z.ZodString;
+        op: z.ZodEnum<{
+          notPerformed: "notPerformed";
+          performed: "performed";
+        }>;
+        atLeast: z.ZodDefault<z.ZodNumber>;
+        withinDays: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>], "kind">>;
+    }, z.core.$strict>;
   }, z.core.$strict>]>;
   purpose: z.ZodString;
+  enrollment: z.ZodOptional<z.ZodObject<{
+    cooldown: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+  }, z.core.$strict>>;
+  description: z.ZodOptional<z.ZodString>;
   from: z.ZodOptional<z.ZodString>;
   kind: z.ZodLiteral<"journey">;
 }, z.core.$strip>, z.ZodObject<{
@@ -269,6 +299,7 @@ declare const manifestOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     transactional: "transactional";
   }>;
   verifyLink: z.ZodBoolean;
+  unsubscribeLink: z.ZodDefault<z.ZodBoolean>;
   propsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
   kind: z.ZodLiteral<"template">;
 }, z.core.$strip>], "kind">;
@@ -276,21 +307,81 @@ type ManifestOutput = z.infer<typeof manifestOutputSchema>;
 //#endregion
 //#region ../../packages/shared/src/journeys-v2/manifest.d.ts
 /**
- * What starts a journey: an event (optionally narrowed to an app id or a
- * list of them) or a segment entry. The registry DTO in `../journeys`
- * reuses it.
+ * The pushed manifest (spec: Build; Push and compile): what `cow build`
+ * extracts from a project and `cow push` uploads with the bundles. The
+ * server validates it with these schemas, compiles every bundle whose key
+ * changed, and stores that entry on the version it creates.
+ */
+/**
+ * A duration as journey code writes it: an ms-style string ("2d") or
+ * milliseconds. It lives here rather than with the guest protocol because a
+ * manifest carries one too (a journey's enrollment cooldown) and `./guest`
+ * already imports this module, so the other direction would be a cycle.
+ */
+declare const durationSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+type Duration = z.infer<typeof durationSchema>;
+/**
+ * What starts a journey: an event, or entry into the segment the trigger
+ * itself describes. The registry DTO in `../journeys` reuses it.
+ *
+ * No trigger names an app (ADR 0022): a repository is one app, the journey
+ * row carries its `app_id`, and the runtime compares that with the event's.
+ * An `appId` here would be a second way to say it, and the way to leak.
  *
- * Both members are strict, so a journey holding the retired `source` key
- * fails to compile instead of silently triggering on every app.
- * There is deliberately no pipe filter: a trigger narrows by the app the
- * write is attributed to, the same token a segment definition names.
+ * A segment trigger carries the predicate list, not a name: the push
+ * materializes one segment row per journey that inlines a definition, owned
+ * by the journey and named after its key, so the segment exists because the
+ * journey exists and there is no order to get wrong (ADR 0016). The
+ * definition is data — validated here, carried on the version, never
+ * compiled and never executed.
+ *
+ * Both members are strict, so a journey holding the retired `source` or
+ * `appId` key, or the retired `{ segment: "name" }` form, fails to build
+ * instead of silently triggering on every app or on nothing. There is
+ * deliberately no pipe filter and no app filter: the journey's own app is
+ * the only narrowing there is.
  */
 declare const triggerSchema: z.ZodUnion<readonly [z.ZodObject<{
   event: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-  appId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strict>, z.ZodObject<{
-  segment: z.ZodString;
+  segment: z.ZodObject<{
+    match: z.ZodDefault<z.ZodEnum<{
+      all: "all";
+      any: "any";
+    }>>;
+    predicates: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"trait">;
+      name: z.ZodString;
+      op: z.ZodEnum<{
+        contains: "contains";
+        eq: "eq";
+        exists: "exists";
+        gt: "gt";
+        gte: "gte";
+        lt: "lt";
+        lte: "lte";
+        neq: "neq";
+        notExists: "notExists";
+      }>;
+      value: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"event">;
+      name: z.ZodString;
+      op: z.ZodEnum<{
+        notPerformed: "notPerformed";
+        performed: "performed";
+      }>;
+      atLeast: z.ZodDefault<z.ZodNumber>;
+      withinDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "kind">>;
+  }, z.core.$strict>;
 }, z.core.$strict>]>;
 type Trigger = z.infer<typeof triggerSchema>;
+/**
+ * A trigger as an author writes it, before zod fills in a predicate's
+ * `match` and `atLeast` defaults. `defineJourney` takes this shape;
+ * everything downstream reads the parsed `Trigger`.
+ */
+type TriggerInput = z.input<typeof triggerSchema>;
 //#endregion
-export { ManifestOutput as a, JourneyStepOutput as i, Duration as n, TemplateRenderOutput as o, GuestEvent as r, Trigger as t };
+export { JourneyStepOutput as a, GuestEvent as i, Trigger as n, ManifestOutput as o, TriggerInput as r, TemplateRenderOutput as s, Duration as t };