@svadmin/drizzle 0.11.16 → 0.12.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/drizzle",
-  "version": "0.11.16",
+  "version": "0.12.6",
   "description": "Drizzle ORM DataProvider — SQLite, PostgreSQL, MySQL, Cloudflare D1 via refine-sqlx",
   "type": "module",
   "sideEffects": false,
@@ -20,14 +20,19 @@
     }
   },
   "peerDependencies": {
-    "@svadmin/core": "^0.50.0",
+    "@svadmin/core": "^0.52.0",
+    "drizzle-orm": "^1.0.0-rc.1",
     "refine-sqlx": "^0.10.3"
   },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.52",
+    "@svadmin/refine-adapter": "^0.11.6"
+  },
   "license": "MIT",
   "author": "zuohuadong",
   "repository": {
     "type": "git",
-    "url": "https://github.com/vibeunion/svadmin.git",
+    "url": "git+https://github.com/vibeunion/svadmin.git",
     "directory": "packages/drizzle"
   },
   "homepage": "https://github.com/vibeunion/svadmin#readme",
@@ -35,7 +40,11 @@
     "url": "https://github.com/vibeunion/svadmin/issues"
   },
   "devDependencies": {
+    "@cloudflare/workers-types": "^5.20260908.1",
+    "@types/better-sqlite3": "^9.6.0",
     "drizzle-orm": "^1.0.0-rc.1",
+    "mysql2": "^3.24.4",
+    "postgres": "^3.4.9",
     "refine-sqlx": "^0.10.3"
   },
   "peerDependenciesMeta": {

package/src/column-metadata.ts

@@ -0,0 +1,45 @@
+import { Type, type Static } from '@sinclair/typebox';
+import { createExactSchemaValidator } from '@svadmin/core/schema';
+
+const columnSchema = Type.Object({
+  name: Type.String({ minLength: 1 }),
+  dataType: Type.String({ minLength: 1 }),
+  columnType: Type.String({ minLength: 1 }),
+  notNull: Type.Boolean(),
+  hasDefault: Type.Boolean(),
+  primary: Type.Boolean(),
+  enumValues: Type.Optional(Type.Array(Type.String())),
+});
+const columnValidator = createExactSchemaValidator(columnSchema);
+
+export type ColumnMetadata = Static<typeof columnSchema>;
+
+function isObject(value: unknown): value is Record<PropertyKey, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** Project only consumed metadata; Drizzle columns contain circular table links. */
+export function decodeColumnMetadata(value: unknown): ColumnMetadata {
+  if (!isObject(value)) throw new TypeError('Invalid Drizzle column metadata');
+  const candidate = {
+    name: value['name'],
+    dataType: value['dataType'],
+    columnType: value['columnType'],
+    notNull: value['notNull'],
+    hasDefault: value['hasDefault'],
+    primary: value['primary'],
+    ...(value['enumValues'] === undefined ? {} : { enumValues: value['enumValues'] }),
+  };
+  if (!columnValidator.Check(candidate)) {
+    throw new TypeError('Invalid Drizzle column metadata');
+  }
+  return {
+    ...candidate,
+    ...(candidate.enumValues === undefined ? {} : { enumValues: [...candidate.enumValues] }),
+  };
+}
+
+export function decodeColumns(value: unknown): [string, ColumnMetadata][] {
+  if (!isObject(value)) throw new TypeError('Invalid Drizzle table columns');
+  return Object.entries(value).map(([key, column]) => [key, decodeColumnMetadata(column)]);
+}

package/src/data-provider.ts

@@ -16,6 +16,7 @@
  */
 
 import type { DataProvider } from '@svadmin/core';
+import { createRefineAdapter } from '@svadmin/refine-adapter';
 import type { RefineSQLConfig } from 'refine-sqlx';
 import { createRefineSQL } from 'refine-sqlx';
 
@@ -25,8 +26,8 @@ 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.
+ * The shared adapter validates method availability and every response envelope
+ * before database results enter the application's typed data layer.
  *
  * @param config - refine-sqlx configuration (connection, schema, features, etc.)
  * @returns A @svadmin/core DataProvider
@@ -54,18 +55,6 @@ export type { RefineSQLConfig } from 'refine-sqlx';
 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;
+  const provider: unknown = await createRefineSQL(config);
+  return createRefineAdapter(provider);
 }

package/src/infer-fields.ts

@@ -15,24 +15,9 @@
  */
 
 import type { FieldDefinition } from '@svadmin/core';
-
-/** Drizzle column shape (duck-typed to avoid version coupling) */
-interface DrizzleColumnLike {
-  dataType?: string;
-  columnType?: string;
-  name?: string;
-  notNull?: boolean;
-  hasDefault?: boolean;
-  default?: unknown;
-  primary?: boolean;
-  enumValues?: string[];
-}
-
-/** Drizzle table shape (duck-typed — works with any Drizzle table object) */
-interface DrizzleTableLike {
-  [Symbol.iterator]?: never;
-  _?: { columns?: Record<string, DrizzleColumnLike> };
-}
+import { getTableColumns } from 'drizzle-orm/utils';
+import { isTable, type Table } from 'drizzle-orm/table';
+import { decodeColumns, type ColumnMetadata } from './column-metadata';
 
 /** Options for field inference */
 export interface InferFieldsOptions {
@@ -49,11 +34,13 @@ export interface InferFieldsOptions {
 /**
  * Map a Drizzle column type string to a svadmin FieldDefinition type.
  */
-function mapColumnType(col: DrizzleColumnLike): FieldDefinition['type'] {
-  const dt = (col.dataType ?? col.columnType ?? '').toLowerCase();
+function mapColumnType(col: ColumnMetadata): FieldDefinition['type'] {
+  const dt = `${col.dataType} ${col.columnType}`.toLowerCase();
 
   // Integer / serial / numeric types
-  if (dt.includes('int') || dt.includes('serial') || dt.includes('numeric') || dt.includes('real') || dt.includes('float') || dt.includes('double') || dt.includes('decimal')) {
+  if (col.dataType.includes('bool')) return 'boolean';
+  if (col.dataType.includes('date')) return 'date';
+  if (dt.includes('int') || dt.includes('serial') || dt.includes('numeric') || dt.includes('real') || dt.includes('float') || dt.includes('double') || dt.includes('decimal') || dt.includes('number')) {
     return 'number';
   }
   // Boolean
@@ -90,37 +77,18 @@ function humanizeKey(key: string): string {
 /**
  * Infer FieldDefinition[] from a Drizzle ORM table schema.
  *
- * Works with any Drizzle table (SQLite, PostgreSQL, MySQL) that exposes
- * the internal `_` metadata with column definitions.
+ * Uses Drizzle's runtime column API; `_` is type-only metadata, not a table
+ * property. Malformed column metadata is rejected before deriving UI fields.
  */
 export function inferFieldsFromDrizzle(
-  table: DrizzleTableLike,
+  table: Table,
   options: InferFieldsOptions = {},
 ): FieldDefinition[] {
-  const columns = (table as Record<string, unknown>)?._ 
-    ? ((table as Record<string, unknown>)._ as Record<string, unknown>)?.columns as Record<string, DrizzleColumnLike> | undefined
-    : undefined;
-
-  if (!columns) {
-    // Fallback: try to iterate over table keys that look like columns
-    const result: FieldDefinition[] = [];
-    for (const [key, val] of Object.entries(table as Record<string, unknown>)) {
-      if (key.startsWith('_') || typeof val === 'function') continue;
-      if (options.exclude?.includes(key)) continue;
-      
-      const col = val as DrizzleColumnLike;
-      if (!col || typeof col !== 'object') continue;
-      
-      // Check if it looks like a Drizzle column (has dataType or columnType)
-      if (!col.dataType && !col.columnType) continue;
-
-      result.push(buildField(key, col, options));
-    }
-    return result;
-  }
+  if (!isTable(table)) throw new TypeError('Expected a Drizzle table');
+  const columns: unknown = getTableColumns(table);
 
   const fields: FieldDefinition[] = [];
-  for (const [key, col] of Object.entries(columns)) {
+  for (const [key, col] of decodeColumns(columns)) {
     if (options.exclude?.includes(key)) continue;
     fields.push(buildField(key, col, options));
   }
@@ -129,12 +97,12 @@ export function inferFieldsFromDrizzle(
 
 function buildField(
   key: string,
-  col: DrizzleColumnLike,
+  col: ColumnMetadata,
   options: InferFieldsOptions,
 ): FieldDefinition {
   const type = mapColumnType(col);
   const field: FieldDefinition = {
-    key: col.name ?? key,
+    key,
     label: options.labels?.[key] ?? humanizeKey(key),
     type,
     required: col.notNull === true && !col.hasDefault,