@lantharos/pult 0.0.0-stage → 0.8.0

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "@lantharos/pult",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.0",
+  "description": "The other side of your app",
+  "license": "MIT",
+  "homepage": "https://pult.sh",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.mts",
+      "default": "./index.mjs"
+    }
+  },
+  "bin": {
+    "pult": "./cli.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "jiti": "2.7.0",
+    "@standard-schema/spec": "1.1.0",
+    "croner": "10.0.1"
+  }
+}

package/schema-CzG8J_9_.mjs

@@ -0,0 +1,638 @@
+//#region ../protocol/src/manifest.ts
+const HOME = "home";
+const FLAG_ACTION = "flag:";
+const DEFAULT_STATES = [
+	"open",
+	"in progress",
+	"handled"
+];
+function splitAction(id) {
+	const dot = id.indexOf(".");
+	return dot === -1 ? {
+		resource: null,
+		name: id
+	} : {
+		resource: id.slice(0, dot),
+		name: id.slice(dot + 1)
+	};
+}
+function findActionDef(manifest, id) {
+	const { resource, name } = splitAction(id);
+	if (!manifest) return null;
+	return (resource === null ? manifest.actions[name] : manifest.resources[resource]?.actions[name]) ?? null;
+}
+//#endregion
+//#region ../protocol/src/blocks.ts
+function eachBlock(blocks, visit) {
+	for (const block of blocks) {
+		visit(block);
+		if (block.type === "columns") for (const column of block.columns) eachBlock(column, visit);
+	}
+}
+function mapBlocks(blocks, map) {
+	return blocks.flatMap((block) => {
+		const mapped = map(block);
+		if (!mapped) return [];
+		if (mapped.type !== "columns") return [mapped];
+		return [{
+			type: "columns",
+			columns: mapped.columns.map((column) => mapBlocks(column, map))
+		}];
+	});
+}
+//#endregion
+//#region ../protocol/src/signing.ts
+const SIGNATURE_TOLERANCE_MS = 3e5;
+const encoder = new TextEncoder();
+function parseKey(key) {
+	const match = /^pult_([a-z0-9]+)_([A-Za-z0-9_-]{32,})$/.exec(key.trim());
+	if (!match) throw new Error("Malformed Pult key");
+	return {
+		environment: match[1],
+		secret: match[2]
+	};
+}
+function randomToken(bytes = 32) {
+	return base64url(crypto.getRandomValues(new Uint8Array(bytes)));
+}
+async function sha256(data) {
+	const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+	const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+	return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function base64url(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+const keyCache = /* @__PURE__ */ new Map();
+function hmacKey(secret) {
+	let key = keyCache.get(secret);
+	if (!key) {
+		key = crypto.subtle.importKey("raw", encoder.encode(secret), {
+			name: "HMAC",
+			hash: "SHA-256"
+		}, false, ["sign", "verify"]);
+		keyCache.set(secret, key);
+	}
+	return key;
+}
+function payload(scope, timestamp, nonce, body) {
+	return encoder.encode(`${scope}\n${timestamp}\n${nonce}\n${body}`);
+}
+async function sign(secret, scope, body) {
+	const timestamp = String(Date.now());
+	const nonce = randomToken(16);
+	const mac = await crypto.subtle.sign("HMAC", await hmacKey(secret), payload(scope, timestamp, nonce, body));
+	return {
+		timestamp,
+		nonce,
+		signature: base64url(new Uint8Array(mac))
+	};
+}
+async function verify(secret, scope, body, headers, now = Date.now()) {
+	const timestamp = Number(headers.timestamp);
+	if (!Number.isFinite(timestamp) || Math.abs(now - timestamp) > 3e5) return "stale";
+	const mac = fromBase64url(headers.signature);
+	if (!mac) return "invalid";
+	return await crypto.subtle.verify("HMAC", await hmacKey(secret), mac, payload(scope, headers.timestamp, headers.nonce, body)) ? null : "invalid";
+}
+function fromBase64url(value) {
+	try {
+		const binary = atob(value.replaceAll("-", "+").replaceAll("_", "/"));
+		return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+	} catch {
+		return null;
+	}
+}
+var NonceWindow = class {
+	ttl;
+	#seen = /* @__PURE__ */ new Map();
+	constructor(ttl = SIGNATURE_TOLERANCE_MS * 2) {
+		this.ttl = ttl;
+	}
+	claim(nonce, now = Date.now()) {
+		if (this.#seen.size > 1e4) this.#sweep(now);
+		const seenAt = this.#seen.get(nonce);
+		if (seenAt !== void 0 && now - seenAt < this.ttl) return false;
+		this.#seen.set(nonce, now);
+		return true;
+	}
+	#sweep(now) {
+		for (const [nonce, at] of this.#seen) if (now - at >= this.ttl) this.#seen.delete(nonce);
+	}
+};
+//#endregion
+//#region ../protocol/src/wire.ts
+function refKey(ref) {
+	return `${ref.resource}:${ref.id}`;
+}
+const HEADER = {
+	environment: "pult-environment",
+	timestamp: "pult-timestamp",
+	nonce: "pult-nonce",
+	signature: "pult-signature"
+};
+//#endregion
+//#region src/define/source.ts
+const KIND = Symbol.for("pult.kind");
+const FRAME = /\(?((?:file:\/\/)?[^()\s]+?):(\d+):\d+\)?\s*$/;
+const RUNTIME = /^node:|[\\/]jiti[\\/]/;
+const UNKNOWN = {
+	file: "",
+	line: 0
+};
+function captureOrigin() {
+	const [own, ...callers] = ((/* @__PURE__ */ new Error()).stack?.split("\n").slice(1) ?? []).flatMap(parseFrame);
+	if (!own) return UNKNOWN;
+	const sdk = own.file.replace(/[^\\/]*$/, "");
+	return callers.find(({ file }) => !file.startsWith(sdk) && !RUNTIME.test(file)) ?? UNKNOWN;
+}
+function parseFrame(frame) {
+	const match = FRAME.exec(frame);
+	return match ? [{
+		file: match[1].replace(/^file:\/\//, ""),
+		line: Number(match[2])
+	}] : [];
+}
+function kindOf(value) {
+	return value && typeof value === "object" && KIND in value ? value[KIND] : null;
+}
+//#endregion
+//#region src/define/page.ts
+function view(name, options) {
+	return {
+		[KIND]: "view",
+		origin: captureOrigin(),
+		name,
+		options
+	};
+}
+function page(name, options) {
+	return {
+		[KIND]: "page",
+		origin: captureOrigin(),
+		name,
+		options
+	};
+}
+function home(options) {
+	const resolved = Array.isArray(options) || typeof options === "function" ? { render: options } : options;
+	return {
+		[KIND]: "page",
+		origin: captureOrigin(),
+		name: HOME,
+		options: {
+			label: "Home",
+			...resolved
+		}
+	};
+}
+function normalizeFilter(filter = {}) {
+	const { state, ...rest } = filter;
+	return {
+		...rest,
+		...state ? { state: [state].flat() } : {}
+	};
+}
+//#endregion
+//#region src/blocks.ts
+function field(value) {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : { date: value.toISOString() };
+	return value ?? null;
+}
+function fieldValues(fields) {
+	return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0).map(([key, value]) => [key, field(value)]));
+}
+function fieldList(fields) {
+	return Object.entries(fields).filter(([, value]) => value !== void 0).map(([label, value]) => ({
+		label,
+		value: field(value)
+	}));
+}
+function ref(resource, id, title) {
+	return {
+		resource: typeof resource === "string" ? resource : resource.name,
+		id,
+		...title ? { title } : {}
+	};
+}
+function chart(source, options = {}) {
+	const range = options.range ?? "24h";
+	if (source === "occurrences") return {
+		type: "chart",
+		metric: source,
+		range,
+		title: options.title
+	};
+	if (kindOf(source) === "inbox") {
+		const inbox = source;
+		return {
+			type: "chart",
+			inbox: inbox.name,
+			range,
+			title: options.title ?? inbox.options.label
+		};
+	}
+	return {
+		type: "chart",
+		points: source.map(({ at, value }) => ({
+			at: +at,
+			value
+		})),
+		title: options.title
+	};
+}
+function listing(target, filter) {
+	if (kindOf(target) === "view") {
+		const view = target;
+		return {
+			inbox: view.options.inbox.name,
+			filter: normalizeFilter({
+				...view.options.filter,
+				...filter
+			}),
+			sort: view.options.sort ?? "-lastSeen",
+			view: view.name,
+			label: view.options.label ?? view.name
+		};
+	}
+	const inbox = target;
+	return {
+		inbox: inbox.name,
+		filter: normalizeFilter(filter),
+		sort: "-lastSeen",
+		view: null,
+		label: inbox.options.label ?? inbox.name
+	};
+}
+const actionId = (action) => typeof action === "string" ? action : action.id;
+function button(input) {
+	if (typeof input === "object" && "action" in input) return {
+		action: actionId(input.action),
+		record: input.record ?? null,
+		...input.input && { input: JSON.parse(JSON.stringify(input.input)) },
+		...input.label && { label: input.label }
+	};
+	return {
+		action: actionId(input),
+		record: null
+	};
+}
+function bindActions(blocks, resource, record) {
+	if (!resource) return blocks;
+	const own = (action) => !action.includes(".") && kindOf(resource.actions[action]) === "action";
+	const bind = (target) => own(target.action) ? {
+		...target,
+		action: `${resource.name}.${target.action}`,
+		record: target.record ?? record
+	} : target;
+	const value = (field) => field && typeof field === "object" && "edit" in field ? { edit: bind(field.edit) } : field;
+	return mapBlocks(blocks, (block) => {
+		if (block.type === "actions") return {
+			...block,
+			actions: block.actions.map(bind)
+		};
+		if (block.type === "form") return {
+			...block,
+			form: bind(block.form)
+		};
+		if (block.type === "fields") return {
+			...block,
+			fields: block.fields.map((entry) => ({
+				...entry,
+				value: value(entry.value)
+			}))
+		};
+		if (block.type === "stats") return {
+			...block,
+			stats: block.stats.map((stat) => ({
+				...stat,
+				value: value(stat.value)
+			}))
+		};
+		if (block.type === "table") return {
+			...block,
+			rows: block.rows.map((row) => row.map(value))
+		};
+		return block;
+	});
+}
+const b = {
+	markdown: (text) => ({
+		type: "markdown",
+		text
+	}),
+	fields: (fields) => ({
+		type: "fields",
+		fields: fieldList(fields)
+	}),
+	code: (code, options = {}) => ({
+		type: "code",
+		code,
+		...options
+	}),
+	chart,
+	attachment: (attachment) => ({
+		type: "attachment",
+		...attachment
+	}),
+	record: (resource, id, title) => ({
+		type: "record",
+		ref: ref(resource, id, title)
+	}),
+	ref: (resource, id, title) => ({ record: ref(resource, id, title) }),
+	sensitive: (value, options = {}) => ({ sensitive: {
+		value: String(value),
+		...options
+	} }),
+	timeline: (entries) => ({
+		type: "timeline",
+		entries: entries.map(({ at, text }) => ({
+			at: +at,
+			text
+		}))
+	}),
+	table: (rows, columns = Object.keys(rows[0] ?? {})) => ({
+		type: "table",
+		columns,
+		rows: rows.map((row) => columns.map((column) => field(row[column])))
+	}),
+	stats: (stats) => ({
+		type: "stats",
+		stats: Object.entries(stats).filter(([, stat]) => stat !== void 0).map(([label, stat]) => stat && typeof stat === "object" && "value" in stat && !(stat instanceof Date) ? {
+			label,
+			value: field(stat.value),
+			...stat.note && { note: stat.note }
+		} : {
+			label,
+			value: field(stat)
+		})
+	}),
+	actions: (...buttons) => ({
+		type: "actions",
+		actions: buttons.map(button)
+	}),
+	form: (action) => ({
+		type: "form",
+		form: button(action)
+	}),
+	columns: (...columns) => ({
+		type: "columns",
+		columns
+	}),
+	count: (target, options = {}) => {
+		const { inbox, filter, view, label } = listing(target, options.filter);
+		return {
+			type: "count",
+			inbox,
+			filter,
+			view,
+			label: options.label ?? label
+		};
+	},
+	items: (target, options = {}) => ({
+		type: "items",
+		...listing(target, options.filter),
+		...options.label && { label: options.label },
+		limit: options.limit ?? 5
+	}),
+	flag: (flag) => ({
+		type: "flag",
+		flag: flag.name
+	}),
+	edit: (value, action, options = {}) => ({ edit: {
+		value: field(value),
+		action: actionId(action),
+		record: options.record ?? null,
+		field: options.field ?? null
+	} })
+};
+function isPendingAttachment(block) {
+	return block.type === "attachment" && "data" in block;
+}
+//#endregion
+//#region src/client/transport.ts
+const DEFAULT_URL = "https://app.pult.sh";
+const UPLOAD_REUSE_MS = 36e5;
+var PultError = class extends Error {
+	status;
+	code;
+	constructor(message, status, code) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "PultError";
+	}
+};
+var Transport = class {
+	send;
+	key;
+	url;
+	#uploads = /* @__PURE__ */ new Map();
+	constructor(key, url, send) {
+		this.send = send;
+		this.key = parseKey(key);
+		this.url = url.replace(/\/$/, "");
+	}
+	async request(method, path, body) {
+		const payload = body === void 0 ? "" : JSON.stringify(body);
+		return this.#fetch(method, path, payload, payload, "application/json");
+	}
+	async upload(name, contentType, data) {
+		const bytes = new Uint8Array(data instanceof Blob ? await data.arrayBuffer() : data);
+		const hex = await sha256(bytes);
+		const id = `${hex}:${name}:${contentType}`;
+		const now = Date.now();
+		const recent = this.#uploads.get(id);
+		if (recent && now - recent.at < UPLOAD_REUSE_MS) return recent.key;
+		for (const [other, { at }] of this.#uploads) {
+			if (now - at < UPLOAD_REUSE_MS) break;
+			this.#uploads.delete(other);
+		}
+		const key = this.#fetch("POST", `/v1/attachments?name=${encodeURIComponent(name)}`, bytes, hex, contentType);
+		this.#uploads.delete(id);
+		this.#uploads.set(id, {
+			key,
+			at: now
+		});
+		key.catch(() => this.#uploads.delete(id));
+		return key;
+	}
+	async #fetch(method, path, body, signed, contentType) {
+		const signature = await sign(this.key.secret, `${method} ${path}`, signed);
+		const response = await this.send(`${this.url}${path}`, {
+			method,
+			body: method === "GET" ? void 0 : body,
+			headers: {
+				"content-type": contentType,
+				[HEADER.environment]: this.key.environment,
+				[HEADER.timestamp]: signature.timestamp,
+				[HEADER.nonce]: signature.nonce,
+				[HEADER.signature]: signature.signature
+			}
+		});
+		const json = await response.json().catch(() => null);
+		if (!response.ok) throw new PultError(json?.error ?? response.statusText, response.status, json?.code);
+		return json;
+	}
+};
+//#endregion
+//#region src/define/flag.ts
+function flag(name, options = {}) {
+	return {
+		[KIND]: "flag",
+		origin: captureOrigin(),
+		name,
+		options: {
+			...options,
+			default: options.default ?? (options.value ? void 0 : false)
+		}
+	};
+}
+function guards(flag) {
+	return [flag.options.guard ?? []].flat();
+}
+//#endregion
+//#region src/define/collect.ts
+function collect(modules) {
+	const found = {
+		resources: /* @__PURE__ */ new Map(),
+		actions: /* @__PURE__ */ new Map(),
+		inboxes: /* @__PURE__ */ new Map(),
+		roles: /* @__PURE__ */ new Map(),
+		views: /* @__PURE__ */ new Map(),
+		pages: /* @__PURE__ */ new Map(),
+		flags: /* @__PURE__ */ new Map(),
+		notify: /* @__PURE__ */ new Map(),
+		status: null,
+		config: null
+	};
+	const claim = (map, value, kind) => {
+		const existing = map.get(value.name);
+		if (existing && existing !== value) throw new Error(`Two ${kind} are named "${value.name}"`);
+		map.set(value.name, value);
+	};
+	const add = (value) => {
+		switch (kindOf(value)) {
+			case "resource": {
+				const resource = value;
+				return claim(found.resources, resource, "resources");
+			}
+			case "action": {
+				const action = value;
+				if (action.resource === null) claim(found.actions, action, "actions");
+				return;
+			}
+			case "inbox": {
+				const inbox = value;
+				claim(found.inboxes, inbox, "inboxes");
+				if (inbox.options.resource) add(inbox.options.resource);
+				return;
+			}
+			case "role": {
+				const role = value;
+				claim(found.roles, role, "roles");
+				for (const inbox of role.options.inboxes ?? []) add(inbox);
+				for (const resource of role.options.resources ?? []) add(resource);
+				for (const action of role.options.actions ?? []) add(action);
+				for (const page of role.options.pages ?? []) add(page);
+				for (const flag of role.options.flags ?? []) add(flag);
+				return;
+			}
+			case "view": {
+				const view = value;
+				claim(found.views, view, "views");
+				add(view.options.inbox);
+				return;
+			}
+			case "page": {
+				const page = value;
+				return claim(found.pages, page, "pages");
+			}
+			case "flag": {
+				const flag = value;
+				claim(found.flags, flag, "flags");
+				if (flag.options.target) add(flag.options.target);
+				for (const guard of guards(flag)) add(guard.inbox);
+				return;
+			}
+			case "notify": {
+				const rule = value;
+				claim(found.notify, rule, "notifications");
+				for (const inbox of rule.options.inboxes) add(inbox);
+				for (const recipient of rule.options.to) add(recipient);
+				return;
+			}
+			case "status": {
+				const page = value;
+				if (found.status && found.status !== page) throw new Error("A project has one status page, and this one defines two");
+				found.status = page;
+				for (const recipient of page.options.alert ?? []) add(recipient);
+				return;
+			}
+			case "config": found.config = value;
+		}
+	};
+	for (const exports of modules) for (const value of Object.values(exports)) add(value);
+	return found;
+}
+function findAction(definitions, id) {
+	const { resource, name } = splitAction(id);
+	const action = resource === null ? definitions.actions.get(name) : definitions.resources.get(resource)?.actions[name];
+	return action && kindOf(action) === "action" ? action : null;
+}
+//#endregion
+//#region src/schema.ts
+const libraryOptions = { zod: {
+	unrepresentable: "any",
+	override: ({ zodSchema, jsonSchema }) => {
+		if (zodSchema._zod.def.type === "date") Object.assign(jsonSchema, {
+			type: "string",
+			format: "date-time"
+		});
+	}
+} };
+function toJsonSchema(schema) {
+	const standard = schema["~standard"];
+	if (!standard.jsonSchema) throw new Error(`Schemas from "${schema["~standard"].vendor}" can't describe themselves as JSON Schema. Use a library that implements Standard JSON Schema, such as zod, valibot or arktype.`);
+	const { $schema: _, ...json } = standard.jsonSchema.input({
+		target: "draft-2020-12",
+		libraryOptions: libraryOptions[standard.vendor]
+	});
+	return json;
+}
+var ValidationError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues.map(describeIssue).join("; "));
+		this.issues = issues;
+		this.name = "ValidationError";
+	}
+};
+function describeIssue(issue) {
+	const path = issue.path?.map((segment) => typeof segment === "object" ? segment.key : segment).join(".");
+	return path ? `${path}: ${issue.message}` : issue.message;
+}
+async function validate(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues) throw new ValidationError(result.issues);
+	return result.value;
+}
+function reviveDates(schema, value) {
+	if (!schema || value === null || value === void 0) return value;
+	if (schema.format === "date-time" && typeof value === "string") return new Date(value);
+	for (const branch of schema.anyOf ?? schema.oneOf ?? []) {
+		const revived = reviveDates(branch, value);
+		if (revived !== value) return revived;
+	}
+	if (Array.isArray(value) && schema.items) return value.map((entry) => reviveDates(schema.items, entry));
+	if (typeof value === "object" && schema.properties) {
+		const out = { ...value };
+		for (const [key, property] of Object.entries(schema.properties)) if (key in out) out[key] = reviveDates(property, out[key]);
+		return out;
+	}
+	return value;
+}
+//#endregion
+export { mapBlocks as A, HEADER as C, sign as D, parseKey as E, FLAG_ACTION as M, HOME as N, verify as O, findActionDef as P, kindOf as S, NonceWindow as T, normalizeFilter as _, collect as a, KIND as b, guards as c, Transport as d, b as f, home as g, isPendingAttachment as h, validate as i, DEFAULT_STATES as j, eachBlock as k, DEFAULT_URL as l, fieldValues as m, reviveDates as n, findAction as o, bindActions as p, toJsonSchema as r, flag as s, ValidationError as t, PultError as u, page as v, refKey as w, captureOrigin as x, view as y };

package/stub.d.mts

@@ -0,0 +1,11 @@
+//#region src/build/stub.d.ts
+export declare const env: never;
+export declare const exports: never;
+export declare class WorkerEntrypoint {}
+export declare class DurableObject {}
+export declare class WorkflowEntrypoint {}
+export declare class RpcTarget {}
+export declare class EmailMessage {}
+export declare function waitUntil(): void;
+export declare function connect(): never;
+//#endregion

package/stub.mjs

@@ -0,0 +1,26 @@
+//#region src/build/stub.ts
+const building = (what) => /* @__PURE__ */ new Error(`${what} isn't available while pult builds your definitions. Use it inside a function instead.`);
+function unavailable(path) {
+	return new Proxy(class {}, {
+		get: (_, name) => typeof name === "symbol" || name === "then" ? void 0 : unavailable(`${path}.${name}`),
+		apply: () => {
+			throw building(path);
+		},
+		construct: () => {
+			throw building(path);
+		}
+	});
+}
+const env = unavailable("env");
+const exports = unavailable("exports");
+var WorkerEntrypoint = class {};
+var DurableObject = class {};
+var WorkflowEntrypoint = class {};
+var RpcTarget = class {};
+var EmailMessage = class {};
+function waitUntil() {}
+function connect() {
+	throw building("A socket");
+}
+//#endregion
+export { DurableObject, EmailMessage, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, connect, env, exports, waitUntil };