@luochuanyuewu/payload-auth 1.8.0

package/dist/better-auth/adapter/generate-schema/generate-schema-builder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This module generates PayloadCMS collection configurations based on the Better Auth schema.
+ *
+ * The generated collection configs include:
+ * - Users: For user management with proper auth configuration
+ * - Sessions: For maintaining user sessions
+ * - Accounts: For OAuth provider accounts
+ * - VerificationTokens: For email verification or social sign in
+ *
+ * Each collection is properly formatted with:
+ * - Appropriate field types (text, relationship, checkbox, etc.)
+ * - Admin configuration for better UI experience
+ * - Auth configuration for the Users collection
+ * - Proper field relationships between collections
+ *
+ * Users can copy these generated collection configs to their PayloadCMS project
+ * and add authentication strategies as needed.
+ */
+import type { BetterAuthOptions } from "better-auth";
+export declare const generateSchemaBuilderStage: ({ BAOptions, code }: {
+    code: string;
+    BAOptions: BetterAuthOptions;
+}) => Promise<string>;
+//# sourceMappingURL=generate-schema-builder.d.ts.map

package/dist/better-auth/adapter/generate-schema/generate-schema-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-schema-builder.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/adapter/generate-schema/generate-schema-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,eAAO,MAAM,0BAA0B,GAAU,qBAG9C;IACD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,iBAAiB,CAAC;CAC9B,oBAUA,CAAC"}

package/dist/better-auth/adapter/generate-schema/generate-schema-builder.js

@@ -0,0 +1,317 @@
+/**
+ * This module generates PayloadCMS collection configurations based on the Better Auth schema.
+ *
+ * The generated collection configs include:
+ * - Users: For user management with proper auth configuration
+ * - Sessions: For maintaining user sessions
+ * - Accounts: For OAuth provider accounts
+ * - VerificationTokens: For email verification or social sign in
+ *
+ * Each collection is properly formatted with:
+ * - Appropriate field types (text, relationship, checkbox, etc.)
+ * - Admin configuration for better UI experience
+ * - Auth configuration for the Users collection
+ * - Proper field relationships between collections
+ *
+ * Users can copy these generated collection configs to their PayloadCMS project
+ * and add authentication strategies as needed.
+ */ import { getAuthTables } from "better-auth/db";
+export const generateSchemaBuilderStage = async ({ BAOptions, code })=>{
+    const { post, collections } = parseExistingSchema(code);
+    const payloadSchemaStr = generatePayloadCollectionConfigs({
+        options: BAOptions,
+        collections,
+        exports: post
+    });
+    return payloadSchemaStr;
+};
+function parseExistingSchema(code) {
+    const collections = [];
+    let post = "";
+    // Extract collection definitions
+    const collectionRegex = /const\s+([A-Z][a-zA-Z0-9]*)\s*:\s*CollectionConfig\s*=\s*{[\s\S]*?}\s*as\s*const;/g;
+    let match;
+    while((match = collectionRegex.exec(code)) !== null){
+        const collectionName = match[1];
+        const collectionDef = match[0];
+        // Extract slug
+        const slugMatch = collectionDef.match(/slug:\s*"([^"]+)"/);
+        const slug = slugMatch ? slugMatch[1] : collectionName.toLowerCase();
+        // Extract useAsTitle
+        const titleMatch = collectionDef.match(/useAsTitle:\s*"([^"]+)"/);
+        const useAsTitle = titleMatch ? titleMatch[1] : "id";
+        // Extract fields
+        const fieldsRegex = /fields:\s*\[([\s\S]*?)\],/;
+        const fieldsMatch = collectionDef.match(fieldsRegex);
+        const fields = [];
+        if (fieldsMatch) {
+            const fieldBlockRegex = /{[\s\S]*?},/g;
+            const fieldBlocks = fieldsMatch[1].match(fieldBlockRegex) || [];
+            for (const fieldBlock of fieldBlocks){
+                const nameMatch = fieldBlock.match(/name:\s*"([^"]+)"/);
+                const typeMatch = fieldBlock.match(/type:\s*"([^"]+)"/);
+                const requiredMatch = fieldBlock.match(/required:\s*(true|false)/);
+                const uniqueMatch = fieldBlock.match(/unique:\s*(true|false)/);
+                const relationToMatch = fieldBlock.match(/relationTo:\s*"([^"]+)"/);
+                if (nameMatch && typeMatch) {
+                    const field = {
+                        name: nameMatch[1],
+                        type: typeMatch[1]
+                    };
+                    if (requiredMatch) {
+                        field.required = requiredMatch[1] === "true";
+                    }
+                    if (uniqueMatch) {
+                        field.unique = uniqueMatch[1] === "true";
+                    }
+                    if (relationToMatch) {
+                        field.relationTo = relationToMatch[1];
+                    }
+                    fields.push(field);
+                }
+            }
+        }
+        // Check for timestamps
+        const timestampsMatch = collectionDef.match(/timestamps:\s*(true|false)/);
+        const hasTimestamps = timestampsMatch ? timestampsMatch[1] === "true" : false;
+        collections.push({
+            slug,
+            admin: {
+                useAsTitle
+            },
+            fields,
+            ...hasTimestamps && {
+                timestamps: true
+            }
+        });
+    }
+    // Extract export statement
+    const exportRegex = /export\s*{[\s\S]*?};/;
+    const exportMatch = code.match(exportRegex);
+    if (exportMatch) {
+        post = exportMatch[0];
+    }
+    return {
+        collections,
+        post
+    };
+}
+function generatePayloadCollectionConfigs({ options, collections, exports }) {
+    let result = "";
+    // add pre message and import statements
+    result += `/**
+ * EXAMPLE COLLECTIONS FOR BETTER AUTH
+ * 
+ * Below is what your Payload collections should look like.
+ * Please copy these to your actual collection configs.
+ * Make sure to add an authStrategy for the users collection if there is one.
+ * 
+ * Example auth strategy:
+ * auth: {
+ *   disableLocalStrategy: true,
+ *   strategies: [
+ *     betterAuthStrategy(),
+ *     // Add other strategies as needed
+ *   ],
+ * },
+ */
+import type { CollectionConfig } from 'payload';
+
+`;
+    // add the collections
+    let collectionsStr = "";
+    const tables = getAuthTables(options);
+    // Process existing collections first
+    const existingCollectionsBySlug = collections.reduce((acc, collection)=>{
+        if (collection.slug) {
+            acc[collection.slug] = collection;
+        }
+        return acc;
+    }, {});
+    for (const [tableKey, table] of Object.entries(tables)){
+        const modelName = table.modelName;
+        const capitalized = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+        // Check if this collection already exists in the provided collections
+        const existingCollection = existingCollectionsBySlug[modelName];
+        if (existingCollection) {
+            // Convert existing collection to string representation
+            collectionsStr += `const ${capitalized}: CollectionConfig = ${JSON.stringify(existingCollection, null, 2).replace(/"([^"]+)":/g, "$1:")} as const;\n\n`;
+            continue;
+        }
+        // Create new collection if it doesn't exist
+        collectionsStr += `const ${capitalized}: CollectionConfig = {
+  slug: "${modelName}",
+`;
+        // Add admin section for better UX
+        collectionsStr += `  admin: {
+    useAsTitle: "${getNameField(table.fields)}",
+  },
+`;
+        // Add auth section ONLY for users collection
+        if (modelName === "users") {
+            collectionsStr += `  auth: {
+    disableLocalStrategy: true,
+    strategies: [],
+    // Add your auth strategies here if needed
+  },
+`;
+        }
+        // Add fields
+        collectionsStr += `  fields: [
+`;
+        for (const [fieldKey, field] of Object.entries(table.fields)){
+            const fieldName = field.fieldName || fieldKey;
+            // Skip id field as Payload handles it automatically
+            if (fieldName === "id") continue;
+            if (fieldName === "createdAt" || fieldName === "updatedAt") continue;
+            // Handle field type mapping with safer type approach
+            let fieldType = mapFieldType(field.type, fieldName);
+            const isRelationship = fieldName.endsWith("_id") || !!field.references?.model;
+            collectionsStr += `    {
+      name: "${isRelationship ? fieldName.replace("_id", "") : fieldName}",
+`;
+            if (isRelationship) {
+                collectionsStr += `      type: "relationship",
+      relationTo: "${field.references?.model || fieldName.replace("_id", "")}",
+`;
+            } else if (fieldType === "upload") {
+                collectionsStr += `      type: "upload",
+      relationTo: "media",
+`;
+            } else {
+                collectionsStr += `      type: "${fieldType}",
+`;
+            }
+            if (field.required) {
+                collectionsStr += `      required: true,
+`;
+            }
+            if (field.unique) {
+                collectionsStr += `      unique: true,
+`;
+            }
+            // Check if field has options and fieldType is select
+            if (fieldType === "select" && "options" in field && Array.isArray(field.options)) {
+                collectionsStr += `      options: ${JSON.stringify(field.options)},
+`;
+            }
+            if (field.defaultValue !== undefined) {
+                if (typeof field.defaultValue === "string") {
+                    collectionsStr += `      defaultValue: "${field.defaultValue}",
+`;
+                } else if (typeof field.defaultValue === "boolean") {
+                    collectionsStr += `      defaultValue: ${field.defaultValue ? "true" : "false"},
+`;
+                } else if (field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("() => !1")) {
+                    // Handle function-like default values with are false
+                    collectionsStr += `      defaultValue: false,
+`;
+                } else if (field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("() => !0")) {
+                    // Handle function-like default values with are true
+                    collectionsStr += `      defaultValue: true,
+`;
+                } else {
+                    collectionsStr += `      defaultValue: ${field.defaultValue},
+`;
+                }
+            }
+            // Add admin section for fields if needed - safely check for admin property
+            if ("admin" in field && field.admin && typeof field.admin === "object" && "readOnly" in field.admin && field.admin.readOnly) {
+                collectionsStr += `      admin: {
+        readOnly: true,
+      },
+`;
+            }
+            collectionsStr += `    },
+`;
+        }
+        collectionsStr += `  ],
+  timestamps: true,
+} as const;
+
+`;
+    }
+    // Add any collections from the input that aren't in the tables
+    for (const collection of collections){
+        if (!collection.slug || tables[collection.slug]) {
+            continue; // Skip if no slug or already processed
+        }
+        const capitalized = collection.slug.charAt(0).toUpperCase() + collection.slug.slice(1);
+        collectionsStr += `const ${capitalized}: CollectionConfig = ${JSON.stringify(collection, null, 2).replace(/"([^"]+)":/g, "$1:")} as const;\n\n`;
+    }
+    result += collectionsStr;
+    // Add export statements for all collections
+    // Check if we have an existing export statement to adapt
+    if (exports && exports.trim()) {
+        // Parse the existing exports to get collection names
+        const existingExportMatch = exports.match(/export\s*{\s*(.*?)\s*}/);
+        const existingCollections = existingExportMatch ? existingExportMatch[1].split(",").map((name)=>name.trim()) : [];
+        // Get the collection names from our tables
+        const tableCollections = Object.keys(tables).map((model)=>{
+            return model.charAt(0).toUpperCase() + model.slice(1);
+        });
+        // Combine existing and new collections, removing duplicates
+        const allCollections = [
+            ...new Set([
+                ...existingCollections,
+                ...tableCollections
+            ])
+        ];
+        // Create the new export statement
+        result += `export { ${allCollections.join(", ")} };
+`;
+    } else if (Object.keys(tables).length > 0) {
+        const collectionNames = Object.keys(tables).map((model)=>{
+            // Convert model name to PascalCase for export
+            const pascalCase = model.charAt(0).toUpperCase() + model.slice(1);
+            return pascalCase;
+        });
+        result += `export { ${collectionNames.join(", ")} };
+`;
+    } else {
+        result += `export {};
+`;
+    }
+    return result;
+}
+// Helper functions
+function mapFieldType(type, fieldName) {
+    if (fieldName.endsWith("_id")) return "relationship";
+    switch(type){
+        case "boolean":
+            return "checkbox";
+        case "number":
+            return "number";
+        case "string":
+            if (fieldName === "email") return "email";
+            if (fieldName.includes("password")) return "text";
+            if (fieldName.includes("image") || fieldName.includes("avatar")) return "upload";
+            return "text";
+        case "date":
+            return "date";
+        case "array":
+            return "array";
+        default:
+            return "text";
+    }
+}
+function getNameField(fields) {
+    // Try to find an appropriate field to use as title
+    const nameOptions = [
+        "name",
+        "title",
+        "label",
+        "email",
+        "username"
+    ];
+    for (const option of nameOptions){
+        if (Object.keys(fields).includes(option)) {
+            return option;
+        }
+    }
+    // Default to first field that's not id
+    const firstNonIdField = Object.keys(fields).find((k)=>k !== "id");
+    return firstNonIdField || "id";
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/better-auth/adapter/generate-schema/generate-schema-builder.ts"],"sourcesContent":["/**\n * This module generates PayloadCMS collection configurations based on the Better Auth schema.\n *\n * The generated collection configs include:\n * - Users: For user management with proper auth configuration\n * - Sessions: For maintaining user sessions\n * - Accounts: For OAuth provider accounts\n * - VerificationTokens: For email verification or social sign in\n *\n * Each collection is properly formatted with:\n * - Appropriate field types (text, relationship, checkbox, etc.)\n * - Admin configuration for better UI experience\n * - Auth configuration for the Users collection\n * - Proper field relationships between collections\n *\n * Users can copy these generated collection configs to their PayloadCMS project\n * and add authentication strategies as needed.\n */\nimport type { BetterAuthOptions } from \"better-auth\";\nimport { getAuthTables } from \"better-auth/db\";\nimport type { CollectionConfig, Field } from \"payload\";\n\nexport const generateSchemaBuilderStage = async ({\n  BAOptions,\n  code\n}: {\n  code: string;\n  BAOptions: BetterAuthOptions;\n}) => {\n  const { post, collections } = parseExistingSchema(code);\n\n  const payloadSchemaStr = generatePayloadCollectionConfigs({\n    options: BAOptions,\n    collections,\n    exports: post\n  });\n\n  return payloadSchemaStr;\n};\n\nfunction parseExistingSchema(code: string): {\n  collections: CollectionConfig[];\n  post: string;\n} {\n  const collections: CollectionConfig[] = [];\n  let post = \"\";\n\n  // Extract collection definitions\n  const collectionRegex =\n    /const\\s+([A-Z][a-zA-Z0-9]*)\\s*:\\s*CollectionConfig\\s*=\\s*{[\\s\\S]*?}\\s*as\\s*const;/g;\n  let match;\n  while ((match = collectionRegex.exec(code)) !== null) {\n    const collectionName = match[1];\n    const collectionDef = match[0];\n\n    // Extract slug\n    const slugMatch = collectionDef.match(/slug:\\s*\"([^\"]+)\"/);\n    const slug = slugMatch ? slugMatch[1] : collectionName.toLowerCase();\n\n    // Extract useAsTitle\n    const titleMatch = collectionDef.match(/useAsTitle:\\s*\"([^\"]+)\"/);\n    const useAsTitle = titleMatch ? titleMatch[1] : \"id\";\n\n    // Extract fields\n    const fieldsRegex = /fields:\\s*\\[([\\s\\S]*?)\\],/;\n    const fieldsMatch = collectionDef.match(fieldsRegex);\n    const fields: Field[] = [];\n\n    if (fieldsMatch) {\n      const fieldBlockRegex = /{[\\s\\S]*?},/g;\n      const fieldBlocks = fieldsMatch[1].match(fieldBlockRegex) || [];\n\n      for (const fieldBlock of fieldBlocks) {\n        const nameMatch = fieldBlock.match(/name:\\s*\"([^\"]+)\"/);\n        const typeMatch = fieldBlock.match(/type:\\s*\"([^\"]+)\"/);\n        const requiredMatch = fieldBlock.match(/required:\\s*(true|false)/);\n        const uniqueMatch = fieldBlock.match(/unique:\\s*(true|false)/);\n        const relationToMatch = fieldBlock.match(/relationTo:\\s*\"([^\"]+)\"/);\n\n        if (nameMatch && typeMatch) {\n          const field = {\n            name: nameMatch[1],\n            type: typeMatch[1] as Field[\"type\"]\n          };\n\n          if (requiredMatch) {\n            (field as any).required = requiredMatch[1] === \"true\";\n          }\n\n          if (uniqueMatch) {\n            (field as any).unique = uniqueMatch[1] === \"true\";\n          }\n\n          if (relationToMatch) {\n            (field as any).relationTo = relationToMatch[1];\n          }\n\n          fields.push(field as Field);\n        }\n      }\n    }\n\n    // Check for timestamps\n    const timestampsMatch = collectionDef.match(/timestamps:\\s*(true|false)/);\n    const hasTimestamps = timestampsMatch\n      ? timestampsMatch[1] === \"true\"\n      : false;\n\n    collections.push({\n      slug,\n      admin: {\n        useAsTitle\n      },\n      fields,\n      ...(hasTimestamps && { timestamps: true })\n    });\n  }\n\n  // Extract export statement\n  const exportRegex = /export\\s*{[\\s\\S]*?};/;\n  const exportMatch = code.match(exportRegex);\n  if (exportMatch) {\n    post = exportMatch[0];\n  }\n\n  return { collections, post };\n}\n\nfunction generatePayloadCollectionConfigs({\n  options,\n  collections,\n  exports\n}: {\n  options: BetterAuthOptions;\n  collections: CollectionConfig[];\n  exports: string;\n}): string {\n  let result = \"\";\n\n  // add pre message and import statements\n  result += `/**\n * EXAMPLE COLLECTIONS FOR BETTER AUTH\n * \n * Below is what your Payload collections should look like.\n * Please copy these to your actual collection configs.\n * Make sure to add an authStrategy for the users collection if there is one.\n * \n * Example auth strategy:\n * auth: {\n *   disableLocalStrategy: true,\n *   strategies: [\n *     betterAuthStrategy(),\n *     // Add other strategies as needed\n *   ],\n * },\n */\nimport type { CollectionConfig } from 'payload';\n\n`;\n\n  // add the collections\n  let collectionsStr = \"\";\n  const tables = getAuthTables(options);\n\n  // Process existing collections first\n  const existingCollectionsBySlug = collections.reduce(\n    (acc, collection) => {\n      if (collection.slug) {\n        acc[collection.slug] = collection;\n      }\n      return acc;\n    },\n    {} as Record<string, CollectionConfig>\n  );\n\n  for (const [tableKey, table] of Object.entries(tables)) {\n    const modelName = table.modelName;\n    const capitalized = modelName.charAt(0).toUpperCase() + modelName.slice(1);\n\n    // Check if this collection already exists in the provided collections\n    const existingCollection = existingCollectionsBySlug[modelName];\n\n    if (existingCollection) {\n      // Convert existing collection to string representation\n      collectionsStr += `const ${capitalized}: CollectionConfig = ${JSON.stringify(existingCollection, null, 2).replace(/\"([^\"]+)\":/g, \"$1:\")} as const;\\n\\n`;\n      continue;\n    }\n\n    // Create new collection if it doesn't exist\n    collectionsStr += `const ${capitalized}: CollectionConfig = {\n  slug: \"${modelName}\",\n`;\n\n    // Add admin section for better UX\n    collectionsStr += `  admin: {\n    useAsTitle: \"${getNameField(table.fields)}\",\n  },\n`;\n\n    // Add auth section ONLY for users collection\n    if (modelName === \"users\") {\n      collectionsStr += `  auth: {\n    disableLocalStrategy: true,\n    strategies: [],\n    // Add your auth strategies here if needed\n  },\n`;\n    }\n\n    // Add fields\n    collectionsStr += `  fields: [\n`;\n\n    for (const [fieldKey, field] of Object.entries(table.fields)) {\n      const fieldName = field.fieldName || fieldKey;\n      // Skip id field as Payload handles it automatically\n      if (fieldName === \"id\") continue;\n\n      if (fieldName === \"createdAt\" || fieldName === \"updatedAt\") continue;\n\n      // Handle field type mapping with safer type approach\n      let fieldType = mapFieldType(field.type as string, fieldName);\n      const isRelationship =\n        fieldName.endsWith(\"_id\") || !!field.references?.model;\n\n      collectionsStr += `    {\n      name: \"${isRelationship ? fieldName.replace(\"_id\", \"\") : fieldName}\",\n`;\n\n      if (isRelationship) {\n        collectionsStr += `      type: \"relationship\",\n      relationTo: \"${field.references?.model || fieldName.replace(\"_id\", \"\")}\",\n`;\n      } else if (fieldType === \"upload\") {\n        collectionsStr += `      type: \"upload\",\n      relationTo: \"media\",\n`;\n      } else {\n        collectionsStr += `      type: \"${fieldType}\",\n`;\n      }\n\n      if (field.required) {\n        collectionsStr += `      required: true,\n`;\n      }\n\n      if (field.unique) {\n        collectionsStr += `      unique: true,\n`;\n      }\n\n      // Check if field has options and fieldType is select\n      if (\n        fieldType === \"select\" &&\n        \"options\" in field &&\n        Array.isArray(field.options)\n      ) {\n        collectionsStr += `      options: ${JSON.stringify(field.options)},\n`;\n      }\n\n      if (field.defaultValue !== undefined) {\n        if (typeof field.defaultValue === \"string\") {\n          collectionsStr += `      defaultValue: \"${field.defaultValue}\",\n`;\n        } else if (typeof field.defaultValue === \"boolean\") {\n          collectionsStr += `      defaultValue: ${field.defaultValue ? \"true\" : \"false\"},\n`;\n        } else if (\n          field.defaultValue &&\n          typeof field.defaultValue === \"function\" &&\n          field.defaultValue.toString().includes(\"() => !1\")\n        ) {\n          // Handle function-like default values with are false\n          collectionsStr += `      defaultValue: false,\n`;\n        } else if (\n          field.defaultValue &&\n          typeof field.defaultValue === \"function\" &&\n          field.defaultValue.toString().includes(\"() => !0\")\n        ) {\n          // Handle function-like default values with are true\n          collectionsStr += `      defaultValue: true,\n`;\n        } else {\n          collectionsStr += `      defaultValue: ${field.defaultValue},\n`;\n        }\n      }\n\n      // Add admin section for fields if needed - safely check for admin property\n      if (\n        \"admin\" in field &&\n        field.admin &&\n        typeof field.admin === \"object\" &&\n        \"readOnly\" in field.admin &&\n        field.admin.readOnly\n      ) {\n        collectionsStr += `      admin: {\n        readOnly: true,\n      },\n`;\n      }\n\n      collectionsStr += `    },\n`;\n    }\n\n    collectionsStr += `  ],\n  timestamps: true,\n} as const;\n\n`;\n  }\n\n  // Add any collections from the input that aren't in the tables\n  for (const collection of collections) {\n    if (!collection.slug || tables[collection.slug]) {\n      continue; // Skip if no slug or already processed\n    }\n\n    const capitalized =\n      collection.slug.charAt(0).toUpperCase() + collection.slug.slice(1);\n    collectionsStr += `const ${capitalized}: CollectionConfig = ${JSON.stringify(collection, null, 2).replace(/\"([^\"]+)\":/g, \"$1:\")} as const;\\n\\n`;\n  }\n\n  result += collectionsStr;\n\n  // Add export statements for all collections\n  // Check if we have an existing export statement to adapt\n  if (exports && exports.trim()) {\n    // Parse the existing exports to get collection names\n    const existingExportMatch = exports.match(/export\\s*{\\s*(.*?)\\s*}/);\n    const existingCollections = existingExportMatch\n      ? existingExportMatch[1].split(\",\").map((name) => name.trim())\n      : [];\n\n    // Get the collection names from our tables\n    const tableCollections = Object.keys(tables).map((model) => {\n      return model.charAt(0).toUpperCase() + model.slice(1);\n    });\n\n    // Combine existing and new collections, removing duplicates\n    const allCollections = [\n      ...new Set([...existingCollections, ...tableCollections])\n    ];\n\n    // Create the new export statement\n    result += `export { ${allCollections.join(\", \")} };\n`;\n  } else if (Object.keys(tables).length > 0) {\n    const collectionNames = Object.keys(tables).map((model) => {\n      // Convert model name to PascalCase for export\n      const pascalCase = model.charAt(0).toUpperCase() + model.slice(1);\n      return pascalCase;\n    });\n\n    result += `export { ${collectionNames.join(\", \")} };\n`;\n  } else {\n    result += `export {};\n`;\n  }\n\n  return result;\n}\n\n// Helper functions\nfunction mapFieldType(type: string, fieldName: string): string {\n  if (fieldName.endsWith(\"_id\")) return \"relationship\";\n\n  switch (type) {\n    case \"boolean\":\n      return \"checkbox\";\n    case \"number\":\n      return \"number\";\n    case \"string\":\n      if (fieldName === \"email\") return \"email\";\n      if (fieldName.includes(\"password\")) return \"text\";\n      if (fieldName.includes(\"image\") || fieldName.includes(\"avatar\"))\n        return \"upload\";\n      return \"text\";\n    case \"date\":\n      return \"date\";\n    case \"array\":\n      return \"array\";\n    default:\n      return \"text\";\n  }\n}\n\nfunction getNameField(fields: Record<string, any>): string {\n  // Try to find an appropriate field to use as title\n  const nameOptions = [\"name\", \"title\", \"label\", \"email\", \"username\"];\n\n  for (const option of nameOptions) {\n    if (Object.keys(fields).includes(option)) {\n      return option;\n    }\n  }\n\n  // Default to first field that's not id\n  const firstNonIdField = Object.keys(fields).find((k) => k !== \"id\");\n  return firstNonIdField || \"id\";\n}\n"],"names":["getAuthTables","generateSchemaBuilderStage","BAOptions","code","post","collections","parseExistingSchema","payloadSchemaStr","generatePayloadCollectionConfigs","options","exports","collectionRegex","match","exec","collectionName","collectionDef","slugMatch","slug","toLowerCase","titleMatch","useAsTitle","fieldsRegex","fieldsMatch","fields","fieldBlockRegex","fieldBlocks","fieldBlock","nameMatch","typeMatch","requiredMatch","uniqueMatch","relationToMatch","field","name","type","required","unique","relationTo","push","timestampsMatch","hasTimestamps","admin","timestamps","exportRegex","exportMatch","result","collectionsStr","tables","existingCollectionsBySlug","reduce","acc","collection","tableKey","table","Object","entries","modelName","capitalized","charAt","toUpperCase","slice","existingCollection","JSON","stringify","replace","getNameField","fieldKey","fieldName","fieldType","mapFieldType","isRelationship","endsWith","references","model","Array","isArray","defaultValue","undefined","toString","includes","readOnly","trim","existingExportMatch","existingCollections","split","map","tableCollections","keys","allCollections","Set","join","length","collectionNames","pascalCase","nameOptions","option","firstNonIdField","find","k"],"mappings":"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"}

package/dist/better-auth/adapter/generate-schema/get-payload-schema.d.ts

@@ -0,0 +1,2 @@
+export declare const getPayloadSchema: (payloadDirPath: string) => Promise<string>;
+//# sourceMappingURL=get-payload-schema.d.ts.map

package/dist/better-auth/adapter/generate-schema/get-payload-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-payload-schema.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/adapter/generate-schema/get-payload-schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,GAC3B,gBAAgB,MAAM,KACrB,OAAO,CAAC,MAAM,CA0BhB,CAAC"}

package/dist/better-auth/adapter/generate-schema/get-payload-schema.js

@@ -0,0 +1,23 @@
+import fs from "node:fs/promises";
+export const getPayloadSchema = async (payloadDirPath)=>{
+    let files;
+    try {
+        files = await fs.readdir(payloadDirPath);
+    } catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Payload directory not found at "${payloadDirPath}". Please run this CLI from the project root directory where the payload directory is located, otherwise specify a payload directory path in your payloadAdapter options, under schema_generation.payload_dir_path.`);
+        }
+        console.error(error);
+        throw new Error(`Failed to access payload directory at "${payloadDirPath}".`);
+    }
+    if (!files.includes(`schema.ts`)) return "";
+    try {
+        const schemaCode = await fs.readFile(`${payloadDirPath}/schema.ts`, "utf8");
+        return schemaCode;
+    } catch (error) {
+        console.error(error);
+        throw new Error(`PayloadAdapter: Failed to read schema.ts file from "${payloadDirPath}".`);
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/adapter/generate-schema/index.d.ts

@@ -0,0 +1,5 @@
+import type { BetterAuthOptions } from "better-auth";
+export declare const generateSchema: (BAoptions: BetterAuthOptions, options?: {
+    outputDir: string;
+}) => Promise<string>;
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/adapter/generate-schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/adapter/generate-schema/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,eAAO,MAAM,cAAc,GACzB,WAAW,iBAAiB,EAC5B,UAAS;IAAE,SAAS,EAAE,MAAM,CAAA;CAE3B,KACA,OAAO,CAAC,MAAM,CAahB,CAAC"}

package/dist/better-auth/adapter/generate-schema/index.js

@@ -0,0 +1,19 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { generateSchemaBuilderStage } from "./generate-schema-builder";
+import { getPayloadSchema } from "./get-payload-schema";
+export const generateSchema = async (BAoptions, options = {
+    outputDir: "./generated"
+})=>{
+    const { outputDir } = options;
+    const existing_schema_code = await getPayloadSchema(outputDir);
+    const new_schema_code = await generateSchemaBuilderStage({
+        code: existing_schema_code,
+        BAOptions: BAoptions
+    });
+    const schemaPath = path.resolve(outputDir, "schema.ts");
+    await fs.writeFile(schemaPath, new_schema_code, "utf8");
+    return new_schema_code;
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/adapter/generate-schema/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function padding(str: string, indent?: number): string;
+export declare function getPayloadPath(provided_payload_dir_path?: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/better-auth/adapter/generate-schema/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/better-auth/adapter/generate-schema/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI,UAM9C;AAED,wBAAgB,cAAc,CAAC,yBAAyB,CAAC,EAAE,MAAM,UAehE"}

package/dist/better-auth/adapter/generate-schema/utils.js

@@ -0,0 +1,20 @@
+import path from "node:path";
+export function padding(str, indent = 2) {
+    if (str.trim() === "") return "";
+    return str.split("\n").map((x)=>x.length > 0 ? `${" ".repeat(indent)}${x}` : x).join("\n");
+}
+export function getPayloadPath(provided_payload_dir_path) {
+    const base_path = process.cwd();
+    // If no path provided, use default "convex" in current directory
+    if (!provided_payload_dir_path) {
+        return path.join(base_path, "payload");
+    }
+    // If it's already an absolute path and exists, use it directly
+    if (path.isAbsolute(provided_payload_dir_path)) {
+        return provided_payload_dir_path;
+    }
+    // Otherwise, treat it as relative to current directory
+    return path.join(base_path, provided_payload_dir_path);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/better-auth/adapter/index.d.ts

@@ -0,0 +1,16 @@
+import { generateSchema } from "./generate-schema";
+import type { PayloadAdapter } from "./types";
+export declare const BETTER_AUTH_CONTEXT_KEY = "payload-db-adapter";
+/**
+ * Payload adapter for Better Auth.
+ *
+ * This adapter connects Better Auth to Payload CMS, allowing authentication
+ * operations to be performed against Payload collections.
+ *
+ * @param payloadClient - The Payload CMS client instance or a function that returns it
+ * @param config - Configuration options for the adapter
+ * @returns A function that creates a Better Auth adapter
+ */
+declare const payloadAdapter: PayloadAdapter;
+export { generateSchema, payloadAdapter };
+//# sourceMappingURL=index.d.ts.map

package/dist/better-auth/adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/better-auth/adapter/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAa5D;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,EAAE,cAqvBrB,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC"}