@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
135 lines • 13.1 kB
JavaScript
/**
* Deep merge utility for objects
*
* Provides a pure, reusable deep merge function with optional security filtering.
*
* @module utils/deepMerge
*/
/**
* Check if a value is a plain object (not null, not array)
*/
function isPlainObject(value) {
return value !== null && typeof value === 'object' && !Array.isArray(value);
}
/**
* Validate DeepMergeOptions at runtime
*
* @param options - Options to validate
* @throws Error if options are malformed
*/
function validateOptions(options) {
if (options.skipProperties !== undefined) {
if (!Array.isArray(options.skipProperties)) {
throw new TypeError('DeepMergeOptions.skipProperties must be an array of strings');
}
for (const prop of options.skipProperties) {
if (typeof prop !== 'string') {
throw new TypeError(`DeepMergeOptions.skipProperties contains non-string value: ${typeof prop}`);
}
}
}
if (options.readOnlyFields !== undefined) {
if (!(options.readOnlyFields instanceof Set)) {
throw new TypeError('DeepMergeOptions.readOnlyFields must be a Set<string>');
}
}
}
/**
* Deep merge two objects
*
* Merge semantics:
* - Plain objects are merged recursively
* - Arrays replace entirely (not merged element-by-element)
* - Primitives replace
* - Dangerous/read-only properties are optionally skipped
*
* @param target - The target object to merge into
* @param source - The source object to merge from
* @param options - Optional merge behavior configuration
* @returns New merged object (does not mutate inputs)
*
* @example
* ```typescript
* // Basic merge
* const result = deepMerge({ a: 1 }, { b: 2 });
* // => { a: 1, b: 2 }
*
* // Nested merge
* const result = deepMerge(
* { settings: { theme: 'light', size: 10 } },
* { settings: { theme: 'dark' } }
* );
* // => { settings: { theme: 'dark', size: 10 } }
*
* // With security filtering
* const result = deepMerge(target, source, {
* skipProperties: ['__proto__', 'constructor'],
* readOnlyFields: new Set(['id', 'type'])
* });
*
* // With type preservation
* interface Config { theme: string; size: number; }
* const result = deepMerge<Config>(defaultConfig, userConfig);
* ```
*/
export function deepMerge(target, source, options) {
// Validate options at runtime if provided
if (options) {
validateOptions(options);
}
const result = { ...target };
const skipProperties = options?.skipProperties ?? [];
const readOnlyFields = options?.readOnlyFields;
for (const key of Object.keys(source)) {
// Skip dangerous properties
if (skipProperties.includes(key)) {
continue;
}
// Skip read-only fields
if (readOnlyFields?.has(key)) {
continue;
}
const sourceValue = source[key];
const targetValue = result[key];
// If both are plain objects, merge recursively
if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
result[key] = deepMerge(targetValue, sourceValue, options);
}
else {
// Arrays and primitives replace entirely
result[key] = sourceValue;
}
}
return result;
}
/**
* Default dangerous properties that should never be merged
* These can be used to prevent prototype pollution attacks
*/
export const DANGEROUS_PROPERTIES = [
'__proto__',
'constructor',
'prototype',
];
/**
* Create a deep merge function with preset options
*
* Useful for creating a configured merger that can be reused
*
* @param options - Preset options for all merges
* @returns A configured deep merge function
*
* @example
* ```typescript
* const secureMerge = createDeepMerge({
* skipProperties: DANGEROUS_PROPERTIES,
* readOnlyFields: new Set(['id', 'type'])
* });
*
* const result = secureMerge(target, source);
* ```
*/
export function createDeepMerge(options) {
return (target, source) => deepMerge(target, source, options);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deepMerge.js","sourceRoot":"","sources":["../../src/utils/deepMerge.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH;;GAEG;AACH,SAAS,aAAa,CAAC,KAAc;IACnC,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;GAKG;AACH,SAAS,eAAe,CAAC,OAAyB;IAChD,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACzC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,SAAS,CAAC,6DAA6D,CAAC,CAAC;QACrF,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;YAC1C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC7B,MAAM,IAAI,SAAS,CAAC,8DAA8D,OAAO,IAAI,EAAE,CAAC,CAAC;YACnG,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACzC,IAAI,CAAC,CAAC,OAAO,CAAC,cAAc,YAAY,GAAG,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,SAAS,CAAC,uDAAuD,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,UAAU,SAAS,CACvB,MAAS,EACT,MAA4C,EAC5C,OAA0B;IAE1B,0CAA0C;IAC1C,IAAI,OAAO,EAAE,CAAC;QACZ,eAAe,CAAC,OAAO,CAAC,CAAC;IAC3B,CAAC;IAED,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,EAA6B,CAAC;IACxD,MAAM,cAAc,GAAG,OAAO,EAAE,cAAc,IAAI,EAAE,CAAC;IACrD,MAAM,cAAc,GAAG,OAAO,EAAE,cAAc,CAAC;IAE/C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,4BAA4B;QAC5B,IAAI,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACjC,SAAS;QACX,CAAC;QAED,wBAAwB;QACxB,IAAI,cAAc,EAAE,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7B,SAAS;QACX,CAAC;QAED,MAAM,WAAW,GAAI,MAAkC,CAAC,GAAG,CAAC,CAAC;QAC7D,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAEhC,+CAA+C;QAC/C,IAAI,aAAa,CAAC,WAAW,CAAC,IAAI,aAAa,CAAC,WAAW,CAAC,EAAE,CAAC;YAC7D,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;QAC7D,CAAC;aAAM,CAAC;YACN,yCAAyC;YACzC,MAAM,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,OAAO,MAAW,CAAC;AACrB,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,WAAW;IACX,aAAa;IACb,WAAW;CACZ,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,eAAe,CAAC,OAAyB;IACvD,OAAO,CAAC,MAA+B,EAAE,MAA+B,EAAE,EAAE,CAC1E,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AACvC,CAAC","sourcesContent":["/**\n * Deep merge utility for objects\n *\n * Provides a pure, reusable deep merge function with optional security filtering.\n *\n * @module utils/deepMerge\n */\n\n/**\n * Options for deep merge behavior\n */\nexport interface DeepMergeOptions {\n  /**\n   * Properties to skip during merge (e.g., dangerous properties like __proto__)\n   */\n  skipProperties?: string[];\n\n  /**\n   * Read-only fields that should be skipped during merge\n   */\n  readOnlyFields?: Set<string>;\n}\n\n/**\n * Check if a value is a plain object (not null, not array)\n */\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\n/**\n * Validate DeepMergeOptions at runtime\n *\n * @param options - Options to validate\n * @throws Error if options are malformed\n */\nfunction validateOptions(options: DeepMergeOptions): void {\n  if (options.skipProperties !== undefined) {\n    if (!Array.isArray(options.skipProperties)) {\n      throw new TypeError('DeepMergeOptions.skipProperties must be an array of strings');\n    }\n    for (const prop of options.skipProperties) {\n      if (typeof prop !== 'string') {\n        throw new TypeError(`DeepMergeOptions.skipProperties contains non-string value: ${typeof prop}`);\n      }\n    }\n  }\n\n  if (options.readOnlyFields !== undefined) {\n    if (!(options.readOnlyFields instanceof Set)) {\n      throw new TypeError('DeepMergeOptions.readOnlyFields must be a Set<string>');\n    }\n  }\n}\n\n/**\n * Deep merge two objects\n *\n * Merge semantics:\n * - Plain objects are merged recursively\n * - Arrays replace entirely (not merged element-by-element)\n * - Primitives replace\n * - Dangerous/read-only properties are optionally skipped\n *\n * @param target - The target object to merge into\n * @param source - The source object to merge from\n * @param options - Optional merge behavior configuration\n * @returns New merged object (does not mutate inputs)\n *\n * @example\n * ```typescript\n * // Basic merge\n * const result = deepMerge({ a: 1 }, { b: 2 });\n * // => { a: 1, b: 2 }\n *\n * // Nested merge\n * const result = deepMerge(\n *   { settings: { theme: 'light', size: 10 } },\n *   { settings: { theme: 'dark' } }\n * );\n * // => { settings: { theme: 'dark', size: 10 } }\n *\n * // With security filtering\n * const result = deepMerge(target, source, {\n *   skipProperties: ['__proto__', 'constructor'],\n *   readOnlyFields: new Set(['id', 'type'])\n * });\n *\n * // With type preservation\n * interface Config { theme: string; size: number; }\n * const result = deepMerge<Config>(defaultConfig, userConfig);\n * ```\n */\nexport function deepMerge<T extends object = Record<string, unknown>>(\n  target: T,\n  source: Partial<T> | Record<string, unknown>,\n  options?: DeepMergeOptions\n): T {\n  // Validate options at runtime if provided\n  if (options) {\n    validateOptions(options);\n  }\n\n  const result = { ...target } as Record<string, unknown>;\n  const skipProperties = options?.skipProperties ?? [];\n  const readOnlyFields = options?.readOnlyFields;\n\n  for (const key of Object.keys(source)) {\n    // Skip dangerous properties\n    if (skipProperties.includes(key)) {\n      continue;\n    }\n\n    // Skip read-only fields\n    if (readOnlyFields?.has(key)) {\n      continue;\n    }\n\n    const sourceValue = (source as Record<string, unknown>)[key];\n    const targetValue = result[key];\n\n    // If both are plain objects, merge recursively\n    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {\n      result[key] = deepMerge(targetValue, sourceValue, options);\n    } else {\n      // Arrays and primitives replace entirely\n      result[key] = sourceValue;\n    }\n  }\n\n  return result as T;\n}\n\n/**\n * Default dangerous properties that should never be merged\n * These can be used to prevent prototype pollution attacks\n */\nexport const DANGEROUS_PROPERTIES = [\n  '__proto__',\n  'constructor',\n  'prototype',\n];\n\n/**\n * Create a deep merge function with preset options\n *\n * Useful for creating a configured merger that can be reused\n *\n * @param options - Preset options for all merges\n * @returns A configured deep merge function\n *\n * @example\n * ```typescript\n * const secureMerge = createDeepMerge({\n *   skipProperties: DANGEROUS_PROPERTIES,\n *   readOnlyFields: new Set(['id', 'type'])\n * });\n *\n * const result = secureMerge(target, source);\n * ```\n */\nexport function createDeepMerge(options: DeepMergeOptions) {\n  return (target: Record<string, unknown>, source: Record<string, unknown>) =>\n    deepMerge(target, source, options);\n}\n"]}