sveltekit-admin 0.1.0

package/dist/server/auth/guard.js

@@ -0,0 +1,38 @@
+/**
+ * better-auth integration for admin panel
+ */
+/**
+ * Default admin check - looks for role field
+ */
+export function defaultAdminCheck(user, adminRole = 'admin') {
+    if (!user || typeof user !== 'object')
+        return false;
+    const u = user;
+    // Check common role field names
+    if (u.role === adminRole)
+        return true;
+    if (u.isAdmin === true)
+        return true;
+    if (Array.isArray(u.roles) && u.roles.includes(adminRole))
+        return true;
+    return false;
+}
+/**
+ * Create auth guard for server routes
+ */
+export function createAuthGuard(config) {
+    const { adminRole = 'admin', adminCheck } = config;
+    return async (locals) => {
+        // Get session from better-auth
+        const session = locals.session;
+        const user = locals.user;
+        if (!session || !user) {
+            return { authorized: false, user: null };
+        }
+        // Check if user is admin
+        const isAdmin = adminCheck
+            ? await adminCheck(user)
+            : defaultAdminCheck(user, adminRole);
+        return { authorized: isAdmin, user };
+    };
+}

package/dist/server/auth/index.d.ts

@@ -0,0 +1 @@
+export * from './guard.js';

package/dist/server/auth/index.js

@@ -0,0 +1 @@
+export * from './guard.js';

package/dist/server/crud/index.d.ts

@@ -0,0 +1 @@
+export * from './operations.js';

package/dist/server/crud/index.js

@@ -0,0 +1 @@
+export * from './operations.js';

package/dist/server/crud/operations.d.ts

@@ -0,0 +1,87 @@
+/**
+ * CRUD Operations Generator
+ * Creates type-safe Prisma operations for admin panel
+ */
+import type { PrismaModel } from '../introspection/parser.js';
+export interface ListOptions {
+    page?: number;
+    perPage?: number;
+    search?: string;
+    searchFields?: string[];
+    orderBy?: string;
+    orderDir?: 'asc' | 'desc';
+    filters?: Record<string, unknown>;
+}
+export interface ListResult<T> {
+    items: T[];
+    total: number;
+    page: number;
+    perPage: number;
+    totalPages: number;
+}
+/**
+ * Build a Prisma where clause for searching
+ */
+export declare function buildSearchWhere(search: string | undefined, searchFields: string[], model: PrismaModel): Record<string, unknown> | undefined;
+/**
+ * Build filter conditions from query params
+ */
+export declare function buildFilterWhere(filters: Record<string, unknown> | undefined, model: PrismaModel): Record<string, unknown>;
+/**
+ * Create list operation config
+ */
+export declare function createListOperation(model: PrismaModel): {
+    modelName: string;
+    searchableFields: string[];
+    defaultOrderBy: string;
+    execute<T>(prisma: {
+        [key: string]: {
+            findMany: Function;
+            count: Function;
+        };
+    }, options?: ListOptions): Promise<ListResult<T>>;
+};
+/**
+ * Create get single record operation
+ */
+export declare function createGetOperation(model: PrismaModel): {
+    modelName: string;
+    execute<T>(prisma: {
+        [key: string]: {
+            findUnique: Function;
+        };
+    }, id: string | number): Promise<T | null>;
+};
+/**
+ * Create create operation
+ */
+export declare function createCreateOperation(model: PrismaModel): {
+    modelName: string;
+    execute<T>(prisma: {
+        [key: string]: {
+            create: Function;
+        };
+    }, data: Record<string, unknown>): Promise<T>;
+};
+/**
+ * Create update operation
+ */
+export declare function createUpdateOperation(model: PrismaModel): {
+    modelName: string;
+    execute<T>(prisma: {
+        [key: string]: {
+            update: Function;
+        };
+    }, id: string | number, data: Record<string, unknown>): Promise<T>;
+};
+/**
+ * Create delete operation
+ */
+export declare function createDeleteOperation(model: PrismaModel): {
+    modelName: string;
+    execute(prisma: {
+        [key: string]: {
+            delete: Function;
+        };
+    }, id: string | number): Promise<void>;
+};

package/dist/server/crud/operations.js

@@ -0,0 +1,276 @@
+/**
+ * CRUD Operations Generator
+ * Creates type-safe Prisma operations for admin panel
+ */
+/**
+ * Build a Prisma where clause for searching
+ */
+export function buildSearchWhere(search, searchFields, model) {
+    if (!search || searchFields.length === 0)
+        return undefined;
+    const stringFields = searchFields.filter(fieldName => {
+        const field = model.fields.find(f => f.name === fieldName);
+        return field?.type === 'String';
+    });
+    if (stringFields.length === 0)
+        return undefined;
+    return {
+        OR: stringFields.map(field => ({
+            [field]: {
+                contains: search,
+                mode: 'insensitive'
+            }
+        }))
+    };
+}
+/**
+ * Build filter conditions from query params
+ */
+export function buildFilterWhere(filters, model) {
+    if (!filters)
+        return {};
+    const where = {};
+    for (const [key, value] of Object.entries(filters)) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        const field = model.fields.find(f => f.name === key);
+        if (!field)
+            continue;
+        // Handle different field types
+        switch (field.type) {
+            case 'String':
+                where[key] = { contains: String(value), mode: 'insensitive' };
+                break;
+            case 'Int':
+            case 'Float':
+            case 'Decimal':
+            case 'BigInt':
+                where[key] = Number(value);
+                break;
+            case 'Boolean':
+                where[key] = value === 'true' || value === true;
+                break;
+            case 'DateTime':
+                // Support date range filters
+                if (typeof value === 'object' && value !== null) {
+                    const dateFilter = {};
+                    if ('from' in value)
+                        dateFilter.gte = new Date(value.from);
+                    if ('to' in value)
+                        dateFilter.lte = new Date(value.to);
+                    where[key] = dateFilter;
+                }
+                else {
+                    where[key] = new Date(String(value));
+                }
+                break;
+            default:
+                // For enums and relations
+                where[key] = value;
+        }
+    }
+    return where;
+}
+/**
+ * Create list operation config
+ */
+export function createListOperation(model) {
+    const searchableFields = model.fields
+        .filter(f => f.type === 'String' && !f.relation)
+        .map(f => f.name);
+    return {
+        modelName: model.name,
+        searchableFields,
+        defaultOrderBy: model.primaryKey || 'id',
+        async execute(prisma, options = {}) {
+            const { page = 1, perPage = 20, search, searchFields = searchableFields, orderBy = model.primaryKey || 'id', orderDir = 'desc', filters } = options;
+            const modelKey = model.name.charAt(0).toLowerCase() + model.name.slice(1);
+            const prismaModel = prisma[modelKey];
+            if (!prismaModel) {
+                throw new Error(`Model ${model.name} not found in Prisma client`);
+            }
+            // Build where clause
+            const searchWhere = buildSearchWhere(search, searchFields, model);
+            const filterWhere = buildFilterWhere(filters, model);
+            const where = {
+                ...filterWhere,
+                ...(searchWhere ? searchWhere : {})
+            };
+            // Build include for relations (limit depth)
+            const include = buildInclude(model);
+            // Execute queries
+            const [items, total] = await Promise.all([
+                prismaModel.findMany({
+                    where,
+                    include,
+                    orderBy: { [orderBy]: orderDir },
+                    skip: (page - 1) * perPage,
+                    take: perPage
+                }),
+                prismaModel.count({ where })
+            ]);
+            return {
+                items: items,
+                total,
+                page,
+                perPage,
+                totalPages: Math.ceil(total / perPage)
+            };
+        }
+    };
+}
+/**
+ * Create get single record operation
+ */
+export function createGetOperation(model) {
+    return {
+        modelName: model.name,
+        async execute(prisma, id) {
+            const modelKey = model.name.charAt(0).toLowerCase() + model.name.slice(1);
+            const prismaModel = prisma[modelKey];
+            if (!prismaModel) {
+                throw new Error(`Model ${model.name} not found in Prisma client`);
+            }
+            const primaryKey = model.primaryKey || 'id';
+            const include = buildInclude(model);
+            // Convert ID to correct type
+            const pkField = model.fields.find(f => f.name === primaryKey);
+            const typedId = pkField?.type === 'Int' ? parseInt(String(id)) : id;
+            return prismaModel.findUnique({
+                where: { [primaryKey]: typedId },
+                include
+            });
+        }
+    };
+}
+/**
+ * Create create operation
+ */
+export function createCreateOperation(model) {
+    return {
+        modelName: model.name,
+        async execute(prisma, data) {
+            const modelKey = model.name.charAt(0).toLowerCase() + model.name.slice(1);
+            const prismaModel = prisma[modelKey];
+            if (!prismaModel) {
+                throw new Error(`Model ${model.name} not found in Prisma client`);
+            }
+            // Process data - handle relations
+            const processedData = processInputData(data, model);
+            return prismaModel.create({
+                data: processedData
+            });
+        }
+    };
+}
+/**
+ * Create update operation
+ */
+export function createUpdateOperation(model) {
+    return {
+        modelName: model.name,
+        async execute(prisma, id, data) {
+            const modelKey = model.name.charAt(0).toLowerCase() + model.name.slice(1);
+            const prismaModel = prisma[modelKey];
+            if (!prismaModel) {
+                throw new Error(`Model ${model.name} not found in Prisma client`);
+            }
+            const primaryKey = model.primaryKey || 'id';
+            const pkField = model.fields.find(f => f.name === primaryKey);
+            const typedId = pkField?.type === 'Int' ? parseInt(String(id)) : id;
+            // Process data - handle relations
+            const processedData = processInputData(data, model);
+            return prismaModel.update({
+                where: { [primaryKey]: typedId },
+                data: processedData
+            });
+        }
+    };
+}
+/**
+ * Create delete operation
+ */
+export function createDeleteOperation(model) {
+    return {
+        modelName: model.name,
+        async execute(prisma, id) {
+            const modelKey = model.name.charAt(0).toLowerCase() + model.name.slice(1);
+            const prismaModel = prisma[modelKey];
+            if (!prismaModel) {
+                throw new Error(`Model ${model.name} not found in Prisma client`);
+            }
+            const primaryKey = model.primaryKey || 'id';
+            const pkField = model.fields.find(f => f.name === primaryKey);
+            const typedId = pkField?.type === 'Int' ? parseInt(String(id)) : id;
+            await prismaModel.delete({
+                where: { [primaryKey]: typedId }
+            });
+        }
+    };
+}
+/**
+ * Build include object for relations
+ */
+function buildInclude(model) {
+    const include = {};
+    for (const field of model.fields) {
+        if (field.relation && !field.isList) {
+            // Only include single relations, not lists (for performance)
+            include[field.name] = true;
+        }
+    }
+    return Object.keys(include).length > 0 ? include : undefined;
+}
+/**
+ * Process input data for create/update
+ */
+function processInputData(data, model) {
+    const processed = {};
+    for (const field of model.fields) {
+        // Skip auto-generated fields
+        if (field.isId || field.isCreatedAt || field.isUpdatedAt)
+            continue;
+        const value = data[field.name];
+        // Skip undefined values
+        if (value === undefined)
+            continue;
+        // Handle relations
+        if (field.relation?.fields) {
+            // This is the "owning" side of a relation with foreign key
+            // User provides the related ID directly
+            const fkField = field.relation.fields[0];
+            if (data[fkField] !== undefined) {
+                processed[fkField] = data[fkField];
+            }
+            continue;
+        }
+        // Handle type conversions
+        if (value !== null && value !== '') {
+            switch (field.type) {
+                case 'Int':
+                case 'BigInt':
+                    processed[field.name] = parseInt(String(value));
+                    break;
+                case 'Float':
+                case 'Decimal':
+                    processed[field.name] = parseFloat(String(value));
+                    break;
+                case 'Boolean':
+                    processed[field.name] = value === true || value === 'true' || value === 'on';
+                    break;
+                case 'DateTime':
+                    processed[field.name] = new Date(String(value));
+                    break;
+                case 'Json':
+                    processed[field.name] = typeof value === 'string' ? JSON.parse(value) : value;
+                    break;
+                default:
+                    processed[field.name] = value;
+            }
+        }
+        else if (!field.isRequired) {
+            processed[field.name] = null;
+        }
+    }
+    return processed;
+}

package/dist/server/introspection/index.d.ts

@@ -0,0 +1 @@
+export * from './parser.js';

package/dist/server/introspection/index.js

@@ -0,0 +1 @@
+export * from './parser.js';

package/dist/server/introspection/parser.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Prisma Schema Parser
+ * Extracts model information from Prisma schema files
+ */
+export interface PrismaField {
+    name: string;
+    type: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isUpdatedAt: boolean;
+    isCreatedAt: boolean;
+    hasDefault: boolean;
+    defaultValue?: string;
+    relation?: {
+        name?: string;
+        model: string;
+        fields?: string[];
+        references?: string[];
+    };
+    documentation?: string;
+}
+export interface PrismaModel {
+    name: string;
+    fields: PrismaField[];
+    documentation?: string;
+    primaryKey?: string;
+}
+export interface PrismaSchema {
+    models: PrismaModel[];
+    enums: Map<string, string[]>;
+}
+export declare function parsePrismaSchema(schemaPath: string): PrismaSchema;
+export declare function parseSchemaContent(content: string): PrismaSchema;
+/**
+ * Get display fields for a model (fields suitable for list view)
+ */
+export declare function getDisplayFields(model: PrismaModel): PrismaField[];
+/**
+ * Get editable fields for a model (fields that can be edited in forms)
+ */
+export declare function getEditableFields(model: PrismaModel): PrismaField[];
+/**
+ * Get a human-readable label from a field name
+ */
+export declare function fieldToLabel(fieldName: string): string;
+/**
+ * Determine the input type for a Prisma field
+ */
+export declare function getInputType(field: PrismaField): string;

package/dist/server/introspection/parser.js

@@ -0,0 +1,193 @@
+/**
+ * Prisma Schema Parser
+ * Extracts model information from Prisma schema files
+ */
+import { readFileSync } from 'fs';
+const SCALAR_TYPES = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'Bytes', 'Decimal', 'BigInt'];
+export function parsePrismaSchema(schemaPath) {
+    const content = readFileSync(schemaPath, 'utf-8');
+    return parseSchemaContent(content);
+}
+export function parseSchemaContent(content) {
+    const models = [];
+    const enums = new Map();
+    // Parse enums
+    const enumRegex = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+    let enumMatch;
+    while ((enumMatch = enumRegex.exec(content)) !== null) {
+        const enumName = enumMatch[1];
+        const enumValues = enumMatch[2]
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('//'));
+        enums.set(enumName, enumValues);
+    }
+    // Parse models
+    const modelRegex = /(?:\/\/\/\s*(.+)\n)?model\s+(\w+)\s*\{([^}]+)\}/g;
+    let modelMatch;
+    while ((modelMatch = modelRegex.exec(content)) !== null) {
+        const documentation = modelMatch[1]?.trim();
+        const modelName = modelMatch[2];
+        const modelBody = modelMatch[3];
+        const fields = parseModelFields(modelBody, enums);
+        const primaryKey = fields.find(f => f.isId)?.name || 'id';
+        models.push({
+            name: modelName,
+            fields,
+            documentation,
+            primaryKey
+        });
+    }
+    return { models, enums };
+}
+function parseModelFields(modelBody, enums) {
+    const fields = [];
+    const lines = modelBody.split('\n');
+    let currentDoc;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines and block-level attributes
+        if (!trimmed || trimmed.startsWith('@@'))
+            continue;
+        // Capture documentation comments
+        if (trimmed.startsWith('///')) {
+            currentDoc = trimmed.slice(3).trim();
+            continue;
+        }
+        // Skip regular comments
+        if (trimmed.startsWith('//'))
+            continue;
+        // Parse field
+        const field = parseFieldLine(trimmed, enums, currentDoc);
+        if (field) {
+            fields.push(field);
+        }
+        currentDoc = undefined;
+    }
+    return fields;
+}
+function parseFieldLine(line, enums, documentation) {
+    // Match: fieldName Type? @attributes
+    const fieldMatch = line.match(/^(\w+)\s+(\w+)(\[\])?(\?)?(.*)$/);
+    if (!fieldMatch)
+        return null;
+    const [, name, rawType, listMarker, optionalMarker, attributes] = fieldMatch;
+    const type = rawType;
+    const isList = !!listMarker;
+    const isRequired = !optionalMarker && !isList;
+    // Parse attributes
+    const isId = /@id\b/.test(attributes);
+    const isUnique = /@unique\b/.test(attributes);
+    const isUpdatedAt = /@updatedAt\b/.test(attributes);
+    const hasDefault = /@default\b/.test(attributes);
+    // Detect createdAt pattern
+    const isCreatedAt = name.toLowerCase() === 'createdat' ||
+        (type === 'DateTime' && /@default\s*\(\s*now\s*\(\s*\)\s*\)/.test(attributes));
+    // Parse default value
+    let defaultValue;
+    const defaultMatch = attributes.match(/@default\s*\(([^)]+)\)/);
+    if (defaultMatch) {
+        defaultValue = defaultMatch[1].trim();
+    }
+    // Parse relation
+    let relation;
+    const relationMatch = attributes.match(/@relation\s*\(([^)]*)\)/);
+    if (relationMatch || (!SCALAR_TYPES.includes(type) && !enums.has(type))) {
+        relation = {
+            model: type,
+        };
+        if (relationMatch) {
+            const relContent = relationMatch[1];
+            // Parse relation name
+            const nameMatch = relContent.match(/name:\s*"([^"]+)"/);
+            if (nameMatch)
+                relation.name = nameMatch[1];
+            // Parse fields
+            const fieldsMatch = relContent.match(/fields:\s*\[([^\]]+)\]/);
+            if (fieldsMatch) {
+                relation.fields = fieldsMatch[1].split(',').map(f => f.trim());
+            }
+            // Parse references
+            const refsMatch = relContent.match(/references:\s*\[([^\]]+)\]/);
+            if (refsMatch) {
+                relation.references = refsMatch[1].split(',').map(r => r.trim());
+            }
+        }
+    }
+    return {
+        name,
+        type,
+        isRequired,
+        isList,
+        isUnique,
+        isId,
+        isUpdatedAt,
+        isCreatedAt,
+        hasDefault,
+        defaultValue,
+        relation,
+        documentation
+    };
+}
+/**
+ * Get display fields for a model (fields suitable for list view)
+ */
+export function getDisplayFields(model) {
+    return model.fields.filter(f => !f.relation?.fields && // Skip relation foreign keys shown separately
+        !f.isList && // Skip array fields
+        !['password', 'hashedPassword', 'hash', 'secret'].some(hidden => f.name.toLowerCase().includes(hidden)));
+}
+/**
+ * Get editable fields for a model (fields that can be edited in forms)
+ */
+export function getEditableFields(model) {
+    return model.fields.filter(f => !f.isId &&
+        !f.isCreatedAt &&
+        !f.isUpdatedAt &&
+        !f.isList &&
+        !f.relation?.references // Skip the "other side" of relations
+    );
+}
+/**
+ * Get a human-readable label from a field name
+ */
+export function fieldToLabel(fieldName) {
+    return fieldName
+        .replace(/([A-Z])/g, ' $1')
+        .replace(/^./, str => str.toUpperCase())
+        .trim();
+}
+/**
+ * Determine the input type for a Prisma field
+ */
+export function getInputType(field) {
+    if (field.relation)
+        return 'relation';
+    switch (field.type) {
+        case 'String':
+            if (field.name.toLowerCase().includes('email'))
+                return 'email';
+            if (field.name.toLowerCase().includes('password'))
+                return 'password';
+            if (field.name.toLowerCase().includes('url'))
+                return 'url';
+            if (field.name.toLowerCase().includes('description') ||
+                field.name.toLowerCase().includes('content') ||
+                field.name.toLowerCase().includes('bio'))
+                return 'textarea';
+            return 'text';
+        case 'Int':
+        case 'Float':
+        case 'Decimal':
+        case 'BigInt':
+            return 'number';
+        case 'Boolean':
+            return 'checkbox';
+        case 'DateTime':
+            return 'datetime';
+        case 'Json':
+            return 'json';
+        default:
+            return 'text';
+    }
+}