loginPrompt: string | (() => string | void | undefined | Promise<string | void | undefined>) | undefined,

): Promise<string | null> {

if (typeof loginPrompt === 'function') {

const resolvedLoginPrompt = await loginPrompt();

return resolvedLoginPrompt || null;

}

return loginPrompt || null;

if (name.includes('_')) {

return name.split('_').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');

} else if (name.includes('-')) {

return name.split('-').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');

} else {

// split by capital letters

return name.split(/(?=[A-Z])/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');

}

const __filename = fileURLToPath(metaUrl);

let __dirname = path.dirname(__filename);

// Check for dist/modules in both Unix and Windows path formats

const normalizedDir = __dirname.replace(/\\/g, '/');

if (normalizedDir.endsWith('/dist/modules')) {

// in prod build we are in dist also, so make another back jump to go to sources

__dirname = path.join(__dirname, '..');

}

return __dirname;

try {

return JSON.parse(input);

} catch {

}

const keywords = ['true', 'false', 'null'];

const normalized = input

.replace(/([{,]\s*)([A-Za-z_$][\w$]*)(\s*:)/g, '$1"$2"$3')

.replace(/(:\s*)([A-Za-z_$][\w$]*)(?=\s*[,}\]])/g, (match, before, word) =>

keywords.includes(word) ? match : `${before}"${word}"`

)

.replace(/([\[,]\s*)([A-Za-z_$][\w$]*)(?=\s*[,\]])/g, (match, before, word) =>

keywords.includes(word) ? match : `${before}"${word}"`

);

return JSON.parse(normalized);

if (typeof target !== 'object' || target === null) {

return source;

}

for (let key in source) {

if (source.hasOwnProperty(key)) {

if (typeof source[key] === 'object' && source[key] !== null) {

if (!target[key]) {

target[key] = {};

}

deepMerge(target[key], source[key]);

} else {

target[key] = source[key];

}

}

}

return target;

for (const key in obj) {

if (obj.hasOwnProperty(key)) {

const camelCaseKey = toCamelCase(parentKey ? `${parentKey}_${key}` : key);

if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {

transformObject(obj[key], camelCaseKey, result);

} else {

result[camelCaseKey] = obj[key];

}

}

}

//remove 'Default' from keys

for (const key in result) {

if (key.includes('Main')) {

const newKey = key.replace('Main', '');

result[newKey] = result[key];

delete result[key];

}

}

return result;

var c;

if(/^#([A-Fa-f0-9]{3}){1,2}$/.test(hex)){

c= hex.substring(1).split('');

if(c.length== 3){

c= [c[0], c[0], c[1], c[1], c[2], c[2]];

}

c= '0x'+c.join('');

return 'rgba(' + [(c >> 16) & 255, (c >> 8) & 255, c & 255].join(',') + ',' + opacity + ')';

}

throw new Error('Bad Hex');

if(!color) return

else if (color.startsWith("rgba")) {

//add opacity to existing rgba color

const rgb = color.match(/[\d.]+/g);

return `rgba(${rgb[0]}, ${rgb[1]}, ${rgb[2]}, ${Number(rgb[3]) * opacity})`;

}

else if (color.startsWith("rgb")) {

const rgb = color.match(/\d+/g);

return `rgba(${rgb[0]}, ${rgb[1]}, ${rgb[2]}, ${opacity})`;

}

else if (color.startsWith("#")) {

return hexToRGBA(color, opacity);

}

else if (csscolors[color]) {

return hexToRGBA(csscolors[color], opacity);

}

else {

return color;

}

const aliasRegex = /alias:([^ ]+)/;

const opacityRegex = /opacity:([0-9.]+)/;

const darkenRegex = /darken/;

const lightenRegex = /lighten/;

const inverseRegex = /inverse/;

// Extract alias and properties

const aliasMatch = str.match(aliasRegex);

const opacityMatch = str.match(opacityRegex)

const darkenMatch = str.match(darkenRegex)

const lightenMatch = str.match(lightenRegex)

const inverseMatch = str.match(inverseRegex)

return {aliasMatch,opacityMatch,darkenMatch,lightenMatch, inverseMatch}

let amount = 0.2

// Extract the RGBA components

let [r, g, b, a] = rgba.match(/\d+/g).map(Number);

// Ensure amount is between 0 and 1

amount = Math.max(0, Math.min(1, amount));

// Calculate the new RGB values

r = Math.max(0, r * (1 - amount));

g = Math.max(0, g * (1 - amount));

b = Math.max(0, b * (1 - amount));

// Return the new RGBA color

return `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${a})`;

let amount = 0.2

// Extract the RGBA components

let [r, g, b, a] = rgba.match(/\d+/g).map(Number);

// Ensure amount is between 0 and 1

amount = Math.max(0, Math.min(1, amount));

// Calculate the new RGB values

r = Math.min(255, r * (1 + amount));

g = Math.min(255, g * (1 + amount));

b = Math.min(255, b * (1 + amount));

// Return the new RGBA color

return `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${a})`;

// return white or black depending on the brightness of the color

let [r, g, b] = rgba.match(/\d+/g).map(Number);

let brightness = (r * 299 + g * 587 + b * 114) / 1000;

return brightness > 128 ? 'rgba(0,0,0,1)' : 'rgba(255,255,255,1)';

if (!name) {

return null;

}

const options = {

includeScore: true, // Includes score in the results to see how close matches are

threshold: 0.3, // Defines the fuzziness (lower values mean stricter matches)

};

const fuse = new Fuse(names.filter(

(n) => !!n

), options);

// Search for a resource

const result = fuse.search(name);

if (result.length > 0) {

return result[0].item;

}

const parsed = Number(value);

if (!Number.isInteger(parsed) || parsed <= 0) {

throw new Error(`${fieldName} must be a positive integer, got: "${source}"`);

}

return parsed;

const value = period.slice(0, -1);

const periodChar = period.slice(-1);

if (!isPeriodUnit(periodChar)) {

throw new Error(`Invalid period: ${period}`);

}

const duration = parsePositiveInteger(value, 'Period', period);

if (periodChar === 's') {

return duration;

} else if (periodChar === 'm') {

return duration * 60;

} else if (periodChar === 'h') {

return duration * 60 * 60;

} else if (periodChar === 'd') {

return duration * 60 * 60 * 24;

}

throw new Error(`Invalid period: ${period}`);

// constructor, accepts string like 10/10m, or 20/10s, or 30/1d

rateLimiter: RateLimiterAbstract;

static parseRate(rate: unknown): { points: number, duration: number } {

if (typeof rate !== 'string') {

throw new Error('Rate limit must be a string in format "500/5m"');

}

const parts = rate.split('/');

if (parts.length !== 2) {

throw new Error(`Rate limit must be in format "500/5m", got: "${rate}"`);

}

const [pointsPart, period] = parts;

const periodValue = period.slice(0, -1);

const periodUnit = period.slice(-1);

if (!periodValue || !isPeriodUnit(periodUnit)) {

throw new Error(`Rate limit must be in format "500/5m", got: "${rate}"`);

}

return {

points: parsePositiveInteger(pointsPart, 'Rate limit points', rate),

duration: convertPeriodToSeconds(period as PeriodString),

};

}

constructor(rate: string) {

const { points, duration } = RateLimiter.parseRate(rate);

const opts = {

points,

duration, // Per second

};

this.rateLimiter = new RateLimiterMemory(opts);

}

async consume(key: string) {

try {

await this.rateLimiter.consume(key);

return true;

} catch (rejRes) {

return false;

}

}

private locks: Map<string, { locked: boolean; queue: Function[] }>;

constructor() {

this.locks = new Map();

}

_getLock(key) {

if (!this.locks.has(key)) {

this.locks.set(key, { locked: false, queue: [] });

}

return this.locks.get(key);

}

async run(key, fn) {

const lock = this._getLock(key);

while (lock.locked) {

await new Promise(resolve => lock.queue.push(resolve));

}

lock.locked = true;

try {

return await fn();

} finally {

lock.locked = false;

if (lock.queue.length > 0) {

const next = lock.queue.shift();

next();

}

}

}

if (column.type?.toLowerCase() === 'uuid') return true;

if (typeof column.sampleValue === 'string') {

return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(column.sampleValue);

}

return false;

return str

.toString()

.toLowerCase()

.replace(/\s+/g, '-')

.replace(/[^a-z0-9-_]/g, '-');

const { adminUser, response } = context;

const childResources = adminforth.config.resources.filter(r =>r.columns.some(c => c.foreignResource?.resourceId === resource.resourceId));

for (const childRes of childResources) {

const foreignColumn = childRes.columns.find(c => c.foreignResource?.resourceId === resource.resourceId);

if (!foreignColumn?.foreignResource?.onDelete) continue;

const strategy = foreignColumn.foreignResource.onDelete;

const childRecords = await adminforth.resource(childRes.resourceId).list(Filters.EQ(foreignColumn.name, primaryKey));

const childPk = childRes.columns.find(c => c.primaryKey)?.name;

if (strategy === 'cascade') {

for (const childRecord of childRecords) {

const childResult = await cascadeChildrenDelete(childRes, childRecord[childPk], context, adminforth);

if (childResult?.error) {

return childResult;

}

const deleteChild = await adminforth.deleteResourceRecord({resource: childRes, record: childRecord, adminUser, recordId: childRecord[childPk], response});

if (deleteChild.error) return { error: deleteChild.error };

if (childResult?.error) {

return childResult;

}

}

}

if (strategy === 'setNull') {

for (const childRecord of childRecords) {

await adminforth.resource(childRes.resourceId).update(childRecord[childPk], {[foreignColumn.name]: null});

}

}

}

return { error: null };

if (!hookResponse || typeof hookResponse.ok !== 'boolean') {

throw new Error(`Hook beforeSave must return { ok: boolean, error?: string | null }`);

}

if (hookResponse.ok === false && !hookResponse.error) {

return { error: hookResponse.error ?? 'Operation aborted by hook' };

}

if (hookResponse.error) {

return { error: hookResponse.error };

}

return null;

for (const column of resource.columns) {

if (column.name === fieldName) {

return true;

}

}

return false;

if (validation?.length) {

const validationArray = validation;

for (let i = 0; i < validationArray.length; i++) {

if (validationArray[i].regExp) {

let flags = '';

if (validationArray[i].caseSensitive) {

flags += 'i';

}

if (validationArray[i].multiline) {

flags += 'm';

}

if (validationArray[i].global) {

flags += 'g';

}

const regExp = new RegExp(validationArray[i].regExp, flags);

if (value === undefined || value === null) {

value = '';

}

let valueS = `${value}`;

if (!regExp.test(valueS)) {

return validationArray[i].message;

}

}

}

}

const RED = '\x1b[31m';

const BG = '\x1b[41m';

const WHITE = '\x1b[97m';

const BOLD = '\x1b[1m';

const RESET = '\x1b[0m';

const horizontal = '═'.repeat(100);

return `

}