@svadmin/drizzle 0.4.1

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@svadmin/drizzle",
+  "version": "0.4.1",
+  "description": "Drizzle ORM DataProvider — SQLite, PostgreSQL, MySQL, Cloudflare D1 via refine-sqlx",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "src/**/*"
+  ],
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "peerDependencies": {
+    "@svadmin/core": "^0.4.1",
+    "refine-sqlx": "^0.9.0"
+  },
+  "license": "MIT",
+  "author": "zuohuadong",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zuohuadong/svadmin.git",
+    "directory": "packages/drizzle"
+  },
+  "homepage": "https://github.com/zuohuadong/svadmin#readme",
+  "bugs": {
+    "url": "https://github.com/zuohuadong/svadmin/issues"
+  },
+  "devDependencies": {
+    "drizzle-orm": "^0.45.1"
+  }
+}

package/src/data-provider.test.ts

@@ -0,0 +1,144 @@
+/**
+ * @svadmin/drizzle — DataProvider integration test
+ *
+ * Uses bun:sqlite in-memory database to verify the full CRUD lifecycle
+ * through the wrapper layer.
+ */
+
+import { describe, it, expect, beforeAll } from 'bun:test';
+import { Database } from 'bun:sqlite';
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';
+import { createDrizzleDataProvider } from './data-provider';
+import type { DataProvider } from '@svadmin/core';
+
+// ─── Test Schema ──────────────────────────────────────────────────
+
+const users = sqliteTable('users', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  name: text('name').notNull(),
+  email: text('email').notNull(),
+  role: text('role').default('user'),
+});
+
+const schema = { users };
+
+// ─── Tests ────────────────────────────────────────────────────────
+
+describe('@svadmin/drizzle DataProvider', () => {
+  let dataProvider: DataProvider;
+  let db: ReturnType<typeof drizzle>;
+
+  beforeAll(async () => {
+    const sqlite = new Database(':memory:');
+    sqlite.run(`
+      CREATE TABLE users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        email TEXT NOT NULL,
+        role TEXT DEFAULT 'user'
+      )
+    `);
+    db = drizzle(sqlite, { schema });
+    dataProvider = await createDrizzleDataProvider({ connection: db, schema });
+  });
+
+  it('returns a valid DataProvider with all required methods', () => {
+    expect(dataProvider.getList).toBeFunction();
+    expect(dataProvider.getOne).toBeFunction();
+    expect(dataProvider.create).toBeFunction();
+    expect(dataProvider.update).toBeFunction();
+    expect(dataProvider.deleteOne).toBeFunction();
+    expect(dataProvider.getApiUrl).toBeFunction();
+  });
+
+  it('create → getOne roundtrip', async () => {
+    const created = await dataProvider.create({
+      resource: 'users',
+      variables: { name: 'Alice', email: 'alice@example.com', role: 'admin' },
+    });
+
+    expect(created.data).toMatchObject({
+      name: 'Alice',
+      email: 'alice@example.com',
+      role: 'admin',
+    });
+
+    const fetched = await dataProvider.getOne({
+      resource: 'users',
+      id: (created.data as Record<string, unknown>).id as number,
+    });
+
+    expect(fetched.data).toMatchObject({
+      name: 'Alice',
+      email: 'alice@example.com',
+    });
+  });
+
+  it('getList with pagination and sorting', async () => {
+    // Seed more data
+    await dataProvider.create({ resource: 'users', variables: { name: 'Bob', email: 'bob@example.com' } });
+    await dataProvider.create({ resource: 'users', variables: { name: 'Charlie', email: 'charlie@example.com' } });
+
+    const result = await dataProvider.getList({
+      resource: 'users',
+      pagination: { current: 1, pageSize: 2 },
+      sorters: [{ field: 'name', order: 'asc' }],
+    });
+
+    expect(result.data.length).toBe(2);
+    expect(result.total).toBeGreaterThanOrEqual(3);
+    // Sorted ascending: Alice before Bob
+    expect((result.data[0] as Record<string, unknown>).name).toBe('Alice');
+  });
+
+  it('getList with filters', async () => {
+    const result = await dataProvider.getList({
+      resource: 'users',
+      filters: [{ field: 'role', operator: 'eq', value: 'admin' }],
+    });
+
+    expect(result.data.length).toBe(1);
+    expect((result.data[0] as Record<string, unknown>).name).toBe('Alice');
+  });
+
+  it('update modifies a record', async () => {
+    const list = await dataProvider.getList({ resource: 'users', filters: [{ field: 'name', operator: 'eq', value: 'Bob' }] });
+    const bobId = (list.data[0] as Record<string, unknown>).id as number;
+
+    const updated = await dataProvider.update({
+      resource: 'users',
+      id: bobId,
+      variables: { role: 'editor' },
+    });
+
+    expect((updated.data as Record<string, unknown>).role).toBe('editor');
+  });
+
+  it('deleteOne removes a record', async () => {
+    const list = await dataProvider.getList({ resource: 'users', filters: [{ field: 'name', operator: 'eq', value: 'Charlie' }] });
+    const charlieId = (list.data[0] as Record<string, unknown>).id as number;
+
+    await dataProvider.deleteOne({ resource: 'users', id: charlieId });
+
+    const afterDelete = await dataProvider.getList({
+      resource: 'users',
+      filters: [{ field: 'name', operator: 'eq', value: 'Charlie' }],
+    });
+    expect(afterDelete.data.length).toBe(0);
+  });
+
+  it('getMany fetches multiple records by IDs', async () => {
+    if (!dataProvider.getMany) return;
+
+    const list = await dataProvider.getList({ resource: 'users' });
+    const ids = list.data.slice(0, 2).map(d => (d as Record<string, unknown>).id as number);
+
+    const result = await dataProvider.getMany({ resource: 'users', ids });
+    expect(result.data.length).toBe(2);
+  });
+
+  it('getApiUrl returns empty string', () => {
+    expect(dataProvider.getApiUrl()).toBe('');
+  });
+});

package/src/data-provider.ts

@@ -0,0 +1,71 @@
+/**
+ * @svadmin/drizzle — Drizzle ORM DataProvider adapter
+ *
+ * Thin wrapper around refine-sqlx that returns a @svadmin/core DataProvider.
+ * Supports SQLite, PostgreSQL, MySQL, and Cloudflare D1.
+ *
+ * @example
+ * ```ts
+ * import { createDrizzleDataProvider } from '@svadmin/drizzle';
+ * import { drizzle } from 'drizzle-orm/bun-sqlite';
+ * import * as schema from './schema';
+ *
+ * const db = drizzle(new Database(':memory:'), { schema });
+ * const dataProvider = await createDrizzleDataProvider({ connection: db, schema });
+ * ```
+ */
+
+import type { DataProvider } from '@svadmin/core';
+import type { RefineSQLConfig } from 'refine-sqlx';
+import { createRefineSQL } from 'refine-sqlx';
+
+export type { RefineSQLConfig } from 'refine-sqlx';
+
+/**
+ * Create a svadmin DataProvider backed by Drizzle ORM.
+ *
+ * Wraps refine-sqlx's `createRefineSQL()` and returns a `@svadmin/core` DataProvider.
+ * Both type systems are structurally compatible (duck typing), so the wrapper is
+ * a simple type-level bridge with no runtime overhead.
+ *
+ * @param config - refine-sqlx configuration (connection, schema, features, etc.)
+ * @returns A @svadmin/core DataProvider
+ *
+ * @example
+ * ```ts
+ * import { createDrizzleDataProvider } from '@svadmin/drizzle';
+ * import { drizzle } from 'drizzle-orm/bun-sqlite';
+ * import { Database } from 'bun:sqlite';
+ * import * as schema from './schema';
+ *
+ * const db = drizzle(new Database('./app.db'), { schema });
+ *
+ * const dataProvider = await createDrizzleDataProvider({
+ *   connection: db,
+ *   schema,
+ *   softDelete: { enabled: true },
+ *   features: {
+ *     relations: { enabled: true },
+ *     transactions: { enabled: true },
+ *   },
+ * });
+ * ```
+ */
+export async function createDrizzleDataProvider<
+  TSchema extends Record<string, unknown>,
+>(config: RefineSQLConfig<TSchema>): Promise<DataProvider> {
+  const provider = await createRefineSQL(config);
+
+  // refine-sqlx's DataProvider is structurally compatible with @svadmin/core's DataProvider:
+  //   - Same method names: getList, getOne, getMany, create, update, deleteOne, etc.
+  //   - Same parameter shapes: { resource, pagination, sorters, filters, meta, ... }
+  //   - Same return shapes: { data, total } / { data }
+  //
+  // The only nominal difference is type naming (GetListResponse vs GetListResult, etc.)
+  // which TypeScript's structural type system bridges automatically.
+  //
+  // The `custom()` method has a minor signature superset (refine-sqlx supports
+  // 'head' and 'options' HTTP methods that svadmin doesn't define), which is
+  // a non-breaking superset — safe to cast.
+  return provider as unknown as DataProvider;
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+// @svadmin/drizzle — Drizzle ORM DataProvider for svadmin
+//
+// Usage:
+//   import { createDrizzleDataProvider } from '@svadmin/drizzle';
+
+export { createDrizzleDataProvider } from './data-provider';
+export type { RefineSQLConfig } from './data-provider';
+
+// Re-export commonly used refine-sqlx utilities for convenience
+export type {
+  SecurityConfig,
+  FeaturesConfig,
+  CacheConfig,
+  CacheAdapter,
+} from 'refine-sqlx';
+
+export {
+  SecurityGuard,
+  validateConfig,
+  validateFeaturesConfig,
+} from 'refine-sqlx';