/omnistudio-callable-apex-generate

name: omnistudio-callable-apex-generate
description: "Salesforce Industries Common Core (OmniStudio/Vlocity) Apex callable generation and review skill with 120-point scoring. Use when creating, reviewing, or migrating Industries callable Apex implementations. TRIGGER when: user creates or reviews System.Callable classes, migrates VlocityOpenInterface or VlocityOpenInterface2, or builds Industries callable extensions used by OmniStudio, Integration Procedures, or DataRaptors. DO NOT TRIGGER when: generic Apex classes or triggers (use platform-apex-generate), building Integration Procedures (use omnistudio-integration-procedure-generate), authoring OmniScripts (use omnistudio-omniscript-generate), configuring Data Mappers (use omnistudio-datamapper-generate), or analyzing namespace/dependency issues (use omnistudio-dependencies-analyze)."
metadata:
  relatedSkills:
    - "external-diagram-mermaid-generate"
    - "omnistudio-datamapper-generate"
    - "omnistudio-dependencies-analyze"
    - "omnistudio-integration-procedure-generate"
    - "omnistudio-omniscript-generate"
    - "platform-apex-generate"
    - "platform-apex-test-run"
    - "platform-custom-field-generate"
    - "platform-custom-object-generate"
    - "platform-data-manage"
    - "platform-metadata-deploy"
    - "platform-soql-query"
  version: "1.0"
  domains: ["OmniStudio"]
  minApiVersion: "60.0"

omnistudio-callable-apex-generate: Callable Apex for Salesforce Industries Common Core

Specialist for Salesforce Industries Common Core callable Apex implementations. Produce secure, deterministic, and configurable Apex that cleanly integrates with OmniStudio and Industries extension points.

Scope

• **In scope**: Creating `System.Callable` classes for Industries extension points; reviewing callable implementations for correctness and risks; migrating `VlocityOpenInterface` / `VlocityOpenInterface2` to `System.Callable`; 120-point scoring and validation
• **Out of scope**: Generic Apex classes without callable interface (use `platform-apex-generate`); building Integration Procedures (use `omnistudio-integration-procedure-generate`); authoring OmniScripts (use `omnistudio-omniscript-generate`); deploying Apex classes (use `platform-metadata-deploy`)

---

Core Responsibilities

1. **Callable Generation**: Build `System.Callable` classes with safe action dispatch 2. **Callable Review**: Audit existing callable implementations for correctness and risks 3. **Validation & Scoring**: Evaluate against the 120-point rubric 4. **Industries Fit**: Ensure compatibility with OmniStudio/Industries extension points

---

Workflow (4-Phase Pattern)

Phase 1: Requirements Gathering

Ask for:

• Entry point (OmniScript, Integration Procedure, DataRaptor, or other Industries hook)
• Action names (strings passed into `call`)
• Input/output contract (required keys, types, and response shape)
• Data access needs (objects/fields, CRUD/FLS (Create/Read/Update/Delete and Field-Level Security) rules)
• Side effects (DML, callouts, async requirements)

Then: 1. Scan for existing callable classes: `Glob: **/*Callable*.cls` 2. Identify shared utilities or base classes used for Industries extensions 3. Create a task list

---

Phase 2: Design & Contract Definition

**Define the callable contract**:

• Action list (explicit, versioned strings)
• Input schema (required keys + types)
• Output schema (consistent response envelope)

**Recommended response envelope**:

{
  "success": true|false,
  "data": {...},
  "errors": [ { "code": "...", "message": "..." } ]
}

**Action dispatch rules**:

• Use `switch on action`
• Default case throws a typed exception
• No dynamic method invocation or reflection

**VlocityOpenInterface / VlocityOpenInterface2 contract mapping**:

When designing for legacy Open Interface extensions (or dual Callable + Open Interface support), map the signature:

invokeMethod(String methodName, Map<String, Object> inputMap, Map<String, Object> outputMap, Map<String, Object> options)

| Parameter | Role | Callable equivalent | |-----------|------|---------------------| | `methodName` | Action selector (same semantics as `action`) | `action` in `call(action, args)` | | `inputMap` | Primary input data (required keys, types) | `args.get('inputMap')` | | `outputMap` | Mutable map where results are written (out-by-reference) | Return value; Callable returns envelope instead | | `options` | Additional context (parent DataRaptor/OmniScript context, invocation metadata) | `args.get('options')` |

Design rules for Open Interface contracts:

• Treat `inputMap` and `options` as the combined input schema
• Define what keys must be written to `outputMap` per action (success and error cases)
• Preserve `methodName` strings so they align with Callable `action` strings
• Document whether `options` is required, optional, or unused for each action

---

Phase 3: Implementation Pattern

**Vanilla System.Callable** (flat args, no Open Interface coupling):

**Read `assets/pattern_callable_vanilla.cls`** before generating — use when callers pass flat args and no VlocityOpenInterface integration is required.

**Callable skeleton** (same inputs as VlocityOpenInterface):

**Read `assets/pattern_callable_openinterface.cls`** before generating — use `inputMap` and `options` keys in `args` when integrating with Open Interface or when callers pass that structure.

**Input format**: Callers pass `args` as `{ 'inputMap' => Map<String, Object>, 'options' => Map<String, Object> }`. For backward compatibility with flat callers, if `args` lacks `'inputMap'`, treat `args` itself as `inputMap` and use an empty map for `options`.

**Implementation rules**: 1. Keep `call()` thin; delegate to private methods or service classes 2. Validate and coerce input types early (null-safe) 3. Enforce CRUD/FLS (Create/Read/Update/Delete and Field-Level Security) and sharing (`with sharing`, `Security.stripInaccessible()`) 4. Bulkify when args i