@rolder/kit-better-auth 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/client/index.d.ts

@@ -1 +1,2 @@
-export * from './tanstack';
+export * from 'better-auth/client/plugins';
+export * from 'better-auth/react';

package/dist/client/index.js

@@ -0,0 +1,2 @@
+export * from "better-auth/client/plugins";
+export * from "better-auth/react";

package/dist/client/tanstack/index.js

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

package/dist/client/tanstack/useSessionUser.js

@@ -0,0 +1,8 @@
+import { useRouteContext } from "@tanstack/react-router";
+const useSessionUser = ()=>{
+    const { user } = useRouteContext({
+        from: '__root__'
+    });
+    return user;
+};
+export { useSessionUser };

package/dist/client/types.d.ts

@@ -0,0 +1 @@
+export type * from 'better-auth/client/plugins';

package/dist/server/defaultAuthServerConfig.js

@@ -0,0 +1,36 @@
+import { baseUrl } from "./env.js";
+import { surrealDbAdapter } from "./surrealDbAdapter/index.js";
+const defaultAuthServerPluginOptions = {
+    admin: {
+        bannedUserMessage: 'Доступ к приложению заблокирован. Обратитесь к администратору.'
+    },
+    surrealDBjwt: {
+        jwks: {
+            keyPairConfig: {
+                alg: 'EdDSA',
+                crv: 'Ed25519'
+            }
+        },
+        jwt: {
+            issuer: baseUrl,
+            audience: baseUrl,
+            expirationTime: '15m',
+            definePayload: ()=>({
+                    ns: process.env.SURREALDB_NAMESPACE,
+                    db: process.env.SURREALDB_DATABASE,
+                    ac: 'better_auth_jwt'
+                })
+        }
+    }
+};
+const defaultAuthServerConfig = {
+    baseURL: baseUrl,
+    secret: process.env.BETTER_AUTH_SECRET
+};
+const defaultSurrealDBAdaperConfig = {
+    database: surrealDbAdapter(),
+    experimental: {
+        joins: true
+    }
+};
+export { defaultAuthServerConfig, defaultAuthServerPluginOptions, defaultSurrealDBAdaperConfig };

package/dist/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/server/index.d.ts

@@ -1,9 +1,5 @@
-export * from 'better-auth/client/plugins';
 export { betterAuth as betterAuthServer } from 'better-auth/minimal';
 export * from 'better-auth/plugins';
 export * from 'better-auth/plugins/admin/access';
-export * from 'better-auth/react';
-export { tanstackStartCookies } from 'better-auth/tanstack-start';
 export * from './defaultAuthServerConfig';
-export * from './tanstack';
 export * from './types';

package/dist/server/index.js

@@ -0,0 +1,6 @@
+import { betterAuth } from "better-auth/minimal";
+export * from "better-auth/plugins";
+export * from "better-auth/plugins/admin/access";
+export * from "./defaultAuthServerConfig.js";
+export * from "./types.js";
+export { betterAuth as betterAuthServer };

package/dist/server/surrealDbAdapter/adapter.js

@@ -0,0 +1,64 @@
+import { createAdapterFactory } from "better-auth/adapters";
+import { count, create, deleteFn, deleteMany, findMany, findOne, update, updateMany } from "./methods/index.js";
+const surrealDbAdapter = ({ surrealDbProps, debugLogs } = {})=>{
+    const adapterCreator = createAdapterFactory({
+        config: {
+            adapterId: 'surrealdb',
+            adapterName: 'SurrealDB Adapter',
+            usePlural: false,
+            supportsJSON: true,
+            supportsArrays: true,
+            supportsDates: true,
+            supportsBooleans: true,
+            supportsUUIDs: true,
+            debugLogs: debugLogs ?? false
+        },
+        adapter: (a)=>({
+                create: (p)=>create({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    }),
+                update: (p)=>update({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    }),
+                updateMany: (p)=>updateMany({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    }),
+                findOne: (p)=>findOne({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    }),
+                findMany: (p)=>findMany({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    }),
+                delete: (p)=>deleteFn({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    }),
+                deleteMany: (p)=>deleteMany({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    }),
+                count: (p)=>count({
+                        ...p,
+                        ...a,
+                        surrealDbProps
+                    })
+            })
+    });
+    return (options)=>{
+        const safeOptions = options ?? {};
+        return adapterCreator(safeOptions);
+    };
+};
+export { surrealDbAdapter };

package/dist/server/surrealDbAdapter/db/getDB.js

@@ -0,0 +1,25 @@
+import { baseUrl } from "../../env.js";
+import { getDBInstance } from "./getDBInstance.js";
+import { schema } from "./schema.js";
+let schemaApplied = false;
+let schemaApplying = false;
+const ensureAuthSchema = async (props = {})=>{
+    if (schemaApplied) return;
+    if (!schemaApplying) try {
+        schemaApplying = true;
+        const db = await getDBInstance(props);
+        const betterAuthJwksUrl = `${baseUrl}/api/auth/jwks`;
+        await db.query(schema, {
+            BETTER_AUTH_JWKS_URL: betterAuthJwksUrl
+        });
+        schemaApplied = true;
+    } finally{
+        schemaApplying = false;
+    }
+};
+const getDb = async (props = {})=>{
+    const db = await getDBInstance(props);
+    await ensureAuthSchema(props);
+    return db;
+};
+export { getDb };

package/dist/server/surrealDbAdapter/db/getDBInstance.js

@@ -0,0 +1,39 @@
+import { Surreal, applyDiagnostics, createRemoteEngines } from "surrealdb";
+let db = null;
+const getDBInstance = async (params = {})=>{
+    if (db?.isConnected) return db;
+    const instance = new Surreal(params.debug ? {
+        engines: applyDiagnostics(createRemoteEngines(), (event)=>{
+            console.log('Surreal debug:', event);
+        })
+    } : void 0);
+    try {
+        const url = params.url || process.env.BETTER_AUTH_SURREALDB_URL;
+        if (!url) throw new Error('Missing required BETTER_AUTH_SURREALDB_URL');
+        const namespace = params.namespace || process.env.BETTER_AUTH_SURREALDB_NAMESPACE;
+        if (!namespace) throw new Error('Missing required BETTER_AUTH_SURREALDB_NAMESPACE');
+        const database = params.database || process.env.BETTER_AUTH_SURREALDB_DATABASE;
+        if (!database) throw new Error('Missing required BETTER_AUTH_SURREALDB_DATABASE');
+        const username = params.username || process.env.BETTER_AUTH_SURREALDB_USERNAME;
+        if (!username) throw new Error('Missing required BETTER_AUTH_SURREALDB_USERNAME');
+        const password = params.password || process.env.BETTER_AUTH_SURREALDB_PASSWORD;
+        if (!password) throw new Error('Missing required BETTER_AUTH_SURREALDB_PASSWORD');
+        await instance.connect(url, {
+            authentication: {
+                username,
+                password
+            }
+        });
+        await instance.use({
+            namespace,
+            database
+        });
+        db = instance;
+        return instance;
+    } catch (error) {
+        console.error('Better Auth failed to connect to SurrealDB:', error);
+        db = null;
+        throw error;
+    }
+};
+export { getDBInstance };

package/dist/server/surrealDbAdapter/db/index.js

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

package/dist/server/surrealDbAdapter/db/schema.js

@@ -0,0 +1,101 @@
+const schema = `
+// Better Auth JWT Access
+DEFINE ACCESS IF NOT EXISTS better_auth_jwt ON DATABASE TYPE RECORD
+  WITH JWT URL $BETTER_AUTH_JWKS_URL
+  AUTHENTICATE {
+    IF $token.sub {
+      RETURN SELECT * FROM ONLY <RECORD>("user:"+ $token.sub);
+    } ELSE {
+      THROW "There is no user id at $token.sub"
+    }
+  }
+;
+
+// User
+DEFINE TABLE IF NOT EXISTS user TYPE NORMAL SCHEMAFULL PERMISSIONS FULL;
+DEFINE FIELD IF NOT EXISTS name ON user TYPE string;
+DEFINE FIELD IF NOT EXISTS email ON user TYPE option<string> ASSERT $value = NONE OR string::is_email($value);
+DEFINE FIELD IF NOT EXISTS email_address ON user TYPE option<string> ASSERT $value = NONE OR string::is_email($value);
+DEFINE INDEX IF NOT EXISTS userUserUnique ON user COLUMNS email UNIQUE;
+DEFINE FIELD IF NOT EXISTS emailVerified ON user TYPE bool;
+DEFINE FIELD IF NOT EXISTS image ON user TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS createdAt ON user TYPE option<datetime> DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS updatedAt ON user TYPE option<datetime> DEFAULT time::now();
+-- Admin plugin
+DEFINE FIELD IF NOT EXISTS role ON user TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS banned ON user TYPE option<bool>;
+DEFINE FIELD IF NOT EXISTS banReason ON user TYPE option<string> | NULL;
+DEFINE FIELD IF NOT EXISTS banExpires ON user TYPE option<datetime> | NULL;
+-- Username plugin
+DEFINE FIELD IF NOT EXISTS username ON user TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS displayUsername ON user TYPE option<string>;
+-- Custom
+DEFINE FIELD IF NOT EXISTS accounts ON user COMPUTED <~account;
+DEFINE FIELD IF NOT EXISTS sessions ON user COMPUTED <~session;
+
+-- // Session
+DEFINE TABLE IF NOT EXISTS session TYPE NORMAL SCHEMAFULL PERMISSIONS FULL;
+DEFINE FIELD IF NOT EXISTS expiresAt ON session TYPE datetime;
+DEFINE FIELD IF NOT EXISTS token ON session TYPE string;
+DEFINE INDEX IF NOT EXISTS sessionSessionUnique ON session COLUMNS token UNIQUE;
+DEFINE FIELD IF NOT EXISTS createdAt ON session TYPE option<datetime> DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS updatedAt ON session TYPE option<datetime> DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS ipAddress ON session TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS userAgent ON session TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS userId ON session TYPE record<user> REFERENCE ON DELETE IGNORE;
+-- Admin plugin
+DEFINE FIELD IF NOT EXISTS impersonatedBy ON user TYPE option<record<user>>;
+
+-- // Account
+DEFINE TABLE IF NOT EXISTS account TYPE NORMAL SCHEMAFULL PERMISSIONS FULL;
+DEFINE FIELD IF NOT EXISTS accountId ON account TYPE string;
+DEFINE FIELD IF NOT EXISTS providerId ON account TYPE string;
+DEFINE FIELD IF NOT EXISTS accessToken ON account TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS refreshToken ON account TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS idToken ON account TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS accessTokenExpiresAt ON account TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS refreshTokenExpiresAt ON account TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS scope ON account TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS password ON account TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS createdAt ON account TYPE option<datetime> DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS updatedAt ON account TYPE option<datetime> DEFAULT time::now();
+-- Custom
+DEFINE FIELD IF NOT EXISTS userId ON account TYPE record<user> REFERENCE ON DELETE IGNORE;
+
+// Verification
+DEFINE TABLE IF NOT EXISTS verification TYPE NORMAL SCHEMAFULL PERMISSIONS FULL;
+DEFINE FIELD IF NOT EXISTS identifier ON verification TYPE string;
+DEFINE FIELD IF NOT EXISTS value ON verification TYPE string;
+DEFINE FIELD IF NOT EXISTS expiresAt ON verification TYPE datetime;
+DEFINE FIELD IF NOT EXISTS createdAt ON verification TYPE option<datetime> DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS updatedAt ON verification TYPE option<datetime> DEFAULT time::now();
+
+// JWKS
+DEFINE TABLE IF NOT EXISTS jwks TYPE NORMAL SCHEMAFULL PERMISSIONS FULL;
+DEFINE FIELD IF NOT EXISTS publicKey ON jwks TYPE string;
+DEFINE FIELD IF NOT EXISTS privateKey ON jwks TYPE string;
+DEFINE FIELD IF NOT EXISTS createdAt ON jwks TYPE option<datetime> DEFAULT time::now();
+DEFINE FIELD IF NOT EXISTS updatedAt ON jwks TYPE option<datetime> DEFAULT time::now();
+
+// Root auth user
+IF !user:root.* {
+    CREATE user:root CONTENT {
+    	name: 'Системная учетная запись',
+    	role: 'admin',
+    	username: 'root',
+    	displayUsername: 'Root',
+    	email: 'mail@rolder.dev',
+    	emailVerified: true,
+    	banned: false,
+    };
+};
+
+IF !account:root.* {
+    CREATE account:root CONTENT {
+    	accountId: 'root',
+    	userId: user:root,
+    	password: '52c2da6bc1a525ee0f6a298e228a1314:c7ba714b9467d4582c5848947c2536340ff9f85ff6ca6c9ee022f68cd5eb60e227ba0cbadd3d46e9316c4562cef9d7551c957192809bf2a4b27f2a2b1365a08e',
+        providerId: 'credential',
+    };
+};`;
+export { schema };

package/dist/server/surrealDbAdapter/index.js

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

package/dist/server/surrealDbAdapter/methods/count.js

@@ -0,0 +1,17 @@
+import { Table, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression } from "../utils/index.js";
+const count = async ({ model, where, surrealDbProps, ...args })=>{
+    const db = await getDb(surrealDbProps);
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const query = surql`SELECT count() AS count FROM ${table}`;
+    if (expression) query.append(surql` WHERE ${expression}`);
+    const [rows] = await db.query(query).json().collect();
+    return rows?.[0]?.count ?? 0;
+};
+export { count };

package/dist/server/surrealDbAdapter/methods/create.js

@@ -0,0 +1,21 @@
+import { RecordId, Table, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { normalizeOutputRecordIds, normalizeRecordIds } from "../utils/index.js";
+const create = async ({ model, data, surrealDbProps, ...args })=>{
+    const db = await getDb(surrealDbProps);
+    const { id, ...content } = data;
+    const normalized = normalizeRecordIds({
+        model,
+        data: content,
+        ...args
+    });
+    const hasId = null != id;
+    const target = hasId ? new RecordId(model, String(id)) : new Table(model);
+    const [rows] = await db.query(surql`CREATE ${target} CONTENT ${normalized} RETURN AFTER`).json().collect();
+    return normalizeOutputRecordIds({
+        model,
+        data: rows?.[0] ?? null,
+        ...args
+    });
+};
+export { create };

package/dist/server/surrealDbAdapter/methods/delete.js

@@ -0,0 +1,18 @@
+import { Table, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression } from "../utils/index.js";
+const deleteFn = async ({ model, where, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('Delete requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const query = surql`DELETE FROM ${table}`;
+    if (expression) query.append(surql` WHERE ${expression}`);
+    query.append(surql` RETURN BEFORE`);
+    await db.query(query);
+};
+export { deleteFn };

package/dist/server/surrealDbAdapter/methods/deleteMany.js

@@ -0,0 +1,19 @@
+import { Table, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression } from "../utils/index.js";
+const deleteMany = async ({ model, where, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('DeleteMany requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const query = surql`DELETE FROM ${table}`;
+    if (expression) query.append(surql` WHERE ${expression}`);
+    query.append(surql` RETURN BEFORE`);
+    const [rows] = await db.query(query).json().collect();
+    return rows?.length ?? 0;
+};
+export { deleteMany };

package/dist/server/surrealDbAdapter/methods/findMany.js

@@ -0,0 +1,51 @@
+import { Table, raw, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { applyJoinMappings, buildExpression, buildJoinPlan, buildSelectFields, normalizeOutputRecordIds } from "../utils/index.js";
+const findMany = async ({ model, where, limit, offset, sortBy, join, surrealDbProps, ...args })=>{
+    const db = await getDb(surrealDbProps);
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const joinPlan = buildJoinPlan({
+        model,
+        join,
+        ...args
+    });
+    const fields = buildSelectFields(void 0, (field)=>args.getFieldName({
+            model,
+            field
+        }));
+    const baseFields = fields.split(', ');
+    const joinFields = joinPlan.selectFields.filter((field)=>!baseFields.includes(field));
+    const finalFields = [
+        ...baseFields,
+        ...joinFields
+    ].join(', ');
+    const query = surql`SELECT ${raw(finalFields)} FROM ${table}`;
+    if (expression) query.append(surql` WHERE ${expression}`);
+    if (sortBy) {
+        const orderField = args.getFieldName({
+            model,
+            field: sortBy.field
+        });
+        const direction = sortBy.direction.toUpperCase();
+        query.append(surql` ORDER BY ${raw(orderField)} ${raw(direction)}`);
+    }
+    if ('number' == typeof offset) query.append(surql` START ${offset}`);
+    query.append(surql` LIMIT ${limit}`);
+    if (joinPlan.fetchFields.size > 0) query.append(surql` FETCH ${raw(Array.from(joinPlan.fetchFields).join(', '))}`);
+    const [rows] = await db.query(query).json().collect();
+    return (rows ?? []).map((row)=>normalizeOutputRecordIds({
+            model,
+            data: applyJoinMappings({
+                row,
+                mappings: joinPlan.mappings,
+                ...args
+            }),
+            ...args
+        }));
+};
+export { findMany };

package/dist/server/surrealDbAdapter/methods/findOne.js

@@ -0,0 +1,42 @@
+import { Table, raw, surql } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { applyJoinMappings, buildExpression, buildJoinPlan, buildSelectFields, normalizeOutputRecordIds } from "../utils/index.js";
+const findOne = async ({ model, where, select, join, surrealDbProps, ...args })=>{
+    const db = await getDb(surrealDbProps);
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const joinPlan = buildJoinPlan({
+        model,
+        join,
+        ...args
+    });
+    const fields = buildSelectFields(select, (field)=>args.getFieldName({
+            model,
+            field
+        }));
+    const baseFields = fields.split(', ');
+    const joinFields = joinPlan.selectFields.filter((field)=>!baseFields.includes(field));
+    const finalFields = [
+        ...baseFields,
+        ...joinFields
+    ].join(', ');
+    const query = surql`SELECT ${raw(finalFields)} FROM ${table}`;
+    if (expression) query.append(surql` WHERE ${expression}`);
+    query.append(surql` LIMIT ${1}`);
+    if (joinPlan.fetchFields.size > 0) query.append(surql` FETCH ${raw(Array.from(joinPlan.fetchFields).join(', '))}`);
+    const [rows] = await db.query(query).json().collect();
+    return normalizeOutputRecordIds({
+        model,
+        data: applyJoinMappings({
+            row: rows?.[0] ?? null,
+            mappings: joinPlan.mappings,
+            ...args
+        }),
+        ...args
+    });
+};
+export { findOne };

package/dist/server/surrealDbAdapter/methods/index.js

@@ -0,0 +1,8 @@
+export * from "./count.js";
+export * from "./create.js";
+export * from "./delete.js";
+export * from "./deleteMany.js";
+export * from "./findMany.js";
+export * from "./findOne.js";
+export * from "./update.js";
+export * from "./updateMany.js";

package/dist/server/surrealDbAdapter/methods/update.js

@@ -0,0 +1,25 @@
+import { Table } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression, normalizeOutputRecordIds, normalizeRecordIds } from "../utils/index.js";
+const update_update = async ({ model, where, update, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('Update requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const normalized = normalizeRecordIds({
+        model,
+        data: update,
+        ...args
+    });
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const [updated] = await db.update(table).merge(normalized).where(expression).json();
+    return normalizeOutputRecordIds({
+        model,
+        data: updated ?? null,
+        ...args
+    });
+};
+export { update_update as update };

package/dist/server/surrealDbAdapter/methods/updateMany.js

@@ -0,0 +1,21 @@
+import { Table } from "surrealdb";
+import { getDb } from "../db/index.js";
+import { buildExpression, normalizeRecordIds } from "../utils/index.js";
+const updateMany = async ({ model, where, update, surrealDbProps, ...args })=>{
+    if (!where || 0 === where.length) throw new Error('UpdateMany requires a where clause');
+    const db = await getDb(surrealDbProps);
+    const normalized = normalizeRecordIds({
+        model,
+        data: update,
+        ...args
+    });
+    const table = new Table(model);
+    const expression = buildExpression({
+        model,
+        where,
+        ...args
+    });
+    const updated = await db.update(table).merge(normalized).where(expression).json();
+    return updated?.length ?? 0;
+};
+export { updateMany };

package/dist/server/surrealDbAdapter/utils/applyJoinMappings.js

@@ -0,0 +1,31 @@
+import { normalizeOutputRecordIds } from "./normalizeOutputRecordIds.js";
+const applyJoinMappings = ({ row, mappings, ...args })=>{
+    if (!row || 0 === mappings.length) return row;
+    const normalized = {
+        ...row
+    };
+    for (const mapping of mappings){
+        if (void 0 !== normalized[mapping.modelName]) continue;
+        if (void 0 === normalized[mapping.sourceField]) continue;
+        const sourceValue = normalized[mapping.sourceField];
+        if (Array.isArray(sourceValue)) {
+            normalized[mapping.modelName] = sourceValue.map((item)=>normalizeOutputRecordIds({
+                    model: mapping.modelName,
+                    data: item,
+                    ...args
+                }));
+            continue;
+        }
+        if (sourceValue && 'object' == typeof sourceValue) {
+            normalized[mapping.modelName] = normalizeOutputRecordIds({
+                model: mapping.modelName,
+                data: sourceValue,
+                ...args
+            });
+            continue;
+        }
+        normalized[mapping.modelName] = sourceValue;
+    }
+    return normalized;
+};
+export { applyJoinMappings };

package/dist/server/surrealDbAdapter/utils/buildExpression.js

@@ -0,0 +1,58 @@
+import { and, contains, eq, gt, gte, inside, lt, lte, or } from "surrealdb";
+import { normalizeWhereValue } from "./normalizeWhereValue.js";
+const buildExpression = ({ model, where, ...args })=>{
+    if (!where || 0 === where.length) return;
+    const opExpression = (clause)=>{
+        const field = clause.field;
+        const value = normalizeWhereValue({
+            model,
+            field,
+            value: clause.value,
+            ...args
+        });
+        const operator = clause.operator ?? 'eq';
+        switch(operator){
+            case 'ne':
+                return {
+                    toSQL: (ctx)=>`${field} != ${ctx.def(value)}`
+                };
+            case 'gt':
+                return gt(field, value);
+            case 'gte':
+                return gte(field, value);
+            case 'lt':
+                return lt(field, value);
+            case 'lte':
+                return lte(field, value);
+            case 'contains':
+                return contains(field, value);
+            case 'starts_with':
+                return {
+                    toSQL: (ctx)=>`string::starts_with(${field}, ${ctx.def(value)})`
+                };
+            case 'ends_with':
+                return {
+                    toSQL: (ctx)=>`string::ends_with(${field}, ${ctx.def(value)})`
+                };
+            case 'in':
+                return inside(field, value);
+            case 'not_in':
+                return {
+                    toSQL: (ctx)=>`${field} NOT IN ${ctx.def(value)}`
+                };
+            default:
+                return eq(field, value);
+        }
+    };
+    let expression;
+    for (const clause of where){
+        const next = opExpression(clause);
+        if (!expression) {
+            expression = next;
+            continue;
+        }
+        expression = 'OR' === clause.connector ? or(expression, next) : and(expression, next);
+    }
+    return expression;
+};
+export { buildExpression };

package/dist/server/surrealDbAdapter/utils/buildJoinPlan.js

@@ -0,0 +1,46 @@
+const buildJoinPlan = ({ model, join, getDefaultModelName })=>{
+    const joinFieldsByModel = {
+        user: {
+            account: 'accounts',
+            session: 'sessions'
+        }
+    };
+    const selectFields = [];
+    const fetchFields = new Set();
+    const mappings = [];
+    if (!join || 0 === Object.keys(join).length) return {
+        selectFields,
+        fetchFields,
+        mappings
+    };
+    for (const [joinModel, joinConfig] of Object.entries(join)){
+        const baseModelName = getDefaultModelName(model);
+        const joinModelName = getDefaultModelName(joinModel);
+        const relation = joinConfig.relation ?? 'one-to-many';
+        if ('one-to-one' === relation) {
+            const fromField = joinConfig.on.from;
+            selectFields.push(fromField);
+            fetchFields.add(fromField);
+            mappings.push({
+                modelName: joinModel,
+                sourceField: fromField
+            });
+            continue;
+        }
+        const computedField = joinFieldsByModel[baseModelName]?.[joinModelName];
+        if (computedField) {
+            selectFields.push(computedField);
+            fetchFields.add(computedField);
+            mappings.push({
+                modelName: joinModel,
+                sourceField: computedField
+            });
+        }
+    }
+    return {
+        selectFields,
+        fetchFields,
+        mappings
+    };
+};
+export { buildJoinPlan };

package/dist/server/surrealDbAdapter/utils/buildSelectFields.js

@@ -0,0 +1,5 @@
+const buildSelectFields = (select, mapField)=>{
+    if (!select || 0 === select.length) return '*';
+    return select.map(mapField).join(', ');
+};
+export { buildSelectFields };

package/dist/server/surrealDbAdapter/utils/index.js

@@ -0,0 +1,6 @@
+export * from "./applyJoinMappings.js";
+export * from "./buildExpression.js";
+export * from "./buildJoinPlan.js";
+export * from "./buildSelectFields.js";
+export * from "./normalizeOutputRecordIds.js";
+export * from "./normalizeRecordIds.js";

package/dist/server/surrealDbAdapter/utils/normalizeOutputRecordIds.js

@@ -0,0 +1,43 @@
+import { RecordId } from "surrealdb";
+const normalizeOutputRecordIds = ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes })=>{
+    if (!data) return data;
+    const normalized = {
+        ...data
+    };
+    const defaultModelName = getDefaultModelName(model);
+    const stripRecordId = (raw)=>{
+        if (raw instanceof RecordId) return stripRecordId(String(raw));
+        if ('string' != typeof raw) return raw;
+        const separatorIndex = raw.indexOf(':');
+        if (-1 === separatorIndex) return raw;
+        let id = raw.slice(separatorIndex + 1);
+        if (id.startsWith('⟨') && id.endsWith('⟩')) id = id.slice(1, -1);
+        return id;
+    };
+    for (const [field, value] of Object.entries(normalized)){
+        let defaultField;
+        try {
+            defaultField = getDefaultFieldName({
+                model: defaultModelName,
+                field
+            });
+        } catch  {
+            continue;
+        }
+        const applyStrip = (targetValue)=>{
+            if (Array.isArray(targetValue)) return targetValue.map((entry)=>stripRecordId(entry));
+            return stripRecordId(targetValue);
+        };
+        if ('id' === defaultField) {
+            normalized[field] = applyStrip(value);
+            continue;
+        }
+        const fieldAttr = getFieldAttributes({
+            model: defaultModelName,
+            field: defaultField
+        });
+        if (fieldAttr?.references?.field === 'id') normalized[field] = applyStrip(value);
+    }
+    return normalized;
+};
+export { normalizeOutputRecordIds };

package/dist/server/surrealDbAdapter/utils/normalizeRecordIds.js

@@ -0,0 +1,38 @@
+import { deserialize } from "@rolder/kit-surreal-db";
+import { RecordId } from "surrealdb";
+const normalizeRecordIds = ({ model, data, getDefaultModelName, getDefaultFieldName, getFieldAttributes, getModelName })=>{
+    const normalized = {
+        ...data
+    };
+    const defaultModelName = getDefaultModelName(model);
+    const toRecordId = (target, raw)=>{
+        if (raw instanceof RecordId) return raw;
+        if ('string' == typeof raw) return raw.includes(':') ? deserialize(raw) : new RecordId(target, raw);
+        return raw;
+    };
+    for (const [field, value] of Object.entries(normalized)){
+        let defaultField;
+        try {
+            defaultField = getDefaultFieldName({
+                model: defaultModelName,
+                field
+            });
+        } catch  {
+            continue;
+        }
+        if ('id' === defaultField) continue;
+        const fieldAttr = getFieldAttributes({
+            model: defaultModelName,
+            field: defaultField
+        });
+        if (fieldAttr?.references?.field !== 'id') continue;
+        const targetModel = getModelName(fieldAttr.references.model);
+        if (Array.isArray(value)) {
+            normalized[field] = value.map((entry)=>toRecordId(targetModel, entry));
+            continue;
+        }
+        normalized[field] = toRecordId(targetModel, value);
+    }
+    return normalized;
+};
+export { normalizeRecordIds };

package/dist/server/surrealDbAdapter/utils/normalizeWhereValue.js

@@ -0,0 +1,33 @@
+import { deserialize } from "@rolder/kit-surreal-db";
+import { RecordId } from "surrealdb";
+const normalizeWhereValue = ({ model, field, value, getDefaultModelName, getDefaultFieldName, getModelName, getFieldAttributes })=>{
+    const defaultModelName = getDefaultModelName(model);
+    const toRecordId = (target, raw)=>{
+        if (raw instanceof RecordId) return raw;
+        if ('string' == typeof raw) return raw.includes(':') ? deserialize(raw) : new RecordId(target, raw);
+        return raw;
+    };
+    let defaultField;
+    try {
+        defaultField = getDefaultFieldName({
+            model: defaultModelName,
+            field
+        });
+    } catch  {
+        return value;
+    }
+    if ('id' === defaultField) {
+        const targetModel = getModelName(defaultModelName);
+        if (Array.isArray(value)) return value.map((entry)=>toRecordId(targetModel, entry));
+        return toRecordId(targetModel, value);
+    }
+    const fieldAttr = getFieldAttributes({
+        model: defaultModelName,
+        field: defaultField
+    });
+    if (fieldAttr?.references?.field !== 'id') return value;
+    const targetModel = getModelName(fieldAttr.references.model);
+    if (Array.isArray(value)) return value.map((entry)=>toRecordId(targetModel, entry));
+    return toRecordId(targetModel, value);
+};
+export { normalizeWhereValue };

package/dist/server/tanstack/getSessionTokenTanstack.js

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

package/dist/server/tanstack/getSessionUserTanstack.js

@@ -0,0 +1,18 @@
+import { createServerFn } from "@tanstack/react-start";
+import { getRequestHeaders } from "@tanstack/react-start/server";
+import { baseUrl } from "../env.js";
+const getSessionUserFn = createServerFn().handler(async ()=>{
+    const headers = getRequestHeaders();
+    const sessionResponse = await fetch(`${baseUrl}/api/auth/get-session`, {
+        headers: {
+            cookie: headers.get('cookie') || ''
+        }
+    });
+    if (!sessionResponse.ok) return;
+    const session = await sessionResponse.json();
+    return session?.user;
+});
+async function getSessionUserTanstack() {
+    return await getSessionUserFn();
+}
+export { getSessionUserTanstack };

package/dist/server/tanstack/index.d.ts

@@ -1,2 +1,3 @@
+export { tanstackStartCookies } from 'better-auth/tanstack-start';
 export * from './getSessionTokenTanstack';
 export * from './getSessionUserTanstack';

package/dist/server/tanstack/index.js

@@ -0,0 +1,4 @@
+import { tanstackStartCookies } from "better-auth/tanstack-start";
+export * from "./getSessionTokenTanstack.js";
+export * from "./getSessionUserTanstack.js";
+export { tanstackStartCookies };

package/dist/server/types.d.ts

@@ -1,4 +1,3 @@
-export type * from 'better-auth/client/plugins';
 export type * from 'better-auth/minimal';
 export type * from 'better-auth/plugins';
 export type InferUserWithRoles<TInferredUser extends {

package/package.json

@@ -1,11 +1,23 @@
 {
 	"name": "@rolder/kit-better-auth",
-	"version": "0.1.0-alpha.2",
+	"version": "0.1.0-alpha.3",
 	"type": "module",
 	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
+		"./server": {
+			"types": "./dist/server/index.d.ts",
+			"import": "./dist/server/index.js"
+		},
+		"./server/tanstack": {
+			"types": "./dist/server/tanstack/index.d.ts",
+			"import": "./dist/server/tanstack/index.js"
+		},
+		"./client": {
+			"types": "./dist/client/index.d.ts",
+			"import": "./dist/client/index.js"
+		},
+		"./client/tanstack": {
+			"types": "./dist/client/tanstack/index.d.ts",
+			"import": "./dist/client/tanstack/index.js"
 		}
 	},
 	"sideEffects": false,

package/dist/index.d.ts

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

package/dist/index.js

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