@neondatabase/neon-js 0.1.0-alpha.4 → 0.1.0-alpha.5

package/README.md

@@ -32,7 +32,7 @@ import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
 
 const client = createClient<Database>({
   auth: {
-    adapter: SupabaseAuthAdapter,
+    adapter: SupabaseAuthAdapter(),
     url: import.meta.env.VITE_NEON_AUTH_URL,
   },
   dataApi: {
@@ -60,7 +60,7 @@ import { createClient, BetterAuthVanillaAdapter } from '@neondatabase/neon-js';
 
 const client = createClient<Database>({
   auth: {
-    adapter: BetterAuthVanillaAdapter,
+    adapter: BetterAuthVanillaAdapter(),
     url: import.meta.env.VITE_NEON_AUTH_URL,
   },
   dataApi: {
@@ -87,7 +87,7 @@ import { createClient, BetterAuthReactAdapter } from '@neondatabase/neon-js';
 
 const client = createClient<Database>({
   auth: {
-    adapter: BetterAuthReactAdapter,
+    adapter: BetterAuthReactAdapter(),
     url: import.meta.env.VITE_NEON_AUTH_URL,
   },
   dataApi: {
@@ -301,11 +301,8 @@ import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
 const client = createClient({
   // Auth configuration
   auth: {
-    adapter: SupabaseAuthAdapter,
+    adapter: SupabaseAuthAdapter(),
     url: 'https://your-auth-server.neon.tech/auth',
-    options: {
-      // Additional adapter-specific options
-    },
   },
 
   // Data API configuration
@@ -340,7 +337,7 @@ import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
 
 const client = createClient({
   auth: {
-    adapter: SupabaseAuthAdapter,
+    adapter: SupabaseAuthAdapter(),
     url: process.env.NEON_AUTH_URL!,
   },
   dataApi: {
@@ -354,7 +351,7 @@ const client = createClient({
 Generate TypeScript types from your database schema:
 
 ```bash
-npx neon-js gen-types --connection-string "postgresql://user:pass@host/db"
+npx neon-js gen-types --db-url "postgresql://user:pass@host/db"
 ```
 
 Use generated types for full type safety:
@@ -365,7 +362,7 @@ import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
 
 const client = createClient<Database>({
   auth: {
-    adapter: SupabaseAuthAdapter,
+    adapter: SupabaseAuthAdapter(),
     url: process.env.NEON_AUTH_URL!,
   },
   dataApi: {
@@ -387,18 +384,18 @@ Generate TypeScript types from your database:
 ```bash
 # Generate types
 npx neon-js gen-types \
-  --connection-string "postgresql://user:pass@host/db" \
+  --db-url "postgresql://user:pass@host/db" \
   --output ./types/database.ts
 
 # With schema filtering
 npx neon-js gen-types \
-  --connection-string "postgresql://user:pass@host/db" \
+  --db-url "postgresql://user:pass@host/db" \
   --schemas public,auth \
   --output ./types/database.ts
 ```
 
 **Options:**
-- `--connection-string`, `-c` - PostgreSQL connection string (required)
+- `--db-url`, `-c` - PostgreSQL connection string (required)
 - `--output`, `-o` - Output file path (default: `./types/database.ts`)
 - `--schemas`, `-s` - Comma-separated list of schemas (default: `public`)
 
@@ -457,7 +454,7 @@ import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
 
 export const neon = createClient({
   auth: {
-    adapter: SupabaseAuthAdapter,
+    adapter: SupabaseAuthAdapter(),
     url: process.env.NEON_AUTH_URL!,
   },
   dataApi: {
@@ -481,7 +478,7 @@ import { createClient, BetterAuthReactAdapter } from '@neondatabase/neon-js';
 
 const client = createClient({
   auth: {
-    adapter: BetterAuthReactAdapter,
+    adapter: BetterAuthReactAdapter(),
     url: process.env.NEXT_PUBLIC_NEON_AUTH_URL!,
   },
   dataApi: {
@@ -525,7 +522,7 @@ import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
 
 const client = createClient({
   auth: {
-    adapter: SupabaseAuthAdapter,
+    adapter: SupabaseAuthAdapter(),
     url: 'https://auth.example.com',
   },
   dataApi: {

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import * as better_auth_react0 from "better-auth/react";
-import { createAuthClient, useStore as useBetterAuthStore } from "better-auth/react";
-import { AuthClient, BetterAuthClientOptions, createAuthClient as createAuthClient$1 } from "better-auth/client";
+import { createAuthClient as createAuthClient$1, useStore as useBetterAuthStore } from "better-auth/react";
+import { AuthClient, BetterAuthClientOptions, createAuthClient as createAuthClient$2 } from "better-auth/client";
 import * as better_auth0 from "better-auth";
 import * as _better_fetch_fetch0 from "@better-fetch/fetch";
 import * as nanostores0 from "nanostores";
@@ -17,15 +17,18 @@ declare abstract class NeonAuthAdapterCore {
    * See CLAUDE.md for architecture details and API mappings.
    */
   constructor(betterAuthClientOptions: NeonAuthAdapterCoreAuthOptions);
-  abstract getBetterAuthInstance?(): AuthClient<BetterAuthClientOptions> | ReturnType<typeof createAuthClient>;
+  abstract getBetterAuthInstance?(): AuthClient<BetterAuthClientOptions> | ReturnType<typeof createAuthClient$1>;
   abstract getJWTToken(): Promise<string | null>;
 }
 //#endregion
 //#region ../neon-auth/src/adapters/better-auth-react/better-auth-react-adapter.d.ts
-type BetterAuthReactAdapterOptions = NeonAuthAdapterCoreAuthOptions;
-declare class BetterAuthReactAdapter extends NeonAuthAdapterCore {
+type BetterAuthReactAdapterOptions = Omit<NeonAuthAdapterCoreAuthOptions, 'baseURL'>;
+/**
+ * Internal implementation class - use BetterAuthReactAdapter factory function instead
+ */
+declare class BetterAuthReactAdapterImpl extends NeonAuthAdapterCore {
   private _betterAuth;
-  constructor(betterAuthClientOptions: BetterAuthReactAdapterOptions);
+  constructor(betterAuthClientOptions: NeonAuthAdapterCoreAuthOptions);
   getBetterAuthInstance(): {
     signIn: {
       social: <FetchOptions extends better_auth0.ClientFetchOption<Partial<{
@@ -716,15 +719,64 @@ declare class BetterAuthReactAdapter extends NeonAuthAdapterCore {
   };
   getJWTToken(): Promise<string | null>;
 }
+/** Instance type for BetterAuthReactAdapter */
+type BetterAuthReactAdapterInstance = BetterAuthReactAdapterImpl;
+/** Builder type that creates adapter instances */
+type BetterAuthReactAdapterBuilder = (url: string) => BetterAuthReactAdapterInstance;
+/**
+ * Factory function that returns an adapter builder.
+ * The builder is called by createClient/createAuthClient with the URL.
+ *
+ * @param options - Optional adapter configuration (baseURL is injected separately)
+ * @returns A builder function that creates the adapter instance
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({
+ *   auth: {
+ *     url: 'https://auth.example.com',
+ *     adapter: BetterAuthReactAdapter(),
+ *   },
+ *   dataApi: { url: 'https://data-api.example.com' },
+ * });
+ * ```
+ */
+declare function BetterAuthReactAdapter(options?: BetterAuthReactAdapterOptions): BetterAuthReactAdapterBuilder;
 //#endregion
 //#region ../neon-auth/src/adapters/better-auth-vanilla/better-auth-vanilla-adapter.d.ts
-type BetterAuthVanillaAdapterOptions = NeonAuthAdapterCoreAuthOptions;
-declare class BetterAuthVanillaAdapter extends NeonAuthAdapterCore {
+type BetterAuthVanillaAdapterOptions = Omit<NeonAuthAdapterCoreAuthOptions, 'baseURL'>;
+/**
+ * Internal implementation class - use BetterAuthVanillaAdapter factory function instead
+ */
+declare class BetterAuthVanillaAdapterImpl extends NeonAuthAdapterCore {
   private _betterAuth;
-  constructor(betterAuthClientOptions: BetterAuthVanillaAdapterOptions);
+  constructor(betterAuthClientOptions: NeonAuthAdapterCoreAuthOptions);
   getBetterAuthInstance(): AuthClient<BetterAuthClientOptions>;
   getJWTToken(): Promise<string | null>;
 }
+/** Instance type for BetterAuthVanillaAdapter */
+type BetterAuthVanillaAdapterInstance = BetterAuthVanillaAdapterImpl;
+/** Builder type that creates adapter instances */
+type BetterAuthVanillaAdapterBuilder = (url: string) => BetterAuthVanillaAdapterInstance;
+/**
+ * Factory function that returns an adapter builder.
+ * The builder is called by createClient/createAuthClient with the URL.
+ *
+ * @param options - Optional adapter configuration (baseURL is injected separately)
+ * @returns A builder function that creates the adapter instance
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({
+ *   auth: {
+ *     url: 'https://auth.example.com',
+ *     adapter: BetterAuthVanillaAdapter(),
+ *   },
+ *   dataApi: { url: 'https://data-api.example.com' },
+ * });
+ * ```
+ */
+declare function BetterAuthVanillaAdapter(options?: BetterAuthVanillaAdapterOptions): BetterAuthVanillaAdapterBuilder;
 //#endregion
 //#region ../neon-auth/src/adapters/supabase/auth-interface.d.ts
 type _UpstreamAuthClientInstance = InstanceType<typeof AuthClient$1>;
@@ -732,14 +784,17 @@ type _AuthClientBase = { [K in keyof _UpstreamAuthClientInstance as _UpstreamAut
 type SupabaseAuthClientInterface = _AuthClientBase;
 //#endregion
 //#region ../neon-auth/src/adapters/supabase/supabase-adapter.d.ts
-type SupabaseAuthAdapterOptions = NeonAuthAdapterCoreAuthOptions;
-declare class SupabaseAuthAdapter extends NeonAuthAdapterCore implements SupabaseAuthClientInterface {
+type SupabaseAuthAdapterOptions = Omit<NeonAuthAdapterCoreAuthOptions, 'baseURL'>;
+/**
+ * Internal implementation class - use SupabaseAuthAdapter factory function instead
+ */
+declare class SupabaseAuthAdapterImpl extends NeonAuthAdapterCore implements SupabaseAuthClientInterface {
   admin: SupabaseAuthClientInterface['admin'];
   mfa: SupabaseAuthClientInterface['mfa'];
   oauth: SupabaseAuthClientInterface['oauth'];
   private _betterAuth;
   private _stateChangeEmitters;
-  constructor(betterAuthClientOptions: SupabaseAuthAdapterOptions);
+  constructor(betterAuthClientOptions: NeonAuthAdapterCoreAuthOptions);
   getBetterAuthInstance(): AuthClient<BetterAuthClientOptions>;
   getJWTToken(): Promise<string | null>;
   initialize: SupabaseAuthClientInterface['initialize'];
@@ -786,44 +841,59 @@ declare class SupabaseAuthAdapter extends NeonAuthAdapterCore implements Supabas
   private verifyPhoneOtp;
   private emitInitialSession;
 }
+/** Instance type for SupabaseAuthAdapter */
+type SupabaseAuthAdapterInstance = SupabaseAuthAdapterImpl;
+/** Builder type that creates adapter instances */
+type SupabaseAuthAdapterBuilder = (url: string) => SupabaseAuthAdapterInstance;
+/**
+ * Factory function that returns an adapter builder.
+ * The builder is called by createClient/createAuthClient with the URL.
+ *
+ * @param options - Optional adapter configuration (baseURL is injected separately)
+ * @returns A builder function that creates the adapter instance
+ *
+ * @example
+ * ```typescript
+ * const client = createClient({
+ *   auth: {
+ *     url: 'https://auth.example.com',
+ *     adapter: SupabaseAuthAdapter(),
+ *   },
+ *   dataApi: { url: 'https://data-api.example.com' },
+ * });
+ * ```
+ */
+declare function SupabaseAuthAdapter(options?: SupabaseAuthAdapterOptions): SupabaseAuthAdapterBuilder;
 //#endregion
 //#region ../neon-auth/src/neon-auth.d.ts
 /**
  * Type representing the Better Auth React client
  */
-type ReactBetterAuthClient = ReturnType<typeof createAuthClient>;
+type ReactBetterAuthClient = ReturnType<typeof createAuthClient$1>;
 /**
  * Type representing the Better Auth Vanilla client
  */
-type VanillaBetterAuthClient = ReturnType<typeof createAuthClient$1>;
-/**
- * Union type of all supported auth adapter CLASSES (not instances)
- * Use this when you need to pass an adapter class as a parameter
- */
-type NeonAuthAdapterClass = typeof BetterAuthVanillaAdapter | typeof BetterAuthReactAdapter | typeof SupabaseAuthAdapter;
+type VanillaBetterAuthClient = ReturnType<typeof createAuthClient$2>;
 /**
  * Union type of all supported auth adapter instances
  */
-type NeonAuthAdapter = BetterAuthVanillaAdapter | BetterAuthReactAdapter | SupabaseAuthAdapter;
+type NeonAuthAdapter = BetterAuthVanillaAdapterInstance | BetterAuthReactAdapterInstance | SupabaseAuthAdapterInstance;
 /**
- * Configuration for createNeonAuth
- * T is the adapter CLASS type (typeof SupabaseAuthAdapter), not the instance type
+ * Configuration for createAuthClient
  */
-interface NeonAuthConfig<T extends NeonAuthAdapterClass> {
-  /** The adapter class to use (e.g., SupabaseAuthAdapter, BetterAuthVanillaAdapter) */
-  adapter: T;
-  /** Additional options to pass to the adapter (baseURL is auto-injected) */
-  options?: Omit<ConstructorParameters<T>[0], 'baseURL'>;
+interface NeonAuthConfig<T extends NeonAuthAdapter> {
+  /** The adapter builder to use. Defaults to BetterAuthVanillaAdapter() if not specified. */
+  adapter?: (url: string) => T;
 }
 /**
  * Resolves the public API type for an adapter.
  * - SupabaseAuthAdapter: exposes its own methods directly (Supabase-compatible API)
  * - BetterAuth adapters: expose the Better Auth client directly
  */
-type NeonAuthPublicApi<T extends NeonAuthAdapter> = T extends BetterAuthVanillaAdapter ? VanillaBetterAuthClient : T extends BetterAuthReactAdapter ? ReactBetterAuthClient : T;
+type NeonAuthPublicApi<T extends NeonAuthAdapter> = T extends BetterAuthVanillaAdapterInstance ? VanillaBetterAuthClient : T extends BetterAuthReactAdapterInstance ? ReactBetterAuthClient : T;
 /**
  * NeonAuth type - combines base functionality with the appropriate public API
- * This is the return type of createNeonAuth()
+ * This is the return type of createAuthClient()
  *
  * For SupabaseAuthAdapter: exposes Supabase-compatible methods (signInWithPassword, getSession, etc.)
  * For BetterAuth adapters: exposes the Better Auth client directly (signIn.email, signUp.email, etc.)
@@ -836,15 +906,15 @@ type NeonAuth<T extends NeonAuthAdapter> = {
  * Create a NeonAuth instance that exposes the appropriate API based on the adapter.
  *
  * @param url - The auth service URL (e.g., 'https://auth.example.com')
- * @param config - Configuration with adapter class and optional adapter-specific options
+ * @param config - Configuration with adapter builder
  * @returns NeonAuth instance with the adapter's API exposed directly
  *
  * @example SupabaseAuthAdapter - Supabase-compatible API
  * ```typescript
- * import { createNeonAuth, SupabaseAuthAdapter } from '@neondatabase/neon-auth';
+ * import { createAuthClient, SupabaseAuthAdapter } from '@neondatabase/neon-auth';
  *
- * const auth = createNeonAuth('https://auth.example.com', {
- *   adapter: SupabaseAuthAdapter,
+ * const auth = createAuthClient('https://auth.example.com', {
+ *   adapter: SupabaseAuthAdapter(),
  * });
  *
  * // Supabase-compatible methods
@@ -854,10 +924,10 @@ type NeonAuth<T extends NeonAuthAdapter> = {
  *
  * @example BetterAuthVanillaAdapter - Direct Better Auth API
  * ```typescript
- * import { createNeonAuth, BetterAuthVanillaAdapter } from '@neondatabase/neon-auth';
+ * import { createAuthClient, BetterAuthVanillaAdapter } from '@neondatabase/neon-auth';
  *
- * const auth = createNeonAuth('https://auth.example.com', {
- *   adapter: BetterAuthVanillaAdapter,
+ * const auth = createAuthClient('https://auth.example.com', {
+ *   adapter: BetterAuthVanillaAdapter(),
  * });
  *
  * // Direct Better Auth API access
@@ -868,10 +938,10 @@ type NeonAuth<T extends NeonAuthAdapter> = {
  *
  * @example BetterAuthReactAdapter - Better Auth with React hooks
  * ```typescript
- * import { createNeonAuth, BetterAuthReactAdapter } from '@neondatabase/neon-auth';
+ * import { createAuthClient, BetterAuthReactAdapter } from '@neondatabase/neon-auth';
  *
- * const auth = createNeonAuth('https://auth.example.com', {
- *   adapter: BetterAuthReactAdapter,
+ * const auth = createAuthClient('https://auth.example.com', {
+ *   adapter: BetterAuthReactAdapter(),
  * });
  *
  * // Direct Better Auth API with React hooks
@@ -879,8 +949,8 @@ type NeonAuth<T extends NeonAuthAdapter> = {
  * const session = auth.useSession(); // React hook
  * ```
  */
-declare function createInternalNeonAuth<T extends NeonAuthAdapterClass>(url: string, config: NeonAuthConfig<T>): NeonAuth<InstanceType<T>>;
-declare function createNeonAuth<T extends NeonAuthAdapterClass>(url: string, config: NeonAuthConfig<T>): NeonAuthPublicApi<InstanceType<T>>;
+declare function createInternalNeonAuth<T extends NeonAuthAdapter = BetterAuthVanillaAdapterInstance>(url: string, config?: NeonAuthConfig<T>): NeonAuth<T>;
+declare function createAuthClient<T extends NeonAuthAdapter = BetterAuthVanillaAdapterInstance>(url: string, config?: NeonAuthConfig<T>): NeonAuthPublicApi<T>;
 //#endregion
 //#region ../neon-auth/src/utils/jwt.d.ts
 /**
@@ -950,13 +1020,11 @@ declare class NeonClient<Database = any, SchemaName extends string & keyof Datab
 /**
  * Auth configuration for createClient
  */
-type CreateClientAuthConfig<T extends NeonAuthAdapterClass> = {
-  /** The adapter class to use (e.g., SupabaseAuthAdapter, BetterAuthVanillaAdapter) */
-  adapter: T;
+type CreateClientAuthConfig<T extends NeonAuthAdapter> = {
+  /** The adapter builder to use. Defaults to BetterAuthVanillaAdapter() if not specified. */
+  adapter?: (url: string) => T;
   /** The auth service URL */
   url: string;
-  /** Additional auth options (baseURL is set from url above) */
-  options?: Omit<ConstructorParameters<T>[0], 'baseURL'>;
 };
 /**
  * Data API configuration for createClient
@@ -970,11 +1038,11 @@ type CreateClientDataApiConfig<SchemaName, TAuth extends NeonAuthAdapter> = {
 /**
  * Configuration for createClient
  */
-type CreateClientConfig<SchemaName, T extends NeonAuthAdapterClass> = {
+type CreateClientConfig<SchemaName, T extends NeonAuthAdapter> = {
   /** Auth service configuration */
   auth: CreateClientAuthConfig<T>;
   /** Data API configuration */
-  dataApi: CreateClientDataApiConfig<SchemaName, InstanceType<T>>;
+  dataApi: CreateClientDataApiConfig<SchemaName, T>;
 };
 /**
  * Factory function to create NeonClient with seamless auth integration.
@@ -985,20 +1053,16 @@ type CreateClientConfig<SchemaName, T extends NeonAuthAdapterClass> = {
  *
  * @example
  * ```typescript
- * import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
+ * // Simple usage with default BetterAuthVanillaAdapter
+ * import { createClient } from '@neondatabase/neon-js';
  *
  * const client = createClient({
- *   auth: {
- *     adapter: SupabaseAuthAdapter,
- *     url: 'https://auth.example.com',
- *   },
- *   dataApi: {
- *     url: 'https://data-api.example.com/rest/v1',
- *   },
+ *   auth: { url: 'https://auth.example.com' },
+ *   dataApi: { url: 'https://data-api.example.com/rest/v1' },
  * });
  *
- * // Auth methods (API depends on adapter)
- * await client.auth.signInWithPassword({ email, password });
+ * // Better Auth API
+ * await client.auth.signIn.email({ email, password });
  *
  * // Database queries (automatic token injection)
  * const { data: items } = await client.from('items').select();
@@ -1006,11 +1070,12 @@ type CreateClientConfig<SchemaName, T extends NeonAuthAdapterClass> = {
  *
  * @example
  * ```typescript
- * import { createClient, BetterAuthVanillaAdapter } from '@neondatabase/neon-js';
+ * // With SupabaseAuthAdapter for Supabase-compatible API
+ * import { createClient, SupabaseAuthAdapter } from '@neondatabase/neon-js';
  *
  * const client = createClient({
  *   auth: {
- *     adapter: BetterAuthVanillaAdapter,
+ *     adapter: SupabaseAuthAdapter,
  *     url: 'https://auth.example.com',
  *   },
  *   dataApi: {
@@ -1018,9 +1083,8 @@ type CreateClientConfig<SchemaName, T extends NeonAuthAdapterClass> = {
  *   },
  * });
  *
- * // Access raw Better Auth client
- * const betterAuth = client.auth.getBetterAuthInstance();
- * await betterAuth.signIn.email({ email, password });
+ * // Supabase-compatible auth methods
+ * await client.auth.signInWithPassword({ email, password });
  * ```
  */
 /**
@@ -1028,8 +1092,14 @@ type CreateClientConfig<SchemaName, T extends NeonAuthAdapterClass> = {
  * Uses 'public' as the default schema since it's the most common case.
  */
 type CreateClientResult<Database, TAdapter extends NeonAuthAdapter> = NeonClient<Database, DefaultSchemaName<Database>, TAdapter>;
-declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, typeof SupabaseAuthAdapter>): CreateClientResult<Database, SupabaseAuthAdapter>;
-declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, typeof BetterAuthVanillaAdapter>): CreateClientResult<Database, BetterAuthVanillaAdapter>;
-declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, typeof BetterAuthReactAdapter>): CreateClientResult<Database, BetterAuthReactAdapter>;
+declare function createClient<Database = any>(config: {
+  auth: {
+    url: string;
+  };
+  dataApi: CreateClientDataApiConfig<DefaultSchemaName<Database>, BetterAuthVanillaAdapterInstance>;
+}): CreateClientResult<Database, BetterAuthVanillaAdapterInstance>;
+declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, SupabaseAuthAdapterInstance>): CreateClientResult<Database, SupabaseAuthAdapterInstance>;
+declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, BetterAuthVanillaAdapterInstance>): CreateClientResult<Database, BetterAuthVanillaAdapterInstance>;
+declare function createClient<Database = any>(config: CreateClientConfig<DefaultSchemaName<Database>, BetterAuthReactAdapterInstance>): CreateClientResult<Database, BetterAuthReactAdapterInstance>;
 //#endregion
-export { AuthApiError, AuthError, BetterAuthReactAdapter, BetterAuthVanillaAdapter, type NeonAuth, type NeonAuthAdapter, type NeonAuthAdapterClass, type NeonAuthConfig, type NeonAuthPublicApi, type ReactBetterAuthClient, type Session, SupabaseAuthAdapter, type SupabaseAuthAdapterOptions, type User, type VanillaBetterAuthClient, createClient, createInternalNeonAuth, createNeonAuth, getJwtExpiration, getJwtExpirationMs, isAuthError, useBetterAuthStore };
+export { AuthApiError, AuthError, BetterAuthReactAdapter, type BetterAuthReactAdapterInstance, type BetterAuthReactAdapterOptions, BetterAuthVanillaAdapter, type BetterAuthVanillaAdapterInstance, type BetterAuthVanillaAdapterOptions, type NeonAuth, type NeonAuthAdapter, type NeonAuthConfig, type NeonAuthPublicApi, type ReactBetterAuthClient, type Session, SupabaseAuthAdapter, type SupabaseAuthAdapterInstance, type SupabaseAuthAdapterOptions, type User, type VanillaBetterAuthClient, createAuthClient, createClient, createInternalNeonAuth, getJwtExpiration, getJwtExpirationMs, isAuthError, useBetterAuthStore };

package/dist/index.mjs

@@ -25,10 +25,7 @@ var NeonClient = class extends NeonPostgrestClient {
 //#region src/client/client-factory.ts
 function createClient(config) {
 	const { auth: authConfig, dataApi: dataApiConfig } = config;
-	const auth = createInternalNeonAuth(authConfig.url, {
-		adapter: authConfig.adapter,
-		options: authConfig.options
-	});
+	const auth = createInternalNeonAuth(authConfig.url, { adapter: authConfig.adapter });
 	const getAccessToken = async () => {
 		return await auth.getJWTToken();
 	};

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neondatabase/neon-js",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.5",
   "description": "A TypeScript SDK for Neon services",
   "type": "module",
   "license": "Apache-2.0",
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "@neondatabase/postgrest-js": "^0.1.0-alpha.1",
-    "@neondatabase/neon-auth": "^0.1.0-alpha.1",
+    "@neondatabase/neon-auth": "^0.1.0-alpha.2",
     "@supabase/postgres-meta": "0.93.1",
     "meow": "14.0.0",
     "zod": "4.1.12"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neondatabase/neon-js",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.5",
   "description": "A TypeScript SDK for Neon services",
   "type": "module",
   "license": "Apache-2.0",