@vexcms/better-auth 0.0.19 → 0.1.0-alpha.2

package/dist/index.js

@@ -1,172 +1,2294 @@
-// src/extract/collections.ts
+// src/adapter.ts
 import {
-  VexAuthConfigError
+  array,
+  checkbox,
+  date,
+  defineCollection,
+  number,
+  select,
+  text
 } from "@vexcms/core";
 import { getAuthTables } from "better-auth/db";
-var EDITABLE_FIELDS = {
-  user: /* @__PURE__ */ new Set(["name", "image", "role", "banned", "banReason", "banExpires"])
-};
-var HIDDEN_FIELDS = {
-  session: /* @__PURE__ */ new Set(["token"]),
-  account: /* @__PURE__ */ new Set(["accessToken", "refreshToken", "idToken"]),
-  verification: /* @__PURE__ */ new Set(["value"])
-};
-var COLLECTION_LABELS = {
-  user: { singular: "User", plural: "Users" },
-  session: { singular: "Session", plural: "Sessions" },
-  account: { singular: "Account", plural: "Accounts" },
-  verification: { singular: "Verification", plural: "Verifications" }
-};
-var GENERATE_API = /* @__PURE__ */ new Set(["user"]);
-var DEFAULT_COLUMNS = {
-  user: ["_id", "name", "email", "createdAt"],
-  session: ["_id", "userId", "expiresAt", "createdAt"],
-  account: ["_id", "providerId", "accountId", "userId"],
-  verification: ["_id", "identifier", "expiresAt", "createdAt"]
-};
-function resolveFieldAdminConfig(tableSlug, fieldName) {
-  const hidden = HIDDEN_FIELDS[tableSlug]?.has(fieldName);
-  if (hidden) return { hidden: true };
-  const editable = EDITABLE_FIELDS[tableSlug]?.has(fieldName);
-  if (!editable) return { readOnly: true };
-  return void 0;
-}
-function convertToVexFields(tableSlug, fields) {
-  const vexFields = {};
-  for (const [fieldName, attribute] of Object.entries(fields)) {
-    if (fieldName === "id") continue;
-    const required = attribute.required ?? false;
-    const admin = resolveFieldAdminConfig(tableSlug, fieldName);
-    if (attribute.references) {
-      vexFields[fieldName] = {
-        type: "relationship",
-        to: attribute.references.model,
-        required,
-        ...admin && { admin }
+var AUTH_COLLECTION_TYPES = {
+  user: "user",
+  session: "session",
+  account: "account",
+  verification: "verification"
+};
+var EDITABLE_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "email",
+  "image",
+  "role",
+  "banned",
+  "banReason",
+  "banExpires"
+]);
+var HIDDEN_FIELDS = /* @__PURE__ */ new Set([
+  "hashedPassword",
+  "password",
+  "twoFactorSecret",
+  "twoFactorBackupCodes",
+  "token",
+  "secret",
+  "code"
+]);
+function betterAuthAdapter(props) {
+  const tables = getAuthTables(props?.config ?? {});
+  const collections = [];
+  const authCollections = [
+    { type: AUTH_COLLECTION_TYPES.user, slug: props?.config?.user?.modelName },
+    {
+      type: AUTH_COLLECTION_TYPES.session,
+      slug: props?.config?.session?.modelName
+    },
+    {
+      type: AUTH_COLLECTION_TYPES.account,
+      slug: props?.config?.account?.modelName
+    },
+    {
+      type: AUTH_COLLECTION_TYPES.verification,
+      slug: props?.config?.verification?.modelName
+    }
+  ];
+  for (const [tableKey, tableDef] of Object.entries(tables)) {
+    const slug = tableDef.modelName ?? tableKey;
+    const fields = {};
+    addAuthCollectionFields({
+      attributes: tableDef.fields,
+      slug,
+      fields,
+      config: props?.config,
+      extractId: true
+    });
+    const authCollectionType = authCollections.find(
+      (ac) => ac.slug === slug
+    )?.type;
+    if (authCollectionType) {
+      switch (authCollectionType) {
+        case "user": {
+          const additionalFields = props?.config?.user?.additionalFields;
+          addAuthCollectionFields({
+            attributes: additionalFields,
+            slug,
+            fields,
+            config: props?.config
+          });
+          break;
+        }
+        case "session": {
+          const additionalFields = props?.config?.session?.additionalFields;
+          addAuthCollectionFields({
+            attributes: additionalFields,
+            slug,
+            fields,
+            config: props?.config
+          });
+          break;
+        }
+        case "account": {
+          const additionalFields = props?.config?.account?.additionalFields;
+          addAuthCollectionFields({
+            attributes: additionalFields,
+            slug,
+            fields,
+            config: props?.config
+          });
+          break;
+        }
+        case "verification": {
+          const additionalFields = props?.config?.verification?.additionalFields;
+          addAuthCollectionFields({
+            attributes: additionalFields,
+            slug,
+            fields,
+            config: props?.config
+          });
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    const isProtected = slug !== "user" && slug !== "users";
+    collections.push(
+      defineCollection({
+        slug,
+        fields,
+        meta: isProtected ? { protected: true } : void 0
+      })
+    );
+  }
+  const userSlug = tables.user?.modelName ?? "user";
+  return {
+    name: "better-auth",
+    collections,
+    userCollection: userSlug
+  };
+}
+function addAuthCollectionFields(props) {
+  if (!props.attributes) return;
+  for (const [fieldName, attr] of Object.entries(props.attributes)) {
+    if (props.extractId === true && fieldName === "id") continue;
+    const field = betterAuthAttrToVexField(
+      fieldName,
+      attr,
+      props.slug,
+      props?.config
+    );
+    if (field) props.fields[fieldName] = field;
+  }
+}
+function betterAuthAttrToVexField(fieldName, attr, tableSlug, authOptions) {
+  if (fieldName === "id") return null;
+  const isUserTable = tableSlug === authOptions?.user?.modelName || tableSlug === "user" || tableSlug === "users";
+  const isEditable = isUserTable && EDITABLE_FIELDS.has(fieldName);
+  const isHidden = HIDDEN_FIELDS.has(fieldName);
+  const admin = {};
+  if (!isEditable) admin.readOnly = true;
+  if (isHidden) admin.hidden = true;
+  const baseOptions = {
+    defaultValue: void 0
+  };
+  if (Object.keys(admin).length > 0) baseOptions.admin = admin;
+  if (!isEditable) baseOptions.meta = { locked: true };
+  if (attr.required) baseOptions.required = attr.required;
+  if (attr.defaultValue !== void 0 && typeof attr.defaultValue !== "function") {
+    baseOptions.defaultValue = attr.defaultValue;
+  }
+  if (attr.unique || attr.index) {
+    baseOptions.index = `by_${fieldName}`;
+  }
+  if (attr.references) {
+    return text(baseOptions);
+  }
+  if (Array.isArray(attr.type)) {
+    return select({
+      options: attr.type.map((v2) => ({ value: v2, label: v2 })),
+      ...baseOptions
+    });
+  }
+  switch (attr.type) {
+    case "string":
+      return text(baseOptions);
+    case "string[]":
+      return array({
+        ...baseOptions,
+        items: text(baseOptions)
+      });
+    case "boolean":
+      return checkbox(baseOptions);
+    case "number":
+      return number(baseOptions);
+    case "number[]":
+      return array({
+        ...baseOptions,
+        items: number(baseOptions)
+      });
+    case "date":
+      return date(baseOptions);
+    case "json":
+      return text(baseOptions);
+    default:
+      return null;
+  }
+}
+
+// src/convex/adapter.ts
+import { anyApi } from "convex/server";
+import {
+  createAdapterFactory
+} from "better-auth/adapters";
+import { getAuthTables as getAuthTables2 } from "better-auth/db";
+var parseWhere = (where) => {
+  return where?.map((where2) => {
+    if (where2.value instanceof Date) {
+      return { ...where2, value: where2.value.getTime() };
+    }
+    return where2;
+  }) ?? [];
+};
+function convexAdapter(ctx, config = {}) {
+  return createAdapterFactory({
+    adapter: ({ options }) => {
+      options.telemetry = { enabled: false };
+      const betterAuthSchema = getAuthTables2(options);
+      const betterAuthSchemaJson = JSON.stringify(betterAuthSchema);
+      return {
+        id: "convex",
+        options: { isRunMutationCtx: "runMutation" in ctx },
+        // Use anyApi to reference db operations, call via ctx.runMutation/ctx.runQuery
+        create: async ({ data, model, select: select2 }) => {
+          return await ctx.runMutation(anyApi.auth.db.dbCreate, {
+            betterAuthSchema: betterAuthSchemaJson,
+            data,
+            model,
+            select: select2
+          });
+        },
+        findOne: async ({ model, select: select2, where }) => {
+          return await ctx.runQuery(anyApi.auth.db.dbFindOne, {
+            betterAuthSchema: betterAuthSchemaJson,
+            model,
+            select: select2,
+            where: parseWhere(where)
+          });
+        },
+        findMany: async ({ limit, model, sortBy, where }) => {
+          return await ctx.runQuery(anyApi.auth.db.dbFindMany, {
+            betterAuthSchema: betterAuthSchemaJson,
+            limit,
+            model,
+            sortBy,
+            where: parseWhere(where)
+          });
+        },
+        count: async ({ model, where }) => {
+          return await ctx.runQuery(anyApi.auth.db.dbCount, {
+            betterAuthSchema: betterAuthSchemaJson,
+            model,
+            where: parseWhere(where)
+          });
+        },
+        update: async ({ model, update: update2, where }) => {
+          return await ctx.runMutation(anyApi.auth.db.dbUpdate, {
+            betterAuthSchema: betterAuthSchemaJson,
+            model,
+            update: update2,
+            where: parseWhere(where)
+          });
+        },
+        updateMany: async ({ model, update: update2, where }) => {
+          return await ctx.runMutation(anyApi.auth.db.dbUpdateMany, {
+            betterAuthSchema: betterAuthSchemaJson,
+            model,
+            update: update2,
+            where: parseWhere(where)
+          });
+        },
+        delete: async ({ model, where }) => {
+          return await ctx.runMutation(anyApi.auth.db.dbDelete, {
+            betterAuthSchema: betterAuthSchemaJson,
+            model,
+            where: parseWhere(where)
+          });
+        },
+        deleteMany: async ({ model, where }) => {
+          return await ctx.runMutation(anyApi.auth.db.dbDeleteMany, {
+            betterAuthSchema: betterAuthSchemaJson,
+            model,
+            where: parseWhere(where)
+          });
+        },
+        transaction: async () => {
+          throw new Error("Transactions not supported");
+        }
+      };
+    },
+    config: {
+      adapterId: "convex",
+      adapterName: "Convex Adapter",
+      customTransformInput: ({ data, fieldAttributes }) => data && fieldAttributes.type === "date" ? new Date(data).getTime() : data,
+      customTransformOutput: ({ data, fieldAttributes }) => data && fieldAttributes.type === "date" ? new Date(data).getTime() : data,
+      debugLogs: config.debugLogs ?? false,
+      disableIdGeneration: true,
+      mapKeysTransformInput: { id: "_id" },
+      mapKeysTransformOutput: { _id: "id" },
+      supportsArrays: true,
+      supportsDates: false,
+      supportsJSON: true,
+      supportsNumericIds: false,
+      transaction: false,
+      usePlural: false
+    }
+  });
+}
+
+// src/convex/db.ts
+import { v } from "convex/values";
+
+// ../../node_modules/.pnpm/convex-helpers@0.1.120_@standard-schema+spec@1.1.0_convex@1.44.0_react@19.2.7__hono@4.1_fda37119e0b134c2babc8f4bd1faf097/node_modules/convex-helpers/index.js
+async function asyncMap(list, asyncTransform) {
+  const promises = [];
+  let index = 0;
+  list = await list;
+  for (const item of list) {
+    promises.push(asyncTransform(item, index));
+    index += 1;
+  }
+  return Promise.all(promises);
+}
+
+// ../../node_modules/.pnpm/convex-helpers@0.1.120_@standard-schema+spec@1.1.0_convex@1.44.0_react@19.2.7__hono@4.1_fda37119e0b134c2babc8f4bd1faf097/node_modules/convex-helpers/server/stream.js
+import { convexToJson, compareValues, jsonToConvex, getDocumentSize } from "convex/values";
+var MAX_DOCUMENT_SCAN_LEN = 32e3;
+var SOFT_MAX_SCAN_LEN = MAX_DOCUMENT_SCAN_LEN / 2;
+function makeExclusive(boundType) {
+  if (boundType === "gt" || boundType === "gte") {
+    return "gt";
+  }
+  return "lt";
+}
+function splitRange(indexFields, order, startBound, endBound, startBoundType, endBoundType) {
+  const commonPrefix2 = [];
+  while (startBound.length > 0 && endBound.length > 0 && compareValues(startBound[0], endBound[0]) === 0) {
+    const indexField = indexFields[0];
+    indexFields = indexFields.slice(1);
+    const eqBound = startBound[0];
+    startBound = startBound.slice(1);
+    endBound = endBound.slice(1);
+    commonPrefix2.push(["eq", indexField, eqBound]);
+  }
+  const makeCompare = (boundType, key) => {
+    const range = commonPrefix2.slice();
+    let i = 0;
+    for (; i < key.length - 1; i++) {
+      range.push(["eq", indexFields[i], key[i]]);
+    }
+    if (i < key.length) {
+      range.push([boundType, indexFields[i], key[i]]);
+    }
+    return range;
+  };
+  const startRanges = [];
+  while (startBound.length > 1) {
+    startRanges.push(makeCompare(startBoundType, startBound));
+    startBoundType = makeExclusive(startBoundType);
+    startBound = startBound.slice(0, -1);
+  }
+  const endRanges = [];
+  while (endBound.length > 1) {
+    endRanges.push(makeCompare(endBoundType, endBound));
+    endBoundType = makeExclusive(endBoundType);
+    endBound = endBound.slice(0, -1);
+  }
+  endRanges.reverse();
+  let middleRange;
+  if (endBound.length === 0) {
+    middleRange = makeCompare(startBoundType, startBound);
+  } else if (startBound.length === 0) {
+    middleRange = makeCompare(endBoundType, endBound);
+  } else {
+    const startValue = startBound[0];
+    const endValue = endBound[0];
+    middleRange = commonPrefix2.slice();
+    middleRange.push([startBoundType, indexFields[0], startValue]);
+    middleRange.push([endBoundType, indexFields[0], endValue]);
+  }
+  const ranges = [...startRanges, middleRange, ...endRanges];
+  if (order === "desc") {
+    ranges.reverse();
+  }
+  return ranges;
+}
+function rangeToQuery(range) {
+  return (q) => {
+    for (const [boundType, field, value] of range) {
+      q = q[boundType](field, value);
+    }
+    return q;
+  };
+}
+function getIndexFields(table, index, schema) {
+  const indexDescriptor = String(index ?? "by_creation_time");
+  if (indexDescriptor === "by_creation_time") {
+    return ["_creationTime", "_id"];
+  }
+  if (indexDescriptor === "by_id") {
+    return ["_id"];
+  }
+  if (!schema) {
+    throw new Error("schema is required to infer index fields");
+  }
+  const tableInfo = schema.tables[table];
+  const indexInfo = tableInfo.indexes.find((index2) => index2.indexDescriptor === indexDescriptor);
+  if (!indexInfo) {
+    throw new Error(`Index ${indexDescriptor} not found in table ${table}`);
+  }
+  const fields = indexInfo.fields.slice();
+  fields.push("_creationTime");
+  fields.push("_id");
+  return fields;
+}
+function getIndexKey(doc, indexFields) {
+  const key = [];
+  for (const field of indexFields) {
+    let obj = doc;
+    for (const subfield of field.split(".")) {
+      obj = obj[subfield];
+    }
+    key.push(obj);
+  }
+  return key;
+}
+function stream(db, schema) {
+  return new StreamDatabaseReader(db, schema);
+}
+var QueryStream = class {
+  /// Methods for creating new streams as modifications of the current stream.
+  /**
+   * Create a new stream with a TypeScript filter applied.
+   *
+   * This is similar to `db.query(tableName).filter(predicate)`, but it's more
+   * general because it can call arbitrary TypeScript code, including more
+   * database queries.
+   *
+   * All documents filtered out are still considered "read" from the database;
+   * they are just excluded from the output stream.
+   *
+   * In contrast to `filter` from convex-helpers/server/filter, this filterWith
+   * is applied *before* any pagination. That means if the filter excludes a lot
+   * of documents, the `.paginate()` method will read a lot of documents until
+   * it gets as many documents as it wants. If you run into issues with reading
+   * too much data, you can pass `maximumRowsRead` to `paginate()`.
+   */
+  filterWith(predicate) {
+    const order = this.getOrder();
+    return new FlatMapStream(this, async (doc) => {
+      const filtered = await predicate(doc) ? doc : null;
+      return new SingletonStream(filtered, order, [], [], []);
+    }, []);
+  }
+  /**
+   * Create a new stream where each element is the result of applying the mapper
+   * function to the elements of the original stream.
+   *
+   * Similar to how [1, 2, 3].map(x => x * 2) => [2, 4, 6]
+   */
+  map(mapper) {
+    const order = this.getOrder();
+    return new FlatMapStream(this, async (doc) => {
+      const mapped = await mapper(doc);
+      return new SingletonStream(mapped, order, [], [], []);
+    }, []);
+  }
+  /**
+   * Similar to flatMap on an array, but iterate over a stream, and the for each
+   * element, iterate over the stream created by the mapper function.
+   *
+   * Ordered by the original stream order, then the mapped stream. Similar to
+   * how ["a", "b"].flatMap(letter => [letter, letter]) => ["a", "a", "b", "b"]
+   *
+   * @param mapper A function that takes a document and returns a new stream.
+   * @param mappedIndexFields The index fields of the streams created by mapper.
+   * @returns A stream of documents returned by the mapper streams,
+   *   grouped by the documents in the original stream.
+   */
+  flatMap(mapper, mappedIndexFields) {
+    normalizeIndexFields(mappedIndexFields);
+    return new FlatMapStream(this, mapper, mappedIndexFields);
+  }
+  /**
+   * Get the first item from the original stream for each distinct value of the
+   * selected index fields.
+   *
+   * e.g. if the stream has an equality filter on `a`, and index fields `[a, b, c]`,
+   * we can do `stream.distinct(["b"])` to get a stream of the first item for
+   * each distinct value of `b`.
+   * Similarly, you could do `stream.distinct(["a", "b"])` with the same result,
+   * or `stream.distinct(["a", "b", "c"])` to get the original stream.
+   *
+   * This stream efficiently skips past items with the same value for the selected
+   * distinct index fields.
+   *
+   * This can be used to perform a loose index scan.
+   */
+  distinct(distinctIndexFields) {
+    return new DistinctStream(this, distinctIndexFields);
+  }
+  /// Implementation of OrderedQuery
+  filter(_predicate) {
+    throw new Error("Cannot call .filter() directly on a query stream. Use .filterWith() for filtering or .collect() if you want to convert the stream to an array first.");
+  }
+  async paginate(opts) {
+    if (opts.numItems === 0) {
+      if (opts.cursor === null) {
+        throw new Error(".paginate called with cursor of null and 0 for numItems. This is not supported, as null is not a valid continueCursor. Advice: avoid calling paginate entirely in these cases.");
+      }
+      return {
+        page: [],
+        isDone: false,
+        continueCursor: opts.cursor
       };
-      continue;
     }
-    if (Array.isArray(attribute.type)) {
-      vexFields[fieldName] = {
-        type: "select",
-        options: attribute.type.map((val) => ({
-          label: val.charAt(0).toUpperCase() + val.slice(1),
-          value: val
-        })),
-        required,
-        ...required && { defaultValue: attribute.type[0] },
-        ...admin && { admin }
+    const order = this.getOrder();
+    let newStartKey = {
+      key: [],
+      inclusive: true
+    };
+    if (opts.cursor !== null) {
+      newStartKey = {
+        key: deserializeCursor(opts.cursor),
+        inclusive: false
       };
-      continue;
     }
-    switch (attribute.type) {
-      case "string":
-        vexFields[fieldName] = {
-          type: "text",
-          required,
-          ...required && { defaultValue: "" },
-          ...admin && { admin }
-        };
+    let newEndKey = {
+      key: [],
+      inclusive: true
+    };
+    const maxRowsToRead = opts.maximumRowsRead;
+    let maxRows = opts.numItems;
+    if (opts.endCursor) {
+      newEndKey = {
+        key: deserializeCursor(opts.endCursor),
+        inclusive: true
+      };
+      maxRows = void 0;
+    }
+    const newLowerBound = order === "asc" ? newStartKey : newEndKey;
+    const newUpperBound = order === "asc" ? newEndKey : newStartKey;
+    const narrowStream = this.narrow({
+      lowerBound: newLowerBound.key,
+      lowerBoundInclusive: newLowerBound.inclusive,
+      upperBound: newUpperBound.key,
+      upperBoundInclusive: newUpperBound.inclusive
+    });
+    const page = [];
+    const indexKeys = [];
+    let hasMore = opts.endCursor && opts.endCursor !== "[]";
+    let continueCursor = opts.endCursor ?? "[]";
+    const maxBytesToRead = opts.maximumBytesRead;
+    const trackBandwidth = maxBytesToRead !== void 0;
+    let totalBytesRead = 0;
+    let hitLimit = false;
+    for await (const [doc, indexKey, bandwidth] of narrowStream.iterWithKeys(trackBandwidth)) {
+      if (doc !== null) {
+        page.push(doc);
+      }
+      indexKeys.push(indexKey);
+      totalBytesRead += bandwidth;
+      if (maxBytesToRead !== void 0 && totalBytesRead >= maxBytesToRead || maxRowsToRead !== void 0 && indexKeys.length >= maxRowsToRead) {
+        hitLimit = true;
+      }
+      if (hitLimit || maxRows !== void 0 && page.length >= maxRows) {
+        hasMore = true;
+        continueCursor = serializeCursor(indexKey);
         break;
-      case "number":
-        vexFields[fieldName] = {
-          type: "number",
-          required,
-          ...required && { defaultValue: 0 },
-          ...admin && { admin }
-        };
+      }
+    }
+    let pageStatus = void 0;
+    let splitCursor = void 0;
+    if (hitLimit) {
+      pageStatus = "SplitRequired";
+      splitCursor = indexKeys[Math.floor((indexKeys.length - 1) / 2)];
+    } else if (indexKeys.length >= SOFT_MAX_SCAN_LEN || page.length > opts.numItems + 1) {
+      pageStatus = "SplitRecommended";
+      splitCursor = indexKeys[Math.floor((indexKeys.length - 1) / 2)];
+    }
+    return {
+      page,
+      isDone: !hasMore,
+      continueCursor,
+      pageStatus,
+      splitCursor: splitCursor ? serializeCursor(splitCursor) : void 0
+    };
+  }
+  async collect() {
+    return await this.take(Infinity);
+  }
+  async take(n) {
+    const results = [];
+    for await (const [doc] of this.iterWithKeys()) {
+      if (doc === null) {
+        continue;
+      }
+      results.push(doc);
+      if (results.length === n) {
         break;
-      case "boolean":
-        vexFields[fieldName] = {
-          type: "checkbox",
-          required,
-          ...required && { defaultValue: false },
-          ...admin && { admin }
+      }
+    }
+    return results;
+  }
+  async unique() {
+    const docs = await this.take(2);
+    if (docs.length === 2) {
+      throw new Error("Query is not unique");
+    }
+    return docs[0] ?? null;
+  }
+  async first() {
+    const docs = await this.take(1);
+    return docs[0] ?? null;
+  }
+  [Symbol.asyncIterator]() {
+    const iterator = this.iterWithKeys()[Symbol.asyncIterator]();
+    return {
+      async next() {
+        const result = await iterator.next();
+        if (result.done) {
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: result.value[0] };
+      }
+    };
+  }
+};
+var StreamDatabaseReader = class {
+  db;
+  schema;
+  // TODO: support system tables
+  system;
+  constructor(db, schema) {
+    this.db = db;
+    this.schema = schema;
+    this.system = db.system;
+  }
+  query(tableName) {
+    return new StreamQueryInitializer(this, tableName);
+  }
+  get(_id) {
+    throw new Error("get() not supported for `paginator`");
+  }
+  normalizeId(_tableName, _id) {
+    throw new Error("normalizeId() not supported for `paginator`.");
+  }
+};
+var StreamableQuery = class extends QueryStream {
+};
+var StreamQueryInitializer = class extends StreamableQuery {
+  parent;
+  table;
+  constructor(parent, table) {
+    super();
+    this.parent = parent;
+    this.table = table;
+  }
+  fullTableScan() {
+    return this.withIndex("by_creation_time");
+  }
+  withIndex(indexName, indexRange) {
+    const indexFields = getIndexFields(this.table, indexName, this.parent.schema);
+    const q = new ReflectIndexRange(indexFields);
+    if (indexRange) {
+      indexRange(q);
+    }
+    return new StreamQuery(this, indexName, q, indexRange);
+  }
+  withSearchIndex(_indexName, _searchFilter) {
+    throw new Error("Cannot paginate withSearchIndex");
+  }
+  inner() {
+    return this.fullTableScan();
+  }
+  order(order) {
+    return this.inner().order(order);
+  }
+  reflect() {
+    return this.inner().reflect();
+  }
+  iterWithKeys(trackBandwidth = false) {
+    return this.inner().iterWithKeys(trackBandwidth);
+  }
+  getOrder() {
+    return this.inner().getOrder();
+  }
+  getEqualityIndexFilter() {
+    return this.inner().getEqualityIndexFilter();
+  }
+  getIndexFields() {
+    return this.inner().getIndexFields();
+  }
+  narrow(indexBounds) {
+    return this.inner().narrow(indexBounds);
+  }
+};
+var StreamQuery = class extends StreamableQuery {
+  parent;
+  index;
+  q;
+  indexRange;
+  constructor(parent, index, q, indexRange) {
+    super();
+    this.parent = parent;
+    this.index = index;
+    this.q = q;
+    this.indexRange = indexRange;
+  }
+  order(order) {
+    return new OrderedStreamQuery(this, order);
+  }
+  inner() {
+    return this.order("asc");
+  }
+  reflect() {
+    return this.inner().reflect();
+  }
+  iterWithKeys(trackBandwidth = false) {
+    return this.inner().iterWithKeys(trackBandwidth);
+  }
+  getOrder() {
+    return this.inner().getOrder();
+  }
+  getEqualityIndexFilter() {
+    return this.inner().getEqualityIndexFilter();
+  }
+  getIndexFields() {
+    return this.inner().getIndexFields();
+  }
+  narrow(indexBounds) {
+    return this.inner().narrow(indexBounds);
+  }
+};
+var OrderedStreamQuery = class extends StreamableQuery {
+  parent;
+  order;
+  constructor(parent, order) {
+    super();
+    this.parent = parent;
+    this.order = order;
+  }
+  reflect() {
+    return {
+      db: this.parent.parent.parent.db,
+      schema: this.parent.parent.parent.schema,
+      table: this.parent.parent.table,
+      index: this.parent.index,
+      indexFields: this.parent.q.indexFields,
+      order: this.order,
+      bounds: {
+        lowerBound: this.parent.q.lowerBoundIndexKey ?? [],
+        lowerBoundInclusive: this.parent.q.lowerBoundInclusive,
+        upperBound: this.parent.q.upperBoundIndexKey ?? [],
+        upperBoundInclusive: this.parent.q.upperBoundInclusive
+      },
+      indexRange: this.parent.indexRange
+    };
+  }
+  /**
+   * inner() is as if you had used ctx.db to construct the query.
+   */
+  inner() {
+    const { db, table, index, order, indexRange } = this.reflect();
+    return db.query(table).withIndex(index, indexRange).order(order);
+  }
+  iterWithKeys(trackBandwidth = false) {
+    const { indexFields } = this.reflect();
+    const iterable = this.inner();
+    return {
+      [Symbol.asyncIterator]() {
+        const iterator = iterable[Symbol.asyncIterator]();
+        return {
+          async next() {
+            const result = await iterator.next();
+            if (result.done) {
+              return { done: true, value: void 0 };
+            }
+            const doc = result.value;
+            const bandwidth = trackBandwidth ? getDocumentSize(doc) : 0;
+            return {
+              done: false,
+              value: [doc, getIndexKey(doc, indexFields), bandwidth]
+            };
+          }
         };
-        break;
-      case "date":
-        vexFields[fieldName] = {
-          type: "date",
-          required,
-          ...required && { defaultValue: 0 },
-          ...admin && { admin }
+      }
+    };
+  }
+  getOrder() {
+    return this.order;
+  }
+  getEqualityIndexFilter() {
+    return this.parent.q.equalityIndexFilter;
+  }
+  getIndexFields() {
+    return this.parent.q.indexFields;
+  }
+  narrow(indexBounds) {
+    const { db, table, index, order, bounds, schema } = this.reflect();
+    let maxLowerBound = bounds.lowerBound;
+    let maxLowerBoundInclusive = bounds.lowerBoundInclusive;
+    if (compareKeys({
+      value: indexBounds.lowerBound,
+      kind: indexBounds.lowerBoundInclusive ? "predecessor" : "successor"
+    }, {
+      value: bounds.lowerBound,
+      kind: bounds.lowerBoundInclusive ? "predecessor" : "successor"
+    }) > 0) {
+      maxLowerBound = indexBounds.lowerBound;
+      maxLowerBoundInclusive = indexBounds.lowerBoundInclusive;
+    }
+    let minUpperBound = bounds.upperBound;
+    let minUpperBoundInclusive = bounds.upperBoundInclusive;
+    if (compareKeys({
+      value: indexBounds.upperBound,
+      kind: indexBounds.upperBoundInclusive ? "successor" : "predecessor"
+    }, {
+      value: bounds.upperBound,
+      kind: bounds.upperBoundInclusive ? "successor" : "predecessor"
+    }) < 0) {
+      minUpperBound = indexBounds.upperBound;
+      minUpperBoundInclusive = indexBounds.upperBoundInclusive;
+    }
+    return streamIndexRange(db, schema, table, index, {
+      lowerBound: maxLowerBound,
+      lowerBoundInclusive: maxLowerBoundInclusive,
+      upperBound: minUpperBound,
+      upperBoundInclusive: minUpperBoundInclusive
+    }, order);
+  }
+};
+function streamIndexRange(db, schema, table, index, bounds, order) {
+  const indexFields = getIndexFields(table, index, schema);
+  const splitBounds = splitRange(indexFields, order, bounds.lowerBound, bounds.upperBound, bounds.lowerBoundInclusive ? "gte" : "gt", bounds.upperBoundInclusive ? "lte" : "lt");
+  const subQueries = splitBounds.map((splitBound) => stream(db, schema).query(table).withIndex(index, rangeToQuery(splitBound)).order(order));
+  return new ConcatStreams(...subQueries);
+}
+var ReflectIndexRange = class {
+  indexFields;
+  #hasSuffix = false;
+  lowerBoundIndexKey = void 0;
+  lowerBoundInclusive = true;
+  upperBoundIndexKey = void 0;
+  upperBoundInclusive = true;
+  equalityIndexFilter = [];
+  constructor(indexFields) {
+    this.indexFields = indexFields;
+  }
+  eq(field, value) {
+    if (!this.#canLowerBound(field) || !this.#canUpperBound(field)) {
+      throw new Error(`Cannot use eq on field '${field}'`);
+    }
+    this.lowerBoundIndexKey = this.lowerBoundIndexKey ?? [];
+    this.lowerBoundIndexKey.push(value);
+    this.upperBoundIndexKey = this.upperBoundIndexKey ?? [];
+    this.upperBoundIndexKey.push(value);
+    this.equalityIndexFilter.push(value);
+    return this;
+  }
+  lt(field, value) {
+    if (!this.#canUpperBound(field)) {
+      throw new Error(`Cannot use lt on field '${field}'`);
+    }
+    this.upperBoundIndexKey = this.upperBoundIndexKey ?? [];
+    this.upperBoundIndexKey.push(value);
+    this.upperBoundInclusive = false;
+    this.#hasSuffix = true;
+    return this;
+  }
+  lte(field, value) {
+    if (!this.#canUpperBound(field)) {
+      throw new Error(`Cannot use lte on field '${field}'`);
+    }
+    this.upperBoundIndexKey = this.upperBoundIndexKey ?? [];
+    this.upperBoundIndexKey.push(value);
+    this.#hasSuffix = true;
+    return this;
+  }
+  gt(field, value) {
+    if (!this.#canLowerBound(field)) {
+      throw new Error(`Cannot use gt on field '${field}'`);
+    }
+    this.lowerBoundIndexKey = this.lowerBoundIndexKey ?? [];
+    this.lowerBoundIndexKey.push(value);
+    this.lowerBoundInclusive = false;
+    this.#hasSuffix = true;
+    return this;
+  }
+  gte(field, value) {
+    if (!this.#canLowerBound(field)) {
+      throw new Error(`Cannot use gte on field '${field}'`);
+    }
+    this.lowerBoundIndexKey = this.lowerBoundIndexKey ?? [];
+    this.lowerBoundIndexKey.push(value);
+    this.#hasSuffix = true;
+    return this;
+  }
+  #canLowerBound(field) {
+    const currentLowerBoundLength = this.lowerBoundIndexKey?.length ?? 0;
+    const currentUpperBoundLength = this.upperBoundIndexKey?.length ?? 0;
+    if (currentLowerBoundLength > currentUpperBoundLength) {
+      return false;
+    }
+    if (currentLowerBoundLength === currentUpperBoundLength && this.#hasSuffix) {
+      return false;
+    }
+    return currentLowerBoundLength < this.indexFields.length && this.indexFields[currentLowerBoundLength] === field;
+  }
+  #canUpperBound(field) {
+    const currentLowerBoundLength = this.lowerBoundIndexKey?.length ?? 0;
+    const currentUpperBoundLength = this.upperBoundIndexKey?.length ?? 0;
+    if (currentUpperBoundLength > currentLowerBoundLength) {
+      return false;
+    }
+    if (currentLowerBoundLength === currentUpperBoundLength && this.#hasSuffix) {
+      return false;
+    }
+    return currentUpperBoundLength < this.indexFields.length && this.indexFields[currentUpperBoundLength] === field;
+  }
+};
+function mergedStream(streams, orderByIndexFields) {
+  return new MergedStream(streams, orderByIndexFields);
+}
+var MergedStream = class _MergedStream extends QueryStream {
+  #order;
+  #streams;
+  #equalityIndexFilter;
+  #indexFields;
+  constructor(streams, orderByIndexFields) {
+    super();
+    if (streams.length === 0) {
+      throw new Error("Cannot union empty array of streams");
+    }
+    this.#order = allSame(streams.map((stream2) => stream2.getOrder()), "Cannot merge streams with different orders");
+    this.#streams = streams.map((stream2) => new OrderByStream(stream2, orderByIndexFields));
+    this.#indexFields = allSame(this.#streams.map((stream2) => stream2.getIndexFields()), "Cannot merge streams with different index fields. Consider using .orderBy()");
+    this.#equalityIndexFilter = commonPrefix(this.#streams.map((stream2) => stream2.getEqualityIndexFilter()));
+  }
+  iterWithKeys(trackBandwidth = false) {
+    const iterables = this.#streams.map((stream2) => stream2.iterWithKeys(trackBandwidth));
+    const comparisonInversion = this.#order === "asc" ? 1 : -1;
+    return {
+      [Symbol.asyncIterator]() {
+        const iterators = iterables.map((iterable) => iterable[Symbol.asyncIterator]());
+        const results = Array(iterators.length);
+        const pendingBandwidth = Array(iterators.length).fill(0);
+        return {
+          async next() {
+            let bandwidthThisIteration = 0;
+            await Promise.all(iterators.map(async (iterator, i) => {
+              if (!results[i]) {
+                const result = await iterator.next();
+                results[i] = result;
+                if (trackBandwidth && !result.done && result.value) {
+                  pendingBandwidth[i] = result.value[2];
+                }
+              }
+            }));
+            if (trackBandwidth) {
+              for (let i = 0; i < pendingBandwidth.length; i++) {
+                bandwidthThisIteration += pendingBandwidth[i];
+                pendingBandwidth[i] = 0;
+              }
+            }
+            let minIndexKeyAndIndex = void 0;
+            for (let i = 0; i < results.length; i++) {
+              const result = results[i];
+              if (result.done || !result.value) {
+                continue;
+              }
+              const [_2, resultIndexKey] = result.value;
+              if (minIndexKeyAndIndex === void 0) {
+                minIndexKeyAndIndex = [resultIndexKey, i];
+                continue;
+              }
+              const [prevMin] = minIndexKeyAndIndex;
+              if (compareKeys({ value: resultIndexKey, kind: "exact" }, { value: prevMin, kind: "exact" }) * comparisonInversion < 0) {
+                minIndexKeyAndIndex = [resultIndexKey, i];
+              }
+            }
+            if (minIndexKeyAndIndex === void 0) {
+              return { done: true, value: void 0 };
+            }
+            const [_, minIndex] = minIndexKeyAndIndex;
+            const [doc, indexKey] = results[minIndex].value;
+            results[minIndex] = void 0;
+            return {
+              done: false,
+              value: [doc, indexKey, bandwidthThisIteration]
+            };
+          }
         };
+      }
+    };
+  }
+  getOrder() {
+    return this.#order;
+  }
+  getEqualityIndexFilter() {
+    return this.#equalityIndexFilter;
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  narrow(indexBounds) {
+    return new _MergedStream(this.#streams.map((stream2) => stream2.narrow(indexBounds)), this.#indexFields);
+  }
+};
+function allSame(values, errorMessage) {
+  const first = values[0];
+  for (const value of values) {
+    if (compareValues(value, first)) {
+      throw new Error(errorMessage);
+    }
+  }
+  return first;
+}
+function commonPrefix(values) {
+  let commonPrefix2 = values[0];
+  for (const value of values) {
+    for (let i = 0; i < commonPrefix2.length; i++) {
+      if (i >= value.length || compareValues(commonPrefix2[i], value[i])) {
+        commonPrefix2 = commonPrefix2.slice(0, i);
         break;
-      case "json":
-        vexFields[fieldName] = {
-          type: "json",
-          required,
-          ...admin && { admin }
+      }
+    }
+  }
+  return commonPrefix2;
+}
+var ConcatStreams = class _ConcatStreams extends QueryStream {
+  #order;
+  #streams;
+  #equalityIndexFilter;
+  #indexFields;
+  constructor(...streams) {
+    super();
+    this.#streams = streams;
+    if (streams.length === 0) {
+      throw new Error("Cannot concat empty array of streams");
+    }
+    this.#order = allSame(streams.map((stream2) => stream2.getOrder()), "Cannot concat streams with different orders. Consider using .orderBy()");
+    this.#indexFields = allSame(streams.map((stream2) => stream2.getIndexFields()), "Cannot concat streams with different index fields. Consider using .orderBy()");
+    this.#equalityIndexFilter = commonPrefix(streams.map((stream2) => stream2.getEqualityIndexFilter()));
+  }
+  iterWithKeys(trackBandwidth = false) {
+    const iterables = this.#streams.map((stream2) => stream2.iterWithKeys(trackBandwidth));
+    const comparisonInversion = this.#order === "asc" ? 1 : -1;
+    let previousIndexKey = void 0;
+    return {
+      [Symbol.asyncIterator]() {
+        const iterators = iterables.map((iterable) => iterable[Symbol.asyncIterator]());
+        return {
+          async next() {
+            while (iterators.length > 0) {
+              const result = await iterators[0].next();
+              if (result.done) {
+                iterators.shift();
+              } else {
+                const [_, indexKey] = result.value;
+                if (previousIndexKey !== void 0 && compareKeys({
+                  value: previousIndexKey,
+                  kind: "exact"
+                }, {
+                  value: indexKey,
+                  kind: "exact"
+                }) * comparisonInversion > 0) {
+                  throw new Error(`ConcatStreams in wrong order: ${JSON.stringify(previousIndexKey)}, ${JSON.stringify(indexKey)}`);
+                }
+                previousIndexKey = indexKey;
+                return result;
+              }
+            }
+            return { done: true, value: void 0 };
+          }
         };
-        break;
-      case "string[]":
-        vexFields[fieldName] = {
-          type: "array",
-          items: { type: "text" },
-          required,
-          ...admin && { admin }
+      }
+    };
+  }
+  getOrder() {
+    return this.#order;
+  }
+  getEqualityIndexFilter() {
+    return this.#equalityIndexFilter;
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  narrow(indexBounds) {
+    return new _ConcatStreams(...this.#streams.map((stream2) => stream2.narrow(indexBounds)));
+  }
+};
+var FlatMapStreamIterator = class {
+  #outerStream;
+  #outerIterator;
+  #currentOuterItem = null;
+  #mapper;
+  #mappedIndexFields;
+  #trackBandwidth;
+  constructor(outerStream, mapper, mappedIndexFields, trackBandwidth) {
+    this.#outerIterator = outerStream.iterWithKeys(trackBandwidth)[Symbol.asyncIterator]();
+    this.#outerStream = outerStream;
+    this.#mapper = mapper;
+    this.#mappedIndexFields = mappedIndexFields;
+    this.#trackBandwidth = trackBandwidth;
+  }
+  singletonSkipInnerStream() {
+    const indexKey = this.#mappedIndexFields.map(() => null);
+    return new SingletonStream(null, this.#outerStream.getOrder(), this.#mappedIndexFields, indexKey, indexKey);
+  }
+  async setCurrentOuterItem(item) {
+    const [t, indexKey, bandwidth] = item;
+    let innerStream;
+    if (t === null) {
+      innerStream = this.singletonSkipInnerStream();
+    } else {
+      innerStream = await this.#mapper(t);
+      if (!equalIndexFields(innerStream.getIndexFields(), this.#mappedIndexFields)) {
+        throw new Error(`FlatMapStream: inner stream has different index fields than expected: ${JSON.stringify(innerStream.getIndexFields())} vs ${JSON.stringify(this.#mappedIndexFields)}`);
+      }
+      if (innerStream.getOrder() !== this.#outerStream.getOrder()) {
+        throw new Error(`FlatMapStream: inner stream has different order than outer stream: ${innerStream.getOrder()} vs ${this.#outerStream.getOrder()}`);
+      }
+    }
+    this.#currentOuterItem = {
+      t,
+      indexKey,
+      innerIterator: innerStream.iterWithKeys(this.#trackBandwidth)[Symbol.asyncIterator](),
+      count: 0,
+      bandwidth
+    };
+  }
+  async next() {
+    if (this.#currentOuterItem === null) {
+      const result2 = await this.#outerIterator.next();
+      if (result2.done) {
+        return { done: true, value: void 0 };
+      }
+      await this.setCurrentOuterItem(result2.value);
+      return await this.next();
+    }
+    const result = await this.#currentOuterItem.innerIterator.next();
+    if (result.done) {
+      if (this.#currentOuterItem.count > 0) {
+        this.#currentOuterItem = null;
+      } else {
+        this.#currentOuterItem.innerIterator = this.singletonSkipInnerStream().iterWithKeys(this.#trackBandwidth)[Symbol.asyncIterator]();
+      }
+      return await this.next();
+    }
+    const [u, indexKey, innerBandwidth] = result.value;
+    this.#currentOuterItem.count++;
+    const fullIndexKey = [...this.#currentOuterItem.indexKey, ...indexKey];
+    const bandwidth = (this.#currentOuterItem.count === 1 ? this.#currentOuterItem.bandwidth : 0) + innerBandwidth;
+    return { done: false, value: [u, fullIndexKey, bandwidth] };
+  }
+};
+var FlatMapStream = class _FlatMapStream extends QueryStream {
+  #stream;
+  #mapper;
+  #mappedIndexFields;
+  constructor(stream2, mapper, mappedIndexFields) {
+    super();
+    this.#stream = stream2;
+    this.#mapper = mapper;
+    this.#mappedIndexFields = mappedIndexFields;
+  }
+  iterWithKeys(trackBandwidth = false) {
+    const outerStream = this.#stream;
+    const mapper = this.#mapper;
+    const mappedIndexFields = this.#mappedIndexFields;
+    return {
+      [Symbol.asyncIterator]() {
+        return new FlatMapStreamIterator(outerStream, mapper, mappedIndexFields, trackBandwidth);
+      }
+    };
+  }
+  getOrder() {
+    return this.#stream.getOrder();
+  }
+  getEqualityIndexFilter() {
+    return this.#stream.getEqualityIndexFilter();
+  }
+  getIndexFields() {
+    return [...this.#stream.getIndexFields(), ...this.#mappedIndexFields];
+  }
+  narrow(indexBounds) {
+    const outerLength = this.#stream.getIndexFields().length;
+    const outerLowerBound = indexBounds.lowerBound.slice(0, outerLength);
+    const outerUpperBound = indexBounds.upperBound.slice(0, outerLength);
+    const innerLowerBound = indexBounds.lowerBound.slice(outerLength);
+    const innerUpperBound = indexBounds.upperBound.slice(outerLength);
+    const outerIndexBounds = {
+      lowerBound: outerLowerBound,
+      lowerBoundInclusive: innerLowerBound.length === 0 ? indexBounds.lowerBoundInclusive : true,
+      upperBound: outerUpperBound,
+      upperBoundInclusive: innerUpperBound.length === 0 ? indexBounds.upperBoundInclusive : true
+    };
+    const innerIndexBounds = {
+      lowerBound: innerLowerBound,
+      lowerBoundInclusive: innerLowerBound.length === 0 ? true : indexBounds.lowerBoundInclusive,
+      upperBound: innerUpperBound,
+      upperBoundInclusive: innerUpperBound.length === 0 ? true : indexBounds.upperBoundInclusive
+    };
+    return new _FlatMapStream(this.#stream.narrow(outerIndexBounds), async (t) => {
+      const innerStream = await this.#mapper(t);
+      return innerStream.narrow(innerIndexBounds);
+    }, this.#mappedIndexFields);
+  }
+};
+var SingletonStream = class _SingletonStream extends QueryStream {
+  #value;
+  #order;
+  #indexFields;
+  #indexKey;
+  #equalityIndexFilter;
+  #bandwidth;
+  constructor(value, order = "asc", indexFields, indexKey, equalityIndexFilter, bandwidth = 0) {
+    super();
+    this.#value = value;
+    this.#order = order;
+    this.#indexFields = indexFields;
+    this.#indexKey = indexKey;
+    this.#equalityIndexFilter = equalityIndexFilter;
+    this.#bandwidth = bandwidth;
+    if (indexKey.length !== indexFields.length) {
+      throw new Error(`indexKey must have the same length as indexFields: ${JSON.stringify(indexKey)} vs ${JSON.stringify(indexFields)}`);
+    }
+  }
+  iterWithKeys(_trackBandwidth = false) {
+    const value = this.#value;
+    const indexKey = this.#indexKey;
+    const bandwidth = this.#bandwidth;
+    return {
+      [Symbol.asyncIterator]() {
+        let sent = false;
+        return {
+          async next() {
+            if (sent) {
+              return { done: true, value: void 0 };
+            }
+            sent = true;
+            return {
+              done: false,
+              value: [value, indexKey, bandwidth]
+            };
+          }
         };
-        break;
-      case "number[]":
-        vexFields[fieldName] = {
-          type: "array",
-          items: { type: "number" },
-          required,
-          ...admin && { admin }
+      }
+    };
+  }
+  getOrder() {
+    return this.#order;
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  getEqualityIndexFilter() {
+    return this.#equalityIndexFilter;
+  }
+  narrow(indexBounds) {
+    const compareLowerBound = compareKeys({
+      value: indexBounds.lowerBound,
+      kind: indexBounds.lowerBoundInclusive ? "exact" : "successor"
+    }, {
+      value: this.#indexKey,
+      kind: "exact"
+    });
+    const compareUpperBound = compareKeys({
+      value: this.#indexKey,
+      kind: "exact"
+    }, {
+      value: indexBounds.upperBound,
+      kind: indexBounds.upperBoundInclusive ? "exact" : "predecessor"
+    });
+    if (compareLowerBound <= 0 && compareUpperBound <= 0) {
+      return new _SingletonStream(this.#value, this.#order, this.#indexFields, this.#indexKey, this.#equalityIndexFilter);
+    }
+    return new EmptyStream(this.#order, this.#indexFields);
+  }
+};
+var EmptyStream = class extends QueryStream {
+  #order;
+  #indexFields;
+  constructor(order, indexFields) {
+    super();
+    this.#order = order;
+    this.#indexFields = indexFields;
+  }
+  iterWithKeys(_trackBandwidth = false) {
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            return { done: true, value: void 0 };
+          }
+        };
+      }
+    };
+  }
+  getOrder() {
+    return this.#order;
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  getEqualityIndexFilter() {
+    return [];
+  }
+  narrow(_indexBounds) {
+    return this;
+  }
+};
+function normalizeIndexFields(indexFields) {
+  if (!indexFields.includes("_creationTime")) {
+    if (indexFields.length !== 1 || indexFields[0] !== "_id") {
+      indexFields.push("_creationTime");
+    }
+  }
+  if (!indexFields.includes("_id")) {
+    indexFields.push("_id");
+  }
+}
+function* getOrderingIndexFields(stream2) {
+  const streamEqualityIndexLength = stream2.getEqualityIndexFilter().length;
+  const streamIndexFields = stream2.getIndexFields();
+  for (let i = 0; i <= streamEqualityIndexLength; i++) {
+    yield streamIndexFields.slice(i);
+  }
+}
+var OrderByStream = class _OrderByStream extends QueryStream {
+  #staticFilter;
+  #stream;
+  #indexFields;
+  constructor(stream2, indexFields) {
+    super();
+    this.#stream = stream2;
+    this.#indexFields = indexFields;
+    normalizeIndexFields(this.#indexFields);
+    const streamIndexFields = stream2.getIndexFields();
+    const orderingIndexFields = Array.from(getOrderingIndexFields(stream2));
+    if (!orderingIndexFields.some((orderingIndexFields2) => equalIndexFields(orderingIndexFields2, indexFields))) {
+      throw new Error(`indexFields must be some sequence of fields the stream is ordered by: ${JSON.stringify(indexFields)}, ${JSON.stringify(streamIndexFields)} (${stream2.getEqualityIndexFilter().length} equality fields)`);
+    }
+    this.#staticFilter = stream2.getEqualityIndexFilter().slice(0, streamIndexFields.length - indexFields.length);
+  }
+  getOrder() {
+    return this.#stream.getOrder();
+  }
+  getEqualityIndexFilter() {
+    return this.#stream.getEqualityIndexFilter().slice(this.#staticFilter.length);
+  }
+  getIndexFields() {
+    return this.#indexFields;
+  }
+  iterWithKeys(trackBandwidth = false) {
+    const iterable = this.#stream.iterWithKeys(trackBandwidth);
+    const staticFilter = this.#staticFilter;
+    return {
+      [Symbol.asyncIterator]() {
+        const iterator = iterable[Symbol.asyncIterator]();
+        return {
+          async next() {
+            const result = await iterator.next();
+            if (result.done) {
+              return result;
+            }
+            const [doc, indexKey, bandwidth] = result.value;
+            return {
+              done: false,
+              value: [doc, indexKey.slice(staticFilter.length), bandwidth]
+            };
+          }
         };
+      }
+    };
+  }
+  narrow(indexBounds) {
+    return new _OrderByStream(this.#stream.narrow({
+      lowerBound: [...this.#staticFilter, ...indexBounds.lowerBound],
+      lowerBoundInclusive: indexBounds.lowerBoundInclusive,
+      upperBound: [...this.#staticFilter, ...indexBounds.upperBound],
+      upperBoundInclusive: indexBounds.upperBoundInclusive
+    }), this.#indexFields);
+  }
+};
+var DistinctStream = class _DistinctStream extends QueryStream {
+  #distinctIndexFieldsLength;
+  #stream;
+  #distinctIndexFields;
+  constructor(stream2, distinctIndexFields) {
+    super();
+    this.#stream = stream2;
+    this.#distinctIndexFields = distinctIndexFields;
+    let distinctIndexFieldsLength = void 0;
+    for (const orderingIndexFields of getOrderingIndexFields(stream2)) {
+      const prefix = orderingIndexFields.slice(0, distinctIndexFields.length);
+      if (equalIndexFields(prefix, distinctIndexFields)) {
+        const equalityLength = stream2.getIndexFields().length - orderingIndexFields.length;
+        distinctIndexFieldsLength = equalityLength + distinctIndexFields.length;
         break;
-      default:
-        throw new VexAuthConfigError(
-          `Unknown better-auth field type: ${attribute.type}`
-        );
+      }
+    }
+    if (distinctIndexFieldsLength === void 0) {
+      throw new Error(`distinctIndexFields must be a prefix of the stream's ordering index fields: ${JSON.stringify(distinctIndexFields)}, ${JSON.stringify(stream2.getIndexFields())} (${stream2.getEqualityIndexFilter().length} equality fields)`);
+    }
+    this.#distinctIndexFieldsLength = distinctIndexFieldsLength;
+  }
+  iterWithKeys(trackBandwidth = false) {
+    const stream2 = this.#stream;
+    const distinctIndexFieldsLength = this.#distinctIndexFieldsLength;
+    return {
+      [Symbol.asyncIterator]() {
+        let currentStream = stream2;
+        let currentIterator = currentStream.iterWithKeys(trackBandwidth)[Symbol.asyncIterator]();
+        return {
+          async next() {
+            const result = await currentIterator.next();
+            if (result.done) {
+              return { done: true, value: void 0 };
+            }
+            const [doc, indexKey, bandwidth] = result.value;
+            if (doc === null) {
+              return {
+                done: false,
+                value: [null, indexKey, bandwidth]
+              };
+            }
+            const distinctIndexKey = indexKey.slice(0, distinctIndexFieldsLength);
+            if (stream2.getOrder() === "asc") {
+              currentStream = currentStream.narrow({
+                lowerBound: distinctIndexKey,
+                lowerBoundInclusive: false,
+                upperBound: [],
+                upperBoundInclusive: true
+              });
+            } else {
+              currentStream = currentStream.narrow({
+                lowerBound: [],
+                lowerBoundInclusive: true,
+                upperBound: distinctIndexKey,
+                upperBoundInclusive: false
+              });
+            }
+            currentIterator = currentStream.iterWithKeys(trackBandwidth)[Symbol.asyncIterator]();
+            return result;
+          }
+        };
+      }
+    };
+  }
+  narrow(indexBounds) {
+    const indexBoundsPrefix = {
+      ...indexBounds,
+      lowerBound: indexBounds.lowerBound.slice(0, this.#distinctIndexFieldsLength),
+      upperBound: indexBounds.upperBound.slice(0, this.#distinctIndexFieldsLength)
+    };
+    return new _DistinctStream(this.#stream.narrow(indexBoundsPrefix), this.#distinctIndexFields);
+  }
+  getOrder() {
+    return this.#stream.getOrder();
+  }
+  getIndexFields() {
+    return this.#stream.getIndexFields();
+  }
+  getEqualityIndexFilter() {
+    return this.#stream.getEqualityIndexFilter();
+  }
+};
+function equalIndexFields(indexFields1, indexFields2) {
+  if (indexFields1.length !== indexFields2.length) {
+    return false;
+  }
+  for (let i = 0; i < indexFields1.length; i++) {
+    if (indexFields1[i] !== indexFields2[i]) {
+      return false;
     }
   }
-  return vexFields;
+  return true;
+}
+function getValueAtIndex(v2, index) {
+  if (index >= v2.length) {
+    return void 0;
+  }
+  return { kind: "found", value: v2[index] };
+}
+function compareDanglingSuffix(shorterKeyKind, longerKeyKind, shorterKey, longerKey) {
+  if (shorterKeyKind === "exact" && longerKeyKind === "exact") {
+    throw new Error(`Exact keys are not the same length:  ${JSON.stringify(shorterKey.value)}, ${JSON.stringify(longerKey.value)}`);
+  }
+  if (shorterKeyKind === "exact") {
+    throw new Error(`Exact key is shorter than prefix: ${JSON.stringify(shorterKey.value)}, ${JSON.stringify(longerKey.value)}`);
+  }
+  if (shorterKeyKind === "predecessor" && longerKeyKind === "successor") {
+    return -1;
+  }
+  if (shorterKeyKind === "successor" && longerKeyKind === "predecessor") {
+    return 1;
+  }
+  if (shorterKeyKind === "predecessor" && longerKeyKind === "predecessor") {
+    return -1;
+  }
+  if (shorterKeyKind === "successor" && longerKeyKind === "successor") {
+    return 1;
+  }
+  if (shorterKeyKind === "predecessor" && longerKeyKind === "exact") {
+    return -1;
+  }
+  if (shorterKeyKind === "successor" && longerKeyKind === "exact") {
+    return 1;
+  }
+  throw new Error(`Unexpected key kinds: ${shorterKeyKind}, ${longerKeyKind}`);
 }
-function extractIndexes(fields) {
-  const indexes = [];
-  for (const [fieldName, attribute] of Object.entries(fields)) {
-    if (fieldName === "id") continue;
-    if (attribute.index || attribute.unique) {
-      indexes.push({ name: `by_${fieldName}`, fields: [fieldName] });
+function compareKeys(key1, key2) {
+  let i = 0;
+  while (i < Math.max(key1.value.length, key2.value.length)) {
+    const v1 = getValueAtIndex(key1.value, i);
+    const v2 = getValueAtIndex(key2.value, i);
+    if (v1 === void 0) {
+      return compareDanglingSuffix(key1.kind, key2.kind, key1, key2);
+    }
+    if (v2 === void 0) {
+      return -1 * compareDanglingSuffix(key2.kind, key1.kind, key2, key1);
+    }
+    const result = compareValues(v1.value, v2.value);
+    if (result !== 0) {
+      return result;
+    }
+    i++;
+  }
+  if (key1.kind === key2.kind) {
+    return 0;
+  }
+  if (key1.kind === "exact") {
+    if (key2.kind === "successor") {
+      return -1;
+    } else {
+      return 1;
     }
   }
-  return indexes;
+  if (key1.kind === "predecessor") {
+    return -1;
+  }
+  if (key1.kind === "successor") {
+    return 1;
+  }
+  throw new Error(`Unexpected key kind: ${key1.kind}`);
 }
-function extractAuthCollections(config) {
-  const authDBSchema = getAuthTables(config);
-  const collections = [];
-  for (const [tableSlug, tableDef] of Object.entries(authDBSchema)) {
-    const slug = tableDef.modelName ?? tableSlug;
-    const fields = convertToVexFields(slug, tableDef.fields);
-    const indexes = extractIndexes(tableDef.fields);
-    const labels = COLLECTION_LABELS[slug];
-    const defaultColumns = DEFAULT_COLUMNS[slug];
-    collections.push({
-      slug,
-      fields,
-      ...labels ? { labels } : {},
-      ...indexes.length > 0 ? { indexes } : {},
-      ...GENERATE_API.has(slug) ? { generateApi: true } : {},
-      admin: {
-        group: "Auth",
-        useAsTitle: "_id",
-        ...defaultColumns ? { defaultColumns } : {}
+function serializeCursor(key) {
+  return JSON.stringify(convexToJson(key.map((v2) => v2 === void 0 ? "undefined" : typeof v2 === "string" && v2.endsWith("undefined") ? (
+    // in the unlikely case their string was "undefined"
+    // or "_undefined" etc, we escape it.
+    "_" + v2
+  ) : v2)));
+}
+function deserializeCursor(cursor) {
+  return jsonToConvex(JSON.parse(cursor)).map((v2) => {
+    if (typeof v2 === "string") {
+      if (v2 === "undefined") {
+        return void 0;
+      }
+      if (v2.endsWith("undefined")) {
+        return v2.slice(1);
       }
+    }
+    return v2;
+  });
+}
+
+// src/convex/utils.ts
+var isUniqueField = (betterAuthSchema, model, field) => {
+  const fields = betterAuthSchema[model]?.fields;
+  if (!fields) {
+    return false;
+  }
+  return Object.entries(fields).filter(([, value]) => value.unique).map(([key]) => key).includes(field);
+};
+var hasUniqueFields = (betterAuthSchema, model, input) => {
+  for (const field of Object.keys(input)) {
+    if (isUniqueField(betterAuthSchema, model, field)) {
+      return true;
+    }
+  }
+  return false;
+};
+var findIndex = (schema, args) => {
+  if ((args.where?.length ?? 0) > 1 && args.where?.some((w) => w.connector === "OR")) {
+    throw new Error(
+      `OR connector not supported with multiple where statements in findIndex, split up the where statements before calling findIndex: ${JSON.stringify(args.where)}`
+    );
+  }
+  const where = args.where?.filter((w) => {
+    return (!w.operator || ["eq", "gt", "gte", "in", "lt", "lte", "not_in"].includes(
+      w.operator
+    )) && w.field !== "_id";
+  });
+  if (!where?.length && !args.sortBy) {
+    return;
+  }
+  const lowerBounds = where?.filter((w) => w.operator === "lt" || w.operator === "lte") ?? [];
+  if (lowerBounds.length > 1) {
+    throw new Error(
+      `cannot have more than one lower bound where clause: ${JSON.stringify(where)}`
+    );
+  }
+  const upperBounds = where?.filter((w) => w.operator === "gt" || w.operator === "gte") ?? [];
+  if (upperBounds.length > 1) {
+    throw new Error(
+      `cannot have more than one upper bound where clause: ${JSON.stringify(where)}`
+    );
+  }
+  const lowerBound = lowerBounds[0];
+  const upperBound = upperBounds[0];
+  if (lowerBound && upperBound && lowerBound.field !== upperBound.field) {
+    throw new Error(
+      `lower bound and upper bound must have the same field: ${JSON.stringify(where)}`
+    );
+  }
+  const boundField = lowerBound?.field ?? upperBound?.field;
+  if (boundField && where?.some(
+    (w) => w.field === boundField && w !== lowerBound && w !== upperBound
+  )) {
+    throw new Error(
+      `too many where clauses on the bound field: ${JSON.stringify(where)}`
+    );
+  }
+  const indexEqFields = where?.filter((w) => !w.operator || w.operator === "eq").sort((a, b) => {
+    return a.field.localeCompare(b.field);
+  }).map((w) => [w.field, w.value]) ?? [];
+  if (!indexEqFields?.length && !boundField && !args.sortBy) {
+    return;
+  }
+  const table = schema.tables[args.model];
+  if (!table) {
+    throw new Error(`Table ${args.model} not found`);
+  }
+  const indexes = table[" indexes"]();
+  const sortField = args.sortBy?.field;
+  const indexFields = indexEqFields.map(([field]) => field).concat(
+    boundField && boundField !== "createdAt" ? `${indexEqFields.length ? "_" : ""}${boundField}` : ""
+  ).concat(
+    sortField && sortField !== "createdAt" && boundField !== sortField ? `${indexEqFields.length || boundField ? "_" : ""}${sortField}` : ""
+  ).filter(Boolean);
+  if (!indexFields.length && !boundField && !sortField) {
+    return;
+  }
+  const index = !indexFields.length ? {
+    fields: [],
+    indexDescriptor: "by_creation_time"
+  } : indexes.find(({ fields }) => {
+    const fieldsMatch = indexFields.every(
+      (field, idx) => field === fields[idx]
+    );
+    const boundFieldMatch = boundField === "createdAt" || sortField === "createdAt" ? indexFields.length === fields.length : true;
+    return fieldsMatch && boundFieldMatch;
+  });
+  if (!index) {
+    return { indexFields };
+  }
+  return {
+    boundField,
+    index: {
+      fields: [...index.fields, "_creationTime"],
+      indexDescriptor: index.indexDescriptor
+    },
+    sortField,
+    values: {
+      eq: indexEqFields.map(([, value]) => value),
+      gt: upperBound?.operator === "gt" ? upperBound.value : void 0,
+      gte: upperBound?.operator === "gte" ? upperBound.value : void 0,
+      lt: lowerBound?.operator === "lt" ? lowerBound.value : void 0,
+      lte: lowerBound?.operator === "lte" ? lowerBound.value : void 0
+    }
+  };
+};
+var checkUniqueFields = async (ctx, schema, betterAuthSchema, table, input, doc) => {
+  if (!hasUniqueFields(betterAuthSchema, table, input)) {
+    return;
+  }
+  for (const field of Object.keys(input)) {
+    if (!isUniqueField(betterAuthSchema, table, field)) {
+      continue;
+    }
+    const { index } = findIndex(schema, {
+      model: table,
+      where: [{ field, operator: "eq", value: input[field] }]
+    }) ?? {};
+    if (!index) {
+      throw new Error(`No index found for ${table}.${field}`);
+    }
+    const existingDoc = await ctx.db.query(table).withIndex(index.indexDescriptor, (q) => q.eq(field, input[field])).unique();
+    if (existingDoc && existingDoc._id !== doc?._id) {
+      throw new Error(`${table} ${field} already exists`);
+    }
+  }
+};
+var selectFields = (doc, select2) => {
+  if (!doc) {
+    return null;
+  }
+  if (!select2?.length) {
+    return doc;
+  }
+  return select2.reduce((acc, field) => {
+    acc[field] = doc[field];
+    return acc;
+  }, {});
+};
+var filterByWhere = (doc, where, filterWhere) => {
+  if (!doc) {
+    return false;
+  }
+  for (const w of where ?? []) {
+    if (filterWhere && !filterWhere(w)) {
+      continue;
+    }
+    const value = doc[w.field];
+    const isLessThan = (val, wVal) => {
+      if (!wVal) {
+        return false;
+      }
+      if (!val) {
+        return true;
+      }
+      return val < wVal;
+    };
+    const isGreaterThan = (val, wVal) => {
+      if (!val) {
+        return false;
+      }
+      if (!wVal) {
+        return true;
+      }
+      return val > wVal;
+    };
+    const filter = (w2) => {
+      switch (w2.operator) {
+        case "contains": {
+          return typeof value === "string" && value.includes(w2.value);
+        }
+        case "ends_with": {
+          return typeof value === "string" && value.endsWith(w2.value);
+        }
+        case "eq":
+        case void 0: {
+          return value === w2.value;
+        }
+        case "gt": {
+          return isGreaterThan(value, w2.value);
+        }
+        case "gte": {
+          return value === w2.value || isGreaterThan(value, w2.value);
+        }
+        case "in": {
+          return Array.isArray(w2.value) && w2.value.includes(value);
+        }
+        case "lt": {
+          return isLessThan(value, w2.value);
+        }
+        case "lte": {
+          return value === w2.value || isLessThan(value, w2.value);
+        }
+        case "ne": {
+          return value !== w2.value;
+        }
+        case "not_in": {
+          return Array.isArray(w2.value) && !w2.value.includes(value);
+        }
+        case "starts_with": {
+          return typeof value === "string" && value.startsWith(w2.value);
+        }
+      }
+    };
+    if (!filter(w)) {
+      return false;
+    }
+  }
+  return true;
+};
+var generateQuery = (ctx, schema, args) => {
+  const { boundField, index, indexFields, values } = findIndex(schema, args) ?? {};
+  const query = stream(ctx.db, schema).query(args.model);
+  const hasValues = values?.eq?.length ?? values?.lt ?? values?.lte ?? values?.gt ?? values?.gte;
+  const indexedQuery = index && index.indexDescriptor !== "by_creation_time" ? query.withIndex(
+    index.indexDescriptor,
+    hasValues ? (q) => {
+      for (const [idx, value] of (values?.eq ?? []).entries()) {
+        q = q.eq(index.fields[idx], value);
+      }
+      if (values?.lt) {
+        q = q.lt(boundField, values.lt);
+      }
+      if (values?.lte) {
+        q = q.lte(boundField, values.lte);
+      }
+      if (values?.gt) {
+        q = q.gt(boundField, values.gt);
+      }
+      if (values?.gte) {
+        q = q.gte(boundField, values.gte);
+      }
+      return q;
+    } : void 0
+  ) : query;
+  const orderedQuery = args.sortBy ? indexedQuery.order(args.sortBy.direction === "desc" ? "desc" : "asc") : indexedQuery;
+  const filteredQuery = orderedQuery.filterWith(async (doc) => {
+    if (!index && indexFields?.length) {
+      console.warn(
+        `Querying without an index on table "${args.model}".
+This can cause performance issues, and may hit the document read limit.
+To fix, add an index that begins with the following fields in order:
+[${indexFields.join(", ")}]`
+      );
+      return filterByWhere(doc, args.where);
+    }
+    return filterByWhere(
+      doc,
+      args.where,
+      // Index used for all eq and range clauses, apply remaining clauses
+      // incompatible with Convex statically.
+      (w) => w.operator && ["contains", "ends_with", "ne", "not_in", "starts_with"].includes(
+        w.operator
+      )
+    );
+  });
+  return filteredQuery;
+};
+var paginate = async (ctx, schema, betterAuthSchema, args) => {
+  if (args.offset) {
+    throw new Error(`offset not supported: ${JSON.stringify(args.offset)}`);
+  }
+  if (args.where?.some((w) => w.connector === "OR") && args.where?.length > 1) {
+    throw new Error(
+      `OR connector not supported with multiple where statements in paginate, split up the where statements before calling paginate: ${JSON.stringify(args.where)}`
+    );
+  }
+  if (args.where?.some(
+    (w) => w.field === "_id" && w.operator && !["eq", "in", "not_in"].includes(w.operator)
+  )) {
+    throw new Error(
+      `_id can only be used with eq, in, or not_in operator: ${JSON.stringify(args.where)}`
+    );
+  }
+  const uniqueWhere = args.where?.find(
+    (w) => (!w.operator || w.operator === "eq") && (isUniqueField(betterAuthSchema, args.model, w.field) || w.field === "_id")
+  );
+  if (uniqueWhere) {
+    const { index } = findIndex(schema, {
+      model: args.model,
+      where: [uniqueWhere]
+    }) ?? {};
+    let doc;
+    if (uniqueWhere.field === "_id") {
+      doc = await ctx.db.get(uniqueWhere.value);
+    } else if (index?.indexDescriptor) {
+      doc = await ctx.db.query(args.model).withIndex(
+        index.indexDescriptor,
+        (q) => q.eq(index.fields[0], uniqueWhere.value)
+      ).unique();
+    } else {
+      const results = await ctx.db.query(args.model).collect();
+      doc = results.find((d) => d[uniqueWhere.field] === uniqueWhere.value) ?? null;
+    }
+    if (filterByWhere(doc, args.where, (w) => w !== uniqueWhere)) {
+      return {
+        continueCursor: "",
+        isDone: true,
+        page: [selectFields(doc, args.select)].filter(Boolean)
+      };
+    }
+    return {
+      continueCursor: "",
+      isDone: true,
+      page: []
+    };
+  }
+  const paginationOpts = {
+    ...args.paginationOpts,
+    // If maximumRowsRead is not at least 1 higher than numItems, bad cursors
+    // and incorrect paging will result (at least with convex-test).
+    maximumRowsRead: Math.max((args.paginationOpts.numItems ?? 0) + 1, 200)
+  };
+  const inWhere = args.where?.find((w) => w.operator === "in");
+  if (inWhere) {
+    if (!Array.isArray(inWhere.value)) {
+      throw new Error("in clause value must be an array");
+    }
+    if (inWhere.field === "_id") {
+      const docs = await asyncMap(inWhere.value, async (value) => {
+        return ctx.db.get(value);
+      });
+      const filteredDocs = docs.flatMap((doc) => doc ? [doc] : []).filter((doc) => filterByWhere(doc, args.where, (w) => w !== inWhere));
+      return {
+        continueCursor: "",
+        isDone: true,
+        page: filteredDocs.sort((a, b) => {
+          if (args.sortBy?.field === "createdAt") {
+            return args.sortBy.direction === "asc" ? a._creationTime - b._creationTime : b._creationTime - a._creationTime;
+          }
+          if (args.sortBy) {
+            const aValue = a[args.sortBy.field];
+            const bValue = b[args.sortBy.field];
+            if (aValue === bValue) {
+              return 0;
+            }
+            return args.sortBy.direction === "asc" ? aValue > bValue ? 1 : -1 : aValue > bValue ? -1 : 1;
+          }
+          return 0;
+        })
+      };
+    }
+    const streams = inWhere.value.map((value) => {
+      return generateQuery(ctx, schema, {
+        ...args,
+        where: args.where?.map((w) => {
+          if (w === inWhere) {
+            return { ...w, operator: "eq", value };
+          }
+          return w;
+        })
+      });
     });
+    const result2 = await mergedStream(
+      streams,
+      [
+        args.sortBy?.field !== "createdAt" && args.sortBy?.field,
+        "_creationTime"
+      ].flatMap((f) => f ? [f] : [])
+    ).paginate(paginationOpts);
+    return {
+      ...result2,
+      page: await asyncMap(
+        result2.page,
+        (doc) => selectFields(doc, args.select)
+      )
+    };
   }
-  return collections;
+  const query = generateQuery(ctx, schema, args);
+  const result = await query.paginate(paginationOpts);
+  return {
+    ...result,
+    page: await asyncMap(result.page, (doc) => selectFields(doc, args.select))
+  };
+};
+var listOne = async (ctx, schema, betterAuthSchema, args) => {
+  return (await paginate(ctx, schema, betterAuthSchema, {
+    ...args,
+    paginationOpts: {
+      cursor: null,
+      numItems: 1
+    }
+  })).page[0];
+};
+
+// src/convex/db.ts
+var getBetterAuthSchema = (schemaJson) => {
+  return JSON.parse(schemaJson);
+};
+var create = {
+  args: {
+    betterAuthSchema: v.string(),
+    data: v.any(),
+    model: v.string(),
+    select: v.optional(v.array(v.string()))
+  },
+  handler: async (ctx, { betterAuthSchema, data, model, select: select2 }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    await checkUniqueFields(ctx, schema, authSchema, model, data);
+    const id = await ctx.db.insert(model, data);
+    const doc = await ctx.db.get(id);
+    if (!doc) {
+      throw new Error(`Failed to create ${model}`);
+    }
+    return selectFields(doc, select2);
+  }
+};
+var findOne = {
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    select: v.optional(v.array(v.string())),
+    where: v.array(v.any())
+  },
+  handler: async (ctx, { betterAuthSchema, model, select: select2, where }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    const result = await listOne(ctx, schema, authSchema, {
+      model,
+      select: select2,
+      where
+    });
+    return result;
+  }
+};
+var findMany = {
+  args: {
+    betterAuthSchema: v.string(),
+    limit: v.optional(v.number()),
+    model: v.string(),
+    sortBy: v.optional(
+      v.object({
+        direction: v.union(v.literal("asc"), v.literal("desc")),
+        field: v.string()
+      })
+    ),
+    where: v.optional(v.array(v.any()))
+  },
+  handler: async (ctx, { betterAuthSchema, limit, model, sortBy, where }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    const parsedWhere = where ?? [];
+    if (parsedWhere.some((w) => w.connector === "OR")) {
+      const results = await Promise.all(
+        parsedWhere.map(async (w) => {
+          const result2 = await paginate(ctx, schema, authSchema, {
+            model,
+            paginationOpts: { cursor: null, numItems: limit ?? 200 },
+            sortBy,
+            where: [w]
+          });
+          return result2.page;
+        })
+      );
+      const seen = /* @__PURE__ */ new Set();
+      const uniqueDocs = [];
+      for (const docs of results) {
+        for (const doc of docs) {
+          const docId = doc._id;
+          if (!seen.has(docId)) {
+            seen.add(docId);
+            uniqueDocs.push(doc);
+          }
+        }
+      }
+      if (sortBy) {
+        uniqueDocs.sort((a, b) => {
+          const aVal = a[sortBy.field];
+          const bVal = b[sortBy.field];
+          if (aVal === bVal) {
+            return 0;
+          }
+          const comparison = aVal > bVal ? 1 : -1;
+          return sortBy.direction === "desc" ? -comparison : comparison;
+        });
+      }
+      return uniqueDocs.slice(0, limit);
+    }
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: limit ?? 200 },
+      sortBy,
+      where: parsedWhere
+    });
+    return result.page;
+  }
+};
+var count = {
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    where: v.optional(v.array(v.any()))
+  },
+  handler: async (ctx, { betterAuthSchema, model, where }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    const parsedWhere = where ?? [];
+    if (parsedWhere.some((w) => w.connector === "OR")) {
+      const results = await Promise.all(
+        parsedWhere.map(async (w) => {
+          const result2 = await paginate(ctx, schema, authSchema, {
+            model,
+            paginationOpts: { cursor: null, numItems: 200 },
+            where: [w]
+          });
+          return result2.page;
+        })
+      );
+      const seen = /* @__PURE__ */ new Set();
+      for (const docs of results) {
+        for (const doc of docs) {
+          const docId = doc._id;
+          seen.add(docId);
+        }
+      }
+      return seen.size;
+    }
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: 200 },
+      where: parsedWhere
+    });
+    return result.page.length;
+  }
+};
+var update = {
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    update: v.any(),
+    where: v.array(v.any())
+  },
+  handler: async (ctx, { betterAuthSchema, model, update: update2, where }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    const parsedWhere = where;
+    const doc = await listOne(ctx, schema, authSchema, {
+      model,
+      where: parsedWhere
+    });
+    if (!doc) {
+      return null;
+    }
+    await checkUniqueFields(ctx, schema, authSchema, model, update2, doc);
+    await ctx.db.patch(doc._id, update2);
+    return await ctx.db.get(doc._id);
+  }
+};
+var updateMany = {
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    update: v.any(),
+    where: v.array(v.any())
+  },
+  handler: async (ctx, { betterAuthSchema, model, update: update2, where }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    const parsedWhere = where;
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: 200 },
+      where: parsedWhere
+    });
+    if (result.page.length > 1) {
+      const uniqueFieldKeys = Object.keys(update2).filter(
+        (key) => authSchema[model]?.fields?.[key]?.unique
+      );
+      if (uniqueFieldKeys.length > 0) {
+        throw new Error(
+          `Attempted to set unique fields in multiple documents in ${model} with the same value. Fields: ${uniqueFieldKeys.join(", ")}`
+        );
+      }
+    }
+    for (const doc of result.page) {
+      await checkUniqueFields(
+        ctx,
+        schema,
+        authSchema,
+        model,
+        update2,
+        doc
+      );
+      await ctx.db.patch(doc._id, update2);
+    }
+    return result.page.length;
+  }
+};
+var deleteOne = {
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    where: v.array(v.any())
+  },
+  handler: async (ctx, { betterAuthSchema, model, where }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    const parsedWhere = where;
+    const doc = await listOne(ctx, schema, authSchema, {
+      model,
+      where: parsedWhere
+    });
+    if (!doc) {
+      return;
+    }
+    await ctx.db.delete(doc._id);
+  }
+};
+var deleteMany = {
+  args: {
+    betterAuthSchema: v.string(),
+    model: v.string(),
+    where: v.array(v.any())
+  },
+  handler: async (ctx, { betterAuthSchema, model, where }, schema) => {
+    const authSchema = getBetterAuthSchema(betterAuthSchema);
+    const parsedWhere = where;
+    const result = await paginate(ctx, schema, authSchema, {
+      model,
+      paginationOpts: { cursor: null, numItems: 200 },
+      where: parsedWhere
+    });
+    for (const doc of result.page) {
+      await ctx.db.delete(doc._id);
+    }
+    return result.page.length;
+  }
+};
+
+// src/convex/getAuth.ts
+function createGetAuth(props) {
+  return async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (identity === null) {
+      return { user: null };
+    }
+    const user = await ctx.db.get(
+      props.userCollectionSlug,
+      identity.subject
+    );
+    if (user === null) {
+      return { user };
+    }
+    if (!props.resolveOrgs) {
+      return { user };
+    }
+    const sessionId = identity.sessionId;
+    const session = sessionId ? await ctx.db.get(props.sessionCollectionSlug, sessionId) : null;
+    const orgId = session?.activeOrganizationId;
+    const organization = orgId ? await ctx.db.get(props.orgCollectionSlug, orgId) ?? void 0 : void 0;
+    return { user, organization };
+  };
 }
 
-// src/index.ts
-function vexBetterAuth(props) {
-  const collections = extractAuthCollections(props?.config ?? {});
+// src/convex/index.ts
+function authDbApi(options) {
   return {
-    name: "better-auth",
-    collections
+    dbCreate: options.internalMutation({
+      ...create,
+      handler: async (ctx, args) => await create.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    }),
+    dbFindOne: options.internalQuery({
+      ...findOne,
+      handler: async (ctx, args) => await findOne.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    }),
+    dbFindMany: options.internalQuery({
+      ...findMany,
+      handler: async (ctx, args) => await findMany.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    }),
+    dbCount: options.internalQuery({
+      ...count,
+      handler: async (ctx, args) => await count.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    }),
+    dbUpdate: options.internalMutation({
+      ...update,
+      handler: async (ctx, args) => await update.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    }),
+    dbUpdateMany: options.internalMutation({
+      ...updateMany,
+      handler: async (ctx, args) => await updateMany.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    }),
+    dbDelete: options.internalMutation({
+      ...deleteOne,
+      handler: async (ctx, args) => await deleteOne.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    }),
+    dbDeleteMany: options.internalMutation({
+      ...deleteMany,
+      handler: async (ctx, args) => await deleteMany.handler(
+        ctx,
+        args,
+        options.schema
+      )
+    })
   };
 }
+function createBetterAuthAdapter(ctx) {
+  return convexAdapter(ctx);
+}
 export {
-  vexBetterAuth
+  authDbApi,
+  betterAuthAdapter,
+  convexAdapter,
+  createBetterAuthAdapter,
+  createGetAuth
 };
 //# sourceMappingURL=index.js.map