@rolder/kit 3.0.0-alpha.91 → 3.0.0-alpha.93

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

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

package/dist/betterAuth/server/auth.test.js

@@ -0,0 +1,71 @@
+import { beforeAll, describe, expect, it } from "vitest";
+const ensureDbEnv = ()=>{
+    process.env.SURREALDB_DATABASE = 'tests';
+};
+const hasDbEnv = ()=>Boolean(process.env.SURREALDB_URL && process.env.SURREALDB_NAMESPACE && process.env.SURREALDB_USERNAME && process.env.SURREALDB_PASSWORD);
+let auth;
+const createUser = ()=>{
+    const id = crypto.randomUUID();
+    return {
+        name: 'Test User',
+        email: `test.user+${id}@example.com`,
+        password: 'password-123'
+    };
+};
+describe.skipIf(!hasDbEnv())('better auth', ()=>{
+    beforeAll(async ()=>{
+        ensureDbEnv();
+        auth = (await import("./index.js")).getAuthServer();
+    });
+    it('rejects protected endpoints without a session', async ()=>{
+        const request = new Request('http://localhost/api/auth/list-accounts');
+        const response = await auth.handler(request);
+        expect([
+            401,
+            403
+        ]).toContain(response.status);
+    });
+    it('supports sign-up and sign-in with session retrieval', async ()=>{
+        const origin = 'http://localhost';
+        const user = createUser();
+        const signUpRequest = new Request('http://localhost/api/auth/sign-up/email', {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                origin
+            },
+            body: JSON.stringify({
+                name: user.name,
+                email: user.email,
+                password: user.password
+            })
+        });
+        const signUpResponse = await auth.handler(signUpRequest);
+        expect(signUpResponse.status).toBe(200);
+        const signInRequest = new Request('http://localhost/api/auth/sign-in/email', {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                origin
+            },
+            body: JSON.stringify({
+                email: user.email,
+                password: user.password
+            })
+        });
+        const signInResponse = await auth.handler(signInRequest);
+        expect(signInResponse.status).toBe(200);
+        const setCookie = signInResponse.headers.get('set-cookie');
+        expect(setCookie).toBeTruthy();
+        const cookie = setCookie?.split(';')[0];
+        const sessionRequest = new Request('http://localhost/api/auth/get-session', {
+            headers: cookie ? {
+                cookie
+            } : void 0
+        });
+        const sessionResponse = await auth.handler(sessionRequest);
+        expect(sessionResponse.status).toBe(200);
+        const sessionBody = await sessionResponse.json();
+        expect(sessionBody?.user?.email).toBe(user.email);
+    });
+});

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

@@ -0,0 +1,8 @@
+import type { BetterAuthOptions } from 'better-auth';
+import { betterAuth } from 'better-auth';
+import { type Role } from 'better-auth/plugins';
+export interface AuthServer<TRoles extends Record<string, Role>> {
+    betterAuthOptions?: Partial<BetterAuthOptions>;
+    roles?: TRoles;
+}
+export declare const getAuthServer: <TRoles extends Record<string, Role>>(config?: AuthServer<TRoles>) => ReturnType<typeof betterAuth>;

package/dist/betterAuth/server/getAuthServer.js

@@ -0,0 +1,69 @@
+import { betterAuth } from "better-auth";
+import { admin, customSession, jwt, username } from "better-auth/plugins";
+import { defaultRoles } from "better-auth/plugins/admin/access";
+import { tanstackStartCookies } from "better-auth/tanstack-start";
+import { surrealDbAdapter } from "./surrealDbAdapter/index.js";
+const baseUrl = "/";
+const getAuthServer = (config)=>{
+    const roles = config?.roles || defaultRoles;
+    const betterAuthOptions = config?.betterAuthOptions;
+    const resultOptions = {
+        baseURL: baseUrl,
+        secret: process.env.BETTER_AUTH_SECRET,
+        database: surrealDbAdapter(),
+        experimental: {
+            joins: true
+        },
+        emailAndPassword: {
+            enabled: true
+        },
+        ...betterAuthOptions,
+        plugins: [
+            admin({
+                roles,
+                bannedUserMessage: 'Доступ к приложению заблокирован. Обратитесь к администратору.'
+            }),
+            username(),
+            ...betterAuthOptions?.plugins || []
+        ]
+    };
+    const auth = betterAuth({
+        ...resultOptions,
+        plugins: [
+            ...resultOptions.plugins,
+            customSession(async ({ user, session })=>({
+                    user: {
+                        ...user,
+                        role: user.role
+                    },
+                    session
+                }), resultOptions),
+            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
+                        })
+                }
+            }),
+            tanstackStartCookies()
+        ]
+    });
+    return auth;
+};
+export { getAuthServer };

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,13 @@
+import { getRequestHeaders } from "@tanstack/react-start/server";
+const getSessionToken = async ()=>{
+    const headers = getRequestHeaders();
+    const tokenResponse = await fetch("//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>;

package/dist/betterAuth/server/getSessionUser.js

@@ -0,0 +1,21 @@
+import { createServerFn } from "@tanstack/react-start";
+import { getRequestHeaders } from "@tanstack/react-start/server";
+const getSessionUserFn = createServerFn().handler(async ()=>{
+    try {
+        const headers = getRequestHeaders();
+        const sessionResponse = await fetch("//api/auth/get-session", {
+            headers: {
+                cookie: headers.get('cookie') || ''
+            }
+        });
+        if (!sessionResponse.ok) throw new Error('Failed to get auth session');
+        const session = await sessionResponse.json();
+        return session?.user;
+    } catch (_) {
+        return;
+    }
+});
+async function getSessionUser() {
+    return await getSessionUserFn();
+}
+export { getSessionUser };

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

@@ -0,0 +1,9 @@
+export { betterAuth } from 'better-auth';
+export * from 'better-auth/client/plugins';
+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 './getAuthServer';
+export * from './getDBSession';
+export * from './getSessionUser';

package/dist/betterAuth/server/index.js

@@ -0,0 +1,10 @@
+import { betterAuth } from "better-auth";
+import { tanstackStartCookies } from "better-auth/tanstack-start";
+export * from "better-auth/client/plugins";
+export * from "better-auth/plugins";
+export * from "better-auth/plugins/admin/access";
+export * from "better-auth/react";
+export * from "./getAuthServer.js";
+export * from "./getDBSession.js";
+export * from "./getSessionUser.js";
+export { betterAuth, tanstackStartCookies };

package/dist/betterAuth/server/surrealDbAdapter/adapter.d.ts

@@ -0,0 +1,8 @@
+import { type DBAdapterDebugLogOption } from 'better-auth/adapters';
+import type { SurrealDBProps } from '../../../surrealDB/types';
+type SurrealAdapterConfig = {
+    surrealDbProps?: SurrealDBProps;
+    debugLogs?: DBAdapterDebugLogOption | boolean;
+};
+export declare const surrealDbAdapter: ({ surrealDbProps, debugLogs, }?: SurrealAdapterConfig | undefined) => (options: Parameters<import("better-auth/adapters").AdapterFactory>[0]) => import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
+export {};

package/dist/betterAuth/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/betterAuth/server/surrealDbAdapter/adapter.test.d.ts

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

package/dist/betterAuth/server/surrealDbAdapter/adapter.test.js

@@ -0,0 +1,84 @@
+import { readFile } from "node:fs/promises";
+import node_path from "node:path";
+import { runAdapterTest } from "better-auth/adapters/test";
+import { Table, surql } from "surrealdb";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { getDBInstance } from "../../../surrealDB/index.js";
+import { surrealDbAdapter } from "./adapter.js";
+const hasDbEnv = ()=>Boolean(process.env.SURREALDB_URL && process.env.SURREALDB_NAMESPACE && process.env.SURREALDB_USERNAME && process.env.SURREALDB_PASSWORD);
+afterAll(async ()=>{
+    const db = await getDBInstance({
+        database: 'test'
+    });
+    await db.query(surql`DELETE ${new Table('session')}`).collect();
+    await db.query(surql`DELETE ${new Table('account')}`).collect();
+    await db.query(surql`DELETE ${new Table('verification')}`).collect();
+    await db.query(surql`DELETE ${new Table('user')}`).collect();
+    await db.close();
+});
+describe.skipIf(!hasDbEnv())('surrealdb adapter', ()=>{
+    beforeAll(async ()=>{
+        const db = await getDBInstance({
+            database: 'test'
+        });
+        const schemaPath = node_path.resolve('src/back/auth/surrealdb/schema.surql');
+        const schema = await readFile(schemaPath, 'utf8');
+        await db.query(schema).collect();
+        await db.query(surql`DELETE ${new Table('session')}`).collect();
+        await db.query(surql`DELETE ${new Table('account')}`).collect();
+        await db.query(surql`DELETE ${new Table('verification')}`).collect();
+        await db.query(surql`DELETE ${new Table('user')}`).collect();
+    });
+    runAdapterTest({
+        testPrefix: 'surrealdb',
+        getAdapter: async (options)=>surrealDbAdapter()(options ?? {})
+    });
+    it('supports experimental joins via computed fields', async ()=>{
+        const adapter = surrealDbAdapter()({
+            experimental: {
+                joins: true
+            }
+        });
+        const user = await adapter.create({
+            model: 'user',
+            data: {
+                name: 'Join User',
+                email: `join-${Date.now()}@example.com`,
+                emailVerified: true,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            }
+        });
+        const account = await adapter.create({
+            model: 'account',
+            data: {
+                userId: user.id,
+                accountId: `join-${Date.now()}`,
+                providerId: 'credential',
+                createdAt: new Date(),
+                updatedAt: new Date()
+            }
+        });
+        const joined = await adapter.findOne({
+            model: 'user',
+            where: [
+                {
+                    field: 'id',
+                    value: user.id
+                }
+            ],
+            join: {
+                account: true
+            }
+        });
+        expect(joined?.account).toBeTruthy();
+        expect(Array.isArray(joined?.account)).toBe(true);
+        expect(joined?.account?.length).toBe(1);
+        expect(joined?.account?.[0]?.id).toBe(account.id);
+        const db = await getDBInstance({
+            database: 'test'
+        });
+        await db.query(surql`DELETE ${new Table('account')} WHERE id = ${account.id}`).collect();
+        await db.query(surql`DELETE ${new Table('user')} WHERE id = ${user.id}`).collect();
+    });
+});

package/dist/betterAuth/server/surrealDbAdapter/db/getDB.d.ts

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

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

@@ -0,0 +1,31 @@
+import { readFile } from "node:fs/promises";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServerOnlyFn } from "@tanstack/react-start";
+import { getDBInstance } from "../../../../surrealDB/index.js";
+const getDB_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const authSchemaPath = node_path.resolve(getDB_dirname, './schema.surql');
+let schemaApplied = false;
+let schemaApplying = false;
+const ensureAuthSchema = async (props = {})=>{
+    if (schemaApplied) return;
+    if (!schemaApplying) try {
+        schemaApplying = true;
+        const db = await getDBInstance(props);
+        const schema = await readFile(authSchemaPath, 'utf8');
+        const betterAuthUrl = "/";
+        const betterAuthJwksUrl = `${betterAuthUrl}/api/auth/jwks`;
+        await db.query(schema, {
+            BETTER_AUTH_JWKS_URL: betterAuthJwksUrl
+        });
+        schemaApplied = true;
+    } finally{
+        schemaApplying = false;
+    }
+};
+const getDb = createServerOnlyFn(async (props = {})=>{
+    const db = await getDBInstance(props);
+    await ensureAuthSchema(props);
+    return db;
+});
+export { getDb };

package/dist/betterAuth/server/surrealDbAdapter/db/index.d.ts

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

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

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

package/dist/betterAuth/server/surrealDbAdapter/index.d.ts

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

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

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

package/dist/betterAuth/server/surrealDbAdapter/methods/count.d.ts

@@ -0,0 +1,2 @@
+import type { Count } from './types';
+export declare const count: ({ model, where, surrealDbProps, ...args }: Count) => Promise<number>;

package/dist/betterAuth/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/betterAuth/server/surrealDbAdapter/methods/create.d.ts

@@ -0,0 +1,2 @@
+import type { Create } from './types';
+export declare const create: <T extends Record<string, unknown>>({ model, data, surrealDbProps, ...args }: Create<T>) => Promise<T>;

package/dist/betterAuth/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/betterAuth/server/surrealDbAdapter/methods/delete.d.ts

@@ -0,0 +1,2 @@
+import type { Delete } from './types';
+export declare const deleteFn: ({ model, where, surrealDbProps, ...args }: Delete) => Promise<void>;

package/dist/betterAuth/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/betterAuth/server/surrealDbAdapter/methods/deleteMany.d.ts

@@ -0,0 +1,2 @@
+import type { DeleteMany } from './types';
+export declare const deleteMany: ({ model, where, surrealDbProps, ...args }: DeleteMany) => Promise<number>;

package/dist/betterAuth/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/betterAuth/server/surrealDbAdapter/methods/findMany.d.ts

@@ -0,0 +1,2 @@
+import type { FindMany } from './types';
+export declare const findMany: <T>({ model, where, limit, offset, sortBy, join, surrealDbProps, ...args }: FindMany) => Promise<T[]>;