Skip to content

kugamon/salesforce-core-skills / plugins/salesforce-core/skills/sf-metadata

sf-metadata

Verified

Salesforce metadata operations expert. Use when creating custom objects, fields, validation rules, record types, permission sets, or querying org metadata structures via a Salesforce MCP server. Do NOT use for comparing metadata across two orgs (use sf-orgdiff), Named or External Credentials and Platform Events (use sf-integration), or querying and loading records (use sf- data). Usage: /sf-metadata [create|update|delete|describe] {ObjectName|FieldName|type} ...

FileKindSize
CREDITS.mdmarkdown2.3 KB
LICENSEother1.1 KB
README.mdmarkdown3.5 KB
SKILL.mdskill md33.8 KB
assets/fields/checkbox-field.xmlconfig971 B
assets/fields/currency-field.xmlconfig1.3 KB
assets/fields/date-field.xmlconfig1.0 KB
assets/fields/email-field.xmlconfig1.1 KB
assets/fields/formula-field.xmlconfig2.3 KB
assets/fields/lookup-field.xmlconfig2.1 KB
assets/fields/master-detail-field.xmlconfig1.8 KB
assets/fields/multi-select-picklist.xmlconfig2.0 KB
assets/fields/number-field.xmlconfig1.4 KB
assets/fields/phone-field.xmlconfig1.0 KB
assets/fields/picklist-field.xmlconfig2.1 KB
assets/fields/rollup-summary-field.xmlconfig2.7 KB
assets/fields/text-field.xmlconfig1.2 KB
assets/fields/textarea-field.xmlconfig1.1 KB
assets/fields/url-field.xmlconfig940 B
assets/layouts/page-layout.xmlconfig6.5 KB
assets/objects/custom-object.xmlconfig2.4 KB
assets/permission-sets/permission-set.xmlconfig5.7 KB
assets/profiles/profile.xmlconfig5.2 KB
assets/record-types/record-type.xmlconfig3.7 KB
assets/validation-rules/validation-rule.xmlconfig5.1 KB
references/best-practices-scoring.mdmarkdown3.6 KB
references/customfield-metadata-schema.jsonconfig16.1 KB
references/customobject-metadata-schema.jsonconfig49.9 KB
references/execution-modes.mdmarkdown7.0 KB
references/field-types-guide.mdmarkdown8.8 KB
references/flexipage-metadata-schema.jsonconfig11.6 KB
references/fls-best-practices.mdmarkdown7.8 KB
references/layout-metadata-schema.jsonconfig17.8 KB
references/mcp-pagination.mdmarkdown3.1 KB
references/metadata-types-reference.mdmarkdown8.5 KB
references/naming-conventions.mdmarkdown5.6 KB
references/permset-auto-generation.mdmarkdown2.8 KB
references/quickaction-metadata-schema.jsonconfig6.9 KB
references/recordtype-metadata-schema.jsonconfig2.9 KB
references/validationrule-metadata-schema.jsonconfig1.2 KB
scripts/mcp_validator.pyscript4.5 KB
scripts/pre-mcp-validate.pyscript4.3 KB
scripts/validate_metadata_operation.pyscript13.9 KB

references/fls-best-practices.md

View on GitHub
<!-- Parent: sf-metadata/SKILL.md -->

# Field-Level Security (FLS) Best Practices

## Overview

Field-Level Security (FLS) controls which users can view and edit specific fields on records. Proper FLS configuration is essential for data security and compliance.

---

## Understanding FLS

### Two Levels of Field Access

1. **Readable**: User can see the field value
2. **Editable**: User can modify the field value (implies readable)

### FLS vs Object Permissions

```
User Access = Object Permissions + Field-Level Security + Record Access

Object Permissions: Can user access the object at all?
FLS: Can user see/edit specific fields?
Record Access: Can user access specific records?
```

### Where FLS is Configured

- Profiles (base access)
- Permission Sets (additive access)
- Permission Set Groups (combined sets)

---

## Best Practices

### 1. Use Permission Sets Over Profiles

**Why:**

- Profiles are monolithic and hard to maintain
- Permission Sets are additive and composable
- Easier to manage feature-based access

**Pattern:**

```
Profile: Base access (read-only on most fields)
Permission Set: Feature-specific edit access
```

**Example:**

```xml
<!-- Permission Set for Invoice Editors -->
<PermissionSet>
    <label>Invoice Editor</label>
    <fieldPermissions>
        <editable>true</editable>
        <field>Invoice__c.Amount__c</field>
        <readable>true</readable>
    </fieldPermissions>
    <fieldPermissions>
        <editable>true</editable>
        <field>Invoice__c.Status__c</field>
        <readable>true</readable>
    </fieldPermissions>
</PermissionSet>
```

---

### 2. Principle of Least Privilege

**Rule:** Grant minimum access needed for the job function

**Steps:**

1. Start with no access
2. Add read access where needed
3. Add edit access only where required
4. Review periodically

**Anti-Pattern:**

```xml
<!-- DON'T: Grant edit on everything -->
<fieldPermissions>
    <editable>true</editable>
    <field>Account.AnnualRevenue</field>
    <readable>true</readable>
</fieldPermissions>
```

**Better:**

```xml
<!-- DO: Grant read-only unless edit is required -->
<fieldPermissions>
    <editable>false</editable>
    <field>Account.AnnualRevenue</field>
    <readable>true</readable>
</fieldPermissions>
```

---

### 3. Protect Sensitive Fields

#### Identify Sensitive Fields

| Category  | Examples                             |
| --------- | ------------------------------------ |
| PII       | SSN, Date of Birth, Driver's License |
| Financial | Bank Account, Credit Card, Salary    |
| Health    | Medical conditions, Insurance        |
| Security  | Password, Token, API Key             |
| Business  | Trade secrets, Pricing formulas      |

#### Protection Strategies

1. **Restrict to Specific Permission Sets**

```xml
<PermissionSet>
    <label>PII_Access</label>
    <description>Access to sensitive PII fields</description>
    <fieldPermissions>
        <editable>false</editable>
        <field>Contact.SSN__c</field>
        <readable>true</readable>
    </fieldPermissions>
</PermissionSet>
```

2. **Use Shield Platform Encryption**

- Encrypts data at rest
- Searchable with deterministic encryption
- Requires Shield license

3. **Use Classic Encryption (Encrypted Text Field)**

- Masks display (shows last 4 characters)
- Limited functionality
- No additional license needed

---

### 4. FLS in Apex Code

#### Always Check FLS in Apex

**With SOQL:**

```apex
// Good: Respects FLS
List<Account> accounts = [
    SELECT Name, Industry
    FROM Account
    WITH USER_MODE
];

// Alternative: Security.stripInaccessible
List<Account> accounts = [SELECT Name, Industry, Revenue FROM Account];
SObjectAccessDecision decision = Security.stripInaccessible(
    AccessType.READABLE,
    accounts
);
List<Account> safeAccounts = decision.getRecords();
```

**With DML:**

```apex
// Good: Respects FLS
Database.insert(accounts, AccessLevel.USER_MODE);

// Alternative: Check before DML
if (Schema.sObjectType.Account.fields.Industry.isUpdateable()) {
    account.Industry = 'Technology';
}
```

---

### 5. Organize Permission Sets by Function

**Pattern:**

```
[Object]_[AccessLevel]
[Feature]_[Role]
[Integration]_Access
```

**Example Structure:**

```
Permission Sets/
├── Account_Read_Only.permissionset-meta.xml
├── Account_Full_Access.permissionset-meta.xml
├── Invoice_Approver.permissionset-meta.xml
├── Invoice_Creator.permissionset-meta.xml
├── ERP_Integration_Access.permissionset-meta.xml
└── Reports_Power_User.permissionset-meta.xml
```

---

### 6. Use Permission Set Groups

**Why:**

- Combine related permission sets
- Easier role-based assignment
- Single assignment per user role

**Example:**

```
Permission Set Group: Sales_Representative
├── Account_Full_Access
├── Contact_Full_Access
├── Opportunity_Full_Access
├── Quote_Creator
└── Reports_Basic
```

---

### 7. Handle Formula Fields Correctly

**Important:** Formula fields inherit FLS from referenced fields

```
Formula: Account.Owner.Manager.Name

User needs READ access to:
- Account.OwnerId
- User.ManagerId
- User.Name (on Manager)
```

**Best Practice:** Test formulas with different user profiles

---

### 8. Document FLS Decisions

**For each sensitive field, document:**

- Why it exists
- Who should have access
- Which permission sets grant access
- Review date

**Example:**

```xml
<CustomField>
    <fullName>SSN__c</fullName>
    <description>
        Social Security Number - SENSITIVE
        Access: HR_PII_Access permission set only
        Review: Quarterly by Security team
    </description>
</CustomField>
```

---

## Common Mistakes

### 1. Relying on Page Layout for Security

```
❌ "Users can't see it because it's not on the layout"
✅ FLS controls true visibility; layouts are UX only
```

### 2. Granting Edit Without Business Need

```
❌ "Give them edit just in case they need it"
✅ Start read-only, add edit when requested
```

### 3. Not Checking FLS in Apex

```
❌ Assuming controller/trigger runs as system
✅ Always use WITH USER_MODE or Security.stripInaccessible
```

### 4. Over-Using System Administrator

```
❌ "Just use System Admin profile"
✅ Create specific permission sets for each function
```

### 5. Not Testing FLS Changes

```
❌ Deploy FLS changes without testing
✅ Test with actual user profiles before deploy
```

---

## FLS Audit Checklist

### For Each Object

- [ ] All fields reviewed for sensitivity
- [ ] Sensitive fields have restricted access
- [ ] Permission Sets exist for each access pattern
- [ ] No unnecessary edit permissions
- [ ] Formula fields tested with limited users
- [ ] Integration users have minimal required access

### For Apex Code

- [ ] All SOQL uses WITH USER_MODE or stripInaccessible
- [ ] All DML uses USER_MODE or checks isUpdateable()
- [ ] Tests verify FLS enforcement
- [ ] No hardcoded field access bypass

### For Deployment

- [ ] FLS changes reviewed by security team
- [ ] Changes tested with representative users
- [ ] Rollback plan exists
- [ ] Documentation updated

---

## Quick Reference

### SOQL FLS Modes

| Mode               | Behavior                     |
| ------------------ | ---------------------------- |
| `WITH USER_MODE`   | Enforces FLS and sharing     |
| `WITH SYSTEM_MODE` | Bypasses FLS (use carefully) |
| Default (no mode)  | Depends on context           |

### Schema Methods

| Method           | Purpose                 |
| ---------------- | ----------------------- |
| `isAccessible()` | Can user read field?    |
| `isUpdateable()` | Can user edit field?    |
| `isCreateable()` | Can user set on create? |

### Security.stripInaccessible

| AccessType   | Strips Fields Not...   |
| ------------ | ---------------------- |
| `READABLE`   | Readable by user       |
| `CREATABLE`  | Creatable by user      |
| `UPDATABLE`  | Updatable by user      |
| `UPSERTABLE` | Creatable or updatable |
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall