Class ArgumentMethodProcessor
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Argument Method Processor(target, propertyName, args): ArgumentMethodProcessor Creates an instance of
+ArgumentMethodProcessor.Parameters
- target: object
The target object.
+ - propertyName: string | symbol
The name of the property.
+ - args: any[]
The arguments to be processed.
+
Returns ArgumentMethodProcessor
- target: object
Properties
Privateargs
args: any[]
The arguments to be processed.
+Private Readonlyproperty
property
The name of the property.
+Private Readonlytarget
target: object
The target object.
+Privatetemporary
A temporary storage for arguments, organized by type.
+ Methods
apply
Privateapply
Privateapply
- apply
Single Decorator By Key(decorator): void Applies a single decorator by key. This method is used only for single decorators, the ones which can appear only once, like Next, Req, Results, etc.
+Parameters
- decorator: {
data: unknown;
metadataKey:
| "IS_ROLE"
| "SINGLE_INSTANCE_SWITCH"
| "IS_PRESENT"
| "IS_COLUMN_SUPPLIED"
| "GET_QUERY"
| "GET_REQUEST"
| "REQ"
| "RES"
| "RESULTS"
| "NEXT"
| "ERROR"
| "JWT";
}The decorator metadata and data.
+data: unknown
metadata
Key:
| "IS_ROLE"
| "SINGLE_INSTANCE_SWITCH"
| "IS_PRESENT"
| "IS_COLUMN_SUPPLIED"
| "GET_QUERY"
| "GET_REQUEST"
| "REQ"
| "RES"
| "RESULTS"
| "NEXT"
| "ERROR"
| "JWT"
Returns void
- decorator: {
Privateexists
- exists
Decorator(metadataKey): undefined | boolean Checks if a decorator exists for the given metadata key.
+Parameters
- metadataKey:
| "IS_ROLE"
| "SINGLE_INSTANCE_SWITCH"
| "IS_PRESENT"
| "IS_COLUMN_SUPPLIED"
| "GET_QUERY"
| "GET_REQUEST"
| "REQ"
| "RES"
| "RESULTS"
| "NEXT"
| "ERROR"
| "JWT"The metadata key.
+
Returns undefined | boolean
True if the decorator exists, otherwise undefined.
+- metadataKey:
Privateget
- get
Attached Decorators(): (
| "IS_ROLE"
| "SINGLE_INSTANCE_SWITCH"
| "IS_PRESENT"
| "IS_COLUMN_SUPPLIED"
| "GET_QUERY"
| "GET_REQUEST"
| "REQ"
| "RES"
| "RESULTS"
| "NEXT"
| "ERROR"
| "JWT")[] Retrieves the assigned decorators, checking if for the current parameter if there's any decorator assigned.
+Returns (
| "IS_ROLE"
| "SINGLE_INSTANCE_SWITCH"
| "IS_PRESENT"
| "IS_COLUMN_SUPPLIED"
| "GET_QUERY"
| "GET_REQUEST"
| "REQ"
| "RES"
| "RESULTS"
| "NEXT"
| "ERROR"
| "JWT")[]An array of decorator keys.
+
Privateget
- get
Metadata(metadataKey): undefined | MetadataFields[] Retrieves metadata for the given metadata key.
+Parameters
- metadataKey:
| "IS_ROLE"
| "SINGLE_INSTANCE_SWITCH"
| "IS_PRESENT"
| "IS_COLUMN_SUPPLIED"
| "GET_QUERY"
| "GET_REQUEST"
| "REQ"
| "RES"
| "RESULTS"
| "NEXT"
| "ERROR"
| "JWT"The metadata key.
+
Returns undefined | MetadataFields[]
The metadata fields or undefined.
+- metadataKey:
Privatehas
Privateon
Staticcreate
- create
Metadata By(metadata): void Creates metadata by given input.
+Parameters
- metadata: MetadataInputs
The metadata inputs.
+
Returns void
- metadata: MetadataInputs
Class CDSDispatcher
CDSDispatcher is responsible for managing and registering event handlers for entities within the CDS framework.
It supports events such as Before, After, On, and Prepend.
Index
Constructors
Properties
Methods
build
Constructors
constructor
- new CDSDispatcher(entities): CDSDispatcher
Creates an instance of
+CDSDispatcher.Parameters
- entities: NonEmptyArray<Constructable<any>>
An array of entity classes to manage event handlers for.
+
Returns CDSDispatcher
- entities: NonEmptyArray<Constructable<any>>
Properties
Private Readonlycontainer
container: Container = ...
The dependency injection container for managing service instances and dependencies.
+This container is configured to:
+-
+
- Skip base class checks. +
- Automatically bind injectable classes. +
Private Readonlyentities
An array of entity classes to manage event handlers for.
+Privatesrv
The service instance used by the dispatcher.
+This is the service that the dispatcher will interact with to register handlers and perform operations.
+ Methods
Privatebuild
- build
Handler By(handlerAndEntity): void Builds the handler by type.
+Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+
Returns void
- handlerAndEntity: [BaseHandler, Constructable<any>]
Privatebuild
Privatebuild
Privateexecute
- execute
After Callback(handlerAndEntity, req, results): Promise<unknown> Executes an 'after' event handler.
+Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+ - req: Request
The request object.
+ - results: unknown
The result of the request.
+
Returns Promise<unknown>
The result of the handler's callback.
+- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateexecute
- execute
Before Callback(handlerAndEntity, req): Promise<unknown> Executes a 'before' event handler.
+Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+ - req: Request
The request object.
+
Returns Promise<unknown>
The result of the handler's callback.
+- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateexecute
- execute
On Callback(handlerAndEntity, req, next): Promise<unknown> Executes an 'on' event handler.
+Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+ - req: Request
The request object.
+ - next: Function
The next middleware function.
+
Returns Promise<unknown>
The result of the handler's callback.
+- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateexecute
- execute
On Error Callback(handlerAndEntity, err, req): unknown Executes an 'onError' event handler.
+Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+ - err: Error
The error object.
+ - req: Request
The request object.
+
Returns unknown
The result of the handler's callback.
+- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateget
- get
Active Entity Or Draft(handler, entityInstance): undefined | Constructable<any> Returns the active entity or the draft entity of the current handler class.
+Parameters
- handler: BaseHandler
The handler instance.
+ - entityInstance: Constructable<any>
The entity instance.
+
Returns undefined | Constructable<any>
The active entity or draft entity, or undefined if not applicable.
+- handler: BaseHandler
Privateget
- get
Handler Props(handler, entityInstance): {
getAction: (() => {
actionName: undefined | CdsFunction;
});
getDefault: (() => {
entity: undefined | Constructable<any>;
event:
| "ERROR"
| "*"
| "CREATE"
| "READ"
| "UPDATE"
| "DELETE"
| "each"
| "ACTION"
| "BOUND_ACTION"
| "BOUND_FUNC"
| "FUNC"
| "EDIT"
| "SAVE"
| "NEW"
| "CANCEL"
| "EVENT";
});
getEvent: (() => {
eventName: undefined | string;
});
getPrepend: (() => {
eventKind: undefined | EventKind;
});
} Retrieves the properties of the handler.
+Parameters
- handler: BaseHandler
The handler instance.
+ - entityInstance: Constructable<any>
The entity instance.
+
Returns {
getAction: (() => {
actionName: undefined | CdsFunction;
});
getDefault: (() => {
entity: undefined | Constructable<any>;
event:
| "ERROR"
| "*"
| "CREATE"
| "READ"
| "UPDATE"
| "DELETE"
| "each"
| "ACTION"
| "BOUND_ACTION"
| "BOUND_FUNC"
| "FUNC"
| "EDIT"
| "SAVE"
| "NEW"
| "CANCEL"
| "EVENT";
});
getEvent: (() => {
eventName: undefined | string;
});
getPrepend: (() => {
eventKind: undefined | EventKind;
});
}The handler properties.
+get
Action: (() => {
actionName: undefined | CdsFunction;
})- (): {
actionName: undefined | CdsFunction;
} Returns {
actionName: undefined | CdsFunction;
}action
Name: undefined | CdsFunction
- (): {
get
Default: (() => {
entity: undefined | Constructable<any>;
event:
| "ERROR"
| "*"
| "CREATE"
| "READ"
| "UPDATE"
| "DELETE"
| "each"
| "ACTION"
| "BOUND_ACTION"
| "BOUND_FUNC"
| "FUNC"
| "EDIT"
| "SAVE"
| "NEW"
| "CANCEL"
| "EVENT";
})- (): {
entity: undefined | Constructable<any>;
event:
| "ERROR"
| "*"
| "CREATE"
| "READ"
| "UPDATE"
| "DELETE"
| "each"
| "ACTION"
| "BOUND_ACTION"
| "BOUND_FUNC"
| "FUNC"
| "EDIT"
| "SAVE"
| "NEW"
| "CANCEL"
| "EVENT";
} Returns {
entity: undefined | Constructable<any>;
event:
| "ERROR"
| "*"
| "CREATE"
| "READ"
| "UPDATE"
| "DELETE"
| "each"
| "ACTION"
| "BOUND_ACTION"
| "BOUND_FUNC"
| "FUNC"
| "EDIT"
| "SAVE"
| "NEW"
| "CANCEL"
| "EVENT";
}entity: undefined | Constructable<any>
event:
| "ERROR"
| "*"
| "CREATE"
| "READ"
| "UPDATE"
| "DELETE"
| "each"
| "ACTION"
| "BOUND_ACTION"
| "BOUND_FUNC"
| "FUNC"
| "EDIT"
| "SAVE"
| "NEW"
| "CANCEL"
| "EVENT"
- (): {
get
Event: (() => {
eventName: undefined | string;
})- (): {
eventName: undefined | string;
} Returns {
eventName: undefined | string;
}event
Name: undefined | string
- (): {
get
Prepend: (() => {
eventKind: undefined | EventKind;
})
- handler: BaseHandler
Privateget
- get
Handlers By(entityInstance): undefined | {
buildHandlers: (() => void);
buildMiddlewares: (() => void);
} Gets the handlers for the entity instance.
+Parameters
- entityInstance: Constructable<any>
The entity instance.
+
Returns undefined | {
buildHandlers: (() => void);
buildMiddlewares: (() => void);
}The handler registration functions if handlers are found.
+- entityInstance: Constructable<any>
initialize
- initialize(): ServiceImpl
Initializes the entities within the
+CDSDispatcher, registering their corresponding handlers.Returns ServiceImpl
An instance of
+ServiceImplrepresenting the registered service implementation.
Privateregister
- register
After Handler(handlerAndEntity): void Registers all
+AFTERevent handlers.Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+
Returns void
- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateregister
- register
After Single Instance Handler(handlerAndEntity): void Registers
+AFTER - SingleInstanceevent handlers.Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+
Returns void
- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateregister
- register
Before Handler(handlerAndEntity): void Registers all
+BEFOREevent handlers.Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+
Returns void
- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateregister
Privateregister
- register
On Handler(handlerAndEntity): void Registers all
+ONevent handlers.Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+
Returns void
- handlerAndEntity: [BaseHandler, Constructable<any>]
Privateregister
- register
Prepend Handler(handlerAndEntity): void Registers all
+PREPENDevent handlers.Parameters
- handlerAndEntity: [BaseHandler, Constructable<any>]
A tuple containing the handler and entity.
+
Returns void
- handlerAndEntity: [BaseHandler, Constructable<any>]
Private Readonlyregister
Privateresolve
Privatestore
- store
Service(srv): void Stores the service instance.
+Parameters
- srv: Service
The service instance.
+
Returns void
- srv: Service
Class MetadataDispatcher
The MetadataDispatcher class handles metadata operations for target objects,
+such as setting and retrieving metadata related to entity handlers, middlewares, and method handlers.
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Metadata Dispatcher(target, metadataKey): MetadataDispatcher Creates an instance of
+MetadataDispatcher.Parameters
- target: object
The target object on which metadata operations will be performed.
+ - metadataKey: string | symbol
The key used to store metadata.
+
Returns MetadataDispatcher
- target: object
Properties
Private Readonlymetadata
metadata
The key used to store metadata.
+Private Readonlytarget
target: object
The target object on which metadata operations will be performed.
+ Methods
add
add
- add
Method Metadata(props): void Adds method handler metadata to the target object.
+Parameters
- props: BaseHandler
The
+BaseHandlerobject containing handler metadata.
Returns void
- props: BaseHandler
Privateget
Privatehas
set
- set
Middlewares(middlewares): void Sets the middlewares metadata for the target object.
+Parameters
- middlewares: Constructable<MiddlewareImpl>[]
An array of middleware constructors.
+
Returns void
- middlewares: Constructable<MiddlewareImpl>[]
Staticget
Staticget
- get
Metadata Handlers(entity): BaseHandler[] Retrieves the method handlers metadata for the given entity.
+Parameters
- entity: Constructable<any>
The entity constructor.
+
Returns BaseHandler[]
An array of
+BaseHandlerobjects.- entity: Constructable<any>
Staticget
- get
Middlewares(entity): Constructable<MiddlewareImpl>[] Retrieves the middlewares metadata for the given entity.
+Parameters
- entity: Constructable<any>
The entity constructor.
+
Returns Constructable<MiddlewareImpl>[]
An array of middleware constructors.
+- entity: Constructable<any>
Class Request
Hierarchy
- Event
- Request
Properties
data
data: any
entity
entity: string
Shortcut to target (entity) name
+event
event: string
Optionalfeatures
features?: {
[key: string]: boolean;
}
[key: string]: boolean;
}
headers
headers: any
Optionalhttp
http?: {
req: Request;
res: Response;
}
req: Request;
res: Response;
}
id
id: string
locale
locale: `${string}_${string}`
method
method: string
params
params: (string | object)[]
path
path: string
query
query: Partial<SELECT & INSERT & UPDATE & DELETE & CREATE & DROP & UPSERT>
subject
subject: ref
target
target: LinkedDefinition
tenant
tenant: string
timestamp
timestamp: Date
user
user: User
Methods
error
- error(code, message, target?, args?): Error
Parameters
- code: number
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- error(code, message, args?): Error
Parameters
- code: number
- message: string
Optionalargs: any[]
Returns Error
- error(message, target?, args?): Error
Parameters
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- error(message): Error
Parameters
- message: {
args?: any[];
code?: string | number;
message: string;
status?: number;
target?: string;
}Optionalargs?: any[]Optionalcode?: string | numbermessage: string
Optionalstatus?: numberOptionaltarget?: string
Returns Error
- message: {
info
- info(code, message, target?, args?): Error
Parameters
- code: number
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- info(code, message, args?): Error
Parameters
- code: number
- message: string
Optionalargs: any[]
Returns Error
- info(message, target?, args?): Error
Parameters
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- info(message): Error
Parameters
- message: {
args?: any[];
code?: string | number;
message: string;
target?: string;
}Optionalargs?: any[]Optionalcode?: string | numbermessage: string
Optionaltarget?: string
Returns Error
- message: {
notify
- notify(code, message, target?, args?): Error
Parameters
- code: number
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- notify(code, message, args?): Error
Parameters
- code: number
- message: string
Optionalargs: any[]
Returns Error
- notify(message, target?, args?): Error
Parameters
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- notify(message): Error
Parameters
- message: {
args?: any[];
code?: string | number;
message: string;
target?: string;
}Optionalargs?: any[]Optionalcode?: string | numbermessage: string
Optionaltarget?: string
Returns Error
- message: {
reject
- reject(code, message, target?, args?): Error
Parameters
- code: number
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- reject(code, message, args?): Error
Parameters
- code: number
- message: string
Optionalargs: any[]
Returns Error
- reject(message, target?, args?): Error
Parameters
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- reject(message): Error
Parameters
- message: {
args?: any[];
code?: string | number;
message: string;
status?: number;
target?: string;
}Optionalargs?: any[]Optionalcode?: string | numbermessage: string
Optionalstatus?: numberOptionaltarget?: string
Returns Error
- message: {
reply
warn
- warn(code, message, target?, args?): Error
Parameters
- code: number
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- warn(code, message, args?): Error
Parameters
- code: number
- message: string
Optionalargs: any[]
Returns Error
- warn(message, target?, args?): Error
Parameters
- message: string
Optionaltarget: stringOptionalargs: any[]
Returns Error
- warn(message): Error
Parameters
- message: {
args?: any[];
code?: string | number;
message: string;
target?: string;
}Optionalargs?: any[]Optionalcode?: string | numbermessage: string
Optionaltarget?: string
Returns Error
- message: {
Class Service
Class cds.Service
+Hierarchy
- QueryAPI
- Service
Constructors
constructor
- new
Service(name?, model?, options?): Service Parameters
Optionalname: stringOptionalmodel: CSNOptionaloptions: {
impl: string | ServiceImpl;
kind: string;
}impl: string | ServiceImpl
kind: string
Returns Service
Properties
create
create: {
<T>(entity: T, key?: any): INSERT<T>;
<T>(entity: string | LinkedDefinition, key?: any): INSERT<T>;
}
<T>(entity: T, key?: any): INSERT<T>;
<T>(entity: string | LinkedDefinition, key?: any): INSERT<T>;
}
delete
delete: {
<T>(entityOrPath: target, data?: object): DELETE<T>;
<T>(entity: T, key?: any): DELETE<T>;
<T>(entity: string | LinkedDefinition, key?: any): DELETE<T>;
}
<T>(entityOrPath: target, data?: object): DELETE<T>;
<T>(entity: T, key?: any): DELETE<T>;
<T>(entity: string | LinkedDefinition, key?: any): DELETE<T>;
}
Constructs and sends a DELETE request.
+emit
emit: {
<T>(details: {
data?: object;
event: event;
headers?: object;
}): Promise<T>;
<T>(event: event, data?: object, headers?: object): Promise<T>;
}
<T>(details: {
data?: object;
event: event;
headers?: object;
}): Promise<T>;
<T>(event: event, data?: object, headers?: object): Promise<T>;
}
Constructs and emits an asynchronous event.
+entities
entities: Definitions & ((namespace: string) => Definitions)
Provides access to the entities exposed by a service
+events
events: Definitions & ((namespace: string) => Definitions)
Provides access to the events declared by a service
+insert
kind
kind: string
The kind of the service
+model
model: LinkedCSN
The model from which the service's definition was loaded
+name
name: string
The name of the service
+operations
operations: Definitions & ((namespace: string) => Definitions)
Provides access to the operations, i.e. actions and functions, exposed by a service
+read
read: {
<T>(entity: T, key?: any): Awaitable<SELECT<T>, InstanceType<T>>;
<T>(entity: string | LinkedDefinition, key?: any): SELECT<T>;
}
<T>(entity: T, key?: any): Awaitable<SELECT<T>, InstanceType<T>>;
<T>(entity: string | LinkedDefinition, key?: any): SELECT<T>;
}
run
run: {
(query: ConstructedQuery | ConstructedQuery[]): Promise<any>;
(query: Partial<SELECT & INSERT & UPDATE & DELETE & CREATE & DROP & UPSERT>): Promise<any>;
(query: string, args?: object | any[]): Promise<any>;
}
(query: ConstructedQuery | ConstructedQuery[]): Promise<any>;
(query: Partial<SELECT & INSERT & UPDATE & DELETE & CREATE & DROP & UPSERT>): Promise<any>;
(query: string, args?: object | any[]): Promise<any>;
}
send
send: {
<T>(event: event, path: string, data?: object, headers?: object): Promise<T>;
<T>(event: event, data?: object, headers?: object): Promise<T>;
<T>(details: {
data?: object;
event: event;
headers?: object;
}): Promise<T>;
<T>(details: {
data?: object;
headers?: object;
query: ConstructedQuery;
}): Promise<T>;
<T>(details: {
data?: object;
headers?: object;
method: string;
path: string;
}): Promise<T>;
<T>(details: {
data?: object;
entity: string | LinkedDefinition;
event: string;
headers?: object;
params?: object;
}): Promise<T>;
}
<T>(event: event, path: string, data?: object, headers?: object): Promise<T>;
<T>(event: event, data?: object, headers?: object): Promise<T>;
<T>(details: {
data?: object;
event: event;
headers?: object;
}): Promise<T>;
<T>(details: {
data?: object;
headers?: object;
query: ConstructedQuery;
}): Promise<T>;
<T>(details: {
data?: object;
headers?: object;
method: string;
path: string;
}): Promise<T>;
<T>(details: {
data?: object;
entity: string | LinkedDefinition;
event: string;
headers?: object;
params?: object;
}): Promise<T>;
}
Constructs and sends a synchronous request.
+stream
stream: {
(column: string): {
from(entity: string | LinkedDefinition): {
where(filter: any): ReadableStream<any>;
};
};
(query: Partial<SELECT & INSERT & UPDATE & DELETE & CREATE & DROP & UPSERT>): Promise<ReadableStream<any>>;
}
(column: string): {
from(entity: string | LinkedDefinition): {
where(filter: any): ReadableStream<any>;
};
};
(query: Partial<SELECT & INSERT & UPDATE & DELETE & CREATE & DROP & UPSERT>): Promise<ReadableStream<any>>;
}
transaction
transaction: {
(fn: ((tx: Transaction) => object)): Promise<any>;
(context?: object): Transaction;
(context: object, fn: ((tx: Transaction) => object)): Promise<any>;
}
(fn: ((tx: Transaction) => object)): Promise<any>;
(context?: object): Transaction;
(context: object, fn: ((tx: Transaction) => object)): Promise<any>;
}
types
types: Definitions & ((namespace: string) => Definitions)
Provides access to the types exposed by a service
+update
update: {
<T>(entity: T, key?: any): UPDATE<T>;
<T>(entity: string | LinkedDefinition, key?: any): UPDATE<T>;
}
<T>(entity: T, key?: any): UPDATE<T>;
<T>(entity: string | LinkedDefinition, key?: any): UPDATE<T>;
}
upsert
Methods
after
- after<T>(eve, entity, handler): this
Type Parameters
Returns this
- after(eve, entity, handler): this
Parameters
- eve: event
- entity: target
- handler: ResultsHandler
Returns this
- after(eve, handler): this
Parameters
- eve: event
- handler: ResultsHandler
Returns this
before
- before<T>(eve, entity, handler): this
Type Parameters
Returns this
- before(eve, entity, handler): this
Parameters
- eve: event
- entity: target
- handler: EventHandler
Returns this
- before(eve, handler): this
Parameters
- eve: event
- handler: EventHandler
Returns this
dispatch
foreach
get
init
on
- on<T>(eve, entity, handler): this
Type Parameters
Returns this
- on<F>(boundAction, service, handler): this
Type Parameters
- F extends CdsFunction
Parameters
Returns this
- on<F>(unboundAction, handler): this
Type Parameters
- F extends CdsFunction
Parameters
Returns this
- on(eve, entity, handler): this
Parameters
- eve: event
- entity: target
- handler: OnEventHandler
Returns this
- on(eve, handler): this
Parameters
- eve: event
- handler: OnEventHandler
Returns this
- on(eve, handler): this
Parameters
- eve: "error"
- handler: OnErrorHandler
Returns this
patch
post
prepend
- prepend(fn): Promise<Service>
Parameters
- fn: ServiceImpl
Returns Promise<Service>
put
reject
Class GetQueryType
Constructors
constructor
- new
Get Query Type(): GetQueryType Returns GetQueryType
Properties
as
as: SELECT
columns
columns: {
forInsert: string[];
forSelect: column_expr[];
forUpsert: string[];
}
forInsert: string[];
forSelect: column_expr[];
forUpsert: string[];
}
data
data: {
[key: string]: expr;
}
[key: string]: expr;
}
distinct
distinct: undefined | true
entity
entity: string | ref
entries
entries: data[]
excluding
excluding: undefined | string[]
from
from: {
forDelete: string | ref;
forSelect: source;
}
forDelete: string | ref;
forSelect: source;
}
group
group
having
having: undefined | predicate
into
into: string | ref
limit
limit: {
offset: {
val: number;
};
rows: {
val: number;
};
}
offset: {
val: number;
};
rows: {
val: number;
};
}
mixin
mixin: undefined | {
[key: string]: expr;
}
[key: string]: expr;
}
one
one: undefined | boolean
order
order
rows
rows: scalar[][]
values
values: scalar[]
where
where: undefined | predicate
Class MiddlewareEntityRegistry
This class registers the middleware classes for @Use decorator.
Index
Constructors
Properties
Methods
Constructors
constructor
- new
Middleware Entity Registry(entityInstance, srv): MiddlewareEntityRegistry Creates an instance of MiddlewareEntityRegistry.
+Parameters
- entityInstance: Constructable<any>
The entity instance to be used.
+ - srv: Service
The service instance to be used.
+
Returns MiddlewareEntityRegistry
- entityInstance: Constructable<any>
Properties
Private Readonlyentity
entity
The entity instance to be used.
+Private Readonlysrv
The service instance to be used.
+ Methods
build
Private Readonlyexecute
- execute
Middleware Chain(req, startIndex?): Promise<void> Executes the middleware chain starting from the specified index.
+Parameters
- req: Request
The request object.
+ - startIndex: number = 0
The index from which to start the middleware chain.
+
Returns Promise<void>
- req: Request
Privateget
has
Privateregister
Privateregister
Privatesort
Enumeration HandlerType
Index
Enumeration Members
Function EntityHandler
- Entity
Handler<T>(entity): ((target: (new (...args: never) => unknown)) => void) This decorator is used to associate a handler class with a specific entity. +It ensures that all handlers within the class operate with the specified entity context.
+Type Parameters
Parameters
- entity: CDSTyperEntity<T>
The entity to associate with the handler class. Must be a
+CDS-Typerclass.
Returns ((target: (new (...args: never) => unknown)) => void)
- (target): void
Parameters
- target: (new (...args: never) => unknown)
- new (...args): unknown
Parameters
Rest...args: never
Returns unknown
Returns void
- target: (new (...args: never) => unknown)
- entity: CDSTyperEntity<T>
- Entity
Handler(entity): ((target: (new (...args: never) => unknown)) => void) This decorator is used to associate a handler class with all entities. +It ensures that all handlers within the class operate with a generic context applicable to all entities.
+Parameters
- entity: "*"
A wildcard
+'*'indicating all entities.
Returns ((target: (new (...args: never) => unknown)) => void)
- (target): void
Parameters
- target: (new (...args: never) => unknown)
- new (...args): unknown
Parameters
Rest...args: never
Returns unknown
Returns void
- target: (new (...args: never) => unknown)
- entity: "*"
Function Repository
- Repository<Target>(): ((target: Target) => void)
This decorator is used to mark a class as a repository, containing
+repository logic.It makes the class injectable and allows dependency injection to be used within the class.
+Type Parameters
Returns ((target: Target) => void)
- (target): void
Parameters
- target: Target
Returns void
Function ServiceLogic
- Service
Logic<Target>(): ((target: Target) => void) This decorator is used to mark a class as containing
+business logic.It makes the class injectable and allows dependency injection to be used within the class.
+Type Parameters
Returns ((target: Target) => void)
- (target): void
Parameters
- target: Target
Returns void
Function UnboundActions
- Unbound
Actions<Target>(): ((target: Target) => void) This decorator is used to mark a class as containing unbound actions.
+Unbound actions are operations that are not tied to a specific entity. +It makes the class injectable and allows dependency injection to be used within the class.
+Type Parameters
Returns ((target: Target) => void)
- (target): void
Parameters
- target: Target
Returns void
Function AfterAll
Use @AfterAll decorator to execute custom logic after creating a new resource for all events ('CREATE', 'READ', 'UPDATE', 'DELETE', 'BOUND ACTION', 'BOUND FUNCTION')
- After
All<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterAllDraft
Use @AfterCreateAll decorator to execute custom logic after creating a new draft resource for all events ('CREATE', 'READ', 'UPDATE', 'DELETE', 'BOUND ACTION', 'BOUND FUNCTION')
- After
All Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterCancelDraft
Use @AfterCancelDraft decorator to execute custom logic after a 'draft' is cancelled.
- After
Cancel Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterCreate
Use @AfterCreate decorator to execute custom logic after creating a new resource.
- After
Create<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterCreateDraft
Use @AfterCreateDraft decorator to execute custom logic after creating a new DRAFT resource.
- After
Create Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterDelete
Use @AfterDelete decorator to execute custom logic after performing a delete operation.
- After
Delete<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterDeleteDraft
Use @AfterDeleteDraft decorator to execute custom logic after performing a delete operation on a draft.
- After
Delete Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterEditDraft
Use @AfterEditDraft decorator to execute custom logic after a 'draft' is edited.
- After
Edit Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterNewDraft
Use @AfterNewDraft decorator to execute custom logic after a new 'draft' is created.
- After
New Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterRead
Use @AfterRead decorator to execute custom logic after performing a read operation.
- After
Read<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterReadDraft
Use @AfterReadDraft decorator to execute custom logic after performing a draft read operation.
- After
Read Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterReadDraftEachInstance
The @AfterReadDraftEachInstance decorator is used to execute custom logic after performing a read operation on each individual draft instance. This behavior is analogous to the JavaScript Array.prototype.forEach method.
- After
Read Draft Each Instance<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterReadDraftSingleInstance
Use @AfterReadDraftSingleInstance decorator to execute custom logic after creating a new DRAFT single instance resource.
- After
Read Draft Single Instance<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterReadEachInstance
The @AfterReadEachInstance decorator is used to execute custom logic after performing a read operation on each individual instance. This behavior is analogous to the JavaScript Array.prototype.forEach method.
- After
Read Each Instance<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterReadSingleInstance
Use @AfterReadSingleInstance decorator to execute custom logic after creating a new single instance resource.
- After
Read Single Instance<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterSaveDraft
Use @AfterSaveDraft decorator to execute custom logic after a 'draft' is saved.
- After
Save Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterUpdate
Use @AfterUpdate decorator to execute custom logic after performing an update operation.
- After
Update<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function AfterUpdateDraft
Use @AfterUpdateDraft decorator to execute custom logic after performing a DRAFT update operation.
- After
Update Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeAll
Use @BeforeAll decorator to execute custom logic before creating a new resource for all events ('CREATE', 'READ', 'UPDATE', 'DELETE', 'BOUND ACTION', 'BOUND FUNCTION')
- Before
All<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeAllDraft
Use @BeforeAllDraft decorator to execute custom logic before creating a new draft resource for all events ('CREATE', 'READ', 'UPDATE', 'DELETE', 'BOUND ACTION', 'BOUND FUNCTION')
- Before
All Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeCancelDraft
Use @BeforeCancelDraft decorator to execute custom logic before a 'draft' is cancelled.
- Before
Cancel Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeCreate
Use @BeforeCreate decorator to execute custom logic before creating a new resource.
- Before
Create<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeCreateDraft
Use @BeforeCreateDraft decorator to execute custom logic before creating a new DRAFT resource.
- Before
Create Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeDelete
Use @BeforeDelete decorator to execute custom logic before performing a delete operation.
- Before
Delete<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeDeleteDraft
Use @BeforeDeleteDraft decorator to execute custom logic before performing a delete operation on a draft.
- Before
Delete Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeEditDraft
Use @BeforeEditDraft decorator to execute custom logic before a 'draft' is edited.
- Before
Edit Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeNewDraft
Use @BeforeNewDraft decorator to execute custom logic before a 'draft' is created.
- Before
New Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeRead
Use @BeforeRead decorator to execute custom logic before performing a read operation.
- Before
Read<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeReadDraft
Use @BeforeReadDraft decorator to execute custom logic before performing a DRAFT read operation.
- Before
Read Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeSaveDraft
Use @BeforeSaveDraft decorator to execute custom logic before a 'draft' is saved.
- Before
Save Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeUpdate
Use @BeforeUpdate decorator to execute custom logic before performing an update operation.
- Before
Update<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function BeforeUpdateDraft
Use @BeforeUpdateDraft decorator to execute custom logic before performing a DRAFT update operation.
- Before
Update Draft<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function ExecutionAllowedForRole
- Execution
Allowed For Role(...roles): (<Target>(_: Target, __: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Use
+@ExecutionAllowedForRoledecorator to enforce role-based access control ensuring that onlyUserswith specific role are authorized to execute theevent(AfterRead,AfterCreate, ...) and the custom logic inside of the event.Parameters
Rest...roles: string[]
Returns (<Target>(_: Target, __: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- <Target>(_, __, descriptor): void
Type Parameters
Parameters
- _: Target
- __: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function FieldsFormatter
- Fields
Formatter<T>(formatter, ...fields): (<Target>(_: Target, __: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Use
+@FieldsFormatterdecorator toenhance / formatthe fields.Type Parameters
Parameters
- formatter: Formatters<T>
The formatter method to apply.
+ Rest...fields: (keyof T)[]An array of fields to apply the formatter method on.
+
Returns (<Target>(_: Target, __: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- <Target>(_, __, descriptor): void
Type Parameters
Parameters
- _: Target
- __: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
- formatter: Formatters<T>
Function OnAction
Use @OnAction decorator to execute custom logic when a custom action event is triggered.
- On
Action<Target>(name): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Parameters
- name: CdsFunction
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnAll
Use @OnAll decorator to execute custom logic when a new resource is (READ, CREATED, UPDATED, DELETED)
- On
All(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnAllDraft
Use @OnAllDraft decorator to execute custom logic.
- On
All Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnBoundAction
Use @OnBoundAction decorator to execute custom logic when a custom bound action event is triggered.
- On
Bound Action<Target>(name): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Parameters
- name: CdsFunction
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnBoundActionDraft
Use @OnBoundActionDraft decorator to execute custom logic when a custom bound action event is triggered on a DRAFT resource.
- On
Bound Action Draft<Target>(name): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Parameters
- name: CdsFunction
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnBoundFunction
Use @OnBoundFunction decorator to execute custom logic when a custom bound function event is triggered.
- On
Bound Function<Target>(name): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Parameters
- name: CdsFunction
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnBoundFunctionDraft
Use @OnBoundFunctionDraft decorator to execute custom logic when a custom bound function event is triggered on a DRAFT resource.
- On
Bound Function Draft<Target>(name): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Parameters
- name: CdsFunction
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnCancelDraft
Use @OnCancelDraft decorator to execute custom logic when a 'draft' is cancelled.
- On
Cancel Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnCreate
Use @OnCreate decorator to execute custom logic when a new resource is created.
- On
Create(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnCreateDraft
Use @OnCreateDraft decorator to execute custom logic when a new DRAFT resource is created.
- On
Create Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnDelete
Use @OnDelete decorator to execute custom logic when a delete operation is performed.
- On
Delete(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnDeleteDraft
Use @OnDeleteDraft decorator to execute custom logic when a delete operation is performed on a DRAFT resource.
- On
Delete Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnEditDraft
Use @OnEditDraft decorator to execute custom logic when a new draft is created from an active instance.
- On
Edit Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnError
Use @OnError decorator to execute custom logic when an error occurs.
- On
Error<Target>(): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<any>) => void) Type Parameters
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<any>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<any>
Returns void
Function OnEvent
Use @OnEvent decorator to execute custom logic when a custom event is triggered.
- On
Event<Target>(name): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Parameters
- name: object
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnFunction
Use @OnFunction decorator to execute custom logic when a custom function event is triggered.
- On
Function<Target>(name): ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Parameters
- name: CdsFunction
Returns ((target: Target, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Target
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnNewDraft
Use @OnNewDraft decorator to execute custom logic when a 'draft' is created.
- On
New Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnRead
Use @OnRead decorator to execute custom logic when a read operation is performed.
- On
Read(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnReadDraft
Use @OnReadDraft decorator to execute custom logic when a read operation is performed on a DRAFT resource.
- On
Read Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnSaveDraft
Use @OnSaveDraft decorator to execute custom logic when the 'active entity' is changed.
- On
Save Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnUpdate
Use @OnUpdate decorator to execute custom logic when an update operation is performed.
- On
Update(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function OnUpdateDraft
Use @OnUpdateDraft decorator to execute custom logic when an update operation is performed on a DRAFT resource.
- On
Update Draft(): ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Returns ((target: Object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: Object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function Prepend
- Prepend(options): ((target: object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
Use
+@Prependdecorator to register an event handler to run before existing ones.Parameters
- options: PrependBase
The options object.
+
Returns ((target: object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
- options: PrependBase
Function PrependDraft
- Prepend
Draft(options): ((target: object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Use
+@PrependDraftdecorator to register an event handler to run before existing ones.Parameters
- options: PrependBaseDraft
The options object.
+
Returns ((target: object, propertyName: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyName, descriptor): void
Parameters
- target: object
- propertyName: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
- options: PrependBaseDraft
Function SingleInstanceCapable
- Single
Instance Capable<Target>(): ((target: Target, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void) Type Parameters
Returns ((target: Target, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- (target, propertyKey, descriptor): void
Parameters
- target: Target
- propertyKey: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function Use
- Use<Middleware>(...MiddlewareClasses): (<Target>(target: Target, propertyKey?: string, descriptor?: TypedPropertyDescriptor<RequestType>) => void)
Use the
+@Usedecorator to associate a method or a class with a specified middleware classes, mainly used toverify,enhance,validatevarious request related-information.Type Parameters
- Middleware extends Constructable<MiddlewareImpl>
Parameters
Rest...MiddlewareClasses: Middleware[]The middleware classes to be applied.
+
Returns (<Target>(target: Target, propertyKey?: string, descriptor?: TypedPropertyDescriptor<RequestType>) => void)
- <Target>(target, propertyKey?, descriptor?): void
Type Parameters
Parameters
- target: Target
OptionalpropertyKey: stringOptionaldescriptor: TypedPropertyDescriptor<RequestType>
Returns void
Function Validate
- Validate<T>(validator, ...fields): (<Target>(_: Target, __: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
Use
+@Validatedecorator to validate fields.Type Parameters
Parameters
- validator: Validators
The validation method to apply.
+ Rest...fields: (keyof T)[]An array of fields to validate.
+
Returns (<Target>(_: Target, __: string | symbol, descriptor: TypedPropertyDescriptor<RequestType>) => void)
- <Target>(_, __, descriptor): void
Type Parameters
Parameters
- _: Target
- __: string | symbol
- descriptor: TypedPropertyDescriptor<RequestType>
Returns void
- validator: Validators
Function Error
Function GetQuery
- Get
Query<Key>(key, property): ParameterDecorator Annotates a parameter of a method to
+gettherequest.query[INSERT, SELECT, UPDATE, UPSERT, DELETE][property]properties.Type Parameters
- Key extends CRUDQueryKeys
Parameters
- key: Key
The key indicating the type of query operation (
+INSERT,SELECT,UPDATE,UPSERT,DELETE). - property: PickQueryPropsByKey<Key>
The specific property to get within the
+request.query[key][property].
Returns ParameterDecorator
Function GetRequest
- Get
Request(property): ParameterDecorator Annotates a parameter of a method to
+gettheRequestproperties.
+NOTE:This is a convenient decorator to get only some properties of theRequestobject, to get all properties use@Req()decorator.Parameters
- property: CustomRequest
The
+Requestproperty to get.
Returns ParameterDecorator
- property: CustomRequest
Function IsColumnSupplied
- Is
Column Supplied<Key>(field): ParameterDecorator Annotates a parameter of a method to
+checkexistence ofrequest.query[INSERT, SELECT, UPSERT].columns - itemwith the value fromfieldparameter.Type Parameters
Parameters
- field: keyof Key
The name of the
+columnto verify in therequest.query[INSERT, SELECT, UPSERT].columns.
Returns ParameterDecorator
boolean
+- field: keyof Key
Function IsPresent
- Is
Present<Key>(key, property): ParameterDecorator Annotates a parameter of a method to
+checkexistence ofrequest.query[INSERT, SELECT, UPDATE, UPSERT, DELETE][property]various properties.Type Parameters
- Key extends CRUDQueryKeys
Parameters
- key: Key
The key indicating the type of query operation (
+INSERT,SELECT,UPDATE,UPSERT,DELETE). - property: PickQueryPropsByKey<Key>
The specific property to check within the
+request.query[key][property].
Returns ParameterDecorator
boolean
+
Function IsRole
- Is
Role(...roles): ParameterDecorator Annotates a parameter of a method to
+checktheexistenceof specific role values in the request.
+NOTE:IsRoleapplies a logicalORbetween the roles, meaning it checks if at least one of the specified roles exists.Parameters
Rest...roles: string[]An array of role names to verify in
+req.user.is(role).
Returns ParameterDecorator
boolean
+
Function Jwt
Function Next
Function Req
Function Res
Function Result
Function Results
\ No newline at end of file
diff --git a/lib/docs/functions/index.Inject.html b/lib/docs/functions/index.Inject.html
new file mode 100644
index 0000000..8616b7c
--- /dev/null
+++ b/lib/docs/functions/index.Inject.html
@@ -0,0 +1 @@
+
Function Inject
- Inject<T>(serviceIdentifier): ((target: DecoratorTarget<unknown>, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void)
Type Parameters
Parameters
- serviceIdentifier: ServiceIdentifierOrFunc<T>
Returns ((target: DecoratorTarget<unknown>, targetKey?: string | symbol, indexOrPropertyDescriptor?: number | TypedPropertyDescriptor<T>) => void)
- (target, targetKey?, indexOrPropertyDescriptor?): void
Parameters
- target: DecoratorTarget<unknown>
OptionaltargetKey: string | symbolOptionalindexOrPropertyDescriptor: number | TypedPropertyDescriptor<T>
Returns void
@dxfrontier/cds-ts-dispatcher
CDS-TS-Dispatcher
+
The goal of CDS-TS-Dispatcher is to significantly reduce the boilerplate code required to implement Typescript handlers provided by the SAP CAP framework.
+Table of Contents
-
+
- Table of Contents +
- Prerequisites +
- Installation + + +
- Usage
+
-
+
Architecture
+CDSDispatcher
+Decorators+-
+
Class+ +
+Field+ +
+Parameter+ +
+Method-active entity+ +
+Method-draft entity+ +
+Method-helpers+ +
+
+
+ Deploymentto BTP using MTA
+Best practices&tips
+Examples
+- Contributing +
- License +
- Authors +
Prerequisites
Install @sap/cds-dk, typescript, ts-node globally:
npm install -g @sap/cds-dk typescript ts-node
+Installation
Option 1 : Install CDS-TS-Dispatcher - New project
Use the following steps if you want to create a new SAP CAP project.
+-
+
- Create new folder : +
mkdir new-sap-cap-project
cd new-sap-cap-project
+-
+
- Initialize the CDS folder structure : +
cds init
+-
+
- Add CDS-Typer to your npm package.json: +
cds add typer
npm install
+-
+
- Add the the following NPM packages : +
npm install @dxfrontier/cds-ts-dispatcher
npm install --save-dev @types/node
+-
+
- Add a tsconfig.json : +
tsc --init
+-
+
- It is recommended to use the following tsconfig.json properties: +
{
"compilerOptions": {
/* Base Options: */
"esModuleInterop": true,
"skipLibCheck": true,
"allowJs": true,
"strictPropertyInitialization": false,
"forceConsistentCasingInFileNames": true,
"allowSyntheticDefaultImports": true,
"strictNullChecks": true,
"target": "ES2022",
"module": "NodeNext",
"moduleResolution": "NodeNext",
/* Allow decorators */
"experimentalDecorators": true,
"emitDecoratorMetadata": true,
/* Strictness */
"strict": true,
"lib": ["es2022"],
"outDir": "./gen/srv"
},
"include": ["./srv"]
}
+-
+
- Run the
CDS-TSserver
+
cds-ts watch
+Option 2 : Install CDS-TS-Dispatcher - Existing project
Use the following steps if you want to add only the @dxfrontier/cds-ts-dispatcher to an existing project :
+npm install @dxfrontier/cds-ts-dispatcher
+It is recommended to use the following tsconfig.json properties:
+{
"compilerOptions": {
/* Base Options: */
"esModuleInterop": true,
"skipLibCheck": true,
"allowJs": true,
"strictPropertyInitialization": false,
"forceConsistentCasingInFileNames": true,
"allowSyntheticDefaultImports": true,
"strictNullChecks": true,
"target": "ES2022",
"module": "NodeNext",
"moduleResolution": "NodeNext",
/* Allow decorators */
"experimentalDecorators": true,
"emitDecoratorMetadata": true,
/* Strictness */
"strict": true,
"lib": ["es2022"],
"outDir": "./gen/srv"
},
"include": ["./srv"]
}
+++ +[!WARNING] +If below message appears
++ +-----------------------------------------------------------------------
WARNING: Package '@sap/cds' was loaded from different installations: [
'***/node_modules/@sap/cds/lib/index.js',
'***/node_modules/@dxfrontier/cds-ts-dispatcher/node_modules/@sap/cds/lib/index.js'
] Rather ensure a single install only to avoid hard-to-resolve errors.
----------------------------------------------------------------------- +Run the following command :
++ +npm install @sap/cds@latest +
Option 3 : Install CDS-TS-Dispatcher - .devcontainer on VSCode & Docker
The CDS-TS-Dispatcher dev container repository contains the CDS-TS-Dispatcher & CDS-TS-Repository and all dependencies needed to boot a new project :
Tools installed inside of the container :
-
+
Controller-Service-Repositoryproject structure folders : +-
+
controller
+service
+repository
+middleware
+util
+test
+
+ESLint,Prettier
+VSCode Extensionsbest extensions for SAP CAP TypeScript development
+Cloud MTA Build toolfor buildingMTA file
+Cloud Foundry CLI (CF)
+Git,Cds,Npm,Node
+CDS-Typerfor building typescript entities out ofCDS files
+tsconfig.json, .eslintrc, .prettierrc- predefined properties
+package.json- predefinedscripts
+
Steps
-
+
- Install Docker desktop +
- Clone CDS-TS-Dispatcher devcontainer using below command : +
git clone https://github.com/dxfrontier/cds-ts-dispatcher-dev-container
+-
+
- Open project in
VSCodeusing:
+
code cds-ts-dispatcher-dev-container
+-
+
- Change GIT remote origin to your origin +
git remote remove origin
git remote add origin https://github.com/user/YOUR_GIT_REPOSITORY.git
git branch -M main
git push -u origin main
+-
+
-
+
Install Remote development pack VScode extension
+
+ -
+
COMMAND + SHIFT + P on
+MacOSor CTRL + SHIFT + P onWindows-
+
- Type -
Rebuild and Reopen in Container- This step will start creating the container project and start the Node server.
+
+ - Type -
-
+
Start development as usual.
+
+
Generate CDS Typed entities
Option 1 - Recommended
Execute the following commands :
+cds add typer
+npm install
+++ +[!TIP] +If above option is being used, this means whenever we change a
+.CDSfile the changes will reflect in the generated@cds-modelsfolder.
Option 2
Execute the command :
+npx @cap-js/cds-typer "*" --outputDirectory ./srv/util/types/entities
+-
+
- Target folder :
./srv/util/types/entities- Change to your desired destination folder.
+
Important
++[!CAUTION] +Import always the
+generated entitiesfrom theservicefolders and not from theindex.ts
++ +[!TIP] +By default cds-typer will create in your
+package.jsona quick path alias like :+ +"imports": {
"#cds-models/*": "./@cds-models/*/index.js"
} +Use import helper to import entities from
+#cds-modelslike example :+
+- +
import { Book } from '#cds-models/CatalogService';
Usage
Architecture
We recommend adhering to the Controller-Service-Repository design pattern using the following folder structure:
+-
+
- EntityHandler
(Controller)- Responsible for managing the REST interface to the business logic implemented in ServiceLogic
+ - ServiceLogic
(Service)- Contains business logic implementations
+ - Repository
(Repository)- This component is dedicated to handling entity manipulation operations by leveraging the power of CDS-QL.
+
Controller-Service-Repository suggested folder structure
<= expanded folders => 
CDSDispatcher
CDSDispatcher(entities : Constructable[])
The CDSDispatcher constructor allows you to create an instance for dispatching and managing entities.
Parameters
-
+
entities (Array): An array of Entity handler(s) (Constructable) that represent the entities in the CDS.
+
Method
-
+
initialize: Theinitializemethod of theCDSDispatcherclass is used to initialize Entity handler(s) and all of their dependencies : Services, Repositories, UnboundActions
+
Example
import { CDSDispatcher } from '@dxfrontier/cds-ts-dispatcher';
export = new CDSDispatcher([
// Entities
BookHandler,
ReviewHandler,
BookStatsHandler,
// Draft
BookEventsHandler,
// Unbound actions
UnboundActionsHandler,
]).initialize();
// or use
// module.exports = new CDSDispatcher([ ...
+Visual image
+
+Decorators
Class
@EntityHandler
The @EntityHandler decorator is utilized at the class-level to annotate a class with:
-
+
- A specific
entitythat will serve as the base entity for all handler decorators within the class.
+ '*'asall entitiesthat will serve as the base entity for all handler decorators within the class.
+
Overloads
| Method | +Parameters | +Description | +
|---|---|---|
1. EntityHandler(entity: CDSTyper) |
+Must be a CDS-Typer generated class |
+It ensures that all handlers within the class operate with the specified entity context. |
+
2. EntityHandler(entity: '*') |
+A wildcard '*' indicating all entities |
+It ensures that all handlers within the class operate with a generic context indicating that registered events will be triggered for all all entities (active entities and draft entities) Excluded will be @OnAction(), @OnFunction(), @OnEvent(), @OnError() as these actions belongs to the Service itself. |
+
Parameters
-
+
entity (CDSTyperEntity | '*'): A specialized class generated using the CDS-Typer or generic wild card'*'applicable to all entities.
+
Example 1 using CDS-Typer
import { EntityHandler } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@EntityHandler(MyEntity)
export class BookHandler {
// ...
constructor() {}
// All events like @AfterRead, @BeforeRead, ... will be triggered based on 'MyEntity'
}
+Example 2 using * wildcard indicating that events will be triggered for all entities
import { EntityHandler, CDS_DISPATCHER } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@EntityHandler(CDS_DISPATCHER.ALL_ENTITIES) // or use the '*'
export class BookHandler {
// ...
constructor() {}
// All events like @AfterRead, @BeforeRead, ... will be triggered on all entities using wildcard '*'
}
+++[!TIP] +After creation of
+BookHandlerclass, you canimport itinto the CDSDispatcher.+ +import { CDSDispatcher } from '@dxfrontier/cds-ts-dispatcher';
export = new CDSDispatcher([
// Entities
BookHandler,
// Unbound actions
// ...
]).initialize(); +
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the class.
+
@ServiceLogic
@ServiceLogic()
+The @ServiceLogic decorator is utilized at the class-level to annotate a class as a specialized class containing only business logic.
Example
import { ServiceLogic } from '@dxfrontier/cds-ts-dispatcher';
@ServiceLogic()
export class CustomerService {
// ...
constructor() {}
// ...
}
+++ +[!TIP] +When applying
+@ServiceLogic()decorator, the class becomes eligible to be used with Inject decorator forDependency injection.
@Repository
@Repository()
+The @Repository decorator is utilized as a class-level annotation that designates a particular class as a specialized Repository, this class should contain only CDS-QL code.
import { Repository } from '@dxfrontier/cds-ts-dispatcher';
@Repository()
export class CustomerRepository {
// ...
constructor() {}
// ...
}
+++[!TIP] +When applying
+@Repository()decorator, the class becomes eligible to be used with Inject decorator forDependency injection.
[Optional] - CDS-TS-Repository - BaseRepository
The CDS-TS-Repository - BaseRepository was designed to reduce the boilerplate code required to implement data access layer for persistance entities.
+It simplifies the implementation by offering a set of ready-to-use actions for interacting with the database. These actions include:
+-
+
.create(): Create new records in the database.
+.getAll(): Retrieve all records from the database.
+.find(): Query the database to find specific data.
+.delete(): Remove records from the database.
+.exists(): Check the existence of data in the database.
+- and many more ... +
Example
import { Repository } from '@dxfrontier/cds-ts-dispatcher';
import { BaseRepository } from '@dxfrontier/cds-ts-repository';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@Repository()
export class CustomerRepository extends BaseRepository<MyEntity> {
constructor() {
super(MyEntity);
}
public async aMethod() {
const created = await this.create(...)
const createdMany = await this.createMany(...)
const updated = await this.update(...)
// ...
}
}
+To get started, refer to the official documentation CDS-TS-Repository - BaseRepository. +Explore the capabilities it offers and enhance your data access layer with ease.
+++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the class.
+
@UnboundActions
@UnboundActions()
+The @UnboundActions decorator is utilized at the class-level to annotate a class as a specialized class which will be used only for Unbound actions.
The following decorators can be used inside of @UnboundActions() :
Example
import { UnboundActions, OnAction, OnFunction, OnEvent, Req, Next, Error } from '@dxfrontier/cds-ts-dispatcher';
import { MyAction, MyFunction, MyEvent } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { ActionRequest, ActionReturn, TypedRequest, Request, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
@UnboundActions()
export class UnboundActionsHandler {
// ... @Inject dependencies, if needed.
constructor() {}
// Unbound action
@OnAction(MyAction)
private async onActionMethod(
@Req() req: ActionRequest<typeof MyAction>,
@Next() next: NextEvent,
): ActionReturn<typeof MyAction> {
// ...
}
// Unbound Function
@OnFunction(MyFunction)
private async onFunctionMethod(
@Req() req: ActionRequest<typeof MyFunction>,
@Next() next: NextEvent,
): ActionReturn<typeof MyFunction> {
// ...
}
// Unbound event
@OnEvent(MyEvent)
private async onEventMethod(@Req() req: TypedRequest<MyEvent>) {
// ...
}
// Unbound error
@OnError()
private onErrorMethod(@Error() err: Error, @Req() req: Request) {
// ...
}
}
+Imported it in the CDSDispatcher
import { CDSDispatcher } from '@dxfrontier/cds-ts-dispatcher';
export = new CDSDispatcher([ UnboundActionsHandler, ...])
// or
// use module.exports = new CDSDispatcher( ... )
+++ +[!NOTE] +The reason behind introducing a distinct decorator for
+Unbound actionsstems from the fact that these actions are not associated with any specificEntitybut instead these actions belongs to the Service itself.
@Use
@Use(...Middleware[])
The @Use decorator simplifies the integration of middlewares into your classes.
When @Use decorator applied at the class-level this decorator inject middlewares into the class and gain access to the req: Request and next: NextMiddleware middleware across all events (@AfterRead, @OnRead ...) within that class.
Middleware decorators can perform the following tasks:
+-
+
- Execute any code. +
- Make changes to the request object. +
- End the request-response cycle. +
- Call the next middleware function in the stack. +
- If the current middleware function does not end the request-response cycle, it must call
next()to pass control to the next middleware function. Otherwise, the request will be left hanging.
+
Parameters
-
+
...Middleware[]): Middleware classes to be injected.
+
Example: middleware implementation
import type { MiddlewareImpl, NextMiddleware, Request } from '@dxfrontier/cds-ts-dispatcher';
export class MiddlewareClass implements MiddlewareImpl {
public async use(req: Request, next: NextMiddleware) {
console.log('Middleware use method called.');
await next(); // call next middleware
}
}
+Example usage
import { EntityHandler, Use, Inject, CDS_DISPATCHER } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import { Middleware1, Middleware2, MiddlewareN } from 'YOUR_MIDDLEWARE_LOCATION';
import type { Service } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
@Use(Middleware1, Middleware2, MiddlewareN)
export class CustomerHandler {
// ...
@Inject(CDS_DISPATCHER.SRV) private srv: Service;
// ...
constructor() {}
// ...
}
+++[!TIP]
++
+- Think of it (middleware) like as a reusable class, enhancing the functionality of all events within the class.
+- Middlewares when applied with
+@Useare executed before the normal events.- If you need to apply middleware to a
+methodyou should use the method specific @Use decorator .
++[!WARNING] +If
+req.reject()is used inside of middleware this will stop the stack of middlewares, this means that next middleware will not be executed.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the class.
+
Field
@Inject
@Inject(serviceIdentifier: ServiceIdentifierOrFunc<unknown>)
The @Inject decorator is utilized as a field-level decorator and allows you to inject dependencies into your classes.
Parameters
-
+
serviceIdentifier(ServiceIdentifierOrFunc<unknown>): A Class representing the service to inject.
+
Example
import { EntityHandler, Inject, CDS_DISPATCHER } from "@dxfrontier/cds-ts-dispatcher";
import type { Service } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@EntityHandler(MyEntity)
export class CustomerHandler {
...
@Inject(CustomerService) private customerService: CustomerService
@Inject(CustomerRepository) private customerService: CustomerRepository
@Inject(AnyOtherInjectableClass) private repository: AnyOtherInjectableClass
@Inject(CDS_DISPATCHER.SRV) private srv: Service
// ...
constructor() {}
// ...
}
+++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the class.
+
@Inject(CDS_DISPATCHER.SRV)
@Inject(CDS_DISPATCHER.SRV) private srv: Service
This specialized @Inject can be used as a constant in and contains the CDS.ApplicationService for further enhancements :
Example
import { EntityHandler, Inject, CDS_DISPATCHER } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Service } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
// OR @ServiceLogic()
// OR @Repository()
// OR @UnboundActions()
export class CustomerHandler {
// @Inject dependencies
@Inject(CDS_DISPATCHER.SRV) private srv: Service;
constructor() {}
// ...
}
+++[!TIP] +The CDS.ApplicationService can be accessed trough
+this.srv.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
Parameter
@Req
@Req()
+The @Req decorator is utilized at the parameter level to annotate a parameter with the Request object, providing access to request-related information of the current event.
Return
-
+
Request: An instance of@sap/cds-Request
+
Example
import { EntityHandler, Req, Results } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
export class BookHandler {
// ...
constructor() {}
// ... all events like @AfterRead, @BeforeRead ...
@AfterRead()
private async aMethod(@Req() req: Request, @Results() results: MyEntity[]) {
// ... req...
}
}
+@Res
@Res()
+The @Res decorator is utilized at the parameter level to annotate a parameter with the Request.http.res - (Response) object, providing access to response-related information of the current event and it can be used to enhance the Response.
Return
-
+
RequestResponse: An instance ofRequestResponseproviding you response-related information.
+
Example
import { EntityHandler, Req, Results } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request, RequestResponse } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
export class BookHandler {
// ...
constructor() {}
// ... all events like @AfterRead, @BeforeRead ...
@AfterRead()
private async aMethod(@Req() req: Request, @Res() response: RequestResponse, @Results() results: MyEntity[]) {
// Example: we assume we want to add a new header language on the response
// We use => res.setHeader('Accept-Language', 'DE_de');
}
}
+++ +[!TIP] +Decorator
+@Rescan be used in all After, Before and On events.
@Results / @Result
@Results() / @Result
+The @Results decorator is utilized at the parameter level to annotate a parameter with the request Results.
Return
-
+
Array / object: Contains the OData RequestBody.
+
Example
import { EntityHandler, Req, Results } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
export class BookHandler {
// ...
constructor() {}
// ... all events like @AfterRead, @BeforeRead ...
@AfterRead()
private async aMethod(@Req() req: Request, @Results() results: MyEntity[]) {
// ...
}
}
+++[!TIP] +When using @AfterCreate(), @AfterUpdate() and @AfterDelete() it's recommended to use the
+@Resultdecorator for single object result and@Resultsfor arrays of objects.
@AfterCreate()
@AfterUpdate()
private async aMethod(
@Result() result: Book, // <== @Result() decorator used to annotate it's a an object and not an array
@Req() req: Request,
) {
// ...
}
@AfterRead()
private async aMethod(
@Results() result: Book[], // <== @Results() decorator used to annotate as array of objects
@Req() req: Request,
) {
// ...
}
@AfterDelete()
private async aMethod(
@Result() deleted: boolean, // <== @Result() decorator used to annotate as a boolean
@Req() req: Request,
) {
// ...
}
+++ +[!TIP] +Decorators
+@Results()and@Result()can be applied to all After events.
@Next
@Next()
+The @Next decorator is utilized at the parameter level to annotate a parameter with the Next function, which is used to proceed to the next event in the chain of execution.
Return
-
+
NextEvent: The next event in chain to be called.
+
Example
import { EntityHandler, Req, Results } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
export class BookHandler {
// ...
constructor() {}
// ... all events like @AfterRead, @BeforeRead, @OnCreate ...
@OnCreate()
public async onCreate(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
return next();
}
}
+++ +[!TIP] +Decorator
+@Nextcan be applied to all On, On - draft event decorators.
@Error
@Error()
+The @Error decorator is utilized at the parameter level to annotate a parameter with the Error and contains information regarding the failed Request.
Return
-
+
Error: An instance of typeError.
+
Example
import { UnboundActions, Req, Error } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@UnboundActions()
export class UnboundActionsHandler {
// ...
constructor() {}
@OnError()
public onError(@Error() err: Error, @Req() req: Request): void {
// ...
}
}
+++[!TIP] +Decorator
+@Errorcan be applied to @OnError() decorator which resides inside of the @UnboundActions().
@Jwt
@Jwt()
+The @Jwt decorator is utilized at the parameter level. It will retrieve the to retrieve JWT from the Request that is based on the node req.http.req - IncomingMessage.
Fails if no authorization header is given or has the wrong format.
+Return
-
+
string|undefined: The retrievedJWT tokenor undefined if no token was found.
+
Example
import { EntityHandler, Req, Results, Jwt } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
export class BookHandler {
// ...
constructor() {}
// ... all events like @AfterRead, @BeforeRead ...
@AfterRead()
private async aMethod(@Req() req: Request, @Results() results: MyEntity[], @Jwt(): string | undefined) {
// ... req...
}
}
+++ +[!IMPORTANT] +Expected format is
+Bearer <TOKEN>.
@IsPresent
@IsPresent<Key extends CRUDQueryKeys>(key: Key, property: PickQueryPropsByKey<Key>)
+The @IsPresent decorator is utilized at the parameter level. It allows you to verify the existence of a specified Query property values.
Parameters
-
+
key (string): Specifies the type of query operation. Accepted values areINSERT,SELECT,UPDATE,UPSERT,DELETE.
+property (string): Specifies the property based on thekey.
+
Return
-
+
boolean: This decorator returnstrueifpropertyvalueis filled,falseotherwise
+
Example
import { EntityHandler, Req, Results, IsPresent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
class BookHandler {
// ...
constructor() {}
@AfterRead()
private async aMethod(
@Req() req: Request,
@Results() results: MyEntity[],
@IsPresent('SELECT', 'columns') columnsPresent: boolean,
) {
if (columnsPresent) {
// ...
}
// ...
}
}
+++ +[!TIP] +Decorator @IsPresent() works well with @GetQuery().
+
@IsRole
@IsRole(...roles: string[])
+The @IsRole decorator is utilized at the parameter level. It allows you to verify
+if the User has assigned a given role.
It applies an logical OR on the specified roles, meaning it checks if at least one of the specified roles is assigned
Parameters
-
+
role (...string[]): An array of role names to check if are assigned.
+
Return
-
+
boolean: This decorator returnstrueif at least one of the specified roles is assigned to the current request user, otherwisefalse.
+
Example
import { EntityHandler, Req, Results, IsPresent, IsRole } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
class BookHandler {
// ...
constructor() {}
@AfterRead()
private async aMethod(
@Req() req: Request,
@Results() results: MyEntity[],
@IsRole('role', 'anotherRole') roleAssigned: boolean,
) {
if (roleAssigned) {
// ...
}
// ...
}
}
+++ +[!TIP] +The role names correspond to the values of
+@requiresand the@restrict.grants.toannotations in yourCDSmodels.
@IsColumnSupplied
@IsColumnSupplied<T>(field : keyof T)
+The @IsColumnSupplied<T>() decorator is utilized at the parameter level. It allows your to verify the existence of a column in the SELECT, INSERT or UPSERT Query.
Parameters
-
+
column (string): A string representing the name of the column to be verified.
+
Return :
-
+
boolean: This decorator returnstrueifcolumnwas found,falseotherwise
+
Example
import { EntityHandler, Req, Results, IsPresent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
class BookHandler {
// ...
constructor() {}
@AfterRead()
private async aMethod(
@Req() req: Request,
@Results() results: MyEntity[],
@IsColumnSupplied<MyEntity>('price') priceSupplied: boolean,
) {
if (priceSupplied) {
// ...
}
// ...
}
}
+@GetQuery
@GetQuery<Key extends CRUDQueryKeys>(key: Key, property: PickQueryPropsByKey<Key>)
+The @GetQuery decorator is utilized at the parameter level. It allows you to retrieve Query property values.
Parameters
-
+
key (string): Specifies the type of query operation. Accepted values areINSERT,SELECT,UPDATE,UPSERT,DELETE.
+property (string): Specifies the property based on thekey.
+
Return: Varies based on the specified property :
-
+
-
+++
SELECT
+-
+
- @GetQuery(
'SELECT','columns') columns:GetQueryType['columns']['forSelect']
+ - @GetQuery(
'SELECT','distinct') distinct:GetQueryType['distinct']
+ - @GetQuery(
'SELECT','excluding') excluding:GetQueryType['excluding']
+ - @GetQuery(
'SELECT','from') from:GetQueryType['from']['forSelect']
+ - @GetQuery(
'SELECT','groupBy') groupBy:GetQueryType['groupBy']
+ - @GetQuery(
'SELECT','having') having:GetQueryType['having']
+ - @GetQuery(
'SELECT','limit') limit:GetQueryType['limit']
+ - @GetQuery(
'SELECT','limit.rows') limitRows:GetQueryType['limit']['rows']
+ - @GetQuery(
'SELECT','limit.offset') limitOffset:GetQueryType['limit']['offset']
+ - @GetQuery(
'SELECT','mixin') mixin:GetQueryType['mixin']
+ - @GetQuery(
'SELECT','one') one:GetQueryType['one']
+ - @GetQuery(
'SELECT','orderBy') orderBy:GetQueryType['orderBy']
+ - @GetQuery(
'SELECT','where') where:GetQueryType['where']
+
+ - @GetQuery(
-
+++
INSERT
+-
+
- @GetQuery(
'INSERT','as') as:GetQueryType['as']
+ - @GetQuery(
'INSERT','columns') columns:GetQueryType['columns']['forInsert']
+ - @GetQuery(
'INSERT','entries') entries:GetQueryType['entries']
+ - @GetQuery(
'INSERT','into') into:GetQueryType['into']
+ - @GetQuery(
'INSERT','rows') rows:GetQueryType['rows']
+ - @GetQuery(
'INSERT','values') values:GetQueryType['values']
+
+ - @GetQuery(
-
+++
UPDATE
+-
+
- @GetQuery(
'UPDATE','data') data:GetQueryType['data']
+ - @GetQuery(
'UPDATE','entity') entity:GetQueryType['entity']
+ - @GetQuery(
'UPDATE','where') where:GetQueryType['where']
+
+ - @GetQuery(
-
+++
UPSERT
+-
+
- @GetQuery(
'UPSERT','columns') columns:GetQueryType['columns'][forUpsert]
+ - @GetQuery(
'UPSERT','entries') entries:GetQueryType['entries']
+ - @GetQuery(
'UPSERT','into') into:GetQueryType['into']
+ - @GetQuery(
'UPSERT','rows') rows:GetQueryType['rows']
+ - @GetQuery(
'UPSERT','values') values:GetQueryType['values']
+
+ - @GetQuery(
-
+++
DELETE
+-
+
-
+
@GetQuery(
+'DELETE','from') from:GetQueryType['from'][forDelete]
+ -
+
@GetQuery(
+'DELETE','where') columns:GetQueryType['where']
+ -
+
Example
import { EntityHandler, Req, Results, IsPresent, GetQuery } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { Request, GetQueryType } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
class BookHandler {
// ...
constructor() {}
@AfterRead()
private async aMethod(
@Req() req: Request,
@Results() results: MyEntity[],
// Check existence of columns
@IsPresent('SELECT', 'columns') columnsPresent: boolean,
// Get columns
@GetQuery('SELECT', 'columns') columns: GetQueryType['columns']['forSelect'],
@GetQuery('SELECT', 'orderBy') orderBy: GetQueryType['orderBy'],
@GetQuery('SELECT', 'groupBy') groupBy: GetQueryType['groupBy'],
) {
if (columnsPresent) {
// do something with columns values
// columns.forEach(...)
}
// ...
}
}
+++ +[!TIP] +Decorator @GetQuery() can be used to get the Query property and @IsPresent() can check if the Query property is empty or not.
+
@GetRequest
@GetRequest(property : keyof Request)
+The @GetRequest decorator is utilized at the parameter level. It allows you tu retrieve the specified property value from the Request object.
Parameters
-
+
property (string): Specifies the property to retrieve from theRequestobject.
+
Return: Varies based on the specified property :
-
+
- @GetRequest(
'entity') entity:Request['entity'],
+ - @GetRequest(
'event') event:Request['event'],
+ - @GetRequest(
'features') features:Request['features'],
+ - @GetRequest(
'headers') headers:Request['headers'],
+ - @GetRequest(
'http') http:Request['http'],
+ - @GetRequest(
'id') id:Request['id'],
+ - @GetRequest(
'locale') locale:Request['locale'],
+ - @GetRequest(
'method') method:Request['method'],
+ - @GetRequest(
'params') params:Request['params'],
+ - @GetRequest(
'query') query:Request['query'],
+ - @GetRequest(
'subject') subject:Request['subject'],
+ - @GetRequest(
'target') target:Request['target'],
+ - @GetRequest(
'tenant') tenant:Request['tenant'],
+ - @GetRequest(
'timestamp') timestamp:Request['timestamp'],
+ - @GetRequest(
'user') user:Request['user'],
+
Example
import { EntityHandler, Results, GetRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
import type { GetTypeLocale, GetTypeMethod, Request } from '@dxfrontier/cds-ts-dispatcher';
@EntityHandler(MyEntity)
class BookHandler {
// ...
constructor() {}
@AfterRead()
private async aMethod(
// @Req() req: Request, we assume we don't need the hole Request object and we need only 'locale' and 'method'
@Results() results: MyEntity[],
@GetRequest('locale') locale: Request['locale'],
@GetRequest('method') method: Request['method'],
) {
// do something with 'locale' and 'method' ...
}
}
+++ +[!TIP] +Type
+Requestcan be import from :+ +import type { Request } from '@dxfrontier/cds-ts-dispatcher'; +
@SingleInstanceSwitch
@SingleInstanceSwitch
+The @SingleInstanceSwitch() decorator is applied at the parameter level.
It allows you to manage different behaviors based on whether the request is for a single entity instance or an entity set, the parameter assigned to the decorator will behave like a switch.
Return
-
+
truewhen theRequestissingle instance
+falsewhen theRequestisentity set
+
Example 1
Single request : http://localhost:4004/odata/v4/main/`MyEntity(ID=2f12d711-b09e-4b57-b035-2cbd0a023a09)`
+import { AfterRead, SingleInstanceCapable } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterRead()
private async singeInstanceMethodAndEntitySet(@Results() results : MyEntity[], @Req() req: TypedRequest<MyEntity>, @SingleInstanceSwitch() isSingleInstance: boolean) {
if(isSingleInstance) {
// This will be executed only when single instance is called : http://localhost:4004/odata/v4/main/MyEntity(ID=2f12d711-b09e-4b57-b035-2cbd0a023a09)
return this.customerService.handleSingleInstance(req)
}
// nothing to entity set
}
+Example 2
Entity request : http://localhost:4004/odata/v4/main/`MyEntity`
+import { AfterRead, SingleInstanceCapable } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterRead()
private async singeInstanceMethodAndEntitySet(@Results() results : MyEntity[], @Req() req: TypedRequest<MyEntity>, @SingleInstanceSwitch() isSingleInstance: boolean) {
if(isSingleInstance) {
// This will be executed only when single instance is called : http://localhost:4004/odata/v4/main/MyEntity(ID=2f12d711-b09e-4b57-b035-2cbd0a023a09)
// ...
}
// ... this will be executed when entity set is called : http://localhost:4004/odata/v4/main/MyEntity
results[0] = {
name : 'new value'
}
}
+++[!TIP] +Decorator
+ +@SingleInstanceSwitchcan be used together with the following decorator events:
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
Method-active entity
Before
Use @BeforeCreate(), @BeforeRead(), @BeforeUpdate(), @BeforeDelete() to register handlers to run before .on handlers, frequently used for validating user input.
The handlers receive one argument:
+-
+
reqof typeTypedRequest
+
See also the official SAP JS CDS-Before event
+++ +[!TIP] +If
+@odata.draft.enabled: trueto manage event handlers for draft version you can use+
+- +
@BeforeCreateDraft()- +
@BeforeReadDraft()- +
@BeforeUpdateDraft()- +
@BeforeDeleteDraft()
@BeforeCreate
@BeforeCreate()
+Example
import { BeforeCreate } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeCreate()
private async beforeCreateMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('CREATE', MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +It is important to note that the decorator
+@BeforeCreate()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@BeforeRead
@BeforeRead()
+Example
import { BeforeRead } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeRead()
private async beforeReadMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('READ', MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeRead()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@BeforeUpdate
@BeforeUpdate()
+Example
import { BeforeUpdate } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeUpdate()
private async beforeUpdateMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('UPDATE', MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeUpdate()will be triggered based on the EntityHandlerargument=>MyEntity
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@BeforeDelete
@BeforeDelete()
+Example
import { BeforeDelete } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeDelete()
private async beforeDeleteMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('DELETE', MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeDelete()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@BeforeAll
The @BeforeAll decorator is triggered whenever any CRUD (Create, Read, Update, Delete) event occurs, whether the entity is active or in draft mode.
ACTIVE ENTITY
For active entities, the @BeforeAll decorator will be triggered when at least one of the following events occurs:
+-
+
CREATE@BeforeCreate(), @AfterCreate(), @OnCreate()
+READ@BeforeRead(), @AfterRead(), @OnRead()
+UPDATE@BeforeUpdate(), @AfterUpdate(), @OnUpdate()
+DELETE@BeforeDelete(), @AfterDelete(), @OnDelete()
+BOUND ACTIONS@OnBoundAction()
+BOUND FUNCTIONS@OnBoundFunction()
+
DRAFT
For draft entities, the @BeforeAll decorator will be triggered when at least one of the following events occurs:
+-
+
CREATE@BeforeNewDraft(), @AfterNewDraft(), @OnNewDraft()
+CANCEL@BeforeCancelDraft(), @AfterCancelDraft(), @OnCancelDraft()
+EDIT@BeforeEditDraft(), @AfterEditDraft(), @OnEditDraft()
+SAVE@BeforeSaveDraft(), @AfterSaveDraft(), @OnSaveDraft()
+- :heavy_plus_sign: All active entity Before, After, On events which have a
Draftvariant.
+
@BeforeAll()
+Example
import { BeforeAll } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeAll()
private async beforeAllEvents(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('*', MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeAll()will be triggered based on the EntityHandlerargument=>MyEntity.
++[!TIP] +If the entity has drafts enabled
+@odata.draft.enabled: true, the@BeforeAlldecorator will still be triggered for draft events.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
After
Use @AfterCreate(), @AfterRead(), @AfterUpdate(), @AfterDelete() register handlers to run after the .on handlers, frequently used to enrich outbound data.
The handlers receive two arguments:
+| Parameters | +Decorator | +Description | +
|---|---|---|
results, req |
+@AfterRead |
+An array of type MyEntity[] and the Request. |
+
result, req |
+@AfterUpdate@AfterCreate |
+An object of type MyEntity and the Request. |
+
deleted, req |
+@AfterDelete |
+A boolean indicating whether the instance was deleted and the Request. |
+
++ +[!TIP] +If
+@odata.draft.enabled: trueto manage event handlers for draft version you can use :+
+- +
@AfterCreateDraft()- +
@AfterReadDraft()- +
@AfterReadDraftSingleInstance()- +
@AfterUpdateDraft()- +
@AfterDeleteDraft()
@AfterCreate
@AfterCreate()
+Example
import { AfterCreate } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterCreate()
private async afterCreateMethod(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('CREATE', MyEntity, async (result, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterCreate()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterRead
@AfterRead()
+Example
import { AfterRead, Results, Req } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterRead()
private async afterReadMethod(@Results() results: MyEntity[], @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('READ', MyEntity, async (results, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterRead()will be triggered based on the EntityHandlerargumentMyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterReadEachInstance
@AfterReadEachInstance()
+The @AfterReadEachInstance decorator is used to execute custom logic after performing a read operation on each individual instance. This behavior is analogous to the JavaScript Array.prototype.forEach method.
Example
import { AfterReadEachInstance, Result, Req } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterReadEachInstance()
private async afterEach(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('each', MyEntity, async (result, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterReadEachInstance()will be triggered based on the EntityHandlerargumentMyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterUpdate
@AfterUpdate()
+Example
Single request : http://localhost:4004/odata/v4/main/`MyEntity(ID=2f12d711-b09e-4b57-b035-2cbd0a023a09)`
+import { AfterUpdate } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterUpdate()
private async afterUpdateMethod(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('UPDATE', MyEntity, async (result, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterUpdate()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterDelete
@AfterDelete()
+Example
import { AfterDelete} from "@dxfrontier/cds-ts-dispatcher";
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterDelete()
private async afterDeleteMethod(@Result() deleted: boolean, @Req() req: Request) {
// ...
}
+Equivalent to 'JS'
this.after('DELETE', MyEntity, async (deleted, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterDelete()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterAll
The @AfterAll decorator is triggered whenever any CRUD (Create, Read, Update, Delete) event occurs, whether the entity is active or in draft mode.
ACTIVE ENTITY
For active entities, the @BeforeAll decorator will be triggered when at least one of the following events occurs:
+-
+
CREATE@BeforeCreate(), @AfterCreate(), @OnCreate()
+READ@BeforeRead(), @AfterRead(), @OnRead()
+UPDATE@BeforeUpdate(), @AfterUpdate(), @OnUpdate()
+DELETE@BeforeDelete(), @AfterDelete(), @OnDelete()
+BOUND ACTIONS@OnBoundAction()
+BOUND FUNCTIONS@OnBoundFunction()
+
DRAFT
For draft entities, the @BeforeAll decorator will be triggered when at least one of the following events occurs:
+-
+
CREATE@BeforeNewDraft(), @AfterNewDraft(), @OnNewDraft()
+CANCEL@BeforeCancelDraft(), @AfterCancelDraft(), @OnCancelDraft()
+EDIT@BeforeEditDraft(), @AfterEditDraft(), @OnEditDraft()
+SAVE@BeforeSaveDraft(), @AfterSaveDraft(), @OnSaveDraft()
+- :heavy_plus_sign: All active entity Before, After, On events which have a
Draftvariant.
+
@AfterAll()
+Example
import { AfterAll} from "@dxfrontier/cds-ts-dispatcher";
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterAll()
private async afterAll(@Result() result: MyEntity | MyEntity[] | boolean, @Req() req: Request) {
if(Array.isArray(result)) {
// when after `READ` event was triggered
}
else if(typeof result === 'boolean' ) {
// when after `DELETE` event was triggered
}
else {
// when after `CREATE`, `UPDATE` was triggered
}
// ...
}
+Equivalent to 'JS'
this.after('*', MyEntity, async (result, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterAll()will be triggered based on the EntityHandlerargument=>MyEntity.
++[!TIP] +If the entity has drafts enabled
+@odata.draft.enabled: true, the@AfterAlldecorator will still be triggered for draft events.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
On
Use @OnCreate(), @OnRead(), @OnUpdate(), @OnDelete(), OnAction(), @OnFunction(), @OnBoundAction(), @OnBoundFunction() handlers to fulfill requests, e.g. by reading/writing data from/to databases handlers.
+The handlers receive two arguments:
+-
+
reqof typeTypedRequest
+nextof typeNextEvent
+
++ +[!TIP] +If
+@odata.draft.enabled: trueto manage event handlers for draft version you can use :+
+- +
@OnCreateDraft()- +
@OnReadDraft()- +
@OnUpdateDraft()- +
@OnDeleteDraft()- +
@OnBoundActionDraft()- +
@OnBoundFunctionDraft()
@OnCreate
@OnCreate()
+Example
import { OnCreate, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnCreate()
private async onCreateMethod(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
+Equivalent to 'JS'
this.on('CREATE', MyEntity, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnCreate()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnRead
@OnRead()
+Example
import { OnRead, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnRead()
private async onReadMethod(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
+Equivalent to 'JS'
this.on('READ', MyEntity, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnRead()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnUpdate
@OnUpdate()
+Example
import { OnUpdate, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnUpdate()
private async onUpdateMethod(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
+Equivalent to 'JS'
this.on('UPDATE', MyEntity, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnUpdate()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnDelete
@OnDelete()
+Example
import { OnDelete, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnDelete()
private async onDeleteMethod(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
+Equivalent to 'JS'
this.on('DELETE', MyEntity, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnDelete()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnAction
@OnAction(name : CdsAction)
Parameters
-
+
name (CdsAction): Representing theCDS actiondefined in theCDS file
+
Example
import { OnAction, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { ActionRequest, ActionReturn, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { AnAction } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnAction(AnAction)
private async onActionMethod(@Req() req: ActionRequest<typeof AnAction>, @Next() next: NextEvent): ActionReturn<typeof AnAction> {
// ...
}
+Equivalent to 'JS'
this.on(AnAction, async (req, next) => {
// ...
});
+++[!NOTE] +AnAction was generated using CDS-Typer and imported in the the class.
+
++ +[!IMPORTANT]
+
+Decorator@OnActionshould be used inside @UnboundActions() class.
@OnFunction
@OnFunction(name : CdsFunction)
Parameters
-
+
name (CdsFunction): Representing theCDS actiondefined in theCDS file.
+
Example
import { OnFunction, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { ActionRequest, ActionReturn, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { AFunction } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnFunction(AFunction)
private async onFunctionMethod(@Req() req: ActionRequest<typeof AFunction>, @Next() next: NextEvent): ActionReturn<typeof AFunction> {
// ...
}
+Equivalent to 'JS'
this.on(AFunction, async (req) => {
// ...
});
+++[!NOTE] +AFunction was generated using CDS-Typer and imported in the the class.
+
++ +[!IMPORTANT]
+
+Decorator@OnFunctionshould be used inside @UnboundAction() class.
@OnEvent
@OnEvent(name : CdsEvent)
The @OnEvent decorator facilitates the listening of messages from a message broker.
This decorator is particularly useful in conjunction with the Emit method to handle triggered events.
+Parameters
-
+
name (CdsEvent): Representing theCDS eventdefined in theCDS file.
+
Example
import { OnEvent, Req } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { AEvent } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnEvent(AEvent)
private async onEventMethod(@Req() req: TypedRequest<AEvent>) {
// ...
}
+Equivalent to 'JS'
this.on('AEvent', async (req) => {
// ...
});
+++[!NOTE] > AEvent was generated using CDS-Typer and imported in the the class.
+
++[!IMPORTANT]
+
+Decorator@OnEventshould be used inside @UnboundActions class.
++ +[!TIP] +More info can be found at https://cap.cloud.sap/docs/guides/messaging/
+
@OnError
@OnError()
+Use @OnError decorator to register custom error handler.
Error handlers are invoked whenever an error occurs during event processing of all potential events and requests, and are used to augment or modify error messages, before they go out to clients.
+Example
import { OnError, Error, Req } from "@dxfrontier/cds-ts-dispatcher";
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
@OnError()
private onError(@Error() err: Error, @Req() req: Request) { // sync func
err.message = 'New message'
// ...
}
+Equivalent to 'JS'
this.on('error', (err, req) => {
err.message = 'New message';
// ...
});
+++[!IMPORTANT]
+
+Decorator@OnErrorshould be used inside @UnboundActions class.
++[!CAUTION] +OnError callback are expected to be a
+syncfunction, i.e.,not async, not returningPromises.
++ +[!TIP] +More info can be found at SAP CAP Error
+
@OnBoundAction
@OnBoundAction(name : CdsAction)
Parameters
-
+
name (CdsAction): Representing theCDS actiondefined in theCDS file.
+
Example
import { OnBoundAction, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { ActionRequest, ActionReturn, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnBoundAction(MyEntity.actions.AnAction)
private async onActionMethod(@Req() req: ActionRequest<typeof MyEntity.actions.AnAction>, @Next() next: NextEvent): ActionReturn<typeof MyEntity.actions.AnAction> {
// ...
}
+Equivalent to 'JS'
this.on(MyEntity.actions.AnAction, MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnBoundAction()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnBoundFunction
@OnBoundFunction(name : CdsFunction)
Parameters
-
+
name (CdsFunction): Representing theCDS actiondefined in theCDS file.
+
Example
import { OnBoundFunction, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { ActionRequest, ActionReturn, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnBoundFunction(MyEntity.actions.AFunction)
private async onFunctionMethod(@Req() req: ActionRequest<typeof MyEntity.actions.AFunction>, @Next() next: NextEvent): ActionReturn<typeof MyEntity.actions.AFunction> {
// ...
}
+Equivalent to 'JS'
this.on(MyEntity.actions.AFunction, MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnBoundFunction()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnAll
@OnAll()
+The @OnAll decorator is triggered whenever any CRUD (Create, Read, Update, Delete) event occurs, whether the entity is active or in draft mode.
ACTIVE ENTITY
For active entities, the @BeforeAll decorator will be triggered when at least one of the following events occurs:
+-
+
CREATE@BeforeCreate(), @AfterCreate(), @OnCreate()
+READ@BeforeRead(), @AfterRead(), @OnRead()
+UPDATE@BeforeUpdate(), @AfterUpdate(), @OnUpdate()
+DELETE@BeforeDelete(), @AfterDelete(), @OnDelete()
+BOUND ACTIONS@OnBoundAction()
+BOUND FUNCTIONS@OnBoundFunction()
+
DRAFT
For draft entities, the @BeforeAll decorator will be triggered when at least one of the following events occurs:
+-
+
CREATE@BeforeNewDraft(), @AfterNewDraft(), @OnNewDraft()
+CANCEL@BeforeCancelDraft(), @AfterCancelDraft(), @OnCancelDraft()
+EDIT@BeforeEditDraft(), @AfterEditDraft(), @OnEditDraft()
+SAVE@BeforeSaveDraft(), @AfterSaveDraft(), @OnSaveDraft()
+- :heavy_plus_sign: All active entity Before, After, On events which have a
Draftvariant.
+
++[!NOTE] +Exception will be the following decorators @OnEvent(), @OnError() and
+UNBOUND ACTIONS@OnAction(),UNBOUND FUNCTIONS@OnFunction() as these are bound to the service itself and not to an entity.
Example
import { OnAll, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { Request, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnAll()
private async onAll(@Req() req: Request, @Next() next: NextEvent) {
// ...
return next();
}
+Equivalent to 'JS'
this.on('*', MyEntity, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnAll()will be triggered based on the EntityHandlerargument=>MyEntity.
++[!TIP] +If the entity has drafts enabled
+@odata.draft.enabled: true, the@OnAlldecorator will still be triggered for draft events.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
Method-draft entity
Before
Use @BeforeNewDraft(), @BeforeCancelDraft(), @BeforeEditDraft(), @BeforeSaveDraft(), @BeforeCreateDraft(), @BeforeReadDraft(), @BeforeUpdateDraft(), @BeforeDeleteDraft() to register handlers to run before.onhandlers, frequently used for validating user input.
The handlers receive one argument:
+-
+
reqof typeTypedRequest
+
@BeforeNewDraft
@BeforeNewDraft()
+Use this decorator when you want to validate inputs before a new draft is created.
+Example
import { BeforeNewDraft, TypedRequest } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeNewDraft()
private async beforeCreateDraftMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('NEW', MyEntity.drafts, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeNewDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@BeforeCancelDraft
@BeforeCancelDraft()
+Use this decorator when you want to validate inputs before a draft is discarded.
+Example
import { BeforeCancelDraft } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeCancelDraft()
private async beforeCancelDraftMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('CANCEL', MyEntity.drafts, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeCancelDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@BeforeEditDraft
@BeforeEditDraft()
+Use this decorator when you want to validate inputs when a new draft is created from an active instance.
+Example
import { BeforeEditDraft } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeEditDraft()
private async beforeEditDraftMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('EDIT', MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeEditDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@BeforeSaveDraft
@BeforeSaveDraft()
+Use this decorator when you want to validate inputs when active entity is changed.
+Example
import { BeforeSaveDraft } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@BeforeSaveDraft()
private async beforeSaveDraftMethod(@Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.before('SAVE', MyEntity, async (req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@BeforeSaveDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
After
Use @AfterNewDraft(), @AfterCancelDraft(), @AfterEditDraft(), @AfterSaveDraft(), @AfterCreateDraft(), @AfterReadDraft(), @AfterUpdateDraft(), @AfterDeleteDraft() register handlers to run after the .on handlers, frequently used to enrich outbound data. The handlers receive two arguments:
The results from the preceding .on handler, with the following types:
| Parameters | +Decorator | +Description | +
|---|---|---|
results, req |
+@AfterRead |
+An array of type MyEntity[] and the Request. |
+
| + | + | + |
result, req |
+@AfterUpdate@AfterCreate |
+An object of type MyEntity and the Request. |
+
| + | + | + |
deleted, req |
+@AfterDelete |
+A boolean indicating whether the instance was deleted and the Request. |
+
@AfterNewDraft
@AfterNewDraft()
+Use this decorator when you want to enhance outbound data when a new draft is created.
+Example
import { AfterNewDraft } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterNewDraft()
private async afterNewDraftMethod(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('NEW', MyEntity.drafts, async (results, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterNewDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterCancelDraft
@AfterCancelDraft()
+Use this decorator when you want to enhance outbound data when a draft is discarded.
+Example
import { AfterCancelDraft } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterCancelDraft()
private async afterCancelDraftMethod(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('CANCEL', MyEntity.drafts, async (results, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterCancelDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterEditDraft
@AfterEditDraft()
+Use this decorator when you want to enhance outbound data when a new draft is created from an active instance.
+Example
import { AfterEditDraft } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterEditDraft()
private async afterEditDraftMethod(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('EDIT', MyEntity, async (results, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterEditDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@AfterSaveDraft
@AfterSaveDraft()
+Use this decorator when you want to enhance outbound data when the active entity is changed.
+Example
import { AfterSaveDraft } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterSaveDraft()
private async afterSaveDraftMethod(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// ...
}
+Equivalent to 'JS'
this.after('SAVE', MyEntity, async (results, req) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@AfterSaveDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
On
Use @OnNewDraft(), @OnCancelDraft(), @OnSaveDraft(), @OnEditDraft(), @OnReadDraft(), @OnUpdateDraft(), @OnCreateDraft(), @OnDeleteDraft(), @OnBoundActionDraft(), @OnBoundFunctionDraft() handlers to support for both, active and draft entities.
+The handlers receive two arguments:
+-
+
reqof typeTypedRequest
+nextof typeNextEvent
+
See Official SAP Fiori-draft
+@OnNewDraft
@OnNewDraft()
+This decorator will be triggered when a new draft is created.
Example
import { OnNewDraft, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnNewDraft()
private async onNewDraft(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
}
+Equivalent to 'JS'
this.on('NEW', MyEntity.drafts, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnNewDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnCancelDraft
@OnCancelDraft()
+This decorator will be triggered when a draft is cancelled.
Example
import { OnCancelDraft, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnCancelDraft()
private async onCancelDraft(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
}
+Equivalent to 'JS'
this.on('CANCEL', MyEntity.drafts, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnCancelDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnEditDraft
@OnEditDraft()
+This decorator will be triggered when a new draft is created from an active instance
Example
import { OnEditDraft, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnEditDraft()
private async onEditDraft(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
}
+Equivalent to 'JS'
this.on('EDIT', MyEntity, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnEditDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@OnSaveDraft
@OnSaveDraft()
+This decorator will be triggered when the active entity is changed
Example
import { OnSaveDraft, Req, Next } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@OnSaveDraft()
private async onSaveDraft(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
}
+Equivalent to 'JS'
this.on('SAVE', MyEntity, async (req, next) => {
// ...
});
+++[!IMPORTANT] +Decorator
+@OnSaveDraft()will be triggered based on the EntityHandlerargument=>MyEntity.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
Other draft decorators
All active entity On, Before, After events have also a Draft variant.
++ +[!NOTE] +Except the @OnAction(), @OnFunction(), @OnEvent(), @OnError() as these actions are bound to the service and not to an entity.
+
Method-helpers
@AfterReadSingleInstance
@AfterReadSingleInstance()
+The @AfterReadSingleInstance decorator is utilized as a method-level and it can be used when you want to execute custom logic for single instance request.
If you want to execute logic for both cases (single instance and entity set) then you should use the @AfterRead(), and you can apply the parameter @SingleInstanceSwitch() decorator to switch between entity set and single instance.
+Example
Single request : http://localhost:4004/odata/v4/main/MyEntity(ID=2f12d711-b09e-4b57-b035-2cbd0a023a09)
+import { AfterReadSingleInstance, Result, Req } from "@dxfrontier/cds-ts-dispatcher";
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@AfterReadSingleInstance()
private async afterReadSingleInstance(@Result() result: MyEntity, @Req() req: TypedRequest<MyEntity>) {
// This will be executed only when single instance is called : http://localhost:4004/odata/v4/main/MyEntity(ID=2f12d711-b09e-4b57-b035-2cbd0a023a09)
// ...
}
+++[!IMPORTANT] +Decorator @AfterReadSingleInstance() will be triggered based on the EntityHandler
+argumentMyEntity.
++[!CAUTION] +If @AfterReadSingleInstance() is used all together with @AfterRead(), the event
+GET (Read), PATCH (Update)will trigger both decorators, this applies only when both decorators are used in the same @EntityHandler().The vice-versa doesn't apply, this means that if you trigger the entity set request the @AfterReadSingleInstance() will not be triggered.
+Example
+GET: http://localhost:4004/odata/v4/main/MyEntity(ID=2f12d711-b09e-4b57-b035-2cbd0a023a09)+ +// use this
@AfterReadSingleInstance()
private async afterReadSingleInstance(
@Req() req: Request,
@Result() result: MyEntity
): Promise<void> {
// The `GET` will trigger the single instance request
}
// or this
@AfterRead()
private async afterRead(
@Req() req: Request,
@Results() results: MyEntity[],
@SingleInstanceSwitch() singleInstance: boolean
): Promise<void> {
// The `GET` will trigger for both cases (single instance & entity instance), but you can use the `singleInstance` flag to verify if it's single or entity set.
} +
++[!TIP] +If
+@odata.draft.enabled: trueand you need to read the draft then you should use@AfterReadDraftSingleInstance()decorator.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the the class.
+
@Prepend
@Prepend({ eventDecorator : string })
+The @Prepend decorator is utilized as a method-level decorator to register an event handler to run before existing ones like @BeforeCreate() @AfterCreate() @OnAction() ..., etc.
Parameters
-
+
eventDecorator (string): The eventDecorator can be one of the following : +-
+
BEFORE:'BeforeCreate','BeforeRead','BeforeUpdate','BeforeDelete','BeforeAll'.
+AFTER:'AfterCreate','AfterRead','AfterReadEachInstance','AfterReadSingleInstance','AfterUpdate','AfterDelete','AfterAll'.
+ON:'OnCreate','OnRead','OnUpdate','OnDelete','OnAll','OnAction','OnFunction','OnBoundAction','OnBoundFunction','OnEvent','OnError'.
+
+actionName: (CDSFunction): Action name, applicable only forOnAction,OnBoundAction,OnFunction,OnBoundFunction.
+eventName: (CDSEvent): Event name, applicable only forOnEvent.
+
Example 1
import { Prepend, AfterRead, Req, Results } from '@dxfrontier/cds-ts-dispatcher';
import type { Request } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@Prepend({ eventDecorator: 'AfterRead' })
private async prepend(@Req() req: Request): Promise<void> {
req.locale = 'DE_de';
}
@AfterRead()
private async afterRead(MyEntity
@Req() req: Request,
@Results() results: MyEntity[],
) {
// req.locale will have the value 'DE_de' ...
// ...
}
+Example 2
import { Prepend, OnEvent, Req } from '@dxfrontier/cds-ts-dispatcher';
import type { TypedRequest } from '@dxfrontier/cds-ts-dispatcher';
import { MyEvent } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@Prepend({ eventDecorator: 'OnEvent', eventName: MyEvent })
private async prepend(@Req() req: TypedRequest<MyEvent>) {
req.locale = 'DE_de';
}
@OnEvent(MyEvent)
public async handleMyEvent(@Req() req: TypedRequest<MyEvent>) {
// req.locale will have the value 'DE_de' ...
// ...
}
+++[!TIP] +The
+@Prependdecorator can be used for example :+
+- When you want to prepare various things
+beforereaching the actual event.- Making transformation on
+Request,Result, ...beforereaching the actual event.- ...
+
++ +[!TIP] +If
+@odata.draft.enabled: trueand you need to read the draft then you should use@PrependDraft()decorator.
@Validate
@Validate<T>({ action, options? }, ...fields: Array<keyof T>)
+The @Validate decorator is utilized as a method-level decorator, used to validate fields of your entity before reaching your event callback.
++[!TIP] +Think of it as a
+pre-validationhelper.
The @Validate decorator can be used when you want to validate the Request.data (Request Body) of the @sap/cds - Request object on the following decorators :
-
+
ON+ +
+BEFORE+ +
+
Parameters
-
+
action: Choose from a list of predefinedValidators.
+options?: [Optional] Additional options for customizing the validation process.
+...fields: Specify the fields of your entity that require validation.
+
Returns
The decorator will raise a Request.reject message if the validation requirements are not met.
Validators
Below is a list of available validators:
+| Action | +Description | +Options | +
|---|---|---|
| contains | +Check if the string contains the seed. | +ignoreCase: boolean | undefined; default : false minOccurrences: number | undefined; default 1 |
+
| equals | +Check if the string matches the comparison. | ++ |
| matches | +Check if the string matches the pattern. | ++ |
| startsWith | +Checks if the string starts with the given target string. |
++ |
| endsWith | +Checks if the string ends with the given target string. |
++ |
| isMailtoURI | +Check if the string is a Mailto URI format. | +allow_display_name: If set to true, the validator will also match Display Name <email-address>. Default: false require_display_name: If set to true, the validator will reject strings without the format Display Name <email-address>. Default: false allow_utf8_local_part: If set to false, the validator will not allow any non-English UTF8 character in the email address' local part. Default: true require_tld: If set to false, email addresses without a TLD in their domain will also be matched. Default: true ignore_max_length: If set to true, the validator will not check for the standard max length of an email. Default: false allow_ip_domain: If set to true, the validator will allow IP addresses in the host part. Default: false domain_specific_validation: If set to true, some additional validation will be enabled, e.g., disallowing certain syntactically valid email addresses that are rejected by GMail. Default: false host_blacklist: An array of strings. If the part of the email after the @ symbol matches any string in the array, validation fails. host_whitelist: An array of strings. If the part of the email after the @ symbol does not match any string in the array, validation fails. blacklisted_chars: A string. If any character in the string appears in the name part of the email, validation fails. |
+
| isNumeric | +Check if the string contains only numbers. | + no_symbols: If set to locale: An object specifying the locale information for alpha validation. |
+
| isTime | +Check if the string is a valid time e.g. 23:01:59. |
+ hourFormat: Specify the hour format to validate. Use mode: Specify the time format to validate. Use |
+
| isLatLong | +check if the string is a valid latitude-longitude coordinate in the format lat,long or lat, long. |
++ |
| isMD5 | +check if the string is a MD5 hash. | ++ |
| isMimeType | +check if the string matches to a valid [MIME type] format. | ++ |
| isPort | +check if the string is a valid port number. | ++ |
| isSlug | +check if the string is of type slug. | ++ |
| isISBN | +check if the string is an [ISBN] | +version: "10", "13", 10, 13; | +
| isEmail | +check if the string is an email. | +Same as isMailtoURI |
+
| isAlpha | +Check if the string contains only letters (a-zA-Z). | ++ |
| isAlphanumeric | +Check if the string contains only letters and numbers. | ++ |
| isCreditCard | +Check if the string is a credit card. | + provider: Specify the credit card provider to validate. Use one of the following: |
+
| isCurrency | +Check if the string is a valid currency amount. | +symbol: The currency symbol to be expected. Default: '$' require_symbol: If set to true, the validator will expect the currency symbol to be present. Default: false allow_space_after_symbol: If set to true, the validator will allow a space after the currency symbol. Default: false symbol_after_digits: If set to true, the currency symbol will be expected after the digits. Default: false allow_negatives: If set to true, negative currency values will be allowed. Default: true parens_for_negatives: If set to true, negative currency values will be enclosed in parentheses. Default: false negative_sign_before_digits: If set to true, the negative sign will be placed before the digits. Default: false negative_sign_after_digits: If set to true, the negative sign will be placed after the digits. Default: false allow_negative_sign_placeholder: If set to true, the validator will allow a placeholder - for negative values. Default: false thousands_separator: The thousands separator to be expected. Default: ',' decimal_separator: The decimal separator to be expected. Default: '.' allow_decimal: If set to true, decimal values will be allowed. Default: true require_decimal: If set to true, a decimal value will be required. Default: false digits_after_decimal: An array of numbers representing the exact number of digits allowed after the decimal point. Default: [2] allow_space_after_digits: If set to true, the validator will allow a space after the digits. Default: false |
+
| isDataURI | +Check if the string is a data URI format. | ++ |
| isDate | +Check if the string is a valid date. | +format: A string representing the expected date format. Default: undefined strictMode: If set to true, the validator will reject inputs different from the specified format. Default: false delimiters: An array of allowed date delimiters. Default: ['/', '-'] |
+
| isEmpty | +Check if the string has a length of zero. | +ignore_whitespace: If set to true, whitespace characters will be ignored. Default: false |
+
| isIBAN | +Check if a string is an IBAN. | +whitelist: An array of IBAN countries to whitelist. Default: undefined blacklist: An array of IBAN countries to blacklist. Default: undefined |
+
| isIMEI | +Check if the string is a valid IMEI. | +allow_hyphens: If set to true, allows IMEI numbers with hyphens. Default: false |
+
| isIP | +Check if the string is an IP (version 4 or 6). | + "4", "6", 4, 6; |
+
| isIdentityCard | +Check if the string is a valid identity card code. | +locale: An array of supported locales for identity cards. Acceptable values: "ar-LY", "ar-TN", "ES", "FI", "he-IL", "IN", "IR", "IT", "LK", "NO", "PL", "TH", "zh-CN", "zh-HK", "zh-TW" or 'any' | +
| isIn | +Check if the string is in an array of allowed values. | ++ |
| isJSON | +Check if the string is valid JSON (note: uses JSON.parse). |
++ |
| isJWT | +Check if the string is a valid JWT token. | ++ |
| isLength | +Check if the string's length falls in a range. | +min: The minimum length allowed for the string. Default: 0 max: The maximum length allowed for the string. Default: undefined |
+
| isLowercase | +Check if the string is lowercase. | ++ |
| isMobilePhone | +Check if the string is a mobile phone number. | +strictMode: If set to true, the mobile phone number must be supplied with the country code and must start with +. Default: false |
+
| isPassportNumber | +Check if the string is a valid passport number relative to a specific country code. | ++ |
| isPostalCode | +Check if the string is a postal code. | +"AD", "AT", "AU", "BE", "BG", "BR", "CA", "CH", "CN", "CZ", "DE", "DK", "DZ", "EE", "ES", "FI", "FR", "GB", "GR", "HR", "HU", "ID", "IE", "IL", "IN", "IR", "IS", "IT", "JP", "KE", "KR", "LI", "LT", "LU", "LV", "MX", "MT", "NL", "NO", "NZ", "PL", "PR", "PT", "RO", "RU", "SA", "SE", "SI", "SK", "TN", "TW", "UA", "US", "ZA", "ZM" | +
| isURL | +Check if the string is a URL. | +protocols: An array of allowed protocols. Default: ['http', 'https', 'ftp'] require_tld: If set to true, URLs must have a top-level domain. Default: true require_protocol: If set to true, URLs must have a protocol. Default: false require_host: If set to true, URLs must have a host. Default: true require_port: If set to true, isURL will check if a port is present in the URL. Default: false require_valid_protocol: If set to true, URLs must have a valid protocol. Default: true allow_underscores: If set to true, underscores are allowed in URLs. Default: false host_whitelist: An array of allowed hosts. host_blacklist: An array of disallowed hosts. allow_trailing_dot: If set to true, trailing dots are allowed in URLs. Default: false allow_protocol_relative_urls: If set to true, protocol-relative URLs are allowed. Default: false disallow_auth: If set to true, authentication credentials in URLs are disallowed. Default: false allow_fragments: If set to true, URL fragments are allowed. Default: true allow_query_components: If set to true, URL query components are allowed. Default: true validate_length: If set to true, URLs will be validated for length. Default: true |
+
| isUUID | +Check if the string is a UUID (version 1, 2, 3, 4, or 5). | ++ |
| isUppercase | +Check if the string is uppercase. | ++ |
| isVAT | +Checks that the string is a valid VAT number. | ++ |
| isWhitelisted | +Checks if characters appear in the whitelist. | ++ |
| isInt | +Check if the string is an integer. | +min: to check the integer min boundary max: to check the integer max boundary allow_leading_zeroes: if false, will disallow integer values with leading zeroes. Default: true lt: enforce integers being greater than the value provided gt: enforce integers being less than the value provided |
+
| isHexadecimal | +Check if the string is a hexadecimal number. | ++ |
| isFloat | +Check if the string is a float. | +min: less or equal max: greater or equal gt: greater than lt: less than locale: FloatLocale |
+
| isHash | +Check if the string is a hash of export type algorithm. | +"md4", "md5", "sha1", "sha256", "sha384", "sha512", "ripemd128", "ripemd160", "tiger128", "tiger160", "tiger192", "crc32", "crc32b" | +
| isEAN | +Check if the string is an EAN (European Article Number). | ++ |
| isDecimal | +Check if the string represents a decimal number, such as 0.1, .3, 1.1, 1.00003, 4.0 etc. |
+force_decimal: If set to true, the validator will only return true if the string contains a decimal number. Default: false decimal_digits: Specifies the number of decimal digits allowed. It can be given as a range like '1,3', a specific value like '3', or min like '1,'. Default: '1,' locale: The locale to use for number formatting. Default: 'en-US' |
+
| isBoolean | +Check if a string is a boolean. | +loose: If set to true, the validator will match a valid boolean string of any case, including ['true', 'True', 'TRUE'], and also 'yes' and 'no'. If set to false, the validator will strictly match ['true', 'false', '0', '1']. Default: false |
+
| isBIC | +Check if a string is a BIC (Bank Identification Code) or SWIFT code. | ++ |
| isBefore | +Check if the string is a date that's before the specified date. | ++ |
| isAfter | +Check if the string is a date that's after the specified date. | ++ |
Example 1
import {
EntityHandler,
Inject,
CDS_DISPATCHER,
Validate,
BeforeCreate,
BeforeUpdate,
OnCreate,
OnUpdate,
Req,
Next,
} from '@dxfrontier/cds-ts-dispatcher';
import type { TypedRequest, Service, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@EntityHandler(MyEntity)
export class CustomerHandler {
// ...
@Inject(CDS_DISPATCHER.SRV) private srv: Service;
// ...
constructor() {}
@BeforeCreate()
@Validate<MyEntity>({ action: 'isLowercase' }, 'comment')
@Validate<MyEntity>({ action: 'endsWith', target: 'N' }, 'description')
private async beforeCreate(@Req() req: TypedRequest<MyEntity>) {
// ...
}
@BeforeUpdate()
@Validate<MyEntity>({ action: 'startsWith', target: 'COMMENT:' }, 'comment')
@Validate<MyEntity>({ action: 'isAlphanumeric' }, 'description')
private async beforeUpdate(@Req() req: TypedRequest<MyEntity>) {
// ...
}
@OnCreate()
@Validate<MyEntity>({ action: 'isAlphanumeric' }, 'book_ID')
private async onCreate(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
@OnUpdate()
@Validate<MyEntity>({ action: 'isLength', options: { min: 5 } }, 'comment')
private async onUpdate(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
// ...
}
+Example 2: @Validate is used inside of @UnboundActions
import { UnboundActions, OnAction, OnFunction, OnEvent, Validate, Next, Req } from '@dxfrontier/cds-ts-dispatcher';
import type { ExposeFields, TypedRequest, ActionRequest, ActionReturn, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { SomeAction, SomeFunction, OrderedBook } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@UnboundActions()
class UnboundActionsHandler {
@OnAction(SomeAction)
@Validate<ExposeFields<typeof SomeAction>>({ action: 'isIn', values: [1, 2] }, 'book', 'quantity')
private async onActionMethod(
@Req() req: ActionRequest<typeof SomeAction>,
@Next() _: NextEvent,
): ActionReturn<typeof SomeAction> {
// ...
}
@OnFunction(SomeFunction)
@Validate<ExposeFields<typeof SomeFunction>>({ action: 'isIn', values: [1, 2] }, 'book', 'quantity')
private async onFunctionMethod(
@Req() req: ActionRequest<typeof SomeFunction>,
@Next() next: NextEvent,
): ActionReturn<typeof SomeFunction> {
// ...
}
@OnEvent(OrderedBook)
@Validate<OrderedBook>({ action: 'isIn', values: [1, 2] }, 'book', 'quantity')
private async onEvent(@Req() req: TypedRequest<OrderedBook>) {
// ...
}
}
+++ +[!IMPORTANT] +To get the fields for
+ +you must use the
+ExposeFieldstype inside of the@Validatedecorator.
@FieldsFormatter
@FieldsFormatter<T>({ action, options? }, ...fields: Array<keyof T>)
+The @FieldsFormatter is used as a method level decorator to modify/enhance fields.
The @FieldsFormatter decorator can be used on the following decorators :
-
+
-
+
When you want to
+modify/enhancetheresultsof your callback.-
+
AFTER+-
+
- @AfterRead() +
+
+ -
+
When you want to
+modify/enhancetheRequest.data(Request Body) of the@sap/cds - Requestobject.-
+
ON+ +
+BEFORE+ +
+
+
Parameters
-
+
action: Choose from a list of predefinedFormatters.
+options?: [Optional] Additional options for customizing the formatter process.
+...fields: Specify the fields of your entity that require formatting.
+
Formatters
Here are the available formatter methods:
+| Action | +Description | +
|---|---|
| blacklist | +Remove characters that appear in the blacklist. | +
| ltrim | +Trim characters from the left-side of the input. | +
| rtrim | +Trim characters from the right-side of the input. | +
| trim | +Trim characters from both sides of the input. | +
| escape | +Replace <, >, &, ', " and / with HTML entities. |
+
| unescape | +Replaces HTML encoded entities with <, >, &, ', " and /. |
+
| toLower | +Converts string, as a whole, to lower case. | +
| toUpper | +Converts string, as a whole, to upper case. | +
| upperFirst | +Converts the first character of the string to upper case. | +
| lowerFirst | +Converts the first character of the string to lower case. | +
| replace | +Replaces matches for pattern in string with replacement. Note: This method is based on String#replace. |
+
| truncate | +Truncates string if it’s longer than the given maximum string length. The last characters of the truncated, string are replaced with the omission string which defaults to "…". |
+
| snakeCase | +Snake case (or snakecase) is the process of writing compound words so that the words are separated with an underscore symbol () instead of a space. The first letter is usually changed to lowercase. Some examples of Snake case would be "foo_bar" or "hello_world". |
+
| kebabCase | +Kebab case, also known as "spinal case" or "hyphen case," involves writing compound words in lowercase letters and separating them with hyphens ("-"). For example, the phrase "user settings panel" would be represented as "user-settings-panel" in the kebab case. |
+
| camelCase | +The format indicates the first word starting with either case, then the following words having an initial uppercase letter. CustomerName, LastName ... |
+
| customFormatter | +Apply a custom formatter when standard ones do not satisfy your needs. | +
Example 1
import {
EntityHandler,
Inject,
CDS_DISPATCHER,
BeforeCreate,
BeforeUpdate,
AfterRead,
OnCreate,
OnUpdate,
FieldsFormatter,
Req,
Next,
} from '@dxfrontier/cds-ts-dispatcher';
import type { Service, TypedRequest, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@EntityHandler(MyEntity)
export class CustomerHandler {
// ...
@Inject(CDS_DISPATCHER.SRV) private srv: Service;
// ...
constructor() {}
@BeforeCreate()
@FieldsFormatter<MyEntity>({ action: 'blacklist', charsToRemove: 'le' }, 'format')
private async beforeCreate(@Req() req: TypedRequest<MyEntity>) {
// ...
}
@BeforeUpdate()
@FieldsFormatter<MyEntity>({ action: 'truncate', options: { length: 7 } }, 'format')
private async beforeUpdate(@Req() req: TypedRequest<MyEntity>) {
// ...
}
@AfterRead()
@FieldsFormatter<MyEntity>({ action: 'toUpper' }, 'format')
@FieldsFormatter<MyEntity>(
{
action: 'customFormatter',
callback(req, results) {
if (results) {
// make first item 'toLowerCase' and leave the rest 'toUpper'
results[0].format = results[0].format?.toLowerCase();
}
},
},
'format',
)
private async afterRead(@Results() results: MyEntity[], @Req() req: TypedRequest<MyEntity>) {
// ...
}
@OnCreate()
@FieldsFormatter<MyEntity>({ action: 'ltrim' }, 'language')
private async onCreate(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
@OnUpdate()
@FieldsFormatter<MyEntity>({ action: 'trim' }, 'format')
private async onUpdate(@Req() req: TypedRequest<MyEntity>, @Next() next: NextEvent) {
// ...
return next();
}
// ...
}
+++[!TIP] +See best practice for customFormatter
+
Example 2 : using @FieldsFormatter decorator inside the @UnboundActions
import {
UnboundActions,
OnAction,
OnFunction,
OnEvent,
FieldsFormatter,
Req,
Next,
} from '@dxfrontier/cds-ts-dispatcher';
import type { ActionRequest, ActionReturn, ExposeFields, NextEvent } from '@dxfrontier/cds-ts-dispatcher';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@UnboundActions()
class UnboundActionsHandler {
@OnAction(AnAction)
@FieldsFormatter<ExposeFields<typeof AnAction>>({ action: 'toLower' }, 'descr', 'bookName')
private async onActionMethod(
@Req() req: ActionRequest<typeof AnAction>,
@Next() _: NextEvent,
): ActionReturn<typeof AnAction> {
// ...
return next();
}
@OnFunction(AFunction)
@FieldsFormatter<ExposeFields<typeof AFunction>>({ action: 'toUpper' }, 'lastName')
private async onFunctionMethod(
@Req() req: ActionRequest<typeof AFunction>,
@Next() next: NextEvent,
): ActionReturn<typeof AFunction> {
// ...
return next();
}
@OnEvent(AnEvent)
@FieldsFormatter<AnEvent>({ action: 'upperFirst' }, 'name')
private async onEvent(@Req() req: TypedRequest<AnEvent>) {
// ...
}
}
+++ +[!IMPORTANT] +To get the fields for
+ +you must use the
+ExposeFields typeinside of the@FieldsFormatterdecorator.
@ExecutionAllowedForRole
@ExecutionAllowedForRole(...roles: string[])
+The @ExecutionAllowedForRole is used as a method level decorator and was designed to enforce role-based access control, ensuring that only users with specific roles are authorized to execute the event.
It applies an logical OR on the specified roles, meaning it checks if at least one of the specified roles is assigned to the current request, then the execution will be allowed.
Parameters
-
+
...roles: string[]: Specifies the roles that are permitted to execute the event logic.
+
Example
@AfterRead()
@ExecutionAllowedForRole('Manager', 'User', 'CEO')
private async afterRead(
@Req() req: Request,
@Results() results: BookSale[],
) {
// Method implementation
// Code will be executed only in case of User ( Manager, User and CEO )
}
+@Use
@Use(...Middleware[])
The @Use decorator is utilized as a method-level decorator and allows you to inject middlewares into your method.
Middleware decorators can perform the following tasks:
+-
+
- Execute any code. +
- Make changes to the request object. +
- End the request-response cycle. +
- Call the next middleware function in the stack. +
- If the current middleware function does not end the request-response cycle, it must call
next()to pass control to the next middleware function. Otherwise, the request will be left hanging.
+
Parameters
-
+
...Middleware[]): Middleware classes to be injected.
+
Example: middleware implementation
import type { MiddlewareImpl, NextMiddleware, Request } from '@dxfrontier/cds-ts-dispatcher';
export class MiddlewareClass implements MiddlewareImpl {
public async use(req: Request, next: NextMiddleware) {
console.log('Middleware use method called.');
await next();
}
}
+Example usage
import { EntityHandler, Use, Inject, CDS_DISPATCHER } from '@dxfrontier/cds-ts-dispatcher';
import type { Service, Request } from '@dxfrontier/cds-ts-dispatcher';
import { MiddlewareClass } from 'YOUR_MIDDLEWARE_LOCATION';
import { MyEntity } from 'YOUR_CDS_TYPER_ENTITIES_LOCATION';
@EntityHandler(MyEntity)
export class CustomerHandler {
// ...
@Inject(CDS_DISPATCHER.SRV) private srv: Service;
// ...
constructor() {}
@AfterRead()
@Use(MiddlewareClass)
private async aMethod(@Results() results: MyEntity[], @Req() req: Request) {
// ...
}
// ...
}
+++[!TIP]
++
+- Middlewares when applied with
+@Useare executed before the normal events.- If you need to apply middleware to
+classyou can have a look over class specific @Use decorator .
++[!WARNING] +If
+req.reject()is being used inside of middleware this will stop the stack of middlewares, this means that next middleware will not be executed.
++ +[!NOTE] +MyEntity was generated using CDS-Typer and imported in the class.
+
Deployment to BTP using MTA
+-
+
- Add
mta.yamlto your project using the following command :
+
cds add mta
+-
+
- Install
npm-run-allpackage:
+
npm install --save-dev npm-run-all
+-
+
- Modify your
package.jsonby adding the followingscripts:
+
"build:cds": "echo 'STEP 1 : Build CDS' && cds build --production",
"build:ts": "echo 'STEP 2 : Transpile TS => JS' && tsc",
"build:srv:clean:ts": "echo 'Step 3: Clean TS files from srv folder' && find gen/srv/srv -type f -name '*.ts' -delete",
"build:production": "run-s build:cds build:ts build:srv:clean:ts"
+-
+
- Modify
mta.yamlas follows :
+
- builder: custom
+ commands:
+ - npm ci
+ - npm run build:production
+ - npx @cap-js/cds-typer "*" --outputDirectory gen/srv/@cds-models
+Steps explained :
-
+
npm ci- Will do a clean install
+npm run build:production- will run the package.json script command for CDS build and transpilation of TS to JS and clean theTS files.
+npx @cap-js/cds-typer "*" --outputDirectory gen/srv/@cds-models- will make sure the @cds-models are generated.
+
-
+
- Install MTA Build tool globally: +
npm i -g mbt
+-
+
- Run command to produce the
.mtar file
+
mbt build
+-
+
- Deploy your
mtarto BTP
+
Best practices & tips
+
+Can I stack multiple decorators on the same callback ?
+Yes, you can stack multiple decorators.
+Example 1
@AfterRead()
@Use(MiddlewareMethodAfterRead1, MiddlewareMethodAfterRead2)
@FieldsFormatter<MyEntity>({ action: 'blacklist', charsToRemove: 'Mysterious' }, 'title')
private async aMethod(@Results() results: MyEntity[], @Req() req: Request) {
// ...
}
+Example 2
@BeforeRead()
@BeforeCreate()
@BeforeUpdate()
@BeforeDelete()
private async aMethod(@Req() req: TypedRequest<MyEntity>) {
// ..
}
+
+
+Is the sequence of decorators important ?
+Yes, it is important as typescript executes the decorators :
+-
+
- for
Class- frombottomtotop
+ - for
method- fromtoptobottom
+
@SecondClassDecorator() // second executed
@FirstClassDecorator() // first executed
class MyClass {
@FirstDecorator() // first executed
@SecondDecorator() // second executed
myMethod() {
console.log('Method called');
}
}
+
+
+
+Best practices for @FieldsFormatter - customFormatter
+To have all the custom formatters in one place you can create a new formatters.ts where you will place all custom formatters and use export to make them visible.
// formatter.ts
export const customFormatter: Formatters<BookFormat> = {
action: 'customFormatter',
callback(req, results) {
if (results && results.length > 0) {
// make first item 'toLowerCase' and leave the rest 'toUpperCase'
results[0].format = results[0].format?.toLowerCase();
}
},
};
+Import the customFormatter in your handler
@AfterRead()
@FieldsFormatter<MyEntity>(customFormatter, 'format') // import it here
private async afterRead(@Results() results: MyEntity[], @Req() req: TypedRequest<MyEntity>) {
// ...
}
+++[!TIP] +To get all the Formatters typing you can import the
+Formatters\<T>type whereTis the entity of yourCDSprovided by CDS-Typer
Examples
Find here a collection of samples for the CDS-TS-Dispatcher-Samples
+Contributing
Pull requests are welcome. For major changes, please open an issue first +to discuss what you would like to change.
+Please make sure to update tests as appropriate.
+License
Copyright (c) 2024 DXFrontier
+Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE.
+Authors
-
+
- @dragolea +
- @sblessing +
- @ABS GmbH team +
Module constants/constants
Index
References
default
+
Variables
References
default
Renames and re-exports CDS_DISPATCHER
\ No newline at end of file
diff --git a/lib/docs/modules/core_ArgumentMethodProcessor.html b/lib/docs/modules/core_ArgumentMethodProcessor.html
new file mode 100644
index 0000000..8782206
--- /dev/null
+++ b/lib/docs/modules/core_ArgumentMethodProcessor.html
@@ -0,0 +1,2 @@
+
Module core/ArgumentMethodProcessor
Index
Classes
Module core/CDSDispatcher
Index
Classes
Module core/MetadataDispatcher
Index
Classes
Module decorators/class
Index
Functions
Module decorators/method
Index
Functions
After
Module decorators/parameter
Index
Functions
Error
+Get
Module docs/assets/icons
Module docs/assets/main
Index
Namespaces
window
+
Namespace window
Index
Variables
Module index
Index
References
ACTION_
Classes
Interfaces
Type Aliases
Functions
Inject
+
References
ACTION_
Re-exports ACTION_EVENTSALL_
Re-exports ALL_EVENTSAction
Re-exports ActionRequestAction
Re-exports ActionReturnAfter
Re-exports AfterAllAfter
Re-exports AfterAllDraftAfter
Re-exports AfterCancelDraftAfter
Re-exports AfterCreateAfter
Re-exports AfterCreateDraftAfter
Re-exports AfterDeleteAfter
Re-exports AfterDeleteDraftAfter
Re-exports AfterEditDraftAfter
Re-exports AfterNewDraftAfter
Re-exports AfterReadAfter
Re-exports AfterReadDraftAfter
Re-exports AfterReadDraftEachInstanceAfter
Re-exports AfterReadDraftSingleInstanceAfter
Re-exports AfterReadEachInstanceAfter
Re-exports AfterReadSingleInstanceAfter
Re-exports AfterSaveDraftAfter
Re-exports AfterUpdateAfter
Re-exports AfterUpdateDraftBefore
Re-exports BeforeAllBefore
Re-exports BeforeAllDraftBefore
Re-exports BeforeCancelDraftBefore
Re-exports BeforeCreateBefore
Re-exports BeforeCreateDraftBefore
Re-exports BeforeDeleteBefore
Re-exports BeforeDeleteDraftBefore
Re-exports BeforeEditDraftBefore
Re-exports BeforeNewDraftBefore
Re-exports BeforeReadBefore
Re-exports BeforeReadDraftBefore
Re-exports BeforeSaveDraftBefore
Re-exports BeforeUpdateBefore
Re-exports BeforeUpdateDraftBlacklist
Re-exports BlacklistActionCDSDispatcher
Re-exports CDSDispatcherCDSTyper
Re-exports CDSTyperEntityCDS_
Re-exports CDS_DISPATCHERCRUD_
Re-exports CRUD_EVENTSCamel
Re-exports CamelCaseCds
Re-exports CdsEventContains
Re-exports ContainsCustom
Re-exports CustomDRAFT_
Re-exports DRAFT_EVENTSEACH_
Re-exports EACH_INSTANCEERROR_
Re-exports ERROR_EVENTEVENTS
Re-exports EVENTSEnds
Re-exports EndsWithEntity
Re-exports EntityHandlerError
Re-exports ErrorEscape
Re-exports EscapeExecution
Re-exports ExecutionAllowedForRoleExpose
Re-exports ExposeFieldsFUNCTION_
Re-exports FUNCTION_EVENTSFields
Re-exports FieldsFormatterFormatters
Re-exports FormattersGet
Re-exports GetQueryGet
Re-exports GetQueryTypeGet
Re-exports GetRequestIs
Re-exports IsAfterIs
Re-exports IsAlphaIs
Re-exports IsAlphaNumericIsBIC
Re-exports IsBICIs
Re-exports IsBeforeIs
Re-exports IsBooleanIs
Re-exports IsColumnSuppliedIs
Re-exports IsCreditCardIs
Re-exports IsCurrencyIs
Re-exports IsDataURIIs
Re-exports IsDateValidatorIs
Re-exports IsDecimalIsEAN
Re-exports IsEANIs
Re-exports IsEmailValidatorIs
Re-exports IsEmptyIs
Re-exports IsEqualsIs
Re-exports IsFloatIs
Re-exports IsHashIs
Re-exports IsHexadecimalIsIBAN
Re-exports IsIBANIsIMEI
Re-exports IsIMEIIsIP
Re-exports IsIPIsISBN
Re-exports IsISBNIs
Re-exports IsIdentityCardIs
Re-exports IsInIs
Re-exports IsIntIsJSON
Re-exports IsJSONIsJWT
Re-exports IsJWTIs
Re-exports IsLatLongIs
Re-exports IsLengthIs
Re-exports IsLowercaseIsMD5
Re-exports IsMD5Is
Re-exports IsMailtoURIIs
Re-exports IsMimeTypeIs
Re-exports IsNumericIs
Re-exports IsPassportNumberIs
Re-exports IsPortIs
Re-exports IsPostalCodeIs
Re-exports IsPresentIs
Re-exports IsRoleIs
Re-exports IsSlugIs
Re-exports IsTimeIsURL
Re-exports IsURLIsUUID
Re-exports IsUUIDIs
Re-exports IsUppercaseIsVAT
Re-exports IsVATIs
Re-exports IsWhitelistedJwt
Re-exports JwtKebab
Re-exports KebabCaseLTrim
Re-exports LTrimLodash
Re-exports LodashFormattersLodash
Re-exports LodashValidatorsLower
Re-exports LowerFirstMatches
Re-exports MatchesMiddleware
Re-exports MiddlewareImplNext
Re-exports NextNext
Re-exports NextEventNext
Re-exports NextMiddlewareON_
Re-exports ON_EVENTOn
Re-exports OnActionOn
Re-exports OnAllOn
Re-exports OnAllDraftOn
Re-exports OnBoundActionOn
Re-exports OnBoundActionDraftOn
Re-exports OnBoundFunctionOn
Re-exports OnBoundFunctionDraftOn
Re-exports OnCancelDraftOn
Re-exports OnCreateOn
Re-exports OnCreateDraftOn
Re-exports OnDeleteOn
Re-exports OnDeleteDraftOn
Re-exports OnEditDraftOn
Re-exports OnErrorOn
Re-exports OnEventOn
Re-exports OnFunctionOn
Re-exports OnNewDraftOn
Re-exports OnReadOn
Re-exports OnReadDraftOn
Re-exports OnSaveDraftOn
Re-exports OnUpdateOn
Re-exports OnUpdateDraftOnly
Re-exports OnlyEntityStringsPrepend
Re-exports PrependPrepend
Re-exports PrependDraftRTrim
Re-exports RTrimReplace
Re-exports ReplaceRepository
Re-exports RepositoryReq
Re-exports ReqRequest
Re-exports RequestResponseRequest
Re-exports RequestTypeRes
Re-exports ResResult
Re-exports ResultResults
Re-exports ResultsSRV
Re-exports SRVService
Re-exports ServiceLogicSingle
Re-exports SingleInstanceCapableSingle
Re-exports SingleInstanceSwitchSnake
Re-exports SnakeCaseStarts
Re-exports StartsWithTo
Re-exports ToLowerTo
Re-exports ToUpperTrim
Re-exports TrimTruncate
Re-exports TruncateUnbound
Re-exports UnboundActionsUnescape
Re-exports UnescapeUpper
Re-exports UpperFirstUse
Re-exports UseValidate
Re-exports ValidateValidator
Re-exports ValidatorBaseValidator
Re-exports ValidatorFieldValidator
Re-exports ValidatorFormattersValidators
Re-exports ValidatorsValidators
Re-exports ValidatorsWithCountryCodeValidators
Re-exports ValidatorsWithLocaleValidators
Re-exports ValidatorsWithLocaleAndOptionsValidators
Re-exports ValidatorsWithMultipleOptionsValidators
Re-exports ValidatorsWithNoOptionsValidators
Re-exports ValidatorsWithOptionsis
Re-exports isMobilePhoneValidatorModule types/enum
Index
Enumerations
Module types/formatter
Index
Type Aliases
Module types/internalTypes
Index
Type Aliases
Base
Module types/types
Index
References
Classes
Type Aliases
References
Cds
Re-exports CdsFunctionRequest
Re-exports RequestService
Re-exports ServiceService
Re-exports ServiceImplTyped
Re-exports TypedRequestModule types/validator
Index
Type Aliases
Contains
+Ends
Module util/decorators/decoratorsUtil
Index
Variables
default
+
Module util/formatter/formatterUtil
Index
Variables
default
+
Module util/middleware/MiddlewareEntityRegistry
Index
Classes
Module util/middleware/middlewareUtil
Index
Variables
default
+
Module util/parameter/parameterUtil
Index
Variables
default
+
Module util/util
Index
Variables
default
+
Module util/validation/validatorUtil
Index
Variables
default
+
Type Alias CdsFunction
Cds
__parameters: object;
__returns: any;
(...args: any[]): any;
}
__parameters: object;
__returns: any;
(...args: any[]): any;
}
Type Alias BlacklistAction
Blacklist
action: "blacklist";
charsToRemove: string;
}
action: "blacklist";
charsToRemove: string;
}
Type declaration
action: "blacklist"
Remove characters that appear in the blacklist.
+chars
To Remove: string The characters are used in a
+RegExpand so you will need to escape some chars, e.g.blacklist(input, '\\[\\]').
Type Alias CamelCase
Camel
action: "camelCase";
}
action: "camelCase";
}
Type declaration
action: "camelCase"
Converts string to camel case.
+
Type Alias Custom<T>
Custom<T>: {
action: "customFormatter";
callback: ((req: TypedRequest<T>, results?: T[]) => Promise<void | Error> | void | Error);
}
action: "customFormatter";
callback: ((req: TypedRequest<T>, results?: T[]) => Promise<void | Error> | void | Error);
}
Type Parameters
Type Alias Escape
Escape: {
action: "escape";
}
action: "escape";
}
Type declaration
action: "escape"
Replace
+<,>,&,',"and/with HTML entities.
Type Alias Formatters<T>
Type Parameters
Type Alias KebabCase
Kebab
action: "kebabCase";
}
action: "kebabCase";
}
Type declaration
action: "kebabCase"
Converts string to kebab case.
+
Type Alias LTrim
LTrim: {
action: "ltrim";
chars?: string;
}
action: "ltrim";
chars?: string;
}
Type declaration
action: "ltrim"
Trim characters from the left-side of the input.
+Optionalchars?: stringcharacters (defaults to whitespace)
+
Type Alias LodashFormatters
Lodash
| SnakeCase
| KebabCase
| CamelCase
| ToLower
| ToUpper
| UpperFirst
| LowerFirst
| Truncate
| Replace
| SnakeCase
| KebabCase
| CamelCase
| ToLower
| ToUpper
| UpperFirst
| LowerFirst
| Truncate
| Replace
Type Alias LowerFirst
Lower
action: "lowerFirst";
}
action: "lowerFirst";
}
Type declaration
action: "lowerFirst"
Converts the first character of
+stringto lower case.
Type Alias RTrim
RTrim: {
action: "rtrim";
chars?: string;
}
action: "rtrim";
chars?: string;
}
Type declaration
action: "rtrim"
Trim characters from the right-side of the input.
+Optionalchars?: stringcharacters (defaults to whitespace)
+
Type Alias Replace
Replace: {
action: "replace";
pattern: RegExp | string;
replacement: ReplaceFunction | string;
}
action: "replace";
pattern: RegExp | string;
replacement: ReplaceFunction | string;
}
Type Alias SnakeCase
Snake
action: "snakeCase";
}
action: "snakeCase";
}
Type declaration
action: "snakeCase"
Converts string to kebab case.
+
Type Alias ToLower
To
action: "toLower";
}
action: "toLower";
}
Type declaration
action: "toLower"
Converts
+string, as a whole, to lower case.
Type Alias ToUpper
To
action: "toUpper";
}
action: "toUpper";
}
Type declaration
action: "toUpper"
Converts
+string, as a whole, to upper case.
Type Alias Trim
Trim: {
action: "trim";
chars?: string;
}
action: "trim";
chars?: string;
}
Type declaration
action: "trim"
Trim characters from both sides of the input.
+Optionalchars?: stringcharacters (defaults to whitespace)
+
Type Alias Truncate
Truncate: {
action: "truncate";
options?: TruncateOptions;
}
action: "truncate";
options?: TruncateOptions;
}
Type declaration
action: "truncate"
Truncates string if it’s longer than the given maximum string length. The last characters of the truncated +string are replaced with the omission string which defaults to "…".
+Optionaloptions?: TruncateOptions
Type Alias Unescape
Unescape: {
action: "unescape";
}
action: "unescape";
}
Type declaration
action: "unescape"
Replaces HTML encoded entities with
+<,>,&,',"and/.
Type Alias UpperFirst
Upper
action: "upperFirst";
}
action: "upperFirst";
}
Type declaration
action: "upperFirst"
Converts the first character of
+stringto upper case.
\ No newline at end of file
diff --git a/lib/docs/types/types_internalTypes.BaseHandler.html b/lib/docs/types/types_internalTypes.BaseHandler.html
new file mode 100644
index 0000000..a4b4706
--- /dev/null
+++ b/lib/docs/types/types_internalTypes.BaseHandler.html
@@ -0,0 +1 @@
+
Type Alias BaseHandler
Base
callback: RequestType;
eventKind: EventKind;
handlerType: HandlerType;
isDraft: boolean;
} & (
| DefaultHandlers
| OnHandler
| EventHandler
| PrependHandler)
callback: RequestType;
eventKind: EventKind;
handlerType: HandlerType;
isDraft: boolean;
} & (
| DefaultHandlers
| OnHandler
| EventHandler
| PrependHandler)
Type Alias CRUDQueryKeys
Type Alias CustomRequest
Type Alias DefaultHandlers
Type Alias EventHandler
Type Alias EventKind
Event
| "BEFORE"
| "AFTER"
| "AFTER_SINGLE"
| "ON"
| "BEFORE"
| "AFTER"
| "AFTER_SINGLE"
| "ON"
Type Alias ExtendedRequestWithResults
Type Alias MapPrepend
Map
actionName?: CdsFunction;
event: EVENTS;
eventKind: EventKind;
eventName?: CdsEvent;
}
actionName?: CdsFunction;
event: EVENTS;
eventKind: EventKind;
eventName?: CdsEvent;
}
Type Alias MetadataFields
Metadata
parameterIndex: number;
} & (
| QueryProperties<QueryKeys>
| RequestProperties
| OnlyParameterIndexDecorator
| IsColumnValueSupplied
| IsRoleProperties)
parameterIndex: number;
} & (
| QueryProperties<QueryKeys>
| RequestProperties
| OnlyParameterIndexDecorator
| IsColumnValueSupplied
| IsRoleProperties)
Type Alias MetadataInputs
Metadata
metadataFields: MetadataFields;
metadataKey: keyof typeof PARAMETER;
propertyKey: string | symbol;
target: object;
}
metadataFields: MetadataFields;
metadataKey: keyof typeof PARAMETER;
propertyKey: string | symbol;
target: object;
}
Type Alias OnHandler
On
actionName: CdsFunction;
event: ACTION_EVENTS | FUNCTION_EVENTS;
type: "ACTION_FUNCTION";
}
actionName: CdsFunction;
event: ACTION_EVENTS | FUNCTION_EVENTS;
type: "ACTION_FUNCTION";
}
Type Alias PickQueryPropsByKey<Key>
Pick
? QueryInsertProps["props"]
: Key extends QuerySelectProps["type"]
? QuerySelectProps["props"]
: Key extends QueryUpdateProps["type"]
? QueryUpdateProps["props"]
: Key extends QueryDeleteProps["type"]
? QueryDeleteProps["props"]
: Key extends QueryUpsertProps["type"]
? QueryUpsertProps["props"]
: never
? QueryInsertProps["props"]
: Key extends QuerySelectProps["type"]
? QuerySelectProps["props"]
: Key extends QueryUpdateProps["type"]
? QueryUpdateProps["props"]
: Key extends QueryDeleteProps["type"]
? QueryDeleteProps["props"]
: Key extends QueryUpsertProps["type"]
? QueryUpsertProps["props"]
: never
Type Parameters
- Key extends QueryKeys
Type Alias PrependAction
Prepend
actionName: CdsFunction;
eventDecorator:
| "OnAction"
| "OnFunction"
| "OnBoundAction"
| "OnBoundFunction";
}
actionName: CdsFunction;
eventDecorator:
| "OnAction"
| "OnFunction"
| "OnBoundAction"
| "OnBoundFunction";
}
Type Alias PrependBase
Type Alias PrependBaseDraft
Type Alias PrependDecorators
Prepend
eventDecorator:
| "AfterCreate"
| "AfterRead"
| "AfterReadSingleInstance"
| "AfterReadEachInstance"
| "AfterUpdate"
| "AfterDelete"
| "AfterAll"
| "BeforeCreate"
| "BeforeRead"
| "BeforeUpdate"
| "BeforeDelete"
| "BeforeAll"
| "OnCreate"
| "OnRead"
| "OnUpdate"
| "OnDelete"
| "OnAll"
| "OnError";
}
eventDecorator:
| "AfterCreate"
| "AfterRead"
| "AfterReadSingleInstance"
| "AfterReadEachInstance"
| "AfterUpdate"
| "AfterDelete"
| "AfterAll"
| "BeforeCreate"
| "BeforeRead"
| "BeforeUpdate"
| "BeforeDelete"
| "BeforeAll"
| "OnCreate"
| "OnRead"
| "OnUpdate"
| "OnDelete"
| "OnAll"
| "OnError";
}
Type Alias PrependDraftAction
Prepend
actionName: CdsFunction;
eventDecorator: "OnBoundActionDraft" | "OnBoundFunctionDraft";
}
actionName: CdsFunction;
eventDecorator: "OnBoundActionDraft" | "OnBoundFunctionDraft";
}
Type Alias PrependDraftDecorators
Prepend
eventDecorator:
| "AfterCreateDraft"
| "AfterReadDraft"
| "AfterReadDraftSingleInstance"
| "AfterReadDraftEachInstance"
| "AfterUpdateDraft"
| "AfterDeleteDraft"
| "AfterNewDraft"
| "AfterCancelDraft"
| "AfterEditDraft"
| "AfterSaveDraft"
| "BeforeCreateDraft"
| "BeforeReadDraft"
| "BeforeUpdateDraft"
| "BeforeDeleteDraft"
| "BeforeNewDraft"
| "BeforeCancelDraft"
| "BeforeEditDraft"
| "BeforeSaveDraft"
| "OnCreateDraft"
| "OnReadDraft"
| "OnUpdateDraft"
| "OnDeleteDraft"
| "OnNewDraft"
| "OnCancelDraft"
| "OnEditDraft"
| "OnSaveDraft";
}
eventDecorator:
| "AfterCreateDraft"
| "AfterReadDraft"
| "AfterReadDraftSingleInstance"
| "AfterReadDraftEachInstance"
| "AfterUpdateDraft"
| "AfterDeleteDraft"
| "AfterNewDraft"
| "AfterCancelDraft"
| "AfterEditDraft"
| "AfterSaveDraft"
| "BeforeCreateDraft"
| "BeforeReadDraft"
| "BeforeUpdateDraft"
| "BeforeDeleteDraft"
| "BeforeNewDraft"
| "BeforeCancelDraft"
| "BeforeEditDraft"
| "BeforeSaveDraft"
| "OnCreateDraft"
| "OnReadDraft"
| "OnUpdateDraft"
| "OnDeleteDraft"
| "OnNewDraft"
| "OnCancelDraft"
| "OnEditDraft"
| "OnSaveDraft";
}
Type Alias PrependEvent
Type Alias PrependHandler
Prepend
event: EVENTS;
options: {
actionName?: CdsFunction;
eventName?: string;
};
type: "PREPEND";
}
event: EVENTS;
options: {
actionName?: CdsFunction;
eventName?: string;
};
type: "PREPEND";
}
Type Alias QueryDeleteProps
Query
props: keyof DELETE<any>["DELETE"];
type: "DELETE";
}
props: keyof DELETE<any>["DELETE"];
type: "DELETE";
}
Type Alias QueryInsertProps
Query
props: keyof INSERT<any>["INSERT"];
type: "INSERT";
}
props: keyof INSERT<any>["INSERT"];
type: "INSERT";
}
Type Alias QueryKeys
Query
Type Alias QuerySelectProps
Query
props: keyof Omit<SELECT<any>["SELECT"], ExcludedSelectProperties> | ExtraProperties;
type: "SELECT";
}
props: keyof Omit<SELECT<any>["SELECT"], ExcludedSelectProperties> | ExtraProperties;
type: "SELECT";
}
Type Alias QueryUpdateProps
Query
props: keyof UPDATE<any>["UPDATE"];
type: "UPDATE";
}
props: keyof UPDATE<any>["UPDATE"];
type: "UPDATE";
}
Type Alias QueryUpsertProps
Query
props: keyof UPSERT<any>["UPSERT"];
type: "UPSERT";
}
props: keyof UPSERT<any>["UPSERT"];
type: "UPSERT";
}
Type Alias RequestProperties
Type Alias ServiceBeforeHandlers
Service
_handlers: {
before: any[];
};
}
_handlers: {
before: any[];
};
}
Type Alias TemporaryArgs
Temporary
error: Error;
next: NextEvent;
req: Request;
res: RequestResponse;
results: unknown | unknown[];
}
error: Error;
next: NextEvent;
req: Request;
res: RequestResponse;
results: unknown | unknown[];
}
Type Alias ACTION_EVENTS
ACTION_
Type Alias ALL_EVENTS
ALL_
Type Alias ActionRequest<T>
Use ActionRequest type to have the Request of @OnAction, @OnBoundAction, @OnFunction, @OnBoundFunction typed.
Type Parameters
- T extends CdsFunction
Type Alias ActionReturn<T>
Use ActionReturn type to have the return of the @OnAction, @OnBoundAction, @OnFunction, @OnBoundFunction typed.
Type Parameters
- T extends CdsFunction
Type Alias CRUD_EVENTS
Type Alias CdsEvent
Cds
Type Alias DRAFT_EVENTS
DRAFT_
| "NEW"
| "CANCEL"
| "EDIT"
| "SAVE"
| "NEW"
| "CANCEL"
| "EDIT"
| "SAVE"
Type Alias EACH_INSTANCE
EACH_
Type Alias ERROR_EVENT
ERROR_
Type Alias EVENTS
Type Alias FUNCTION_EVENTS
FUNCTION_
Type Alias MiddlewareImpl
Type Alias NextEvent
Use NextEvent type to annotate the next parameter of the implementation of the ON events.
Type Alias NextMiddleware
Next
Use NextMiddleware type to annotate the next parameter of the implementation of the middleware.
Type Alias ON_EVENT
ON_
Type Alias RequestResponse
Request
This object is created internally by an HTTP server, not by the user. Contains various methods and properties related to the response object.
Type Alias RequestType
Request
Type Alias ValidatorField
Validator
| string
| number
| undefined
| null
| boolean
| string
| number
| undefined
| null
| boolean
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.EndsWith.html b/lib/docs/types/types_validator.EndsWith.html
new file mode 100644
index 0000000..b44faf2
--- /dev/null
+++ b/lib/docs/types/types_validator.EndsWith.html
@@ -0,0 +1,5 @@
+
Type Alias EndsWith
Ends
action: "endsWith";
position?: number;
target: string;
}
action: "endsWith";
position?: number;
target: string;
}
Type Alias ExposeFields<T>
Type Parameters
- T extends CdsFunction
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsAlpha.html b/lib/docs/types/types_validator.IsAlpha.html
new file mode 100644
index 0000000..3ad4829
--- /dev/null
+++ b/lib/docs/types/types_validator.IsAlpha.html
@@ -0,0 +1,4 @@
+
Type Alias IsAlpha
Is
action: "isAlpha";
locale?: AlphaLocale;
options?: IsAlphaOptions;
}
action: "isAlpha";
locale?: AlphaLocale;
options?: IsAlphaOptions;
}
Type Alias IsAlphaNumeric
Is
action: "isAlphanumeric";
locale?: AlphanumericLocale;
options?: IsAlphanumericOptions;
}
action: "isAlphanumeric";
locale?: AlphanumericLocale;
options?: IsAlphanumericOptions;
}
Type Alias IsBIC
IsBIC: {
action: "isBIC";
}
action: "isBIC";
}
Type declaration
action: "isBIC"
Check if a string is a BIC (Bank Identification Code) or SWIFT code.
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsBoolean.html b/lib/docs/types/types_validator.IsBoolean.html
new file mode 100644
index 0000000..e486e48
--- /dev/null
+++ b/lib/docs/types/types_validator.IsBoolean.html
@@ -0,0 +1,2 @@
+
Type Alias IsBoolean
Is
action: "isBoolean";
options?: Options;
}
action: "isBoolean";
options?: Options;
}
Type declaration
action: "isBoolean"
check if a string is a boolean.
+Optionaloptions?: Options
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsCurrency.html b/lib/docs/types/types_validator.IsCurrency.html
new file mode 100644
index 0000000..4ac7de4
--- /dev/null
+++ b/lib/docs/types/types_validator.IsCurrency.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsDataURI.html b/lib/docs/types/types_validator.IsDataURI.html
new file mode 100644
index 0000000..1a8eaba
--- /dev/null
+++ b/lib/docs/types/types_validator.IsDataURI.html
@@ -0,0 +1,2 @@
+
Type Alias IsDataURI
Is
action: "isDataURI";
}
action: "isDataURI";
}
Type declaration
action: "isDataURI"
Check if the string is a data uri format.
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsDecimal.html b/lib/docs/types/types_validator.IsDecimal.html
new file mode 100644
index 0000000..2522918
--- /dev/null
+++ b/lib/docs/types/types_validator.IsDecimal.html
@@ -0,0 +1,4 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsEAN.html b/lib/docs/types/types_validator.IsEAN.html
new file mode 100644
index 0000000..96d4810
--- /dev/null
+++ b/lib/docs/types/types_validator.IsEAN.html
@@ -0,0 +1,2 @@
+
Type Alias IsEAN
IsEAN: {
action: "isEAN";
}
action: "isEAN";
}
Type declaration
action: "isEAN"
Check if the string is an EAN (European Article Number).
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsEmpty.html b/lib/docs/types/types_validator.IsEmpty.html
new file mode 100644
index 0000000..5bb5f76
--- /dev/null
+++ b/lib/docs/types/types_validator.IsEmpty.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsEquals.html b/lib/docs/types/types_validator.IsEquals.html
new file mode 100644
index 0000000..73611a5
--- /dev/null
+++ b/lib/docs/types/types_validator.IsEquals.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsFloat.html b/lib/docs/types/types_validator.IsFloat.html
new file mode 100644
index 0000000..e8cd39f
--- /dev/null
+++ b/lib/docs/types/types_validator.IsFloat.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsHash.html b/lib/docs/types/types_validator.IsHash.html
new file mode 100644
index 0000000..adf3419
--- /dev/null
+++ b/lib/docs/types/types_validator.IsHash.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsHexadecimal.html b/lib/docs/types/types_validator.IsHexadecimal.html
new file mode 100644
index 0000000..56643ac
--- /dev/null
+++ b/lib/docs/types/types_validator.IsHexadecimal.html
@@ -0,0 +1,2 @@
+
Type Alias IsHexadecimal
Is
action: "isHexadecimal";
}
action: "isHexadecimal";
}
Type declaration
action: "isHexadecimal"
Check if the string is a hexadecimal number.
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsIMEI.html b/lib/docs/types/types_validator.IsIMEI.html
new file mode 100644
index 0000000..7df5bd1
--- /dev/null
+++ b/lib/docs/types/types_validator.IsIMEI.html
@@ -0,0 +1,5 @@
+
Type Alias IsIMEI
IsIMEI: {
action: "isIMEI";
options?: IsIMEIOptions;
}
action: "isIMEI";
options?: IsIMEIOptions;
}
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsISBN.html b/lib/docs/types/types_validator.IsISBN.html
new file mode 100644
index 0000000..1e5e31f
--- /dev/null
+++ b/lib/docs/types/types_validator.IsISBN.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsIdentityCard.html b/lib/docs/types/types_validator.IsIdentityCard.html
new file mode 100644
index 0000000..44ef31d
--- /dev/null
+++ b/lib/docs/types/types_validator.IsIdentityCard.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsIn.html b/lib/docs/types/types_validator.IsIn.html
new file mode 100644
index 0000000..e1ec475
--- /dev/null
+++ b/lib/docs/types/types_validator.IsIn.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsInt.html b/lib/docs/types/types_validator.IsInt.html
new file mode 100644
index 0000000..f14c653
--- /dev/null
+++ b/lib/docs/types/types_validator.IsInt.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsJSON.html b/lib/docs/types/types_validator.IsJSON.html
new file mode 100644
index 0000000..8cd976f
--- /dev/null
+++ b/lib/docs/types/types_validator.IsJSON.html
@@ -0,0 +1,2 @@
+
Type Alias IsJSON
IsJSON: {
action: "isJSON";
}
action: "isJSON";
}
Type declaration
action: "isJSON"
Check if the string is valid JSON (note: uses
+JSON.parse).
Type Alias IsJWT
IsJWT: {
action: "isJWT";
}
action: "isJWT";
}
Type declaration
action: "isJWT"
Check if the string is valid JWT token.
+
Type Alias IsLatLong
Is
action: "isLatLong";
}
action: "isLatLong";
}
Type declaration
action: "isLatLong"
Check if the string is a valid latitude-longitude coordinate in the format:
+
+lat,longorlat, long.
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsLowercase.html b/lib/docs/types/types_validator.IsLowercase.html
new file mode 100644
index 0000000..409d74d
--- /dev/null
+++ b/lib/docs/types/types_validator.IsLowercase.html
@@ -0,0 +1,2 @@
+
Type Alias IsLowercase
Is
action: "isLowercase";
}
action: "isLowercase";
}
Type declaration
action: "isLowercase"
Check if the string is lowercase.
+
Type Alias IsMD5
IsMD5: {
action: "isMD5";
}
action: "isMD5";
}
Type declaration
action: "isMD5"
Check if the string is a MD5 hash.
+
Type Alias IsMailtoURI
Is
action: "isMailtoURI";
options?: IsEmailOptions;
}
action: "isMailtoURI";
options?: IsEmailOptions;
}
Type Alias IsMimeType
Is
action: "isMimeType";
}
action: "isMimeType";
}
Type declaration
action: "isMimeType"
Check if the string matches to a valid [MIME export type](https://en.wikipedia.org/wiki/Media_export type) format.
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsPassportNumber.html b/lib/docs/types/types_validator.IsPassportNumber.html
new file mode 100644
index 0000000..8676b84
--- /dev/null
+++ b/lib/docs/types/types_validator.IsPassportNumber.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsPort.html b/lib/docs/types/types_validator.IsPort.html
new file mode 100644
index 0000000..a3dca01
--- /dev/null
+++ b/lib/docs/types/types_validator.IsPort.html
@@ -0,0 +1,2 @@
+
Type Alias IsPort
Is
action: "isPort";
}
action: "isPort";
}
Type declaration
action: "isPort"
check if the string is a valid port number.
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsSlug.html b/lib/docs/types/types_validator.IsSlug.html
new file mode 100644
index 0000000..137222f
--- /dev/null
+++ b/lib/docs/types/types_validator.IsSlug.html
@@ -0,0 +1,2 @@
+
Type Alias IsSlug
Is
action: "isSlug";
}
action: "isSlug";
}
Type declaration
action: "isSlug"
Check if the string is of export type slug.
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsURL.html b/lib/docs/types/types_validator.IsURL.html
new file mode 100644
index 0000000..57ecc66
--- /dev/null
+++ b/lib/docs/types/types_validator.IsURL.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsUUID.html b/lib/docs/types/types_validator.IsUUID.html
new file mode 100644
index 0000000..b0138c3
--- /dev/null
+++ b/lib/docs/types/types_validator.IsUUID.html
@@ -0,0 +1,3 @@
+
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.IsUppercase.html b/lib/docs/types/types_validator.IsUppercase.html
new file mode 100644
index 0000000..72fa555
--- /dev/null
+++ b/lib/docs/types/types_validator.IsUppercase.html
@@ -0,0 +1,2 @@
+
Type Alias IsUppercase
Is
action: "isUppercase";
}
action: "isUppercase";
}
Type declaration
action: "isUppercase"
Check if the string is uppercase.
+
Type Alias IsVAT
IsVAT: {
action: "isVAT";
countryCode: string;
}
action: "isVAT";
countryCode: string;
}
Type declaration
action: "isVAT"
Checks that the string is a [valid VAT number
+country
Code: string
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.LodashValidators.html b/lib/docs/types/types_validator.LodashValidators.html
new file mode 100644
index 0000000..26aa48d
--- /dev/null
+++ b/lib/docs/types/types_validator.LodashValidators.html
@@ -0,0 +1 @@
+
Type Alias LodashValidators
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.OnlyEntityStrings.html b/lib/docs/types/types_validator.OnlyEntityStrings.html
new file mode 100644
index 0000000..085975f
--- /dev/null
+++ b/lib/docs/types/types_validator.OnlyEntityStrings.html
@@ -0,0 +1 @@
+
Type Alias StartsWith
Starts
action: "startsWith";
position?: number;
target: string;
}
action: "startsWith";
position?: number;
target: string;
}
Type Alias ValidatorBase
Validator
customMessage?: string;
mandatoryFieldValidation?: boolean;
}
customMessage?: string;
mandatoryFieldValidation?: boolean;
}
Type declaration
OptionalcustomMessage?: string 'customMessage' will replace the standard message of the validator.
+OptionalmandatoryField Validation?: boolean If
+mandatoryFieldValidation : truethis will mandatory check theRequest.dataobject for the field which needs to be validated. +ifmandatoryFieldValidation : falseor omitted, this will let theRequest.datanot to have the field in thebodyand the validation will just be omitted. +Defaultis set tofalse
Type Alias Validators
Type Alias ValidatorsWithCountryCode
Type Alias ValidatorsWithLocale
Type Alias ValidatorsWithLocaleAndOptions
\ No newline at end of file
diff --git a/lib/docs/types/types_validator.ValidatorsWithNoOptions.html b/lib/docs/types/types_validator.ValidatorsWithNoOptions.html
new file mode 100644
index 0000000..51275ef
--- /dev/null
+++ b/lib/docs/types/types_validator.ValidatorsWithNoOptions.html
@@ -0,0 +1 @@
+
Type Alias ValidatorsWithNoOptions
Validators
| IsBIC
| IsEAN
| IsHexadecimal
| IsLatLong
| IsMD5
| IsMimeType
| IsPort
| IsSlug
| IsDataURI
| IsEmpty
| IsLowercase
| IsUppercase
| IsJSON
| IsJWT
| IsBIC
| IsEAN
| IsHexadecimal
| IsLatLong
| IsMD5
| IsMimeType
| IsPort
| IsSlug
| IsDataURI
| IsEmpty
| IsLowercase
| IsUppercase
| IsJSON
| IsJWT
Type Alias ValidatorsWithOptions
Validators
| IsBoolean
| IsDecimal
| IsFloat
| IsInt
| IsMailtoURI
| IsNumeric
| IsTime
| IsDateValidator
| IsEmailValidator
| IsCurrency
| IsIBAN
| IsIMEI
| IsURL
| IsUUID
| IsCreditCard
| IsLength
| IsBoolean
| IsDecimal
| IsFloat
| IsInt
| IsMailtoURI
| IsNumeric
| IsTime
| IsDateValidator
| IsEmailValidator
| IsCurrency
| IsIBAN
| IsIMEI
| IsURL
| IsUUID
| IsCreditCard
| IsLength
Type Alias isMobilePhoneValidator
is
action: "isMobilePhone";
locale?: "any" | MobilePhoneLocale | MobilePhoneLocale[];
options?: IsMobilePhoneOptions;
}
action: "isMobilePhone";
locale?: "any" | MobilePhoneLocale | MobilePhoneLocale[];
options?: IsMobilePhoneOptions;
}
Variable CDS_DISPATCHERConst
CDS_
ALL_ENTITIES: "*";
SRV: "srv";
} = ...
ALL_ENTITIES: "*";
SRV: "srv";
} = ...
CDS-TS-Dispatcher app helper constants.
+Type declaration
ReadonlyALL_ENTITIES: "*" Represents all entities. Use
+CDS_DISPATCHER.ALL_ENTITIESwith theEntityHandlerdecorator to target all entities in your application.This is a constant, but you can also use the asterisk (
+*) instead ofCDS_DISPATCHER.ALL_ENTITIES.ReadonlySRV: "srv"Represents the CDS Service. Use
+CDS_DISPATCHER.SRVto inject the CDS Service into your class as a dependency.This is a constant, but you can also use the string
+'srv'instead ofCDS_DISPATCHER.SRV.
\ No newline at end of file
diff --git a/lib/docs/variables/constants_internalConstants.constants.html b/lib/docs/variables/constants_internalConstants.constants.html
new file mode 100644
index 0000000..651982d
--- /dev/null
+++ b/lib/docs/variables/constants_internalConstants.constants.html
@@ -0,0 +1 @@
+
Variable constantsConst
constants: {
ALL_EVENTS: "*";
DECORATOR: {
ENTITY_HANDLER_NAME: string;
METHOD_ACCUMULATOR_NAME: string;
MIDDLEWARE_KEY: string;
MIDDLEWARE_NAME: string;
PARAMETER: {
ERROR: symbol;
GET_QUERY: symbol;
GET_REQUEST: symbol;
IS_COLUMN_SUPPLIED: symbol;
IS_PRESENT: symbol;
IS_ROLE: symbol;
JWT: symbol;
NEXT: symbol;
REQ: symbol;
RES: symbol;
RESULTS: symbol;
SINGLE_INSTANCE_SWITCH: symbol;
};
};
MESSAGES: {
UNSUPPORTED_DECORATOR_ACTIONS: string;
VALIDATOR_FIELD_NOT_EXISTS: string;
VALIDATOR_MANDATORY_PROPERTY_DATA: string;
VALIDATOR_NOT_VALID: string;
};
} = ...
ALL_EVENTS: "*";
DECORATOR: {
ENTITY_HANDLER_NAME: string;
METHOD_ACCUMULATOR_NAME: string;
MIDDLEWARE_KEY: string;
MIDDLEWARE_NAME: string;
PARAMETER: {
ERROR: symbol;
GET_QUERY: symbol;
GET_REQUEST: symbol;
IS_COLUMN_SUPPLIED: symbol;
IS_PRESENT: symbol;
IS_ROLE: symbol;
JWT: symbol;
NEXT: symbol;
REQ: symbol;
RES: symbol;
RESULTS: symbol;
SINGLE_INSTANCE_SWITCH: symbol;
};
};
MESSAGES: {
UNSUPPORTED_DECORATOR_ACTIONS: string;
VALIDATOR_FIELD_NOT_EXISTS: string;
VALIDATOR_MANDATORY_PROPERTY_DATA: string;
VALIDATOR_NOT_VALID: string;
};
} = ...
Variable navigationData
navigation
Variable searchData
search
Variable translations
translations: {
copied: string;
copy: string;
normally_hidden: string;
}
copied: string;
copy: string;
normally_hidden: string;
}
Variable defaultConst
default: {
mapPrependDraftEvent(options: PrependBaseDraft): MapPrepend;
mapPrependEvent(options: PrependBase): MapPrepend;
} = ...
mapPrependDraftEvent(options: PrependBaseDraft): MapPrepend;
mapPrependEvent(options: PrependBase): MapPrepend;
} = ...
Variable defaultConst
default: {
applyFormatter<T>(formatter: LodashFormatters | ValidatorFormatters, value: any): string;
findResults<T>(args: any[]): undefined | T | T[];
handleCustomFormatter<T>(req: Request, formatter: Custom<T>, results: undefined | T | T[]): Promise<void>;
handleManyItems<T, Results, Field>(formatter: LodashFormatters | ValidatorFormatters, results: Results, field: Field): void;
handleOneItem<T, Result, Field>(formatter: LodashFormatters | ValidatorFormatters, result: Result, field: Field): void;
handleOneItemOfRequest<T, Field>(req: Request, formatter: LodashFormatters | ValidatorFormatters, field: Field): void;
} = ...
applyFormatter<T>(formatter: LodashFormatters | ValidatorFormatters, value: any): string;
findResults<T>(args: any[]): undefined | T | T[];
handleCustomFormatter<T>(req: Request, formatter: Custom<T>, results: undefined | T | T[]): Promise<void>;
handleManyItems<T, Results, Field>(formatter: LodashFormatters | ValidatorFormatters, results: Results, field: Field): void;
handleOneItem<T, Result, Field>(formatter: LodashFormatters | ValidatorFormatters, result: Result, field: Field): void;
handleOneItemOfRequest<T, Field>(req: Request, formatter: LodashFormatters | ValidatorFormatters, field: Field): void;
} = ...
Utility functions for applying formatters to various data structures.
+Type declaration
apply
Formatter:function - apply
Formatter<T>(formatter, value): string Applies the specified formatter to the given value.
+Type Parameters
Parameters
- formatter: LodashFormatters | ValidatorFormatters
The formatter to apply.
+ - value: any
The value to format.
+
Returns string
The formatted value.
+- formatter: LodashFormatters | ValidatorFormatters
- apply
find
Results:function handle
Custom Formatter:function handle
Many Items:function - handle
Many Items<T, Results, Field>(formatter, results, field): void Applies the specified formatter to a single field of multiple items.
+Type Parameters
- T
- Results extends T[] = any
- Field extends string | number | symbol = any
Parameters
- formatter: LodashFormatters | ValidatorFormatters
The formatter to apply.
+ - results: Results
The items to format.
+ - field: Field
The field of the items to format.
+
Returns void
- handle
handle
One Item:function - handle
One Item<T, Result, Field>(formatter, result, field): void Applies the specified formatter to a single field of a single item.
+Type Parameters
Parameters
- formatter: LodashFormatters | ValidatorFormatters
The formatter to apply.
+ - result: Result
The item to format.
+ - field: Field
The field of the item to format.
+
Returns void
- formatter: LodashFormatters | ValidatorFormatters
- handle
handle
One Item Of Request:function - handle
One Item Of Request<T, Field>(req, formatter, field): void Applies the specified formatter to a single field of the request data.
+Type Parameters
Parameters
- req: Request
The request containing the data to format.
+ - formatter: LodashFormatters | ValidatorFormatters
The formatter to apply.
+ - field: Field
The field of the request data to format.
+
Returns void
- req: Request
- handle
Variable defaultConst
default: {
executeMiddlewareChain<Middleware>(req: Request, index?: number, middlewares: Middleware[], entityInstance?: Constructable<any>): Promise<void>;
isRejectUsed(req: Request): boolean;
registerToClass<Middleware, Target>(target: Target, middlewareClasses: Middleware[]): void;
registerToMethod<Middleware>(middlewares: Middleware[], descriptor: TypedPropertyDescriptor<RequestType>): void;
} = ...
executeMiddlewareChain<Middleware>(req: Request, index?: number, middlewares: Middleware[], entityInstance?: Constructable<any>): Promise<void>;
isRejectUsed(req: Request): boolean;
registerToClass<Middleware, Target>(target: Target, middlewareClasses: Middleware[]): void;
registerToMethod<Middleware>(middlewares: Middleware[], descriptor: TypedPropertyDescriptor<RequestType>): void;
} = ...
Utility object for handling middleware operations.
+Type declaration
execute
Middleware Chain:function - execute
Middleware Chain<Middleware>(req, index?, middlewares, entityInstance?): Promise<void> Executes a chain of middleware functions.
+Type Parameters
- Middleware extends Constructable<MiddlewareImpl>
Parameters
- req: Request
The request object.
+ - index: number = 0
The current index in the middleware chain. Defaults to 0.
+ - middlewares: Middleware[]
An array of middleware classes to execute.
+ OptionalentityInstance: Constructable<any>An optional entity instance.
+
Returns Promise<void>
A promise that resolves when the middleware chain is complete.
+
- execute
is
Reject Used:function - is
Reject Used(req): boolean Checks if the request object has been rejected.
+Parameters
- req: Request
The request object.
+
Returns boolean
True if the request has been rejected, otherwise false.
+- req: Request
- is
register
To Class:function - register
To Class<Middleware, Target>(target, middlewareClasses): void Registers middleware functions to a class.
+Type Parameters
- Middleware extends Constructable<MiddlewareImpl>
- Target extends object
Parameters
- target: Target
The target class.
+ - middlewareClasses: Middleware[]
An array of middleware classes to register.
+
Returns void
- register
register
To Method:function - register
To Method<Middleware>(middlewares, descriptor): void Registers middleware functions to a method.
+Type Parameters
- Middleware extends Constructable<MiddlewareImpl>
Parameters
- middlewares: Middleware[]
An array of middleware classes to register.
+ - descriptor: TypedPropertyDescriptor<RequestType>
The property descriptor of the method.
+
Returns void
- register
Variable defaultConst
default: {
applyIsColumnSupplied(req: Request, args: any[], metadata: MetadataFields[]): void;
applyIsPresentOrGetDecorator(type: "IsPresent" | "Get", metadataParameters: MetadataFields[], req: Request, args: unknown[]): void;
applyIsRole(req: Request, args: any[], metadata: MetadataFields[]): void;
extractArguments(args: any[]): TemporaryArgs;
findExecutionAllowedRoles(args: any[], roles: string[]): boolean;
findResults(arg: any):
| undefined
| boolean
| object
| any[];
handleRequestOptions(req: Request, args: unknown[], metadata: MetadataFields[]): void;
isSingleInstance(req: Request): boolean;
retrieveJwt(req: Request): undefined | string;
retrieveResponse(req: Request): ServerResponse<IncomingMessage>;
} = ...
applyIsColumnSupplied(req: Request, args: any[], metadata: MetadataFields[]): void;
applyIsPresentOrGetDecorator(type: "IsPresent" | "Get", metadataParameters: MetadataFields[], req: Request, args: unknown[]): void;
applyIsRole(req: Request, args: any[], metadata: MetadataFields[]): void;
extractArguments(args: any[]): TemporaryArgs;
findExecutionAllowedRoles(args: any[], roles: string[]): boolean;
findResults(arg: any):
| undefined
| boolean
| object
| any[];
handleRequestOptions(req: Request, args: unknown[], metadata: MetadataFields[]): void;
isSingleInstance(req: Request): boolean;
retrieveJwt(req: Request): undefined | string;
retrieveResponse(req: Request): ServerResponse<IncomingMessage>;
} = ...
Utility object for handling parameter operations.
+Type declaration
apply
Is Column Supplied:function - apply
Is Column Supplied(req, args, metadata): void Applies the 'is column supplied' parameter to the request arguments.
+Parameters
- req: Request
The request object.
+ - args: any[]
The arguments array.
+ - metadata: MetadataFields[]
The metadata fields array.
+
Returns void
- req: Request
- apply
apply
Is Present Or Get Decorator:function - apply
Is Present Or Get Decorator(type, metadataParameters, req, args): void Applies the 'is present' or 'get' decorator to the request arguments.
+Parameters
- type: "IsPresent" | "Get"
The type of decorator, either 'Get' or 'IsPresent'.
+ - metadataParameters: MetadataFields[]
The metadata parameters array.
+ - req: Request
The request object.
+ - args: unknown[]
The arguments array.
+
Returns void
- type: "IsPresent" | "Get"
- apply
apply
Is Role:function - apply
Is Role(req, args, metadata): void Applies the 'is role' parameter to the request arguments.
+Parameters
- req: Request
The request object.
+ - args: any[]
The arguments array.
+ - metadata: MetadataFields[]
The metadata fields array.
+
Returns void
- req: Request
- apply
extract
Arguments:function - extract
Arguments(args): TemporaryArgs Parameters
- args: any[]
Returns TemporaryArgs
- extract
find
Execution Allowed Roles:function find
Results:function handle
Request Options:function - handle
Request Options(req, args, metadata): void Handles request options and applies them to the arguments.
+Parameters
- req: Request
The request object.
+ - args: unknown[]
The arguments array.
+ - metadata: MetadataFields[]
The metadata fields array.
+
Returns void
- req: Request
- handle
is
Single Instance:function - is
Single Instance(req): boolean Checks if the request is for a single instance.
+Parameters
- req: Request
The request object.
+
Returns boolean
True if the request is for a single instance, otherwise false.
+- req: Request
- is
retrieve
Jwt:function - retrieve
Jwt(req): undefined | string Retrieves the JWT from the request.
+Parameters
- req: Request
The request object.
+
Returns undefined | string
The JWT string if present, otherwise undefined.
+- req: Request
- retrieve
retrieve
Response:function - retrieve
Response(req): ServerResponse<IncomingMessage> Retrieves the response object from the request.
+Parameters
- req: Request
The request object.
+
Returns ServerResponse<IncomingMessage>
The response object.
+- req: Request
- retrieve
Variable defaultConst
default: {
isRequestType: ((arg: any) => arg is Request);
lodash: LoDashStatic;
buildMessage(message: string, placeholders: Record<string, any>): string;
cleanArgs(args: any[]): void;
findRequest(args: any[]): Request;
getArrayFirstItem(data: any): object;
isFieldEmpty(value: ValidatorField): boolean;
isNextEvent(arg: any): arg is NextEvent;
raiseBadRequestEmptyField(req: Request, validatorOrFormatter: Validators | Formatters<any>, field: string): void;
raiseBadRequestMessage(req: Request, message: string): void;
subtractLastDotString(str: string): string;
throwErrorMessage(message: string): void;
} = ...
isRequestType: ((arg: any) => arg is Request);
lodash: LoDashStatic;
buildMessage(message: string, placeholders: Record<string, any>): string;
cleanArgs(args: any[]): void;
findRequest(args: any[]): Request;
getArrayFirstItem(data: any): object;
isFieldEmpty(value: ValidatorField): boolean;
isNextEvent(arg: any): arg is NextEvent;
raiseBadRequestEmptyField(req: Request, validatorOrFormatter: Validators | Formatters<any>, field: string): void;
raiseBadRequestMessage(req: Request, message: string): void;
subtractLastDotString(str: string): string;
throwErrorMessage(message: string): void;
} = ...
This util contains common methods for reusable purposes. +Methods don't contain business logic.
+Type declaration
is
Request Type: ((arg: any) => arg is Request) Type guard to check if an argument is a Request.
+lodash: LoDashStatic
Single point of lodash.
+build
Message:function clean
Args:function find
Request:function get
Array First Item:function is
Field Empty:function - is
Field Empty(value): boolean Checks if a field is empty.
+Parameters
- value: ValidatorField
The field value to check.
+
Returns boolean
True if the field is empty, otherwise false.
+- value: ValidatorField
- is
is
Next Event:function raise
Bad Request Empty Field:function - raise
Bad Request Empty Field(req, validatorOrFormatter, field): void Raises a bad request error indicating that a required field is empty.
+Parameters
- req: Request
The SAP CAP Request object.
+ - validatorOrFormatter: Validators | Formatters<any>
The validator or formatter that identified the empty field.
+ - field: string
The field that is empty.
+
Returns void
- req: Request
- raise
raise
Bad Request Message:function - raise
Bad Request Message(req, message): void Raises a bad request error from the SAP CAP Request with '400' error code.
+Parameters
- req: Request
The SAP CAP Request object.
+ - message: string
The message to be raised.
+
Returns void
- req: Request
- raise
subtract
Last Dot String:function throw
Error Message:function
Variable defaultConst
default: {
applyValidator(req: Request, validator: Validators, field: string): void;
canValidate(req: Request, validator: Validators, field: string): boolean;
showNotValidMessage(options: {
field: string;
input: string;
message?: null | string;
req: Request;
validator: string;
}): void;
} = ...
applyValidator(req: Request, validator: Validators, field: string): void;
canValidate(req: Request, validator: Validators, field: string): boolean;
showNotValidMessage(options: {
field: string;
input: string;
message?: null | string;
req: Request;
validator: string;
}): void;
} = ...
Utility object for handling validation operations.
+Type declaration
apply
Validator:function - apply
Validator(req, validator, field): void Applies the specified validator to the given field in the request.
+Parameters
- req: Request
The request object.
+ - validator: Validators
The validator object.
+ - field: string
The field to validate.
+
Returns void
- req: Request
- apply
can
Validate:function - can
Validate(req, validator, field): boolean Determines if validation can be applied to the given field in the request.
+Parameters
- req: Request
The request object.
+ - validator: Validators
The validator object.
+ - field: string
The field to validate.
+
Returns boolean
True if validation can be applied, otherwise false.
+- req: Request
- can
show
Not Valid Message:function - show
Not Valid Message(options): void Displays a message indicating the validation error.
+Parameters
- options: {
field: string;
input: string;
message?: null | string;
req: Request;
validator: string;
}An object containing the validation error details.
+field: string
The field that failed validation.
+input: string
The input value that failed validation.
+Optionalmessage?: null | stringAn optional custom message for the validation error.
+req: Request
The request object.
+validator: string
The validator that failed.
+
Returns void
- options: {
- show
The
+ArgumentMethodProcessorclass is responsible for processing method arguments, including reordering arguments by type and applying decorators.