@svadmin/core 0.50.0 → 0.53.0

package/src/provider-bundle.ts

@@ -1,3 +1,4 @@
+import { definedOptions } from './defined-options';
 import type {
   AgentProvider,
   ChatProvider,
@@ -40,50 +41,50 @@ import type {
   UpdateResult,
 } from './types';
 
-export type DataProviderInput = DataProvider | Record<string, DataProvider>;
+export type DataProviderInput=DataProvider|Record<string,DataProvider>;
 
 /**
- * 一等 Provider 配置对象。字段名与现有独立 provider API 保持一致，
- * 因此调用方可以渐进地从多个 props 迁移为一个 typed bundle。
+ * First-class provider configuration object. Field names match the existing standalone provider APIs,
+ * allowing callers to migrate gradually from multiple props to one typed bundle.
  */
 export interface ProviderBundle {
   readonly dataProvider: DataProviderInput;
-  readonly authProvider?: AuthProvider | null;
-  readonly accessControlProvider?: AccessControlProvider | null;
+  readonly authProvider?: AuthProvider|null;
+  readonly accessControlProvider?: AccessControlProvider|null;
   readonly liveProvider?: LiveProvider;
-  readonly auditLogProvider?: AuditLogProvider | null;
-  readonly notificationProvider?: NotificationProvider | null;
-  readonly chatProvider?: ChatProvider | null;
-  readonly agentProvider?: AgentProvider | null;
+  readonly auditLogProvider?: AuditLogProvider|null;
+  readonly notificationProvider?: NotificationProvider|null;
+  readonly chatProvider?: ChatProvider|null;
+  readonly agentProvider?: AgentProvider|null;
   readonly taskProvider?: TaskProvider;
   readonly routerProvider?: RouterProvider;
   readonly tenantAdapter?: TenantAdapter;
-  readonly organizationProvider?: OrganizationProvider | null;
-  readonly identityGovernanceProvider?: IdentityGovernanceProvider | null;
-  readonly sessionProvider?: SessionProvider | null;
-  readonly credentialProvider?: CredentialProvider | null;
+  readonly organizationProvider?: OrganizationProvider|null;
+  readonly identityGovernanceProvider?: IdentityGovernanceProvider|null;
+  readonly sessionProvider?: SessionProvider|null;
+  readonly credentialProvider?: CredentialProvider|null;
 }
 
-/** 保留传入对象的精确类型，同时执行 ProviderBundle 的编译期校验。 */
+/** Preserves the input object's exact type while applying compile-time ProviderBundle validation. */
 export function createProviderBundle<const TBundle extends ProviderBundle>(bundle: TBundle): TBundle {
   return bundle;
 }
 
-export type TenantId = string | number;
-export type TenantCacheIdentity = string | number;
+export type TenantId=string|number;
+export type TenantCacheIdentity=string|number;
 
-/** 请求树内的租户状态；不得通过模块级变量在 SSR 请求之间共享。 */
+/** Tenant state within a request tree; never share it between SSR requests through module-level variables. */
 export interface TenantContext {
   readonly tenantId: TenantId;
-  readonly meta?: Readonly<Record<string, unknown>>;
+  readonly meta?: Readonly<Record<string,unknown>>;
 }
 
 /**
- * 将标准 TenantContext 投影到具体后端所需的 provider meta 与 cache identity。
- * Core 始终额外写入标准 `tenantId`，adapter 不能覆盖该字段。
+ * Projects the standard TenantContext into provider metadata and cache identity for a concrete backend.
+ * Core always writes the standard `tenantId`; adapters cannot override it.
  */
 export interface TenantAdapter {
-  readonly getProviderMeta?: (tenant: TenantContext) => Readonly<Record<string, unknown>>;
+  readonly getProviderMeta?: (tenant: TenantContext) => Readonly<Record<string,unknown>>;
   readonly getCacheIdentity?: (tenant: TenantContext) => TenantCacheIdentity;
 }
 
@@ -91,38 +92,38 @@ export interface TenantCacheKey {
   readonly __svadminTenant: TenantCacheIdentity;
 }
 
-export const defaultTenantAdapter: Required<TenantAdapter> = {
-  getProviderMeta: (tenant) => tenant.meta ?? {},
+export const defaultTenantAdapter: Required<TenantAdapter>={
+  getProviderMeta: (tenant) => tenant.meta??{},
   getCacheIdentity: (tenant) => tenant.tenantId,
 };
 
 export function resolveTenantProviderMeta(
   tenant: TenantContext,
-  adapter: TenantAdapter = defaultTenantAdapter,
-): Record<string, unknown> {
+  adapter: TenantAdapter=defaultTenantAdapter,
+): Record<string,unknown> {
   return {
-    ...(tenant.meta ?? {}),
-    ...(adapter.getProviderMeta?.(tenant) ?? {}),
+    ...(tenant.meta??{}),
+    ...(adapter.getProviderMeta?.(tenant)??{}),
     tenantId: tenant.tenantId,
   };
 }
 
 export function createTenantCacheKey(
   tenant: TenantContext,
-  adapter: TenantAdapter = defaultTenantAdapter,
+  adapter: TenantAdapter=defaultTenantAdapter,
 ): TenantCacheKey {
   return {
-    __svadminTenant: adapter.getCacheIdentity?.(tenant) ?? tenant.tenantId,
+    __svadminTenant: adapter.getCacheIdentity?.(tenant)??tenant.tenantId,
   };
 }
 
 export function isTenantCacheKey(value: unknown): value is TenantCacheKey {
   return Boolean(
     value
-      && typeof value === 'object'
-      && Object.keys(value).length === 1
-      && '__svadminTenant' in value
-      && (typeof value.__svadminTenant === 'string' || typeof value.__svadminTenant === 'number'),
+    &&typeof value==='object'
+    &&Object.keys(value).length===1
+    &&'__svadminTenant' in value
+    &&(typeof value.__svadminTenant==='string'||typeof value.__svadminTenant==='number'),
   );
 }
 
@@ -132,9 +133,9 @@ export function isTenantCacheKey(value: unknown): value is TenantCacheKey {
  */
 export function appendTenantCacheKey(
   queryKey: readonly unknown[],
-  tenantCacheKey: TenantCacheKey | undefined,
+  tenantCacheKey: TenantCacheKey|undefined,
 ): readonly unknown[] {
-  return tenantCacheKey ? [...queryKey, tenantCacheKey] : queryKey;
+  return tenantCacheKey? [...queryKey,tenantCacheKey]:queryKey;
 }
 
 /**
@@ -143,64 +144,69 @@ export function appendTenantCacheKey(
  */
 export function queryKeyMatchesTenant(
   queryKey: readonly unknown[],
-  tenantCacheKey: TenantCacheKey | undefined,
+  tenantCacheKey: TenantCacheKey|undefined,
 ): boolean {
-  const candidate = queryKey.at(-1);
-  const keyTenant = isTenantCacheKey(candidate) ? candidate : undefined;
-  if (!tenantCacheKey) return keyTenant === undefined;
-  return keyTenant?.__svadminTenant === tenantCacheKey.__svadminTenant;
+  const candidate=queryKey.at(-1);
+  const keyTenant=isTenantCacheKey(candidate)? candidate:undefined;
+  if(!tenantCacheKey) return keyTenant===undefined;
+  return keyTenant?.__svadminTenant===tenantCacheKey.__svadminTenant;
 }
 
 export interface ProviderMetaInput {
   readonly resource?: string;
-  readonly meta?: Record<string, unknown>;
+  readonly meta?: Record<string,unknown>;
 }
 
-export type ProviderMetaResolver = (input: ProviderMetaInput) => Record<string, unknown> | undefined;
+export type ProviderMetaResolver=(input: ProviderMetaInput) => Record<string,unknown>|undefined;
 
 /**
- * 为 DataProvider 的所有标准操作增量注入 meta；未声明的扩展字段仍由原 provider 保留。
+ * Adds metadata to every standard DataProvider operation while preserving undeclared extension fields from the original provider.
  */
-export function withProviderMeta(provider: DataProvider, resolveMeta: ProviderMetaResolver): DataProvider {
-  const adapted: DataProvider = {
+export function withProviderMeta(provider: DataProvider,resolveMeta: ProviderMetaResolver): DataProvider {
+  function resolvedParams<P extends ProviderMetaInput>(params: P) {
+    const { meta: _meta,...rest }=params;
+    return { ...rest,...definedOptions({ meta: resolveMeta(params) }) };
+  }
+
+  const adapted: DataProvider={
     ...provider,
-    getList: <TData extends BaseRecord = BaseRecord>(params: GetListParams): Promise<GetListResult<TData>> =>
-      provider.getList<TData>({ ...params, meta: resolveMeta(params) }),
-    getOne: <TData extends BaseRecord = BaseRecord>(params: GetOneParams): Promise<GetOneResult<TData>> =>
-      provider.getOne<TData>({ ...params, meta: resolveMeta(params) }),
-    create: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateParams<TVariables>): Promise<CreateResult<TData>> =>
-      provider.create<TData, TVariables>({ ...params, meta: resolveMeta(params) }),
-    update: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateParams<TVariables>): Promise<UpdateResult<TData>> =>
-      provider.update<TData, TVariables>({ ...params, meta: resolveMeta(params) }),
-    deleteOne: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteParams<TVariables>): Promise<DeleteResult<TData>> =>
-      provider.deleteOne<TData, TVariables>({ ...params, meta: resolveMeta(params) }),
+    getList: (params: GetListParams): Promise<GetListResult<BaseRecord>> =>
+      provider.getList(resolvedParams(params)),
+    getOne: (params: GetOneParams): Promise<GetOneResult<BaseRecord>> =>
+      provider.getOne(resolvedParams(params)),
+    create: (params: CreateParams<unknown>): Promise<CreateResult<BaseRecord>> =>
+      provider.create(resolvedParams(params)),
+    update: (params: UpdateParams<unknown>): Promise<UpdateResult<BaseRecord>> =>
+      provider.update(resolvedParams(params)),
+    deleteOne: (params: DeleteParams<unknown>): Promise<DeleteResult<BaseRecord>> =>
+      provider.deleteOne(resolvedParams(params)),
     getApiUrl: () => provider.getApiUrl(),
   };
 
-  const getMany = provider.getMany?.bind(provider);
-  if (getMany) {
-    adapted.getMany = <TData extends BaseRecord = BaseRecord>(params: GetManyParams): Promise<GetManyResult<TData>> =>
-      getMany<TData>({ ...params, meta: resolveMeta(params) });
+  const getMany=provider.getMany?.bind(provider);
+  if(getMany) {
+    adapted.getMany=(params: GetManyParams): Promise<GetManyResult<BaseRecord>> =>
+      getMany(resolvedParams(params));
   }
-  const createMany = provider.createMany?.bind(provider);
-  if (createMany) {
-    adapted.createMany = <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateManyParams<TVariables>): Promise<CreateManyResult<TData>> =>
-      createMany<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  const createMany=provider.createMany?.bind(provider);
+  if(createMany) {
+    adapted.createMany=(params: CreateManyParams<unknown>): Promise<CreateManyResult<BaseRecord>> =>
+      createMany(resolvedParams(params));
   }
-  const updateMany = provider.updateMany?.bind(provider);
-  if (updateMany) {
-    adapted.updateMany = <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateManyParams<TVariables>): Promise<UpdateManyResult<TData>> =>
-      updateMany<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  const updateMany=provider.updateMany?.bind(provider);
+  if(updateMany) {
+    adapted.updateMany=(params: UpdateManyParams<unknown>): Promise<UpdateManyResult<BaseRecord>> =>
+      updateMany(resolvedParams(params));
   }
-  const deleteMany = provider.deleteMany?.bind(provider);
-  if (deleteMany) {
-    adapted.deleteMany = <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteManyParams<TVariables>): Promise<DeleteManyResult<TData>> =>
-      deleteMany<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  const deleteMany=provider.deleteMany?.bind(provider);
+  if(deleteMany) {
+    adapted.deleteMany=(params: DeleteManyParams<unknown>): Promise<DeleteManyResult<BaseRecord>> =>
+      deleteMany(resolvedParams(params));
   }
-  const custom = provider.custom?.bind(provider);
-  if (custom) {
-    adapted.custom = <TData = unknown, TVariables = unknown>(params: CustomParams<TVariables>): Promise<CustomResult<TData>> =>
-      custom<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  const custom=provider.custom?.bind(provider);
+  if(custom) {
+    adapted.custom=(params: CustomParams<unknown>): Promise<CustomResult> =>
+      custom(resolvedParams(params));
   }
 
   return adapted;
@@ -209,10 +215,10 @@ export function withProviderMeta(provider: DataProvider, resolveMeta: ProviderMe
 export function withTenantDataProvider(
   provider: DataProvider,
   tenant: TenantContext,
-  adapter: TenantAdapter = defaultTenantAdapter,
+  adapter: TenantAdapter=defaultTenantAdapter,
 ): DataProvider {
-  return withProviderMeta(provider, ({ meta }) => ({
-    ...(meta ?? {}),
-    ...resolveTenantProviderMeta(tenant, adapter),
+  return withProviderMeta(provider,({ meta }) => ({
+    ...(meta??{}),
+    ...resolveTenantProviderMeta(tenant,adapter),
   }));
 }

package/src/provider-response.ts

@@ -0,0 +1,35 @@
+import type { DataProvider } from './types';
+import { decodeBaseRecord, decodeOneResult, decodeManyResult, decodeListResult, decodeCustomResult } from './record-decoder';
+
+type UntrustedResponse<F> = F extends (...params: infer P) => Promise<unknown>
+  ? (...params: P) => Promise<unknown> : F;
+
+/** Transport implementations cannot claim a response shape before validation. */
+export type DataTransport = { [K in keyof DataProvider]: UntrustedResponse<DataProvider[K]> };
+
+export function withValidatedResponses(transport: DataTransport): DataProvider {
+  const {
+    getMany: rawGetMany, createMany: rawCreateMany, updateMany: rawUpdateMany,
+    deleteMany: rawDeleteMany, custom: rawCustom, ...required
+  } = transport;
+  const provider: DataProvider = {
+    ...required,
+    getApiUrl: () => transport.getApiUrl(),
+    getList: async params => decodeListResult(await transport.getList(params), decodeBaseRecord),
+    getOne: async params => decodeOneResult(await transport.getOne(params), decodeBaseRecord),
+    create: async params => decodeOneResult(await transport.create(params), decodeBaseRecord, true),
+    update: async params => decodeOneResult(await transport.update(params), decodeBaseRecord, true),
+    deleteOne: async params => decodeOneResult(await transport.deleteOne(params), decodeBaseRecord, true),
+  };
+  const getMany = rawGetMany?.bind(transport);
+  if (getMany) provider.getMany = async params => decodeManyResult(await getMany(params), decodeBaseRecord);
+  const createMany = rawCreateMany?.bind(transport);
+  if (createMany) provider.createMany = async params => decodeManyResult(await createMany(params), decodeBaseRecord, true);
+  const updateMany = rawUpdateMany?.bind(transport);
+  if (updateMany) provider.updateMany = async params => decodeManyResult(await updateMany(params), decodeBaseRecord, true);
+  const deleteMany = rawDeleteMany?.bind(transport);
+  if (deleteMany) provider.deleteMany = async params => decodeManyResult(await deleteMany(params), decodeBaseRecord, true);
+  const custom = rawCustom?.bind(transport);
+  if (custom) provider.custom = async params => decodeCustomResult(await custom(params), params.method !== 'get');
+  return provider;
+}