adminizer 5.0.0-build.2 → 5.0.0-build.21

package/lib/DataAccessor.js

@@ -46,29 +46,28 @@ export class DataAccessor {
         this.action = action;
         this.actionVerb = getTokenAction(this.action);
     }
-    getModelConfig(modelName) {
-        const resolvedModelName = this.adminizer.modelHandler.resolveModelName(modelName);
-        const entry = Object.entries(this.adminizer.config.models)
-            .find(([key, config]) => {
-            if (key.toLowerCase() === resolvedModelName.toLowerCase()) {
-                return true;
-            }
-            if (!isObject(config)) {
-                return false;
-            }
-            return config.model?.toLowerCase() === resolvedModelName.toLowerCase();
-        });
-        const config = entry ? entry[1] : undefined;
+    getModelConfig(resourceName) {
+        const config = this.adminizer.config.models?.[resourceName];
         return isObject(config) ? config : undefined;
     }
-    accessRelationModel(modelName) {
-        return this.adminizer.modelHandler.internal("data-accessor").get(modelName);
+    accessRelationModel(modelName, resourceName) {
+        const resolvedResourceName = this.resolveRelationTarget(modelName, resourceName);
+        if (!resolvedResourceName) {
+            throw new Error(`Relation model "${modelName}" was not found`);
+        }
+        return this.adminizer.modelHandler.internal("data-accessor").get(resolvedResourceName);
     }
-    resolveRelationTarget(modelName) {
+    resolveRelationTarget(modelName, resourceName) {
         if (!modelName) {
             return undefined;
         }
-        return this.adminizer.modelHandler.resolveModelName(modelName).toLowerCase();
+        return this.adminizer.modelHandler.resolveAssociationResource(modelName, resourceName);
+    }
+    getRelationModel(modelName, resourceName) {
+        const resolvedResourceName = this.resolveRelationTarget(modelName, resourceName);
+        return resolvedResourceName
+            ? this.adminizer.modelHandler.getResource(resolvedResourceName)
+            : undefined;
     }
     /**
      * Retrieves the fields for the given ModelResource based on action type,
@@ -86,9 +85,9 @@ export class DataAccessor {
         const actionConfig = ControllerHelper.findActionConfig(this.modelResource, this.action);
         const fieldsConfig = this.modelResource.config?.fields || {};
         const modelAttributes = this.modelResource.model.attributes;
-        const tokenId = `${this.actionVerb}-${this.modelResource.model.modelname}-${MODEL_TOKEN_SUFFIX}`;
+        const tokenId = `${this.actionVerb}-${this.modelResource.name}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} model: ${this.modelResource.model.modelname}`);
+            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} model: ${this.modelResource.name}`);
             return undefined;
         }
         const result = {};
@@ -131,14 +130,14 @@ export class DataAccessor {
             let populatedModelFieldsConfig = {};
             if (modelField.type === "association" || modelField.type === "association-many") {
                 const modelName = modelField.model || modelField.collection;
-                const resolvedModelName = modelName ? this.adminizer.modelHandler.resolveModelName(modelName) : undefined;
+                const resolvedModelName = this.resolveRelationTarget(modelName, modelField.resourceName);
                 if (modelName && resolvedModelName) {
                     const tokenId = `read-${resolvedModelName}-${MODEL_TOKEN_SUFFIX}`;
                     if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-                        Adminizer.log.silly(`No access rights to model: ${this.modelResource.model.modelname}`);
+                        Adminizer.log.silly(`No access rights to model: ${this.modelResource.name}`);
                         return undefined;
                     }
-                    const model = this.adminizer.modelHandler.model.get(modelName);
+                    const model = this.adminizer.modelHandler.getResource(resolvedModelName);
                     if (model) {
                         populatedModelFieldsConfig = this.getAssociatedFieldsConfig(resolvedModelName);
                         const modelCfg = this.getModelConfig(resolvedModelName);
@@ -157,7 +156,11 @@ export class DataAccessor {
             // Set required and type attributes
             fldConfig.required = Boolean(fldConfig.required ?? modelField.required);
             // Default type for field. Could be fetched from config file or model if not defined in config file.
-            fldConfig.type = (fldConfig.type || modelField.type).toLowerCase();
+            // The model layer has a single temporal type (`date`), the UI distinguishes
+            // date/datetime/time. Default to `datetime` so the time part survives editing;
+            // a date-only column can be narrowed with `type: "date"` in the model config.
+            const modelFieldType = modelField.type === "date" ? "datetime" : modelField.type;
+            fldConfig.type = (fldConfig.type || modelFieldType).toLowerCase();
             // Normalize final configuration (fldConfig is always an object here, normalize never returns undefined)
             fldConfig = this.adminizer.configHelper.normalizeFieldConfig(this.adminizer, fldConfig, key, modelField);
             // Add new field to result set
@@ -182,17 +185,16 @@ export class DataAccessor {
         Object.keys(fields).forEach(appendField);
         return orderedFields;
     }
-    getAssociatedFieldsConfig(modelName) {
-        const resolvedModelName = this.adminizer.modelHandler.resolveModelName(modelName);
-        const model = this.adminizer.modelHandler.model.get(resolvedModelName);
-        const modelConfig = this.getModelConfig(resolvedModelName);
+    getAssociatedFieldsConfig(resourceName) {
+        const model = this.adminizer.modelHandler.getResource(resourceName);
+        const modelConfig = this.getModelConfig(resourceName);
         if (!model || !modelConfig) {
             return undefined;
         }
         // Check if user has access to the associated model
-        const tokenId = `read-${resolvedModelName}-${MODEL_TOKEN_SUFFIX}`;
+        const tokenId = `read-${resourceName}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} model: ${resolvedModelName}`);
+            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} model: ${resourceName}`);
             return undefined;
         }
         const associatedFields = {};
@@ -375,7 +377,7 @@ export class DataAccessor {
     async sanitizeUserRelationAccess(criteria = {}) {
         let sanitizedCriteria = {};
         // Retrieve model configuration from adminpanel config
-        const modelName = this.modelResource.model.modelname;
+        const modelName = this.modelResource.name;
         const modelConfig = this.modelResource.config;
         // Check if the model has `userAccessRelation` configured
         if (!this.user.isAdministrator && modelConfig && modelConfig.userAccessRelation) {
@@ -388,18 +390,18 @@ export class DataAccessor {
                 // Check if the relation points to `User` or `Group` in the model's attributes
                 const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
-                const relationModel = this.resolveRelationTarget(relation?.model);
-                const relationCollection = this.resolveRelationTarget(relation?.collection);
-                if (!relation || !['user', 'group'].includes(relationModel ?? relationCollection ?? "")) {
+                const relationModel = this.resolveRelationTarget(relation?.model, relation?.resourceName);
+                const relationCollection = this.resolveRelationTarget(relation?.collection, relation?.resourceName);
+                if (!relation || !['User', 'Group'].includes(relationModel ?? relationCollection ?? "")) {
                     throw new Error(`Invalid userAccessRelation configuration for model ${modelName}`);
                 }
                 // Determine if the current user matches the access criteria
                 if (relationModel) {
-                    if (relationModel === 'user') {
+                    if (relationModel === 'User') {
                         // Filter by the user's ID if related to User as a model
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: this.user.id };
                     }
-                    else if (relationModel === 'group') {
+                    else if (relationModel === 'Group') {
                         // Filter by user's group membership if related to Group as a model
                         const userGroups = this.user.groups?.map((group) => group.id);
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { in: userGroups } };
@@ -408,11 +410,11 @@ export class DataAccessor {
                 /** Warning: collection relation access is not supported and needs adapter-level processing */
                 if (relationCollection) {
                     Adminizer.log.warn(`Collection relation is not supported and was not tested. You may have an error here: ${JSON.stringify(relation, null, 2)}`);
-                    if (relationCollection === 'user') {
+                    if (relationCollection === 'User') {
                         // Ensure user's ID is part of the associated collection to User
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { contains: this.user.id } };
                     }
-                    else if (relationCollection === 'group') {
+                    else if (relationCollection === 'Group') {
                         // Ensure user's groups intersect with the collection to Group
                         const userGroups = this.user.groups?.map((group) => group.id);
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { intersects: userGroups } };
@@ -429,19 +431,19 @@ export class DataAccessor {
                     throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${modelName}`);
                 }
                 // Retrieve the intermediate model
-                const intermediateModel = this.adminizer.modelHandler.model.get(intermediateRelation.model.toLowerCase());
+                const intermediateModel = this.getRelationModel(intermediateRelation.model, intermediateRelation.resourceName);
                 if (!intermediateModel) {
                     throw new Error(`Intermediate model "${intermediateRelation.model}" not found`);
                 }
                 // Validate the `via` field in the intermediate model
                 const intermediateAttributes = intermediateModel.attributes;
                 const viaRelation = intermediateAttributes[via];
-                if (!viaRelation || this.resolveRelationTarget(viaRelation.model) !== 'user') {
+                if (!viaRelation || this.resolveRelationTarget(viaRelation.model, viaRelation.resourceName) !== 'User') {
                     throw new Error(`Unsupported or invalid via field "${via}" in intermediate model "${intermediateRelation.model}". ` +
                         `Currently, only relations to "User" are supported`);
                 }
                 // Fetch all intermediate records associated with the user
-                const intermediateRecords = await this.accessRelationModel(intermediateRelation.model).find({ where: { [via]: this.user.id } });
+                const intermediateRecords = await this.accessRelationModel(intermediateRelation.model, intermediateRelation.resourceName).find({ where: { [via]: this.user.id } });
                 const intermediateIds = (intermediateRecords || []).map((r) => r.id);
                 // Filter main model by all matching intermediate record IDs
                 sanitizedCriteria = { ...sanitizedCriteria, [field]: { in: intermediateIds } };
@@ -467,14 +469,14 @@ export class DataAccessor {
                 // Check if the relation points to `User` or `Group` in the model's attributes
                 const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
-                const relationModel = this.resolveRelationTarget(relation?.model);
-                if (relation && ['user', 'group'].includes(relationModel ?? "")) {
-                    if (relationModel === 'user') {
+                const relationModel = this.resolveRelationTarget(relation?.model, relation?.resourceName);
+                if (relation && ['User', 'Group'].includes(relationModel ?? "")) {
+                    if (relationModel === 'User') {
                         if (!this.user.isAdministrator) {
                             updatedRecord[accessField] = this.user.id;
                         }
                     }
-                    else if (relationModel === 'group') {
+                    else if (relationModel === 'Group') {
                         const userGroups = this.user.groups || [];
                         if (userGroups.length === 1) {
                             updatedRecord[accessField] = userGroups[0].id;
@@ -496,16 +498,16 @@ export class DataAccessor {
                     const modelAttributes = this.modelResource.model.attributes;
                     const intermediateRelation = modelAttributes[field];
                     if (!intermediateRelation || !intermediateRelation.model) {
-                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.modelResource.model.modelname}`);
+                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.modelResource.name}`);
                     }
-                    const intermediateModel = this.adminizer.modelHandler.model.get(intermediateRelation.model.toLowerCase());
+                    const intermediateModel = this.getRelationModel(intermediateRelation.model, intermediateRelation.resourceName);
                     if (!intermediateModel) {
                         throw new Error(`Intermediate model "${intermediateRelation.model}" not found`);
                     }
                     // Validate the `via` field in the intermediate model
                     const intermediateAttributes = intermediateModel.attributes;
                     const viaRelation = intermediateAttributes[via];
-                    if (!viaRelation || this.resolveRelationTarget(viaRelation.model) !== 'user') {
+                    if (!viaRelation || this.resolveRelationTarget(viaRelation.model, viaRelation.resourceName) !== 'User') {
                         throw new Error(`Unsupported or invalid via field "${via}" in intermediate model "${intermediateRelation.model}". ` +
                             `Currently, only relations to "User" are supported`);
                     }
@@ -513,7 +515,7 @@ export class DataAccessor {
                     const chosenId = typeof updatedRecord[field] === 'object'
                         ? updatedRecord[field][intermediatePk]
                         : updatedRecord[field];
-                    const record = await this.accessRelationModel(intermediateRelation.model).findOne({ where: { [intermediatePk]: chosenId, [via]: this.user.id } });
+                    const record = await this.accessRelationModel(intermediateRelation.model, intermediateRelation.resourceName).findOne({ where: { [intermediatePk]: chosenId, [via]: this.user.id } });
                     if (!record) {
                         throw new Error(`Access denied: "${field}" does not belong to the current user`);
                     }

package/lib/MiddlewareManager.d.ts

@@ -1,4 +1,4 @@
-import { Adminizer } from "./Adminizer";
+import { Adminizer } from "./Adminizer.js";
 declare class MiddlewareManager {
     private readonly _adminizer;
     constructor(adminizer: Adminizer);

package/lib/access-rights/AccessRightsHandler.d.ts

@@ -1,5 +1,5 @@
-import type { AccessRightsToken } from "../../interfaces/types";
-import type { Adminizer } from "../Adminizer";
+import type { AccessRightsToken } from "../../interfaces/types.js";
+import type { Adminizer } from "../Adminizer.js";
 export interface AccessRightsRecord {
     id: string;
     appName: string;

package/lib/admin-links/AdminLinkHandler.d.ts

@@ -0,0 +1,72 @@
+import type { User } from '../../models/User.js';
+import type { Adminizer } from '../Adminizer.js';
+export interface AdminLink {
+    id: string;
+    type: string;
+    name: string;
+    link: string;
+    title?: string;
+    section?: string;
+    accessRightsToken?: string;
+}
+export interface ResolvedAdminLink extends AdminLink {
+    owner: string;
+    title: string;
+}
+/** A placeholder of an admin link template, e.g. `id` in `/model/Test/edit/:id`. */
+export interface AdminLinkTemplateParam {
+    name: string;
+    description?: string;
+}
+/**
+ * A parametrized admin page, e.g. `/admin/model/Test/edit/:id`. Templates are
+ * what makes a record page reachable: the concrete URL only exists once the
+ * caller knows the record id.
+ */
+export interface AdminLinkTemplate {
+    id: string;
+    title: string;
+    /** Absolute admin path with `:param` placeholders. */
+    template: string;
+    description?: string;
+    section?: string;
+    accessRightsToken?: string;
+    /** Placeholder descriptions; placeholders absent here are still required. */
+    params?: AdminLinkTemplateParam[];
+}
+export interface ResolvedAdminLinkTemplate extends AdminLinkTemplate {
+    owner: string;
+    params: AdminLinkTemplateParam[];
+}
+/** Server-side registry of standalone admin pages contributed by applications. */
+export declare class AdminLinkHandler {
+    private readonly adminizer;
+    private readonly links;
+    private readonly templates;
+    constructor(adminizer: Adminizer);
+    add(link: AdminLink, owner?: string): string;
+    remove(id: string, owner?: string): boolean;
+    list(user: User, type?: string): ResolvedAdminLink[];
+    resolve(user: User, type: string, name: string): ResolvedAdminLink | undefined;
+    addTemplate(template: AdminLinkTemplate, owner?: string): string;
+    removeTemplate(id: string, owner?: string): boolean;
+    /**
+     * Every parametrized page this user may open: model record pages, catalog
+     * items, templates registered by apps and any navigation link that carries
+     * placeholders of its own.
+     */
+    listTemplates(user: User): ResolvedAdminLinkTemplate[];
+    /**
+     * Turns a template id (or its title) plus placeholder values into a real
+     * admin URL, rejecting templates this user may not open.
+     */
+    resolveTemplate(user: User, id: string, params?: Record<string, unknown>): string;
+    /** Fills the placeholders of a template with url-encoded values. */
+    buildHref(template: ResolvedAdminLinkTemplate, params?: Record<string, unknown>): string;
+    /** True for paths that change data and therefore must never be navigated to. */
+    isDestructivePath(path: string): boolean;
+    /** Templates derived from the current configuration, catalogs and navigation. */
+    private builtinTemplates;
+    private describeParams;
+    private slug;
+}

package/lib/admin-links/AdminLinkHandler.js

@@ -0,0 +1,175 @@
+/** Segments no template may point at: opening one mutates data. */
+const DESTRUCTIVE_PATH = /\/model\/[^/]+\/remove(\/|$)/i;
+/** Server-side registry of standalone admin pages contributed by applications. */
+export class AdminLinkHandler {
+    adminizer;
+    links = new Map();
+    templates = new Map();
+    constructor(adminizer) {
+        this.adminizer = adminizer;
+    }
+    add(link, owner = 'host') {
+        const type = link.type.trim();
+        const name = link.name.trim();
+        const href = link.link.trim();
+        if (!type || !name || !href)
+            throw new Error('Admin link requires type, name and link');
+        if (!href.startsWith('/'))
+            throw new Error(`Admin link "${name}" must use an absolute admin path`);
+        const id = `${this.slug(type)}:${this.slug(name)}`;
+        if (this.links.has(id))
+            throw new Error(`Admin link "${id}" is already registered`);
+        this.links.set(id, {
+            ...link, id, type, name, link: href, owner,
+            title: link.title?.trim() || name,
+            section: link.section?.trim() || undefined,
+        });
+        return id;
+    }
+    remove(id, owner) {
+        const link = this.links.get(id);
+        if (!link || (owner && link.owner !== owner))
+            return false;
+        return this.links.delete(id);
+    }
+    list(user, type) {
+        const wanted = type ? this.slug(type) : null;
+        return [...this.links.values()].filter((link) => (!wanted || this.slug(link.type) === wanted)
+            && (!link.accessRightsToken || this.adminizer.accessRightsHelper.hasPermission(link.accessRightsToken, user)));
+    }
+    resolve(user, type, name) {
+        const wanted = this.slug(name);
+        return this.list(user, type).find((link) => this.slug(link.name) === wanted || this.slug(link.title) === wanted);
+    }
+    addTemplate(template, owner = 'host') {
+        const id = template.id.trim();
+        const title = template.title.trim();
+        const path = template.template.trim();
+        if (!id || !title || !path)
+            throw new Error('Admin link template requires id, title and template');
+        if (!path.startsWith('/'))
+            throw new Error(`Admin link template "${id}" must use an absolute admin path`);
+        if (this.templates.has(id))
+            throw new Error(`Admin link template "${id}" is already registered`);
+        this.templates.set(id, {
+            ...template, id, title, template: path, owner,
+            description: template.description?.trim() || undefined,
+            section: template.section?.trim() || undefined,
+            params: this.describeParams(path, template.params),
+        });
+        return id;
+    }
+    removeTemplate(id, owner) {
+        const template = this.templates.get(id);
+        if (!template || (owner && template.owner !== owner))
+            return false;
+        return this.templates.delete(id);
+    }
+    /**
+     * Every parametrized page this user may open: model record pages, catalog
+     * items, templates registered by apps and any navigation link that carries
+     * placeholders of its own.
+     */
+    listTemplates(user) {
+        const templates = [];
+        const push = (template) => {
+            if (DESTRUCTIVE_PATH.test(template.template))
+                return;
+            if (template.accessRightsToken && !this.adminizer.accessRightsHelper.hasPermission(template.accessRightsToken, user))
+                return;
+            if (templates.some((existing) => existing.template === template.template || existing.id === template.id))
+                return;
+            templates.push(template);
+        };
+        for (const template of this.builtinTemplates(user))
+            push(template);
+        for (const template of this.templates.values())
+            push(template);
+        return templates;
+    }
+    /**
+     * Turns a template id (or its title) plus placeholder values into a real
+     * admin URL, rejecting templates this user may not open.
+     */
+    resolveTemplate(user, id, params = {}) {
+        const wanted = this.slug(id);
+        const available = this.listTemplates(user);
+        const template = available.find((candidate) => this.slug(candidate.id) === wanted)
+            ?? available.find((candidate) => this.slug(candidate.title) === wanted || this.slug(candidate.template) === wanted);
+        if (!template)
+            throw new Error(`Admin link template "${id}" is not available`);
+        return this.buildHref(template, params);
+    }
+    /** Fills the placeholders of a template with url-encoded values. */
+    buildHref(template, params = {}) {
+        return template.template.replace(/:([A-Za-z0-9_]+)/g, (_match, name) => {
+            const value = params[name];
+            if (value === undefined || value === null || value === '') {
+                throw new Error(`Admin link template "${template.id}" requires the "${name}" parameter`);
+            }
+            return encodeURIComponent(String(value));
+        });
+    }
+    /** True for paths that change data and therefore must never be navigated to. */
+    isDestructivePath(path) {
+        return DESTRUCTIVE_PATH.test(path);
+    }
+    /** Templates derived from the current configuration, catalogs and navigation. */
+    builtinTemplates(user) {
+        const prefix = (this.adminizer.config.routePrefix || '').replace(/\/+$/, '');
+        const templates = [];
+        const builtin = (id, title, path, accessRightsToken, description, section, params = []) => {
+            templates.push({
+                id, title, template: path, accessRightsToken, description, section, owner: 'host',
+                params: this.describeParams(path, params),
+            });
+        };
+        const recordId = [
+            { name: 'id', description: 'Identifier of the record, as returned when reading its data.' },
+        ];
+        for (const [model, config] of Object.entries(this.adminizer.config.models ?? {})) {
+            const title = typeof config === 'object' && config?.title ? config.title : model;
+            const section = typeof config === 'object' ? config?.navbar?.section : undefined;
+            builtin(`model-${model}-edit`, `${title}: open record`, `${prefix}/model/${model}/edit/:id`, `update-${model}-model`, `Open the edit page of a single ${title} record by its id.`, section, recordId);
+            builtin(`model-${model}-add`, `${title}: create record`, `${prefix}/model/${model}/add`, `create-${model}-model`, `Open the create form of ${title}.`, section);
+        }
+        for (const catalog of this.adminizer.catalogHandler.getAll()) {
+            if (!catalog?.slug)
+                continue;
+            builtin(`catalog-${catalog.slug}-item`, `${catalog.name || catalog.slug}: open item`, `${prefix}/catalog/${catalog.slug}/:id`, `catalog-${catalog.slug}`, `Open a single item of the ${catalog.name || catalog.slug} catalog by its id.`, undefined, recordId);
+        }
+        // Navigation links may carry placeholders themselves (app pages, custom
+        // tools). Such a link cannot be opened as-is, so it is a template.
+        const fromNavigation = (item, section) => {
+            const path = typeof item?.link === 'string' ? item.link : '';
+            if (path.startsWith('/') && /:[A-Za-z0-9_]+/.test(path) && item.title) {
+                templates.push({
+                    id: `link-${this.slug(String(item.id || item.title))}`,
+                    title: String(item.title),
+                    template: path,
+                    section: item.section || section,
+                    accessRightsToken: item.accessRightsToken || undefined,
+                    owner: 'host',
+                    params: this.describeParams(path),
+                });
+            }
+            for (const child of item?.actions ?? item?.subItems ?? [])
+                fromNavigation(child, item?.section || section);
+        };
+        for (const item of this.adminizer.menuHelper.getMenuItems(user))
+            fromNavigation(item, item.section);
+        for (const link of this.links.values())
+            fromNavigation(link, link.section);
+        return templates;
+    }
+    describeParams(path, described = []) {
+        const names = [...path.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1]);
+        return [...new Set(names)].map((name) => ({
+            name,
+            description: described.find((param) => param.name === name)?.description,
+        }));
+    }
+    slug(value) {
+        return String(value).trim().toLowerCase().replace(/[\s_-]+/g, '-');
+    }
+}

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

@@ -0,0 +1,39 @@
+import type { Adminizer } from '../Adminizer.js';
+import type { AbstractAiModelService } from './AbstractAiModelService.js';
+import type { User } from '../../models/User.js';
+export interface AiConversation {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    messages: Array<Record<string, unknown>>;
+}
+/**
+ * Storage contract for an agent's dialogs. Applications can extend this class
+ * to persist conversations in their own database instead of process memory.
+ */
+export declare abstract class AbstractAiConversationHistoryService {
+    protected agent: AbstractAiModelService;
+    protected adminizer: Adminizer;
+    initialize(agent: AbstractAiModelService, adminizer: Adminizer): void;
+    abstract list(user: User): AiConversation[];
+    abstract getActive(user: User): AiConversation;
+    abstract create(user: User, title?: string): AiConversation;
+    abstract select(user: User, conversationId: string): AiConversation | undefined;
+    abstract remove(user: User, conversationId: string): boolean;
+    abstract saveActive(user: User, messages: Array<Record<string, unknown>>, title?: string): AiConversation;
+}
+/** Default storage used when an agent does not provide a database-backed one. */
+export declare class InMemoryAiConversationHistoryService extends AbstractAiConversationHistoryService {
+    private readonly conversations;
+    private readonly activeConversationIds;
+    list(user: User): AiConversation[];
+    getActive(user: User): AiConversation;
+    create(user: User, title?: string): AiConversation;
+    select(user: User, conversationId: string): AiConversation | undefined;
+    remove(user: User, conversationId: string): boolean;
+    saveActive(user: User, messages: Array<Record<string, unknown>>, title?: string): AiConversation;
+    private getConversations;
+    private getKey;
+    private findFirstUserText;
+}

package/lib/ai-assistant/AbstractAiConversationHistoryService.js

@@ -0,0 +1,98 @@
+/**
+ * Storage contract for an agent's dialogs. Applications can extend this class
+ * to persist conversations in their own database instead of process memory.
+ */
+export class AbstractAiConversationHistoryService {
+    agent;
+    adminizer;
+    initialize(agent, adminizer) {
+        this.agent = agent;
+        this.adminizer = adminizer;
+    }
+}
+/** Default storage used when an agent does not provide a database-backed one. */
+export class InMemoryAiConversationHistoryService extends AbstractAiConversationHistoryService {
+    conversations = new Map();
+    activeConversationIds = new Map();
+    list(user) {
+        return [...this.getConversations(user)]
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    }
+    getActive(user) {
+        const key = this.getKey(user);
+        const conversations = this.getConversations(user);
+        const activeId = this.activeConversationIds.get(key);
+        const active = conversations.find((conversation) => conversation.id === activeId);
+        if (active)
+            return active;
+        const conversation = this.create(user);
+        this.activeConversationIds.set(key, conversation.id);
+        return conversation;
+    }
+    create(user, title = 'New conversation') {
+        const now = new Date().toISOString();
+        const conversation = {
+            id: `conversation-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+            title,
+            createdAt: now,
+            updatedAt: now,
+            messages: [],
+        };
+        this.getConversations(user).push(conversation);
+        this.activeConversationIds.set(this.getKey(user), conversation.id);
+        return conversation;
+    }
+    select(user, conversationId) {
+        const conversation = this.getConversations(user).find((item) => item.id === conversationId);
+        if (conversation)
+            this.activeConversationIds.set(this.getKey(user), conversation.id);
+        return conversation;
+    }
+    remove(user, conversationId) {
+        const conversations = this.getConversations(user);
+        const index = conversations.findIndex((conversation) => conversation.id === conversationId);
+        if (index < 0)
+            return false;
+        conversations.splice(index, 1);
+        if (this.activeConversationIds.get(this.getKey(user)) === conversationId) {
+            this.activeConversationIds.delete(this.getKey(user));
+        }
+        return true;
+    }
+    saveActive(user, messages, title) {
+        const conversation = this.getActive(user);
+        conversation.messages = messages;
+        conversation.updatedAt = new Date().toISOString();
+        if (title)
+            conversation.title = title;
+        else if (conversation.title === 'New conversation') {
+            const firstText = this.findFirstUserText(messages);
+            if (firstText)
+                conversation.title = firstText.slice(0, 80);
+        }
+        return conversation;
+    }
+    getConversations(user) {
+        const key = this.getKey(user);
+        let conversations = this.conversations.get(key);
+        if (!conversations) {
+            conversations = [];
+            this.conversations.set(key, conversations);
+        }
+        return conversations;
+    }
+    getKey(user) {
+        return `${user.id}:${this.agent.id}`;
+    }
+    findFirstUserText(messages) {
+        const message = messages.find((item) => item.role === 'user');
+        const content = message?.content;
+        if (typeof content === 'string')
+            return content.trim();
+        if (Array.isArray(content)) {
+            const text = content.find((part) => part && typeof part === 'object' && part.type === 'text');
+            return typeof text?.text === 'string' ? text.text.trim() : undefined;
+        }
+        return undefined;
+    }
+}