@drax/ai-back 3.43.0 → 3.45.0

package/dist/controllers/TTSVoiceController.js

@@ -0,0 +1,18 @@
+import TTSVoiceServiceFactory from "../factory/services/TTSVoiceServiceFactory.js";
+import { AbstractFastifyController } from "@drax/crud-back";
+import TTSVoicePermissions from "../permissions/TTSVoicePermissions.js";
+class TTSVoiceController extends AbstractFastifyController {
+    constructor() {
+        super(TTSVoiceServiceFactory.instance, TTSVoicePermissions);
+        this.tenantField = "tenant";
+        this.userField = "user";
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+        this.userFilter = false;
+        this.userSetter = false;
+        this.userAssert = false;
+    }
+}
+export default TTSVoiceController;
+export { TTSVoiceController };

package/dist/factory/services/TTSVoiceServiceFactory.js

@@ -0,0 +1,28 @@
+import TTSVoiceMongoRepository from '../../repository/mongo/TTSVoiceMongoRepository.js';
+import TTSVoiceSqliteRepository from '../../repository/sqlite/TTSVoiceSqliteRepository.js';
+import { TTSVoiceService } from '../../services/TTSVoiceService.js';
+import { TTSVoiceBaseSchema, TTSVoiceSchema } from "../../schemas/TTSVoiceSchema.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+class TTSVoiceServiceFactory {
+    static get instance() {
+        if (!TTSVoiceServiceFactory.service) {
+            let repository;
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new TTSVoiceMongoRepository();
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                    repository = new TTSVoiceSqliteRepository(dbFile, false);
+                    repository.build();
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            TTSVoiceServiceFactory.service = new TTSVoiceService(repository, TTSVoiceBaseSchema, TTSVoiceSchema);
+        }
+        return TTSVoiceServiceFactory.service;
+    }
+}
+export default TTSVoiceServiceFactory;
+export { TTSVoiceServiceFactory };

package/dist/index.js

@@ -4,10 +4,14 @@ import { OllamaAiConfig } from "./config/OllamaAiConfig.js";
 import { DeepSeekConfig } from "./config/DeepSeekConfig.js";
 import { ElevenLabsTTSConfig } from "./config/ElevenLabsTTSConfig.js";
 import { AILogSchema, AILogBaseSchema } from "./schemas/AILogSchema.js";
+import { TTSVoiceSchema, TTSVoiceBaseSchema, TTSVoiceProviderSchema } from "./schemas/TTSVoiceSchema.js";
 import { TTSRequestSchema, TTSVoiceSettingsSchema } from "./schemas/TTSRequestSchema.js";
 import AILogModel from "./models/AILogModel.js";
+import TTSVoiceModel from "./models/TTSVoiceModel.js";
 import AILogMongoRepository from "./repository/mongo/AILogMongoRepository.js";
 import AILogSqliteRepository from "./repository/sqlite/AILogSqliteRepository.js";
+import TTSVoiceMongoRepository from "./repository/mongo/TTSVoiceMongoRepository.js";
+import TTSVoiceSqliteRepository from "./repository/sqlite/TTSVoiceSqliteRepository.js";
 import { OpenAiProviderFactory } from "./factory/ai/OpenAiProviderFactory.js";
 import { GoogleAiProviderFactory } from "./factory/ai/GoogleAiProviderFactory.js";
 import { OllamaAiProviderFactory } from "./factory/ai/OllamaAiProviderFactory.js";
@@ -17,6 +21,7 @@ import { ElevenLabsTTSProviderFactory } from "./factory/tts/ElevenLabsTTSProvide
 import { TTSProviderFactory } from "./factory/tts/TTSProviderFactory.js";
 import { DraxAgentFactory } from "./factory/DraxAgentFactory.js";
 import AILogServiceFactory from "./factory/services/AILogServiceFactory.js";
+import TTSVoiceServiceFactory from "./factory/services/TTSVoiceServiceFactory.js";
 import { OpenAiProvider } from "./providers/ai/OpenAiProvider.js";
 import { GoogleAiProvider } from "./providers/ai/GoogleAiProvider.js";
 import { OllamaAiProvider } from "./providers/ai/OllamaAiProvider.js";
@@ -25,6 +30,7 @@ import { ElevenLabsTTSProvider } from "./providers/tts/ElevenLabsTTSProvider.js"
 import { BuilderTool } from "./tools/BuilderTool.js";
 import { KnowledgeService } from "./services/KnowledgeService.js";
 import { AILogService } from "./services/AILogService.js";
+import { TTSVoiceService } from "./services/TTSVoiceService.js";
 import { TTSGenericService } from "./services/TTSGenericService.js";
 import { PromptAudioService } from "./services/PromptAudioService.js";
 import AILogPermissions from "./permissions/AILogPermissions.js";
@@ -32,22 +38,26 @@ import AgentPermissions from "./permissions/AgentPermissions.js";
 import AgentSessionPermissions from "./permissions/AgentSessionPermissions.js";
 import AIPermissions from "./permissions/AIPermissions.js";
 import TTSPermissions from "./permissions/TTSPermissions.js";
+import TTSVoicePermissions from "./permissions/TTSVoicePermissions.js";
 import AILogController from "./controllers/AILogController.js";
 import AICrudController from "./controllers/AICrudController.js";
 import AIGenericController from "./controllers/AIGenericController.js";
 import TTSGenericController from "./controllers/TTSGenericController.js";
+import TTSVoiceController from "./controllers/TTSVoiceController.js";
 import DraxAgentController from "./controllers/DraxAgentController.js";
 import AgentSessionController from "./controllers/AgentSessionController.js";
 import AILogRoutes from "./routes/AILogRoutes.js";
 import AIRoutes from "./routes/AIRoutes.js";
 import TTSRoutes from "./routes/TTSRoutes.js";
+import TTSVoiceRoutes from "./routes/TTSVoiceRoutes.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, TTSVoiceSchema, TTSVoiceBaseSchema, TTSVoiceProviderSchema, TTSRequestSchema, TTSVoiceSettingsSchema, AILogModel, TTSVoiceModel, AILogMongoRepository, AILogSqliteRepository, TTSVoiceMongoRepository, TTSVoiceSqliteRepository, OpenAiProviderFactory, GoogleAiProviderFactory, OllamaAiProviderFactory, DeepSeekAiProviderFactory, AiProviderFactory, ElevenLabsTTSProviderFactory, TTSProviderFactory, DraxAgentFactory, AILogServiceFactory, TTSVoiceServiceFactory, OpenAiProvider, GoogleAiProvider, OllamaAiProvider, DeepSeekAiProvider, ElevenLabsTTSProvider, BuilderTool, BuildContextTool, 
 //Service
-KnowledgeService, AILogService, TTSGenericService, PromptAudioService, 
+KnowledgeService, AILogService, TTSVoiceService, TTSGenericService, PromptAudioService, 
 //Permissions
-AILogPermissions, AgentPermissions, AIPermissions, TTSPermissions, AgentSessionPermissions, 
+AILogPermissions, AgentPermissions, AIPermissions, TTSPermissions, TTSVoicePermissions, AgentSessionPermissions, 
 //Controllers
-AILogController, AICrudController, AIGenericController, TTSGenericController, DraxAgentController, AgentSessionController, DraxAgent, AILogRoutes, AIRoutes, TTSRoutes, DraxAgentRoutes, AgentSessionRoutes };
+AILogController, AICrudController, AIGenericController, TTSGenericController, TTSVoiceController, DraxAgentController, AgentSessionController, DraxAgent, AILogRoutes, AIRoutes, TTSRoutes, TTSVoiceRoutes, DraxAgentRoutes, AgentSessionRoutes };

package/dist/interfaces/ITTSVoice.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/ITTSVoiceRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/models/TTSVoiceModel.js

@@ -0,0 +1,25 @@
+import { mongoose } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+const TTSVoiceSchema = new mongoose.Schema({
+    name: { type: String, required: true, index: true, unique: false },
+    ttsProvider: { type: String, enum: ['ElevenLabs'], required: true, index: true, unique: false },
+    voiceId: { type: String, required: true, index: true, unique: false },
+    model: { type: String, required: false, index: true, unique: false },
+    languageCode: { type: String, required: false, index: true, unique: false },
+    tenant: { type: mongoose.Schema.Types.ObjectId, ref: 'Tenant', required: false, index: true, unique: false },
+    user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: false, index: true, unique: false }
+}, { timestamps: true });
+TTSVoiceSchema.index({ ttsProvider: 1, voiceId: 1, tenant: 1 }, { unique: true, sparse: true });
+TTSVoiceSchema.plugin(uniqueValidator, { message: 'validation.unique' });
+TTSVoiceSchema.plugin(mongoosePaginate);
+TTSVoiceSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+TTSVoiceSchema.set('toJSON', { getters: true, virtuals: true });
+TTSVoiceSchema.set('toObject', { getters: true, virtuals: true });
+const MODEL_NAME = 'TTSVoice';
+const COLLECTION_NAME = 'TTSVoice';
+const TTSVoiceModel = mongoose.model(MODEL_NAME, TTSVoiceSchema, COLLECTION_NAME);
+export { TTSVoiceSchema, TTSVoiceModel };
+export default TTSVoiceModel;

package/dist/permissions/TTSVoicePermissions.js

@@ -0,0 +1,10 @@
+var TTSVoicePermissions;
+(function (TTSVoicePermissions) {
+    TTSVoicePermissions["Create"] = "ttsvoice:create";
+    TTSVoicePermissions["Update"] = "ttsvoice:update";
+    TTSVoicePermissions["Delete"] = "ttsvoice:delete";
+    TTSVoicePermissions["View"] = "ttsvoice:view";
+    TTSVoicePermissions["Manage"] = "ttsvoice:manage";
+})(TTSVoicePermissions || (TTSVoicePermissions = {}));
+export { TTSVoicePermissions };
+export default TTSVoicePermissions;

package/dist/repository/mongo/TTSVoiceMongoRepository.js

@@ -0,0 +1,13 @@
+import { AbstractMongoRepository } from "@drax/crud-back";
+import { TTSVoiceModel } from "../../models/TTSVoiceModel.js";
+class TTSVoiceMongoRepository extends AbstractMongoRepository {
+    constructor() {
+        super();
+        this._model = TTSVoiceModel;
+        this._searchFields = ['name', 'ttsProvider', 'voiceId', 'model', 'languageCode'];
+        this._populateFields = ['tenant', 'user'];
+        this._lean = true;
+    }
+}
+export default TTSVoiceMongoRepository;
+export { TTSVoiceMongoRepository };

package/dist/repository/sqlite/TTSVoiceSqliteRepository.js

@@ -0,0 +1,27 @@
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class TTSVoiceSqliteRepository extends AbstractSqliteRepository {
+    constructor() {
+        super(...arguments);
+        this.tableName = 'TTSVoice';
+        this.searchFields = ['name', 'ttsProvider', 'voiceId', 'model', 'languageCode'];
+        this.booleanFields = [];
+        this.jsonFields = [];
+        this.identifier = '_id';
+        this.populateFields = [
+            { field: 'tenant', table: 'tenant', identifier: '_id' },
+            { field: 'user', table: 'user', identifier: '_id' }
+        ];
+        this.verbose = false;
+        this.tableFields = [
+            { name: "name", type: "TEXT", unique: false, primary: false },
+            { name: "ttsProvider", type: "TEXT", unique: false, primary: false },
+            { name: "voiceId", type: "TEXT", unique: false, primary: false },
+            { name: "model", type: "TEXT", unique: false, primary: false },
+            { name: "languageCode", type: "TEXT", unique: false, primary: false },
+            { name: "tenant", type: "TEXT", unique: false, primary: false },
+            { name: "user", type: "TEXT", unique: false, primary: false }
+        ];
+    }
+}
+export default TTSVoiceSqliteRepository;
+export { TTSVoiceSqliteRepository };

package/dist/routes/TTSVoiceRoutes.js

@@ -0,0 +1,21 @@
+import TTSVoiceController from "../controllers/TTSVoiceController.js";
+import { CrudSchemaBuilder } from "@drax/crud-back";
+import { TTSVoiceSchema, TTSVoiceBaseSchema } from '../schemas/TTSVoiceSchema.js';
+async function TTSVoiceRoutes(fastify, options) {
+    const controller = new TTSVoiceController();
+    const schemas = new CrudSchemaBuilder(TTSVoiceSchema, TTSVoiceBaseSchema, TTSVoiceBaseSchema, 'TTSVoice', 'openapi-3.0', ['ai']);
+    fastify.get('/api/ttsvoice', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.get('/api/ttsvoice/find', { schema: schemas.findSchema }, (req, rep) => controller.find(req, rep));
+    fastify.get('/api/ttsvoice/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
+    fastify.get('/api/ttsvoice/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));
+    fastify.get('/api/ttsvoice/find-one', { schema: schemas.findOneSchema }, (req, rep) => controller.findOne(req, rep));
+    fastify.get('/api/ttsvoice/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
+    fastify.post('/api/ttsvoice', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/ttsvoice/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
+    fastify.patch('/api/ttsvoice/:id', { schema: schemas.updateSchema }, (req, rep) => controller.updatePartial(req, rep));
+    fastify.delete('/api/ttsvoice/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+    fastify.get('/api/ttsvoice/export', (req, rep) => controller.export(req, rep));
+    fastify.post('/api/ttsvoice/import', (req, rep) => controller.import(req, rep));
+}
+export default TTSVoiceRoutes;
+export { TTSVoiceRoutes };

package/dist/schemas/TTSVoiceSchema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+const TTSVoiceProviderSchema = z.enum(['ElevenLabs']);
+const TTSVoiceBaseSchema = z.object({
+    name: z.string().min(1, 'validation.required'),
+    ttsProvider: TTSVoiceProviderSchema,
+    voiceId: z.string().min(1, 'validation.required'),
+    model: z.string().optional().nullable(),
+    languageCode: z.string().optional().nullable(),
+    tenant: z.coerce.string().optional().nullable(),
+    user: z.coerce.string().optional().nullable()
+});
+const TTSVoiceSchema = TTSVoiceBaseSchema
+    .extend({
+    _id: z.coerce.string(),
+    tenant: z.object({ _id: z.coerce.string(), name: z.string().optional() }).nullable().optional(),
+    user: z.object({ _id: z.coerce.string(), username: z.string().optional() }).nullable().optional()
+});
+export default TTSVoiceSchema;
+export { TTSVoiceSchema, TTSVoiceBaseSchema, TTSVoiceProviderSchema };

package/dist/services/TTSVoiceService.js

@@ -0,0 +1,9 @@
+import { AbstractService } from "@drax/crud-back";
+class TTSVoiceService extends AbstractService {
+    constructor(TTSVoiceRepository, baseSchema, fullSchema) {
+        super(TTSVoiceRepository, baseSchema, fullSchema);
+        this._validateOutput = true;
+    }
+}
+export default TTSVoiceService;
+export { TTSVoiceService };

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.45.0",
   "description": "Ai utils",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -18,7 +18,7 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/ai-share": "^3.43.0",
+    "@drax/ai-share": "^3.45.0",
     "@drax/crud-back": "^3.39.0",
     "mongoose": "^8.23.0",
     "mongoose-paginate-v2": "^1.8.3"
@@ -46,5 +46,5 @@
     "typescript": "^5.9.3",
     "vitest": "^3.0.8"
   },
-  "gitHead": "9cb1cab8a6fe2a6c574d08596bc6287f5a5311a6"
+  "gitHead": "825b67f313cc64dd26bf455b2503fbeb606df308"
 }

package/src/controllers/TTSVoiceController.ts

@@ -0,0 +1,27 @@
+import TTSVoiceServiceFactory from "../factory/services/TTSVoiceServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import TTSVoicePermissions from "../permissions/TTSVoicePermissions.js";
+import type {ITTSVoice, ITTSVoiceBase} from "../interfaces/ITTSVoice";
+
+class TTSVoiceController extends AbstractFastifyController<ITTSVoice, ITTSVoiceBase, ITTSVoiceBase> {
+
+    constructor() {
+        super(TTSVoiceServiceFactory.instance, TTSVoicePermissions)
+        this.tenantField = "tenant";
+        this.userField = "user";
+
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+
+        this.userFilter = false;
+        this.userSetter = false;
+        this.userAssert = false;
+    }
+
+}
+
+export default TTSVoiceController;
+export {
+    TTSVoiceController
+}

package/src/factory/services/TTSVoiceServiceFactory.ts

@@ -0,0 +1,36 @@
+import TTSVoiceMongoRepository from '../../repository/mongo/TTSVoiceMongoRepository.js'
+import TTSVoiceSqliteRepository from '../../repository/sqlite/TTSVoiceSqliteRepository.js'
+import type {ITTSVoiceRepository} from "../../interfaces/ITTSVoiceRepository";
+import {TTSVoiceService} from '../../services/TTSVoiceService.js'
+import {TTSVoiceBaseSchema, TTSVoiceSchema} from "../../schemas/TTSVoiceSchema.js";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
+
+class TTSVoiceServiceFactory {
+    private static service: TTSVoiceService;
+
+    public static get instance(): TTSVoiceService {
+        if (!TTSVoiceServiceFactory.service) {
+            let repository: ITTSVoiceRepository
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new TTSVoiceMongoRepository()
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                    repository = new TTSVoiceSqliteRepository(dbFile, false)
+                    repository.build()
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+
+            TTSVoiceServiceFactory.service = new TTSVoiceService(repository, TTSVoiceBaseSchema, TTSVoiceSchema);
+        }
+        return TTSVoiceServiceFactory.service;
+    }
+}
+
+export default TTSVoiceServiceFactory
+export {
+    TTSVoiceServiceFactory
+}