@hitch42/applet 0.1.1-beta.1

package/dist/upload-DRbVhuDm.js

@@ -0,0 +1,114 @@
+import "@orpc/server";
+//#region src/hitch/registry.ts
+let registeredContract;
+function registerHitchContract(contract) {
+	registeredContract = contract;
+}
+function getRegisteredHitchContract() {
+	return registeredContract;
+}
+//#endregion
+//#region src/hitch/upload.ts
+function abortError(signal) {
+	return signal?.reason ?? new DOMException("The upload was aborted.", "AbortError");
+}
+function putWithProgress(xhr, url, file, contentType, onProgress, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(abortError(signal));
+			return;
+		}
+		const onSignalAbort = () => xhr.abort();
+		const cleanup = () => {
+			xhr.upload.onprogress = null;
+			xhr.onload = null;
+			xhr.onerror = null;
+			xhr.onabort = null;
+			signal?.removeEventListener("abort", onSignalAbort);
+		};
+		xhr.open("PUT", url);
+		xhr.setRequestHeader("content-type", contentType);
+		xhr.upload.onprogress = (event) => {
+			if (event.lengthComputable) onProgress({
+				loaded: event.loaded,
+				total: event.total
+			});
+		};
+		xhr.onload = () => {
+			const status = xhr.status;
+			cleanup();
+			resolve(status);
+		};
+		xhr.onerror = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`Upload of "${file.name}" failed before reaching storage.`));
+		};
+		xhr.onabort = () => {
+			const error = abortError(signal);
+			cleanup();
+			reject(error);
+		};
+		signal?.addEventListener("abort", onSignalAbort, { once: true });
+		try {
+			xhr.send(file);
+		} catch (error) {
+			cleanup();
+			reject(error);
+		}
+	});
+}
+async function putFile(file, url, contentType, options) {
+	if (options.onProgress && typeof XMLHttpRequest !== "undefined") return putWithProgress(new XMLHttpRequest(), url, file, contentType, options.onProgress, options.signal);
+	let response;
+	try {
+		response = await fetch(url, {
+			method: "PUT",
+			body: file,
+			headers: { "content-type": contentType },
+			signal: options.signal
+		});
+	} catch (error) {
+		if (options.signal?.aborted) throw error;
+		throw new Error(`Upload of "${file.name}" failed before reaching storage.`, { cause: error });
+	}
+	return response.status;
+}
+async function uploadFile(files, file, options = {}) {
+	const created = await files.create({ body: {
+		filename: file.name,
+		contentType: file.type === "" ? "application/octet-stream" : file.type
+	} }, { signal: options.signal });
+	const status = await putFile(file, created.uploadUrl, created.data.contentType, options);
+	if (status < 200 || status >= 300) throw new Error(`Upload of "${file.name}" failed with status ${status}.`);
+	const confirmed = await files.confirm({ params: { id: created.data.id } }, { signal: options.signal });
+	return {
+		...confirmed.data,
+		downloadUrl: confirmed.downloadUrl
+	};
+}
+function withFilesUpload(target, files) {
+	let cachedFiles;
+	return new Proxy(target, { get(inner, property, receiver) {
+		const value = Reflect.get(inner, property, receiver);
+		if (property !== "files") return value;
+		if (cachedFiles?.raw === value) return cachedFiles.proxy;
+		const proxy = new Proxy(value, { get: (filesInner, filesProperty, filesReceiver) => {
+			if (filesProperty === "upload") return (file, options) => uploadFile(files(), file, options);
+			if (filesProperty === "download") return async (id, options) => {
+				const result = await files().get({ params: { id } }, options);
+				return {
+					...result.data,
+					downloadUrl: result.downloadUrl
+				};
+			};
+			return Reflect.get(filesInner, filesProperty, filesReceiver);
+		} });
+		cachedFiles = {
+			raw: value,
+			proxy
+		};
+		return proxy;
+	} });
+}
+//#endregion
+export { registerHitchContract as i, withFilesUpload as n, getRegisteredHitchContract as r, uploadFile as t };

package/dist/upload-YbRKEqR6.d.ts

@@ -0,0 +1,112 @@
+import { ContractProcedure, Meta } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/files.d.ts
+type HitchFile = {
+  id: string;
+  organizationId: string;
+  key: string;
+  filename: string;
+  contentType: string;
+  sizeBytes: number;
+  arrivedAt: string;
+  uploadedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+type PendingHitchFile = Omit<HitchFile, "sizeBytes" | "arrivedAt"> & {
+  sizeBytes: null;
+  arrivedAt: null;
+};
+type CreateFileInput = {
+  body: {
+    filename: string;
+    contentType: string;
+  };
+};
+type CreateFileOutput = {
+  data: PendingHitchFile;
+  uploadUrl: string;
+};
+type FileIdInput = {
+  params: {
+    id: string;
+  };
+};
+type FileOutput = {
+  data: HitchFile;
+  downloadUrl: string;
+};
+declare const fileSchema: z.ZodType<HitchFile>;
+declare const createFileOutputSchema: z.ZodType<CreateFileOutput>;
+declare const getFileOutputSchema: z.ZodType<FileOutput>;
+type FilesContract = {
+  create: ContractProcedure<z.ZodType<CreateFileInput>, z.ZodType<CreateFileOutput>, Record<never, never>, Meta>;
+  confirm: ContractProcedure<z.ZodType<FileIdInput>, z.ZodType<FileOutput>, Record<never, never>, Meta>;
+  get: ContractProcedure<z.ZodType<FileIdInput>, z.ZodType<FileOutput>, Record<never, never>, Meta>;
+};
+declare const filesContract: FilesContract;
+//#endregion
+//#region src/hitch/upload.d.ts
+type FilesClient = {
+  create(input: {
+    body: {
+      filename: string;
+      contentType: string;
+    };
+  }, options?: {
+    signal?: AbortSignal;
+  }): Promise<{
+    data: {
+      id: string;
+      contentType: string;
+    };
+    uploadUrl: string;
+  }>;
+  confirm(input: {
+    params: {
+      id: string;
+    };
+  }, options?: {
+    signal?: AbortSignal;
+  }): Promise<{
+    data: HitchFile;
+    downloadUrl: string;
+  }>;
+  get(input: {
+    params: {
+      id: string;
+    };
+  }, options?: {
+    signal?: AbortSignal;
+  }): Promise<{
+    data: HitchFile;
+    downloadUrl: string;
+  }>;
+};
+type UploadedHitchFile = HitchFile & {
+  downloadUrl: string;
+};
+type UploadProgress = {
+  loaded: number;
+  total: number;
+};
+type UploadFileOptions = {
+  signal?: AbortSignal;
+  onProgress?: (progress: UploadProgress) => void;
+};
+type FilesUpload = {
+  upload: (file: File, options?: UploadFileOptions) => Promise<UploadedHitchFile>;
+  download: (id: string, options?: {
+    signal?: AbortSignal;
+  }) => Promise<UploadedHitchFile>;
+};
+declare function uploadFile(files: FilesClient, file: File, options?: UploadFileOptions): Promise<UploadedHitchFile>;
+type WithFilesUpload<T> = T extends {
+  files: infer F;
+} ? Omit<T, "files"> & {
+  files: Omit<F, "create" | "confirm"> & FilesUpload;
+} : T & {
+  files: FilesUpload;
+};
+//#endregion
+export { UploadedHitchFile as a, createFileOutputSchema as c, getFileOutputSchema as d, UploadProgress as i, fileSchema as l, FilesUpload as n, WithFilesUpload as o, UploadFileOptions as r, uploadFile as s, FilesClient as t, filesContract as u };

package/dist/variables-CP7Ce3Np.js

@@ -0,0 +1,133 @@
+import { t as fetchWithOrgAuth } from "./auth-DaVK0k5R.js";
+import { t as loadAppletConfig } from "./load-config-BnxocLAQ.js";
+import { z } from "zod";
+import { Writable } from "node:stream";
+import { createInterface } from "node:readline";
+//#region src/variables.ts
+const variableRowSchema = z.object({
+	key: z.string(),
+	secret: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	value: z.string().optional()
+});
+const variableResponseSchema = z.object({ data: variableRowSchema });
+const variablesResponseSchema = z.object({ data: z.array(variableRowSchema) });
+function question(prompt, hidden = false) {
+	return new Promise((resolveAnswer, rejectAnswer) => {
+		let muted = false;
+		const output = hidden ? new Writable({ write(chunk, encoding, callback) {
+			if (!muted) process.stdout.write(chunk, encoding);
+			callback();
+		} }) : process.stdout;
+		const readline = createInterface({
+			input: process.stdin,
+			output,
+			terminal: true
+		});
+		readline.once("error", rejectAnswer);
+		if (hidden) {
+			process.stdout.write(prompt);
+			muted = true;
+		}
+		readline.question(hidden ? "" : prompt, (answer) => {
+			readline.close();
+			if (hidden) process.stdout.write("\n");
+			resolveAnswer(answer);
+		});
+	});
+}
+async function getValue(options) {
+	if (options.value !== void 0) return options.value;
+	if (!(options.stdinIsTTY ?? process.stdin.isTTY === true)) throw new Error("A value is required when stdin is not a TTY.");
+	return question("Value: ", true);
+}
+async function confirmLiveChange(code, options) {
+	if (options.yes === true) return;
+	if (!(options.stdinIsTTY ?? process.stdin.isTTY === true)) throw new Error("Confirmation requires a TTY. Pass -y to continue.");
+	const answer = await question(`This modifies the live applet "${code}". Continue? [y/N] `);
+	if (!["y", "yes"].includes(answer.trim().toLowerCase())) throw new Error("Variable change cancelled.");
+}
+async function readErrorDetails(response) {
+	let code;
+	let message;
+	try {
+		const body = await response.json();
+		if (body !== null && typeof body === "object") {
+			code = "code" in body && typeof body.code === "string" ? body.code : void 0;
+			message = "message" in body && typeof body.message === "string" ? body.message : void 0;
+		}
+	} catch {
+		code = void 0;
+		message = void 0;
+	}
+	return {
+		code,
+		message
+	};
+}
+function variablesError(status, code, message) {
+	const details = [code, message].filter((value) => value !== void 0).join(": ");
+	return /* @__PURE__ */ new Error(`Variables request failed (${status})${details ? `: ${details}` : ""}.`);
+}
+async function requestForApplet(options, request) {
+	const { code, org } = await loadAppletConfig(process.cwd());
+	return {
+		code,
+		response: await fetchWithOrgAuth(org, options, (instanceUrl, accessToken) => request(instanceUrl, accessToken, code))
+	};
+}
+async function runVariablesSet(options) {
+	const value = await getValue(options);
+	const manifest = await loadAppletConfig(process.cwd());
+	await confirmLiveChange(manifest.code, options);
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const response = await fetchWithOrgAuth(manifest.org, options, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/v1/applets/${encodeURIComponent(manifest.code)}/variables/${encodeURIComponent(options.key)}`, {
+		method: "PUT",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({
+			value,
+			secret: options.secret ?? false
+		})
+	}));
+	if (!response.ok) {
+		const { code, message } = await readErrorDetails(response);
+		throw variablesError(response.status, code, message);
+	}
+	const { data } = variableResponseSchema.parse(await response.json());
+	console.log(`Set ${data.key} ${data.secret ? "(secret)" : data.value ?? value} for applet "${manifest.code}".`);
+}
+async function runVariablesList(options) {
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const { code, response } = await requestForApplet(options, (instanceUrl, accessToken, appletCode) => fetcher(`${instanceUrl}/api/v1/applets/${encodeURIComponent(appletCode)}/variables`, { headers: { Authorization: `Bearer ${accessToken}` } }));
+	if (!response.ok) {
+		const { code: errorCode, message } = await readErrorDetails(response);
+		throw variablesError(response.status, errorCode, message);
+	}
+	const { data } = variablesResponseSchema.parse(await response.json());
+	if (data.length === 0) {
+		console.log(`No variables set for "${code}".`);
+		return;
+	}
+	data.forEach((variable) => console.log(`${variable.key}\t${variable.secret ? "secret" : variable.value ?? ""}\t${variable.updatedAt}`));
+}
+async function runVariablesDelete(options) {
+	const manifest = await loadAppletConfig(process.cwd());
+	await confirmLiveChange(manifest.code, options);
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const response = await fetchWithOrgAuth(manifest.org, options, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/v1/applets/${encodeURIComponent(manifest.code)}/variables/${encodeURIComponent(options.key)}`, {
+		method: "DELETE",
+		headers: { Authorization: `Bearer ${accessToken}` }
+	}));
+	if (!response.ok) {
+		const { code, message } = await readErrorDetails(response);
+		if (response.status === 404 && code === "variable_not_found") throw new Error(`Variable "${options.key}" was not found for applet "${manifest.code}".`);
+		throw variablesError(response.status, code, message);
+	}
+	console.log(`Deleted ${options.key} from applet "${manifest.code}".`);
+}
+//#endregion
+export { runVariablesDelete, runVariablesList, runVariablesSet };

package/dist/vite.d.ts

@@ -0,0 +1,63 @@
+import { o as RegisteredAppletSourceDefinition } from "./manifest-BQCAxATS.js";
+import { PluginOption } from "vite";
+//#region ../shared/auth/src/store.d.mts
+interface SessionCredentials {
+  type: "session";
+  accessToken: string;
+  expiresAt?: number;
+  organizationId: string;
+  orgCode: string;
+}
+interface StoreOptions {
+  env?: NodeJS.ProcessEnv;
+  homeDir?: string;
+}
+//#endregion
+//#region ../shared/auth/src/device.d.mts
+interface MeResponse {
+  memberships: Array<{
+    code: string;
+    name: string;
+    orgId: string;
+  }>;
+  organization: {
+    code: string;
+    id: string;
+  } | null;
+  person: {
+    email: string;
+    firstName: string;
+    id: string;
+    lastName: string;
+  };
+}
+interface DeviceLoginOptions {
+  expectedOrg?: string;
+  fetch?: typeof fetch;
+  noBrowser?: boolean;
+  now?: () => number;
+  openUrl?: (url: string) => void | Promise<void>;
+  print?: (message: string) => void;
+  sleep?: (milliseconds: number) => Promise<void>;
+  store?: StoreOptions;
+}
+interface DeviceLoginResult {
+  credentials: SessionCredentials;
+  me: MeResponse;
+  membership: MeResponse["memberships"][number];
+}
+declare function loginWithDevice(instanceUrl: string, options?: DeviceLoginOptions): Promise<DeviceLoginResult>;
+//#endregion
+//#region src/auth.d.ts
+interface OrgAuthOptions {
+  fetch?: typeof fetch;
+  login?: typeof loginWithDevice;
+  stdinIsTTY?: boolean;
+  store?: StoreOptions;
+}
+//#endregion
+//#region src/vite.d.ts
+type AppletOptions = OrgAuthOptions;
+declare function applet<const M extends RegisteredAppletSourceDefinition>(sourceDefinition: M, options?: AppletOptions): PluginOption[];
+//#endregion
+export { AppletOptions, applet };