kitcn 0.0.1 → 0.12.1

package/dist/crpc/index.js

@@ -0,0 +1,169 @@
+import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r as isCRPCClientError, t as CRPCClientError } from "../error-BZEnI7Sq.js";
+import { a as defaultCRPCTransformer, c as identityTransformer, i as decodeWire, n as createTaggedTransformer, o as encodeWire, r as dateWireCodec, s as getTransformer, t as DATE_CODEC_TAG } from "../transformer-DtDhR3Lc.js";
+import { n as convexInfiniteQueryOptions, r as convexQuery, t as convexAction } from "../query-options-Dw7cOyXl.js";
+
+//#region src/crpc/auth-error.ts
+/**
+* Auth Mutation Error
+*
+* Framework-agnostic error class for Better Auth mutations.
+*/
+/**
+* Error thrown when a Better Auth mutation fails.
+* Contains the original error details from Better Auth.
+*/
+var AuthMutationError = class extends Error {
+	/** Error code from Better Auth (e.g., 'INVALID_PASSWORD', 'EMAIL_ALREADY_REGISTERED') */
+	code;
+	/** HTTP status code */
+	status;
+	/** HTTP status text */
+	statusText;
+	constructor(authError) {
+		super(authError.message || authError.statusText);
+		this.name = "AuthMutationError";
+		this.code = authError.code;
+		this.status = authError.status;
+		this.statusText = authError.statusText;
+	}
+};
+/**
+* Type guard to check if an error is an AuthMutationError.
+*/
+function isAuthMutationError(error) {
+	return error instanceof AuthMutationError;
+}
+
+//#endregion
+//#region src/crpc/http-types.ts
+/** HTTP client error */
+var HttpClientError = class extends Error {
+	name = "HttpClientError";
+	code;
+	status;
+	procedureName;
+	constructor(opts) {
+		super(opts.message ?? `${opts.code}: ${opts.procedureName}`);
+		this.code = opts.code;
+		this.status = opts.status;
+		this.procedureName = opts.procedureName;
+	}
+};
+/** Type guard for HttpClientError */
+const isHttpClientError = (error) => error instanceof HttpClientError;
+
+//#endregion
+//#region src/crpc/http-client.ts
+/**
+* HTTP Client Helpers
+*
+* Framework-agnostic utilities for executing HTTP requests
+* against Convex HTTP endpoints.
+*/
+/** Reserved keys that are not part of JSON body */
+const RESERVED_KEYS = new Set([
+	"params",
+	"searchParams",
+	"form",
+	"fetch",
+	"init",
+	"headers"
+]);
+/**
+* Replace URL path parameters with actual values.
+* e.g., '/users/:id' with { id: '123' } -> '/users/123'
+*/
+function replaceUrlParam(url, params) {
+	return url.replace(/:(\w+)/g, (_, key) => {
+		const value = params[key];
+		return value !== void 0 ? encodeURIComponent(value) : `:${key}`;
+	});
+}
+/**
+* Build URLSearchParams from query object.
+* Handles array values as multiple params with same key (like Hono).
+*/
+function buildSearchParams(query) {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) if (Array.isArray(value)) for (const v of value) params.append(key, v);
+	else if (value !== void 0 && value !== null) params.append(key, value);
+	return params;
+}
+/**
+* Hono-style HTTP request executor.
+* Processes args in the same way as Hono's ClientRequestImpl.fetch().
+*/
+async function executeHttpRequest(opts) {
+	const { method, path } = opts.route;
+	const args = opts.args ?? {};
+	let rBody;
+	let cType;
+	if (args.form) {
+		const form = new FormData();
+		for (const [k, v] of Object.entries(args.form)) if (Array.isArray(v)) for (const v2 of v) form.append(k, v2);
+		else form.append(k, v);
+		rBody = form;
+	} else {
+		const jsonBody = {};
+		for (const [key, value] of Object.entries(args)) if (!RESERVED_KEYS.has(key) && value !== void 0) jsonBody[key] = value;
+		if (Object.keys(jsonBody).length > 0) {
+			rBody = JSON.stringify(opts.transformer.input.serialize(jsonBody));
+			cType = "application/json";
+		}
+	}
+	const argsClientOpts = {};
+	if (args.fetch) argsClientOpts.fetch = args.fetch;
+	if (args.init) argsClientOpts.init = args.init;
+	if (args.headers) argsClientOpts.headers = args.headers;
+	const mergedClientOpts = {
+		...opts.clientOpts,
+		...argsClientOpts
+	};
+	const resolvedBaseHeaders = typeof opts.baseHeaders === "function" ? await opts.baseHeaders() : opts.baseHeaders;
+	const headerValues = { ...typeof mergedClientOpts.headers === "function" ? await mergedClientOpts.headers() : mergedClientOpts.headers };
+	if (cType) headerValues["Content-Type"] = cType;
+	const finalHeaders = {};
+	if (resolvedBaseHeaders) {
+		for (const [key, value] of Object.entries(resolvedBaseHeaders)) if (value !== void 0) finalHeaders[key] = value;
+	}
+	Object.assign(finalHeaders, headerValues);
+	let url = opts.convexSiteUrl + path;
+	if (args.params) url = opts.convexSiteUrl + replaceUrlParam(path, args.params);
+	if (args.searchParams) {
+		const queryString = buildSearchParams(args.searchParams).toString();
+		if (queryString) url = `${url}?${queryString}`;
+	}
+	const methodUpperCase = method.toUpperCase();
+	const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+	const response = await (mergedClientOpts.fetch ?? opts.baseFetch ?? globalThis.fetch)(url, {
+		body: setBody ? rBody : void 0,
+		method: methodUpperCase,
+		headers: finalHeaders,
+		...mergedClientOpts.init
+	});
+	if (!response.ok) {
+		const errorData = await response.json().catch(() => ({ error: {
+			code: "UNKNOWN",
+			message: response.statusText
+		} }));
+		const errorCode = errorData?.error?.code || "UNKNOWN";
+		const errorMessage = errorData?.error?.message || response.statusText;
+		throw new HttpClientError({
+			code: errorCode,
+			status: response.status,
+			procedureName: opts.procedureName,
+			message: errorMessage
+		});
+	}
+	if (response.headers.get("content-length") === "0" || response.status === 204) return;
+	if ((response.headers.get("content-type") || "").includes("application/json")) return opts.transformer.output.deserialize(await response.json());
+	return response.text();
+}
+
+//#endregion
+//#region src/crpc/types.ts
+/** Symbol key for attaching FunctionReference to options (non-serializable) */
+const FUNC_REF_SYMBOL = Symbol.for("convex.funcRef");
+
+//#endregion
+export { AuthMutationError, CRPCClientError, DATE_CODEC_TAG, FUNC_REF_SYMBOL, HttpClientError, RESERVED_KEYS, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };

package/dist/customFunctions-C0voKmtx.js

@@ -0,0 +1,144 @@
+import { c as omit, l as pick, t as addFieldsToValidator } from "./validators-B7oIJCAp.js";
+
+//#region src/internal/upstream/server/customFunctions.ts
+/**
+* A helper for defining a Customization when your mod doesn't need to add or remove
+* anything from args.
+* @param modifyCtx A function that defines how to modify the ctx.
+* @returns A ctx delta to be applied to the original ctx.
+*/
+function customCtx(modifyCtx) {
+	return {
+		args: {},
+		input: async (ctx, _, extra) => ({
+			ctx: await modifyCtx(ctx, extra),
+			args: {}
+		})
+	};
+}
+/**
+* A Customization that doesn't add or remove any context or args.
+*/
+const NoOp = {
+	args: {},
+	input() {
+		return {
+			args: {},
+			ctx: {}
+		};
+	}
+};
+/**
+* customMutation helps define custom behavior on top of `mutation`
+* or `internalMutation` by passing a function that modifies the ctx and args.
+*
+* Example usage:
+* ```js
+* const myMutationBuilder = customMutation(mutation, {
+*   args: { sessionId: v.id("sessions") },
+*   input: async (ctx, args) => {
+*     const user = await getUserOrNull(ctx);
+*     const session = await db.get(sessionId);
+*     const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
+*     return {
+*       ctx: { db, user, session },
+*       args: {},
+*       onSuccess: ({ result }) => {
+*         // Optional callback that runs after the function executes
+*         // Has access to resources created during input processing
+*         console.log(`User ${user.name} returned:`, result);
+*       }
+*     };
+*   },
+* });
+*
+* // Using the custom builder
+* export const setSomeData = myMutationBuilder({
+*   args: { someArg: v.string() },
+*   handler: async (ctx, args) => {
+*     const { db, user, session, scheduler } = ctx;
+*     const { someArg } = args;
+*     // ...
+*   }
+* });
+* ```
+*
+* Simple usage only modifying ctx:
+* ```js
+* const myUserMutation = customMutation(
+*   mutation,
+*   customCtx(async (ctx) => {
+*     return {
+*       // Throws an exception if the user isn't logged in
+*       user: await getUserByTokenIdentifier(ctx),
+*     };
+*   })
+* );
+*
+* // Using it
+* export const setMyName = myUserMutation({
+*   args: { name: v.string() },
+*   handler: async (ctx, args) => {
+*     await ctx.db.patch(ctx.user._id, { name: args.name });
+*   },
+* });
+*
+* @param mutation The mutation to be modified. Usually `mutation` or `internalMutation`
+*   from `_generated/server`.
+* @param customization The modifier to be applied to the mutation, changing ctx and args.
+* @returns A new mutation builder to define queries with modified ctx and args.
+*/
+function customMutation(mutation, customization) {
+	return customFnBuilder(mutation, customization);
+}
+function customFnBuilder(builder, customization) {
+	const customInput = customization.input ?? NoOp.input;
+	const inputArgs = customization.args ?? NoOp.args;
+	return function customBuilder(fn) {
+		const { args, handler = fn, returns, ...extra } = fn;
+		if (args) return builder({
+			args: addFieldsToValidator(args, inputArgs),
+			returns,
+			handler: async (ctx, allArgs) => {
+				const added = await customInput(ctx, pick(allArgs, Object.keys(inputArgs)), extra);
+				const args = omit(allArgs, Object.keys(inputArgs));
+				const result = await handler({
+					...ctx,
+					...added.ctx
+				}, {
+					...args,
+					...added.args
+				});
+				if (added.onSuccess) await added.onSuccess({
+					ctx,
+					args,
+					result
+				});
+				return result;
+			}
+		});
+		if (Object.keys(inputArgs).length > 0) throw new Error("If you're using a custom function with arguments for the input customization, you must declare the arguments for the function too.");
+		return builder({
+			returns: fn.returns,
+			handler: async (ctx, args) => {
+				const added = await customInput(ctx, args, extra);
+				const result = await handler({
+					...ctx,
+					...added.ctx
+				}, {
+					...args,
+					...added.args
+				});
+				if (added.onSuccess) await added.onSuccess({
+					ctx,
+					args,
+					result
+				});
+				return result;
+			}
+		});
+	};
+}
+
+//#endregion
+export { customCtx as n, customMutation as r, NoOp as t };

package/dist/error-BZEnI7Sq.js

@@ -0,0 +1,41 @@
+//#region src/crpc/error.ts
+/**
+* Client-side CRPC error.
+* Mirrors backend CRPCError pattern with typed error codes.
+*/
+var CRPCClientError = class extends Error {
+	name = "CRPCClientError";
+	code;
+	functionName;
+	constructor(opts) {
+		super(opts.message ?? `${opts.code}: ${opts.functionName}`);
+		this.code = opts.code;
+		this.functionName = opts.functionName;
+	}
+};
+/** Type guard for CRPCClientError */
+const isCRPCClientError = (error) => error instanceof CRPCClientError;
+/**
+* Unified check for any deterministic CRPC error (Convex or HTTP).
+* Use in retry logic to skip retrying client errors (4xx).
+*/
+const isCRPCError = (error) => {
+	if (error instanceof CRPCClientError) return true;
+	if (error instanceof Error && error.name === "HttpClientError" && "status" in error && typeof error.status === "number") return error.status < 500;
+	return false;
+};
+/** Type guard for specific error code */
+const isCRPCErrorCode = (error, code) => isCRPCClientError(error) && error.code === code;
+/** Default unauthorized detection - checks UNAUTHORIZED code */
+const defaultIsUnauthorized = (error) => {
+	if (!error || typeof error !== "object") return false;
+	if ("data" in error) {
+		const data = error.data;
+		if (data && typeof data === "object" && "code" in data) return data.code === "UNAUTHORIZED";
+	}
+	if ("code" in error) return error.code === "UNAUTHORIZED";
+	return false;
+};
+
+//#endregion
+export { isCRPCErrorCode as a, isCRPCError as i, defaultIsUnauthorized as n, isCRPCClientError as r, CRPCClientError as t };

package/dist/generated-contract-disabled-Cih4eITO.js

@@ -0,0 +1,50 @@
+//#region src/auth/define-auth.ts
+const defineAuth = (definition) => definition;
+
+//#endregion
+//#region src/auth/generated-contract-disabled.ts
+const DEFAULT_AUTH_DEFINITION_PATH = "convex/auth.ts";
+const resolveAuthDefinitionPath = (authDefinitionPath) => {
+	const normalized = authDefinitionPath?.trim();
+	return normalized && normalized.length > 0 ? normalized : DEFAULT_AUTH_DEFINITION_PATH;
+};
+const getGeneratedAuthDisabledReason = (kind, authDefinitionPath) => {
+	const resolvedAuthDefinitionPath = resolveAuthDefinitionPath(authDefinitionPath);
+	switch (kind) {
+		case "default_export_unavailable": return `Auth runtime is disabled. ${resolvedAuthDefinitionPath} default export is unavailable. Export \`default defineAuth((ctx) => ({ ...options, triggers }))\` and run \`kitcn codegen\`.`;
+		case "missing_auth_file": return `Auth runtime is disabled. Create ${resolvedAuthDefinitionPath} with \`export default defineAuth(...)\` and run \`kitcn codegen\`.`;
+		case "missing_default_export": return `Auth runtime is disabled. ${resolvedAuthDefinitionPath} exists but does not export a default auth definition. Export \`default defineAuth((ctx) => ({ ...options, triggers }))\` and run \`kitcn codegen\`.`;
+	}
+};
+const DEFAULT_DISABLED_AUTH_MESSAGE = getGeneratedAuthDisabledReason("missing_auth_file");
+const createDisabledError = (message, exportName) => () => {
+	throw new Error(`${message} (${exportName})`);
+};
+const createDisabledRuntimeExport = (message, exportName) => createDisabledError(message, exportName);
+const createDisabledAuthRuntime = (config) => {
+	const message = config?.reason ?? DEFAULT_DISABLED_AUTH_MESSAGE;
+	return {
+		authEnabled: false,
+		authClient: {
+			authFunctions: {},
+			triggers: void 0,
+			adapter: createDisabledError(message, "authClient.adapter")
+		},
+		auth: new Proxy({}, { get() {
+			throw new Error(`${message} (auth)`);
+		} }),
+		getAuth: createDisabledError(message, "getAuth"),
+		create: createDisabledRuntimeExport(message, "create"),
+		deleteMany: createDisabledRuntimeExport(message, "deleteMany"),
+		deleteOne: createDisabledRuntimeExport(message, "deleteOne"),
+		findMany: createDisabledRuntimeExport(message, "findMany"),
+		findOne: createDisabledRuntimeExport(message, "findOne"),
+		updateMany: createDisabledRuntimeExport(message, "updateMany"),
+		updateOne: createDisabledRuntimeExport(message, "updateOne"),
+		getLatestJwks: createDisabledRuntimeExport(message, "getLatestJwks"),
+		rotateKeys: createDisabledRuntimeExport(message, "rotateKeys")
+	};
+};
+
+//#endregion
+export { defineAuth as i, createDisabledAuthRuntime as n, getGeneratedAuthDisabledReason as r, DEFAULT_AUTH_DEFINITION_PATH as t };