adminizer 4.4.0-build.175 → 4.4.0

package/controllers/ai/AiAssistantController.js

@@ -1,92 +0,0 @@
-import { Adminizer } from '../../lib/Adminizer.js';
-export class AiAssistantController {
-    static async getModels(req, res) {
-        if (!req.adminizer.config.aiAssistant?.enabled) {
-            return res.json([]);
-        }
-        const handler = req.adminizer.aiAssistantHandler;
-        if (!handler) {
-            Adminizer.log.warn('AI assistant handler is not initialized');
-            return res.json([]);
-        }
-        const models = handler
-            .getModels()
-            .filter((model) => req.adminizer.accessRightsHelper.hasPermission(`ai-assistant-${model.id}`, req.user));
-        return res.json(models);
-    }
-    static async getHistory(req, res) {
-        if (!req.adminizer.config.aiAssistant?.enabled) {
-            return res.json({ history: [] });
-        }
-        const { modelId } = req.params;
-        if (!modelId) {
-            return res.status(400).json({ error: 'Model id is required' });
-        }
-        if (!req.adminizer.accessRightsHelper.hasPermission(`ai-assistant-${modelId}`, req.user)) {
-            return res.status(403).json({ error: 'Forbidden' });
-        }
-        const handler = req.adminizer.aiAssistantHandler;
-        if (!handler) {
-            return res.status(500).json({ error: 'AI assistant is not available' });
-        }
-        const history = handler.getHistory(req.user.id, modelId).map(AiAssistantController.serializeMessage);
-        return res.json({ history });
-    }
-    static async sendMessage(req, res) {
-        if (!req.adminizer.config.aiAssistant?.enabled) {
-            return res.status(503).json({ error: 'AI assistant is disabled' });
-        }
-        const { modelId, message } = req.body;
-        if (!modelId || typeof modelId !== 'string') {
-            return res.status(400).json({ error: 'Model id is required' });
-        }
-        if (!message || typeof message !== 'string' || message.trim().length === 0) {
-            return res.status(400).json({ error: 'Message is required' });
-        }
-        if (!req.adminizer.accessRightsHelper.hasPermission(`ai-assistant-${modelId}`, req.user)) {
-            return res.status(403).json({ error: 'Forbidden' });
-        }
-        const handler = req.adminizer.aiAssistantHandler;
-        if (!handler) {
-            return res.status(500).json({ error: 'AI assistant is not available' });
-        }
-        try {
-            const response = await handler.sendMessage(req.user, modelId, message.trim());
-            return res.json({
-                modelId,
-                history: response.history.map(AiAssistantController.serializeMessage),
-            });
-        }
-        catch (error) {
-            Adminizer.log.error('AI assistant error', error);
-            return res.status(500).json({ error: 'Failed to process request' });
-        }
-    }
-    static async resetHistory(req, res) {
-        if (!req.adminizer.config.aiAssistant?.enabled) {
-            return res.status(503).json({ error: 'AI assistant is disabled' });
-        }
-        const { modelId } = req.params;
-        if (!modelId) {
-            return res.status(400).json({ error: 'Model id is required' });
-        }
-        if (!req.adminizer.accessRightsHelper.hasPermission(`ai-assistant-${modelId}`, req.user)) {
-            return res.status(403).json({ error: 'Forbidden' });
-        }
-        const handler = req.adminizer.aiAssistantHandler;
-        if (!handler) {
-            return res.status(500).json({ error: 'AI assistant is not available' });
-        }
-        handler.resetHistory(req.user.id, modelId);
-        return res.json({ history: [] });
-    }
-    static serializeMessage(message) {
-        return {
-            id: message.id,
-            role: message.role,
-            content: message.content,
-            timestamp: message.timestamp instanceof Date ? message.timestamp.toISOString() : message.timestamp,
-            modelId: message.modelId,
-        };
-    }
-}

package/lib/ai-assistant/AbstractAiModelService.d.ts

@@ -1,17 +0,0 @@
-import { Adminizer } from '../Adminizer';
-import { AiAssistantMessage, AiAssistantModelInfo } from '../../interfaces/types';
-import { UserAP } from '../../models/UserAP';
-/**
- * Base class for AI assistant models. It is responsible for registering
- * access rights for the model and providing metadata for the front-end.
- */
-export declare abstract class AbstractAiModelService {
-    protected readonly adminizer: Adminizer;
-    readonly id: string;
-    readonly name: string;
-    readonly description?: string;
-    protected constructor(adminizer: Adminizer, metadata: AiAssistantModelInfo);
-    protected registerAccessRight(): void;
-    getMetadata(): AiAssistantModelInfo;
-    abstract generateReply(prompt: string, history: AiAssistantMessage[], user: UserAP): Promise<string>;
-}

package/lib/ai-assistant/AbstractAiModelService.js

@@ -1,32 +0,0 @@
-/**
- * Base class for AI assistant models. It is responsible for registering
- * access rights for the model and providing metadata for the front-end.
- */
-export class AbstractAiModelService {
-    adminizer;
-    id;
-    name;
-    description;
-    constructor(adminizer, metadata) {
-        this.adminizer = adminizer;
-        this.id = metadata.id;
-        this.name = metadata.name;
-        this.description = metadata.description;
-        this.registerAccessRight();
-    }
-    registerAccessRight() {
-        this.adminizer.accessRightsHelper.registerToken({
-            id: `ai-assistant-${this.id}`,
-            name: this.name,
-            description: `Access to AI assistant model ${this.name}`,
-            department: 'AI Assistant',
-        });
-    }
-    getMetadata() {
-        return {
-            id: this.id,
-            name: this.name,
-            description: this.description,
-        };
-    }
-}

package/lib/ai-assistant/AiAssistantHandler.d.ts

@@ -1,19 +0,0 @@
-import { Adminizer } from '../Adminizer';
-import { AbstractAiModelService } from './AbstractAiModelService';
-import { AiAssistantMessage, AiAssistantModelInfo } from '../../interfaces/types';
-import { UserAP } from '../../models/UserAP';
-export declare class AiAssistantHandler {
-    private readonly adminizer;
-    private readonly models;
-    private readonly history;
-    constructor(adminizer: Adminizer);
-    registerModel(service: AbstractAiModelService): void;
-    getModel(id: string): AbstractAiModelService | undefined;
-    getModels(): AiAssistantModelInfo[];
-    getHistory(userId: number, modelId: string): AiAssistantMessage[];
-    resetHistory(userId: number, modelId: string): void;
-    sendMessage(user: UserAP, modelId: string, prompt: string): Promise<{
-        history: AiAssistantMessage[];
-    }>;
-    private getSessionKey;
-}

package/lib/ai-assistant/AiAssistantHandler.js

@@ -1,58 +0,0 @@
-import { v4 as uuid } from 'uuid';
-import { Adminizer } from '../Adminizer.js';
-export class AiAssistantHandler {
-    adminizer;
-    models = new Map();
-    history = new Map();
-    constructor(adminizer) {
-        this.adminizer = adminizer;
-    }
-    registerModel(service) {
-        if (this.models.has(service.id)) {
-            Adminizer.log.warn(`AI assistant model with id "${service.id}" is already registered. Overwriting.`);
-        }
-        this.models.set(service.id, service);
-    }
-    getModel(id) {
-        return this.models.get(id);
-    }
-    getModels() {
-        return Array.from(this.models.values()).map((service) => service.getMetadata());
-    }
-    getHistory(userId, modelId) {
-        return this.history.get(this.getSessionKey(userId, modelId)) ?? [];
-    }
-    resetHistory(userId, modelId) {
-        this.history.delete(this.getSessionKey(userId, modelId));
-    }
-    async sendMessage(user, modelId, prompt) {
-        const service = this.getModel(modelId);
-        if (!service) {
-            throw new Error(`AI assistant model not found: ${modelId}`);
-        }
-        const sessionKey = this.getSessionKey(user.id, modelId);
-        const currentHistory = [...this.getHistory(user.id, modelId)];
-        const userMessage = {
-            id: uuid(),
-            role: 'user',
-            content: prompt,
-            timestamp: new Date(),
-            modelId,
-        };
-        currentHistory.push(userMessage);
-        const reply = await service.generateReply(prompt, currentHistory, user);
-        const assistantMessage = {
-            id: uuid(),
-            role: 'assistant',
-            content: reply,
-            timestamp: new Date(),
-            modelId,
-        };
-        currentHistory.push(assistantMessage);
-        this.history.set(sessionKey, currentHistory);
-        return { history: currentHistory };
-    }
-    getSessionKey(userId, modelId) {
-        return `${userId}:${modelId}`;
-    }
-}

package/lib/ai-assistant/DummyAiModelService.d.ts

@@ -1,8 +0,0 @@
-import { AbstractAiModelService } from './AbstractAiModelService';
-import { AiAssistantMessage } from '../../interfaces/types';
-import { UserAP } from '../../models/UserAP';
-import { Adminizer } from '../Adminizer';
-export declare class DummyAiModelService extends AbstractAiModelService {
-    constructor(adminizer: Adminizer);
-    generateReply(_prompt: string, _history: AiAssistantMessage[], _user: UserAP): Promise<string>;
-}

package/lib/ai-assistant/DummyAiModelService.js

@@ -1,14 +0,0 @@
-import { AbstractAiModelService } from './AbstractAiModelService.js';
-const DUMMY_RESPONSE = 'Ai-assystant dummy in deveploment';
-export class DummyAiModelService extends AbstractAiModelService {
-    constructor(adminizer) {
-        super(adminizer, {
-            id: 'dummy',
-            name: 'Dummy assistant',
-            description: 'Development placeholder model that returns a static response.',
-        });
-    }
-    async generateReply(_prompt, _history, _user) {
-        return DUMMY_RESPONSE;
-    }
-}

package/lib/ai-assistant/OpenAiModelService.d.ts

@@ -1,24 +0,0 @@
-import { AbstractAiModelService } from './AbstractAiModelService';
-import { AiAssistantMessage } from '../../interfaces/types';
-import { UserAP } from '../../models/UserAP';
-import { Adminizer } from '../Adminizer';
-import { ActionType } from '../../interfaces/adminpanelConfig';
-import { Entity } from '../../interfaces/types';
-import { DataAccessor } from '../DataAccessor';
-type DataAccessorFactory = (entity: Entity, user: UserAP, action: ActionType) => DataAccessor;
-export declare class OpenAiModelService extends AbstractAiModelService {
-    private readonly createAccessor;
-    constructor(adminizer: Adminizer, accessorFactory?: DataAccessorFactory);
-    generateReply(prompt: string, _history: AiAssistantMessage[], user: UserAP): Promise<string>;
-    private handleCreate;
-    private parseInstruction;
-    private usageMessage;
-    private resolveEntity;
-    private normalizeModelConfig;
-    private userHasPermission;
-    private getPermissionToken;
-    private extractPrimaryKey;
-    private extractString;
-    private extractObject;
-}
-export {};

package/lib/ai-assistant/OpenAiModelService.js

@@ -1,185 +0,0 @@
-import { AbstractAiModelService } from './AbstractAiModelService.js';
-import { Adminizer } from '../Adminizer.js';
-import { DataAccessor } from '../DataAccessor.js';
-const ACTION_TOKENS = {
-    add: 'create',
-    edit: 'update',
-    list: 'read',
-    view: 'read',
-    remove: 'delete',
-};
-export class OpenAiModelService extends AbstractAiModelService {
-    createAccessor;
-    constructor(adminizer, accessorFactory) {
-        super(adminizer, {
-            id: 'openai',
-            name: 'OpenAI fixture agent',
-            description: 'Executes structured commands with DataAccessor using the current user permissions.',
-        });
-        this.createAccessor = accessorFactory ?? ((entity, user, action) => new DataAccessor(adminizer, user, entity, action));
-    }
-    async generateReply(prompt, _history, user) {
-        const instruction = this.parseInstruction(prompt);
-        if (!instruction) {
-            return this.usageMessage();
-        }
-        switch (instruction.action) {
-            case 'create':
-                return this.handleCreate(instruction, user);
-            default:
-                return `Unsupported action "${instruction.action}". The OpenAI agent currently supports only the "create" action.`;
-        }
-    }
-    async handleCreate(instruction, user) {
-        const entity = this.resolveEntity(instruction.entity);
-        if (!entity || !entity.model) {
-            return `Model "${instruction.entity}" is not available in this project.`;
-        }
-        if (!this.userHasPermission(entity, user, 'add')) {
-            return `User "${user.login}" does not have permission to create ${entity.name} records.`;
-        }
-        if (!instruction.payload || typeof instruction.payload !== 'object') {
-            return 'The "create" action requires a "data" object with field values.';
-        }
-        try {
-            const accessor = this.createAccessor(entity, user, 'add');
-            const created = await entity.model.create(instruction.payload, accessor);
-            const preview = JSON.stringify(created, null, 2);
-            const recordId = this.extractPrimaryKey(created, entity);
-            const idMessage = recordId !== undefined ? ` (id: ${recordId})` : '';
-            return `Record created in ${entity.name}${idMessage}:\n${preview}`;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            Adminizer.log.error('OpenAI agent failed to create record', error);
-            return `Failed to create ${entity.name} record: ${message}`;
-        }
-    }
-    parseInstruction(prompt) {
-        try {
-            const parsed = JSON.parse(prompt);
-            if (!parsed || typeof parsed !== 'object') {
-                return null;
-            }
-            const rawAction = this.extractString(parsed, ['action', 'type']);
-            if (!rawAction) {
-                return null;
-            }
-            const action = rawAction.toLowerCase();
-            if (!['create', 'list', 'update', 'delete'].includes(action)) {
-                return null;
-            }
-            const entity = this.extractString(parsed, ['entity', 'model']);
-            if (!entity) {
-                return null;
-            }
-            const payload = this.extractObject(parsed, ['data', 'payload', 'record']);
-            const criteria = this.extractObject(parsed, ['criteria', 'where', 'filter']);
-            return {
-                action: action,
-                entity,
-                payload,
-                criteria,
-            };
-        }
-        catch {
-            return null;
-        }
-    }
-    usageMessage() {
-        return [
-            'Provide JSON instructions so the OpenAI agent can execute them with your permissions.',
-            'Example:',
-            '```json',
-            '{',
-            '  "action": "create",',
-            '  "entity": "Example",',
-            '  "data": { "title": "Hello from the agent" }',
-            '}',
-            '```',
-            'The agent uses DataAccessor, so any field-level restrictions from your account are respected.',
-        ].join('\n');
-    }
-    resolveEntity(modelName) {
-        const models = this.adminizer.config.models;
-        if (!models) {
-            return null;
-        }
-        const loweredName = modelName.toLowerCase();
-        const match = Object.entries(models).find(([key, config]) => {
-            if (key.toLowerCase() === loweredName) {
-                return true;
-            }
-            if (typeof config === 'object' && config && 'model' in config && typeof config.model === 'string') {
-                return config.model.toLowerCase() === loweredName;
-            }
-            return false;
-        });
-        if (!match) {
-            return null;
-        }
-        const [configName, configValue] = match;
-        const normalizedConfig = this.normalizeModelConfig(configName, configValue);
-        const model = this.adminizer.modelHandler.model.get(normalizedConfig.model);
-        if (!model) {
-            return null;
-        }
-        return {
-            name: configName,
-            uri: `${this.adminizer.config.routePrefix}/model/${configName}`,
-            type: 'model',
-            config: normalizedConfig,
-            model,
-        };
-    }
-    normalizeModelConfig(name, config) {
-        const baseConfig = {
-            model: name,
-            icon: 'description',
-            title: name,
-            list: true,
-            add: true,
-            edit: true,
-            remove: true,
-            view: true,
-        };
-        if (typeof config === 'boolean') {
-            return config ? baseConfig : { ...baseConfig, list: false, add: false, edit: false, remove: false, view: false };
-        }
-        return { ...baseConfig, ...config };
-    }
-    userHasPermission(entity, user, action) {
-        const token = this.getPermissionToken(entity, action);
-        return this.adminizer.accessRightsHelper.hasPermission(token, user);
-    }
-    getPermissionToken(entity, action) {
-        const verb = ACTION_TOKENS[action];
-        const modelName = entity.model?.modelname ?? entity.config?.model ?? entity.name;
-        return `${verb}-${modelName}-${entity.type}`.toLowerCase();
-    }
-    extractPrimaryKey(record, entity) {
-        if (!record) {
-            return undefined;
-        }
-        const primaryKey = entity.model?.primaryKey ?? 'id';
-        return record[primaryKey];
-    }
-    extractString(source, keys) {
-        for (const key of keys) {
-            const value = source?.[key];
-            if (typeof value === 'string' && value.trim().length > 0) {
-                return value.trim();
-            }
-        }
-        return undefined;
-    }
-    extractObject(source, keys) {
-        for (const key of keys) {
-            const value = source?.[key];
-            if (value && typeof value === 'object' && !Array.isArray(value)) {
-                return value;
-            }
-        }
-        return undefined;
-    }
-}

package/system/bindAiAssistant.d.ts

@@ -1,2 +0,0 @@
-import { Adminizer } from '../lib/Adminizer';
-export declare function bindAiAssistant(adminizer: Adminizer): Promise<void>;

package/system/bindAiAssistant.js

@@ -1,30 +0,0 @@
-import { Adminizer } from '../lib/Adminizer.js';
-import { AiAssistantHandler } from '../lib/ai-assistant/AiAssistantHandler.js';
-import { DummyAiModelService } from '../lib/ai-assistant/DummyAiModelService.js';
-import { OpenAiModelService } from '../lib/ai-assistant/OpenAiModelService.js';
-const modelFactories = {
-    dummy: (adminizer) => new DummyAiModelService(adminizer),
-    openai: (adminizer) => new OpenAiModelService(adminizer),
-};
-export async function bindAiAssistant(adminizer) {
-    // Early return if AI assistant is disabled
-    if (!adminizer.config.aiAssistant?.enabled) {
-        Adminizer.log.info('AI assistant is disabled in configuration. Skipping initialization.');
-        return;
-    }
-    adminizer.aiAssistantHandler = new AiAssistantHandler(adminizer);
-    const configModels = adminizer.config.aiAssistant?.models;
-    const requestedModels = Array.isArray(configModels) && configModels.length > 0
-        ? configModels
-        : ['dummy'];
-    requestedModels.forEach((modelId) => {
-        const factory = modelFactories[modelId];
-        if (!factory) {
-            Adminizer.log.warn(`AI assistant model "${modelId}" is not registered. Skipping.`);
-            return;
-        }
-        const service = factory(adminizer);
-        adminizer.aiAssistantHandler.registerModel(service);
-    });
-    Adminizer.log.info(`AI assistant initialized with models: ${adminizer.aiAssistantHandler.getModels().map((m) => m.id).join(', ')}`);
-}