@salesforce/b2c-cli 1.11.0 → 1.12.0

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/svc/ServiceProfile.d.ts

@@ -0,0 +1,66 @@
+import ExtensibleObject = require('../object/ExtensibleObject');
+import CustomAttributes = require('../object/CustomAttributes');
+
+declare global {
+    module ICustomAttributes {
+        interface ServiceProfile extends CustomAttributes {
+        }
+    }
+}
+
+/**
+ * Configuration object for Service Profiles.
+ */
+declare class ServiceProfile extends ExtensibleObject<ICustomAttributes.ServiceProfile> {
+    /**
+     * Returns the unique Service ID.
+     */
+    readonly ID: string;
+    /**
+     * Returns the maximum number of errors in an interval allowed by the circuit breaker.
+     */
+    readonly cbCalls: number;
+    /**
+     * Returns the interval of the circuit breaker in milliseconds.
+     */
+    readonly cbMillis: number;
+    /**
+     * Returns the maximum number of calls in an interval allowed by the rate limiter.
+     */
+    readonly rateLimitCalls: number;
+    /**
+     * Returns the interval of the rate limiter in milliseconds.
+     */
+    readonly rateLimitMillis: number;
+    /**
+     * Returns the service call timeout in milliseconds.
+     */
+    readonly timeoutMillis: number;
+    private constructor();
+    /**
+     * Returns the maximum number of errors in an interval allowed by the circuit breaker.
+     */
+    getCbCalls(): number;
+    /**
+     * Returns the interval of the circuit breaker in milliseconds.
+     */
+    getCbMillis(): number;
+    /**
+     * Returns the unique Service ID.
+     */
+    getID(): string;
+    /**
+     * Returns the maximum number of calls in an interval allowed by the rate limiter.
+     */
+    getRateLimitCalls(): number;
+    /**
+     * Returns the interval of the rate limiter in milliseconds.
+     */
+    getRateLimitMillis(): number;
+    /**
+     * Returns the service call timeout in milliseconds.
+     */
+    getTimeoutMillis(): number;
+}
+
+export = ServiceProfile;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/svc/ServiceRegistry.d.ts

@@ -0,0 +1,75 @@
+import ServiceDefinition = require('./ServiceDefinition');
+import Service = require('./Service');
+
+/**
+ * The ServiceRegistry is responsible for managing Service definitions and their instances.
+ * 
+ * Typical usage involves several steps:
+ * 
+ * - The service is defined in the Business Manager and configured with necessary credentials.
+ * - The service callback is configured once during cartridge initialization:
+ * 
+ * ```
+ * ServiceRegistry.configure("MyFTPService", {
+ *     mockExec : function(svc:FTPService, params) {
+ *         return [
+ *             { "name": "file1", "timestamp": new Date(2011, 02, 21)},
+ *             { "name": "file2", "timestamp": new Date(2012, 02, 21)},
+ *             { "name": "file3", "timestamp": new Date(2013, 02, 21)}
+ *         ];
+ *     },
+ *     createRequest: function(svc:FTPService, params) {
+ *         svc.setOperation("list", "/");
+ *     },
+ *     parseResponse : function(svc:FTPService, listOutput) {
+ *         var x : Array = [];
+ *         var resp : Array = listOutput;
+ *         for(var i = 0; i < resp.length; i++) {
+ *             var f = resp[i];
+ *             x.push( { "name": f['name'], "timestamp": f['timestamp'] } );
+ *         }
+ *         return x;
+ *     }
+ * });
+ * ```
+ * 
+ * - A new service instance is created and called in order to perform the operation:
+ * 
+ * ```
+ * var result : Result = ServiceRegistry.get("MyFTPService").call();
+ * if(result.status == 'OK') {
+ * // The result.object is the object returned by the 'after' callback.
+ * } else {
+ * // Handle the error. See result.error for more information.
+ * }
+ * ```
+ * 
+ * See ServiceCallback for all the callback options, and individual ServiceDefinition
+ * classes for customization specific to a service type.
+ * @deprecated It is recommended to use the LocalServiceRegistry instead of this class.
+ */
+declare class ServiceRegistry {
+    private constructor();
+    /**
+     * Configure the given serviceId with a callback.
+     * 
+     * If the service is already configured, the given callback will replace any existing one.
+     */
+    static configure(serviceID: string, configObj: Object): ServiceDefinition;
+    /**
+     * Constructs a new instance of the given service.
+     */
+    static get(serviceID: string): Service;
+    /**
+     * Gets a Service Definition.
+     * 
+     * This Service Definition is shared across all Service instances returned by get.
+     */
+    static getDefinition(serviceID: string): ServiceDefinition;
+    /**
+     * Returns the status of whether the given service has been configured with a callback.
+     */
+    static isConfigured(serviceID: string): boolean;
+}
+
+export = ServiceRegistry;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/svc/index.d.ts

@@ -0,0 +1,37 @@
+import FTPService = require('./FTPService');
+import FTPServiceDefinition = require('./FTPServiceDefinition');
+import HTTPFormService = require('./HTTPFormService');
+import HTTPFormServiceDefinition = require('./HTTPFormServiceDefinition');
+import HTTPService = require('./HTTPService');
+import HTTPServiceDefinition = require('./HTTPServiceDefinition');
+import LocalServiceRegistry = require('./LocalServiceRegistry');
+import Result = require('./Result');
+import SOAPService = require('./SOAPService');
+import SOAPServiceDefinition = require('./SOAPServiceDefinition');
+import Service = require('./Service');
+import ServiceCallback = require('./ServiceCallback');
+import ServiceConfig = require('./ServiceConfig');
+import ServiceCredential = require('./ServiceCredential');
+import ServiceDefinition = require('./ServiceDefinition');
+import ServiceProfile = require('./ServiceProfile');
+import ServiceRegistry = require('./ServiceRegistry');
+
+export {
+    FTPService,
+    FTPServiceDefinition,
+    HTTPFormService,
+    HTTPFormServiceDefinition,
+    HTTPService,
+    HTTPServiceDefinition,
+    LocalServiceRegistry,
+    Result,
+    SOAPService,
+    SOAPServiceDefinition,
+    Service,
+    ServiceCallback,
+    ServiceConfig,
+    ServiceCredential,
+    ServiceDefinition,
+    ServiceProfile,
+    ServiceRegistry
+};

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/AgentUserStatusCodes.d.ts

@@ -0,0 +1,14 @@
+import customerAgentUserStatusCodes = require('../customer/AgentUserStatusCodes');
+
+/**
+ * AgentUserStatusCodes contains constants representing status codes that can be
+ * used with a Status object to indicate the success or failure of the agent
+ * user login process.
+ * @see dw.system.Status
+ * @deprecated see dw.customer.AgentUserStatusCodes - this class should only be used for the LoginAgentUser / LoginOnBehalfCustomer pipelets
+ */
+declare class AgentUserStatusCodes extends customerAgentUserStatusCodes {
+    private constructor();
+}
+
+export = AgentUserStatusCodes;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/Cache.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The Cache class represents a custom cache.
+ * 
+ * A cache stores data over multiple requests. Each cartridge can define its own
+ * caches for different business requirements. To limit the
+ * visibility of cache entries by scope, for example, by site, catalog, or
+ * external system, include the scope reference when constructing the
+ * key. For example:
+ * 
+ * ```
+ * var cache = CacheMgr.getCache( 'SiteConfigurations' );
+ * cache.get( Site.current.ID + "config", function loadSiteConfiguration() {return loadCfg( Site.current );} );
+ * ```
+ * 
+ * Do not build the cache key using personal user data, since the key might be
+ * visible in log messages.
+ * 
+ * There is never a guarantee that a stored object can be retrieved from the
+ * cache. The storage allocated for entries is limited and clearing or
+ * invalidation might occur at any time. To maintain the cache size limits, the
+ * cache evicts entries that are less likely to be used again. For example, the
+ * cache might evict an entry because it hasn't been used recently or very
+ * often. Cache entries aren't synchronized between different application
+ * servers.
+ * 
+ * The cache returns immutable copies of the original objects put into the
+ * cache. Lists are converted to arrays during this process. Only JavaScript
+ * primitive values and tree-like object structures can be stored as entries.
+ * Object structures can consist of arrays, lists, and basic JavaScript
+ * objects. Script API classes are not supported, except dw.util.List
+ * and its subclasses. `null` can be stored as a value.
+ * `undefined` can't be stored.
+ * 
+ * See CacheMgr for details about how to configure a custom cache.
+ */
+declare class Cache {
+    private constructor();
+    /**
+     * Returns the value associated with key in this cache, or invokes the loader function to generate the entry if
+     * there is no entry found. The generated entry is stored for future retrieval. If the loader function returns
+     * `undefined`, this value is not stored in the cache.
+     */
+    get(key: string, loader: Function): any;
+    /**
+     * Returns the value associated with key in this cache. If there is no entry in the cache then
+     * `undefined` is returned.
+     */
+    get(key: string): any;
+    /**
+     * Removes the cache entry for key (if one exists) manually before the cache's eviction strategy goes into effect.
+     */
+    invalidate(key: string): void;
+    /**
+     * Stores the specified entry directly into the cache, replacing any previously cached entry for key if one exists.
+     * Storing `undefined` as value has the same effect as calling invalidate for that key.
+     */
+    put(key: string, value: any): void;
+}
+
+export = Cache;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/CacheMgr.d.ts

@@ -0,0 +1,39 @@
+import Cache = require('./Cache');
+
+/**
+ * The CacheMgr class is the entry point for using custom caches.
+ * 
+ * The CacheMgr can manage multiple custom caches that share one storage space. Each individual cache has a unique ID
+ * and an optional expiration time that specifies the maximum time (in seconds) an entry is stored in the cache. For
+ * registering caches inside the cartridge root folder, a 'package.json' file with a 'caches' entry must exist. The
+ * registration of caches is independent of any site context.
+ * 
+ * ```
+ * "caches": "./caches.json"
+ * ```
+ * 
+ * The caches entry links to a JSON file, with a path relative to the 'package.json' file. This file lists all
+ * registered caches inside the caches property:
+ * @example
+ * {
+ * "caches": [
+ * {
+ * "id": "UnlimitedTestCache"
+ * },
+ * {
+ * "id": "TestCacheWithExpiration",
+ * "expireAfterSeconds": 10
+ * }
+ * ]
+ * }
+ */
+declare class CacheMgr {
+    private constructor();
+    /**
+     * Returns the defined cache instance for the given ID. Throws an exception when the requested cache has not been
+     * defined in any caches.json descriptor.
+     */
+    static getCache(cacheID: string): Cache;
+}
+
+export = CacheMgr;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/HookMgr.d.ts

@@ -0,0 +1,31 @@
+/**
+ * This class provides functionality to call hooks. A hook is an extension point in the business logic,
+ * where you can register scripts to customize functionality.
+ */
+declare class HookMgr {
+    private constructor();
+    /**
+     * Calls a hook on base of the specified extensionPoint and function. If a hook throws an exception, then
+     * this method will also throw an exception. If no hook and no system default implementation is provided,
+     * then this method will return undefined.
+     * 
+     * Sample:
+     * @example
+     * dw.system.HookMgr.callHook( "dw.order.calculate", "calculate", basket );
+     */
+    static callHook(extensionPoint: string, function_: string, ...args: any[]): any;
+    /**
+     * Checks whether a hook is registered or a system default implementation exists for this extension point.
+     * 
+     * extensionPoint refers to the same name used to register a script as implementation. With this method it's only
+     * possible to check for a whole script registered but it is not possible to check, whether an individual function
+     * is implemented.
+     * 
+     * Sample:
+     * @example
+     * dw.system.HookMgr.hasHook( "dw.order.calculate" );
+     */
+    static hasHook(extensionPoint: string): boolean;
+}
+
+export = HookMgr;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/InternalObject.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Class used to wrap internal objects to hide them from
+ * B2C Commerce Script code.
+ */
+declare class InternalObject {
+    private constructor();
+    /**
+     * Returns a string representation of this object.
+     */
+    toString(): string;
+    /**
+     * Returns a string representation of this object.
+     */
+    valueOf(): string;
+}
+
+export = InternalObject;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/JobProcessMonitor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Reserved for future use.
+ */
+declare class JobProcessMonitor {
+    /**
+     * Reserved for future use. Gets the total work count.
+     */
+    totalWork: number;
+    /**
+     * Reserved for future use. Gets the work message.
+     */
+    workMessage: string;
+    private constructor();
+    /**
+     * Reserved for future use. Gets the total work count.
+     */
+    getTotalWork(): number;
+    /**
+     * Reserved for future use. Gets the work message.
+     */
+    getWorkMessage(): string;
+    /**
+     * Reserved for future use. Sets the total work count.
+     */
+    setTotalWork(totalWork: number): void;
+    /**
+     * Reserved for future use. Sets the work message.
+     */
+    setWorkMessage(msg: string): void;
+    /**
+     * Reserved for future use. Increments the count of work items by the value of the specified
+     * parameter.
+     */
+    worked(worked: number): void;
+}
+
+export = JobProcessMonitor;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/Log.d.ts

@@ -0,0 +1,77 @@
+import LogNDC = require('./LogNDC');
+
+/**
+ * A log4j like logger instance. To obtain such an instance, use the dw.system.Logger.getRootLogger or
+ * dw.system.Logger.getLogger or dw.system.Logger.getLogger methods.
+ */
+declare class Log {
+    /**
+     * Returns the Nested Diagnostic Context for this script call.
+     */
+    static readonly NDC: LogNDC;
+    /**
+     * This method returns true if debug logging is enabled for this logging instance.
+     */
+    readonly debugEnabled: boolean;
+    /**
+     * This method returns true if error logging is enabled for this logging instance.
+     */
+    readonly errorEnabled: boolean;
+    /**
+     * This method returns true if information logging is enabled for this logging instance.
+     */
+    readonly infoEnabled: boolean;
+    /**
+     * This method returns true if warning logging is enabled for this logging instance.
+     */
+    readonly warnEnabled: boolean;
+    private constructor();
+    /**
+     * Returns the Nested Diagnostic Context for this script call.
+     */
+    static getNDC(): LogNDC;
+    /**
+     * The method reports an debug level message. Arguments can be embedded into the message, e.g. like "Failure {0} in
+     * {1}". The method implements the Java MessageFormat.format() syntax.
+     */
+    debug(msg: string, ...args: any[]): void;
+    /**
+     * The method reports an error level message. Arguments can be embedded into the message, e.g. like "Failure {0} in
+     * {1}". The method implements the Java MessageFormat.format() syntax.
+     */
+    error(msg: string, ...args: any[]): void;
+    /**
+     * The method reports an warning level message. Arguments can be embedded into the message, e.g. like "Failure {0}
+     * in {1}". The method implements the Java MessageFormat.format() syntax. Note: Fatal log messages are always
+     * enabled and optionally send via E-Mail.
+     */
+    fatal(msg: string, ...args: any[]): void;
+    /**
+     * The method reports an information level message. Arguments can be embedded into the message, e.g. like "Failure
+     * {0} in {1}". The method implements the Java MessageFormat.format() syntax.
+     */
+    info(msg: string, ...args: any[]): void;
+    /**
+     * This method returns true if debug logging is enabled for this logging instance.
+     */
+    isDebugEnabled(): boolean;
+    /**
+     * This method returns true if error logging is enabled for this logging instance.
+     */
+    isErrorEnabled(): boolean;
+    /**
+     * This method returns true if information logging is enabled for this logging instance.
+     */
+    isInfoEnabled(): boolean;
+    /**
+     * This method returns true if warning logging is enabled for this logging instance.
+     */
+    isWarnEnabled(): boolean;
+    /**
+     * The method reports an warning level message. Arguments can be embedded into the message, e.g. like "Failure {0}
+     * in {1}". The method implements the Java MessageFormat.format() syntax.
+     */
+    warn(msg: string, ...args: any[]): void;
+}
+
+export = Log;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/LogNDC.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A Nested Diagnostic Context, or NDC in short, is an instrument to distinguish
+ * interleaved log output from different sources. Log output is typically
+ * interleaved when a server handles multiple script calls near-simultaneously.
+ */
+declare class LogNDC {
+    private constructor();
+    /**
+     * Looks at the last diagnostic context at the top of this NDC without
+     * removing it.
+     * The returned value is the value that was pushed last. If no context is
+     * available, then the empty string "" is returned.
+     */
+    peek(): string;
+    /**
+     * Clients should call this method before leaving a diagnostic context.
+     * The returned value is the value that was pushed last.
+     * If no context is available, then the empty string "" is returned.
+     * NOTE: The NDC is removed after every script execution.
+     */
+    pop(): string;
+    /**
+     * Push new diagnostic context information for the current script execution.
+     */
+    push(message: string): void;
+    /**
+     * Remove the diagnostic context for this script call.
+     */
+    remove(): void;
+}
+
+export = LogNDC;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/Logger.d.ts

@@ -0,0 +1,83 @@
+import Log = require('./Log');
+
+/**
+ * The Logger class provides logging utility methods.
+ */
+declare class Logger {
+    /**
+     * This method returns true if debug logging is enabled.
+     */
+    static readonly debugEnabled: boolean;
+    /**
+     * This method returns true if error logging is enabled.
+     */
+    static readonly errorEnabled: boolean;
+    /**
+     * This method returns true if info logging is enabled.
+     */
+    static readonly infoEnabled: boolean;
+    /**
+     * Returns the root logger object.
+     */
+    static readonly rootLogger: Log;
+    /**
+     * This method returns true if warning logging is enabled.
+     */
+    static readonly warnEnabled: boolean;
+    private constructor();
+    /**
+     * The method reports an debug level message. Arguments can be embedded
+     * into the message, e.g. like "Failure {0} in {1}". The method implements
+     * the Java MessageFormat.format() syntax.
+     */
+    static debug(msg: string, ...args: any[]): void;
+    /**
+     * The method reports an error level message. Arguments can be embedded
+     * into the message, e.g. like "Failure {0} in {1}". The method implements
+     * the Java MessageFormat.format() syntax.
+     */
+    static error(msg: string, ...args: any[]): void;
+    /**
+     * Returns the logger object for the given category.
+     */
+    static getLogger(category: string): Log;
+    /**
+     * Returns the logger object for the given file name prefix and category.
+     * Throws an exception if maximum number of custom log files per day has already been obtained.
+     */
+    static getLogger(fileNamePrefix: string | null, category: string): Log;
+    /**
+     * Returns the root logger object.
+     */
+    static getRootLogger(): Log;
+    /**
+     * The method reports an information level message. Arguments can be embedded
+     * into the message, e.g. like "Failure {0} in {1}". The method implements
+     * the Java MessageFormat.format() syntax.
+     */
+    static info(msg: string, ...args: any[]): void;
+    /**
+     * This method returns true if debug logging is enabled.
+     */
+    static isDebugEnabled(): boolean;
+    /**
+     * This method returns true if error logging is enabled.
+     */
+    static isErrorEnabled(): boolean;
+    /**
+     * This method returns true if info logging is enabled.
+     */
+    static isInfoEnabled(): boolean;
+    /**
+     * This method returns true if warning logging is enabled.
+     */
+    static isWarnEnabled(): boolean;
+    /**
+     * The method reports an warning level message. Arguments can be embedded
+     * into the message, e.g. like "Failure {0} in {1}". The method implements
+     * the Java MessageFormat.format() syntax.
+     */
+    static warn(msg: string, ...args: any[]): void;
+}
+
+export = Logger;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/OrganizationPreferences.d.ts

@@ -0,0 +1,40 @@
+import ExtensibleObject = require('../object/ExtensibleObject');
+import CustomAttributes = require('../object/CustomAttributes');
+
+declare global {
+    module ICustomAttributes {
+        interface OrganizationPreferences extends CustomAttributes {
+        }
+    }
+}
+
+/**
+ * OrganizationPreferences is a container for custom global (i.e.
+ * organization-level) attributes. The object corresponds with system object
+ * definition "OrganizationPreferences". It has no system attributes and exists
+ * only as a place for merchants to define custom attributes which need to be
+ * available to all of their sites.
+ * 
+ * An instance is obtained by calling dw.system.System.getPreferences.
+ * Once an instance of the container is obtained, it is possible to read/write
+ * organization preference values by using the usual syntax for
+ * dw.object.ExtensibleObject instances. For example:
+ * 
+ * ```
+ * var orgPrefs : OrganizationPreferences = dw.system.System.getPreferences();
+ * var myOrgPrefValue : String = orgPrefs.getCustom()["myOrgPref"];
+ * ```
+ * 
+ * Note: this class allows access to sensitive security-related data.
+ * Pay special attention to PCI DSS v3. requirements 2, 4, and 12.
+ * 
+ * Commerce Cloud Digital defines many organization-level preferences, relating to
+ * locale, timezone, geolocations, etc, which can be managed within the
+ * "Global Preferences" module of the Business Manager, but these preferences
+ * are not accessible through this object.
+ */
+declare class OrganizationPreferences extends ExtensibleObject<ICustomAttributes.OrganizationPreferences> {
+    private constructor();
+}
+
+export = OrganizationPreferences;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/system/Pipeline.d.ts

@@ -0,0 +1,46 @@
+import PipelineDictionary = require('./PipelineDictionary');
+
+/**
+ * A helper for executing pipelines from JavaScript. The main purpose for this API is to invoke process pipelines from
+ * JavaScript controllers, e.g. pipelines that return with an end node and that do not perform user interactions.
+ * Pipelines that span across multiple requests (e.g. that contain Interaction-Continue-Nodes) are not supported and may
+ * not work as expected. The pipeline will be executed within the current request and not by a remote call, so this API
+ * works roughly like a Call node in a pipeline. The called pipeline will get its own local pipeline dictionary. The
+ * dictionary can be populated with initial values from an argument object. Any results from the pipeline can be read
+ * from the pipeline dictionary that is returned by the execute methods.
+ * 
+ * If an exception occurs during the pipeline processing, the Error-branch of the pipeline will be called. If no error
+ * handling exists for the pipeline, the exception will be propagated and can be handled by the script code.
+ * 
+ * If the pipeline finishes with an End node, the name of the end node can be obtained from the returned pipeline
+ * dictionary under the key 'EndNodeName'.
+ * 
+ * Example:
+ * 
+ * ```
+ * let Pipeline = require('dw/system/Pipeline');
+ * let pdict = Pipeline.execute('MyPipeline-Start', {
+ * MyArgString:     'someStringValue',
+ * MyArgNumber:     12345,
+ * MyArgBoolean:    true
+ * });
+ * let result = pdict.MyReturnValue;
+ * ```
+ * 
+ * This feature requires an API version >=15.5.
+ */
+declare class Pipeline {
+    private constructor();
+    /**
+     * Executes a pipeline.
+     * @since 15.5
+     */
+    static execute(pipeline: string): PipelineDictionary;
+    /**
+     * Executes a pipeline. The pipeline dictionary will be initialized with the provided arguments.
+     * @since 15.5
+     */
+    static execute(pipeline: string, args: any): PipelineDictionary;
+}
+
+export = Pipeline;