@teamblind/axeda-better-auth 0.0.0-stage → 0.1.0-alpha.0

package/dist/tenant-stores.js

@@ -0,0 +1,408 @@
+import { AxedaError, scopeKey, withoutSecret, } from '@teamblind/axeda-core';
+import { isForeignKeyViolation, isUniqueViolation } from './errors.js';
+import { scopeColumns, toScope } from './rows.js';
+import { MODELS } from './schema.js';
+import { byId, decodeCursor, encodeCursor, MAX_ROWS } from './shared.js';
+const tenantBase = (row) => ({
+    id: row.id,
+    slug: row.slug,
+    name: row.name,
+    logoUrl: row.logoUrl ?? null,
+    faviconUrl: row.faviconUrl ?? null,
+    // Un estado desconocido se trata como inactivo: ante la duda, no concede nada.
+    status: (row.status === 'active' ? 'active' : 'inactive'),
+    metadata: row.metadata,
+    version: row.version,
+    deletedAt: row.deletedAt ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+});
+const toCompany = (row) => ({
+    ...tenantBase(row),
+    legalName: row.legalName ?? null,
+});
+const toBusiness = (row) => ({
+    ...tenantBase(row),
+    companyId: row.companyId,
+});
+const toInvitation = (row) => ({
+    id: row.id,
+    email: row.email,
+    scope: toScope({ id: row.id, scopeType: row.scopeType, scopeId: row.scopeId }),
+    roleIds: row.roleIds,
+    invitedBy: row.invitedBy,
+    secretHash: row.secretHash,
+    expiresAt: row.expiresAt,
+    createdAt: row.createdAt,
+    acceptedAt: row.acceptedAt ?? null,
+    revokedAt: row.revokedAt ?? null,
+});
+/** Condiciones del filtro de borrados y de identificadores. */
+function filterWhere(filter) {
+    const where = [];
+    const deleted = filter.deleted ?? 'exclude';
+    if (deleted === 'exclude')
+        where.push({ field: 'deletedAt', value: null });
+    if (deleted === 'only')
+        where.push({ field: 'deletedAt', operator: 'ne', value: null });
+    if (filter.ids !== undefined)
+        where.push({ field: 'id', operator: 'in', value: [...filter.ids] });
+    return where;
+}
+/**
+ * Cambio con la versión como guarda (`incrementOne`): de dos escritores con la misma versión solo
+ * uno la cumple. Si no cambia nada se distingue «no existe» de «versión distinta».
+ */
+async function guarded(adapter, model, id, expectedVersion, set, now, missing) {
+    const updated = await adapter.incrementOne({
+        model,
+        where: [
+            { field: 'id', value: id },
+            { field: 'version', value: expectedVersion },
+        ],
+        increment: { version: 1 },
+        set: { ...set, updatedAt: now() },
+    });
+    if (updated)
+        return updated;
+    const current = await adapter.findOne({ model, where: byId(id) });
+    if (!current)
+        throw missing();
+    throw new AxedaError('AXEDA_VERSION_CONFLICT', `"${id}" is at version ${current.version}, not ${expectedVersion}.`);
+}
+const defined = (values) => Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
+async function pageOf(adapter, model, where, sortField, sortKey, page, map) {
+    const after = page.cursor === undefined ? null : decodeCursor(page.cursor);
+    const rows = await adapter.findMany({
+        model,
+        where: [
+            ...where,
+            ...(after === null ? [] : [{ field: sortField, operator: 'gt', value: after }]),
+        ],
+        sortBy: { field: sortField, direction: 'asc' },
+        limit: page.limit + 1,
+    });
+    const items = rows.slice(0, page.limit);
+    const last = items.at(-1);
+    return {
+        items: items.map(map),
+        nextCursor: rows.length > page.limit && last ? encodeCursor(sortKey(last)) : null,
+    };
+}
+const emptyPage = () => ({ items: [], nextCursor: null });
+/** Borra de verdad las asignaciones e invitaciones de estos alcances. */
+async function dropScopes(adapter, scopeType, ids) {
+    if (ids.length === 0)
+        return;
+    const where = [
+        { field: 'scopeType', value: scopeType },
+        { field: 'scopeId', operator: 'in', value: [...ids] },
+    ];
+    await adapter.deleteMany({ model: MODELS.assignment, where });
+    await adapter.deleteMany({ model: MODELS.invitation, where });
+}
+// ---------- compañías ----------
+export function createCompanyStore(adapter, atomic, now) {
+    const model = MODELS.company;
+    const missing = (id) => () => new AxedaError('AXEDA_COMPANY_NOT_FOUND', `Company "${id}" does not exist.`);
+    return {
+        async get(id) {
+            const row = await adapter.findOne({ model, where: byId(id) });
+            return row ? toCompany(row) : null;
+        },
+        async getMany(ids) {
+            if (ids.length === 0)
+                return [];
+            const rows = await adapter.findMany({
+                model,
+                where: [{ field: 'id', operator: 'in', value: [...ids] }],
+                limit: ids.length,
+            });
+            return rows.map(toCompany);
+        },
+        async getBySlug(slug) {
+            const row = await adapter.findOne({
+                model,
+                where: [{ field: 'slug', value: slug }],
+            });
+            return row ? toCompany(row) : null;
+        },
+        async list(filter, page) {
+            if (filter.ids?.length === 0)
+                return emptyPage();
+            return pageOf(adapter, model, filterWhere(filter), 'slug', (row) => row.slug, page, toCompany);
+        },
+        async create(input) {
+            const taken = () => new AxedaError('AXEDA_SLUG_TAKEN', `A company with slug "${input.slug}" already exists.`);
+            if (await adapter.findOne({ model, where: [{ field: 'slug', value: input.slug }] }))
+                throw taken();
+            const at = now();
+            try {
+                const row = await adapter.create({
+                    model,
+                    data: {
+                        slug: input.slug,
+                        name: input.name,
+                        legalName: input.legalName ?? null,
+                        logoUrl: input.logoUrl ?? null,
+                        faviconUrl: input.faviconUrl ?? null,
+                        status: 'active',
+                        metadata: { ...(input.metadata ?? {}) },
+                        version: 1,
+                        deletedAt: null,
+                        createdAt: at,
+                        updatedAt: at,
+                    },
+                });
+                return toCompany(row);
+            }
+            catch (error) {
+                if (isUniqueViolation(error))
+                    throw taken();
+                throw error;
+            }
+        },
+        async update(id, expectedVersion, changes) {
+            const set = defined({
+                name: changes.name,
+                legalName: changes.legalName,
+                logoUrl: changes.logoUrl,
+                faviconUrl: changes.faviconUrl,
+                metadata: changes.metadata === undefined ? undefined : { ...changes.metadata },
+            });
+            return toCompany(await guarded(adapter, model, id, expectedVersion, set, now, missing(id)));
+        },
+        async setStatus(id, expectedVersion, status) {
+            return toCompany(await guarded(adapter, model, id, expectedVersion, { status }, now, missing(id)));
+        },
+        async setDeleted(id, expectedVersion, at) {
+            return toCompany(await guarded(adapter, model, id, expectedVersion, { deletedAt: at }, now, missing(id)));
+        },
+        async listDeletedBefore(before, limit) {
+            const rows = await adapter.findMany({
+                model,
+                where: [{ field: 'deletedAt', operator: 'lt', value: before }],
+                sortBy: { field: 'slug', direction: 'asc' },
+                limit,
+            });
+            return rows.map(toCompany);
+        },
+        purge: (ids) => ids.length === 0
+            ? Promise.resolve(0)
+            : atomic(async (trx) => {
+                const businesses = await trx.findMany({
+                    model: MODELS.business,
+                    where: [{ field: 'companyId', operator: 'in', value: [...ids] }],
+                    limit: MAX_ROWS,
+                });
+                await dropScopes(trx, 'business', businesses.map((business) => business.id));
+                await dropScopes(trx, 'company', ids);
+                await trx.deleteMany({
+                    model: MODELS.business,
+                    where: [{ field: 'companyId', operator: 'in', value: [...ids] }],
+                });
+                return trx.deleteMany({
+                    model,
+                    where: [{ field: 'id', operator: 'in', value: [...ids] }],
+                });
+            }),
+    };
+}
+// ---------- negocios ----------
+export function createBusinessStore(adapter, atomic, now) {
+    const model = MODELS.business;
+    const missing = (id) => () => new AxedaError('AXEDA_BUSINESS_NOT_FOUND', `Business "${id}" does not exist.`);
+    return {
+        async get(id) {
+            const row = await adapter.findOne({ model, where: byId(id) });
+            return row ? toBusiness(row) : null;
+        },
+        async getMany(ids) {
+            if (ids.length === 0)
+                return [];
+            const rows = await adapter.findMany({
+                model,
+                where: [{ field: 'id', operator: 'in', value: [...ids] }],
+                limit: ids.length,
+            });
+            return rows.map(toBusiness);
+        },
+        async getBySlug(companyId, slug) {
+            const row = await adapter.findOne({
+                model,
+                where: [
+                    { field: 'companyId', value: companyId },
+                    { field: 'slug', value: slug },
+                ],
+            });
+            return row ? toBusiness(row) : null;
+        },
+        async listForCompany(companyId, filter, page) {
+            if (filter.ids?.length === 0)
+                return emptyPage();
+            return pageOf(adapter, model, [{ field: 'companyId', value: companyId }, ...filterWhere(filter)], 'slug', (row) => row.slug, page, toBusiness);
+        },
+        async create(input) {
+            const taken = () => new AxedaError('AXEDA_SLUG_TAKEN', `A business with slug "${input.slug}" already exists in that company.`);
+            const noCompany = () => new AxedaError('AXEDA_COMPANY_NOT_FOUND', `Company "${input.companyId}" does not exist.`);
+            if (!(await adapter.findOne({ model: MODELS.company, where: byId(input.companyId) })))
+                throw noCompany();
+            const existing = await adapter.findOne({
+                model,
+                where: [
+                    { field: 'companyId', value: input.companyId },
+                    { field: 'slug', value: input.slug },
+                ],
+            });
+            if (existing)
+                throw taken();
+            const at = now();
+            try {
+                const row = await adapter.create({
+                    model,
+                    data: {
+                        companyId: input.companyId,
+                        slug: input.slug,
+                        name: input.name,
+                        logoUrl: input.logoUrl ?? null,
+                        faviconUrl: input.faviconUrl ?? null,
+                        status: 'active',
+                        metadata: { ...(input.metadata ?? {}) },
+                        version: 1,
+                        deletedAt: null,
+                        createdAt: at,
+                        updatedAt: at,
+                    },
+                });
+                return toBusiness(row);
+            }
+            catch (error) {
+                if (isUniqueViolation(error))
+                    throw taken();
+                if (isForeignKeyViolation(error))
+                    throw noCompany();
+                throw error;
+            }
+        },
+        async update(id, expectedVersion, changes) {
+            const set = defined({
+                name: changes.name,
+                logoUrl: changes.logoUrl,
+                faviconUrl: changes.faviconUrl,
+                metadata: changes.metadata === undefined ? undefined : { ...changes.metadata },
+            });
+            return toBusiness(await guarded(adapter, model, id, expectedVersion, set, now, missing(id)));
+        },
+        async setStatus(id, expectedVersion, status) {
+            return toBusiness(await guarded(adapter, model, id, expectedVersion, { status }, now, missing(id)));
+        },
+        async setDeleted(id, expectedVersion, at) {
+            return toBusiness(await guarded(adapter, model, id, expectedVersion, { deletedAt: at }, now, missing(id)));
+        },
+        async listDeletedBefore(before, limit) {
+            const rows = await adapter.findMany({
+                model,
+                where: [{ field: 'deletedAt', operator: 'lt', value: before }],
+                sortBy: { field: 'id', direction: 'asc' },
+                limit,
+            });
+            return rows.map(toBusiness);
+        },
+        purge: (ids) => ids.length === 0
+            ? Promise.resolve(0)
+            : atomic(async (trx) => {
+                await dropScopes(trx, 'business', ids);
+                return trx.deleteMany({
+                    model,
+                    where: [{ field: 'id', operator: 'in', value: [...ids] }],
+                });
+            }),
+    };
+}
+// ---------- invitaciones ----------
+/** Texto estable de «correo + alcance»; se reduce a un hash corto para la clave única. */
+async function pendingKey(email, scope) {
+    const data = new TextEncoder().encode(`${email}|${scopeKey(scope)}`);
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', data);
+    return `pending:${Buffer.from(digest).toString('hex')}`;
+}
+export function createInvitationStore(adapter, now) {
+    const model = MODELS.invitation;
+    return {
+        async get(id) {
+            const row = await adapter.findOne({ model, where: byId(id) });
+            return row ? toInvitation(row) : null;
+        },
+        async findPending(email, scope) {
+            const row = await adapter.findOne({
+                model,
+                where: [{ field: 'pendingKey', value: await pendingKey(email, scope) }],
+            });
+            return row ? toInvitation(row) : null;
+        },
+        async create(input) {
+            const exists = () => new AxedaError('AXEDA_INVITATION_EXISTS', 'There is already a pending invitation for that email and scope.');
+            const key = await pendingKey(input.email, input.scope);
+            if (await adapter.findOne({ model, where: [{ field: 'pendingKey', value: key }] }))
+                throw exists();
+            try {
+                const row = await adapter.create({
+                    model,
+                    data: {
+                        email: input.email,
+                        ...scopeColumns(input.scope),
+                        roleIds: [...input.roleIds],
+                        invitedBy: input.invitedBy,
+                        secretHash: input.secretHash,
+                        expiresAt: input.expiresAt,
+                        acceptedAt: null,
+                        revokedAt: null,
+                        pendingKey: key,
+                        consumed: 0,
+                        createdAt: now(),
+                    },
+                });
+                return toInvitation(row);
+            }
+            catch (error) {
+                if (isUniqueViolation(error))
+                    throw exists();
+                throw error;
+            }
+        },
+        async close(id, outcome, at) {
+            // Solo una llamada consigue pasar `consumed` de 0 a 1; el resto recibe `null`.
+            const closed = await adapter.incrementOne({
+                model,
+                where: [
+                    { field: 'id', value: id },
+                    { field: 'consumed', value: 0 },
+                ],
+                increment: { consumed: 1 },
+                set: {
+                    [outcome === 'accepted' ? 'acceptedAt' : 'revokedAt']: at,
+                    pendingKey: `closed:${id}`,
+                },
+            });
+            return closed !== null;
+        },
+        async list(scope, options, page) {
+            const columns = scopeColumns(scope);
+            const where = [
+                { field: 'scopeType', value: columns.scopeType },
+                { field: 'scopeId', value: columns.scopeId },
+                ...(options.pendingOnly
+                    ? [
+                        { field: 'consumed', value: 0 },
+                        { field: 'expiresAt', operator: 'gt', value: options.now },
+                    ]
+                    : []),
+            ];
+            const result = await pageOf(adapter, model, where, 'id', (row) => row.id, page, toInvitation);
+            return {
+                items: result.items.map(withoutSecret),
+                nextCursor: result.nextCursor,
+            };
+        },
+    };
+}

package/dist/user-admin.d.ts

@@ -0,0 +1,28 @@
+import type { AuthContext } from '@better-auth/core';
+import { type ManagedUser, type UserAdmin } from '@teamblind/axeda-core';
+interface UserRow {
+    id: string;
+    email: string;
+    name: string;
+    emailVerified?: boolean | null;
+    twoFactorEnabled?: boolean | null;
+    banned?: boolean | null;
+    banReason?: string | null;
+    banExpires?: Date | string | null;
+    createdAt: Date | string;
+}
+/**
+ * El usuario como lo ve la administración. Nunca se copia el resto de la fila: así una columna
+ * nueva (o un secreto que una aplicación añada al usuario) no sale por la API (S17).
+ */
+export declare function toManagedUser(row: UserRow, now: Date): ManagedUser;
+export interface BetterAuthUserAdminOptions {
+    readonly now?: () => Date;
+}
+/**
+ * Administración de usuarios sobre Better Auth. Crea y modifica usuarios con su `internalAdapter`
+ * (así se ejecutan los ganchos de la aplicación) y **no maneja contraseñas**: la cuenta nace sin
+ * credencial y la persona la establece por el flujo normal.
+ */
+export declare function createBetterAuthUserAdmin(context: Pick<AuthContext, 'adapter' | 'internalAdapter'>, options?: BetterAuthUserAdminOptions): UserAdmin;
+export {};

package/dist/user-admin.js

@@ -0,0 +1,105 @@
+import { AxedaError, isBanned, } from '@teamblind/axeda-core';
+import { isUniqueViolation } from './errors.js';
+import { byId, decodeCursor, encodeCursor } from './shared.js';
+const asDate = (value) => value === null || value === undefined ? null : new Date(value);
+/**
+ * El usuario como lo ve la administración. Nunca se copia el resto de la fila: así una columna
+ * nueva (o un secreto que una aplicación añada al usuario) no sale por la API (S17).
+ */
+export function toManagedUser(row, now) {
+    const banExpires = asDate(row.banExpires);
+    const flag = row.banned === true;
+    return {
+        id: row.id,
+        email: row.email,
+        name: row.name,
+        emailVerified: row.emailVerified === true,
+        twoFactorEnabled: row.twoFactorEnabled === true,
+        // El bloqueo se calcula con la hora actual: uno con fecha de fin se levanta solo.
+        banned: isBanned({ banned: flag, banExpires }, now),
+        banReason: flag ? (row.banReason ?? null) : null,
+        banExpires: flag ? banExpires : null,
+        createdAt: asDate(row.createdAt) ?? new Date(0),
+    };
+}
+/**
+ * Administración de usuarios sobre Better Auth. Crea y modifica usuarios con su `internalAdapter`
+ * (así se ejecutan los ganchos de la aplicación) y **no maneja contraseñas**: la cuenta nace sin
+ * credencial y la persona la establece por el flujo normal.
+ */
+export function createBetterAuthUserAdmin(context, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const { adapter, internalAdapter } = context;
+    const need = async (userId) => {
+        const row = await adapter.findOne({ model: 'user', where: byId(userId) });
+        if (row === null) {
+            throw new AxedaError('AXEDA_USER_NOT_FOUND', `User "${userId}" does not exist.`);
+        }
+        return row;
+    };
+    return {
+        async get(userId) {
+            const row = await adapter.findOne({ model: 'user', where: byId(userId) });
+            return row === null ? null : toManagedUser(row, now());
+        },
+        async list(filter, page) {
+            const after = page.cursor === undefined ? null : decodeCursor(page.cursor);
+            const rows = await adapter.findMany({
+                model: 'user',
+                where: [
+                    ...(filter.emailPrefix === undefined
+                        ? []
+                        : [
+                            {
+                                field: 'email',
+                                operator: 'starts_with',
+                                value: filter.emailPrefix.toLowerCase(),
+                            },
+                        ]),
+                    ...(after === null ? [] : [{ field: 'id', operator: 'gt', value: after }]),
+                ],
+                sortBy: { field: 'id', direction: 'asc' },
+                limit: page.limit + 1,
+            });
+            const at = now();
+            const kept = rows.slice(0, page.limit);
+            const last = kept.at(-1);
+            // El filtro de bloqueo se aplica con la hora actual (un bloqueo vencido ya no cuenta), por
+            // eso no puede ir en la consulta; una página puede salir con menos elementos que el límite.
+            const items = kept
+                .map((row) => toManagedUser(row, at))
+                .filter((user) => filter.banned === undefined || user.banned === filter.banned);
+            return { items, nextCursor: rows.length > page.limit && last ? encodeCursor(last.id) : null };
+        },
+        async create(input) {
+            const taken = () => new AxedaError('AXEDA_EMAIL_TAKEN', 'That email already has an account.');
+            if (await internalAdapter.findUserByEmail(input.email))
+                throw taken();
+            try {
+                // `method: 'admin'`: Better Auth lo marca como alta hecha por un administrador.
+                const created = await internalAdapter.createUser({ email: input.email, name: input.name, emailVerified: false }, { method: 'admin' });
+                return toManagedUser(await need(created.id), now());
+            }
+            catch (error) {
+                if (isUniqueViolation(error))
+                    throw taken();
+                throw error;
+            }
+        },
+        async setBan(userId, ban) {
+            await need(userId);
+            await internalAdapter.updateUser(userId, {
+                banned: ban !== null,
+                banReason: ban?.reason ?? null,
+                banExpires: ban?.expiresAt ?? null,
+            });
+            return toManagedUser(await need(userId), now());
+        },
+        async revokeSessions(userId) {
+            await need(userId);
+            const open = (await internalAdapter.listSessions(userId)).length;
+            await internalAdapter.deleteUserSessions(userId);
+            return open;
+        },
+    };
+}

package/dist/users.d.ts

@@ -0,0 +1,10 @@
+import type { BetterAuthOptions } from '@better-auth/core';
+import type { DBAdapter } from '@better-auth/core/db/adapter';
+import { type UserDirectory } from '@teamblind/axeda-core';
+/**
+ * Directorio de usuarios sobre la tabla `user` de Better Auth. Axeda no crea ni modifica
+ * usuarios: solo los consulta.
+ */
+export declare function createBetterAuthUserDirectory<Options extends BetterAuthOptions>(databaseAdapter: DBAdapter<Options>, options?: {
+    readonly now?: () => Date;
+}): UserDirectory;

package/dist/users.js

@@ -0,0 +1,27 @@
+import { isBanned } from '@teamblind/axeda-core';
+const toDirectoryUser = (row, now) => ({
+    id: row.id,
+    email: row.email,
+    emailVerified: row.emailVerified === true,
+    // Ante la duda, sin 2FA: las funciones que lo exigen no se asignan ni conceden.
+    twoFactorEnabled: row.twoFactorEnabled === true,
+    // Un bloqueo con fecha de fin deja de valer al llegar esa fecha.
+    banned: isBanned({ banned: row.banned === true, banExpires: row.banExpires ? new Date(row.banExpires) : null }, now),
+});
+/**
+ * Directorio de usuarios sobre la tabla `user` de Better Auth. Axeda no crea ni modifica
+ * usuarios: solo los consulta.
+ */
+export function createBetterAuthUserDirectory(databaseAdapter, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const adapter = databaseAdapter;
+    const find = async (field, value) => {
+        const row = await adapter.findOne({ model: 'user', where: [{ field, value }] });
+        return row === null ? null : toDirectoryUser(row, now());
+    };
+    return {
+        find: (userId) => find('id', userId),
+        // Better Auth guarda los correos en minúsculas.
+        findByEmail: (email) => find('email', email.trim().toLowerCase()),
+    };
+}

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@teamblind/axeda-better-auth",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.0",
+  "description": "Better Auth plugin for Axeda: schema, endpoints, client plugin and store implementations.",
+  "license": "Apache-2.0",
+  "author": "TeamBlind",
+  "homepage": "https://github.com/teamblindmx/axeda#readme",
+  "bugs": {
+    "url": "https://github.com/teamblindmx/axeda/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/teamblindmx/axeda.git",
+    "directory": "packages/better-auth"
+  },
+  "keywords": [
+    "authorization",
+    "rbac",
+    "multi-tenant",
+    "better-auth",
+    "access-control"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@teamblind/axeda-core": "^0.1.0-alpha.0",
+    "zod": "^4.6.7"
+  },
+  "peerDependencies": {
+    "@better-auth/core": "^1.7.10",
+    "better-auth": "^1.7.10"
+  },
+  "devDependencies": {
+    "@better-auth/core": "^1.7.10",
+    "@electric-sql/pglite": "^0.5.10",
+    "@types/better-sqlite3": "^9.6.0",
+    "@types/pg": "^8.23.1",
+    "better-auth": "^1.7.10",
+    "better-sqlite3": "^13.0.3",
+    "kysely": "^0.29.6",
+    "pg": "^8.23.1"
+  }
+}