SFCC Contracts

SFCC connects many features through strings and configuration files. Intellij SFCC indexes those relationships so completion can suggest valid names and navigation can take you from a caller or registration to the implementation

System and custom hooks

Hook intelligence starts with a recognized hooks.json registration and its script. Known system hooks are typed automatically: their parameters and return value get SFCC types without any JSDoc

storefront

Explorer

storefront

cartridges

app_custom

cartridge

scripts

hooks

calculate.js

loyalty.js

hooks.json

package.json

app_storefront_base

calculate.jshooks.jsonloyalty.js

app_customcartridgescriptshooksloyalty.js

1'use strict';

3var Status = require('dw/system/Status');

4var helpers = require('*/cartridge/scripts/helpers/basketCalculationHelpers');

dw.order.calculate

6exports.calculate = function (basket) {

7 helpers.calculateTotals(basket);

8 return new Status(Status.OK);

9};

1'use strict';

3var Transaction = require('dw/system/Transaction');

app.loyalty.points → earn

5exports.earn = function (order) {

6 return Math.floor(order.totalGrossPrice.value);

7};

app.loyalty.points → redeem

9exports.redeem = function (customer, points) {

10 Transaction.wrap(function () {

11 customer.profile.custom.loyaltyPoints -= points;

12 });

13};

2 "hooks": [

3 {

4 "name": "dw.order.calculate",

5 "script": "./cartridge/scripts/hooks/calculate.js"

6 },

7 {

8 "name": "app.loyalty.points",

9 "script": "./cartridge/scripts/hooks/loyalty.js"

10 }

11 ]

12}

mainLn 10, Col 1UTF-8SFCC JavaScript

A system hook's function shows the hook it implements, and every function of a custom hook shows hook → function. Click a lens to open its registration in hooks.json

cartridge/hooks.json

{
  "hooks": [
    {
      "name": "dw.order.calculate",
      "script": "./scripts/hooks/calculate"
    }
  ]
}

Keep your cartridge's normal hook-file registration in place so SFCC can load it at runtime. Local indexing does not deploy or enable a hook on the sandbox

cartridge/scripts/hooks/calculate.js

var Status = require('dw/system/Status');

exports.calculate = function (basket) {
    // Demonstrates typing only; real basket calculation belongs here.
    var currency = basket.currencyCode;
    return new Status(Status.OK);
};

For this known hook, basket is typed as dw.order.Basket and the function must return a dw.system.Status. Typed Hooks lists every typed hook

var HookMgr = require('dw/system/HookMgr');
var BasketMgr = require('dw/order/BasketMgr');
var basket = BasketMgr.getCurrentBasket();

if (basket && HookMgr.hasHook('dw.order.calculate')) {
    HookMgr.callHook('dw.order.calculate', 'calculate', basket);
}

The hook-name argument completes from indexed hooks; the function argument can complete from the selected hook. Use Go to Definition to inspect its implementation

For custom hooks, registered names and indexed exports remain navigable. Write JSDoc or TypeScript annotations for your own contract where the server has no known system signature; it cannot infer a domain model from the hook's name alone

Hook CodeLens provides the reverse path from the implementation to its registration

SFRA, SiteGenesis, and pipeline routes

Route intelligence recognizes SFRA controller declarations, SiteGenesis endpoints, and pipeline entry points. Completion details identify the kind of route and its cartridge context

storefront

accountLinks.js

app_customcartridgescriptshelpersaccountLinks.js

1var URLUtils = require('dw/web/URLUtils');

2var href = URLUtils.url('Account-S');

◈Account-SaveNewPassword

◈Account-SavePassword

◈Account-SaveProfile

◈Account-SetNewPassword

◈Account-Show

◈Account-StartRegister

◈Account-SubmitRegistration

Pipeline | SFRA Controller | Site Genesis Controller

main00Ln 2, Col 35UTF-8SFCC JavaScript

Inside URLUtils.url('') the indexed routes complete by name; the detail tells whether a route is backed by a pipeline, an SFRA controller or a SiteGenesis controller

var URLUtils = require('dw/web/URLUtils');
var productUrl = URLUtils.url('Product-Show', 'pid', 'demo-product');

Place the caret inside 'Product-Show' and invoke completion, or use Go to Definition on it. Find All References and the route's usage lens help locate indexed callers. For SFRA, append, prepend, and replace relationships are available through route CodeLens

Typed route callbacks

Route callbacks need no annotations. In server.get, post, use, append, prepend, and replace, the req, res, and next parameters are typed as sfra.Request, sfra.Response, and sfra.Next, so request members and response methods complete with their docs

storefront

Explorer

storefront

cartridges

app_custom

cartridge

controllers

Product.js

templates

package.json

app_storefront_base

Product.js

app_customcartridgecontrollersProduct.js

1'use strict';

3var server = require('server');

Open Endpoint | Copy Endpoint URL | 2 usages

5server.get('Show', function (req, res, next) {

6 var pid = req.querystring.pid;

8 res.render('product/productDetails', { pid: pid });

9 next();

10});

12module.exports = server.exports();

parameter

declare const req: sfra.Request;

▫body

▫currentCustomer

▫form

▫geolocation

▫host

▫httpHeaders

▫httpMethod

▫httpParameterMap

▫https

◇redirect

▫redirectStatus

▫redirectUrl

◇render

▫renderings

◇setRedirectStatus

main00Ln 5, Col 31UTF-8SFCC JavaScript

SFRA route callbacks need no annotations: req, res and next are typed, so request members and response methods complete with their documentation

In SiteGenesis controllers, exported route functions can expose a .public flag. The engine models that member and checks boolean-compatible assignments. This is separate from an SFRA server.get declaration or a public pipeline start node

Job step registrations

In steptypes.json, module fields complete to cartridge scripts, and function fields can complete to the module's exports. Definition navigation connects those configuration values to code

storefront

Explorer

storefront

cartridges

app_custom

cartridge

scripts

jobs

exportOrders.js

importProducts.js

package.json

steptypes.json

app_storefront_base

exportOrders.jssteptypes.jsonimportProducts.js

app_customcartridgescriptsjobsimportProducts.js

1'use strict';

3var Status = require('dw/system/Status');

custom.ExportOrders → function

5exports.execute = function (parameters, stepExecution) {

6 exportOrders(parameters.FolderPath);

7 return new Status(Status.OK);

8};

1'use strict';

custom.ImportProducts → readFunction

3exports.read = function () {

4 return products.hasNext() ? products.next() : null;

5};

custom.ImportProducts → processFunction

7exports.process = function (product) {

8 return mapProduct(product);

9};

custom.ImportProducts → writeFunction

11exports.write = function (chunk) {

12 chunk.toArray().forEach(saveProduct);

13};

2 "step-types": {

3 "script-module-step": [

4 {

5 "@type-id": "custom.ExportOrders",

6 "module": "app_custom/cartridge/scripts/jobs/exportOrders.js",

7 "function": "execute"

8 }

9 ],

10 "chunk-script-module-step": [

11 {

12 "@type-id": "custom.ImportProducts",

13 "module": "app_custom/cartridge/scripts/jobs/importProducts.js",

14 "read-function": "read",

15 "process-function": "process",

16 "write-function": "write",

17 "chunk-size": 100

18 }

19 ]

20 }

21}

mainLn 9, Col 1UTF-8SFCC JavaScript

Each job step function shows the step type and the steptypes.json property that calls it. Click the lens to open that property

The relationship includes task-oriented steps and chunk-oriented lifecycle functions. Step CodeLens connects a script export back to the registered step type and its role. Keep names consistent across the JSON and script; renaming a function manually does not automatically rewrite every registration

Custom APIs

Custom API support indexes api.json, the associated OpenAPI YAML, and implementation scripts. It connects endpoint identifiers, operation declarations, and exported handlers

storefront

Explorer

storefront

cartridges

app_custom

cartridge

controllers

rest-apis

loyalty

api.json

loyalty.js

schema.yaml

scripts

api.json

app_customcartridgerest-apisloyaltyapi.json

2 "endpoints": [

3 {

GET

4 "endpoint": "getPoints",

/points

5 "schema": "schema.yaml",

6 "implementation": "loyalty"

7 }

8 ]

1'use strict';

3var RESTResponseMgr = require('dw/system/RESTResponseMgr');

schema.yaml | api.json

5exports.getPoints = function () {

6 var points = customer.profile.custom.loyaltyPoints || 0;

7 RESTResponseMgr.createSuccess({ points: points }).render();

8};

10exports.getPoints.public = true;

1openapi: 3.0.0

2info:

3 title: Loyalty Points

4 version: 1.0.0

5paths:

6 /points:

loyalty.js | api.json

7 get:

8 operationId: getPoints

9 summary: Points balance of the current shopper

10 responses:

11 '200':

12 description: OK

mainLn 4, Col 13UTF-8JSON

api.json shows the method and the path of each endpoint, while the script and the schema link to the other two files. Each lens opens its target at the matching operation

Where you work	Use the connection to…
`api.json`	Complete relevant endpoint wiring and navigate to the indexed implementation or schema
OpenAPI operation	Inspect the operation's implementation and registration through CodeLens
Exported handler	Return to the schema or registration to understand the HTTP contract

These features describe indexed endpoint relationships. They do not establish that an API is registered or authorized on the active sandbox. See B2C Entry Points for the view that lists them

Templates and localized resources

storefront

checkout.properties

app_customcartridgetemplatesresourcescheckout.properties

1# Checkout

2 usages | 3 localizations

2button.place.order=Place your order

2 usages | 4 localizations

3heading.checkout=Checkout

3 usages | 4 localizations

4error.payment.not.valid=Please check your payment information.

4 usages | 4 localizations

5label.order.summary=Order Summary

placeOrder.ismlapp_custom/cartridge/templates/default/checkout - Locations (2)

10<div class="place-order">

11 <button class="btn btn-primary place-order" type="submit">

12 ${Resource.msg('button.place.order', 'checkout', null)}

13 </button>

14</div>

placeOrder.ismlapp_custom/cartridge/templates/default/checkout1

${Resource.msg('button.place.order', 'checkout', null)}

CheckoutServices.jsapp_custom/cartridge/controllers1

Resource.msg('button.place.order', 'checkout', null)

checkout.properties

button.place.order2 usages

1app_customCurrent3 filescartridges/app_custom

checkout.propertiesDefault

Place your order

checkout_de.propertiesGerman

Bestellung aufgeben

checkout_fr.propertiesMissingFrench

3app_storefront_base1 filecartridges/app_storefront_base

checkout.propertiesOverridden by app_customDefault

Place Order

mainLn 3, Col 1UTF-8Properties

Every key in a .properties text editor shows how often scripts and templates use it and how many files of the bundle define it. Usages opens a peek, Localizations opens the Resource Bundle Editor on that key

Use the same completion-and-definition workflow for rendered templates and resource messages:

var Resource = require('dw/web/Resource');

// Within an SFRA route handler:
res.render('product/details', {
    heading: Resource.msg('product.details.title', 'product', null)
});

String	Source of intelligence
`'product/details'`	Indexed `.isml` templates; inserted paths omit the extension
`'product.details.title'`	Keys in indexed `.properties` resource bundles
`'product'`	Resource bundle names and available locale variants

Find All References on a resource key locates recognized usages. The resource lenses show usage and localization counts from the .properties declaration

If a project wraps these APIs in its own helpers, completion-context rules let you identify the relevant method and argument position

System and custom hooks

SFRA, SiteGenesis, and pipeline routes

Typed route callbacks

Job step registrations

Custom APIs

Templates and localized resources

Forms and pipeline dictionaries

Forms & fields

Pipeline scripts & XML

On this page