@hestia-earth/api 0.26.0 → 0.26.2

package/dist/esm/aggregations/model/document.js

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

package/dist/esm/aggregations/model/model.js

@@ -0,0 +1,36 @@
+import { isNumber } from '@hestia-earth/utils';
+import { BaseModel } from '../../db/model.base';
+import { filenameWithoutExt } from '../../files/model/model';
+export class Aggregation extends BaseModel {
+    folder;
+    filename;
+    filepath;
+    validatedAt;
+    status;
+    pipelineStatus;
+    metadata;
+    productId;
+    countryId;
+    startYear;
+    endYear;
+}
+export const defaultAggregationPeriod = 20;
+export const aggregationFolderFromFilename = (filename) => {
+    const name = filenameWithoutExt(filename);
+    const parts = name.split('-');
+    const timestamp = parts.pop();
+    return timestamp.length === 8 ? parts.join('-') : name;
+};
+export const parseAggregationValues = (value) => {
+    const [productId, ...parts] = aggregationFolderFromFilename(value).split('-');
+    const countryId = parts.filter(v => !isNumber(v)).join('-');
+    const endYear = +parts.pop();
+    const lastPart = parts.pop();
+    const startYear = isNumber(lastPart) ? +lastPart : endYear - defaultAggregationPeriod + 1;
+    return {
+        productId,
+        countryId,
+        startYear,
+        endYear
+    };
+};

package/dist/esm/analyses/model/document.js

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

package/dist/esm/analyses/model/model.js

@@ -0,0 +1,16 @@
+import { BaseModel } from '../../db/model.base';
+export var AnalysisType;
+(function (AnalysisType) {
+    AnalysisType["gapFilling"] = "gap-filling";
+    AnalysisType["quantity"] = "quantity";
+    AnalysisType["term"] = "term";
+})(AnalysisType || (AnalysisType = {}));
+export class Analysis extends BaseModel {
+    cycleId;
+    name;
+    indicators;
+    cycle;
+    impactAssessment;
+    quantity;
+    term;
+}

package/dist/esm/api-calls/model/model.js

@@ -0,0 +1,6 @@
+import { BaseModel } from '../../db/model.base';
+export class ApiCall extends BaseModel {
+    url;
+    user;
+    duration;
+}

package/dist/esm/cycles/model/model.js

@@ -0,0 +1 @@
+export const getPrimaryProduct = (products) => (products || []).find(product => product.primary === true);

package/dist/esm/db/model.base.js

@@ -0,0 +1,5 @@
+export class BaseModel {
+    id;
+    createdAt;
+    updatedAt;
+}

package/dist/esm/db/mongoose.model.js

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

package/dist/esm/earth-engine/model/model.js

@@ -0,0 +1,11 @@
+export var EarthEngineCallType;
+(function (EarthEngineCallType) {
+    EarthEngineCallType["boundary"] = "boundary";
+    EarthEngineCallType["coordinates"] = "coordinates";
+    EarthEngineCallType["gadm"] = "gadm";
+})(EarthEngineCallType || (EarthEngineCallType = {}));
+export var EarthEngineType;
+(function (EarthEngineType) {
+    EarthEngineType["raster"] = "raster";
+    EarthEngineType["vector"] = "vector";
+})(EarthEngineType || (EarthEngineType = {}));

package/dist/esm/files/model/document.js

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

package/dist/esm/files/model/model.js

@@ -0,0 +1,255 @@
+import { BaseModel } from '../../db/model.base';
+import { hasPermission, isAdmin, isReviewer, UserPermission, UserRole } from '../../users/model/model';
+export const mb = 1048576;
+export const sizeInMb = (size) => Math.round((size / mb) * 1000) / 1000;
+export const maxFileSizeMb = 100;
+export const maxFileSize = maxFileSizeMb * mb;
+export var SupportedExtensions;
+(function (SupportedExtensions) {
+    SupportedExtensions["xlsx"] = "xlsx";
+    SupportedExtensions["xls"] = "xls";
+    SupportedExtensions["csv"] = "csv";
+    SupportedExtensions["json"] = "json";
+    SupportedExtensions["draft"] = "txt";
+    SupportedExtensions["pdf"] = "pdf";
+})(SupportedExtensions || (SupportedExtensions = {}));
+const maxFileSizeExt = {
+    [SupportedExtensions.csv]: maxFileSize,
+    [SupportedExtensions.xlsx]: maxFileSize / 2,
+    [SupportedExtensions.xls]: maxFileSize / 2,
+    [SupportedExtensions.draft]: maxFileSize,
+    [SupportedExtensions.json]: maxFileSize,
+    [SupportedExtensions.pdf]: maxFileSize / 2
+};
+export const maxFileSizeByFile = (filename) => maxFileSizeExt[fileExt(filename).replace('.', '')];
+export const finalFormatExtensions = [SupportedExtensions.json, SupportedExtensions.csv];
+export var HestiaExtensions;
+(function (HestiaExtensions) {
+    HestiaExtensions["nodes"] = "hestia";
+    HestiaExtensions["progress"] = "progress";
+    HestiaExtensions["log"] = "log";
+    HestiaExtensions["jsonLog"] = "jlog";
+    HestiaExtensions["error"] = "err";
+    HestiaExtensions["json"] = "json";
+    HestiaExtensions["jsonld"] = "jsonld";
+    HestiaExtensions["contributions"] = "contributions";
+})(HestiaExtensions || (HestiaExtensions = {}));
+export var FileFindFields;
+(function (FileFindFields) {
+    FileFindFields["sources"] = "sources";
+    FileFindFields["cycles"] = "nbCycles";
+    FileFindFields["impactAssessments"] = "nbImpactAssessments";
+    FileFindFields["users"] = "user";
+    FileFindFields["hestiaData"] = "hestiaDataPath";
+})(FileFindFields || (FileFindFields = {}));
+export var FileProgress;
+(function (FileProgress) {
+    FileProgress["convertExcel"] = "convertExcel";
+    FileProgress["convertCsv"] = "convertCsv";
+    FileProgress["convertJson"] = "convertJson";
+    FileProgress["checkExisting"] = "checkExisting";
+    FileProgress["extendBibliography"] = "extendBibliography";
+    FileProgress["addMetadata"] = "addMetadata";
+    FileProgress["validateHestia"] = "validateHestia";
+    FileProgress["validateData"] = "validateData";
+    FileProgress["copyHestia"] = "copyHestia";
+    FileProgress["processJson"] = "processJson";
+    FileProgress["indexJson"] = "indexJson";
+})(FileProgress || (FileProgress = {}));
+export var FileStatus;
+(function (FileStatus) {
+    FileStatus["convertExcelDone"] = "convertExcelDone";
+    FileStatus["convertCsvDone"] = "convertCsvDone";
+    FileStatus["convertJsonDone"] = "convertJsonDone";
+    FileStatus["checkExistingDone"] = "checkExistingDone";
+    FileStatus["extendBibliographyDone"] = "extendBibliographyDone";
+    FileStatus["addMetadataDone"] = "addMetadataDone";
+    FileStatus["validateHestiaDone"] = "validateHestiaDone";
+    FileStatus["validateDataDone"] = "validateDataDone";
+    FileStatus["copyHestiaDone"] = "copyHestiaDone";
+    FileStatus["processJsonDone"] = "processJsonDone";
+    FileStatus["indexJsonDone"] = "indexJsonDone";
+})(FileStatus || (FileStatus = {}));
+export var FileError;
+(function (FileError) {
+    FileError["convertExcelError"] = "convertExcelError";
+    FileError["convertCsvError"] = "convertCsvError";
+    FileError["convertJsonError"] = "convertJsonError";
+    FileError["checkExistingError"] = "checkExistingError";
+    FileError["extendBibliographyError"] = "extendBibliographyError";
+    FileError["addMetadataError"] = "addMetadataError";
+    FileError["validateHestiaError"] = "validateHestiaError";
+    FileError["validateDataError"] = "validateDataError";
+    FileError["copyHestiaError"] = "copyHestiaError";
+    FileError["processJsonError"] = "processJsonError";
+    FileError["indexJsonError"] = "indexJsonError";
+})(FileError || (FileError = {}));
+export var FilePipelineStatus;
+(function (FilePipelineStatus) {
+    FilePipelineStatus["indexEngineDone"] = "indexEngineDone";
+    FilePipelineStatus["calculationEngineDone"] = "calculationEngineDone";
+})(FilePipelineStatus || (FilePipelineStatus = {}));
+export var FilePipelineProgress;
+(function (FilePipelineProgress) {
+    FilePipelineProgress["indexEngine"] = "indexEngine";
+    FilePipelineProgress["calculationEngine"] = "calculationEngine";
+})(FilePipelineProgress || (FilePipelineProgress = {}));
+export var FilePipelineError;
+(function (FilePipelineError) {
+    FilePipelineError["indexEngineError"] = "indexEngineError";
+    FilePipelineError["calculationEngineError"] = "calculationEngineError";
+})(FilePipelineError || (FilePipelineError = {}));
+export var FileValidationStatus;
+(function (FileValidationStatus) {
+    FileValidationStatus["success"] = "success";
+    FileValidationStatus["error"] = "error";
+})(FileValidationStatus || (FileValidationStatus = {}));
+export class File extends BaseModel {
+    filename;
+    filepath;
+    folder;
+    user;
+    assignedUsers;
+    authorizedUsers;
+    contentType;
+    archived;
+    status;
+    pipelineStatus;
+    validationStatus;
+    userValidatedAt;
+    validatedUser;
+    validatedAt;
+    schemaVersion;
+    schemaOutdated;
+    glossaryOutdated;
+    comments;
+    todos;
+    metadata;
+    isPrivate;
+    skipValidation;
+    study;
+    fromDraft;
+    deleted;
+    isOwner;
+    isAuthorized;
+    isAssignedToMe;
+    isValidated;
+    isDraft;
+    originalPath;
+    hestiaPath;
+    progressPath;
+    studyPath;
+    dataPath;
+    dataProgressPath;
+    dataCsvPath;
+    dataRecalculatedCsvPath;
+    dataRecalculatedStatusPath;
+    logPath;
+    errorPath;
+    sources;
+    nbCycles;
+    nbImpactAssessments;
+    hestiaDataPath;
+}
+const fileNoExtSearch = (key, ...parts) => {
+    const [filepathNoExt] = parts.filter(Boolean).join('/').split('.');
+    return {
+        [key]: {
+            $in: Object.values(SupportedExtensions).map(ext => `${filepathNoExt}.${ext}`)
+        }
+    };
+};
+export const filenameSearch = (...parts) => (parts?.length ? fileNoExtSearch('filename', ...parts) : {});
+export const filepathSearch = (...parts) => (parts?.length ? fileNoExtSearch('filepath', ...parts) : {});
+export const fileExt = (path) => {
+    const paths = path?.split('/')?.pop()?.split('.');
+    return paths.length > 1 ? paths.pop() : null;
+};
+export const isSupportedExt = (path) => Object.values(SupportedExtensions).includes(fileExt(path));
+export const fileToExt = (path, extension = '') => [
+    path
+        .replace(`.${fileExt(path)}`, '')
+        .replace(/^\./g, '')
+        .replace(/\.$/g, ''),
+    (extension || '').replace(/[.]/g, '')
+]
+    .filter(Boolean)
+    .join('.');
+export const filenameWithoutExt = (filepath = '') => {
+    const filename = filenameFromPath(filepath);
+    const file = fileToExt(filename, '');
+    return file.endsWith('.') ? file.substring(0, file.length - 1) : file;
+};
+export const validPathChars = 'A-Za-z\\d\\-_';
+const rstripChar = (value) => (value.length > 1 ? value.replace(/(\.|\_)$/g, '') : value);
+export const replaceInvalidChars = (value) => {
+    const folder = folderFromPath(value);
+    const newFilename = value
+        ? rstripChar(rstripChar(filenameWithoutExt(value))
+            .replace(new RegExp(`[^${validPathChars}]`, 'g'), '_')
+            .replace(new RegExp(Object.values(SupportedExtensions)
+            .map(v => `(\_${v})`)
+            .join('|'), 'g'), '')
+            .replace(/[\_]{2,}/g, '_'))
+        : null;
+    return newFilename
+        ? value?.includes('.')
+            ? [normalizeFolder(folder), fileToExt(newFilename, fileExt(value))].filter(Boolean).join('/')
+            : newFilename
+        : value;
+};
+export const canUseFolder = (value) => !!value && !isFolderUpload(value.toLowerCase());
+export const canUploadFolderFile = (value) => !!value && isSupportedExt(value) && isFolderUpload(value);
+export const isFilenameValid = (filename) => !!filename && filename.split('.').filter(Boolean).length > 1 && isSupportedExt(filename);
+export const isFilepathValid = (filepath) => !!filepath && [isSupportedExt(filepath), canUseFolder(filepath)].every(Boolean);
+export const normalizeFolder = (folder) => folder.replace(new RegExp(`[^${validPathChars}]`, 'g'), '_').replace(/[\_]{2,}/g, '_');
+export const folderFromPath = (path) => (path?.includes('.') ? path.split('/').slice(0, -1).join('/') : path);
+export const rootFolderFromPath = (path) => path.split('/')[0];
+export const filenameFromPath = (path) => path.split('/').pop();
+export const analysesFolder = 'analyses';
+export const glossaryFolder = 'glossary';
+export const termFolder = 'term';
+export const reconciliationFolder = 'reconciliation';
+export const isAnalysis = (path) => rootFolderFromPath(path) === analysesFolder;
+export const isReconciliation = (path) => rootFolderFromPath(path) === reconciliationFolder;
+export const hasReconciliationAccess = (file, user) => 'idRecalculated' in file && hasPermission(UserPermission.reconciliationsRead, user);
+export const isGlossary = (path) => rootFolderFromPath(path) === glossaryFolder;
+export const isTerm = (path) => rootFolderFromPath(path) === termFolder;
+export const aggregationFolder = 'aggregation';
+export const isAggregation = (path) => rootFolderFromPath(path) === aggregationFolder;
+export const isAdminFolder = (path) => !!path && [isTerm, isAnalysis, isAggregation, isReconciliation].some(f => f(path));
+export const isFolderUpload = (path, termsOnly = false) => [isGlossary, isTerm, ...(termsOnly ? [] : [isAggregation, isReconciliation])].some(f => f(path));
+const asString = (v) => (typeof v === 'object' ? v?._id?.toString() || v?.id?.toString() : v?.toString());
+export const userFolder = (user) => asString(user);
+export const isOwner = (file, user) => asString(file?.user) === asString(user);
+export const isAuthorized = ({ authorizedUsers }, user) => (authorizedUsers || []).map(asString).includes(asString(user));
+export const isAssigned = ({ assignedUsers }, user) => (assignedUsers || []).map(asString).includes(asString(user));
+export const isLocked = ({ status, pipelineStatus }) => ![FileStatus.validateDataDone, ...Object.values(FileError)].includes(status) &&
+    (status !== FileStatus.indexJsonDone ||
+        ![FilePipelineStatus.calculationEngineDone, FilePipelineError.calculationEngineError].includes(pipelineStatus));
+export const canForceRemove = (file, user, forceDelete) => (isAdmin(user) && forceDelete === true) || !isLocked(file);
+export const canRemove = (file, user) => isAdmin(user) || !isValidated(file) || file.isPrivate;
+const validateStatuses = [FileStatus.validateDataDone, FileStatus.indexJsonDone, FileError.indexJsonError];
+export const validatedStatuses = [FileStatus.copyHestiaDone, FileStatus.processJsonDone, FileStatus.indexJsonDone];
+export const canValidate = ({ status, isPrivate, archived }, user) => !archived && validateStatuses.includes(status) && (isPrivate || isReviewer(user));
+export const isValidated = ({ validatedAt, status }) => !!validatedAt || validatedStatuses.includes(status);
+const submitStatuses = [FileStatus.validateDataDone];
+export const canSubmit = (file, user) => !file.archived &&
+    submitStatuses.includes(file.status) &&
+    !file.userValidatedAt &&
+    (isOwner(file, user) || isAuthorized(file, user));
+export const isDraft = ({ filepath, filename }) => (filepath || filename || '').endsWith(SupportedExtensions.draft);
+export const canEditComment = (comment, user) => asString(comment?.user) === asString(user);
+export const canCommitHestiaData = (file, user) => !file.archived && isValidated(file) && (isReviewer(user) || user?.canCommitHestiaData);
+const grantAccessByRole = {
+    [UserRole.Admin]: () => true,
+    [UserRole.Reviewer]: (file, user) => !file.isPrivate || isAssigned(file, user),
+    [UserRole.Developer]: () => false,
+    [UserRole.Researcher]: () => false
+};
+export const hasAccess = (file, user, allowedRoles) => [
+    isAdmin(user),
+    hasReconciliationAccess(file, user),
+    (!allowedRoles.length || allowedRoles.includes(user.role)) &&
+        (isAuthorized(file, user) || grantAccessByRole[user.role]?.(file, user))
+].some(Boolean);

package/dist/esm/glossary/model/model.js

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

package/dist/esm/migrations/model/model.js

@@ -0,0 +1,10 @@
+import { BaseModel } from '../../db/model.base';
+export var MigrationType;
+(function (MigrationType) {
+    MigrationType["glossary"] = "glossary";
+    MigrationType["schema"] = "schema";
+})(MigrationType || (MigrationType = {}));
+export class Migration extends BaseModel {
+    filenames;
+    type;
+}

package/dist/esm/models.js

@@ -0,0 +1,15 @@
+export * from './api-calls/model/model';
+export * from './aggregations/model/model';
+export * from './analyses/model/model';
+export * from './cycles/model/model';
+export * from './earth-engine/model/model';
+export * from './files/model/model';
+export * from './glossary/model/model';
+export * from './migrations/model/model';
+export * from './nodes/model/model';
+export * from './reconciliations/model/model';
+export * from './settings/model/model';
+export * from './url-shortener/model/model';
+export * from './users/model/model';
+export * from './webhooks/model/model';
+export * from './ws.model';

package/dist/esm/nodes/model/model.js

@@ -0,0 +1,93 @@
+import { SchemaType, NodeType, TermTermType, jsonldPath, isTypeNode, isExpandable } from '@hestia-earth/schema';
+import { dayMs, reduceUndefinedValues, unique } from '@hestia-earth/utils';
+import { fileToExt, SupportedExtensions } from '../../files/model/model';
+import { hasPermission, UserPermission } from '../../users/model/model';
+export const blankNodeTypes = Object.values(SchemaType).filter(t => !isTypeNode(t));
+export var DataState;
+(function (DataState) {
+    DataState["original"] = "original";
+    DataState["recalculated"] = "recalculated";
+})(DataState || (DataState = {}));
+export const dataStatesTypeMapping = {
+    [DataState.original]: Object.values(NodeType),
+    [DataState.recalculated]: [NodeType.Cycle, NodeType.ImpactAssessment, NodeType.Site]
+};
+export const allowedDataStates = (type) => Object.values(DataState).filter(dataState => dataStatesTypeMapping[dataState].includes(type));
+export const pathWithState = (type, id, dataState = DataState.original, strictDataState = false) => {
+    const state = dataStatesTypeMapping[dataState].includes(type) ? dataState : null;
+    return state !== null || !strictDataState
+        ? [state === DataState.original ? null : state, jsonldPath(type, id)].filter(Boolean).join('/')
+        : null;
+};
+export const nodeTypeToParam = (type) => `${(type || '').toLowerCase()}s`;
+export const paramToNodeType = (type) => Object.values(NodeType).find(v => nodeTypeToParam(v) === type);
+const csvValue = (value) => (value || '').replace('[', '').replace(']', '');
+const parseMessage = (message) => {
+    try {
+        const data = JSON.parse(message);
+        return data.message.split(',').reduce((prev, parts) => {
+            const [key, value] = parts.split('=');
+            const val = csvValue(value);
+            return {
+                ...prev,
+                ...(key && val ? { [key.trim()]: val } : {})
+            };
+        }, { logger: data.logger });
+    }
+    catch (err) {
+        return {};
+    }
+};
+const termTypes = Object.values(TermTermType);
+const parseFilename = (filepath) => {
+    const [filename] = filepath.split('.');
+    const ext = termTypes.includes(filename) ? SupportedExtensions.xlsx : SupportedExtensions.csv;
+    return fileToExt(filename, ext);
+};
+const missingLookupPrefix = 'Missing lookup';
+const parseLookup = ({ column, termid, [missingLookupPrefix]: missingLookup }) => ({
+    filename: parseFilename(missingLookup),
+    termId: termid,
+    column
+});
+export const parseLogMissingLookups = (data) => {
+    const lines = data.split('\n').filter(log => log.includes(missingLookupPrefix));
+    const messages = lines.map(parseMessage).filter(v => Object.keys(v).length > 1);
+    return unique(messages.map(parseLookup));
+};
+const mapTypeToId = (nodes) => nodes.reduce((prev, { '@type': type, '@id': id }) => {
+    prev[type] = prev[type] || [];
+    prev[type].push(id);
+    return prev;
+}, {});
+export const formatForUpload = (nodes, typeToId = mapTypeToId(nodes)) => nodes.map(({ '@type': type, '@id': id, ...node }) => type === NodeType.Term
+    ? { '@type': type, '@id': id }
+    : reduceUndefinedValues({
+        ...(!id || (typeToId[type] ?? []).includes(id) ? { type, id } : { '@type': type, '@id': id }),
+        ...Object.fromEntries(Object.entries(node).map(([key, value]) => {
+            const newValue = isExpandable(value)
+                ? Array.isArray(value)
+                    ? formatForUpload(value, typeToId)
+                    : formatForUpload([value], typeToId)[0]
+                : value;
+            return [key, newValue];
+        }))
+    }, true));
+export const setPrivate = ({ source, defaultSource, ...node }) => ({
+    ...node,
+    dataPrivate: true
+});
+export const dataVersionRestrictedDays = 182;
+export const isDataVersionRestricted = (dataVersion) => (new Date().getTime() - new Date(dataVersion).getTime()) / dayMs < dataVersionRestrictedDays;
+export const isDataVersionAuthorised = (user, dataVersion) => dataVersion
+    ? isDataVersionRestricted(dataVersion)
+        ?
+            hasPermission(UserPermission.aggregationsLatest, user)
+        : true
+    :
+        hasPermission(UserPermission.aggregationsPreview, user);
+export const isNodeAuthorised = (user, node, dataVersion) => !node.aggregated ||
+    [
+        hasPermission(UserPermission.aggregationsRead, user),
+        node.aggregatedDataValidated && isDataVersionAuthorised(user, dataVersion)
+    ].some(Boolean);

package/dist/esm/reconciliations/model/document.js

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

package/dist/esm/reconciliations/model/model.js

@@ -0,0 +1,19 @@
+import { BaseModel } from '../../db/model.base';
+export { getMainErrorMessage as reconciliationsGetMainErrorMessage, validateProductCorrespondence as reconciliationsValidateProductCorrespondence, validateImpactAssessmentLinks as reconciliationsValidateImpactAssessmentLinks, validateExpectedNodes as reconciliationsValidateExpectedNodes, validatePrivate as reconciliationsValidatePrivate } from './validations';
+export var ReconciliationLevel;
+(function (ReconciliationLevel) {
+    ReconciliationLevel["success"] = "success";
+    ReconciliationLevel["warning"] = "warning";
+    ReconciliationLevel["danger"] = "danger";
+})(ReconciliationLevel || (ReconciliationLevel = {}));
+export class Reconciliation extends BaseModel {
+    idExpected;
+    idRecalculated;
+    dataPrivate;
+    name;
+    level;
+    details;
+    error;
+    uploadStatus;
+    uploadPipelineStatus;
+}

package/dist/esm/reconciliations/model/validations.js

@@ -0,0 +1,62 @@
+import { NodeType } from '@hestia-earth/schema';
+export const notPrivateError = 'expected-not-private';
+export const EXTRANEOUS = 'extraneous';
+const isExtraneousError = (error) => (typeof error === 'string' ? error : error?.message)?.includes(EXTRANEOUS);
+const isNotPrivateError = (error) => (typeof error === 'string' ? error : error?.message) === notPrivateError;
+const getType = (node) => node?.['@type'] || node?.type;
+const getId = (node) => node?.['@id'] || node?.id;
+const filterByType = (nodeType) => (node) => getType(node) === nodeType;
+const getErrorsFromValidationsObj = validations => Object.entries(validations)
+    .filter(([_errorMsg, validationFailed]) => !!validationFailed)
+    .map(([errorMsg]) => errorMsg);
+export const validateExpectedNodes = (nodes) => {
+    const cycles = nodes.filter(node => getType(node) === NodeType.Cycle);
+    const sites = nodes.filter(node => getType(node) === NodeType.Site);
+    const impactAssessments = nodes.filter(node => getType(node) === NodeType.ImpactAssessment);
+    const cycleId = getId(cycles?.[0]);
+    const cycleSiteId = getId(cycles?.[0]?.site);
+    const siteId = getId(sites?.[0]);
+    return getErrorsFromValidationsObj({
+        ['More than one Cycle found in expected nodes']: cycles.length > 1,
+        ['No Cycle found in expected nodes']: cycles.length < 1,
+        ['Cycle missing name field in expected nodes']: cycles.length && !cycles[0].name,
+        ['More than one Site found in expected nodes']: sites.length > 1,
+        [`Cycle ${cycleId} is not linked to Site ${siteId} in expected nodes`]: cycleSiteId !== siteId,
+        ...impactAssessments.reduce((acc, ia) => {
+            acc[`ImpactAssessment ${getId(ia)} is not linked to Cycle ${cycleId} in expected nodes`] =
+                getId(ia?.cycle) !== cycleId;
+            return acc;
+        }, {})
+    });
+};
+const matchedProduct = (impacts) => (product) => impacts.filter(ia => getId(product.term) === getId(ia.product.term)).length > 1;
+export const validateImpactAssessmentLinks = (nodes) => {
+    const impactAssessments = nodes.filter(filterByType(NodeType.ImpactAssessment));
+    const cycle = nodes.find(filterByType(NodeType.Cycle));
+    const cycleId = getId(cycle);
+    return getErrorsFromValidationsObj({
+        [`Cycle ${cycleId} has no associated impact assessment`]: !impactAssessments.length,
+        [`Cycle ${cycleId} has no products`]: !cycle.products?.length,
+        [`Cycle ${cycleId} has a product with more than one linked impact assessment`]: cycle.products?.some(matchedProduct(impactAssessments))
+    });
+};
+export const validatePrivate = (cycle) => getErrorsFromValidationsObj({ [notPrivateError]: !cycle.dataPrivate });
+export const validateProductCorrespondence = (expectedProducts, recalculatedProducts, idRecalculated) => {
+    const missingProducts = expectedProducts.filter(pExpected => !recalculatedProducts.some(pRecalculated => getId(pRecalculated) === getId(pExpected)));
+    const extraneousProducts = recalculatedProducts.filter(pRecalculated => !expectedProducts.some(pExpected => getId(pRecalculated) === getId(pExpected)));
+    return [
+        [missingProducts, 'missing'],
+        [extraneousProducts, EXTRANEOUS]
+    ]
+        .map(([products, errorType]) => products.length
+        ? `Cycle ${idRecalculated} has ${errorType} impact assessment for products: ${products
+            .map(p => p['@id'])
+            .join(', ')}`
+        : null)
+        .filter(Boolean);
+};
+export const getMainErrorMessage = errors => errors?.length === 1 && isExtraneousError(errors[0])
+    ? 'recalculation-error'
+    : errors.some(isNotPrivateError)
+        ? notPrivateError
+        : 'invalid-nodes';

package/dist/esm/settings/model/model.js

@@ -0,0 +1,18 @@
+import { BaseModel } from '../../db/model.base';
+export const cacheKey = 'settings';
+export var SettingKey;
+(function (SettingKey) {
+    SettingKey["maintenanceEnabled"] = "maintenanceEnabled";
+    SettingKey["readonlyEnabled"] = "readonlyEnabled";
+    SettingKey["privateUploadsEnabled"] = "privateUploadsEnabled";
+    SettingKey["publicUploadsEnabled"] = "publicUploadsEnabled";
+    SettingKey["aggregationEngine"] = "aggregationEngine";
+    SettingKey["calculationEngine"] = "calculationEngine";
+    SettingKey["users"] = "users";
+    SettingKey["dataReleases"] = "dataReleases";
+})(SettingKey || (SettingKey = {}));
+export class Setting extends BaseModel {
+    key;
+    value;
+    metadata;
+}

package/dist/esm/url-shortener/model/model.js

@@ -0,0 +1,10 @@
+import { BaseModel } from '../../db/model.base';
+export class UrlShortener extends BaseModel {
+    shortId;
+    path;
+    count;
+}
+export const whitelistedQueryParams = {
+    '/explorer': ['sortBy', 'sortOrder', 'page', 'dataVersion', 'type', 'filters']
+};
+export const isShortPathAllowed = (path) => path.split('?')[0] in whitelistedQueryParams;

package/dist/esm/users/model/document.js

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

package/dist/esm/users/model/model.js

@@ -0,0 +1,107 @@
+import { NodeType } from '@hestia-earth/schema';
+import { dayMs } from '@hestia-earth/utils';
+import { BaseModel } from '../../db/model.base';
+export const defaultMaxApiCalls = 100;
+export const userPermissionRequestTimeout = 7 * dayMs;
+export var MaxUploads;
+(function (MaxUploads) {
+    MaxUploads[MaxUploads["New"] = 1] = "New";
+    MaxUploads[MaxUploads["Confirmed"] = 10] = "Confirmed";
+})(MaxUploads || (MaxUploads = {}));
+export var UserRole;
+(function (UserRole) {
+    UserRole["Researcher"] = "default";
+    UserRole["Developer"] = "developer";
+    UserRole["Reviewer"] = "reviewer";
+    UserRole["Admin"] = "admin";
+})(UserRole || (UserRole = {}));
+export var UserPermission;
+(function (UserPermission) {
+    UserPermission["aggregationsCreate"] = "aggregations-create";
+    UserPermission["aggregationsRead"] = "aggregations-read";
+    UserPermission["aggregationsPreview"] = "aggregations-preview";
+    UserPermission["aggregationsDelete"] = "aggregations-delete";
+    UserPermission["aggregationsVerify"] = "aggregations-verify";
+    UserPermission["aggregationsLatest"] = "aggregations-latest";
+    UserPermission["reconciliationsCreate"] = "reconciliations-create";
+    UserPermission["reconciliationsRead"] = "reconciliations-view";
+    UserPermission["reconciliationsUpdate"] = "reconciliations-update";
+    UserPermission["reconciliationsDelete"] = "reconciliations-delete";
+})(UserPermission || (UserPermission = {}));
+export var UserPermissionRequestStatus;
+(function (UserPermissionRequestStatus) {
+    UserPermissionRequestStatus["Approved"] = "approved";
+    UserPermissionRequestStatus["Rejected"] = "rejected";
+    UserPermissionRequestStatus["Pending"] = "pending";
+})(UserPermissionRequestStatus || (UserPermissionRequestStatus = {}));
+export class User extends BaseModel {
+    email;
+    firstName;
+    lastName;
+    displayName;
+    password;
+    token;
+    role = UserRole.Researcher;
+    maxUploads = MaxUploads.New;
+    maxSkills = 1;
+    maxApiCalls = defaultMaxApiCalls;
+    dataPrivate = false;
+    validFilesCount = 0;
+    canCommitHestiaData = false;
+    permissions = [];
+    permissionsRequests = [];
+    emailNotificationsSuccess = false;
+    emailNotificationsFailure = false;
+    emailNotificationsFeedback = false;
+    emailNotificationsDownload = true;
+    autoSubmitPrivateSubmissions = false;
+    confirmToken;
+    confirmedAt;
+    lastActiveAt;
+    scopusID;
+    googleID;
+    linkedInID;
+    gitlabID;
+    gitlabUsername;
+    orcid;
+    website;
+    city;
+    country;
+    primaryInstitution;
+    metadata = {};
+    admin;
+    name;
+    actorId;
+}
+export const name = ({ firstName, lastName }) => [firstName, lastName].filter(Boolean).join(' ');
+export const isAdmin = (user) => user?.role === UserRole.Admin;
+export const isReviewer = (user) => [UserRole.Reviewer, UserRole.Admin].includes(user?.role);
+export const isDeveloper = (user) => [UserRole.Developer, UserRole.Reviewer, UserRole.Admin].includes(user?.role);
+export const hasPermission = (permission, user) => isAdmin(user) || (user?.permissions ?? []).includes(permission);
+export const isPermissionRequestExpired = (request, timeout = userPermissionRequestTimeout) => new Date().getTime() - new Date(request.createdAt).getTime() >= timeout;
+export const isPermissionExpired = (request, now = new Date()) => request.status === UserPermissionRequestStatus.Approved && request.expiryDate && new Date(request.expiryDate) <= now;
+export const contains = (users, user) => users.some(u => u.email === user.email);
+export const actorId = (user) => `${(user._id || user.id).toString()}`;
+const jsonLDContext = (type, domain) => `${domain}/schema/${type}.jsonld`;
+const addIfDefined = (key, value) => (!!value ? { [key]: value } : {});
+const profileData = (user) => user.dataPrivate
+    ? {}
+    : {
+        email: user.email,
+        firstName: user.firstName,
+        lastName: user.lastName,
+        name: user.displayName || name(user),
+        ...addIfDefined('scopusID', user.scopusID),
+        ...addIfDefined('orcid', user.orcid),
+        ...addIfDefined('primaryInstitution', user.primaryInstitution),
+        ...addIfDefined('city', user.city),
+        ...addIfDefined('country', user.country ? { type: NodeType.Term, name: user.country } : undefined),
+        ...addIfDefined('website', user.website ? { '@id': user.website } : undefined)
+    };
+export const userToActor = (user, domain = 'https://hestia.earth') => ({
+    '@context': jsonLDContext(NodeType.Actor, domain),
+    '@type': NodeType.Actor,
+    '@id': actorId(user),
+    dataPrivate: false,
+    ...profileData(user)
+});

package/dist/esm/webhooks/model/document.js

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

package/dist/esm/webhooks/model/model.js

@@ -0,0 +1,15 @@
+export var WebhookType;
+(function (WebhookType) {
+    WebhookType["Files"] = "files";
+})(WebhookType || (WebhookType = {}));
+export var WebhookEvent;
+(function (WebhookEvent) {
+    WebhookEvent["Created"] = "created";
+    WebhookEvent["Updated"] = "updated";
+})(WebhookEvent || (WebhookEvent = {}));
+export var WebhookStatus;
+(function (WebhookStatus) {
+    WebhookStatus["Active"] = "active";
+    WebhookStatus["Inactive"] = "inactive";
+})(WebhookStatus || (WebhookStatus = {}));
+export const webHookTestEvent = 'test';

package/dist/esm/ws.model.js

@@ -0,0 +1,5 @@
+export var SocketNamespace;
+(function (SocketNamespace) {
+    SocketNamespace["aggregation"] = "aggregation";
+    SocketNamespace["file"] = "file";
+})(SocketNamespace || (SocketNamespace = {}));

package/dist/users/model/model.d.ts

@@ -47,6 +47,7 @@ export declare class User extends BaseModel {
     token?: string;
     role: UserRole;
     maxUploads: MaxUploads;
+    maxSkills: number;
     maxApiCalls: number;
     dataPrivate: boolean;
     validFilesCount: number;

package/dist/users/model/model.js

@@ -46,6 +46,7 @@ class User extends model_base_1.BaseModel {
     token;
     role = UserRole.Researcher;
     maxUploads = MaxUploads.New;
+    maxSkills = 1;
     maxApiCalls = exports.defaultMaxApiCalls;
     dataPrivate = false;
     validFilesCount = 0;
@@ -88,9 +89,7 @@ const hasPermission = (permission, user) => (0, exports.isAdmin)(user) || (user?
 exports.hasPermission = hasPermission;
 const isPermissionRequestExpired = (request, timeout = exports.userPermissionRequestTimeout) => new Date().getTime() - new Date(request.createdAt).getTime() >= timeout;
 exports.isPermissionRequestExpired = isPermissionRequestExpired;
-const isPermissionExpired = (request, now = new Date()) => request.status === UserPermissionRequestStatus.Approved &&
-    request.expiryDate &&
-    new Date(request.expiryDate) <= now;
+const isPermissionExpired = (request, now = new Date()) => request.status === UserPermissionRequestStatus.Approved && request.expiryDate && new Date(request.expiryDate) <= now;
 exports.isPermissionExpired = isPermissionExpired;
 const contains = (users, user) => users.some(u => u.email === user.email);
 exports.contains = contains;

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@hestia-earth/api",
-  "version": "0.26.0",
+  "version": "0.26.2",
   "description": "Hestia API definitions",
   "main": "dist/models.js",
+  "module": "dist/esm/models.js",
   "typings": "dist/models.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/models.js",
+      "require": "./dist/models.js",
+      "types": "./dist/models.d.ts"
+    }
+  },
+  "sideEffects": false,
   "scripts": {
     "build": "rm -rf build && tsc -p tsconfig.build.json",
-    "build:module": "rm -rf dist && tsc -p tsconfig.dist.json",
+    "build:module": "rm -rf dist && tsc -p tsconfig.dist.json && tsc -p tsconfig.esm.json",
     "build:lambdas": "rm -rf build && tsc -p tsconfig.lambdas.json",
     "validate:jsonld": "hestia-validate-jsonld test/fixtures/nodes",
     "start": "npm run build && node index.js",