سلسلة معالج وكيل JavaScript: إتقان اعتراض الكائنات متعدد المستويات

            
const userConfig = {
  id: 123,
  profile: {
    name: 'Alice',
    address: {
      street: '123 Main St',
      city: 'Anytown',
      zip: '12345'
    }
  },
  settings: {
    theme: 'dark',
    notifications: {
      email: true,
      sms: false
    }
  }
};

            

              
                Copy
              
            
          

            
function createLoggingProxy(obj, path = []) {
  return new Proxy(obj, {
    get(target, property, receiver) {
      const currentPath = [...path, property].join('.');
      console.log(`Accessing: ${currentPath}`);

      const value = Reflect.get(target, property, receiver);

      // If the value is an object and not null, and not a function (to avoid proxying functions themselves unless intended)
      if (typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value !== 'function') {
        return createLoggingProxy(value, [...path, property]);
      }

      return value;
    },

    set(target, property, value, receiver) {
      const currentPath = [...path, property].join('.');
      console.log(`Setting: ${currentPath} to ${value}`);
      return Reflect.set(target, property, value, receiver);
    }
  });
}

const userConfig = {
  id: 123,
  profile: {
    name: 'Alice',
    address: {
      street: '123 Main St',
      city: 'Anytown',
      zip: '12345'
    }
  }
};

const proxiedUserConfig = createLoggingProxy(userConfig);

console.log(proxiedUserConfig.profile.name);
// Output:
// Accessing: profile
// Accessing: profile.name
// Alice

proxiedUserConfig.profile.address.city = 'Metropolis';
// Output:
// Accessing: profile
// Setting: profile.address.city to Metropolis

            

              
                Copy
              
            
          

            
function createValidatingProxy(obj, path = [], validationRules = {}) {
  return new Proxy(obj, {
    get(target, property, receiver) {
      const value = Reflect.get(target, property, receiver);
      if (typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value !== 'function') {
        return createValidatingProxy(value, [...path, property], validationRules);
      }
      return value;
    },

    set(target, property, value, receiver) {
      const currentPath = [...path, property].join('.');
      const rules = validationRules[currentPath];

      if (rules) {
        if (rules.required && (value === null || value === undefined || value === '')) {
          throw new Error(`Validation Error: ${currentPath} is required.`);
        }
        if (rules.type && typeof value !== rules.type) {
          throw new Error(`Validation Error: ${currentPath} must be of type ${rules.type}.`);
        }
        if (rules.minLength && typeof value === 'string' && value.length < rules.minLength) {
          throw new Error(`Validation Error: ${currentPath} must be at least ${rules.minLength} characters long.`);
        }
        // Add more validation rules as needed
      }

      return Reflect.set(target, property, value, receiver);
    }
  });
}

const userProfileSchema = {
  name: { required: true, type: 'string', minLength: 2 },
  age: { type: 'number', min: 18 },
  contact: {
    email: { required: true, type: 'string' },
    phone: { type: 'string' }
  }
};

const userProfile = {
  name: '',
  age: 25,
  contact: {
    email: '',
    phone: '123-456-7890'
  }
};

const proxiedUserProfile = createValidatingProxy(userProfile, [], userProfileSchema);

try {
  proxiedUserProfile.name = 'Bo'; // Valid
  proxiedUserProfile.contact.email = 'bo@example.com'; // Valid
  console.log('Initial profile setup successful.');
} catch (error) {
  console.error(error.message);
}

try {
  proxiedUserProfile.name = 'B'; // Invalid - minLength
} catch (error {
  console.error(error.message);
}

try {
  proxiedUserProfile.contact.email = ''; // Invalid - required
} catch (error) {
  console.error(error.message);
}

try {
  proxiedUserProfile.age = 'twenty'; // Invalid - type
} catch (error) {
  console.error(error.message);
}

            

              
                Copy
              
            
          

            
function createAccessControlledProxy(obj, accessConfig, path = []) {
  // Default access: allow everything if not specified
  const defaultAccess = { read: true, write: true };

  return new Proxy(obj, {
    get(target, property, receiver) {
      const currentPath = [...path, property].join('.');
      const config = accessConfig[currentPath] || defaultAccess;

      if (!config.read) {
        throw new Error(`Access Denied: Cannot read property '${currentPath}'.`);
      }

      const value = Reflect.get(target, property, receiver);
      if (typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value !== 'function') {
        // Pass down the access config for nested properties
        return createAccessControlledProxy(value, accessConfig, [...path, property]);
      }
      return value;
    },

    set(target, property, value, receiver) {
      const currentPath = [...path, property].join('.');
      const config = accessConfig[currentPath] || defaultAccess;

      if (!config.write) {
        throw new Error(`Access Denied: Cannot write to property '${currentPath}'.`);
      }

      return Reflect.set(target, property, value, receiver);
    }
  });
}

const sensitiveData = {
  id: 'user-123',
  personal: {
    name: 'Alice',
    ssn: '123-456-7890'
  },
  preferences: {
    theme: 'dark',
    language: 'en-US'
  }
};

// Define access rules: Admin can read/write everything. User can only read preferences.
const accessRules = {
  'personal.ssn': { read: false, write: false }, // Only admins can see SSN
  'preferences': { read: true, write: true }    // Users can manage preferences
};

// Simulate a user with limited access
const userAccessConfig = {
  'personal.name': { read: true, write: true },
  'personal.ssn': { read: false, write: false },
  'preferences.theme': { read: true, write: true },
  'preferences.language': { read: true, write: true }
  // ... other preferences are implicitly readable/writable by defaultAccess
};

const proxiedSensitiveData = createAccessControlledProxy(sensitiveData, userAccessConfig);

console.log(proxiedSensitiveData.id); // Accessing 'id' - falls back to defaultAccess
console.log(proxiedSensitiveData.personal.name); // Accessing 'personal.name' - allowed

try {
  console.log(proxiedSensitiveData.personal.ssn); // Attempt to read SSN
} catch (error) {
  console.error(error.message);
  // Output: Access Denied: Cannot read property 'personal.ssn'.
}

try {
  proxiedSensitiveData.preferences.theme = 'light'; // Modifying preferences - allowed
  console.log(`Theme changed to: ${proxiedSensitiveData.preferences.theme}`);
} catch (error) {
  console.error(error.message);
}

try {
  proxiedSensitiveData.personal.name = 'Alicia'; // Modifying name - allowed
  console.log(`Name changed to: ${proxiedSensitiveData.personal.name}`);
} catch (error) {
  console.error(error.message);
}

try {
  proxiedSensitiveData.personal.ssn = '987-654-3210'; // Attempt to write SSN
} catch (error) {
  console.error(error.message);
  // Output: Access Denied: Cannot write to property 'personal.ssn'.
}

            

              
                Copy
              
            
          

            
function createReactiveStore(initialState) {
  const listeners = new Map(); // Map of property paths to arrays of callback functions

  function subscribe(path, callback) {
    if (!listeners.has(path)) {
      listeners.set(path, []);
    }
    listeners.get(path).push(callback);
  }

  function notify(path, newValue) {
    if (listeners.has(path)) {
      listeners.get(path).forEach(callback => callback(newValue));
    }
  }

  function createProxy(obj, currentPath = '') {
    return new Proxy(obj, {
      get(target, property, receiver) {
        const value = Reflect.get(target, property, receiver);
        const fullPath = currentPath ? `${currentPath}.${String(property)}` : String(property);

        if (typeof value === 'object' && value !== null && !Array.isArray(value) && typeof value !== 'function') {
          // Recursively create proxy for nested objects
          return createProxy(value, fullPath);
        }
        return value;
      },

      set(target, property, value, receiver) {
        const oldValue = target[property];
        const result = Reflect.set(target, property, value, receiver);
        const fullPath = currentPath ? `${currentPath}.${String(property)}` : String(property);

        // Notify listeners if the value has changed
        if (oldValue !== value) {
          notify(fullPath, value);
          // Also notify for parent paths if the change is significant, e.g., an object modification
          if (currentPath) {
            notify(currentPath, receiver); // Notify parent path with the whole updated object
          }
        }

        return result;
      }
    });
  }

  const proxyStore = createProxy(initialState);
  return { store: proxyStore, subscribe, notify };
}

const appState = {
  user: {
    name: 'Guest',
    isLoggedIn: false
  },
  settings: {
    theme: 'light',
    language: 'en'
  }
};

const { store, subscribe } = createReactiveStore(appState);

// Subscribe to changes
subscribe('user.name', (newName) => {
  console.log(`User name changed to: ${newName}`);
});

subscribe('settings.theme', (newTheme) => {
  console.log(`Theme changed to: ${newTheme}`);
});

subscribe('user', (updatedUser) => {
  console.log('User object updated:', updatedUser);
});

// Simulate state updates
store.user.name = 'Bob';
// Output:
// User name changed to: Bob

store.settings.theme = 'dark';
// Output:
// Theme changed to: dark

store.user.isLoggedIn = true;
// Output:
// User object updated: { name: 'Bob', isLoggedIn: true }

store.user = { ...store.user, name: 'Alice' }; // Reassigning a nested object property
// Output:
// User name changed to: Alice
// User object updated: { name: 'Alice', isLoggedIn: true }

            

              
                Copy