@meeovi/auth 1.0.2 → 1.0.4

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

@@ -0,0 +1,9 @@
+export * from './useAuth';
+export * from "better-auth";
+export * from "@better-auth/cli";
+export * from "@better-auth/oauth-provider";
+export * from "@better-auth/passkey";
+export * from "@better-auth/scim";
+export * from "@better-auth/sso";
+export * from "@better-auth/stripe";
+export * as polarSh from "@polar-sh/better-auth";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from './useAuth';
+export * from "better-auth";
+export * from "@better-auth/cli";
+export * from "@better-auth/oauth-provider";
+export * from "@better-auth/passkey";
+export * from "@better-auth/scim";
+export * from "@better-auth/sso";
+export * from "@better-auth/stripe";
+export * as polarSh from "@polar-sh/better-auth";

package/dist/middleware/redirect.global.d.ts

@@ -0,0 +1 @@
+export declare function normalizeTrailingSlash(path: string): string | null;

package/dist/middleware/redirect.global.js

@@ -0,0 +1,6 @@
+export function normalizeTrailingSlash(path) {
+    if (path !== '/' && path.endsWith('/')) {
+        return path.replace(/\/+$/, '') || '/';
+    }
+    return null;
+}

package/dist/middleware/seller.d.ts

@@ -0,0 +1,2 @@
+export declare function isSeller(user: any): boolean;
+export declare function isSellerRoute(path: string): boolean;

package/dist/middleware/seller.js

@@ -0,0 +1,6 @@
+export function isSeller(user) {
+    return !!(user && user.role === 'seller');
+}
+export function isSellerRoute(path) {
+    return path.startsWith('/dashboard/');
+}

package/dist/middleware/session.d.ts

@@ -0,0 +1,5 @@
+export interface Session {
+    id: string;
+    date_created: string;
+}
+export declare function ensureSession(getCookie: (name: string) => any, setCookie: (name: string, value: string) => void, generateId: () => string): void;

package/dist/middleware/session.js

@@ -0,0 +1,10 @@
+export function ensureSession(getCookie, setCookie, generateId) {
+    const session = getCookie('session');
+    if (!session) {
+        const newSession = {
+            id: generateId(),
+            date_created: new Date().toISOString(),
+        };
+        setCookie('session', JSON.stringify(newSession));
+    }
+}

package/dist/plugins.d.ts

@@ -0,0 +1,5 @@
+export type AuthPluginOptions = {
+    /** whether to enable subscription support for stripe plugin */
+    subscription?: boolean;
+};
+export declare function getAuthPlugins(opts?: AuthPluginOptions): any[];

package/dist/plugins.js

@@ -0,0 +1,18 @@
+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 })
+    ];
+}

package/dist/providers/better-auth.d.ts

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

package/dist/providers/better-auth.js

@@ -0,0 +1,84 @@
+import * as BetterAuth from 'better-auth';
+import { registerAuthProvider } from '../registry';
+import { getAuthConfig } from '../config';
+import { getFrameworkContext } from '../framework';
+// 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 = {}) => {
+            // Framework‑agnostic request wrapper
+            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;
+    }
+};
+registerAuthProvider('better-auth', BetterAuthProvider);

package/dist/registry.d.ts

@@ -0,0 +1,4 @@
+import type { AuthProvider } from './types';
+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,17 @@
+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');
+    }
+    return providers[activeProvider];
+}

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/useAuth.d.ts

@@ -0,0 +1,36 @@
+import type { Subscription } from '@better-auth/stripe';
+export type UseAuthOptions = {
+    /** An existing auth client. If provided, it's used as-is. */
+    client?: any;
+    /** Base URL for the auth client if creating one. */
+    baseURL?: string;
+    /** Optional headers to send with requests. */
+    headers?: Record<string, string>;
+    /** Payment provider: 'stripe' or 'polar'. If omitted, 'stripe' is assumed. */
+    payment?: 'stripe' | 'polar';
+    /** Optional app-level reload/redirect function (framework-specific). */
+    reload?: (opts: {
+        path?: string;
+    }) => Promise<void>;
+};
+export declare function useAuth(options?: UseAuthOptions): {
+    session: null;
+    user: null;
+    subscription: any;
+    subscriptions: Subscription[];
+    loggedIn: () => boolean;
+    activeStripeSubscription: () => Subscription | undefined;
+    activePolarSubscriptions: () => import("@polar-sh/sdk/models/components/customerstatesubscription.js").CustomerStateSubscription[] | undefined;
+    signIn: any;
+    signUp: any;
+    forgetPassword: any;
+    resetPassword: any;
+    sendVerificationEmail: any;
+    errorCodes: any;
+    signOut({ redirectTo }?: {
+        redirectTo?: string;
+    }): Promise<void>;
+    fetchSession: () => Promise<any>;
+    payment: "stripe" | "polar";
+    client: any;
+};

package/dist/useAuth.js

@@ -0,0 +1,88 @@
+import { createAuthClient } from 'better-auth/client';
+import { getAuthPlugins } from './plugins';
+export function useAuth(options = {}) {
+    const { client: providedClient, baseURL, headers, payment = 'stripe', reload } = options;
+    const client = providedClient || createAuthClient({
+        baseURL: baseURL || undefined,
+        fetchOptions: {
+            headers
+        },
+        plugins: getAuthPlugins({ subscription: true })
+    });
+    let session = null;
+    let user = null;
+    let subscriptions = [];
+    let polarState = null;
+    let sessionFetching = false;
+    const fetchSession = async () => {
+        if (sessionFetching)
+            return;
+        sessionFetching = true;
+        const { data } = await client.getSession();
+        session = data?.session || null;
+        const userDefaults = {
+            image: null,
+            role: null,
+            banReason: null,
+            banned: null,
+            banExpires: null,
+            stripeCustomerId: null
+        };
+        user = data?.user ? Object.assign({}, userDefaults, data.user) : null;
+        subscriptions = [];
+        if (user) {
+            if (payment == 'stripe') {
+                const { data: subscriptionData } = await client.subscription.list();
+                subscriptions = subscriptionData || [];
+            }
+            else if (payment == 'polar') {
+                const { data: customerState } = await client.customer.state();
+                polarState = customerState;
+            }
+        }
+        sessionFetching = false;
+        return data;
+    };
+    if (client?.$store?.listen) {
+        client.$store.listen('$sessionSignal', async (signal) => {
+            if (!signal)
+                return;
+            await fetchSession();
+        });
+    }
+    return {
+        session,
+        user,
+        subscription: client.subscription,
+        subscriptions,
+        loggedIn: () => !!session,
+        activeStripeSubscription: () => {
+            return subscriptions.find((sub) => sub.status === 'active' || sub.status === 'trialing');
+        },
+        activePolarSubscriptions: () => {
+            return polarState?.activeSubscriptions;
+        },
+        signIn: client.signIn,
+        signUp: client.signUp,
+        forgetPassword: client.forgetPassword,
+        resetPassword: client.resetPassword,
+        sendVerificationEmail: client.sendVerificationEmail,
+        errorCodes: client.$ERROR_CODES,
+        async signOut({ redirectTo } = {}) {
+            await client.signOut({
+                fetchOptions: {
+                    onSuccess: async () => {
+                        session = null;
+                        user = null;
+                        if (redirectTo && typeof reload === 'function') {
+                            await reload({ path: redirectTo.toString() });
+                        }
+                    }
+                }
+            });
+        },
+        fetchSession,
+        payment,
+        client
+    };
+}

package/package.json

@@ -1,13 +1,29 @@
 {
   "name": "@meeovi/auth",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Authentication for M Framework.",
-  "license": "ISC",
-  "author": "",
-  "type": "commonjs",
-  "main": "index.ts",
+  "license": "MIT",
+  "author": "Meeovi",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "keywords": [
+    "better-auth",
+    "authentication",
+    "auth",
+    "typescript",
+    "vue",
+    "m-framework"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc -p tsconfig.json"
   },
   "dependencies": {
     "@better-auth/cli": "^1.4.10",
@@ -19,12 +35,15 @@
     "@polar-sh/better-auth": "^1.6.3",
     "better-auth": "^1.4.12",
     "mjml": "^4.18.0",
+    "typescript": "^5.9.3",
     "uncrypto": "^0.1.3",
     "uuid": "^13.0.0",
     "vue": "^3.5.27",
     "vue-router": "^4.6.4"
   },
   "devDependencies": {
+    "@types/mjml": "^4.7.4",
+    "@types/node": "^25.0.9",
     "@types/uuid": "^10.0.0"
   }
 }

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './useAuth'
+
+export * from "better-auth";
+export * from "@better-auth/cli";
+export * from "@better-auth/oauth-provider";
+export * from "@better-auth/passkey";
+export * from "@better-auth/scim";
+export * from "@better-auth/sso";
+export * from "@better-auth/stripe";
+export * as polarSh from "@polar-sh/better-auth";

package/src/middleware/redirect.global.ts

@@ -0,0 +1,7 @@
+
+export function normalizeTrailingSlash(path: string) {
+  if (path !== '/' && path.endsWith('/')) {
+    return path.replace(/\/+$/, '') || '/';
+  }
+  return null;
+}

package/src/middleware/seller.ts

@@ -0,0 +1,8 @@
+
+export function isSeller(user: any): boolean {
+  return !!(user && user.role === 'seller');
+}
+
+export function isSellerRoute(path: string): boolean {
+  return path.startsWith('/dashboard/');
+}

package/src/middleware/session.ts

@@ -0,0 +1,18 @@
+
+export interface Session {
+  id: string;
+  date_created: string;
+}
+
+export function ensureSession(getCookie: (name: string) => any, setCookie: (name: string, value: string) => void, generateId: () => string) {
+  const session = getCookie('session');
+
+  if (!session) {
+    const newSession: Session = {
+      id: generateId(),
+      date_created: new Date().toISOString(),
+    };
+
+    setCookie('session', JSON.stringify(newSession));
+  }
+}

package/src/plugins.ts

@@ -7,7 +7,7 @@ export type AuthPluginOptions = {
   subscription?: boolean
 }
 
-export function getAuthPlugins(opts: AuthPluginOptions = {}) {
+export function getAuthPlugins(opts: AuthPluginOptions = {}): any[] {
   const { subscription = true } = opts
 
   return [

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist",
+    "moduleResolution": "bundler",
+    "module": "ESNext",
+    "target": "ESNext",
+    "strict": true,
+    "jsx": "react-jsx",
+    "skipLibCheck": true, 
+    "noEmitOnError": false
+  },
+  "include": ["src"]
+}

package/index.ts

@@ -1 +0,0 @@
-export * from './src/useAuth'