@voltro/cli 0.33.0 → 0.35.0

package/dist/scheduleManifestCmd-D2x0CTTY.js

@@ -0,0 +1,249 @@
+import { n as e, t } from "./cliArgs-D4p8n7EE.js";
+import { dirname as n, join as r, resolve as i } from "node:path";
+import { promises as a } from "node:fs";
+import { pathToFileURL as o } from "node:url";
+import { createLogger as s } from "@voltro/logger";
+import { isScheduleDefinition as c } from "@voltro/runtime";
+//#region src/scheduleManifest.ts
+var l = (e) => `/_voltro/schedule/${encodeURIComponent(e)}/fire?trigger=external`, u = (e) => {
+	let t = e.trim().split(/\s+/);
+	return t.length === 6 ? `6-field (seconds) cron "${e}" can't drive an external scheduler — k8s/gcp/aws are minute-resolution. Use a 5-field expression or trigger:'self'.` : t.length === 5 ? null : `expected a 5-field cron expression, got ${t.length} fields: "${e}"`;
+}, d = (e, t) => {
+	let n = t.tokenEnv ?? "VOLTRO_SCHEDULE_TOKEN", r = e.name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+	return `---
+# ${e.description ?? `schedule "${e.name}"`}
+# Generated from defineSchedule("${e.name}") — do not edit by hand;
+# re-run \`voltro schedule-manifest\` after changing the cron.
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: ${t.appName}-${r}
+spec:
+  schedule: "${e.cron}"
+  timeZone: "${e.timezone}"
+  concurrencyPolicy: Forbid
+  jobTemplate:
+    spec:
+      backoffLimit: 2
+      template:
+        spec:
+          restartPolicy: Never
+          containers:
+            - name: trigger
+              image: curlimages/curl:8.11.0
+              env:
+                - name: ${n}
+                  valueFrom:
+                    secretKeyRef:
+                      name: ${t.appName}-schedule
+                      key: token
+              command: ["sh", "-c"]
+              args:
+                - >
+                  curl -fsS -X POST
+                  -H "Authorization: Bearer $(${n})"
+                  "${t.baseUrl}${l(e.name)}"
+`;
+}, f = (e, t) => {
+	let n = t.tokenEnv ?? "VOLTRO_SCHEDULE_TOKEN", r = e.name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+	return `# ${e.description ?? `schedule "${e.name}"`}
+gcloud scheduler jobs create http ${t.appName}-${r} \\
+  --schedule="${e.cron}" \\
+  --time-zone="${e.timezone}" \\
+  --uri="${t.baseUrl}${l(e.name)}" \\
+  --http-method=POST \\
+  --headers="Authorization=Bearer $${n}"
+`;
+}, p = (e) => {
+	let [t, n, r, i, a] = e.trim().split(/\s+/), o = r, s = a, c = null;
+	return r === "*" && a === "*" ? s = "?" : r !== "*" && a !== "*" ? c = `AWS cron can't constrain BOTH day-of-month AND day-of-week — review "${e}" manually.` : a === "*" ? s = "?" : o = "?", {
+		expr: `cron(${t} ${n} ${o} ${i} ${s} *)`,
+		note: c
+	};
+}, m = (e, t) => {
+	let n = e.name.replace(/[^a-zA-Z0-9-_]/g, "-"), { expr: r, note: i } = p(e.cron);
+	return `# ${e.description ?? `schedule "${e.name}"`}${i ? `\n# ⚠ ${i}` : ""}
+# EventBridge Scheduler → HTTP needs an API destination + connection
+# (holds the bearer secret). Create those once, then:
+aws scheduler create-schedule \\
+  --name "${t.appName}-${n}" \\
+  --schedule-expression "${r}" \\
+  --schedule-expression-timezone "${e.timezone}" \\
+  --flexible-time-window '{"Mode":"OFF"}' \\
+  --target '{
+    "Arn": "<API_DESTINATION_ARN>",
+    "RoleArn": "<SCHEDULER_ROLE_ARN>",
+    "HttpParameters": { "HeaderParameters": {} },
+    "Input": ""
+  }'
+# Target endpoint: ${t.baseUrl}${l(e.name)}
+`;
+}, h = (e, t) => `// ${e.description ?? `schedule "${e.name}"`}
+// Azure has no direct cron→HTTP primitive. Two options:
+//   1. Logic App with a Recurrence trigger (skeleton below) → HTTP action.
+//   2. An Azure Function with a timer trigger ("${e.cron}") that does the POST.
+// Logic App recurrence skeleton (paste into the App's definition):
+{
+  "triggers": {
+    "${e.name}": {
+      "type": "Recurrence",
+      "recurrence": { "frequency": "Minute", "interval": 1, "timeZone": "${e.timezone}" },
+      "note": "Translate cron '${e.cron}' into the recurrence schedule; the Recurrence trigger is interval-based, not cron — a timer-trigger Function matches cron exactly."
+    }
+  },
+  "actions": {
+    "fire": {
+      "type": "Http",
+      "inputs": {
+        "method": "POST",
+        "uri": "${t.baseUrl}${l(e.name)}",
+        "headers": { "Authorization": "Bearer @{parameters('scheduleToken')}" }
+      }
+    }
+  }
+}
+`, g = (e, t) => {
+	let n = t.tokenEnv ?? "VOLTRO_SCHEDULE_TOKEN", r = e.map((e) => `| \`${e.name}\` | \`${e.cron}\` | ${e.timezone} | \`POST ${l(e.name)}\` |`).join("\n");
+	return `# External-trigger schedules — ${t.appName}
+
+These schedules use \`trigger: 'external'\`. The app does NOT run an
+in-process timer for them; an outside scheduler must POST the fire
+endpoint on the cadence below. Each call is authenticated with a
+bearer token (env \`${n}\`).
+
+| Schedule | Cron | Timezone | Endpoint |
+|---|---|---|---|
+${r}
+
+## curl shape
+
+\`\`\`sh
+curl -fsS -X POST \\
+  -H "Authorization: Bearer $${n}" \\
+  "${t.baseUrl}/_voltro/schedule/<name>/fire?trigger=external"
+\`\`\`
+
+The endpoint returns \`{ "runId": "sr_..." }\` on success (or \`null\`
+when the schedule lost a coordination race — harmless). It is
+idempotent-safe to call at-most-once per intended firing; the
+external scheduler owns the once-only guarantee.
+`;
+}, _ = (e, t, n) => {
+	let r = [], i = [];
+	for (let t of e) {
+		let e = u(t.cron);
+		if (e) {
+			r.push(`schedule "${t.name}": ${e}`);
+			continue;
+		}
+		i.push(t);
+	}
+	if (i.length === 0) return {
+		files: [],
+		warnings: r
+	};
+	let a = [];
+	switch (t) {
+		case "kubernetes":
+			a.push({
+				path: ".voltro/scheduling/kubernetes-cronjobs.yaml",
+				content: i.map((e) => d(e, n)).join("\n")
+			});
+			break;
+		case "gcp":
+			a.push({
+				path: ".voltro/scheduling/gcp-cloud-scheduler.sh",
+				content: `#!/bin/sh\n# GCP Cloud Scheduler jobs — generated from defineSchedule(...).\nset -e\n\n${i.map((e) => f(e, n)).join("\n")}`
+			});
+			break;
+		case "aws":
+			a.push({
+				path: ".voltro/scheduling/aws-eventbridge.sh",
+				content: `#!/bin/sh\n# AWS EventBridge Scheduler — generated from defineSchedule(...).\n# Review the cron translations flagged with ⚠ before applying.\nset -e\n\n${i.map((e) => m(e, n)).join("\n")}`
+			});
+			break;
+		case "azure":
+			a.push({
+				path: ".voltro/scheduling/azure-recurrence.jsonc",
+				content: i.map((e) => h(e, n)).join("\n")
+			});
+			break;
+		case "generic": break;
+	}
+	return a.push({
+		path: ".voltro/scheduling/README.md",
+		content: g(i, n)
+	}), {
+		files: a,
+		warnings: r
+	};
+}, v = s({ scope: "voltro:schedule-manifest" }), y = /* @__PURE__ */ new Set([
+	"kubernetes",
+	"aws",
+	"gcp",
+	"azure",
+	"generic"
+]), b = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	"build",
+	".turbo",
+	".vite",
+	".git",
+	".framework",
+	".voltro"
+]), x = async (e) => {
+	let t = [], n = async (e) => {
+		let i = await a.readdir(e, { withFileTypes: !0 });
+		for (let a of i) {
+			if (b.has(a.name)) continue;
+			let i = r(e, a.name);
+			a.isDirectory() ? await n(i) : a.isFile() && /\.cron\.tsx?$/.test(a.name) && t.push(i);
+		}
+	};
+	return await n(e), t;
+}, S = [
+	"--provider",
+	"--base-url",
+	"--token-env"
+], C = async (s) => {
+	let l = i(t(s, S) ?? process.cwd()), u, d = "app";
+	try {
+		let e = (await import(o(r(l, "app.config.ts")).href)).default ?? {};
+		d = typeof e.name == "string" ? e.name : d, u = e.scheduling?.externalProvider;
+	} catch {}
+	let f = e(s, "--provider") ?? u ?? "generic";
+	if (!y.has(f)) return v.error(`unknown --provider "${f}" (expected: ${[...y].join(", ")})`), 1;
+	let p = f, m = e(s, "--base-url") ?? process.env.VOLTRO_PUBLIC_URL ?? "https://CHANGE-ME.example.com", h = e(s, "--token-env") ?? "VOLTRO_SCHEDULE_TOKEN", g = "self";
+	try {
+		g = (await import(o(r(l, "app.config.ts")).href)).default?.scheduling?.trigger ?? "self";
+	} catch {}
+	let b = await x(l), C = [];
+	for (let e of b) {
+		let t = (await import(o(e).href)).default;
+		c(t) && (t.trigger ?? g) === "external" && C.push({
+			name: t.name,
+			cron: t.cron,
+			timezone: t.timezone,
+			...t.description === void 0 ? {} : { description: t.description }
+		});
+	}
+	if (C.length === 0) return v.info("no external-trigger schedules found — nothing to emit", { scanned: b.length }), 0;
+	let { files: w, warnings: T } = _(C, p, {
+		baseUrl: m,
+		tokenEnv: h,
+		appName: d
+	});
+	for (let e of T) v.warn(e);
+	for (let e of w) {
+		let t = r(l, e.path);
+		await a.mkdir(n(t), { recursive: !0 }), await a.writeFile(t, e.content, "utf8"), v.info("wrote", { path: e.path });
+	}
+	return v.info("schedule manifests emitted", {
+		provider: p,
+		schedules: C.length,
+		files: w.length
+	}), m.includes("CHANGE-ME") && v.warn("base URL not set — pass --base-url https://your-app or set VOLTRO_PUBLIC_URL"), 0;
+};
+//#endregion
+export { C as runScheduleManifest };

package/dist/schemaIr-UJybUUZW.js

@@ -0,0 +1,103 @@
+//#region src/sdkgen/schemaIr.ts
+var e = () => ({
+	models: /* @__PURE__ */ new Map(),
+	enums: /* @__PURE__ */ new Map(),
+	inProgress: /* @__PURE__ */ new Set()
+}), t = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter((e) => e.length > 0), n = (e) => {
+	let n = t(e);
+	if (n.length === 0) return "Value";
+	let r = n.map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join("");
+	return /^[0-9]/.test(r) ? `T${r}` : r;
+}, r = (e) => {
+	let t = n(e);
+	return t.charAt(0).toLowerCase() + t.slice(1);
+}, i = (e) => {
+	let n = t(e);
+	if (n.length === 0) return "VALUE";
+	let r = n.map((e) => e.toUpperCase()).join("_");
+	return /^[0-9]/.test(r) ? `V_${r}` : r;
+}, a = (e) => typeof e == "object" && !!e && e.type === "null", o = (e) => n(e.split("/").pop() ?? e), s = (e) => e.every((e) => typeof e == "string"), c = (e, t, n) => (e.enums.has(t) || e.enums.set(t, {
+	name: t,
+	values: n
+}), {
+	kind: "ref",
+	name: t
+}), l = (e, t, r, i) => {
+	let u = e.$ref;
+	if (typeof u == "string") {
+		let e = o(u);
+		if (i.models.has(e) || i.enums.has(e) || i.inProgress.has(e)) return {
+			kind: "ref",
+			name: e
+		};
+		let t = r[u.split("/").pop() ?? ""];
+		if (t === void 0) return { kind: "unknown" };
+		i.inProgress.add(e);
+		let n = l(t, e, r, i);
+		return i.inProgress.delete(e), n;
+	}
+	let d = e.type;
+	if (Array.isArray(d)) {
+		let n = d.filter((e) => e !== "null"), a = d.includes("null"), o = l({
+			...e,
+			...n.length === 1 ? { type: n[0] } : { type: void 0 }
+		}, t, r, i);
+		return a ? {
+			kind: "optional",
+			inner: o
+		} : o;
+	}
+	let f = e.anyOf ?? e.oneOf;
+	if (Array.isArray(f)) {
+		let e = f.filter(a), n = f.filter((e) => !a(e));
+		if (n.length === 1 && n[0] !== void 0) {
+			let a = l(n[0], t, r, i);
+			return e.length > 0 ? {
+				kind: "optional",
+				inner: a
+			} : a;
+		}
+		return { kind: "unknown" };
+	}
+	let p = e.enum;
+	if (Array.isArray(p) && p.length > 0 && s(p)) return c(i, t, [...p]);
+	switch (d) {
+		case "string": return { kind: "string" };
+		case "integer": return { kind: "integer" };
+		case "number": return { kind: "number" };
+		case "boolean": return { kind: "boolean" };
+		case "array": {
+			let n = e.items;
+			return {
+				kind: "array",
+				element: n !== void 0 && typeof n == "object" && !Array.isArray(n) ? l(n, `${t}Item`, r, i) : { kind: "unknown" }
+			};
+		}
+		case "object": {
+			let a = e.properties;
+			if (a === void 0 || Object.keys(a).length === 0) return { kind: "unknown" };
+			let o = new Set(Array.isArray(e.required) ? e.required : []);
+			i.inProgress.add(t);
+			let s = Object.entries(a).map(([e, a]) => {
+				let s = l(a, `${t}${n(e)}`, r, i);
+				return {
+					jsonName: e,
+					type: !o.has(e) && s.kind !== "optional" ? {
+						kind: "optional",
+						inner: s
+					} : s
+				};
+			});
+			return i.inProgress.delete(t), i.models.set(t, {
+				name: t,
+				fields: s
+			}), {
+				kind: "ref",
+				name: t
+			};
+		}
+		default: return { kind: "unknown" };
+	}
+}, u = (e, t, n) => e === void 0 ? void 0 : l(e, t, e.$defs ?? e.definitions ?? {}, n);
+//#endregion
+export { i as a, u as i, e as n, n as r, r as t };