@robelest/convex-auth 0.0.4-preview.2 → 0.0.4-preview.21

package/src/server/implementation/types.ts

@@ -1,444 +0,0 @@
-import {
-  DataModelFromSchemaDefinition,
-  GenericActionCtx,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  TableNamesInDataModel,
-} from "convex/server";
-import { GenericId } from "convex/values";
-import { GenericDoc } from "../types";
-import schema from "../../component/schema";
-import { AuthComponentApi } from "../types";
-
-/** Data model derived from the component schema. */
-export type AuthDataModel = DataModelFromSchemaDefinition<typeof schema>;
-
-/** Action context typed to the auth component's data model. */
-export type ActionCtx = GenericActionCtx<AuthDataModel>;
-
-/** Mutation context typed to the auth component's data model. */
-export type MutationCtx = GenericMutationCtx<AuthDataModel>;
-
-/** Query context typed to the auth component's data model. */
-export type QueryCtx = GenericQueryCtx<AuthDataModel>;
-
-/** A document from any table in the auth component schema. */
-export type Doc<T extends TableNamesInDataModel<AuthDataModel>> = GenericDoc<
-  AuthDataModel,
-  T
->;
-
-/** A pair of JWT access token and refresh token. */
-export type Tokens = { token: string; refreshToken: string };
-
-/** Session information returned after authentication. */
-export type SessionInfo = {
-  userId: GenericId<"user">;
-  sessionId: GenericId<"session">;
-  tokens: Tokens | null;
-};
-
-/** Session information with guaranteed non-null tokens. */
-export type SessionInfoWithTokens = {
-  userId: GenericId<"user">;
-  sessionId: GenericId<"session">;
-  tokens: Tokens;
-};
-
-// ---------------------------------------------------------------------------
-// Cross-component document shapes
-// ---------------------------------------------------------------------------
-// These mirror the component schema tables. They exist so that server-side
-// code can work with typed results from cross-component queries/mutations
-// instead of casting to `any` at every field access.
-
-export interface TotpDoc {
-  _id: string;
-  _creationTime: number;
-  userId: string;
-  secret: ArrayBuffer;
-  digits: number;
-  period: number;
-  verified: boolean;
-  name?: string;
-  createdAt: number;
-  lastUsedAt?: number;
-}
-
-export interface PasskeyDoc {
-  _id: string;
-  _creationTime: number;
-  userId: string;
-  credentialId: string;
-  publicKey: ArrayBuffer;
-  algorithm: number;
-  counter: number;
-  transports?: string[];
-  deviceType: string;
-  backedUp: boolean;
-  name?: string;
-  createdAt: number;
-  lastUsedAt?: number;
-}
-
-export interface VerifierDoc {
-  _id: string;
-  _creationTime: number;
-  signature?: string;
-  sessionId?: string;
-}
-
-export interface UserDoc {
-  _id: string;
-  _creationTime: number;
-  email?: string;
-  emailVerificationTime?: number;
-  phone?: string;
-  phoneVerificationTime?: number;
-  name?: string;
-  image?: string;
-  isAnonymous?: boolean;
-}
-
-export interface KeyDoc {
-  _id: string;
-  _creationTime: number;
-  userId: string;
-  prefix: string;
-  hashedKey: string;
-  name: string;
-  scopes: Array<{ resource: string; actions: string[] }>;
-  rateLimit?: { maxRequests: number; windowMs: number };
-  rateLimitState?: { attemptsLeft: number; lastAttemptTime: number };
-  expiresAt?: number;
-  lastUsedAt?: number;
-  createdAt: number;
-  revoked: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Cross-component wrapper context
-// ---------------------------------------------------------------------------
-// Structural type accepted by all wrappers below.  Works for both action and
-// mutation contexts — the only capabilities we need are runQuery / runMutation
-// and access to the component API via `auth.config.component`.
-
-/** @internal */
-export type ComponentCallCtx = {
-  runQuery: GenericActionCtx<AuthDataModel>["runQuery"];
-  runMutation: GenericActionCtx<AuthDataModel>["runMutation"];
-  auth: { config: { component: AuthComponentApi } };
-};
-
-// ---------------------------------------------------------------------------
-// Typed wrappers for cross-component calls
-// ---------------------------------------------------------------------------
-// Each wrapper encapsulates the single `as any` cast at the component
-// boundary so that callers get full type safety on both args and return
-// values.
-
-// -- User queries --
-
-export async function queryUserById(
-  ctx: ComponentCallCtx,
-  userId: string,
-): Promise<UserDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.userGetById,
-    { userId },
-  )) as UserDoc | null;
-}
-
-export async function queryUserByVerifiedEmail(
-  ctx: ComponentCallCtx,
-  email: string,
-): Promise<UserDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.userFindByVerifiedEmail,
-    { email },
-  )) as UserDoc | null;
-}
-
-// -- Verifier queries / mutations --
-
-export async function queryVerifierById(
-  ctx: ComponentCallCtx,
-  verifierId: string,
-): Promise<VerifierDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.verifierGetById,
-    { verifierId },
-  )) as VerifierDoc | null;
-}
-
-export async function mutateVerifierDelete(
-  ctx: ComponentCallCtx,
-  verifierId: string,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.verifierDelete,
-    { verifierId },
-  );
-}
-
-// -- TOTP queries / mutations --
-
-export async function queryTotpById(
-  ctx: ComponentCallCtx,
-  totpId: string,
-): Promise<TotpDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.totpGetById,
-    { totpId },
-  )) as TotpDoc | null;
-}
-
-export async function queryTotpVerifiedByUserId(
-  ctx: ComponentCallCtx,
-  userId: string,
-): Promise<TotpDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.totpGetVerifiedByUserId,
-    { userId },
-  )) as TotpDoc | null;
-}
-
-export async function mutateTotpInsert(
-  ctx: ComponentCallCtx,
-  args: {
-    userId: string;
-    secret: ArrayBuffer;
-    digits: number;
-    period: number;
-    verified: boolean;
-    name?: string;
-    createdAt: number;
-  },
-): Promise<string> {
-  return (await ctx.runMutation(
-    ctx.auth.config.component.public.totpInsert,
-    args,
-  )) as string;
-}
-
-export async function mutateTotpMarkVerified(
-  ctx: ComponentCallCtx,
-  totpId: string,
-  lastUsedAt: number,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.totpMarkVerified,
-    { totpId, lastUsedAt },
-  );
-}
-
-export async function mutateTotpUpdateLastUsed(
-  ctx: ComponentCallCtx,
-  totpId: string,
-  lastUsedAt: number,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.totpUpdateLastUsed,
-    { totpId, lastUsedAt },
-  );
-}
-
-// -- Passkey queries / mutations --
-
-export async function queryPasskeysByUserId(
-  ctx: ComponentCallCtx,
-  userId: string,
-): Promise<PasskeyDoc[]> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.passkeyListByUserId,
-    { userId },
-  )) as PasskeyDoc[];
-}
-
-export async function queryPasskeyByCredentialId(
-  ctx: ComponentCallCtx,
-  credentialId: string,
-): Promise<PasskeyDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.passkeyGetByCredentialId,
-    { credentialId },
-  )) as PasskeyDoc | null;
-}
-
-export async function mutatePasskeyInsert(
-  ctx: ComponentCallCtx,
-  args: {
-    userId: string;
-    credentialId: string;
-    publicKey: ArrayBuffer | ArrayBufferLike;
-    algorithm: number;
-    counter: number;
-    transports?: string[];
-    deviceType: string;
-    backedUp: boolean;
-    name?: string;
-    createdAt: number;
-  },
-): Promise<string> {
-  return (await ctx.runMutation(
-    ctx.auth.config.component.public.passkeyInsert,
-    args,
-  )) as string;
-}
-
-export async function mutatePasskeyUpdateCounter(
-  ctx: ComponentCallCtx,
-  passkeyId: string,
-  counter: number,
-  lastUsedAt: number,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.passkeyUpdateCounter,
-    { passkeyId, counter, lastUsedAt },
-  );
-}
-
-// -- Key queries / mutations --
-
-export async function mutateKeyInsert(
-  ctx: ComponentCallCtx,
-  args: {
-    userId: string;
-    prefix: string;
-    hashedKey: string;
-    name: string;
-    scopes: Array<{ resource: string; actions: string[] }>;
-    rateLimit?: { maxRequests: number; windowMs: number };
-    expiresAt?: number;
-  },
-): Promise<string> {
-  return (await ctx.runMutation(
-    ctx.auth.config.component.public.keyInsert,
-    args,
-  )) as string;
-}
-
-export async function queryKeysByUserId(
-  ctx: ComponentCallCtx,
-  userId: string,
-): Promise<KeyDoc[]> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.keyListByUserId,
-    { userId },
-  )) as KeyDoc[];
-}
-
-export async function queryKeyById(
-  ctx: ComponentCallCtx,
-  keyId: string,
-): Promise<KeyDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.keyGetById,
-    { keyId },
-  )) as KeyDoc | null;
-}
-
-export async function mutateKeyPatch(
-  ctx: ComponentCallCtx,
-  keyId: string,
-  data: Record<string, unknown>,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.keyPatch,
-    { keyId, data },
-  );
-}
-
-export async function mutateKeyDelete(
-  ctx: ComponentCallCtx,
-  keyId: string,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.keyDelete,
-    { keyId },
-  );
-}
-
-// -- Device authorization queries / mutations --
-
-export interface DeviceDoc {
-  _id: string;
-  _creationTime: number;
-  deviceCodeHash: string;
-  userCode: string;
-  expiresAt: number;
-  interval: number;
-  status: "pending" | "authorized" | "denied";
-  userId?: string;
-  sessionId?: string;
-  lastPolledAt?: number;
-}
-
-export async function mutateDeviceInsert(
-  ctx: ComponentCallCtx,
-  args: {
-    deviceCodeHash: string;
-    userCode: string;
-    expiresAt: number;
-    interval: number;
-    status: "pending" | "authorized" | "denied";
-  },
-): Promise<string> {
-  return (await ctx.runMutation(
-    ctx.auth.config.component.public.deviceInsert,
-    args,
-  )) as string;
-}
-
-export async function queryDeviceByCodeHash(
-  ctx: ComponentCallCtx,
-  deviceCodeHash: string,
-): Promise<DeviceDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.deviceGetByCodeHash,
-    { deviceCodeHash },
-  )) as DeviceDoc | null;
-}
-
-export async function queryDeviceByUserCode(
-  ctx: ComponentCallCtx,
-  userCode: string,
-): Promise<DeviceDoc | null> {
-  return (await ctx.runQuery(
-    ctx.auth.config.component.public.deviceGetByUserCode,
-    { userCode },
-  )) as DeviceDoc | null;
-}
-
-export async function mutateDeviceAuthorize(
-  ctx: ComponentCallCtx,
-  deviceId: string,
-  userId: string,
-  sessionId: string,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.deviceAuthorize,
-    { deviceId, userId, sessionId },
-  );
-}
-
-export async function mutateDeviceUpdateLastPolled(
-  ctx: ComponentCallCtx,
-  deviceId: string,
-  lastPolledAt: number,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.deviceUpdateLastPolled,
-    { deviceId, lastPolledAt },
-  );
-}
-
-export async function mutateDeviceDelete(
-  ctx: ComponentCallCtx,
-  deviceId: string,
-): Promise<void> {
-  await ctx.runMutation(
-    ctx.auth.config.component.public.deviceDelete,
-    { deviceId },
-  );
-}

package/src/server/implementation/utils.ts

@@ -1,91 +0,0 @@
-import { sha256 as rawSha256 } from "@oslojs/crypto/sha2";
-import { encodeHexLowerCase } from "@oslojs/encoding";
-import {
-  RandomReader,
-  generateRandomString as osloGenerateRandomString,
-} from "@oslojs/crypto/random";
-
-export const TOKEN_SUB_CLAIM_DIVIDER = "|";
-export const REFRESH_TOKEN_DIVIDER = "|";
-
-export function stringToNumber(value: string | undefined) {
-  return value !== undefined ? Number(value) : undefined;
-}
-
-export async function sha256(input: string) {
-  return encodeHexLowerCase(rawSha256(new TextEncoder().encode(input)));
-}
-
-export function generateRandomString(length: number, alphabet: string) {
-  const random: RandomReader = {
-    read(bytes) {
-      crypto.getRandomValues(bytes);
-    },
-  };
-
-  return osloGenerateRandomString(random, alphabet, length);
-}
-
-export function logError(error: unknown) {
-  logWithLevel(
-    LOG_LEVELS.ERROR,
-    error instanceof Error
-      ? error.message + "\n" + error.stack?.replace("\\n", "\n")
-      : error,
-  );
-}
-
-export const LOG_LEVELS = {
-  ERROR: "ERROR",
-  WARN: "WARN",
-  INFO: "INFO",
-  DEBUG: "DEBUG",
-} as const;
-type LogLevel = keyof typeof LOG_LEVELS;
-
-export function logWithLevel(level: LogLevel, ...args: unknown[]) {
-  const configuredLogLevel =
-    LOG_LEVELS[
-      (process.env.AUTH_LOG_LEVEL as LogLevel | undefined) ?? "INFO"
-    ] ?? "INFO";
-  switch (level) {
-    case "ERROR":
-      console.error(...args);
-      break;
-    case "WARN":
-      if (configuredLogLevel !== "ERROR") {
-        console.warn(...args);
-      }
-      break;
-    case "INFO":
-      if (configuredLogLevel === "INFO" || configuredLogLevel === "DEBUG") {
-        console.info(...args);
-      }
-      break;
-    case "DEBUG":
-      if (configuredLogLevel === "DEBUG") {
-        console.debug(...args);
-      }
-      break;
-  }
-}
-
-const UNREDACTED_LENGTH = 5;
-export function maybeRedact(value: string) {
-  if (value === "") {
-    return "";
-  }
-  const shouldRedact = process.env.AUTH_LOG_SECRETS !== "true";
-  if (shouldRedact) {
-    if (value.length < UNREDACTED_LENGTH * 2) {
-      return "<redacted>";
-    }
-    return (
-      value.substring(0, UNREDACTED_LENGTH) +
-      "<redacted>" +
-      value.substring(value.length - UNREDACTED_LENGTH)
-    );
-  } else {
-    return value;
-  }
-}

package/src/server/version.ts

@@ -1,2 +0,0 @@
-// Auto-generated by scripts/generate-version.js — do not edit.
-export const AUTH_VERSION = "0.0.4-preview.2";