sveltekit-admin 0.1.0

package/README.md

@@ -0,0 +1,172 @@
+# sveltekit-admin
+
+🎛️ A Django-like admin panel for SvelteKit applications with Prisma and better-auth.
+
+![Version](https://img.shields.io/npm/v/sveltekit-admin)
+![License](https://img.shields.io/npm/l/sveltekit-admin)
+
+## Features
+
+- 🔍 **Auto-introspection** of Prisma schema
+- 📝 **CRUD operations** auto-generated for all models
+- 🔐 **better-auth integration** for admin authentication
+- 🎨 **Standalone UI** - no Tailwind or other CSS framework required
+- ⚡ **Zero-config** - just add the plugin and you're ready
+- 🔧 **Customizable** - hide fields, set readonly, custom labels
+
+## Installation
+
+```bash
+npm install sveltekit-admin
+# or
+bun add sveltekit-admin
+# or
+pnpm add sveltekit-admin
+```
+
+## Quick Start
+
+### 1. Add the Vite plugin
+
+```typescript
+// vite.config.ts
+import { sveltekit } from '@sveltejs/kit/vite';
+import { svelteKitAdmin } from 'sveltekit-admin/plugin';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [
+    sveltekit(),
+    svelteKitAdmin({
+      prismaSchemaPath: './prisma/schema.prisma',
+      basePath: '/admin',
+      auth: {
+        provider: 'better-auth',
+        adminRole: 'admin'
+      }
+    })
+  ]
+});
+```
+
+### 2. Add the auth hook (optional, for protected admin)
+
+```typescript
+// src/hooks.server.ts
+import { createAdminHandle } from 'sveltekit-admin';
+import { sequence } from '@sveltejs/kit/hooks';
+
+const adminHandle = createAdminHandle({
+  basePath: '/admin',
+  auth: {
+    provider: 'better-auth',
+    adminRole: 'admin'
+  }
+});
+
+export const handle = sequence(
+  // your auth handle first
+  adminHandle
+);
+```
+
+### 3. Access your admin panel
+
+Navigate to `/admin` and you'll see:
+- Dashboard with model statistics
+- List views with pagination, search, and sorting
+- Create/Edit forms auto-generated from your Prisma schema
+- Delete with confirmation
+
+## Configuration
+
+```typescript
+svelteKitAdmin({
+  // Path to your Prisma schema (default: './prisma/schema.prisma')
+  prismaSchemaPath: './prisma/schema.prisma',
+  
+  // Base path for admin routes (default: '/admin')
+  basePath: '/admin',
+  
+  // Authentication configuration
+  auth: {
+    provider: 'better-auth',
+    adminRole: 'admin', // Role required to access admin
+    // Or custom check function:
+    adminCheck: async (user) => user.isAdmin === true
+  },
+  
+  // Per-model configuration
+  models: {
+    User: {
+      // Fields to hide from all views
+      hidden: ['password', 'hashedPassword'],
+      // Fields that cannot be edited
+      readonly: ['id', 'createdAt', 'updatedAt'],
+      // Fields to show in list view (default: auto-detect)
+      listFields: ['email', 'name', 'role', 'createdAt'],
+      // Custom label for the model
+      label: 'Users',
+      // Icon name (Lucide icon)
+      icon: 'users'
+    },
+    Session: {
+      // Completely exclude this model from admin
+      hidden: true
+    }
+  },
+  
+  // Models to exclude from admin
+  exclude: ['Session', 'VerificationToken'],
+  
+  // Custom branding
+  branding: {
+    title: 'My Admin',
+    logo: '/logo.svg',
+    primaryColor: '#6366f1'
+  }
+})
+```
+
+## Components
+
+You can also use the admin components directly in your own pages:
+
+```svelte
+<script>
+  import { AdminLayout, DataTable, AdminForm } from 'sveltekit-admin/components';
+</script>
+
+<AdminLayout title="Custom Admin" models={[...]}>
+  <DataTable 
+    data={users}
+    columns={[
+      { key: 'email', label: 'Email', sortable: true },
+      { key: 'name', label: 'Name', sortable: true }
+    ]}
+    basePath="/admin"
+    modelName="User"
+  />
+</AdminLayout>
+```
+
+## Prisma Schema Introspection
+
+The admin automatically parses your Prisma schema and:
+
+- Extracts all models and their fields
+- Detects field types and generates appropriate form inputs
+- Handles relations (1-1, 1-N, N-N)
+- Respects field attributes (@id, @unique, @default, @updatedAt)
+- Hides sensitive fields by name pattern (password, hash, secret)
+
+## Requirements
+
+- SvelteKit 2.x
+- Svelte 5.x
+- Prisma 5.x or 6.x
+- better-auth 1.x (for authentication)
+
+## License
+
+MIT

package/dist/admin.d.ts

@@ -0,0 +1,227 @@
+/**
+ * SvelteKit Admin - Core Admin Factory
+ * Creates all the necessary handlers for the admin panel
+ */
+import { type PrismaSchema, type PrismaModel } from './server/introspection/parser.js';
+export interface AdminConfig {
+    /** Prisma client instance */
+    prisma: any;
+    /** Path to Prisma schema file */
+    schemaPath?: string;
+    /** Parsed schema (alternative to schemaPath) */
+    schema?: PrismaSchema;
+    /** Base path for admin (default: /admin) */
+    basePath?: string;
+    /** Models to exclude */
+    exclude?: string[];
+    /** Per-model configuration */
+    models?: Record<string, {
+        hidden?: string[];
+        readonly?: string[];
+        listFields?: string[];
+        label?: string;
+    }>;
+    /** Branding options */
+    branding?: {
+        title?: string;
+        logo?: string;
+        primaryColor?: string;
+    };
+    /** Auth check function */
+    checkAdmin?: (user: unknown) => boolean | Promise<boolean>;
+    /** Admin role name (if using default check) */
+    adminRole?: string;
+}
+export interface AdminContext {
+    config: AdminConfig;
+    schema: PrismaSchema;
+    models: PrismaModel[];
+    getModel: (name: string) => PrismaModel | undefined;
+}
+/**
+ * Create admin context with all necessary data
+ */
+export declare function createAdmin(config: AdminConfig): AdminContext;
+/**
+ * Layout data loader - provides models list and config to layout
+ */
+export declare function createLayoutLoad(ctx: AdminContext): ({ locals }: {
+    locals: any;
+}) => Promise<{
+    models: {
+        name: string;
+        label: string;
+    }[];
+    user: {
+        name: any;
+        email: any;
+    } | undefined;
+    config: {
+        basePath: string;
+        branding: {
+            title: string;
+            logo: string | undefined;
+            primaryColor: string;
+        };
+    };
+}>;
+/**
+ * Dashboard data loader - provides model counts
+ */
+export declare function createDashboardLoad(ctx: AdminContext): () => Promise<{
+    models: {
+        name: string;
+        label: string;
+        count: number;
+    }[];
+    stats: {
+        totalRecords: number;
+        modelsCount: number;
+    };
+}>;
+/**
+ * Model list data loader
+ */
+export declare function createModelListLoad(ctx: AdminContext): ({ params, url }: {
+    params: {
+        model: string;
+    };
+    url: URL;
+}) => Promise<{
+    model: {
+        name: string;
+        label: string;
+        fields: {
+            name: string;
+            type: string;
+            label: string;
+        }[];
+        primaryKey: string;
+    };
+    items: unknown[];
+    total: number;
+    page: number;
+    perPage: number;
+    orderBy: string;
+    orderDir: "asc" | "desc";
+    search: string;
+    config: {
+        basePath: string;
+        hidden: string[];
+        listFields: string[] | undefined;
+    };
+}>;
+/**
+ * Model create page loader
+ */
+export declare function createModelNewLoad(ctx: AdminContext): ({ params }: {
+    params: {
+        model: string;
+    };
+}) => Promise<{
+    model: {
+        name: string;
+        label: string;
+        fields: {
+            name: string;
+            type: string;
+            required: boolean;
+            label: string;
+        }[];
+    };
+    config: {
+        basePath: string;
+        hidden: string[];
+        readonly: string[];
+    };
+    relationOptions: Record<string, {
+        id: string | number;
+        label: string;
+    }[]>;
+}>;
+/**
+ * Model create action
+ */
+export declare function createModelNewAction(ctx: AdminContext): ({ params, request }: {
+    params: {
+        model: string;
+    };
+    request: Request;
+}) => Promise<{
+    success: boolean;
+    error?: undefined;
+    fieldErrors?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    fieldErrors: {};
+}>;
+/**
+ * Model edit page loader
+ */
+export declare function createModelEditLoad(ctx: AdminContext): ({ params }: {
+    params: {
+        model: string;
+        id: string;
+    };
+}) => Promise<{
+    model: {
+        name: string;
+        label: string;
+        primaryKey: string;
+        fields: {
+            name: string;
+            type: string;
+            required: boolean;
+            label: string;
+        }[];
+    };
+    item: {};
+    config: {
+        basePath: string;
+        hidden: string[];
+        readonly: string[];
+    };
+    relationOptions: Record<string, {
+        id: string | number;
+        label: string;
+    }[]>;
+}>;
+/**
+ * Model update action
+ */
+export declare function createModelEditAction(ctx: AdminContext): ({ params, request }: {
+    params: {
+        model: string;
+        id: string;
+    };
+    request: Request;
+}) => Promise<{
+    success: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+}>;
+/**
+ * Model delete action
+ */
+export declare function createModelDeleteAction(ctx: AdminContext): ({ params, request }: {
+    params: {
+        model: string;
+    };
+    request: Request;
+}) => Promise<{
+    success: boolean;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+}>;
+/**
+ * Auth guard hook
+ */
+export declare function createAdminGuard(ctx: AdminContext): ({ event, resolve }: {
+    event: any;
+    resolve: Function;
+}) => Promise<any>;