refactor: change folder names

Author: productdevbook

README.md

@@ -47,6 +47,21 @@ unadapter provides a consistent interface for database operations, allowing you
 
 I've seen the need for this kind of adapter system in several of my own projects and across the open-source ecosystem. In the future, better-auth might utilize unadapter, bringing this unified adapter structure to a wider range of open-source projects with full ESM support.
 
+## 📦 Installation
+
+```bash
+# Using pnpm
+pnpm add unadapter
+
+# Using npm
+npm install unadapter
+
+# Using yarn
+yarn add unadapter
+```
+
+You'll also need to install the specific database driver or ORM you plan to use.
+
 ## 🧩 Available Adapters
 
 <table>
@@ -92,9 +107,302 @@ I've seen the need for this kind of adapter system in several of my own projects
 - 🗺️ Custom field mapping
 - 📊 Support for various data types across different database systems
 
-## 📝 License
 
-See the [LICENSE](LICENSE) file for details.
+## 🚀 Getting Started
+
+### Basic Usage
+
+```typescript
+import { memoryAdapter } from 'unadapter/adapters/memory'
+
+// Create an in-memory database for testing
+const db = {
+  user: [],
+  session: []
+}
+
+// Initialize the adapter
+const adapter = memoryAdapter(db)
+
+// Now you can use the adapter to perform database operations
+const user = await adapter.create({
+  model: 'user',
+  data: {
+    name: 'John Doe',
+    email: '[email protected]',
+    emailVerified: true,
+    createdAt: new Date(),
+    updatedAt: new Date()
+  }
+})
+
+// Find the user
+const foundUser = await adapter.findOne({
+  model: 'user',
+  where: [
+    {
+      field: 'email',
+      value: '[email protected]'
+    }
+  ]
+})
+
+// Update the user
+const updatedUser = await adapter.update({
+  model: 'user',
+  where: [
+    {
+      field: 'id',
+      value: user.id
+    }
+  ],
+  update: {
+    name: 'John Smith'
+  }
+})
+
+// Delete the user
+await adapter.delete({
+  model: 'user',
+  where: [
+    {
+      field: 'id',
+      value: user.id
+    }
+  ]
+})
+```
+
+### Using Prisma Adapter
+
+```typescript
+import { PrismaClient } from '@prisma/client'
+import { prismaAdapter } from 'unadapter/adapters/prisma-adapter'
+
+const prisma = new PrismaClient()
+const adapter = prismaAdapter(prisma)
+
+// Now you can use the same adapter interface with Prisma
+const user = await adapter.create({
+  model: 'user',
+  data: {
+    name: 'Jane Doe',
+    email: '[email protected]',
+    emailVerified: true,
+    createdAt: new Date(),
+    updatedAt: new Date()
+  }
+})
+```
+
+### Using MongoDB Adapter
+
+```typescript
+import { MongoClient } from 'mongodb'
+import { mongodbAdapter } from 'unadapter/adapters/mongodb'
+
+const client = new MongoClient('mongodb://localhost:27017')
+await client.connect()
+const db = client.db('myDatabase')
+
+const adapter = mongodbAdapter(db)
+
+// Now you can use the same adapter interface with MongoDB
+const user = await adapter.create({
+  model: 'user',
+  data: {
+    name: 'Alex Smith',
+    email: '[email protected]',
+    emailVerified: false,
+    createdAt: new Date(),
+    updatedAt: new Date()
+  }
+})
+```
+
+### Using Drizzle Adapter
+
+```typescript
+import { drizzle } from 'drizzle-orm/...' // Import appropriate driver
+import { drizzleAdapter } from 'unadapter/adapters/drizzle'
+
+const db = drizzle(/* your DB connection */)
+const adapter = drizzleAdapter(db, {
+  provider: 'postgresql', // or 'mysql', 'sqlite'
+  usePlural: false
+})
+
+// Now you can use the same adapter interface with Drizzle
+const user = await adapter.create({
+  model: 'user',
+  data: {
+    name: 'Taylor Swift',
+    email: '[email protected]',
+    emailVerified: true,
+    createdAt: new Date(),
+    updatedAt: new Date()
+  }
+})
+```
+
+### Using Kysely Adapter
+
+```typescript
+import { Kysely } from 'kysely'
+import { kyselyAdapter } from 'unadapter/adapters/kysely'
+
+const db = new Kysely(/* your DB connection */)
+const adapter = kyselyAdapter(db, {
+  type: 'postgresql', // or 'mysql', 'sqlite', 'mssql'
+  usePlural: false
+})
+
+// Now you can use the same adapter interface with Kysely
+const user = await adapter.create({
+  model: 'user',
+  data: {
+    name: 'Chris Evans',
+    email: '[email protected]',
+    emailVerified: true,
+    createdAt: new Date(),
+    updatedAt: new Date()
+  }
+})
+```
+
+## 🔍 API Reference
+
+### Adapter Interface
+
+All adapters implement the following interface:
+
+```typescript
+interface Adapter {
+  id: string;
+  
+  // Create a new record
+  create<T>({
+    model: string,
+    data: Omit<T, 'id'>,
+    select?: string[]
+  }): Promise<T>;
+  
+  // Find a single record
+  findOne<T>({
+    model: string,
+    where: Where[],
+    select?: string[]
+  }): Promise<T | null>;
+  
+  // Find multiple records
+  findMany<T>({
+    model: string,
+    where?: Where[],
+    limit?: number,
+    sortBy?: {
+      field: string,
+      direction: 'asc' | 'desc'
+    },
+    offset?: number
+  }): Promise<T[]>;
+  
+  // Update a record
+  update<T>({
+    model: string,
+    where: Where[],
+    update: Record<string, any>
+  }): Promise<T | null>;
+  
+  // Update multiple records
+  updateMany({
+    model: string,
+    where: Where[],
+    update: Record<string, any>
+  }): Promise<number>;
+  
+  // Delete a record
+  delete({
+    model: string,
+    where: Where[]
+  }): Promise<void>;
+  
+  // Delete multiple records
+  deleteMany({
+    model: string,
+    where: Where[]
+  }): Promise<number>;
+  
+  // Count records
+  count({
+    model: string,
+    where?: Where[]
+  }): Promise<number>;
+  
+  // Additional options
+  options?: Record<string, any>;
+}
+```
+
+### Where Clause Interface
+
+The `Where` interface is used for filtering records:
+
+```typescript
+interface Where {
+  field: string;
+  value?: any;
+  operator?: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'starts_with' | 'ends_with';
+  connector?: 'AND' | 'OR';
+}
+```
+
+### Creating Custom Adapters
+
+You can create your own adapters using the `createAdapter` function:
+
+```typescript
+import { createAdapter } from 'unadapter/adapters/create-adapter'
+
+const myCustomAdapter = createAdapter({
+  config: {
+    adapterId: 'my-custom-adapter',
+    adapterName: 'My Custom Adapter',
+    usePlural: false,
+    supportsJSON: true,
+    supportsDates: true,
+    supportsBooleans: true
+  },
+  adapter: ({ options, schema }) => {
+    // Implement adapter methods
+    return {
+      async create({ model, data }) {
+        // Your implementation here
+      },
+      async findOne({ model, where, select }) {
+        // Your implementation here
+      },
+      async findMany({ model, where, limit, sortBy, offset }) {
+        // Your implementation here
+      },
+      async update({ model, where, update }) {
+        // Your implementation here
+      },
+      async updateMany({ model, where, update }) {
+        // Your implementation here
+      },
+      async delete({ model, where }) {
+        // Your implementation here
+      },
+      async deleteMany({ model, where }) {
+        // Your implementation here
+      },
+      async count({ model, where }) {
+        // Your implementation here
+      }
+    }
+  }
+})
+```
 
 ## 🤝 Contributing
 
@@ -106,6 +414,11 @@ This project draws inspiration and core concepts from:
 
 - [better-auth](https://github.com/better-auth) - The original adapter architecture that inspired this project
 
+## 📝 License
+
+See the [LICENSE](LICENSE) file for details.
+
+
 <hr />
 
 <div align="center">

package.json

@@ -54,8 +54,8 @@
     "test:coverage": "vitest run --coverage.enabled true",
     "test:coverage:badges": "vitest run --coverage.enabled true && node scripts/update-badges.mjs",
     "update:badges": "node scripts/update-badges.mjs",
-    "prisma:normal:push": "prisma db push --schema src/adapters/prisma-adapter/test/normal-tests/schema.prisma --accept-data-loss",
-    "prisma:number-id:push": "prisma db push --schema src/adapters/prisma-adapter/test/number-id-tests/schema.prisma --accept-data-loss",
+    "prisma:normal:push": "prisma db push --schema src/adapters/prisma/test/normal-tests/schema.prisma --accept-data-loss",
+    "prisma:number-id:push": "prisma db push --schema src/adapters/prisma/test/number-id-tests/schema.prisma --accept-data-loss",
     "prepare": "npm run build",
     "prepublishOnly": "npm run test",
     "bumpp": "bumpp package.json",

src/adapters/create-adapter/index.ts renamed to src/adapters/create/index.ts

@@ -6,7 +6,7 @@ import type {
   CleanedWhere,
   CreateCustomAdapter,
 } from './types.ts'
-import { withApplyDefault } from '../../adapters/utils.ts'
+import { withApplyDefault } from '../utils.ts'
 import { getAuthTables } from '../../db/get-tables.ts'
 import { generateId as defaultGenerateId, logger } from '../../utils/index.ts'
 import { safeJSONParse } from '../../utils/json.ts'

src/adapters/create-adapter/test/__snapshots__/create-adapter.test.ts.snap renamed to src/adapters/create/test/__snapshots__/create-adapter.test.ts.snap

@@ -2,7 +2,7 @@ import type {
   SQL,
 } from 'drizzle-orm'
 import type { Where } from '../../types/index.ts'
-import type { AdapterDebugLogs } from '../create-adapter/index.ts'
+import type { AdapterDebugLogs } from '../create/index.ts'
 import {
   and,
   asc,
@@ -17,7 +17,7 @@ import {
   sql,
 } from 'drizzle-orm'
 import { BetterAuthError } from '../../error/index.ts'
-import { createAdapter } from '../create-adapter/index.ts'
+import { createAdapter } from '../create/index.ts'
 
 export interface DB {
   [key: string]: any

src/adapters/create-adapter/test/create-adapter.test.ts renamed to src/adapters/create/test/create-adapter.test.ts

@@ -1 +1 @@
-export * from './create-adapter/index.ts'
+export * from './create/index.ts'

src/adapters/create-adapter/types.ts renamed to src/adapters/create/types.ts

@@ -1,8 +1,8 @@
 import type { InsertQueryBuilder, Kysely, UpdateQueryBuilder } from 'kysely'
 import type { Where } from '../../types/index.ts'
-import type { AdapterDebugLogs } from '../create-adapter/index.ts'
+import type { AdapterDebugLogs } from '../create/index.ts'
 import type { KyselyDatabaseType } from './types.ts'
-import { createAdapter } from '../create-adapter/index.ts'
+import { createAdapter } from '../create/index.ts'
 
 interface KyselyAdapterConfig {
   /**