@mframework/adapter-betterauth 0.0.10 → 0.0.11

package/dist/auth.d.ts

@@ -0,0 +1,2 @@
+import type { AuthAdapter, TransportAdapter } from '@mframework/core';
+export declare const createAuthAdapter: (transport: TransportAdapter) => AuthAdapter;

package/dist/auth.js

@@ -0,0 +1,31 @@
+import { unwrap } from './utils.js';
+export const createAuthAdapter = (transport) => ({
+    async login(input) {
+        const res = await transport.request('POST', '/login', {
+            body: input
+        });
+        return unwrap(res);
+    },
+    async register(input) {
+        const res = await transport.request('POST', '/register', {
+            body: input
+        });
+        return unwrap(res);
+    },
+    async logout() {
+        const res = await transport.request('POST', '/logout');
+        return unwrap({ ...res, data: true });
+    },
+    async getSession() {
+        const res = await transport.request('GET', '/session');
+        return unwrap(res);
+    },
+    async refresh() {
+        const res = await transport.request('POST', '/refresh');
+        return unwrap(res);
+    },
+    async getUser() {
+        const res = await transport.request('GET', '/user');
+        return unwrap(res);
+    }
+});

package/dist/betterauth.d.ts

@@ -0,0 +1,11 @@
+import "dotenv/config";
+export declare const auth: import("better-auth").Auth<{
+    experimental: {
+        joins: true;
+    };
+    database: (options: import("better-auth").BetterAuthOptions) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+    emailAndPassword: {
+        enabled: true;
+    };
+}>;
+export type Auth = typeof auth;

package/dist/betterauth.js

@@ -0,0 +1,12 @@
+import "dotenv/config";
+import { betterAuth } from "better-auth";
+import { prismaAdapter } from "better-auth/adapters/prisma";
+import { prisma } from "@mframework/core";
+// Create and export the BetterAuth runtime instance using the centralized
+// Prisma client exported from packages/modules/api. Layers can import `auth`
+// from this package to get the configured auth instance.
+export const auth = betterAuth({
+    experimental: { joins: true },
+    database: prismaAdapter(prisma, { provider: 'postgresql' }),
+    emailAndPassword: { enabled: true }
+});

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+export interface AuthConfig {
+    baseUrl: any;
+    authProvider: string;
+    authUrl?: string;
+    sessionCookieName?: string;
+}
+export declare function setAuthConfig(newConfig: Partial<AuthConfig>): void;
+export declare function getAuthConfig(): AuthConfig;

package/dist/config.js

@@ -0,0 +1,12 @@
+let config = {
+    authProvider: 'better-auth',
+    authUrl: '',
+    sessionCookieName: 'session',
+    baseUrl: undefined
+};
+export function setAuthConfig(newConfig) {
+    config = { ...config, ...newConfig };
+}
+export function getAuthConfig() {
+    return config;
+}

package/dist/framework.d.ts

@@ -0,0 +1,17 @@
+export interface FrameworkContext {
+    getRequestURL?(): string;
+    getRequestHeaders?(): Record<string, string>;
+    getConfig?(): any;
+    reloadApp?(): void;
+    state?<T>(key: string, init: () => T): {
+        value: T;
+    };
+}
+/**
+ * Frameworks (Nuxt, React, etc.) call this once during initialization.
+ */
+export declare function setFrameworkContext(newCtx: FrameworkContext): void;
+/**
+ * Auth providers use this to access framework-specific helpers.
+ */
+export declare function getFrameworkContext(): FrameworkContext;

package/dist/framework.js

@@ -0,0 +1,13 @@
+let ctx = {};
+/**
+ * Frameworks (Nuxt, React, etc.) call this once during initialization.
+ */
+export function setFrameworkContext(newCtx) {
+    ctx = { ...ctx, ...newCtx };
+}
+/**
+ * Auth providers use this to access framework-specific helpers.
+ */
+export function getFrameworkContext() {
+    return ctx;
+}

package/dist/index.d.ts

@@ -2,24 +2,24 @@ export declare const installAuthAdapter: (config: {
     baseUrl: string;
     apiKey?: string;
 }) => void;
-export { auth, Auth } from './src/betterauth';
-export { default as BetterAuthProvider } from './src/provider';
-export { getAuthPlugins } from './src/plugins';
-export * from './src/types';
-export * from './src/auth';
-export * from './src/utils';
-export * from './src/transport';
-export * from './src/framework';
-export * from './src/registry';
-export * from './src/validation';
-export * from './src/config';
+export { auth, Auth } from './betterauth';
+export { default as BetterAuthProvider } from './provider';
+export { getAuthPlugins } from './plugins';
+export * from './types';
+export * from './auth';
+export * from './utils';
+export * from './transport';
+export * from './framework';
+export * from './registry';
+export * from './validation';
+export * from './config';
 export * from 'better-auth/client/plugins';
 export * from '@polar-sh/better-auth';
 export * as BetterAuth from 'better-auth';
-export { getAuthConfig } from './src/config';
-export { getFrameworkContext } from './src/framework';
-export type { AuthProvider } from './src/types';
-export { registerAuthProvider } from './src/registry';
+export { getAuthConfig } from './config';
+export { getFrameworkContext } from './framework';
+export type { AuthProvider } from './types';
+export { registerAuthProvider } from './registry';
 export { polarClient } from '@polar-sh/better-auth';
 export { adminClient, inferAdditionalFields } from 'better-auth/client/plugins';
 export { stripeClient } from '@better-auth/stripe/client';

package/dist/index.js

@@ -1,6 +1,6 @@
 import { setAuthAdapter } from '@mframework/core';
-import { createAuthTransport } from './src/transport';
-import { createAuthAdapter } from './src/auth';
+import { createAuthTransport } from './transport';
+import { createAuthAdapter } from './auth';
 export const installAuthAdapter = (config) => {
     const transport = createAuthTransport(config);
     setAuthAdapter(createAuthAdapter(transport));
@@ -8,23 +8,23 @@ export const installAuthAdapter = (config) => {
 // Export the server-side BetterAuth instance (if present) so other layers can
 // import the runtime `auth` instance from this package. The file is optional
 // and will only exist when BetterAuth is configured for the adapter.
-export { auth } from './src/betterauth';
-export { default as BetterAuthProvider } from './src/provider';
-export { getAuthPlugins } from './src/plugins';
-export * from './src/types';
-export * from './src/auth';
-export * from './src/utils';
-export * from './src/transport';
-export * from './src/framework';
-export * from './src/registry';
-export * from './src/validation';
-export * from './src/config';
+export { auth } from './betterauth';
+export { default as BetterAuthProvider } from './provider';
+export { getAuthPlugins } from './plugins';
+export * from './types';
+export * from './auth';
+export * from './utils';
+export * from './transport';
+export * from './framework';
+export * from './registry';
+export * from './validation';
+export * from './config';
 export * from 'better-auth/client/plugins';
 export * from '@polar-sh/better-auth';
 export * as BetterAuth from 'better-auth';
-export { getAuthConfig } from './src/config';
-export { getFrameworkContext } from './src/framework';
-export { registerAuthProvider } from './src/registry';
+export { getAuthConfig } from './config';
+export { getFrameworkContext } from './framework';
+export { registerAuthProvider } from './registry';
 export { polarClient } from '@polar-sh/better-auth';
 export { adminClient, inferAdditionalFields } from 'better-auth/client/plugins';
 export { stripeClient } from '@better-auth/stripe/client';

package/dist/plugins.d.ts

@@ -0,0 +1,5 @@
+export type AuthPluginOptions = {
+    subscription?: boolean;
+};
+export declare function getAuthPlugins(opts?: AuthPluginOptions): any[];
+export default getAuthPlugins;

package/dist/plugins.js

@@ -0,0 +1,19 @@
+import { stripeClient } from '@better-auth/stripe/client';
+import { polarClient } from '@polar-sh/better-auth';
+import { adminClient, inferAdditionalFields } from 'better-auth/client/plugins';
+export function getAuthPlugins(opts = {}) {
+    const { subscription = true } = opts;
+    return [
+        inferAdditionalFields({
+            user: {
+                polarCustomerId: {
+                    type: 'string'
+                }
+            }
+        }),
+        adminClient(),
+        polarClient(),
+        stripeClient({ subscription })
+    ];
+}
+export default getAuthPlugins;

package/dist/provider.d.ts

@@ -0,0 +1,2 @@
+declare const BetterAuthProvider: any;
+export default BetterAuthProvider;

package/dist/provider.js

@@ -0,0 +1,84 @@
+import * as BetterAuth from 'better-auth';
+import { getAuthConfig } from './config.js';
+import { getFrameworkContext } from './framework.js';
+// Create a single shared Better Auth client instance
+let client = null;
+function resolveClientFactory() {
+    return BetterAuth.Client ?? BetterAuth.default ?? BetterAuth;
+}
+function getClient() {
+    if (client)
+        return client;
+    const config = getAuthConfig();
+    const ctx = getFrameworkContext();
+    const Client = resolveClientFactory();
+    client = Client({
+        baseURL: config.baseUrl,
+        fetch: async (url, options = {}) => {
+            const baseHeaders = ctx.getRequestHeaders?.() || {};
+            let optionHeaders = {};
+            if (options.headers instanceof Headers) {
+                options.headers.forEach((value, key) => {
+                    optionHeaders[key] = value;
+                });
+            }
+            else if (Array.isArray(options.headers)) {
+                for (const [k, v] of options.headers) {
+                    optionHeaders[k] = v;
+                }
+            }
+            else if (typeof options.headers === 'object' && options.headers !== null) {
+                optionHeaders = options.headers;
+            }
+            const headers = {
+                ...baseHeaders,
+                ...optionHeaders
+            };
+            return fetch(url, { ...options, headers });
+        }
+    });
+    return client;
+}
+const BetterAuthProvider = {
+    async login(credentials) {
+        const client = getClient();
+        const result = await client.signIn(credentials);
+        if (result.error) {
+            throw new Error(result.error.message || 'Login failed');
+        }
+        return result.data;
+    },
+    async logout() {
+        const client = getClient();
+        await client.signOut();
+        const ctx = getFrameworkContext();
+        ctx.reloadApp?.();
+    },
+    async session() {
+        const client = getClient();
+        const result = await client.session();
+        if (result.error) {
+            return null;
+        }
+        return result.data;
+    },
+    async register(data) {
+        const client = getClient();
+        const result = await client.signUp(data);
+        if (result.error) {
+            throw new Error(result.error.message || 'Registration failed');
+        }
+        return result.data;
+    },
+    async refresh() {
+        const client = getClient();
+        const result = await client.refresh();
+        if (result.error) {
+            throw new Error(result.error.message || 'Session refresh failed');
+        }
+        return result.data;
+    }
+};
+// Register the provider under the canonical name so other layers can discover
+// it using the existing registry mechanism.
+export default BetterAuthProvider;

package/dist/registry.d.ts

@@ -0,0 +1,4 @@
+import type { AuthProvider } from './types.js';
+export declare function registerAuthProvider(name: string, provider: AuthProvider): void;
+export declare function setActiveAuthProvider(name: string): void;
+export declare function getAuthProvider(): AuthProvider;

package/dist/registry.js

@@ -0,0 +1,21 @@
+// allow missing entries in the map so TypeScript understands runtime checks
+const providers = {};
+let activeProvider = null;
+export function registerAuthProvider(name, provider) {
+    providers[name] = provider;
+}
+export function setActiveAuthProvider(name) {
+    if (!providers[name]) {
+        throw new Error(`Auth provider "${name}" is not registered`);
+    }
+    activeProvider = name;
+}
+export function getAuthProvider() {
+    if (!activeProvider) {
+        throw new Error('No active auth provider has been set');
+    }
+    const prov = providers[activeProvider];
+    if (!prov)
+        throw new Error(`Auth provider "${activeProvider}" not found`);
+    return prov;
+}

package/dist/transport.d.ts

@@ -0,0 +1,5 @@
+import type { TransportAdapter } from '@mframework/core';
+export declare const createAuthTransport: (config: {
+    baseUrl: string;
+    apiKey?: string;
+}) => TransportAdapter;

package/dist/transport.js

@@ -0,0 +1,42 @@
+export const createAuthTransport = (config) => {
+    return {
+        async request(method, path, options = {}) {
+            try {
+                const url = new URL(path, config.baseUrl);
+                if (options.query) {
+                    Object.entries(options.query).forEach(([key, value]) => {
+                        url.searchParams.set(key, String(value));
+                    });
+                }
+                const res = await fetch(url.toString(), {
+                    method,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}),
+                        ...(options.headers || {})
+                    },
+                    body: options.body ? JSON.stringify(options.body) : undefined
+                });
+                const data = await res.json().catch(() => null);
+                if (!res.ok) {
+                    return {
+                        status: res.status,
+                        data: null,
+                        error: data?.message || 'Unknown error'
+                    };
+                }
+                return {
+                    status: res.status,
+                    data
+                };
+            }
+            catch (err) {
+                return {
+                    status: 500,
+                    data: null,
+                    error: err.message || 'Transport error'
+                };
+            }
+        }
+    };
+};

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+export interface AuthSession {
+    user: {
+        id: string;
+        email?: string;
+        name?: string;
+        avatarUrl?: string;
+        [key: string]: any;
+    };
+    expiresAt?: string;
+    [key: string]: any;
+}
+export interface AuthCredentials {
+    email: string;
+    password: string;
+    [key: string]: any;
+}
+export interface AuthRegistration {
+    email: string;
+    password: string;
+    name?: string;
+    [key: string]: any;
+}
+export interface AuthProvider {
+    login(credentials: AuthCredentials): Promise<AuthSession>;
+    logout(): Promise<void>;
+    session(): Promise<AuthSession | null>;
+    register?(data: AuthRegistration): Promise<AuthSession>;
+    refresh?(): Promise<AuthSession>;
+}

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+import type { APIResponse, Result } from '@mframework/core';
+export declare const unwrap: <T>(response: APIResponse<T>) => Result<T>;

package/dist/utils.js

@@ -0,0 +1,12 @@
+export const unwrap = (response) => {
+    if (response.error) {
+        return {
+            ok: false,
+            error: response.error
+        };
+    }
+    return {
+        ok: true,
+        data: response.data
+    };
+};

package/dist/validation.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type LoginInput = z.infer<typeof loginSchema>;
+export declare const registerSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+}, z.core.$strip>;
+export type RegisterInput = z.infer<typeof registerSchema>;
+export declare const forgotPasswordSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+export type ForgotPasswordInput = z.infer<typeof forgotPasswordSchema>;
+export declare const resetPasswordSchema: z.ZodObject<{
+    token: z.ZodString;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+}, z.core.$strip>;
+export type ResetPasswordInput = z.infer<typeof resetPasswordSchema>;

package/dist/validation.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export const loginSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(8)
+});
+export const registerSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(8),
+    confirmPassword: z.string().min(8)
+}).refine((data) => data.password === data.confirmPassword, {
+    message: 'Passwords do not match',
+    path: ['confirmPassword']
+});
+export const forgotPasswordSchema = z.object({
+    email: z.string().email()
+});
+export const resetPasswordSchema = z.object({
+    token: z.string(),
+    password: z.string().min(8),
+    confirmPassword: z.string().min(8)
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mframework/adapter-betterauth",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Official Better-Auth adapter for M Framework Auth Layer",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",