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

package/dist/index.js

@@ -1,205 +1,13 @@
-// src/adapter.ts
 import {
-  array,
-  checkbox,
-  date,
-  defineCollection,
-  number,
-  select,
-  text
-} from "@vexcms/core";
-import { getAuthTables } from "better-auth/db";
-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;
-  }
-}
+  betterAuthAdapter
+} from "./chunk-YPIEILO5.js";
 
 // src/convex/adapter.ts
 import { anyApi } from "convex/server";
 import {
   createAdapterFactory
 } from "better-auth/adapters";
-import { getAuthTables as getAuthTables2 } from "better-auth/db";
+import { getAuthTables } from "better-auth/db";
 var parseWhere = (where) => {
   return where?.map((where2) => {
     if (where2.value instanceof Date) {
@@ -212,25 +20,25 @@ function convexAdapter(ctx, config = {}) {
   return createAdapterFactory({
     adapter: ({ options }) => {
       options.telemetry = { enabled: false };
-      const betterAuthSchema = getAuthTables2(options);
+      const betterAuthSchema = getAuthTables(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 }) => {
+        create: async ({ data, model, select }) => {
           return await ctx.runMutation(anyApi.auth.db.dbCreate, {
             betterAuthSchema: betterAuthSchemaJson,
             data,
             model,
-            select: select2
+            select
           });
         },
-        findOne: async ({ model, select: select2, where }) => {
+        findOne: async ({ model, select, where }) => {
           return await ctx.runQuery(anyApi.auth.db.dbFindOne, {
             betterAuthSchema: betterAuthSchemaJson,
             model,
-            select: select2,
+            select,
             where: parseWhere(where)
           });
         },
@@ -1691,14 +1499,14 @@ var checkUniqueFields = async (ctx, schema, betterAuthSchema, table, input, doc)
     }
   }
 };
-var selectFields = (doc, select2) => {
+var selectFields = (doc, select) => {
   if (!doc) {
     return null;
   }
-  if (!select2?.length) {
+  if (!select?.length) {
     return doc;
   }
-  return select2.reduce((acc, field) => {
+  return select.reduce((acc, field) => {
     acc[field] = doc[field];
     return acc;
   }, {});
@@ -1960,7 +1768,7 @@ var create = {
     model: v.string(),
     select: v.optional(v.array(v.string()))
   },
-  handler: async (ctx, { betterAuthSchema, data, model, select: select2 }, schema) => {
+  handler: async (ctx, { betterAuthSchema, data, model, select }, schema) => {
     const authSchema = getBetterAuthSchema(betterAuthSchema);
     await checkUniqueFields(ctx, schema, authSchema, model, data);
     const id = await ctx.db.insert(model, data);
@@ -1968,7 +1776,7 @@ var create = {
     if (!doc) {
       throw new Error(`Failed to create ${model}`);
     }
-    return selectFields(doc, select2);
+    return selectFields(doc, select);
   }
 };
 var findOne = {
@@ -1978,11 +1786,11 @@ var findOne = {
     select: v.optional(v.array(v.string())),
     where: v.array(v.any())
   },
-  handler: async (ctx, { betterAuthSchema, model, select: select2, where }, schema) => {
+  handler: async (ctx, { betterAuthSchema, model, select, where }, schema) => {
     const authSchema = getBetterAuthSchema(betterAuthSchema);
     const result = await listOne(ctx, schema, authSchema, {
       model,
-      select: select2,
+      select,
       where
     });
     return result;
@@ -2201,17 +2009,29 @@ function createGetAuth(props) {
     if (user === null) {
       return { user };
     }
-    if (!props.resolveOrgs) {
+    if (!props.resolveOrgs || !props.orgCollectionSlug) {
       return { user };
     }
+    const orgCollectionSlug = props.orgCollectionSlug;
     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;
+    const organization = orgId ? await ctx.db.get(orgCollectionSlug, orgId) ?? void 0 : void 0;
     return { user, organization };
   };
 }
 
+// src/convex/anonRole.ts
+function anonRoleDatabaseHook(role) {
+  return {
+    create: {
+      before: async (user) => ({
+        data: user.isAnonymous === true ? { ...user, roles: [role] } : user
+      })
+    }
+  };
+}
+
 // src/convex/index.ts
 function authDbApi(options) {
   return {
@@ -2285,6 +2105,7 @@ function createBetterAuthAdapter(ctx) {
   return convexAdapter(ctx);
 }
 export {
+  anonRoleDatabaseHook,
   authDbApi,
   betterAuthAdapter,
   convexAdapter,