@svadmin/refine-adapter 0.12.15 → 0.14.1

package/README.md

@@ -1,6 +1,6 @@
 # @svadmin/refine-adapter
 
-> Bridge any [@refinedev](https://github.com/refinedev/refine) data provider to svadmin
+> Bridge [@refinedev](https://github.com/refinedev/refine) data and framework providers to svadmin
 
 [![npm](https://img.shields.io/npm/v/@svadmin/refine-adapter?color=ff3e00&label=npm)](https://www.npmjs.com/package/@svadmin/refine-adapter)
 
@@ -66,6 +66,36 @@ Then pass `dataProvider` to `<AdminApp>` or `setDataProvider()` as usual.
 
 Optional methods are only wired if the underlying Refine provider implements them.
 
+## Other Refine providers
+
+```typescript
+import {
+  createRefineAuthAdapter,
+  createRefineAccessControlAdapter,
+  createRefineNotificationAdapter,
+  createRefineLiveAdapter,
+  createRefineRouterAdapter,
+  createRefineI18nAdapter,
+} from '@svadmin/refine-adapter';
+
+const authProvider = createRefineAuthAdapter(refineAuthProvider);
+const accessControlProvider = createRefineAccessControlAdapter(refineAccessControlProvider);
+const notificationProvider = createRefineNotificationAdapter(refineNotificationProvider);
+const liveProvider = createRefineLiveAdapter(refineLiveProvider);
+const routerProvider = createRefineRouterAdapter(refineRouterProvider);
+const i18nProvider = createRefineI18nAdapter(refineI18nProvider);
+```
+
+Router adapters resolve Refine's function-generator bindings at call time. I18n
+adapters normalize translations to strings and map `changeLocale` to
+`setLocale`.
+
+## UI boundary
+
+Like Refine, this package keeps the core headless. It does not ship Table,
+Upload, DatePicker, Modal/Drawer, or form components. Those stay in the UI layer
+or host application, while Refine-style provider contracts stay in core.
+
 ## Which Svadmin Providers Use This?
 
 The following `@svadmin/*` packages internally use `@svadmin/refine-adapter` to bridge their corresponding `@refinedev/*` provider:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/refine-adapter",
-  "version": "0.12.15",
+  "version": "0.14.1",
   "description": "Universal Refine DataProvider adapter for svadmin",
   "type": "module",
   "sideEffects": false,
@@ -20,7 +20,7 @@
     }
   },
   "peerDependencies": {
-    "@svadmin/core": "^0.67.0"
+    "@svadmin/core": "^0.69.2"
   },
   "license": "MIT",
   "repository": {

package/src/access-control.ts

@@ -0,0 +1,49 @@
+/**
+ * Refine AccessControlProvider → svadmin AccessControlProvider.
+ *
+ * Browser checks remain UI hints; the backend must enforce the same policy.
+ */
+import type { AccessControlProvider, CanParams, CanResult } from '@svadmin/core';
+import { decodeCanResult } from '@svadmin/core/contracts';
+import { definedOptions } from '@svadmin/core/options';
+
+type RefineCan = (params: { resource: string; action: string; params?: CanParams['params']; meta?: Record<string, unknown> }) => Promise<unknown>;
+type RefineAccessSource = {
+  can?: RefineCan;
+  canMany?: (params: readonly { resource: string; action: string; params?: CanParams['params']; meta?: Record<string, unknown> }[]) => Promise<unknown>;
+  options?: unknown;
+};
+
+function normalizeParams(params: CanParams) {
+  return {
+    resource: params.resource,
+    action: params.action,
+    ...(params.params === undefined ? {} : { params: params.params }),
+    ...(params.meta === undefined ? {} : { meta: params.meta }),
+  };
+}
+
+/** Register the adapter with `setAccessControlProvider` after creation. */
+export function createRefineAccessControlAdapter(source: unknown): AccessControlProvider {
+  if (typeof source !== 'object' || source === null || typeof (source as RefineAccessSource).can !== 'function') {
+    throw new TypeError('createRefineAccessControlAdapter: expected a can() method');
+  }
+  const input = source as RefineAccessSource;
+  const can = input.can as RefineCan;
+  const canMany = input.canMany;
+  const options = typeof input.options === 'object' && input.options !== null
+    ? input.options as NonNullable<AccessControlProvider['options']> : undefined;
+  return {
+    can: async (params: CanParams): Promise<CanResult> => decodeCanResult(await can.call(input, normalizeParams(params))),
+    ...(typeof canMany === 'function' ? {
+      canMany: async (params: readonly CanParams[]): Promise<CanResult[]> => {
+        const results = await canMany.call(input, params.map(normalizeParams));
+        if (!Array.isArray(results) || results.length !== params.length) {
+          throw new TypeError('Invalid access control batch response');
+        }
+        return results.map((result) => decodeCanResult(result));
+      },
+    } : {}),
+    ...definedOptions({ options }),
+  };
+}

package/src/auth.ts

@@ -0,0 +1,85 @@
+/**
+ * Refine AuthProvider → svadmin AuthProvider.
+ *
+ * Refine's auth contract is structurally close to svadmin's, so this adapter only
+ * normalizes results through the same validated decoders used by first-party
+ * providers. Optional methods are forwarded only when the source implements them.
+ */
+import type {
+  AuthActionResult,
+  AuthErrorResult,
+  AuthProvider,
+  CheckResult,
+  Identity,
+} from '@svadmin/core';
+import {
+  decodeAuthAction,
+  decodeAuthCheck,
+  decodeAuthErrorResult,
+  decodeIdentity,
+} from '@svadmin/core/contracts';
+
+type RefineAuthSource = Partial<Record<
+  | 'login' | 'logout' | 'check' | 'getIdentity' | 'getPermissions'
+  | 'register' | 'forgotPassword' | 'updatePassword' | 'onError',
+  (...args: never[]) => unknown
+>>;
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function method<T extends (...args: never[]) => unknown>(source: RefineAuthSource, name: keyof RefineAuthSource): T | undefined {
+  const value = source[name];
+  return typeof value === 'function' ? value as T : undefined;
+}
+
+function actionResult(value: unknown): AuthActionResult {
+  if (isObject(value) && value['success'] === true) {
+    return decodeAuthAction({
+      success: true,
+      ...(typeof value['redirectTo'] === 'string' ? { redirectTo: value['redirectTo'] } : {}),
+    });
+  }
+  const rawError = isObject(value) ? value['error'] : undefined;
+  const error = isObject(rawError)
+    ? {
+      message: typeof rawError['message'] === 'string' ? rawError['message'] : 'Authentication failed',
+      ...(typeof rawError['name'] === 'string' ? { name: rawError['name'] } : {}),
+    }
+    : { message: 'Authentication failed' };
+  return decodeAuthAction({ success: false, error });
+}
+
+function call<A extends unknown[], R>(source: RefineAuthSource, name: keyof RefineAuthSource, args: A): Promise<R> {
+  const fn = method<(...input: A) => Promise<R> | R>(source, name);
+  if (!fn) throw new TypeError(`Refine AuthProvider is missing "${String(name)}"`);
+  return Promise.resolve(fn.apply(source, args));
+}
+
+/** Validate that the source exposes the methods svadmin requires before mounting it. */
+export function createRefineAuthAdapter(source: unknown): AuthProvider {
+  if (!isObject(source) || typeof source['login'] !== 'function' ||
+    typeof source['logout'] !== 'function' || typeof source['check'] !== 'function' ||
+    typeof source['getIdentity'] !== 'function') {
+    throw new TypeError('createRefineAuthAdapter: expected login, logout, check, and getIdentity');
+  }
+  const input = source as RefineAuthSource;
+  const register = method(input, 'register');
+  const forgotPassword = method(input, 'forgotPassword');
+  const updatePassword = method(input, 'updatePassword');
+  const getPermissions = method(input, 'getPermissions');
+  const onError = method(input, 'onError');
+
+  return {
+    login: async (params): Promise<AuthActionResult> => actionResult(await call(input, 'login', [params])),
+    logout: async (params): Promise<AuthActionResult> => actionResult(await call(input, 'logout', [params ?? {}])),
+    check: async (params): Promise<CheckResult> => decodeAuthCheck(await call(input, 'check', [params ?? {}])),
+    getIdentity: async (): Promise<Identity | null> => decodeIdentity(await call(input, 'getIdentity', [])),
+    ...(register ? { register: async (params: Record<string, unknown>) => actionResult(await call(input, 'register', [params])) } : {}),
+    ...(forgotPassword ? { forgotPassword: async (params: Record<string, unknown>) => actionResult(await call(input, 'forgotPassword', [params])) } : {}),
+    ...(updatePassword ? { updatePassword: async (params: Record<string, unknown>) => actionResult(await call(input, 'updatePassword', [params])) } : {}),
+    ...(getPermissions ? { getPermissions: async (params?: Record<string, unknown>) => call(input, 'getPermissions', [params]) } : {}),
+    ...(onError ? { onError: async (error: unknown): Promise<AuthErrorResult> => decodeAuthErrorResult(await call(input, 'onError', [error])) } : {}),
+  };
+}

package/src/i18n.ts

@@ -0,0 +1,45 @@
+/**
+ * Refine I18nProvider → svadmin I18nProvider.
+ *
+ * Refine's provider is imperative and may return non-string translations.
+ * svadmin keeps translation returns strictly string-shaped at the boundary.
+ */
+import type { I18nProvider } from '@svadmin/core';
+
+type RefineI18nSource = {
+  translate?: (key: string, options?: unknown, defaultMessage?: string) => unknown;
+  changeLocale?: (locale: string, options?: unknown) => unknown;
+  getLocale?: () => unknown;
+};
+
+function isObject(value: unknown): value is Record<PropertyKey, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+export function createRefineI18nAdapter(source: unknown): I18nProvider {
+  if (!isObject(source)) {
+    throw new TypeError('[svadmin] createRefineI18nAdapter: expected a Refine I18nProvider object');
+  }
+  const i18n = source as RefineI18nSource;
+  if (typeof i18n.translate !== 'function'
+    || typeof i18n.changeLocale !== 'function'
+    || typeof i18n.getLocale !== 'function') {
+    throw new TypeError('createRefineI18nAdapter: expected translate, changeLocale and getLocale');
+  }
+
+  return {
+    translate(key, params) {
+      const value = i18n.translate?.(key, params, key);
+      if (typeof value !== 'string') throw new TypeError('Refine I18nProvider translate() must return a string');
+      return value;
+    },
+    getLocale() {
+      const value = i18n.getLocale?.();
+      if (typeof value !== 'string') throw new TypeError('Refine I18nProvider getLocale() must return a string');
+      return value;
+    },
+    setLocale(locale) {
+      void i18n.changeLocale?.(locale);
+    },
+  };
+}

package/src/index.ts

@@ -95,3 +95,10 @@ export function createRefineAdapter(refineProvider: unknown): SvadminDataProvide
 
   return withValidatedResponses(transport);
 }
+
+export { createRefineAuthAdapter } from './auth';
+export { createRefineAccessControlAdapter } from './access-control';
+export { createRefineNotificationAdapter } from './notification';
+export { createRefineLiveAdapter } from './live';
+export { createRefineRouterAdapter } from './router';
+export { createRefineI18nAdapter } from './i18n';

package/src/live.ts

@@ -0,0 +1,85 @@
+/**
+ * Refine LiveProvider → svadmin LiveProvider.
+ *
+ * Refine emits `created | updated | deleted` while svadmin uses
+ * `INSERT | UPDATE | DELETE`. Channels map to svadmin resources.
+ */
+import type { LiveEvent, LiveProvider } from '@svadmin/core';
+import { snapshotLiveEvent } from '@svadmin/core/contracts';
+
+type RefineEventType = 'created' | 'updated' | 'deleted' | string;
+type RefineLiveEvent = {
+  type: RefineEventType;
+  channel: string;
+  payload?: unknown;
+  date?: Date | string;
+};
+type RefineLiveSource = {
+  subscribe: (params: {
+    channel: string;
+    types?: RefineEventType[];
+    params?: Record<string, unknown>;
+    callback: (event: RefineLiveEvent) => void;
+    onError?: (error: unknown) => void;
+  }) => unknown;
+  unsubscribe?: (params: { channel: string; params?: Record<string, unknown> }) => void;
+  publish?: (event: RefineLiveEvent) => unknown;
+};
+
+const toEventType: Record<string, LiveEvent['type']> = {
+  created: 'INSERT', updated: 'UPDATE', deleted: 'DELETE',
+  INSERT: 'INSERT', UPDATE: 'UPDATE', DELETE: 'DELETE',
+};
+const fromEventType: Record<LiveEvent['type'], RefineEventType> = {
+  INSERT: 'created', UPDATE: 'updated', DELETE: 'deleted',
+};
+
+function toLiveEvent(event: RefineLiveEvent, resource: string): LiveEvent | undefined {
+  const type = toEventType[String(event.type)];
+  if (!type) return undefined;
+  const payload = typeof event.payload === 'object' && event.payload !== null
+    ? event.payload as Record<string, unknown>
+    : {};
+  return snapshotLiveEvent({ type, resource, payload });
+}
+
+export function createRefineLiveAdapter(source: unknown): LiveProvider {
+  if (typeof source !== 'object' || source === null || typeof (source as RefineLiveSource).subscribe !== 'function') {
+    throw new TypeError('createRefineLiveAdapter: expected a subscribe() method');
+  }
+  const input = source as RefineLiveSource;
+  return {
+    subscribe: ({ resource, liveParams, callback }) => {
+      const dispose = input.subscribe.call(input, {
+        channel: resource,
+        ...(liveParams === undefined ? {} : { params: liveParams }),
+        callback: (event) => {
+          if (typeof event !== 'object' || event === null) return;
+          const decoded = toLiveEvent(event, resource);
+          if (decoded) callback(decoded);
+        },
+      });
+      return typeof dispose === 'function' ? dispose as () => void : () => {};
+    },
+    ...(typeof input.unsubscribe === 'function' ? {
+      unsubscribe: (params: { resource: string; liveParams?: Record<string, unknown> }) => {
+        input.unsubscribe?.call(input, {
+          channel: params.resource,
+          ...(params.liveParams === undefined ? {} : { params: params.liveParams }),
+        });
+      },
+    } : {}),
+    ...(typeof input.publish === 'function' ? {
+      publish: (event: LiveEvent) => {
+        const checked = snapshotLiveEvent(event);
+        if (!checked) throw new TypeError('Invalid live event');
+        void input.publish?.call(input, {
+          channel: checked.resource,
+          type: fromEventType[checked.type],
+          payload: checked.payload,
+          date: new Date(),
+        });
+      },
+    } : {}),
+  };
+}

package/src/notification.ts

@@ -0,0 +1,30 @@
+/**
+ * Refine NotificationProvider → svadmin NotificationProvider.
+ *
+ * Refine allows extra fields such as `undoable`; svadmin keeps the checked
+ * message envelope and ignores provider-specific extras.
+ */
+import type { NotificationProvider } from '@svadmin/core';
+
+type RefineNotificationSource = {
+  open?: (params: { type: string; message: string; description?: string; key?: string }) => unknown;
+  close?: (key: string) => unknown;
+};
+
+const types = new Set(['success', 'error', 'warning', 'info']);
+
+export function createRefineNotificationAdapter(source: unknown): NotificationProvider {
+  if (typeof source !== 'object' || source === null ||
+    typeof (source as RefineNotificationSource).open !== 'function' ||
+    typeof (source as RefineNotificationSource).close !== 'function') {
+    throw new TypeError('createRefineNotificationAdapter: expected open() and close()');
+  }
+  const input = source as Required<RefineNotificationSource>;
+  return {
+    open: (params) => {
+      if (!types.has(params.type)) throw new TypeError('Invalid notification type');
+      input.open.call(source, params);
+    },
+    close: (key) => { input.close.call(source, key); },
+  };
+}

package/src/refinedev-optional.d.ts

@@ -57,3 +57,17 @@ declare module '@refinedev/supabase' {
   const defaultExport: (...args: unknown[]) => unknown;
   export default defaultExport;
 }
+
+declare module '@refinedev/parse' {
+  export const createDataProvider: (...args: unknown[]) => unknown;
+  export const dataProvider: (...args: unknown[]) => unknown;
+  const defaultExport: (...args: unknown[]) => unknown;
+  export default defaultExport;
+}
+
+declare module '@refinedev/strapi-graphql' {
+  export const createDataProvider: (...args: unknown[]) => unknown;
+  export const dataProvider: (...args: unknown[]) => unknown;
+  const defaultExport: (...args: unknown[]) => unknown;
+  export default defaultExport;
+}

package/src/router.ts

@@ -0,0 +1,89 @@
+/**
+ * Refine RouterProvider → svadmin RouterProvider.
+ *
+ * Refine exposes router bindings as function generators so UI packages can use
+ * hooks inside `go`, `back` and `parse`. svadmin consumes plain functions, so
+ * this adapter resolves the generators once per call and normalizes the result.
+ */
+import type { RouterProvider } from '@svadmin/core';
+
+type RefineGoConfig = {
+  to?: string;
+  query?: Record<string, unknown>;
+  hash?: string;
+  type?: 'push' | 'replace' | 'path';
+};
+
+type RefineParsed = {
+  resource?: { name?: string; identifier?: string } | string;
+  action?: string;
+  id?: string | number;
+  params?: Record<string, unknown>;
+  pathname?: string;
+};
+
+type RefineRouterSource = {
+  go?: () => ((config: RefineGoConfig) => unknown);
+  back?: () => (() => unknown);
+  parse?: () => (() => RefineParsed);
+};
+
+function isObject(value: unknown): value is Record<PropertyKey, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function queryRecord(query: Record<string, string> | undefined): Record<string, unknown> | undefined {
+  if (!query) return undefined;
+  return Object.fromEntries(Object.entries(query).map(([key, value]) => [key, value]));
+}
+
+function resourceName(resource: RefineParsed['resource']): string | undefined {
+  if (typeof resource === 'string') return resource;
+  return resource?.identifier ?? resource?.name;
+}
+
+export function createRefineRouterAdapter(source: unknown): RouterProvider {
+  if (!isObject(source)) {
+    throw new TypeError('[svadmin] createRefineRouterAdapter: expected a Refine RouterProvider object');
+  }
+  const router = source as RefineRouterSource;
+
+  return {
+    go({ to, query, hash, type }) {
+      if (!router.go) return false;
+      const go = router.go();
+      if (typeof go !== 'function') throw new TypeError('Refine RouterProvider go() must return a function');
+      const normalizedType = type === 'replace' ? 'replace' : 'push';
+      const queryValue = queryRecord(query);
+      const result = go({
+        ...(to === undefined ? {} : { to }),
+        ...(queryValue === undefined ? {} : { query: queryValue }),
+        ...(hash === undefined ? {} : { hash }),
+        type: normalizedType,
+      });
+      if (typeof result === 'string') return false;
+      return;
+    },
+    back() {
+      if (!router.back) return;
+      const back = router.back();
+      if (typeof back !== 'function') throw new TypeError('Refine RouterProvider back() must return a function');
+      back();
+    },
+    parse() {
+      if (!router.parse) return { params: {}, pathname: '/' };
+      const parse = router.parse();
+      if (typeof parse !== 'function') throw new TypeError('Refine RouterProvider parse() must return a function');
+      const parsed = parse();
+      const params = Object.fromEntries(Object.entries(parsed.params ?? {}).map(([key, value]) => [key, String(value)]));
+      const resource = resourceName(parsed.resource);
+      return {
+        ...(resource === undefined ? {} : { resource }),
+        ...(parsed.action === undefined ? {} : { action: String(parsed.action) }),
+        ...(parsed.id === undefined ? {} : { id: String(parsed.id) }),
+        params,
+        pathname: typeof parsed.pathname === 'string' ? parsed.pathname : '/',
+      };
+    },
+  };
+}