@robelest/convex-auth 0.0.4-preview.25 → 0.0.4-preview.28

package/dist/server/auth.js

@@ -1,19 +1,14 @@
-import { createUnauthenticatedAuthContext, getAuthContext } from "./context.js";
+import { assertAuthResolverContext, createAuthContextCustomization, createPublicAuthContext } from "./auth-context.js";
 import { Auth } from "./runtime.js";
-import { Cv } from "@robelest/fx/convex";
+import { ConvexError } from "convex/values";
 
 //#region src/server/auth.ts
 /**
-* Auth configuration helpers for Convex Auth.
-*
-* @module
-*/
-/**
 * Create an auth API object.
 *
-* When `new SSO()` is included in providers, `auth.sso` and `auth.scim`
-* are available on the returned object. Without it, those namespaces are
-* absent and accessing them is a TypeScript compile error.
+* When `sso()` is included in providers, `auth.group.sso` is available
+* on the returned object. Without it, that namespace is absent and
+* accessing it is a TypeScript compile error.
 *
 * @param component - The installed auth component reference from
 *   `components.auth` in your Convex app definition.
@@ -21,7 +16,7 @@ import { Cv } from "@robelest/fx/convex";
 *   `authorization`. All fields from {@link AuthConfig} are accepted
 *   except `component` (passed as the first argument).
 * @returns A {@link ConvexAuthResult} object — either {@link AuthApi}
-*   (with `sso`/`scim`) or {@link AuthApiBase}, depending on whether
+*   (with `group.sso`) or {@link AuthApiBase}, depending on whether
 *   an SSO provider is present.
 *
 * @example
@@ -34,29 +29,6 @@ import { Cv } from "@robelest/fx/convex";
 *
 * @see {@link AuthContextConfig}
 */
-async function resolveConfiguredAuthContext(auth, ctx, config) {
-	const fallback = () => getAuthContext(auth, ctx);
-	const authOverride = config?.authResolve ? await config.authResolve(ctx, fallback) : void 0;
-	return authOverride === void 0 ? await fallback() : authOverride;
-}
-function createNotSignedInError() {
-	return Cv.error({
-		code: "NOT_SIGNED_IN",
-		message: "Authentication required."
-	});
-}
-async function createPublicAuthContext(auth, ctx, config) {
-	const resolved = await resolveConfiguredAuthContext(auth, ctx, config);
-	if (resolved === null) {
-		if (config?.optional !== true) throw createNotSignedInError();
-		return createUnauthenticatedAuthContext();
-	}
-	const extra = config?.resolve ? await config.resolve(ctx, resolved.user, resolved) : {};
-	return {
-		...resolved,
-		...extra
-	};
-}
 function createAuth(component, config) {
 	const authResult = Auth({
 		...config,
@@ -64,11 +36,11 @@ function createAuth(component, config) {
 		providers: [...config.providers]
 	});
 	const { domain: domainApi, scim: scimApi, connection: connectionApi, audit: auditApi, webhook: webhookApi, oidc: oidcApi, saml: samlApi, ...restSso } = authResult.auth.sso;
-	const setEnterpriseDomains = async (ctx, enterpriseId, domains) => {
-		const enterprise = await connectionApi.get(ctx, enterpriseId);
-		if (enterprise === null) throw Cv.error({
+	const setGroupConnectionDomains = async (ctx, connectionId, domains) => {
+		const connection = await connectionApi.get(ctx, connectionId);
+		if (connection === null) throw new ConvexError({
 			code: "INVALID_PARAMETERS",
-			message: "Enterprise not found."
+			message: "Connection not found."
 		});
 		const normalized = domains.map((entry) => ({
 			...entry,
@@ -76,11 +48,11 @@ function createAuth(component, config) {
 		}));
 		const deduped = /* @__PURE__ */ new Map();
 		for (const entry of normalized) {
-			if (entry.domain.length === 0) throw Cv.error({
+			if (entry.domain.length === 0) throw new ConvexError({
 				code: "INVALID_PARAMETERS",
 				message: "Domain must not be empty."
 			});
-			if (deduped.has(entry.domain)) throw Cv.error({
+			if (deduped.has(entry.domain)) throw new ConvexError({
 				code: "INVALID_PARAMETERS",
 				message: `Duplicate domain: ${entry.domain}`
 			});
@@ -88,7 +60,7 @@ function createAuth(component, config) {
 		}
 		const nextDomains = [...deduped.values()];
 		const primaryCount = nextDomains.filter((entry) => entry.isPrimary).length;
-		if (primaryCount > 1) throw Cv.error({
+		if (primaryCount > 1) throw new ConvexError({
 			code: "INVALID_PARAMETERS",
 			message: "Only one primary domain may be set."
 		});
@@ -96,7 +68,7 @@ function createAuth(component, config) {
 			...nextDomains[0],
 			isPrimary: true
 		};
-		const currentDomains = await domainApi.list(ctx, enterpriseId);
+		const currentDomains = await domainApi.list(ctx, connectionId);
 		const currentByDomain = new Map(currentDomains.map((entry) => [entry.domain.toLowerCase(), entry]));
 		for (const existing of currentDomains) if (!deduped.has(existing.domain.toLowerCase())) await domainApi.remove(ctx, existing._id);
 		for (const nextDomain of nextDomains) {
@@ -104,54 +76,57 @@ function createAuth(component, config) {
 			if (current && current.isPrimary === Boolean(nextDomain.isPrimary)) continue;
 			if (current) await domainApi.remove(ctx, current._id);
 			const domainId = await domainApi.add(ctx, {
-				enterpriseId: enterprise._id,
-				groupId: enterprise.groupId,
+				connectionId: connection._id,
+				groupId: connection.groupId,
 				domain: nextDomain.domain,
-				isPrimary: nextDomain.isPrimary
+				isPrimary: Boolean(nextDomain.isPrimary)
 			});
-			if (current?.verifiedAt !== void 0) await ctx.runMutation(component.public.enterpriseDomainVerify, {
+			if (current?.verifiedAt !== void 0) await ctx.runMutation(component.public.groupConnectionDomainVerify, {
 				domainId,
 				verifiedAt: current.verifiedAt
 			});
 		}
 		return {
-			enterpriseId,
-			domains: (await domainApi.list(ctx, enterpriseId)).map((domain) => ({
+			connectionId,
+			domains: (await domainApi.list(ctx, connectionId)).map((domain) => ({
 				domainId: domain._id,
 				domain: domain.domain,
-				isPrimary: domain.isPrimary,
+				isPrimary: Boolean(domain.isPrimary),
 				verified: domain.verifiedAt !== void 0,
 				verifiedAt: domain.verifiedAt ?? null
 			}))
 		};
 	};
-	const publicSso = {
-		admin: {
-			...restSso,
-			oidc: { ...oidcApi },
-			saml: { ...samlApi },
-			connection: {
-				...connectionApi,
-				domain: {
-					list: domainApi.list,
-					validate: domainApi.validate,
-					set: setEnterpriseDomains,
-					verification: {
-						request: domainApi.verification.request,
-						confirm: domainApi.verification.confirm
-					}
+	const publicGroupSso = {
+		...restSso,
+		signIn: oidcApi.signIn,
+		metadata: samlApi.metadata,
+		oidc: { ...oidcApi },
+		saml: { ...samlApi },
+		connection: {
+			...connectionApi,
+			domain: {
+				list: domainApi.list,
+				validate: domainApi.validate,
+				status: domainApi.status,
+				set: setGroupConnectionDomains,
+				verification: {
+					request: domainApi.verification.request,
+					confirm: domainApi.verification.confirm
 				}
-			},
-			policy: restSso.policy,
-			audit: { list: auditApi.list },
-			webhook: {
-				endpoint: webhookApi.endpoint,
-				delivery: { list: webhookApi.delivery.list }
 			}
 		},
-		client: {
-			signIn: oidcApi.signIn,
-			metadata: samlApi.metadata
+		policy: restSso.policy,
+		audit: { list: auditApi.list },
+		webhook: {
+			endpoint: webhookApi.endpoint,
+			delivery: { list: webhookApi.delivery.list }
+		},
+		scim: {
+			configure: scimApi.configure,
+			get: scimApi.get,
+			status: scimApi.status,
+			validate: scimApi.validate
 		}
 	};
 	return {
@@ -162,92 +137,21 @@ function createAuth(component, config) {
 		session: authResult.auth.session,
 		provider: authResult.auth.provider,
 		account: authResult.auth.account,
-		group: authResult.auth.group,
+		group: {
+			...authResult.auth.group,
+			sso: publicGroupSso
+		},
 		member: authResult.auth.member,
 		invite: authResult.auth.invite,
 		key: authResult.auth.key,
-		sso: publicSso,
-		scim: { admin: {
-			configure: scimApi.configure,
-			get: scimApi.get,
-			validate: scimApi.validate
-		} },
 		http: authResult.auth.http,
-		context: ((ctx, config$1) => createPublicAuthContext(authResult.auth, ctx, config$1)),
+		context: ((ctx, config$1) => {
+			assertAuthResolverContext(ctx);
+			return createPublicAuthContext(authResult.auth, ctx, config$1);
+		}),
 		ctx: ((config$1) => createAuthContextCustomization(authResult.auth, config$1))
 	};
 }
-/**
-* Create a context enrichment for `customQuery` / `customMutation` — optional auth.
-*
-* When `optional: true` is set, unauthenticated requests are allowed.
-* The enriched `ctx.auth` will have `userId: null`, `user: null`,
-* `groupId: null`, `role: null`, and `grants: []` for unauthenticated callers.
-*
-* @param config - Configuration with `optional: true` and an optional
-*   `resolve` callback for attaching extra fields to the auth context.
-* @returns An object with `args` and `input` compatible with Convex
-*   custom function builders.
-*
-* @example
-* ```ts
-* const authCtx = auth.ctx({
-*   optional: true,
-*   resolve: async (_ctx, user) => ({ plan: user.extend?.plan ?? null }),
-* });
-* ```
-*
-* @see {@link createAuth}
-*/
-/**
-* Create a context enrichment for `customQuery` / `customMutation` — required auth (default).
-*
-* When `optional` is omitted or `false`, unauthenticated requests throw a
-* structured `ConvexError` before your handler runs.
-*
-* @param config - Optional configuration with a `resolve` callback
-*   for attaching extra fields to the auth context.
-* @returns An object with `args` and `input` compatible with Convex
-*   custom function builders.
-*
-* @example
-* ```ts
-* const authCtx = auth.ctx({
-*   resolve: async (_ctx, user) => ({ email: user.email }),
-* });
-* ```
-*
-* @see {@link createAuth}
-*/
-function createAuthContextCustomization(auth, config) {
-	return {
-		args: {},
-		input: async (ctx, _args, _extra) => {
-			const nativeAuth = ctx.auth;
-			const getUserIdentity = nativeAuth.getUserIdentity.bind(nativeAuth);
-			const resolved = await resolveConfiguredAuthContext(auth, ctx, config);
-			if (resolved === null) {
-				if (config?.optional !== true) throw createNotSignedInError();
-				return {
-					ctx: { auth: {
-						getUserIdentity,
-						...createUnauthenticatedAuthContext()
-					} },
-					args: {}
-				};
-			}
-			const extra = config?.resolve ? await config.resolve(ctx, resolved.user, resolved) : {};
-			return {
-				ctx: { auth: {
-					getUserIdentity,
-					...resolved,
-					...extra
-				} },
-				args: {}
-			};
-		}
-	};
-}
 
 //#endregion
 export { createAuth };

package/dist/server/componentContext.d.ts

@@ -0,0 +1,12 @@
+import { GenericDataModel, GenericMutationCtx, GenericQueryCtx } from "convex/server";
+
+//#region src/server/componentContext.d.ts
+type ComponentReadCtx = {
+  runQuery: GenericQueryCtx<GenericDataModel>["runQuery"];
+};
+type ComponentCtx = ComponentReadCtx & {
+  runMutation: GenericMutationCtx<GenericDataModel>["runMutation"];
+};
+//#endregion
+export { ComponentCtx, ComponentReadCtx };
+//# sourceMappingURL=componentContext.d.ts.map

package/dist/server/componentContext.js

@@ -0,0 +1 @@
+export {  };

package/dist/server/config.js

@@ -1,16 +1,7 @@
-import { isOAuthProvider } from "../providers/oauth.js";
-
 //#region src/server/config.ts
-/** Check if something is a new-style class provider with `_toMaterialized()`. */
-function isClassProvider(provider) {
-	return typeof provider === "object" && provider !== null && typeof provider._toMaterialized === "function";
-}
 /**
 * Resolve raw provider configs into materialized form and apply defaults.
-*
-* @internal
 */
-/** @internal */
 function configDefaults(config_) {
 	const config = materializeAndDefaultProviders(config_);
 	const extraProviders = config.providers.filter((p) => p.type === "credentials").map((p) => p.extraProviders).flat().filter((p) => p !== void 0);
@@ -21,25 +12,8 @@ function configDefaults(config_) {
 	};
 }
 /**
-* Materialize a single provider config into its runtime form.
-*
-* @internal
-*/
-/** @internal */
-function materializeProvider(provider) {
-	const config = {
-		providers: [provider],
-		component: {}
-	};
-	materializeAndDefaultProviders(config);
-	return config.providers[0];
-}
-/**
 * List available provider IDs for error messages.
-*
-* @internal
 */
-/** @internal */
 function listAvailableProviders(config, allowExtraProviders) {
 	const availableProviders = config.providers.concat(allowExtraProviders ? config.extraProviders : []).map((provider) => `\`${provider.id}\``);
 	return availableProviders.length > 0 ? availableProviders.join(", ") : "no providers have been configured";
@@ -52,35 +26,12 @@ function materializeProviders(providers) {
 	materializeAndDefaultProviders(config);
 	return config.providers;
 }
-function decodeProviderMaterializationDispatch(raw) {
-	if (isOAuthProvider(raw)) return {
-		tag: "oauth",
-		raw
-	};
-	if (isClassProvider(raw)) return {
-		tag: "class",
-		raw
-	};
-	return {
-		tag: "factoryOrObject",
-		raw
-	};
-}
-function matchProviderMaterializationDispatch(dispatch, handlers) {
-	return handlers[dispatch.tag](dispatch);
-}
 function materializeProviderConfig(raw) {
-	return matchProviderMaterializationDispatch(decodeProviderMaterializationDispatch(raw), {
-		oauth: (d) => materializeOAuthProvider(d.raw),
-		class: (d) => d.raw._toMaterialized(),
-		factoryOrObject: (d) => {
-			const resolved = typeof d.raw === "function" ? d.raw() : d.raw;
-			return resolved.options ? {
-				...resolved,
-				...resolved.options
-			} : resolved;
-		}
-	});
+	const resolved = typeof raw === "function" ? raw() : raw;
+	return "options" in resolved && typeof resolved.options === "object" && resolved.options !== null ? {
+		...resolved,
+		...resolved.options
+	} : resolved;
 }
 function materializeAndDefaultProviders(config_) {
 	const allProviders = [];
@@ -103,19 +54,7 @@ function normalizeAuthorizationConfig(authorization) {
 		grants: Array.from(new Set(role.grants)).sort()
 	}])) };
 }
-/**
-* Materialize an Arctic-based `OAuthProviderInstance` into the runtime config.
-*/
-function materializeOAuthProvider(instance) {
-	return {
-		id: instance.id,
-		type: "oauth",
-		provider: instance.provider,
-		scopes: instance.scopes,
-		profile: instance.profile
-	};
-}
 
 //#endregion
-export { configDefaults, listAvailableProviders, materializeProvider };
+export { configDefaults, listAvailableProviders };
 //# sourceMappingURL=config.js.map

package/dist/server/constants.js

@@ -0,0 +1,6 @@
+//#region src/server/constants.ts
+const TOKEN_SUB_CLAIM_DIVIDER = "|";
+
+//#endregion
+export { TOKEN_SUB_CLAIM_DIVIDER };
+//# sourceMappingURL=constants.js.map

package/dist/server/contract.d.ts

@@ -0,0 +1,105 @@
+import "./componentContext.js";
+import "./types.js";
+
+//#region src/server/contract.d.ts
+type GroupConnectionRecord = {
+  _id: string;
+  _creationTime: number;
+  groupId: string;
+  slug?: string;
+  name?: string;
+  protocol: "oidc" | "saml";
+  status: "draft" | "active" | "disabled";
+  config?: unknown;
+  extend?: unknown;
+};
+type GroupConnectionDomainLookupRecord = {
+  connection: GroupConnectionRecord | null;
+  domain: ConnectionDomainRecord | null;
+};
+type GroupConnectionListResult = {
+  items: GroupConnectionRecord[];
+  nextCursor: string | null;
+};
+type ConnectionDomainRecord = {
+  _id: string;
+  _creationTime: number;
+  connectionId: string;
+  groupId: string;
+  domain: string;
+  isPrimary: boolean;
+  verifiedAt?: number;
+};
+type ScimConfigRecord = {
+  _id: string;
+  _creationTime: number;
+  connectionId: string;
+  groupId: string;
+  status: string;
+  basePath: string;
+  tokenHash: string;
+  lastRotatedAt?: number;
+  extend?: unknown;
+};
+type WebhookEndpointRecord = {
+  _id: string;
+  _creationTime: number;
+  connectionId: string;
+  groupId: string;
+  url: string;
+  status: string;
+  secretHash: string;
+  subscriptions: string[];
+  createdByUserId?: string;
+  lastSuccessAt?: number;
+  lastFailureAt?: number;
+  failureCount: number;
+  extend?: unknown;
+};
+type WebhookDeliveryRecord = {
+  _id: string;
+  _creationTime: number;
+  connectionId: string;
+  endpointId: string;
+  auditEventId?: string;
+  eventType: string;
+  status: string;
+  attemptCount: number;
+  nextAttemptAt: number;
+  lastAttemptAt?: number;
+  lastResponseStatus?: number;
+  lastError?: string;
+  payload: unknown;
+};
+type ScimIdentityRecord = {
+  _id: string;
+  _creationTime: number;
+  connectionId: string;
+  groupId: string;
+  resourceType: string;
+  externalId: string;
+  userId?: string;
+  mappedGroupId?: string;
+  active?: boolean;
+  raw?: Record<string, unknown>;
+  lastProvisionedAt?: number;
+};
+type AuditEventRecord = {
+  _id: string;
+  _creationTime: number;
+  connectionId?: string;
+  groupId: string;
+  eventType: string;
+  actorType: string;
+  actorId?: string;
+  subjectType: string;
+  subjectId?: string;
+  status: string;
+  occurredAt: number;
+  requestId?: string;
+  ip?: string;
+  metadata?: Record<string, unknown>;
+};
+//#endregion
+export { AuditEventRecord, ConnectionDomainRecord, GroupConnectionDomainLookupRecord, GroupConnectionListResult, GroupConnectionRecord, ScimConfigRecord, ScimIdentityRecord, WebhookDeliveryRecord, WebhookEndpointRecord };
+//# sourceMappingURL=contract.d.ts.map

package/dist/server/contract.js

@@ -0,0 +1,43 @@
+//#region src/server/contract.ts
+const query = (ctx, ref, args) => ctx.runQuery(ref, args);
+const mutate = (ctx, ref, args) => ctx.runMutation(ref, args);
+const getGroupConnection = (ctx, componentPublic, connectionId) => query(ctx, componentPublic.groupConnectionGet, { connectionId });
+const getGroupConnectionByDomain = (ctx, componentPublic, domain) => query(ctx, componentPublic.groupConnectionGetByDomain, { domain });
+const listGroupConnections = (ctx, componentPublic, args) => query(ctx, componentPublic.groupConnectionList, args);
+const createGroupConnection = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionCreate, args);
+const updateGroupConnection = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionUpdate, args);
+const deleteGroupConnection = (ctx, componentPublic, connectionId) => mutate(ctx, componentPublic.groupConnectionDelete, { connectionId });
+const getGroup = (ctx, componentPublic, groupId) => query(ctx, componentPublic.groupGet, { groupId });
+const listConnectionDomains = (ctx, componentPublic, connectionId) => query(ctx, componentPublic.groupConnectionDomainList, { connectionId });
+const addConnectionDomain = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionDomainAdd, args);
+const deleteConnectionDomain = (ctx, componentPublic, domainId) => mutate(ctx, componentPublic.groupConnectionDomainDelete, { domainId });
+const getScimConfigByConnection = (ctx, componentPublic, connectionId) => query(ctx, componentPublic.groupConnectionScimConfigGetByGroupConnection, { connectionId });
+const getScimConfigByTokenHash = (ctx, componentPublic, tokenHash) => query(ctx, componentPublic.groupConnectionScimConfigGetByTokenHash, { tokenHash });
+const upsertScimConfig = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionScimConfigUpsert, args);
+const getConnectionDomainVerification = (ctx, componentPublic, domainId) => query(ctx, componentPublic.groupConnectionDomainVerificationGet, { domainId });
+const upsertConnectionDomainVerification = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionDomainVerificationUpsert, args);
+const deleteConnectionDomainVerification = (ctx, componentPublic, domainId) => mutate(ctx, componentPublic.groupConnectionDomainVerificationDelete, { domainId });
+const verifyConnectionDomain = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionDomainVerify, args);
+const getGroupConnectionSecret = (ctx, componentPublic, args) => query(ctx, componentPublic.groupConnectionSecretGet, args);
+const upsertGroupConnectionSecret = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionSecretUpsert, args);
+const listWebhookEndpoints = (ctx, componentPublic, connectionId) => query(ctx, componentPublic.groupWebhookEndpointList, { connectionId });
+const listWebhookDeliveries = (ctx, componentPublic, args) => query(ctx, componentPublic["groupWebhookDeliveryList"], args);
+const listScimIdentitiesByConnection = (ctx, componentPublic, connectionId) => query(ctx, componentPublic.groupConnectionScimIdentityListByGroupConnection, { connectionId });
+const getScimIdentityByConnectionAndUser = (ctx, componentPublic, args) => query(ctx, componentPublic.groupConnectionScimIdentityGetByGroupConnectionAndUser, args);
+const getScimIdentityByMappedGroup = (ctx, componentPublic, mappedGroupId) => query(ctx, componentPublic.groupConnectionScimIdentityGetByMappedGroup, { mappedGroupId });
+const upsertScimIdentity = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupConnectionScimIdentityUpsert, args);
+const deleteScimIdentity = (ctx, componentPublic, identityId) => mutate(ctx, componentPublic.groupConnectionScimIdentityDelete, { identityId });
+const insertAccount = (ctx, componentPublic, args) => mutate(ctx, componentPublic.accountInsert, args);
+const insertUser = (ctx, componentPublic, data) => mutate(ctx, componentPublic.userInsert, { data });
+const patchUser = (ctx, componentPublic, args) => mutate(ctx, componentPublic.userPatch, args);
+const getScimIdentity = (ctx, componentPublic, args) => query(ctx, componentPublic.groupConnectionScimIdentityGet, args);
+const listAuditEvents = (ctx, componentPublic, args) => query(ctx, componentPublic.groupAuditEventList, args);
+const getWebhookEndpoint = (ctx, componentPublic, endpointId) => query(ctx, componentPublic.groupWebhookEndpointGet, { endpointId });
+const createWebhookEndpoint = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupWebhookEndpointCreate, args);
+const updateWebhookEndpoint = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupWebhookEndpointUpdate, args);
+const listReadyWebhookDeliveries = (ctx, componentPublic, args) => query(ctx, componentPublic.groupWebhookDeliveryListReady, args);
+const patchWebhookDelivery = (ctx, componentPublic, args) => mutate(ctx, componentPublic.groupWebhookDeliveryPatch, args);
+
+//#endregion
+export { addConnectionDomain, createGroupConnection, createWebhookEndpoint, deleteConnectionDomain, deleteConnectionDomainVerification, deleteGroupConnection, deleteScimIdentity, getConnectionDomainVerification, getGroup, getGroupConnection, getGroupConnectionByDomain, getGroupConnectionSecret, getScimConfigByConnection, getScimConfigByTokenHash, getScimIdentity, getScimIdentityByConnectionAndUser, getScimIdentityByMappedGroup, getWebhookEndpoint, insertAccount, insertUser, listAuditEvents, listConnectionDomains, listGroupConnections, listReadyWebhookDeliveries, listScimIdentitiesByConnection, listWebhookDeliveries, listWebhookEndpoints, patchUser, patchWebhookDelivery, updateGroupConnection, updateWebhookEndpoint, upsertConnectionDomainVerification, upsertGroupConnectionSecret, upsertScimConfig, upsertScimIdentity, verifyConnectionDomain };
+//# sourceMappingURL=contract.js.map

package/dist/server/cookies.js

@@ -1,4 +1,5 @@
-import { isLocalHost } from "./utils.js";
+import { envOptionalString, readConfigSync } from "./env.js";
+import { isLocalHost } from "./url.js";
 
 //#region src/server/cookies.ts
 /** @internal */
@@ -39,7 +40,7 @@ function useRedirectToParam(providerId, cookies) {
 	};
 }
 function redirectToParamCookieName(providerId) {
-	return (!isLocalHost(process.env.CONVEX_SITE_URL) ? "__Host-" : "") + providerId + "RedirectTo";
+	return (!isLocalHost(readConfigSync(envOptionalString("CONVEX_SITE_URL")) ?? void 0) ? "__Host-" : "") + providerId + "RedirectTo";
 }
 
 //#endregion