@gonvex/cli 0.5.2-staging.2 → 0.5.2-staging.20

package/dist/templates/vite-react/gonvex/_build/module.js

@@ -1,572 +0,0 @@
-//#region ../../packages/module-sdk/dist/index.js
-const freeze = (value) => Object.freeze(value);
-/** Constructors for the language-neutral schema subset. */
-const schema = {
-	string(options = {}) {
-		return freeze({
-			kind: "string",
-			...options
-		});
-	},
-	email() {
-		return freeze({
-			kind: "string",
-			format: "email"
-		});
-	},
-	uri() {
-		return freeze({
-			kind: "string",
-			format: "uri"
-		});
-	},
-	uuid() {
-		return freeze({
-			kind: "string",
-			format: "uuid"
-		});
-	},
-	datetime() {
-		return freeze({
-			kind: "string",
-			format: "datetime"
-		});
-	},
-	number(options = {}) {
-		return freeze({
-			kind: "number",
-			...options
-		});
-	},
-	integer(options = {}) {
-		return freeze({
-			kind: "number",
-			integer: true,
-			...options
-		});
-	},
-	boolean() {
-		return freeze({ kind: "boolean" });
-	},
-	null() {
-		return freeze({ kind: "null" });
-	},
-	any() {
-		return freeze({ kind: "any" });
-	},
-	id(entity) {
-		if (!entity.trim()) throw new Error("schema.id requires an entity name");
-		return freeze({
-			kind: "id",
-			entity
-		});
-	},
-	literal(value) {
-		return freeze({
-			kind: "literal",
-			value
-		});
-	},
-	array(items) {
-		return freeze({
-			kind: "array",
-			items
-		});
-	},
-	object(fields, options = {}) {
-		return freeze({
-			kind: "object",
-			fields: freeze({ ...fields }),
-			...options
-		});
-	},
-	record(values) {
-		return freeze({
-			kind: "record",
-			values
-		});
-	},
-	optional(value) {
-		return freeze({
-			kind: "optional",
-			value
-		});
-	}
-};
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const validateOfflinePolicy = (value, path) => {
-	if (!isRecord(value) || value.mode !== "forbidden" && value.mode !== "allowed" && value.mode !== "onlineOnly") throw new Error(`reducer ${path} must declare a valid offline policy`);
-	if (value.mode === "onlineOnly" && (typeof value.reason !== "string" || !value.reason.trim())) throw new Error(`reducer ${path} onlineOnly policy requires a reason`);
-	if (value.mode === "allowed" && value.conflict !== void 0 && value.conflict !== "reject" && value.conflict !== "expectedVersion" && value.conflict !== "merge") throw new Error(`reducer ${path} has an invalid offline conflict policy`);
-};
-const validateOptimisticTransaction = (value, path) => {
-	if (!isRecord(value) || !Array.isArray(value.effects) || value.effects.length === 0) throw new Error(`reducer ${path} optimistic metadata must contain a non-empty effects array`);
-	if (value.expectedRevision !== void 0 && (typeof value.expectedRevision !== "number" || !Number.isSafeInteger(value.expectedRevision) || value.expectedRevision < 0)) throw new Error(`reducer ${path} optimistic expectedRevision must be a non-negative integer`);
-	for (const effect of value.effects) {
-		if (!isRecord(effect) || effect.operation !== "patch" && effect.operation !== "upsert" && effect.operation !== "delete") throw new Error(`reducer ${path} has an invalid optimistic effect`);
-		if (typeof effect.entity !== "string" || !effect.entity.trim()) throw new Error(`reducer ${path} optimistic effects require an entity`);
-		if (typeof effect.id === "string" && !effect.id.trim() || typeof effect.id !== "string" && (!Array.isArray(effect.id) || effect.id.length === 0 || effect.id.some((part) => typeof part !== "string" || !part.trim()))) throw new Error(`reducer ${path} optimistic effects require a string id or id references`);
-		if ((effect.operation === "patch" || effect.operation === "upsert") && !isRecord(effect.operation === "patch" ? effect.fields : effect.value)) throw new Error(`reducer ${path} optimistic ${effect.operation} effects require an object value`);
-	}
-};
-const validateReplicaCollection = (value, path) => {
-	if (!isRecord(value) || typeof value.table !== "string" || !value.table.trim() || typeof value.key !== "string" || !value.key.trim() || !Array.isArray(value.columns) || value.columns.some((column) => typeof column !== "string" || !column.trim())) throw new Error(`replica collection ${path} requires a table, key, and columns`);
-	for (const field of [
-		"maxRows",
-		"maxBytes",
-		"retentionMs"
-	]) {
-		const budget = value[field];
-		if (budget !== void 0 && (typeof budget !== "number" || !Number.isSafeInteger(budget) || budget <= 0)) throw new Error(`replica collection ${path} ${field} must be a positive integer`);
-	}
-	if (value.mode !== void 0 && value.mode !== "eager" && value.mode !== "progressive") throw new Error(`replica collection ${path} has an invalid completeness mode`);
-	if (value.orderDirection !== void 0 && value.orderDirection !== "asc" && value.orderDirection !== "desc") throw new Error(`replica collection ${path} has an invalid order direction`);
-};
-const validateActionCapabilities = (profile, value, path) => {
-	if (value === void 0) return;
-	if (!isRecord(value)) throw new Error(`action ${path} capabilities must be an object`);
-	const allowed = /* @__PURE__ */ new Set([
-		"networkOrigins",
-		"secrets",
-		"tools",
-		"scheduler",
-		"storage",
-		"sandbox",
-		"functions"
-	]);
-	for (const field of Object.keys(value)) if (!allowed.has(field)) throw new Error(`action ${path} capabilities has unsupported field ${field}`);
-	if (value.networkOrigins !== void 0) {
-		if (!Array.isArray(value.networkOrigins) || value.networkOrigins.length === 0) throw new Error(`action ${path} networkOrigins must be a non-empty array`);
-		const seen = /* @__PURE__ */ new Set();
-		for (const origin of value.networkOrigins) {
-			if (typeof origin !== "string") throw new Error(`action ${path} networkOrigins must contain strings`);
-			let parsed;
-			try {
-				parsed = new URL(origin);
-			} catch {
-				throw new Error(`action ${path} network origin ${JSON.stringify(origin)} is invalid`);
-			}
-			if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.origin !== origin || parsed.username || parsed.password) throw new Error(`action ${path} network origin ${JSON.stringify(origin)} must be an exact HTTP(S) origin`);
-			if (seen.has(origin)) throw new Error(`action ${path} declares duplicate network origin ${origin}`);
-			seen.add(origin);
-		}
-	}
-	if (value.secrets !== void 0) {
-		if (!Array.isArray(value.secrets) || value.secrets.some((name) => typeof name !== "string" || !/^[A-Z][A-Z0-9_]*$/.test(name))) throw new Error(`action ${path} secrets must be uppercase environment names`);
-	}
-	if (value.tools !== void 0) {
-		if (profile !== "agent") throw new Error(`action ${path} tools require profile "agent"`);
-		if (!isRecord(value.tools) || Object.keys(value.tools).length === 0) throw new Error(`agent action ${path} tools must be a non-empty object`);
-		for (const [name, binding] of Object.entries(value.tools)) if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) || !isRecord(binding) || binding.kind !== "query" && binding.kind !== "reducer" || typeof binding.function !== "string" || !binding.function.trim()) throw new Error(`agent action ${path} has an invalid tool binding ${JSON.stringify(name)}`);
-	}
-	if (value.scheduler !== void 0 && value.scheduler !== true) throw new Error(`action ${path} scheduler must be true when declared`);
-	if (value.storage !== void 0 && value.storage !== true) throw new Error(`action ${path} storage must be true when declared`);
-	if (value.functions !== void 0) {
-		if (profile !== "agent") throw new Error(`action ${path} functions require profile "agent"`);
-		if (value.functions !== true) throw new Error(`action ${path} functions must be true when declared`);
-	}
-	if (value.sandbox !== void 0) {
-		if (profile !== "agent") throw new Error(`action ${path} sandbox requires profile "agent"`);
-		if (!isRecord(value.sandbox)) throw new Error(`action ${path} sandbox must be an object`);
-		for (const field of Object.keys(value.sandbox)) if (field !== "duckdb") throw new Error(`action ${path} sandbox has unsupported field ${field}`);
-		if (value.sandbox.duckdb !== void 0 && value.sandbox.duckdb !== true) throw new Error(`action ${path} sandbox.duckdb must be true when declared`);
-	}
-};
-const validateStructuredQueryPlan = (value, path) => {
-	if (!isRecord(value) || typeof value.table !== "string" || !value.table.trim() || typeof value.key !== "string" || !value.key.trim() || !Array.isArray(value.columns) || value.columns.length === 0 || value.columns.some((column) => typeof column !== "string" || !column.trim())) throw new Error(`one-shot query ${path} requires a structured live query plan with a table, key, and columns`);
-	if (!value.columns.includes(value.key)) throw new Error(`one-shot query ${path} live query plan columns must include its key`);
-	if (value.filters !== void 0) {
-		if (!isRecord(value.filters) || typeof value.filters.argument !== "string" || !value.filters.argument.trim() || !Array.isArray(value.filters.allowedColumns) || value.filters.allowedColumns.length === 0 || value.filters.allowedColumns.some((column) => typeof column !== "string" || !column.trim()) || !Array.isArray(value.filters.allowedOperators) || value.filters.allowedOperators.length === 0) throw new Error(`structured query plan ${path} filters must declare an argument, allowed columns, and allowed operators`);
-		const operators = /* @__PURE__ */ new Set([
-			"contains",
-			"notContains",
-			"equals",
-			"notEquals",
-			"startsWith",
-			"endsWith",
-			"empty",
-			"notEmpty",
-			"oneOf",
-			"lessThan",
-			"lessThanOrEqual",
-			"greaterThan",
-			"greaterThanOrEqual",
-			"inRange"
-		]);
-		if (value.filters.allowedOperators.some((operator) => typeof operator !== "string" || !operators.has(operator))) throw new Error(`structured query plan ${path} filters contains an unsupported operator`);
-	}
-};
-const visibilityOperators = /* @__PURE__ */ new Set([
-	"public",
-	"permission",
-	"role",
-	"eqContext",
-	"inSet",
-	"and",
-	"or",
-	"not"
-]);
-const visibilityContexts = /* @__PURE__ */ new Set([
-	"account.id",
-	"member.id",
-	"tenant.id"
-]);
-const validateExactObject = (value, path, fields) => {
-	if (!isRecord(value)) throw new Error(`${path} must be an object`);
-	const allowed = new Set(fields);
-	const unexpected = Object.keys(value).find((field) => !allowed.has(field));
-	if (unexpected !== void 0) throw new Error(`${path} has unsupported field ${unexpected}`);
-};
-const requireVisibilityString = (value, path) => {
-	if (typeof value !== "string" || !value.trim()) throw new Error(`${path} must be a non-empty string`);
-	return value;
-};
-const validateVisibilityContext = (value, path) => {
-	if (typeof value !== "string" || !visibilityContexts.has(value)) throw new Error(`${path} must be account.id, member.id, or tenant.id`);
-	return value;
-};
-const validateVisibilityExpression = (value, path, sets, ancestors = /* @__PURE__ */ new Set()) => {
-	validateExactObject(value, path, [
-		"operator",
-		"column",
-		"context",
-		"set",
-		"value",
-		"children"
-	]);
-	if (ancestors.has(value)) throw new Error(`${path} contains a cycle`);
-	const operator = value.operator;
-	if (typeof operator !== "string" || !visibilityOperators.has(operator)) throw new Error(`${path}.operator is unsupported`);
-	const nested = new Set(ancestors);
-	nested.add(value);
-	switch (operator) {
-		case "public":
-			validateExactObject(value, path, ["operator"]);
-			return;
-		case "permission":
-		case "role":
-			validateExactObject(value, path, ["operator", "value"]);
-			requireVisibilityString(value.value, `${path}.value`);
-			return;
-		case "eqContext":
-			validateExactObject(value, path, [
-				"operator",
-				"column",
-				"context"
-			]);
-			requireVisibilityString(value.column, `${path}.column`);
-			validateVisibilityContext(value.context, `${path}.context`);
-			return;
-		case "inSet": {
-			validateExactObject(value, path, [
-				"operator",
-				"column",
-				"set"
-			]);
-			requireVisibilityString(value.column, `${path}.column`);
-			const set = requireVisibilityString(value.set, `${path}.set`);
-			if (!Object.prototype.hasOwnProperty.call(sets, set)) throw new Error(`${path}.set references unknown visibility set ${set}`);
-			return;
-		}
-		case "and":
-		case "or":
-			validateExactObject(value, path, ["operator", "children"]);
-			if (!Array.isArray(value.children) || value.children.length === 0) throw new Error(`${path}.${operator} requires children`);
-			value.children.forEach((child, index) => validateVisibilityExpression(child, `${path}.children[${index}]`, sets, nested));
-			return;
-		case "not":
-			validateExactObject(value, path, ["operator", "children"]);
-			if (!Array.isArray(value.children) || value.children.length !== 1) throw new Error(`${path}.not requires exactly one child`);
-			validateVisibilityExpression(value.children[0], `${path}.children[0]`, sets, nested);
-			return;
-	}
-};
-const validateVisibilityPlan = (value, path) => {
-	validateExactObject(value, path, [
-		"table",
-		"key",
-		"sets",
-		"where"
-	]);
-	requireVisibilityString(value.table, `${path}.table`);
-	requireVisibilityString(value.key, `${path}.key`);
-	if (!isRecord(value.sets)) throw new Error(`${path}.sets must be an object`);
-	for (const [name, candidate] of Object.entries(value.sets)) {
-		requireVisibilityString(name, `${path}.sets key`);
-		const setPath = `${path}.sets.${name}`;
-		validateExactObject(candidate, setPath, [
-			"table",
-			"alias",
-			"select",
-			"selectFrom",
-			"joins",
-			"where"
-		]);
-		requireVisibilityString(candidate.table, `${setPath}.table`);
-		if (candidate.alias !== void 0) requireVisibilityString(candidate.alias, `${setPath}.alias`);
-		requireVisibilityString(candidate.select, `${setPath}.select`);
-		if (candidate.selectFrom !== void 0) requireVisibilityString(candidate.selectFrom, `${setPath}.selectFrom`);
-		if (!Array.isArray(candidate.joins)) throw new Error(`${setPath}.joins must be an array`);
-		const joins = candidate.joins;
-		joins.forEach((join, index) => {
-			const joinPath = `${setPath}.joins[${index}]`;
-			validateExactObject(join, joinPath, [
-				"table",
-				"alias",
-				"leftAlias",
-				"leftColumn",
-				"rightColumn"
-			]);
-			requireVisibilityString(join.table, `${joinPath}.table`);
-			if (join.alias !== void 0) requireVisibilityString(join.alias, `${joinPath}.alias`);
-			if (join.leftAlias !== void 0) requireVisibilityString(join.leftAlias, `${joinPath}.leftAlias`);
-			requireVisibilityString(join.leftColumn, `${joinPath}.leftColumn`);
-			requireVisibilityString(join.rightColumn, `${joinPath}.rightColumn`);
-		});
-		const occurrences = [{
-			table: candidate.table,
-			alias: candidate.alias ?? candidate.table,
-			explicit: candidate.alias !== void 0
-		}, ...joins.map((join) => ({
-			table: join.table,
-			alias: join.alias ?? join.table,
-			explicit: join.alias !== void 0
-		}))];
-		const aliases = /* @__PURE__ */ new Set();
-		const tableCounts = /* @__PURE__ */ new Map();
-		for (const occurrence of occurrences) tableCounts.set(occurrence.table, (tableCounts.get(occurrence.table) ?? 0) + 1);
-		occurrences.forEach((occurrence, index) => {
-			if ((tableCounts.get(occurrence.table) ?? 0) > 1 && !occurrence.explicit) throw new Error(`${setPath} repeats table ${occurrence.table}; every occurrence requires an explicit alias`);
-			if (aliases.has(occurrence.alias)) throw new Error(`${setPath} repeats logical alias ${occurrence.alias}`);
-			if (index > 0) {
-				const leftAlias = joins[index - 1].leftAlias;
-				if (leftAlias !== void 0 && !aliases.has(leftAlias)) throw new Error(`${setPath}.joins[${index - 1}].leftAlias must reference an earlier occurrence`);
-			}
-			aliases.add(occurrence.alias);
-		});
-		const selectFrom = candidate.selectFrom ?? occurrences[0].alias;
-		if (!aliases.has(selectFrom)) throw new Error(`${setPath}.selectFrom references unknown alias ${selectFrom}`);
-		if (!Array.isArray(candidate.where)) throw new Error(`${setPath}.where must be an array`);
-		candidate.where.forEach((constraint, index) => {
-			const constraintPath = `${setPath}.where[${index}]`;
-			validateExactObject(constraint, constraintPath, [
-				"table",
-				"column",
-				"context"
-			]);
-			requireVisibilityString(constraint.table, `${constraintPath}.table`);
-			if (!aliases.has(constraint.table)) throw new Error(`${constraintPath}.table references unknown alias ${constraint.table}`);
-			requireVisibilityString(constraint.column, `${constraintPath}.column`);
-			validateVisibilityContext(constraint.context, `${constraintPath}.context`);
-		});
-	}
-	validateVisibilityExpression(value.where, `${path}.where`, value.sets);
-};
-const freezeVisibilityExpression = (expression) => freeze({
-	...expression,
-	children: expression.children === void 0 ? void 0 : freeze(expression.children.map(freezeVisibilityExpression))
-});
-const freezeVisibilityPlan = (plan) => {
-	const sets = {};
-	for (const name of Object.keys(plan.sets).sort()) {
-		const set = plan.sets[name];
-		sets[name] = freeze({
-			...set,
-			joins: freeze(set.joins.map((join) => freeze({ ...join }))),
-			where: freeze(set.where.map((constraint) => freeze({ ...constraint })))
-		});
-	}
-	return freeze({
-		...plan,
-		sets: freeze(sets),
-		where: freezeVisibilityExpression(plan.where)
-	});
-};
-/** Declare and validate one source table's language-neutral visibility plan. */
-function visibility(options) {
-	validateVisibilityPlan(options, "visibility");
-	return freezeVisibilityPlan(options);
-}
-const executableOptions = (options) => freeze({ ...options });
-const queryDefinition = (options, deliveryOverride) => {
-	const liveQueryPlan = options.liveQueryPlan;
-	const replica = options.replica;
-	const delivery = deliveryOverride ?? options.delivery ?? "oneShot";
-	if (delivery === "live" && !liveQueryPlan) throw new Error("live query requires a live query plan");
-	if (delivery === "oneShot") {
-		if (!liveQueryPlan) throw new Error("one-shot query requires a structured live query plan");
-		validateStructuredQueryPlan(liveQueryPlan, "<export>");
-	}
-	if (delivery === "replica") {
-		if (!replica) throw new Error("replica collection requires a replica definition");
-		validateReplicaCollection(replica, "<export>");
-	}
-	return freeze({
-		kind: "query",
-		internal: options.internal,
-		delivery,
-		liveQueryPlan,
-		replica,
-		options: executableOptions(options),
-		handler: options.run
-	});
-};
-/** Declare an executable one-shot, live, or replica query export. */
-function query(options = {}) {
-	return queryDefinition(options);
-}
-/** Declare an executable live query export with a structured live plan. */
-function liveQuery(options = {}) {
-	return queryDefinition({
-		...options,
-		delivery: "live"
-	}, "live");
-}
-const reducerDefinition = (options, internal = false) => {
-	validateOfflinePolicy(options.offline, "<export>");
-	if (options.optimistic !== void 0) validateOptimisticTransaction(options.optimistic, "<export>");
-	if (options.interactive === false && options.optimistic !== void 0) throw new Error("non-interactive reducer <export> cannot declare optimistic metadata");
-	if (options.interactive !== false && options.optimistic === void 0 && !options.nonOptimisticReason?.trim()) throw new Error("interactive reducer <export> requires an optimistic transaction or nonOptimisticReason");
-	return freeze({
-		kind: "reducer",
-		internal: internal || options.internal,
-		options: executableOptions(options),
-		handler: options.run
-	});
-};
-/** Declare an executable public reducer export. */
-function reducer(options) {
-	return reducerDefinition(options);
-}
-/** Declare an executable action export. */
-function action(options = {}) {
-	validateActionCapabilities(options.profile ?? "standard", options.capabilities, options.name?.trim() || "<export>");
-	return freeze({
-		kind: "action",
-		options: executableOptions(options),
-		handler: options.run
-	});
-}
-//#endregion
-//#region gonvex/messages.ts
-const messagesVisibility = visibility({
-	table: "messages",
-	key: "id",
-	sets: {},
-	where: { operator: "public" }
-});
-const list = liveQuery({
-	args: schema.object({}),
-	result: schema.array(schema.object({
-		id: schema.id("messages"),
-		body: schema.string(),
-		author: schema.string(),
-		created_at: schema.datetime()
-	})),
-	liveQueryPlan: {
-		table: "messages",
-		key: "id",
-		columns: [
-			"id",
-			"body",
-			"author",
-			"created_at"
-		],
-		sort: {
-			defaultColumn: "created_at",
-			defaultDirection: "asc",
-			allowedColumns: ["created_at"]
-		}
-	},
-	run: async () => []
-});
-const get = query({
-	interactive: true,
-	description: "Read one visible message by ID.",
-	agent: {
-		tags: ["messages"],
-		confirmation: "none"
-	},
-	args: schema.object({ id: schema.id("messages") }),
-	result: schema.array(schema.object({
-		id: schema.id("messages"),
-		body: schema.string(),
-		author: schema.string(),
-		created_at: schema.datetime()
-	})),
-	liveQueryPlan: {
-		table: "messages",
-		key: "id",
-		columns: [
-			"id",
-			"body",
-			"author",
-			"created_at"
-		],
-		where: {
-			operator: "eq",
-			column: "id",
-			value: { argument: "id" }
-		}
-	},
-	run: async () => []
-});
-const send = reducer({
-	interactive: true,
-	description: "Send a message as the acting tenant member.",
-	agent: {
-		tags: ["messages"],
-		confirmation: "none"
-	},
-	args: schema.object({ body: schema.string() }),
-	result: schema.object({
-		id: schema.id("messages"),
-		body: schema.string(),
-		author: schema.string(),
-		created_at: schema.datetime()
-	}),
-	offline: {
-		mode: "onlineOnly",
-		reason: "server assigns the message id"
-	},
-	nonOptimisticReason: "server assigns the message id",
-	run: async ({ db, member }, args) => {
-		if (!member || member.status !== "active") throw new Error("active tenant membership required");
-		return db.insert("messages", {
-			id: crypto.randomUUID(),
-			body: args.body,
-			author: member.displayName ?? member.id
-		});
-	}
-});
-const echo = action({
-	interactive: true,
-	description: "Return the supplied message without changing durable state.",
-	agent: {
-		tags: ["messages"],
-		confirmation: "none"
-	},
-	args: schema.object({ message: schema.string() }),
-	result: schema.object({ message: schema.string() }),
-	run: async (_ctx, args) => args
-});
-/** Minimal reference for testing permission-equivalent delegated invocation. */
-const agentInvoke = action({
-	profile: "agent",
-	interactive: false,
-	description: "Invoke one function from the active interactive catalog.",
-	capabilities: { functions: true },
-	args: schema.object({
-		path: schema.string(),
-		args: schema.any(),
-		artifactHash: schema.string()
-	}),
-	result: schema.any(),
-	run: (ctx, args) => ctx.functions.invoke({
-		path: args.path,
-		args: args.args,
-		artifactHash: args.artifactHash
-	})
-});
-//#endregion
-export { agentInvoke, echo, get, list, messagesVisibility, send };