@cowliss/cli 0.10.0 → 0.12.0

package/dist/guest/journeys.js

@@ -1,3 +1,60 @@
-import { n as defineJourney, t as CapabilityError } from "./journeys-F8Yk8s1P.js";
+import { a as manifestJourneySchema } from "./journeys-v2-Djgs8U91.js";
 
+//#region src/guest/journeys.ts
+/**
+* A capability that failed host-side (an unknown webhook, invalid
+* props, a profile that is not there). The failure is journaled, so a
+* journey that catches it takes the same branch on every replay.
+*/
+var CapabilityError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "CapabilityError";
+		this.code = code;
+	}
+};
+/**
+* The config half of a journey, validated with the same schema the release
+* manifest is validated with, so a bad trigger, a malformed purpose key, or
+* a `from` that is not an address fails at build time rather than at the
+* first execution. Whether the org declares that purpose, and whether it may
+* send from that domain, are questions only the push can answer.
+*/
+const journeyConfigSchema = manifestJourneySchema.pick({
+	trigger: true,
+	purpose: true,
+	enrollment: true,
+	description: true,
+	from: true,
+	tags: true
+});
+/**
+* Author a journey. Throws at definition time on an invalid config.
+*
+* There is no environment gate here: an organization has one data space, and
+* a journey runs wherever it is on and nowhere else (ADR 0011, ADR 0013).
+*
+* There is no app gate either. A journey belongs to the one app `cow.json`
+* names, so it only ever sees that app's events, profiles and segments
+* (ADR 0022); a trigger naming an app is refused rather than honoured.
+*/
+function defineJourney(input) {
+	const config = journeyConfigSchema.parse({
+		trigger: input.trigger,
+		purpose: input.purpose,
+		enrollment: input.enrollment,
+		description: input.description,
+		from: input.from,
+		tags: input.tags
+	});
+	if (config.from === void 0) throw new Error("defineJourney needs a \"from\": the address this journey sends as, on a domain your organization verified. Add and verify it on the Domains page (Settings, Domains). For example from: \"Billing <billing@your-domain.com>\".");
+	return {
+		...config,
+		from: config.from,
+		run: input.run
+	};
+}
+
+//#endregion
 export { CapabilityError, defineJourney };

package/dist/guest/segments.d.ts

@@ -0,0 +1,81 @@
+import { i as manifestSegmentSchema } from "./index-DADBwPaG.js";
+import { z } from "zod";
+//#region src/guest/segments.d.ts
+/**
+ * The authoring surface tenant segments import (`@cowliss/cli/segments`):
+ * one `segments/<key>.ts` file is one audience, named by its filename and
+ * enrolled from by any journey in the same repository (ADR 0023).
+ *
+ * A segment compiles to nothing. The definition is a predicate list the
+ * evaluator folds host-side, so this file is read once by `cow build` and
+ * never bundled into the sandbox — but it is authored beside journeys and
+ * imported the same way, so like `./journeys` it reaches for nothing but
+ * `@cowliss/shared/journeys-v2`.
+ */
+/** A predicate list as an author writes it, before zod fills its defaults. */
+type DefinitionInput = z.input<typeof manifestSegmentSchema>["definition"];
+/** One predicate over a trait or over the recipient's event history. */
+type Predicate = DefinitionInput["predicates"][number];
+declare const segmentConfigSchema: z.ZodObject<{
+  tags: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[]>>;
+  description: z.ZodOptional<z.ZodString>;
+  definition: 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.$strip>;
+/**
+ * A segment as `defineSegment` returns it. `cow build` reads it off the
+ * module's default export and copies it into the manifest under the file's
+ * key; the push writes one row from it.
+ */
+type Segment = z.infer<typeof segmentConfigSchema>;
+/**
+ * Author a segment. Throws at definition time on an invalid predicate list,
+ * so a typo is a build error with the file in hand rather than an audience
+ * that quietly matches nobody.
+ *
+ * Reach for this when two journeys enroll from the same audience: they then
+ * name one file instead of repeating a predicate list that can drift. A
+ * segment only one journey uses belongs in that journey's trigger, where the
+ * code and the audience cannot disagree (ADR 0016).
+ *
+ * There is no app here, and no consent purpose: a segment belongs to the one
+ * app its repository pushes to, and evaluates that app's profiles and events
+ * and no others (ADR 0022).
+ */
+declare function defineSegment(input: DefinitionInput & {
+  /** One plain sentence about who is in it. Shown wherever it is read. */
+  description?: string;
+  /** The author's labels; the dashboard's only grouping. */
+  tags?: string[];
+}): Segment;
+//#endregion
+export { Predicate, Segment, defineSegment };

package/dist/guest/segments.js

@@ -0,0 +1,35 @@
+import { o as manifestSegmentSchema } from "./journeys-v2-Djgs8U91.js";
+
+//#region src/guest/segments.ts
+const segmentConfigSchema = manifestSegmentSchema.pick({
+	tags: true,
+	description: true,
+	definition: true
+});
+/**
+* Author a segment. Throws at definition time on an invalid predicate list,
+* so a typo is a build error with the file in hand rather than an audience
+* that quietly matches nobody.
+*
+* Reach for this when two journeys enroll from the same audience: they then
+* name one file instead of repeating a predicate list that can drift. A
+* segment only one journey uses belongs in that journey's trigger, where the
+* code and the audience cannot disagree (ADR 0016).
+*
+* There is no app here, and no consent purpose: a segment belongs to the one
+* app its repository pushes to, and evaluates that app's profiles and events
+* and no others (ADR 0022).
+*/
+function defineSegment(input) {
+	return segmentConfigSchema.parse({
+		description: input.description,
+		tags: input.tags,
+		definition: {
+			match: input.match,
+			predicates: input.predicates
+		}
+	});
+}
+
+//#endregion
+export { defineSegment };