@hitch42/applet 0.1.0-beta.10

package/dist/batch-Qa4B4-Yp.d.ts

@@ -0,0 +1,30 @@
+import { AnyContractRouter } from "@orpc/contract";
+//#region src/hitch/batch.d.ts
+type BatchVerb = "create" | "update" | "delete" | "updateWhere";
+type BatchTxRecords<Records> = { [Code in keyof Records]: { [Verb in keyof Records[Code] & BatchVerb]: Records[Code][Verb] extends ((...args: infer Args) => unknown) ? (input: Args[0]) => void : never; }; };
+type BatchTx<T> = T extends {
+  records: infer Records;
+} ? BatchTxRecords<Records> : never;
+type BatchRecorderOptions = {
+  dryRun?: boolean;
+  idempotencyKey?: string;
+};
+type BatchRecorderCall<T, Batch> = Batch extends ((...args: infer _Args) => infer Result) ? (record: (tx: BatchTx<T>) => void | Promise<void>, options?: BatchRecorderOptions) => Result : never;
+type WithBatchRecorder<T> = T extends {
+  records: unknown;
+  batch: infer Batch;
+} ? Omit<T, "batch"> & {
+  /**
+   * Record record writes inside `record` and send them as one atomic batch.
+   *
+   * The callback receives a `tx` whose `create` / `update` / `updateWhere` /
+   * `delete` calls are buffered, not sent immediately; the whole batch runs
+   * in a single transaction when the callback resolves.
+   *
+   * @remarks A batch may contain at most **100** requests. More than that is
+   * rejected with a `400` before any write runs.
+   */
+  batch: BatchRecorderCall<T, Batch> & Batch;
+} : T;
+//#endregion
+export { WithBatchRecorder as t };

package/dist/build-BlmLiKro.js

@@ -0,0 +1,90 @@
+import { i as prepareAppletProjects, r as prepareAppletProject } from "./project-B0qNXnFu.js";
+import { rm } from "node:fs/promises";
+import { resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+//#region src/build.ts
+function isMissingFile(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function runPnpm(args, cwd) {
+	await new Promise((resolveRun, rejectRun) => {
+		let finished = false;
+		const child = spawn("pnpm", args, {
+			cwd,
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.once("error", (error) => {
+			finished = true;
+			rejectRun(isMissingFile(error) ? /* @__PURE__ */ new Error("pnpm was not found. Install pnpm, then run applet build again.") : error);
+		});
+		child.once("close", (code) => {
+			if (finished) return;
+			finished = true;
+			if (code === 0) {
+				resolveRun();
+				return;
+			}
+			rejectRun(/* @__PURE__ */ new Error(`pnpm ${args.join(" ")} failed${code === null ? "." : ` with exit code ${code}.`}`));
+		});
+	});
+}
+async function buildApplet(appletRoot, outDir = ".hitch/dist") {
+	await runPnpm(["install"], await prepareAppletProject(appletRoot));
+	await buildPreparedApplet(appletRoot, outDir);
+}
+async function prepareWorkspaceBuild(workspaceRoot, appletRoots) {
+	await prepareAppletProjects(workspaceRoot, appletRoots);
+	await runPnpm(["install"], workspaceRoot);
+}
+async function buildPreparedApplet(appletRoot, outDir = ".hitch/dist", logPrefix = "") {
+	await rm(resolve(appletRoot, ".hitch"), {
+		force: true,
+		recursive: true
+	});
+	await new Promise((resolveBuild, rejectBuild) => {
+		let finished = false;
+		const child = spawn("pnpm", [
+			"exec",
+			"vite",
+			"build",
+			"--outDir",
+			outDir
+		], {
+			cwd: appletRoot,
+			stdio: logPrefix === "" ? "inherit" : [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			shell: process.platform === "win32"
+		});
+		if (child.stdout) createInterface({
+			input: child.stdout,
+			crlfDelay: Infinity
+		}).on("line", (line) => console.log(`${logPrefix}${line}`));
+		if (child.stderr) createInterface({
+			input: child.stderr,
+			crlfDelay: Infinity
+		}).on("line", (line) => console.error(`${logPrefix}${line}`));
+		child.once("error", (error) => {
+			finished = true;
+			rejectBuild(isMissingFile(error) ? /* @__PURE__ */ new Error("pnpm was not found. Install pnpm, then run applet build again.") : error);
+		});
+		child.once("close", (code) => {
+			if (finished) return;
+			finished = true;
+			if (code === 0) {
+				resolveBuild();
+				return;
+			}
+			rejectBuild(/* @__PURE__ */ new Error(`pnpm exec vite build failed${code === null ? "." : ` with exit code ${code}.`}`));
+		});
+	});
+}
+async function runBuild() {
+	await buildApplet(process.cwd());
+}
+//#endregion
+export { runBuild as i, buildPreparedApplet as n, prepareWorkspaceBuild as r, buildApplet as t };

package/dist/build-CcT-wNN9.js

@@ -0,0 +1,2 @@
+import { i as runBuild } from "./build-BlmLiKro.js";
+export { runBuild };

package/dist/ci-0Q2mUh53.js

@@ -0,0 +1,68 @@
+import { f as resolveInstanceUrl } from "./workspace-DruAZPmV.js";
+//#region src/ci.ts
+function githubActionsContext(env = process.env) {
+	if (env.GITHUB_ACTIONS !== "true" || env.HITCH_API_KEY) return void 0;
+	const requestUrl = env.ACTIONS_ID_TOKEN_REQUEST_URL;
+	const requestToken = env.ACTIONS_ID_TOKEN_REQUEST_TOKEN;
+	if (!requestUrl || !requestToken) throw new Error("GitHub Actions did not provide an OIDC token. Grant the job the id-token: write permission, or set HITCH_API_KEY.");
+	return {
+		requestUrl,
+		requestToken
+	};
+}
+async function hitchResponseError(response, summary) {
+	let details = "";
+	try {
+		const body = await response.json();
+		if (body !== null && typeof body === "object") details = ["code" in body && typeof body.code === "string" ? body.code : void 0, "message" in body && typeof body.message === "string" ? body.message : void 0].filter((value) => value !== void 0).join(": ");
+	} catch {
+		details = "";
+	}
+	return /* @__PURE__ */ new Error(`${summary} (${response.status})${details ? `: ${details}` : ""}.`);
+}
+async function githubActionsToken(context, instanceUrl, fetcher) {
+	const url = new URL(context.requestUrl);
+	url.searchParams.set("audience", new URL(instanceUrl).origin);
+	const response = await fetcher(url, { headers: { Authorization: `bearer ${context.requestToken}` } });
+	if (!response.ok) throw new Error(`GitHub did not issue an OIDC token (${response.status}).`);
+	const body = await response.json();
+	if (body === null || typeof body !== "object" || !("value" in body)) throw new Error("GitHub returned an OIDC token response without a value.");
+	if (typeof body.value !== "string") throw new Error("GitHub returned an OIDC token response without a value.");
+	return body.value;
+}
+async function fetchWithGitHubActions(context, options, request) {
+	const instanceUrl = await resolveInstanceUrl(void 0, options.store);
+	return request(instanceUrl, await githubActionsToken(context, instanceUrl, options.fetch ?? globalThis.fetch));
+}
+async function loadGitHubActionsBuildInputs(context, options, requiresChangeset) {
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const query = requiresChangeset === void 0 ? "" : `?changeset_id=${encodeURIComponent(requiresChangeset)}`;
+	const response = await fetchWithGitHubActions(context, options, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/ci/v1/build-inputs${query}`, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${accessToken}` }
+	}));
+	if (!response.ok) throw await hitchResponseError(response, "Failed to load the CI build inputs");
+	const body = await response.json();
+	if (body === null || typeof body !== "object" || !("openapi" in body) || !("theme" in body) || typeof body.theme !== "string") throw new Error("The CI build inputs must contain an openapi document and a theme string.");
+	return {
+		openapi: body.openapi,
+		theme: body.theme
+	};
+}
+async function loadGitHubActionsSources(context, options) {
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const response = await fetchWithGitHubActions(context, options, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/ci/v1/applets`, { headers: { Authorization: `Bearer ${accessToken}` } }));
+	if (!response.ok) throw await hitchResponseError(response, "Failed to load the CI applets");
+	const body = await response.json();
+	if (body === null || typeof body !== "object" || !("data" in body) || !Array.isArray(body.data)) throw new Error("The CI applets response must contain a data array.");
+	return body.data.map((source) => {
+		if (source === null || typeof source !== "object" || !("code" in source) || typeof source.code !== "string" || !("source_directory" in source) || typeof source.source_directory !== "string" || !("git_sha" in source) || source.git_sha !== null && typeof source.git_sha !== "string") throw new Error("Each CI applet must contain code, source_directory, and git_sha fields.");
+		return {
+			code: source.code,
+			sourceDirectory: source.source_directory,
+			gitSha: source.git_sha
+		};
+	});
+}
+//#endregion
+export { loadGitHubActionsSources as a, loadGitHubActionsBuildInputs as i, githubActionsContext as n, hitchResponseError as r, fetchWithGitHubActions as t };

package/dist/client.d.ts

@@ -0,0 +1,48 @@
+import { f as RegisteredContract, m as RegisteredRouter, p as RegisteredManifest } from "./manifest-I-9s8R36.js";
+import { t as NarrowContract } from "./contract-QUvEGiRI.js";
+import { t as WithBatchRecorder } from "./batch-Qa4B4-Yp.js";
+import { o as WithFilesUpload } from "./upload-DKZzz5kW.js";
+import { RouterClient } from "@orpc/server";
+import { ContractRouterClient } from "@orpc/contract";
+import { NestedClient } from "@orpc/client";
+import { RouterUtils } from "@orpc/tanstack-query";
+//#region src/query-utils.d.ts
+type Exact<Expected, Actual> = Actual extends symbol ? Actual : Actual extends Expected ? Actual extends readonly unknown[] ? Actual : Actual extends object ? NonNullable<Expected> extends object ? { [Key in keyof Actual]: Key extends keyof NonNullable<Expected> ? Exact<NonNullable<Expected>[Key], Actual[Key]> : never; } : Actual : Actual : never;
+type QueryOptionsFunction<Utils> = Extract<Utils extends {
+  queryOptions: infer Function;
+} ? Function : never, (...args: never[]) => unknown>;
+type QueryOptionsArgument<Utils> = NonNullable<Parameters<QueryOptionsFunction<Utils>>[0]>;
+type ExactOptions<Input, Options> = Options extends {
+  input: infer Actual;
+} ? Options & {
+  input: Exact<Input, Actual>;
+} : Options extends {
+  input?: infer Actual;
+} ? Options & {
+  input?: Exact<Input, Actual>;
+} : Options;
+type QueryOptionsResult<Utils, Options> = Options & Omit<ReturnType<QueryOptionsFunction<Utils>>, keyof Options>;
+type ExactQueryOptions<Utils, Input> = <Options extends QueryOptionsArgument<Utils> = QueryOptionsArgument<Utils>>(...rest: undefined extends Input ? [options?: ExactOptions<Input, Options>] : [options: ExactOptions<Input, Options>]) => QueryOptionsResult<Utils, Options>;
+type ClientTree = NestedClient<Record<never, never>>;
+type ExactRouterUtils<Client extends ClientTree> = Client extends ((...args: infer Arguments) => unknown) ? Omit<RouterUtils<Client>, "queryOptions"> & {
+  queryOptions: ExactQueryOptions<RouterUtils<Client>, Arguments[0]>;
+} : Omit<RouterUtils<Client>, keyof Client> & { [Key in keyof Client]: Client[Key] extends ClientTree ? ExactRouterUtils<Client[Key]> : never; };
+//#endregion
+//#region src/author/client.d.ts
+type AuthorContract = NarrowContract<RegisteredContract, RegisteredManifest>;
+type BaseHitchClient = ContractRouterClient<AuthorContract>;
+type AuthorHitchClient = WithBatchRecorder<BaseHitchClient>;
+type BaseHitchUtils = ExactRouterUtils<BaseHitchClient>;
+type AuthorHitchUtils = AuthorHitchClient extends {
+  batch: infer Batch;
+} ? BaseHitchUtils extends {
+  batch: infer BatchUtils;
+} ? Omit<BaseHitchUtils, "batch"> & {
+  batch: Omit<BatchUtils, "call"> & {
+    call: Batch;
+  };
+} : BaseHitchUtils : BaseHitchUtils;
+declare const hitch: WithFilesUpload<AuthorHitchUtils>;
+declare const api: ExactRouterUtils<RouterClient<RegisteredRouter>>;
+//#endregion
+export { api, hitch };

package/dist/client.js

@@ -0,0 +1,38 @@
+import { n as withFilesUpload, r as getRegisteredHitchContract } from "./upload-DRbVhuDm.js";
+import { n as withBatchRecorder, t as createLazyClientProxy } from "./lazy-client-x0DCI98S.js";
+import { createORPCClient } from "@orpc/client";
+import { OpenAPILink } from "@orpc/openapi-client/fetch";
+import { createTanstackQueryUtils } from "@orpc/tanstack-query";
+import { RPCLink } from "@orpc/client/fetch";
+//#region src/hitch/browser.ts
+function createHitchClient(contract) {
+	return createLazyClientProxy(() => createORPCClient(new OpenAPILink(contract, {
+		url: `${location.origin}/api`,
+		fetch: (request, init) => globalThis.fetch(request, init)
+	})));
+}
+//#endregion
+//#region src/client.ts
+function createClient(...[options]) {
+	const clientOptions = options;
+	return createLazyClientProxy(() => {
+		const base = clientOptions?.base ?? `${import.meta.env.BASE_URL}api`;
+		const origin = typeof location === "undefined" ? "http://localhost" : location.origin;
+		return createORPCClient(new RPCLink({
+			url: new URL(base, origin),
+			fetch: (request, init) => (clientOptions?.fetch ?? globalThis.fetch)(request, init)
+		}));
+	});
+}
+//#endregion
+//#region src/author/client.ts
+function buildClientHitch() {
+	const contract = getRegisteredHitchContract();
+	if (contract === void 0) throw new Error("`hitch` is unavailable: run `applet generate` first. The framework imports your .hitch automatically at build; in plain node import your .hitch once before calling hitch.");
+	return withBatchRecorder(createHitchClient(contract), contract);
+}
+const hitchClient = createLazyClientProxy(buildClientHitch);
+const hitch = withFilesUpload(createTanstackQueryUtils(hitchClient), () => hitchClient.files);
+const api = createTanstackQueryUtils(createClient());
+//#endregion
+export { api, hitch };

package/dist/contract-QUvEGiRI.d.ts

@@ -0,0 +1,23 @@
+import { n as AppletManifest } from "./manifest-I-9s8R36.js";
+import { AnyContractRouter } from "@orpc/contract";
+//#region src/hitch/contract.d.ts
+type ManifestObjectFor<Manifest, Code> = Manifest extends {
+  objects: readonly (infer Object)[];
+} ? Object extends {
+  code: infer ObjectCode;
+} ? Code extends ObjectCode ? Object : never : never : never;
+type ManifestObjectCodes<Manifest> = Manifest extends {
+  objects: readonly (infer Object)[];
+} ? Object extends {
+  code: infer Code extends PropertyKey;
+} ? Code : never : never;
+type Capability<ManifestObject, Key extends "canCreate" | "canDelete" | "readWrite"> = ManifestObject extends Record<Key, infer Value> ? Value : never;
+type NarrowProcedures<Procedures, ManifestObject> = Omit<Procedures, (true extends Capability<ManifestObject, "canCreate"> ? never : "create") | (true extends Capability<ManifestObject, "canDelete"> ? never : "delete") | (Capability<ManifestObject, "readWrite"> extends readonly [] ? "update" | "updateWhere" : never)>;
+type NarrowContract<Contract, Manifest> = Contract extends {
+  records: infer Records;
+} ? Omit<Contract, "records"> & {
+  records: { [Code in keyof Records & ManifestObjectCodes<Manifest>]: NarrowProcedures<Records[Code], ManifestObjectFor<Manifest, Code>>; };
+} : Contract;
+declare function pruneContract<const Contract extends AnyContractRouter, const Manifest extends AppletManifest>(contract: Contract, manifest: Manifest): NarrowContract<Contract, Manifest>;
+//#endregion
+export { pruneContract as n, NarrowContract as t };