@gonvex/cli 0.4.1 → 0.5.1

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

@@ -122,6 +122,56 @@ const validateReplicaCollection = (value, path) => {
 	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`);
@@ -246,24 +296,56 @@ const validateVisibilityPlan = (value, path) => {
 		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`);
-		candidate.joins.forEach((join, index) => {
+		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}]`;
@@ -273,6 +355,7 @@ const validateVisibilityPlan = (value, path) => {
 				"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`);
 		});
@@ -320,6 +403,7 @@ const queryDefinition = (options, deliveryOverride) => {
 	}
 	return freeze({
 		kind: "query",
+		internal: options.internal,
 		delivery,
 		liveQueryPlan,
 		replica,
@@ -327,6 +411,10 @@ const queryDefinition = (options, deliveryOverride) => {
 		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({
@@ -350,6 +438,15 @@ const reducerDefinition = (options, internal = false) => {
 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({
@@ -383,7 +480,44 @@ const list = liveQuery({
 	},
 	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"),
@@ -396,12 +530,43 @@ const send = reducer({
 		reason: "server assigns the message id"
 	},
 	nonOptimisticReason: "server assigns the message id",
-	run: async ({ now }, args) => ({
-		id: "pending",
-		body: args.body,
-		author: "demo-user",
-		created_at: new Date(now).toISOString()
+	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 { list, messagesVisibility, send };
+export { agentInvoke, echo, get, list, messagesVisibility, send };

package/dist/templates/vite-react/gonvex/_generated/api.ts

@@ -1,6 +1,6 @@
 // Generated by gonvex dev. Do not edit.
 
-import type { LiveQueryPlan } from "@gonvex/client";
+import { control as gonvexControl, type LiveQueryPlan } from "@gonvex/client";
 
 export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
 export type FunctionKind = "query" | "reducer" | "action";
@@ -22,6 +22,27 @@ export type FunctionReference<Kind extends FunctionKind = FunctionKind, Args = J
   readonly optimistic?: { readonly transaction?: OptimisticTransactionDefinition };
 };
 
+export type MessagesAgentInvokeArgs = {
+  path: string;
+  args: JsonValue;
+  artifactHash: string;
+};
+export type MessagesAgentInvokeResult = JsonValue;
+export type MessagesEchoArgs = {
+  message: string;
+};
+export type MessagesEchoResult = {
+  message: string;
+};
+export type MessagesGetArgs = {
+  id: string;
+};
+export type MessagesGetResult = Array<{
+  id: string;
+  body: string;
+  author: string;
+  created_at: string;
+}>;
 export type MessagesListArgs = { };
 export type MessagesListResult = Array<{
   id: string;
@@ -41,6 +62,83 @@ export type MessagesSendResult = {
 
 export const api = {
   messages: {
+    agentInvoke: {
+      args: {
+        fields: {
+          args: {
+            kind: "any",
+          },
+          artifactHash: {
+            kind: "string",
+          },
+          path: {
+            kind: "string",
+          },
+        },
+        kind: "object",
+      },
+      kind: "action",
+      path: "messages.agentInvoke",
+      result: {
+        kind: "any",
+      },
+    } as unknown as FunctionReference<"action", MessagesAgentInvokeArgs, MessagesAgentInvokeResult>,
+    echo: {
+      args: {
+        fields: {
+          message: {
+            kind: "string",
+          },
+        },
+        kind: "object",
+      },
+      kind: "action",
+      path: "messages.echo",
+      result: {
+        fields: {
+          message: {
+            kind: "string",
+          },
+        },
+        kind: "object",
+      },
+    } as unknown as FunctionReference<"action", MessagesEchoArgs, MessagesEchoResult>,
+    get: {
+      args: {
+        fields: {
+          id: {
+            entity: "messages",
+            kind: "id",
+          },
+        },
+        kind: "object",
+      },
+      delivery: "oneShot",
+      kind: "query",
+      path: "messages.get",
+      result: {
+        items: {
+          fields: {
+            author: {
+              kind: "string",
+            },
+            body: {
+              kind: "string",
+            },
+            created_at: {
+              format: "datetime",
+              kind: "string",
+            },
+            id: {
+              entity: "messages",
+              kind: "id",
+            },
+          },
+          kind: "object",
+        },
+        kind: "array",
+      },
+    } as unknown as FunctionReference<"query", MessagesGetArgs, MessagesGetResult>,
     list: {
       args: {
         fields: {
@@ -128,18 +226,27 @@ export const api = {
   },
 } as const;
 
-export const internal = {} as const;
+export const control = gonvexControl;
+
+export const internal = {
+} as const;
 export type Api = typeof api;
 
 export const optimisticTransactions: Record<string, OptimisticTransactionDefinition> = {
 };
 
 export type ApiArgs = {
+  "messages.agentInvoke": MessagesAgentInvokeArgs;
+  "messages.echo": MessagesEchoArgs;
+  "messages.get": MessagesGetArgs;
   "messages.list": MessagesListArgs;
   "messages.send": MessagesSendArgs;
 };
 
 export type ApiResults = {
+  "messages.agentInvoke": MessagesAgentInvokeResult;
+  "messages.echo": MessagesEchoResult;
+  "messages.get": MessagesGetResult;
   "messages.list": MessagesListResult;
   "messages.send": MessagesSendResult;
 };