@researchdatabox/redbox-core 0.0.0-bootstrap.0

package/dist/services/RaidService.js

@@ -0,0 +1,556 @@
+"use strict";
+// Copyright (c) 2023 Queensland Cyber Infrastructure Foundation (http://www.qcif.edu.au/)
+//
+// GNU GENERAL PUBLIC LICENSE
+//    Version 2, June 1991
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+const CoreService_1 = require("../CoreService");
+const RBValidationError_1 = require("../model/RBValidationError");
+const momentShim_1 = require("../shims/momentShim");
+const raido_openapi_generated_node_1 = require("@researchdatabox/raido-openapi-generated-node");
+const numeral_1 = __importDefault(require("numeral"));
+const axios_1 = __importDefault(require("axios"));
+var Services;
+(function (Services) {
+    /**
+     *  Uses `@researchdatabox/raido-openapi-generated-node` to interact with ARDC's RAID API.
+     *
+     * Author: <a href='https://github.com/shilob' target='_blank'>Shilo Banihit</a>
+     *
+     */
+    class Raid extends CoreService_1.Services.Core.Service {
+        _exportedMethods = [
+            'mintTrigger',
+            'getContributors',
+            'buildContribVal',
+            'mintPostCreateRetryHandler',
+            'mintRetryJob'
+        ];
+        oauthTokenData = {
+            accessTokenExpiryMillis: null,
+            accessToken: null,
+            responseData: null
+        };
+        constructor() {
+            super();
+            this.logHeader = "RaidService::";
+        }
+        async mintTrigger(oid, record, options) {
+            if (this.metTriggerCondition(oid, record, options) === "true") {
+                await this.mintRaid(oid, record, options);
+            }
+            else {
+                sails.log.debug(`${this.logHeader} mintTrigger()-> RAiD URL already minted.`);
+            }
+            return record;
+        }
+        /**
+         * Light AgendaQueue wrapper for the main mint method.
+        */
+        async mintRetryJob(job) {
+            const data = job.attrs.data;
+            const record = await RecordsService.getMeta(data.oid);
+            const attemptCount = data.attemptCount ?? 0;
+            const options = data.options ?? {};
+            await this.mintRaid(data.oid, record, options, attemptCount);
+        }
+        /**
+         * Light retry handler for preSave onCreate failures, when OID is still unknown.
+         *
+         * @param oid
+         * @param record
+         * @param options
+         */
+        async mintPostCreateRetryHandler(oid, record, _options) {
+            const attemptCount = Number(_.get(record, 'metaMetadata.raid.attemptCount', 0));
+            if (!_.isEmpty(oid) && attemptCount > 0) {
+                sails.log.verbose(`${this.logHeader} mintPostCreateRetryHandler() -> Scheduled for ${oid} `);
+                const raidOptions = _.get(record, 'metaMetadata.raid.options', {});
+                this.scheduleMintRetry({ oid: oid, options: raidOptions, attemptCount: attemptCount });
+            }
+        }
+        /**
+         * Returns `sails.config.raid.token`
+         *
+         * If not set, retrieves an access token using `sails.config.raid.username` and `sails.config.raid.password`
+         *
+         * Access tokens have 24 hour validity
+         *
+         * @returns access token
+         */
+        async getToken() {
+            if (!_.isEmpty(_.trim(sails.config.raid.token))) {
+                sails.log.verbose(`${this.logHeader} getToken() -> Using 'sails.config.raid.token'`);
+                return sails.config.raid.token;
+            }
+            const now = Date.now();
+            if (this.oauthTokenData.accessTokenExpiryMillis && now < this.oauthTokenData.accessTokenExpiryMillis) {
+                sails.log.verbose(`${this.logHeader} getToken() -> Using cached accessToken`);
+                return this.oauthTokenData.accessToken;
+            }
+            const oauthUrl = sails.config.raid.oauth.url;
+            const oauthClientId = sails.config.raid.oauth.client_id;
+            const username = sails.config.raid.oauth.username;
+            const password = sails.config.raid.oauth.password;
+            // FYI: as of 03 October 2024, the staging environment's  `refresh_expires_in` has the same value as `expires_in` rendering it useless
+            if (_.isEmpty(username) || _.isEmpty(password)) {
+                throw new RBValidationError_1.RBValidationError({
+                    message: "Username and/or Password not configured",
+                    displayErrors: [{ code: 'raid-mint-transform-validation-error' }],
+                });
+            }
+            try {
+                sails.log.verbose(`${this.logHeader} getToken() -> Getting new access token...`);
+                const oauthConfig = {
+                    url: oauthUrl,
+                    grant_type: 'password',
+                    username: username,
+                    password: password,
+                    client_id: oauthClientId
+                };
+                const auth1 = await this.fetchAuthToken(oauthConfig);
+                sails.log.verbose(`${this.logHeader} getToken() -> Got new token!`);
+                if (auth1) {
+                    this.oauthTokenData.responseData = auth1;
+                    this.oauthTokenData.accessTokenExpiryMillis = Date.now() + ((auth1.expires_in ?? 0) * 1000);
+                    this.oauthTokenData.accessToken = auth1.access_token ?? null;
+                }
+            }
+            catch (err) {
+                throw new RBValidationError_1.RBValidationError({
+                    message: "Failed to get token",
+                    options: { cause: err },
+                    displayErrors: [{ code: 'raid-mint-transform-validation-error' }],
+                });
+            }
+            return this.oauthTokenData.accessToken;
+        }
+        async fetchAuthToken(oauthConfig) {
+            try {
+                const params = new URLSearchParams({
+                    'grant_type': String(oauthConfig.grantType ?? oauthConfig.grant_type ?? ''),
+                    'client_id': String(oauthConfig.clientId ?? oauthConfig.client_id ?? ''),
+                    'username': String(oauthConfig.username ?? ''),
+                    'password': String(oauthConfig.password ?? '')
+                });
+                const response = await axios_1.default.post(oauthConfig.url, params, {
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded'
+                    }
+                });
+                const tokenData = response.data;
+                return tokenData;
+            }
+            catch (error) {
+                throw new RBValidationError_1.RBValidationError({
+                    message: "Error fetching the token",
+                    options: { cause: error },
+                    displayErrors: [{ code: 'raid-mint-server-error' }],
+                });
+            }
+        }
+        async mintRaid(oid, record, options, attemptCount = 0) {
+            const basePath = sails.config.raid.basePath;
+            const apiToken = await this.getToken();
+            const configuration = new raido_openapi_generated_node_1.Configuration({
+                basePath: basePath,
+                accessToken: apiToken || undefined
+            });
+            const api = new raido_openapi_generated_node_1.RaidApi(configuration);
+            const request = {};
+            try {
+                let srcRecord = record;
+                const srcRecField = String(_.get(options, 'request.sourceOidField', ''));
+                if (!_.isEmpty(srcRecField)) {
+                    let srcRecVal = null;
+                    const srcRecOid = String(_.get(record, srcRecField, ''));
+                    if (!_.isEmpty(srcRecOid)) {
+                        srcRecVal = await RecordsService.getMeta(srcRecOid);
+                        if (!_.isEmpty(srcRecVal)) {
+                            srcRecord = srcRecVal;
+                            // process any overrides to the source record
+                            const recordOverrides = _.get(options, 'request.recordOverrides', []);
+                            if (!_.isEmpty(recordOverrides) && _.isArray(recordOverrides)) {
+                                for (const recOverride of recordOverrides) {
+                                    const fieldPath = String(recOverride.field ?? '');
+                                    const valuePath = String(recOverride.value ?? '');
+                                    if (!_.isEmpty(fieldPath) && !_.isEmpty(valuePath)) {
+                                        _.set(srcRecord, fieldPath, _.get(record, valuePath));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (_.isEmpty(srcRecVal)) {
+                        throw new RBValidationError_1.RBValidationError({
+                            message: `Failed to retrieve the source record: ${srcRecOid}, using path: ${srcRecField}, please check your recordtype configuration.`,
+                            displayErrors: [{ code: 'raid-mint-transform-validation-error' }],
+                        });
+                    }
+                }
+                let mintRequestFields = _.get(options, 'request.mint.fields');
+                if (_.isString(mintRequestFields)) {
+                    // allows to DRYer config
+                    mintRequestFields = _.get(sails.config, mintRequestFields);
+                }
+                const mappedData = this.getMappedData(srcRecord, mintRequestFields ?? {}, options);
+                request.title = _.get(mappedData, 'title');
+                request.date = _.get(mappedData, 'date');
+                request.description = _.get(mappedData, 'description');
+                request.access = _.get(mappedData, 'access');
+                request.alternateUrl = _.get(mappedData, 'alternateUrl');
+                request.contributor = _.get(mappedData, 'contributor');
+                request.organisation = _.get(mappedData, 'organisation');
+                request.subject = _.get(mappedData, 'subject');
+            }
+            catch (error) {
+                throw new RBValidationError_1.RBValidationError({
+                    options: { cause: error },
+                    displayErrors: [{ code: 'raid-mint-transform-validation-error' }],
+                });
+            }
+            let raid = undefined;
+            let metaMetadataInfo = undefined;
+            let responseStatus = undefined;
+            let responseBody = undefined;
+            try {
+                sails.log.verbose(`${this.logHeader} mintRaid() ${oid} -> Sending data::`);
+                sails.log.verbose(JSON.stringify(request));
+                const axiosResponse = await api.mintRaid(request);
+                _.set(axiosResponse, 'config.headers.Authorization', '-redacted-');
+                responseStatus = axiosResponse.status;
+                responseBody = axiosResponse.data;
+                sails.log.verbose(JSON.stringify(responseStatus));
+                sails.log.verbose(`${this.logHeader} mintRaid() ${oid} -> Body::`);
+                sails.log.verbose(JSON.stringify(responseBody));
+                if (responseStatus == 201) {
+                    raid = _.get(responseBody, 'identifier');
+                    if (sails.config.raid.saveBodyInMeta) {
+                        metaMetadataInfo = responseBody;
+                    }
+                }
+                else {
+                    // Note: if there's any 'notSet' validation errors, these will have to be hashed out during development,
+                    // with the specific fields set to 'required' and not treat these as runtime errors
+                    throw new RBValidationError_1.RBValidationError({
+                        message: `Failed to mint RAiD for oid ${oid} statusCode ${responseStatus} body ${JSON.stringify(responseBody)}`,
+                        displayErrors: [{ code: 'raid-mint-server-error', status: String(responseStatus ?? '') }],
+                    });
+                }
+            }
+            catch (error) {
+                const errObj = error;
+                _.set(errObj, 'response.request.headers.Authorization', '-redacted-');
+                const statusCode = _.get(errObj, 'statusCode');
+                const msgs = [];
+                if (statusCode == 401 || statusCode == 403 || statusCode == 400) {
+                    msgs.push(`Authentication failed for oid ${oid}, check if the auth token is properly configured.`);
+                    if (statusCode == 400) {
+                        msgs.push(`Possible validation issues for oid ${oid}!`);
+                    }
+                    throw new RBValidationError_1.RBValidationError({
+                        message: msgs.join(' '),
+                        options: { cause: error },
+                        displayErrors: [{ code: 'raid-mint-server-error', status: String(statusCode ?? ''), meta: { oid } }],
+                    });
+                }
+                // This is the generic handler for when the API call itself throws an exception, e.g. 404, 5xx status code that can possibly be resolved by retrying the request
+                sails.log.error(`${this.logHeader} mintRaid() ${oid} -> API error, Status Code: '${errObj.statusCode}'`);
+                sails.log.error(`${this.logHeader} mintRaid() ${oid} -> Error: ${JSON.stringify(errObj)}`);
+                // set response as the error so it can be saved in the retry block
+                responseStatus = statusCode;
+                // saving as much info by setting the body to either the actual return value or the entire error object
+                responseBody = !_.isEmpty(errObj.body) ? errObj.body : JSON.stringify(errObj);
+                // swallow as this will be handled after this block
+            }
+            if (!_.isEmpty(raid)) {
+                await this.saveRaid(raid, record, options, metaMetadataInfo);
+            }
+            else {
+                sails.log.error(`${this.logHeader} mintRaid() ${oid} -> Failed to mint raid!`);
+                if (!_.isEmpty(sails.config.raid.retryJobName)) {
+                    // a generic/comms error, so we put this in the queue so we can retry later
+                    attemptCount++;
+                    if (attemptCount <= sails.config.raid.retryJobMaxAttempts) {
+                        // set the flag for post-save processor to add the job
+                        _.set(record, 'metaMetadata.raid.attemptCount', attemptCount);
+                        _.set(record, 'metaMetadata.raid.options', options);
+                        _.set(record, 'metaMetadata.raid.attemptResponse', { statusCode: responseStatus, body: responseBody });
+                        if (!_.isEmpty(oid)) {
+                            // same as above but directly schedule as we know the oid
+                            this.scheduleMintRetry({ oid: oid, options: options, attemptCount: attemptCount });
+                        }
+                        // we let the process proceed so the record is saved
+                    }
+                    else {
+                        sails.log.error(`${this.logHeader} mintRaid() -> Max retry attempts reached, giving up: ${oid}`);
+                    }
+                }
+                else {
+                    sails.log.debug(`${this.logHeader} mintRaid() -> Retries not configured, please set 'sails.config.raid.retryJobName'`);
+                    // we fail fast if retries aren't supported
+                    throw new RBValidationError_1.RBValidationError({
+                        message: "Retries not configured, please set 'sails.config.raid.retryJobName'",
+                        displayErrors: [{ code: 'raid-mint-server-error' }],
+                    });
+                }
+            }
+            return record;
+        }
+        scheduleMintRetry(data) {
+            AgendaQueueService.schedule(sails.config.raid.retryJobName, sails.config.raid.retryJobSchedule, data);
+        }
+        getContributors(record, options, fieldConfig, mappedData) {
+            // start with a map to simplify uniqueness guarantees
+            const contributors = {};
+            const contributorMapConfig = _.get(fieldConfig, 'contributorMap', {});
+            const startDate = String(_.get(mappedData, 'date.startDate', ''));
+            const endDateRaw = _.get(mappedData, 'date.endDate', '');
+            const endDate = !_.isEmpty(endDateRaw) ? String(endDateRaw) : undefined;
+            for (const fieldName in contributorMapConfig) {
+                const contribVal = _.get(record, `metadata.${fieldName}`);
+                const contribConfig = contributorMapConfig[fieldName];
+                if (Array.isArray(contribVal)) {
+                    for (const entry of contribVal) {
+                        this.buildContribVal(contributors, entry, contribConfig, startDate, endDate);
+                    }
+                }
+                else {
+                    this.buildContribVal(contributors, contribVal, contribConfig, startDate, endDate);
+                }
+            }
+            // convert to array for the API
+            return _.map(contributors, (val) => { return val; });
+        }
+        buildContribVal(contributors, contribVal, contribConfig, startDate, endDate) {
+            if (!contribVal || typeof contribVal !== 'object') {
+                return;
+            }
+            if (_.isEmpty(_.get(contribVal, 'text_full_name'))) {
+                sails.log.verbose(`${this.logHeader} buildContribVal() -> Ignoring blank record.`);
+                return;
+            }
+            const id = this.getContributorId(contribVal, contribConfig);
+            if (!_.isEmpty(id)) {
+                if (_.isUndefined(contributors[id])) {
+                    // this the first entry to the map, successive updates will only be appending the incoming position & role
+                    const positionType = String(_.get(contribConfig, 'position', ''));
+                    const roleType = String(_.get(contribConfig, 'role', ''));
+                    const contrib = {
+                        id: id,
+                        schemaUri: sails.config.raid.orcidBaseUrl,
+                        position: [
+                            this.getContributorPosition(positionType, startDate, endDate)
+                        ],
+                        role: [
+                            this.getContributorRole(roleType)
+                        ]
+                    };
+                    this.setContributorFlags(contrib, contribConfig);
+                    contributors[id] = contrib;
+                }
+                else {
+                    const positionType = String(_.get(contribConfig, 'position', ''));
+                    const roleType = String(_.get(contribConfig, 'role', ''));
+                    const position = this.getContributorPosition(positionType, startDate, endDate);
+                    const existingContributor = contributors[id];
+                    if (!_.find(existingContributor.position, { id: position.id })) {
+                        // as per https://metadata.raid.org/en/latest/core/contributors.html#contributor-position
+                        // contributors can only have one position for a certain time (unsupported by RB) period so only use the 'highest'
+                        const curPosIdx = _.findIndex(sails.config.raid.types.contributor.hiearchy.position, (lbl) => { return lbl == positionType; });
+                        const existPosLabel = _.findKey(sails.config.raid.types.contributor.position, { id: existingContributor.position?.[0]?.id });
+                        const existPosIdx = _.findIndex(sails.config.raid.types.contributor.hiearchy.position, (lbl) => { return lbl == existPosLabel; });
+                        if (curPosIdx < existPosIdx) {
+                            // the current position is higher, overwrite existing
+                            if (existingContributor.position) {
+                                existingContributor.position[0] = position;
+                            }
+                        }
+                        // if the incoming incoming position is the same or lower hiearchy, ignore...
+                    }
+                    const role = this.getContributorRole(roleType);
+                    if (!_.find(existingContributor.role, { id: role.id })) {
+                        if (existingContributor.role) {
+                            existingContributor.role.push(role);
+                        }
+                    }
+                    this.setContributorFlags(existingContributor, contribConfig);
+                }
+            }
+            else {
+                sails.log.verbose(`${this.logHeader} buildContribVal() -> Missing/invalid identifier for: ${JSON.stringify(contribVal)}`);
+                // we ignore records that don't have a valid ORCID, otherwise we reject the RAiD creation
+                if (_.get(contribConfig, 'requireOrcid', false) == true) {
+                    // reject mint as we have a missing ORCID
+                    throw new RBValidationError_1.RBValidationError({
+                        message: `Missing ORCID and requireOrcid is true for ${JSON.stringify(contribVal)}`,
+                        displayErrors: [{ code: 'raid-mint-transform-missing-contributorid-error', meta: { fullName: _.get(contribVal, 'text_full_name') } }],
+                    });
+                }
+            }
+        }
+        setContributorFlags(contrib, contribConfig) {
+            // setting the required flags: https://metadata.raid.org/en/latest/core/contributors.html
+            const configFlags = sails.config.raid.types.contributor.flags;
+            for (const configFlagName in configFlags) {
+                if (_.includes(configFlags[configFlagName], contribConfig.position)) {
+                    _.set(contrib, configFlagName, true);
+                }
+            }
+        }
+        /**
+         * As per https://support.orcid.org/hc/en-us/articles/360006897674-Structure-of-the-ORCID-Identifier
+         *
+         * orcid must be a 0-9,X
+         *
+         * @param contribVal
+         * @param contribConfig
+         * @returns
+         */
+        getContributorId(contribVal, contribConfig) {
+            const idField = String(_.get(contribConfig, 'fieldMap.id', ''));
+            const rawId = idField ? _.get(contribVal, idField) : '';
+            const rawIdStr = String(rawId ?? '');
+            const strippedId = _.replace(rawIdStr, sails.config.raid.orcidBaseUrl, '');
+            const regex = /(\d{4}-){3}\d{3}(\d|X)/;
+            if (_.isEmpty(strippedId) || _.size(strippedId) !== 19 || regex.test(strippedId) === false) {
+                return '';
+            }
+            // ID now should be the full ORCID Url
+            let id = rawIdStr;
+            if (!_.startsWith(id, sails.config.raid.orcidBaseUrl)) {
+                id = `${sails.config.raid.orcidBaseUrl}${id}`;
+            }
+            return id;
+        }
+        getContributorPosition(type, startDate, endDate) {
+            return {
+                schemaUri: sails.config.raid.types.contributor.position[type].schemaUri,
+                id: sails.config.raid.types.contributor.position[type].id,
+                startDate: startDate,
+                endDate: endDate
+            }; // not currently matching to any generated class so returning as POJO
+        }
+        getContributorRole(type) {
+            return {
+                schemaUri: sails.config.raid.types.contributor.roles.schemaUri,
+                id: `${sails.config.raid.types.contributor.roles.schemaUri}contributor-roles/${sails.config.raid.types.contributor.roles.types[type]}/`
+            }; // not currently matching to any generated class so returning as POJO
+        }
+        getMappedData(record, fields, options) {
+            const mappedData = {};
+            for (const fieldName in fields) {
+                try {
+                    const fieldConfig = _.get(fields, fieldName, {});
+                    const src = String(_.get(fieldConfig, 'src', ''));
+                    const dest = _.get(fieldConfig, 'dest');
+                    let data = undefined;
+                    if (src && src.indexOf('<%') != -1) {
+                        const that = this;
+                        const imports = _.extend({
+                            record: record,
+                            options: options,
+                            moment: momentShim_1.momentShim,
+                            numeral: numeral_1.default,
+                            mappedData: mappedData,
+                            fieldConfig: fieldConfig,
+                            types: sails.config.raid.types,
+                            that: that
+                        }, this);
+                        const templateData = {
+                            imports: imports
+                        };
+                        data = _.template(src, templateData)();
+                        if (_.get(fieldConfig, 'parseJson', false)) {
+                            data = JSON.parse(data);
+                        }
+                    }
+                    else {
+                        data = _.get(record, src);
+                    }
+                    const destPath = dest != null ? String(dest) : '';
+                    if (!_.isEmpty(destPath)) {
+                        _.set(mappedData, destPath, data);
+                    }
+                    else {
+                        sails.log.warn(`${this.logHeader} getMappedData() -> Destination field is empty for ${fieldName}, if there is a missing mapped value, check if the template/fn call is setting the destination value.`);
+                    }
+                }
+                catch (fieldErr) {
+                    throw new RBValidationError_1.RBValidationError({
+                        message: `Failed to process field: ${fieldName}`,
+                        options: { cause: fieldErr },
+                        displayErrors: [{ code: 'raid-mint-transform-validation-error' }],
+                    });
+                }
+            }
+            return mappedData;
+        }
+        getSubject(record, options, fieldConfig, subjects = [], subjectType = '', subjectData) {
+            if (_.isArray(subjectData) && !_.isEmpty(subjectData) && !_.isEmpty(subjectType)) {
+                for (const subject of subjectData) {
+                    const notation = String(_.get(subject, 'notation', ''));
+                    const label = String(_.get(subject, 'label', ''));
+                    subjects.push({
+                        id: `${sails.config.raid.types.subject[subjectType].id}${notation}`,
+                        schemaUri: sails.config.raid.types.subject[subjectType].schemaUri,
+                        keyword: [
+                            {
+                                text: label
+                            }
+                        ]
+                    });
+                }
+            }
+            else {
+                sails.log.warn(`${this.logHeader} getSubject() -> Missing subject source data: ${String(_.get(fieldConfig, 'dest', ''))}`);
+            }
+            return subjects;
+        }
+        async saveRaid(raid, record, options, metaMetadataInfo) {
+            // add raid to record, defaults to 'raidUrl'
+            const raidFieldName = String(_.get(sails.config.raid, 'raidFieldName', 'raidUrl'));
+            _.set(record, `metadata.${raidFieldName}`, raid.id);
+            if (sails.config.raid.saveBodyInMeta) {
+                // don't save the response object as it contains the auth token
+                _.set(record, 'metaMetadata.raid.response', metaMetadataInfo);
+            }
+            const alsoSaveRaidToOid = _.get(options, 'request.alsoSaveRaidToOid', []);
+            if (!_.isEmpty(alsoSaveRaidToOid)) {
+                sails.log.verbose(`${this.logHeader} saveRaid() -> Configured to save to associated records, config: ${JSON.stringify(alsoSaveRaidToOid)}`);
+                for (const saveOidConfig of alsoSaveRaidToOid) {
+                    const oidPath = String(saveOidConfig.oidPath ?? '');
+                    const raidPath = String(saveOidConfig.raidPath ?? '');
+                    const optOid = _.get(record, oidPath);
+                    if (!_.isEmpty(optOid)) {
+                        sails.log.verbose(`${this.logHeader} saveRaid() -> Saving to associated record: ${optOid}`);
+                        const updateResp = await RecordsService.appendToRecord(String(optOid), raid.id, raidPath);
+                        if (!updateResp.isSuccessful()) {
+                            sails.log.error(`${this.logHeader} saveRaid() -> Failed to save to record: ${optOid}, reason: ${updateResp.message}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Services.Raid = Raid;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RaidService.js","sourceRoot":"","sources":["../../src/services/RaidService.ts"],"names":[],"mappings":"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"}

package/dist/services/RecordTypesService.d.ts

@@ -0,0 +1,27 @@
+import { Observable } from 'rxjs';
+import { Services as services } from '../CoreService';
+import { BrandingModel } from '../model/storage/BrandingModel';
+import { RecordTypeModel } from '../model/storage/RecordTypeModel';
+export declare namespace Services {
+    /**
+     * WorkflowSteps related functions...
+     *
+     * Author: <a href='https://github.com/shilob' target='_blank'>Shilo Banihit</a>
+     *
+     */
+    class RecordTypes extends services.Core.Service {
+        protected _exportedMethods: string[];
+        protected recordTypes: RecordTypeModel[];
+        bootstrap(defBrand: BrandingModel): Promise<RecordTypeModel[]>;
+        create(brand: BrandingModel, name: string, config: RecordTypeModel & {
+            dashboard?: unknown;
+        }): Observable<RecordTypeModel>;
+        get(brand: BrandingModel, name: string, fields?: string[] | null): Observable<RecordTypeModel>;
+        getAll(brand: BrandingModel, fields?: string[] | null): Observable<RecordTypeModel[]>;
+        getAllCache(): RecordTypeModel[];
+    }
+}
+declare global {
+    let RecordTypesService: Services.RecordTypes;
+}
+//# sourceMappingURL=RecordTypesService.d.ts.map

package/dist/services/RecordTypesService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordTypesService.d.ts","sourceRoot":"","sources":["../../src/services/RecordTypesService.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,UAAU,EAAkB,MAAM,MAAM,CAAC;AAClD,OAAO,EAAE,QAAQ,IAAI,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAGnE,yBAAiB,QAAQ,CAAC;IACxB;;;;;OAKG;IACH,MAAa,WAAY,SAAQ,QAAQ,CAAC,IAAI,CAAC,OAAO;QAEpD,UAAmB,gBAAgB,EAAE,MAAM,EAAE,CAM3C;QAEF,SAAS,CAAC,WAAW,EAAE,eAAe,EAAE,CAAC;QAE5B,SAAS,CAAE,QAAQ,EAAC,aAAa,GAAE,OAAO,CAAC,eAAe,EAAE,CAAC;QAiCnE,MAAM,CAAC,KAAK,EAAC,aAAa,EAAE,IAAI,EAAC,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG;YAAE,SAAS,CAAC,EAAE,OAAO,CAAA;SAAE,GAAE,UAAU,CAAC,eAAe,CAAC;QAgBvH,GAAG,CAAC,KAAK,EAAC,aAAa,EAAE,IAAI,EAAC,MAAM,EAAE,MAAM,GAAE,MAAM,EAAE,GAAG,IAAW,GAAG,UAAU,CAAC,eAAe,CAAC;QAQlG,MAAM,CAAC,KAAK,EAAC,aAAa,EAAE,MAAM,GAAE,MAAM,EAAE,GAAG,IAAW,GAAG,UAAU,CAAC,eAAe,EAAE,CAAC;QAQ1F,WAAW,IAAI,eAAe,EAAE;KAGxC;CACF;AAED,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAAC;CAC9C"}