@delmaredigital/payload-better-auth 0.3.8 → 0.3.9

package/src/scripts/generate-types.ts

@@ -1,269 +0,0 @@
-/**
- * Type generation script for Better Auth schema.
- *
- * Generates TypeScript types by introspecting Better Auth's schema
- * and diffing plugin additions against the base schema.
- *
- * Run with: pnpm generate:types
- */
-
-import { passkey } from '@better-auth/passkey'
-import type { DBFieldAttribute } from 'better-auth/db'
-import { getSchema } from 'better-auth/db'
-import {
-  admin,
-  anonymous,
-  apiKey,
-  bearer,
-  emailOTP,
-  genericOAuth,
-  jwt,
-  magicLink,
-  multiSession,
-  oidcProvider,
-  oneTap,
-  oneTimeToken,
-  openAPI,
-  organization,
-  phoneNumber,
-  twoFactor,
-  username,
-} from 'better-auth/plugins'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-type Schema = Record<string, { fields: Record<string, DBFieldAttribute> }>
-
-// Plugins to include in type generation
-// Add new plugins here as they become supported
-const plugins = [
-  username(),
-  admin(),
-  apiKey(),
-  passkey(),
-  bearer(),
-  emailOTP({ sendVerificationOTP: async () => {} }),
-  magicLink({ sendMagicLink: async () => {} }),
-  phoneNumber({ sendOTP: async () => {} }),
-  oneTap(),
-  anonymous(),
-  multiSession(),
-  oneTimeToken(),
-  oidcProvider({ loginPage: '' }),
-  genericOAuth({
-    config: [
-      {
-        providerId: 'generic',
-        clientId: 'generic',
-        clientSecret: 'generic',
-      },
-    ],
-  }),
-  openAPI(),
-  organization({
-    teams: { enabled: true },
-  }),
-  jwt(),
-  twoFactor(),
-]
-
-const betterAuthConfig = {
-  emailAndPassword: { enabled: true },
-  user: {
-    additionalFields: {
-      role: { type: 'string' as const, defaultValue: 'user', input: false },
-    },
-  },
-  plugins,
-}
-
-const baseSchema = getSchema({ ...betterAuthConfig, plugins: [] })
-
-/**
- * Map Better Auth field types to TypeScript types
- */
-function mapType(t: string): string {
-  switch (t) {
-    case 'boolean':
-      return 'boolean'
-    case 'date':
-      return 'Date'
-    case 'number':
-      return 'number'
-    case 'string':
-      return 'string'
-    case 'number[]':
-      return 'number[]'
-    case 'string[]':
-      return 'string[]'
-    default:
-      return 'unknown'
-  }
-}
-
-/**
- * Convert string to PascalCase
- */
-function pascal(s: string): string {
-  return s
-    .split(/[-_]/g)
-    .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
-    .join('')
-}
-
-/**
- * Find fields added by a plugin compared to base schema
- */
-function diff(
-  base: Schema,
-  target: Schema
-): Record<string, Record<string, DBFieldAttribute>> {
-  const d: Record<string, Record<string, DBFieldAttribute>> = {}
-  for (const [m, { fields }] of Object.entries(target)) {
-    const added = Object.entries(fields).filter(
-      ([k]) => !(k in (base[m]?.fields ?? {}))
-    )
-    if (added.length) d[m] = Object.fromEntries(added)
-  }
-  return d
-}
-
-/**
- * Generate TypeScript type definitions
- */
-function generate(): string {
-  let out = `/**
- * Auto-generated Better Auth types.
- * DO NOT EDIT - Run \`pnpm generate:types\` to regenerate.
- *
- * Generated from Better Auth schema introspection.
- * Contains types for all supported plugins and their field additions.
- */
-
-`
-
-  const pluginAdds: Record<
-    string,
-    Record<string, Record<string, DBFieldAttribute>>
-  > = {}
-  const seen = new Set<string>()
-
-  // Diff each plugin's schema against base to find additions
-  for (const pl of plugins) {
-    const id = (pl as { id?: string }).id
-    if (!id || seen.has(id)) continue
-    seen.add(id)
-    const adds = diff(
-      baseSchema,
-      getSchema({ ...betterAuthConfig, plugins: [pl] })
-    )
-    for (const [m, f] of Object.entries(adds)) {
-      pluginAdds[m] ??= {}
-      pluginAdds[m][id] = f
-    }
-  }
-
-  // Collect all models from base and plugins
-  const models = new Set<string>([
-    ...Object.keys(baseSchema),
-    ...Object.keys(pluginAdds),
-  ])
-
-  // Generate types for each model
-  for (const model of models) {
-    const P = pascal(model)
-    const base = baseSchema[model]?.fields ?? {}
-    const pluginsForModel = pluginAdds[model] ?? {}
-    const pluginIds = Object.keys(pluginsForModel)
-
-    // Base fields type
-    if (Object.keys(base).length) {
-      out += `export type Base${P}Fields = {\n`
-      for (const [k, f] of Object.entries(base)) {
-        const fieldName = f.fieldName ?? k
-        const optional = f.required ? '' : '?'
-        out += `  ${fieldName}${optional}: ${mapType(f.type as string)}\n`
-      }
-      out += '}\n\n'
-    }
-
-    // Plugin fields mapping
-    const needPluginMap = pluginIds.length > 1 || Object.keys(base).length
-    if (needPluginMap && pluginIds.length) {
-      out += `export type ${P}PluginFields = {\n`
-      for (const [pid, flds] of Object.entries(pluginsForModel)) {
-        out += `  ${JSON.stringify(pid)}: {\n`
-        for (const [k, f] of Object.entries(flds)) {
-          const fieldName = f.fieldName ?? k
-          const optional = f.required ? '' : '?'
-          out += `    ${fieldName}${optional}: ${mapType(f.type as string)}\n`
-        }
-        out += '  }\n'
-      }
-      out += '}\n\n'
-    }
-
-    // Handle single-plugin-only models
-    if (!Object.keys(base).length && pluginIds.length === 1) {
-      const only = pluginIds[0]
-      out += `export type ${P}Fields = {\n`
-      for (const [k, f] of Object.entries(pluginsForModel[only])) {
-        const fieldName = f.fieldName ?? k
-        const optional = f.required ? '' : '?'
-        out += `  ${fieldName}${optional}: ${mapType(f.type as string)}\n`
-      }
-      out += '}\n\n'
-      out += `export type ${P} = ${P}Fields\n\n`
-      continue
-    }
-
-    // Combined type as intersection
-    const parts: string[] = []
-    if (Object.keys(base).length) parts.push(`Base${P}Fields`)
-    if (pluginIds.length) {
-      const mapName = needPluginMap ? `${P}PluginFields` : undefined
-      parts.push(
-        ...pluginIds.map((id) =>
-          mapName ? `${mapName}[${JSON.stringify(id)}]` : 'never'
-        )
-      )
-    }
-    out += `export type ${P} = ${parts.join(' & ')}\n\n`
-  }
-
-  // Plugin ID union type
-  const pluginIdUnion = [...seen].map((id) => JSON.stringify(id)).join(' | ')
-  out += `/**
- * Union of all supported plugin identifiers.
- */
-export type PluginId = ${pluginIdUnion}\n\n`
-
-  // Full schema mapping
-  out += `/**
- * Complete schema mapping of all models to their types.
- */
-export type BetterAuthFullSchema = {\n`
-  for (const model of models) {
-    const P = pascal(model)
-    out += `  ${JSON.stringify(model)}: ${P}\n`
-  }
-  out += '}\n\n'
-
-  // Model key union
-  out += `/**
- * Union of all model names in the schema.
- */
-export type ModelKey = keyof BetterAuthFullSchema\n`
-
-  return out
-}
-
-// Generate and write types
-const generated = generate()
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const outputFile = path.resolve(__dirname, '../generated-types.ts')
-
-await fs.writeFile(outputFile, generated, 'utf8')
-console.log(`Generated types written to ${outputFile}`)

package/src/types/apiKey.ts

@@ -1,63 +0,0 @@
-/**
- * API Key Scope Types
- *
- * Provides typed configuration for API key permission scopes.
- */
-
-/**
- * A single permission scope definition.
- * Scopes are human-readable permission groups (like GitHub OAuth scopes).
- */
-export type ScopeDefinition = {
-  /** Human-readable label for the scope (e.g., "Read Content") */
-  label: string
-  /** Description of what this scope allows (e.g., "View posts, pages, and comments") */
-  description: string
-  /**
-   * Permission mapping: { resourceType: ['action1', 'action2'] }
-   * Maps to Better Auth's permission format.
-   * Use '*' for resource to match all resources.
-   * Use '*' in actions array to grant all actions on a resource.
-   */
-  permissions: Record<string, string[]>
-  /** If true, only admin users can create keys with this scope */
-  adminOnly?: boolean
-}
-
-/**
- * Configuration options for API key scopes.
- * Can be used in plugin options to customize available scopes.
- */
-export type ApiKeyScopesConfig = {
-  /**
-   * Custom scope definitions.
-   * Key is the scope ID (e.g., 'content:read'), value is the scope definition.
-   */
-  scopes?: Record<string, ScopeDefinition>
-  /**
-   * Include auto-generated collection scopes.
-   * When true (default), generates {collection}:read, {collection}:write, {collection}:delete
-   * for each Payload collection.
-   * @default true when no custom scopes provided, false when custom scopes provided
-   */
-  includeCollectionScopes?: boolean
-  /**
-   * Collections to exclude from auto-generated scopes.
-   * Useful for hiding sensitive collections like 'sessions' or 'verifications'.
-   * @default ['sessions', 'verifications', 'accounts', 'twoFactors']
-   */
-  excludeCollections?: string[]
-  /**
-   * Default scopes assigned to new API keys when user doesn't select any.
-   * If not provided, keys without scopes will have no permissions.
-   */
-  defaultScopes?: string[]
-}
-
-/**
- * Scope data passed to the API keys management client component.
- */
-export type AvailableScope = ScopeDefinition & {
-  /** The scope ID (e.g., 'content:read') */
-  id: string
-}

package/src/types/betterAuth.ts

@@ -1,253 +0,0 @@
-/**
- * Enhanced TypeScript types for Better Auth integration.
- *
- * Provides improved type inference for the Better Auth instance,
- * including session/user types, API methods, and error codes.
- */
-
-import type { AuthContext } from 'better-auth'
-import { router } from 'better-auth/api'
-import type {
-  BetterAuthOptions,
-  BetterAuthPlugin,
-  InferAPI,
-  InferPluginTypes,
-  InferSession,
-  InferUser,
-} from 'better-auth/types'
-import type { BasePayload, Endpoint, PayloadRequest } from 'payload'
-
-/**
- * Base error codes from Better Auth core.
- */
-type BaseErrorCodes = {
-  FAILED_TO_GET_USER_INFO: string
-  USER_ALREADY_EXISTS: string
-  INVALID_PASSWORD: string
-  FAILED_TO_CREATE_USER: string
-  FAILED_TO_CREATE_SESSION: string
-  FAILED_TO_UPDATE_USER: string
-  FAILED_TO_GET_SESSION: string
-  INVALID_EMAIL_OR_PASSWORD: string
-  SOCIAL_ACCOUNT_ALREADY_LINKED: string
-  PROVIDER_NOT_FOUND: string
-  INVALID_TOKEN: string
-  ID_TOKEN_NOT_SUPPORTED: string
-  FAILED_TO_GET_USER_INFO_OPENID: string
-  UNEXPECTED_PROVIDER_RESPONSE: string
-  TOKEN_REFRESH_FAILED: string
-  FAILED_TO_UNLINK: string
-  ACCOUNT_NOT_FOUND: string
-  SESSION_EXPIRED: string
-  INTERNAL_SERVER_ERROR: string
-  VALIDATION_ERROR: string
-}
-
-/**
- * Union to intersection utility type.
- */
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (
-  k: infer I
-) => void
-  ? I
-  : never
-
-/**
- * Deeply prettify a type for better IDE display.
- * Flattens intersections and preserves functions/arrays/dates.
- */
-type PrettifyDeep<T> = {
-  [K in keyof T]: T[K] extends (...args: unknown[]) => unknown
-    ? T[K]
-    : T[K] extends object
-      ? T[K] extends Array<unknown>
-        ? T[K]
-        : T[K] extends Date
-          ? T[K]
-          : PrettifyDeep<T[K]>
-      : T[K]
-} & {}
-
-/**
- * Infer error codes from enabled plugins.
- */
-type InferPluginErrorCodes<O extends BetterAuthOptions> =
-  O['plugins'] extends Array<infer P>
-    ? UnionToIntersection<
-        P extends BetterAuthPlugin
-          ? P['$ERROR_CODES'] extends Record<string, unknown>
-            ? P['$ERROR_CODES']
-            : never
-          : never
-      > extends infer R
-      ? [R] extends [never]
-        ? object
-        : R
-      : object
-    : object
-
-/**
- * Role array type with configurable roles.
- */
-export type RoleArray<O extends readonly string[] = readonly ['user']> =
-  | O[number][]
-  | null
-
-/**
- * Override role field in a type with configured roles.
- */
-type OverrideRole<T, O extends readonly string[]> = T extends object
-  ? Omit<T, 'role'> & { role: RoleArray<O> }
-  : T
-
-/**
- * The return type of a Better Auth instance.
- *
- * This provides full type inference for:
- * - API endpoints and their return types
- * - Session/user types based on enabled plugins
- * - Error codes from all enabled plugins
- * - Auth context for advanced use cases
- *
- * @template O - Better Auth options type for inference
- *
- * @example
- * ```ts
- * // Access inferred types
- * type MySession = typeof payload.betterAuth.$Infer.Session
- *
- * // Type-safe API calls
- * const result = await payload.betterAuth.api.getSession({ headers })
- * ```
- */
-export type BetterAuthReturn<O extends BetterAuthOptions = BetterAuthOptions> = {
-  /** The request handler for auth endpoints */
-  handler: (request: Request) => Promise<Response>
-  /** Type-safe API methods */
-  api: InferAPI<ReturnType<typeof router<O>>>['endpoints']
-  /** The resolved options */
-  options: O
-  /** All error codes from enabled plugins */
-  $ERROR_CODES: InferPluginErrorCodes<O> & BaseErrorCodes
-  /** Auth context (async) for advanced use cases */
-  $context: Promise<AuthContext>
-  /** Inferred types for Session and User */
-  $Infer: InferPluginTypes<O> extends { Session: unknown }
-    ? InferPluginTypes<O>
-    : {
-        Session: {
-          session: PrettifyDeep<InferSession<O>>
-          user: PrettifyDeep<InferUser<O>>
-        }
-      } & InferPluginTypes<O>
-}
-
-/**
- * Payload instance with Better Auth attached.
- *
- * After initialization, the Payload instance is extended with
- * the `betterAuth` property containing the auth instance.
- *
- * @template O - Better Auth options type for inference
- *
- * @example
- * ```ts
- * // In a server action or API route
- * const payload = await getPayload({ config })
- * const payloadWithAuth = payload as PayloadWithAuth
- *
- * const session = await payloadWithAuth.betterAuth.api.getSession({ headers })
- * ```
- */
-export type PayloadWithAuth<O extends BetterAuthOptions = BetterAuthOptions> =
-  BasePayload & {
-    betterAuth: BetterAuthReturn<O>
-  }
-
-/**
- * Extended Payload request with Better Auth instance.
- *
- * Use this type in hooks and endpoints to get type-safe
- * access to the Better Auth instance.
- *
- * @template O - Better Auth options type for inference
- *
- * @example
- * ```ts
- * const myHook: CollectionBeforeChangeHook = async ({ req }) => {
- *   const typedReq = req as PayloadRequestWithBetterAuth<typeof myBetterAuthOptions>
- *   const session = await typedReq.payload.betterAuth.api.getSession({
- *     headers: req.headers,
- *   })
- *   // ...
- * }
- * ```
- */
-export interface PayloadRequestWithBetterAuth<
-  O extends BetterAuthOptions = BetterAuthOptions,
-> extends PayloadRequest {
-  payload: PayloadWithAuth<O>
-}
-
-/**
- * Type utility for collection hooks with Better Auth context.
- *
- * Transforms a standard Payload hook type to include Better Auth
- * on the request's payload instance.
- *
- * @template O - Better Auth options type for inference
- * @template T - The original hook function type
- *
- * @example
- * ```ts
- * import type { CollectionBeforeChangeHook } from 'payload'
- *
- * const beforeChange: CollectionHookWithBetterAuth<
- *   typeof myOptions,
- *   CollectionBeforeChangeHook
- * > = async ({ req, data }) => {
- *   // req.payload.betterAuth is fully typed
- *   const session = await req.payload.betterAuth.api.getSession({
- *     headers: req.headers,
- *   })
- *   return data
- * }
- * ```
- */
-export type CollectionHookWithBetterAuth<
-  O extends BetterAuthOptions,
-  T extends (args: Record<string, unknown>) => unknown,
-> = T extends (args: infer A) => infer R
-  ? (
-      args: Omit<A, 'req'> & { req: PayloadRequestWithBetterAuth<O> }
-    ) => R
-  : never
-
-/**
- * Payload endpoint type with Better Auth context.
- *
- * Use this for custom endpoints that need access to Better Auth.
- *
- * @template O - Better Auth options type for inference
- *
- * @example
- * ```ts
- * const myEndpoint: EndpointWithBetterAuth<typeof myOptions> = {
- *   path: '/custom-auth',
- *   method: 'post',
- *   handler: async (req) => {
- *     // req.payload.betterAuth is fully typed
- *     const session = await req.payload.betterAuth.api.getSession({
- *       headers: req.headers,
- *     })
- *     return Response.json({ session })
- *   },
- * }
- * ```
- */
-export type EndpointWithBetterAuth<O extends BetterAuthOptions> = Omit<
-  Endpoint,
-  'handler'
-> & {
-  handler: (req: PayloadRequestWithBetterAuth<O>) => Promise<Response> | Response
-}