@researchdatabox/redbox-core 0.0.0-bootstrap.0

package/dist/services/VocabularyService.js

@@ -0,0 +1,752 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const CoreService_1 = require("../CoreService");
+const TransactionUtils_1 = require("../utilities/TransactionUtils");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const sails_ng_common_1 = require("@researchdatabox/sails-ng-common");
+var Services;
+(function (Services) {
+    const VALID_TYPES = new Set(['flat', 'tree']);
+    const VALID_SOURCES = new Set(['local', 'rva']);
+    const RVA_IMPORTS_FILE = 'rva-imports.json';
+    const DEFAULT_BOOTSTRAP_DATA_PATH = 'bootstrap-data';
+    const RVA_IMPORT_TIMEOUT_MS = 30_000;
+    class InvalidParentIdError extends Error {
+        code;
+        constructor(message = 'Parent entry does not belong to the requested vocabulary') {
+            super(message);
+            this.name = 'InvalidParentIdError';
+            this.code = 'invalid-parent-id';
+        }
+    }
+    Services.InvalidParentIdError = InvalidParentIdError;
+    class VocabularyService extends CoreService_1.Services.Core.Service {
+        _exportedMethods = [
+            'list',
+            'getById',
+            'getByIdOrSlug',
+            'getEntries',
+            'getChildren',
+            'bootstrapData',
+            'create',
+            'update',
+            'reorderEntries',
+            'delete',
+            'getTree',
+            'normalizeEntry',
+            'validateParent',
+            'upsertEntries'
+        ];
+        async executeQuery(query, connection) {
+            if (connection) {
+                return query.usingConnection(connection);
+            }
+            return query;
+        }
+        async executeFindQuery(query, connection) {
+            if (connection) {
+                return await query.usingConnection(connection);
+            }
+            return await query;
+        }
+        async createAndFetch(createQuery, connection) {
+            const fetchedQuery = createQuery.fetch();
+            return this.executeQuery(fetchedQuery, connection);
+        }
+        resolveBrandingId(branding) {
+            if (branding && typeof branding === 'object') {
+                const brandingObject = branding;
+                if (brandingObject.id) {
+                    return String(brandingObject.id);
+                }
+                if (brandingObject._id) {
+                    return String(brandingObject._id);
+                }
+                if (typeof brandingObject.name === 'string' && brandingObject.name.trim()) {
+                    return brandingObject.name.trim();
+                }
+                return '';
+            }
+            const brandingString = String(branding ?? '').trim();
+            if (!brandingString) {
+                return brandingString;
+            }
+            const globals = globalThis;
+            const brandingService = globals.BrandingService;
+            const brand = brandingService?.getBrand?.(brandingString);
+            if (brand?.id) {
+                return String(brand.id);
+            }
+            return brandingString;
+        }
+        async list(options) {
+            const parsedLimit = Number.parseInt(String(options.limit ?? 25), 10);
+            const parsedOffset = Number.parseInt(String(options.offset ?? 0), 10);
+            const limit = Number.isInteger(parsedLimit) && parsedLimit > 0 ? Math.min(200, parsedLimit) : 25;
+            const offset = Number.isInteger(parsedOffset) && parsedOffset >= 0 ? parsedOffset : 0;
+            const sort = options.sort || 'name ASC';
+            const where = {};
+            if (options.type && VALID_TYPES.has(options.type)) {
+                where.type = options.type;
+            }
+            if (options.source && VALID_SOURCES.has(options.source)) {
+                where.source = options.source;
+            }
+            // Branding is single-tenant for this admin feature; avoid ObjectId/string mismatch
+            // filtering at query time which can hide records in Mongo-backed environments.
+            if (options.q) {
+                where.or = [
+                    { name: { contains: options.q } },
+                    { slug: { contains: options.q } }
+                ];
+            }
+            const total = await Vocabulary.count(where);
+            const data = await Vocabulary.find(where).sort(sort).skip(offset).limit(limit);
+            return { data, meta: { total, limit, offset } };
+        }
+        async getById(id) {
+            return await Vocabulary.findOne({ id });
+        }
+        async getByIdOrSlug(branding, idOrSlug) {
+            const normalizedBranding = this.resolveBrandingId(branding);
+            const normalizedIdOrSlug = String(idOrSlug ?? '').trim();
+            if (!normalizedBranding || !normalizedIdOrSlug) {
+                return null;
+            }
+            const byId = await Vocabulary.findOne({ id: normalizedIdOrSlug, branding: normalizedBranding });
+            if (byId) {
+                return byId;
+            }
+            return await Vocabulary.findOne({ slug: normalizedIdOrSlug, branding: normalizedBranding });
+        }
+        async getEntries(branding, vocabIdOrSlug, options) {
+            const vocabulary = await this.getByIdOrSlug(branding, vocabIdOrSlug);
+            if (!vocabulary) {
+                return null;
+            }
+            const parsedLimit = Number.parseInt(String(options?.limit ?? 200), 10);
+            const parsedOffset = Number.parseInt(String(options?.offset ?? 0), 10);
+            const limit = Number.isInteger(parsedLimit) && parsedLimit > 0 ? Math.min(1000, parsedLimit) : 200;
+            const offset = Number.isInteger(parsedOffset) && parsedOffset >= 0 ? parsedOffset : 0;
+            const search = String(options?.search ?? '').trim().toLowerCase();
+            const where = {
+                vocabulary: String(vocabulary.id)
+            };
+            if (search) {
+                where.labelLower = { contains: search };
+            }
+            const total = await VocabularyEntry.count(where);
+            const entries = await VocabularyEntry.find(where)
+                .sort([{ order: 'ASC' }, { label: 'ASC' }])
+                .skip(offset)
+                .limit(limit);
+            return {
+                entries,
+                meta: {
+                    total,
+                    limit,
+                    offset,
+                    vocabularyId: String(vocabulary.id)
+                }
+            };
+        }
+        async getChildren(branding, vocabIdOrSlug, parentId) {
+            const vocabulary = await this.getByIdOrSlug(branding, vocabIdOrSlug);
+            if (!vocabulary) {
+                return null;
+            }
+            const normalizedParentId = String(parentId ?? '').trim();
+            if (normalizedParentId) {
+                const parentEntry = await VocabularyEntry.findOne({
+                    id: normalizedParentId,
+                    vocabulary: String(vocabulary.id)
+                });
+                if (!parentEntry) {
+                    throw new InvalidParentIdError();
+                }
+            }
+            const where = {
+                vocabulary: String(vocabulary.id),
+            };
+            where.parent = normalizedParentId || null;
+            const entries = await VocabularyEntry.find(where)
+                .sort([{ order: 'ASC' }, { label: 'ASC' }]);
+            const childParentIds = entries.map((entry) => String(entry.id));
+            const hasChildrenById = new Map();
+            if (childParentIds.length > 0) {
+                const descendants = await VocabularyEntry.find({
+                    vocabulary: String(vocabulary.id),
+                    parent: { in: childParentIds }
+                });
+                for (const descendant of descendants) {
+                    const descendantParent = String(descendant.parent ?? '');
+                    if (descendantParent) {
+                        hasChildrenById.set(descendantParent, true);
+                    }
+                }
+            }
+            const responseEntries = entries.map((entry) => {
+                const id = String(entry.id);
+                const parent = entry.parent ? String(entry.parent) : null;
+                const notation = String(entry.identifier ?? '').trim() || String(entry.value ?? '').trim();
+                return {
+                    id,
+                    label: String(entry.label ?? ''),
+                    value: String(entry.value ?? ''),
+                    notation: notation || undefined,
+                    parent,
+                    hasChildren: hasChildrenById.get(id) === true
+                };
+            });
+            return {
+                entries: responseEntries,
+                meta: {
+                    vocabularyId: String(vocabulary.id),
+                    parentId: normalizedParentId || null,
+                    total: responseEntries.length
+                }
+            };
+        }
+        async create(input) {
+            const payload = {
+                ...input,
+                type: input.type ?? 'flat',
+                source: input.source ?? 'local'
+            };
+            const entries = payload.entries ?? [];
+            delete payload.entries;
+            const createPayload = {
+                name: payload.name,
+                description: payload.description,
+                type: payload.type,
+                source: payload.source,
+                sourceId: payload.sourceId,
+                sourceVersionId: payload.sourceVersionId,
+                lastSyncedAt: payload.lastSyncedAt,
+                owner: payload.owner,
+                branding: this.resolveBrandingId(payload.branding)
+            };
+            if (payload.slug) {
+                createPayload.slug = payload.slug;
+            }
+            return (0, TransactionUtils_1.runWithOptionalTransaction)(this.getDatastore(), async (connection) => {
+                let created = null;
+                try {
+                    created = await this.createAndFetch(Vocabulary.create(createPayload), connection);
+                    if (!created) {
+                        throw new Error('Vocabulary create failed');
+                    }
+                    if (entries.length > 0) {
+                        await this.replaceEntries(created.id, created.type === 'flat', entries, connection);
+                    }
+                    const findQuery = Vocabulary.findOne({ id: created.id });
+                    const saved = await this.executeQuery(findQuery, connection);
+                    if (!saved) {
+                        throw new Error('Vocabulary create failed');
+                    }
+                    return saved;
+                }
+                catch (err) {
+                    if (!connection && created?.id) {
+                        try {
+                            await VocabularyEntry.destroy({ vocabulary: created.id });
+                            await Vocabulary.destroyOne({ id: created.id });
+                        }
+                        catch (_cleanupErr) {
+                            // Swallow cleanup errors to preserve the original failure.
+                        }
+                    }
+                    throw err;
+                }
+            }, {
+                logger: sails.log,
+                unsupportedAdapterWarning: 'Transactions are not supported by this datastore adapter. Falling back to non-transactional create.'
+            });
+        }
+        async bootstrapData() {
+            const bootstrapPath = this.getBootstrapDataPath();
+            let fileNames = [];
+            const fileOps = this.getBootstrapFileOps();
+            try {
+                const fileEntries = await fileOps.readdir(bootstrapPath, { withFileTypes: true });
+                fileNames = fileEntries
+                    .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+                    .map((entry) => entry.name)
+                    .sort((a, b) => a.localeCompare(b));
+            }
+            catch (error) {
+                const ioError = error;
+                if (ioError.code === 'ENOENT') {
+                    sails.log.verbose(`Vocabulary bootstrap data path not found: ${bootstrapPath}`);
+                    return;
+                }
+                sails.log.error(`Failed to read vocabulary bootstrap data path: ${bootstrapPath}`, error);
+                return;
+            }
+            const defaultBranding = this.resolveBrandingId(sails.services.brandingservice.getDefault?.() ?? sails.config?.auth?.defaultBrand ?? 'default');
+            if (!defaultBranding) {
+                sails.log.error('Unable to resolve default branding for vocabulary bootstrap data');
+                return;
+            }
+            for (const fileName of fileNames) {
+                if (fileName === RVA_IMPORTS_FILE) {
+                    await this.processRvaImportsFile(bootstrapPath, fileName, defaultBranding);
+                    continue;
+                }
+                await this.processVocabularyBootstrapFile(bootstrapPath, fileName, defaultBranding);
+            }
+        }
+        async update(id, input) {
+            const existing = await Vocabulary.findOne({ id });
+            if (!existing) {
+                throw new Error('Vocabulary not found');
+            }
+            const updatePayload = { ...input };
+            const entries = updatePayload.entries;
+            delete updatePayload.entries;
+            const modelUpdate = {
+                name: updatePayload.name,
+                description: updatePayload.description,
+                type: updatePayload.type,
+                source: updatePayload.source,
+                sourceId: updatePayload.sourceId,
+                sourceVersionId: updatePayload.sourceVersionId,
+                lastSyncedAt: updatePayload.lastSyncedAt,
+                owner: updatePayload.owner
+            };
+            if (typeof updatePayload.branding !== 'undefined') {
+                modelUpdate.branding = this.resolveBrandingId(updatePayload.branding);
+            }
+            if (typeof updatePayload.slug !== 'undefined') {
+                modelUpdate.slug = updatePayload.slug;
+            }
+            return (0, TransactionUtils_1.runWithOptionalTransaction)(this.getDatastore(), async (connection) => {
+                const updateQuery = Vocabulary.updateOne({ id }).set(modelUpdate);
+                await this.executeQuery(updateQuery, connection);
+                const updatedQuery = Vocabulary.findOne({ id });
+                const updated = await this.executeQuery(updatedQuery, connection);
+                if (!updated) {
+                    throw new Error('Vocabulary not found');
+                }
+                if (entries) {
+                    await this.replaceEntries(id, updated.type === 'flat', entries, connection);
+                }
+                const refreshedQuery = Vocabulary.findOne({ id });
+                const refreshed = await this.executeQuery(refreshedQuery, connection);
+                if (!refreshed) {
+                    throw new Error('Vocabulary not found');
+                }
+                return refreshed;
+            }, {
+                logger: sails.log,
+                unsupportedAdapterWarning: 'Transactions are not supported by this datastore adapter. Falling back to non-transactional update.'
+            });
+        }
+        async reorderEntries(vocabularyId, entryOrders) {
+            if (!Array.isArray(entryOrders) || entryOrders.length === 0) {
+                return 0;
+            }
+            return (0, TransactionUtils_1.runWithOptionalTransaction)(this.getDatastore(), async (connection) => {
+                const vocabularyQuery = Vocabulary.findOne({ id: vocabularyId });
+                const vocabulary = await this.executeQuery(vocabularyQuery, connection);
+                if (!vocabulary) {
+                    throw new Error('Vocabulary not found');
+                }
+                const requestedIds = entryOrders.map((entry) => String(entry.id));
+                const dedupedIds = new Set(requestedIds);
+                if (requestedIds.length !== dedupedIds.size) {
+                    throw new Error('entryOrders contains duplicate ids');
+                }
+                const existingQuery = VocabularyEntry.find({ id: Array.from(dedupedIds) });
+                const existingEntries = await this.executeFindQuery(existingQuery, connection);
+                if (existingEntries.length !== dedupedIds.size) {
+                    throw new Error('One or more entry ids were not found');
+                }
+                for (const entry of existingEntries) {
+                    if (String(entry.vocabulary) !== String(vocabularyId)) {
+                        throw new Error('All entries must belong to the target vocabulary');
+                    }
+                }
+                let updated = 0;
+                for (const entryOrder of entryOrders) {
+                    const updateQuery = VocabularyEntry.updateOne({ id: entryOrder.id }).set({ order: entryOrder.order });
+                    const updatedEntry = await this.executeQuery(updateQuery, connection);
+                    if (updatedEntry) {
+                        updated++;
+                    }
+                }
+                return updated;
+            }, {
+                logger: sails.log,
+                unsupportedAdapterWarning: 'Transactions are not supported by this datastore adapter. Falling back to non-transactional reorder.'
+            });
+        }
+        async delete(id) {
+            await VocabularyEntry.destroy({ vocabulary: id });
+            await Vocabulary.destroyOne({ id });
+        }
+        normalizeEntry(entry) {
+            return {
+                ...entry,
+                label: String(entry.label ?? '').trim(),
+                value: String(entry.value ?? '').trim(),
+                historical: (0, sails_ng_common_1.toBoolean)(entry.historical)
+            };
+        }
+        async validateParent(vocabularyId, entryId, parentId, connection) {
+            if (!parentId) {
+                return;
+            }
+            if (entryId && parentId === entryId) {
+                throw new Error('VocabularyEntry cannot parent itself');
+            }
+            const parentQuery = VocabularyEntry.findOne({ id: parentId });
+            const parent = await this.executeQuery(parentQuery, connection);
+            if (!parent) {
+                throw new Error('VocabularyEntry.parent not found');
+            }
+            if (String(parent.vocabulary) !== String(vocabularyId)) {
+                throw new Error('VocabularyEntry.parent must belong to the same vocabulary');
+            }
+            if (!entryId) {
+                return;
+            }
+            let cursor = parent;
+            while (cursor?.parent) {
+                if (String(cursor.parent) === entryId) {
+                    throw new Error('VocabularyEntry cycle detected');
+                }
+                const cursorQuery = VocabularyEntry.findOne({ id: String(cursor.parent) });
+                cursor = await this.executeQuery(cursorQuery, connection);
+            }
+        }
+        async getTree(vocabularyId) {
+            const entries = await VocabularyEntry.find({ vocabulary: vocabularyId })
+                .sort([{ order: 'ASC' }, { label: 'ASC' }]);
+            const nodes = {};
+            const roots = [];
+            for (const entry of entries) {
+                const node = {
+                    ...entry,
+                    children: []
+                };
+                nodes[String(entry.id)] = node;
+            }
+            for (const entry of entries) {
+                const node = nodes[String(entry.id)];
+                if (entry.parent && nodes[String(entry.parent)]) {
+                    nodes[String(entry.parent)].children.push(node);
+                }
+                else {
+                    roots.push(node);
+                }
+            }
+            return roots;
+        }
+        async upsertEntries(vocabularyId, entries, connection) {
+            let created = 0;
+            let updated = 0;
+            let skipped = 0;
+            const inputIdToEntryId = {};
+            const parentAssignments = [];
+            for (const rawEntry of entries) {
+                const entry = rawEntry;
+                if (!entry.label || entry.value === null || entry.value === undefined) {
+                    skipped++;
+                    continue;
+                }
+                let existing = null;
+                if (entry.identifier) {
+                    const byIdentifier = VocabularyEntry.findOne({ vocabulary: vocabularyId, identifier: entry.identifier });
+                    existing = await this.executeQuery(byIdentifier, connection);
+                }
+                if (!existing) {
+                    const byValue = VocabularyEntry.findOne({ vocabulary: vocabularyId, valueLower: entry.value.toLowerCase() });
+                    existing = await this.executeQuery(byValue, connection);
+                }
+                if (!existing) {
+                    const createQuery = VocabularyEntry.create({
+                        vocabulary: vocabularyId,
+                        label: entry.label,
+                        value: entry.value,
+                        identifier: entry.identifier,
+                        order: entry.order ?? 0,
+                        historical: entry.historical ?? false
+                    });
+                    const createdEntry = await this.createAndFetch(createQuery, connection);
+                    const createdEntryId = String(createdEntry.id);
+                    if (entry.id) {
+                        inputIdToEntryId[String(entry.id)] = createdEntryId;
+                    }
+                    parentAssignments.push({ entryId: createdEntryId, parent: entry.parent ?? null });
+                    created++;
+                    continue;
+                }
+                const existingEntryId = String(existing.id);
+                if (entry.id) {
+                    inputIdToEntryId[String(entry.id)] = existingEntryId;
+                }
+                parentAssignments.push({ entryId: existingEntryId, parent: entry.parent ?? null });
+                const updateQuery = VocabularyEntry.updateOne({ id: existing.id }).set({
+                    label: entry.label,
+                    value: entry.value,
+                    identifier: entry.identifier,
+                    order: entry.order ?? existing.order ?? 0,
+                    historical: entry.historical ?? existing.historical ?? false
+                });
+                await this.executeQuery(updateQuery, connection);
+                updated++;
+            }
+            for (const assignment of parentAssignments) {
+                const parentCandidate = assignment.parent ? inputIdToEntryId[assignment.parent] ?? assignment.parent : null;
+                await this.validateParent(vocabularyId, assignment.entryId, parentCandidate, connection);
+                const parentUpdateQuery = VocabularyEntry.updateOne({ id: assignment.entryId }).set({
+                    parent: parentCandidate ?? null
+                });
+                await this.executeQuery(parentUpdateQuery, connection);
+            }
+            return { created, updated, skipped };
+        }
+        async replaceEntries(vocabularyId, isFlat, entries, connection) {
+            const flatEntries = this.flattenEntries(entries);
+            if (isFlat && flatEntries.some(entry => entry.parent)) {
+                throw new Error('Vocabulary.type = flat does not support parent entries');
+            }
+            const destroyQuery = VocabularyEntry.destroy({ vocabulary: vocabularyId });
+            await this.executeQuery(destroyQuery, connection);
+            const oldToNewIds = {};
+            for (const entry of flatEntries) {
+                const normalized = entry;
+                if (!normalized.label || normalized.value === null || normalized.value === undefined) {
+                    throw new Error('VocabularyEntry.label and VocabularyEntry.value are required');
+                }
+                const createQuery = VocabularyEntry.create({
+                    vocabulary: vocabularyId,
+                    label: normalized.label,
+                    value: normalized.value,
+                    identifier: normalized.identifier,
+                    order: normalized.order ?? 0,
+                    historical: normalized.historical ?? false
+                });
+                const created = await this.createAndFetch(createQuery, connection);
+                oldToNewIds[String(normalized.id)] = String(created.id);
+            }
+            for (const entry of flatEntries) {
+                if (!entry.parent) {
+                    continue;
+                }
+                const entryId = oldToNewIds[String(entry.id)];
+                const mappedParentId = oldToNewIds[entry.parent] ?? entry.parent;
+                if (!entryId) {
+                    continue;
+                }
+                await this.validateParent(vocabularyId, entryId, mappedParentId, connection);
+                const updateQuery = VocabularyEntry.updateOne({ id: entryId }).set({ parent: mappedParentId });
+                await this.executeQuery(updateQuery, connection);
+            }
+        }
+        getDatastore() {
+            return Vocabulary.getDatastore?.()
+                ?? sails.getDatastore?.()
+                ?? null;
+        }
+        getBootstrapDataPath() {
+            const configuredPath = _.get(sails.config, 'bootstrap.bootstrapDataPath', DEFAULT_BOOTSTRAP_DATA_PATH);
+            return path.resolve(String(configuredPath), 'vocabularies');
+        }
+        getBootstrapFileOps() {
+            return fs;
+        }
+        async processVocabularyBootstrapFile(basePath, fileName, defaultBranding) {
+            const filePath = path.join(basePath, fileName);
+            const parsed = await this.readJsonFile(filePath);
+            if (!parsed) {
+                return;
+            }
+            const name = typeof parsed.name === 'string' ? parsed.name.trim() : '';
+            const slug = typeof parsed.slug === 'string' ? parsed.slug.trim() : '';
+            if (!name || !slug) {
+                sails.log.error(`Skipping vocabulary bootstrap file with missing name or slug: ${fileName}`);
+                return;
+            }
+            const existing = await Vocabulary.findOne({ slug, branding: defaultBranding });
+            if (existing) {
+                sails.log.verbose(`Skipping existing vocabulary bootstrap data: ${slug}`);
+                return;
+            }
+            const createPayload = {
+                name,
+                slug,
+                branding: defaultBranding
+            };
+            if (typeof parsed.description === 'string') {
+                createPayload.description = parsed.description;
+            }
+            if (typeof parsed.type === 'string' && VALID_TYPES.has(parsed.type)) {
+                createPayload.type = parsed.type;
+            }
+            const entries = this.toBootstrapEntries(parsed.entries);
+            if (entries.length > 0) {
+                createPayload.entries = entries;
+            }
+            try {
+                const created = await this.create(createPayload);
+                sails.log.verbose(`Created vocabulary bootstrap data: ${slug} (${String(created.id)})`);
+            }
+            catch (error) {
+                sails.log.error(`Failed to create vocabulary from bootstrap file: ${fileName}`, error);
+            }
+        }
+        async processRvaImportsFile(basePath, fileName, defaultBranding) {
+            if (_.get(sails.config, 'vocab.bootstrapRvaImports') === false) {
+                sails.log.verbose(`Skipping RVA imports bootstrap file (disabled): ${fileName}`);
+                return;
+            }
+            const filePath = path.join(basePath, fileName);
+            const parsed = await this.readJsonFile(filePath);
+            if (!parsed) {
+                return;
+            }
+            const imports = Array.isArray(parsed.imports) ? parsed.imports : [];
+            if (!Array.isArray(parsed.imports)) {
+                sails.log.error(`Invalid RVA imports format in bootstrap file: ${fileName}`);
+                return;
+            }
+            const rvaImportService = sails.services.rvaimportservice;
+            if (!rvaImportService?.importRvaVocabulary) {
+                sails.log.error('RVA import service unavailable while processing vocabulary bootstrap data');
+                return;
+            }
+            for (const item of imports) {
+                const rvaId = typeof item?.rvaId === 'string' ? item.rvaId.trim() : String(item?.rvaId ?? '').trim();
+                if (!rvaId) {
+                    sails.log.error(`Skipping RVA bootstrap import with missing rvaId in ${fileName}`);
+                    continue;
+                }
+                const sourceKey = `rva:${rvaId}`;
+                const existing = await Vocabulary.findOne({ rvaSourceKey: sourceKey });
+                if (existing) {
+                    sails.log.verbose(`Skipping existing RVA bootstrap import: ${sourceKey}`);
+                    continue;
+                }
+                const versionId = typeof item?.versionId === 'string' ? item.versionId.trim() : undefined;
+                try {
+                    await this.promiseWithTimeout(rvaImportService.importRvaVocabulary(rvaId, versionId, defaultBranding), RVA_IMPORT_TIMEOUT_MS, `RVA import ${sourceKey}`);
+                    sails.log.verbose(`Imported RVA bootstrap vocabulary: ${sourceKey}`);
+                }
+                catch (error) {
+                    sails.log.error(`Failed RVA bootstrap import: ${sourceKey}`, error);
+                }
+            }
+        }
+        async readJsonFile(filePath) {
+            try {
+                const content = await this.getBootstrapFileOps().readFile(filePath, 'utf8');
+                return JSON.parse(content);
+            }
+            catch (error) {
+                sails.log.error(`Failed to read vocabulary bootstrap file: ${path.basename(filePath)}`, error);
+                return null;
+            }
+        }
+        toBootstrapEntries(entries) {
+            if (!Array.isArray(entries)) {
+                return [];
+            }
+            return entries.map((entry, index) => this.toBootstrapEntry(entry, index, 'bootstrap'));
+        }
+        toBootstrapEntry(rawEntry, index, branch) {
+            const entry = (rawEntry && typeof rawEntry === 'object')
+                ? rawEntry
+                : {};
+            const generatedId = typeof entry.id !== 'undefined' ? String(entry.id) : `${branch}-${index}`;
+            const normalized = {
+                id: generatedId,
+                label: String(entry.label ?? '').trim(),
+                value: String(entry.value ?? '').trim(),
+                order: typeof entry.order === 'number' ? entry.order : index,
+                historical: typeof entry.historical === 'undefined' ? false : (0, sails_ng_common_1.toBoolean)(entry.historical)
+            };
+            if (typeof entry.identifier === 'string' && entry.identifier.trim()) {
+                normalized.identifier = entry.identifier.trim();
+            }
+            if (typeof entry.parent !== 'undefined' && entry.parent !== null) {
+                normalized.parent = String(entry.parent);
+            }
+            if (Array.isArray(entry.children)) {
+                normalized.children = entry.children.map((child, childIndex) => this.toBootstrapEntry(child, childIndex, generatedId));
+            }
+            return normalized;
+        }
+        async promiseWithTimeout(promise, timeoutMs, label) {
+            let timeoutHandle = null;
+            const timeoutPromise = new Promise((_resolve, reject) => {
+                timeoutHandle = setTimeout(() => {
+                    reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+            });
+            try {
+                return await Promise.race([promise, timeoutPromise]);
+            }
+            finally {
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+            }
+        }
+        flattenEntries(entries, parentId = null, branch = 'n') {
+            const flat = [];
+            entries.forEach((entry, index) => {
+                const generatedId = entry.id ?? `${branch}-${index}`;
+                const normalized = {
+                    ...entry,
+                    id: generatedId,
+                    order: entry.order ?? index,
+                    parent: parentId ?? entry.parent
+                };
+                flat.push(normalized);
+                if (entry.children && entry.children.length > 0) {
+                    flat.push(...this.flattenEntries(entry.children, generatedId, generatedId));
+                }
+            });
+            return flat;
+        }
+    }
+    Services.VocabularyService = VocabularyService;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VocabularyService.js","sourceRoot":"","sources":["../../src/services/VocabularyService.ts"],"names":[],"mappings":"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"}