@delmaredigital/payload-better-auth 0.1.0

package/dist/index.mjs

@@ -0,0 +1,603 @@
+import { getAuthTables } from 'better-auth/db';
+
+// src/adapter/index.ts
+var DEFAULT_COLLECTIONS = {
+  user: "users",
+  session: "sessions",
+  account: "accounts",
+  verification: "verifications"
+};
+function payloadAdapter({
+  payloadClient,
+  adapterConfig
+}) {
+  const { collections = {}, enableDebugLogs = false, idType } = adapterConfig;
+  const finalCollections = { ...DEFAULT_COLLECTIONS, ...collections };
+  const log = (...args) => {
+    if (enableDebugLogs) console.log("[payload-adapter]", ...args);
+  };
+  async function resolvePayloadClient() {
+    return typeof payloadClient === "function" ? await payloadClient() : payloadClient;
+  }
+  function getCollection(model) {
+    return finalCollections[model] ?? model;
+  }
+  function transformFieldName(fieldName) {
+    if (fieldName.endsWith("Id") && fieldName !== "id" && fieldName !== "accountId" && fieldName !== "providerId") {
+      return fieldName.slice(0, -2);
+    }
+    return fieldName;
+  }
+  function convertWhere(where) {
+    if (!where || where.length === 0) return {};
+    if (where.length === 1) {
+      const w = where[0];
+      return {
+        [transformFieldName(w.field)]: convertOperator(w.operator, w.value)
+      };
+    }
+    const andConditions = where.filter((w) => w.connector !== "OR");
+    const orConditions = where.filter((w) => w.connector === "OR");
+    const result = {};
+    if (andConditions.length > 0) {
+      result.and = andConditions.map((w) => ({
+        [transformFieldName(w.field)]: convertOperator(w.operator, w.value)
+      }));
+    }
+    if (orConditions.length > 0) {
+      result.or = orConditions.map((w) => ({
+        [transformFieldName(w.field)]: convertOperator(w.operator, w.value)
+      }));
+    }
+    return result;
+  }
+  function convertOperator(operator, value) {
+    switch (operator) {
+      case "eq":
+        return { equals: value };
+      case "ne":
+        return { not_equals: value };
+      case "gt":
+        return { greater_than: value };
+      case "gte":
+        return { greater_than_equal: value };
+      case "lt":
+        return { less_than: value };
+      case "lte":
+        return { less_than_equal: value };
+      case "in":
+        return { in: value };
+      case "contains":
+        return { contains: value };
+      case "starts_with":
+        return { like: `${value}%` };
+      case "ends_with":
+        return { like: `%${value}` };
+      default:
+        return { equals: value };
+    }
+  }
+  function extractSingleId(where) {
+    if ("and" in where || "or" in where) return null;
+    const idCondition = where.id;
+    if (idCondition && typeof idCondition === "object" && "equals" in idCondition) {
+      const value = idCondition.equals;
+      if (typeof value === "string" || typeof value === "number") {
+        return value;
+      }
+    }
+    return null;
+  }
+  function transformInput(data) {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key.endsWith("Id") && key !== "id" && key !== "accountId" && key !== "providerId") {
+        const fieldName = key.slice(0, -2);
+        if (idType === "number" && typeof value === "string") {
+          const num = parseInt(value, 10);
+          result[fieldName] = isNaN(num) ? value : num;
+        } else {
+          result[fieldName] = value;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  function transformOutput(doc) {
+    if (!doc || typeof doc !== "object") return doc;
+    const result = { ...doc };
+    if ("id" in result && result.id !== void 0) {
+      result.id = String(result.id);
+    }
+    for (const [key, value] of Object.entries(result)) {
+      if (value && typeof value === "object" && "id" in value) {
+        result[`${key}Id`] = String(value.id);
+        delete result[key];
+      } else if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(value)) {
+        result[key] = new Date(value);
+      }
+    }
+    return result;
+  }
+  function convertId(id) {
+    if (idType === "number" && typeof id === "string") {
+      const num = parseInt(id, 10);
+      return isNaN(num) ? id : num;
+    }
+    if (idType === "text" && typeof id === "number") {
+      return String(id);
+    }
+    return id;
+  }
+  async function handleJoins(payload, doc, model, join) {
+    const result = { ...doc };
+    for (const [joinKey, joinConfig] of Object.entries(join)) {
+      if (!joinConfig) continue;
+      const limit = typeof joinConfig === "object" ? joinConfig.limit : void 0;
+      log("handleJoins", { model, joinKey, docId: doc.id });
+      if (model === "user" && joinKey === "account") {
+        const accounts = await payload.find({
+          collection: getCollection("account"),
+          where: { user: { equals: doc.id } },
+          limit: limit ?? 100,
+          depth: 0
+        });
+        result[joinKey] = accounts.docs.map((a) => transformOutput(a));
+      } else if (model === "session" && joinKey === "user") {
+        const userId = doc.userId;
+        if (userId) {
+          try {
+            const user = await payload.findByID({
+              collection: getCollection("user"),
+              id: userId,
+              depth: 0
+            });
+            result[joinKey] = transformOutput(user);
+          } catch {
+            result[joinKey] = null;
+          }
+        }
+      } else if (model === "account" && joinKey === "user") {
+        const userId = doc.userId;
+        if (userId) {
+          try {
+            const user = await payload.findByID({
+              collection: getCollection("user"),
+              id: userId,
+              depth: 0
+            });
+            result[joinKey] = transformOutput(user);
+          } catch {
+            result[joinKey] = null;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  return (_options) => {
+    log("Adapter initialized", { collections: finalCollections });
+    return {
+      id: "payload-adapter",
+      async create({
+        model,
+        data
+      }) {
+        const payload = await resolvePayloadClient();
+        const collection = getCollection(model);
+        const transformedData = transformInput(data);
+        log("create", { collection, data: transformedData });
+        try {
+          const result = await payload.create({
+            collection,
+            data: transformedData,
+            depth: 0
+          });
+          return transformOutput(result);
+        } catch (error) {
+          console.error("[payload-adapter] create failed:", {
+            collection,
+            model,
+            error: error instanceof Error ? error.message : error
+          });
+          throw error;
+        }
+      },
+      async findOne({
+        model,
+        where,
+        select: _select,
+        join
+      }) {
+        try {
+          const payload = await resolvePayloadClient();
+          const collection = getCollection(model);
+          const payloadWhere = convertWhere(where);
+          const id = extractSingleId(payloadWhere);
+          if (id) {
+            try {
+              const result2 = await payload.findByID({
+                collection,
+                id: convertId(id),
+                depth: 1
+              });
+              let doc2 = transformOutput(result2);
+              if (join) {
+                doc2 = await handleJoins(payload, doc2, model, join);
+              }
+              return doc2;
+            } catch (error) {
+              if (error instanceof Error && "status" in error && error.status === 404) {
+                return null;
+              }
+              throw error;
+            }
+          }
+          const result = await payload.find({
+            collection,
+            where: payloadWhere,
+            limit: 1,
+            depth: 1
+          });
+          let doc = result.docs[0] ? transformOutput(result.docs[0]) : null;
+          if (doc && join) {
+            doc = await handleJoins(payload, doc, model, join);
+          }
+          return doc;
+        } catch (error) {
+          console.error("[payload-adapter] findOne FAILED", {
+            model,
+            where,
+            error
+          });
+          throw error;
+        }
+      },
+      async findMany({
+        model,
+        where,
+        limit,
+        offset,
+        sortBy
+      }) {
+        const payload = await resolvePayloadClient();
+        const collection = getCollection(model);
+        const payloadWhere = convertWhere(where);
+        const result = await payload.find({
+          collection,
+          where: payloadWhere,
+          limit: limit ?? 100,
+          page: offset ? Math.floor(offset / (limit ?? 100)) + 1 : 1,
+          sort: sortBy ? `${sortBy.direction === "desc" ? "-" : ""}${sortBy.field}` : void 0,
+          depth: 1
+        });
+        return result.docs.map((doc) => transformOutput(doc));
+      },
+      async update({
+        model,
+        where,
+        update: data
+      }) {
+        const payload = await resolvePayloadClient();
+        const collection = getCollection(model);
+        const payloadWhere = convertWhere(where);
+        const transformedData = transformInput(data);
+        const id = extractSingleId(payloadWhere);
+        if (id) {
+          const result2 = await payload.update({
+            collection,
+            id: convertId(id),
+            data: transformedData,
+            depth: 1
+          });
+          return transformOutput(result2);
+        }
+        const result = await payload.update({
+          collection,
+          where: payloadWhere,
+          data: transformedData,
+          depth: 1
+        });
+        return result.docs[0] ? transformOutput(result.docs[0]) : null;
+      },
+      async updateMany({
+        model,
+        where,
+        update: data
+      }) {
+        const payload = await resolvePayloadClient();
+        const collection = getCollection(model);
+        const payloadWhere = convertWhere(where);
+        const transformedData = transformInput(data);
+        const result = await payload.update({
+          collection,
+          where: payloadWhere,
+          data: transformedData,
+          depth: 0
+        });
+        return result.docs.length;
+      },
+      async delete({ model, where }) {
+        const payload = await resolvePayloadClient();
+        const collection = getCollection(model);
+        const payloadWhere = convertWhere(where);
+        const id = extractSingleId(payloadWhere);
+        if (id) {
+          await payload.delete({ collection, id: convertId(id) });
+          return;
+        }
+        await payload.delete({ collection, where: payloadWhere });
+      },
+      async deleteMany({
+        model,
+        where
+      }) {
+        const payload = await resolvePayloadClient();
+        const collection = getCollection(model);
+        const payloadWhere = convertWhere(where);
+        const result = await payload.delete({
+          collection,
+          where: payloadWhere
+        });
+        return result.docs.length;
+      },
+      async count({
+        model,
+        where
+      }) {
+        const payload = await resolvePayloadClient();
+        const collection = getCollection(model);
+        const payloadWhere = convertWhere(where);
+        const result = await payload.count({
+          collection,
+          where: payloadWhere
+        });
+        return result.totalDocs;
+      },
+      async transaction(callback) {
+        return callback(this);
+      }
+    };
+  };
+}
+var DEFAULT_SLUG_OVERRIDES = {
+  user: "users",
+  session: "sessions",
+  account: "accounts",
+  verification: "verifications"
+};
+function mapFieldType(type, fieldName, hasReferences) {
+  if (hasReferences) {
+    return "relationship";
+  }
+  switch (type) {
+    case "boolean":
+      return "checkbox";
+    case "number":
+      return "number";
+    case "date":
+      return "date";
+    case "string":
+      if (fieldName === "email") return "email";
+      return "text";
+    default:
+      return "text";
+  }
+}
+function extractRelationTarget(fieldName, slugOverrides) {
+  const base = fieldName.replace(/(_id|Id)$/, "");
+  const pluralized = base.endsWith("s") ? base : `${base}s`;
+  return slugOverrides[base] ?? slugOverrides[pluralized] ?? pluralized;
+}
+function generateCollection(modelKey, table, slugOverrides, adminGroup, customAccess) {
+  const slug = slugOverrides[modelKey] ?? table.modelName ?? modelKey;
+  const fields = [];
+  for (const [fieldKey, fieldDef] of Object.entries(table.fields)) {
+    if (["id", "createdAt", "updatedAt"].includes(fieldKey)) {
+      continue;
+    }
+    const fieldName = fieldDef.fieldName ?? fieldKey;
+    const hasReferences = fieldDef.references !== void 0;
+    const fieldType = mapFieldType(fieldDef.type, fieldKey, hasReferences);
+    if (fieldType === "relationship") {
+      const relationTo = fieldDef.references?.model ? slugOverrides[fieldDef.references.model] ?? fieldDef.references.model : extractRelationTarget(fieldKey, slugOverrides);
+      fields.push({
+        name: fieldName.replace(/(_id|Id)$/, ""),
+        type: "relationship",
+        relationTo,
+        required: fieldDef.required ?? false,
+        index: true
+      });
+      continue;
+    }
+    const field = {
+      name: fieldName,
+      type: fieldType
+    };
+    if (fieldDef.required) field.required = true;
+    if (fieldDef.unique) {
+      field.unique = true;
+      field.index = true;
+    }
+    if (fieldDef.defaultValue !== void 0) {
+      let defaultValue = fieldDef.defaultValue;
+      if (typeof defaultValue === "function") {
+        try {
+          defaultValue = defaultValue();
+        } catch {
+          defaultValue = void 0;
+        }
+      }
+      if (defaultValue !== void 0 && defaultValue !== null) {
+        field.defaultValue = defaultValue;
+      }
+    }
+    fields.push(field);
+  }
+  const titleField = ["name", "email", "title", "identifier"].find(
+    (f) => fields.some((field) => "name" in field && field.name === f)
+  );
+  const defaultAccess = {
+    read: ({ req }) => req.user?.role === "admin",
+    create: () => false,
+    update: () => false,
+    delete: ({ req }) => req.user?.role === "admin"
+  };
+  return {
+    slug,
+    admin: {
+      useAsTitle: titleField ?? "id",
+      group: adminGroup,
+      description: `Auto-generated from Better Auth schema (${modelKey})`
+    },
+    access: customAccess ?? defaultAccess,
+    fields,
+    timestamps: true
+  };
+}
+function betterAuthCollections(options = {}) {
+  const {
+    betterAuthOptions = {},
+    slugOverrides = {},
+    skipCollections = ["user"],
+    adminGroup = "Auth",
+    access
+  } = options;
+  const finalSlugOverrides = { ...DEFAULT_SLUG_OVERRIDES, ...slugOverrides };
+  return (incomingConfig) => {
+    const existingCollectionSlugs = new Set(
+      (incomingConfig.collections ?? []).map((c) => c.slug)
+    );
+    const tables = getAuthTables(betterAuthOptions);
+    const generatedCollections = [];
+    for (const [modelKey, table] of Object.entries(tables)) {
+      if (skipCollections.includes(modelKey)) {
+        continue;
+      }
+      const slug = finalSlugOverrides[modelKey] ?? table.modelName ?? modelKey;
+      if (existingCollectionSlugs.has(slug)) {
+        continue;
+      }
+      const collection = generateCollection(
+        modelKey,
+        table,
+        finalSlugOverrides,
+        adminGroup,
+        access
+      );
+      generatedCollections.push(collection);
+    }
+    return {
+      ...incomingConfig,
+      collections: [
+        ...incomingConfig.collections ?? [],
+        ...generatedCollections
+      ]
+    };
+  };
+}
+
+// src/plugin/index.ts
+var authInstance = null;
+function createBetterAuthPlugin(options) {
+  const { createAuth } = options;
+  return (incomingConfig) => {
+    const existingOnInit = incomingConfig.onInit;
+    return {
+      ...incomingConfig,
+      onInit: async (payload) => {
+        if (existingOnInit) {
+          await existingOnInit(payload);
+        }
+        if ("betterAuth" in payload) {
+          return;
+        }
+        if (!authInstance) {
+          try {
+            authInstance = createAuth(payload);
+          } catch (error) {
+            console.error("[better-auth] Failed to create auth:", error);
+            throw error;
+          }
+        }
+        Object.defineProperty(payload, "betterAuth", {
+          value: authInstance,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+      }
+    };
+  };
+}
+function betterAuthStrategy(options = {}) {
+  const { usersCollection = "users" } = options;
+  return {
+    name: "better-auth",
+    authenticate: async ({
+      payload,
+      headers
+    }) => {
+      try {
+        const payloadWithAuth = payload;
+        const auth = payloadWithAuth.betterAuth;
+        if (!auth) {
+          console.error("Better Auth not initialized on payload instance");
+          return { user: null };
+        }
+        const session = await auth.api.getSession({ headers });
+        if (!session?.user?.id) {
+          return { user: null };
+        }
+        const users = await payload.find({
+          collection: usersCollection,
+          where: { id: { equals: session.user.id } },
+          limit: 1,
+          depth: 0
+        });
+        if (users.docs.length === 0) {
+          return { user: null };
+        }
+        return {
+          user: {
+            ...users.docs[0],
+            collection: usersCollection,
+            _strategy: "better-auth"
+          }
+        };
+      } catch (error) {
+        console.error("Better Auth strategy error:", error);
+        return { user: null };
+      }
+    }
+  };
+}
+function resetAuthInstance() {
+  authInstance = null;
+}
+
+// src/utils/session.ts
+async function getServerSession(payload, headers) {
+  try {
+    const payloadWithAuth = payload;
+    if (!payloadWithAuth.betterAuth) {
+      console.error("[session] Better Auth not initialized");
+      return null;
+    }
+    const session = await payloadWithAuth.betterAuth.api.getSession({ headers });
+    return session;
+  } catch (error) {
+    console.error("[session] Error getting session:", error);
+    return null;
+  }
+}
+async function getServerUser(payload, headers) {
+  const session = await getServerSession(payload, headers);
+  return session?.user ?? null;
+}
+
+export { betterAuthCollections, betterAuthStrategy, createBetterAuthPlugin, getServerSession, getServerUser, payloadAdapter, resetAuthInstance };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map