lazyconvex 0.0.0

package/dist/next/index.mjs

@@ -0,0 +1,151 @@
+import { fetchQuery } from "convex/nextjs";
+import { cookies } from "next/headers";
+import { convexAuthNextjsToken } from "@convex-dev/auth/nextjs/server";
+import { ConvexHttpClient } from "convex/browser";
+import { NextResponse } from "next/server";
+import sharp from "sharp";
+
+//#region src/next/active-org.ts
+const setActiveOrgCookie = async ({ orgId, slug }) => {
+	const cookieStore = await cookies(), opts = {
+		httpOnly: false,
+		maxAge: 3600 * 24 * 365,
+		path: "/"
+	};
+	cookieStore.set("activeOrgId", orgId, opts);
+	cookieStore.set("activeOrgSlug", slug, opts);
+}, clearActiveOrgCookie = async () => {
+	const cookieStore = await cookies();
+	cookieStore.delete("activeOrgId");
+	cookieStore.delete("activeOrgSlug");
+}, getActiveOrg = async ({ query, token }) => {
+	if (!token) return null;
+	const cookieStore = await cookies(), orgId = cookieStore.get("activeOrgId")?.value;
+	if (!orgId) return null;
+	try {
+		return await fetchQuery(query, { orgId }, { token });
+	} catch {
+		cookieStore.delete("activeOrgId");
+		cookieStore.delete("activeOrgSlug");
+		return null;
+	}
+};
+
+//#endregion
+//#region src/next/auth.ts
+const isTest = Boolean(process.env.PLAYWRIGHT || process.env.TEST_MODE), getToken = async () => isTest ? void 0 : convexAuthNextjsToken(), isAuthenticated = async () => isTest || Boolean(await convexAuthNextjsToken());
+
+//#endregion
+//#region src/next/image.ts
+const IMAGE_TYPES = new Set([
+	"image/gif",
+	"image/jpeg",
+	"image/png",
+	"image/svg+xml",
+	"image/webp"
+]), isImageType = (contentType) => IMAGE_TYPES.has(contentType), formatToMime = {
+	jpeg: "image/jpeg",
+	png: "image/png",
+	webp: "image/webp"
+}, applyFormat = ({ contentType, format, pipeline, quality }) => {
+	if (format === "jpeg") return pipeline.jpeg({ quality });
+	if (format === "png") return pipeline.png({ quality });
+	if (format === "webp") return pipeline.webp({ quality });
+	const [, ext] = contentType.split("/");
+	if (ext === "jpeg" || ext === "jpg") return pipeline.jpeg({ quality });
+	if (ext === "png") return pipeline.png({ quality });
+	if (ext === "webp") return pipeline.webp({ quality });
+	return pipeline;
+}, applyTransforms = ({ contentType, options, pipeline, thumbnail }) => {
+	const quality = options?.compress?.quality ?? 80;
+	if (thumbnail) return pipeline.resize({
+		fit: "cover",
+		height: 200,
+		width: 200
+	}).webp({ quality: 80 });
+	let result = pipeline;
+	if (options?.resize) result = result.resize({
+		fit: options.resize.fit ?? "cover",
+		height: options.resize.height,
+		width: options.resize.width
+	});
+	if (options?.format || options?.compress) result = applyFormat({
+		contentType,
+		format: options.format,
+		pipeline: result,
+		quality
+	});
+	return result;
+}, fetchImage = async ({ client, queryRef, storageId }) => {
+	const url = (await client.query(queryRef, { id: storageId }))?.url;
+	if (!url) return {
+		error: "File not found",
+		status: 404
+	};
+	const response = await fetch(url);
+	if (!response.ok) return {
+		error: "Failed to fetch image",
+		status: 500
+	};
+	const contentType = response.headers.get("content-type") ?? "";
+	if (!isImageType(contentType)) return {
+		error: "Not an image file",
+		status: 400
+	};
+	return {
+		buffer: Buffer.from(await response.arrayBuffer()),
+		contentType
+	};
+}, makeGet = ({ getClient, queryRef }) => async (req) => {
+	try {
+		const storageId = req.nextUrl.searchParams.get("id");
+		if (!storageId) return NextResponse.json({ error: "id is required" }, { status: 400 });
+		const result = await fetchImage({
+			client: getClient(),
+			queryRef,
+			storageId
+		});
+		if ("error" in result) return NextResponse.json({ error: result.error }, { status: result.status });
+		return new NextResponse(new Uint8Array(result.buffer), { headers: {
+			"Cache-Control": "public, max-age=31536000, immutable",
+			"Content-Type": result.contentType
+		} });
+	} catch (error) {
+		return NextResponse.json({ error: error instanceof Error ? error.message : "Failed to fetch image" }, { status: 500 });
+	}
+}, makePost = ({ getClient, queryRef }) => async (req) => {
+	try {
+		const { options, storageId, thumbnail } = await req.json();
+		if (!storageId) return NextResponse.json({ error: "storageId is required" }, { status: 400 });
+		const result = await fetchImage({
+			client: getClient(),
+			queryRef,
+			storageId
+		});
+		if ("error" in result) return NextResponse.json({ error: result.error }, { status: result.status });
+		const { buffer, contentType } = result, outputBuffer = await applyTransforms({
+			contentType,
+			options,
+			pipeline: sharp(buffer),
+			thumbnail: thumbnail ?? false
+		}).toBuffer(), outputMime = thumbnail ? "image/webp" : options?.format ? formatToMime[options.format] : contentType;
+		return new NextResponse(new Uint8Array(outputBuffer), { headers: {
+			"Cache-Control": "public, max-age=31536000, immutable",
+			"Content-Type": outputMime
+		} });
+	} catch (error) {
+		return NextResponse.json({ error: error instanceof Error ? error.message : "Processing failed" }, { status: 500 });
+	}
+}, makeImageRoute = async ({ convexUrl, fileInfoQuery = "file:info" }) => {
+	const getClient = () => new ConvexHttpClient(convexUrl), opts = {
+		getClient,
+		queryRef: fileInfoQuery
+	};
+	return {
+		GET: makeGet(opts),
+		POST: makePost(opts)
+	};
+};
+
+//#endregion
+export { clearActiveOrgCookie, getActiveOrg, getToken, isAuthenticated, makeImageRoute, setActiveOrgCookie };

package/dist/org-CmJBb8z-.d.mts

@@ -0,0 +1,56 @@
+import { w as OrgRole } from "./types-DWBVRtit.mjs";
+import { FunctionReference } from "convex/server";
+import { ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/react/org.d.ts
+interface OrgContextValue<O extends OrgDoc = OrgDoc, M = unknown> {
+  canDeleteOrg: boolean;
+  canManageAdmins: boolean;
+  canManageMembers: boolean;
+  isAdmin: boolean;
+  isMember: boolean;
+  isOwner: boolean;
+  membership: M | null;
+  org: O;
+  orgId: string;
+  role: OrgRole;
+}
+interface OrgDoc {
+  [key: string]: unknown;
+  _id: string;
+}
+interface OrgProviderProps<O extends OrgDoc, M> {
+  children: ReactNode;
+  membership: M | null;
+  org: O;
+  role: OrgRole;
+}
+declare const OrgProvider: <O extends OrgDoc, M>({
+    children,
+    membership,
+    org,
+    role
+  }: OrgProviderProps<O, M>) => react_jsx_runtime0.JSX.Element, useOrg: <O extends OrgDoc = OrgDoc, M = unknown>() => OrgContextValue<O, M>, useOrgQuery: <F extends FunctionReference<"query">>(query: F, args?: "skip" | Omit<F["_args"], "orgId">) => F["_returnType"] | undefined, useOrgMutation: <F extends FunctionReference<"mutation">>(mutation: F) => (args?: Omit<F["_args"], "orgId">) => Promise<F["_returnType"]>, canEditResource: ({
+    editorsList,
+    isAdmin,
+    resource,
+    userId
+  }: {
+    editorsList: {
+      userId: string;
+    }[];
+    isAdmin: boolean;
+    resource: {
+      userId: string;
+    };
+    userId: string;
+  }) => boolean, useMyOrgs: <O extends OrgDoc>(myOrgsQuery: FunctionReference<"query">) => {
+    isLoading: boolean;
+    orgs: {
+      org: O;
+      role: OrgRole;
+    }[];
+  };
+//#endregion
+export { canEditResource as a, useOrgMutation as c, OrgProviderProps as i, useOrgQuery as l, OrgDoc as n, useMyOrgs as o, OrgProvider as r, useOrg as s, OrgContextValue as t };

package/dist/react/index.mjs

@@ -0,0 +1,158 @@
+import "../error-D4GuI0ot.mjs";
+import { a as getMeta, i as buildMeta, n as useForm, r as useFormMutation, t as useOnlineStatus } from "../use-online-status-CMr73Jlk.mjs";
+import { t as useUpload } from "../use-upload-DtELytQi.mjs";
+import { useMutation, useQuery } from "convex/react";
+import { createContext, use, useCallback, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/react/org.tsx
+const OrgContext = createContext(null);
+const OrgProvider = ({ children, membership, org, role }) => {
+	return /* @__PURE__ */ jsx(OrgContext, {
+		value: useMemo(() => {
+			const isOwner = role === "owner", isAdmin = role === "owner" || role === "admin";
+			return {
+				canDeleteOrg: isOwner,
+				canManageAdmins: isOwner,
+				canManageMembers: isAdmin,
+				isAdmin,
+				isMember: true,
+				isOwner,
+				membership,
+				org,
+				orgId: org._id,
+				role
+			};
+		}, [
+			membership,
+			org,
+			role
+		]),
+		children
+	});
+}, useOrg = () => {
+	const ctx = use(OrgContext);
+	if (!ctx) throw new Error("useOrg must be used inside OrgProvider");
+	return ctx;
+}, useOrgQuery = (query, args) => {
+	const { orgId } = useOrg();
+	return useQuery(query, args === "skip" ? "skip" : {
+		...args,
+		orgId
+	});
+}, useOrgMutation = (mutation) => {
+	const { orgId } = useOrg(), mutate = useMutation(mutation);
+	return useCallback(async (args) => mutate({
+		...args,
+		orgId
+	}), [mutate, orgId]);
+}, canEditResource = ({ editorsList, isAdmin, resource, userId }) => isAdmin || resource.userId === userId || editorsList.some((e) => e.userId === userId), useMyOrgs = (myOrgsQuery) => {
+	const data = useQuery(myOrgsQuery);
+	return {
+		isLoading: data === void 0,
+		orgs: data ?? []
+	};
+};
+
+//#endregion
+//#region src/react/use-active-org.ts
+const ACTIVE_ORG_REGEX = /activeOrgId=(?<id>[^;]+)/u, getActiveOrgIdFromCookie = () => {
+	if (typeof document === "undefined") return null;
+	return ACTIVE_ORG_REGEX.exec(document.cookie)?.groups?.id ?? null;
+}, setActiveOrgCookieClient = ({ orgId, slug }) => {
+	const maxAge = 3600 * 24 * 365;
+	document.cookie = `activeOrgId=${orgId}; path=/; max-age=${maxAge}`;
+	document.cookie = `activeOrgSlug=${slug}; path=/; max-age=${maxAge}`;
+}, useActiveOrg = (orgGetQuery) => {
+	const [activeOrgId, setActiveOrgId] = useState(getActiveOrgIdFromCookie), activeOrg = useQuery(orgGetQuery, activeOrgId ? { orgId: activeOrgId } : "skip"), setActiveOrg = useCallback((org) => {
+		setActiveOrgCookieClient({
+			orgId: org._id,
+			slug: org.slug
+		});
+		setActiveOrgId(org._id);
+	}, []), clearActiveOrg = useCallback(() => {
+		document.cookie = "activeOrgId=; path=/; max-age=0";
+		document.cookie = "activeOrgSlug=; path=/; max-age=0";
+		setActiveOrgId(null);
+	}, []);
+	return {
+		activeOrg: activeOrg ?? null,
+		activeOrgId,
+		clearActiveOrg,
+		isLoading: activeOrgId ? activeOrg === void 0 : false,
+		setActiveOrg
+	};
+};
+
+//#endregion
+//#region src/react/use-bulk-selection.ts
+const useBulkSelection = ({ bulkRm, items, onError, onSuccess, orgId }) => {
+	const [selected, setSelected] = useState(/* @__PURE__ */ new Set()), clear = () => {
+		setSelected(/* @__PURE__ */ new Set());
+	}, toggleSelect = (id) => {
+		setSelected((prev) => {
+			const next = new Set(prev);
+			if (next.has(id)) next.delete(id);
+			else next.add(id);
+			return next;
+		});
+	}, toggleSelectAll = () => {
+		if (selected.size === items.length) setSelected(/* @__PURE__ */ new Set());
+		else setSelected(new Set(items.map((i) => i._id)));
+	}, handleBulkDelete = () => {
+		if (selected.size === 0) return;
+		const count = selected.size;
+		bulkRm({
+			ids: [...selected],
+			orgId
+		}).then(() => {
+			onSuccess?.(count);
+			setSelected(/* @__PURE__ */ new Set());
+			return null;
+		}).catch((bulkError) => onError?.(bulkError));
+	};
+	return {
+		clear,
+		handleBulkDelete,
+		selected,
+		toggleSelect,
+		toggleSelectAll
+	};
+};
+
+//#endregion
+//#region src/react/use-optimistic.ts
+const useOptimisticMutation = ({ mutation, onOptimistic, onRollback, onSuccess }) => {
+	const mutate = useMutation(mutation), [isPending, setIsPending] = useState(false), [mutationError, setMutationError] = useState(null), pendingCount = useRef(0);
+	return {
+		error: mutationError,
+		execute: useCallback(async (args) => {
+			pendingCount.current += 1;
+			setIsPending(true);
+			setMutationError(null);
+			onOptimistic?.(args);
+			try {
+				const result = await mutate(args);
+				onSuccess?.(result, args);
+				return result;
+			} catch (error) {
+				const err = error instanceof Error ? error : /* @__PURE__ */ new Error("Mutation failed");
+				setMutationError(err);
+				onRollback?.(args, err);
+				return null;
+			} finally {
+				pendingCount.current -= 1;
+				if (pendingCount.current === 0) setIsPending(false);
+			}
+		}, [
+			mutate,
+			onOptimistic,
+			onRollback,
+			onSuccess
+		]),
+		isPending
+	};
+};
+
+//#endregion
+export { OrgProvider, buildMeta, canEditResource, getMeta, setActiveOrgCookieClient, useActiveOrg, useBulkSelection, useForm, useFormMutation, useMyOrgs, useOnlineStatus, useOptimisticMutation, useOrg, useOrgMutation, useOrgQuery, useUpload };

package/dist/retry.d.mts

@@ -0,0 +1,12 @@
+//#region src/retry.d.ts
+interface RetryOptions {
+  base?: number;
+  initialDelayMs?: number;
+  maxAttempts?: number;
+  maxDelayMs?: number;
+}
+declare const withRetry: <T>(fn: () => Promise<T>, options?: RetryOptions) => Promise<T>, fetchWithRetry: (url: string, options?: RequestInit & {
+    retry?: RetryOptions;
+  }) => Promise<Response>;
+//#endregion
+export { fetchWithRetry, withRetry };

package/dist/retry.mjs

@@ -0,0 +1,35 @@
+//#region src/retry.ts
+const DEFAULT_OPTIONS = {
+	base: 2,
+	initialDelayMs: 500,
+	maxAttempts: 3,
+	maxDelayMs: 1e4
+}, sleep = async (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+}), calculateDelay = (attempt, opts) => {
+	const jitter = Math.random() * .3 + .85;
+	return Math.min(opts.initialDelayMs * opts.base ** attempt * jitter, opts.maxDelayMs);
+}, withRetry = async (fn, options = {}) => {
+	const opts = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	let lastError = /* @__PURE__ */ new Error("Retry failed");
+	for (let attempt = 0; attempt < opts.maxAttempts; attempt += 1) try {
+		return await fn();
+	} catch (error) {
+		lastError = error instanceof Error ? error : new Error(String(error));
+		if (attempt < opts.maxAttempts - 1) await sleep(calculateDelay(attempt, opts));
+	}
+	throw lastError;
+}, fetchWithRetry = async (url, options) => {
+	const { retry, ...fetchOptions } = options ?? {};
+	return withRetry(async () => {
+		const response = await fetch(url, fetchOptions);
+		if (!response.ok && response.status >= 500) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		return response;
+	}, retry);
+};
+
+//#endregion
+export { fetchWithRetry, withRetry };

package/dist/schema.d.mts

@@ -0,0 +1,23 @@
+import * as zod_v40 from "zod/v4";
+import { ZodObject, ZodRawShape } from "zod/v4";
+import * as convex_helpers_server_zod40 from "convex-helpers/server/zod4";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/schema.d.ts
+declare const cvFile: () => convex_helpers_server_zod40.Zid<"_storage">, cvFiles: () => zod_v40.ZodArray<convex_helpers_server_zod40.Zid<"_storage">>, child: <const P extends string, const S extends ZodRawShape, const FK extends keyof S & string>(config: {
+    foreignKey: FK;
+    index?: string;
+    parent: P;
+    schema: ZodObject<S>;
+  }) => {
+    foreignKey: FK;
+    index: string;
+    parent: P;
+    schema: ZodObject<S>;
+  }, orgSchema: ZodObject<{
+    avatarId: zod_v40.ZodOptional<zod_v40.ZodNullable<convex_helpers_server_zod40.Zid<"_storage">>>;
+    name: zod_v40.ZodString;
+    slug: zod_v40.ZodString;
+  }, zod_v4_core0.$strip>;
+//#endregion
+export { child, cvFile, cvFiles, orgSchema };

package/dist/schema.mjs

@@ -0,0 +1,15 @@
+import { array, object, string } from "zod/v4";
+import { zid } from "convex-helpers/server/zod4";
+
+//#region src/schema.ts
+const cvFile = () => zid("_storage").meta({ cv: "file" }), cvFiles = () => array(cvFile()).meta({ cv: "files" }), child = (config) => ({
+	...config,
+	index: config.index ?? `by_${config.parent}`
+}), orgSchema = object({
+	avatarId: zid("_storage").nullable().optional(),
+	name: string().min(1),
+	slug: string().min(1).regex(/^[a-z0-9-]+$/u)
+});
+
+//#endregion
+export { child, cvFile, cvFiles, orgSchema };