Use better-auth native naming conventions for seamless migration

- Changed table names: auth_user → user, auth_session → session, etc.
- Changed field names: email_verified → emailVerified, created_at → createdAt, etc.
- Removed name conversion logic from adapter (no longer needed)
- Updated documentation to reflect better-auth native schema usage
- All tests passing (11/11)

This ensures existing better-auth databases can migrate without schema changes.

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/plugins/plugin-auth/README.md

@@ -32,14 +32,15 @@ Authentication & Identity Plugin for ObjectStack.
 ### ObjectQL-Based Database Architecture
 - ✅ **Native ObjectQL Data Persistence** - Uses ObjectQL's IDataEngine interface
 - ✅ **No Third-Party ORM** - No dependency on drizzle-orm or other ORMs
+- ✅ **Better-Auth Native Schema** - Uses better-auth's naming conventions for seamless migration
 - ✅ **Object Definitions** - Auth objects defined using ObjectStack's Object Protocol
-  - `auth_user` - User accounts
-  - `auth_session` - Active sessions
-  - `auth_account` - OAuth provider accounts
-  - `auth_verification` - Email/phone verification tokens
+  - `user` - User accounts (better-auth native table name)
+  - `session` - Active sessions (better-auth native table name)
+  - `account` - OAuth provider accounts (better-auth native table name)
+  - `verification` - Email/phone verification tokens (better-auth native table name)
 - ✅ **ObjectQL Adapter** - Custom adapter bridges better-auth to ObjectQL
 
-The plugin uses [better-auth](https://www.better-auth.com/) for robust, production-ready authentication functionality. All requests are forwarded directly to better-auth's universal handler, ensuring full compatibility with all better-auth features. Data persistence is handled by ObjectQL, adhering to ObjectStack's "Data as Code" philosophy.
+The plugin uses [better-auth](https://www.better-auth.com/) for robust, production-ready authentication functionality. All requests are forwarded directly to better-auth's universal handler, ensuring full compatibility with all better-auth features. Data persistence is handled by ObjectQL using **better-auth's native naming conventions** (camelCase) to ensure seamless migration for existing better-auth users.
 
 ## Installation
 
@@ -184,13 +185,16 @@ This architecture provides:
 The plugin uses **ObjectQL** for data persistence instead of third-party ORMs:
 
 ```typescript
-// Object definitions replace ORM schemas
+// Object definitions use better-auth's native naming conventions
 export const AuthUser = ObjectSchema.create({
-  name: 'auth_user',
+  name: 'user',  // better-auth native table name
   fields: {
     id: Field.text({ label: 'User ID', required: true }),
     email: Field.email({ label: 'Email', required: true }),
+    emailVerified: Field.boolean({ label: 'Email Verified' }),  // camelCase
     name: Field.text({ label: 'Name', required: true }),
+    createdAt: Field.datetime({ label: 'Created At' }),  // camelCase
+    updatedAt: Field.datetime({ label: 'Updated At' }),  // camelCase
     // ... other fields
   },
   indexes: [
@@ -206,18 +210,20 @@ export const AuthUser = ObjectSchema.create({
 - ✅ **Type-Safe** - Zod-based schemas provide runtime + compile-time safety
 - ✅ **"Data as Code"** - Object definitions are versioned, declarative code
 - ✅ **Metadata Driven** - Supports migrations, validation, indexing via metadata
+- ✅ **Seamless Migration** - Uses better-auth's native naming (camelCase) for easy migration
 
 **Database Objects:**
-- `auth_user` - User accounts (email, name, emailVerified, etc.)
-- `auth_session` - Active sessions (token, expiresAt, ipAddress, etc.)
-- `auth_account` - OAuth provider accounts (providerId, tokens, etc.)
-- `auth_verification` - Verification tokens (email, phone verification)
+Uses better-auth's native table and field names for compatibility:
+- `user` - User accounts (id, email, name, emailVerified, createdAt, etc.)
+- `session` - Active sessions (id, token, userId, expiresAt, ipAddress, etc.)
+- `account` - OAuth provider accounts (id, providerId, accountId, userId, tokens, etc.)
+- `verification` - Verification tokens (id, value, identifier, expiresAt, etc.)
 
 **Adapter:**
-The `createObjectQLAdapter()` function bridges better-auth's database interface to ObjectQL's IDataEngine:
+The `createObjectQLAdapter()` function bridges better-auth's database interface to ObjectQL's IDataEngine using better-auth's native naming conventions:
 
 ```typescript
-// Better-auth → ObjectQL Adapter
+// Better-auth → ObjectQL Adapter (no name conversion needed)
 const adapter = createObjectQLAdapter(dataEngine);
 
 // Better-auth uses this adapter for all database operations

packages/plugins/plugin-auth/src/objectql-adapter.ts

@@ -10,51 +10,21 @@ import type { CleanedWhere } from 'better-auth/adapters';
  * This allows better-auth to use ObjectQL for data persistence instead of
  * third-party ORMs like drizzle-orm.
  * 
+ * Uses better-auth's native naming conventions (camelCase) for seamless migration.
+ * 
  * @param dataEngine - ObjectQL data engine instance
  * @returns better-auth CustomAdapter
  */
 export function createObjectQLAdapter(dataEngine: IDataEngine) {
-  /**
-   * Convert better-auth table names to ObjectQL object names
-   * better-auth uses camelCase, ObjectQL uses snake_case
-   */
-  function toObjectName(tableName: string): string {
-    // Map better-auth table names to our object names
-    const tableMap: Record<string, string> = {
-      'user': 'auth_user',
-      'session': 'auth_session',
-      'account': 'auth_account',
-      'verification': 'auth_verification',
-    };
-    return tableMap[tableName] || `auth_${tableName}`;
-  }
-
-  /**
-   * Convert better-auth field names to ObjectQL field names
-   * better-auth uses camelCase, ObjectQL uses snake_case
-   */
-  function toFieldName(fieldName: string): string {
-    // Convert camelCase to snake_case
-    return fieldName.replace(/([A-Z])/g, '_$1').toLowerCase();
-  }
-
-  /**
-   * Convert ObjectQL field names back to better-auth field names
-   * ObjectQL uses snake_case, better-auth uses camelCase
-   */
-  function fromFieldName(fieldName: string): string {
-    // Convert snake_case to camelCase
-    return fieldName.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-  }
-
   /**
    * Convert better-auth where clause to ObjectQL query format
    */
   function convertWhere(where: CleanedWhere[]): Record<string, any> {
     const filter: Record<string, any> = {};
 
     for (const condition of where) {
-      const fieldName = toFieldName(condition.field);
+      // Use field names as-is (no conversion needed)
+      const fieldName = condition.field;
 
       if (condition.operator === 'eq') {
         filter[fieldName] = condition.value;
@@ -78,41 +48,19 @@ export function createObjectQLAdapter(dataEngine: IDataEngine) {
     return filter;
   }
 
-  /**
-   * Convert data from better-auth format to ObjectQL format
-   */
-  function convertDataToObjectQL(data: Record<string, any>): Record<string, any> {
-    const converted: Record<string, any> = {};
-    for (const [key, value] of Object.entries(data)) {
-      converted[toFieldName(key)] = value;
-    }
-    return converted;
-  }
-
-  /**
-   * Convert data from ObjectQL format to better-auth format
-   */
-  function convertDataFromObjectQL(data: Record<string, any>): Record<string, any> {
-    const converted: Record<string, any> = {};
-    for (const [key, value] of Object.entries(data)) {
-      converted[fromFieldName(key)] = value;
-    }
-    return converted;
-  }
-
   return {
     create: async <T extends Record<string, any>>({ model, data, select: _select }: { model: string; data: T; select?: string[] }): Promise<T> => {
-      const objectName = toObjectName(model);
-      const objectData = convertDataToObjectQL(data);
+      // Use model name as-is (no conversion needed)
+      const objectName = model;
 
       // Note: select parameter is currently not supported by ObjectQL's insert operation
       // The full record is always returned after insertion
-      const result = await dataEngine.insert(objectName, objectData);
-      return convertDataFromObjectQL(result) as T;
+      const result = await dataEngine.insert(objectName, data);
+      return result as T;
     },
 
     findOne: async <T>({ model, where, select, join: _join }: { model: string; where: CleanedWhere[]; select?: string[]; join?: any }): Promise<T | null> => {
-      const objectName = toObjectName(model);
+      const objectName = model;
       const filter = convertWhere(where);
 
       // Note: join parameter is not currently supported by ObjectQL's findOne operation
@@ -121,21 +69,21 @@ export function createObjectQLAdapter(dataEngine: IDataEngine) {
 
       const result = await dataEngine.findOne(objectName, {
         filter,
-        select: select?.map(toFieldName),
+        select,
       });
 
-      return result ? convertDataFromObjectQL(result) as T : null;
+      return result ? result as T : null;
     },
 
     findMany: async <T>({ model, where, limit, offset, sortBy, join: _join }: { model: string; where?: CleanedWhere[]; limit: number; offset?: number; sortBy?: { field: string; direction: 'asc' | 'desc' }; join?: any }): Promise<T[]> => {
-      const objectName = toObjectName(model);
+      const objectName = model;
       const filter = where ? convertWhere(where) : {};
 
       // Note: join parameter is not currently supported by ObjectQL's find operation
       // Joins/populate functionality is planned for future ObjectQL releases
 
       const sort = sortBy ? [{
-        field: toFieldName(sortBy.field),
+        field: sortBy.field,
         order: sortBy.direction as 'asc' | 'desc',
       }] : undefined;
 
@@ -146,20 +94,19 @@ export function createObjectQLAdapter(dataEngine: IDataEngine) {
         sort,
       });
 
-      return results.map(r => convertDataFromObjectQL(r)) as T[];
+      return results as T[];
     },
 
     count: async ({ model, where }: { model: string; where?: CleanedWhere[] }): Promise<number> => {
-      const objectName = toObjectName(model);
+      const objectName = model;
       const filter = where ? convertWhere(where) : {};
 
       return await dataEngine.count(objectName, { filter });
     },
 
     update: async <T>({ model, where, update }: { model: string; where: CleanedWhere[]; update: Record<string, any> }): Promise<T | null> => {
-      const objectName = toObjectName(model);
+      const objectName = model;
       const filter = convertWhere(where);
-      const updateData = convertDataToObjectQL(update);
 
       // Find the record first to get its ID
       const record = await dataEngine.findOne(objectName, { filter });
@@ -168,17 +115,16 @@ export function createObjectQLAdapter(dataEngine: IDataEngine) {
       }
 
       const result = await dataEngine.update(objectName, {
-        ...updateData,
+        ...update,
         id: record.id,
       });
 
-      return result ? convertDataFromObjectQL(result) as T : null;
+      return result ? result as T : null;
     },
 
     updateMany: async ({ model, where, update }: { model: string; where: CleanedWhere[]; update: Record<string, any> }): Promise<number> => {
-      const objectName = toObjectName(model);
+      const objectName = model;
       const filter = convertWhere(where);
-      const updateData = convertDataToObjectQL(update);
 
       // Note: Sequential updates are used here because ObjectQL's IDataEngine interface
       // requires an ID for updates. A future optimization could use a bulk update
@@ -190,7 +136,7 @@ export function createObjectQLAdapter(dataEngine: IDataEngine) {
       // Update each record
       for (const record of records) {
         await dataEngine.update(objectName, {
-          ...updateData,
+          ...update,
           id: record.id,
         });
       }
@@ -199,7 +145,7 @@ export function createObjectQLAdapter(dataEngine: IDataEngine) {
     },
 
     delete: async ({ model, where }: { model: string; where: CleanedWhere[] }): Promise<void> => {
-      const objectName = toObjectName(model);
+      const objectName = model;
       const filter = convertWhere(where);
 
       // Note: We need to find the record first to get its ID because ObjectQL's
@@ -214,7 +160,7 @@ export function createObjectQLAdapter(dataEngine: IDataEngine) {
     },
 
     deleteMany: async ({ model, where }: { model: string; where: CleanedWhere[] }): Promise<number> => {
-      const objectName = toObjectName(model);
+      const objectName = model;
       const filter = convertWhere(where);
 
       // Note: Sequential deletes are used here because ObjectQL's delete operation

packages/plugins/plugin-auth/src/objects/auth-account.object.ts

@@ -5,13 +5,13 @@ import { ObjectSchema, Field } from '@objectstack/spec/data';
 /**
  * Auth Account Object
  * 
- * Maps to better-auth's Account schema for OAuth providers:
+ * Uses better-auth's native schema for seamless migration:
  * - id: string
  * - createdAt: Date
  * - updatedAt: Date
  * - providerId: string (e.g., 'google', 'github')
  * - accountId: string (provider's user ID)
- * - userId: string (link to auth_user)
+ * - userId: string (link to user table)
  * - accessToken: string | null
  * - refreshToken: string | null
  * - idToken: string | null
@@ -21,13 +21,13 @@ import { ObjectSchema, Field } from '@objectstack/spec/data';
  * - password: string | null (for email/password provider)
  */
 export const AuthAccount = ObjectSchema.create({
-  name: 'auth_account',
+  name: 'account',
   label: 'Account',
   pluralLabel: 'Accounts',
   icon: 'link',
   description: 'OAuth and authentication provider accounts',
-  titleFormat: '{provider_id} - {account_id}',
-  compactLayout: ['provider_id', 'user_id', 'account_id'],
+  titleFormat: '{providerId} - {accountId}',
+  compactLayout: ['providerId', 'userId', 'accountId'],
 
   fields: {
     id: Field.text({
@@ -36,57 +36,57 @@ export const AuthAccount = ObjectSchema.create({
       readonly: true,
     }),
 
-    created_at: Field.datetime({
+    createdAt: Field.datetime({
       label: 'Created At',
       defaultValue: 'NOW()',
       readonly: true,
     }),
 
-    updated_at: Field.datetime({
+    updatedAt: Field.datetime({
       label: 'Updated At',
       defaultValue: 'NOW()',
       readonly: true,
     }),
 
-    provider_id: Field.text({
+    providerId: Field.text({
       label: 'Provider ID',
       required: true,
       description: 'OAuth provider identifier (google, github, etc.)',
     }),
 
-    account_id: Field.text({
+    accountId: Field.text({
       label: 'Provider Account ID',
       required: true,
       description: "User's ID in the provider's system",
     }),
 
-    user_id: Field.text({
+    userId: Field.text({
       label: 'User ID',
       required: true,
-      description: 'Link to auth_user',
+      description: 'Link to user table',
     }),
 
-    access_token: Field.textarea({
+    accessToken: Field.textarea({
       label: 'Access Token',
       required: false,
     }),
 
-    refresh_token: Field.textarea({
+    refreshToken: Field.textarea({
       label: 'Refresh Token',
       required: false,
     }),
 
-    id_token: Field.textarea({
+    idToken: Field.textarea({
       label: 'ID Token',
       required: false,
     }),
 
-    access_token_expires_at: Field.datetime({
+    accessTokenExpiresAt: Field.datetime({
       label: 'Access Token Expires At',
       required: false,
     }),
 
-    refresh_token_expires_at: Field.datetime({
+    refreshTokenExpiresAt: Field.datetime({
       label: 'Refresh Token Expires At',
       required: false,
     }),
@@ -105,8 +105,8 @@ export const AuthAccount = ObjectSchema.create({
 
   // Database indexes for performance
   indexes: [
-    { fields: ['user_id'], unique: false },
-    { fields: ['provider_id', 'account_id'], unique: true },
+    { fields: ['userId'], unique: false },
+    { fields: ['providerId', 'accountId'], unique: true },
   ],
 
   // Enable features