@sync-in/server
Version:
The secure, open-source platform for file storage, sharing, collaboration, and sync
300 lines (299 loc) • 9.18 kB
JavaScript
/*
* Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
* This file is part of Sync-in | The open source file sync and share solution
* See the LICENSE file for licensing details
*/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: Object.getOwnPropertyDescriptor(all, name).get
});
}
_export(exports, {
get anonymizePassword () {
return anonymizePassword;
},
get comparePassword () {
return comparePassword;
},
get convertDiffUpdate () {
return convertDiffUpdate;
},
get convertHumanTimeToMs () {
return convertHumanTimeToMs;
},
get convertHumanTimeToSeconds () {
return convertHumanTimeToSeconds;
},
get diffCollection () {
return diffCollection;
},
get differencePermissions () {
return differencePermissions;
},
get escapePath () {
return escapePath;
},
get escapeSQLRegexp () {
return escapeSQLRegexp;
},
get escapeString () {
return escapeString;
},
get formatDateISOString () {
return formatDateISOString;
},
get generateShortUUID () {
return generateShortUUID;
},
get hashPassword () {
return hashPassword;
},
get loadOptionalModule () {
return loadOptionalModule;
},
get regExpPathPattern () {
return regExpPathPattern;
},
get regexSpecialChars () {
return regexSpecialChars;
},
get regexSpecialCharsWithSpace () {
return regexSpecialCharsWithSpace;
},
get regexpEscape () {
return regexpEscape;
},
get sleep () {
return sleep;
},
get sortObjByName () {
return sortObjByName;
},
get splitFullName () {
return splitFullName;
},
get transformAndValidate () {
return transformAndValidate;
},
get uniquePermissions () {
return uniquePermissions;
},
get urlToPath () {
return urlToPath;
}
});
const _ms = require("@lukeed/ms");
const _bcryptjs = /*#__PURE__*/ _interop_require_default(require("bcryptjs"));
const _classtransformer = require("class-transformer");
const _classvalidator = require("class-validator");
const _nodecrypto = /*#__PURE__*/ _interop_require_default(require("node:crypto"));
const _promises = require("node:timers/promises");
const _spaces = require("../applications/spaces/constants/spaces");
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return {
default: obj
};
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = {
__proto__: null
};
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for(var key in obj){
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
const regexpEscape = /[.*+?^${}()|[\]\\]/g;
const regexSpecialChars = /[-[\]{}()*+!<=:?./\\^$|#,]/g;
const regexSpecialCharsWithSpace = /[-[\]{}()*+!<=:?./\\^$|#\s,]/g;
async function loadOptionalModule(moduleName) {
return await Promise.resolve(moduleName).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
}
async function sleep(ms) {
await (0, _promises.setTimeout)(ms);
}
function escapeSQLRegexp(input) {
return input.replace(regexSpecialCharsWithSpace, '\\\\$&').replaceAll("'", "''");
}
function escapeString(input) {
return input.replace(regexSpecialChars, '\\$&');
}
function escapePath(path) {
return path.replace(regexpEscape, '\\$&');
}
function regExpPathPattern(path) {
return new RegExp(`^${escapePath(path)}[/\\\\]`);
}
function convertHumanTimeToSeconds(value) {
return (0, _ms.parse)(value) / 1000;
}
function convertHumanTimeToMs(value) {
return (0, _ms.parse)(value);
}
function formatDateISOString(date) {
return date.toISOString().replaceAll('-', '.').replaceAll(':', '-').replace('T', ' ').replace('Z', '');
}
function urlToPath(url) {
// transform https://sync-in.com/webdav/ to /webdav/
try {
// transform https://sync-in.com/webdav/ to /webdav/
return new URL(url).pathname;
} catch {
// or allows uri like : /webdav/
return url;
}
}
async function hashPassword(password) {
return await _bcryptjs.default.hash(password, 10);
}
async function comparePassword(password, hash) {
return await _bcryptjs.default.compare(password, hash);
}
function generateShortUUID(length = 32, encoding = 'base64url') {
const bytes = Math.ceil(length * 3 / 4) // adapt to real length
;
return _nodecrypto.default.randomBytes(bytes).toString(encoding);
}
function anonymizePassword(obj) {
return {
...obj,
...obj?.password && {
password: '********'
},
...obj?.secrets && {
secrets: '********'
}
};
}
function splitFullName(fullName) {
if (!fullName || !fullName.trim()) return {
firstName: '',
lastName: ''
};
const parts = fullName.trim().split(/\s+/);
if (parts.length === 1) {
return {
firstName: '',
lastName: parts[0]
};
}
const lastName = parts.pop();
const firstName = parts.join(' ');
return {
firstName,
lastName
};
}
function transformAndValidate(schema, object, transformOptions = {}, validatorOptions = {}) {
// warning: plainToInstance do not use constructor to instantiate class
const instance = (0, _classtransformer.plainToInstance)(schema, object, transformOptions);
const errors = (0, _classvalidator.validateSync)(instance, validatorOptions);
if (errors.length > 0) {
throw new Error(errors.toString());
}
return instance;
}
function uniquePermissions(permissions, permissionsSeparator = _spaces.SPACE_PERMS_SEP) {
/*
Returns unique permissions : 'c:r:w:c:r' -> 'c:r:w'
*/ if (permissions.length === 0) return permissions;
return [
...new Set(permissions.split(permissionsSeparator).filter((p)=>p && p !== 'null').sort())
].join(permissionsSeparator);
}
function differencePermissions(aPermissions, bPermissions, permissionsSeparator = _spaces.SPACE_PERMS_SEP) {
const aPerms = aPermissions.split(permissionsSeparator);
const bPerms = bPermissions.split(permissionsSeparator);
return aPerms.filter((p)=>p !== '' && bPerms.indexOf(p) === -1).sort();
}
function sortObjByName(a, b, asc = false) {
const aN = a.name.toLowerCase();
const bN = b.name.toLowerCase();
if (asc) {
return aN < bN ? 1 : aN > bN ? -1 : 0;
} else {
return aN < bN ? -1 : aN > bN ? 1 : 0;
}
}
function diffProperties(a, b, props) {
for (const p of props){
if (a[p] !== b[p]) {
return false;
}
}
return true;
}
function diffCollection(curCollection, newCollection, updateProps, compareProps = [
'id'
]) {
const toAdd = [];
const toUpdate = [];
const toRemove = curCollection.filter((c)=>!newCollection.find((n)=>diffProperties(c, n, compareProps)));
for (const n of newCollection){
const o = curCollection.find((c)=>diffProperties(c, n, compareProps));
if (o) {
const diff = {};
for (const p of updateProps.filter((p)=>n[p] !== o[p])){
diff[p] = {
old: o[p],
new: n[p]
};
}
if (Object.keys(diff).length) {
diff['object'] = n;
toUpdate.push(diff);
}
} else {
toAdd.push(n);
}
}
return [
toAdd,
toUpdate,
toRemove
];
}
function convertDiffUpdate(update) {
// only keep the new values
return update.map((o)=>Object.fromEntries(Object.entries(o).map(([p, v])=>[
p,
p === 'object' ? v : v.new
])));
}
//# sourceMappingURL=functions.js.map