@svadmin/core 0.42.1 → 0.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.42.1",
+  "version": "0.45.0",
   "author": "zuohuadong",
   "repository": {
     "type": "git",
@@ -9,20 +9,20 @@
   },
   "main": "src/index.ts",
   "devDependencies": {
-    "@happy-dom/global-registrator": "^20.11.2",
+    "@happy-dom/global-registrator": "^20.11.12",
     "@sveltejs/vite-plugin-svelte": "^7.3.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/svelte": "^5.4.2",
-    "@testing-library/user-event": "^14.6.4",
+    "@testing-library/user-event": "^14.6.6",
     "@types/bun": "^1.4.0",
     "@types/jsdom": "^30.0.0",
-    "happy-dom": "^20.11.2",
+    "happy-dom": "^20.11.12",
     "jsdom": "^30.0.1",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.11"
   },
   "peerDependencies": {
-    "svelte": "^5.56.8",
-    "@tanstack/svelte-query": "^6.1.38"
+    "svelte": "^5.56.10",
+    "@tanstack/svelte-query": "^6.1.48"
   },
   "exports": {
     ".": {
@@ -56,6 +56,18 @@
     "./theme": {
       "types": "./src/theme.svelte.ts",
       "default": "./src/theme.svelte.ts"
+    },
+    "./inferencer": {
+      "types": "./src/inferencer.ts",
+      "default": "./src/inferencer.ts"
+    },
+    "./inferencer-openapi": {
+      "types": "./src/inferencer-openapi.ts",
+      "default": "./src/inferencer-openapi.ts"
+    },
+    "./inferencer-graphql": {
+      "types": "./src/inferencer-graphql.ts",
+      "default": "./src/inferencer-graphql.ts"
     }
   },
   "bugs": {

package/src/audit.ts

@@ -1,10 +1,13 @@
 // Audit logging — record admin operations
 // Full AuditLogProvider interface
 
+export type AuditAction = 'create' | 'update' | 'delete' | 'login' | 'logout' | 'rollback' | 'undo' | (string & {});
+
 export interface AuditEntry {
   id?: string | number;
   timestamp: string;
-  action: 'create' | 'update' | 'delete' | 'login' | 'logout';
+  action: AuditAction;
+  mutationId?: string;
   resource?: string;
   recordId?: string | number;
   userId?: string;
@@ -136,3 +139,41 @@ export async function writeAuditEntry(
     },
   });
 }
+
+/**
+ * 记录乐观变更回滚或撤回事件至审计流。
+ * 将前序状态快照与回滚原因作为不可变事实写入审计。
+ */
+export async function recordMutationRollback(
+  params: {
+    resource: string;
+    recordId?: string | number;
+    mutationId?: string;
+    previousData?: Record<string, unknown>;
+    currentData?: Record<string, unknown>;
+    reason?: string;
+    userId?: string;
+    tenantId?: string | number;
+    requestId?: string;
+    traceId?: string;
+  },
+  provider: AuditLogProvider | null | undefined = auditLogProvider,
+): Promise<AuditEntry> {
+  return writeAuditEntry({
+    action: 'rollback',
+    resource: params.resource,
+    recordId: params.recordId,
+    userId: params.userId,
+    tenantId: params.tenantId,
+    requestId: params.requestId,
+    traceId: params.traceId,
+    outcome: 'success',
+    previousData: params.previousData,
+    data: params.currentData,
+    meta: {
+      actionType: 'mutation_rollback',
+      mutationId: params.mutationId,
+      reason: params.reason,
+    },
+  }, provider);
+}

package/src/chatProvider.svelte.ts

@@ -92,6 +92,12 @@ export interface AdminTool {
    * The agent emits an `approval_request` event and waits for `approveToolCall()`.
    */
   needsApproval?: boolean;
+  /** 显式声明是否为只读操作（只读操作可并发执行，无副作用） */
+  readOnly?: boolean;
+  /** 显式声明是否为破坏性/高风险操作（默认触发 Approval Gate） */
+  destructive?: boolean;
+  /** 显式声明是否支持并发调用 */
+  concurrent?: boolean;
   /** Execute the tool with the given arguments. */
   execute(args: Record<string, unknown>): Promise<ToolResult>;
 }
@@ -224,6 +230,30 @@ export function getChatContext(): ChatContext {
   return chatContext;
 }
 
+/**
+ * 将 AdminTool 投影为发给 LLM / MCP 客户端的白名单 Schema。
+ * 剥离底层执行逻辑（execute）与宿主私有状态，保留 name、description、parameters 及并发/安全声明。
+ */
+export function projectAdminToolSchema(tool: AdminTool): {
+  name: string;
+  description: string;
+  parameters: Record<string, AdminToolParameter>;
+  readOnly?: boolean;
+  destructive?: boolean;
+  concurrent?: boolean;
+  needsApproval?: boolean;
+} {
+  return {
+    name: tool.name,
+    description: tool.description,
+    parameters: { ...tool.parameters },
+    ...(tool.readOnly !== undefined ? { readOnly: tool.readOnly } : {}),
+    ...(tool.destructive !== undefined ? { destructive: tool.destructive } : {}),
+    ...(tool.concurrent !== undefined ? { concurrent: tool.concurrent } : {}),
+    ...(tool.needsApproval !== undefined ? { needsApproval: tool.needsApproval } : {}),
+  };
+}
+
 export function resetChatProvider(): void {
   chatProvider = null;
   agentProvider = null;

package/src/helpers-pure.ts

@@ -164,3 +164,197 @@ export function parseCSV(text: string): string[][] {
   }
   return rows;
 }
+
+// ─── Universal Schema Validator Helper ──────────────────────────
+
+/**
+ * Universal schema interface compatible with TypeBox, Standard Schema (v1), Valibot, Zod,
+ * Yup, Joi, etc.
+ */
+export interface SchemaValidatorLike {
+  Check?: (value: unknown) => boolean;
+  Errors?: (value: unknown) => Iterable<{ path?: string; message: string; schema?: unknown }>;
+  safeParse?: (data: unknown) => {
+    success: boolean;
+    data?: unknown;
+    error?: {
+      issues?: Array<{ path?: Array<string | number>; message: string }>;
+      errors?: Array<{ path?: Array<string | number>; message: string }>;
+    };
+  };
+  parse?: (data: unknown) => unknown;
+  validate?: (data: unknown) => {
+    error?: {
+      details?: Array<{ path?: Array<string | number>; message: string }>;
+      message?: string;
+    };
+  };
+  '~standard'?: {
+    validate: (data: unknown) => unknown | Promise<unknown>;
+  };
+}
+
+/**
+ * TypeBox validator interface matching TypeCompiler.Compile or Value.Errors
+ */
+export type TypeBoxValidatorLike = {
+  Check?: (value: unknown) => boolean;
+  Errors: (value: unknown) => Iterable<{ path?: string; message: string }>;
+};
+
+/**
+ * Creates a synchronous form validator function from any TypeBox, Standard Schema v1,
+ * Valibot, Zod, Yup, or Joi object.
+ *
+ * @example
+ * ```ts
+ * import { Type } from '@sinclair/typebox';
+ * import { TypeCompiler } from '@sinclair/typebox/compiler';
+ * import { createSchemaValidator, useForm } from '@svadmin/core';
+ *
+ * const userSchema = Type.Object({
+ *   name: Type.String({ minLength: 2 }),
+ *   email: Type.String({ format: 'email' }),
+ * });
+ *
+ * const form = useForm({
+ *   resource: 'users',
+ *   validate: createSchemaValidator(TypeCompiler.Compile(userSchema)),
+ * });
+ * ```
+ */
+export function createSchemaValidator(
+  schema: SchemaValidatorLike | unknown
+): (values: Record<string, unknown>) => Record<string, string> | null {
+  if (!schema || typeof schema !== 'object') {
+    return () => null;
+  }
+
+  const s = schema as SchemaValidatorLike;
+
+  return (values: Record<string, unknown>) => {
+    const errors: Record<string, string> = {};
+
+    // 0. TypeBox TypeCompiler compiled validator (.Check & .Errors)
+    if (typeof s.Check === 'function' && typeof s.Errors === 'function') {
+      if (s.Check(values)) return null;
+      for (const err of s.Errors(values)) {
+        const rawPath = err.path || '';
+        const cleanPath = rawPath.replace(/^\//, '').replace(/\//g, '.');
+        const key = cleanPath || '_root';
+        if (!errors[key]) errors[key] = err.message;
+      }
+      return Object.keys(errors).length > 0 ? errors : null;
+    }
+
+    // 0b. TypeBox Value.Errors iterator provider
+    if (typeof s.Errors === 'function') {
+      for (const err of s.Errors(values)) {
+        const rawPath = err.path || '';
+        const cleanPath = rawPath.replace(/^\//, '').replace(/\//g, '.');
+        const key = cleanPath || '_root';
+        if (!errors[key]) errors[key] = err.message;
+      }
+      return Object.keys(errors).length > 0 ? errors : null;
+    }
+
+    // 1. Standard Schema v1 (~standard)
+    if (s['~standard'] && typeof s['~standard'].validate === 'function') {
+      const res = s['~standard'].validate(values);
+      if (res && typeof res === 'object' && 'issues' in res && Array.isArray((res as { issues?: Array<{ path?: Array<unknown>; message: string }> }).issues)) {
+        for (const issue of (res as { issues: Array<{ path?: Array<unknown>; message: string }> }).issues) {
+          const rawPath = issue.path?.[0];
+          const key = typeof rawPath === 'object' && rawPath !== null && 'key' in rawPath
+            ? String((rawPath as { key: unknown }).key)
+            : rawPath != null
+              ? String(rawPath)
+              : '_root';
+          if (!errors[key]) errors[key] = issue.message;
+        }
+      }
+      return Object.keys(errors).length > 0 ? errors : null;
+    }
+
+    // 2. Zod / Valibot safeParse
+    if (typeof s.safeParse === 'function') {
+      const res = s.safeParse(values);
+      if (!res.success && res.error) {
+        const issues = res.error.issues ?? res.error.errors ?? [];
+        for (const issue of issues) {
+          const key = issue.path?.[0] != null ? String(issue.path[0]) : '_root';
+          if (!errors[key]) errors[key] = issue.message;
+        }
+      }
+      return Object.keys(errors).length > 0 ? errors : null;
+    }
+
+    // 3. Joi / generic .validate()
+    if (typeof s.validate === 'function') {
+      const res = s.validate(values);
+      if (res && typeof res === 'object' && res.error) {
+        const details = res.error.details;
+        if (Array.isArray(details) && details.length > 0) {
+          for (const d of details) {
+            const key = d.path?.[0] != null ? String(d.path[0]) : '_root';
+            if (!errors[key]) errors[key] = d.message;
+          }
+        } else if (res.error.message) {
+          errors._root = res.error.message;
+        }
+      }
+      return Object.keys(errors).length > 0 ? errors : null;
+    }
+
+    // 4. Synchronous .parse() that throws (e.g. standard Zod parse or Yup validateSync)
+    if (typeof s.parse === 'function') {
+      try {
+        s.parse(values);
+      } catch (err: unknown) {
+        if (err && typeof err === 'object') {
+          const issues = (err as { issues?: Array<{ path?: Array<string | number>; message: string }>; errors?: Array<{ path?: Array<string | number>; message: string }> }).issues ??
+            (err as { errors?: Array<{ path?: Array<string | number>; message: string }> }).errors;
+          if (Array.isArray(issues)) {
+            for (const issue of issues) {
+              const key = issue.path?.[0] != null ? String(issue.path[0]) : '_root';
+              if (!errors[key]) errors[key] = issue.message;
+            }
+          } else if ('message' in err && typeof (err as { message: unknown }).message === 'string') {
+            errors._root = (err as { message: string }).message;
+          }
+        }
+      }
+      return Object.keys(errors).length > 0 ? errors : null;
+    }
+
+    return null;
+  };
+}
+
+/**
+ * Creates a synchronous form validator function specifically optimized for TypeBox
+ * compiled validators (from TypeCompiler.Compile) or TypeBox value checks.
+ *
+ * @example
+ * ```ts
+ * import { Type } from '@sinclair/typebox';
+ * import { TypeCompiler } from '@sinclair/typebox/compiler';
+ * import { createTypeBoxValidator, useForm } from '@svadmin/core';
+ *
+ * const userSchema = Type.Object({
+ *   name: Type.String({ minLength: 2 }),
+ *   email: Type.String({ format: 'email' }),
+ * });
+ *
+ * const compiledUser = TypeCompiler.Compile(userSchema);
+ *
+ * const form = useForm({
+ *   resource: 'users',
+ *   validate: createTypeBoxValidator(compiledUser),
+ * });
+ * ```
+ */
+export function createTypeBoxValidator(
+  compiledOrSchema: TypeBoxValidatorLike | SchemaValidatorLike | unknown
+): (values: Record<string, unknown>) => Record<string, string> | null {
+  return createSchemaValidator(compiledOrSchema);
+}

package/src/helpers.ts

@@ -8,7 +8,10 @@ export {
   getDefaultFilter, getDefaultSortOrder,
   unionFilters, unionSorters,
   file2Base64, parseCSV,
+  createSchemaValidator,
+  createTypeBoxValidator,
 } from './helpers-pure';
+export type { SchemaValidatorLike, TypeBoxValidatorLike } from './helpers-pure';
 
 
 // ─── Document Title Helper ────────────────────────────────────

package/src/index.ts

@@ -90,7 +90,7 @@ export {
 export type { NotificationParams } from './notification.svelte';
 export { t, setLocale, getLocale, getAvailableLocales, addTranslations, useTranslation, setI18nProvider, getI18nProvider, createI18nScope, provideI18nScope, getI18nScope, resetI18n } from './i18n.svelte';
 export type { I18nProvider, I18nScope, I18nScopeOptions } from './i18n.svelte';
-export { audit, auditWithProvider, writeAuditEntry, setAuditHandler, setAuditLogProvider, getAuditLogProvider } from './audit';
+export { audit, auditWithProvider, writeAuditEntry, recordMutationRollback, setAuditHandler, setAuditLogProvider, getAuditLogProvider } from './audit';
 export type { AuditLogProvider } from './audit';
 export type {
   ApiCredentialSummary,
@@ -116,7 +116,7 @@ export type {
   WebhookSummary,
 } from './enterprise';
 export { assertEnterpriseRequestContext, createEnterpriseRequestContext } from './enterprise';
-export { setChatProvider, getChatProvider, setChatContext, getChatContext, setAgentProvider, getAgentProvider, registerApproval, resolveApproval, hasPendingApprovals, resetChatProvider } from './chatProvider.svelte';
+export { setChatProvider, getChatProvider, setChatContext, getChatContext, setAgentProvider, getAgentProvider, registerApproval, resolveApproval, hasPendingApprovals, resetChatProvider, projectAdminToolSchema } from './chatProvider.svelte';
 export type { ChatProvider, ChatMessage, ChatContext, ChatAction, AgentProvider, AgentEvent, AgentOptions, AdminTool, AdminToolParameter, ToolResult } from './chatProvider.svelte';
 export { getTheme, setTheme, toggleTheme, getResolvedTheme, getColorTheme, setColorTheme, getColorThemes, configureTheme, getThemeConfig, clearCssOverrides, builtinPresets, registerColorPreset, getColorPresets, registerThemeOwner, updateThemeOwner, unregisterThemeOwner, resetTheme } from './theme.svelte';
 export type { ThemeMode, ColorTheme, ThemeStrategy, ThemeConfig, ColorPreset, ThemeOwnerOptions, ThemeOwnerToken } from './theme.svelte';
@@ -150,7 +150,7 @@ export type {
 export type { InvalidateScope } from './options.svelte';
 export type { LiveProvider, LiveEvent, LiveMode } from './live.svelte';
 export type { Action, CanParams, CanResult, AccessControlProvider, FeatureGateConfig, FeatureGateUser } from './permissions.svelte';
-export type { AuditEntry, AuditHandler } from './audit';
+export type { AuditEntry, AuditHandler, AuditAction } from './audit';
 export { useCan } from './useCan';
 export type { UseCanOptions, UseCanResult } from './useCan';
 export { createCaslAccessControl } from './adapters/casl';
@@ -177,7 +177,18 @@ export { useParsed, resetGlobalPath, syncGlobalPath } from './useParsed.svelte';
 export * from './useStepsForm.svelte';
 export { createHashRouterProvider, createHistoryRouterProvider } from './router-provider';
 export type { RouterNavigationResult, RouterProvider } from './router-provider';
-export { inferFieldType, inferResource } from './inferencer';
+export {
+  inferFieldType,
+  inferResource,
+  generateTypeBoxSchemaCode,
+  generateListPageCode,
+  generateCreatePageCode,
+  generateEditPageCode,
+  generateShowPageCode,
+  generateResourceCode,
+  generateComponentCode,
+  generateResourceBundle,
+} from './inferencer';
 export type { InferResult } from './inferencer';
 export { createWebSocketLiveProvider } from './live-websocket';
 export type { WebSocketLiveProviderOptions } from './live-websocket';
@@ -185,12 +196,17 @@ export { createSSELiveProvider } from './live-sse';
 export type { SSELiveProviderOptions } from './live-sse';
 export { inferFromOpenAPI } from './inferencer-openapi';
 export type { InferFromOpenAPIOptions } from './inferencer-openapi';
+export { inferFromGraphQL, GRAPHQL_INTROSPECTION_QUERY } from './inferencer-graphql';
+export type { InferFromGraphQLOptions, GraphQLIntrospectionSchema, GraphQLTypeDescriptor } from './inferencer-graphql';
 export {
   getDefaultFilter, getDefaultSortOrder,
   unionFilters, unionSorters,
   file2Base64, generateDefaultDocumentTitle,
   deriveValidator,
+  createSchemaValidator,
+  createTypeBoxValidator,
 } from './helpers';
+export type { SchemaValidatorLike, TypeBoxValidatorLike } from './helpers';
 export { TableState } from './table-state.svelte';
 export type { TableStateOptions } from './table-state.svelte';
 export type { UseInfiniteListOptions } from './hooks.svelte';

package/src/inferencer-graphql.ts

@@ -0,0 +1,495 @@
+/**
+ * GraphQL Schema / Introspection → ResourceDefinition converter
+ *
+ * Parses a GraphQL introspection JSON result or schema definition and generates
+ * ResourceDefinition[] by analyzing entity types, fields, enums, queries, and mutations.
+ */
+import type { FieldDefinition, ResourceDefinition } from './types';
+
+// ─── GraphQL Introspection Types ─────────────────────────────
+
+export interface GraphQLIntrospectionSchema {
+  __schema?: GraphQLSchemaBody;
+  data?: {
+    __schema?: GraphQLSchemaBody;
+  };
+  types?: GraphQLTypeDescriptor[];
+}
+
+export interface GraphQLSchemaBody {
+  queryType?: { name?: string | null } | null;
+  mutationType?: { name?: string | null } | null;
+  subscriptionType?: { name?: string | null } | null;
+  types: GraphQLTypeDescriptor[];
+}
+
+export interface GraphQLTypeDescriptor {
+  kind: 'SCALAR' | 'OBJECT' | 'INTERFACE' | 'UNION' | 'ENUM' | 'INPUT_OBJECT' | 'LIST' | 'NON_NULL';
+  name: string | null;
+  description?: string | null;
+  fields?: GraphQLFieldDescriptor[] | null;
+  inputFields?: GraphQLInputValueDescriptor[] | null;
+  interfaces?: GraphQLTypeRef[] | null;
+  enumValues?: Array<{ name: string; description?: string | null }> | null;
+  possibleTypes?: GraphQLTypeRef[] | null;
+}
+
+export interface GraphQLFieldDescriptor {
+  name: string;
+  description?: string | null;
+  args?: GraphQLInputValueDescriptor[];
+  type: GraphQLTypeRef;
+  isDeprecated?: boolean;
+  deprecationReason?: string | null;
+}
+
+export interface GraphQLInputValueDescriptor {
+  name: string;
+  description?: string | null;
+  type: GraphQLTypeRef;
+  defaultValue?: string | null;
+}
+
+export interface GraphQLTypeRef {
+  kind: 'SCALAR' | 'OBJECT' | 'INTERFACE' | 'UNION' | 'ENUM' | 'INPUT_OBJECT' | 'LIST' | 'NON_NULL';
+  name?: string | null;
+  ofType?: GraphQLTypeRef | null;
+}
+
+/**
+ * Standard GraphQL introspection query string to fetch the schema from any GraphQL endpoint.
+ */
+export const GRAPHQL_INTROSPECTION_QUERY = `query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      kind
+      name
+      description
+      fields(includeDeprecated: true) {
+        name
+        description
+        type {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+      enumValues(includeDeprecated: true) {
+        name
+        description
+      }
+    }
+  }
+}`;
+
+// ─── Core Type Resolution ────────────────────────────────────
+
+interface ResolvedTypeInfo {
+  baseName: string;
+  kind: string;
+  isList: boolean;
+  isRequired: boolean;
+}
+
+function unwrapType(typeRef: GraphQLTypeRef): ResolvedTypeInfo {
+  let current: GraphQLTypeRef = typeRef;
+  let isRequired = false;
+  let isList = false;
+
+  if (current.kind === 'NON_NULL') {
+    isRequired = true;
+    if (current.ofType) current = current.ofType;
+  }
+
+  if (current.kind === 'LIST') {
+    isList = true;
+    if (current.ofType) {
+      current = current.ofType;
+      if (current.kind === 'NON_NULL') {
+        if (current.ofType) current = current.ofType;
+      }
+    }
+  }
+
+  return {
+    baseName: current.name ?? 'String',
+    kind: current.kind,
+    isList,
+    isRequired,
+  };
+}
+
+function mapGraphQLTypeToFieldType(
+  key: string,
+  typeInfo: ResolvedTypeInfo,
+  enumMap: Map<string, string[]>
+): FieldDefinition['type'] {
+  const { baseName, isList } = typeInfo;
+  const lk = key.toLowerCase();
+
+  // Enums
+  if (enumMap.has(baseName)) return 'select';
+
+  // Arrays / Lists
+  if (isList) {
+    if (lk.includes('image') || lk.includes('photo') || lk.includes('avatar') || lk.includes('picture')) {
+      return 'images';
+    }
+    return 'tags';
+  }
+
+  // Built-in Scalars & Custom Scalars
+  switch (baseName) {
+    case 'Int':
+    case 'Float':
+    case 'Decimal':
+    case 'BigInt':
+      return 'number';
+    case 'Boolean':
+      return 'boolean';
+    case 'Date':
+    case 'DateTime':
+    case 'Time':
+    case 'Timestamp':
+      return 'date';
+    case 'JSON':
+    case 'JsonObject':
+    case 'JSONObject':
+    case 'Json':
+      return 'json';
+    case 'ID':
+      return 'text';
+    case 'String':
+    default:
+      break;
+  }
+
+  // String field heuristics based on key name
+  if (lk.includes('email')) return 'email';
+  if (lk.includes('phone') || lk.includes('tel') || lk.includes('mobile')) return 'phone';
+  if (lk.includes('url') || lk.includes('link') || lk.includes('website')) return 'url';
+  if (lk.includes('avatar') || lk.includes('image') || lk.includes('photo') || lk.includes('thumbnail') || lk.includes('logo')) return 'image';
+  if (lk.includes('color') || lk.includes('colour')) return 'color';
+  if (lk.includes('description') || lk.includes('content') || lk.includes('body') || lk.includes('bio') || lk.includes('summary')) return 'textarea';
+  if (lk === 'created_at' || lk === 'updated_at' || lk.endsWith('_at') || lk.endsWith('_date') || /\bdate\b/.test(lk)) return 'date';
+
+  return 'text';
+}
+
+// ─── GraphQL SDL Parser (Fallback for raw .graphql schemas) ──
+
+function parseGraphQLSDL(sdl: string): GraphQLSchemaBody {
+  const types: GraphQLTypeDescriptor[] = [];
+  const queryType: { name: string } = { name: 'Query' };
+  const mutationType: { name: string } = { name: 'Mutation' };
+
+  // Remove comments
+  const cleanSDL = sdl.replace(/#[^\n\r]*/g, '');
+
+  // Extract enums: enum Status { DRAFT PUBLISHED ARCHIVED }
+  const enumRegex = /enum\s+([A-Za-z0-9_]+)\s*\{([^}]+)\}/g;
+  let match: RegExpExecArray | null;
+  while ((match = enumRegex.exec(cleanSDL)) !== null) {
+    const enumName = match[1];
+    const rawValues = match[2].split(/\s+/).filter(Boolean);
+    types.push({
+      kind: 'ENUM',
+      name: enumName,
+      enumValues: rawValues.map(v => ({ name: v })),
+    });
+  }
+
+  // Extract types: type Post { id: ID! title: String ... }
+  const typeRegex = /type\s+([A-Za-z0-9_]+)\s*(?:implements\s+[A-Za-z0-9_&,\s]+)?\s*\{([^}]+)\}/g;
+  while ((match = typeRegex.exec(cleanSDL)) !== null) {
+    const typeName = match[1];
+    const fieldsBody = match[2];
+    const fieldLines = fieldsBody.split('\n').map(l => l.trim()).filter(Boolean);
+    const fields: GraphQLFieldDescriptor[] = [];
+
+    for (const line of fieldLines) {
+      // fieldName(args): TypeName!
+      const fieldMatch = /^([A-Za-z0-9_]+)(?:\([^)]*\))?\s*:\s*([[\]A-Za-z0-9_!]+)/.exec(line);
+      if (!fieldMatch) continue;
+
+      const fName = fieldMatch[1];
+      const rawType = fieldMatch[2];
+
+      const isNonNullable = rawType.endsWith('!');
+      const cleanType = isNonNullable ? rawType.slice(0, -1) : rawType;
+      const isList = cleanType.startsWith('[') && cleanType.endsWith(']');
+      const innerType = isList ? cleanType.slice(1, -1).replace(/!$/, '') : cleanType;
+
+      let typeRef: GraphQLTypeRef = {
+        kind: 'SCALAR',
+        name: innerType,
+      };
+
+      if (isList) {
+        typeRef = {
+          kind: 'LIST',
+          ofType: typeRef,
+        };
+      }
+
+      if (isNonNullable) {
+        typeRef = {
+          kind: 'NON_NULL',
+          ofType: typeRef,
+        };
+      }
+
+      fields.push({
+        name: fName,
+        type: typeRef,
+      });
+    }
+
+    types.push({
+      kind: 'OBJECT',
+      name: typeName,
+      fields,
+    });
+  }
+
+  return {
+    queryType,
+    mutationType,
+    types,
+  };
+}
+
+// ─── Core: inferFromGraphQL ──────────────────────────────────
+
+export interface InferFromGraphQLOptions {
+  /** Include only specific type names */
+  include?: string[];
+  /** Exclude specific type names */
+  exclude?: string[];
+  /** Custom primary key (default: 'id') */
+  primaryKey?: string;
+}
+
+/**
+ * Parses a GraphQL schema (introspection object or SDL string) and returns ResourceDefinition[].
+ */
+export function inferFromGraphQL(
+  schemaOrIntrospection: GraphQLIntrospectionSchema | GraphQLSchemaBody | string | unknown,
+  options: InferFromGraphQLOptions = {}
+): ResourceDefinition[] {
+  const { primaryKey = 'id', include, exclude } = options;
+
+  let schemaBody: GraphQLSchemaBody;
+
+  if (typeof schemaOrIntrospection === 'string') {
+    schemaBody = parseGraphQLSDL(schemaOrIntrospection);
+  } else if (
+    schemaOrIntrospection &&
+    typeof schemaOrIntrospection === 'object' &&
+    'data' in schemaOrIntrospection &&
+    (schemaOrIntrospection as { data?: { __schema?: GraphQLSchemaBody } }).data?.__schema
+  ) {
+    schemaBody = (schemaOrIntrospection as { data: { __schema: GraphQLSchemaBody } }).data.__schema;
+  } else if (
+    schemaOrIntrospection &&
+    typeof schemaOrIntrospection === 'object' &&
+    '__schema' in schemaOrIntrospection &&
+    (schemaOrIntrospection as { __schema?: GraphQLSchemaBody }).__schema
+  ) {
+    schemaBody = (schemaOrIntrospection as { __schema: GraphQLSchemaBody }).__schema;
+  } else if (
+    schemaOrIntrospection &&
+    typeof schemaOrIntrospection === 'object' &&
+    'types' in schemaOrIntrospection &&
+    Array.isArray((schemaOrIntrospection as GraphQLSchemaBody).types)
+  ) {
+    schemaBody = schemaOrIntrospection as GraphQLSchemaBody;
+  } else {
+    return [];
+  }
+
+  const types = schemaBody.types ?? [];
+  const queryTypeName = schemaBody.queryType?.name ?? 'Query';
+  const mutationTypeName = schemaBody.mutationType?.name ?? 'Mutation';
+  const subscriptionTypeName = schemaBody.subscriptionType?.name ?? 'Subscription';
+
+  // Build enum map
+  const enumMap = new Map<string, string[]>();
+  for (const t of types) {
+    if (t.kind === 'ENUM' && t.name) {
+      const values = (t.enumValues ?? []).map(ev => ev.name);
+      enumMap.set(t.name, values);
+    }
+  }
+
+  // Build object types map
+  const objectTypeMap = new Map<string, GraphQLTypeDescriptor>();
+  for (const t of types) {
+    if (t.kind === 'OBJECT' && t.name) {
+      objectTypeMap.set(t.name, t);
+    }
+  }
+
+  // Find root query & mutation fields to detect capabilities
+  const queryFields = new Set<string>();
+  const queryType = objectTypeMap.get(queryTypeName);
+  if (queryType?.fields) {
+    for (const f of queryType.fields) queryFields.add(f.name.toLowerCase());
+  }
+
+  const mutationFields = new Set<string>();
+  const mutationType = objectTypeMap.get(mutationTypeName);
+  if (mutationType?.fields) {
+    for (const f of mutationType.fields) mutationFields.add(f.name.toLowerCase());
+  }
+
+  const resources: ResourceDefinition[] = [];
+
+  for (const typeObj of types) {
+    const typeName = typeObj.name;
+    if (!typeName) continue;
+
+    // Filter out root types, internal types (__*), and input objects
+    if (
+      typeName.startsWith('__') ||
+      typeName === queryTypeName ||
+      typeName === mutationTypeName ||
+      typeName === subscriptionTypeName ||
+      typeObj.kind !== 'OBJECT' ||
+      !typeObj.fields ||
+      typeObj.fields.length === 0
+    ) {
+      continue;
+    }
+
+    // Apply include/exclude filters
+    if (include && !include.includes(typeName)) continue;
+    if (exclude && exclude.includes(typeName)) continue;
+
+    const baseName = typeName.toLowerCase();
+    const resourceName = baseName.endsWith('s') ? baseName : baseName + 's';
+
+    const fields: FieldDefinition[] = [];
+
+    for (const fieldDesc of typeObj.fields) {
+      const fieldName = fieldDesc.name;
+      const typeInfo = unwrapType(fieldDesc.type);
+
+      let fieldType = mapGraphQLTypeToFieldType(fieldName, typeInfo, enumMap);
+      let relatedResource: string | null = null;
+
+      // Check if type references another Object entity in the schema
+      if (objectTypeMap.has(typeInfo.baseName) && typeInfo.baseName !== typeName) {
+        const target = typeInfo.baseName.toLowerCase();
+        relatedResource = target.endsWith('s') ? target : target + 's';
+        fieldType = 'relation';
+      } else if (fieldName.endsWith('_id') || fieldName.endsWith('Id')) {
+        const base = fieldName.replace(/_id$|Id$/, '');
+        relatedResource = base.endsWith('s') ? base : base + 's';
+        fieldType = 'relation';
+      }
+
+      const field: FieldDefinition = {
+        key: fieldName,
+        label: humanize(fieldName),
+        type: relatedResource ? 'relation' : fieldType,
+        required: typeInfo.isRequired,
+        sortable: ['text', 'number', 'date'].includes(fieldType),
+        searchable: ['text', 'email'].includes(fieldType),
+        showInList: fieldName !== primaryKey && fieldType !== 'textarea' && fieldType !== 'json',
+        showInForm: fieldName !== primaryKey,
+      };
+
+      if (relatedResource) {
+        field.resource = relatedResource;
+        field.optionLabel = 'name';
+        field.optionValue = 'id';
+      }
+
+      if (enumMap.has(typeInfo.baseName)) {
+        const enumValues = enumMap.get(typeInfo.baseName) ?? [];
+        field.options = enumValues.map(val => ({
+          label: humanize(val),
+          value: val,
+        }));
+      }
+
+      fields.push(field);
+    }
+
+    // Sort fields: primaryKey first, then alphabetically
+    fields.sort((a, b) => {
+      if (a.key === primaryKey) return -1;
+      if (b.key === primaryKey) return 1;
+      return a.key.localeCompare(b.key);
+    });
+
+    // Detect CRUD capabilities
+    const canShow = queryFields.size === 0 ||
+      queryFields.has(baseName) ||
+      queryFields.has(resourceName) ||
+      queryFields.has(`get${baseName}`) ||
+      queryFields.has(`${baseName}byid`) ||
+      queryFields.has(`find${baseName}`);
+
+    const canCreate = mutationFields.size === 0 ||
+      mutationFields.has(`create${baseName}`) ||
+      mutationFields.has(`insert${baseName}`) ||
+      mutationFields.has(`add${baseName}`) ||
+      mutationFields.has(`insert_${resourceName}`) ||
+      mutationFields.has(`create_${baseName}`);
+
+    const canEdit = mutationFields.size === 0 ||
+      mutationFields.has(`update${baseName}`) ||
+      mutationFields.has(`edit${baseName}`) ||
+      mutationFields.has(`update_${resourceName}`) ||
+      mutationFields.has(`update_${baseName}`) ||
+      mutationFields.has(`save${baseName}`);
+
+    const canDelete = mutationFields.size === 0 ||
+      mutationFields.has(`delete${baseName}`) ||
+      mutationFields.has(`remove${baseName}`) ||
+      mutationFields.has(`delete_${resourceName}`) ||
+      mutationFields.has(`delete_${baseName}`);
+
+    resources.push({
+      name: resourceName,
+      label: typeName,
+      primaryKey,
+      fields,
+      canCreate,
+      canEdit,
+      canDelete,
+      canShow,
+    });
+  }
+
+  return resources;
+}
+
+// ─── Utilities ───────────────────────────────────────────────
+
+function humanize(key: string): string {
+  return key
+    .replace(/_/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/\b\w/g, c => c.toUpperCase());
+}

package/src/inferencer.ts

@@ -4,7 +4,7 @@
  * Analyzes API response data and infers ResourceDefinition + FieldDefinition[].
  * Can also generate copy-paste-ready Svelte component code.
  */
-import type { FieldDefinition, ResourceDefinition } from '@svadmin/core';
+import type { FieldDefinition, ResourceDefinition } from './types';
 
 // ─── Field Type Inference ────────────────────────────────────
 
@@ -83,6 +83,13 @@ export interface InferResult {
   fields: FieldDefinition[];
   resource: ResourceDefinition;
   code: string;
+  typeboxCode: string;
+  componentCode: {
+    list: string;
+    create: string;
+    edit: string;
+    show: string;
+  };
 }
 
 /**
@@ -103,10 +110,18 @@ export function inferResource(
   const label = options.label ?? capitalize(resourceName);
 
   if (!sampleData.length) {
+    const emptyResource: ResourceDefinition = { name: resourceName, label, fields: [], primaryKey };
     return {
       fields: [],
-      resource: { name: resourceName, label, fields: [], primaryKey },
+      resource: emptyResource,
       code: `// No data available to infer fields for "${resourceName}".`,
+      typeboxCode: generateTypeBoxSchemaCode(emptyResource),
+      componentCode: {
+        list: generateListPageCode(emptyResource),
+        create: generateCreatePageCode(emptyResource),
+        edit: generateEditPageCode(emptyResource),
+        show: generateShowPageCode(emptyResource),
+      },
     };
   }
 
@@ -190,15 +205,22 @@ export function inferResource(
   };
 
   const code = generateCode(resource);
+  const typeboxCode = generateTypeBoxSchemaCode(resource);
+  const componentCode = {
+    list: generateListPageCode(resource),
+    create: generateCreatePageCode(resource),
+    edit: generateEditPageCode(resource),
+    show: generateShowPageCode(resource),
+  };
 
-  return { fields, resource, code };
+  return { fields, resource, code, typeboxCode, componentCode };
 }
 
 // ─── Code Generation ─────────────────────────────────────────
 
 function generateCode(resource: ResourceDefinition): string {
   const esc = (s: string) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-  const fieldsCode = resource.fields.map(f => {
+  const fieldsCode = resource.fields.map((f: FieldDefinition) => {
     const lines = [
       `    { key: '${esc(f.key)}', label: '${esc(f.label)}', type: '${f.type}'`,
     ];
@@ -235,6 +257,180 @@ ${fieldsCode}
 `;
 }
 
+/**
+ * Generate Svelte 5 ListPage component code for a resource.
+ */
+export function generateListPageCode(resource: ResourceDefinition): string {
+  return `<script lang="ts">
+  import { ListPage, AutoTable } from '@svadmin/ui';
+</script>
+
+<ListPage resourceName="${resource.name}">
+  <AutoTable resourceName="${resource.name}" />
+</ListPage>
+`;
+}
+
+/**
+ * Generate Svelte 5 CreatePage component code for a resource.
+ */
+export function generateCreatePageCode(resource: ResourceDefinition): string {
+  return `<script lang="ts">
+  import { CreatePage, AutoForm } from '@svadmin/ui';
+</script>
+
+<CreatePage resourceName="${resource.name}">
+  <AutoForm resourceName="${resource.name}" mode="create" />
+</CreatePage>
+`;
+}
+
+/**
+ * Generate Svelte 5 EditPage component code for a resource.
+ */
+export function generateEditPageCode(resource: ResourceDefinition): string {
+  return `<script lang="ts">
+  import { EditPage, AutoForm } from '@svadmin/ui';
+
+  interface Props {
+    id?: string | number;
+  }
+
+  let { id }: Props = $props();
+</script>
+
+<EditPage resourceName="${resource.name}" {id}>
+  <AutoForm resourceName="${resource.name}" {id} mode="edit" />
+</EditPage>
+`;
+}
+
+/**
+ * Generate Svelte 5 ShowPage component code for a resource.
+ */
+export function generateShowPageCode(resource: ResourceDefinition): string {
+  return `<script lang="ts">
+  import { ShowPage, AutoForm } from '@svadmin/ui';
+
+  interface Props {
+    id?: string | number;
+  }
+
+  let { id }: Props = $props();
+</script>
+
+<ShowPage resourceName="${resource.name}" {id}>
+  <AutoForm resourceName="${resource.name}" {id} mode="show" />
+</ShowPage>
+`;
+}
+
+/**
+ * Generate TypeScript code for ResourceDefinition.
+ */
+export function generateResourceCode(resource: ResourceDefinition): string {
+  return generateCode(resource);
+}
+
+/**
+ * Generate TypeScript code for TypeBox schema definition.
+ */
+export function generateTypeBoxSchemaCode(resource: ResourceDefinition): string {
+  const esc = (s: string) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+  const schemaProps = resource.fields.map((f: FieldDefinition) => {
+    let typeDef: string;
+    const isRequired = f.required === true;
+
+    switch (f.type) {
+      case 'number':
+        typeDef = 'Type.Number()';
+        break;
+      case 'boolean':
+        typeDef = 'Type.Boolean()';
+        break;
+      case 'date':
+        typeDef = "Type.String({ format: 'date-time' })";
+        break;
+      case 'email':
+        typeDef = "Type.String({ format: 'email' })";
+        break;
+      case 'url':
+        typeDef = "Type.String({ format: 'uri' })";
+        break;
+      case 'phone':
+        typeDef = "Type.String({ pattern: '^\\\\+?[\\\\d\\\\s\\\\-()]{7,}$' })";
+        break;
+      case 'tags':
+        typeDef = 'Type.Array(Type.String())';
+        break;
+      case 'images':
+        typeDef = "Type.Array(Type.String({ format: 'uri' }))";
+        break;
+      case 'json':
+        typeDef = 'Type.Record(Type.String(), Type.Unknown())';
+        break;
+      case 'select':
+        if (f.options && f.options.length > 0) {
+          const literals = f.options.map(o => `Type.Literal('${esc(String(o.value))}')`).join(', ');
+          typeDef = `Type.Union([${literals}])`;
+        } else {
+          typeDef = 'Type.String()';
+        }
+        break;
+      case 'relation':
+        typeDef = 'Type.Union([Type.String(), Type.Number()])';
+        break;
+      case 'textarea':
+      case 'richtext':
+      case 'text':
+      default:
+        typeDef = 'Type.String()';
+        break;
+    }
+
+    if (!isRequired && f.key !== (resource.primaryKey ?? 'id')) {
+      typeDef = `Type.Optional(${typeDef})`;
+    }
+
+    return `  ${f.key}: ${typeDef},`;
+  }).join('\n');
+
+  const baseName = resource.name.endsWith('s') ? resource.name.slice(0, -1) : resource.name;
+  const typeName = capitalize(baseName);
+
+  return `import { Type, type Static } from '@sinclair/typebox';
+
+export const ${typeName}Schema = Type.Object({
+${schemaProps}
+});
+
+export type ${typeName} = Static<typeof ${typeName}Schema>;
+`;
+}
+
+/**
+ * Universal code generator for resource definition or Svelte page components.
+ */
+export function generateComponentCode(
+  resource: ResourceDefinition,
+  kind: 'resource' | 'typebox' | 'list' | 'create' | 'edit' | 'show'
+): string {
+  switch (kind) {
+    case 'resource':
+      return generateResourceCode(resource);
+    case 'typebox':
+      return generateTypeBoxSchemaCode(resource);
+    case 'list':
+      return generateListPageCode(resource);
+    case 'create':
+      return generateCreatePageCode(resource);
+    case 'edit':
+      return generateEditPageCode(resource);
+    case 'show':
+      return generateShowPageCode(resource);
+  }
+}
+
 // ─── Utilities ───────────────────────────────────────────────
 
 function capitalize(s: string): string {
@@ -247,3 +443,28 @@ function humanize(key: string): string {
     .replace(/([a-z])([A-Z])/g, '$1 $2')
     .replace(/\b\w/g, c => c.toUpperCase());
 }
+
+/**
+ * Generate a complete InferResult bundle from an existing ResourceDefinition.
+ */
+export function generateResourceBundle(resource: ResourceDefinition): InferResult {
+  return {
+    fields: resource.fields,
+    resource,
+    code: generateResourceCode(resource),
+    typeboxCode: generateTypeBoxSchemaCode(resource),
+    componentCode: {
+      list: generateListPageCode(resource),
+      create: generateCreatePageCode(resource),
+      edit: generateEditPageCode(resource),
+      show: generateShowPageCode(resource),
+    },
+  };
+}
+
+export { inferFromOpenAPI } from './inferencer-openapi';
+export type { InferFromOpenAPIOptions } from './inferencer-openapi';
+export { inferFromGraphQL, GRAPHQL_INTROSPECTION_QUERY } from './inferencer-graphql';
+export type { InferFromGraphQLOptions, GraphQLIntrospectionSchema, GraphQLTypeDescriptor } from './inferencer-graphql';
+
+export type { FieldDefinition, ResourceDefinition } from './types';