@rolder/kit 3.0.0-alpha.11 → 3.0.0-alpha.112

package/dist/betterAuth/client/getAuthClient.js

@@ -0,0 +1,18 @@
+import { adminClient, usernameClient } from "better-auth/client/plugins";
+import { defaultRoles } from "better-auth/plugins/organization/access";
+import { createAuthClient } from "better-auth/react";
+const getAuthClient = (config)=>{
+    const roles = config?.roles || defaultRoles;
+    const betterAuthClientOptions = config?.betterAuthClientOptions;
+    return createAuthClient({
+        ...betterAuthClientOptions,
+        plugins: [
+            adminClient({
+                roles
+            }),
+            usernameClient(),
+            ...betterAuthClientOptions?.plugins || []
+        ]
+    });
+};
+export { getAuthClient };

package/dist/betterAuth/client/index.d.ts

@@ -0,0 +1 @@
+export * from './getAuthClient';

package/dist/betterAuth/client/index.js

@@ -0,0 +1 @@
+export * from "./getAuthClient.js";

package/dist/betterAuth/index.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './server';
+export * from './useSessionUser';

package/dist/betterAuth/index.js

@@ -0,0 +1,3 @@
+export * from "./client/index.js";
+export * from "./server/index.js";
+export * from "./useSessionUser.js";

package/dist/betterAuth/server/defaultAuthServerConfig.d.ts

@@ -0,0 +1,452 @@
+import { type JwtOptions } from 'better-auth/plugins';
+export declare const defaultAuthServerPluginOptions: {
+    admin: {
+        bannedUserMessage: string;
+    };
+    jwt: {
+        jwks: {
+            keyPairConfig: {
+                alg: "EdDSA";
+                crv: "Ed25519";
+            };
+        };
+        jwt: {
+            issuer: string;
+            audience: string;
+            expirationTime: string;
+            definePayload: ({ user, session }: {
+                user: import("better-auth").User & Record<string, any>;
+                session: import("better-auth").Session & Record<string, any>;
+            }) => {
+                id: string;
+                ns: string;
+                db: string;
+                ac: string;
+                email: string;
+                name: string;
+                role: string;
+                sessionId: string;
+            };
+        };
+    };
+};
+export declare const defaultAuthServerConfig: {
+    baseURL: string;
+    secret: string | undefined;
+    database: (options: Parameters<import("better-auth/adapters").AdapterFactory>[0]) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+    experimental: {
+        joins: boolean;
+    };
+    emailAndPassword: {
+        enabled: boolean;
+    };
+    plugins: ({
+        id: "username";
+        init(ctx: import("better-auth").AuthContext): {
+            options: {
+                databaseHooks: {
+                    user: {
+                        create: {
+                            before(user: {
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            } & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                data: {
+                                    displayUsername?: string | undefined;
+                                    username?: string | undefined;
+                                    id: string;
+                                    createdAt: Date;
+                                    updatedAt: Date;
+                                    email: string;
+                                    emailVerified: boolean;
+                                    name: string;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                        update: {
+                            before(user: Partial<{
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }> & Record<string, unknown>, context: import("better-auth").GenericEndpointContext | null): Promise<{
+                                data: {
+                                    displayUsername?: string | undefined;
+                                    username?: string | undefined;
+                                    id?: string | undefined;
+                                    createdAt?: Date | undefined;
+                                    updatedAt?: Date | undefined;
+                                    email?: string | undefined;
+                                    emailVerified?: boolean | undefined;
+                                    name?: string | undefined;
+                                    image?: string | null | undefined;
+                                };
+                            }>;
+                        };
+                    };
+                };
+            };
+        };
+        endpoints: {
+            signInUsername: import("better-auth").StrictEndpoint<"/sign-in/username", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    username: import("zod").ZodString;
+                    password: import("zod").ZodString;
+                    rememberMe: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("better-auth").$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                            422: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                message: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                } & {
+                    username: string;
+                    displayUsername: string;
+                };
+            } | null>;
+            isUsernameAvailable: import("better-auth").StrictEndpoint<"/is-username-available", {
+                method: "POST";
+                body: import("zod").ZodObject<{
+                    username: import("zod").ZodString;
+                }, import("better-auth").$strip>;
+            }, {
+                available: boolean;
+            }>;
+        };
+        schema: {
+            user: {
+                fields: {
+                    username: {
+                        type: "string";
+                        required: false;
+                        sortable: true;
+                        unique: true;
+                        returned: true;
+                        transform: {
+                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                        };
+                    };
+                    displayUsername: {
+                        type: "string";
+                        required: false;
+                        transform: {
+                            input(value: import("better-auth").DBPrimitive): string | number | boolean | Date | unknown[] | Record<string, unknown> | null | undefined;
+                        };
+                    };
+                };
+            };
+        };
+        hooks: {
+            before: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        options: import("better-auth/plugins").UsernameOptions | undefined;
+        $ERROR_CODES: {
+            readonly INVALID_USERNAME_OR_PASSWORD: "Invalid username or password";
+            readonly EMAIL_NOT_VERIFIED: "Email not verified";
+            readonly UNEXPECTED_ERROR: "Unexpected error";
+            readonly USERNAME_IS_ALREADY_TAKEN: "Username is already taken. Please try another.";
+            readonly USERNAME_TOO_SHORT: "Username is too short";
+            readonly USERNAME_TOO_LONG: "Username is too long";
+            readonly INVALID_USERNAME: "Username is invalid";
+            readonly INVALID_DISPLAY_USERNAME: "Display username is invalid";
+        };
+    } | {
+        id: "jwt";
+        options: NoInfer<{
+            jwks: {
+                keyPairConfig: {
+                    alg: "EdDSA";
+                    crv: "Ed25519";
+                };
+            };
+            jwt: {
+                issuer: string;
+                audience: string;
+                expirationTime: string;
+                definePayload: ({ user, session }: {
+                    user: import("better-auth").User & Record<string, any>;
+                    session: import("better-auth").Session & Record<string, any>;
+                }) => {
+                    id: string;
+                    ns: string;
+                    db: string;
+                    ac: string;
+                    email: string;
+                    name: string;
+                    role: string;
+                    sessionId: string;
+                };
+            };
+        }>;
+        endpoints: {
+            getJwks: import("better-auth").StrictEndpoint<string, {
+                method: "GET";
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                keys: {
+                                                    type: string;
+                                                    description: string;
+                                                    items: {
+                                                        type: string;
+                                                        properties: {
+                                                            kid: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            kty: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            alg: {
+                                                                type: string;
+                                                                description: string;
+                                                            };
+                                                            use: {
+                                                                type: string;
+                                                                description: string;
+                                                                enum: string[];
+                                                                nullable: boolean;
+                                                            };
+                                                            n: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            e: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            crv: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            x: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            y: {
+                                                                type: string;
+                                                                description: string;
+                                                                nullable: boolean;
+                                                            };
+                                                        };
+                                                        required: string[];
+                                                    };
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, import("better-auth").JSONWebKeySet>;
+            getToken: import("better-auth").StrictEndpoint<"/token", {
+                method: "GET";
+                requireHeaders: true;
+                use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+            }>;
+            signJWT: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                metadata: {
+                    $Infer: {
+                        body: {
+                            payload: import("better-auth").JWTPayload;
+                            overrideOptions?: JwtOptions | undefined;
+                        };
+                    };
+                };
+                body: import("zod").ZodObject<{
+                    payload: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>;
+                    overrideOptions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                }, import("better-auth").$strip>;
+            }, {
+                token: string;
+            }>;
+            verifyJWT: import("better-auth").StrictEndpoint<string, {
+                method: "POST";
+                metadata: {
+                    $Infer: {
+                        body: {
+                            token: string;
+                            issuer?: string;
+                        };
+                        response: {
+                            payload: {
+                                sub: string;
+                                aud: string;
+                                [key: string]: any;
+                            } | null;
+                        };
+                    };
+                };
+                body: import("zod").ZodObject<{
+                    token: import("zod").ZodString;
+                    issuer: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("better-auth").$strip>;
+            }, {
+                payload: (import("better-auth").JWTPayload & Required<Pick<import("better-auth").JWTPayload, "sub" | "aud">>) | null;
+            }>;
+        };
+        hooks: {
+            after: {
+                matcher(context: import("better-auth").HookEndpointContext): boolean;
+                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+        schema: {
+            jwks: {
+                fields: {
+                    publicKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    privateKey: {
+                        type: "string";
+                        required: true;
+                    };
+                    createdAt: {
+                        type: "date";
+                        required: true;
+                    };
+                    expiresAt: {
+                        type: "date";
+                        required: false;
+                    };
+                };
+            };
+        };
+    } | {
+        id: "tanstack-start-cookies";
+        hooks: {
+            after: {
+                matcher(ctx: import("better-auth").HookEndpointContext): true;
+                handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<void>;
+            }[];
+        };
+    })[];
+};

package/dist/betterAuth/server/defaultAuthServerConfig.js

@@ -0,0 +1,49 @@
+import { jwt, username } from "better-auth/plugins";
+import { tanstackStartCookies } from "better-auth/tanstack-start";
+import { baseUrl } from "./env.js";
+import { surrealDbAdapter } from "./surrealDbAdapter/index.js";
+const defaultAuthServerPluginOptions = {
+    admin: {
+        bannedUserMessage: 'Доступ к приложению заблокирован. Обратитесь к администратору.'
+    },
+    jwt: {
+        jwks: {
+            keyPairConfig: {
+                alg: 'EdDSA',
+                crv: 'Ed25519'
+            }
+        },
+        jwt: {
+            issuer: baseUrl,
+            audience: baseUrl,
+            expirationTime: '15m',
+            definePayload: ({ user, session })=>({
+                    id: user.id,
+                    ns: process.env.SURREALDB_NAMESPACE || 'dev',
+                    db: process.env.SURREALDB_DATABASE || 'data',
+                    ac: 'better_auth_jwt',
+                    email: user.email,
+                    name: user.name,
+                    role: user.role,
+                    sessionId: session.id
+                })
+        }
+    }
+};
+const defaultAuthServerConfig = {
+    baseURL: baseUrl,
+    secret: process.env.BETTER_AUTH_SECRET,
+    database: surrealDbAdapter(),
+    experimental: {
+        joins: true
+    },
+    emailAndPassword: {
+        enabled: true
+    },
+    plugins: [
+        username(),
+        jwt(defaultAuthServerPluginOptions.jwt),
+        tanstackStartCookies()
+    ]
+};
+export { defaultAuthServerConfig, defaultAuthServerPluginOptions };

package/dist/betterAuth/server/env.d.ts

@@ -0,0 +1 @@
+export declare const baseUrl: string;

package/dist/betterAuth/server/env.js

@@ -0,0 +1,8 @@
+const baseUrl = {
+    MODE: "production",
+    DEV: false,
+    PROD: true,
+    BASE_URL: "/",
+    ASSET_PREFIX: "auto"
+}.VITE_BASE_URL || 'http://localhost:3000';
+export { baseUrl };

package/dist/betterAuth/server/getDBSession.d.ts

@@ -0,0 +1,2 @@
+import type { SurrealDBProps } from '../../surrealDB/types';
+export declare const getDBSession: (surrealDBProps?: SurrealDBProps) => Promise<import("surrealdb").SurrealSession>;

package/dist/betterAuth/server/getDBSession.js

@@ -0,0 +1,85 @@
+import { createServerOnlyFn } from "@tanstack/react-start";
+import { getDBInstance } from "../../surrealDB/index.js";
+import { getSessionToken } from "./getSessionToken.js";
+function _ts_add_disposable_resource(env, value, async) {
+    if (null != value) {
+        if ("object" != typeof value && "function" != typeof value) throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (void 0 === dispose) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if ("function" != typeof dispose) throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) env.stack.push({
+        async: true
+    });
+    return value;
+}
+function getDBSession_ts_dispose_resources(env) {
+    var _SuppressedError = "function" == typeof SuppressedError ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (getDBSession_ts_dispose_resources = function(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop())try {
+                if (!r.async && 1 === s) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                if (r.dispose) {
+                    var result = r.dispose.call(r.value);
+                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                        fail(e);
+                        return next();
+                    });
+                } else s |= 1;
+            } catch (e) {
+                fail(e);
+            }
+            if (1 === s) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+const getDBSession = createServerOnlyFn(async (surrealDBProps = {})=>{
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const token = await getSessionToken();
+        const db = await getDBInstance(surrealDBProps);
+        const dbSession = _ts_add_disposable_resource(env, await db.newSession(), true);
+        if (token) await dbSession.authenticate(token);
+        return dbSession;
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = getDBSession_ts_dispose_resources(env);
+        if (result) await result;
+    }
+});
+export { getDBSession };

package/dist/betterAuth/server/getSessionToken.d.ts

@@ -0,0 +1 @@
+export declare const getSessionToken: () => Promise<any>;

package/dist/betterAuth/server/getSessionToken.js

@@ -0,0 +1,14 @@
+import { getRequestHeaders } from "@tanstack/react-start/server";
+import { baseUrl } from "./env.js";
+const getSessionToken = async ()=>{
+    const headers = getRequestHeaders();
+    const tokenResponse = await fetch(`${baseUrl}/api/auth/token`, {
+        headers: {
+            cookie: headers.get('cookie') || ''
+        }
+    });
+    if (!tokenResponse.ok) throw new Error('Failed to get JWT token');
+    const { token } = await tokenResponse.json();
+    return token;
+};
+export { getSessionToken };

package/dist/betterAuth/server/getSessionUser.d.ts

@@ -0,0 +1 @@
+export declare function getSessionUser<TUser = unknown>(): Promise<TUser | undefined>;