@metabase/cli 0.2.1 → 0.2.2-alpha.extract-api-client.27e2241

package/dist/measure-BsYv0p26.mjs

@@ -0,0 +1,22 @@
+import { t as defineCommandGroup } from "./group-DBM87IgC.mjs";
+//#region src/commands/measure/index.ts
+var measure_default = defineCommandGroup({
+	name: "measure",
+	description: "Manage Metabase measures",
+	skills: [{
+		skill: "mbql",
+		purpose: "the definition aggregation"
+	}, {
+		skill: "data-workflow",
+		purpose: "define reusable measures"
+	}],
+	subCommands: {
+		list: () => import("./list-BtmsNOEn.mjs").then((mod) => mod.default),
+		get: () => import("./get-CDMGbgrh.mjs").then((mod) => mod.default),
+		create: () => import("./create-CAWytBE5.mjs").then((mod) => mod.default),
+		update: () => import("./update-Nfi44RrE.mjs").then((mod) => mod.default),
+		archive: () => import("./archive-4tmm946K.mjs").then((mod) => mod.default)
+	}
+});
+//#endregion
+export { measure_default as default };

package/dist/{measure-S9WszHre.mjs → measure-CtfjqJFP.mjs}

@@ -1,6 +1,5 @@
 import { z } from "zod";
-
-//#region src/domain/measure.ts
+//#region ../client/src/domain/measure.ts
 const Measure = z.object({
 	id: z.number().int(),
 	name: z.string(),
@@ -24,32 +23,7 @@ const MeasureCompact = Measure.pick({
 	archived: true,
 	table_id: true
 }).strip();
-const measureView = {
-	compactPick: MeasureCompact,
-	tableColumns: [
-		{
-			key: "id",
-			label: "ID"
-		},
-		{
-			key: "name",
-			label: "Name"
-		},
-		{
-			key: "description",
-			label: "Description"
-		},
-		{
-			key: "table_id",
-			label: "Table"
-		},
-		{
-			key: "archived",
-			label: "Archived"
-		}
-	]
-};
-const MeasureDefinition = z.record(z.string(), z.unknown()).describe("MBQL query holding exactly one aggregation — full MBQL 5 schema: mb query --print-schema");
+const MeasureDefinition = z.record(z.string(), z.unknown()).describe("MBQL query holding exactly one aggregation");
 const MeasureCreateInput = z.object({
 	name: z.string().min(1),
 	table_id: z.number().int().positive(),
@@ -63,6 +37,5 @@ const MeasureUpdateInput = z.object({
 	archived: z.boolean().nullable().optional(),
 	description: z.string().nullable().optional()
 }).loose();
-
 //#endregion
-export { Measure, MeasureCompact, MeasureCreateInput, MeasureUpdateInput, measureView };
+export { MeasureUpdateInput as i, MeasureCompact as n, MeasureCreateInput as r, Measure as t };

package/dist/network-error-CEb9ymDW.mjs

@@ -0,0 +1,423 @@
+import { d as ValidationError, f as errorMessage, i as ConfigError, o as MetabaseError, r as ChainedRequestError, s as NetworkError, t as isPlainObject } from "./predicates-Bkm2IoeX.mjs";
+import { z } from "zod";
+//#region ../client/src/json.ts
+const JSON_CONTENT_TYPE = "application/json";
+function parseJson(input, schema, opts = {}) {
+	const result = parseJsonResult(input, schema, opts);
+	if (!result.ok) throw result.error;
+	return result.value;
+}
+function parseJsonResult(input, schema, opts = {}) {
+	const sourcePrefix = opts.source === void 0 ? "" : `${opts.source}: `;
+	let raw;
+	try {
+		raw = JSON.parse(input);
+	} catch (error) {
+		return {
+			ok: false,
+			error: new ConfigError(`${sourcePrefix}invalid JSON: ${errorMessage(error)}`)
+		};
+	}
+	const parsed = schema.safeParse(raw);
+	if (!parsed.success) return {
+		ok: false,
+		error: new ValidationError(`${sourcePrefix}value did not match expected schema`, {
+			source: opts.source ?? "<input>",
+			zodIssues: parsed.error.issues
+		})
+	};
+	return {
+		ok: true,
+		value: parsed.data
+	};
+}
+function parseJsonOrPlain(text, contentType, schema, opts = {}) {
+	if (!isJsonContentType(contentType)) return parseJson(JSON.stringify(text), schema, opts);
+	const attempt = parseJsonResult(text, schema, opts);
+	if (attempt.ok) return attempt.value;
+	if (attempt.error instanceof ValidationError) throw attempt.error;
+	return parseJson(JSON.stringify(text), schema, opts);
+}
+function isJsonContentType(contentType) {
+	return contentType !== null && contentType.includes("application/json");
+}
+//#endregion
+//#region ../client/src/auth/credential.ts
+const API_KEY_HEADER = "x-api-key";
+const AUTHORIZATION_HEADER = "authorization";
+const BEARER_PREFIX = "Bearer ";
+const EXPIRY_SKEW_MS = 6e4;
+function credentialAuthHeader(credential) {
+	if (credential.kind === "apiKey") return {
+		name: API_KEY_HEADER,
+		value: credential.apiKey
+	};
+	return {
+		name: AUTHORIZATION_HEADER,
+		value: BEARER_PREFIX + credential.accessToken
+	};
+}
+const MAX_HEADER_CODE_UNIT = 255;
+function headerBearingSecret(credential) {
+	if (credential.kind === "apiKey") return {
+		field: "apiKey",
+		value: credential.apiKey
+	};
+	return {
+		field: "accessToken",
+		value: credential.accessToken
+	};
+}
+function assertCredentialHeaderSafe(credential) {
+	const { field, value } = headerBearingSecret(credential);
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit > MAX_HEADER_CODE_UNIT) {
+			const codePoint = codeUnit.toString(16).toUpperCase().padStart(4, "0");
+			throw new ConfigError(`Credential field "${field}" has a character at index ${index} (U+${codePoint}) that cannot be sent in an HTTP header. Header values are limited to Latin-1; a smart quote, ellipsis, or dash substituted during copy-paste is the usual cause.`);
+		}
+	}
+}
+function credentialSecrets(credential) {
+	if (credential.kind === "apiKey") return [credential.apiKey];
+	return [credential.accessToken, credential.refreshToken];
+}
+function isOAuthExpired(credential, nowMs) {
+	const expiryMs = Date.parse(credential.expiresAt);
+	if (Number.isNaN(expiryMs)) return true;
+	return expiryMs - EXPIRY_SKEW_MS <= nowMs;
+}
+function expiresAtFromNow(expiresInSeconds, nowMs) {
+	return new Date(nowMs + expiresInSeconds * 1e3).toISOString();
+}
+function oauthCredentialFromTokens(tokens, refreshToken, clientId, nowMs) {
+	return {
+		kind: "oauth",
+		accessToken: tokens.access_token,
+		refreshToken,
+		expiresAt: expiresAtFromNow(tokens.expires_in ?? 3600, nowMs),
+		clientId
+	};
+}
+//#endregion
+//#region ../client/src/url.ts
+function normalizeUrl(input) {
+	const trimmed = input.trim().replace(/\/+$/, "");
+	if (!/^https?:\/\//i.test(trimmed)) throw new ConfigError("URL must start with http:// or https://");
+	return trimmed;
+}
+function displayUrl(input) {
+	const parsed = new URL(input);
+	const path = parsed.pathname.replace(/\/+$/, "");
+	return `${parsed.origin}${path}`;
+}
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+]);
+function isLoopbackHost(hostname) {
+	return LOOPBACK_HOSTS.has(hostname.toLowerCase());
+}
+function assertEndpointOrigin(endpoint, baseUrl, label) {
+	let parsed;
+	try {
+		parsed = new URL(endpoint);
+	} catch {
+		throw new ConfigError(`OAuth ${label} is not a valid URL: ${endpoint}`);
+	}
+	const base = new URL(baseUrl);
+	if (parsed.protocol !== "https:" && !isLoopbackHost(parsed.hostname)) throw new ConfigError(`OAuth ${label} must use https: ${endpoint}`);
+	if (parsed.origin !== base.origin) throw new ConfigError(`OAuth ${label} origin (${parsed.origin}) does not match the Metabase URL (${base.origin})`);
+}
+//#endregion
+//#region ../client/src/http/sanitize.ts
+const SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
+	"authorization",
+	"x-api-key",
+	"x-metabase-session",
+	"cookie",
+	"set-cookie",
+	"proxy-authorization"
+]);
+const REDACTED = "[REDACTED]";
+function redactHeaders(headers) {
+	const result = {};
+	const entries = headers instanceof Headers ? headers.entries() : Object.entries(headers);
+	for (const [key, value] of entries) result[key] = SECRET_HEADER_NAMES.has(key.toLowerCase()) ? REDACTED : value;
+	return result;
+}
+function redactBody(body, ctx) {
+	let result = body;
+	for (const secret of ctx.knownSecrets) {
+		if (secret.length === 0) continue;
+		result = result.replaceAll(secret, REDACTED);
+	}
+	return result;
+}
+//#endregion
+//#region ../client/src/http/errors.ts
+const NOT_FOUND_STATUS = 404;
+const ROUTE_MISSING_LITERAL = "API endpoint does not exist.";
+const RESOURCE_MISSING_LITERAL = "Not found.";
+const STATUS_CLASSIFICATIONS = {
+	401: { retryable: false },
+	403: { retryable: false },
+	404: { retryable: false },
+	408: {
+		retryable: true,
+		message: "Metabase timed out responding."
+	},
+	425: { retryable: true },
+	429: {
+		retryable: true,
+		message: "Metabase rate-limited the request."
+	},
+	500: { retryable: true },
+	502: { retryable: true },
+	503: { retryable: true },
+	504: {
+		retryable: true,
+		message: "Metabase timed out responding."
+	}
+};
+const ErrorEnvelope = z.object({
+	message: z.string().optional(),
+	error: z.string().optional(),
+	"error-message": z.string().optional(),
+	via: z.array(z.object({ message: z.string().optional() }).loose()).optional(),
+	"specific-errors": z.unknown().optional(),
+	errors: z.unknown().optional()
+}).loose();
+const FieldErrorNodeSchema = z.lazy(() => z.union([
+	z.string(),
+	z.array(z.string()),
+	z.record(z.string(), FieldErrorNodeSchema)
+]));
+const FieldErrorTree = z.record(z.string(), FieldErrorNodeSchema);
+const FIELD_MESSAGE_SEPARATOR = "; ";
+const MAX_EXTRACTED_MESSAGE_LEN = 500;
+const ELLIPSIS = "…";
+var HttpError = class extends MetabaseError {
+	category = "http";
+	status;
+	kind;
+	developerDetail;
+	constructor(input) {
+		const sanitizedBody = sanitizeBody(input.rawBody, input.redactionContext);
+		const redactedHeaders = redactHeaders(input.responseHeaders);
+		const kind = classifyKind(input.status, sanitizedBody, redactedHeaders);
+		super(input.overrideUserMessage ?? buildUserMessage(kind, input, sanitizedBody));
+		const fields = extractFieldErrors(sanitizedBody);
+		this.name = "HttpError";
+		this.status = input.status;
+		this.kind = kind;
+		this.developerDetail = {
+			status: input.status,
+			statusText: input.statusText,
+			method: input.method,
+			url: input.url,
+			responseHeaders: redactedHeaders,
+			body: sanitizedBody,
+			fieldErrors: fields.fieldErrors,
+			specificFieldErrors: fields.specificFieldErrors
+		};
+	}
+	get isRetryable() {
+		return isRetryableStatus(this.status);
+	}
+	get fieldErrors() {
+		return this.developerDetail.fieldErrors;
+	}
+	get specificFieldErrors() {
+		return this.developerDetail.specificFieldErrors;
+	}
+};
+function chainRequestFailure(cause, message) {
+	if (cause instanceof HttpError) return new HttpError({
+		status: cause.status,
+		statusText: cause.developerDetail.statusText,
+		method: cause.developerDetail.method,
+		url: cause.developerDetail.url,
+		responseHeaders: cause.developerDetail.responseHeaders,
+		rawBody: cause.developerDetail.body,
+		overrideUserMessage: message
+	});
+	return new ChainedRequestError(message, cause);
+}
+function isRetryableStatus(status) {
+	return STATUS_CLASSIFICATIONS[status]?.retryable === true;
+}
+function sanitizeBody(rawBody, ctx) {
+	if (rawBody === null) return null;
+	if (ctx === void 0) return rawBody;
+	return redactBody(rawBody, ctx);
+}
+function classifyKind(status, sanitizedBody, redactedHeaders) {
+	if (status === 401 || status === 403) return "auth";
+	if (status === NOT_FOUND_STATUS) return isRouteMissingResponse(sanitizedBody, redactedHeaders) ? "route-missing" : "resource-missing";
+	if (status === 429) return "rate-limit";
+	if (status >= 500 && status < 600) return "server-error";
+	return "generic";
+}
+function isRouteMissingResponse(sanitizedBody, redactedHeaders) {
+	if (sanitizedBody?.includes(ROUTE_MISSING_LITERAL)) return true;
+	if (sanitizedBody?.includes(RESOURCE_MISSING_LITERAL)) return false;
+	if (redactedHeaders["content-type"]?.includes("application/json")) return false;
+	if (sanitizedBody === null || sanitizedBody.trim() === "") return true;
+	return parseEnvelope(sanitizedBody) === null;
+}
+function buildUserMessage(kind, input, sanitizedBody) {
+	if (kind === "route-missing") return buildRouteMissingMessage(input);
+	if (kind === "resource-missing") return `Not found: ${input.method} ${pathFromUrl(input.url)}.`;
+	const fromBody = parseEnvelopeMessage(sanitizedBody);
+	if (fromBody !== null) return fromBody;
+	if (kind === "auth") return `Invalid or unauthorized API key (host: ${hostFromUrl(input.url)}).`;
+	return defaultMessageForStatus(input.status);
+}
+function buildRouteMissingMessage(input) {
+	const path = pathFromUrl(input.url);
+	if (!input.serverTag) return `This endpoint is not available on the connected Metabase: ${input.method} ${path}.`;
+	return `This endpoint is not available on Metabase ${input.serverTag}: ${input.method} ${path}. It may require a newer Metabase major version.`;
+}
+function pathFromUrl(url) {
+	const parsed = new URL(url);
+	return parsed.pathname + parsed.search;
+}
+function hostFromUrl(url) {
+	return new URL(url).host;
+}
+function parseEnvelope(sanitizedBody) {
+	if (!sanitizedBody) return null;
+	const result = parseJsonResult(sanitizedBody, ErrorEnvelope);
+	return result.ok ? result.value : null;
+}
+const NO_FIELD_ERRORS = {
+	fieldErrors: null,
+	specificFieldErrors: null
+};
+function extractFieldErrors(sanitizedBody) {
+	const envelope = parseEnvelope(sanitizedBody);
+	if (envelope === null) return NO_FIELD_ERRORS;
+	return {
+		fieldErrors: parseFieldErrors(envelope.errors),
+		specificFieldErrors: parseFieldErrors(envelope["specific-errors"])
+	};
+}
+function parseFieldErrors(value) {
+	const parsed = FieldErrorTree.safeParse(value);
+	if (!parsed.success) return null;
+	const entries = collectLeafEntries(parsed.data, []);
+	if (entries.length === 0) return null;
+	return Object.fromEntries(entries.map((entry) => [entry.path, entry.message]));
+}
+function parseEnvelopeMessage(sanitizedBody) {
+	const envelope = parseEnvelope(sanitizedBody);
+	if (envelope === null) return null;
+	const topLevel = envelope.message ?? envelope.error ?? envelope["error-message"];
+	if (topLevel) return capLength(topLevel);
+	const viaMessage = envelope.via?.find((entry) => entry.message)?.message;
+	if (viaMessage) return capLength(viaMessage);
+	const specific = formatErrorTree(envelope["specific-errors"]);
+	if (specific) return capLength(specific);
+	const generic = formatErrorTree(envelope.errors);
+	if (generic) return capLength(generic);
+	return null;
+}
+function formatErrorTree(value) {
+	const entries = collectLeafEntries(value, []);
+	if (entries.length === 0) return null;
+	return entries.map(formatLeafEntry).join(FIELD_MESSAGE_SEPARATOR);
+}
+function formatLeafEntry(entry) {
+	return entry.path === "" ? entry.message : `${entry.path}: ${entry.message}`;
+}
+function collectLeafEntries(value, path) {
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		return trimmed === "" ? [] : [{
+			path: path.join("."),
+			message: trimmed
+		}];
+	}
+	if (Array.isArray(value)) {
+		const messages = value.filter((entry) => typeof entry === "string" && entry.trim() !== "");
+		if (messages.length === 0) return [];
+		return [{
+			path: path.join("."),
+			message: messages.join(FIELD_MESSAGE_SEPARATOR)
+		}];
+	}
+	if (isPlainObject(value)) return Object.entries(value).flatMap(([key, child]) => collectLeafEntries(child, [...path, key]));
+	return [];
+}
+function capLength(message) {
+	if (message.length <= MAX_EXTRACTED_MESSAGE_LEN) return message;
+	return message.slice(0, MAX_EXTRACTED_MESSAGE_LEN - 1) + ELLIPSIS;
+}
+function defaultMessageForStatus(status) {
+	return STATUS_CLASSIFICATIONS[status]?.message ?? `Metabase returned ${status}.`;
+}
+//#endregion
+//#region ../client/src/http/network-error.ts
+const NETWORK_HINTS = {
+	ECONNREFUSED: (t) => `Connection refused by ${t.host} — is Metabase running and is the port correct?`,
+	ENOTFOUND: (t) => `Host not found: ${t.hostname} — check the URL.`,
+	EAI_AGAIN: (t) => `Could not resolve ${t.hostname} — check your network connection and the URL.`,
+	ECONNRESET: (t) => `Connection to ${t.host} was reset — the server may have closed it, or http/https may be mismatched.`,
+	UND_ERR_SOCKET: (t) => `Connection to ${t.host} was closed by the other side — a pooled connection or a proxy may have dropped it.`,
+	EPIPE: (t) => `Connection to ${t.host} closed while the request was still being written — the server or a proxy dropped it.`,
+	ETIMEDOUT: (t) => `Connection to ${t.host} timed out — check the host, port, and your network.`
+};
+const CONNECTION_CLOSED_CODES = /* @__PURE__ */ new Set([
+	"ECONNRESET",
+	"UND_ERR_SOCKET",
+	"EPIPE"
+]);
+const TLS_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EPROTO",
+	"DEPTH_ZERO_SELF_SIGNED_CERT",
+	"SELF_SIGNED_CERT_IN_CHAIN",
+	"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+	"CERT_HAS_EXPIRED",
+	"ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+function buildNetworkError(error, method, url) {
+	const fallback = errorMessage(error);
+	const code = failureCode(error);
+	return new NetworkError(networkMessage(code, networkTarget(url), fallback), {
+		method,
+		url,
+		cause: code ?? fallback
+	});
+}
+function isConnectionClosed(error) {
+	const code = failureCode(error);
+	return code !== null && CONNECTION_CLOSED_CODES.has(code);
+}
+function networkMessage(code, target, fallback) {
+	if (code === null) return `Could not reach Metabase: ${fallback}`;
+	if (TLS_ERROR_CODES.has(code)) return `Could not reach Metabase: TLS error contacting ${target.host} (${code}) — the certificate could not be verified, or https:// was used against a plain-HTTP server. For a certificate the OS does not trust either, set NODE_EXTRA_CA_CERTS to its CA bundle.`;
+	const hint = NETWORK_HINTS[code];
+	if (hint === void 0) return `Could not reach Metabase: ${fallback} (${code})`;
+	return `Could not reach Metabase: ${hint(target)}`;
+}
+function failureCode(error) {
+	const own = errorCode(error);
+	if (own !== null) return own;
+	return errorCode(error instanceof Error ? error.cause : void 0);
+}
+function errorCode(value) {
+	if (value instanceof Error && "code" in value && typeof value.code === "string") return value.code;
+	return null;
+}
+function networkTarget(url) {
+	const parsed = new URL(url);
+	return {
+		host: parsed.host,
+		hostname: parsed.hostname
+	};
+}
+//#endregion
+export { parseJsonResult as _, isRetryableStatus as a, normalizeUrl as c, credentialSecrets as d, isOAuthExpired as f, parseJsonOrPlain as g, parseJson as h, chainRequestFailure as i, assertCredentialHeaderSafe as l, JSON_CONTENT_TYPE as m, isConnectionClosed as n, assertEndpointOrigin as o, oauthCredentialFromTokens as p, HttpError as r, displayUrl as s, buildNetworkError as t, credentialAuthHeader as u };

package/dist/notification-DaA4bBHW.mjs

@@ -0,0 +1,138 @@
+import { t as CronUiDisplayType } from "./cron-LKRffEC-.mjs";
+import { z } from "zod";
+//#region ../client/src/domain/notification.ts
+const NotificationPayloadType = z.enum([
+	"notification/card",
+	"notification/dashboard",
+	"notification/system-event",
+	"notification/testing"
+]);
+const CARD_PAYLOAD_TYPE = "notification/card";
+const NotificationSendCondition = z.enum([
+	"has_result",
+	"goal_above",
+	"goal_below"
+]);
+const NotificationChannelType = z.enum([
+	"channel/email",
+	"channel/slack",
+	"channel/http"
+]);
+const NotificationRecipientType = z.enum([
+	"notification-recipient/user",
+	"notification-recipient/group",
+	"notification-recipient/raw-value",
+	"notification-recipient/template"
+]);
+const NotificationSubscriptionType = z.enum(["notification-subscription/cron", "notification-subscription/system-event"]);
+const NotificationRecipientDetails = z.object({
+	value: z.string().optional(),
+	channel_id: z.string().nullable().optional()
+}).loose();
+const NotificationRecipientDetailsCompact = NotificationRecipientDetails.pick({
+	value: true,
+	channel_id: true
+}).strip();
+const NotificationRecipient = z.object({
+	id: z.number().int().optional(),
+	type: NotificationRecipientType,
+	user_id: z.number().int().nullable().optional(),
+	permissions_group_id: z.number().int().nullable().optional(),
+	details: NotificationRecipientDetails.nullable().optional()
+}).loose();
+const NotificationRecipientCompact = NotificationRecipient.pick({
+	type: true,
+	user_id: true,
+	permissions_group_id: true
+}).strip().extend({ details: NotificationRecipientDetailsCompact.nullable().optional() });
+const NotificationHandler = z.object({
+	id: z.number().int().optional(),
+	channel_type: NotificationChannelType,
+	channel_id: z.number().int().nullable().optional(),
+	template_id: z.number().int().nullable().optional(),
+	active: z.boolean().optional(),
+	recipients: z.array(NotificationRecipient).optional()
+}).loose();
+const NotificationHandlerCompact = NotificationHandler.pick({
+	channel_type: true,
+	channel_id: true
+}).strip().extend({ recipients: z.array(NotificationRecipientCompact).optional() });
+const NotificationSubscription = z.object({
+	id: z.number().int().optional(),
+	type: NotificationSubscriptionType,
+	cron_schedule: z.string().nullable().optional(),
+	event_name: z.string().nullable().optional(),
+	ui_display_type: CronUiDisplayType.nullable().optional()
+}).loose();
+const NotificationSubscriptionCompact = NotificationSubscription.pick({
+	type: true,
+	cron_schedule: true
+}).strip();
+const NotificationCardPayload = z.object({
+	id: z.number().int().optional(),
+	card_id: z.number().int(),
+	send_condition: NotificationSendCondition,
+	send_once: z.boolean()
+}).loose();
+const NotificationCardPayloadCompact = NotificationCardPayload.pick({
+	card_id: true,
+	send_condition: true,
+	send_once: true
+}).strip();
+const Notification = z.object({
+	id: z.number().int(),
+	payload_type: NotificationPayloadType,
+	payload_id: z.number().int().nullable(),
+	payload: NotificationCardPayload.nullable(),
+	active: z.boolean(),
+	creator_id: z.number().int().nullable(),
+	subscriptions: z.array(NotificationSubscription),
+	handlers: z.array(NotificationHandler)
+}).loose();
+const NotificationCompact = Notification.pick({
+	id: true,
+	payload_type: true,
+	active: true,
+	creator_id: true
+}).strip().extend({
+	payload: NotificationCardPayloadCompact.nullable(),
+	subscriptions: z.array(NotificationSubscriptionCompact),
+	handlers: z.array(NotificationHandlerCompact)
+});
+const NotificationRecipientInput = z.object({
+	type: NotificationRecipientType,
+	user_id: z.number().int().positive().optional(),
+	permissions_group_id: z.number().int().positive().optional(),
+	details: NotificationRecipientDetails.optional()
+}).loose();
+const NotificationHandlerInput = z.object({
+	channel_type: NotificationChannelType,
+	channel_id: z.number().int().positive().nullable().optional(),
+	active: z.boolean().optional(),
+	recipients: z.array(NotificationRecipientInput).optional()
+}).loose();
+const NotificationSubscriptionInput = z.object({
+	type: NotificationSubscriptionType.default("notification-subscription/cron"),
+	cron_schedule: z.string().min(1)
+}).loose();
+const NotificationCardPayloadInput = z.object({
+	card_id: z.number().int().positive(),
+	send_condition: NotificationSendCondition.optional(),
+	send_once: z.boolean().optional()
+}).loose();
+const NotificationCreateInput = z.object({
+	payload_type: NotificationPayloadType.default(CARD_PAYLOAD_TYPE),
+	payload: NotificationCardPayloadInput,
+	subscriptions: z.array(NotificationSubscriptionInput).min(1),
+	handlers: z.array(NotificationHandlerInput).min(1),
+	active: z.boolean().optional()
+}).loose();
+const NotificationCardPayloadPatch = NotificationCardPayloadInput.partial();
+const NotificationUpdateInput = z.object({
+	payload: NotificationCardPayloadPatch.optional(),
+	subscriptions: z.array(NotificationSubscriptionInput).min(1).optional(),
+	handlers: z.array(NotificationHandlerInput).min(1).optional(),
+	active: z.boolean().optional()
+}).loose();
+//#endregion
+export { NotificationCreateInput as a, NotificationUpdateInput as c, NotificationCompact as i, Notification as n, NotificationHandler as o, NotificationCardPayload as r, NotificationSubscription as s, CARD_PAYLOAD_TYPE as t };

package/dist/notification-Fcq1fIPw.mjs

@@ -0,0 +1,67 @@
+import { d as MALFORMED_CELL } from "./cli.mjs";
+import { i as NotificationCompact, o as NotificationHandler, r as NotificationCardPayload, s as NotificationSubscription } from "./notification-DaA4bBHW.mjs";
+import { z } from "zod";
+//#region src/output/views/notification.ts
+const NullableCardPayload = NotificationCardPayload.nullable();
+const NotificationSubscriptionList = z.array(NotificationSubscription);
+const NotificationHandlerList = z.array(NotificationHandler);
+function formatPayload(value) {
+	const parsed = NullableCardPayload.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	if (parsed.data === null) return "";
+	const { card_id, send_condition, send_once } = parsed.data;
+	return `${card_id} (${send_condition}${send_once ? ", once" : ""})`;
+}
+function formatSubscriptions(value) {
+	const parsed = NotificationSubscriptionList.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	return parsed.data.map((subscription) => subscription.cron_schedule ?? subscription.event_name ?? "").filter((label) => label !== "").join("; ");
+}
+function describeRecipient(recipient) {
+	switch (recipient.type) {
+		case "notification-recipient/user": return `user:${recipient.user_id}`;
+		case "notification-recipient/group": return `group:${recipient.permissions_group_id}`;
+		case "notification-recipient/raw-value": return recipient.details?.value ?? "";
+		case "notification-recipient/template": return "template";
+	}
+}
+function describeHandler(handler) {
+	const channel = handler.channel_type.replace("channel/", "");
+	const recipients = (handler.recipients ?? []).map(describeRecipient).join(", ");
+	return recipients === "" ? channel : `${channel} → ${recipients}`;
+}
+function formatHandlers(value) {
+	const parsed = NotificationHandlerList.safeParse(value);
+	if (!parsed.success) return MALFORMED_CELL;
+	return parsed.data.map(describeHandler).join("; ");
+}
+const notificationView = {
+	compactPick: NotificationCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "payload",
+			label: "Card",
+			format: formatPayload
+		},
+		{
+			key: "subscriptions",
+			label: "Schedule",
+			format: formatSubscriptions
+		},
+		{
+			key: "handlers",
+			label: "Delivery",
+			format: formatHandlers
+		},
+		{
+			key: "active",
+			label: "Active"
+		}
+	]
+};
+//#endregion
+export { notificationView as t };