@onmax/nuxt-better-auth 0.0.2-alpha.21 → 0.0.2-alpha.23

package/dist/runtime/adapters/convex.js

@@ -1,213 +0,0 @@
-import { createAdapterFactory } from "better-auth/adapters";
-import { ConvexHttpClient } from "convex/browser";
-function parseWhere(where) {
-  if (!where)
-    return [];
-  const whereArray = Array.isArray(where) ? where : [where];
-  return whereArray.map((w) => {
-    if (w.value instanceof Date)
-      return { ...w, value: w.value.getTime() };
-    return w;
-  });
-}
-async function handlePagination(next, { limit } = {}) {
-  const state = { isDone: false, cursor: null, docs: [], count: 0 };
-  const onResult = (result) => {
-    state.cursor = result.pageStatus === "SplitRecommended" || result.pageStatus === "SplitRequired" ? result.splitCursor ?? result.continueCursor : result.continueCursor;
-    if (result.page) {
-      state.docs.push(...result.page);
-      state.isDone = limit && state.docs.length >= limit || result.isDone;
-      return;
-    }
-    if (result.count) {
-      state.count += result.count;
-      state.isDone = limit && state.count >= limit || result.isDone;
-      return;
-    }
-    state.isDone = result.isDone;
-  };
-  do {
-    const result = await next({
-      paginationOpts: {
-        numItems: Math.min(200, (limit ?? 200) - state.docs.length, 200),
-        cursor: state.cursor
-      }
-    });
-    onResult(result);
-  } while (!state.isDone);
-  return state;
-}
-export function createConvexHttpAdapter(options) {
-  if (!options.url.startsWith("https://") || !options.url.includes(".convex.")) {
-    throw new Error(`Invalid Convex URL: ${options.url}. Expected format: https://your-app.convex.cloud`);
-  }
-  const client = new ConvexHttpClient(options.url);
-  return createAdapterFactory({
-    config: {
-      adapterId: "convex-http",
-      adapterName: "Convex HTTP Adapter",
-      debugLogs: options.debugLogs ?? false,
-      disableIdGeneration: true,
-      transaction: false,
-      supportsNumericIds: false,
-      supportsJSON: false,
-      supportsDates: false,
-      supportsArrays: true,
-      usePlural: false,
-      mapKeysTransformInput: { id: "_id" },
-      mapKeysTransformOutput: { _id: "id" },
-      customTransformInput: ({ data, fieldAttributes }) => {
-        if (data && fieldAttributes.type === "date")
-          return new Date(data).getTime();
-        return data;
-      },
-      customTransformOutput: ({ data, fieldAttributes }) => {
-        if (data && fieldAttributes.type === "date")
-          return new Date(data).getTime();
-        return data;
-      }
-    },
-    adapter: ({ options: authOptions }) => {
-      authOptions.telemetry = { enabled: false };
-      return {
-        id: "convex-http",
-        create: async ({ model, data, select }) => {
-          return client.mutation(options.api.create, {
-            input: { model, data },
-            select
-          });
-        },
-        findOne: async (data) => {
-          if (data.where?.every((w) => w.connector === "OR")) {
-            for (const w of data.where) {
-              const result = await client.query(options.api.findOne, {
-                ...data,
-                model: data.model,
-                where: parseWhere(w)
-              });
-              if (result)
-                return result;
-            }
-            return null;
-          }
-          return client.query(options.api.findOne, {
-            ...data,
-            model: data.model,
-            where: parseWhere(data.where)
-          });
-        },
-        findMany: async (data) => {
-          if (data.offset)
-            throw new Error("offset not supported");
-          if (data.where?.some((w) => w.connector === "OR")) {
-            const results = await Promise.all(
-              data.where.map(
-                async (w) => handlePagination(async ({ paginationOpts }) => {
-                  return client.query(options.api.findMany, {
-                    ...data,
-                    model: data.model,
-                    where: parseWhere(w),
-                    paginationOpts
-                  });
-                }, { limit: data.limit })
-              )
-            );
-            const allDocs = results.flatMap((r) => r.docs);
-            const uniqueDocs = [...new Map(allDocs.map((d) => [d._id, d])).values()];
-            if (data.sortBy) {
-              return uniqueDocs.sort((a, b) => {
-                const aVal = a[data.sortBy.field];
-                const bVal = b[data.sortBy.field];
-                const cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
-                return data.sortBy.direction === "asc" ? cmp : -cmp;
-              });
-            }
-            return uniqueDocs;
-          }
-          const result = await handlePagination(
-            async ({ paginationOpts }) => client.query(options.api.findMany, {
-              ...data,
-              model: data.model,
-              where: parseWhere(data.where),
-              paginationOpts
-            }),
-            { limit: data.limit }
-          );
-          return result.docs;
-        },
-        // Note: Convex doesn't have a native count query, so we fetch all docs and count client-side.
-        // This is inefficient for large datasets but acceptable for auth tables (typically small).
-        count: async (data) => {
-          if (data.where?.some((w) => w.connector === "OR")) {
-            const results = await Promise.all(
-              data.where.map(
-                async (w) => handlePagination(async ({ paginationOpts }) => {
-                  return client.query(options.api.findMany, {
-                    ...data,
-                    model: data.model,
-                    where: parseWhere(w),
-                    paginationOpts
-                  });
-                })
-              )
-            );
-            const allDocs = results.flatMap((r) => r.docs);
-            const uniqueDocs = [...new Map(allDocs.map((d) => [d._id, d])).values()];
-            return uniqueDocs.length;
-          }
-          const result = await handlePagination(async ({ paginationOpts }) => client.query(options.api.findMany, {
-            ...data,
-            model: data.model,
-            where: parseWhere(data.where),
-            paginationOpts
-          }));
-          return result.docs.length;
-        },
-        // Supports single eq or multiple AND-connected conditions (Better Auth's common patterns)
-        update: async (data) => {
-          const hasOrConnector = data.where?.some((w) => w.connector === "OR");
-          if (hasOrConnector) {
-            throw new Error("update() does not support OR conditions - use updateMany() or split into multiple calls");
-          }
-          return client.mutation(options.api.updateOne, {
-            input: {
-              model: data.model,
-              where: parseWhere(data.where),
-              update: data.update
-            }
-          });
-        },
-        updateMany: async (data) => {
-          const result = await handlePagination(async ({ paginationOpts }) => client.mutation(options.api.updateMany, {
-            input: {
-              ...data,
-              model: data.model,
-              where: parseWhere(data.where)
-            },
-            paginationOpts
-          }));
-          return result.count;
-        },
-        delete: async (data) => {
-          await client.mutation(options.api.deleteOne, {
-            input: {
-              model: data.model,
-              where: parseWhere(data.where)
-            }
-          });
-        },
-        deleteMany: async (data) => {
-          const result = await handlePagination(async ({ paginationOpts }) => client.mutation(options.api.deleteMany, {
-            input: {
-              ...data,
-              model: data.model,
-              where: parseWhere(data.where)
-            },
-            paginationOpts
-          }));
-          return result.count;
-        }
-      };
-    }
-  });
-}