@drax/ai-back 3.43.0 → 3.44.0

package/dist/index.js

@@ -44,7 +44,8 @@ import TTSRoutes from "./routes/TTSRoutes.js";
 import DraxAgentRoutes from "./routes/DraxAgentRoutes.js";
 import AgentSessionRoutes from "./routes/AgentSessionRoutes.js";
 import { DraxAgent } from "./agents/DraxAgent.js";
-export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, DeepSeekConfig, ElevenLabsTTSConfig, AILogSchema, AILogBaseSchema, TTSRequestSchema, TTSVoiceSettingsSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, DeepSeekAiProviderFactory, AiProviderFactory, ElevenLabsTTSProviderFactory, TTSProviderFactory, DraxAgentFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, DeepSeekAiProvider, ElevenLabsTTSProvider, BuilderTool, 
+import { BuildContextTool } from "./tools/BuildContextTool.js";
+export { OpenAiConfig, GoogleAiConfig, OllamaAiConfig, DeepSeekConfig, ElevenLabsTTSConfig, AILogSchema, AILogBaseSchema, TTSRequestSchema, TTSVoiceSettingsSchema, AILogModel, AILogMongoRepository, AILogSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, DeepSeekAiProviderFactory, AiProviderFactory, ElevenLabsTTSProviderFactory, TTSProviderFactory, DraxAgentFactory, AILogServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, DeepSeekAiProvider, ElevenLabsTTSProvider, BuilderTool, BuildContextTool, 
 //Service
 KnowledgeService, AILogService, TTSGenericService, PromptAudioService, 
 //Permissions

package/dist/tools/BuildContextTool.js

@@ -0,0 +1,267 @@
+import { setNestedValue, UnauthorizedError } from "@drax/common-back";
+import { BuilderTool } from "./BuilderTool.js";
+class BuildContextTool extends BuilderTool {
+    constructor(options) {
+        super({
+            ...options,
+            service: BuildContextTool.createContextService(options),
+        });
+    }
+    static fromPromptContext(options, promptContext) {
+        return new BuildContextTool({
+            ...options,
+            context: {
+                userId: promptContext.input?.userId ?? promptContext.session.userId ?? null,
+                tenantId: promptContext.input?.tenantId ?? promptContext.session.tenantId ?? null,
+            },
+        });
+    }
+    static createContextService(options) {
+        const service = options.service;
+        const helper = new BuildContextToolServiceHelper(options);
+        const contextService = { ...service };
+        if (typeof service.create === "function") {
+            contextService.create = async (data) => service.create?.(helper.applySetters(helper.clonePayload(data)));
+        }
+        if (typeof service.update === "function") {
+            contextService.update = async (id, data) => {
+                const preItem = await service.findById?.(id);
+                helper.assertWritable(preItem, "update");
+                const payload = helper.removeSetterFields(helper.clonePayload(data));
+                return service.update?.(id, payload);
+            };
+        }
+        if (typeof service.updatePartial === "function") {
+            contextService.updatePartial = async (id, data) => {
+                const preItem = await service.findById?.(id);
+                helper.assertWritable(preItem, "update");
+                const payload = helper.removeSetterFields(helper.clonePayload(data));
+                return service.updatePartial?.(id, payload);
+            };
+        }
+        if (typeof service.delete === "function") {
+            contextService.delete = async (id) => {
+                const item = await service.findById?.(id);
+                helper.assertWritable(item, "delete");
+                return service.delete?.(id);
+            };
+        }
+        if (typeof service.findById === "function") {
+            contextService.findById = async (id) => {
+                const item = await service.findById?.(id);
+                helper.assertReadable(item);
+                return item;
+            };
+        }
+        if (typeof service.findByIds === "function") {
+            contextService.findByIds = async (ids) => {
+                const items = await service.findByIds?.(ids);
+                helper.assertReadableItems(items);
+                return items;
+            };
+        }
+        if (typeof service.findOneBy === "function") {
+            contextService.findOneBy = async (field, value, filters = []) => service.findOneBy?.(field, value, helper.applyReadFilters(filters));
+        }
+        if (typeof service.findOne === "function") {
+            contextService.findOne = async (findOptions) => service.findOne?.({
+                ...findOptions,
+                filters: helper.applyReadFilters(findOptions?.filters ?? []),
+            });
+        }
+        if (typeof service.findBy === "function") {
+            contextService.findBy = async (field, value, limit = helper.defaultLimit, filters = []) => service.findBy?.(field, value, limit, helper.applyReadFilters(filters));
+        }
+        if (typeof service.fetchAll === "function") {
+            contextService.fetchAll = async () => {
+                const filters = helper.applyReadFilters([]);
+                if (filters.length > 0 && typeof service.find === "function") {
+                    return service.find({
+                        search: "",
+                        filters,
+                        order: false,
+                        orderBy: "",
+                        limit: helper.defaultLimit,
+                    });
+                }
+                return service.fetchAll?.();
+            };
+        }
+        if (typeof service.findFirst === "function") {
+            contextService.findFirst = async (quantity, filters = []) => service.findFirst?.(quantity, helper.applyReadFilters(filters));
+        }
+        if (typeof service.findLast === "function") {
+            contextService.findLast = async (quantity, filters = []) => service.findLast?.(quantity, helper.applyReadFilters(filters));
+        }
+        if (typeof service.search === "function") {
+            contextService.search = async (value, limit = helper.defaultLimit, filters = []) => service.search?.(value, limit, helper.applyReadFilters(filters));
+        }
+        if (typeof service.find === "function") {
+            contextService.find = async (findOptions) => service.find?.({
+                ...findOptions,
+                filters: helper.applyReadFilters(findOptions?.filters ?? []),
+            });
+        }
+        if (typeof service.paginate === "function") {
+            contextService.paginate = async (paginateOptions) => service.paginate?.({
+                ...paginateOptions,
+                filters: helper.applyReadFilters(paginateOptions?.filters ?? []),
+            });
+        }
+        if (typeof service.groupBy === "function") {
+            contextService.groupBy = async (groupByOptions) => service.groupBy?.({
+                ...groupByOptions,
+                filters: helper.applyReadFilters(groupByOptions?.filters ?? []),
+            });
+        }
+        return contextService;
+    }
+}
+class BuildContextToolServiceHelper {
+    constructor(options) {
+        this.context = options.context ?? {};
+        this.permission = options.permission;
+        this.tenantField = options.tenantField ?? "tenant";
+        this.userField = options.userField ?? "user";
+        this.tenantFilter = options.tenantFilter ?? false;
+        this.tenantSetter = options.tenantSetter ?? false;
+        this.tenantAssert = options.tenantAssert ?? false;
+        this.userFilter = options.userFilter ?? false;
+        this.userSetter = options.userSetter ?? false;
+        this.userAssert = options.userAssert ?? false;
+        this.defaultLimit = options.defaultLimit ?? 1000;
+    }
+    clonePayload(payload) {
+        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+            return payload;
+        }
+        return { ...payload };
+    }
+    applySetters(payload) {
+        if (!payload || typeof payload !== "object") {
+            return payload;
+        }
+        if (this.tenantSetter && this.context.tenantId) {
+            setNestedValue(payload, this.tenantField, this.context.tenantId);
+        }
+        if (this.userSetter && this.context.userId) {
+            setNestedValue(payload, this.userField, this.context.userId);
+        }
+        return payload;
+    }
+    removeSetterFields(payload) {
+        if (!payload || typeof payload !== "object") {
+            return payload;
+        }
+        if (this.tenantSetter) {
+            this.deleteNestedValue(payload, this.tenantField);
+        }
+        if (this.userSetter) {
+            this.deleteNestedValue(payload, this.userField);
+        }
+        return payload;
+    }
+    applyReadFilters(filters = []) {
+        const nextFilters = [...filters];
+        if (this.tenantFilter && this.context.tenantId) {
+            nextFilters.push({ field: this.tenantField, operator: "eq", value: this.context.tenantId });
+        }
+        if (this.userFilter &&
+            this.context.userId &&
+            !this.hasSomePermission([this.permission?.All, this.permission?.ViewAll])) {
+            nextFilters.push({ field: this.userField, operator: "eq", value: this.context.userId });
+        }
+        return nextFilters;
+    }
+    assertReadable(item) {
+        if (this.hasSomePermission([this.permission?.All, this.permission?.ViewAll])) {
+            this.assertTenant(item);
+            return;
+        }
+        this.assertTenant(item);
+        this.assertUser(item);
+    }
+    assertReadableItems(items) {
+        if (!Array.isArray(items)) {
+            return;
+        }
+        items.forEach(item => this.assertReadable(item));
+    }
+    assertWritable(item, operation) {
+        const allPermission = this.permission?.All;
+        const operationAllPermission = operation === "update"
+            ? this.permission?.UpdateAll
+            : this.permission?.DeleteAll;
+        if (!this.hasSomePermission([allPermission, operationAllPermission])) {
+            this.assertUser(item);
+        }
+        this.assertTenant(item);
+    }
+    assertTenant(item) {
+        if (!this.tenantAssert || !this.context.tenantId) {
+            return;
+        }
+        const tenantId = this.resolveItemFieldId(item, this.tenantField);
+        if (tenantId) {
+            this.assertId(this.context.tenantId, tenantId);
+        }
+    }
+    assertUser(item) {
+        if (!this.userAssert || !this.context.userId) {
+            return;
+        }
+        const userId = this.resolveItemFieldId(item, this.userField);
+        if (userId) {
+            this.assertId(this.context.userId, userId);
+        }
+    }
+    assertId(expectedId, actualId) {
+        if (expectedId !== actualId) {
+            throw new UnauthorizedError();
+        }
+    }
+    hasSomePermission(permissions) {
+        const requiredPermissions = permissions.filter((permission) => !!permission);
+        if (requiredPermissions.length === 0) {
+            return false;
+        }
+        if (this.context.hasSomePermission?.(requiredPermissions)) {
+            return true;
+        }
+        return requiredPermissions.some(permission => this.context.permissions?.includes(permission));
+    }
+    resolveItemFieldId(item, field) {
+        const value = this.getNestedValue(item, field);
+        return this.stringifyRelationId(value);
+    }
+    getNestedValue(item, path) {
+        return path.split(".").reduce((value, key) => value?.[key], item);
+    }
+    stringifyRelationId(value) {
+        if (value === null || value === undefined || value === "") {
+            return null;
+        }
+        const id = value?._id ?? value?.id ?? value;
+        if (typeof id === "string" || typeof id === "number" || typeof id === "boolean") {
+            return String(id);
+        }
+        if (typeof id?.toString === "function") {
+            const stringId = id.toString();
+            return stringId && stringId !== "[object Object]" ? stringId : null;
+        }
+        return null;
+    }
+    deleteNestedValue(payload, path) {
+        const keys = path.split(".");
+        const lastKey = keys.pop();
+        if (!lastKey) {
+            return;
+        }
+        const parent = keys.reduce((value, key) => value?.[key], payload);
+        if (parent && typeof parent === "object") {
+            delete parent[lastKey];
+        }
+    }
+}
+export default BuildContextTool;
+export { BuildContextTool };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.43.0",
+  "version": "3.44.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -46,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "9cb1cab8a6fe2a6c574d08596bc6287f5a5311a6"
+  "gitHead": "4ba7a86c8b28bba3156bd124a76f3150ba0f676e"
 }

package/src/index.ts

@@ -45,6 +45,7 @@ import TTSRoutes from "./routes/TTSRoutes.js";
 import DraxAgentRoutes from "./routes/DraxAgentRoutes.js";
 import AgentSessionRoutes from "./routes/AgentSessionRoutes.js";
 import {DraxAgent} from "./agents/DraxAgent.js";
+import {BuildContextTool} from "./tools/BuildContextTool.js";
 import type {IAILogRepository} from "./interfaces/IAILogRepository.js";
 import type {
     IAIProvider,
@@ -80,6 +81,10 @@ import type {
     ToolBuilderOptions,
     ToolBuilderService
 } from "./interfaces/IBuilderTool.js";
+import type {
+    BuildContextToolContext,
+    BuildContextToolOptions,
+} from "./tools/BuildContextTool.js";
 import type {
     DraxAgentControllerOptions
 } from "./interfaces/IDraxAgentController.js";
@@ -127,6 +132,8 @@ export type {
     ToolBuilderMethod,
     ToolBuilderOptions,
     ToolBuilderService,
+    BuildContextToolContext,
+    BuildContextToolOptions,
     DraxAgentControllerOptions,
     DraxAgentFastifyRoutesOptions,
     DraxAgentConfig,
@@ -169,6 +176,7 @@ export {
     DeepSeekAiProvider,
     ElevenLabsTTSProvider,
     BuilderTool,
+    BuildContextTool,
     //Service
     KnowledgeService,
     AILogService,