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

package/src/server/config.ts

@@ -1,200 +0,0 @@
-import {
-  isOAuthProvider,
-  type OAuthProviderInstance,
-} from "../providers/oauth";
-import {
-  AuthAuthorizationConfig,
-  AuthProviderConfig,
-  AuthProviderMaterializedConfig,
-  ConvexAuthConfig,
-  OAuthMaterializedConfig,
-} from "./types";
-
-// ============================================================================
-// Provider class detection
-// ============================================================================
-
-/** Check if something is a new-style class provider with `_toMaterialized()`. */
-function isClassProvider(
-  provider: any,
-): provider is { _toMaterialized(): AuthProviderMaterializedConfig } {
-  return (
-    typeof provider === "object" &&
-    provider !== null &&
-    typeof provider._toMaterialized === "function"
-  );
-}
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-/**
- * Resolve raw provider configs into materialized form and apply defaults.
- *
- * @internal
- */
-/** @internal */
-export function configDefaults(config_: ConvexAuthConfig) {
-  const config = materializeAndDefaultProviders(config_);
-  // Collect extra providers from credentials providers
-  const extraProviders = config.providers
-    .filter((p) => p.type === "credentials")
-    .map((p) => p.extraProviders)
-    .flat()
-    .filter((p) => p !== undefined);
-  return {
-    ...config,
-    authorization: normalizeAuthorizationConfig(config.authorization),
-    extraProviders: materializeProviders(extraProviders),
-  };
-}
-
-/**
- * Materialize a single provider config into its runtime form.
- *
- * @internal
- */
-/** @internal */
-export function materializeProvider(provider: AuthProviderConfig) {
-  const config = { providers: [provider], component: {} as any };
-  materializeAndDefaultProviders(config);
-  return config.providers[0] as AuthProviderMaterializedConfig;
-}
-
-/**
- * List available provider IDs for error messages.
- *
- * @internal
- */
-/** @internal */
-export function listAvailableProviders(
-  config: ReturnType<typeof configDefaults>,
-  allowExtraProviders: boolean,
-) {
-  const availableProviders = config.providers
-    .concat(allowExtraProviders ? config.extraProviders : [])
-    .map((provider) => `\`${provider.id}\``);
-  return availableProviders.length > 0
-    ? availableProviders.join(", ")
-    : "no providers have been configured";
-}
-
-// ============================================================================
-// Internal helpers
-// ============================================================================
-
-function materializeProviders(providers: AuthProviderConfig[]) {
-  const config = { providers, component: {} as any };
-  materializeAndDefaultProviders(config);
-  return config.providers as AuthProviderMaterializedConfig[];
-}
-
-type ProviderMaterializationDispatch =
-  | { tag: "oauth"; raw: OAuthProviderInstance }
-  | {
-      tag: "class";
-      raw: { _toMaterialized(): AuthProviderMaterializedConfig };
-    }
-  | { tag: "factoryOrObject"; raw: AuthProviderConfig };
-
-type ProviderMaterializationHandlers<T> = {
-  oauth: (
-    dispatch: Extract<ProviderMaterializationDispatch, { tag: "oauth" }>,
-  ) => T;
-  class: (
-    dispatch: Extract<ProviderMaterializationDispatch, { tag: "class" }>,
-  ) => T;
-  factoryOrObject: (
-    dispatch: Extract<
-      ProviderMaterializationDispatch,
-      { tag: "factoryOrObject" }
-    >,
-  ) => T;
-};
-
-function decodeProviderMaterializationDispatch(
-  raw: AuthProviderConfig,
-): ProviderMaterializationDispatch {
-  if (isOAuthProvider(raw)) {
-    return { tag: "oauth", raw };
-  }
-  if (isClassProvider(raw)) {
-    return { tag: "class", raw };
-  }
-  return { tag: "factoryOrObject", raw };
-}
-
-function matchProviderMaterializationDispatch<T>(
-  dispatch: ProviderMaterializationDispatch,
-  handlers: ProviderMaterializationHandlers<T>,
-): T {
-  return (
-    handlers[dispatch.tag] as (dispatch: ProviderMaterializationDispatch) => T
-  )(dispatch);
-}
-
-function materializeProviderConfig(raw: AuthProviderConfig) {
-  const dispatch = decodeProviderMaterializationDispatch(raw);
-  return matchProviderMaterializationDispatch(dispatch, {
-    oauth: (d) => materializeOAuthProvider(d.raw),
-    class: (d) => d.raw._toMaterialized(),
-    factoryOrObject: (d) => {
-      const resolved = typeof d.raw === "function" ? d.raw() : (d.raw as any);
-      const merged = resolved.options
-        ? { ...resolved, ...resolved.options }
-        : resolved;
-      return merged as AuthProviderMaterializedConfig;
-    },
-  });
-}
-
-function materializeAndDefaultProviders(config_: ConvexAuthConfig) {
-  const allProviders: AuthProviderMaterializedConfig[] = [];
-
-  for (const raw of config_.providers) {
-    allProviders.push(materializeProviderConfig(raw));
-  }
-
-  const config = { ...config_, providers: allProviders };
-
-  // Set phone provider API key from env
-  config.providers.forEach((provider) => {
-    if (provider.type === "phone") {
-      const ID = provider.id.toUpperCase().replace(/-/g, "_");
-      provider.apiKey ??= process.env[`AUTH_${ID}_KEY`];
-    }
-  });
-
-  return config;
-}
-
-function normalizeAuthorizationConfig(
-  authorization: ConvexAuthConfig["authorization"],
-): AuthAuthorizationConfig {
-  const roles = Object.fromEntries(
-    Object.entries(authorization?.roles ?? {}).map(([roleId, role]) => [
-      roleId,
-      {
-        ...(role.label ? { label: role.label } : {}),
-        grants: Array.from(new Set(role.grants)).sort(),
-      },
-    ]),
-  );
-  return { roles };
-}
-
-/**
- * Materialize an Arctic-based `OAuthProviderInstance` into the runtime config.
- */
-function materializeOAuthProvider(
-  instance: OAuthProviderInstance,
-): OAuthMaterializedConfig {
-  return {
-    id: instance.id,
-    type: "oauth",
-    provider: instance.provider,
-    scopes: instance.scopes,
-    profile: instance.profile,
-  };
-}

package/src/server/context.ts

@@ -1,90 +0,0 @@
-import type { UserIdentity } from "convex/server";
-
-import { userIdFromIdentitySubject } from "./identity";
-import type { AuthContext, AuthLike, OptionalAuthContext, UserDoc } from "./auth";
-
-type AuthIdentityCtx = {
-  auth: {
-    getUserIdentity: () => Promise<UserIdentity | null>;
-  };
-};
-
-type AuthContextResolverLike = {
-  user: {
-    get: (ctx: any, userId: string) => Promise<UserDoc>;
-    getActiveGroup: (
-      ctx: any,
-      args: { userId: string },
-    ) => Promise<string | null>;
-  };
-  member: {
-    inspect: (
-      ctx: any,
-      args: { userId: string; groupId: string },
-    ) => Promise<{
-      membership: unknown;
-      roleIds: string[];
-      grants: string[];
-    }>;
-  };
-};
-
-/** @internal */
-export async function getSessionUserId(
-  ctx: AuthIdentityCtx,
-): Promise<string | null> {
-  const identity = await ctx.auth.getUserIdentity();
-  if (identity === null) {
-    return null;
-  }
-  return userIdFromIdentitySubject(identity.subject);
-}
-
-/** @internal */
-export async function getAuthContextForUser(
-  auth: AuthContextResolverLike,
-  ctx: any,
-  userId: string,
-): Promise<AuthContext> {
-  const user = await auth.user.get(ctx, userId);
-  const groupId = await auth.user.getActiveGroup(ctx, { userId });
-  let role: string | null = null;
-  let grants: string[] = [];
-  if (groupId) {
-    const resolved = await auth.member.inspect(ctx, { userId, groupId });
-    if (resolved.membership) {
-      role = resolved.roleIds[0] ?? null;
-      grants = resolved.grants;
-    }
-  }
-  return {
-    userId: userId as AuthContext["userId"],
-    user,
-    groupId,
-    role,
-    grants,
-  };
-}
-
-/** @internal */
-export async function getAuthContext(
-  auth: AuthLike,
-  ctx: AuthIdentityCtx & Record<string, unknown>,
-): Promise<AuthContext | null> {
-  const userId = await getSessionUserId(ctx);
-  if (userId === null) {
-    return null;
-  }
-  return await getAuthContextForUser(auth, ctx, userId);
-}
-
-/** @internal */
-export function createUnauthenticatedAuthContext(): OptionalAuthContext {
-  return {
-    userId: null,
-    user: null,
-    groupId: null,
-    role: null,
-    grants: [],
-  };
-}

package/src/server/cookies.ts

@@ -1,49 +0,0 @@
-import { isLocalHost } from "./utils";
-
-/** @internal */
-export const SHARED_COOKIE_OPTIONS = {
-  httpOnly: true,
-  sameSite: "none" as const,
-  secure: true,
-  path: "/",
-  partitioned: true,
-};
-
-const REDIRECT_MAX_AGE = 60 * 15; // 15 minutes in seconds
-/** @internal */
-export function redirectToParamCookie(providerId: string, redirectTo: string) {
-  return {
-    name: redirectToParamCookieName(providerId),
-    value: redirectTo,
-    options: { ...SHARED_COOKIE_OPTIONS, maxAge: REDIRECT_MAX_AGE },
-  };
-}
-
-/** @internal */
-export function useRedirectToParam(
-  providerId: string,
-  cookies: Record<string, string | undefined>,
-) {
-  const cookieName = redirectToParamCookieName(providerId);
-  const redirectTo = cookies[cookieName];
-  if (redirectTo === undefined) {
-    return null;
-  }
-
-  // Clear the cookie
-  const updatedCookie = {
-    name: cookieName,
-    value: "",
-    options: { ...SHARED_COOKIE_OPTIONS, maxAge: 0 },
-  };
-
-  return { redirectTo, updatedCookie };
-}
-
-function redirectToParamCookieName(providerId: string) {
-  return (
-    (!isLocalHost(process.env.CONVEX_SITE_URL) ? "__Host-" : "") +
-    providerId +
-    "RedirectTo"
-  );
-}